Debian Codegraph @

closure-library/closure/goog/dom/range_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.RangeTest');
16 goog.setTestOnly('goog.dom.RangeTest');
17
18 goog.require('goog.dom');
19 goog.require('goog.dom.NodeType');
20 goog.require('goog.dom.Range');
21 goog.require('goog.dom.RangeType');
22 goog.require('goog.dom.TagName');
23 goog.require('goog.dom.TextRange');
24 goog.require('goog.dom.browserrange');
25 goog.require('goog.testing.dom');
26 goog.require('goog.testing.jsunit');
27 goog.require('goog.userAgent');
28
29 var assertRangeEquals = goog.testing.dom.assertRangeEquals;
30
31 function setUp() {
32 // Reset the focus; some tests may invalidate the focus to exercise various
33 // browser bugs.
34 var focusableElement = goog.dom.getElement('focusableElement');
35 focusableElement.focus();
36 focusableElement.blur();
37 }
38
39 function normalizeHtml(str) {
40 return str.toLowerCase()
41 .replace(/[\n\r\f"]/g, '')
42 .replace(/<\/li>/g, ''); // " for emacs
43 }
44
45 function testCreate() {
46 assertNotNull(
47 'Browser range object can be created for node',
48 goog.dom.Range.createFromNodeContents(goog.dom.getElement('test1')));
49 }
50
51 function testTableRange() {
52 var tr = goog.dom.getElement('cell').parentNode;
53 var range = goog.dom.Range.createFromNodeContents(tr);
54 assertEquals('Selection should have correct text', '12', range.getText());
55 assertEquals(
56 'Selection should have correct html fragment', '1</td><td>2',
57 normalizeHtml(range.getHtmlFragment()));
58
59 // TODO(robbyw): On IE the TR is included, on FF it is not.
60 // assertEquals('Selection should have correct valid html',
61 // '<tr id=row><td>1</td><td>2</td></tr>',
62 // normalizeHtml(range.getValidHtml()));
63
64 assertEquals(
65 'Selection should have correct pastable html',
66 '<table><tbody><tr><td id=cell>1</td><td>2</td></tr></tbody></table>',
67 normalizeHtml(range.getPastableHtml()));
68 }
69
70 function testUnorderedListRange() {
71 var ul = goog.dom.getElement('ulTest').firstChild;
72 var range = goog.dom.Range.createFromNodeContents(ul);
73 assertEquals(
74 'Selection should have correct html fragment', '1<li>2',
75 normalizeHtml(range.getHtmlFragment()));
76
77 // TODO(robbyw): On IE the UL is included, on FF it is not.
78 // assertEquals('Selection should have correct valid html',
79 // '<li>1</li><li>2</li>', normalizeHtml(range.getValidHtml()));
80
81 assertEquals(
82 'Selection should have correct pastable html', '<ul><li>1<li>2</ul>',
83 normalizeHtml(range.getPastableHtml()));
84 }
85
86 function testOrderedListRange() {
87 var ol = goog.dom.getElement('olTest').firstChild;
88 var range = goog.dom.Range.createFromNodeContents(ol);
89 assertEquals(
90 'Selection should have correct html fragment', '1<li>2',
91 normalizeHtml(range.getHtmlFragment()));
92
93 // TODO(robbyw): On IE the OL is included, on FF it is not.
94 // assertEquals('Selection should have correct valid html',
95 // '<li>1</li><li>2</li>', normalizeHtml(range.getValidHtml()));
96
97 assertEquals(
98 'Selection should have correct pastable html', '<ol><li>1<li>2</ol>',
99 normalizeHtml(range.getPastableHtml()));
100 }
101
102 function testCreateFromNodes() {
103 var start = goog.dom.getElement('test1').firstChild;
104 var end = goog.dom.getElement('br');
105 var range = goog.dom.Range.createFromNodes(start, 2, end, 0);
106 assertNotNull(
107 'Browser range object can be created for W3C node range', range);
108
109 assertEquals(
110 'Start node should be selected at start endpoint', start,
111 range.getStartNode());
112 assertEquals('Selection should start at offset 2', 2, range.getStartOffset());
113 assertEquals(
114 'Start node should be selected at anchor endpoint', start,
115 range.getAnchorNode());
116 assertEquals(
117 'Selection should be anchored at offset 2', 2, range.getAnchorOffset());
118
119 var div = goog.dom.getElement('test2');
120 assertEquals(
121 'DIV node should be selected at end endpoint', div, range.getEndNode());
122 assertEquals('Selection should end at offset 1', 1, range.getEndOffset());
123 assertEquals(
124 'DIV node should be selected at focus endpoint', div,
125 range.getFocusNode());
126 assertEquals(
127 'Selection should be focused at offset 1', 1, range.getFocusOffset());
128
129
130 assertTrue(
131 'Text content should be "xt\\s*abc"', /xt\s*abc/.test(range.getText()));
132 assertFalse('Nodes range is not collapsed', range.isCollapsed());
133 }
134
135
136 function testCreateControlRange() {
137 if (!goog.userAgent.IE) {
138 return;
139 }
140 var cr = document.body.createControlRange();
141 cr.addElement(goog.dom.getElement('logo'));
142
143 var range = goog.dom.Range.createFromBrowserRange(cr);
144 assertNotNull(
145 'Control range object can be created from browser range', range);
146 assertEquals(
147 'Created range is a control range', goog.dom.RangeType.CONTROL,
148 range.getType());
149 }
150
151
152 function testTextNode() {
153 var range = goog.dom.Range.createFromNodeContents(
154 goog.dom.getElement('test1').firstChild);
155
156 assertEquals(
157 'Created range is a text range', goog.dom.RangeType.TEXT,
158 range.getType());
159 assertEquals(
160 'Text node should be selected at start endpoint', 'Text',
161 range.getStartNode().nodeValue);
162 assertEquals('Selection should start at offset 0', 0, range.getStartOffset());
163
164 assertEquals(
165 'Text node should be selected at end endpoint', 'Text',
166 range.getEndNode().nodeValue);
167 assertEquals(
168 'Selection should end at offset 4', 'Text'.length, range.getEndOffset());
169
170 assertEquals(
171 'Container should be text node', goog.dom.NodeType.TEXT,
172 range.getContainer().nodeType);
173
174 assertEquals('Text content should be "Text"', 'Text', range.getText());
175 assertFalse('Text range is not collapsed', range.isCollapsed());
176 }
177
178
179 function testDiv() {
180 var range =
181 goog.dom.Range.createFromNodeContents(goog.dom.getElement('test2'));
182
183 assertEquals(
184 'Text node "abc" should be selected at start endpoint', 'abc',
185 range.getStartNode().nodeValue);
186 assertEquals('Selection should start at offset 0', 0, range.getStartOffset());
187
188 assertEquals(
189 'Text node "def" should be selected at end endpoint', 'def',
190 range.getEndNode().nodeValue);
191 assertEquals(
192 'Selection should end at offset 3', 'def'.length, range.getEndOffset());
193
194 assertEquals(
195 'Container should be DIV', goog.dom.getElement('test2'),
196 range.getContainer());
197
198 assertTrue(
199 'Div text content should be "abc\\s*def"',
200 /abc\s*def/.test(range.getText()));
201 assertFalse('Div range is not collapsed', range.isCollapsed());
202 }
203
204
205 function testEmptyNode() {
206 var range =
207 goog.dom.Range.createFromNodeContents(goog.dom.getElement('empty'));
208
209 assertEquals(
210 'DIV be selected at start endpoint', goog.dom.getElement('empty'),
211 range.getStartNode());
212 assertEquals('Selection should start at offset 0', 0, range.getStartOffset());
213
214 assertEquals(
215 'DIV should be selected at end endpoint', goog.dom.getElement('empty'),
216 range.getEndNode());
217 assertEquals('Selection should end at offset 0', 0, range.getEndOffset());
218
219 assertEquals(
220 'Container should be DIV', goog.dom.getElement('empty'),
221 range.getContainer());
222
223 assertEquals('Empty text content should be ""', '', range.getText());
224 assertTrue('Empty range is collapsed', range.isCollapsed());
225 }
226
227
228 function testCollapse() {
229 var range =
230 goog.dom.Range.createFromNodeContents(goog.dom.getElement('test2'));
231 assertFalse('Div range is not collapsed', range.isCollapsed());
232 range.collapse();
233 assertTrue(
234 'Div range is collapsed after call to empty()', range.isCollapsed());
235
236 range = goog.dom.Range.createFromNodeContents(goog.dom.getElement('empty'));
237 assertTrue('Empty range is collapsed', range.isCollapsed());
238 range.collapse();
239 assertTrue('Empty range is still collapsed', range.isCollapsed());
240 }
241
242 // TODO(robbyw): Test iteration over a strange document fragment.
243
244 function testIterator() {
245 goog.testing.dom.assertNodesMatch(
246 goog.dom.Range.createFromNodeContents(goog.dom.getElement('test2')),
247 ['abc', '#br', '#br', 'def']);
248 }
249
250 function testReversedNodes() {
251 var node = goog.dom.getElement('test1').firstChild;
252 var range = goog.dom.Range.createFromNodes(node, 4, node, 0);
253 assertTrue('Range is reversed', range.isReversed());
254 node = goog.dom.getElement('test3');
255 range = goog.dom.Range.createFromNodes(node, 0, node, 1);
256 assertFalse('Range is not reversed', range.isReversed());
257 }
258
259 function testReversedContents() {
260 var range =
261 goog.dom.Range.createFromNodeContents(goog.dom.getElement('test1'), true);
262 assertTrue('Range is reversed', range.isReversed());
263 assertEquals('Range should select "Text"', 'Text', range.getText());
264 assertEquals('Range start offset should be 0', 0, range.getStartOffset());
265 assertEquals('Range end offset should be 4', 4, range.getEndOffset());
266 assertEquals('Range anchor offset should be 4', 4, range.getAnchorOffset());
267 assertEquals('Range focus offset should be 0', 0, range.getFocusOffset());
268
269 var range2 = range.clone();
270
271 range.collapse(true);
272 assertTrue('Range is collapsed', range.isCollapsed());
273 assertFalse('Collapsed range is not reversed', range.isReversed());
274 assertEquals(
275 'Post collapse start offset should be 4', 4, range.getStartOffset());
276
277 range2.collapse(false);
278 assertTrue('Range 2 is collapsed', range2.isCollapsed());
279 assertFalse('Collapsed range 2 is not reversed', range2.isReversed());
280 assertEquals(
281 'Post collapse start offset 2 should be 0', 0, range2.getStartOffset());
282 }
283
284 function testRemoveContents() {
285 var outer = goog.dom.getElement('removeTest');
286 var range = goog.dom.Range.createFromNodeContents(outer.firstChild);
287
288 range.removeContents();
289
290 assertEquals('Removed range content should be ""', '', range.getText());
291 assertTrue('Removed range should be collapsed', range.isCollapsed());
292 assertEquals('Outer div should have 1 child now', 1, outer.childNodes.length);
293 assertEquals(
294 'Inner div should be empty', 0, outer.firstChild.childNodes.length);
295 }
296
297 function testRemovePartialContents() {
298 var outer = goog.dom.getElement('removePartialTest');
299 var originalText = goog.dom.getTextContent(outer);
300
301 try {
302 var range = goog.dom.Range.createFromNodes(
303 outer.firstChild, 2, outer.firstChild, 4);
304 removeHelper(1, range, outer, 1, '0145');
305
306 range = goog.dom.Range.createFromNodes(
307 outer.firstChild, 0, outer.firstChild, 1);
308 removeHelper(2, range, outer, 1, '145');
309
310 range = goog.dom.Range.createFromNodes(
311 outer.firstChild, 2, outer.firstChild, 3);
312 removeHelper(3, range, outer, 1, '14');
313
314 var br = goog.dom.createDom(goog.dom.TagName.BR);
315 outer.appendChild(br);
316 range = goog.dom.Range.createFromNodes(outer.firstChild, 1, outer, 1);
317 removeHelper(4, range, outer, 2, '1<br>');
318
319 outer.innerHTML = '<br>123';
320 range = goog.dom.Range.createFromNodes(outer, 0, outer.lastChild, 2);
321 removeHelper(5, range, outer, 1, '3');
322
323 outer.innerHTML = '123<br>456';
324 range =
325 goog.dom.Range.createFromNodes(outer.firstChild, 1, outer.lastChild, 2);
326 removeHelper(6, range, outer, 2, '16');
327
328 outer.innerHTML = '123<br>456';
329 range =
330 goog.dom.Range.createFromNodes(outer.firstChild, 0, outer.lastChild, 2);
331 removeHelper(7, range, outer, 1, '6');
332
333 outer.innerHTML = '<div></div>';
334 range = goog.dom.Range.createFromNodeContents(outer.firstChild);
335 removeHelper(8, range, outer, 1, '<div></div>');
336 } finally {
337 // Restore the original text state for repeated runs.
338 goog.dom.setTextContent(outer, originalText);
339 }
340
341 // TODO(robbyw): Fix the following edge cases:
342 // * Selecting contents of a node containing multiply empty divs
343 // * Selecting via createFromNodes(x, 0, x, x.childNodes.length)
344 // * Consistent handling of nodeContents(<div><div></div></div>).remove
345 }
346
347 function removeHelper(
348 testNumber, range, outer, expectedChildCount, expectedContent) {
349 range.removeContents();
350 assertTrue(
351 testNumber + ': Removed range should now be collapsed',
352 range.isCollapsed());
353 assertEquals(
354 testNumber + ': Removed range content should be ""', '', range.getText());
355 assertEquals(
356 testNumber + ': Outer div should contain correct text', expectedContent,
357 outer.innerHTML.toLowerCase());
358 assertEquals(
359 testNumber + ': Outer div should have ' + expectedChildCount +
360 ' children now',
361 expectedChildCount, outer.childNodes.length);
362 assertNotNull(
363 testNumber + ': Empty node should still exist',
364 goog.dom.getElement('empty'));
365 }
366
367 function testSurroundContents() {
368 var outer = goog.dom.getElement('surroundTest');
369 outer.innerHTML = '---Text that<br>will be surrounded---';
370 var range = goog.dom.Range.createFromNodes(
371 outer.firstChild, 3, outer.lastChild,
372 outer.lastChild.nodeValue.length - 3);
373
374 var div = goog.dom.createDom(goog.dom.TagName.DIV, {'style': 'color: red'});
375 var output = range.surroundContents(div);
376
377 assertEquals(
378 'Outer element should contain new element', outer, output.parentNode);
379 assertFalse('New element should have no id', !!output.id);
380 assertEquals('New element should be red', 'red', output.style.color);
381 assertEquals(
382 'Outer element should have three children', 3, outer.childNodes.length);
383 assertEquals(
384 'New element should have three children', 3, output.childNodes.length);
385
386 // TODO(robbyw): Ensure the range stays in a reasonable state.
387 }
388
389
390 /**
391 * Given two offsets into the 'foobar' node, make sure that inserting
392 * nodes at those offsets doesn't change a selection of 'oba'.
393 * @bug 1480638
394 */
395 function assertSurroundDoesntChangeSelectionWithOffsets(
396 offset1, offset2, expectedHtml) {
397 var div = goog.dom.getElement('bug1480638');
398 goog.dom.setTextContent(div, 'foobar');
399 var rangeToSelect =
400 goog.dom.Range.createFromNodes(div.firstChild, 2, div.firstChild, 5);
401 rangeToSelect.select();
402
403 var rangeToSurround = goog.dom.Range.createFromNodes(
404 div.firstChild, offset1, div.firstChild, offset2);
405 rangeToSurround.surroundWithNodes(
406 goog.dom.createDom(goog.dom.TagName.SPAN),
407 goog.dom.createDom(goog.dom.TagName.SPAN));
408
409 // Make sure that the selection didn't change.
410 assertHTMLEquals(
411 'Selection must not change when contents are surrounded.', expectedHtml,
412 goog.dom.Range.createFromWindow().getHtmlFragment());
413 }
414
415 function testSurroundWithNodesDoesntChangeSelection1() {
416 assertSurroundDoesntChangeSelectionWithOffsets(
417 3, 4, 'o<span></span>b<span></span>a');
418 }
419
420 function testSurroundWithNodesDoesntChangeSelection2() {
421 assertSurroundDoesntChangeSelectionWithOffsets(3, 6, 'o<span></span>ba');
422 }
423
424 function testSurroundWithNodesDoesntChangeSelection3() {
425 assertSurroundDoesntChangeSelectionWithOffsets(1, 3, 'o<span></span>ba');
426 }
427
428 function testSurroundWithNodesDoesntChangeSelection4() {
429 assertSurroundDoesntChangeSelectionWithOffsets(1, 6, 'oba');
430 }
431
432 function testInsertNode() {
433 var outer = goog.dom.getElement('insertTest');
434 goog.dom.setTextContent(outer, 'ACD');
435
436 var range =
437 goog.dom.Range.createFromNodes(outer.firstChild, 1, outer.firstChild, 2);
438 range.insertNode(goog.dom.createTextNode('B'), true);
439 assertEquals(
440 'Element should have correct innerHTML', 'ABCD', outer.innerHTML);
441
442 goog.dom.setTextContent(outer, '12');
443 range =
444 goog.dom.Range.createFromNodes(outer.firstChild, 0, outer.firstChild, 1);
445 var br = range.insertNode(goog.dom.createDom(goog.dom.TagName.BR), false);
446 assertEquals(
447 'New element should have correct innerHTML', '1<br>2',
448 outer.innerHTML.toLowerCase());
449 assertEquals('BR should be in outer', outer, br.parentNode);
450 }
451
452 function testReplaceContentsWithNode() {
453 var outer = goog.dom.getElement('insertTest');
454 goog.dom.setTextContent(outer, 'AXC');
455
456 var range =
457 goog.dom.Range.createFromNodes(outer.firstChild, 1, outer.firstChild, 2);
458 range.replaceContentsWithNode(goog.dom.createTextNode('B'));
459 assertEquals('Element should have correct innerHTML', 'ABC', outer.innerHTML);
460
461 goog.dom.setTextContent(outer, 'ABC');
462 range =
463 goog.dom.Range.createFromNodes(outer.firstChild, 3, outer.firstChild, 3);
464 range.replaceContentsWithNode(goog.dom.createTextNode('D'));
465 assertEquals(
466 'Element should have correct innerHTML after collapsed replace', 'ABCD',
467 outer.innerHTML);
468
469 outer.innerHTML = 'AX<b>X</b>XC';
470 range =
471 goog.dom.Range.createFromNodes(outer.firstChild, 1, outer.lastChild, 1);
472 range.replaceContentsWithNode(goog.dom.createTextNode('B'));
473 goog.testing.dom.assertHtmlContentsMatch('ABC', outer);
474 }
475
476 function testSurroundWithNodes() {
477 var outer = goog.dom.getElement('insertTest');
478 goog.dom.setTextContent(outer, 'ACE');
479 var range =
480 goog.dom.Range.createFromNodes(outer.firstChild, 1, outer.firstChild, 2);
481
482 range.surroundWithNodes(
483 goog.dom.createTextNode('B'), goog.dom.createTextNode('D'));
484
485 assertEquals(
486 'New element should have correct innerHTML', 'ABCDE', outer.innerHTML);
487 }
488
489 function testIsRangeInDocument() {
490 var outer = goog.dom.getElement('insertTest');
491 outer.innerHTML = '<br>ABC';
492 var range = goog.dom.Range.createCaret(outer.lastChild, 1);
493
494 assertEquals(
495 'Should get correct start element', 'ABC',
496 range.getStartNode().nodeValue);
497 assertTrue('Should be considered in document', range.isRangeInDocument());
498
499 goog.dom.setTextContent(outer, 'DEF');
500
501 assertFalse('Should be marked as out of document', range.isRangeInDocument());
502 }
503
504 function testRemovedNode() {
505 var node = goog.dom.getElement('removeNodeTest');
506 var range = goog.dom.browserrange.createRangeFromNodeContents(node);
507 range.select();
508 goog.dom.removeNode(node);
509
510 var newRange = goog.dom.Range.createFromWindow(window);
511
512 // In Chrome 14 and below (<= Webkit 535.1), newRange will be null.
513 // In Chrome 16 and above (>= Webkit 535.7), newRange will be collapsed
514 // like on other browsers.
515 // We didn't bother testing in between.
516 if (goog.userAgent.WEBKIT && !goog.userAgent.isVersionOrHigher('535.7')) {
517 assertNull('Webkit supports rangeCount == 0', newRange);
518 } else {
519 assertTrue(
520 'The other browsers will just have an empty range.',
521 newRange.isCollapsed());
522 }
523 }
524
525 function testReversedRange() {
526 if (goog.userAgent.EDGE_OR_IE) return; // IE doesn't make this distinction.
527
528 goog.dom.Range
529 .createFromNodes(
530 goog.dom.getElement('test2'), 0, goog.dom.getElement('test1'), 0)
531 .select();
532
533 var range = goog.dom.Range.createFromWindow(window);
534 assertTrue('Range should be reversed', range.isReversed());
535 }
536
537 function testUnreversedRange() {
538 goog.dom.Range
539 .createFromNodes(
540 goog.dom.getElement('test1'), 0, goog.dom.getElement('test2'), 0)
541 .select();
542
543 var range = goog.dom.Range.createFromWindow(window);
544 assertFalse('Range should not be reversed', range.isReversed());
545 }
546
547 function testReversedThenUnreversedRange() {
548 // This tests a workaround for a webkit bug where webkit caches selections
549 // incorrectly.
550 goog.dom.Range
551 .createFromNodes(
552 goog.dom.getElement('test2'), 0, goog.dom.getElement('test1'), 0)
553 .select();
554 goog.dom.Range
555 .createFromNodes(
556 goog.dom.getElement('test1'), 0, goog.dom.getElement('test2'), 0)
557 .select();
558
559 var range = goog.dom.Range.createFromWindow(window);
560 assertFalse('Range should not be reversed', range.isReversed());
561 }
562
563 function testHasAndClearSelection() {
564 goog.dom.Range.createFromNodeContents(goog.dom.getElement('test1')).select();
565
566 assertTrue('Selection should exist', goog.dom.Range.hasSelection());
567
568 goog.dom.Range.clearSelection();
569
570 assertFalse('Selection should not exist', goog.dom.Range.hasSelection());
571 }
572
573 function assertForward(string, startNode, startOffset, endNode, endOffset) {
574 var root = goog.dom.getElement('test2');
575 var originalInnerHtml = root.innerHTML;
576
577 assertFalse(
578 string,
579 goog.dom.Range.isReversed(startNode, startOffset, endNode, endOffset));
580 assertTrue(
581 string,
582 goog.dom.Range.isReversed(endNode, endOffset, startNode, startOffset));
583 assertEquals(
584 'Contents should be unaffected after: ' + string, root.innerHTML,
585 originalInnerHtml);
586 }
587
588 function testIsReversed() {
589 var root = goog.dom.getElement('test2');
590 var text1 = root.firstChild; // Text content: 'abc'.
591 var br = root.childNodes[1];
592 var text2 = root.lastChild; // Text content: 'def'.
593
594 assertFalse(
595 'Same element position gives false',
596 goog.dom.Range.isReversed(root, 0, root, 0));
597 assertFalse(
598 'Same text position gives false',
599 goog.dom.Range.isReversed(text1, 0, text2, 0));
600 assertForward(
601 'Element offsets should compare against each other', root, 0, root, 2);
602 assertForward(
603 'Text node offsets should compare against each other', text1, 0, text2,
604 2);
605 assertForward('Text nodes should compare correctly', text1, 0, text2, 0);
606 assertForward('Text nodes should compare to later elements', text1, 0, br, 0);
607 assertForward(
608 'Text nodes should compare to earlier elements', br, 0, text2, 0);
609 assertForward('Parent is before element child', root, 0, br, 0);
610 assertForward('Parent is before text child', root, 0, text1, 0);
611 assertFalse(
612 'Equivalent position gives false',
613 goog.dom.Range.isReversed(root, 0, text1, 0));
614 assertFalse(
615 'Equivalent position gives false',
616 goog.dom.Range.isReversed(root, 1, br, 0));
617 assertForward('End of element is after children', text1, 0, root, 3);
618 assertForward('End of element is after children', br, 0, root, 3);
619 assertForward('End of element is after children', text2, 0, root, 3);
620 assertForward('End of element is after end of last child', text2, 3, root, 3);
621 }
622
623 function testSelectAroundSpaces() {
624 // set the selection
625 var textNode = goog.dom.getElement('textWithSpaces').firstChild;
626 goog.dom.TextRange.createFromNodes(textNode, 5, textNode, 12).select();
627
628 // get the selection and check that it matches what we set it to
629 var range = goog.dom.Range.createFromWindow();
630 assertEquals(' world ', range.getText());
631 assertEquals(5, range.getStartOffset());
632 assertEquals(12, range.getEndOffset());
633 assertEquals(textNode, range.getContainer());
634
635 // Check the contents again, because there used to be a bug where
636 // it changed after calling getContainer().
637 assertEquals(' world ', range.getText());
638 }
639
640 function testSelectInsideSpaces() {
641 // set the selection
642 var textNode = goog.dom.getElement('textWithSpaces').firstChild;
643 goog.dom.TextRange.createFromNodes(textNode, 6, textNode, 11).select();
644
645 // get the selection and check that it matches what we set it to
646 var range = goog.dom.Range.createFromWindow();
647 assertEquals('world', range.getText());
648 assertEquals(6, range.getStartOffset());
649 assertEquals(11, range.getEndOffset());
650 assertEquals(textNode, range.getContainer());
651
652 // Check the contents again, because there used to be a bug where
653 // it changed after calling getContainer().
654 assertEquals('world', range.getText());
655 }
656
657 function testRangeBeforeBreak() {
658 var container = goog.dom.getElement('rangeAroundBreaks');
659 var text = container.firstChild;
660 var offset = text.length;
661 assertEquals(4, offset);
662
663 var br = container.childNodes[1];
664 var caret = goog.dom.Range.createCaret(text, offset);
665 caret.select();
666 assertEquals(offset, caret.getStartOffset());
667
668 var range = goog.dom.Range.createFromWindow();
669 assertFalse('Should not contain whole <br>', range.containsNode(br, false));
670 if (goog.userAgent.IE && !goog.userAgent.isDocumentModeOrHigher(9)) {
671 assertTrue(
672 'Range over <br> is adjacent to the immediate range before it',
673 range.containsNode(br, true));
674 } else {
675 assertFalse(
676 'Should not contain partial <br>', range.containsNode(br, true));
677 }
678
679 assertEquals(offset, range.getStartOffset());
680 assertEquals(text, range.getStartNode());
681 }
682
683 function testRangeAfterBreak() {
684 var container = goog.dom.getElement('rangeAroundBreaks');
685 var br = container.childNodes[1];
686 var caret = goog.dom.Range.createCaret(container.lastChild, 0);
687 caret.select();
688 assertEquals(0, caret.getStartOffset());
689
690 var range = goog.dom.Range.createFromWindow();
691 assertFalse('Should not contain whole <br>', range.containsNode(br, false));
692 var isSafari3 =
693 goog.userAgent.WEBKIT && !goog.userAgent.isVersionOrHigher('528');
694
695 if (goog.userAgent.IE && !goog.userAgent.isDocumentModeOrHigher(9) ||
696 isSafari3) {
697 assertTrue(
698 'Range over <br> is adjacent to the immediate range after it',
699 range.containsNode(br, true));
700 } else {
701 assertFalse(
702 'Should not contain partial <br>', range.containsNode(br, true));
703 }
704
705 if (isSafari3) {
706 assertEquals(2, range.getStartOffset());
707 assertEquals(container, range.getStartNode());
708 } else {
709 assertEquals(0, range.getStartOffset());
710 assertEquals(container.lastChild, range.getStartNode());
711 }
712 }
713
714 function testRangeAtBreakAtStart() {
715 var container = goog.dom.getElement('breaksAroundNode');
716 var br = container.firstChild;
717 var caret = goog.dom.Range.createCaret(container.firstChild, 0);
718 caret.select();
719 assertEquals(0, caret.getStartOffset());
720
721 var range = goog.dom.Range.createFromWindow();
722 assertTrue(
723 'Range over <br> is adjacent to the immediate range before it',
724 range.containsNode(br, true));
725 assertFalse('Should not contain whole <br>', range.containsNode(br, false));
726
727 assertRangeEquals(container, 0, container, 0, range);
728 }
729
730 function testFocusedElementDisappears() {
731 // This reproduces a failure case specific to Gecko, where an element is
732 // created, contentEditable is set, is focused, and removed. After that
733 // happens, calling selection.collapse fails.
734 // https://bugzilla.mozilla.org/show_bug.cgi?id=773137
735 var disappearingElement = goog.dom.createDom(goog.dom.TagName.DIV);
736 document.body.appendChild(disappearingElement);
737 disappearingElement.contentEditable = true;
738 disappearingElement.focus();
739 document.body.removeChild(disappearingElement);
740 var container = goog.dom.getElement('empty');
741 var caret = goog.dom.Range.createCaret(container, 0);
742 // This should not throw.
743 caret.select();
744 assertEquals(0, caret.getStartOffset());
745 }
746
747 function assertNodeEquals(expected, actual) {
748 assertEquals(
749 'Expected: ' + goog.testing.dom.exposeNode(expected) + '\nActual: ' +
750 goog.testing.dom.exposeNode(actual),
751 expected, actual);
752 }