Debian Codegraph @

closure-library/closure/goog/dom/browserrange/browserrange_test.js

raw
1 // Copyright 2007 The Closure Library Authors. All Rights Reserved.
2 //
3 // Licensed under the Apache License, Version 2.0 (the "License");
4 // you may not use this file except in compliance with the License.
5 // You may obtain a copy of the License at
6 //
7 // http://www.apache.org/licenses/LICENSE-2.0
8 //
9 // Unless required by applicable law or agreed to in writing, software
10 // distributed under the License is distributed on an "AS-IS" BASIS,
11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 // See the License for the specific language governing permissions and
13 // limitations under the License.
14
15 goog.provide('goog.dom.browserrangeTest');
16 goog.setTestOnly('goog.dom.browserrangeTest');
17
18 goog.require('goog.dom');
19 goog.require('goog.dom.NodeType');
20 goog.require('goog.dom.Range');
21 goog.require('goog.dom.RangeEndpoint');
22 goog.require('goog.dom.TagName');
23 goog.require('goog.dom.browserrange');
24 goog.require('goog.html.testing');
25 goog.require('goog.testing.dom');
26 goog.require('goog.testing.jsunit');
27
28 var test1;
29 var test2;
30 var cetest;
31 var empty;
32 var dynamic;
33 var onlybrdiv;
34
35 function setUpPage() {
36 test1 = goog.dom.getElement('test1');
37 test2 = goog.dom.getElement('test2');
38 cetest = goog.dom.getElement('cetest');
39 empty = goog.dom.getElement('empty');
40 dynamic = goog.dom.getElement('dynamic');
41 onlybrdiv = goog.dom.getElement('onlybr');
42 }
43
44 function testCreate() {
45 assertNotNull(
46 'Browser range object can be created for node',
47 goog.dom.browserrange.createRangeFromNodeContents(test1));
48 }
49
50 function testRangeEndPoints() {
51 var container = cetest.firstChild;
52 var range =
53 goog.dom.browserrange.createRangeFromNodes(container, 2, container, 2);
54 range.select();
55
56 var selRange = goog.dom.Range.createFromWindow();
57 var startNode = selRange.getStartNode();
58 var endNode = selRange.getEndNode();
59 var startOffset = selRange.getStartOffset();
60 var endOffset = selRange.getEndOffset();
61 if (startNode.nodeType == goog.dom.NodeType.TEXT) {
62 // Special case for Webkit (up to Chrome 57) and IE8.
63 assertEquals(
64 'Start node should have text: abc', 'abc', startNode.nodeValue);
65 assertEquals('End node should have text: abc', 'abc', endNode.nodeValue);
66 assertEquals('Start offset should be 3', 3, startOffset);
67 assertEquals('End offset should be 3', 3, endOffset);
68 } else {
69 assertEquals('Start node should be the first div', container, startNode);
70 assertEquals('End node should be the first div', container, endNode);
71 assertEquals('Start offset should be 2', 2, startOffset);
72 assertEquals('End offset should be 2', 2, endOffset);
73 }
74 }
75
76 function testCreateFromNodeContents() {
77 var range = goog.dom.Range.createFromNodeContents(onlybrdiv);
78 goog.testing.dom.assertRangeEquals(onlybrdiv, 0, onlybrdiv, 1, range);
79 }
80
81 /**
82 * @param {string} str
83 * @return {string}
84 */
85 function normalizeHtml(str) {
86 return str.toLowerCase().replace(/[\n\r\f"]/g, '');
87 }
88
89 // TODO(robbyw): We really need tests for (and code fixes for)
90 // createRangeFromNodes in the following cases:
91 // * BR boundary (before + after)
92
93 function testCreateFromNodes() {
94 var start = test1.firstChild;
95 var range =
96 goog.dom.browserrange.createRangeFromNodes(start, 2, test2.firstChild, 2);
97 assertNotNull(
98 'Browser range object can be created for W3C node range', range);
99
100 assertEquals(
101 'Start node should be selected at start endpoint', start,
102 range.getStartNode());
103 assertEquals('Selection should start at offset 2', 2, range.getStartOffset());
104
105 assertEquals(
106 'Text node should be selected at end endpoint', test2.firstChild,
107 range.getEndNode());
108 assertEquals('Selection should end at offset 2', 2, range.getEndOffset());
109
110 assertTrue(
111 'Text content should be "xt\\s*ab"', /xt\s*ab/.test(range.getText()));
112 assertFalse('Nodes range is not collapsed', range.isCollapsed());
113 assertEquals(
114 'Should contain correct html fragment', 'xt</div><div id=test2>ab',
115 normalizeHtml(range.getHtmlFragment()));
116 assertEquals(
117 'Should contain correct valid html',
118 '<div id=test1>xt</div><div id=test2>ab</div>',
119 normalizeHtml(range.getValidHtml()));
120 }
121
122
123 function testTextNode() {
124 var range =
125 goog.dom.browserrange.createRangeFromNodeContents(test1.firstChild);
126
127 assertEquals(
128 'Text node should be selected at start endpoint', 'Text',
129 range.getStartNode().nodeValue);
130 assertEquals('Selection should start at offset 0', 0, range.getStartOffset());
131
132 assertEquals(
133 'Text node should be selected at end endpoint', 'Text',
134 range.getEndNode().nodeValue);
135 assertEquals(
136 'Selection should end at offset 4', 'Text'.length, range.getEndOffset());
137
138 assertEquals(
139 'Container should be text node', goog.dom.NodeType.TEXT,
140 range.getContainer().nodeType);
141
142 assertEquals('Text content should be "Text"', 'Text', range.getText());
143 assertFalse('Text range is not collapsed', range.isCollapsed());
144 assertEquals(
145 'Should contain correct html fragment', 'Text', range.getHtmlFragment());
146 assertEquals(
147 'Should contain correct valid html', 'Text', range.getValidHtml());
148 }
149
150 function testTextNodes() {
151 goog.dom.removeChildren(dynamic);
152 dynamic.appendChild(goog.dom.createTextNode('Part1'));
153 dynamic.appendChild(goog.dom.createTextNode('Part2'));
154 var range = goog.dom.browserrange.createRangeFromNodes(
155 dynamic.firstChild, 0, dynamic.lastChild, 5);
156
157 assertEquals(
158 'Text node 1 should be selected at start endpoint', 'Part1',
159 range.getStartNode().nodeValue);
160 assertEquals('Selection should start at offset 0', 0, range.getStartOffset());
161
162 assertEquals(
163 'Text node 2 should be selected at end endpoint', 'Part2',
164 range.getEndNode().nodeValue);
165 assertEquals(
166 'Selection should end at offset 5', 'Part2'.length, range.getEndOffset());
167
168 assertEquals(
169 'Container should be DIV', String(goog.dom.TagName.DIV),
170 range.getContainer().tagName);
171
172 assertEquals(
173 'Text content should be "Part1Part2"', 'Part1Part2', range.getText());
174 assertFalse('Text range is not collapsed', range.isCollapsed());
175 assertEquals(
176 'Should contain correct html fragment', 'Part1Part2',
177 range.getHtmlFragment());
178 assertEquals(
179 'Should contain correct valid html', 'part1part2',
180 normalizeHtml(range.getValidHtml()));
181 }
182
183 function testDiv() {
184 var range = goog.dom.browserrange.createRangeFromNodeContents(test2);
185
186 assertEquals(
187 'Text node "abc" should be selected at start endpoint', 'abc',
188 range.getStartNode().nodeValue);
189 assertEquals('Selection should start at offset 0', 0, range.getStartOffset());
190
191 assertEquals(
192 'Text node "def" should be selected at end endpoint', 'def',
193 range.getEndNode().nodeValue);
194 assertEquals(
195 'Selection should end at offset 3', 'def'.length, range.getEndOffset());
196
197 assertEquals('Container should be DIV', 'DIV', range.getContainer().tagName);
198
199 assertTrue(
200 'Div text content should be "abc\\s*def"',
201 /abc\s*def/.test(range.getText()));
202 assertEquals(
203 'Should contain correct html fragment', 'abc<br id=br>def',
204 normalizeHtml(range.getHtmlFragment()));
205 assertEquals(
206 'Should contain correct valid html',
207 '<div id=test2>abc<br id=br>def</div>',
208 normalizeHtml(range.getValidHtml()));
209 assertFalse('Div range is not collapsed', range.isCollapsed());
210 }
211
212 function testEmptyNodeHtmlInsert() {
213 var range = goog.dom.browserrange.createRangeFromNodeContents(empty);
214 var html = '<b>hello</b>';
215 range.insertNode(goog.dom.safeHtmlToNode(
216 goog.html.testing.newSafeHtmlForTest(html)));
217 assertEquals(
218 'Html is not inserted correctly', html, normalizeHtml(empty.innerHTML));
219 goog.dom.removeChildren(empty);
220 }
221
222 function testEmptyNode() {
223 var range = goog.dom.browserrange.createRangeFromNodeContents(empty);
224
225 assertEquals(
226 'DIV be selected at start endpoint', 'DIV', range.getStartNode().tagName);
227 assertEquals('Selection should start at offset 0', 0, range.getStartOffset());
228
229 assertEquals(
230 'DIV should be selected at end endpoint', 'DIV',
231 range.getEndNode().tagName);
232 assertEquals('Selection should end at offset 0', 0, range.getEndOffset());
233
234 assertEquals('Container should be DIV', 'DIV', range.getContainer().tagName);
235
236 assertEquals('Empty text content should be ""', '', range.getText());
237 assertTrue('Empty range is collapsed', range.isCollapsed());
238 assertEquals(
239 'Should contain correct valid html', '<div id=empty></div>',
240 normalizeHtml(range.getValidHtml()));
241 assertEquals('Should contain no html fragment', '', range.getHtmlFragment());
242 }
243
244
245 function testRemoveContents() {
246 var outer = goog.dom.getElement('removeTest');
247 var range =
248 goog.dom.browserrange.createRangeFromNodeContents(outer.firstChild);
249
250 range.removeContents();
251
252 assertEquals('Removed range content should be ""', '', range.getText());
253 assertTrue('Removed range is now collapsed', range.isCollapsed());
254 assertEquals('Outer div has 1 child now', 1, outer.childNodes.length);
255 assertEquals('Inner div is empty', 0, outer.firstChild.childNodes.length);
256 }
257
258
259 function testRemoveContentsEmptyNode() {
260 var outer = goog.dom.getElement('removeTestEmptyNode');
261 var range = goog.dom.browserrange.createRangeFromNodeContents(outer);
262
263 range.removeContents();
264
265 assertEquals('Removed range content should be ""', '', range.getText());
266 assertTrue('Removed range is now collapsed', range.isCollapsed());
267 assertEquals(
268 'Outer div should have 0 children now', 0, outer.childNodes.length);
269 }
270
271
272 function testRemoveContentsSingleNode() {
273 var outer = goog.dom.getElement('removeTestSingleNode');
274 var range =
275 goog.dom.browserrange.createRangeFromNodeContents(outer.firstChild);
276
277 range.removeContents();
278
279 assertEquals('Removed range content should be ""', '', range.getText());
280 assertTrue('Removed range is now collapsed', range.isCollapsed());
281 assertEquals('', goog.dom.getTextContent(outer));
282 }
283
284
285 function testRemoveContentsMidNode() {
286 var outer = goog.dom.getElement('removeTestMidNode');
287 var textNode = outer.firstChild.firstChild;
288 var range =
289 goog.dom.browserrange.createRangeFromNodes(textNode, 1, textNode, 4);
290
291 assertEquals(
292 'Previous range content should be "123"', '123', range.getText());
293 range.removeContents();
294
295 assertEquals(
296 'Removed range content should be "0456789"', '0456789',
297 goog.dom.getTextContent(outer));
298 }
299
300
301 function testRemoveContentsMidMultipleNodes() {
302 var outer = goog.dom.getElement('removeTestMidMultipleNodes');
303 var firstTextNode = outer.firstChild.firstChild;
304 var lastTextNode = outer.lastChild.firstChild;
305 var range = goog.dom.browserrange.createRangeFromNodes(
306 firstTextNode, 1, lastTextNode, 4);
307
308 assertEquals(
309 'Previous range content', '1234567890123',
310 range.getText().replace(/\s/g, ''));
311 range.removeContents();
312
313 assertEquals(
314 'Removed range content should be "0456789"', '0456789',
315 goog.dom.getTextContent(outer).replace(/\s/g, ''));
316 }
317
318
319 function testRemoveDivCaretRange() {
320 var outer = goog.dom.getElement('sandbox');
321 outer.innerHTML = '<div>Test1</div><div></div>';
322 var range = goog.dom.browserrange.createRangeFromNodes(
323 outer.lastChild, 0, outer.lastChild, 0);
324
325 range.removeContents();
326 range.insertNode(
327 goog.dom.createDom(goog.dom.TagName.SPAN, undefined, 'Hello'), true);
328
329 assertEquals(
330 'Resulting contents', 'Test1Hello',
331 goog.dom.getTextContent(outer).replace(/\s/g, ''));
332 }
333
334
335 function testCollapse() {
336 var range = goog.dom.browserrange.createRangeFromNodeContents(test2);
337 assertFalse('Div range is not collapsed', range.isCollapsed());
338 range.collapse();
339 assertTrue(
340 'Div range is collapsed after call to empty()', range.isCollapsed());
341
342 range = goog.dom.browserrange.createRangeFromNodeContents(empty);
343 assertTrue('Empty range is collapsed', range.isCollapsed());
344 range.collapse();
345 assertTrue('Empty range is still collapsed', range.isCollapsed());
346 }
347
348
349 function testIdWithSpecialCharacters() {
350 goog.dom.removeChildren(dynamic);
351 dynamic.appendChild(goog.dom.createTextNode('1'));
352 dynamic.appendChild(goog.dom.createDom(goog.dom.TagName.DIV, {id: '<>'}));
353 dynamic.appendChild(goog.dom.createTextNode('2'));
354 var range = goog.dom.browserrange.createRangeFromNodes(
355 dynamic.firstChild, 0, dynamic.lastChild, 1);
356
357 // Difference in special character handling is ok.
358 assertContains(
359 'Should have correct html fragment',
360 normalizeHtml(range.getHtmlFragment()),
361 [
362 '1<div id=<>></div>2', // IE
363 '1<div id=&lt;>></div>2', // WebKit
364 '1<div id=&lt;&gt;></div>2' // Others
365 ]);
366 }
367
368 function testEndOfChildren() {
369 dynamic.innerHTML = '<span id="a">123<br>456</span><span id="b">text</span>';
370 var range = goog.dom.browserrange.createRangeFromNodes(
371 goog.dom.getElement('a'), 3, goog.dom.getElement('b'), 1);
372 assertEquals('Should have correct text.', 'text', range.getText());
373 }
374
375 function testEndOfDiv() {
376 dynamic.innerHTML = '<div id="a">abc</div><div id="b">def</div>';
377 var a = goog.dom.getElement('a');
378 var range = goog.dom.browserrange.createRangeFromNodes(a, 1, a, 1);
379 var expectedStartNode = a;
380 var expectedStartOffset = 1;
381 var expectedEndNode = a;
382 var expectedEndOffset = 1;
383 assertEquals('startNode is wrong', expectedStartNode, range.getStartNode());
384 assertEquals(
385 'startOffset is wrong', expectedStartOffset, range.getStartOffset());
386 assertEquals('endNode is wrong', expectedEndNode, range.getEndNode());
387 assertEquals('endOffset is wrong', expectedEndOffset, range.getEndOffset());
388 }
389
390 function testRangeEndingWithBR() {
391 dynamic.innerHTML = '<span id="a">123<br>456</span>';
392 var spanElem = goog.dom.getElement('a');
393 var range =
394 goog.dom.browserrange.createRangeFromNodes(spanElem, 0, spanElem, 2);
395 var htmlText = range.getValidHtml().toLowerCase();
396 assertContains('Should include BR in HTML.', 'br', htmlText);
397 assertEquals('Should have correct text.', '123', range.getText());
398
399 range.select();
400
401 var selRange = goog.dom.Range.createFromWindow();
402 var startNode = selRange.getStartNode();
403 if (startNode.nodeType == goog.dom.NodeType.TEXT) {
404 // Special case for Webkit (up to Chrome 57) and IE8.
405 assertEquals('Startnode should have text:123', '123', startNode.nodeValue);
406 } else {
407 assertEquals('Start node should be span', spanElem, startNode);
408 }
409 assertEquals('Startoffset should be 0', 0, selRange.getStartOffset());
410 var endNode = selRange.getEndNode();
411 assertEquals('Endnode should be span', spanElem, endNode);
412 assertEquals('Endoffset should be 2', 2, selRange.getEndOffset());
413 }
414
415 function testRangeEndingWithBR2() {
416 dynamic.innerHTML = '<span id="a">123<br></span>';
417 var spanElem = goog.dom.getElement('a');
418 var range =
419 goog.dom.browserrange.createRangeFromNodes(spanElem, 0, spanElem, 2);
420 var htmlText = range.getValidHtml().toLowerCase();
421 assertContains('Should include BR in HTML.', 'br', htmlText);
422 assertEquals('Should have correct text.', '123', range.getText());
423
424 range.select();
425
426 var selRange = goog.dom.Range.createFromWindow();
427 var startNode = selRange.getStartNode();
428 var endNode = selRange.getEndNode();
429 if (startNode.nodeType == goog.dom.NodeType.TEXT) {
430 // Special case for Webkit (up to Chrome 57) and IE8.
431 assertEquals('Start node should have text:123', '123', startNode.nodeValue);
432 } else {
433 assertEquals('Start node should be span', spanElem, startNode);
434 }
435 assertEquals('Startoffset should be 0', 0, selRange.getStartOffset());
436 if (endNode.nodeType == goog.dom.NodeType.TEXT) {
437 // Special case for Webkit (up to Chrome 57) and IE8.
438 assertEquals('Endnode should have text', '123', endNode.nodeValue);
439 assertEquals('Endoffset should be 3', 3, selRange.getEndOffset());
440 } else {
441 assertEquals('Endnode should be span', spanElem, endNode);
442 assertEquals('Endoffset should be 2', 2, selRange.getEndOffset());
443 }
444 }
445
446 function testRangeEndingBeforeBR() {
447 dynamic.innerHTML = '<span id="a">123<br>456</span>';
448 var spanElem = goog.dom.getElement('a');
449 var range =
450 goog.dom.browserrange.createRangeFromNodes(spanElem, 0, spanElem, 1);
451 var htmlText = range.getValidHtml().toLowerCase();
452 assertNotContains('Should not include BR in HTML.', 'br', htmlText);
453 assertEquals('Should have correct text.', '123', range.getText());
454 range.select();
455
456 var selRange = goog.dom.Range.createFromWindow();
457 var startNode = selRange.getStartNode();
458 if (startNode.nodeType == goog.dom.NodeType.TEXT) {
459 // Special case for Webkit (up to Chrome 57) and IE8.
460 assertEquals('Startnode should have text:123', '123', startNode.nodeValue);
461 } else {
462 assertEquals('Start node should be span', spanElem, startNode);
463 }
464 assertEquals('Startoffset should be 0', 0, selRange.getStartOffset());
465 var endNode = selRange.getEndNode();
466 if (endNode.nodeType == goog.dom.NodeType.TEXT) {
467 // Special case for Webkit (up to Chrome 57) and IE8.
468 assertEquals('Endnode should have text:123', '123', endNode.nodeValue);
469 assertEquals('Endoffset should be 3', 3, selRange.getEndOffset());
470 } else {
471 assertEquals('Endnode should be span', spanElem, endNode);
472 assertEquals('Endoffset should be 1', 1, selRange.getEndOffset());
473 }
474 }
475
476 function testRangeStartingWithBR() {
477 dynamic.innerHTML = '<span id="a">123<br>456</span>';
478 var spanElem = goog.dom.getElement('a');
479 var range =
480 goog.dom.browserrange.createRangeFromNodes(spanElem, 1, spanElem, 3);
481 var htmlText = range.getValidHtml().toLowerCase();
482 assertContains('Should include BR in HTML.', 'br', htmlText);
483 // Firefox returns '456' as the range text while IE returns '\r\n456'.
484 // Therefore skipping the text check.
485
486 range.select();
487 var selRange = goog.dom.Range.createFromWindow();
488 var startNode = selRange.getStartNode();
489 var endNode = selRange.getEndNode();
490 if (startNode.nodeType == goog.dom.NodeType.TEXT) {
491 // Special case for Webkit (up to Chrome 57) and IE8.
492 assertEquals('Start node should be text:123', '123', startNode.nodeValue);
493 assertEquals('Startoffset should be 1', 1, selRange.getStartOffset());
494 } else {
495 assertEquals('Start node should be span', spanElem, startNode);
496 assertEquals('Startoffset should be 1', 1, selRange.getStartOffset());
497 }
498 if (endNode.nodeType == goog.dom.NodeType.TEXT) {
499 assertEquals('Endnode should have text:456', '456', endNode.nodeValue);
500 assertEquals('Endoffset should be 3', 3, selRange.getEndOffset());
501 } else {
502 assertEquals('Endnode should be span', spanElem, endNode);
503 assertEquals('Endoffset should be 3', 3, selRange.getEndOffset());
504 }
505 }
506
507 function testRangeStartingAfterBR() {
508 dynamic.innerHTML = '<span id="a">123<br>4567</span>';
509 var spanElem = goog.dom.getElement('a');
510 var range =
511 goog.dom.browserrange.createRangeFromNodes(spanElem, 2, spanElem, 3);
512 var htmlText = range.getValidHtml().toLowerCase();
513 assertNotContains('Should not include BR in HTML.', 'br', htmlText);
514 assertEquals('Should have correct text.', '4567', range.getText());
515
516 range.select();
517
518 var selRange = goog.dom.Range.createFromWindow();
519 var startNode = selRange.getStartNode();
520 if (startNode.nodeType == goog.dom.NodeType.TEXT) {
521 // Special case for Webkit (up to Chrome 57) and IE8.
522 assertEquals(
523 'Startnode should have text:4567', '4567', startNode.nodeValue);
524 assertEquals('Startoffset should be 0', 0, selRange.getStartOffset());
525 } else {
526 assertEquals('Start node should be span', spanElem, startNode);
527 assertEquals('Startoffset should be 2', 2, selRange.getStartOffset());
528 }
529 var endNode = selRange.getEndNode();
530 if (startNode.nodeType == goog.dom.NodeType.TEXT) {
531 // Special case for Webkit (up to Chrome 57) and IE8.
532 assertEquals('Endnode should have text:4567', '4567', endNode.nodeValue);
533 assertEquals('Endoffset should be 4', 4, selRange.getEndOffset());
534 } else {
535 assertEquals('Endnode should be span', spanElem, endNode);
536 assertEquals('Endoffset should be 3', 3, selRange.getEndOffset());
537 }
538 }
539
540 function testCollapsedRangeBeforeBR() {
541 dynamic.innerHTML = '<span id="a">123<br>456</span>';
542 var range = goog.dom.browserrange.createRangeFromNodes(
543 goog.dom.getElement('a'), 1, goog.dom.getElement('a'), 1);
544 // Firefox returns <span id="a"></span> as the range HTML while IE returns
545 // empty string. Therefore skipping the HTML check.
546 assertEquals('Should have no text.', '', range.getText());
547 }
548
549 function testCollapsedRangeAfterBR() {
550 dynamic.innerHTML = '<span id="a">123<br>456</span>';
551 var range = goog.dom.browserrange.createRangeFromNodes(
552 goog.dom.getElement('a'), 2, goog.dom.getElement('a'), 2);
553 // Firefox returns <span id="a"></span> as the range HTML while IE returns
554 // empty string. Therefore skipping the HTML check.
555 assertEquals('Should have no text.', '', range.getText());
556 }
557
558 function testCompareBrowserRangeEndpoints() {
559 var outer = goog.dom.getElement('outer');
560 var inner = goog.dom.getElement('inner');
561 var range_outer = goog.dom.browserrange.createRangeFromNodeContents(outer);
562 var range_inner = goog.dom.browserrange.createRangeFromNodeContents(inner);
563
564 assertEquals(
565 'The start of the inner selection should be after the outer.', 1,
566 range_inner.compareBrowserRangeEndpoints(
567 range_outer.getBrowserRange(), goog.dom.RangeEndpoint.START,
568 goog.dom.RangeEndpoint.START));
569
570 assertEquals(
571 "The start of the inner selection should be before the outer's end.", -1,
572 range_inner.compareBrowserRangeEndpoints(
573 range_outer.getBrowserRange(), goog.dom.RangeEndpoint.START,
574 goog.dom.RangeEndpoint.END));
575
576 assertEquals(
577 "The end of the inner selection should be after the outer's start.", 1,
578 range_inner.compareBrowserRangeEndpoints(
579 range_outer.getBrowserRange(), goog.dom.RangeEndpoint.END,
580 goog.dom.RangeEndpoint.START));
581
582 assertEquals(
583 "The end of the inner selection should be before the outer's end.", -1,
584 range_inner.compareBrowserRangeEndpoints(
585 range_outer.getBrowserRange(), goog.dom.RangeEndpoint.END,
586 goog.dom.RangeEndpoint.END));
587 }
588
589
590 /**
591 * Regression test for a bug in IeRange.insertNode_ where if the node to be
592 * inserted was not an element (e.g. a text node), it would clone the node
593 * in the inserting process but return the original node instead of the newly
594 * created and inserted node.
595 */
596 function testInsertNodeNonElement() {
597 goog.dom.setTextContent(dynamic, 'beforeafter');
598 var range = goog.dom.browserrange.createRangeFromNodes(
599 dynamic.firstChild, 6, dynamic.firstChild, 6);
600 var newNode = goog.dom.createTextNode('INSERTED');
601 var inserted = range.insertNode(newNode, false);
602
603 assertEquals(
604 'Text should be inserted between "before" and "after"',
605 'beforeINSERTEDafter', goog.dom.getRawTextContent(dynamic));
606 assertEquals(
607 'Node returned by insertNode() should be a child of the div' +
608 ' containing the text',
609 dynamic, inserted.parentNode);
610 }
611
612 function testSelectOverwritesOldSelection() {
613 goog.dom.browserrange.createRangeFromNodes(test1, 0, test1, 1).select();
614 goog.dom.browserrange.createRangeFromNodes(test2, 0, test2, 1).select();
615 assertEquals(
616 'The old selection must be replaced with the new one', 'abc',
617 goog.dom.Range.createFromWindow().getText());
618 }
619
620 // Following testcase is special for IE. The comparison of ranges created in
621 // testcases with a range over empty span using native inRange fails. So the
622 // fallback mechanism is needed.
623 function testGetContainerInTextNodesAroundEmptySpan() {
624 dynamic.innerHTML = 'abc<span></span>def';
625 var abc = dynamic.firstChild;
626 var def = dynamic.lastChild;
627
628 var range;
629 range = goog.dom.browserrange.createRangeFromNodes(abc, 1, abc, 1);
630 assertEquals(
631 'textNode abc should be the range container', abc, range.getContainer());
632 assertEquals(
633 'textNode abc should be the range start node', abc, range.getStartNode());
634 assertEquals(
635 'textNode abc should be the range end node', abc, range.getEndNode());
636
637 range = goog.dom.browserrange.createRangeFromNodes(def, 1, def, 1);
638 assertEquals(
639 'textNode def should be the range container', def, range.getContainer());
640 assertEquals(
641 'textNode def should be the range start node', def, range.getStartNode());
642 assertEquals(
643 'textNode def should be the range end node', def, range.getEndNode());
644 }