[level2-baseline.html]
  type: testharness
  [Document supports find]
    expected: FAIL

  [Document supports findAll]
    expected: FAIL

  [Detached Element supports find]
    expected: FAIL

  [Detached Element supports findAll]
    expected: FAIL

  [Fragment supports find]
    expected: FAIL

  [Fragment supports findAll]
    expected: FAIL

  [In-document Element supports find]
    expected: FAIL

  [In-document Element supports findAll]
    expected: FAIL

  [Document.findAll null]
    expected: FAIL

  [Document.findAll undefined]
    expected: FAIL

  [Document.find null]
    expected: FAIL

  [Document.find undefined]
    expected: FAIL

  [Document.findAll tree order]
    expected: FAIL

  [Detached Element.findAll null]
    expected: FAIL

  [Detached Element.findAll undefined]
    expected: FAIL

  [Detached Element.find null]
    expected: FAIL

  [Detached Element.find undefined]
    expected: FAIL

  [Detached Element.findAll tree order]
    expected: FAIL

  [Fragment.findAll null]
    expected: FAIL

  [Fragment.findAll undefined]
    expected: FAIL

  [Fragment.find null]
    expected: FAIL

  [Fragment.find undefined]
    expected: FAIL

  [Fragment.findAll tree order]
    expected: FAIL

  [In-document Element.findAll null]
    expected: FAIL

  [In-document Element.findAll undefined]
    expected: FAIL

  [In-document Element.find null]
    expected: FAIL

  [In-document Element.find undefined]
    expected: FAIL

  [In-document Element.findAll tree order]
    expected: FAIL

  [Document: static NodeList]
    expected: FAIL

  [Document: new NodeList]
    expected: FAIL

  [Detached Element: static NodeList]
    expected: FAIL

  [Detached Element: new NodeList]
    expected: FAIL

  [Fragment: static NodeList]
    expected: FAIL

  [Fragment: new NodeList]
    expected: FAIL

  [In-document Element: static NodeList]
    expected: FAIL

  [In-document Element: new NodeList]
    expected: FAIL

  [Document.find: Empty String: ]
    expected: FAIL

  [Document.findAll: Empty String: ]
    expected: FAIL

  [Document.find: Invalid character: []
    expected: FAIL

  [Document.findAll: Invalid character: []
    expected: FAIL

  [Document.find: Invalid character: \]]
    expected: FAIL

  [Document.findAll: Invalid character: \]]
    expected: FAIL

  [Document.find: Invalid character: (]
    expected: FAIL

  [Document.findAll: Invalid character: (]
    expected: FAIL

  [Document.find: Invalid character: )]
    expected: FAIL

  [Document.findAll: Invalid character: )]
    expected: FAIL

  [Document.find: Invalid character: {]
    expected: FAIL

  [Document.findAll: Invalid character: {]
    expected: FAIL

  [Document.find: Invalid character: }]
    expected: FAIL

  [Document.findAll: Invalid character: }]
    expected: FAIL

  [Document.find: Invalid character: <]
    expected: FAIL

  [Document.findAll: Invalid character: <]
    expected: FAIL

  [Document.find: Invalid character: >]
    expected: FAIL

  [Document.findAll: Invalid character: >]
    expected: FAIL

  [Document.find: Invalid ID: #]
    expected: FAIL

  [Document.findAll: Invalid ID: #]
    expected: FAIL

  [Document.find: Invalid group of selectors: div,]
    expected: FAIL

  [Document.findAll: Invalid group of selectors: div,]
    expected: FAIL

  [Document.find: Invalid class: .]
    expected: FAIL

  [Document.findAll: Invalid class: .]
    expected: FAIL

  [Document.find: Invalid class: .5cm]
    expected: FAIL

  [Document.findAll: Invalid class: .5cm]
    expected: FAIL

  [Document.find: Invalid class: ..test]
    expected: FAIL

  [Document.findAll: Invalid class: ..test]
    expected: FAIL

  [Document.find: Invalid class: .foo..quux]
    expected: FAIL

  [Document.findAll: Invalid class: .foo..quux]
    expected: FAIL

  [Document.find: Invalid class: .bar.]
    expected: FAIL

  [Document.findAll: Invalid class: .bar.]
    expected: FAIL

  [Document.find: Invalid combinator: div & address, p]
    expected: FAIL

  [Document.findAll: Invalid combinator: div & address, p]
    expected: FAIL

  [Document.find: Invalid combinator: div >> address, p]
    expected: FAIL

  [Document.findAll: Invalid combinator: div >> address, p]
    expected: FAIL

  [Document.find: Invalid combinator: div ++ address, p]
    expected: FAIL

  [Document.findAll: Invalid combinator: div ++ address, p]
    expected: FAIL

  [Document.find: Invalid combinator: div ~~ address, p]
    expected: FAIL

  [Document.findAll: Invalid combinator: div ~~ address, p]
    expected: FAIL

  [Document.find: Invalid [att=value\] selector: [*=test\]]
    expected: FAIL

  [Document.findAll: Invalid [att=value\] selector: [*=test\]]
    expected: FAIL

  [Document.find: Invalid [att=value\] selector: [*|*=test\]]
    expected: FAIL

  [Document.findAll: Invalid [att=value\] selector: [*|*=test\]]
    expected: FAIL

  [Document.find: Invalid [att=value\] selector: [class= space unquoted \]]
    expected: FAIL

  [Document.findAll: Invalid [att=value\] selector: [class= space unquoted \]]
    expected: FAIL

  [Document.find: Unknown pseudo-class: div:example]
    expected: FAIL

  [Document.findAll: Unknown pseudo-class: div:example]
    expected: FAIL

  [Document.find: Unknown pseudo-class: :example]
    expected: FAIL

  [Document.findAll: Unknown pseudo-class: :example]
    expected: FAIL

  [Document.find: Unknown pseudo-element: div::example]
    expected: FAIL

  [Document.findAll: Unknown pseudo-element: div::example]
    expected: FAIL

  [Document.find: Unknown pseudo-element: ::example]
    expected: FAIL

  [Document.findAll: Unknown pseudo-element: ::example]
    expected: FAIL

  [Document.find: Invalid pseudo-element: :::before]
    expected: FAIL

  [Document.findAll: Invalid pseudo-element: :::before]
    expected: FAIL

  [Document.find: Undeclared namespace: ns|div]
    expected: FAIL

  [Document.findAll: Undeclared namespace: ns|div]
    expected: FAIL

  [Document.find: Undeclared namespace: :not(ns|div)]
    expected: FAIL

  [Document.findAll: Undeclared namespace: :not(ns|div)]
    expected: FAIL

  [Document.find: Invalid namespace: ^|div]
    expected: FAIL

  [Document.findAll: Invalid namespace: ^|div]
    expected: FAIL

  [Document.find: Invalid namespace: $|div]
    expected: FAIL

  [Document.findAll: Invalid namespace: $|div]
    expected: FAIL

  [Detached Element.find: Empty String: ]
    expected: FAIL

  [Detached Element.findAll: Empty String: ]
    expected: FAIL

  [Detached Element.find: Invalid character: []
    expected: FAIL

  [Detached Element.findAll: Invalid character: []
    expected: FAIL

  [Detached Element.find: Invalid character: \]]
    expected: FAIL

  [Detached Element.findAll: Invalid character: \]]
    expected: FAIL

  [Detached Element.find: Invalid character: (]
    expected: FAIL

  [Detached Element.findAll: Invalid character: (]
    expected: FAIL

  [Detached Element.find: Invalid character: )]
    expected: FAIL

  [Detached Element.findAll: Invalid character: )]
    expected: FAIL

  [Detached Element.find: Invalid character: {]
    expected: FAIL

  [Detached Element.findAll: Invalid character: {]
    expected: FAIL

  [Detached Element.find: Invalid character: }]
    expected: FAIL

  [Detached Element.findAll: Invalid character: }]
    expected: FAIL

  [Detached Element.find: Invalid character: <]
    expected: FAIL

  [Detached Element.findAll: Invalid character: <]
    expected: FAIL

  [Detached Element.find: Invalid character: >]
    expected: FAIL

  [Detached Element.findAll: Invalid character: >]
    expected: FAIL

  [Detached Element.find: Invalid ID: #]
    expected: FAIL

  [Detached Element.findAll: Invalid ID: #]
    expected: FAIL

  [Detached Element.find: Invalid group of selectors: div,]
    expected: FAIL

  [Detached Element.findAll: Invalid group of selectors: div,]
    expected: FAIL

  [Detached Element.find: Invalid class: .]
    expected: FAIL

  [Detached Element.findAll: Invalid class: .]
    expected: FAIL

  [Detached Element.find: Invalid class: .5cm]
    expected: FAIL

  [Detached Element.findAll: Invalid class: .5cm]
    expected: FAIL

  [Detached Element.find: Invalid class: ..test]
    expected: FAIL

  [Detached Element.findAll: Invalid class: ..test]
    expected: FAIL

  [Detached Element.find: Invalid class: .foo..quux]
    expected: FAIL

  [Detached Element.findAll: Invalid class: .foo..quux]
    expected: FAIL

  [Detached Element.find: Invalid class: .bar.]
    expected: FAIL

  [Detached Element.findAll: Invalid class: .bar.]
    expected: FAIL

  [Detached Element.find: Invalid combinator: div & address, p]
    expected: FAIL

  [Detached Element.findAll: Invalid combinator: div & address, p]
    expected: FAIL

  [Detached Element.find: Invalid combinator: div >> address, p]
    expected: FAIL

  [Detached Element.findAll: Invalid combinator: div >> address, p]
    expected: FAIL

  [Detached Element.find: Invalid combinator: div ++ address, p]
    expected: FAIL

  [Detached Element.findAll: Invalid combinator: div ++ address, p]
    expected: FAIL

  [Detached Element.find: Invalid combinator: div ~~ address, p]
    expected: FAIL

  [Detached Element.findAll: Invalid combinator: div ~~ address, p]
    expected: FAIL

  [Detached Element.find: Invalid [att=value\] selector: [*=test\]]
    expected: FAIL

  [Detached Element.findAll: Invalid [att=value\] selector: [*=test\]]
    expected: FAIL

  [Detached Element.find: Invalid [att=value\] selector: [*|*=test\]]
    expected: FAIL

  [Detached Element.findAll: Invalid [att=value\] selector: [*|*=test\]]
    expected: FAIL

  [Detached Element.find: Invalid [att=value\] selector: [class= space unquoted \]]
    expected: FAIL

  [Detached Element.findAll: Invalid [att=value\] selector: [class= space unquoted \]]
    expected: FAIL

  [Detached Element.find: Unknown pseudo-class: div:example]
    expected: FAIL

  [Detached Element.findAll: Unknown pseudo-class: div:example]
    expected: FAIL

  [Detached Element.find: Unknown pseudo-class: :example]
    expected: FAIL

  [Detached Element.findAll: Unknown pseudo-class: :example]
    expected: FAIL

  [Detached Element.find: Unknown pseudo-element: div::example]
    expected: FAIL

  [Detached Element.findAll: Unknown pseudo-element: div::example]
    expected: FAIL

  [Detached Element.find: Unknown pseudo-element: ::example]
    expected: FAIL

  [Detached Element.findAll: Unknown pseudo-element: ::example]
    expected: FAIL

  [Detached Element.find: Invalid pseudo-element: :::before]
    expected: FAIL

  [Detached Element.findAll: Invalid pseudo-element: :::before]
    expected: FAIL

  [Detached Element.find: Undeclared namespace: ns|div]
    expected: FAIL

  [Detached Element.findAll: Undeclared namespace: ns|div]
    expected: FAIL

  [Detached Element.find: Undeclared namespace: :not(ns|div)]
    expected: FAIL

  [Detached Element.findAll: Undeclared namespace: :not(ns|div)]
    expected: FAIL

  [Detached Element.find: Invalid namespace: ^|div]
    expected: FAIL

  [Detached Element.findAll: Invalid namespace: ^|div]
    expected: FAIL

  [Detached Element.find: Invalid namespace: $|div]
    expected: FAIL

  [Detached Element.findAll: Invalid namespace: $|div]
    expected: FAIL

  [Fragment.find: Empty String: ]
    expected: FAIL

  [Fragment.findAll: Empty String: ]
    expected: FAIL

  [Fragment.find: Invalid character: []
    expected: FAIL

  [Fragment.findAll: Invalid character: []
    expected: FAIL

  [Fragment.find: Invalid character: \]]
    expected: FAIL

  [Fragment.findAll: Invalid character: \]]
    expected: FAIL

  [Fragment.find: Invalid character: (]
    expected: FAIL

  [Fragment.findAll: Invalid character: (]
    expected: FAIL

  [Fragment.find: Invalid character: )]
    expected: FAIL

  [Fragment.findAll: Invalid character: )]
    expected: FAIL

  [Fragment.find: Invalid character: {]
    expected: FAIL

  [Fragment.findAll: Invalid character: {]
    expected: FAIL

  [Fragment.find: Invalid character: }]
    expected: FAIL

  [Fragment.findAll: Invalid character: }]
    expected: FAIL

  [Fragment.find: Invalid character: <]
    expected: FAIL

  [Fragment.findAll: Invalid character: <]
    expected: FAIL

  [Fragment.find: Invalid character: >]
    expected: FAIL

  [Fragment.findAll: Invalid character: >]
    expected: FAIL

  [Fragment.find: Invalid ID: #]
    expected: FAIL

  [Fragment.findAll: Invalid ID: #]
    expected: FAIL

  [Fragment.find: Invalid group of selectors: div,]
    expected: FAIL

  [Fragment.findAll: Invalid group of selectors: div,]
    expected: FAIL

  [Fragment.find: Invalid class: .]
    expected: FAIL

  [Fragment.findAll: Invalid class: .]
    expected: FAIL

  [Fragment.find: Invalid class: .5cm]
    expected: FAIL

  [Fragment.findAll: Invalid class: .5cm]
    expected: FAIL

  [Fragment.find: Invalid class: ..test]
    expected: FAIL

  [Fragment.findAll: Invalid class: ..test]
    expected: FAIL

  [Fragment.find: Invalid class: .foo..quux]
    expected: FAIL

  [Fragment.findAll: Invalid class: .foo..quux]
    expected: FAIL

  [Fragment.find: Invalid class: .bar.]
    expected: FAIL

  [Fragment.findAll: Invalid class: .bar.]
    expected: FAIL

  [Fragment.find: Invalid combinator: div & address, p]
    expected: FAIL

  [Fragment.findAll: Invalid combinator: div & address, p]
    expected: FAIL

  [Fragment.find: Invalid combinator: div >> address, p]
    expected: FAIL

  [Fragment.findAll: Invalid combinator: div >> address, p]
    expected: FAIL

  [Fragment.find: Invalid combinator: div ++ address, p]
    expected: FAIL

  [Fragment.findAll: Invalid combinator: div ++ address, p]
    expected: FAIL

  [Fragment.find: Invalid combinator: div ~~ address, p]
    expected: FAIL

  [Fragment.findAll: Invalid combinator: div ~~ address, p]
    expected: FAIL

  [Fragment.find: Invalid [att=value\] selector: [*=test\]]
    expected: FAIL

  [Fragment.findAll: Invalid [att=value\] selector: [*=test\]]
    expected: FAIL

  [Fragment.find: Invalid [att=value\] selector: [*|*=test\]]
    expected: FAIL

  [Fragment.findAll: Invalid [att=value\] selector: [*|*=test\]]
    expected: FAIL

  [Fragment.find: Invalid [att=value\] selector: [class= space unquoted \]]
    expected: FAIL

  [Fragment.findAll: Invalid [att=value\] selector: [class= space unquoted \]]
    expected: FAIL

  [Fragment.find: Unknown pseudo-class: div:example]
    expected: FAIL

  [Fragment.findAll: Unknown pseudo-class: div:example]
    expected: FAIL

  [Fragment.find: Unknown pseudo-class: :example]
    expected: FAIL

  [Fragment.findAll: Unknown pseudo-class: :example]
    expected: FAIL

  [Fragment.find: Unknown pseudo-element: div::example]
    expected: FAIL

  [Fragment.findAll: Unknown pseudo-element: div::example]
    expected: FAIL

  [Fragment.find: Unknown pseudo-element: ::example]
    expected: FAIL

  [Fragment.findAll: Unknown pseudo-element: ::example]
    expected: FAIL

  [Fragment.find: Invalid pseudo-element: :::before]
    expected: FAIL

  [Fragment.findAll: Invalid pseudo-element: :::before]
    expected: FAIL

  [Fragment.find: Undeclared namespace: ns|div]
    expected: FAIL

  [Fragment.findAll: Undeclared namespace: ns|div]
    expected: FAIL

  [Fragment.find: Undeclared namespace: :not(ns|div)]
    expected: FAIL

  [Fragment.findAll: Undeclared namespace: :not(ns|div)]
    expected: FAIL

  [Fragment.find: Invalid namespace: ^|div]
    expected: FAIL

  [Fragment.findAll: Invalid namespace: ^|div]
    expected: FAIL

  [Fragment.find: Invalid namespace: $|div]
    expected: FAIL

  [Fragment.findAll: Invalid namespace: $|div]
    expected: FAIL

  [In-document Element.find: Empty String: ]
    expected: FAIL

  [In-document Element.findAll: Empty String: ]
    expected: FAIL

  [In-document Element.find: Invalid character: []
    expected: FAIL

  [In-document Element.findAll: Invalid character: []
    expected: FAIL

  [In-document Element.find: Invalid character: \]]
    expected: FAIL

  [In-document Element.findAll: Invalid character: \]]
    expected: FAIL

  [In-document Element.find: Invalid character: (]
    expected: FAIL

  [In-document Element.findAll: Invalid character: (]
    expected: FAIL

  [In-document Element.find: Invalid character: )]
    expected: FAIL

  [In-document Element.findAll: Invalid character: )]
    expected: FAIL

  [In-document Element.find: Invalid character: {]
    expected: FAIL

  [In-document Element.findAll: Invalid character: {]
    expected: FAIL

  [In-document Element.find: Invalid character: }]
    expected: FAIL

  [In-document Element.findAll: Invalid character: }]
    expected: FAIL

  [In-document Element.find: Invalid character: <]
    expected: FAIL

  [In-document Element.findAll: Invalid character: <]
    expected: FAIL

  [In-document Element.find: Invalid character: >]
    expected: FAIL

  [In-document Element.findAll: Invalid character: >]
    expected: FAIL

  [In-document Element.find: Invalid ID: #]
    expected: FAIL

  [In-document Element.findAll: Invalid ID: #]
    expected: FAIL

  [In-document Element.find: Invalid group of selectors: div,]
    expected: FAIL

  [In-document Element.findAll: Invalid group of selectors: div,]
    expected: FAIL

  [In-document Element.find: Invalid class: .]
    expected: FAIL

  [In-document Element.findAll: Invalid class: .]
    expected: FAIL

  [In-document Element.find: Invalid class: .5cm]
    expected: FAIL

  [In-document Element.findAll: Invalid class: .5cm]
    expected: FAIL

  [In-document Element.find: Invalid class: ..test]
    expected: FAIL

  [In-document Element.findAll: Invalid class: ..test]
    expected: FAIL

  [In-document Element.find: Invalid class: .foo..quux]
    expected: FAIL

  [In-document Element.findAll: Invalid class: .foo..quux]
    expected: FAIL

  [In-document Element.find: Invalid class: .bar.]
    expected: FAIL

  [In-document Element.findAll: Invalid class: .bar.]
    expected: FAIL

  [In-document Element.find: Invalid combinator: div & address, p]
    expected: FAIL

  [In-document Element.findAll: Invalid combinator: div & address, p]
    expected: FAIL

  [In-document Element.find: Invalid combinator: div >> address, p]
    expected: FAIL

  [In-document Element.findAll: Invalid combinator: div >> address, p]
    expected: FAIL

  [In-document Element.find: Invalid combinator: div ++ address, p]
    expected: FAIL

  [In-document Element.findAll: Invalid combinator: div ++ address, p]
    expected: FAIL

  [In-document Element.find: Invalid combinator: div ~~ address, p]
    expected: FAIL

  [In-document Element.findAll: Invalid combinator: div ~~ address, p]
    expected: FAIL

  [In-document Element.find: Invalid [att=value\] selector: [*=test\]]
    expected: FAIL

  [In-document Element.findAll: Invalid [att=value\] selector: [*=test\]]
    expected: FAIL

  [In-document Element.find: Invalid [att=value\] selector: [*|*=test\]]
    expected: FAIL

  [In-document Element.findAll: Invalid [att=value\] selector: [*|*=test\]]
    expected: FAIL

  [In-document Element.find: Invalid [att=value\] selector: [class= space unquoted \]]
    expected: FAIL

  [In-document Element.findAll: Invalid [att=value\] selector: [class= space unquoted \]]
    expected: FAIL

  [In-document Element.find: Unknown pseudo-class: div:example]
    expected: FAIL

  [In-document Element.findAll: Unknown pseudo-class: div:example]
    expected: FAIL

  [In-document Element.find: Unknown pseudo-class: :example]
    expected: FAIL

  [In-document Element.findAll: Unknown pseudo-class: :example]
    expected: FAIL

  [In-document Element.find: Unknown pseudo-element: div::example]
    expected: FAIL

  [In-document Element.findAll: Unknown pseudo-element: div::example]
    expected: FAIL

  [In-document Element.find: Unknown pseudo-element: ::example]
    expected: FAIL

  [In-document Element.findAll: Unknown pseudo-element: ::example]
    expected: FAIL

  [In-document Element.find: Invalid pseudo-element: :::before]
    expected: FAIL

  [In-document Element.findAll: Invalid pseudo-element: :::before]
    expected: FAIL

  [In-document Element.find: Undeclared namespace: ns|div]
    expected: FAIL

  [In-document Element.findAll: Undeclared namespace: ns|div]
    expected: FAIL

  [In-document Element.find: Undeclared namespace: :not(ns|div)]
    expected: FAIL

  [In-document Element.findAll: Undeclared namespace: :not(ns|div)]
    expected: FAIL

  [In-document Element.find: Invalid namespace: ^|div]
    expected: FAIL

  [In-document Element.findAll: Invalid namespace: ^|div]
    expected: FAIL

  [In-document Element.find: Invalid namespace: $|div]
    expected: FAIL

  [In-document Element.findAll: Invalid namespace: $|div]
    expected: FAIL

  [In-document Element.mozMatchesSelector: Universal selector, matching all children of the specified reference element (with refNode Element): >*]
    expected: FAIL

  [In-document Element.mozMatchesSelector: Universal selector, matching all grandchildren of the specified reference element (with refNode Element): >*>*]
    expected: FAIL

  [In-document Element.mozMatchesSelector: Universal selector, matching all descendants of the specified reference element (with refNode Element): *]
    expected: FAIL

  [In-document Element.mozMatchesSelector: Class selector, matching element with class value using non-ASCII characters (with no refNodes): .\xe5\x8f\xb0\xe5\x8c\x97T\xc3\xa1ib\xc4\x9bi]
    expected: FAIL

  [In-document Element.mozMatchesSelector: Class selector, chained, matching element with multiple class values using non-ASCII characters (with no refNodes): .\xe5\x8f\xb0\xe5\x8c\x97T\xc3\xa1ib\xc4\x9bi.\xe5\x8f\xb0\xe5\x8c\x97]
    expected: FAIL

  [In-document Element.mozMatchesSelector: ID selector, matching id value using non-ASCII characters (with no refNodes): #\xe5\x8f\xb0\xe5\x8c\x97T\xc3\xa1ib\xc4\x9bi]
    expected: FAIL

  [In-document Element.mozMatchesSelector: ID selector, matching id values using non-ASCII characters (with no refNodes): #\xe5\x8f\xb0\xe5\x8c\x97T\xc3\xa1ib\xc4\x9bi, #\xe5\x8f\xb0\xe5\x8c\x97]
    expected: FAIL

  [In-document [Context Element\].findAll: Universal selector, matching all children of the specified reference element (with no refNodes): >*]
    expected: FAIL

  [In-document [Context Element\].find: Universal selector, matching all children of the specified reference element (with no refNodes): >*]
    expected: FAIL

  [In-document [Root Node\].findAll: Universal selector, matching all children of the specified reference element (with refNode Element): >*]
    expected: FAIL

  [In-document [Root Node\].find: Universal selector, matching all children of the specified reference element (with refNode Element): >*]
    expected: FAIL

  [In-document [Context Element\].findAll: Universal selector, matching all grandchildren of the specified reference element (with no refNodes): >*>*]
    expected: FAIL

  [In-document [Context Element\].find: Universal selector, matching all grandchildren of the specified reference element (with no refNodes): >*>*]
    expected: FAIL

  [In-document [Root Node\].findAll: Universal selector, matching all grandchildren of the specified reference element (with refNode Element): >*>*]
    expected: FAIL

  [In-document [Root Node\].find: Universal selector, matching all grandchildren of the specified reference element (with refNode Element): >*>*]
    expected: FAIL

  [In-document [Context Element\].findAll: Universal selector, matching all descendants of the specified reference element (with no refNodes): *]
    expected: FAIL

  [In-document [Context Element\].find: Universal selector, matching all descendants of the specified reference element (with no refNodes): *]
    expected: FAIL

  [In-document [Root Node\].findAll: Universal selector, matching all descendants of the specified reference element (with refNode Element): *]
    expected: FAIL

  [In-document [Root Node\].find: Universal selector, matching all descendants of the specified reference element (with refNode Element): *]
    expected: FAIL

  [In-document [Context Element\].findAll: Attribute presence selector, matching align attribute with value (with no refNodes): .attr-presence-div1[align\]]
    expected: FAIL

  [In-document [Context Element\].find: Attribute presence selector, matching align attribute with value (with no refNodes): .attr-presence-div1[align\]]
    expected: FAIL

  [In-document [Root Node\].findAll: Attribute presence selector, matching align attribute with value (with refNode Element): .attr-presence-div1[align\]]
    expected: FAIL

  [In-document [Root Node\].find: Attribute presence selector, matching align attribute with value (with refNode Element): .attr-presence-div1[align\]]
    expected: FAIL

  [In-document [Context Element\].findAll: Attribute presence selector, matching align attribute with empty value (with no refNodes): .attr-presence-div2[align\]]
    expected: FAIL

  [In-document [Context Element\].find: Attribute presence selector, matching align attribute with empty value (with no refNodes): .attr-presence-div2[align\]]
    expected: FAIL

  [In-document [Root Node\].findAll: Attribute presence selector, matching align attribute with empty value (with refNode Element): .attr-presence-div2[align\]]
    expected: FAIL

  [In-document [Root Node\].find: Attribute presence selector, matching align attribute with empty value (with refNode Element): .attr-presence-div2[align\]]
    expected: FAIL

  [In-document [Context Element\].findAll: Attribute presence selector, matching title attribute, case insensitivity (with no refNodes): [TiTlE\]]
    expected: FAIL

  [In-document [Context Element\].find: Attribute presence selector, matching title attribute, case insensitivity (with no refNodes): [TiTlE\]]
    expected: FAIL

  [In-document [Root Node\].findAll: Attribute presence selector, matching title attribute, case insensitivity (with refNode Element): [TiTlE\]]
    expected: FAIL

  [In-document [Root Node\].find: Attribute presence selector, matching title attribute, case insensitivity (with refNode Element): [TiTlE\]]
    expected: FAIL

  [In-document [Context Element\].findAll: Attribute presence selector, matching custom data-* attribute (with no refNodes): [data-attr-presence\]]
    expected: FAIL

  [In-document [Context Element\].find: Attribute presence selector, matching custom data-* attribute (with no refNodes): [data-attr-presence\]]
    expected: FAIL

  [In-document [Root Node\].findAll: Attribute presence selector, matching custom data-* attribute (with refNode Element): [data-attr-presence\]]
    expected: FAIL

  [In-document [Root Node\].find: Attribute presence selector, matching custom data-* attribute (with refNode Element): [data-attr-presence\]]
    expected: FAIL

  [In-document [Context Element\].findAll: Attribute presence selector, not matching attribute with similar name (with no refNodes): .attr-presence-div3[align\], .attr-presence-div4[align\]]
    expected: FAIL

  [In-document [Context Element\].find: Attribute presence selector, not matching attribute with similar name (with no refNodes): .attr-presence-div3[align\], .attr-presence-div4[align\]]
    expected: FAIL

  [In-document [Root Node\].findAll: Attribute presence selector, not matching attribute with similar name (with refNode Element): .attr-presence-div3[align\], .attr-presence-div4[align\]]
    expected: FAIL

  [In-document [Root Node\].find: Attribute presence selector, not matching attribute with similar name (with refNode Element): .attr-presence-div3[align\], .attr-presence-div4[align\]]
    expected: FAIL

  [In-document [Context Element\].findAll: Attribute presence selector, matching attribute with non-ASCII characters (with no refNodes): ul[data-\xe4\xb8\xad\xe6\x96\x87\]]
    expected: FAIL

  [In-document [Context Element\].find: Attribute presence selector, matching attribute with non-ASCII characters (with no refNodes): ul[data-\xe4\xb8\xad\xe6\x96\x87\]]
    expected: FAIL

  [In-document [Root Node\].findAll: Attribute presence selector, matching attribute with non-ASCII characters (with refNode Element): ul[data-\xe4\xb8\xad\xe6\x96\x87\]]
    expected: FAIL

  [In-document [Root Node\].find: Attribute presence selector, matching attribute with non-ASCII characters (with refNode Element): ul[data-\xe4\xb8\xad\xe6\x96\x87\]]
    expected: FAIL

  [In-document [Context Element\].findAll: Attribute presence selector, not matching default option without selected attribute (with no refNodes): #attr-presence-select1 option[selected\]]
    expected: FAIL

  [In-document [Context Element\].find: Attribute presence selector, not matching default option without selected attribute (with no refNodes): #attr-presence-select1 option[selected\]]
    expected: FAIL

  [In-document [Root Node\].findAll: Attribute presence selector, not matching default option without selected attribute (with refNode Element): #attr-presence-select1 option[selected\]]
    expected: FAIL

  [In-document [Root Node\].find: Attribute presence selector, not matching default option without selected attribute (with refNode Element): #attr-presence-select1 option[selected\]]
    expected: FAIL

  [In-document [Context Element\].findAll: Attribute presence selector, matching option with selected attribute (with no refNodes): #attr-presence-select2 option[selected\]]
    expected: FAIL

  [In-document [Context Element\].find: Attribute presence selector, matching option with selected attribute (with no refNodes): #attr-presence-select2 option[selected\]]
    expected: FAIL

  [In-document [Root Node\].findAll: Attribute presence selector, matching option with selected attribute (with refNode Element): #attr-presence-select2 option[selected\]]
    expected: FAIL

  [In-document [Root Node\].find: Attribute presence selector, matching option with selected attribute (with refNode Element): #attr-presence-select2 option[selected\]]
    expected: FAIL

  [In-document [Context Element\].findAll: Attribute presence selector, matching multiple options with selected attributes (with no refNodes): #attr-presence-select3 option[selected\]]
    expected: FAIL

  [In-document [Context Element\].find: Attribute presence selector, matching multiple options with selected attributes (with no refNodes): #attr-presence-select3 option[selected\]]
    expected: FAIL

  [In-document [Root Node\].findAll: Attribute presence selector, matching multiple options with selected attributes (with refNode Element): #attr-presence-select3 option[selected\]]
    expected: FAIL

  [In-document [Root Node\].find: Attribute presence selector, matching multiple options with selected attributes (with refNode Element): #attr-presence-select3 option[selected\]]
    expected: FAIL

  [In-document [Context Element\].findAll: Attribute value selector, matching align attribute with value (with no refNodes): [align="center"\]]
    expected: FAIL

  [In-document [Context Element\].find: Attribute value selector, matching align attribute with value (with no refNodes): [align="center"\]]
    expected: FAIL

  [In-document [Root Node\].findAll: Attribute value selector, matching align attribute with value (with refNode Element): [align="center"\]]
    expected: FAIL

  [In-document [Root Node\].find: Attribute value selector, matching align attribute with value (with refNode Element): [align="center"\]]
    expected: FAIL

  [In-document [Context Element\].findAll: Attribute value selector, matching align attribute with empty value (with no refNodes): [align=""\]]
    expected: FAIL

  [In-document [Context Element\].find: Attribute value selector, matching align attribute with empty value (with no refNodes): [align=""\]]
    expected: FAIL

  [In-document [Root Node\].findAll: Attribute value selector, matching align attribute with empty value (with refNode Element): [align=""\]]
    expected: FAIL

  [In-document [Root Node\].find: Attribute value selector, matching align attribute with empty value (with refNode Element): [align=""\]]
    expected: FAIL

  [In-document [Context Element\].findAll: Attribute value selector, not matching align attribute with partial value (with no refNodes): [align="c"\]]
    expected: FAIL

  [In-document [Context Element\].find: Attribute value selector, not matching align attribute with partial value (with no refNodes): [align="c"\]]
    expected: FAIL

  [In-document [Root Node\].findAll: Attribute value selector, not matching align attribute with partial value (with refNode Element): [align="c"\]]
    expected: FAIL

  [In-document [Root Node\].find: Attribute value selector, not matching align attribute with partial value (with refNode Element): [align="c"\]]
    expected: FAIL

  [In-document [Context Element\].findAll: Attribute value selector, not matching align attribute with incorrect value (with no refNodes): [align="centera"\]]
    expected: FAIL

  [In-document [Context Element\].find: Attribute value selector, not matching align attribute with incorrect value (with no refNodes): [align="centera"\]]
    expected: FAIL

  [In-document [Root Node\].findAll: Attribute value selector, not matching align attribute with incorrect value (with refNode Element): [align="centera"\]]
    expected: FAIL

  [In-document [Root Node\].find: Attribute value selector, not matching align attribute with incorrect value (with refNode Element): [align="centera"\]]
    expected: FAIL

  [In-document [Context Element\].findAll: Attribute value selector, matching custom data-* attribute with unicode escaped value (with no refNodes): [data-attr-value="\\e9"\]]
    expected: FAIL

  [In-document [Context Element\].find: Attribute value selector, matching custom data-* attribute with unicode escaped value (with no refNodes): [data-attr-value="\\e9"\]]
    expected: FAIL

  [In-document [Root Node\].findAll: Attribute value selector, matching custom data-* attribute with unicode escaped value (with refNode Element): [data-attr-value="\\e9"\]]
    expected: FAIL

  [In-document [Root Node\].find: Attribute value selector, matching custom data-* attribute with unicode escaped value (with refNode Element): [data-attr-value="\\e9"\]]
    expected: FAIL

  [In-document [Context Element\].findAll: Attribute value selector, matching custom data-* attribute with escaped character (with no refNodes): [data-attr-value_foo="\\e9"\]]
    expected: FAIL

  [In-document [Context Element\].find: Attribute value selector, matching custom data-* attribute with escaped character (with no refNodes): [data-attr-value_foo="\\e9"\]]
    expected: FAIL

  [In-document [Root Node\].findAll: Attribute value selector, matching custom data-* attribute with escaped character (with refNode Element): [data-attr-value_foo="\\e9"\]]
    expected: FAIL

  [In-document [Root Node\].find: Attribute value selector, matching custom data-* attribute with escaped character (with refNode Element): [data-attr-value_foo="\\e9"\]]
    expected: FAIL

  [In-document [Context Element\].findAll: Attribute value selector with single-quoted value, matching multiple inputs with type attributes (with no refNodes): input[type=\'hidden\'\],#attr-value input[type=\'radio\'\]]
    expected: FAIL

  [In-document [Context Element\].find: Attribute value selector with single-quoted value, matching multiple inputs with type attributes (with no refNodes): input[type=\'hidden\'\],#attr-value input[type=\'radio\'\]]
    expected: FAIL

  [In-document [Root Node\].findAll: Attribute value selector with single-quoted value, matching multiple inputs with type attributes (with refNode Element): input[type=\'hidden\'\],#attr-value input[type=\'radio\'\]]
    expected: FAIL

  [In-document [Root Node\].find: Attribute value selector with single-quoted value, matching multiple inputs with type attributes (with refNode Element): input[type=\'hidden\'\],#attr-value input[type=\'radio\'\]]
    expected: FAIL

  [In-document [Context Element\].findAll: Attribute value selector with double-quoted value, matching multiple inputs with type attributes (with no refNodes): input[type="hidden"\],#attr-value input[type=\'radio\'\]]
    expected: FAIL

  [In-document [Context Element\].find: Attribute value selector with double-quoted value, matching multiple inputs with type attributes (with no refNodes): input[type="hidden"\],#attr-value input[type=\'radio\'\]]
    expected: FAIL

  [In-document [Root Node\].findAll: Attribute value selector with double-quoted value, matching multiple inputs with type attributes (with refNode Element): input[type="hidden"\],#attr-value input[type=\'radio\'\]]
    expected: FAIL

  [In-document [Root Node\].find: Attribute value selector with double-quoted value, matching multiple inputs with type attributes (with refNode Element): input[type="hidden"\],#attr-value input[type=\'radio\'\]]
    expected: FAIL

  [In-document [Context Element\].findAll: Attribute value selector with unquoted value, matching multiple inputs with type attributes (with no refNodes): input[type=hidden\],#attr-value input[type=radio\]]
    expected: FAIL

  [In-document [Context Element\].find: Attribute value selector with unquoted value, matching multiple inputs with type attributes (with no refNodes): input[type=hidden\],#attr-value input[type=radio\]]
    expected: FAIL

  [In-document [Root Node\].findAll: Attribute value selector with unquoted value, matching multiple inputs with type attributes (with refNode Element): input[type=hidden\],#attr-value input[type=radio\]]
    expected: FAIL

  [In-document [Root Node\].find: Attribute value selector with unquoted value, matching multiple inputs with type attributes (with refNode Element): input[type=hidden\],#attr-value input[type=radio\]]
    expected: FAIL

  [In-document [Context Element\].findAll: Attribute value selector, matching attribute with value using non-ASCII characters (with no refNodes): [data-attr-value=\xe4\xb8\xad\xe6\x96\x87\]]
    expected: FAIL

  [In-document [Context Element\].find: Attribute value selector, matching attribute with value using non-ASCII characters (with no refNodes): [data-attr-value=\xe4\xb8\xad\xe6\x96\x87\]]
    expected: FAIL

  [In-document [Root Node\].findAll: Attribute value selector, matching attribute with value using non-ASCII characters (with refNode Element): [data-attr-value=\xe4\xb8\xad\xe6\x96\x87\]]
    expected: FAIL

  [In-document [Root Node\].find: Attribute value selector, matching attribute with value using non-ASCII characters (with refNode Element): [data-attr-value=\xe4\xb8\xad\xe6\x96\x87\]]
    expected: FAIL

  [In-document [Context Element\].findAll: Attribute whitespace-separated list selector, matching class attribute with value (with no refNodes): [class~="div1"\]]
    expected: FAIL

  [In-document [Context Element\].find: Attribute whitespace-separated list selector, matching class attribute with value (with no refNodes): [class~="div1"\]]
    expected: FAIL

  [In-document [Root Node\].findAll: Attribute whitespace-separated list selector, matching class attribute with value (with refNode Element): [class~="div1"\]]
    expected: FAIL

  [In-document [Root Node\].find: Attribute whitespace-separated list selector, matching class attribute with value (with refNode Element): [class~="div1"\]]
    expected: FAIL

  [In-document [Context Element\].findAll: Attribute whitespace-separated list selector, not matching class attribute with empty value (with no refNodes): [class~=""\]]
    expected: FAIL

  [In-document [Context Element\].find: Attribute whitespace-separated list selector, not matching class attribute with empty value (with no refNodes): [class~=""\]]
    expected: FAIL

  [In-document [Root Node\].findAll: Attribute whitespace-separated list selector, not matching class attribute with empty value (with refNode Element): [class~=""\]]
    expected: FAIL

  [In-document [Root Node\].find: Attribute whitespace-separated list selector, not matching class attribute with empty value (with refNode Element): [class~=""\]]
    expected: FAIL

  [In-document [Context Element\].findAll: Attribute whitespace-separated list selector, not matching class attribute with partial value (with no refNodes): [data-attr-whitespace~="div"\]]
    expected: FAIL

  [In-document [Context Element\].find: Attribute whitespace-separated list selector, not matching class attribute with partial value (with no refNodes): [data-attr-whitespace~="div"\]]
    expected: FAIL

  [In-document [Root Node\].findAll: Attribute whitespace-separated list selector, not matching class attribute with partial value (with refNode Element): [data-attr-whitespace~="div"\]]
    expected: FAIL

  [In-document [Root Node\].find: Attribute whitespace-separated list selector, not matching class attribute with partial value (with refNode Element): [data-attr-whitespace~="div"\]]
    expected: FAIL

  [In-document [Context Element\].findAll: Attribute whitespace-separated list selector, matching custom data-* attribute with unicode escaped value (with no refNodes): [data-attr-whitespace~="\\0000e9"\]]
    expected: FAIL

  [In-document [Context Element\].find: Attribute whitespace-separated list selector, matching custom data-* attribute with unicode escaped value (with no refNodes): [data-attr-whitespace~="\\0000e9"\]]
    expected: FAIL

  [In-document [Root Node\].findAll: Attribute whitespace-separated list selector, matching custom data-* attribute with unicode escaped value (with refNode Element): [data-attr-whitespace~="\\0000e9"\]]
    expected: FAIL

  [In-document [Root Node\].find: Attribute whitespace-separated list selector, matching custom data-* attribute with unicode escaped value (with refNode Element): [data-attr-whitespace~="\\0000e9"\]]
    expected: FAIL

  [In-document [Context Element\].findAll: Attribute whitespace-separated list selector, matching custom data-* attribute with escaped character (with no refNodes): [data-attr-whitespace_foo~="\\e9"\]]
    expected: FAIL

  [In-document [Context Element\].find: Attribute whitespace-separated list selector, matching custom data-* attribute with escaped character (with no refNodes): [data-attr-whitespace_foo~="\\e9"\]]
    expected: FAIL

  [In-document [Root Node\].findAll: Attribute whitespace-separated list selector, matching custom data-* attribute with escaped character (with refNode Element): [data-attr-whitespace_foo~="\\e9"\]]
    expected: FAIL

  [In-document [Root Node\].find: Attribute whitespace-separated list selector, matching custom data-* attribute with escaped character (with refNode Element): [data-attr-whitespace_foo~="\\e9"\]]
    expected: FAIL

  [In-document [Context Element\].findAll: Attribute whitespace-separated list selector with single-quoted value, matching multiple links with rel attributes (with no refNodes): a[rel~=\'bookmark\'\],  #attr-whitespace a[rel~=\'nofollow\'\]]
    expected: FAIL

  [In-document [Context Element\].find: Attribute whitespace-separated list selector with single-quoted value, matching multiple links with rel attributes (with no refNodes): a[rel~=\'bookmark\'\],  #attr-whitespace a[rel~=\'nofollow\'\]]
    expected: FAIL

  [In-document [Root Node\].findAll: Attribute whitespace-separated list selector with single-quoted value, matching multiple links with rel attributes (with refNode Element): a[rel~=\'bookmark\'\],  #attr-whitespace a[rel~=\'nofollow\'\]]
    expected: FAIL

  [In-document [Root Node\].find: Attribute whitespace-separated list selector with single-quoted value, matching multiple links with rel attributes (with refNode Element): a[rel~=\'bookmark\'\],  #attr-whitespace a[rel~=\'nofollow\'\]]
    expected: FAIL

  [In-document [Context Element\].findAll: Attribute whitespace-separated list selector with double-quoted value, matching multiple links with rel attributes (with no refNodes): a[rel~="bookmark"\],#attr-whitespace a[rel~=\'nofollow\'\]]
    expected: FAIL

  [In-document [Context Element\].find: Attribute whitespace-separated list selector with double-quoted value, matching multiple links with rel attributes (with no refNodes): a[rel~="bookmark"\],#attr-whitespace a[rel~=\'nofollow\'\]]
    expected: FAIL

  [In-document [Root Node\].findAll: Attribute whitespace-separated list selector with double-quoted value, matching multiple links with rel attributes (with refNode Element): a[rel~="bookmark"\],#attr-whitespace a[rel~=\'nofollow\'\]]
    expected: FAIL

  [In-document [Root Node\].find: Attribute whitespace-separated list selector with double-quoted value, matching multiple links with rel attributes (with refNode Element): a[rel~="bookmark"\],#attr-whitespace a[rel~=\'nofollow\'\]]
    expected: FAIL

  [In-document [Context Element\].findAll: Attribute whitespace-separated list selector with unquoted value, matching multiple links with rel attributes (with no refNodes): a[rel~=bookmark\],    #attr-whitespace a[rel~=nofollow\]]
    expected: FAIL

  [In-document [Context Element\].find: Attribute whitespace-separated list selector with unquoted value, matching multiple links with rel attributes (with no refNodes): a[rel~=bookmark\],    #attr-whitespace a[rel~=nofollow\]]
    expected: FAIL

  [In-document [Root Node\].findAll: Attribute whitespace-separated list selector with unquoted value, matching multiple links with rel attributes (with refNode Element): a[rel~=bookmark\],    #attr-whitespace a[rel~=nofollow\]]
    expected: FAIL

  [In-document [Root Node\].find: Attribute whitespace-separated list selector with unquoted value, matching multiple links with rel attributes (with refNode Element): a[rel~=bookmark\],    #attr-whitespace a[rel~=nofollow\]]
    expected: FAIL

  [In-document [Context Element\].findAll: Attribute whitespace-separated list selector with double-quoted value, not matching value with space (with no refNodes): a[rel~="book mark"\]]
    expected: FAIL

  [In-document [Context Element\].find: Attribute whitespace-separated list selector with double-quoted value, not matching value with space (with no refNodes): a[rel~="book mark"\]]
    expected: FAIL

  [In-document [Root Node\].findAll: Attribute whitespace-separated list selector with double-quoted value, not matching value with space (with refNode Element): a[rel~="book mark"\]]
    expected: FAIL

  [In-document [Root Node\].find: Attribute whitespace-separated list selector with double-quoted value, not matching value with space (with refNode Element): a[rel~="book mark"\]]
    expected: FAIL

  [In-document [Context Element\].findAll: Attribute whitespace-separated list selector, matching title attribute with value using non-ASCII characters (with no refNodes): [title~=\xe4\xb8\xad\xe6\x96\x87\]]
    expected: FAIL

  [In-document [Context Element\].find: Attribute whitespace-separated list selector, matching title attribute with value using non-ASCII characters (with no refNodes): [title~=\xe4\xb8\xad\xe6\x96\x87\]]
    expected: FAIL

  [In-document [Root Node\].findAll: Attribute whitespace-separated list selector, matching title attribute with value using non-ASCII characters (with refNode Element): [title~=\xe4\xb8\xad\xe6\x96\x87\]]
    expected: FAIL

  [In-document [Root Node\].find: Attribute whitespace-separated list selector, matching title attribute with value using non-ASCII characters (with refNode Element): [title~=\xe4\xb8\xad\xe6\x96\x87\]]
    expected: FAIL

  [In-document [Context Element\].findAll: Attribute hyphen-separated list selector, not matching unspecified lang attribute (with no refNodes): #attr-hyphen-div1[lang|="en"\]]
    expected: FAIL

  [In-document [Context Element\].find: Attribute hyphen-separated list selector, not matching unspecified lang attribute (with no refNodes): #attr-hyphen-div1[lang|="en"\]]
    expected: FAIL

  [In-document [Root Node\].findAll: Attribute hyphen-separated list selector, not matching unspecified lang attribute (with refNode Element): #attr-hyphen-div1[lang|="en"\]]
    expected: FAIL

  [In-document [Root Node\].find: Attribute hyphen-separated list selector, not matching unspecified lang attribute (with refNode Element): #attr-hyphen-div1[lang|="en"\]]
    expected: FAIL

  [In-document [Context Element\].findAll: Attribute hyphen-separated list selector, matching lang attribute with exact value (with no refNodes): #attr-hyphen-div2[lang|="fr"\]]
    expected: FAIL

  [In-document [Context Element\].find: Attribute hyphen-separated list selector, matching lang attribute with exact value (with no refNodes): #attr-hyphen-div2[lang|="fr"\]]
    expected: FAIL

  [In-document [Root Node\].findAll: Attribute hyphen-separated list selector, matching lang attribute with exact value (with refNode Element): #attr-hyphen-div2[lang|="fr"\]]
    expected: FAIL

  [In-document [Root Node\].find: Attribute hyphen-separated list selector, matching lang attribute with exact value (with refNode Element): #attr-hyphen-div2[lang|="fr"\]]
    expected: FAIL

  [In-document [Context Element\].findAll: Attribute hyphen-separated list selector, matching lang attribute with partial value (with no refNodes): #attr-hyphen-div3[lang|="en"\]]
    expected: FAIL

  [In-document [Context Element\].find: Attribute hyphen-separated list selector, matching lang attribute with partial value (with no refNodes): #attr-hyphen-div3[lang|="en"\]]
    expected: FAIL

  [In-document [Root Node\].findAll: Attribute hyphen-separated list selector, matching lang attribute with partial value (with refNode Element): #attr-hyphen-div3[lang|="en"\]]
    expected: FAIL

  [In-document [Root Node\].find: Attribute hyphen-separated list selector, matching lang attribute with partial value (with refNode Element): #attr-hyphen-div3[lang|="en"\]]
    expected: FAIL

  [In-document [Context Element\].findAll: Attribute hyphen-separated list selector, not matching incorrect value (with no refNodes): #attr-hyphen-div4[lang|="es-AR"\]]
    expected: FAIL

  [In-document [Context Element\].find: Attribute hyphen-separated list selector, not matching incorrect value (with no refNodes): #attr-hyphen-div4[lang|="es-AR"\]]
    expected: FAIL

  [In-document [Root Node\].findAll: Attribute hyphen-separated list selector, not matching incorrect value (with refNode Element): #attr-hyphen-div4[lang|="es-AR"\]]
    expected: FAIL

  [In-document [Root Node\].find: Attribute hyphen-separated list selector, not matching incorrect value (with refNode Element): #attr-hyphen-div4[lang|="es-AR"\]]
    expected: FAIL

  [In-document [Context Element\].findAll: Attribute begins with selector, matching href attributes beginning with specified substring (with no refNodes): a[href^="http://www"\]]
    expected: FAIL

  [In-document [Context Element\].find: Attribute begins with selector, matching href attributes beginning with specified substring (with no refNodes): a[href^="http://www"\]]
    expected: FAIL

  [In-document [Root Node\].findAll: Attribute begins with selector, matching href attributes beginning with specified substring (with refNode Element): a[href^="http://www"\]]
    expected: FAIL

  [In-document [Root Node\].find: Attribute begins with selector, matching href attributes beginning with specified substring (with refNode Element): a[href^="http://www"\]]
    expected: FAIL

  [In-document [Context Element\].findAll: Attribute begins with selector, matching lang attributes beginning with specified substring,  (with no refNodes): [lang^="en-"\]]
    expected: FAIL

  [In-document [Context Element\].find: Attribute begins with selector, matching lang attributes beginning with specified substring,  (with no refNodes): [lang^="en-"\]]
    expected: FAIL

  [In-document [Root Node\].findAll: Attribute begins with selector, matching lang attributes beginning with specified substring,  (with refNode Element): [lang^="en-"\]]
    expected: FAIL

  [In-document [Root Node\].find: Attribute begins with selector, matching lang attributes beginning with specified substring,  (with refNode Element): [lang^="en-"\]]
    expected: FAIL

  [In-document [Context Element\].findAll: Attribute begins with selector, not matching class attribute not beginning with specified substring (with no refNodes): [class^=apple\]]
    expected: FAIL

  [In-document [Context Element\].find: Attribute begins with selector, not matching class attribute not beginning with specified substring (with no refNodes): [class^=apple\]]
    expected: FAIL

  [In-document [Root Node\].findAll: Attribute begins with selector, not matching class attribute not beginning with specified substring (with refNode Element): [class^=apple\]]
    expected: FAIL

  [In-document [Root Node\].find: Attribute begins with selector, not matching class attribute not beginning with specified substring (with refNode Element): [class^=apple\]]
    expected: FAIL

  [In-document [Context Element\].findAll: Attribute begins with selector with single-quoted value, matching class attribute beginning with specified substring (with no refNodes): [class^=\' apple\'\]]
    expected: FAIL

  [In-document [Context Element\].find: Attribute begins with selector with single-quoted value, matching class attribute beginning with specified substring (with no refNodes): [class^=\' apple\'\]]
    expected: FAIL

  [In-document [Root Node\].findAll: Attribute begins with selector with single-quoted value, matching class attribute beginning with specified substring (with refNode Element): [class^=\' apple\'\]]
    expected: FAIL

  [In-document [Root Node\].find: Attribute begins with selector with single-quoted value, matching class attribute beginning with specified substring (with refNode Element): [class^=\' apple\'\]]
    expected: FAIL

  [In-document [Context Element\].findAll: Attribute begins with selector with double-quoted value, matching class attribute beginning with specified substring (with no refNodes): [class^=" apple"\]]
    expected: FAIL

  [In-document [Context Element\].find: Attribute begins with selector with double-quoted value, matching class attribute beginning with specified substring (with no refNodes): [class^=" apple"\]]
    expected: FAIL

  [In-document [Root Node\].findAll: Attribute begins with selector with double-quoted value, matching class attribute beginning with specified substring (with refNode Element): [class^=" apple"\]]
    expected: FAIL

  [In-document [Root Node\].find: Attribute begins with selector with double-quoted value, matching class attribute beginning with specified substring (with refNode Element): [class^=" apple"\]]
    expected: FAIL

  [In-document [Context Element\].findAll: Attribute begins with selector with unquoted value, not matching class attribute not beginning with specified substring (with no refNodes): [class^= apple\]]
    expected: FAIL

  [In-document [Context Element\].find: Attribute begins with selector with unquoted value, not matching class attribute not beginning with specified substring (with no refNodes): [class^= apple\]]
    expected: FAIL

  [In-document [Root Node\].findAll: Attribute begins with selector with unquoted value, not matching class attribute not beginning with specified substring (with refNode Element): [class^= apple\]]
    expected: FAIL

  [In-document [Root Node\].find: Attribute begins with selector with unquoted value, not matching class attribute not beginning with specified substring (with refNode Element): [class^= apple\]]
    expected: FAIL

  [In-document [Context Element\].findAll: Attribute ends with selector, matching href attributes ending with specified substring (with no refNodes): a[href$=".org"\]]
    expected: FAIL

  [In-document [Context Element\].find: Attribute ends with selector, matching href attributes ending with specified substring (with no refNodes): a[href$=".org"\]]
    expected: FAIL

  [In-document [Root Node\].findAll: Attribute ends with selector, matching href attributes ending with specified substring (with refNode Element): a[href$=".org"\]]
    expected: FAIL

  [In-document [Root Node\].find: Attribute ends with selector, matching href attributes ending with specified substring (with refNode Element): a[href$=".org"\]]
    expected: FAIL

  [In-document [Context Element\].findAll: Attribute ends with selector, matching lang attributes ending with specified substring,  (with no refNodes): [lang$="-CH"\]]
    expected: FAIL

  [In-document [Context Element\].find: Attribute ends with selector, matching lang attributes ending with specified substring,  (with no refNodes): [lang$="-CH"\]]
    expected: FAIL

  [In-document [Root Node\].findAll: Attribute ends with selector, matching lang attributes ending with specified substring,  (with refNode Element): [lang$="-CH"\]]
    expected: FAIL

  [In-document [Root Node\].find: Attribute ends with selector, matching lang attributes ending with specified substring,  (with refNode Element): [lang$="-CH"\]]
    expected: FAIL

  [In-document [Context Element\].findAll: Attribute ends with selector, not matching class attribute not ending with specified substring (with no refNodes): [class$=apple\]]
    expected: FAIL

  [In-document [Context Element\].find: Attribute ends with selector, not matching class attribute not ending with specified substring (with no refNodes): [class$=apple\]]
    expected: FAIL

  [In-document [Root Node\].findAll: Attribute ends with selector, not matching class attribute not ending with specified substring (with refNode Element): [class$=apple\]]
    expected: FAIL

  [In-document [Root Node\].find: Attribute ends with selector, not matching class attribute not ending with specified substring (with refNode Element): [class$=apple\]]
    expected: FAIL

  [In-document [Context Element\].findAll: Attribute ends with selector with single-quoted value, matching class attribute ending with specified substring (with no refNodes): [class$=\'apple \'\]]
    expected: FAIL

  [In-document [Context Element\].find: Attribute ends with selector with single-quoted value, matching class attribute ending with specified substring (with no refNodes): [class$=\'apple \'\]]
    expected: FAIL

  [In-document [Root Node\].findAll: Attribute ends with selector with single-quoted value, matching class attribute ending with specified substring (with refNode Element): [class$=\'apple \'\]]
    expected: FAIL

  [In-document [Root Node\].find: Attribute ends with selector with single-quoted value, matching class attribute ending with specified substring (with refNode Element): [class$=\'apple \'\]]
    expected: FAIL

  [In-document [Context Element\].findAll: Attribute ends with selector with double-quoted value, matching class attribute ending with specified substring (with no refNodes): [class$="apple "\]]
    expected: FAIL

  [In-document [Context Element\].find: Attribute ends with selector with double-quoted value, matching class attribute ending with specified substring (with no refNodes): [class$="apple "\]]
    expected: FAIL

  [In-document [Root Node\].findAll: Attribute ends with selector with double-quoted value, matching class attribute ending with specified substring (with refNode Element): [class$="apple "\]]
    expected: FAIL

  [In-document [Root Node\].find: Attribute ends with selector with double-quoted value, matching class attribute ending with specified substring (with refNode Element): [class$="apple "\]]
    expected: FAIL

  [In-document [Context Element\].findAll: Attribute ends with selector with unquoted value, not matching class attribute not ending with specified substring (with no refNodes): [class$=apple \]]
    expected: FAIL

  [In-document [Context Element\].find: Attribute ends with selector with unquoted value, not matching class attribute not ending with specified substring (with no refNodes): [class$=apple \]]
    expected: FAIL

  [In-document [Root Node\].findAll: Attribute ends with selector with unquoted value, not matching class attribute not ending with specified substring (with refNode Element): [class$=apple \]]
    expected: FAIL

  [In-document [Root Node\].find: Attribute ends with selector with unquoted value, not matching class attribute not ending with specified substring (with refNode Element): [class$=apple \]]
    expected: FAIL

  [In-document [Context Element\].findAll: Attribute contains selector, matching href attributes beginning with specified substring (with no refNodes): a[href*="http://www"\]]
    expected: FAIL

  [In-document [Context Element\].find: Attribute contains selector, matching href attributes beginning with specified substring (with no refNodes): a[href*="http://www"\]]
    expected: FAIL

  [In-document [Root Node\].findAll: Attribute contains selector, matching href attributes beginning with specified substring (with refNode Element): a[href*="http://www"\]]
    expected: FAIL

  [In-document [Root Node\].find: Attribute contains selector, matching href attributes beginning with specified substring (with refNode Element): a[href*="http://www"\]]
    expected: FAIL

  [In-document [Context Element\].findAll: Attribute contains selector, matching href attributes ending with specified substring (with no refNodes): a[href*=".org"\]]
    expected: FAIL

  [In-document [Context Element\].find: Attribute contains selector, matching href attributes ending with specified substring (with no refNodes): a[href*=".org"\]]
    expected: FAIL

  [In-document [Root Node\].findAll: Attribute contains selector, matching href attributes ending with specified substring (with refNode Element): a[href*=".org"\]]
    expected: FAIL

  [In-document [Root Node\].find: Attribute contains selector, matching href attributes ending with specified substring (with refNode Element): a[href*=".org"\]]
    expected: FAIL

  [In-document [Context Element\].findAll: Attribute contains selector, matching href attributes containing specified substring (with no refNodes): a[href*=".example."\]]
    expected: FAIL

  [In-document [Context Element\].find: Attribute contains selector, matching href attributes containing specified substring (with no refNodes): a[href*=".example."\]]
    expected: FAIL

  [In-document [Root Node\].findAll: Attribute contains selector, matching href attributes containing specified substring (with refNode Element): a[href*=".example."\]]
    expected: FAIL

  [In-document [Root Node\].find: Attribute contains selector, matching href attributes containing specified substring (with refNode Element): a[href*=".example."\]]
    expected: FAIL

  [In-document [Context Element\].findAll: Attribute contains selector, matching lang attributes beginning with specified substring,  (with no refNodes): [lang*="en-"\]]
    expected: FAIL

  [In-document [Context Element\].find: Attribute contains selector, matching lang attributes beginning with specified substring,  (with no refNodes): [lang*="en-"\]]
    expected: FAIL

  [In-document [Root Node\].findAll: Attribute contains selector, matching lang attributes beginning with specified substring,  (with refNode Element): [lang*="en-"\]]
    expected: FAIL

  [In-document [Root Node\].find: Attribute contains selector, matching lang attributes beginning with specified substring,  (with refNode Element): [lang*="en-"\]]
    expected: FAIL

  [In-document [Context Element\].findAll: Attribute contains selector, matching lang attributes ending with specified substring,  (with no refNodes): [lang*="-CH"\]]
    expected: FAIL

  [In-document [Context Element\].find: Attribute contains selector, matching lang attributes ending with specified substring,  (with no refNodes): [lang*="-CH"\]]
    expected: FAIL

  [In-document [Root Node\].findAll: Attribute contains selector, matching lang attributes ending with specified substring,  (with refNode Element): [lang*="-CH"\]]
    expected: FAIL

  [In-document [Root Node\].find: Attribute contains selector, matching lang attributes ending with specified substring,  (with refNode Element): [lang*="-CH"\]]
    expected: FAIL

  [In-document [Context Element\].findAll: Attribute contains selector with single-quoted value, matching class attribute beginning with specified substring (with no refNodes): [class*=\' apple\'\]]
    expected: FAIL

  [In-document [Context Element\].find: Attribute contains selector with single-quoted value, matching class attribute beginning with specified substring (with no refNodes): [class*=\' apple\'\]]
    expected: FAIL

  [In-document [Root Node\].findAll: Attribute contains selector with single-quoted value, matching class attribute beginning with specified substring (with refNode Element): [class*=\' apple\'\]]
    expected: FAIL

  [In-document [Root Node\].find: Attribute contains selector with single-quoted value, matching class attribute beginning with specified substring (with refNode Element): [class*=\' apple\'\]]
    expected: FAIL

  [In-document [Context Element\].findAll: Attribute contains selector with single-quoted value, matching class attribute ending with specified substring (with no refNodes): [class*=\'orange \'\]]
    expected: FAIL

  [In-document [Context Element\].find: Attribute contains selector with single-quoted value, matching class attribute ending with specified substring (with no refNodes): [class*=\'orange \'\]]
    expected: FAIL

  [In-document [Root Node\].findAll: Attribute contains selector with single-quoted value, matching class attribute ending with specified substring (with refNode Element): [class*=\'orange \'\]]
    expected: FAIL

  [In-document [Root Node\].find: Attribute contains selector with single-quoted value, matching class attribute ending with specified substring (with refNode Element): [class*=\'orange \'\]]
    expected: FAIL

  [In-document [Context Element\].findAll: Attribute contains selector with single-quoted value, matching class attribute containing specified substring (with no refNodes): [class*=\'ple banana ora\'\]]
    expected: FAIL

  [In-document [Context Element\].find: Attribute contains selector with single-quoted value, matching class attribute containing specified substring (with no refNodes): [class*=\'ple banana ora\'\]]
    expected: FAIL

  [In-document [Root Node\].findAll: Attribute contains selector with single-quoted value, matching class attribute containing specified substring (with refNode Element): [class*=\'ple banana ora\'\]]
    expected: FAIL

  [In-document [Root Node\].find: Attribute contains selector with single-quoted value, matching class attribute containing specified substring (with refNode Element): [class*=\'ple banana ora\'\]]
    expected: FAIL

  [In-document [Context Element\].findAll: Attribute contains selector with double-quoted value, matching class attribute beginning with specified substring (with no refNodes): [class*=" apple"\]]
    expected: FAIL

  [In-document [Context Element\].find: Attribute contains selector with double-quoted value, matching class attribute beginning with specified substring (with no refNodes): [class*=" apple"\]]
    expected: FAIL

  [In-document [Root Node\].findAll: Attribute contains selector with double-quoted value, matching class attribute beginning with specified substring (with refNode Element): [class*=" apple"\]]
    expected: FAIL

  [In-document [Root Node\].find: Attribute contains selector with double-quoted value, matching class attribute beginning with specified substring (with refNode Element): [class*=" apple"\]]
    expected: FAIL

  [In-document [Context Element\].findAll: Attribute contains selector with double-quoted value, matching class attribute ending with specified substring (with no refNodes): [class*="orange "\]]
    expected: FAIL

  [In-document [Context Element\].find: Attribute contains selector with double-quoted value, matching class attribute ending with specified substring (with no refNodes): [class*="orange "\]]
    expected: FAIL

  [In-document [Root Node\].findAll: Attribute contains selector with double-quoted value, matching class attribute ending with specified substring (with refNode Element): [class*="orange "\]]
    expected: FAIL

  [In-document [Root Node\].find: Attribute contains selector with double-quoted value, matching class attribute ending with specified substring (with refNode Element): [class*="orange "\]]
    expected: FAIL

  [In-document [Context Element\].findAll: Attribute contains selector with double-quoted value, matching class attribute containing specified substring (with no refNodes): [class*="ple banana ora"\]]
    expected: FAIL

  [In-document [Context Element\].find: Attribute contains selector with double-quoted value, matching class attribute containing specified substring (with no refNodes): [class*="ple banana ora"\]]
    expected: FAIL

  [In-document [Root Node\].findAll: Attribute contains selector with double-quoted value, matching class attribute containing specified substring (with refNode Element): [class*="ple banana ora"\]]
    expected: FAIL

  [In-document [Root Node\].find: Attribute contains selector with double-quoted value, matching class attribute containing specified substring (with refNode Element): [class*="ple banana ora"\]]
    expected: FAIL

  [In-document [Context Element\].findAll: Attribute contains selector with unquoted value, matching class attribute beginning with specified substring (with no refNodes): [class*= apple\]]
    expected: FAIL

  [In-document [Context Element\].find: Attribute contains selector with unquoted value, matching class attribute beginning with specified substring (with no refNodes): [class*= apple\]]
    expected: FAIL

  [In-document [Root Node\].findAll: Attribute contains selector with unquoted value, matching class attribute beginning with specified substring (with refNode Element): [class*= apple\]]
    expected: FAIL

  [In-document [Root Node\].find: Attribute contains selector with unquoted value, matching class attribute beginning with specified substring (with refNode Element): [class*= apple\]]
    expected: FAIL

  [In-document [Context Element\].findAll: Attribute contains selector with unquoted value, matching class attribute ending with specified substring (with no refNodes): [class*=orange \]]
    expected: FAIL

  [In-document [Context Element\].find: Attribute contains selector with unquoted value, matching class attribute ending with specified substring (with no refNodes): [class*=orange \]]
    expected: FAIL

  [In-document [Root Node\].findAll: Attribute contains selector with unquoted value, matching class attribute ending with specified substring (with refNode Element): [class*=orange \]]
    expected: FAIL

  [In-document [Root Node\].find: Attribute contains selector with unquoted value, matching class attribute ending with specified substring (with refNode Element): [class*=orange \]]
    expected: FAIL

  [In-document [Context Element\].findAll: Attribute contains selector with unquoted value, matching class attribute containing specified substring (with no refNodes): [class*= banana \]]
    expected: FAIL

  [In-document [Context Element\].find: Attribute contains selector with unquoted value, matching class attribute containing specified substring (with no refNodes): [class*= banana \]]
    expected: FAIL

  [In-document [Root Node\].findAll: Attribute contains selector with unquoted value, matching class attribute containing specified substring (with refNode Element): [class*= banana \]]
    expected: FAIL

  [In-document [Root Node\].find: Attribute contains selector with unquoted value, matching class attribute containing specified substring (with refNode Element): [class*= banana \]]
    expected: FAIL

  [In-document.findAll: :root pseudo-class selector, matching document root element (with no refNodes): :root]
    expected: FAIL

  [In-document.find: :root pseudo-class selector, matching document root element (with no refNodes): :root]
    expected: FAIL

  [In-document [Context Element\].findAll: :root pseudo-class selector, not matching document root element (with no refNodes): :root]
    expected: FAIL

  [In-document [Context Element\].find: :root pseudo-class selector, not matching document root element (with no refNodes): :root]
    expected: FAIL

  [In-document [Root Node\].findAll: :root pseudo-class selector, not matching document root element (with refNode Element): :root]
    expected: FAIL

  [In-document [Root Node\].find: :root pseudo-class selector, not matching document root element (with refNode Element): :root]
    expected: FAIL

  [In-document [Context Element\].findAll: :nth-child selector, matching the third child element (with no refNodes): :nth-child(3)]
    expected: FAIL

  [In-document [Context Element\].find: :nth-child selector, matching the third child element (with no refNodes): :nth-child(3)]
    expected: FAIL

  [In-document [Root Node\].findAll: :nth-child selector, matching the third child element (with refNode Element): :nth-child(3)]
    expected: FAIL

  [In-document [Root Node\].find: :nth-child selector, matching the third child element (with refNode Element): :nth-child(3)]
    expected: FAIL

  [In-document [Context Element\].findAll: :nth-child selector, matching every third child element (with no refNodes): li:nth-child(3n)]
    expected: FAIL

  [In-document [Context Element\].find: :nth-child selector, matching every third child element (with no refNodes): li:nth-child(3n)]
    expected: FAIL

  [In-document [Root Node\].findAll: :nth-child selector, matching every third child element (with refNode Element): li:nth-child(3n)]
    expected: FAIL

  [In-document [Root Node\].find: :nth-child selector, matching every third child element (with refNode Element): li:nth-child(3n)]
    expected: FAIL

  [In-document [Context Element\].findAll: :nth-child selector, matching every second child element, starting from the fourth (with no refNodes): li:nth-child(2n+4)]
    expected: FAIL

  [In-document [Context Element\].find: :nth-child selector, matching every second child element, starting from the fourth (with no refNodes): li:nth-child(2n+4)]
    expected: FAIL

  [In-document [Root Node\].findAll: :nth-child selector, matching every second child element, starting from the fourth (with refNode Element): li:nth-child(2n+4)]
    expected: FAIL

  [In-document [Root Node\].find: :nth-child selector, matching every second child element, starting from the fourth (with refNode Element): li:nth-child(2n+4)]
    expected: FAIL

  [In-document [Context Element\].findAll: :nth-child selector, matching every fourth child element, starting from the third (with no refNodes): :nth-child(4n-1)]
    expected: FAIL

  [In-document [Context Element\].find: :nth-child selector, matching every fourth child element, starting from the third (with no refNodes): :nth-child(4n-1)]
    expected: FAIL

  [In-document [Root Node\].findAll: :nth-child selector, matching every fourth child element, starting from the third (with refNode Element): :nth-child(4n-1)]
    expected: FAIL

  [In-document [Root Node\].find: :nth-child selector, matching every fourth child element, starting from the third (with refNode Element): :nth-child(4n-1)]
    expected: FAIL

  [In-document [Context Element\].findAll: :nth-last-child selector, matching the third last child element (with no refNodes): :nth-last-child(3)]
    expected: FAIL

  [In-document [Context Element\].find: :nth-last-child selector, matching the third last child element (with no refNodes): :nth-last-child(3)]
    expected: FAIL

  [In-document [Root Node\].findAll: :nth-last-child selector, matching the third last child element (with refNode Element): :nth-last-child(3)]
    expected: FAIL

  [In-document [Root Node\].find: :nth-last-child selector, matching the third last child element (with refNode Element): :nth-last-child(3)]
    expected: FAIL

  [In-document [Context Element\].findAll: :nth-last-child selector, matching every third child element from the end (with no refNodes): li:nth-last-child(3n)]
    expected: FAIL

  [In-document [Context Element\].find: :nth-last-child selector, matching every third child element from the end (with no refNodes): li:nth-last-child(3n)]
    expected: FAIL

  [In-document [Root Node\].findAll: :nth-last-child selector, matching every third child element from the end (with refNode Element): li:nth-last-child(3n)]
    expected: FAIL

  [In-document [Root Node\].find: :nth-last-child selector, matching every third child element from the end (with refNode Element): li:nth-last-child(3n)]
    expected: FAIL

  [In-document [Context Element\].findAll: :nth-last-child selector, matching every second child element from the end, starting from the fourth last (with no refNodes): li:nth-last-child(2n+4)]
    expected: FAIL

  [In-document [Context Element\].find: :nth-last-child selector, matching every second child element from the end, starting from the fourth last (with no refNodes): li:nth-last-child(2n+4)]
    expected: FAIL

  [In-document [Root Node\].findAll: :nth-last-child selector, matching every second child element from the end, starting from the fourth last (with refNode Element): li:nth-last-child(2n+4)]
    expected: FAIL

  [In-document [Root Node\].find: :nth-last-child selector, matching every second child element from the end, starting from the fourth last (with refNode Element): li:nth-last-child(2n+4)]
    expected: FAIL

  [In-document [Context Element\].findAll: :nth-last-child selector, matching every fourth element from the end, starting from the third last (with no refNodes): :nth-last-child(4n-1)]
    expected: FAIL

  [In-document [Context Element\].find: :nth-last-child selector, matching every fourth element from the end, starting from the third last (with no refNodes): :nth-last-child(4n-1)]
    expected: FAIL

  [In-document [Root Node\].findAll: :nth-last-child selector, matching every fourth element from the end, starting from the third last (with refNode Element): :nth-last-child(4n-1)]
    expected: FAIL

  [In-document [Root Node\].find: :nth-last-child selector, matching every fourth element from the end, starting from the third last (with refNode Element): :nth-last-child(4n-1)]
    expected: FAIL

  [In-document [Context Element\].findAll: :nth-of-type selector, matching the third em element (with no refNodes): em:nth-of-type(3)]
    expected: FAIL

  [In-document [Context Element\].find: :nth-of-type selector, matching the third em element (with no refNodes): em:nth-of-type(3)]
    expected: FAIL

  [In-document [Root Node\].findAll: :nth-of-type selector, matching the third em element (with refNode Element): em:nth-of-type(3)]
    expected: FAIL

  [In-document [Root Node\].find: :nth-of-type selector, matching the third em element (with refNode Element): em:nth-of-type(3)]
    expected: FAIL

  [In-document [Context Element\].findAll: :nth-of-type selector, matching every second element of their type (with no refNodes): :nth-of-type(2n)]
    expected: FAIL

  [In-document [Context Element\].find: :nth-of-type selector, matching every second element of their type (with no refNodes): :nth-of-type(2n)]
    expected: FAIL

  [In-document [Root Node\].findAll: :nth-of-type selector, matching every second element of their type (with refNode Element): :nth-of-type(2n)]
    expected: FAIL

  [In-document [Root Node\].find: :nth-of-type selector, matching every second element of their type (with refNode Element): :nth-of-type(2n)]
    expected: FAIL

  [In-document [Context Element\].findAll: :nth-of-type selector, matching every second elemetn of their type, starting from the first (with no refNodes): span:nth-of-type(2n-1)]
    expected: FAIL

  [In-document [Context Element\].find: :nth-of-type selector, matching every second elemetn of their type, starting from the first (with no refNodes): span:nth-of-type(2n-1)]
    expected: FAIL

  [In-document [Root Node\].findAll: :nth-of-type selector, matching every second elemetn of their type, starting from the first (with refNode Element): span:nth-of-type(2n-1)]
    expected: FAIL

  [In-document [Root Node\].find: :nth-of-type selector, matching every second elemetn of their type, starting from the first (with refNode Element): span:nth-of-type(2n-1)]
    expected: FAIL

  [In-document [Context Element\].findAll: :nth-last-of-type selector, matching the thrid last em element (with no refNodes): em:nth-last-of-type(3)]
    expected: FAIL

  [In-document [Context Element\].find: :nth-last-of-type selector, matching the thrid last em element (with no refNodes): em:nth-last-of-type(3)]
    expected: FAIL

  [In-document [Root Node\].findAll: :nth-last-of-type selector, matching the thrid last em element (with refNode Element): em:nth-last-of-type(3)]
    expected: FAIL

  [In-document [Root Node\].find: :nth-last-of-type selector, matching the thrid last em element (with refNode Element): em:nth-last-of-type(3)]
    expected: FAIL

  [In-document [Context Element\].findAll: :nth-last-of-type selector, matching every second last element of their type (with no refNodes): :nth-last-of-type(2n)]
    expected: FAIL

  [In-document [Context Element\].find: :nth-last-of-type selector, matching every second last element of their type (with no refNodes): :nth-last-of-type(2n)]
    expected: FAIL

  [In-document [Root Node\].findAll: :nth-last-of-type selector, matching every second last element of their type (with refNode Element): :nth-last-of-type(2n)]
    expected: FAIL

  [In-document [Root Node\].find: :nth-last-of-type selector, matching every second last element of their type (with refNode Element): :nth-last-of-type(2n)]
    expected: FAIL

  [In-document [Context Element\].findAll: :nth-last-of-type selector, matching every second last element of their type, starting from the last (with no refNodes): span:nth-last-of-type(2n-1)]
    expected: FAIL

  [In-document [Context Element\].find: :nth-last-of-type selector, matching every second last element of their type, starting from the last (with no refNodes): span:nth-last-of-type(2n-1)]
    expected: FAIL

  [In-document [Root Node\].findAll: :nth-last-of-type selector, matching every second last element of their type, starting from the last (with refNode Element): span:nth-last-of-type(2n-1)]
    expected: FAIL

  [In-document [Root Node\].find: :nth-last-of-type selector, matching every second last element of their type, starting from the last (with refNode Element): span:nth-last-of-type(2n-1)]
    expected: FAIL

  [In-document [Context Element\].findAll: :first-of-type selector, matching the first em element (with no refNodes): em:first-of-type]
    expected: FAIL

  [In-document [Context Element\].find: :first-of-type selector, matching the first em element (with no refNodes): em:first-of-type]
    expected: FAIL

  [In-document [Root Node\].findAll: :first-of-type selector, matching the first em element (with refNode Element): em:first-of-type]
    expected: FAIL

  [In-document [Root Node\].find: :first-of-type selector, matching the first em element (with refNode Element): em:first-of-type]
    expected: FAIL

  [In-document [Context Element\].findAll: :first-of-type selector, matching the first of every type of element (with no refNodes): :first-of-type]
    expected: FAIL

  [In-document [Context Element\].find: :first-of-type selector, matching the first of every type of element (with no refNodes): :first-of-type]
    expected: FAIL

  [In-document [Root Node\].findAll: :first-of-type selector, matching the first of every type of element (with refNode Element): :first-of-type]
    expected: FAIL

  [In-document [Root Node\].find: :first-of-type selector, matching the first of every type of element (with refNode Element): :first-of-type]
    expected: FAIL

  [In-document [Context Element\].findAll: :first-of-type selector, matching the first td element in each table row (with no refNodes): tr :first-of-type]
    expected: FAIL

  [In-document [Context Element\].find: :first-of-type selector, matching the first td element in each table row (with no refNodes): tr :first-of-type]
    expected: FAIL

  [In-document [Root Node\].findAll: :first-of-type selector, matching the first td element in each table row (with refNode Element): tr :first-of-type]
    expected: FAIL

  [In-document [Root Node\].find: :first-of-type selector, matching the first td element in each table row (with refNode Element): tr :first-of-type]
    expected: FAIL

  [In-document [Context Element\].findAll: :last-of-type selector, matching the last em elemnet (with no refNodes): em:last-of-type]
    expected: FAIL

  [In-document [Context Element\].find: :last-of-type selector, matching the last em elemnet (with no refNodes): em:last-of-type]
    expected: FAIL

  [In-document [Root Node\].findAll: :last-of-type selector, matching the last em elemnet (with refNode Element): em:last-of-type]
    expected: FAIL

  [In-document [Root Node\].find: :last-of-type selector, matching the last em elemnet (with refNode Element): em:last-of-type]
    expected: FAIL

  [In-document [Context Element\].findAll: :last-of-type selector, matching the last of every type of element (with no refNodes): :last-of-type]
    expected: FAIL

  [In-document [Context Element\].find: :last-of-type selector, matching the last of every type of element (with no refNodes): :last-of-type]
    expected: FAIL

  [In-document [Root Node\].findAll: :last-of-type selector, matching the last of every type of element (with refNode Element): :last-of-type]
    expected: FAIL

  [In-document [Root Node\].find: :last-of-type selector, matching the last of every type of element (with refNode Element): :last-of-type]
    expected: FAIL

  [In-document [Context Element\].findAll: :last-of-type selector, matching the last td element in each table row (with no refNodes): tr :last-of-type]
    expected: FAIL

  [In-document [Context Element\].find: :last-of-type selector, matching the last td element in each table row (with no refNodes): tr :last-of-type]
    expected: FAIL

  [In-document [Root Node\].findAll: :last-of-type selector, matching the last td element in each table row (with refNode Element): tr :last-of-type]
    expected: FAIL

  [In-document [Root Node\].find: :last-of-type selector, matching the last td element in each table row (with refNode Element): tr :last-of-type]
    expected: FAIL

  [In-document [Context Element\].findAll: :first-child pseudo-class selector, matching first child div element (with no refNodes): div:first-child]
    expected: FAIL

  [In-document [Context Element\].find: :first-child pseudo-class selector, matching first child div element (with no refNodes): div:first-child]
    expected: FAIL

  [In-document [Root Node\].findAll: :first-child pseudo-class selector, matching first child div element (with refNode Element): div:first-child]
    expected: FAIL

  [In-document [Root Node\].find: :first-child pseudo-class selector, matching first child div element (with refNode Element): div:first-child]
    expected: FAIL

  [In-document [Context Element\].findAll: :first-child pseudo-class selector, doesn\'t match non-first-child elements (with no refNodes): .pseudo-first-child-div2:first-child, .pseudo-first-child-div3:first-child]
    expected: FAIL

  [In-document [Context Element\].find: :first-child pseudo-class selector, doesn\'t match non-first-child elements (with no refNodes): .pseudo-first-child-div2:first-child, .pseudo-first-child-div3:first-child]
    expected: FAIL

  [In-document [Root Node\].findAll: :first-child pseudo-class selector, doesn\'t match non-first-child elements (with refNode Element): .pseudo-first-child-div2:first-child, .pseudo-first-child-div3:first-child]
    expected: FAIL

  [In-document [Root Node\].find: :first-child pseudo-class selector, doesn\'t match non-first-child elements (with refNode Element): .pseudo-first-child-div2:first-child, .pseudo-first-child-div3:first-child]
    expected: FAIL

  [In-document [Context Element\].findAll: :first-child pseudo-class selector, matching first-child of multiple elements (with no refNodes): span:first-child]
    expected: FAIL

  [In-document [Context Element\].find: :first-child pseudo-class selector, matching first-child of multiple elements (with no refNodes): span:first-child]
    expected: FAIL

  [In-document [Root Node\].findAll: :first-child pseudo-class selector, matching first-child of multiple elements (with refNode Element): span:first-child]
    expected: FAIL

  [In-document [Root Node\].find: :first-child pseudo-class selector, matching first-child of multiple elements (with refNode Element): span:first-child]
    expected: FAIL

  [In-document [Context Element\].findAll: :last-child pseudo-class selector, matching last child div element (with no refNodes): div:last-child]
    expected: FAIL

  [In-document [Context Element\].find: :last-child pseudo-class selector, matching last child div element (with no refNodes): div:last-child]
    expected: FAIL

  [In-document [Root Node\].findAll: :last-child pseudo-class selector, matching last child div element (with refNode Element): div:last-child]
    expected: FAIL

  [In-document [Root Node\].find: :last-child pseudo-class selector, matching last child div element (with refNode Element): div:last-child]
    expected: FAIL

  [In-document [Context Element\].findAll: :last-child pseudo-class selector, doesn\'t match non-last-child elements (with no refNodes): .pseudo-last-child-div1:last-child, .pseudo-last-child-div2:first-child]
    expected: FAIL

  [In-document [Context Element\].find: :last-child pseudo-class selector, doesn\'t match non-last-child elements (with no refNodes): .pseudo-last-child-div1:last-child, .pseudo-last-child-div2:first-child]
    expected: FAIL

  [In-document [Root Node\].findAll: :last-child pseudo-class selector, doesn\'t match non-last-child elements (with refNode Element): .pseudo-last-child-div1:last-child, .pseudo-last-child-div2:first-child]
    expected: FAIL

  [In-document [Root Node\].find: :last-child pseudo-class selector, doesn\'t match non-last-child elements (with refNode Element): .pseudo-last-child-div1:last-child, .pseudo-last-child-div2:first-child]
    expected: FAIL

  [In-document [Context Element\].findAll: :last-child pseudo-class selector, matching first-child of multiple elements (with no refNodes): span:last-child]
    expected: FAIL

  [In-document [Context Element\].find: :last-child pseudo-class selector, matching first-child of multiple elements (with no refNodes): span:last-child]
    expected: FAIL

  [In-document [Root Node\].findAll: :last-child pseudo-class selector, matching first-child of multiple elements (with refNode Element): span:last-child]
    expected: FAIL

  [In-document [Root Node\].find: :last-child pseudo-class selector, matching first-child of multiple elements (with refNode Element): span:last-child]
    expected: FAIL

  [In-document [Context Element\].findAll: :pseudo-only-child pseudo-class selector, matching all only-child elements (with no refNodes): :only-child]
    expected: FAIL

  [In-document [Context Element\].find: :pseudo-only-child pseudo-class selector, matching all only-child elements (with no refNodes): :only-child]
    expected: FAIL

  [In-document [Root Node\].findAll: :pseudo-only-child pseudo-class selector, matching all only-child elements (with refNode Element): :only-child]
    expected: FAIL

  [In-document [Root Node\].find: :pseudo-only-child pseudo-class selector, matching all only-child elements (with refNode Element): :only-child]
    expected: FAIL

  [In-document [Context Element\].findAll: :pseudo-only-child pseudo-class selector, matching only-child em elements (with no refNodes): em:only-child]
    expected: FAIL

  [In-document [Context Element\].find: :pseudo-only-child pseudo-class selector, matching only-child em elements (with no refNodes): em:only-child]
    expected: FAIL

  [In-document [Root Node\].findAll: :pseudo-only-child pseudo-class selector, matching only-child em elements (with refNode Element): em:only-child]
    expected: FAIL

  [In-document [Root Node\].find: :pseudo-only-child pseudo-class selector, matching only-child em elements (with refNode Element): em:only-child]
    expected: FAIL

  [In-document [Context Element\].findAll: :pseudo-only-of-type pseudo-class selector, matching all elements with no siblings of the same type (with no refNodes):  :only-of-type]
    expected: FAIL

  [In-document [Context Element\].find: :pseudo-only-of-type pseudo-class selector, matching all elements with no siblings of the same type (with no refNodes):  :only-of-type]
    expected: FAIL

  [In-document [Root Node\].findAll: :pseudo-only-of-type pseudo-class selector, matching all elements with no siblings of the same type (with refNode Element):  :only-of-type]
    expected: FAIL

  [In-document [Root Node\].find: :pseudo-only-of-type pseudo-class selector, matching all elements with no siblings of the same type (with refNode Element):  :only-of-type]
    expected: FAIL

  [In-document [Context Element\].findAll: :pseudo-only-of-type pseudo-class selector, matching em elements with no siblings of the same type (with no refNodes):  em:only-of-type]
    expected: FAIL

  [In-document [Context Element\].find: :pseudo-only-of-type pseudo-class selector, matching em elements with no siblings of the same type (with no refNodes):  em:only-of-type]
    expected: FAIL

  [In-document [Root Node\].findAll: :pseudo-only-of-type pseudo-class selector, matching em elements with no siblings of the same type (with refNode Element):  em:only-of-type]
    expected: FAIL

  [In-document [Root Node\].find: :pseudo-only-of-type pseudo-class selector, matching em elements with no siblings of the same type (with refNode Element):  em:only-of-type]
    expected: FAIL

  [In-document [Context Element\].findAll: :empty pseudo-class selector, matching empty p elements (with no refNodes): p:empty]
    expected: FAIL

  [In-document [Context Element\].find: :empty pseudo-class selector, matching empty p elements (with no refNodes): p:empty]
    expected: FAIL

  [In-document [Root Node\].findAll: :empty pseudo-class selector, matching empty p elements (with refNode Element): p:empty]
    expected: FAIL

  [In-document [Root Node\].find: :empty pseudo-class selector, matching empty p elements (with refNode Element): p:empty]
    expected: FAIL

  [In-document [Context Element\].findAll: :empty pseudo-class selector, matching all empty elements (with no refNodes): :empty]
    expected: FAIL

  [In-document [Context Element\].find: :empty pseudo-class selector, matching all empty elements (with no refNodes): :empty]
    expected: FAIL

  [In-document [Root Node\].findAll: :empty pseudo-class selector, matching all empty elements (with refNode Element): :empty]
    expected: FAIL

  [In-document [Root Node\].find: :empty pseudo-class selector, matching all empty elements (with refNode Element): :empty]
    expected: FAIL

  [In-document [Context Element\].findAll: :link and :visited pseudo-class selectors, matching a and area elements with href attributes (with no refNodes):  :link, #pseudo-link :visited]
    expected: FAIL

  [In-document [Context Element\].find: :link and :visited pseudo-class selectors, matching a and area elements with href attributes (with no refNodes):  :link, #pseudo-link :visited]
    expected: FAIL

  [In-document [Root Node\].findAll: :link and :visited pseudo-class selectors, matching a and area elements with href attributes (with refNode Element):  :link, #pseudo-link :visited]
    expected: FAIL

  [In-document [Root Node\].find: :link and :visited pseudo-class selectors, matching a and area elements with href attributes (with refNode Element):  :link, #pseudo-link :visited]
    expected: FAIL

  [In-document [Context Element\].findAll: :link and :visited pseudo-class selectors, matching link elements with href attributes (with no refNodes):  :link, #head :visited]
    expected: FAIL

  [In-document [Context Element\].find: :link and :visited pseudo-class selectors, matching link elements with href attributes (with no refNodes):  :link, #head :visited]
    expected: FAIL

  [In-document [Root Node\].findAll: :link and :visited pseudo-class selectors, matching link elements with href attributes (with refNode Element):  :link, #head :visited]
    expected: FAIL

  [In-document [Root Node\].find: :link and :visited pseudo-class selectors, matching link elements with href attributes (with refNode Element):  :link, #head :visited]
    expected: FAIL

  [In-document.findAll: :target pseudo-class selector, matching the element referenced by the URL fragment identifier (with no refNodes): :target]
    expected: FAIL

  [In-document.find: :target pseudo-class selector, matching the element referenced by the URL fragment identifier (with no refNodes): :target]
    expected: FAIL

  [In-document.findAll: :lang pseudo-class selector, matching inherited language (with no refNodes): #pseudo-lang-div1:lang(en)]
    expected: FAIL

  [In-document.find: :lang pseudo-class selector, matching inherited language (with no refNodes): #pseudo-lang-div1:lang(en)]
    expected: FAIL

  [In-document.findAll: :lang pseudo-class selector, matching specified language with exact value (with no refNodes): #pseudo-lang-div2:lang(fr)]
    expected: FAIL

  [In-document.find: :lang pseudo-class selector, matching specified language with exact value (with no refNodes): #pseudo-lang-div2:lang(fr)]
    expected: FAIL

  [In-document.findAll: :lang pseudo-class selector, matching specified language with partial value (with no refNodes): #pseudo-lang-div3:lang(en)]
    expected: FAIL

  [In-document.find: :lang pseudo-class selector, matching specified language with partial value (with no refNodes): #pseudo-lang-div3:lang(en)]
    expected: FAIL

  [In-document.findAll: :lang pseudo-class selector, not matching incorrect language (with no refNodes): #pseudo-lang-div4:lang(es-AR)]
    expected: FAIL

  [In-document.find: :lang pseudo-class selector, not matching incorrect language (with no refNodes): #pseudo-lang-div4:lang(es-AR)]
    expected: FAIL

  [In-document.findAll: :enabled pseudo-class selector, matching all enabled form controls (with no refNodes): #pseudo-ui :enabled]
    expected: FAIL

  [In-document.find: :enabled pseudo-class selector, matching all enabled form controls (with no refNodes): #pseudo-ui :enabled]
    expected: FAIL

  [In-document.findAll: :enabled pseudo-class selector, matching all disabled form controls (with no refNodes): #pseudo-ui :disabled]
    expected: FAIL

  [In-document.find: :enabled pseudo-class selector, matching all disabled form controls (with no refNodes): #pseudo-ui :disabled]
    expected: FAIL

  [In-document.findAll: :checked pseudo-class selector, matching checked radio buttons and checkboxes (with no refNodes): #pseudo-ui :checked]
    expected: FAIL

  [In-document.find: :checked pseudo-class selector, matching checked radio buttons and checkboxes (with no refNodes): #pseudo-ui :checked]
    expected: FAIL

  [In-document.findAll: :not pseudo-class selector, matching  (with no refNodes): #not>:not(div)]
    expected: FAIL

  [In-document.find: :not pseudo-class selector, matching  (with no refNodes): #not>:not(div)]
    expected: FAIL

  [In-document.findAll: :not pseudo-class selector, matching  (with no refNodes): #not * :not(:first-child)]
    expected: FAIL

  [In-document.find: :not pseudo-class selector, matching  (with no refNodes): #not * :not(:first-child)]
    expected: FAIL

  [In-document.findAll: :not pseudo-class selector, matching nothing (with no refNodes): :not(*)]
    expected: FAIL

  [In-document.find: :not pseudo-class selector, matching nothing (with no refNodes): :not(*)]
    expected: FAIL

  [In-document.findAll: :not pseudo-class selector, matching nothing (with no refNodes): :not(*|*)]
    expected: FAIL

  [In-document.find: :not pseudo-class selector, matching nothing (with no refNodes): :not(*|*)]
    expected: FAIL

  [In-document.findAll: :first-line pseudo-element (one-colon syntax) selector, not matching any elements (with no refNodes): #pseudo-element:first-line]
    expected: FAIL

  [In-document.find: :first-line pseudo-element (one-colon syntax) selector, not matching any elements (with no refNodes): #pseudo-element:first-line]
    expected: FAIL

  [In-document.findAll: ::first-line pseudo-element (two-colon syntax) selector, not matching any elements (with no refNodes): #pseudo-element::first-line]
    expected: FAIL

  [In-document.find: ::first-line pseudo-element (two-colon syntax) selector, not matching any elements (with no refNodes): #pseudo-element::first-line]
    expected: FAIL

  [In-document.findAll: :first-letter pseudo-element (one-colon syntax) selector, not matching any elements (with no refNodes): #pseudo-element:first-letter]
    expected: FAIL

  [In-document.find: :first-letter pseudo-element (one-colon syntax) selector, not matching any elements (with no refNodes): #pseudo-element:first-letter]
    expected: FAIL

  [In-document.findAll: ::first-letter pseudo-element (two-colon syntax) selector, not matching any elements (with no refNodes): #pseudo-element::first-letter]
    expected: FAIL

  [In-document.find: ::first-letter pseudo-element (two-colon syntax) selector, not matching any elements (with no refNodes): #pseudo-element::first-letter]
    expected: FAIL

  [In-document.findAll: :before pseudo-element (one-colon syntax) selector, not matching any elements (with no refNodes): #pseudo-element:before]
    expected: FAIL

  [In-document.find: :before pseudo-element (one-colon syntax) selector, not matching any elements (with no refNodes): #pseudo-element:before]
    expected: FAIL

  [In-document.findAll: ::before pseudo-element (two-colon syntax) selector, not matching any elements (with no refNodes): #pseudo-element::before]
    expected: FAIL

  [In-document.find: ::before pseudo-element (two-colon syntax) selector, not matching any elements (with no refNodes): #pseudo-element::before]
    expected: FAIL

  [In-document.findAll: :after pseudo-element (one-colon syntax) selector, not matching any elements (with no refNodes): #pseudo-element:after]
    expected: FAIL

  [In-document.find: :after pseudo-element (one-colon syntax) selector, not matching any elements (with no refNodes): #pseudo-element:after]
    expected: FAIL

  [In-document.findAll: ::after pseudo-element (two-colon syntax) selector, not matching any elements (with no refNodes): #pseudo-element::after]
    expected: FAIL

  [In-document.find: ::after pseudo-element (two-colon syntax) selector, not matching any elements (with no refNodes): #pseudo-element::after]
    expected: FAIL

  [In-document.findAll: Class selector, matching element with specified class (with no refNodes): .class-p]
    expected: FAIL

  [In-document.find: Class selector, matching element with specified class (with no refNodes): .class-p]
    expected: FAIL

  [In-document.findAll: Class selector, chained, matching only elements with all specified classes (with no refNodes): #class .apple.orange.banana]
    expected: FAIL

  [In-document.find: Class selector, chained, matching only elements with all specified classes (with no refNodes): #class .apple.orange.banana]
    expected: FAIL

  [In-document.findAll: Class Selector, chained, with type selector (with no refNodes): div.apple.banana.orange]
    expected: FAIL

  [In-document.find: Class Selector, chained, with type selector (with no refNodes): div.apple.banana.orange]
    expected: FAIL

  [In-document.findAll: Class selector, matching element with class value using non-ASCII characters (with no refNodes): .\xe5\x8f\xb0\xe5\x8c\x97T\xc3\xa1ib\xc4\x9bi]
    expected: FAIL

  [In-document.find: Class selector, matching element with class value using non-ASCII characters (with no refNodes): .\xe5\x8f\xb0\xe5\x8c\x97T\xc3\xa1ib\xc4\x9bi]
    expected: FAIL

  [In-document.findAll: Class selector, matching multiple elements with class value using non-ASCII characters (with no refNodes): .\xe5\x8f\xb0\xe5\x8c\x97]
    expected: FAIL

  [In-document.find: Class selector, matching multiple elements with class value using non-ASCII characters (with no refNodes): .\xe5\x8f\xb0\xe5\x8c\x97]
    expected: FAIL

  [In-document.findAll: Class selector, chained, matching element with multiple class values using non-ASCII characters (with no refNodes): .\xe5\x8f\xb0\xe5\x8c\x97T\xc3\xa1ib\xc4\x9bi.\xe5\x8f\xb0\xe5\x8c\x97]
    expected: FAIL

  [In-document.find: Class selector, chained, matching element with multiple class values using non-ASCII characters (with no refNodes): .\xe5\x8f\xb0\xe5\x8c\x97T\xc3\xa1ib\xc4\x9bi.\xe5\x8f\xb0\xe5\x8c\x97]
    expected: FAIL

  [In-document.findAll: Class selector, matching element with class with escaped character (with no refNodes): .foo\\:bar]
    expected: FAIL

  [In-document.find: Class selector, matching element with class with escaped character (with no refNodes): .foo\\:bar]
    expected: FAIL

  [In-document.findAll: Class selector, matching element with class with escaped character (with no refNodes): .test\\.foo\\[5\\\]bar]
    expected: FAIL

  [In-document.find: Class selector, matching element with class with escaped character (with no refNodes): .test\\.foo\\[5\\\]bar]
    expected: FAIL

  [In-document.findAll: ID selector, matching element with specified id (with no refNodes): #id #id-div1]
    expected: FAIL

  [In-document.find: ID selector, matching element with specified id (with no refNodes): #id #id-div1]
    expected: FAIL

  [In-document.findAll: ID selector, chained, matching element with specified id (with no refNodes): #id-div1, #id-div1]
    expected: FAIL

  [In-document.find: ID selector, chained, matching element with specified id (with no refNodes): #id-div1, #id-div1]
    expected: FAIL

  [In-document.findAll: ID selector, chained, matching element with specified id (with no refNodes): #id-div1, #id-div2]
    expected: FAIL

  [In-document.find: ID selector, chained, matching element with specified id (with no refNodes): #id-div1, #id-div2]
    expected: FAIL

  [In-document.findAll: ID Selector, chained, with type selector (with no refNodes): div#id-div1, div#id-div2]
    expected: FAIL

  [In-document.find: ID Selector, chained, with type selector (with no refNodes): div#id-div1, div#id-div2]
    expected: FAIL

  [In-document.findAll: ID selector, not matching non-existent descendant (with no refNodes): #id #none]
    expected: FAIL

  [In-document.find: ID selector, not matching non-existent descendant (with no refNodes): #id #none]
    expected: FAIL

  [In-document.findAll: ID selector, not matching non-existent ancestor (with no refNodes): #none #id-div1]
    expected: FAIL

  [In-document.find: ID selector, not matching non-existent ancestor (with no refNodes): #none #id-div1]
    expected: FAIL

  [In-document.findAll: ID selector, matching multiple elements with duplicate id (with no refNodes): #id-li-duplicate]
    expected: FAIL

  [In-document.find: ID selector, matching multiple elements with duplicate id (with no refNodes): #id-li-duplicate]
    expected: FAIL

  [In-document.findAll: ID selector, matching id value using non-ASCII characters (with no refNodes): #\xe5\x8f\xb0\xe5\x8c\x97T\xc3\xa1ib\xc4\x9bi]
    expected: FAIL

  [In-document.find: ID selector, matching id value using non-ASCII characters (with no refNodes): #\xe5\x8f\xb0\xe5\x8c\x97T\xc3\xa1ib\xc4\x9bi]
    expected: FAIL

  [In-document.findAll: ID selector, matching id value using non-ASCII characters (with no refNodes): #\xe5\x8f\xb0\xe5\x8c\x97]
    expected: FAIL

  [In-document.find: ID selector, matching id value using non-ASCII characters (with no refNodes): #\xe5\x8f\xb0\xe5\x8c\x97]
    expected: FAIL

  [In-document.findAll: ID selector, matching id values using non-ASCII characters (with no refNodes): #\xe5\x8f\xb0\xe5\x8c\x97T\xc3\xa1ib\xc4\x9bi, #\xe5\x8f\xb0\xe5\x8c\x97]
    expected: FAIL

  [In-document.find: ID selector, matching id values using non-ASCII characters (with no refNodes): #\xe5\x8f\xb0\xe5\x8c\x97T\xc3\xa1ib\xc4\x9bi, #\xe5\x8f\xb0\xe5\x8c\x97]
    expected: FAIL

  [In-document.findAll: ID selector, matching element with id with escaped character (with no refNodes): #\\#foo\\:bar]
    expected: FAIL

  [In-document.find: ID selector, matching element with id with escaped character (with no refNodes): #\\#foo\\:bar]
    expected: FAIL

  [In-document.findAll: ID selector, matching element with id with escaped character (with no refNodes): #test\\.foo\\[5\\\]bar]
    expected: FAIL

  [In-document.find: ID selector, matching element with id with escaped character (with no refNodes): #test\\.foo\\[5\\\]bar]
    expected: FAIL

  [In-document.findAll: Namespace selector, matching element with any namespace (with no refNodes): #any-namespace *|div]
    expected: FAIL

  [In-document.find: Namespace selector, matching element with any namespace (with no refNodes): #any-namespace *|div]
    expected: FAIL

  [In-document.findAll: Namespace selector, matching div elements in no namespace only (with no refNodes): #no-namespace |div]
    expected: FAIL

  [In-document.find: Namespace selector, matching div elements in no namespace only (with no refNodes): #no-namespace |div]
    expected: FAIL

  [In-document.findAll: Namespace selector, matching any elements in no namespace only (with no refNodes): #no-namespace |*]
    expected: FAIL

  [In-document.find: Namespace selector, matching any elements in no namespace only (with no refNodes): #no-namespace |*]
    expected: FAIL

  [In-document.findAll: Descendant combinator, matching element that is a descendant of an element with id (with no refNodes): #descendant div]
    expected: FAIL

  [In-document.find: Descendant combinator, matching element that is a descendant of an element with id (with no refNodes): #descendant div]
    expected: FAIL

  [In-document.findAll: Descendant combinator, matching element with id that is a descendant of an element (with no refNodes): body #descendant-div1]
    expected: FAIL

  [In-document.find: Descendant combinator, matching element with id that is a descendant of an element (with no refNodes): body #descendant-div1]
    expected: FAIL

  [In-document.findAll: Descendant combinator, matching element with id that is a descendant of an element (with no refNodes): div #descendant-div1]
    expected: FAIL

  [In-document.find: Descendant combinator, matching element with id that is a descendant of an element (with no refNodes): div #descendant-div1]
    expected: FAIL

  [In-document.findAll: Descendant combinator, matching element with id that is a descendant of an element with id (with no refNodes): #descendant #descendant-div2]
    expected: FAIL

  [In-document.find: Descendant combinator, matching element with id that is a descendant of an element with id (with no refNodes): #descendant #descendant-div2]
    expected: FAIL

  [In-document.findAll: Descendant combinator, matching element with class that is a descendant of an element with id (with no refNodes): #descendant .descendant-div2]
    expected: FAIL

  [In-document.find: Descendant combinator, matching element with class that is a descendant of an element with id (with no refNodes): #descendant .descendant-div2]
    expected: FAIL

  [In-document.findAll: Descendant combinator, matching element with class that is a descendant of an element with class (with no refNodes): .descendant-div1 .descendant-div3]
    expected: FAIL

  [In-document.find: Descendant combinator, matching element with class that is a descendant of an element with class (with no refNodes): .descendant-div1 .descendant-div3]
    expected: FAIL

  [In-document.findAll: Descendant combinator, not matching element with id that is not a descendant of an element with id (with no refNodes): #descendant-div1 #descendant-div4]
    expected: FAIL

  [In-document.find: Descendant combinator, not matching element with id that is not a descendant of an element with id (with no refNodes): #descendant-div1 #descendant-div4]
    expected: FAIL

  [In-document.findAll: Descendant combinator, whitespace characters (with no refNodes): #descendant\t\r\n#descendant-div2]
    expected: FAIL

  [In-document.find: Descendant combinator, whitespace characters (with no refNodes): #descendant\t\r\n#descendant-div2]
    expected: FAIL

  [In-document.findAll: Child combinator, matching element that is a child of an element with id (with no refNodes): #child>div]
    expected: FAIL

  [In-document.find: Child combinator, matching element that is a child of an element with id (with no refNodes): #child>div]
    expected: FAIL

  [In-document.findAll: Child combinator, matching element with id that is a child of an element (with no refNodes): div>#child-div1]
    expected: FAIL

  [In-document.find: Child combinator, matching element with id that is a child of an element (with no refNodes): div>#child-div1]
    expected: FAIL

  [In-document.findAll: Child combinator, matching element with id that is a child of an element with id (with no refNodes): #child>#child-div1]
    expected: FAIL

  [In-document.find: Child combinator, matching element with id that is a child of an element with id (with no refNodes): #child>#child-div1]
    expected: FAIL

  [In-document.findAll: Child combinator, matching element with id that is a child of an element with class (with no refNodes): #child-div1>.child-div2]
    expected: FAIL

  [In-document.find: Child combinator, matching element with id that is a child of an element with class (with no refNodes): #child-div1>.child-div2]
    expected: FAIL

  [In-document.findAll: Child combinator, matching element with class that is a child of an element with class (with no refNodes): .child-div1>.child-div2]
    expected: FAIL

  [In-document.find: Child combinator, matching element with class that is a child of an element with class (with no refNodes): .child-div1>.child-div2]
    expected: FAIL

  [In-document.findAll: Child combinator, not matching element with id that is not a child of an element with id (with no refNodes): #child>#child-div3]
    expected: FAIL

  [In-document.find: Child combinator, not matching element with id that is not a child of an element with id (with no refNodes): #child>#child-div3]
    expected: FAIL

  [In-document.findAll: Child combinator, not matching element with id that is not a child of an element with class (with no refNodes): #child-div1>.child-div3]
    expected: FAIL

  [In-document.find: Child combinator, not matching element with id that is not a child of an element with class (with no refNodes): #child-div1>.child-div3]
    expected: FAIL

  [In-document.findAll: Child combinator, not matching element with class that is not a child of an element with class (with no refNodes): .child-div1>.child-div3]
    expected: FAIL

  [In-document.find: Child combinator, not matching element with class that is not a child of an element with class (with no refNodes): .child-div1>.child-div3]
    expected: FAIL

  [In-document.findAll: Child combinator, surrounded by whitespace (with no refNodes): #child-div1\t\r\n>\t\r\n#child-div2]
    expected: FAIL

  [In-document.find: Child combinator, surrounded by whitespace (with no refNodes): #child-div1\t\r\n>\t\r\n#child-div2]
    expected: FAIL

  [In-document.findAll: Child combinator, whitespace after (with no refNodes): #child-div1>\t\r\n#child-div2]
    expected: FAIL

  [In-document.find: Child combinator, whitespace after (with no refNodes): #child-div1>\t\r\n#child-div2]
    expected: FAIL

  [In-document.findAll: Child combinator, whitespace before (with no refNodes): #child-div1\t\r\n>#child-div2]
    expected: FAIL

  [In-document.find: Child combinator, whitespace before (with no refNodes): #child-div1\t\r\n>#child-div2]
    expected: FAIL

  [In-document.findAll: Child combinator, no whitespace (with no refNodes): #child-div1>#child-div2]
    expected: FAIL

  [In-document.find: Child combinator, no whitespace (with no refNodes): #child-div1>#child-div2]
    expected: FAIL

  [In-document.findAll: Adjacent sibling combinator, matching element that is an adjacent sibling of an element with id (with no refNodes): #adjacent-div2+div]
    expected: FAIL

  [In-document.find: Adjacent sibling combinator, matching element that is an adjacent sibling of an element with id (with no refNodes): #adjacent-div2+div]
    expected: FAIL

  [In-document.findAll: Adjacent sibling combinator, matching element with id that is an adjacent sibling of an element (with no refNodes): div+#adjacent-div4]
    expected: FAIL

  [In-document.find: Adjacent sibling combinator, matching element with id that is an adjacent sibling of an element (with no refNodes): div+#adjacent-div4]
    expected: FAIL

  [In-document.findAll: Adjacent sibling combinator, matching element with id that is an adjacent sibling of an element with id (with no refNodes): #adjacent-div2+#adjacent-div4]
    expected: FAIL

  [In-document.find: Adjacent sibling combinator, matching element with id that is an adjacent sibling of an element with id (with no refNodes): #adjacent-div2+#adjacent-div4]
    expected: FAIL

  [In-document.findAll: Adjacent sibling combinator, matching element with class that is an adjacent sibling of an element with id (with no refNodes): #adjacent-div2+.adjacent-div4]
    expected: FAIL

  [In-document.find: Adjacent sibling combinator, matching element with class that is an adjacent sibling of an element with id (with no refNodes): #adjacent-div2+.adjacent-div4]
    expected: FAIL

  [In-document.findAll: Adjacent sibling combinator, matching element with class that is an adjacent sibling of an element with class (with no refNodes): .adjacent-div2+.adjacent-div4]
    expected: FAIL

  [In-document.find: Adjacent sibling combinator, matching element with class that is an adjacent sibling of an element with class (with no refNodes): .adjacent-div2+.adjacent-div4]
    expected: FAIL

  [In-document.findAll: Adjacent sibling combinator, matching p element that is an adjacent sibling of a div element (with no refNodes): #adjacent div+p]
    expected: FAIL

  [In-document.find: Adjacent sibling combinator, matching p element that is an adjacent sibling of a div element (with no refNodes): #adjacent div+p]
    expected: FAIL

  [In-document.findAll: Adjacent sibling combinator, not matching element with id that is not an adjacent sibling of an element with id (with no refNodes): #adjacent-div2+#adjacent-p2, #adjacent-div2+#adjacent-div1]
    expected: FAIL

  [In-document.find: Adjacent sibling combinator, not matching element with id that is not an adjacent sibling of an element with id (with no refNodes): #adjacent-div2+#adjacent-p2, #adjacent-div2+#adjacent-div1]
    expected: FAIL

  [In-document.findAll: Adjacent sibling combinator, surrounded by whitespace (with no refNodes): #adjacent-p2\t\r\n+\t\r\n#adjacent-p3]
    expected: FAIL

  [In-document.find: Adjacent sibling combinator, surrounded by whitespace (with no refNodes): #adjacent-p2\t\r\n+\t\r\n#adjacent-p3]
    expected: FAIL

  [In-document.findAll: Adjacent sibling combinator, whitespace after (with no refNodes): #adjacent-p2+\t\r\n#adjacent-p3]
    expected: FAIL

  [In-document.find: Adjacent sibling combinator, whitespace after (with no refNodes): #adjacent-p2+\t\r\n#adjacent-p3]
    expected: FAIL

  [In-document.findAll: Adjacent sibling combinator, whitespace before (with no refNodes): #adjacent-p2\t\r\n+#adjacent-p3]
    expected: FAIL

  [In-document.find: Adjacent sibling combinator, whitespace before (with no refNodes): #adjacent-p2\t\r\n+#adjacent-p3]
    expected: FAIL

  [In-document.findAll: Adjacent sibling combinator, no whitespace (with no refNodes): #adjacent-p2+#adjacent-p3]
    expected: FAIL

  [In-document.find: Adjacent sibling combinator, no whitespace (with no refNodes): #adjacent-p2+#adjacent-p3]
    expected: FAIL

  [In-document.findAll: General sibling combinator, matching element that is a sibling of an element with id (with no refNodes): #sibling-div2~div]
    expected: FAIL

  [In-document.find: General sibling combinator, matching element that is a sibling of an element with id (with no refNodes): #sibling-div2~div]
    expected: FAIL

  [In-document.findAll: General sibling combinator, matching element with id that is a sibling of an element (with no refNodes): div~#sibling-div4]
    expected: FAIL

  [In-document.find: General sibling combinator, matching element with id that is a sibling of an element (with no refNodes): div~#sibling-div4]
    expected: FAIL

  [In-document.findAll: General sibling combinator, matching element with id that is a sibling of an element with id (with no refNodes): #sibling-div2~#sibling-div4]
    expected: FAIL

  [In-document.find: General sibling combinator, matching element with id that is a sibling of an element with id (with no refNodes): #sibling-div2~#sibling-div4]
    expected: FAIL

  [In-document.findAll: General sibling combinator, matching element with class that is a sibling of an element with id (with no refNodes): #sibling-div2~.sibling-div]
    expected: FAIL

  [In-document.find: General sibling combinator, matching element with class that is a sibling of an element with id (with no refNodes): #sibling-div2~.sibling-div]
    expected: FAIL

  [In-document.findAll: General sibling combinator, matching p element that is a sibling of a div element (with no refNodes): #sibling div~p]
    expected: FAIL

  [In-document.find: General sibling combinator, matching p element that is a sibling of a div element (with no refNodes): #sibling div~p]
    expected: FAIL

  [In-document.findAll: General sibling combinator, not matching element with id that is not a sibling after a p element (with no refNodes): #sibling>p~div]
    expected: FAIL

  [In-document.find: General sibling combinator, not matching element with id that is not a sibling after a p element (with no refNodes): #sibling>p~div]
    expected: FAIL

  [In-document.findAll: General sibling combinator, not matching element with id that is not a sibling after an element with id (with no refNodes): #sibling-div2~#sibling-div3, #sibling-div2~#sibling-div1]
    expected: FAIL

  [In-document.find: General sibling combinator, not matching element with id that is not a sibling after an element with id (with no refNodes): #sibling-div2~#sibling-div3, #sibling-div2~#sibling-div1]
    expected: FAIL

  [In-document.findAll: General sibling combinator, surrounded by whitespace (with no refNodes): #sibling-p2\t\r\n~\t\r\n#sibling-p3]
    expected: FAIL

  [In-document.find: General sibling combinator, surrounded by whitespace (with no refNodes): #sibling-p2\t\r\n~\t\r\n#sibling-p3]
    expected: FAIL

  [In-document.findAll: General sibling combinator, whitespace after (with no refNodes): #sibling-p2~\t\r\n#sibling-p3]
    expected: FAIL

  [In-document.find: General sibling combinator, whitespace after (with no refNodes): #sibling-p2~\t\r\n#sibling-p3]
    expected: FAIL

  [In-document.findAll: General sibling combinator, whitespace before (with no refNodes): #sibling-p2\t\r\n~#sibling-p3]
    expected: FAIL

  [In-document.find: General sibling combinator, whitespace before (with no refNodes): #sibling-p2\t\r\n~#sibling-p3]
    expected: FAIL

  [In-document.findAll: General sibling combinator, no whitespace (with no refNodes): #sibling-p2~#sibling-p3]
    expected: FAIL

  [In-document.find: General sibling combinator, no whitespace (with no refNodes): #sibling-p2~#sibling-p3]
    expected: FAIL

  [In-document.findAll: Syntax, group of selectors separator, surrounded by whitespace (with no refNodes): #group em\t\r \n,\t\r \n#group strong]
    expected: FAIL

  [In-document.find: Syntax, group of selectors separator, surrounded by whitespace (with no refNodes): #group em\t\r \n,\t\r \n#group strong]
    expected: FAIL

  [In-document.findAll: Syntax, group of selectors separator, whitespace after (with no refNodes): #group em,\t\r\n#group strong]
    expected: FAIL

  [In-document.find: Syntax, group of selectors separator, whitespace after (with no refNodes): #group em,\t\r\n#group strong]
    expected: FAIL

  [In-document.findAll: Syntax, group of selectors separator, whitespace before (with no refNodes): #group em\t\r\n,#group strong]
    expected: FAIL

  [In-document.find: Syntax, group of selectors separator, whitespace before (with no refNodes): #group em\t\r\n,#group strong]
    expected: FAIL

  [In-document.findAll: Syntax, group of selectors separator, no whitespace (with no refNodes): #group em,#group strong]
    expected: FAIL

  [In-document.find: Syntax, group of selectors separator, no whitespace (with no refNodes): #group em,#group strong]
    expected: FAIL

  [In-document Element.matches: Universal selector, matching all children of the specified reference element (with refNode Element): >*]
    expected: FAIL

  [In-document Element.matches: Universal selector, matching all grandchildren of the specified reference element (with refNode Element): >*>*]
    expected: FAIL

  [In-document Element.matches: Universal selector, matching all descendants of the specified reference element (with refNode Element): *]
    expected: FAIL

  [In-document Element.matches: Class selector, matching element with class value using non-ASCII characters (with no refNodes): .\xe5\x8f\xb0\xe5\x8c\x97T\xc3\xa1ib\xc4\x9bi]
    expected: FAIL

  [In-document Element.matches: Class selector, chained, matching element with multiple class values using non-ASCII characters (with no refNodes): .\xe5\x8f\xb0\xe5\x8c\x97T\xc3\xa1ib\xc4\x9bi.\xe5\x8f\xb0\xe5\x8c\x97]
    expected: FAIL

  [In-document Element.matches: ID selector, matching id value using non-ASCII characters (with no refNodes): #\xe5\x8f\xb0\xe5\x8c\x97T\xc3\xa1ib\xc4\x9bi]
    expected: FAIL

  [In-document Element.matches: ID selector, matching id values using non-ASCII characters (with no refNodes): #\xe5\x8f\xb0\xe5\x8c\x97T\xc3\xa1ib\xc4\x9bi, #\xe5\x8f\xb0\xe5\x8c\x97]
    expected: FAIL

  [In-document.findAll: :lang pseudo-class selector, matching inherited language (1) (with no refNodes): #pseudo-lang-div1:lang(en)]
    expected: FAIL

  [In-document.find: :lang pseudo-class selector, matching inherited language (1) (with no refNodes): #pseudo-lang-div1:lang(en)]
    expected: FAIL

  [In-document.findAll: :lang pseudo-class selector, matching specified language with exact value (1) (with no refNodes): #pseudo-lang-div2:lang(fr)]
    expected: FAIL

  [In-document.find: :lang pseudo-class selector, matching specified language with exact value (1) (with no refNodes): #pseudo-lang-div2:lang(fr)]
    expected: FAIL

  [In-document.findAll: :lang pseudo-class selector, matching specified language with partial value (1) (with no refNodes): #pseudo-lang-div3:lang(en)]
    expected: FAIL

  [In-document.find: :lang pseudo-class selector, matching specified language with partial value (1) (with no refNodes): #pseudo-lang-div3:lang(en)]
    expected: FAIL

  [In-document.findAll: :enabled pseudo-class selector, matching all enabled form controls (1) (with no refNodes): #pseudo-ui :enabled]
    expected: FAIL

  [In-document.find: :enabled pseudo-class selector, matching all enabled form controls (1) (with no refNodes): #pseudo-ui :enabled]
    expected: FAIL

  [In-document.findAll: :enabled pseudo-class selector, matching all disabled form controls (1) (with no refNodes): #pseudo-ui :disabled]
    expected: FAIL

  [In-document.find: :enabled pseudo-class selector, matching all disabled form controls (1) (with no refNodes): #pseudo-ui :disabled]
    expected: FAIL

  [In-document.findAll: :checked pseudo-class selector, matching checked radio buttons and checkboxes (1) (with no refNodes): #pseudo-ui :checked]
    expected: FAIL

  [In-document.find: :checked pseudo-class selector, matching checked radio buttons and checkboxes (1) (with no refNodes): #pseudo-ui :checked]
    expected: FAIL

  [In-document.findAll: :not pseudo-class selector, matching (1) (with no refNodes): #not>:not(div)]
    expected: FAIL

  [In-document.find: :not pseudo-class selector, matching (1) (with no refNodes): #not>:not(div)]
    expected: FAIL

  [In-document.findAll: :not pseudo-class selector, matching (1) (with no refNodes): #not * :not(:first-child)]
    expected: FAIL

  [In-document.find: :not pseudo-class selector, matching (1) (with no refNodes): #not * :not(:first-child)]
    expected: FAIL

  [In-document.findAll: Class selector, matching element with specified class (1) (with no refNodes): .class-p]
    expected: FAIL

  [In-document.find: Class selector, matching element with specified class (1) (with no refNodes): .class-p]
    expected: FAIL

  [In-document.findAll: Class selector, chained, matching only elements with all specified classes (1) (with no refNodes): #class .apple.orange.banana]
    expected: FAIL

  [In-document.find: Class selector, chained, matching only elements with all specified classes (1) (with no refNodes): #class .apple.orange.banana]
    expected: FAIL

  [In-document.findAll: Class Selector, chained, with type selector (1) (with no refNodes): div.apple.banana.orange]
    expected: FAIL

  [In-document.find: Class Selector, chained, with type selector (1) (with no refNodes): div.apple.banana.orange]
    expected: FAIL

  [In-document.findAll: Class selector, matching multiple elements with class value using non-ASCII characters (1) (with no refNodes): .\xe5\x8f\xb0\xe5\x8c\x97]
    expected: FAIL

  [In-document.find: Class selector, matching multiple elements with class value using non-ASCII characters (1) (with no refNodes): .\xe5\x8f\xb0\xe5\x8c\x97]
    expected: FAIL

  [In-document.findAll: Class selector, matching element with class with escaped character (1) (with no refNodes): .foo\\:bar]
    expected: FAIL

  [In-document.find: Class selector, matching element with class with escaped character (1) (with no refNodes): .foo\\:bar]
    expected: FAIL

  [In-document.findAll: Class selector, matching element with class with escaped character (1) (with no refNodes): .test\\.foo\\[5\\\]bar]
    expected: FAIL

  [In-document.find: Class selector, matching element with class with escaped character (1) (with no refNodes): .test\\.foo\\[5\\\]bar]
    expected: FAIL

  [In-document.findAll: ID selector, matching element with specified id (1) (with no refNodes): #id #id-div1]
    expected: FAIL

  [In-document.find: ID selector, matching element with specified id (1) (with no refNodes): #id #id-div1]
    expected: FAIL

  [In-document.findAll: ID selector, chained, matching element with specified id (1) (with no refNodes): #id-div1, #id-div1]
    expected: FAIL

  [In-document.find: ID selector, chained, matching element with specified id (1) (with no refNodes): #id-div1, #id-div1]
    expected: FAIL

  [In-document.findAll: ID selector, chained, matching element with specified id (1) (with no refNodes): #id-div1, #id-div2]
    expected: FAIL

  [In-document.find: ID selector, chained, matching element with specified id (1) (with no refNodes): #id-div1, #id-div2]
    expected: FAIL

  [In-document.findAll: ID Selector, chained, with type selector (1) (with no refNodes): div#id-div1, div#id-div2]
    expected: FAIL

  [In-document.find: ID Selector, chained, with type selector (1) (with no refNodes): div#id-div1, div#id-div2]
    expected: FAIL

  [In-document.findAll: ID selector, matching multiple elements with duplicate id (1) (with no refNodes): #id-li-duplicate]
    expected: FAIL

  [In-document.find: ID selector, matching multiple elements with duplicate id (1) (with no refNodes): #id-li-duplicate]
    expected: FAIL

  [In-document.findAll: ID selector, matching id value using non-ASCII characters (1) (with no refNodes): #\xe5\x8f\xb0\xe5\x8c\x97]
    expected: FAIL

  [In-document.find: ID selector, matching id value using non-ASCII characters (1) (with no refNodes): #\xe5\x8f\xb0\xe5\x8c\x97]
    expected: FAIL

  [In-document.findAll: Descendant combinator, matching element that is a descendant of an element with id (1) (with no refNodes): #descendant div]
    expected: FAIL

  [In-document.find: Descendant combinator, matching element that is a descendant of an element with id (1) (with no refNodes): #descendant div]
    expected: FAIL

  [In-document.findAll: Descendant combinator, matching element with id that is a descendant of an element (1) (with no refNodes): body #descendant-div1]
    expected: FAIL

  [In-document.find: Descendant combinator, matching element with id that is a descendant of an element (1) (with no refNodes): body #descendant-div1]
    expected: FAIL

  [In-document.findAll: Descendant combinator, matching element with id that is a descendant of an element (1) (with no refNodes): div #descendant-div1]
    expected: FAIL

  [In-document.find: Descendant combinator, matching element with id that is a descendant of an element (1) (with no refNodes): div #descendant-div1]
    expected: FAIL

  [In-document.findAll: Descendant combinator, matching element with id that is a descendant of an element with id (1) (with no refNodes): #descendant #descendant-div2]
    expected: FAIL

  [In-document.find: Descendant combinator, matching element with id that is a descendant of an element with id (1) (with no refNodes): #descendant #descendant-div2]
    expected: FAIL

  [In-document.findAll: Descendant combinator, matching element with class that is a descendant of an element with id (1) (with no refNodes): #descendant .descendant-div2]
    expected: FAIL

  [In-document.find: Descendant combinator, matching element with class that is a descendant of an element with id (1) (with no refNodes): #descendant .descendant-div2]
    expected: FAIL

  [In-document.findAll: Descendant combinator, matching element with class that is a descendant of an element with class (1) (with no refNodes): .descendant-div1 .descendant-div3]
    expected: FAIL

  [In-document.find: Descendant combinator, matching element with class that is a descendant of an element with class (1) (with no refNodes): .descendant-div1 .descendant-div3]
    expected: FAIL

  [In-document.findAll: Descendant combinator, whitespace characters (1) (with no refNodes): #descendant\t\r\n#descendant-div2]
    expected: FAIL

  [In-document.find: Descendant combinator, whitespace characters (1) (with no refNodes): #descendant\t\r\n#descendant-div2]
    expected: FAIL

  [In-document.findAll: Child combinator, matching element that is a child of an element with id (1) (with no refNodes): #child>div]
    expected: FAIL

  [In-document.find: Child combinator, matching element that is a child of an element with id (1) (with no refNodes): #child>div]
    expected: FAIL

  [In-document.findAll: Child combinator, matching element with id that is a child of an element (1) (with no refNodes): div>#child-div1]
    expected: FAIL

  [In-document.find: Child combinator, matching element with id that is a child of an element (1) (with no refNodes): div>#child-div1]
    expected: FAIL

  [In-document.findAll: Child combinator, matching element with id that is a child of an element with id (1) (with no refNodes): #child>#child-div1]
    expected: FAIL

  [In-document.find: Child combinator, matching element with id that is a child of an element with id (1) (with no refNodes): #child>#child-div1]
    expected: FAIL

  [In-document.findAll: Child combinator, matching element with id that is a child of an element with class (1) (with no refNodes): #child-div1>.child-div2]
    expected: FAIL

  [In-document.find: Child combinator, matching element with id that is a child of an element with class (1) (with no refNodes): #child-div1>.child-div2]
    expected: FAIL

  [In-document.findAll: Child combinator, matching element with class that is a child of an element with class (1) (with no refNodes): .child-div1>.child-div2]
    expected: FAIL

  [In-document.find: Child combinator, matching element with class that is a child of an element with class (1) (with no refNodes): .child-div1>.child-div2]
    expected: FAIL

  [In-document.findAll: Child combinator, surrounded by whitespace (1) (with no refNodes): #child-div1\t\r\n>\t\r\n#child-div2]
    expected: FAIL

  [In-document.find: Child combinator, surrounded by whitespace (1) (with no refNodes): #child-div1\t\r\n>\t\r\n#child-div2]
    expected: FAIL

  [In-document.findAll: Child combinator, whitespace after (1) (with no refNodes): #child-div1>\t\r\n#child-div2]
    expected: FAIL

  [In-document.find: Child combinator, whitespace after (1) (with no refNodes): #child-div1>\t\r\n#child-div2]
    expected: FAIL

  [In-document.findAll: Child combinator, whitespace before (1) (with no refNodes): #child-div1\t\r\n>#child-div2]
    expected: FAIL

  [In-document.find: Child combinator, whitespace before (1) (with no refNodes): #child-div1\t\r\n>#child-div2]
    expected: FAIL

  [In-document.findAll: Child combinator, no whitespace (1) (with no refNodes): #child-div1>#child-div2]
    expected: FAIL

  [In-document.find: Child combinator, no whitespace (1) (with no refNodes): #child-div1>#child-div2]
    expected: FAIL

  [In-document.findAll: Adjacent sibling combinator, matching element that is an adjacent sibling of an element with id (1) (with no refNodes): #adjacent-div2+div]
    expected: FAIL

  [In-document.find: Adjacent sibling combinator, matching element that is an adjacent sibling of an element with id (1) (with no refNodes): #adjacent-div2+div]
    expected: FAIL

  [In-document.findAll: Adjacent sibling combinator, matching element with id that is an adjacent sibling of an element (1) (with no refNodes): div+#adjacent-div4]
    expected: FAIL

  [In-document.find: Adjacent sibling combinator, matching element with id that is an adjacent sibling of an element (1) (with no refNodes): div+#adjacent-div4]
    expected: FAIL

  [In-document.findAll: Adjacent sibling combinator, matching element with id that is an adjacent sibling of an element with id (1) (with no refNodes): #adjacent-div2+#adjacent-div4]
    expected: FAIL

  [In-document.find: Adjacent sibling combinator, matching element with id that is an adjacent sibling of an element with id (1) (with no refNodes): #adjacent-div2+#adjacent-div4]
    expected: FAIL

  [In-document.findAll: Adjacent sibling combinator, matching element with class that is an adjacent sibling of an element with id (1) (with no refNodes): #adjacent-div2+.adjacent-div4]
    expected: FAIL

  [In-document.find: Adjacent sibling combinator, matching element with class that is an adjacent sibling of an element with id (1) (with no refNodes): #adjacent-div2+.adjacent-div4]
    expected: FAIL

  [In-document.findAll: Adjacent sibling combinator, matching element with class that is an adjacent sibling of an element with class (1) (with no refNodes): .adjacent-div2+.adjacent-div4]
    expected: FAIL

  [In-document.find: Adjacent sibling combinator, matching element with class that is an adjacent sibling of an element with class (1) (with no refNodes): .adjacent-div2+.adjacent-div4]
    expected: FAIL

  [In-document.findAll: Adjacent sibling combinator, matching p element that is an adjacent sibling of a div element (1) (with no refNodes): #adjacent div+p]
    expected: FAIL

  [In-document.find: Adjacent sibling combinator, matching p element that is an adjacent sibling of a div element (1) (with no refNodes): #adjacent div+p]
    expected: FAIL

  [In-document.findAll: Adjacent sibling combinator, surrounded by whitespace (1) (with no refNodes): #adjacent-p2\t\r\n+\t\r\n#adjacent-p3]
    expected: FAIL

  [In-document.find: Adjacent sibling combinator, surrounded by whitespace (1) (with no refNodes): #adjacent-p2\t\r\n+\t\r\n#adjacent-p3]
    expected: FAIL

  [In-document.findAll: Adjacent sibling combinator, whitespace after (1) (with no refNodes): #adjacent-p2+\t\r\n#adjacent-p3]
    expected: FAIL

  [In-document.find: Adjacent sibling combinator, whitespace after (1) (with no refNodes): #adjacent-p2+\t\r\n#adjacent-p3]
    expected: FAIL

  [In-document.findAll: Adjacent sibling combinator, whitespace before (1) (with no refNodes): #adjacent-p2\t\r\n+#adjacent-p3]
    expected: FAIL

  [In-document.find: Adjacent sibling combinator, whitespace before (1) (with no refNodes): #adjacent-p2\t\r\n+#adjacent-p3]
    expected: FAIL

  [In-document.findAll: Adjacent sibling combinator, no whitespace (1) (with no refNodes): #adjacent-p2+#adjacent-p3]
    expected: FAIL

  [In-document.find: Adjacent sibling combinator, no whitespace (1) (with no refNodes): #adjacent-p2+#adjacent-p3]
    expected: FAIL

  [In-document.findAll: General sibling combinator, matching element that is a sibling of an element with id (1) (with no refNodes): #sibling-div2~div]
    expected: FAIL

  [In-document.find: General sibling combinator, matching element that is a sibling of an element with id (1) (with no refNodes): #sibling-div2~div]
    expected: FAIL

  [In-document.findAll: General sibling combinator, matching element with id that is a sibling of an element (1) (with no refNodes): div~#sibling-div4]
    expected: FAIL

  [In-document.find: General sibling combinator, matching element with id that is a sibling of an element (1) (with no refNodes): div~#sibling-div4]
    expected: FAIL

  [In-document.findAll: General sibling combinator, matching element with id that is a sibling of an element with id (1) (with no refNodes): #sibling-div2~#sibling-div4]
    expected: FAIL

  [In-document.find: General sibling combinator, matching element with id that is a sibling of an element with id (1) (with no refNodes): #sibling-div2~#sibling-div4]
    expected: FAIL

  [In-document.findAll: General sibling combinator, matching element with class that is a sibling of an element with id (1) (with no refNodes): #sibling-div2~.sibling-div]
    expected: FAIL

  [In-document.find: General sibling combinator, matching element with class that is a sibling of an element with id (1) (with no refNodes): #sibling-div2~.sibling-div]
    expected: FAIL

  [In-document.findAll: General sibling combinator, matching p element that is a sibling of a div element (1) (with no refNodes): #sibling div~p]
    expected: FAIL

  [In-document.find: General sibling combinator, matching p element that is a sibling of a div element (1) (with no refNodes): #sibling div~p]
    expected: FAIL

  [In-document.findAll: General sibling combinator, not matching element with id that is not a sibling after a p element (1) (with no refNodes): #sibling>p~div]
    expected: FAIL

  [In-document.find: General sibling combinator, not matching element with id that is not a sibling after a p element (1) (with no refNodes): #sibling>p~div]
    expected: FAIL

  [In-document.findAll: General sibling combinator, surrounded by whitespace (1) (with no refNodes): #sibling-p2\t\r\n~\t\r\n#sibling-p3]
    expected: FAIL

  [In-document.find: General sibling combinator, surrounded by whitespace (1) (with no refNodes): #sibling-p2\t\r\n~\t\r\n#sibling-p3]
    expected: FAIL

  [In-document.findAll: General sibling combinator, whitespace after (1) (with no refNodes): #sibling-p2~\t\r\n#sibling-p3]
    expected: FAIL

  [In-document.find: General sibling combinator, whitespace after (1) (with no refNodes): #sibling-p2~\t\r\n#sibling-p3]
    expected: FAIL

  [In-document.findAll: General sibling combinator, whitespace before (1) (with no refNodes): #sibling-p2\t\r\n~#sibling-p3]
    expected: FAIL

  [In-document.find: General sibling combinator, whitespace before (1) (with no refNodes): #sibling-p2\t\r\n~#sibling-p3]
    expected: FAIL

  [In-document.findAll: General sibling combinator, no whitespace (1) (with no refNodes): #sibling-p2~#sibling-p3]
    expected: FAIL

  [In-document.find: General sibling combinator, no whitespace (1) (with no refNodes): #sibling-p2~#sibling-p3]
    expected: FAIL

  [In-document.findAll: Syntax, group of selectors separator, surrounded by whitespace (1) (with no refNodes): #group em\t\r \n,\t\r \n#group strong]
    expected: FAIL

  [In-document.find: Syntax, group of selectors separator, surrounded by whitespace (1) (with no refNodes): #group em\t\r \n,\t\r \n#group strong]
    expected: FAIL

  [In-document.findAll: Syntax, group of selectors separator, whitespace after (1) (with no refNodes): #group em,\t\r\n#group strong]
    expected: FAIL

  [In-document.find: Syntax, group of selectors separator, whitespace after (1) (with no refNodes): #group em,\t\r\n#group strong]
    expected: FAIL

  [In-document.findAll: Syntax, group of selectors separator, whitespace before (1) (with no refNodes): #group em\t\r\n,#group strong]
    expected: FAIL

  [In-document.find: Syntax, group of selectors separator, whitespace before (1) (with no refNodes): #group em\t\r\n,#group strong]
    expected: FAIL

  [In-document.findAll: Syntax, group of selectors separator, no whitespace (1) (with no refNodes): #group em,#group strong]
    expected: FAIL

  [In-document.find: Syntax, group of selectors separator, no whitespace (1) (with no refNodes): #group em,#group strong]
    expected: FAIL

