corrade-nucleus-nucleons – Blame information for rev 37

Subversion Repositories:
Rev:
Rev Author Line No. Line
37 office 1 (function (root, factory) {
2 'use strict';
3  
4 if (typeof module === 'object' && module.exports) {
5 // Node. Does not work with strict CommonJS, but only CommonJS-like
6 // environments that support module.exports, like Node.
7 factory(require('./x2js'), require('qunit-cli'));
8 } else {
9 // Browser globals (root is window)
10 factory(root.X2JS, root.QUnit);
11 }
12 })(this, function (X2JS, QUnit) {
13 'use strict';
14  
15 QUnit.module('Converting JavaScript objects to XML');
16  
17 QUnit.test('Element with attribute', function (assert) {
18 var js = {
19 'document': {
20 'element': {
21 '_attribute': 'value'
22 }
23 }
24 };
25 var x = new X2JS();
26 var xml = x.js2xml(js);
27  
28 var expected = '<document>' +
29 '<element attribute="value" />' +
30 '</document>';
31  
32 // Implementation does not guarantee formatting so the test is somewhat fragile.
33 assert.strictEqual(xml, expected);
34 });
35  
36 QUnit.test('Element with attribute and selfClosingElements set to false', function (assert) {
37 var js = {
38 'document': {
39 'element': {
40 '_attribute': 'value'
41 }
42 }
43 };
44 var x = new X2JS({
45 'selfClosingElements': false
46 });
47 var xml = x.js2xml(js);
48  
49 var expected = '<document>' +
50 '<element attribute="value"></element>' +
51 '</document>';
52  
53 // Implementation does not guarantee formatting so the test is somewhat fragile.
54 assert.strictEqual(xml, expected);
55 });
56  
57 QUnit.test('Element with attribute and selfClosingElements set to true', function (assert) {
58 var js = {
59 'document': {
60 'element': {
61 '_attribute': 'value'
62 }
63 }
64 };
65 var x = new X2JS({
66 'selfClosingElements': true
67 });
68 var xml = x.js2xml(js);
69  
70 var expected = '<document>' +
71 '<element attribute="value" />' +
72 '</document>';
73  
74 // Implementation does not guarantee formatting so the test is somewhat fragile.
75 assert.strictEqual(xml, expected);
76 });
77  
78 QUnit.test('Element with attribute containing XML characters', function (assert) {
79 var js = {
80 'document': {
81 'element': {
82 '_attribute': 'va&lue<'
83 }
84 }
85 };
86 var x = new X2JS();
87 var xml = x.js2xml(js);
88  
89 var expected = '<document>' +
90 '<element attribute="va&amp;lue&lt;" />' +
91 '</document>';
92  
93 // Implementation does not guarantee formatting so the test is somewhat fragile.
94 assert.strictEqual(xml, expected);
95 });
96  
97 QUnit.test('Just a string', function (assert) {
98 var js = {
99 'document': {
100 'elementY': 'hello there'
101 }
102 };
103 var x = new X2JS();
104 var xml = x.js2xml(js);
105  
106 var expected = '<document>' +
107 '<elementY>hello there</elementY>' +
108 '</document>';
109  
110 // Implementation does not guarantee formatting so the test is somewhat fragile.
111 assert.strictEqual(xml, expected);
112 });
113  
114 QUnit.test('String with XML characters', function (assert) {
115 var js = {
116 'document': {
117 'elementY': 'hello &there<'
118 }
119 };
120 var x = new X2JS();
121 var xml = x.js2xml(js);
122  
123 var expected = '<document>' +
124 '<elementY>hello &amp;there&lt;</elementY>' +
125 '</document>';
126  
127 // Implementation does not guarantee formatting so the test is somewhat fragile.
128 assert.strictEqual(xml, expected);
129 });
130  
131 QUnit.test('CDATA', function (assert) {
132 var js = {
133 'document': {
134 'elementZ': { '__cdata': 'hello again' }
135 }
136 };
137 var x = new X2JS();
138 var xml = x.js2xml(js);
139  
140 var expected = '<document>' +
141 '<elementZ><![CDATA[hello again]]></elementZ>' +
142 '</document>';
143  
144 // Implementation does not guarantee formatting so the test is somewhat fragile.
145 assert.strictEqual(xml, expected);
146 });
147  
148 QUnit.test('CDATA with XML characters', function (assert) {
149 var js = {
150 'document': {
151 'elementZ': { '__cdata': 'hello &again<' }
152 }
153 };
154 var x = new X2JS();
155 var xml = x.js2xml(js);
156  
157 var expected = '<document>' +
158 '<elementZ><![CDATA[hello &again<]]></elementZ>' +
159 '</document>';
160  
161 // Implementation does not guarantee formatting so the test is somewhat fragile.
162 assert.strictEqual(xml, expected);
163 });
164  
165 QUnit.test('Empty string as value', function (assert) {
166 var js = {
167 'document': {
168 'elementU': ''
169 }
170 };
171 var x = new X2JS();
172 var xml = x.js2xml(js);
173  
174 var expected = '<document>' +
175 '<elementU />' +
176 '</document>';
177  
178 // Implementation does not guarantee formatting so the test is somewhat fragile.
179 assert.strictEqual(xml, expected);
180 });
181  
182 QUnit.test('Zero as value', function (assert) {
183 var js = {
184 'document': {
185 'element': 0
186 }
187 };
188 var x = new X2JS();
189 var xml = x.js2xml(js);
190  
191 var expected = '<document>' +
192 '<element>0</element>' +
193 '</document>';
194  
195 assert.strictEqual(xml, expected);
196 });
197  
198 QUnit.test('Empty string as value with selfClosingElements set to false', function (assert) {
199 var js = {
200 'document': {
201 'elementU': ''
202 }
203 };
204 var x = new X2JS({
205 'selfClosingElements': false
206 });
207  
208 var xml = x.js2xml(js);
209  
210 var expected = '<document>' +
211 '<elementU></elementU>' +
212 '</document>';
213  
214 // Implementation does not guarantee formatting so the test is somewhat fragile.
215 assert.strictEqual(xml, expected);
216 });
217  
218 QUnit.test('Basic array', function (assert) {
219 var js = {
220 'document': {
221 'elementV': [
222 { 'x': 't' },
223 { 'm': 'n' }
224 ]
225 }
226 };
227 var x = new X2JS();
228 var xml = x.js2xml(js);
229  
230 var expected = '<document>' +
231 '<elementV><x>t</x></elementV>' +
232 '<elementV><m>n</m></elementV>' +
233 '</document>';
234  
235 // Implementation does not guarantee formatting so the test is somewhat fragile.
236 assert.strictEqual(xml, expected);
237 });
238  
239 QUnit.test('Array of empty strings', function (assert) {
240 var js = {
241 'document': {
242 'elementX': ['', '']
243 }
244 };
245 var x = new X2JS();
246 var xml = x.js2xml(js);
247  
248 var expected = '<document>' +
249 '<elementX />' +
250 '<elementX />' +
251 '</document>';
252  
253 // Implementation does not guarantee formatting so the test is somewhat fragile.
254 assert.strictEqual(xml, expected);
255 });
256  
257 QUnit.test('Array of empty strings with selfClosingElements set to false', function (assert) {
258 var js = {
259 'document': {
260 'elementX': ['', '']
261 }
262 };
263 var x = new X2JS({
264 'selfClosingElements': false
265 });
266 var xml = x.js2xml(js);
267  
268 var expected = '<document>' +
269 '<elementX></elementX>' +
270 '<elementX></elementX>' +
271 '</document>';
272  
273 // Implementation does not guarantee formatting so the test is somewhat fragile.
274 assert.strictEqual(xml, expected);
275 });
276  
277 QUnit.test('Attributes in array', function (assert) {
278 var js = {
279 'document': {
280 'elementV': [
281 {
282 'x': 't',
283 '_a': 'a'
284 },
285 {
286 'm': 'n',
287 '_b': 'b'
288 }
289 ]
290 }
291 };
292 var x = new X2JS();
293 var xml = x.js2xml(js);
294  
295 var expected = '<document>' +
296 '<elementV a="a"><x>t</x></elementV>' +
297 '<elementV b="b"><m>n</m></elementV>' +
298 '</document>';
299  
300 // Implementation does not guarantee formatting so the test is somewhat fragile.
301 assert.strictEqual(xml, expected);
302 });
303  
304 QUnit.test('Namespaces', function (assert) {
305 var js = {
306 'document': {
307 '__prefix': 'ns',
308 '_ns:xmlns': 'http://example.com',
309 'elementV': [
310 {
311 '__prefix': 'ns',
312 'x': 't',
313 '_a': 'a'
314 },
315 {
316 'm': {
317 '__text': 'n',
318 '__prefix': 'ns'
319 },
320 '_b': 'b'
321 }
322 ]
323 }
324 };
325 var x = new X2JS();
326 var xml = x.js2xml(js);
327  
328 var expected = '<ns:document ns:xmlns="http://example.com">' +
329 '<ns:elementV a="a"><x>t</x></ns:elementV>' +
330 '<elementV b="b"><ns:m>n</ns:m></elementV>' +
331 '</ns:document>';
332  
333 // Implementation does not guarantee formatting so the test is somewhat fragile.
334 assert.strictEqual(xml, expected);
335 });
336 });