Mirrors/servo
1
0
Fork 0
mirror of https://github.com/servo/servo.git synced 2025-09-05 20:48:22 +01:00
Code Issues Projects Releases Packages Wiki Activity

Update web-platform-tests to revision 58133dd71b16037669a0aa011b2afd448b52d434.

Browse source
This commit is contained in:
Ms2ger 2015-08-11 17:14:59 +02:00
parent 84c4a26e4d
commit 88ea7c4291
192 changed files with 50802 additions and 1334 deletions
Download patch file Download diff file Expand all files Collapse all files

29
tests/wpt/web-platform-tests/dom/traversal/NodeIterator.html
View file

@ -9,6 +9,22 @@
<script>
"use strict";
function check_iter(iter, root, whatToShowValue) {
whatToShowValue = whatToShowValue === undefined ? 0xFFFFFFFF : whatToShowValue;
assert_equals(iter.toString(), '[object NodeIterator]', 'toString');
assert_equals(iter.root, root, 'root');
assert_equals(iter.whatToShow, whatToShowValue, 'whatToShow');
assert_equals(iter.filter, null, 'filter');
assert_equals(iter.referenceNode, root, 'referenceNode');
assert_equals(iter.pointerBeforeReferenceNode, true, 'pointerBeforeReferenceNode');
assert_readonly(iter, 'root');
assert_readonly(iter, 'whatToShow');
assert_readonly(iter, 'filter');
assert_readonly(iter, 'referenceNode');
assert_readonly(iter, 'pointerBeforeReferenceNode');
}
test(function() {
var iter = document.createNodeIterator(document);
iter.detach();
@ -17,10 +33,19 @@ test(function() {
test(function() {
var iter = document.createNodeIterator(document);
assert_equals(iter.whatToShow, 0xFFFFFFFF, "whatToShow");
assert_equals(iter.filter, null, "filter");
check_iter(iter, document);
}, "createNodeIterator() parameter defaults");
test(function() {
var iter = document.createNodeIterator(document, null, null);
check_iter(iter, document, 0);
}, "createNodeIterator() with null as arguments");
test(function() {
var iter = document.createNodeIterator(document, undefined, undefined);
check_iter(iter, document);
}, "createNodeIterator() with undefined as arguments");
test(function() {
var iter = document.createNodeIterator(document, NodeFilter.SHOW_ALL,
function() { throw {name: "failed"} });

34
tests/wpt/web-platform-tests/dom/traversal/TreeWalker-acceptNode-filter.html
View file

@ -37,11 +37,11 @@ test(function()
function filter(node)
{
if (node.id == "B1")
return /*NodeFilter.*/FILTER_SKIP;
return /*NodeFilter.*/FILTER_ACCEPT;
return NodeFilter.FILTER_SKIP;
return NodeFilter.FILTER_ACCEPT;
}
var walker = document.createTreeWalker(testElement, /*NodeFilter.*/SHOW_ELEMENT, filter);
var walker = document.createTreeWalker(testElement, NodeFilter.SHOW_ELEMENT, filter);
assert_node(walker.currentNode, { type: Element, id: 'root' });
assert_node(walker.firstChild(), { type: Element, id: 'A1' });
assert_node(walker.currentNode, { type: Element, id: 'A1' });
@ -51,11 +51,11 @@ test(function()
test(function()
{
var walker = document.createTreeWalker(testElement, /*NodeFilter.*/SHOW_ELEMENT, {
var walker = document.createTreeWalker(testElement, NodeFilter.SHOW_ELEMENT, {
acceptNode : function(node) {
if (node.id == "B1")
return /*NodeFilter.*/FILTER_SKIP;
return /*NodeFilter.*/FILTER_ACCEPT;
return NodeFilter.FILTER_SKIP;
return NodeFilter.FILTER_ACCEPT;
}
});
assert_node(walker.currentNode, { type: Element, id: 'root' });
@ -67,7 +67,7 @@ test(function()
test(function()
{
var walker = document.createTreeWalker(testElement, /*NodeFilter.*/SHOW_ELEMENT, null);
var walker = document.createTreeWalker(testElement, NodeFilter.SHOW_ELEMENT, null);
assert_node(walker.currentNode, { type: Element, id: 'root' });
assert_node(walker.firstChild(), { type: Element, id: 'A1' });
assert_node(walker.currentNode, { type: Element, id: 'A1' });
@ -77,7 +77,7 @@ test(function()
test(function()
{
var walker = document.createTreeWalker(testElement, /*NodeFilter.*/SHOW_ELEMENT, undefined);
var walker = document.createTreeWalker(testElement, NodeFilter.SHOW_ELEMENT, undefined);
assert_node(walker.currentNode, { type: Element, id: 'root' });
assert_node(walker.firstChild(), { type: Element, id: 'A1' });
assert_node(walker.currentNode, { type: Element, id: 'A1' });
@ -87,7 +87,7 @@ test(function()
test(function()
{
var walker = document.createTreeWalker(testElement, /*NodeFilter.*/SHOW_ELEMENT, {});
var walker = document.createTreeWalker(testElement, NodeFilter.SHOW_ELEMENT, {});
assert_throws(new TypeError(), function () { walker.firstChild(); });
assert_node(walker.currentNode, { type: Element, id: 'root' });
assert_throws(new TypeError(), function () { walker.nextNode(); });
@ -96,7 +96,7 @@ test(function()
test(function()
{
var walker = document.createTreeWalker(testElement, /*NodeFilter.*/SHOW_ELEMENT, { acceptNode: "foo" });
var walker = document.createTreeWalker(testElement, NodeFilter.SHOW_ELEMENT, { acceptNode: "foo" });
assert_throws(new TypeError(), function () { walker.firstChild(); });
assert_node(walker.currentNode, { type: Element, id: 'root' });
assert_throws(new TypeError(), function () { walker.nextNode(); });
@ -105,9 +105,9 @@ test(function()
test(function()
{
var filter = function() { return /*NodeFilter.*/FILTER_ACCEPT; };
filter.acceptNode = function(node) { return /*NodeFilter.*/FILTER_SKIP; };
var walker = document.createTreeWalker(testElement, /*NodeFilter.*/SHOW_ELEMENT, filter);
var filter = function() { return NodeFilter.FILTER_ACCEPT; };
filter.acceptNode = function(node) { return NodeFilter.FILTER_SKIP; };
var walker = document.createTreeWalker(testElement, NodeFilter.SHOW_ELEMENT, filter);
assert_node(walker.firstChild(), { type: Element, id: 'A1' });
assert_node(walker.nextNode(), { type: Element, id: 'B1' });
}, 'Testing with function having acceptNode function');
@ -116,17 +116,17 @@ test(function()
{
var filter = {
acceptNode: function(node) {
return /*NodeFilter.*/FILTER_ACCEPT;
return NodeFilter.FILTER_ACCEPT;
}
};
var walker = document.createTreeWalker(testElement, /*NodeFilter.*/SHOW_ELEMENT, filter);
var walker = document.createTreeWalker(testElement, NodeFilter.SHOW_ELEMENT, filter);
assert_node(walker.firstChild(), { type: Element, id: 'A1' });
}, 'Testing acceptNode callee');
test(function()
{
var test_error = { name: "test" };
var walker = document.createTreeWalker(testElement, /*NodeFilter.*/SHOW_ELEMENT,
var walker = document.createTreeWalker(testElement, NodeFilter.SHOW_ELEMENT,
function(node) {
throw test_error;
});
@ -139,7 +139,7 @@ test(function()
test(function()
{
var test_error = { name: "test" };
var walker = document.createTreeWalker(testElement, /*NodeFilter.*/SHOW_ELEMENT,
var walker = document.createTreeWalker(testElement, NodeFilter.SHOW_ELEMENT,
{
acceptNode : function(node) {
throw test_error;

21
tests/wpt/web-platform-tests/dom/traversal/TreeWalker-basic.html
View file

@ -70,13 +70,15 @@ function createSampleDOM()
return div;
}
function check_walker(walker, root)
function check_walker(walker, root, whatToShowValue)
{
assert_equals(walker.toString(), '[object TreeWalker]');
assert_equals(walker.root, root);
assert_equals(walker.whatToShow, 0xFFFFFFFF);
assert_equals(walker.filter, null);
assert_equals(walker.currentNode, root);
whatToShowValue = whatToShowValue === undefined ? 0xFFFFFFFF : whatToShowValue;
assert_equals(walker.toString(), '[object TreeWalker]', 'toString');
assert_equals(walker.root, root, 'root');
assert_equals(walker.whatToShow, whatToShowValue, 'whatToShow');
assert_equals(walker.filter, null, 'filter');
assert_equals(walker.currentNode, root, 'currentNode');
assert_readonly(walker, 'root');
assert_readonly(walker, 'whatToShow');
assert_readonly(walker, 'filter');
@ -89,6 +91,13 @@ test(function ()
check_walker(walker, root);
}, 'Construct a TreeWalker by document.createTreeWalker(root).');
test(function ()
{
var root = createSampleDOM();
var walker = document.createTreeWalker(root, null, null);
check_walker(walker, root, 0);
}, 'Construct a TreeWalker by document.createTreeWalker(root, null, null).');
test(function ()
{
var root = createSampleDOM();

8
tests/wpt/web-platform-tests/dom/traversal/TreeWalker-currentNode.html
View file

@ -26,7 +26,7 @@ var all = function(node) { return true; }
test(function()
{
var w = document.createTreeWalker(subTree, /*NodeFilter.*/SHOW_ELEMENT, all);
var w = document.createTreeWalker(subTree, NodeFilter.SHOW_ELEMENT, all);
assert_node(w.currentNode, { type: Element, id: 'subTree' });
assert_equals(w.parentNode(), null);
assert_node(w.currentNode, { type: Element, id: 'subTree' });
@ -35,8 +35,8 @@ test(function()
test(function()
{
var w = document.createTreeWalker(subTree,
/*NodeFilter.*/SHOW_ELEMENT
| /*NodeFilter.*/SHOW_COMMENT,
NodeFilter.SHOW_ELEMENT
| NodeFilter.SHOW_COMMENT,
all);
w.currentNode = document.documentElement;
assert_equals(w.parentNode(), null);
@ -63,7 +63,7 @@ test(function()
test(function()
{
var w = document.createTreeWalker(subTree, /*NodeFilter.*/SHOW_ELEMENT, all);
var w = document.createTreeWalker(subTree, NodeFilter.SHOW_ELEMENT, all);
w.currentNode = subTree.previousSibling;
assert_equals(w.nextNode(), subTree);
w.currentNode = document.getElementById("parent");

6
tests/wpt/web-platform-tests/dom/traversal/TreeWalker-previousNodeLastChildReject.html
View file

@ -66,11 +66,11 @@ test(function()
function filter(node)
{
if (node.id == "C2")
return /*NodeFilter.*/FILTER_REJECT;
return /*NodeFilter.*/FILTER_ACCEPT;
return NodeFilter.FILTER_REJECT;
return NodeFilter.FILTER_ACCEPT;
}
var walker = document.createTreeWalker(testElement, /*NodeFilter.*/SHOW_ELEMENT, filter);
var walker = document.createTreeWalker(testElement, NodeFilter.SHOW_ELEMENT, filter);
assert_node(walker.currentNode, { type: Element, id: 'root' });
assert_node(walker.firstChild(), { type: Element, id: 'A1' });
assert_node(walker.currentNode, { type: Element, id: 'A1' });

6
tests/wpt/web-platform-tests/dom/traversal/TreeWalker-previousSiblingLastChildSkip.html
View file

@ -66,11 +66,11 @@ test(function()
function filter(node)
{
if (node.id == "B1")
return /*NodeFilter.*/FILTER_SKIP;
return /*NodeFilter.*/FILTER_ACCEPT;
return NodeFilter.FILTER_SKIP;
return NodeFilter.FILTER_ACCEPT;
}
var walker = document.createTreeWalker(testElement, /*NodeFilter.*/SHOW_ELEMENT, filter);
var walker = document.createTreeWalker(testElement, NodeFilter.SHOW_ELEMENT, filter);
assert_node(walker.currentNode, { type: Element, id: 'root' });
assert_node(walker.firstChild(), { type: Element, id: 'A1' });
assert_node(walker.currentNode, { type: Element, id: 'A1' });

20
tests/wpt/web-platform-tests/dom/traversal/TreeWalker-traversal-reject.html
View file

@ -45,24 +45,24 @@ setup(function() {
var rejectB1Filter = {
acceptNode: function(node) {
if (node.id == 'B1')
return /*NodeFilter.*/FILTER_REJECT;
return NodeFilter.FILTER_REJECT;
return /*NodeFilter.*/FILTER_ACCEPT;
return NodeFilter.FILTER_ACCEPT;
}
}
var skipB2Filter = {
acceptNode: function(node) {
if (node.id == 'B2')
return /*NodeFilter.*/FILTER_SKIP;
return NodeFilter.FILTER_SKIP;
return /*NodeFilter.*/FILTER_ACCEPT;
return NodeFilter.FILTER_ACCEPT;
}
}
test(function()
{
var walker = document.createTreeWalker(testElement, /*NodeFilter.*/SHOW_ELEMENT, rejectB1Filter);
var walker = document.createTreeWalker(testElement, NodeFilter.SHOW_ELEMENT, rejectB1Filter);
assert_node(walker.nextNode(), { type: Element, id: 'A1' });
assert_node(walker.nextNode(), { type: Element, id: 'B2' });
assert_node(walker.nextNode(), { type: Element, id: 'B3' });
@ -70,14 +70,14 @@ test(function()
test(function()
{
var walker = document.createTreeWalker(testElement, /*NodeFilter.*/SHOW_ELEMENT, rejectB1Filter);
var walker = document.createTreeWalker(testElement, NodeFilter.SHOW_ELEMENT, rejectB1Filter);
assert_node(walker.firstChild(), { type: Element, id: 'A1' });
assert_node(walker.firstChild(), { type: Element, id: 'B2' });
}, 'Testing firstChild');
test(function()
{
var walker = document.createTreeWalker(testElement, /*NodeFilter.*/SHOW_ELEMENT, skipB2Filter);
var walker = document.createTreeWalker(testElement, NodeFilter.SHOW_ELEMENT, skipB2Filter);
assert_node(walker.firstChild(), { type: Element, id: 'A1' });
assert_node(walker.firstChild(), { type: Element, id: 'B1' });
assert_node(walker.nextSibling(), { type: Element, id: 'B3' });
@ -85,21 +85,21 @@ test(function()
test(function()
{
var walker = document.createTreeWalker(testElement, /*NodeFilter.*/SHOW_ELEMENT, rejectB1Filter);
var walker = document.createTreeWalker(testElement, NodeFilter.SHOW_ELEMENT, rejectB1Filter);
walker.currentNode = testElement.querySelectorAll('#C1')[0];
assert_node(walker.parentNode(), { type: Element, id: 'A1' });
}, 'Testing parentNode');
test(function()
{
var walker = document.createTreeWalker(testElement, /*NodeFilter.*/SHOW_ELEMENT, skipB2Filter);
var walker = document.createTreeWalker(testElement, NodeFilter.SHOW_ELEMENT, skipB2Filter);
walker.currentNode = testElement.querySelectorAll('#B3')[0];
assert_node(walker.previousSibling(), { type: Element, id: 'B1' });
}, 'Testing previousSibling');
test(function()
{
var walker = document.createTreeWalker(testElement, /*NodeFilter.*/SHOW_ELEMENT, rejectB1Filter);
var walker = document.createTreeWalker(testElement, NodeFilter.SHOW_ELEMENT, rejectB1Filter);
walker.currentNode = testElement.querySelectorAll('#B3')[0];
assert_node(walker.previousNode(), { type: Element, id: 'B2' });
assert_node(walker.previousNode(), { type: Element, id: 'A1' });

8
tests/wpt/web-platform-tests/dom/traversal/TreeWalker-traversal-skip-most.html
View file

@ -42,22 +42,22 @@ setup(function() {
var filter = {
acceptNode: function(node) {
if (node.className == 'keep')
return /*NodeFilter.*/FILTER_ACCEPT;
return NodeFilter.FILTER_ACCEPT;
return /*NodeFilter.*/FILTER_SKIP;
return NodeFilter.FILTER_SKIP;
}
}
test(function()
{
var walker = document.createTreeWalker(testElement, /*NodeFilter.*/SHOW_ELEMENT, filter);
var walker = document.createTreeWalker(testElement, NodeFilter.SHOW_ELEMENT, filter);
assert_node(walker.firstChild(), { type: Element, id: 'B1' });
assert_node(walker.nextSibling(), { type: Element, id: 'B3' });
}, 'Testing nextSibling');
test(function()
{
var walker = document.createTreeWalker(testElement, /*NodeFilter.*/SHOW_ELEMENT, filter);
var walker = document.createTreeWalker(testElement, NodeFilter.SHOW_ELEMENT, filter);
walker.currentNode = testElement.querySelectorAll('#B3')[0];
assert_node(walker.previousSibling(), { type: Element, id: 'B1' });
}, 'Testing previousSibling');

20
tests/wpt/web-platform-tests/dom/traversal/TreeWalker-traversal-skip.html
View file

@ -45,24 +45,24 @@ setup(function() {
var skipB1Filter = {
acceptNode: function(node) {
if (node.id == 'B1')
return /*NodeFilter.*/FILTER_SKIP;
return NodeFilter.FILTER_SKIP;
return /*NodeFilter.*/FILTER_ACCEPT;
return NodeFilter.FILTER_ACCEPT;
}
}
var skipB2Filter = {
acceptNode: function(node) {
if (node.id == 'B2')
return /*NodeFilter.*/FILTER_SKIP;
return NodeFilter.FILTER_SKIP;
return /*NodeFilter.*/FILTER_ACCEPT;
return NodeFilter.FILTER_ACCEPT;
}
}
test(function()
{
var walker = document.createTreeWalker(testElement, /*NodeFilter.*/SHOW_ELEMENT, skipB1Filter);
var walker = document.createTreeWalker(testElement, NodeFilter.SHOW_ELEMENT, skipB1Filter);
assert_node(walker.nextNode(), { type: Element, id: 'A1' });
assert_node(walker.nextNode(), { type: Element, id: 'C1' });
assert_node(walker.nextNode(), { type: Element, id: 'B2' });
@ -71,14 +71,14 @@ test(function()
test(function()
{
var walker = document.createTreeWalker(testElement, /*NodeFilter.*/SHOW_ELEMENT, skipB1Filter);
var walker = document.createTreeWalker(testElement, NodeFilter.SHOW_ELEMENT, skipB1Filter);
assert_node(walker.firstChild(), { type: Element, id: 'A1' });
assert_node(walker.firstChild(), { type: Element, id: 'C1' });
}, 'Testing firstChild');
test(function()
{
var walker = document.createTreeWalker(testElement, /*NodeFilter.*/SHOW_ELEMENT, skipB2Filter);
var walker = document.createTreeWalker(testElement, NodeFilter.SHOW_ELEMENT, skipB2Filter);
assert_node(walker.firstChild(), { type: Element, id: 'A1' });
assert_node(walker.firstChild(), { type: Element, id: 'B1' });
assert_node(walker.nextSibling(), { type: Element, id: 'B3' });
@ -86,21 +86,21 @@ test(function()
test(function()
{
var walker = document.createTreeWalker(testElement, /*NodeFilter.*/SHOW_ELEMENT, skipB1Filter);
var walker = document.createTreeWalker(testElement, NodeFilter.SHOW_ELEMENT, skipB1Filter);
walker.currentNode = testElement.querySelectorAll('#C1')[0];
assert_node(walker.parentNode(), { type: Element, id: 'A1' });
}, 'Testing parentNode');
test(function()
{
var walker = document.createTreeWalker(testElement, /*NodeFilter.*/SHOW_ELEMENT, skipB2Filter);
var walker = document.createTreeWalker(testElement, NodeFilter.SHOW_ELEMENT, skipB2Filter);
walker.currentNode = testElement.querySelectorAll('#B3')[0];
assert_node(walker.previousSibling(), { type: Element, id: 'B1' });
}, 'Testing previousSibling');
test(function()
{
var walker = document.createTreeWalker(testElement, /*NodeFilter.*/SHOW_ELEMENT, skipB1Filter);
var walker = document.createTreeWalker(testElement, NodeFilter.SHOW_ELEMENT, skipB1Filter);
walker.currentNode = testElement.querySelectorAll('#B3')[0];
assert_node(walker.previousNode(), { type: Element, id: 'B2' });
assert_node(walker.previousNode(), { type: Element, id: 'C1' });

298
tests/wpt/web-platform-tests/dom/traversal/TreeWalker.html Normal file
View file

@ -0,0 +1,298 @@
<!doctype html>
<title>TreeWalker tests</title>
<link rel="author" title="Aryeh Gregor" href=ayg@aryeh.name>
<meta name=timeout content=long>
<div id=log></div>
<script src=/resources/testharness.js></script>
<script src=/resources/testharnessreport.js></script>
<script src=../common.js></script>
<script>
"use strict";
// TODO .previousNode, .nextNode
function filterNode(node, whatToShow, filter) {
// "If active flag is set throw an "InvalidStateError"."
// Ignore active flag for these tests, we aren't calling recursively
// TODO Test me
// "Let n be node's nodeType attribute value minus 1."
var n = node.nodeType - 1;
// "If the nth bit (where 0 is the least significant bit) of whatToShow is
// not set, return FILTER_SKIP."
if (!(whatToShow & (1 << n))) {
return NodeFilter.FILTER_SKIP;
}
// "If filter is null, return FILTER_ACCEPT."
if (!filter) {
return NodeFilter.FILTER_ACCEPT;
}
// "Set the active flag."
//
// "Let result be the return value of invoking filter."
//
// "Unset the active flag."
//
// "If an exception was thrown, re-throw the exception."
// TODO Test me
//
// "Return result."
return filter(node);
}
function testTraverseChildren(type, walker, root, whatToShow, filter) {
// TODO We don't test .currentNode other than the root
walker.currentNode = root;
assert_equals(walker.currentNode, root, "Setting .currentNode");
var expectedReturn = null;
var expectedCurrentNode = root;
// "To traverse children of type type, run these steps:
//
// "Let node be the value of the currentNode attribute."
var node = walker.currentNode;
// "Set node to node's first child if type is first, and node's last child
// if type is last."
node = type == "first" ? node.firstChild : node.lastChild;
// "Main: While node is not null, run these substeps:"
while (node) {
// "Filter node and let result be the return value."
var result = filterNode(node, whatToShow, filter);
// "If result is FILTER_ACCEPT, then set the currentNode attribute to
// node and return node."
if (result == NodeFilter.FILTER_ACCEPT) {
expectedCurrentNode = expectedReturn = node;
break;
}
// "If result is FILTER_SKIP, run these subsubsteps:"
if (result == NodeFilter.FILTER_SKIP) {
// "Let child be node's first child if type is first, and node's
// last child if type is last."
var child = type == "first" ? node.firstChild : node.lastChild;
// "If child is not null, set node to child and goto Main."
if (child) {
node = child;
continue;
}
}
// "While node is not null, run these subsubsteps:"
while (node) {
// "Let sibling be node's next sibling if type is first, and node's
// previous sibling if type is last."
var sibling = type == "first" ? node.nextSibling
: node.previousSibling;
// "If sibling is not null, set node to sibling and goto Main."
if (sibling) {
node = sibling;
break;
}
// "Let parent be node's parent."
var parent = node.parentNode;
// "If parent is null, parent is root, or parent is currentNode
// attribute's value, return null."
if (!parent || parent == root || parent == walker.currentNode) {
expectedReturn = node = null;
break;
} else {
// "Otherwise, set node to parent."
node = parent;
}
}
}
if (type == "first") {
assert_equals(walker.firstChild(), expectedReturn, ".firstChild()");
assert_equals(walker.currentNode, expectedCurrentNode,
".currentNode after .firstChild()");
} else {
assert_equals(walker.lastChild(), expectedReturn, ".lastChild()");
assert_equals(walker.currentNode, expectedCurrentNode,
".currentNode after .lastChild()");
}
}
function testTraverseSiblings(type, walker, root, whatToShow, filter) {
// TODO We don't test .currentNode other than the root's first or last child
if (!root.firstChild) {
// Nothing much to test
walker.currentNode = root;
assert_equals(walker.currentNode, root, "Setting .currentNode");
if (type == "next") {
assert_equals(walker.nextSibling(), null, ".nextSibling()");
assert_equals(walker.currentNode, root,
".currentNode after .nextSibling()")
} else {
assert_equals(walker.previousSibling(), null, ".previousSibling()");
assert_equals(walker.currentNode, root,
".currentNode after .previousSibling()")
}
return;
}
if (type == "next") {
walker.currentNode = root.firstChild;
assert_equals(walker.currentNode, root.firstChild,
"Setting .currentNode");
} else {
walker.currentNode = root.lastChild;
assert_equals(walker.currentNode, root.lastChild,
"Setting .currentNode");
}
var expectedReturn = null;
var expectedCurrentNode = type == "next" ? root.firstChild : root.lastChild;
// "To traverse siblings of type type run these steps:"
(function() {
// "Let node be the value of the currentNode attribute."
var node = type == "next" ? root.firstChild : root.lastChild;
// "If node is root, return null.
//
// "Run these substeps:
do {
// "Let sibling be node's next sibling if type is next, and node's
// previous sibling if type is previous."
var sibling = type == "next" ? node.nextSibling :
node.previousSibling;
// "While sibling is not null, run these subsubsteps:"
while (sibling) {
// "Set node to sibling."
node = sibling;
// "Filter node and let result be the return value."
var result = filterNode(node, whatToShow, filter);
// "If result is FILTER_ACCEPT, then set the currentNode
// attribute to node and return node."
if (result == NodeFilter.FILTER_ACCEPT) {
expectedCurrentNode = expectedReturn = node;
return;
}
// "Set sibling to node's first child if type is next, and
// node's last child if type is previous."
sibling = type == "next" ? node.firstChild : node.lastChild;
// "If result is FILTER_REJECT or sibling is null, then set
// sibling to node's next sibling if type is next, and node's
// previous sibling if type is previous."
if (result == NodeFilter.FILTER_REJECT || !sibling) {
sibling = type == "next" ? node.nextSibling :
node.previousSibling;
}
}
// "Set node to its parent."
node = node.parentNode;
// "If node is null or is root, return null.
if (!node || node == root) {
return;
}
// "Filter node and if the return value is FILTER_ACCEPT, then
// return null."
if (filterNode(node, whatToShow, filter)) {
return;
}
// "Run these substeps again."
} while (true);
})();
if (type == "next") {
assert_equals(walker.nextSibling(), expectedReturn, ".nextSibling()");
assert_equals(walker.currentNode, expectedCurrentNode,
".currentNode after .nextSibling()");
} else {
assert_equals(walker.previousSibling(), expectedReturn, ".previousSibling()");
assert_equals(walker.currentNode, expectedCurrentNode,
".currentNode after .previousSibling()");
}
}
function testWalker(root, whatToShow, filter) {
var walker = document.createTreeWalker(root, whatToShow, filter);
assert_equals(walker.root, root, ".root");
assert_equals(walker.whatToShow, whatToShow, ".whatToShow");
assert_equals(walker.filter, filter, ".filter");
assert_equals(walker.currentNode, root, ".currentNode");
var expectedReturn = null;
var expectedCurrentNode = walker.currentNode;
// "The parentNode() method must run these steps:"
//
// "Let node be the value of the currentNode attribute."
var node = walker.currentNode;
// "While node is not null and is not root, run these substeps:"
while (node && node != root) {
// "Let node be node's parent."
node = node.parentNode;
// "If node is not null and filtering node returns FILTER_ACCEPT, then
// set the currentNode attribute to node, return node."
if (node && filterNode(node, whatToShow, filter) ==
NodeFilter.FILTER_ACCEPT) {
expectedCurrentNode = expectedReturn = node;
}
}
assert_equals(walker.parentNode(), expectedReturn, ".parentNode()");
assert_equals(walker.currentNode, expectedCurrentNode,
".currentNode after .parentNode()");
testTraverseChildren("first", walker, root, whatToShow, filter);
testTraverseChildren("last", walker, root, whatToShow, filter);
testTraverseSiblings("next", walker, root, whatToShow, filter);
testTraverseSiblings("previous", walker, root, whatToShow, filter);
}
var whatToShows = [
"0",
"0xFFFFFFFF",
"NodeFilter.SHOW_ELEMENT",
"NodeFilter.SHOW_ATTRIBUTE",
"NodeFilter.SHOW_ELEMENT | NodeFilter.SHOW_DOCUMENT",
];
var callbacks = [
"null",
"(function(node) { return true })",
"(function(node) { return false })",
"(function(node) { return node.nodeName[0] == '#' })",
];
var tests = [];
for (var i = 0; i < testNodes.length; i++) {
for (var j = 0; j < whatToShows.length; j++) {
for (var k = 0; k < callbacks.length; k++) {
tests.push([
"document.createTreeWalker(" + testNodes[i] +
", " + whatToShows[j] + ", " + callbacks[k] + ")",
eval(testNodes[i]), eval(whatToShows[j]), eval(callbacks[k])
]);
}
}
}
generate_tests(testWalker, tests);
testDiv.style.display = "none";
</script>

18
tests/wpt/web-platform-tests/dom/traversal/traversal-support.js
View file

@ -8,21 +8,3 @@ function assert_node(actual, expected)
if (typeof(expected.nodeValue) !== 'undefined')
assert_equals(actual.nodeValue, expected.nodeValue);
}
// XXX Servo doesn't have these constants in NodeFilter yet
var FILTER_ACCEPT = 1;
var FILTER_REJECT = 2;
var FILTER_SKIP = 3;
var SHOW_ALL = 0xFFFFFFFF;
var SHOW_ELEMENT = 0x1;
var SHOW_ATTRIBUTE = 0x2;
var SHOW_TEXT = 0x4;
var SHOW_CDATA_SECTION = 0x8;
var SHOW_ENTITY_REFERENCE = 0x10;
var SHOW_ENTITY = 0x20;
var SHOW_PROCESSING_INSTRUCTION = 0x40;
var SHOW_COMMENT = 0x80;
var SHOW_DOCUMENT = 0x100;
var SHOW_DOCUMENT_TYPE = 0x200;
var SHOW_DOCUMENT_FRAGMENT = 0x400;
var SHOW_NOTATION = 0x800;