Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

Added TreeWalker tests #1235

Merged
merged 2 commits into from
Oct 6, 2014
Merged

Added TreeWalker tests #1235

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
100b7fb
Added TreeWalker tests
ChrisParis Sep 8, 2014
831db0a
Address review comments
ChrisParis Sep 27, 2014
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
160 changes: 160 additions & 0 deletions dom/traversal/TreeWalker-acceptNode-filter.html
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,160 @@
<!DOCTYPE html>
<html>
<!--
Test adapted from https://mxr.mozilla.org/chromium/source/src/third_party/WebKit/LayoutTests/fast/dom/TreeWalker/script-tests/acceptNode-filter.js
-->
<head>
<title>TreeWalker: acceptNode-filter</title>
<script src="/resources/testharness.js"></script>
<script src="/resources/testharnessreport.js"></script>
<script src="traversal-support.js"></script>
<link rel="stylesheet" href="/resources/testharness.css">
<div id=log></div>
</head>
<body>
<p>Test JS objects as NodeFilters</p>
<script>
var testElement;
setup(function() {
testElement = document.createElement("div");
testElement.id = 'root';
//testElement.innerHTML='<div id="A1"><div id="B1"></div><div id="B2"></div></div>';

// XXX for Servo, build the tree without using innerHTML
var a1 = document.createElement("div");
a1.id = "A1";
var b1 = document.createElement("div");
b1.id = "B1";
var b2 = document.createElement("div");
b2.id = "B2";
testElement.appendChild(a1);
a1.appendChild(b1);
a1.appendChild(b2);
});

test(function()
{
function filter(node)
{
if (node.id == "B1")
return /*NodeFilter.*/FILTER_SKIP;
return /*NodeFilter.*/FILTER_ACCEPT;
}

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' });
assert_node(walker.nextNode(), { type: Element, id: 'B2' });
assert_node(walker.currentNode, { type: Element, id: 'B2' });
}, 'Testing with raw function filter');

test(function()
{
var walker = document.createTreeWalker(testElement, /*NodeFilter.*/SHOW_ELEMENT, {
acceptNode : function(node) {
if (node.id == "B1")
return /*NodeFilter.*/FILTER_SKIP;
return /*NodeFilter.*/FILTER_ACCEPT;
}
});
assert_node(walker.currentNode, { type: Element, id: 'root' });
assert_node(walker.firstChild(), { type: Element, id: 'A1' });
assert_node(walker.currentNode, { type: Element, id: 'A1' });
assert_node(walker.nextNode(), { type: Element, id: 'B2' });
assert_node(walker.currentNode, { type: Element, id: 'B2' });
}, 'Testing with object filter');

test(function()
{
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' });
assert_node(walker.nextNode(), { type: Element, id: 'B1' });
assert_node(walker.currentNode, { type: Element, id: 'B1' });
}, 'Testing with null filter');

test(function()
{
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' });
assert_node(walker.nextNode(), { type: Element, id: 'B1' });
assert_node(walker.currentNode, { type: Element, id: 'B1' });
}, 'Testing with undefined filter');

// XXX Servo breaks the test when a callback isn't callable
test(function()
{
var walker = document.createTreeWalker(testElement, /*NodeFilter.*/SHOW_ELEMENT, {});
assert_throws(null, function () { walker.firstChild(); });
assert_node(walker.currentNode, { type: Element, id: 'root' });
assert_throws(null, function () { walker.nextNode(); });
assert_node(walker.currentNode, { type: Element, id: 'root' });
}, 'Testing with object lacking acceptNode property');

// XXX Servo breaks the test when a callback isn't callable
test(function()
{
var walker = document.createTreeWalker(testElement, /*NodeFilter.*/SHOW_ELEMENT, { acceptNode: "foo" });
assert_throws(null, function () { walker.firstChild(); });
assert_node(walker.currentNode, { type: Element, id: 'root' });
assert_throws(null, function () { walker.nextNode(); });
assert_node(walker.currentNode, { type: Element, id: 'root' });
}, 'Testing with object with non-function acceptNode property');

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);
assert_node(walker.firstChild(), { type: Element, id: 'A1' });
assert_node(walker.nextNode(), { type: Element, id: 'B1' });
}, 'Testing with function having acceptNode function');

test(function()
{
var filter = {
acceptNode: function(node) {
return /*NodeFilter.*/FILTER_ACCEPT;
}
};
var walker = document.createTreeWalker(testElement, /*NodeFilter.*/SHOW_ELEMENT, filter);
assert_node(walker.firstChild(), { type: Element, id: 'A1' });
}, 'Testing acceptNode callee');

// XXX Looks like Servo is doing something wrong when a callback function throws
test(function()
{
var walker = document.createTreeWalker(testElement, /*NodeFilter.*/SHOW_ELEMENT,
function(node) {
throw('filter exception');
return /*NodeFilter.*/FILTER_ACCEPT;
});
assert_throws(null, function () { walker.firstChild(); });
assert_node(walker.currentNode, { type: Element, id: 'root' });
assert_throws(null, function () { walker.nextNode(); });
assert_node(walker.currentNode, { type: Element, id: 'root' });
}, 'Testing with filter function that throws');

// XXX Looks like Servo is doing something wrong when a callback function throws
test(function()
{
var walker = document.createTreeWalker(testElement, /*NodeFilter.*/SHOW_ELEMENT,
{
acceptNode : function(node) {
throw('filter exception');
return /*NodeFilter.*/FILTER_ACCEPT;
}
});
assert_throws(null, function () { walker.firstChild(); });
assert_node(walker.currentNode, { type: Element, id: 'root' });
assert_throws(null, function () { walker.nextNode(); });
assert_node(walker.currentNode, { type: Element, id: 'root' });
}, 'Testing with filter object that throws');

</script>
</body>
</html>
146 changes: 146 additions & 0 deletions dom/traversal/TreeWalker-basic.html
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,146 @@
<!DOCTYPE html>
<html>
<!--
Test adapted from https://mxr.mozilla.org/chromium/source/src/third_party/WebKit/LayoutTests/fast/dom/TreeWalker/TreeWalker-basic.html
-->
<head>
<title>TreeWalker: Basic test</title>
<script src="/resources/testharness.js"></script>
<script src="/resources/testharnessreport.js"></script>
<script src="traversal-support.js"></script>
<link rel="stylesheet" href="/resources/testharness.css">
<div id=log></div>
</head>
<body>
<p>This test checks the basic functionality of TreeWalker.</p>
<script>
function createSampleDOM()
{
// Tree structure:
// #a
// |
// +----+----+
// | |
// "b" #c
// |
// +----+----+
// | |
// #d <!--j-->
// |
// +----+----+
// | | |
// "e" #f "i"
// |
// +--+--+
// | |
// "g" <!--h-->
var div = document.createElement('div');
div.id = 'a';
// div.innerHTML = 'b<div id="c"><div id="d">e<span id="f">g<!--h--></span>i</div><!--j--></div>';

div.appendChild(document.createTextNode("b"));

var c = document.createElement("div");
c.id = 'c';
div.appendChild(c);

var d = document.createElement("div");
d.id = 'd';
c.appendChild(d);

var e = document.createTextNode("e");
d.appendChild(e);

var f = document.createElement("span");
f.id = 'f';
d.appendChild(f);

var g = document.createTextNode("g");
f.appendChild(g);

var h = document.createComment("h");
f.appendChild(h);

var i = document.createTextNode("i");
d.appendChild(i);

var j = document.createComment("j");
c.appendChild(j);

return div;
}

function check_walker(walker, root)
{
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);
assert_readonly(walker, 'root');
assert_readonly(walker, 'whatToShow');
assert_readonly(walker, 'filter');
}

test(function ()
{
var root = createSampleDOM();
var walker = document.createTreeWalker(root);
check_walker(walker, root);
}, 'Construct a TreeWalker by document.createTreeWalker(root).');

test(function ()
{
var root = createSampleDOM();
var walker = document.createTreeWalker(root, undefined, undefined);
check_walker(walker, root);
}, 'Construct a TreeWalker by document.createTreeWalker(root, undefined, undefined).');

test(function ()
{
assert_throws(new TypeError(), function () { document.createTreeWalker(); });
assert_throws(new TypeError(), function () { document.createTreeWalker(null); });
assert_throws(new TypeError(), function () { document.createTreeWalker(undefined); });
assert_throws(new TypeError(), function () { document.createTreeWalker(new Object()); });
assert_throws(new TypeError(), function () { document.createTreeWalker(1); });
}, 'Give an invalid root node to document.createTreeWalker().');

test(function ()
{
var root = createSampleDOM();
var walker = document.createTreeWalker(root);
var f = root.lastChild.firstChild.childNodes[1]; // An element node: div#f.

assert_node(walker.currentNode, { type: Element, id: 'a' });
assert_equals(walker.parentNode(), null);
assert_node(walker.currentNode, { type: Element, id: 'a' });
assert_node(walker.firstChild(), { type: Text, nodeValue: 'b' });
assert_node(walker.currentNode, { type: Text, nodeValue: 'b' });
assert_node(walker.nextSibling(), { type: Element, id: 'c' });
assert_node(walker.currentNode, { type: Element, id: 'c' });
assert_node(walker.lastChild(), { type: Comment, nodeValue: 'j' });
assert_node(walker.currentNode, { type: Comment, nodeValue: 'j' });
assert_node(walker.previousSibling(), { type: Element, id: 'd' });
assert_node(walker.currentNode, { type: Element, id: 'd' });
assert_node(walker.nextNode(), { type: Text, nodeValue: 'e' });
assert_node(walker.currentNode, { type: Text, nodeValue: 'e' });
assert_node(walker.parentNode(), { type: Element, id: 'd' });
assert_node(walker.currentNode, { type: Element, id: 'd' });
assert_node(walker.previousNode(), { type: Element, id: 'c' });
assert_node(walker.currentNode, { type: Element, id: 'c' });
assert_equals(walker.nextSibling(), null);
assert_node(walker.currentNode, { type: Element, id: 'c' });
walker.currentNode = f;
assert_equals(walker.currentNode, f);
}, 'Walk over nodes.');

test(function() {
var treeWalker = document.createTreeWalker(document.body, 42, null);
assert_equals(treeWalker.root, document.body);
assert_equals(treeWalker.currentNode, document.body);
assert_equals(treeWalker.whatToShow, 42);
assert_equals(treeWalker.filter, null);
}, "Optional arguments to createTreeWalker should be optional (3 passed, null).");
</script>
</body>
</html>
74 changes: 74 additions & 0 deletions dom/traversal/TreeWalker-currentNode.html
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,74 @@
<!DOCTYPE html>
<html>
<!--
Test adapted from https://mxr.mozilla.org/chromium/source/src/third_party/WebKit/LayoutTests/fast/dom/TreeWalker/resources/TreeWalker-currentNode.js
-->
<head>
<title>TreeWalker: currentNode</title>
<script src="/resources/testharness.js"></script>
<script src="/resources/testharnessreport.js"></script>
<script src="traversal-support.js"></script>
<link rel="stylesheet" href="/resources/testharness.css">
<div id=log></div>
</head>
<body>
<div id='parent'>
<div id='subTree'><p>Lorem ipsum <span>dolor <b>sit</b> amet</span>, consectetur <i>adipisicing</i> elit, sed do eiusmod <tt>tempor <b><i>incididunt ut</i> labore</b> et dolore magna</tt> aliqua.</p></div>
</div>
<p>Test TreeWalker currentNode functionality</p>
<script>
// var subTree = document.createElement('div');
// subTree.innerHTML = "<p>Lorem ipsum <span>dolor <b>sit</b> amet</span>, consectetur <i>adipisicing</i> elit, sed do eiusmod <tt>tempor <b><i>incididunt ut</i> labore</b> et dolore magna</tt> aliqua.</p>"
// document.body.appendChild(subTree);
var subTree = document.getElementById("subTree");

var all = function(node) { return true; }

test(function()
{
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' });
}, "Test that TreeWalker.parent() doesn't set the currentNode to a node not under the root.");

test(function()
{
var w = document.createTreeWalker(subTree,
/*NodeFilter.*/SHOW_ELEMENT
| /*NodeFilter.*/SHOW_COMMENT,
all);
w.currentNode = document.documentElement;
assert_equals(w.parentNode(), null);
assert_equals(w.currentNode, document.documentElement);
w.currentNode = document.documentElement;
assert_equals(w.nextNode(), document.documentElement.firstChild);
assert_equals(w.currentNode, document.documentElement.firstChild);
w.currentNode = document.documentElement;
assert_equals(w.previousNode(), null);
assert_equals(w.currentNode, document.documentElement);
w.currentNode = document.documentElement;
assert_equals(w.firstChild(), document.documentElement.firstChild);
assert_equals(w.currentNode, document.documentElement.firstChild);
w.currentNode = document.documentElement;
assert_equals(w.lastChild(), document.documentElement.lastChild);
assert_equals(w.currentNode, document.documentElement.lastChild);
w.currentNode = document.documentElement;
assert_equals(w.nextSibling(), null);
assert_equals(w.currentNode, document.documentElement);
w.currentNode = document.documentElement;
assert_equals(w.previousSibling(), null);
assert_equals(w.currentNode, document.documentElement);
}, "Test that we handle setting the currentNode to arbitrary nodes not under the root element.");

test(function()
{
var w = document.createTreeWalker(subTree, /*NodeFilter.*/SHOW_ELEMENT, all);
w.currentNode = subTree.previousSibling;
assert_equals(w.nextNode(), subTree);
w.currentNode = document.getElementById("parent");
assert_equals(w.firstChild(), subTree);
}, "Test how we handle the case when the traversed to node is within the root, but the currentElement is not.");
</script>
</body>
</html>
Loading