Modified: trunk/LayoutTests/fast/shadow-dom/HTMLSlotElement-interface.html (200284 => 200285)
--- trunk/LayoutTests/fast/shadow-dom/HTMLSlotElement-interface.html 2016-04-30 04:13:22 UTC (rev 200284)
+++ trunk/LayoutTests/fast/shadow-dom/HTMLSlotElement-interface.html 2016-04-30 04:19:00 UTC (rev 200285)
@@ -34,126 +34,237 @@
assert_equals(slotElement.getAttribute('name'), 'bar', '"name" attribute must update the "name" content attribute');
}, '"name" attribute on HTMLSlotElement must reflect "name" attribute');
-test(function () {
- assert_true('getAssignedNodes' in HTMLSlotElement.prototype, '"getAssignedNodes" method must be defined on HTMLSlotElement.prototype');
+function testSlotOutsideShadowTree(options)
+{
+ test(function () {
+ assert_true('assignedNodes' in HTMLSlotElement.prototype, '"assignedNodes" method must be defined on HTMLSlotElement.prototype');
- var shadowHost = document.createElement('div');
- var child = document.createElement('p');
+ var slotElement = document.createElement('slot');
+ assert_array_equals(slotElement.assignedNodes(options), [], 'assignedNodes() must return an empty array when the slot element is not in any tree');
- var shadowRoot = shadowHost.attachShadow({mode: 'open'});
- var slotElement = document.createElement('slot');
- shadowRoot.appendChild(slotElement);
+ document.body.appendChild(slotElement);
+ assert_array_equals(slotElement.assignedNodes(options), [], 'assignedNodes() must return an empty array when the slot element is in a document tree');
- assert_array_equals(slotElement.getAssignedNodes(), [], 'getAssignedNodes must return an empty array when there are no nodes in the shadow tree');
+ }, 'assignedNodes(' + (options ? JSON.stringify(options) : '')
+ + ') on a HTMLSlotElement must return an empty array when the slot element is not in a tree or in a document tree');
+}
- shadowHost.appendChild(child);
- assert_array_equals(slotElement.getAssignedNodes(), [child], 'getAssignedNodes on a default slot must return an element without slot element');
+testSlotOutsideShadowTree(null);
+testSlotOutsideShadowTree({flattened: false});
+testSlotOutsideShadowTree({flattened: true});
- child.setAttribute('slot', 'foo');
- assert_array_equals(slotElement.getAssignedNodes(), [], 'getAssignedNodes on a default slot must not return an element with non-empty slot attribute');
+function testSingleLevelOfSlotting(options)
+{
+ test(function () {
+ assert_true('assignedNodes' in HTMLSlotElement.prototype, '"assignedNodes" method must be defined on HTMLSlotElement.prototype');
- child.setAttribute('slot', '');
- assert_array_equals(slotElement.getAssignedNodes(), [child], 'getAssignedNodes on a default slot must return an element with empty slot attribute');
+ var shadowHost = document.createElement('div');
+ var child = document.createElement('p');
- slotElement.setAttribute('name', 'bar');
- assert_array_equals(slotElement.getAssignedNodes(), [], 'getAssignedNodes on a named slot must not return an element with empty slot attribute');
+ var shadowRoot = shadowHost.attachShadow({mode: 'open'});
+ var slotElement = document.createElement('slot');
+ shadowRoot.appendChild(slotElement);
- slotElement.setAttribute('name', '');
- assert_array_equals(slotElement.getAssignedNodes(), [child], 'getAssignedNodes on an empty name slot must return an element with empty slot attribute');
+ assert_array_equals(slotElement.assignedNodes(options), [], 'assignedNodes() must return an empty array when there are no nodes in the shadow tree');
-}, 'getAssignedNodes method on HTMLSlotElement must return the list of distributed nodes');
+ shadowHost.appendChild(child);
+ assert_array_equals(slotElement.assignedNodes(options), [child], 'assignedNodes() on a default slot must return an element without slot element');
-test(function () {
- var shadowHost = document.createElement('div');
- var p = document.createElement('p');
- var b = document.createElement('b');
- shadowHost.appendChild(p);
- shadowHost.appendChild(b);
+ child.setAttribute('slot', 'foo');
+ assert_array_equals(slotElement.assignedNodes(options), [], 'assignedNodes() on a default slot must not return an element with non-empty slot attribute');
- var shadowRoot = shadowHost.attachShadow({mode: 'open'});
- var slotElement = document.createElement('slot');
- shadowRoot.appendChild(slotElement);
+ child.setAttribute('slot', '');
+ assert_array_equals(slotElement.assignedNodes(options), [child], 'assignedNodes() on a default slot must return an element with empty slot attribute');
- assert_array_equals(slotElement.getAssignedNodes(), [p, b], 'getAssignedNodes must return the distributed nodes');
+ slotElement.setAttribute('name', 'bar');
+ assert_array_equals(slotElement.assignedNodes(options), [], 'assignedNodes() on a named slot must not return an element with empty slot attribute');
- slotElement.name = 'foo';
- assert_array_equals(slotElement.getAssignedNodes(), [], 'getAssignedNodes must be empty when there are no matching elements for the slot name');
+ slotElement.setAttribute('name', '');
+ assert_array_equals(slotElement.assignedNodes(options), [child], 'assignedNodes() on an empty name slot must return an element with empty slot attribute');
- b.slot = 'foo';
- assert_array_equals(slotElement.getAssignedNodes(), [b], 'getAssignedNodes must return the nodes with the matching slot name');
+ }, 'assignedNodes(' + (options ? JSON.stringify(options) : '') + ') must return the list of assigned nodes when none of the assigned nodes themselves are slots');
+}
- p.slot = 'foo';
- assert_array_equals(slotElement.getAssignedNodes(), [p, b], 'getAssignedNodes must return the nodes with the matching slot name in the tree order');
+testSingleLevelOfSlotting(null);
+testSingleLevelOfSlotting({flattened: false});
+testSingleLevelOfSlotting({flattened: true});
- slotElement.removeAttribute('name');
- assert_array_equals(slotElement.getAssignedNodes(), [], 'getAssignedNodes must be empty for a default slot when all elements have "slot" attributes specified');
+function testMutatingSlottedContents(options)
+{
+ test(function () {
+ var shadowHost = document.createElement('div');
+ var p = document.createElement('p');
+ var b = document.createElement('b');
+ shadowHost.appendChild(p);
+ shadowHost.appendChild(b);
-}, 'getAssignedNodes must update when slot and name attributes are modified');
+ var shadowRoot = shadowHost.attachShadow({mode: 'open'});
+ var slotElement = document.createElement('slot');
+ shadowRoot.appendChild(slotElement);
-test(function () {
- var shadowHost = document.createElement('div');
- var child = document.createElement('span');
- shadowHost.appendChild(child);
+ assert_array_equals(slotElement.assignedNodes(options), [p, b], 'assignedNodes must return the distributed nodes');
- var shadowRoot = shadowHost.attachShadow({mode: 'open'});
- var slotElement = document.createElement('slot');
- slotElement.name = 'foo';
- shadowRoot.appendChild(slotElement);
+ slotElement.name = 'foo';
+ assert_array_equals(slotElement.assignedNodes(options), [], 'assignedNodes must be empty when there are no matching elements for the slot name');
- assert_array_equals(slotElement.getAssignedNodes(), [], 'getAssignedNodes must be empty when there are no matching elements for the slot name');
+ b.slot = 'foo';
+ assert_array_equals(slotElement.assignedNodes(options), [b], 'assignedNodes must return the nodes with the matching slot name');
- slotElement.removeAttribute('name');
- assert_array_equals(slotElement.getAssignedNodes(), [child], 'getAssignedNodes must be empty when there are no matching elements for the slot name');
+ p.slot = 'foo';
+ assert_array_equals(slotElement.assignedNodes(options), [p, b], 'assignedNodes must return the nodes with the matching slot name in the tree order');
-}, 'getAssignedNodes must update when a default slot is introduced dynamically by a slot rename');
+ slotElement.removeAttribute('name');
+ assert_array_equals(slotElement.assignedNodes(options), [], 'assignedNodes must be empty for a default slot when all elements have "slot" attributes specified');
+ }, 'assignedNodes(' + (options ? JSON.stringify(options) : '') + ') must update when slot and name attributes are modified');
+}
+
+testMutatingSlottedContents(null);
+testMutatingSlottedContents({flattened: false});
+testMutatingSlottedContents({flattened: true});
+
+function testMutatingSlotName(options)
+{
+ test(function () {
+ var shadowHost = document.createElement('div');
+ var child = document.createElement('span');
+ shadowHost.appendChild(child);
+
+ var shadowRoot = shadowHost.attachShadow({mode: 'open'});
+ var slotElement = document.createElement('slot');
+ slotElement.name = 'foo';
+ shadowRoot.appendChild(slotElement);
+
+ assert_array_equals(slotElement.assignedNodes(options), [], 'assignedNodes must be empty when there are no matching elements for the slot name');
+
+ slotElement.removeAttribute('name');
+ assert_array_equals(slotElement.assignedNodes(options), [child], 'assignedNodes must be empty when there are no matching elements for the slot name');
+
+ }, 'assignedNodes must update when a default slot is introduced dynamically by a slot rename');
+}
+
+testMutatingSlotName(null);
+testMutatingSlottedContents({flattened: false});
+testMutatingSlottedContents({flattened: true});
+
+function testInsertingAndRemovingSlots(options)
+{
+ test(function () {
+ var shadowHost = document.createElement('div');
+ var p = document.createElement('p');
+ var text = document.createTextNode('');
+ var comment = document.createComment('');
+ var processingInstruction = document.createProcessingInstruction('target', 'data');
+ var b = document.createElement('b');
+ shadowHost.appendChild(p);
+ shadowHost.appendChild(text);
+ shadowHost.appendChild(comment);
+ shadowHost.appendChild(processingInstruction);
+ shadowHost.appendChild(b);
+
+ var shadowRoot = shadowHost.attachShadow({mode: 'open'});
+
+ var firstSlotElement = document.createElement('slot');
+ shadowRoot.appendChild(firstSlotElement);
+
+ var secondSlotElement = document.createElement('slot');
+ shadowRoot.appendChild(secondSlotElement);
+
+ assert_array_equals(firstSlotElement.assignedNodes(options), [p, text, b],
+ 'assignedNodes on a default slot must return the elements without slot attributes and text nodes');
+ assert_array_equals(secondSlotElement.assignedNodes(options), [],
+ 'assignedNodes on the second unnamed slot element must return an empty array');
+
+ shadowRoot.removeChild(firstSlotElement);
+ assert_array_equals(firstSlotElement.assignedNodes(options), [],
+ 'assignedNodes on a detached formerly-default slot must return an empty array');
+ assert_array_equals(secondSlotElement.assignedNodes(options), [p, text, b],
+ 'assignedNodes on the second unnamed slot element after removing the first must return the elements without slot attributes and text nodes');
+
+ shadowRoot.removeChild(secondSlotElement);
+ shadowRoot.appendChild(secondSlotElement);
+ assert_array_equals(firstSlotElement.assignedNodes(options), [],
+ 'Removing and re-inserting a default slot must not change the result of assignedNodes on a detached slot');
+ assert_array_equals(secondSlotElement.assignedNodes(options), [p, text, b],
+ 'Removing and re-inserting a default slot must not change the result of assignedNodes');
+
+ shadowRoot.insertBefore(firstSlotElement, secondSlotElement);
+ assert_array_equals(firstSlotElement.assignedNodes(options), [p, text, b],
+ 'assignedNodes on a newly inserted unnamed slot element must return the elements without slot attributes and text nodes');
+ assert_array_equals(secondSlotElement.assignedNodes(options), [],
+ 'assignedNodes on formerly-first but now second unnamed slot element must return an empty array');
+
+ }, 'assignedNodes must update when slot elements are inserted or removed');
+}
+
+testInsertingAndRemovingSlots(null);
+testInsertingAndRemovingSlots({flattened: false});
+testInsertingAndRemovingSlots({flattened: true});
+
test(function () {
- var shadowHost = document.createElement('div');
- var p = document.createElement('p');
- var text = document.createTextNode('');
- var comment = document.createComment('');
- var processingInstruction = document.createProcessingInstruction('target', 'data');
- var b = document.createElement('b');
- shadowHost.appendChild(p);
- shadowHost.appendChild(text);
- shadowHost.appendChild(comment);
- shadowHost.appendChild(processingInstruction);
- shadowHost.appendChild(b);
+ var outerHost = document.createElement('div');
+ var outerChild = document.createElement('span');
+ outerHost.appendChild(outerChild);
- var shadowRoot = shadowHost.attachShadow({mode: 'open'});
+ var outerShadow = outerHost.attachShadow({mode: 'closed'});
+ var innerHost = document.createElement('div');
+ var outerSlot = document.createElement('slot');
+ var innerChild = document.createElement('b');
+ outerShadow.appendChild(innerHost);
+ innerHost.appendChild(outerSlot);
+ innerHost.appendChild(innerChild);
- var firstSlotElement = document.createElement('slot');
- shadowRoot.appendChild(firstSlotElement);
+ var innerShadow = innerHost.attachShadow({mode: 'closed'});
+ var innerSlot = document.createElement('slot');
+ innerShadow.appendChild(innerSlot);
- var secondSlotElement = document.createElement('slot');
- shadowRoot.appendChild(secondSlotElement);
+ assert_array_equals(outerSlot.assignedNodes(), [outerChild], 'assignedNodes() on a default slot must return the assigned nodes');
+ assert_array_equals(outerSlot.assignedNodes({flatten: false}), [outerChild], 'assignedNodes({flatten: false}) on a default slot must return the assigned nodes');
+ assert_array_equals(outerSlot.assignedNodes({flatten: true}), [outerChild], 'assignedNodes({flatten: true}) on a default slot must return the assigned nodes if they are not themselves slots');
- assert_array_equals(firstSlotElement.getAssignedNodes(), [p, text, b],
- 'getAssignedNodes on a default slot must return the elements without slot attributes and text nodes');
- assert_array_equals(secondSlotElement.getAssignedNodes(), [],
- 'getAssignedNodes on the second unnamed slot element must return an empty array');
+ assert_array_equals(innerSlot.assignedNodes(), [outerSlot, innerChild], 'assignedNodes() on a default slot must return the assigned nodes');
+ assert_array_equals(innerSlot.assignedNodes({flatten: false}), [outerSlot, innerChild], 'assignedNodes({flatten: false}) on a default slot must return the assigned nodes');
+ assert_array_equals(innerSlot.assignedNodes({flatten: true}), [outerChild, innerChild], 'assignedNodes({flatten: true}) on a default slot must return the distributed nodes');
- shadowRoot.removeChild(firstSlotElement);
- assert_array_equals(firstSlotElement.getAssignedNodes(), [],
- 'getAssignedNodes on a detached formerly-default slot must return an empty array');
- assert_array_equals(secondSlotElement.getAssignedNodes(), [p, text, b],
- 'getAssignedNodes on the second unnamed slot element after removing the first must return the elements without slot attributes and text nodes');
+ outerSlot.name = 'foo';
+ assert_array_equals(outerSlot.assignedNodes(), [], 'assignedNodes() on a named slot must return an empty array if there are no matching elements');
+ assert_array_equals(outerSlot.assignedNodes({flatten: false}), [], 'assignedNodes({flatten: false}) on a named slot must return an empty array if there are no matching elements');
+ assert_array_equals(outerSlot.assignedNodes({flatten: true}), [], 'assignedNodes({flatten: true}) on a named slot must return an empty array if there are no matching elements');
- shadowRoot.removeChild(secondSlotElement);
- shadowRoot.appendChild(secondSlotElement);
- assert_array_equals(firstSlotElement.getAssignedNodes(), [],
- 'Removing and re-inserting a default slot must not change the result of getAssignedNodes on a detached slot');
- assert_array_equals(secondSlotElement.getAssignedNodes(), [p, text, b],
- 'Removing and re-inserting a default slot must not change the result of getAssignedNodes');
+ assert_array_equals(innerSlot.assignedNodes(), [outerSlot, innerChild], 'assignedNodes() on a default slot must return the assigned nodes');
+ assert_array_equals(innerSlot.assignedNodes({flatten: false}), [outerSlot, innerChild], 'assignedNodes({flatten: false}) on a default slot must return the assigned nodes');
+ assert_array_equals(innerSlot.assignedNodes({flatten: true}), [innerChild], 'assignedNodes({flatten: true}) on a default slot must return the distributed nodes');
- shadowRoot.insertBefore(firstSlotElement, secondSlotElement);
- assert_array_equals(firstSlotElement.getAssignedNodes(), [p, text, b],
- 'getAssignedNodes on a newly inserted unnamed slot element must return the elements without slot attributes and text nodes');
- assert_array_equals(secondSlotElement.getAssignedNodes(), [],
- 'getAssignedNodes on formerly-first but now second unnamed slot element must return an empty array');
+ outerChild.slot = 'foo';
+ assert_array_equals(outerSlot.assignedNodes(), [outerChild], 'assignedNodes() on a named slot must return matching elements');
+ assert_array_equals(outerSlot.assignedNodes({flatten: false}), [outerChild], 'assignedNodes({flatten: false}) on a named slot must return matching elements');
+ assert_array_equals(outerSlot.assignedNodes({flatten: true}), [outerChild], 'assignedNodes({flatten: true}) on a named slot must return matching elements');
-}, 'getAssignedNodes must update when slot elements are inserted or removed');
+ assert_array_equals(innerSlot.assignedNodes(), [outerSlot, innerChild], 'assignedNodes() on a default slot must return the assigned nodes');
+ assert_array_equals(innerSlot.assignedNodes({flatten: false}), [outerSlot, innerChild], 'assignedNodes({flatten: false}) on a default slot must return the assigned nodes');
+ assert_array_equals(innerSlot.assignedNodes({flatten: true}), [outerChild, innerChild], 'assignedNodes({flatten: true}) on a default slot must return the distributed nodes');
+ var newInnerSlot = document.createElement('slot');
+ innerShadow.insertBefore(newInnerSlot, innerSlot);
+ assert_array_equals(newInnerSlot.assignedNodes(), [outerSlot, innerChild], 'assignedNodes() on a default slot must return the assigned nodes');
+ assert_array_equals(newInnerSlot.assignedNodes({flatten: false}), [outerSlot, innerChild], 'assignedNodes({flatten: false}) on a default slot must return the assigned nodes');
+ assert_array_equals(newInnerSlot.assignedNodes({flatten: true}), [outerChild, innerChild], 'assignedNodes({flatten: true}) on a default slot must return the distributed nodes');
+
+ assert_array_equals(innerSlot.assignedNodes(), [], 'assignedNodes() on a nameless slot element which appears after a default slot must return an empty array');
+ assert_array_equals(innerSlot.assignedNodes({flatten: false}), [], 'assignedNodes({flatten: false}) on a nameless slot element which appears after a default slot must return an empty array');
+ assert_array_equals(innerSlot.assignedNodes({flatten: true}), [], 'assignedNodes({flatten: true}) on a nameless slot element which appears after a default slot must return an empty array');
+
+ innerShadow.removeChild(newInnerSlot);
+ assert_array_equals(newInnerSlot.assignedNodes(), [], 'assignedNodes() must return an empty array when the slot element is not in any tree');
+ assert_array_equals(newInnerSlot.assignedNodes({flatten: false}), [], 'assignedNodes({flatten: false}) must return an empty array when the slot element is not in any tree');
+ assert_array_equals(newInnerSlot.assignedNodes({flatten: true}), [], 'assignedNodes({flatten: true}) must return an empty array when the slot element is not in any tree');
+
+ assert_array_equals(innerSlot.assignedNodes(), [outerSlot, innerChild], 'assignedNodes() on a default slot must return the assigned nodes');
+ assert_array_equals(innerSlot.assignedNodes({flatten: false}), [outerSlot, innerChild], 'assignedNodes({flatten: false}) on a default slot must return the assigned nodes');
+ assert_array_equals(innerSlot.assignedNodes({flatten: true}), [outerChild, innerChild], 'assignedNodes({flatten: true}) on a default slot must return the distributed nodes');
+
+}, 'assignedNodes({flatten: true}) must return the distributed nodes, and assignedNodes() and assignedNodes({flatten: false}) must returned the assigned nodes');
+
</script>
</body>
</html>
