mirror of
https://github.com/mozilla/gecko-dev.git
synced 2025-11-11 21:58:41 +02:00
a7a0e9b4ee
Automatic update from web-platform-tests XMLSerializer: Keep redundant but harmless default namespace declarations Since crrev.com/632142, XMLSerializer has dropped redundant xmlns="..." declarations. It matches to IE, Edge, and DOM P&S standard. This CL reverts the behavior to unbreak existing applications. The restored behavior matches to Firefox and Safari. * MarkupAccumulator::AppendElement(): Even if ignore_namespace_definition_attribute_ is set, we drop a xmlns="..." only if its value is inconsistent with element's namespace. * MarkupAccumulator::AppendStartTagOpen(): if local_default_namespace is "" and ns is null, do not emit xmlns="". This avoids to serialize xmlns="" twice. Bug: https://github.com/w3c/DOM-Parsing/issues/47 Bug: 940204 Change-Id: I2978ddc9a3f9511d227a9a1b902f1811ac1c3c07 Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1516124 Reviewed-by: Yoshifumi Inoue <yosin@chromium.org> Commit-Queue: Kent Tamura <tkent@chromium.org> Auto-Submit: Kent Tamura <tkent@chromium.org> Cr-Commit-Position: refs/heads/master@{#639873} -- wpt-commits: 4dc79803ad127fb635a03ec8b248c8671b4c3b67 wpt-pr: 15779
209 lines
9.8 KiB
HTML
209 lines
9.8 KiB
HTML
<!DOCTYPE HTML>
|
|
<meta charset=utf-8>
|
|
<html>
|
|
<head>
|
|
<title>domparsing Test: XMLSerializer.serializeToString</title>
|
|
<script src="/resources/testharness.js"></script>
|
|
<script src="/resources/testharnessreport.js"></script>
|
|
</head>
|
|
<body>
|
|
<h1>domparsing_XMLSerializer_serializeToString</h1>
|
|
<script>
|
|
const XMLNS_URI = 'http://www.w3.org/2000/xmlns/';
|
|
|
|
function createXmlDoc(){
|
|
var input = '<?xml version="1.0" encoding="UTF-8"?><root><child1>value1</child1></root>';
|
|
var parser = new DOMParser();
|
|
return parser.parseFromString(input, 'text/xml');
|
|
}
|
|
|
|
// Returns the root element.
|
|
function parse(xmlString) {
|
|
return (new DOMParser()).parseFromString(xmlString, 'text/xml').documentElement;
|
|
}
|
|
|
|
function serialize(node) {
|
|
return (new XMLSerializer()).serializeToString(node);
|
|
}
|
|
|
|
test(function() {
|
|
var root = createXmlDoc().documentElement;
|
|
assert_equals(serialize(root), '<root><child1>value1</child1></root>');
|
|
}, 'check XMLSerializer.serializeToString method could parsing xmldoc to string');
|
|
|
|
test(function() {
|
|
var root = createXmlDoc().documentElement;
|
|
var element = root.ownerDocument.createElementNS('urn:foo', 'another');
|
|
var child1 = root.firstChild;
|
|
root.replaceChild(element, child1);
|
|
element.appendChild(child1);
|
|
assert_equals(serialize(root), '<root><another xmlns="urn:foo"><child1 xmlns="">value1</child1></another></root>');
|
|
}, 'Check if the default namespace is correctly reset.');
|
|
|
|
test(function() {
|
|
var root = parse('<root xmlns="urn:bar"><outer xmlns=""><inner>value1</inner></outer></root>');
|
|
assert_equals(serialize(root), '<root xmlns="urn:bar"><outer xmlns=""><inner>value1</inner></outer></root>');
|
|
}, 'Check if there is no redundant empty namespace declaration.');
|
|
|
|
test(function() {
|
|
assert_equals(serialize(parse('<root><child xmlns=""/></root>')),
|
|
'<root><child/></root>');
|
|
assert_equals(serialize(parse('<root xmlns=""><child xmlns=""/></root>')),
|
|
'<root><child/></root>');
|
|
assert_equals(serialize(parse('<root xmlns="u1"><child xmlns="u1"/></root>')),
|
|
'<root xmlns="u1"><child/></root>');
|
|
}, 'Check if redundant xmlns="..." is dropped.');
|
|
|
|
test(function() {
|
|
const root = parse('<root xmlns="uri1"/>');
|
|
const child = root.ownerDocument.createElement('child');
|
|
child.setAttributeNS(XMLNS_URI, 'xmlns', 'FAIL1');
|
|
root.appendChild(child);
|
|
const child2 = root.ownerDocument.createElementNS('uri2', 'child2');
|
|
child2.setAttributeNS(XMLNS_URI, 'xmlns', 'FAIL2');
|
|
root.appendChild(child2);
|
|
const child3 = root.ownerDocument.createElementNS('uri1', 'child3');
|
|
child3.setAttributeNS(XMLNS_URI, 'xmlns', 'FAIL3');
|
|
root.appendChild(child3);
|
|
const child4 = root.ownerDocument.createElementNS('uri4', 'child4');
|
|
child4.setAttributeNS(XMLNS_URI, 'xmlns', 'uri4');
|
|
root.appendChild(child4);
|
|
const child5 = root.ownerDocument.createElement('child5');
|
|
child5.setAttributeNS(XMLNS_URI, 'xmlns', '');
|
|
root.appendChild(child5);
|
|
assert_equals(serialize(root), '<root xmlns="uri1"><child xmlns=""/><child2 xmlns="uri2"/><child3/><child4 xmlns="uri4"/><child5 xmlns=""/></root>');
|
|
}, 'Check if inconsistent xmlns="..." is dropped.');
|
|
|
|
test(function() {
|
|
let root = parse('<r xmlns:xx="uri"></r>');
|
|
root.setAttributeNS('uri', 'name', 'v');
|
|
assert_equals(serialize(root), '<r xmlns:xx="uri" xx:name="v"/>');
|
|
|
|
let root2 = parse('<r xmlns:xx="uri"><b/></r>');
|
|
let child = root2.firstChild;
|
|
child.setAttributeNS('uri', 'name', 'v');
|
|
assert_equals(serialize(root2), '<r xmlns:xx="uri"><b xx:name="v"/></r>');
|
|
|
|
let root3 = parse('<r xmlns:x0="uri" xmlns:x2="uri"><b xmlns:x1="uri"/></r>');
|
|
let child3 = root3.firstChild;
|
|
child3.setAttributeNS('uri', 'name', 'v');
|
|
assert_equals(serialize(root3),
|
|
'<r xmlns:x0="uri" xmlns:x2="uri"><b xmlns:x1="uri" x1:name="v"/></r>',
|
|
'Should choose the nearest prefix');
|
|
}, 'Check if an attribute with namespace and no prefix is serialized with the nearest-declared prefix');
|
|
|
|
test(function() {
|
|
let root = parse('<el1 xmlns:p="u1" xmlns:q="u1"><el2 xmlns:q="u2"/></el1>');
|
|
root.firstChild.setAttributeNS('u1', 'name', 'v');
|
|
assert_equals(serialize(root),
|
|
'<el1 xmlns:p="u1" xmlns:q="u1"><el2 xmlns:q="u2" q:name="v"/></el1>');
|
|
// Maybe this is a specification error.
|
|
}, 'Check if an attribute with namespace and no prefix is serialized with the nearest-declared prefix even if the prefix is assigned to another namespace.');
|
|
|
|
test(function() {
|
|
let root = parse('<r xmlns:xx="uri"></r>');
|
|
root.setAttributeNS('uri', 'p:name', 'v');
|
|
assert_equals(serialize(root), '<r xmlns:xx="uri" xx:name="v"/>');
|
|
|
|
let root2 = parse('<r xmlns:xx="uri"><b/></r>');
|
|
let child = root2.firstChild;
|
|
child.setAttributeNS('uri', 'p:name', 'value');
|
|
assert_equals(serialize(root2),
|
|
'<r xmlns:xx="uri"><b xx:name="value"/></r>');
|
|
}, 'Check if the prefix of an attribute is replaced with another existing prefix mapped to the same namespace URI.');
|
|
|
|
test(function() {
|
|
let root = parse('<r xmlns:xx="uri"></r>');
|
|
root.setAttributeNS('uri2', 'p:name', 'value');
|
|
assert_equals(serialize(root),
|
|
'<r xmlns:xx="uri" xmlns:ns1="uri2" ns1:name="value"/>');
|
|
}, 'Check if the prefix of an attribute is NOT preserved in a case where neither its prefix nor its namespace URI is not already used.');
|
|
|
|
test(function() {
|
|
let root = parse('<r xmlns:xx="uri"></r>');
|
|
root.setAttributeNS('uri2', 'xx:name', 'value');
|
|
assert_equals(serialize(root),
|
|
'<r xmlns:xx="uri" xmlns:ns1="uri2" ns1:name="value"/>');
|
|
}, 'Check if the prefix of an attribute is replaced with a generated one in a case where the prefix is already mapped to a different namespace URI.');
|
|
|
|
test(function() {
|
|
var root = parse('<root />');
|
|
root.setAttribute('attr', '\t');
|
|
assert_in_array(serialize(root), [
|
|
'<root attr="	"/>', '<root attr="	"/>']);
|
|
root.setAttribute('attr', '\n');
|
|
assert_in_array(serialize(root), [
|
|
'<root attr="
"/>', '<root attr=" "/>']);
|
|
root.setAttribute('attr', '\r');
|
|
assert_in_array(serialize(root), [
|
|
'<root attr="
"/>', '<root attr=" "/>']);
|
|
}, 'check XMLSerializer.serializeToString escapes attribute values for roundtripping');
|
|
|
|
test(function() {
|
|
const root = (new Document()).createElement('root');
|
|
root.setAttributeNS('uri1', 'p:foobar', 'value1');
|
|
root.setAttributeNS(XMLNS_URI, 'xmlns:p', 'uri2');
|
|
assert_equals(serialize(root), '<root xmlns:ns1="uri1" ns1:foobar="value1" xmlns:p="uri2"/>');
|
|
}, 'Check if attribute serialization takes into account of following xmlns:* attributes');
|
|
|
|
test(function() {
|
|
const root = parse('<root xmlns:p="uri1"><child/></root>');
|
|
root.firstChild.setAttributeNS('uri2', 'p:foobar', 'v');
|
|
assert_equals(serialize(root), '<root xmlns:p="uri1"><child xmlns:ns1="uri2" ns1:foobar="v"/></root>');
|
|
}, 'Check if attribute serialization takes into account of the same prefix declared in an ancestor element');
|
|
|
|
test(function() {
|
|
assert_equals(serialize(parse('<root><child/></root>')), '<root><child/></root>');
|
|
assert_equals(serialize(parse('<root xmlns="u1"><p:child xmlns:p="u1"/></root>')), '<root xmlns="u1"><child xmlns:p="u1"/></root>');
|
|
}, 'Check if start tag serialization drops element prefix if the namespace is same as inherited default namespace.');
|
|
|
|
test(function() {
|
|
const root = parse('<root xmlns:p1="u1"><child xmlns:p2="u1"/></root>');
|
|
const child2 = root.ownerDocument.createElementNS('u1', 'child2');
|
|
root.firstChild.appendChild(child2);
|
|
assert_equals(serialize(root), '<root xmlns:p1="u1"><child xmlns:p2="u1"><p2:child2/></child></root>');
|
|
}, 'Check if start tag serialization finds an appropriate prefix.');
|
|
|
|
test(function() {
|
|
const root = (new Document()).createElementNS('uri1', 'p:root');
|
|
root.setAttributeNS(XMLNS_URI, 'xmlns:p', 'uri2');
|
|
assert_equals(serialize(root), '<ns1:root xmlns:ns1="uri1" xmlns:p="uri2"/>');
|
|
}, 'Check if start tag serialization takes into account of its xmlns:* attributes');
|
|
|
|
test(function() {
|
|
const root = (new Document()).createElement('root');
|
|
root.setAttributeNS(XMLNS_URI, 'xmlns:p', 'uri2');
|
|
const child = root.ownerDocument.createElementNS('uri1', 'p:child');
|
|
root.appendChild(child);
|
|
assert_equals(serialize(root), '<root xmlns:p="uri2"><p:child xmlns:p="uri1"/></root>');
|
|
}, 'Check if start tag serialization applied the original prefix even if it is declared in an ancestor element.');
|
|
|
|
test(function() {
|
|
const root = parse('<root><child1/><child2/></root>');
|
|
root.firstChild.setAttributeNS('uri1', 'attr1', 'value1');
|
|
root.firstChild.setAttributeNS('uri2', 'attr2', 'value2');
|
|
root.lastChild.setAttributeNS('uri3', 'attr3', 'value3');
|
|
assert_equals(serialize(root), '<root><child1 xmlns:ns1="uri1" ns1:attr1="value1" xmlns:ns2="uri2" ns2:attr2="value2"/><child2 xmlns:ns3="uri3" ns3:attr3="value3"/></root>');
|
|
}, 'Check if generated prefixes match to "ns${index}".');
|
|
|
|
test(function() {
|
|
const root = parse('<root xmlns:ns2="uri2"><child xmlns:ns1="uri1"/></root>');
|
|
root.firstChild.setAttributeNS('uri3', 'attr1', 'value1');
|
|
// According to 'DOM Parsing and Serialization' draft as of 2018-12-11,
|
|
// 'generate a prefix' result can conflict with an existing xmlns:ns* declaration.
|
|
assert_equals(serialize(root), '<root xmlns:ns2="uri2"><child xmlns:ns1="uri1" xmlns:ns1="uri3" ns1:attr1="value1"/></root>');
|
|
}, 'Check if "ns1" is generated even if the element already has xmlns:ns1.');
|
|
|
|
test(function() {
|
|
const root = (new Document()).createElement('root');
|
|
root.setAttributeNS('http://www.w3.org/1999/xlink', 'href', 'v');
|
|
assert_equals(serialize(root), '<root xmlns:ns1="http://www.w3.org/1999/xlink" ns1:href="v"/>');
|
|
|
|
const root2 = (new Document()).createElement('root');
|
|
root2.setAttributeNS('http://www.w3.org/1999/xlink', 'xl:type', 'v');
|
|
assert_equals(serialize(root2), '<root xmlns:xl="http://www.w3.org/1999/xlink" xl:type="v"/>');
|
|
}, 'Check if no special handling for XLink namespace unlike HTML serializer.');
|
|
|
|
</script>
|
|
</body>
|
|
</html>
|