Selectors-API Level 2 Test Suite: HTML with Selectors Level 3

Summary

Harness status: OK

Found 669 tests

669 Pass

Details

Result

Test Name

Message

Pass

Selectors-API Level 2 Test Suite: HTML with Selectors Level 3

Asserts run

No asserts ran

Pass

Document should not support matches

Asserts run

Pass	assert_false(false, "Document supports matches") at Test.<anonymous> ( /dom/nodes/Element-matches.js:11:7)

Pass

Detached Element supports matches

Asserts run

Pass	assert_idl_attribute(Element node <div id="root"> <div id="target"></div> <div id="uni..., "matches", "Detached Element supports matches") at Test.<anonymous> ( /dom/nodes/Element-matches.js:7:7)

Pass

Fragment should not support matches

Asserts run

Pass	assert_false(false, "Fragment supports matches") at Test.<anonymous> ( /dom/nodes/Element-matches.js:11:7)

Pass

In-document Element supports matches

Asserts run

Pass

assert_idl_attribute(Element node <div id="root">   <div id="target"></div>    <div id="uni..., "matches", "In-document Element supports matches")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:7:7)

Pass

DIV Element.matches(null)

Asserts run

Pass	assert_false(false, "An element with the tag name 'div' should not match.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:21:7)

Pass

DIV Element.matches(undefined)

Asserts run

Pass	assert_false(false, "An element with the tag name 'div' should not match.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:29:7)

Pass

DIV Element.matches no parameter

Asserts run

Pass

assert_throws_js(function "function TypeError() { [native code] }", function "function() {       element[method]();     }", "This should throw a TypeError.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:34:5)

Pass

NULL Element.matches(null)

Asserts run

Pass	assert_true(true, "An element with the tag name 'null' should match.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:19:7)

Pass

NULL Element.matches(undefined)

Asserts run

Pass	assert_false(false, "An element with the tag name 'null' should not match.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:29:7)

Pass

NULL Element.matches no parameter

Asserts run

Pass

assert_throws_js(function "function TypeError() { [native code] }", function "function() {       element[method]();     }", "This should throw a TypeError.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:34:5)

Pass

UNDEFINED Element.matches(null)

Asserts run

Pass	assert_false(false, "An element with the tag name 'undefined' should not match.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:21:7)

Pass

UNDEFINED Element.matches(undefined)

Asserts run

Pass	assert_true(true, "An element with the tag name 'undefined' should match.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:27:7)

Pass

UNDEFINED Element.matches no parameter

Asserts run

Pass

assert_throws_js(function "function TypeError() { [native code] }", function "function() {       element[method]();     }", "This should throw a TypeError.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:34:5)

Pass

Detached Element.matches: Empty String:

Asserts run

Pass	assert_throws_dom("SyntaxError", function "function DOMException() { [native code] }", function "function() { root[method](q) }") at Test.<anonymous> ( /dom/nodes/Element-matches.js:52:9)

Pass

Detached Element.matches: Invalid character: [

Asserts run

Pass	assert_throws_dom("SyntaxError", function "function DOMException() { [native code] }", function "function() { root[method](q) }") at Test.<anonymous> ( /dom/nodes/Element-matches.js:52:9)

Pass

Detached Element.matches: Invalid character: ]

Asserts run

Pass	assert_throws_dom("SyntaxError", function "function DOMException() { [native code] }", function "function() { root[method](q) }") at Test.<anonymous> ( /dom/nodes/Element-matches.js:52:9)

Pass

Detached Element.matches: Invalid character: (

Asserts run

Pass	assert_throws_dom("SyntaxError", function "function DOMException() { [native code] }", function "function() { root[method](q) }") at Test.<anonymous> ( /dom/nodes/Element-matches.js:52:9)

Pass

Detached Element.matches: Invalid character: )

Asserts run

Pass	assert_throws_dom("SyntaxError", function "function DOMException() { [native code] }", function "function() { root[method](q) }") at Test.<anonymous> ( /dom/nodes/Element-matches.js:52:9)

Pass

Detached Element.matches: Invalid character: {

Asserts run

Pass	assert_throws_dom("SyntaxError", function "function DOMException() { [native code] }", function "function() { root[method](q) }") at Test.<anonymous> ( /dom/nodes/Element-matches.js:52:9)

Pass

Detached Element.matches: Invalid character: }

Asserts run

Pass	assert_throws_dom("SyntaxError", function "function DOMException() { [native code] }", function "function() { root[method](q) }") at Test.<anonymous> ( /dom/nodes/Element-matches.js:52:9)

Pass

Detached Element.matches: Invalid character: <

Asserts run

Pass	assert_throws_dom("SyntaxError", function "function DOMException() { [native code] }", function "function() { root[method](q) }") at Test.<anonymous> ( /dom/nodes/Element-matches.js:52:9)

Pass

Detached Element.matches: Invalid character: >

Asserts run

Pass	assert_throws_dom("SyntaxError", function "function DOMException() { [native code] }", function "function() { root[method](q) }") at Test.<anonymous> ( /dom/nodes/Element-matches.js:52:9)

Pass

Detached Element.matches: Invalid ID: #

Asserts run

Pass	assert_throws_dom("SyntaxError", function "function DOMException() { [native code] }", function "function() { root[method](q) }") at Test.<anonymous> ( /dom/nodes/Element-matches.js:52:9)

Pass

Detached Element.matches: Invalid group of selectors: div,

Asserts run

Pass	assert_throws_dom("SyntaxError", function "function DOMException() { [native code] }", function "function() { root[method](q) }") at Test.<anonymous> ( /dom/nodes/Element-matches.js:52:9)

Pass

Detached Element.matches: Invalid class: .

Asserts run

Pass	assert_throws_dom("SyntaxError", function "function DOMException() { [native code] }", function "function() { root[method](q) }") at Test.<anonymous> ( /dom/nodes/Element-matches.js:52:9)

Pass

Detached Element.matches: Invalid class: .5cm

Asserts run

Pass	assert_throws_dom("SyntaxError", function "function DOMException() { [native code] }", function "function() { root[method](q) }") at Test.<anonymous> ( /dom/nodes/Element-matches.js:52:9)

Pass

Detached Element.matches: Invalid class: ..test

Asserts run

Pass	assert_throws_dom("SyntaxError", function "function DOMException() { [native code] }", function "function() { root[method](q) }") at Test.<anonymous> ( /dom/nodes/Element-matches.js:52:9)

Pass

Detached Element.matches: Invalid class: .foo..quux

Asserts run

Pass	assert_throws_dom("SyntaxError", function "function DOMException() { [native code] }", function "function() { root[method](q) }") at Test.<anonymous> ( /dom/nodes/Element-matches.js:52:9)

Pass

Detached Element.matches: Invalid class: .bar.

Asserts run

Pass	assert_throws_dom("SyntaxError", function "function DOMException() { [native code] }", function "function() { root[method](q) }") at Test.<anonymous> ( /dom/nodes/Element-matches.js:52:9)

Pass

Detached Element.matches: Invalid combinator: div % address, p

Asserts run

Pass	assert_throws_dom("SyntaxError", function "function DOMException() { [native code] }", function "function() { root[method](q) }") at Test.<anonymous> ( /dom/nodes/Element-matches.js:52:9)

Pass

Detached Element.matches: Invalid combinator: div ++ address, p

Asserts run

Pass	assert_throws_dom("SyntaxError", function "function DOMException() { [native code] }", function "function() { root[method](q) }") at Test.<anonymous> ( /dom/nodes/Element-matches.js:52:9)

Pass

Detached Element.matches: Invalid combinator: div ~~ address, p

Asserts run

Pass	assert_throws_dom("SyntaxError", function "function DOMException() { [native code] }", function "function() { root[method](q) }") at Test.<anonymous> ( /dom/nodes/Element-matches.js:52:9)

Pass

Detached Element.matches: Invalid [att=value] selector: [*=test]

Asserts run

Pass	assert_throws_dom("SyntaxError", function "function DOMException() { [native code] }", function "function() { root[method](q) }") at Test.<anonymous> ( /dom/nodes/Element-matches.js:52:9)

Pass

Detached Element.matches: Invalid [att=value] selector: [*|*=test]

Asserts run

Pass	assert_throws_dom("SyntaxError", function "function DOMException() { [native code] }", function "function() { root[method](q) }") at Test.<anonymous> ( /dom/nodes/Element-matches.js:52:9)

Pass

Detached Element.matches: Invalid [att=value] selector: [class= space unquoted ]

Asserts run

Pass	assert_throws_dom("SyntaxError", function "function DOMException() { [native code] }", function "function() { root[method](q) }") at Test.<anonymous> ( /dom/nodes/Element-matches.js:52:9)

Pass

Detached Element.matches: Unknown pseudo-class: div:example

Asserts run

Pass	assert_throws_dom("SyntaxError", function "function DOMException() { [native code] }", function "function() { root[method](q) }") at Test.<anonymous> ( /dom/nodes/Element-matches.js:52:9)

Pass

Detached Element.matches: Unknown pseudo-class: :example

Asserts run

Pass	assert_throws_dom("SyntaxError", function "function DOMException() { [native code] }", function "function() { root[method](q) }") at Test.<anonymous> ( /dom/nodes/Element-matches.js:52:9)

Pass

Detached Element.matches: Unknown pseudo-class: div:linkexample

Asserts run

Pass	assert_throws_dom("SyntaxError", function "function DOMException() { [native code] }", function "function() { root[method](q) }") at Test.<anonymous> ( /dom/nodes/Element-matches.js:52:9)

Pass

Detached Element.matches: Unknown pseudo-element: div::example

Asserts run

Pass	assert_throws_dom("SyntaxError", function "function DOMException() { [native code] }", function "function() { root[method](q) }") at Test.<anonymous> ( /dom/nodes/Element-matches.js:52:9)

Pass

Detached Element.matches: Unknown pseudo-element: ::example

Asserts run

Pass	assert_throws_dom("SyntaxError", function "function DOMException() { [native code] }", function "function() { root[method](q) }") at Test.<anonymous> ( /dom/nodes/Element-matches.js:52:9)

Pass

Detached Element.matches: Invalid pseudo-element: :::before

Asserts run

Pass	assert_throws_dom("SyntaxError", function "function DOMException() { [native code] }", function "function() { root[method](q) }") at Test.<anonymous> ( /dom/nodes/Element-matches.js:52:9)

Pass

Detached Element.matches: Invalid pseudo-element: :: before

Asserts run

Pass	assert_throws_dom("SyntaxError", function "function DOMException() { [native code] }", function "function() { root[method](q) }") at Test.<anonymous> ( /dom/nodes/Element-matches.js:52:9)

Pass

Detached Element.matches: Undeclared namespace: ns|div

Asserts run

Pass	assert_throws_dom("SyntaxError", function "function DOMException() { [native code] }", function "function() { root[method](q) }") at Test.<anonymous> ( /dom/nodes/Element-matches.js:52:9)

Pass

Detached Element.matches: Undeclared namespace: :not(ns|div)

Asserts run

Pass	assert_throws_dom("SyntaxError", function "function DOMException() { [native code] }", function "function() { root[method](q) }") at Test.<anonymous> ( /dom/nodes/Element-matches.js:52:9)

Pass

Detached Element.matches: Invalid namespace: ^|div

Asserts run

Pass	assert_throws_dom("SyntaxError", function "function DOMException() { [native code] }", function "function() { root[method](q) }") at Test.<anonymous> ( /dom/nodes/Element-matches.js:52:9)

Pass

Detached Element.matches: Invalid namespace: $|div

Asserts run

Pass	assert_throws_dom("SyntaxError", function "function DOMException() { [native code] }", function "function() { root[method](q) }") at Test.<anonymous> ( /dom/nodes/Element-matches.js:52:9)

Pass

Detached Element.matches: Relative selector: >*

Asserts run

Pass	assert_throws_dom("SyntaxError", function "function DOMException() { [native code] }", function "function() { root[method](q) }") at Test.<anonymous> ( /dom/nodes/Element-matches.js:52:9)

Pass

In-document Element.matches: Empty String:

Asserts run

Pass	assert_throws_dom("SyntaxError", function "function DOMException() { [native code] }", function "function() { root[method](q) }") at Test.<anonymous> ( /dom/nodes/Element-matches.js:52:9)

Pass

In-document Element.matches: Invalid character: [

Asserts run

Pass	assert_throws_dom("SyntaxError", function "function DOMException() { [native code] }", function "function() { root[method](q) }") at Test.<anonymous> ( /dom/nodes/Element-matches.js:52:9)

Pass

In-document Element.matches: Invalid character: ]

Asserts run

Pass	assert_throws_dom("SyntaxError", function "function DOMException() { [native code] }", function "function() { root[method](q) }") at Test.<anonymous> ( /dom/nodes/Element-matches.js:52:9)

Pass

In-document Element.matches: Invalid character: (

Asserts run

Pass	assert_throws_dom("SyntaxError", function "function DOMException() { [native code] }", function "function() { root[method](q) }") at Test.<anonymous> ( /dom/nodes/Element-matches.js:52:9)

Pass

In-document Element.matches: Invalid character: )

Asserts run

Pass	assert_throws_dom("SyntaxError", function "function DOMException() { [native code] }", function "function() { root[method](q) }") at Test.<anonymous> ( /dom/nodes/Element-matches.js:52:9)

Pass

In-document Element.matches: Invalid character: {

Asserts run

Pass	assert_throws_dom("SyntaxError", function "function DOMException() { [native code] }", function "function() { root[method](q) }") at Test.<anonymous> ( /dom/nodes/Element-matches.js:52:9)

Pass

In-document Element.matches: Invalid character: }

Asserts run

Pass	assert_throws_dom("SyntaxError", function "function DOMException() { [native code] }", function "function() { root[method](q) }") at Test.<anonymous> ( /dom/nodes/Element-matches.js:52:9)

Pass

In-document Element.matches: Invalid character: <

Asserts run

Pass	assert_throws_dom("SyntaxError", function "function DOMException() { [native code] }", function "function() { root[method](q) }") at Test.<anonymous> ( /dom/nodes/Element-matches.js:52:9)

Pass

In-document Element.matches: Invalid character: >

Asserts run

Pass	assert_throws_dom("SyntaxError", function "function DOMException() { [native code] }", function "function() { root[method](q) }") at Test.<anonymous> ( /dom/nodes/Element-matches.js:52:9)

Pass

In-document Element.matches: Invalid ID: #

Asserts run

Pass	assert_throws_dom("SyntaxError", function "function DOMException() { [native code] }", function "function() { root[method](q) }") at Test.<anonymous> ( /dom/nodes/Element-matches.js:52:9)

Pass

In-document Element.matches: Invalid group of selectors: div,

Asserts run

Pass	assert_throws_dom("SyntaxError", function "function DOMException() { [native code] }", function "function() { root[method](q) }") at Test.<anonymous> ( /dom/nodes/Element-matches.js:52:9)

Pass

In-document Element.matches: Invalid class: .

Asserts run

Pass	assert_throws_dom("SyntaxError", function "function DOMException() { [native code] }", function "function() { root[method](q) }") at Test.<anonymous> ( /dom/nodes/Element-matches.js:52:9)

Pass

In-document Element.matches: Invalid class: .5cm

Asserts run

Pass	assert_throws_dom("SyntaxError", function "function DOMException() { [native code] }", function "function() { root[method](q) }") at Test.<anonymous> ( /dom/nodes/Element-matches.js:52:9)

Pass

In-document Element.matches: Invalid class: ..test

Asserts run

Pass	assert_throws_dom("SyntaxError", function "function DOMException() { [native code] }", function "function() { root[method](q) }") at Test.<anonymous> ( /dom/nodes/Element-matches.js:52:9)

Pass

In-document Element.matches: Invalid class: .foo..quux

Asserts run

Pass	assert_throws_dom("SyntaxError", function "function DOMException() { [native code] }", function "function() { root[method](q) }") at Test.<anonymous> ( /dom/nodes/Element-matches.js:52:9)

Pass

In-document Element.matches: Invalid class: .bar.

Asserts run

Pass	assert_throws_dom("SyntaxError", function "function DOMException() { [native code] }", function "function() { root[method](q) }") at Test.<anonymous> ( /dom/nodes/Element-matches.js:52:9)

Pass

In-document Element.matches: Invalid combinator: div % address, p

Asserts run

Pass	assert_throws_dom("SyntaxError", function "function DOMException() { [native code] }", function "function() { root[method](q) }") at Test.<anonymous> ( /dom/nodes/Element-matches.js:52:9)

Pass

In-document Element.matches: Invalid combinator: div ++ address, p

Asserts run

Pass	assert_throws_dom("SyntaxError", function "function DOMException() { [native code] }", function "function() { root[method](q) }") at Test.<anonymous> ( /dom/nodes/Element-matches.js:52:9)

Pass

In-document Element.matches: Invalid combinator: div ~~ address, p

Asserts run

Pass	assert_throws_dom("SyntaxError", function "function DOMException() { [native code] }", function "function() { root[method](q) }") at Test.<anonymous> ( /dom/nodes/Element-matches.js:52:9)

Pass

In-document Element.matches: Invalid [att=value] selector: [*=test]

Asserts run

Pass	assert_throws_dom("SyntaxError", function "function DOMException() { [native code] }", function "function() { root[method](q) }") at Test.<anonymous> ( /dom/nodes/Element-matches.js:52:9)

Pass

In-document Element.matches: Invalid [att=value] selector: [*|*=test]

Asserts run

Pass	assert_throws_dom("SyntaxError", function "function DOMException() { [native code] }", function "function() { root[method](q) }") at Test.<anonymous> ( /dom/nodes/Element-matches.js:52:9)

Pass

In-document Element.matches: Invalid [att=value] selector: [class= space unquoted ]

Asserts run

Pass	assert_throws_dom("SyntaxError", function "function DOMException() { [native code] }", function "function() { root[method](q) }") at Test.<anonymous> ( /dom/nodes/Element-matches.js:52:9)

Pass

In-document Element.matches: Unknown pseudo-class: div:example

Asserts run

Pass	assert_throws_dom("SyntaxError", function "function DOMException() { [native code] }", function "function() { root[method](q) }") at Test.<anonymous> ( /dom/nodes/Element-matches.js:52:9)

Pass

In-document Element.matches: Unknown pseudo-class: :example

Asserts run

Pass	assert_throws_dom("SyntaxError", function "function DOMException() { [native code] }", function "function() { root[method](q) }") at Test.<anonymous> ( /dom/nodes/Element-matches.js:52:9)

Pass

In-document Element.matches: Unknown pseudo-class: div:linkexample

Asserts run

Pass	assert_throws_dom("SyntaxError", function "function DOMException() { [native code] }", function "function() { root[method](q) }") at Test.<anonymous> ( /dom/nodes/Element-matches.js:52:9)

Pass

In-document Element.matches: Unknown pseudo-element: div::example

Asserts run

Pass	assert_throws_dom("SyntaxError", function "function DOMException() { [native code] }", function "function() { root[method](q) }") at Test.<anonymous> ( /dom/nodes/Element-matches.js:52:9)

Pass

In-document Element.matches: Unknown pseudo-element: ::example

Asserts run

Pass	assert_throws_dom("SyntaxError", function "function DOMException() { [native code] }", function "function() { root[method](q) }") at Test.<anonymous> ( /dom/nodes/Element-matches.js:52:9)

Pass

In-document Element.matches: Invalid pseudo-element: :::before

Asserts run

Pass	assert_throws_dom("SyntaxError", function "function DOMException() { [native code] }", function "function() { root[method](q) }") at Test.<anonymous> ( /dom/nodes/Element-matches.js:52:9)

Pass

In-document Element.matches: Invalid pseudo-element: :: before

Asserts run

Pass	assert_throws_dom("SyntaxError", function "function DOMException() { [native code] }", function "function() { root[method](q) }") at Test.<anonymous> ( /dom/nodes/Element-matches.js:52:9)

Pass

In-document Element.matches: Undeclared namespace: ns|div

Asserts run

Pass	assert_throws_dom("SyntaxError", function "function DOMException() { [native code] }", function "function() { root[method](q) }") at Test.<anonymous> ( /dom/nodes/Element-matches.js:52:9)

Pass

In-document Element.matches: Undeclared namespace: :not(ns|div)

Asserts run

Pass	assert_throws_dom("SyntaxError", function "function DOMException() { [native code] }", function "function() { root[method](q) }") at Test.<anonymous> ( /dom/nodes/Element-matches.js:52:9)

Pass

In-document Element.matches: Invalid namespace: ^|div

Asserts run

Pass	assert_throws_dom("SyntaxError", function "function DOMException() { [native code] }", function "function() { root[method](q) }") at Test.<anonymous> ( /dom/nodes/Element-matches.js:52:9)

Pass

In-document Element.matches: Invalid namespace: $|div

Asserts run

Pass	assert_throws_dom("SyntaxError", function "function DOMException() { [native code] }", function "function() { root[method](q) }") at Test.<anonymous> ( /dom/nodes/Element-matches.js:52:9)

Pass

In-document Element.matches: Relative selector: >*

Asserts run

Pass	assert_throws_dom("SyntaxError", function "function DOMException() { [native code] }", function "function() { root[method](q) }") at Test.<anonymous> ( /dom/nodes/Element-matches.js:52:9)

Pass

In-document Element.matches: Type selector, matching html element (with no refNodes): html

Asserts run

Pass	assert_true(true, "The element #html should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: Type selector, matching body element (with no refNodes): body

Asserts run

Pass	assert_true(true, "The element #body should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: Universal selector, matching all elements (with no refNodes): *

Asserts run

Pass	assert_true(true, "The element #universal should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #universal-p1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #universal-code1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #universal-hr1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #universal-pre1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #universal-span1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #universal-p2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #universal-a1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #universal-address1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #universal-code2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #universal-a2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: Universal selector, matching all children of element with specified ID (with no refNodes): #universal>*

Asserts run

Pass	assert_true(true, "The element #universal-p1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #universal-hr1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #universal-pre1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #universal-p2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #universal-address1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: Universal selector, matching all grandchildren of element with specified ID (with no refNodes): #universal>*>*

Asserts run

Pass	assert_true(true, "The element #universal-code1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #universal-span1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #universal-a1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #universal-code2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: Universal selector, matching all descendants of element with specified ID (with no refNodes): #universal *

Asserts run

Pass	assert_true(true, "The element #universal-p1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #universal-code1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #universal-hr1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #universal-pre1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #universal-span1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #universal-p2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #universal-a1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #universal-address1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #universal-code2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #universal-a2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: Attribute presence selector, matching align attribute with value (with no refNodes): .attr-presence-div1[align]

Asserts run

Pass	assert_true(true, "The element #attr-presence-div1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

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

Asserts run

Pass	assert_true(true, "The element #attr-presence-div2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: Attribute presence selector, matching title attribute, case insensitivity (with no refNodes): #attr-presence [*|TiTlE]

Asserts run

Pass

assert_true(true, "The element #attr-presence-a1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #attr-presence-span1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #attr-presence-i1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: Attribute presence selector, matching custom data-* attribute (with no refNodes): [data-attr-presence]

Asserts run

Pass

assert_true(true, "The element #attr-presence-pre1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #attr-presence-blockquote1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: Attribute presence selector, matching attribute with non-ASCII characters (with no refNodes): ul[data-中文]

Asserts run

Pass	assert_true(true, "The element #attr-presence-ul1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

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

Asserts run

Pass	assert_true(true, "The element #attr-presence-select2-option4 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

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

Asserts run

Pass

assert_true(true, "The element #attr-presence-select3-option2 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #attr-presence-select3-option3 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: Attribute value selector, matching align attribute with value (with no refNodes): #attr-value [align="center"]

Asserts run

Pass	assert_true(true, "The element #attr-value-div1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: Attribute value selector, matching align attribute with value, unclosed bracket (with no refNodes): #attr-value [align="center"

Asserts run

Pass	assert_true(true, "The element #attr-value-div1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: Attribute value selector, matching align attribute with empty value (with no refNodes): #attr-value [align=""]

Asserts run

Pass	assert_true(true, "The element #attr-value-div2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

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

Asserts run

Pass	assert_true(true, "The element #attr-value-div3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

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

Asserts run

Pass	assert_true(true, "The element #attr-value-div4 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

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

Asserts run

Pass	assert_true(true, "The element #attr-value-input3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #attr-value-input4 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #attr-value-input6 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #attr-value-input8 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #attr-value-input9 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

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

Asserts run

Pass	assert_true(true, "The element #attr-value-input3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #attr-value-input4 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #attr-value-input6 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #attr-value-input8 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #attr-value-input9 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

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

Asserts run

Pass	assert_true(true, "The element #attr-value-input3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #attr-value-input4 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #attr-value-input6 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #attr-value-input8 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #attr-value-input9 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: Attribute value selector, matching attribute with value using non-ASCII characters (with no refNodes): [data-attr-value=中文]

Asserts run

Pass	assert_true(true, "The element #attr-value-div5 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: Attribute whitespace-separated list selector, matching class attribute with value (with no refNodes): #attr-whitespace [class~="div1"]

Asserts run

Pass	assert_true(true, "The element #attr-whitespace-div1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

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

Asserts run

Pass	assert_true(true, "The element #attr-whitespace-div4 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

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

Asserts run

Pass	assert_true(true, "The element #attr-whitespace-div5 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

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

Asserts run

Pass	assert_true(true, "The element #attr-whitespace-a1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #attr-whitespace-a2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #attr-whitespace-a3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #attr-whitespace-a5 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #attr-whitespace-a7 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

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

Asserts run

Pass	assert_true(true, "The element #attr-whitespace-a1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #attr-whitespace-a2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #attr-whitespace-a3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #attr-whitespace-a5 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #attr-whitespace-a7 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

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

Asserts run

Pass	assert_true(true, "The element #attr-whitespace-a1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #attr-whitespace-a2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #attr-whitespace-a3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #attr-whitespace-a5 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #attr-whitespace-a7 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: Attribute whitespace-separated list selector, matching title attribute with value using non-ASCII characters (with no refNodes): #attr-whitespace [title~=中文]

Asserts run

Pass	assert_true(true, "The element #attr-whitespace-p1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

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

Asserts run

Pass	assert_true(true, "The element #attr-hyphen-div2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

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

Asserts run

Pass	assert_true(true, "The element #attr-hyphen-div3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: Attribute begins with selector, matching href attributes beginning with specified substring (with no refNodes): #attr-begins a[href^="http://www"]

Asserts run

Pass

assert_true(true, "The element #attr-begins-a1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #attr-begins-a3 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: Attribute begins with selector, matching lang attributes beginning with specified substring, (with no refNodes): #attr-begins [lang^="en-"]

Asserts run

Pass

assert_true(true, "The element #attr-begins-div2 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #attr-begins-div4 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: Attribute begins with selector with single-quoted value, matching class attribute beginning with specified substring (with no refNodes): #attr-begins [class^=' apple']

Asserts run

Pass	assert_true(true, "The element #attr-begins-p1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: Attribute begins with selector with double-quoted value, matching class attribute beginning with specified substring (with no refNodes): #attr-begins [class^=" apple"]

Asserts run

Pass	assert_true(true, "The element #attr-begins-p1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: Attribute ends with selector, matching href attributes ending with specified substring (with no refNodes): #attr-ends a[href$=".org"]

Asserts run

Pass

assert_true(true, "The element #attr-ends-a1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #attr-ends-a3 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: Attribute ends with selector, matching lang attributes ending with specified substring, (with no refNodes): #attr-ends [lang$="-CH"]

Asserts run

Pass

assert_true(true, "The element #attr-ends-div2 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #attr-ends-div4 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: Attribute ends with selector with single-quoted value, matching class attribute ending with specified substring (with no refNodes): #attr-ends [class$='apple ']

Asserts run

Pass	assert_true(true, "The element #attr-ends-p1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: Attribute ends with selector with double-quoted value, matching class attribute ending with specified substring (with no refNodes): #attr-ends [class$="apple "]

Asserts run

Pass	assert_true(true, "The element #attr-ends-p1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: Attribute contains selector, matching href attributes beginning with specified substring (with no refNodes): #attr-contains a[href*="http://www"]

Asserts run

Pass

assert_true(true, "The element #attr-contains-a1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #attr-contains-a3 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: Attribute contains selector, matching href attributes ending with specified substring (with no refNodes): #attr-contains a[href*=".org"]

Asserts run

Pass

assert_true(true, "The element #attr-contains-a1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #attr-contains-a2 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: Attribute contains selector, matching href attributes containing specified substring (with no refNodes): #attr-contains a[href*=".example."]

Asserts run

Pass

assert_true(true, "The element #attr-contains-a1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #attr-contains-a3 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: Attribute contains selector, matching lang attributes beginning with specified substring, (with no refNodes): #attr-contains [lang*="en-"]

Asserts run

Pass

assert_true(true, "The element #attr-contains-div2 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #attr-contains-div6 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: Attribute contains selector, matching lang attributes ending with specified substring, (with no refNodes): #attr-contains [lang*="-CH"]

Asserts run

Pass

assert_true(true, "The element #attr-contains-div3 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #attr-contains-div5 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: Attribute contains selector with single-quoted value, matching class attribute beginning with specified substring (with no refNodes): #attr-contains [class*=' apple']

Asserts run

Pass	assert_true(true, "The element #attr-contains-p1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: Attribute contains selector with single-quoted value, matching class attribute ending with specified substring (with no refNodes): #attr-contains [class*='orange ']

Asserts run

Pass	assert_true(true, "The element #attr-contains-p1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

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

Asserts run

Pass	assert_true(true, "The element #attr-contains-p1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: Attribute contains selector with double-quoted value, matching class attribute beginning with specified substring (with no refNodes): #attr-contains [class*=" apple"]

Asserts run

Pass	assert_true(true, "The element #attr-contains-p1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: Attribute contains selector with double-quoted value, matching class attribute ending with specified substring (with no refNodes): #attr-contains [class*="orange "]

Asserts run

Pass	assert_true(true, "The element #attr-contains-p1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

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

Asserts run

Pass	assert_true(true, "The element #attr-contains-p1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: Attribute contains selector with unquoted value, matching class attribute beginning with specified substring (with no refNodes): #attr-contains [class*= apple]

Asserts run

Pass	assert_true(true, "The element #attr-contains-p1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: Attribute contains selector with unquoted value, matching class attribute ending with specified substring (with no refNodes): #attr-contains [class*=orange ]

Asserts run

Pass	assert_true(true, "The element #attr-contains-p1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: Attribute contains selector with unquoted value, matching class attribute containing specified substring (with no refNodes): #attr-contains [class*= banana ]

Asserts run

Pass	assert_true(true, "The element #attr-contains-p1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: :root pseudo-class selector, matching document root element (with no refNodes): :root

Asserts run

Pass	assert_true(true, "The element #html should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: :nth-child selector, matching the third child element (with no refNodes): #pseudo-nth-table1 :nth-child(3)

Asserts run

Pass	assert_true(true, "The element #pseudo-nth-td3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-nth-td9 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-nth-tr3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-nth-td15 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: :nth-child selector, matching every third child element (with no refNodes): #pseudo-nth li:nth-child(3n)

Asserts run

Pass	assert_true(true, "The element #pseudo-nth-li3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-nth-li6 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-nth-li9 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-nth-li12 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: :nth-child selector, matching every second child element, starting from the fourth (with no refNodes): #pseudo-nth li:nth-child(2n+4)

Asserts run

Pass	assert_true(true, "The element #pseudo-nth-li4 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-nth-li6 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-nth-li8 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-nth-li10 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-nth-li12 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: :nth-child selector, matching every fourth child element, starting from the third (with no refNodes): #pseudo-nth-p1 :nth-child(4n-1)

Asserts run

Pass

assert_true(true, "The element #pseudo-nth-em2 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #pseudo-nth-span3 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: :nth-last-child selector, matching the third last child element (with no refNodes): #pseudo-nth-table1 :nth-last-child(3)

Asserts run

Pass	assert_true(true, "The element #pseudo-nth-tr1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-nth-td4 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-nth-td10 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-nth-td16 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: :nth-last-child selector, matching every third child element from the end (with no refNodes): #pseudo-nth li:nth-last-child(3n)

Asserts run

Pass	assert_true(true, "The element #pseudo-nth-li1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-nth-li4 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-nth-li7 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-nth-li10 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: :nth-last-child selector, matching every second child element from the end, starting from the fourth last (with no refNodes): #pseudo-nth li:nth-last-child(2n+4)

Asserts run

Pass	assert_true(true, "The element #pseudo-nth-li1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-nth-li3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-nth-li5 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-nth-li7 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-nth-li9 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: :nth-last-child selector, matching every fourth element from the end, starting from the third last (with no refNodes): #pseudo-nth-p1 :nth-last-child(4n-1)

Asserts run

Pass

assert_true(true, "The element #pseudo-nth-span2 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #pseudo-nth-span4 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: :nth-of-type selector, matching the third em element (with no refNodes): #pseudo-nth-p1 em:nth-of-type(3)

Asserts run

Pass	assert_true(true, "The element #pseudo-nth-em3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: :nth-of-type selector, matching every second element of their type (with no refNodes): #pseudo-nth-p1 :nth-of-type(2n)

Asserts run

Pass	assert_true(true, "The element #pseudo-nth-em2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-nth-span2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-nth-span4 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-nth-strong2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-nth-em4 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: :nth-of-type selector, matching every second elemetn of their type, starting from the first (with no refNodes): #pseudo-nth-p1 span:nth-of-type(2n-1)

Asserts run

Pass

assert_true(true, "The element #pseudo-nth-span1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #pseudo-nth-span3 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: :nth-last-of-type selector, matching the third last em element (with no refNodes): #pseudo-nth-p1 em:nth-last-of-type(3)

Asserts run

Pass	assert_true(true, "The element #pseudo-nth-em2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: :nth-last-of-type selector, matching every second last element of their type (with no refNodes): #pseudo-nth-p1 :nth-last-of-type(2n)

Asserts run

Pass	assert_true(true, "The element #pseudo-nth-span1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-nth-em1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-nth-strong1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-nth-em3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-nth-span3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: :nth-last-of-type selector, matching every second last element of their type, starting from the last (with no refNodes): #pseudo-nth-p1 span:nth-last-of-type(2n-1)

Asserts run

Pass

assert_true(true, "The element #pseudo-nth-span2 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #pseudo-nth-span4 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: :first-of-type selector, matching the first em element (with no refNodes): #pseudo-nth-p1 em:first-of-type

Asserts run

Pass	assert_true(true, "The element #pseudo-nth-em1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: :first-of-type selector, matching the first of every type of element (with no refNodes): #pseudo-nth-p1 :first-of-type

Asserts run

Pass

assert_true(true, "The element #pseudo-nth-span1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #pseudo-nth-em1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #pseudo-nth-strong1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: :first-of-type selector, matching the first td element in each table row (with no refNodes): #pseudo-nth-table1 tr :first-of-type

Asserts run

Pass

assert_true(true, "The element #pseudo-nth-td1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #pseudo-nth-td7 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #pseudo-nth-td13 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: :last-of-type selector, matching the last em elemnet (with no refNodes): #pseudo-nth-p1 em:last-of-type

Asserts run

Pass	assert_true(true, "The element #pseudo-nth-em4 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: :last-of-type selector, matching the last of every type of element (with no refNodes): #pseudo-nth-p1 :last-of-type

Asserts run

Pass

assert_true(true, "The element #pseudo-nth-span4 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #pseudo-nth-strong2 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #pseudo-nth-em4 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: :last-of-type selector, matching the last td element in each table row (with no refNodes): #pseudo-nth-table1 tr :last-of-type

Asserts run

Pass

assert_true(true, "The element #pseudo-nth-td6 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #pseudo-nth-td12 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #pseudo-nth-td18 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: :first-child pseudo-class selector, matching first child div element (with no refNodes): #pseudo-first-child div:first-child

Asserts run

Pass	assert_true(true, "The element #pseudo-first-child-div1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: :first-child pseudo-class selector, matching first-child of multiple elements (with no refNodes): #pseudo-first-child span:first-child

Asserts run

Pass

assert_true(true, "The element #pseudo-first-child-span1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #pseudo-first-child-span3 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #pseudo-first-child-span5 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: :last-child pseudo-class selector, matching last child div element (with no refNodes): #pseudo-last-child div:last-child

Asserts run

Pass	assert_true(true, "The element #pseudo-last-child-div3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: :last-child pseudo-class selector, matching first-child of multiple elements (with no refNodes): #pseudo-last-child span:last-child

Asserts run

Pass

assert_true(true, "The element #pseudo-last-child-span2 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #pseudo-last-child-span4 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #pseudo-last-child-span6 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: :pseudo-only-child pseudo-class selector, matching all only-child elements (with no refNodes): #pseudo-only :only-child

Asserts run

Pass	assert_true(true, "The element #pseudo-only-span1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: :pseudo-only-of-type pseudo-class selector, matching all elements with no siblings of the same type (with no refNodes): #pseudo-only :only-of-type

Asserts run

Pass

assert_true(true, "The element #pseudo-only-span1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #pseudo-only-em1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: :pseudo-only-of-type pseudo-class selector, matching em elements with no siblings of the same type (with no refNodes): #pseudo-only em:only-of-type

Asserts run

Pass	assert_true(true, "The element #pseudo-only-em1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: :empty pseudo-class selector, matching empty p elements (with no refNodes): #pseudo-empty p:empty

Asserts run

Pass

assert_true(true, "The element #pseudo-empty-p1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #pseudo-empty-p2 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: :empty pseudo-class selector, matching all empty elements (with no refNodes): #pseudo-empty :empty

Asserts run

Pass

assert_true(true, "The element #pseudo-empty-p1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #pseudo-empty-p2 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #pseudo-empty-span1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: :link and :visited pseudo-class selectors, matching a and area elements with href attributes (with no refNodes): #pseudo-link :link, #pseudo-link :visited

Asserts run

Pass

assert_true(true, "The element #pseudo-link-a1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #pseudo-link-a2 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #pseudo-link-area1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: :link and :visited pseudo-class selectors, matching no elements (with no refNodes): #head :link, #head :visited

Asserts run

No asserts ran

Pass

In-document Element.matches: :target pseudo-class selector, matching the element referenced by the URL fragment identifier (with no refNodes): :target

Asserts run

Pass	assert_true(true, "The element #target should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: :lang pseudo-class selector, matching inherited language (with no refNodes): #pseudo-lang-div1:lang(en)

Asserts run

Pass	assert_true(true, "The element #pseudo-lang-div1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: :lang pseudo-class selector, matching specified language with exact value (with no refNodes): #pseudo-lang-div2:lang(fr)

Asserts run

Pass	assert_true(true, "The element #pseudo-lang-div2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: :lang pseudo-class selector, matching specified language with partial value (with no refNodes): #pseudo-lang-div3:lang(en)

Asserts run

Pass	assert_true(true, "The element #pseudo-lang-div3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: :enabled pseudo-class selector, matching all enabled form controls (with no refNodes): #pseudo-ui :enabled

Asserts run

Pass	assert_true(true, "The element #pseudo-ui-input1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-ui-input2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-ui-input3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-ui-input4 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-ui-input5 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-ui-input6 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-ui-input7 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-ui-input8 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-ui-input9 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-ui-textarea1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-ui-button1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: :enabled pseudo-class selector, not matching link elements (with no refNodes): #pseudo-link :enabled

Asserts run

Pass	assert_false(false, "The element #pseudo-link-a1 should not match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:128:15)
Pass	assert_false(false, "The element #pseudo-link-a2 should not match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:128:15)
Pass	assert_false(false, "The element #pseudo-link-a3 should not match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:128:15)
Pass	assert_false(false, "The element #pseudo-link-map1 should not match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:128:15)
Pass	assert_false(false, "The element #pseudo-link-area1 should not match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:128:15)
Pass	assert_false(false, "The element #pseudo-link-area2 should not match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:128:15)

Pass

In-document Element.matches: :disabled pseudo-class selector, matching all disabled form controls (with no refNodes): #pseudo-ui :disabled

Asserts run

Pass	assert_true(true, "The element #pseudo-ui-input10 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-ui-input11 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-ui-input12 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-ui-input13 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-ui-input14 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-ui-input15 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-ui-input16 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-ui-input17 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-ui-input18 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-ui-textarea2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-ui-button2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: :disabled pseudo-class selector, not matching link elements (with no refNodes): #pseudo-link :disabled

Asserts run

Pass	assert_false(false, "The element #pseudo-link-a1 should not match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:128:15)
Pass	assert_false(false, "The element #pseudo-link-a2 should not match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:128:15)
Pass	assert_false(false, "The element #pseudo-link-a3 should not match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:128:15)
Pass	assert_false(false, "The element #pseudo-link-map1 should not match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:128:15)
Pass	assert_false(false, "The element #pseudo-link-area1 should not match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:128:15)
Pass	assert_false(false, "The element #pseudo-link-area2 should not match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:128:15)

Pass

In-document Element.matches: :checked pseudo-class selector, matching checked radio buttons and checkboxes (with no refNodes): #pseudo-ui :checked

Asserts run

Pass	assert_true(true, "The element #pseudo-ui-input4 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-ui-input6 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-ui-input13 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-ui-input15 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: :not pseudo-class selector, matching (with no refNodes): #not>:not(div)

Asserts run

Pass

assert_true(true, "The element #not-p1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #not-p2 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #not-p3 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: :not pseudo-class selector, matching (with no refNodes): #not * :not(:first-child)

Asserts run

Pass

assert_true(true, "The element #not-em1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #not-em2 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #not-em3 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: :not pseudo-class selector argument surrounded by spaces, matching (with no refNodes): #not>:not( div )

Asserts run

Pass

assert_true(true, "The element #not-p1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #not-p2 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #not-p3 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: Class selector, matching element with specified class (with no refNodes): .class-p

Asserts run

Pass

assert_true(true, "The element #class-p1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #class-p2 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #class-p3 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: Class selector, chained, matching only elements with all specified classes (with no refNodes): #class .apple.orange.banana

Asserts run

Pass	assert_true(true, "The element #class-div1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #class-div2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #class-p4 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #class-div3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #class-p6 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #class-div4 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: Class Selector, chained, with type selector (with no refNodes): div.apple.banana.orange

Asserts run

Pass	assert_true(true, "The element #class-div1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #class-div2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #class-div3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #class-div4 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: Class selector, matching element with class value using non-ASCII characters (1) (with no refNodes): .台北Táiběi

Asserts run

Pass	assert_true(true, "The element #class-span1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: Class selector, matching multiple elements with class value using non-ASCII characters (with no refNodes): .台北

Asserts run

Pass

assert_true(true, "The element #class-span1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #class-span2 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: Class selector, chained, matching element with multiple class values using non-ASCII characters (1) (with no refNodes): .台北Táiběi.台北

Asserts run

Pass	assert_true(true, "The element #class-span1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: Class selector, matching element with class with escaped character (with no refNodes): .foo\:bar

Asserts run

Pass	assert_true(true, "The element #class-span3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

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

Asserts run

Pass	assert_true(true, "The element #class-span4 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: ID selector, matching element with specified id (with no refNodes): #id #id-div1

Asserts run

Pass	assert_true(true, "The element #id-div1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: ID selector, chained, matching element with specified id (with no refNodes): #id-div1, #id-div1

Asserts run

Pass	assert_true(true, "The element #id-div1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: ID selector, chained, matching element with specified id (with no refNodes): #id-div1, #id-div2

Asserts run

Pass

assert_true(true, "The element #id-div1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #id-div2 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: ID Selector, chained, with type selector (with no refNodes): div#id-div1, div#id-div2

Asserts run

Pass

assert_true(true, "The element #id-div1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #id-div2 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: ID selector, matching multiple elements with duplicate id (with no refNodes): #id-li-duplicate

Asserts run

Pass	assert_true(true, "The element #id-li-duplicate should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #id-li-duplicate should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #id-li-duplicate should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #id-li-duplicate should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: ID selector, matching id value using non-ASCII characters (1) (with no refNodes): #台北Táiběi

Asserts run

Pass	assert_true(true, "The element #台北Táiběi should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: ID selector, matching id value using non-ASCII characters (2) (with no refNodes): #台北

Asserts run

Pass	assert_true(true, "The element #台北 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: ID selector, matching id values using non-ASCII characters (1) (with no refNodes): #台北Táiběi, #台北

Asserts run

Pass

assert_true(true, "The element #台北Táiběi should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #台北 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: Descendant combinator, matching element that is a descendant of an element with id (with no refNodes): #descendant div

Asserts run

Pass	assert_true(true, "The element #descendant-div1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #descendant-div2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #descendant-div3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #descendant-div4 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: Descendant combinator, matching element with id that is a descendant of an element (with no refNodes): body #descendant-div1

Asserts run

Pass	assert_true(true, "The element #descendant-div1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: Descendant combinator, matching element with id that is a descendant of an element (with no refNodes): div #descendant-div1

Asserts run

Pass	assert_true(true, "The element #descendant-div1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: Descendant combinator, matching element with id that is a descendant of an element with id (with no refNodes): #descendant #descendant-div2

Asserts run

Pass	assert_true(true, "The element #descendant-div2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: Descendant combinator, matching element with class that is a descendant of an element with id (with no refNodes): #descendant .descendant-div2

Asserts run

Pass	assert_true(true, "The element #descendant-div2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: Descendant combinator, matching element with class that is a descendant of an element with class (with no refNodes): .descendant-div1 .descendant-div3

Asserts run

Pass	assert_true(true, "The element #descendant-div3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: Descendant combinator, whitespace characters (with no refNodes): #descendant #descendant-div2

Asserts run

Pass	assert_true(true, "The element #descendant-div2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: Child combinator, matching element that is a child of an element with id (with no refNodes): #child>div

Asserts run

Pass

assert_true(true, "The element #child-div1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #child-div4 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: Child combinator, matching element with id that is a child of an element (with no refNodes): div>#child-div1

Asserts run

Pass	assert_true(true, "The element #child-div1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: Child combinator, matching element with id that is a child of an element with id (with no refNodes): #child>#child-div1

Asserts run

Pass	assert_true(true, "The element #child-div1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: Child combinator, matching element with id that is a child of an element with class (with no refNodes): #child-div1>.child-div2

Asserts run

Pass	assert_true(true, "The element #child-div2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: Child combinator, matching element with class that is a child of an element with class (with no refNodes): .child-div1>.child-div2

Asserts run

Pass	assert_true(true, "The element #child-div2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: Child combinator, surrounded by whitespace (with no refNodes): #child-div1 > #child-div2

Asserts run

Pass	assert_true(true, "The element #child-div2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: Child combinator, whitespace after (with no refNodes): #child-div1> #child-div2

Asserts run

Pass	assert_true(true, "The element #child-div2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: Child combinator, whitespace before (with no refNodes): #child-div1 >#child-div2

Asserts run

Pass	assert_true(true, "The element #child-div2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: Child combinator, no whitespace (with no refNodes): #child-div1>#child-div2

Asserts run

Pass	assert_true(true, "The element #child-div2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: Adjacent sibling combinator, matching element that is an adjacent sibling of an element with id (with no refNodes): #adjacent-div2+div

Asserts run

Pass	assert_true(true, "The element #adjacent-div4 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: Adjacent sibling combinator, matching element with id that is an adjacent sibling of an element (with no refNodes): div+#adjacent-div4

Asserts run

Pass	assert_true(true, "The element #adjacent-div4 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: Adjacent sibling combinator, matching element with id that is an adjacent sibling of an element with id (with no refNodes): #adjacent-div2+#adjacent-div4

Asserts run

Pass	assert_true(true, "The element #adjacent-div4 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: Adjacent sibling combinator, matching element with class that is an adjacent sibling of an element with id (with no refNodes): #adjacent-div2+.adjacent-div4

Asserts run

Pass	assert_true(true, "The element #adjacent-div4 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: Adjacent sibling combinator, matching element with class that is an adjacent sibling of an element with class (with no refNodes): .adjacent-div2+.adjacent-div4

Asserts run

Pass	assert_true(true, "The element #adjacent-div4 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: Adjacent sibling combinator, matching p element that is an adjacent sibling of a div element (with no refNodes): #adjacent div+p

Asserts run

Pass	assert_true(true, "The element #adjacent-p2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: Adjacent sibling combinator, surrounded by whitespace (with no refNodes): #adjacent-p2 + #adjacent-p3

Asserts run

Pass	assert_true(true, "The element #adjacent-p3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: Adjacent sibling combinator, whitespace after (with no refNodes): #adjacent-p2+ #adjacent-p3

Asserts run

Pass	assert_true(true, "The element #adjacent-p3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: Adjacent sibling combinator, whitespace before (with no refNodes): #adjacent-p2 +#adjacent-p3

Asserts run

Pass	assert_true(true, "The element #adjacent-p3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: Adjacent sibling combinator, no whitespace (with no refNodes): #adjacent-p2+#adjacent-p3

Asserts run

Pass	assert_true(true, "The element #adjacent-p3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: General sibling combinator, matching element that is a sibling of an element with id (with no refNodes): #sibling-div2~div

Asserts run

Pass

assert_true(true, "The element #sibling-div4 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #sibling-div6 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: General sibling combinator, matching element with id that is a sibling of an element (with no refNodes): div~#sibling-div4

Asserts run

Pass	assert_true(true, "The element #sibling-div4 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: General sibling combinator, matching element with id that is a sibling of an element with id (with no refNodes): #sibling-div2~#sibling-div4

Asserts run

Pass	assert_true(true, "The element #sibling-div4 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: General sibling combinator, matching element with class that is a sibling of an element with id (with no refNodes): #sibling-div2~.sibling-div

Asserts run

Pass

assert_true(true, "The element #sibling-div4 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #sibling-div6 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: General sibling combinator, matching p element that is a sibling of a div element (with no refNodes): #sibling div~p

Asserts run

Pass

assert_true(true, "The element #sibling-p2 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #sibling-p3 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: General sibling combinator, surrounded by whitespace (with no refNodes): #sibling-p2 ~ #sibling-p3

Asserts run

Pass	assert_true(true, "The element #sibling-p3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: General sibling combinator, whitespace after (with no refNodes): #sibling-p2~ #sibling-p3

Asserts run

Pass	assert_true(true, "The element #sibling-p3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: General sibling combinator, whitespace before (with no refNodes): #sibling-p2 ~#sibling-p3

Asserts run

Pass	assert_true(true, "The element #sibling-p3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: General sibling combinator, no whitespace (with no refNodes): #sibling-p2~#sibling-p3

Asserts run

Pass	assert_true(true, "The element #sibling-p3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: Syntax, group of selectors separator, surrounded by whitespace (with no refNodes): #group em , #group strong

Asserts run

Pass

assert_true(true, "The element #group-em1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #group-strong1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: Syntax, group of selectors separator, whitespace after (with no refNodes): #group em, #group strong

Asserts run

Pass

assert_true(true, "The element #group-em1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #group-strong1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: Syntax, group of selectors separator, whitespace before (with no refNodes): #group em ,#group strong

Asserts run

Pass

assert_true(true, "The element #group-em1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #group-strong1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: Syntax, group of selectors separator, no whitespace (with no refNodes): #group em,#group strong

Asserts run

Pass

assert_true(true, "The element #group-em1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #group-strong1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: Universal selector, matching all elements (with no refNodes): *

Asserts run

Pass	assert_true(true, "The element #universal should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #universal-p1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #universal-code1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #universal-hr1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #universal-pre1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #universal-span1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #universal-p2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #universal-a1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #universal-address1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #universal-code2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #universal-a2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: Universal selector, matching all children of element with specified ID (with no refNodes): #universal>*

Asserts run

Pass	assert_true(true, "The element #universal-p1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #universal-hr1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #universal-pre1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #universal-p2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #universal-address1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: Universal selector, matching all grandchildren of element with specified ID (with no refNodes): #universal>*>*

Asserts run

Pass	assert_true(true, "The element #universal-code1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #universal-span1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #universal-a1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #universal-code2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: Universal selector, matching all descendants of element with specified ID (with no refNodes): #universal *

Asserts run

Pass	assert_true(true, "The element #universal-p1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #universal-code1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #universal-hr1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #universal-pre1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #universal-span1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #universal-p2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #universal-a1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #universal-address1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #universal-code2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #universal-a2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: Attribute presence selector, matching align attribute with value (with no refNodes): .attr-presence-div1[align]

Asserts run

Pass	assert_true(true, "The element #attr-presence-div1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: Attribute presence selector, matching align attribute with empty value (with no refNodes): .attr-presence-div2[align]

Asserts run

Pass	assert_true(true, "The element #attr-presence-div2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: Attribute presence selector, matching title attribute, case insensitivity (with no refNodes): #attr-presence [*|TiTlE]

Asserts run

Pass

assert_true(true, "The element #attr-presence-a1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #attr-presence-span1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #attr-presence-i1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: Attribute presence selector, matching custom data-* attribute (with no refNodes): [data-attr-presence]

Asserts run

Pass

assert_true(true, "The element #attr-presence-pre1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #attr-presence-blockquote1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: Attribute presence selector, matching attribute with non-ASCII characters (with no refNodes): ul[data-中文]

Asserts run

Pass	assert_true(true, "The element #attr-presence-ul1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: Attribute presence selector, matching option with selected attribute (with no refNodes): #attr-presence-select2 option[selected]

Asserts run

Pass	assert_true(true, "The element #attr-presence-select2-option4 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: Attribute presence selector, matching multiple options with selected attributes (with no refNodes): #attr-presence-select3 option[selected]

Asserts run

Pass

assert_true(true, "The element #attr-presence-select3-option2 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #attr-presence-select3-option3 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: Attribute value selector, matching align attribute with value (with no refNodes): #attr-value [align="center"]

Asserts run

Pass	assert_true(true, "The element #attr-value-div1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: Attribute value selector, matching align attribute with value, unclosed bracket (with no refNodes): #attr-value [align="center"

Asserts run

Pass	assert_true(true, "The element #attr-value-div1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: Attribute value selector, matching align attribute with empty value (with no refNodes): #attr-value [align=""]

Asserts run

Pass	assert_true(true, "The element #attr-value-div2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: Attribute value selector, matching custom data-* attribute with unicode escaped value (with no refNodes): [data-attr-value="\e9"]

Asserts run

Pass	assert_true(true, "The element #attr-value-div3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: Attribute value selector, matching custom data-* attribute with escaped character (with no refNodes): [data-attr-value_foo="\e9"]

Asserts run

Pass	assert_true(true, "The element #attr-value-div4 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: Attribute value selector with single-quoted value, matching multiple inputs with type attributes (with no refNodes): #attr-value input[type='hidden'],#attr-value input[type='radio']

Asserts run

Pass	assert_true(true, "The element #attr-value-input3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #attr-value-input4 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #attr-value-input6 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #attr-value-input8 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #attr-value-input9 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: Attribute value selector with double-quoted value, matching multiple inputs with type attributes (with no refNodes): #attr-value input[type="hidden"],#attr-value input[type='radio']

Asserts run

Pass	assert_true(true, "The element #attr-value-input3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #attr-value-input4 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #attr-value-input6 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #attr-value-input8 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #attr-value-input9 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: Attribute value selector with unquoted value, matching multiple inputs with type attributes (with no refNodes): #attr-value input[type=hidden],#attr-value input[type=radio]

Asserts run

Pass	assert_true(true, "The element #attr-value-input3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #attr-value-input4 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #attr-value-input6 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #attr-value-input8 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #attr-value-input9 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: Attribute value selector, matching attribute with value using non-ASCII characters (with no refNodes): [data-attr-value=中文]

Asserts run

Pass	assert_true(true, "The element #attr-value-div5 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: Attribute whitespace-separated list selector, matching class attribute with value (with no refNodes): #attr-whitespace [class~="div1"]

Asserts run

Pass	assert_true(true, "The element #attr-whitespace-div1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

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

Asserts run

Pass	assert_true(true, "The element #attr-whitespace-div4 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: Attribute whitespace-separated list selector, matching custom data-* attribute with escaped character (with no refNodes): [data-attr-whitespace_foo~="\e9"]

Asserts run

Pass	assert_true(true, "The element #attr-whitespace-div5 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: Attribute whitespace-separated list selector with single-quoted value, matching multiple links with rel attributes (with no refNodes): #attr-whitespace a[rel~='bookmark'], #attr-whitespace a[rel~='nofollow']

Asserts run

Pass	assert_true(true, "The element #attr-whitespace-a1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #attr-whitespace-a2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #attr-whitespace-a3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #attr-whitespace-a5 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #attr-whitespace-a7 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: Attribute whitespace-separated list selector with double-quoted value, matching multiple links with rel attributes (with no refNodes): #attr-whitespace a[rel~="bookmark"],#attr-whitespace a[rel~='nofollow']

Asserts run

Pass	assert_true(true, "The element #attr-whitespace-a1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #attr-whitespace-a2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #attr-whitespace-a3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #attr-whitespace-a5 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #attr-whitespace-a7 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: Attribute whitespace-separated list selector with unquoted value, matching multiple links with rel attributes (with no refNodes): #attr-whitespace a[rel~=bookmark], #attr-whitespace a[rel~=nofollow]

Asserts run

Pass	assert_true(true, "The element #attr-whitespace-a1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #attr-whitespace-a2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #attr-whitespace-a3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #attr-whitespace-a5 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #attr-whitespace-a7 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: Attribute whitespace-separated list selector, matching title attribute with value using non-ASCII characters (with no refNodes): #attr-whitespace [title~=中文]

Asserts run

Pass	assert_true(true, "The element #attr-whitespace-p1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: Attribute hyphen-separated list selector, matching lang attribute with exact value (with no refNodes): #attr-hyphen-div2[lang|="fr"]

Asserts run

Pass	assert_true(true, "The element #attr-hyphen-div2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: Attribute hyphen-separated list selector, matching lang attribute with partial value (with no refNodes): #attr-hyphen-div3[lang|="en"]

Asserts run

Pass	assert_true(true, "The element #attr-hyphen-div3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: Attribute begins with selector, matching href attributes beginning with specified substring (with no refNodes): #attr-begins a[href^="http://www"]

Asserts run

Pass

assert_true(true, "The element #attr-begins-a1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #attr-begins-a3 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: Attribute begins with selector, matching lang attributes beginning with specified substring, (with no refNodes): #attr-begins [lang^="en-"]

Asserts run

Pass

assert_true(true, "The element #attr-begins-div2 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #attr-begins-div4 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: Attribute begins with selector with single-quoted value, matching class attribute beginning with specified substring (with no refNodes): #attr-begins [class^=' apple']

Asserts run

Pass	assert_true(true, "The element #attr-begins-p1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: Attribute begins with selector with double-quoted value, matching class attribute beginning with specified substring (with no refNodes): #attr-begins [class^=" apple"]

Asserts run

Pass	assert_true(true, "The element #attr-begins-p1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: Attribute ends with selector, matching href attributes ending with specified substring (with no refNodes): #attr-ends a[href$=".org"]

Asserts run

Pass

assert_true(true, "The element #attr-ends-a1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #attr-ends-a3 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: Attribute ends with selector, matching lang attributes ending with specified substring, (with no refNodes): #attr-ends [lang$="-CH"]

Asserts run

Pass

assert_true(true, "The element #attr-ends-div2 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #attr-ends-div4 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: Attribute ends with selector with single-quoted value, matching class attribute ending with specified substring (with no refNodes): #attr-ends [class$='apple ']

Asserts run

Pass	assert_true(true, "The element #attr-ends-p1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: Attribute ends with selector with double-quoted value, matching class attribute ending with specified substring (with no refNodes): #attr-ends [class$="apple "]

Asserts run

Pass	assert_true(true, "The element #attr-ends-p1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: Attribute contains selector, matching href attributes beginning with specified substring (with no refNodes): #attr-contains a[href*="http://www"]

Asserts run

Pass

assert_true(true, "The element #attr-contains-a1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #attr-contains-a3 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: Attribute contains selector, matching href attributes ending with specified substring (with no refNodes): #attr-contains a[href*=".org"]

Asserts run

Pass

assert_true(true, "The element #attr-contains-a1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #attr-contains-a2 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: Attribute contains selector, matching href attributes containing specified substring (with no refNodes): #attr-contains a[href*=".example."]

Asserts run

Pass

assert_true(true, "The element #attr-contains-a1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #attr-contains-a3 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: Attribute contains selector, matching lang attributes beginning with specified substring, (with no refNodes): #attr-contains [lang*="en-"]

Asserts run

Pass

assert_true(true, "The element #attr-contains-div2 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #attr-contains-div6 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: Attribute contains selector, matching lang attributes ending with specified substring, (with no refNodes): #attr-contains [lang*="-CH"]

Asserts run

Pass

assert_true(true, "The element #attr-contains-div3 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #attr-contains-div5 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: Attribute contains selector with single-quoted value, matching class attribute beginning with specified substring (with no refNodes): #attr-contains [class*=' apple']

Asserts run

Pass	assert_true(true, "The element #attr-contains-p1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: Attribute contains selector with single-quoted value, matching class attribute ending with specified substring (with no refNodes): #attr-contains [class*='orange ']

Asserts run

Pass	assert_true(true, "The element #attr-contains-p1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: Attribute contains selector with single-quoted value, matching class attribute containing specified substring (with no refNodes): #attr-contains [class*='ple banana ora']

Asserts run

Pass	assert_true(true, "The element #attr-contains-p1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: Attribute contains selector with double-quoted value, matching class attribute beginning with specified substring (with no refNodes): #attr-contains [class*=" apple"]

Asserts run

Pass	assert_true(true, "The element #attr-contains-p1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: Attribute contains selector with double-quoted value, matching class attribute ending with specified substring (with no refNodes): #attr-contains [class*="orange "]

Asserts run

Pass	assert_true(true, "The element #attr-contains-p1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: Attribute contains selector with double-quoted value, matching class attribute containing specified substring (with no refNodes): #attr-contains [class*="ple banana ora"]

Asserts run

Pass	assert_true(true, "The element #attr-contains-p1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: Attribute contains selector with unquoted value, matching class attribute beginning with specified substring (with no refNodes): #attr-contains [class*= apple]

Asserts run

Pass	assert_true(true, "The element #attr-contains-p1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: Attribute contains selector with unquoted value, matching class attribute ending with specified substring (with no refNodes): #attr-contains [class*=orange ]

Asserts run

Pass	assert_true(true, "The element #attr-contains-p1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: Attribute contains selector with unquoted value, matching class attribute containing specified substring (with no refNodes): #attr-contains [class*= banana ]

Asserts run

Pass	assert_true(true, "The element #attr-contains-p1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: :nth-child selector, matching the third child element (with no refNodes): #pseudo-nth-table1 :nth-child(3)

Asserts run

Pass	assert_true(true, "The element #pseudo-nth-td3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-nth-td9 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-nth-tr3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-nth-td15 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: :nth-child selector, matching every third child element (with no refNodes): #pseudo-nth li:nth-child(3n)

Asserts run

Pass	assert_true(true, "The element #pseudo-nth-li3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-nth-li6 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-nth-li9 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-nth-li12 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: :nth-child selector, matching every second child element, starting from the fourth (with no refNodes): #pseudo-nth li:nth-child(2n+4)

Asserts run

Pass	assert_true(true, "The element #pseudo-nth-li4 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-nth-li6 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-nth-li8 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-nth-li10 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-nth-li12 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: :nth-child selector, matching every fourth child element, starting from the third (with no refNodes): #pseudo-nth-p1 :nth-child(4n-1)

Asserts run

Pass

assert_true(true, "The element #pseudo-nth-em2 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #pseudo-nth-span3 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: :nth-last-child selector, matching the third last child element (with no refNodes): #pseudo-nth-table1 :nth-last-child(3)

Asserts run

Pass	assert_true(true, "The element #pseudo-nth-tr1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-nth-td4 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-nth-td10 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-nth-td16 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: :nth-last-child selector, matching every third child element from the end (with no refNodes): #pseudo-nth li:nth-last-child(3n)

Asserts run

Pass	assert_true(true, "The element #pseudo-nth-li1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-nth-li4 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-nth-li7 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-nth-li10 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: :nth-last-child selector, matching every second child element from the end, starting from the fourth last (with no refNodes): #pseudo-nth li:nth-last-child(2n+4)

Asserts run

Pass	assert_true(true, "The element #pseudo-nth-li1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-nth-li3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-nth-li5 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-nth-li7 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-nth-li9 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: :nth-last-child selector, matching every fourth element from the end, starting from the third last (with no refNodes): #pseudo-nth-p1 :nth-last-child(4n-1)

Asserts run

Pass

assert_true(true, "The element #pseudo-nth-span2 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #pseudo-nth-span4 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: :nth-of-type selector, matching the third em element (with no refNodes): #pseudo-nth-p1 em:nth-of-type(3)

Asserts run

Pass	assert_true(true, "The element #pseudo-nth-em3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: :nth-of-type selector, matching every second element of their type (with no refNodes): #pseudo-nth-p1 :nth-of-type(2n)

Asserts run

Pass	assert_true(true, "The element #pseudo-nth-em2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-nth-span2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-nth-span4 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-nth-strong2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-nth-em4 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: :nth-of-type selector, matching every second elemetn of their type, starting from the first (with no refNodes): #pseudo-nth-p1 span:nth-of-type(2n-1)

Asserts run

Pass

assert_true(true, "The element #pseudo-nth-span1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #pseudo-nth-span3 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: :nth-last-of-type selector, matching the third last em element (with no refNodes): #pseudo-nth-p1 em:nth-last-of-type(3)

Asserts run

Pass	assert_true(true, "The element #pseudo-nth-em2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: :nth-last-of-type selector, matching every second last element of their type (with no refNodes): #pseudo-nth-p1 :nth-last-of-type(2n)

Asserts run

Pass	assert_true(true, "The element #pseudo-nth-span1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-nth-em1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-nth-strong1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-nth-em3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-nth-span3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: :nth-last-of-type selector, matching every second last element of their type, starting from the last (with no refNodes): #pseudo-nth-p1 span:nth-last-of-type(2n-1)

Asserts run

Pass

assert_true(true, "The element #pseudo-nth-span2 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #pseudo-nth-span4 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: :first-of-type selector, matching the first em element (with no refNodes): #pseudo-nth-p1 em:first-of-type

Asserts run

Pass	assert_true(true, "The element #pseudo-nth-em1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: :first-of-type selector, matching the first of every type of element (with no refNodes): #pseudo-nth-p1 :first-of-type

Asserts run

Pass

assert_true(true, "The element #pseudo-nth-span1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #pseudo-nth-em1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #pseudo-nth-strong1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: :first-of-type selector, matching the first td element in each table row (with no refNodes): #pseudo-nth-table1 tr :first-of-type

Asserts run

Pass

assert_true(true, "The element #pseudo-nth-td1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #pseudo-nth-td7 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #pseudo-nth-td13 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: :last-of-type selector, matching the last em elemnet (with no refNodes): #pseudo-nth-p1 em:last-of-type

Asserts run

Pass	assert_true(true, "The element #pseudo-nth-em4 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: :last-of-type selector, matching the last of every type of element (with no refNodes): #pseudo-nth-p1 :last-of-type

Asserts run

Pass

assert_true(true, "The element #pseudo-nth-span4 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #pseudo-nth-strong2 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #pseudo-nth-em4 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: :last-of-type selector, matching the last td element in each table row (with no refNodes): #pseudo-nth-table1 tr :last-of-type

Asserts run

Pass

assert_true(true, "The element #pseudo-nth-td6 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #pseudo-nth-td12 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #pseudo-nth-td18 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: :first-child pseudo-class selector, matching first child div element (with no refNodes): #pseudo-first-child div:first-child

Asserts run

Pass	assert_true(true, "The element #pseudo-first-child-div1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: :first-child pseudo-class selector, matching first-child of multiple elements (with no refNodes): #pseudo-first-child span:first-child

Asserts run

Pass

assert_true(true, "The element #pseudo-first-child-span1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #pseudo-first-child-span3 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #pseudo-first-child-span5 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: :last-child pseudo-class selector, matching last child div element (with no refNodes): #pseudo-last-child div:last-child

Asserts run

Pass	assert_true(true, "The element #pseudo-last-child-div3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: :last-child pseudo-class selector, matching first-child of multiple elements (with no refNodes): #pseudo-last-child span:last-child

Asserts run

Pass

assert_true(true, "The element #pseudo-last-child-span2 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #pseudo-last-child-span4 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #pseudo-last-child-span6 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: :pseudo-only-child pseudo-class selector, matching all only-child elements (with no refNodes): #pseudo-only :only-child

Asserts run

Pass	assert_true(true, "The element #pseudo-only-span1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: :pseudo-only-of-type pseudo-class selector, matching all elements with no siblings of the same type (with no refNodes): #pseudo-only :only-of-type

Asserts run

Pass

assert_true(true, "The element #pseudo-only-span1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #pseudo-only-em1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: :pseudo-only-of-type pseudo-class selector, matching em elements with no siblings of the same type (with no refNodes): #pseudo-only em:only-of-type

Asserts run

Pass	assert_true(true, "The element #pseudo-only-em1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: :empty pseudo-class selector, matching empty p elements (with no refNodes): #pseudo-empty p:empty

Asserts run

Pass

assert_true(true, "The element #pseudo-empty-p1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #pseudo-empty-p2 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: :empty pseudo-class selector, matching all empty elements (with no refNodes): #pseudo-empty :empty

Asserts run

Pass

assert_true(true, "The element #pseudo-empty-p1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #pseudo-empty-p2 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #pseudo-empty-span1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: :link and :visited pseudo-class selectors, matching a and area elements with href attributes (with no refNodes): #pseudo-link :link, #pseudo-link :visited

Asserts run

Pass

assert_true(true, "The element #pseudo-link-a1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #pseudo-link-a2 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #pseudo-link-area1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: :lang pseudo-class selector, matching specified language with exact value (with no refNodes): #pseudo-lang-div2:lang(fr)

Asserts run

Pass	assert_true(true, "The element #pseudo-lang-div2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: :lang pseudo-class selector, matching specified language with partial value (with no refNodes): #pseudo-lang-div3:lang(en)

Asserts run

Pass	assert_true(true, "The element #pseudo-lang-div3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: :enabled pseudo-class selector, matching all enabled form controls (with no refNodes): #pseudo-ui :enabled

Asserts run

Pass	assert_true(true, "The element #pseudo-ui-input1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-ui-input2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-ui-input3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-ui-input4 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-ui-input5 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-ui-input6 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-ui-input7 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-ui-input8 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-ui-input9 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-ui-textarea1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-ui-button1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: :enabled pseudo-class selector, not matching link elements (with no refNodes): #pseudo-link :enabled

Asserts run

Pass	assert_false(false, "The element #pseudo-link-a1 should not match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:128:15)
Pass	assert_false(false, "The element #pseudo-link-a2 should not match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:128:15)
Pass	assert_false(false, "The element #pseudo-link-a3 should not match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:128:15)
Pass	assert_false(false, "The element #pseudo-link-map1 should not match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:128:15)
Pass	assert_false(false, "The element #pseudo-link-area1 should not match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:128:15)
Pass	assert_false(false, "The element #pseudo-link-area2 should not match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:128:15)

Pass

Detached Element.matches: :disabled pseudo-class selector, matching all disabled form controls (with no refNodes): #pseudo-ui :disabled

Asserts run

Pass	assert_true(true, "The element #pseudo-ui-input10 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-ui-input11 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-ui-input12 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-ui-input13 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-ui-input14 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-ui-input15 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-ui-input16 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-ui-input17 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-ui-input18 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-ui-textarea2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-ui-button2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: :disabled pseudo-class selector, not matching link elements (with no refNodes): #pseudo-link :disabled

Asserts run

Pass	assert_false(false, "The element #pseudo-link-a1 should not match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:128:15)
Pass	assert_false(false, "The element #pseudo-link-a2 should not match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:128:15)
Pass	assert_false(false, "The element #pseudo-link-a3 should not match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:128:15)
Pass	assert_false(false, "The element #pseudo-link-map1 should not match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:128:15)
Pass	assert_false(false, "The element #pseudo-link-area1 should not match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:128:15)
Pass	assert_false(false, "The element #pseudo-link-area2 should not match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:128:15)

Pass

Detached Element.matches: :checked pseudo-class selector, matching checked radio buttons and checkboxes (with no refNodes): #pseudo-ui :checked

Asserts run

Pass	assert_true(true, "The element #pseudo-ui-input4 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-ui-input6 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-ui-input13 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-ui-input15 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: :not pseudo-class selector, matching (with no refNodes): #not>:not(div)

Asserts run

Pass

assert_true(true, "The element #not-p1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #not-p2 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #not-p3 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: :not pseudo-class selector, matching (with no refNodes): #not * :not(:first-child)

Asserts run

Pass

assert_true(true, "The element #not-em1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #not-em2 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #not-em3 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: :not pseudo-class selector argument surrounded by spaces, matching (with no refNodes): #not>:not( div )

Asserts run

Pass

assert_true(true, "The element #not-p1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #not-p2 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #not-p3 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: Class selector, matching element with specified class (with no refNodes): .class-p

Asserts run

Pass

assert_true(true, "The element #class-p1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #class-p2 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #class-p3 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: Class selector, chained, matching only elements with all specified classes (with no refNodes): #class .apple.orange.banana

Asserts run

Pass	assert_true(true, "The element #class-div1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #class-div2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #class-p4 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #class-div3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #class-p6 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #class-div4 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: Class Selector, chained, with type selector (with no refNodes): div.apple.banana.orange

Asserts run

Pass	assert_true(true, "The element #class-div1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #class-div2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #class-div3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #class-div4 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: Class selector, matching element with class value using non-ASCII characters (1) (with no refNodes): .台北Táiběi

Asserts run

Pass	assert_true(true, "The element #class-span1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: Class selector, matching multiple elements with class value using non-ASCII characters (with no refNodes): .台北

Asserts run

Pass

assert_true(true, "The element #class-span1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #class-span2 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: Class selector, chained, matching element with multiple class values using non-ASCII characters (1) (with no refNodes): .台北Táiběi.台北

Asserts run

Pass	assert_true(true, "The element #class-span1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: Class selector, matching element with class with escaped character (with no refNodes): .foo\:bar

Asserts run

Pass	assert_true(true, "The element #class-span3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: Class selector, matching element with class with escaped character (with no refNodes): .test\.foo\[5\]bar

Asserts run

Pass	assert_true(true, "The element #class-span4 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: ID selector, matching element with specified id (with no refNodes): #id #id-div1

Asserts run

Pass	assert_true(true, "The element #id-div1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: ID selector, chained, matching element with specified id (with no refNodes): #id-div1, #id-div1

Asserts run

Pass	assert_true(true, "The element #id-div1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: ID selector, chained, matching element with specified id (with no refNodes): #id-div1, #id-div2

Asserts run

Pass

assert_true(true, "The element #id-div1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #id-div2 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: ID Selector, chained, with type selector (with no refNodes): div#id-div1, div#id-div2

Asserts run

Pass

assert_true(true, "The element #id-div1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #id-div2 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: ID selector, matching multiple elements with duplicate id (with no refNodes): #id-li-duplicate

Asserts run

Pass	assert_true(true, "The element #id-li-duplicate should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #id-li-duplicate should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #id-li-duplicate should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #id-li-duplicate should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: ID selector, matching id value using non-ASCII characters (1) (with no refNodes): #台北Táiběi

Asserts run

Pass	assert_true(true, "The element #台北Táiběi should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: ID selector, matching id value using non-ASCII characters (2) (with no refNodes): #台北

Asserts run

Pass	assert_true(true, "The element #台北 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: ID selector, matching id values using non-ASCII characters (1) (with no refNodes): #台北Táiběi, #台北

Asserts run

Pass

assert_true(true, "The element #台北Táiběi should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #台北 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: Descendant combinator, matching element that is a descendant of an element with id (with no refNodes): #descendant div

Asserts run

Pass	assert_true(true, "The element #descendant-div1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #descendant-div2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #descendant-div3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #descendant-div4 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: Descendant combinator, matching element with id that is a descendant of an element (with no refNodes): div #descendant-div1

Asserts run

Pass	assert_true(true, "The element #descendant-div1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: Descendant combinator, matching element with id that is a descendant of an element with id (with no refNodes): #descendant #descendant-div2

Asserts run

Pass	assert_true(true, "The element #descendant-div2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: Descendant combinator, matching element with class that is a descendant of an element with id (with no refNodes): #descendant .descendant-div2

Asserts run

Pass	assert_true(true, "The element #descendant-div2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: Descendant combinator, matching element with class that is a descendant of an element with class (with no refNodes): .descendant-div1 .descendant-div3

Asserts run

Pass	assert_true(true, "The element #descendant-div3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: Descendant combinator, whitespace characters (with no refNodes): #descendant #descendant-div2

Asserts run

Pass	assert_true(true, "The element #descendant-div2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: Child combinator, matching element that is a child of an element with id (with no refNodes): #child>div

Asserts run

Pass

assert_true(true, "The element #child-div1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #child-div4 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: Child combinator, matching element with id that is a child of an element (with no refNodes): div>#child-div1

Asserts run

Pass	assert_true(true, "The element #child-div1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: Child combinator, matching element with id that is a child of an element with id (with no refNodes): #child>#child-div1

Asserts run

Pass	assert_true(true, "The element #child-div1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: Child combinator, matching element with id that is a child of an element with class (with no refNodes): #child-div1>.child-div2

Asserts run

Pass	assert_true(true, "The element #child-div2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: Child combinator, matching element with class that is a child of an element with class (with no refNodes): .child-div1>.child-div2

Asserts run

Pass	assert_true(true, "The element #child-div2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: Child combinator, surrounded by whitespace (with no refNodes): #child-div1 > #child-div2

Asserts run

Pass	assert_true(true, "The element #child-div2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: Child combinator, whitespace after (with no refNodes): #child-div1> #child-div2

Asserts run

Pass	assert_true(true, "The element #child-div2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: Child combinator, whitespace before (with no refNodes): #child-div1 >#child-div2

Asserts run

Pass	assert_true(true, "The element #child-div2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: Child combinator, no whitespace (with no refNodes): #child-div1>#child-div2

Asserts run

Pass	assert_true(true, "The element #child-div2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: Adjacent sibling combinator, matching element that is an adjacent sibling of an element with id (with no refNodes): #adjacent-div2+div

Asserts run

Pass	assert_true(true, "The element #adjacent-div4 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: Adjacent sibling combinator, matching element with id that is an adjacent sibling of an element (with no refNodes): div+#adjacent-div4

Asserts run

Pass	assert_true(true, "The element #adjacent-div4 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: Adjacent sibling combinator, matching element with id that is an adjacent sibling of an element with id (with no refNodes): #adjacent-div2+#adjacent-div4

Asserts run

Pass	assert_true(true, "The element #adjacent-div4 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: Adjacent sibling combinator, matching element with class that is an adjacent sibling of an element with id (with no refNodes): #adjacent-div2+.adjacent-div4

Asserts run

Pass	assert_true(true, "The element #adjacent-div4 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: Adjacent sibling combinator, matching element with class that is an adjacent sibling of an element with class (with no refNodes): .adjacent-div2+.adjacent-div4

Asserts run

Pass	assert_true(true, "The element #adjacent-div4 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: Adjacent sibling combinator, matching p element that is an adjacent sibling of a div element (with no refNodes): #adjacent div+p

Asserts run

Pass	assert_true(true, "The element #adjacent-p2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: Adjacent sibling combinator, surrounded by whitespace (with no refNodes): #adjacent-p2 + #adjacent-p3

Asserts run

Pass	assert_true(true, "The element #adjacent-p3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: Adjacent sibling combinator, whitespace after (with no refNodes): #adjacent-p2+ #adjacent-p3

Asserts run

Pass	assert_true(true, "The element #adjacent-p3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: Adjacent sibling combinator, whitespace before (with no refNodes): #adjacent-p2 +#adjacent-p3

Asserts run

Pass	assert_true(true, "The element #adjacent-p3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: Adjacent sibling combinator, no whitespace (with no refNodes): #adjacent-p2+#adjacent-p3

Asserts run

Pass	assert_true(true, "The element #adjacent-p3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: General sibling combinator, matching element that is a sibling of an element with id (with no refNodes): #sibling-div2~div

Asserts run

Pass

assert_true(true, "The element #sibling-div4 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #sibling-div6 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: General sibling combinator, matching element with id that is a sibling of an element (with no refNodes): div~#sibling-div4

Asserts run

Pass	assert_true(true, "The element #sibling-div4 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: General sibling combinator, matching element with id that is a sibling of an element with id (with no refNodes): #sibling-div2~#sibling-div4

Asserts run

Pass	assert_true(true, "The element #sibling-div4 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: General sibling combinator, matching element with class that is a sibling of an element with id (with no refNodes): #sibling-div2~.sibling-div

Asserts run

Pass

assert_true(true, "The element #sibling-div4 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #sibling-div6 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: General sibling combinator, matching p element that is a sibling of a div element (with no refNodes): #sibling div~p

Asserts run

Pass

assert_true(true, "The element #sibling-p2 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #sibling-p3 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: General sibling combinator, surrounded by whitespace (with no refNodes): #sibling-p2 ~ #sibling-p3

Asserts run

Pass	assert_true(true, "The element #sibling-p3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: General sibling combinator, whitespace after (with no refNodes): #sibling-p2~ #sibling-p3

Asserts run

Pass	assert_true(true, "The element #sibling-p3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: General sibling combinator, whitespace before (with no refNodes): #sibling-p2 ~#sibling-p3

Asserts run

Pass	assert_true(true, "The element #sibling-p3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: General sibling combinator, no whitespace (with no refNodes): #sibling-p2~#sibling-p3

Asserts run

Pass	assert_true(true, "The element #sibling-p3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: Syntax, group of selectors separator, surrounded by whitespace (with no refNodes): #group em , #group strong

Asserts run

Pass

assert_true(true, "The element #group-em1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #group-strong1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: Syntax, group of selectors separator, whitespace after (with no refNodes): #group em, #group strong

Asserts run

Pass

assert_true(true, "The element #group-em1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #group-strong1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: Syntax, group of selectors separator, whitespace before (with no refNodes): #group em ,#group strong

Asserts run

Pass

assert_true(true, "The element #group-em1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #group-strong1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Detached Element.matches: Syntax, group of selectors separator, no whitespace (with no refNodes): #group em,#group strong

Asserts run

Pass

assert_true(true, "The element #group-em1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #group-strong1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: Universal selector, matching all elements (with no refNodes): *

Asserts run

Pass	assert_true(true, "The element #universal should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #universal-p1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #universal-code1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #universal-hr1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #universal-pre1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #universal-span1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #universal-p2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #universal-a1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #universal-address1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #universal-code2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #universal-a2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: Universal selector, matching all children of element with specified ID (with no refNodes): #universal>*

Asserts run

Pass	assert_true(true, "The element #universal-p1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #universal-hr1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #universal-pre1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #universal-p2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #universal-address1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: Universal selector, matching all grandchildren of element with specified ID (with no refNodes): #universal>*>*

Asserts run

Pass	assert_true(true, "The element #universal-code1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #universal-span1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #universal-a1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #universal-code2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: Universal selector, matching all descendants of element with specified ID (with no refNodes): #universal *

Asserts run

Pass	assert_true(true, "The element #universal-p1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #universal-code1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #universal-hr1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #universal-pre1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #universal-span1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #universal-p2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #universal-a1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #universal-address1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #universal-code2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #universal-a2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: Attribute presence selector, matching align attribute with value (with no refNodes): .attr-presence-div1[align]

Asserts run

Pass	assert_true(true, "The element #attr-presence-div1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: Attribute presence selector, matching align attribute with empty value (with no refNodes): .attr-presence-div2[align]

Asserts run

Pass	assert_true(true, "The element #attr-presence-div2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: Attribute presence selector, matching title attribute, case insensitivity (with no refNodes): #attr-presence [*|TiTlE]

Asserts run

Pass

assert_true(true, "The element #attr-presence-a1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #attr-presence-span1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #attr-presence-i1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: Attribute presence selector, matching custom data-* attribute (with no refNodes): [data-attr-presence]

Asserts run

Pass

assert_true(true, "The element #attr-presence-pre1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #attr-presence-blockquote1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: Attribute presence selector, matching attribute with non-ASCII characters (with no refNodes): ul[data-中文]

Asserts run

Pass	assert_true(true, "The element #attr-presence-ul1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: Attribute presence selector, matching option with selected attribute (with no refNodes): #attr-presence-select2 option[selected]

Asserts run

Pass	assert_true(true, "The element #attr-presence-select2-option4 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: Attribute presence selector, matching multiple options with selected attributes (with no refNodes): #attr-presence-select3 option[selected]

Asserts run

Pass

assert_true(true, "The element #attr-presence-select3-option2 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #attr-presence-select3-option3 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: Attribute value selector, matching align attribute with value (with no refNodes): #attr-value [align="center"]

Asserts run

Pass	assert_true(true, "The element #attr-value-div1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: Attribute value selector, matching align attribute with value, unclosed bracket (with no refNodes): #attr-value [align="center"

Asserts run

Pass	assert_true(true, "The element #attr-value-div1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: Attribute value selector, matching align attribute with empty value (with no refNodes): #attr-value [align=""]

Asserts run

Pass	assert_true(true, "The element #attr-value-div2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: Attribute value selector, matching custom data-* attribute with unicode escaped value (with no refNodes): [data-attr-value="\e9"]

Asserts run

Pass	assert_true(true, "The element #attr-value-div3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: Attribute value selector, matching custom data-* attribute with escaped character (with no refNodes): [data-attr-value_foo="\e9"]

Asserts run

Pass	assert_true(true, "The element #attr-value-div4 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: Attribute value selector with single-quoted value, matching multiple inputs with type attributes (with no refNodes): #attr-value input[type='hidden'],#attr-value input[type='radio']

Asserts run

Pass	assert_true(true, "The element #attr-value-input3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #attr-value-input4 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #attr-value-input6 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #attr-value-input8 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #attr-value-input9 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: Attribute value selector with double-quoted value, matching multiple inputs with type attributes (with no refNodes): #attr-value input[type="hidden"],#attr-value input[type='radio']

Asserts run

Pass	assert_true(true, "The element #attr-value-input3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #attr-value-input4 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #attr-value-input6 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #attr-value-input8 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #attr-value-input9 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: Attribute value selector with unquoted value, matching multiple inputs with type attributes (with no refNodes): #attr-value input[type=hidden],#attr-value input[type=radio]

Asserts run

Pass	assert_true(true, "The element #attr-value-input3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #attr-value-input4 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #attr-value-input6 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #attr-value-input8 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #attr-value-input9 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: Attribute value selector, matching attribute with value using non-ASCII characters (with no refNodes): [data-attr-value=中文]

Asserts run

Pass	assert_true(true, "The element #attr-value-div5 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: Attribute whitespace-separated list selector, matching class attribute with value (with no refNodes): #attr-whitespace [class~="div1"]

Asserts run

Pass	assert_true(true, "The element #attr-whitespace-div1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

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

Asserts run

Pass	assert_true(true, "The element #attr-whitespace-div4 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: Attribute whitespace-separated list selector, matching custom data-* attribute with escaped character (with no refNodes): [data-attr-whitespace_foo~="\e9"]

Asserts run

Pass	assert_true(true, "The element #attr-whitespace-div5 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: Attribute whitespace-separated list selector with single-quoted value, matching multiple links with rel attributes (with no refNodes): #attr-whitespace a[rel~='bookmark'], #attr-whitespace a[rel~='nofollow']

Asserts run

Pass	assert_true(true, "The element #attr-whitespace-a1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #attr-whitespace-a2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #attr-whitespace-a3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #attr-whitespace-a5 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #attr-whitespace-a7 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: Attribute whitespace-separated list selector with double-quoted value, matching multiple links with rel attributes (with no refNodes): #attr-whitespace a[rel~="bookmark"],#attr-whitespace a[rel~='nofollow']

Asserts run

Pass	assert_true(true, "The element #attr-whitespace-a1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #attr-whitespace-a2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #attr-whitespace-a3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #attr-whitespace-a5 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #attr-whitespace-a7 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: Attribute whitespace-separated list selector with unquoted value, matching multiple links with rel attributes (with no refNodes): #attr-whitespace a[rel~=bookmark], #attr-whitespace a[rel~=nofollow]

Asserts run

Pass	assert_true(true, "The element #attr-whitespace-a1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #attr-whitespace-a2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #attr-whitespace-a3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #attr-whitespace-a5 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #attr-whitespace-a7 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: Attribute whitespace-separated list selector, matching title attribute with value using non-ASCII characters (with no refNodes): #attr-whitespace [title~=中文]

Asserts run

Pass	assert_true(true, "The element #attr-whitespace-p1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: Attribute hyphen-separated list selector, matching lang attribute with exact value (with no refNodes): #attr-hyphen-div2[lang|="fr"]

Asserts run

Pass	assert_true(true, "The element #attr-hyphen-div2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: Attribute hyphen-separated list selector, matching lang attribute with partial value (with no refNodes): #attr-hyphen-div3[lang|="en"]

Asserts run

Pass	assert_true(true, "The element #attr-hyphen-div3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: Attribute begins with selector, matching href attributes beginning with specified substring (with no refNodes): #attr-begins a[href^="http://www"]

Asserts run

Pass

assert_true(true, "The element #attr-begins-a1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #attr-begins-a3 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: Attribute begins with selector, matching lang attributes beginning with specified substring, (with no refNodes): #attr-begins [lang^="en-"]

Asserts run

Pass

assert_true(true, "The element #attr-begins-div2 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #attr-begins-div4 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: Attribute begins with selector with single-quoted value, matching class attribute beginning with specified substring (with no refNodes): #attr-begins [class^=' apple']

Asserts run

Pass	assert_true(true, "The element #attr-begins-p1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: Attribute begins with selector with double-quoted value, matching class attribute beginning with specified substring (with no refNodes): #attr-begins [class^=" apple"]

Asserts run

Pass	assert_true(true, "The element #attr-begins-p1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: Attribute ends with selector, matching href attributes ending with specified substring (with no refNodes): #attr-ends a[href$=".org"]

Asserts run

Pass

assert_true(true, "The element #attr-ends-a1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #attr-ends-a3 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: Attribute ends with selector, matching lang attributes ending with specified substring, (with no refNodes): #attr-ends [lang$="-CH"]

Asserts run

Pass

assert_true(true, "The element #attr-ends-div2 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #attr-ends-div4 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: Attribute ends with selector with single-quoted value, matching class attribute ending with specified substring (with no refNodes): #attr-ends [class$='apple ']

Asserts run

Pass	assert_true(true, "The element #attr-ends-p1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: Attribute ends with selector with double-quoted value, matching class attribute ending with specified substring (with no refNodes): #attr-ends [class$="apple "]

Asserts run

Pass	assert_true(true, "The element #attr-ends-p1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: Attribute contains selector, matching href attributes beginning with specified substring (with no refNodes): #attr-contains a[href*="http://www"]

Asserts run

Pass

assert_true(true, "The element #attr-contains-a1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #attr-contains-a3 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: Attribute contains selector, matching href attributes ending with specified substring (with no refNodes): #attr-contains a[href*=".org"]

Asserts run

Pass

assert_true(true, "The element #attr-contains-a1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #attr-contains-a2 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: Attribute contains selector, matching href attributes containing specified substring (with no refNodes): #attr-contains a[href*=".example."]

Asserts run

Pass

assert_true(true, "The element #attr-contains-a1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #attr-contains-a3 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: Attribute contains selector, matching lang attributes beginning with specified substring, (with no refNodes): #attr-contains [lang*="en-"]

Asserts run

Pass

assert_true(true, "The element #attr-contains-div2 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #attr-contains-div6 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: Attribute contains selector, matching lang attributes ending with specified substring, (with no refNodes): #attr-contains [lang*="-CH"]

Asserts run

Pass

assert_true(true, "The element #attr-contains-div3 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #attr-contains-div5 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: Attribute contains selector with single-quoted value, matching class attribute beginning with specified substring (with no refNodes): #attr-contains [class*=' apple']

Asserts run

Pass	assert_true(true, "The element #attr-contains-p1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: Attribute contains selector with single-quoted value, matching class attribute ending with specified substring (with no refNodes): #attr-contains [class*='orange ']

Asserts run

Pass	assert_true(true, "The element #attr-contains-p1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: Attribute contains selector with single-quoted value, matching class attribute containing specified substring (with no refNodes): #attr-contains [class*='ple banana ora']

Asserts run

Pass	assert_true(true, "The element #attr-contains-p1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: Attribute contains selector with double-quoted value, matching class attribute beginning with specified substring (with no refNodes): #attr-contains [class*=" apple"]

Asserts run

Pass	assert_true(true, "The element #attr-contains-p1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: Attribute contains selector with double-quoted value, matching class attribute ending with specified substring (with no refNodes): #attr-contains [class*="orange "]

Asserts run

Pass	assert_true(true, "The element #attr-contains-p1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: Attribute contains selector with double-quoted value, matching class attribute containing specified substring (with no refNodes): #attr-contains [class*="ple banana ora"]

Asserts run

Pass	assert_true(true, "The element #attr-contains-p1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: Attribute contains selector with unquoted value, matching class attribute beginning with specified substring (with no refNodes): #attr-contains [class*= apple]

Asserts run

Pass	assert_true(true, "The element #attr-contains-p1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: Attribute contains selector with unquoted value, matching class attribute ending with specified substring (with no refNodes): #attr-contains [class*=orange ]

Asserts run

Pass	assert_true(true, "The element #attr-contains-p1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: Attribute contains selector with unquoted value, matching class attribute containing specified substring (with no refNodes): #attr-contains [class*= banana ]

Asserts run

Pass	assert_true(true, "The element #attr-contains-p1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: :nth-child selector, matching the third child element (with no refNodes): #pseudo-nth-table1 :nth-child(3)

Asserts run

Pass	assert_true(true, "The element #pseudo-nth-td3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-nth-td9 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-nth-tr3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-nth-td15 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: :nth-child selector, matching every third child element (with no refNodes): #pseudo-nth li:nth-child(3n)

Asserts run

Pass	assert_true(true, "The element #pseudo-nth-li3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-nth-li6 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-nth-li9 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-nth-li12 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: :nth-child selector, matching every second child element, starting from the fourth (with no refNodes): #pseudo-nth li:nth-child(2n+4)

Asserts run

Pass	assert_true(true, "The element #pseudo-nth-li4 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-nth-li6 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-nth-li8 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-nth-li10 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-nth-li12 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: :nth-child selector, matching every fourth child element, starting from the third (with no refNodes): #pseudo-nth-p1 :nth-child(4n-1)

Asserts run

Pass

assert_true(true, "The element #pseudo-nth-em2 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #pseudo-nth-span3 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: :nth-last-child selector, matching the third last child element (with no refNodes): #pseudo-nth-table1 :nth-last-child(3)

Asserts run

Pass	assert_true(true, "The element #pseudo-nth-tr1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-nth-td4 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-nth-td10 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-nth-td16 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: :nth-last-child selector, matching every third child element from the end (with no refNodes): #pseudo-nth li:nth-last-child(3n)

Asserts run

Pass	assert_true(true, "The element #pseudo-nth-li1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-nth-li4 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-nth-li7 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-nth-li10 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: :nth-last-child selector, matching every second child element from the end, starting from the fourth last (with no refNodes): #pseudo-nth li:nth-last-child(2n+4)

Asserts run

Pass	assert_true(true, "The element #pseudo-nth-li1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-nth-li3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-nth-li5 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-nth-li7 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-nth-li9 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: :nth-last-child selector, matching every fourth element from the end, starting from the third last (with no refNodes): #pseudo-nth-p1 :nth-last-child(4n-1)

Asserts run

Pass

assert_true(true, "The element #pseudo-nth-span2 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #pseudo-nth-span4 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: :nth-of-type selector, matching the third em element (with no refNodes): #pseudo-nth-p1 em:nth-of-type(3)

Asserts run

Pass	assert_true(true, "The element #pseudo-nth-em3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: :nth-of-type selector, matching every second element of their type (with no refNodes): #pseudo-nth-p1 :nth-of-type(2n)

Asserts run

Pass	assert_true(true, "The element #pseudo-nth-em2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-nth-span2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-nth-span4 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-nth-strong2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-nth-em4 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: :nth-of-type selector, matching every second elemetn of their type, starting from the first (with no refNodes): #pseudo-nth-p1 span:nth-of-type(2n-1)

Asserts run

Pass

assert_true(true, "The element #pseudo-nth-span1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #pseudo-nth-span3 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: :nth-last-of-type selector, matching the third last em element (with no refNodes): #pseudo-nth-p1 em:nth-last-of-type(3)

Asserts run

Pass	assert_true(true, "The element #pseudo-nth-em2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: :nth-last-of-type selector, matching every second last element of their type (with no refNodes): #pseudo-nth-p1 :nth-last-of-type(2n)

Asserts run

Pass	assert_true(true, "The element #pseudo-nth-span1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-nth-em1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-nth-strong1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-nth-em3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-nth-span3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: :nth-last-of-type selector, matching every second last element of their type, starting from the last (with no refNodes): #pseudo-nth-p1 span:nth-last-of-type(2n-1)

Asserts run

Pass

assert_true(true, "The element #pseudo-nth-span2 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #pseudo-nth-span4 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: :first-of-type selector, matching the first em element (with no refNodes): #pseudo-nth-p1 em:first-of-type

Asserts run

Pass	assert_true(true, "The element #pseudo-nth-em1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: :first-of-type selector, matching the first of every type of element (with no refNodes): #pseudo-nth-p1 :first-of-type

Asserts run

Pass

assert_true(true, "The element #pseudo-nth-span1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #pseudo-nth-em1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #pseudo-nth-strong1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: :first-of-type selector, matching the first td element in each table row (with no refNodes): #pseudo-nth-table1 tr :first-of-type

Asserts run

Pass

assert_true(true, "The element #pseudo-nth-td1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #pseudo-nth-td7 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #pseudo-nth-td13 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: :last-of-type selector, matching the last em elemnet (with no refNodes): #pseudo-nth-p1 em:last-of-type

Asserts run

Pass	assert_true(true, "The element #pseudo-nth-em4 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: :last-of-type selector, matching the last of every type of element (with no refNodes): #pseudo-nth-p1 :last-of-type

Asserts run

Pass

assert_true(true, "The element #pseudo-nth-span4 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #pseudo-nth-strong2 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #pseudo-nth-em4 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: :last-of-type selector, matching the last td element in each table row (with no refNodes): #pseudo-nth-table1 tr :last-of-type

Asserts run

Pass

assert_true(true, "The element #pseudo-nth-td6 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #pseudo-nth-td12 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #pseudo-nth-td18 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: :first-child pseudo-class selector, matching first child div element (with no refNodes): #pseudo-first-child div:first-child

Asserts run

Pass	assert_true(true, "The element #pseudo-first-child-div1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: :first-child pseudo-class selector, matching first-child of multiple elements (with no refNodes): #pseudo-first-child span:first-child

Asserts run

Pass

assert_true(true, "The element #pseudo-first-child-span1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #pseudo-first-child-span3 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #pseudo-first-child-span5 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: :last-child pseudo-class selector, matching last child div element (with no refNodes): #pseudo-last-child div:last-child

Asserts run

Pass	assert_true(true, "The element #pseudo-last-child-div3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: :last-child pseudo-class selector, matching first-child of multiple elements (with no refNodes): #pseudo-last-child span:last-child

Asserts run

Pass

assert_true(true, "The element #pseudo-last-child-span2 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #pseudo-last-child-span4 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #pseudo-last-child-span6 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: :pseudo-only-child pseudo-class selector, matching all only-child elements (with no refNodes): #pseudo-only :only-child

Asserts run

Pass	assert_true(true, "The element #pseudo-only-span1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: :pseudo-only-of-type pseudo-class selector, matching all elements with no siblings of the same type (with no refNodes): #pseudo-only :only-of-type

Asserts run

Pass

assert_true(true, "The element #pseudo-only-span1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #pseudo-only-em1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: :pseudo-only-of-type pseudo-class selector, matching em elements with no siblings of the same type (with no refNodes): #pseudo-only em:only-of-type

Asserts run

Pass	assert_true(true, "The element #pseudo-only-em1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: :empty pseudo-class selector, matching empty p elements (with no refNodes): #pseudo-empty p:empty

Asserts run

Pass

assert_true(true, "The element #pseudo-empty-p1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #pseudo-empty-p2 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: :empty pseudo-class selector, matching all empty elements (with no refNodes): #pseudo-empty :empty

Asserts run

Pass

assert_true(true, "The element #pseudo-empty-p1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #pseudo-empty-p2 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #pseudo-empty-span1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: :link and :visited pseudo-class selectors, matching a and area elements with href attributes (with no refNodes): #pseudo-link :link, #pseudo-link :visited

Asserts run

Pass

assert_true(true, "The element #pseudo-link-a1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #pseudo-link-a2 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #pseudo-link-area1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: :lang pseudo-class selector, matching specified language with exact value (with no refNodes): #pseudo-lang-div2:lang(fr)

Asserts run

Pass	assert_true(true, "The element #pseudo-lang-div2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: :lang pseudo-class selector, matching specified language with partial value (with no refNodes): #pseudo-lang-div3:lang(en)

Asserts run

Pass	assert_true(true, "The element #pseudo-lang-div3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: :enabled pseudo-class selector, matching all enabled form controls (with no refNodes): #pseudo-ui :enabled

Asserts run

Pass	assert_true(true, "The element #pseudo-ui-input1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-ui-input2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-ui-input3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-ui-input4 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-ui-input5 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-ui-input6 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-ui-input7 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-ui-input8 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-ui-input9 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-ui-textarea1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-ui-button1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: :enabled pseudo-class selector, not matching link elements (with no refNodes): #pseudo-link :enabled

Asserts run

Pass	assert_false(false, "The element #pseudo-link-a1 should not match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:128:15)
Pass	assert_false(false, "The element #pseudo-link-a2 should not match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:128:15)
Pass	assert_false(false, "The element #pseudo-link-a3 should not match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:128:15)
Pass	assert_false(false, "The element #pseudo-link-map1 should not match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:128:15)
Pass	assert_false(false, "The element #pseudo-link-area1 should not match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:128:15)
Pass	assert_false(false, "The element #pseudo-link-area2 should not match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:128:15)

Pass

Fragment Element.matches: :disabled pseudo-class selector, matching all disabled form controls (with no refNodes): #pseudo-ui :disabled

Asserts run

Pass	assert_true(true, "The element #pseudo-ui-input10 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-ui-input11 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-ui-input12 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-ui-input13 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-ui-input14 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-ui-input15 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-ui-input16 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-ui-input17 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-ui-input18 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-ui-textarea2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-ui-button2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: :disabled pseudo-class selector, not matching link elements (with no refNodes): #pseudo-link :disabled

Asserts run

Pass	assert_false(false, "The element #pseudo-link-a1 should not match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:128:15)
Pass	assert_false(false, "The element #pseudo-link-a2 should not match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:128:15)
Pass	assert_false(false, "The element #pseudo-link-a3 should not match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:128:15)
Pass	assert_false(false, "The element #pseudo-link-map1 should not match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:128:15)
Pass	assert_false(false, "The element #pseudo-link-area1 should not match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:128:15)
Pass	assert_false(false, "The element #pseudo-link-area2 should not match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:128:15)

Pass

Fragment Element.matches: :checked pseudo-class selector, matching checked radio buttons and checkboxes (with no refNodes): #pseudo-ui :checked

Asserts run

Pass	assert_true(true, "The element #pseudo-ui-input4 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-ui-input6 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-ui-input13 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-ui-input15 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: :not pseudo-class selector, matching (with no refNodes): #not>:not(div)

Asserts run

Pass

assert_true(true, "The element #not-p1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #not-p2 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #not-p3 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: :not pseudo-class selector, matching (with no refNodes): #not * :not(:first-child)

Asserts run

Pass

assert_true(true, "The element #not-em1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #not-em2 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #not-em3 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: :not pseudo-class selector argument surrounded by spaces, matching (with no refNodes): #not>:not( div )

Asserts run

Pass

assert_true(true, "The element #not-p1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #not-p2 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #not-p3 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: Class selector, matching element with specified class (with no refNodes): .class-p

Asserts run

Pass

assert_true(true, "The element #class-p1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #class-p2 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #class-p3 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: Class selector, chained, matching only elements with all specified classes (with no refNodes): #class .apple.orange.banana

Asserts run

Pass	assert_true(true, "The element #class-div1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #class-div2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #class-p4 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #class-div3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #class-p6 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #class-div4 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: Class Selector, chained, with type selector (with no refNodes): div.apple.banana.orange

Asserts run

Pass	assert_true(true, "The element #class-div1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #class-div2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #class-div3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #class-div4 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: Class selector, matching element with class value using non-ASCII characters (1) (with no refNodes): .台北Táiběi

Asserts run

Pass	assert_true(true, "The element #class-span1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: Class selector, matching multiple elements with class value using non-ASCII characters (with no refNodes): .台北

Asserts run

Pass

assert_true(true, "The element #class-span1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #class-span2 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: Class selector, chained, matching element with multiple class values using non-ASCII characters (1) (with no refNodes): .台北Táiběi.台北

Asserts run

Pass	assert_true(true, "The element #class-span1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: Class selector, matching element with class with escaped character (with no refNodes): .foo\:bar

Asserts run

Pass	assert_true(true, "The element #class-span3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: Class selector, matching element with class with escaped character (with no refNodes): .test\.foo\[5\]bar

Asserts run

Pass	assert_true(true, "The element #class-span4 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: ID selector, matching element with specified id (with no refNodes): #id #id-div1

Asserts run

Pass	assert_true(true, "The element #id-div1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: ID selector, chained, matching element with specified id (with no refNodes): #id-div1, #id-div1

Asserts run

Pass	assert_true(true, "The element #id-div1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: ID selector, chained, matching element with specified id (with no refNodes): #id-div1, #id-div2

Asserts run

Pass

assert_true(true, "The element #id-div1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #id-div2 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: ID Selector, chained, with type selector (with no refNodes): div#id-div1, div#id-div2

Asserts run

Pass

assert_true(true, "The element #id-div1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #id-div2 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: ID selector, matching multiple elements with duplicate id (with no refNodes): #id-li-duplicate

Asserts run

Pass	assert_true(true, "The element #id-li-duplicate should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #id-li-duplicate should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #id-li-duplicate should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #id-li-duplicate should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: ID selector, matching id value using non-ASCII characters (1) (with no refNodes): #台北Táiběi

Asserts run

Pass	assert_true(true, "The element #台北Táiběi should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: ID selector, matching id value using non-ASCII characters (2) (with no refNodes): #台北

Asserts run

Pass	assert_true(true, "The element #台北 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: ID selector, matching id values using non-ASCII characters (1) (with no refNodes): #台北Táiběi, #台北

Asserts run

Pass

assert_true(true, "The element #台北Táiběi should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #台北 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: Descendant combinator, matching element that is a descendant of an element with id (with no refNodes): #descendant div

Asserts run

Pass	assert_true(true, "The element #descendant-div1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #descendant-div2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #descendant-div3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #descendant-div4 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: Descendant combinator, matching element with id that is a descendant of an element (with no refNodes): div #descendant-div1

Asserts run

Pass	assert_true(true, "The element #descendant-div1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: Descendant combinator, matching element with id that is a descendant of an element with id (with no refNodes): #descendant #descendant-div2

Asserts run

Pass	assert_true(true, "The element #descendant-div2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: Descendant combinator, matching element with class that is a descendant of an element with id (with no refNodes): #descendant .descendant-div2

Asserts run

Pass	assert_true(true, "The element #descendant-div2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: Descendant combinator, matching element with class that is a descendant of an element with class (with no refNodes): .descendant-div1 .descendant-div3

Asserts run

Pass	assert_true(true, "The element #descendant-div3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: Descendant combinator, whitespace characters (with no refNodes): #descendant #descendant-div2

Asserts run

Pass	assert_true(true, "The element #descendant-div2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: Child combinator, matching element that is a child of an element with id (with no refNodes): #child>div

Asserts run

Pass

assert_true(true, "The element #child-div1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #child-div4 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: Child combinator, matching element with id that is a child of an element (with no refNodes): div>#child-div1

Asserts run

Pass	assert_true(true, "The element #child-div1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: Child combinator, matching element with id that is a child of an element with id (with no refNodes): #child>#child-div1

Asserts run

Pass	assert_true(true, "The element #child-div1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: Child combinator, matching element with id that is a child of an element with class (with no refNodes): #child-div1>.child-div2

Asserts run

Pass	assert_true(true, "The element #child-div2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: Child combinator, matching element with class that is a child of an element with class (with no refNodes): .child-div1>.child-div2

Asserts run

Pass	assert_true(true, "The element #child-div2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: Child combinator, surrounded by whitespace (with no refNodes): #child-div1 > #child-div2

Asserts run

Pass	assert_true(true, "The element #child-div2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: Child combinator, whitespace after (with no refNodes): #child-div1> #child-div2

Asserts run

Pass	assert_true(true, "The element #child-div2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: Child combinator, whitespace before (with no refNodes): #child-div1 >#child-div2

Asserts run

Pass	assert_true(true, "The element #child-div2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: Child combinator, no whitespace (with no refNodes): #child-div1>#child-div2

Asserts run

Pass	assert_true(true, "The element #child-div2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: Adjacent sibling combinator, matching element that is an adjacent sibling of an element with id (with no refNodes): #adjacent-div2+div

Asserts run

Pass	assert_true(true, "The element #adjacent-div4 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: Adjacent sibling combinator, matching element with id that is an adjacent sibling of an element (with no refNodes): div+#adjacent-div4

Asserts run

Pass	assert_true(true, "The element #adjacent-div4 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: Adjacent sibling combinator, matching element with id that is an adjacent sibling of an element with id (with no refNodes): #adjacent-div2+#adjacent-div4

Asserts run

Pass	assert_true(true, "The element #adjacent-div4 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: Adjacent sibling combinator, matching element with class that is an adjacent sibling of an element with id (with no refNodes): #adjacent-div2+.adjacent-div4

Asserts run

Pass	assert_true(true, "The element #adjacent-div4 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: Adjacent sibling combinator, matching element with class that is an adjacent sibling of an element with class (with no refNodes): .adjacent-div2+.adjacent-div4

Asserts run

Pass	assert_true(true, "The element #adjacent-div4 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: Adjacent sibling combinator, matching p element that is an adjacent sibling of a div element (with no refNodes): #adjacent div+p

Asserts run

Pass	assert_true(true, "The element #adjacent-p2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: Adjacent sibling combinator, surrounded by whitespace (with no refNodes): #adjacent-p2 + #adjacent-p3

Asserts run

Pass	assert_true(true, "The element #adjacent-p3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: Adjacent sibling combinator, whitespace after (with no refNodes): #adjacent-p2+ #adjacent-p3

Asserts run

Pass	assert_true(true, "The element #adjacent-p3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: Adjacent sibling combinator, whitespace before (with no refNodes): #adjacent-p2 +#adjacent-p3

Asserts run

Pass	assert_true(true, "The element #adjacent-p3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: Adjacent sibling combinator, no whitespace (with no refNodes): #adjacent-p2+#adjacent-p3

Asserts run

Pass	assert_true(true, "The element #adjacent-p3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: General sibling combinator, matching element that is a sibling of an element with id (with no refNodes): #sibling-div2~div

Asserts run

Pass

assert_true(true, "The element #sibling-div4 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #sibling-div6 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: General sibling combinator, matching element with id that is a sibling of an element (with no refNodes): div~#sibling-div4

Asserts run

Pass	assert_true(true, "The element #sibling-div4 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: General sibling combinator, matching element with id that is a sibling of an element with id (with no refNodes): #sibling-div2~#sibling-div4

Asserts run

Pass	assert_true(true, "The element #sibling-div4 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: General sibling combinator, matching element with class that is a sibling of an element with id (with no refNodes): #sibling-div2~.sibling-div

Asserts run

Pass

assert_true(true, "The element #sibling-div4 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #sibling-div6 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: General sibling combinator, matching p element that is a sibling of a div element (with no refNodes): #sibling div~p

Asserts run

Pass

assert_true(true, "The element #sibling-p2 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #sibling-p3 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: General sibling combinator, surrounded by whitespace (with no refNodes): #sibling-p2 ~ #sibling-p3

Asserts run

Pass	assert_true(true, "The element #sibling-p3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: General sibling combinator, whitespace after (with no refNodes): #sibling-p2~ #sibling-p3

Asserts run

Pass	assert_true(true, "The element #sibling-p3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: General sibling combinator, whitespace before (with no refNodes): #sibling-p2 ~#sibling-p3

Asserts run

Pass	assert_true(true, "The element #sibling-p3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: General sibling combinator, no whitespace (with no refNodes): #sibling-p2~#sibling-p3

Asserts run

Pass	assert_true(true, "The element #sibling-p3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: Syntax, group of selectors separator, surrounded by whitespace (with no refNodes): #group em , #group strong

Asserts run

Pass

assert_true(true, "The element #group-em1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #group-strong1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: Syntax, group of selectors separator, whitespace after (with no refNodes): #group em, #group strong

Asserts run

Pass

assert_true(true, "The element #group-em1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #group-strong1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: Syntax, group of selectors separator, whitespace before (with no refNodes): #group em ,#group strong

Asserts run

Pass

assert_true(true, "The element #group-em1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #group-strong1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

Fragment Element.matches: Syntax, group of selectors separator, no whitespace (with no refNodes): #group em,#group strong

Asserts run

Pass

assert_true(true, "The element #group-em1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #group-strong1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: Attribute presence selector, matching align attribute with value (with refNode Element): .attr-presence-div1[align]

Asserts run

Pass	assert_true(true, "The element #attr-presence-div1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)

Pass

In-document Element.matches: Attribute presence selector, matching align attribute with empty value (with refNode Element): .attr-presence-div2[align]

Asserts run

Pass	assert_true(true, "The element #attr-presence-div2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)

Pass

In-document Element.matches: Attribute presence selector, matching title attribute, case insensitivity (with refNode Element): [TiTlE]

Asserts run

Pass

assert_true(true, "The element #attr-presence-a1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)

Pass

assert_true(true, "The element #attr-presence-span1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)

Pass

In-document Element.matches: Attribute presence selector, matching custom data-* attribute (with refNode Element): [data-attr-presence]

Asserts run

Pass

assert_true(true, "The element #attr-presence-pre1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)

Pass

assert_true(true, "The element #attr-presence-blockquote1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)

Pass

In-document Element.matches: Attribute presence selector, matching attribute with non-ASCII characters (with refNode Element): ul[data-中文]

Asserts run

Pass	assert_true(true, "The element #attr-presence-ul1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)

Pass

In-document Element.matches: Attribute presence selector, matching option with selected attribute (with refNode Element): #attr-presence-select2 option[selected]

Asserts run

Pass	assert_true(true, "The element #attr-presence-select2-option4 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)

Pass

In-document Element.matches: Attribute presence selector, matching multiple options with selected attributes (with refNode Element): #attr-presence-select3 option[selected]

Asserts run

Pass

assert_true(true, "The element #attr-presence-select3-option2 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)

Pass

assert_true(true, "The element #attr-presence-select3-option3 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)

Pass

In-document Element.matches: Attribute value selector, matching align attribute with value (with refNode Element): [align="center"]

Asserts run

Pass	assert_true(true, "The element #attr-value-div1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)

Pass

In-document Element.matches: Attribute value selector, matching align attribute with empty value (with refNode Element): [align=""]

Asserts run

Pass	assert_true(true, "The element #attr-value-div2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)

Pass

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

Asserts run

Pass	assert_true(true, "The element #attr-value-div3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)

Pass

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

Asserts run

Pass	assert_true(true, "The element #attr-value-div4 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)

Pass

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

Asserts run

Pass	assert_true(true, "The element #attr-value-input3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)
Pass	assert_true(true, "The element #attr-value-input4 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)
Pass	assert_true(true, "The element #attr-value-input6 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)
Pass	assert_true(true, "The element #attr-value-input8 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)
Pass	assert_true(true, "The element #attr-value-input9 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)

Pass

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

Asserts run

Pass	assert_true(true, "The element #attr-value-input3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)
Pass	assert_true(true, "The element #attr-value-input4 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)
Pass	assert_true(true, "The element #attr-value-input6 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)
Pass	assert_true(true, "The element #attr-value-input8 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)
Pass	assert_true(true, "The element #attr-value-input9 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)

Pass

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

Asserts run

Pass	assert_true(true, "The element #attr-value-input3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)
Pass	assert_true(true, "The element #attr-value-input4 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)
Pass	assert_true(true, "The element #attr-value-input6 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)
Pass	assert_true(true, "The element #attr-value-input8 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)
Pass	assert_true(true, "The element #attr-value-input9 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)

Pass

In-document Element.matches: Attribute value selector, matching attribute with value using non-ASCII characters (with refNode Element): [data-attr-value=中文]

Asserts run

Pass	assert_true(true, "The element #attr-value-div5 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)

Pass

In-document Element.matches: Attribute whitespace-separated list selector, matching class attribute with value (with refNode Element): [class~="div1"]

Asserts run

Pass	assert_true(true, "The element #attr-whitespace-div1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)

Pass

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

Asserts run

Pass	assert_true(true, "The element #attr-whitespace-div4 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)

Pass

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

Asserts run

Pass	assert_true(true, "The element #attr-whitespace-div5 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)

Pass

In-document Element.matches: 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']

Asserts run

Pass	assert_true(true, "The element #attr-whitespace-a1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)
Pass	assert_true(true, "The element #attr-whitespace-a2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)
Pass	assert_true(true, "The element #attr-whitespace-a3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)
Pass	assert_true(true, "The element #attr-whitespace-a5 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)
Pass	assert_true(true, "The element #attr-whitespace-a7 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)

Pass

In-document Element.matches: 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']

Asserts run

Pass	assert_true(true, "The element #attr-whitespace-a1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)
Pass	assert_true(true, "The element #attr-whitespace-a2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)
Pass	assert_true(true, "The element #attr-whitespace-a3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)
Pass	assert_true(true, "The element #attr-whitespace-a5 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)
Pass	assert_true(true, "The element #attr-whitespace-a7 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)

Pass

In-document Element.matches: 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]

Asserts run

Pass	assert_true(true, "The element #attr-whitespace-a1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)
Pass	assert_true(true, "The element #attr-whitespace-a2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)
Pass	assert_true(true, "The element #attr-whitespace-a3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)
Pass	assert_true(true, "The element #attr-whitespace-a5 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)
Pass	assert_true(true, "The element #attr-whitespace-a7 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)

Pass

In-document Element.matches: Attribute whitespace-separated list selector, matching title attribute with value using non-ASCII characters (with refNode Element): [title~=中文]

Asserts run

Pass	assert_true(true, "The element #attr-whitespace-p1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)

Pass

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

Asserts run

Pass	assert_true(true, "The element #attr-hyphen-div2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)

Pass

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

Asserts run

Pass	assert_true(true, "The element #attr-hyphen-div3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)

Pass

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

Asserts run

Pass

assert_true(true, "The element #attr-begins-a1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)

Pass

assert_true(true, "The element #attr-begins-a3 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)

Pass

In-document Element.matches: Attribute begins with selector, matching lang attributes beginning with specified substring, (with refNode Element): [lang^="en-"]

Asserts run

Pass

assert_true(true, "The element #attr-begins-div2 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)

Pass

assert_true(true, "The element #attr-begins-div4 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)

Pass

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

Asserts run

Pass	assert_true(true, "The element #attr-begins-p1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)

Pass

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

Asserts run

Pass	assert_true(true, "The element #attr-begins-p1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)

Pass

In-document Element.matches: Attribute ends with selector, matching href attributes ending with specified substring (with refNode Element): a[href$=".org"]

Asserts run

Pass

assert_true(true, "The element #attr-ends-a1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)

Pass

assert_true(true, "The element #attr-ends-a3 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)

Pass

In-document Element.matches: Attribute ends with selector, matching lang attributes ending with specified substring, (with refNode Element): [lang$="-CH"]

Asserts run

Pass

assert_true(true, "The element #attr-ends-div2 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)

Pass

assert_true(true, "The element #attr-ends-div4 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)

Pass

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

Asserts run

Pass	assert_true(true, "The element #attr-ends-p1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)

Pass

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

Asserts run

Pass	assert_true(true, "The element #attr-ends-p1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)

Pass

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

Asserts run

Pass

assert_true(true, "The element #attr-contains-a1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)

Pass

assert_true(true, "The element #attr-contains-a3 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)

Pass

In-document Element.matches: Attribute contains selector, matching href attributes ending with specified substring (with refNode Element): a[href*=".org"]

Asserts run

Pass

assert_true(true, "The element #attr-contains-a1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)

Pass

assert_true(true, "The element #attr-contains-a2 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)

Pass

In-document Element.matches: Attribute contains selector, matching href attributes containing specified substring (with refNode Element): a[href*=".example."]

Asserts run

Pass

assert_true(true, "The element #attr-contains-a1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)

Pass

assert_true(true, "The element #attr-contains-a3 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)

Pass

In-document Element.matches: Attribute contains selector, matching lang attributes beginning with specified substring, (with refNode Element): [lang*="en-"]

Asserts run

Pass

assert_true(true, "The element #attr-contains-div2 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)

Pass

assert_true(true, "The element #attr-contains-div6 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)

Pass

In-document Element.matches: Attribute contains selector, matching lang attributes ending with specified substring, (with refNode Element): [lang*="-CH"]

Asserts run

Pass

assert_true(true, "The element #attr-contains-div3 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)

Pass

assert_true(true, "The element #attr-contains-div5 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)

Pass

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

Asserts run

Pass	assert_true(true, "The element #attr-contains-p1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)

Pass

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

Asserts run

Pass	assert_true(true, "The element #attr-contains-p1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)

Pass

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

Asserts run

Pass	assert_true(true, "The element #attr-contains-p1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)

Pass

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

Asserts run

Pass	assert_true(true, "The element #attr-contains-p1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)

Pass

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

Asserts run

Pass	assert_true(true, "The element #attr-contains-p1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)

Pass

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

Asserts run

Pass	assert_true(true, "The element #attr-contains-p1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)

Pass

In-document Element.matches: Attribute contains selector with unquoted value, matching class attribute beginning with specified substring (with refNode Element): [class*= apple]

Asserts run

Pass	assert_true(true, "The element #attr-contains-p1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)

Pass

In-document Element.matches: Attribute contains selector with unquoted value, matching class attribute ending with specified substring (with refNode Element): [class*=orange ]

Asserts run

Pass	assert_true(true, "The element #attr-contains-p1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)

Pass

In-document Element.matches: Attribute contains selector with unquoted value, matching class attribute containing specified substring (with refNode Element): [class*= banana ]

Asserts run

Pass	assert_true(true, "The element #attr-contains-p1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)

Pass

In-document Element.matches: :nth-child selector, matching the third child element (with refNode Element): :nth-child(3)

Asserts run

Pass	assert_true(true, "The element #pseudo-nth-td3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)
Pass	assert_true(true, "The element #pseudo-nth-td9 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)
Pass	assert_true(true, "The element #pseudo-nth-tr3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)
Pass	assert_true(true, "The element #pseudo-nth-td15 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)

Pass

In-document Element.matches: :nth-child selector, matching every third child element (with refNode Element): li:nth-child(3n)

Asserts run

Pass	assert_true(true, "The element #pseudo-nth-li3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)
Pass	assert_true(true, "The element #pseudo-nth-li6 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)
Pass	assert_true(true, "The element #pseudo-nth-li9 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)
Pass	assert_true(true, "The element #pseudo-nth-li12 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)

Pass

In-document Element.matches: :nth-child selector, matching every second child element, starting from the fourth (with refNode Element): li:nth-child(2n+4)

Asserts run

Pass	assert_true(true, "The element #pseudo-nth-li4 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)
Pass	assert_true(true, "The element #pseudo-nth-li6 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)
Pass	assert_true(true, "The element #pseudo-nth-li8 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)
Pass	assert_true(true, "The element #pseudo-nth-li10 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)
Pass	assert_true(true, "The element #pseudo-nth-li12 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)

Pass

In-document Element.matches: :nth-child selector, matching every second child element, starting from the fourth, with whitespace (with refNode Element): li:nth-child(2n + 4)

Asserts run

Pass	assert_true(true, "The element #pseudo-nth-li4 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)
Pass	assert_true(true, "The element #pseudo-nth-li6 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)
Pass	assert_true(true, "The element #pseudo-nth-li8 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)
Pass	assert_true(true, "The element #pseudo-nth-li10 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)
Pass	assert_true(true, "The element #pseudo-nth-li12 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)

Pass

In-document Element.matches: :nth-child selector, matching every fourth child element, starting from the third (with refNode Element): :nth-child(4n-1)

Asserts run

Pass

assert_true(true, "The element #pseudo-nth-em2 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)

Pass

assert_true(true, "The element #pseudo-nth-span3 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)

Pass

In-document Element.matches: :nth-child selector, matching every fourth child element, starting from the third, with whitespace (with refNode Element): :nth-child(4n - 1)

Asserts run

Pass

assert_true(true, "The element #pseudo-nth-em2 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)

Pass

assert_true(true, "The element #pseudo-nth-span3 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)

Pass

In-document Element.matches: :nth-child selector used twice, matching (with refNode Element): :nth-child(1) :nth-child(1)

Asserts run

Pass

assert_true(true, "The element #pseudo-nth-table1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)

Pass

assert_true(true, "The element #pseudo-nth-tr1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)

Pass

In-document Element.matches: :nth-last-child selector, matching the third last child element (with refNode Element): :nth-last-child(3)

Asserts run

Pass	assert_true(true, "The element #pseudo-nth-tr1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)
Pass	assert_true(true, "The element #pseudo-nth-td4 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)
Pass	assert_true(true, "The element #pseudo-nth-td10 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)
Pass	assert_true(true, "The element #pseudo-nth-td16 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)

Pass

In-document Element.matches: :nth-last-child selector, matching every third child element from the end (with refNode Element): li:nth-last-child(3n)

Asserts run

Pass	assert_true(true, "The element #pseudo-nth-li1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)
Pass	assert_true(true, "The element #pseudo-nth-li4 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)
Pass	assert_true(true, "The element #pseudo-nth-li7 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)
Pass	assert_true(true, "The element #pseudo-nth-li10 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)

Pass

In-document Element.matches: :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)

Asserts run

Pass	assert_true(true, "The element #pseudo-nth-li1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)
Pass	assert_true(true, "The element #pseudo-nth-li3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)
Pass	assert_true(true, "The element #pseudo-nth-li5 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)
Pass	assert_true(true, "The element #pseudo-nth-li7 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)
Pass	assert_true(true, "The element #pseudo-nth-li9 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)

Pass

In-document Element.matches: :nth-last-child selector, matching every fourth element from the end, starting from the third last (with refNode Element): :nth-last-child(4n-1)

Asserts run

Pass

assert_true(true, "The element #pseudo-nth-span2 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)

Pass

assert_true(true, "The element #pseudo-nth-span4 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)

Pass

In-document Element.matches: :nth-of-type selector, matching the third em element (with refNode Element): em:nth-of-type(3)

Asserts run

Pass	assert_true(true, "The element #pseudo-nth-em3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)

Pass

In-document Element.matches: :nth-of-type selector, matching every second element of their type (with refNode Element): :nth-of-type(2n)

Asserts run

Pass	assert_true(true, "The element #pseudo-nth-em2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)
Pass	assert_true(true, "The element #pseudo-nth-span2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)
Pass	assert_true(true, "The element #pseudo-nth-span4 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)
Pass	assert_true(true, "The element #pseudo-nth-strong2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)
Pass	assert_true(true, "The element #pseudo-nth-em4 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)

Pass

In-document Element.matches: :nth-of-type selector, matching every second elemetn of their type, starting from the first (with refNode Element): span:nth-of-type(2n-1)

Asserts run

Pass

assert_true(true, "The element #pseudo-nth-span1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)

Pass

assert_true(true, "The element #pseudo-nth-span3 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)

Pass

In-document Element.matches: :nth-last-of-type selector, matching the third last em element (with refNode Element): em:nth-last-of-type(3)

Asserts run

Pass	assert_true(true, "The element #pseudo-nth-em2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)

Pass

In-document Element.matches: :nth-last-of-type selector, matching every second last element of their type (with refNode Element): :nth-last-of-type(2n)

Asserts run

Pass	assert_true(true, "The element #pseudo-nth-span1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)
Pass	assert_true(true, "The element #pseudo-nth-em1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)
Pass	assert_true(true, "The element #pseudo-nth-strong1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)
Pass	assert_true(true, "The element #pseudo-nth-em3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)
Pass	assert_true(true, "The element #pseudo-nth-span3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)

Pass

In-document Element.matches: :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)

Asserts run

Pass

assert_true(true, "The element #pseudo-nth-span2 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)

Pass

assert_true(true, "The element #pseudo-nth-span4 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)

Pass

In-document Element.matches: :first-of-type selector, matching the first em element (with refNode Element): em:first-of-type

Asserts run

Pass	assert_true(true, "The element #pseudo-nth-em1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)

Pass

In-document Element.matches: :first-of-type selector, matching the first of every type of element (with refNode Element): :first-of-type

Asserts run

Pass

assert_true(true, "The element #pseudo-nth-span1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)

Pass

assert_true(true, "The element #pseudo-nth-em1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)

Pass

assert_true(true, "The element #pseudo-nth-strong1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)

Pass

In-document Element.matches: :first-of-type selector, matching the first td element in each table row (with refNode Element): tr :first-of-type

Asserts run

Pass

assert_true(true, "The element #pseudo-nth-td1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)

Pass

assert_true(true, "The element #pseudo-nth-td7 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)

Pass

assert_true(true, "The element #pseudo-nth-td13 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)

Pass

In-document Element.matches: :last-of-type selector, matching the last em elemnet (with refNode Element): em:last-of-type

Asserts run

Pass	assert_true(true, "The element #pseudo-nth-em4 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)

Pass

In-document Element.matches: :last-of-type selector, matching the last of every type of element (with refNode Element): :last-of-type

Asserts run

Pass

assert_true(true, "The element #pseudo-nth-span4 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)

Pass

assert_true(true, "The element #pseudo-nth-strong2 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)

Pass

assert_true(true, "The element #pseudo-nth-em4 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)

Pass

In-document Element.matches: :last-of-type selector, matching the last td element in each table row (with refNode Element): tr :last-of-type

Asserts run

Pass

assert_true(true, "The element #pseudo-nth-td6 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)

Pass

assert_true(true, "The element #pseudo-nth-td12 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)

Pass

assert_true(true, "The element #pseudo-nth-td18 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)

Pass

In-document Element.matches: :first-child pseudo-class selector, matching first child div element (with refNode Element): div:first-child

Asserts run

Pass	assert_true(true, "The element #pseudo-first-child-div1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)

Pass

In-document Element.matches: :first-child pseudo-class selector, matching first-child of multiple elements (with refNode Element): span:first-child

Asserts run

Pass

assert_true(true, "The element #pseudo-first-child-span1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)

Pass

assert_true(true, "The element #pseudo-first-child-span3 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)

Pass

assert_true(true, "The element #pseudo-first-child-span5 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)

Pass

In-document Element.matches: :last-child pseudo-class selector, matching last child div element (with refNode Element): div:last-child

Asserts run

Pass	assert_true(true, "The element #pseudo-last-child-div3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)

Pass

In-document Element.matches: :last-child pseudo-class selector, matching first-child of multiple elements (with refNode Element): span:last-child

Asserts run

Pass

assert_true(true, "The element #pseudo-last-child-span2 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)

Pass

assert_true(true, "The element #pseudo-last-child-span4 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)

Pass

assert_true(true, "The element #pseudo-last-child-span6 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)

Pass

In-document Element.matches: :pseudo-only-child pseudo-class selector, matching all only-child elements (with refNode Element): :only-child

Asserts run

Pass	assert_true(true, "The element #pseudo-only-span1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)

Pass

In-document Element.matches: :pseudo-only-of-type pseudo-class selector, matching all elements with no siblings of the same type (with refNode Element): :only-of-type

Asserts run

Pass

assert_true(true, "The element #pseudo-only-span1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)

Pass

assert_true(true, "The element #pseudo-only-em1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)

Pass

In-document Element.matches: :pseudo-only-of-type pseudo-class selector, matching em elements with no siblings of the same type (with refNode Element): em:only-of-type

Asserts run

Pass	assert_true(true, "The element #pseudo-only-em1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)

Pass

In-document Element.matches: :empty pseudo-class selector, matching empty p elements (with refNode Element): p:empty

Asserts run

Pass

assert_true(true, "The element #pseudo-empty-p1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)

Pass

assert_true(true, "The element #pseudo-empty-p2 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)

Pass

In-document Element.matches: :empty pseudo-class selector, matching all empty elements (with refNode Element): :empty

Asserts run

Pass

assert_true(true, "The element #pseudo-empty-p1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)

Pass

assert_true(true, "The element #pseudo-empty-p2 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)

Pass

assert_true(true, "The element #pseudo-empty-span1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)

Pass

In-document Element.matches: :link and :visited pseudo-class selectors, matching a and area elements with href attributes (with refNode Element): :link, #pseudo-link :visited

Asserts run

Pass

assert_true(true, "The element #pseudo-link-a1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)

Pass

assert_true(true, "The element #pseudo-link-a2 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)

Pass

assert_true(true, "The element #pseudo-link-area1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:86:13)

Pass

In-document Element.matches: :link and :visited pseudo-class selectors, matching no elements (with refNode Element): :link, #head :visited

Asserts run

No asserts ran

Pass

In-document Element.matches: :lang pseudo-class selector, matching inherited language (1) (with no refNodes): #pseudo-lang-div1:lang(en)

Asserts run

Pass	assert_true(true, "The element #pseudo-lang-div1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: :lang pseudo-class selector, matching specified language with exact value (1) (with no refNodes): #pseudo-lang-div2:lang(fr)

Asserts run

Pass	assert_true(true, "The element #pseudo-lang-div2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: :lang pseudo-class selector, matching specified language with partial value (1) (with no refNodes): #pseudo-lang-div3:lang(en)

Asserts run

Pass	assert_true(true, "The element #pseudo-lang-div3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: :enabled pseudo-class selector, matching all enabled form controls (1) (with no refNodes): #pseudo-ui :enabled

Asserts run

Pass	assert_true(true, "The element #pseudo-ui-input1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-ui-input2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-ui-input3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-ui-input4 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-ui-input5 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-ui-input6 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-ui-input7 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-ui-input8 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-ui-input9 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-ui-textarea1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-ui-button1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: :enabled pseudo-class selector, not matching link elements (1) (with no refNodes): #pseudo-link :enabled

Asserts run

Pass	assert_false(false, "The element #pseudo-link-a1 should not match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:128:15)
Pass	assert_false(false, "The element #pseudo-link-a2 should not match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:128:15)
Pass	assert_false(false, "The element #pseudo-link-a3 should not match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:128:15)
Pass	assert_false(false, "The element #pseudo-link-map1 should not match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:128:15)
Pass	assert_false(false, "The element #pseudo-link-area1 should not match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:128:15)
Pass	assert_false(false, "The element #pseudo-link-area2 should not match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:128:15)

Pass

In-document Element.matches: :disabled pseudo-class selector, matching all disabled form controls (1) (with no refNodes): #pseudo-ui :disabled

Asserts run

Pass	assert_true(true, "The element #pseudo-ui-input10 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-ui-input11 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-ui-input12 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-ui-input13 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-ui-input14 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-ui-input15 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-ui-input16 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-ui-input17 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-ui-input18 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-ui-textarea2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-ui-button2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: :disabled pseudo-class selector, not matching link elements (1) (with no refNodes): #pseudo-link :disabled

Asserts run

Pass	assert_false(false, "The element #pseudo-link-a1 should not match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:128:15)
Pass	assert_false(false, "The element #pseudo-link-a2 should not match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:128:15)
Pass	assert_false(false, "The element #pseudo-link-a3 should not match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:128:15)
Pass	assert_false(false, "The element #pseudo-link-map1 should not match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:128:15)
Pass	assert_false(false, "The element #pseudo-link-area1 should not match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:128:15)
Pass	assert_false(false, "The element #pseudo-link-area2 should not match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:128:15)

Pass

In-document Element.matches: :checked pseudo-class selector, matching checked radio buttons and checkboxes (1) (with no refNodes): #pseudo-ui :checked

Asserts run

Pass	assert_true(true, "The element #pseudo-ui-input4 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-ui-input6 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-ui-input13 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #pseudo-ui-input15 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: :not pseudo-class selector, matching (1) (with no refNodes): #not>:not(div)

Asserts run

Pass

assert_true(true, "The element #not-p1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #not-p2 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #not-p3 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: :not pseudo-class selector, matching (1) (with no refNodes): #not * :not(:first-child)

Asserts run

Pass

assert_true(true, "The element #not-em1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #not-em2 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #not-em3 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: Class selector, matching element with specified class (1) (with no refNodes): .class-p

Asserts run

Pass

assert_true(true, "The element #class-p1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #class-p2 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #class-p3 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: Class selector, chained, matching only elements with all specified classes (1) (with no refNodes): #class .apple.orange.banana

Asserts run

Pass	assert_true(true, "The element #class-div1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #class-div2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #class-p4 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #class-div3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #class-p6 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #class-div4 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: Class Selector, chained, with type selector (1) (with no refNodes): div.apple.banana.orange

Asserts run

Pass	assert_true(true, "The element #class-div1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #class-div2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #class-div3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #class-div4 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: Class selector, matching element with class value using non-ASCII characters (2) (with no refNodes): .台北Táiběi

Asserts run

Pass	assert_true(true, "The element #class-span1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: Class selector, matching multiple elements with class value using non-ASCII characters (1) (with no refNodes): .台北

Asserts run

Pass

assert_true(true, "The element #class-span1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #class-span2 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: Class selector, chained, matching element with multiple class values using non-ASCII characters (2) (with no refNodes): .台北Táiběi.台北

Asserts run

Pass	assert_true(true, "The element #class-span1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: Class selector, matching element with class with escaped character (1) (with no refNodes): .foo\:bar

Asserts run

Pass	assert_true(true, "The element #class-span3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

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

Asserts run

Pass	assert_true(true, "The element #class-span4 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: ID selector, matching element with specified id (1) (with no refNodes): #id #id-div1

Asserts run

Pass	assert_true(true, "The element #id-div1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: ID selector, chained, matching element with specified id (1) (with no refNodes): #id-div1, #id-div1

Asserts run

Pass	assert_true(true, "The element #id-div1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: ID selector, chained, matching element with specified id (1) (with no refNodes): #id-div1, #id-div2

Asserts run

Pass

assert_true(true, "The element #id-div1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #id-div2 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: ID Selector, chained, with type selector (1) (with no refNodes): div#id-div1, div#id-div2

Asserts run

Pass

assert_true(true, "The element #id-div1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #id-div2 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: ID selector, matching multiple elements with duplicate id (1) (with no refNodes): #id-li-duplicate

Asserts run

Pass	assert_true(true, "The element #id-li-duplicate should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #id-li-duplicate should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #id-li-duplicate should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #id-li-duplicate should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: ID selector, matching id value using non-ASCII characters (3) (with no refNodes): #台北Táiběi

Asserts run

Pass	assert_true(true, "The element #台北Táiběi should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: ID selector, matching id value using non-ASCII characters (4) (with no refNodes): #台北

Asserts run

Pass	assert_true(true, "The element #台北 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: ID selector, matching id values using non-ASCII characters (2) (with no refNodes): #台北Táiběi, #台北

Asserts run

Pass

assert_true(true, "The element #台北Táiběi should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #台北 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: Descendant combinator, matching element that is a descendant of an element with id (1) (with no refNodes): #descendant div

Asserts run

Pass	assert_true(true, "The element #descendant-div1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #descendant-div2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #descendant-div3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)
Pass	assert_true(true, "The element #descendant-div4 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: Descendant combinator, matching element with id that is a descendant of an element (1) (with no refNodes): body #descendant-div1

Asserts run

Pass	assert_true(true, "The element #descendant-div1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: Descendant combinator, matching element with id that is a descendant of an element (1) (with no refNodes): div #descendant-div1

Asserts run

Pass	assert_true(true, "The element #descendant-div1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: Descendant combinator, matching element with id that is a descendant of an element with id (1) (with no refNodes): #descendant #descendant-div2

Asserts run

Pass	assert_true(true, "The element #descendant-div2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: Descendant combinator, matching element with class that is a descendant of an element with id (1) (with no refNodes): #descendant .descendant-div2

Asserts run

Pass	assert_true(true, "The element #descendant-div2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: Descendant combinator, matching element with class that is a descendant of an element with class (1) (with no refNodes): .descendant-div1 .descendant-div3

Asserts run

Pass	assert_true(true, "The element #descendant-div3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: Descendant combinator, whitespace characters (1) (with no refNodes): #descendant #descendant-div2

Asserts run

Pass	assert_true(true, "The element #descendant-div2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: Child combinator, matching element that is a child of an element with id (1) (with no refNodes): #child>div

Asserts run

Pass

assert_true(true, "The element #child-div1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #child-div4 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: Child combinator, matching element with id that is a child of an element (1) (with no refNodes): div>#child-div1

Asserts run

Pass	assert_true(true, "The element #child-div1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: Child combinator, matching element with id that is a child of an element with id (1) (with no refNodes): #child>#child-div1

Asserts run

Pass	assert_true(true, "The element #child-div1 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: Child combinator, matching element with id that is a child of an element with class (1) (with no refNodes): #child-div1>.child-div2

Asserts run

Pass	assert_true(true, "The element #child-div2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: Child combinator, matching element with class that is a child of an element with class (1) (with no refNodes): .child-div1>.child-div2

Asserts run

Pass	assert_true(true, "The element #child-div2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: Child combinator, surrounded by whitespace (1) (with no refNodes): #child-div1 > #child-div2

Asserts run

Pass	assert_true(true, "The element #child-div2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: Child combinator, whitespace after (1) (with no refNodes): #child-div1> #child-div2

Asserts run

Pass	assert_true(true, "The element #child-div2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: Child combinator, whitespace before (1) (with no refNodes): #child-div1 >#child-div2

Asserts run

Pass	assert_true(true, "The element #child-div2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: Child combinator, no whitespace (1) (with no refNodes): #child-div1>#child-div2

Asserts run

Pass	assert_true(true, "The element #child-div2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: Adjacent sibling combinator, matching element that is an adjacent sibling of an element with id (1) (with no refNodes): #adjacent-div2+div

Asserts run

Pass	assert_true(true, "The element #adjacent-div4 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: Adjacent sibling combinator, matching element with id that is an adjacent sibling of an element (1) (with no refNodes): div+#adjacent-div4

Asserts run

Pass	assert_true(true, "The element #adjacent-div4 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: 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

Asserts run

Pass	assert_true(true, "The element #adjacent-div4 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: 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

Asserts run

Pass	assert_true(true, "The element #adjacent-div4 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: 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

Asserts run

Pass	assert_true(true, "The element #adjacent-div4 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: Adjacent sibling combinator, matching p element that is an adjacent sibling of a div element (1) (with no refNodes): #adjacent div+p

Asserts run

Pass	assert_true(true, "The element #adjacent-p2 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: Adjacent sibling combinator, surrounded by whitespace (1) (with no refNodes): #adjacent-p2 + #adjacent-p3

Asserts run

Pass	assert_true(true, "The element #adjacent-p3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: Adjacent sibling combinator, whitespace after (1) (with no refNodes): #adjacent-p2+ #adjacent-p3

Asserts run

Pass	assert_true(true, "The element #adjacent-p3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: Adjacent sibling combinator, whitespace before (1) (with no refNodes): #adjacent-p2 +#adjacent-p3

Asserts run

Pass	assert_true(true, "The element #adjacent-p3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: Adjacent sibling combinator, no whitespace (1) (with no refNodes): #adjacent-p2+#adjacent-p3

Asserts run

Pass	assert_true(true, "The element #adjacent-p3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: General sibling combinator, matching element that is a sibling of an element with id (1) (with no refNodes): #sibling-div2~div

Asserts run

Pass

assert_true(true, "The element #sibling-div4 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #sibling-div6 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: General sibling combinator, matching element with id that is a sibling of an element (1) (with no refNodes): div~#sibling-div4

Asserts run

Pass	assert_true(true, "The element #sibling-div4 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: General sibling combinator, matching element with id that is a sibling of an element with id (1) (with no refNodes): #sibling-div2~#sibling-div4

Asserts run

Pass	assert_true(true, "The element #sibling-div4 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: General sibling combinator, matching element with class that is a sibling of an element with id (1) (with no refNodes): #sibling-div2~.sibling-div

Asserts run

Pass

assert_true(true, "The element #sibling-div4 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #sibling-div6 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: General sibling combinator, matching p element that is a sibling of a div element (1) (with no refNodes): #sibling div~p

Asserts run

Pass

assert_true(true, "The element #sibling-p2 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #sibling-p3 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: General sibling combinator, surrounded by whitespace (1) (with no refNodes): #sibling-p2 ~ #sibling-p3

Asserts run

Pass	assert_true(true, "The element #sibling-p3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: General sibling combinator, whitespace after (1) (with no refNodes): #sibling-p2~ #sibling-p3

Asserts run

Pass	assert_true(true, "The element #sibling-p3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: General sibling combinator, whitespace before (1) (with no refNodes): #sibling-p2 ~#sibling-p3

Asserts run

Pass	assert_true(true, "The element #sibling-p3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: General sibling combinator, no whitespace (1) (with no refNodes): #sibling-p2~#sibling-p3

Asserts run

Pass	assert_true(true, "The element #sibling-p3 should match the selector.") at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: Syntax, group of selectors separator, surrounded by whitespace (1) (with no refNodes): #group em , #group strong

Asserts run

Pass

assert_true(true, "The element #group-em1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #group-strong1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: Syntax, group of selectors separator, whitespace after (1) (with no refNodes): #group em, #group strong

Asserts run

Pass

assert_true(true, "The element #group-em1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #group-strong1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: Syntax, group of selectors separator, whitespace before (1) (with no refNodes): #group em ,#group strong

Asserts run

Pass

assert_true(true, "The element #group-em1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #group-strong1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

In-document Element.matches: Syntax, group of selectors separator, no whitespace (1) (with no refNodes): #group em,#group strong

Asserts run

Pass

assert_true(true, "The element #group-em1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)

Pass

assert_true(true, "The element #group-strong1 should match the selector.")
    at Test.<anonymous> ( /dom/nodes/Element-matches.js:122:13)