1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
|
<?xml version="1.0"?>
<?xml-stylesheet href="chrome://global/skin" type="text/css"?>
<?xml-stylesheet href="chrome://mochikit/content/tests/SimpleTest/test.css" type="text/css"?>
<window title="Test for the Mozilla extesion of the DOM Parsing and Serialization API"
xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul">
<script src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"/>
<!-- test results are displayed in the html:body -->
<body xmlns="http://www.w3.org/1999/xhtml"
xmlns:xul="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul">
<a href="https://bugzilla.mozilla.org/show_bug.cgi?id=816410"
target="_blank">Mozilla Bug 816410</a>
<xul:browser id="test1" type="content" src="data:text/html,content" />
</body>
<!-- test code goes here -->
<script type="application/javascript"><![CDATA[
"use strict";
/** Test for Bug 816410 **/
function throws(fn, type, message) {
try {
fn();
ok(false, message);
} catch (e) {
if (type) {
is(e.name, type, message);
} else {
ok(true, message);
}
}
}
add_task(function dom_parser_extra_args() {
// DOMParser constructor should not throw for extra arguments
new DOMParser(undefined);
new DOMParser(null);
new DOMParser(false);
new DOMParser(0);
new DOMParser("");
new DOMParser({});
});
add_task(function xml_serializer_extra_args() {
// XMLSerializer constructor should not throw for extra arguments
new XMLSerializer(undefined);
new XMLSerializer(null);
new XMLSerializer(false);
new XMLSerializer(0);
new XMLSerializer("");
new XMLSerializer({});
});
add_task(function chrome_window() {
runTest(window, true);
});
add_task(function content_window() {
runTest(document.getElementById("test1").contentWindow, false);
});
function runTest(win, expectSystem) {
let parser = new win.DOMParser();
let serializer = new win.XMLSerializer();
let principal = win.document.nodePrincipal;
is(principal.isSystemPrincipal, expectSystem,
`expected ${expectSystem ? "system" : "content"} principal`);
is(typeof parser.parseFromString, "function", "parseFromString should exist");
is(typeof parser.parseFromBuffer, "function", "parseFromBuffer should exist");
is(typeof parser.parseFromStream, "function", "parseFromStream should exist");
is(typeof parser.parseFromSafeString, "function", "parseFromSafeString should exist");
is(typeof serializer.serializeToString, "function", "serializeToString should exist");
is(typeof serializer.serializeToStream, "function", "serializeToStream should exist");
let tests = [
{input: "<html></html>", type: "text/html",
expected: '<html xmlns="http://www.w3.org/1999/xhtml"><head></head><body></body></html>'},
{input: "<xml></xml>", type: "text/xml", expected: "<xml/>"},
{input: "<xml></xml>", type: "application/xml", expected: "<xml/>"},
{input: "<html></html>", type: "application/xhtml+xml", expected: "<html/>"},
{input: "<svg></svg>", type: "image/svg+xml", expected: "<svg/>"},
];
for (let t of tests) {
const fromNormalString = parser.parseFromString(t.input, t.type);
if (principal.isSystemPrincipal) {
ok(fromNormalString.nodePrincipal.isNullPrincipal,
"system principal DOMParser produces a null principal document");
} else {
ok(fromNormalString.nodePrincipal === principal,
"content principal DOMParser produces a document with an object-identical principal");
}
const fromSafeString = parser.parseFromSafeString(t.input, t.type);
ok(fromSafeString.nodePrincipal === principal,
"DOMParser with parseFromSafeString always produces a document with an object-identical principal");
is(serializer.serializeToString(parser.parseFromString(t.input, t.type)), t.expected,
"parseFromString test for " + t.type);
for (let charset of [null, "UTF-8"]) {
let pipe = Cc["@mozilla.org/pipe;1"].createInstance(Ci.nsIPipe);
pipe.init(false, false, 0, 0xffffffff, null);
let ostream = pipe.outputStream;
serializer.serializeToStream(parser.parseFromString(t.input, t.type), ostream, charset);
let istream = Cc["@mozilla.org/scriptableinputstream;1"].createInstance(
Ci.nsIScriptableInputStream
);
istream.init(pipe.inputStream);
let data = istream.read(0xffffffff);
is(data, t.expected,
"serializeToStream test for " + t.type + ", charset=" + charset);
}
if (t.type === "text/html") {
// parseFromBuffer and parseFromStream don't support "text/html".
continue;
}
let array = Array.from(t.input, function(c) { return c.charCodeAt(c); });
let inputs = [
{array, name: "parseFromBuffer (array)"},
{array: new Uint8Array(array), name: "parseFromBuffer (Uint8Array)"},
];
for (let input of inputs) {
let a = input.array;
is(serializer.serializeToString(parser.parseFromBuffer(a, t.type)), t.expected,
input.name + " test for " + t.type);
}
let istream = Cc["@mozilla.org/io/string-input-stream;1"].
createInstance(Ci.nsIStringInputStream);
for (let charset of [null, "UTF-8"]) {
istream.setData(t.input, -1);
is(serializer.serializeToString(parser.parseFromStream(istream, charset, t.input.length, t.type)),
t.expected, "parseFromStream test for " + t.type + ", charset=" + charset);
}
}
throws(function() {
parser.parseFromString("<xml></xml>", "foo/bar");
}, "TypeError", "parseFromString should throw for the unknown type");
}
]]></script>
</window>
|
