Debian Codegraph @

closure-library/closure/goog/editor/range_test.js

raw
1 // Copyright 2008 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.editor.rangeTest');
16 goog.setTestOnly('goog.editor.rangeTest');
17
18 goog.require('goog.dom');
19 goog.require('goog.dom.Range');
20 goog.require('goog.dom.TagName');
21 goog.require('goog.editor.range');
22 goog.require('goog.editor.range.Point');
23 goog.require('goog.string');
24 goog.require('goog.testing.dom');
25 goog.require('goog.testing.jsunit');
26 goog.require('goog.userAgent');
27
28 var savedHtml;
29 var $;
30
31 function setUpPage() {
32 $ = goog.dom.getElement;
33 }
34
35 function setUp() {
36 savedHtml = $('root').innerHTML;
37 }
38
39 function tearDown() {
40 $('root').innerHTML = savedHtml;
41 }
42
43 function testNoNarrow() {
44 var def = $('def');
45 var jkl = $('jkl');
46 var range =
47 goog.dom.Range.createFromNodes(def.firstChild, 1, jkl.firstChild, 2);
48
49 range = goog.editor.range.narrow(range, $('parentNode'));
50 goog.testing.dom.assertRangeEquals(
51 def.firstChild, 1, jkl.firstChild, 2, range);
52 }
53
54 function testNarrowAtEndEdge() {
55 var def = $('def');
56 var jkl = $('jkl');
57 var range =
58 goog.dom.Range.createFromNodes(def.firstChild, 1, jkl.firstChild, 2);
59
60 range = goog.editor.range.narrow(range, def);
61 goog.testing.dom.assertRangeEquals(
62 def.firstChild, 1, def.firstChild, 3, range);
63 }
64
65 function testNarrowAtStartEdge() {
66 var def = $('def');
67 var jkl = $('jkl');
68 var range =
69 goog.dom.Range.createFromNodes(def.firstChild, 1, jkl.firstChild, 2);
70
71 range = goog.editor.range.narrow(range, jkl);
72
73 goog.testing.dom.assertRangeEquals(
74 jkl.firstChild, 0, jkl.firstChild, 2, range);
75 }
76
77 function testNarrowOutsideElement() {
78 var def = $('def');
79 var jkl = $('jkl');
80 var range =
81 goog.dom.Range.createFromNodes(def.firstChild, 1, jkl.firstChild, 2);
82
83 range = goog.editor.range.narrow(range, $('pqr'));
84 assertNull(range);
85 }
86
87 function testNoExpand() {
88 var div = $('parentNode');
89 div.innerHTML = '<div>longword</div>';
90 // Select "ongwo" and make sure we don't expand since this is not
91 // a full container.
92 var textNode = div.firstChild.firstChild;
93 var range = goog.dom.Range.createFromNodes(textNode, 1, textNode, 6);
94
95 range = goog.editor.range.expand(range);
96 goog.testing.dom.assertRangeEquals(textNode, 1, textNode, 6, range);
97 }
98
99 function testSimpleExpand() {
100 var div = $('parentNode');
101 div.innerHTML = '<div>longword</div>foo';
102 // Select "longword" and make sure we do expand to include the div since
103 // the full container text is selected.
104 var textNode = div.firstChild.firstChild;
105 var range = goog.dom.Range.createFromNodes(textNode, 0, textNode, 8);
106
107 range = goog.editor.range.expand(range);
108 goog.testing.dom.assertRangeEquals(div, 0, div, 1, range);
109
110 // Select "foo" and make sure we expand out to the parent div.
111 var fooNode = div.lastChild;
112 range = goog.dom.Range.createFromNodes(fooNode, 0, fooNode, 3);
113
114 range = goog.editor.range.expand(range);
115 goog.testing.dom.assertRangeEquals(div, 1, div, 2, range);
116 }
117
118 function testDoubleExpand() {
119 var div = $('parentNode');
120 div.innerHTML = '<div><span>longword</span></div>foo';
121 // Select "longword" and make sure we do expand to include the span
122 // and the div since both of their full contents are selected.
123 var textNode = div.firstChild.firstChild.firstChild;
124 var range = goog.dom.Range.createFromNodes(textNode, 0, textNode, 8);
125
126 range = goog.editor.range.expand(range);
127 goog.testing.dom.assertRangeEquals(div, 0, div, 1, range);
128
129 // Same visible position, different dom position.
130 // Start in text node, end in span.
131 range = goog.dom.Range.createFromNodes(textNode, 0, textNode.parentNode, 1);
132
133 range = goog.editor.range.expand(range);
134 goog.testing.dom.assertRangeEquals(div, 0, div, 1, range);
135 }
136
137 function testMultipleChildrenExpand() {
138 var div = $('parentNode');
139 div.innerHTML = '<ol><li>one</li><li>two</li><li>three</li></ol>';
140 // Select "two" and make sure we expand to the li, but not the ol.
141 var li = div.firstChild.childNodes[1];
142 var textNode = li.firstChild;
143 var range = goog.dom.Range.createFromNodes(textNode, 0, textNode, 3);
144
145 range = goog.editor.range.expand(range);
146 goog.testing.dom.assertRangeEquals(li.parentNode, 1, li.parentNode, 2, range);
147
148 // Make the same visible selection, only slightly different dom position.
149 // Select starting from the text node, but ending in the li.
150 range = goog.dom.Range.createFromNodes(textNode, 0, li, 1);
151
152 range = goog.editor.range.expand(range);
153 goog.testing.dom.assertRangeEquals(li.parentNode, 1, li.parentNode, 2, range);
154 }
155
156 function testSimpleDifferentContainersExpand() {
157 var div = $('parentNode');
158 div.innerHTML = '<ol><li>1</li><li><b>bold</b><i>italic</i></li></ol>';
159 // Select all of "bold" and "italic" at the text node level, and
160 // make sure we expand to the li.
161 var li = div.firstChild.childNodes[1];
162 var boldNode = li.childNodes[0];
163 var italicNode = li.childNodes[1];
164 var range = goog.dom.Range.createFromNodes(
165 boldNode.firstChild, 0, italicNode.firstChild, 6);
166
167 range = goog.editor.range.expand(range);
168 goog.testing.dom.assertRangeEquals(li.parentNode, 1, li.parentNode, 2, range);
169
170 // Make the same visible selection, only slightly different dom position.
171 // Select "bold" at the b node level and "italic" at the text node level.
172 range = goog.dom.Range.createFromNodes(boldNode, 0, italicNode.firstChild, 6);
173
174 range = goog.editor.range.expand(range);
175 goog.testing.dom.assertRangeEquals(li.parentNode, 1, li.parentNode, 2, range);
176 }
177
178 function testSimpleDifferentContainersSmallExpand() {
179 var div = $('parentNode');
180 div.innerHTML = '<ol><li>1</li><li><b>bold</b><i>italic</i>' +
181 '<u>under</u></li></ol>';
182 // Select all of "bold" and "italic", but we can't expand to the
183 // entire li since we didn't select "under".
184 var li = div.firstChild.childNodes[1];
185 var boldNode = li.childNodes[0];
186 var italicNode = li.childNodes[1];
187 var range = goog.dom.Range.createFromNodes(
188 boldNode.firstChild, 0, italicNode.firstChild, 6);
189
190 range = goog.editor.range.expand(range);
191 goog.testing.dom.assertRangeEquals(li, 0, li, 2, range);
192
193 // Same visible position, different dom position.
194 // Select "bold" starting in text node, "italic" at i node.
195 range = goog.dom.Range.createFromNodes(boldNode.firstChild, 0, italicNode, 1);
196
197 range = goog.editor.range.expand(range);
198 goog.testing.dom.assertRangeEquals(li, 0, li, 2, range);
199 }
200
201 function testEmbeddedDifferentContainersExpand() {
202 var div = $('parentNode');
203 div.innerHTML = '<div><b><i>italic</i>after</b><u>under</u></div>foo';
204 // Select "italic" "after" "under", should expand all the way to parent.
205 var boldNode = div.firstChild.childNodes[0];
206 var italicNode = boldNode.childNodes[0];
207 var underNode = div.firstChild.childNodes[1];
208 var range = goog.dom.Range.createFromNodes(
209 italicNode.firstChild, 0, underNode.firstChild, 5);
210
211 range = goog.editor.range.expand(range);
212 goog.testing.dom.assertRangeEquals(div, 0, div, 1, range);
213 }
214
215 function testReverseSimpleExpand() {
216 var div = $('parentNode');
217 div.innerHTML = '<div>longword</div>foo';
218 // Select "longword" and make sure we do expand to include the div since
219 // the full container text is selected.
220 var textNode = div.firstChild.firstChild;
221 var range = goog.dom.Range.createFromNodes(textNode, 8, textNode, 0);
222
223 range = goog.editor.range.expand(range);
224
225 goog.testing.dom.assertRangeEquals(div, 0, div, 1, range);
226 }
227
228 function testExpandWithStopNode() {
229 var div = $('parentNode');
230 div.innerHTML = '<div><span>word</span></div>foo';
231 // Select "word".
232 var span = div.firstChild.firstChild;
233 var textNode = span.firstChild;
234 var range = goog.dom.Range.createFromNodes(textNode, 0, textNode, 4);
235
236 range = goog.editor.range.expand(range);
237
238 goog.testing.dom.assertRangeEquals(div, 0, div, 1, range);
239
240 // Same selection, but force stop at the span.
241 range = goog.dom.Range.createFromNodes(textNode, 0, textNode, 4);
242
243 range = goog.editor.range.expand(range, span);
244
245 goog.testing.dom.assertRangeEquals(span, 0, span, 1, range);
246 }
247
248 // Ojan didn't believe this code worked, this was the case he
249 // thought was broken. Keeping just as a regression test.
250 function testOjanCase() {
251 var div = $('parentNode');
252 div.innerHTML = '<em><i><b>foo</b>bar</i></em>';
253 // Select "foo", at text node level.
254 var iNode = div.firstChild.firstChild;
255 var textNode = iNode.firstChild.firstChild;
256 var range = goog.dom.Range.createFromNodes(textNode, 0, textNode, 3);
257
258 range = goog.editor.range.expand(range);
259
260 goog.testing.dom.assertRangeEquals(iNode, 0, iNode, 1, range);
261
262 // Same selection, at b node level.
263 range =
264 goog.dom.Range.createFromNodes(iNode.firstChild, 0, iNode.firstChild, 1);
265 range = goog.editor.range.expand(range);
266
267 goog.testing.dom.assertRangeEquals(iNode, 0, iNode, 1, range);
268 }
269
270 function testPlaceCursorNextToLeft() {
271 var div = $('parentNode');
272 div.innerHTML = 'foo<div id="bar">bar</div>baz';
273 var node = $('bar');
274 var range = goog.editor.range.placeCursorNextTo(node, true);
275
276 var expose = goog.testing.dom.exposeNode;
277 assertEquals(
278 'Selection should be to the left of the node ' + expose(node) + ',' +
279 expose(range.getStartNode().nextSibling),
280 node, range.getStartNode().nextSibling);
281 assertEquals('Selection should be collapsed', true, range.isCollapsed());
282 }
283
284
285 function testPlaceCursorNextToRight() {
286 var div = $('parentNode');
287 div.innerHTML = 'foo<div id="bar">bar</div>baz';
288 var node = $('bar');
289 var range = goog.editor.range.placeCursorNextTo(node, false);
290
291 assertEquals(
292 'Selection should be to the right of the node', node,
293 range.getStartNode().previousSibling);
294 assertEquals('Selection should be collapsed', true, range.isCollapsed());
295 }
296
297 function testPlaceCursorNextTo_rightOfLineBreak() {
298 var div = $('parentNode');
299 div.innerHTML = '<div contentEditable="true">hhhh<br />h</div>';
300 var children = div.firstChild.childNodes;
301 assertEquals(3, children.length);
302 var node = children[1];
303 var range = goog.editor.range.placeCursorNextTo(node, false);
304 assertEquals(node.nextSibling, range.getStartNode());
305 }
306
307 function testPlaceCursorNextTo_leftOfHr() {
308 var div = $('parentNode');
309 div.innerHTML = '<hr />aaa';
310 var children = div.childNodes;
311 assertEquals(2, children.length);
312 var node = children[0];
313 var range = goog.editor.range.placeCursorNextTo(node, true);
314
315 assertEquals(div, range.getStartNode());
316 assertEquals(0, range.getStartOffset());
317 }
318
319 function testPlaceCursorNextTo_rightOfHr() {
320 var div = $('parentNode');
321 div.innerHTML = 'aaa<hr>';
322 var children = div.childNodes;
323 assertEquals(2, children.length);
324 var node = children[1];
325 var range = goog.editor.range.placeCursorNextTo(node, false);
326
327 assertEquals(div, range.getStartNode());
328 assertEquals(2, range.getStartOffset());
329 }
330
331 function testPlaceCursorNextTo_rightOfImg() {
332 var div = $('parentNode');
333 div.innerHTML =
334 'aaa<img src="https://www.google.com/images/srpr/logo3w.png">bbb';
335 var children = div.childNodes;
336 assertEquals(3, children.length);
337 var imgNode = children[1];
338 var range = goog.editor.range.placeCursorNextTo(imgNode, false);
339
340 assertEquals(
341 'range node should be the right sibling of img tag', children[2],
342 range.getStartNode());
343 assertEquals(0, range.getStartOffset());
344 }
345
346 function testPlaceCursorNextTo_rightOfImgAtEnd() {
347 var div = $('parentNode');
348 div.innerHTML =
349 'aaa<img src="https://www.google.com/images/srpr/logo3w.png">';
350 var children = div.childNodes;
351 assertEquals(2, children.length);
352 var imgNode = children[1];
353 var range = goog.editor.range.placeCursorNextTo(imgNode, false);
354
355 assertEquals(
356 'range node should be the parent of img', div, range.getStartNode());
357 assertEquals(
358 'offset should be right after the img tag', 2, range.getStartOffset());
359 }
360
361 function testPlaceCursorNextTo_leftOfImg() {
362 var div = $('parentNode');
363 div.innerHTML =
364 '<img src="https://www.google.com/images/srpr/logo3w.png">xxx';
365 var children = div.childNodes;
366 assertEquals(2, children.length);
367 var imgNode = children[0];
368 var range = goog.editor.range.placeCursorNextTo(imgNode, true);
369
370 assertEquals(
371 'range node should be the parent of img', div, range.getStartNode());
372 assertEquals('offset should point to the img tag', 0, range.getStartOffset());
373 }
374
375 function testPlaceCursorNextTo_rightOfFirstOfTwoImgTags() {
376 var div = $('parentNode');
377 div.innerHTML =
378 'aaa<img src="https://www.google.com/images/srpr/logo3w.png">' +
379 '<img src="https://www.google.com/images/srpr/logo3w.png">';
380 var children = div.childNodes;
381 assertEquals(3, children.length);
382 var imgNode = children[1]; // First of two IMG nodes
383 var range = goog.editor.range.placeCursorNextTo(imgNode, false);
384
385 assertEquals(
386 'range node should be the parent of img instead of ' +
387 'node with innerHTML=' + range.getStartNode().innerHTML,
388 div, range.getStartNode());
389 assertEquals(
390 'offset should be right after the img tag', 2, range.getStartOffset());
391 }
392
393 function testGetDeepEndPoint() {
394 var div = $('parentNode');
395 var def = $('def');
396 var jkl = $('jkl');
397
398 assertPointEquals(
399 div.firstChild, 0, goog.editor.range.getDeepEndPoint(
400 goog.dom.Range.createFromNodeContents(div), true));
401 assertPointEquals(
402 div.lastChild, div.lastChild.length,
403 goog.editor.range.getDeepEndPoint(
404 goog.dom.Range.createFromNodeContents(div), false));
405
406 assertPointEquals(
407 def.firstChild, 0, goog.editor.range.getDeepEndPoint(
408 goog.dom.Range.createCaret(div, 1), true));
409 assertPointEquals(
410 def.nextSibling, 0, goog.editor.range.getDeepEndPoint(
411 goog.dom.Range.createCaret(div, 2), true));
412 }
413
414 function testNormalizeOnNormalizedDom() {
415 var defText = $('def').firstChild;
416 var jklText = $('jkl').firstChild;
417 var range = goog.dom.Range.createFromNodes(defText, 1, jklText, 2);
418
419 var newRange = normalizeBody(range);
420 goog.testing.dom.assertRangeEquals(defText, 1, jklText, 2, newRange);
421 }
422
423 function testDeepPointFindingOnNormalizedDom() {
424 var def = $('def');
425 var jkl = $('jkl');
426 var range = goog.dom.Range.createFromNodes(def, 0, jkl, 1);
427
428 var newRange = normalizeBody(range);
429
430 // Make sure that newRange is measured relative to the text nodes,
431 // not the DIV elements.
432 goog.testing.dom.assertRangeEquals(
433 def.firstChild, 0, jkl.firstChild, 3, newRange);
434 }
435
436 function testNormalizeOnVeryFragmentedDom() {
437 var defText = $('def').firstChild;
438 var jklText = $('jkl').firstChild;
439 var range = goog.dom.Range.createFromNodes(defText, 1, jklText, 2);
440
441 // Fragment the DOM a bunch.
442 fragmentText(defText);
443 fragmentText(jklText);
444
445 var newRange = normalizeBody(range);
446
447 // our old text nodes may not be valid anymore. find new ones.
448 defText = $('def').firstChild;
449 jklText = $('jkl').firstChild;
450
451 goog.testing.dom.assertRangeEquals(defText, 1, jklText, 2, newRange);
452 }
453
454 function testNormalizeOnDivWithEmptyTextNodes() {
455 var emptyDiv = $('normalizeTest-with-empty-text-nodes');
456
457 // Append empty text nodes to the emptyDiv.
458 var tnode1 = goog.dom.createTextNode('');
459 var tnode2 = goog.dom.createTextNode('');
460 var tnode3 = goog.dom.createTextNode('');
461
462 goog.dom.appendChild(emptyDiv, tnode1);
463 goog.dom.appendChild(emptyDiv, tnode2);
464 goog.dom.appendChild(emptyDiv, tnode3);
465
466 var range = goog.dom.Range.createFromNodes(emptyDiv, 1, emptyDiv, 2);
467
468 // Cannot use document.body.normalize() as it fails to normalize the div
469 // (in IE) if it has nothing but empty text nodes.
470 var newRange = goog.editor.range.rangePreservingNormalize(emptyDiv, range);
471
472 if (goog.userAgent.GECKO &&
473 goog.string.compareVersions(goog.userAgent.VERSION, '1.9') == -1) {
474 // In FF2, node.normalize() leaves an empty textNode in the div, unlike
475 // other browsers where the div is left with no children.
476 goog.testing.dom.assertRangeEquals(
477 emptyDiv.firstChild, 0, emptyDiv.firstChild, 0, newRange);
478 } else {
479 goog.testing.dom.assertRangeEquals(emptyDiv, 0, emptyDiv, 0, newRange);
480 }
481 }
482
483 function testRangeCreatedInVeryFragmentedDom() {
484 var def = $('def');
485 var defText = def.firstChild;
486 var jkl = $('jkl');
487 var jklText = jkl.firstChild;
488
489 // Fragment the DOM a bunch.
490 fragmentText(defText);
491 fragmentText(jklText);
492
493 // Notice that there are two empty text nodes at the beginning of each
494 // fragmented node.
495 var range = goog.dom.Range.createFromNodes(def, 3, jkl, 4);
496
497 var newRange = normalizeBody(range);
498
499 // our old text nodes may not be valid anymore. find new ones.
500 defText = $('def').firstChild;
501 jklText = $('jkl').firstChild;
502 goog.testing.dom.assertRangeEquals(defText, 1, jklText, 2, newRange);
503 }
504
505 function testNormalizeInFragmentedDomWithPreviousSiblings() {
506 var ghiText = $('def').nextSibling;
507 var mnoText = $('jkl').nextSibling;
508 var range = goog.dom.Range.createFromNodes(ghiText, 1, mnoText, 2);
509
510 // Fragment the DOM a bunch.
511 fragmentText($('def').previousSibling); // fragment abc
512 fragmentText(ghiText);
513 fragmentText(mnoText);
514
515 var newRange = normalizeBody(range);
516
517 // our old text nodes may not be valid anymore. find new ones.
518 ghiText = $('def').nextSibling;
519 mnoText = $('jkl').nextSibling;
520
521 goog.testing.dom.assertRangeEquals(ghiText, 1, mnoText, 2, newRange);
522 }
523
524 function testRangeCreatedInFragmentedDomWithPreviousSiblings() {
525 var def = $('def');
526 var ghiText = $('def').nextSibling;
527 var jkl = $('jkl');
528 var mnoText = $('jkl').nextSibling;
529
530 // Fragment the DOM a bunch.
531 fragmentText($('def').previousSibling); // fragment abc
532 fragmentText(ghiText);
533 fragmentText(mnoText);
534
535 // Notice that there are two empty text nodes at the beginning of each
536 // fragmented node.
537 var root = $('parentNode');
538 var range = goog.dom.Range.createFromNodes(root, 9, root, 16);
539
540 var newRange = normalizeBody(range);
541
542 // our old text nodes may not be valid anymore. find new ones.
543 ghiText = $('def').nextSibling;
544 mnoText = $('jkl').nextSibling;
545 goog.testing.dom.assertRangeEquals(ghiText, 1, mnoText, 2, newRange);
546 }
547
548
549 /**
550 * Branched from the tests for goog.dom.SavedCaretRange.
551 */
552 function testSavedCaretRange() {
553 var def = $('def-1');
554 var jkl = $('jkl-1');
555
556 var range =
557 goog.dom.Range.createFromNodes(def.firstChild, 1, jkl.firstChild, 2);
558 range.select();
559
560 var saved = goog.editor.range.saveUsingNormalizedCarets(range);
561 assertHTMLEquals(
562 'd<span id="' + saved.startCaretId_ + '"></span>ef', def.innerHTML);
563 assertHTMLEquals(
564 'jk<span id="' + saved.endCaretId_ + '"></span>l', jkl.innerHTML);
565
566 clearSelectionAndRestoreSaved(saved);
567
568 var selection = goog.dom.Range.createFromWindow(window);
569 def = $('def-1');
570 jkl = $('jkl-1');
571 assertHTMLEquals('def', def.innerHTML);
572 assertHTMLEquals('jkl', jkl.innerHTML);
573
574 // Check that everything was normalized ok.
575 assertEquals(1, def.childNodes.length);
576 assertEquals(1, jkl.childNodes.length);
577 goog.testing.dom.assertRangeEquals(
578 def.firstChild, 1, jkl.firstChild, 2, selection);
579 }
580
581 function testRangePreservingNormalize() {
582 var parent = $('normalizeTest-4');
583 var def = $('def-4');
584 var jkl = $('jkl-4');
585 fragmentText(def.firstChild);
586 fragmentText(jkl.firstChild);
587
588 var range = goog.dom.Range.createFromNodes(def, 3, jkl, 4);
589 var oldRangeDescription = goog.testing.dom.exposeRange(range);
590 range = goog.editor.range.rangePreservingNormalize(parent, range);
591
592 // Check that everything was normalized ok.
593 assertEquals(
594 'def should have 1 child; range is ' +
595 goog.testing.dom.exposeRange(range) + ', range was ' +
596 oldRangeDescription,
597 1, def.childNodes.length);
598 assertEquals(
599 'jkl should have 1 child; range is ' +
600 goog.testing.dom.exposeRange(range) + ', range was ' +
601 oldRangeDescription,
602 1, jkl.childNodes.length);
603 goog.testing.dom.assertRangeEquals(
604 def.firstChild, 1, jkl.firstChild, 2, range);
605 }
606
607 function testRangePreservingNormalizeWhereEndNodePreviousSiblingIsSplit() {
608 var parent = $('normalizeTest-with-br');
609 var br = parent.childNodes[1];
610 fragmentText(parent.firstChild);
611
612 var range = goog.dom.Range.createFromNodes(parent, 3, br, 0);
613 range = goog.editor.range.rangePreservingNormalize(parent, range);
614
615 // Code used to throw an error here.
616
617 assertEquals('parent should have 3 children', 3, parent.childNodes.length);
618 goog.testing.dom.assertRangeEquals(parent.firstChild, 1, parent, 1, range);
619 }
620
621 function testRangePreservingNormalizeWhereStartNodePreviousSiblingIsSplit() {
622 var parent = $('normalizeTest-with-br');
623 var br = parent.childNodes[1];
624 fragmentText(parent.firstChild);
625 fragmentText(parent.lastChild);
626
627 var range = goog.dom.Range.createFromNodes(br, 0, parent, 9);
628 range = goog.editor.range.rangePreservingNormalize(parent, range);
629
630 // Code used to throw an error here.
631
632 assertEquals('parent should have 3 children', 3, parent.childNodes.length);
633 goog.testing.dom.assertRangeEquals(parent, 1, parent.lastChild, 1, range);
634 }
635
636 function testSelectionPreservingNormalize1() {
637 var parent = $('normalizeTest-2');
638 var def = $('def-2');
639 var jkl = $('jkl-2');
640 fragmentText(def.firstChild);
641 fragmentText(jkl.firstChild);
642
643 goog.dom.Range.createFromNodes(def, 3, jkl, 4).select();
644 assertFalse(goog.dom.Range.createFromWindow(window).isReversed());
645
646 var oldRangeDescription =
647 goog.testing.dom.exposeRange(goog.dom.Range.createFromWindow(window));
648 goog.editor.range.selectionPreservingNormalize(parent);
649
650 // Check that everything was normalized ok.
651 var range = goog.dom.Range.createFromWindow(window);
652 assertFalse(range.isReversed());
653
654 assertEquals(
655 'def should have 1 child; range is ' +
656 goog.testing.dom.exposeRange(range) + ', range was ' +
657 oldRangeDescription,
658 1, def.childNodes.length);
659 assertEquals(
660 'jkl should have 1 child; range is ' +
661 goog.testing.dom.exposeRange(range) + ', range was ' +
662 oldRangeDescription,
663 1, jkl.childNodes.length);
664 goog.testing.dom.assertRangeEquals(
665 def.firstChild, 1, jkl.firstChild, 2, range);
666 }
667
668
669 /**
670 * Make sure that selectionPreservingNormalize doesn't explode with no
671 * selection in the document.
672 */
673 function testSelectionPreservingNormalize2() {
674 var parent = $('normalizeTest-3');
675 var def = $('def-3');
676 var jkl = $('jkl-3');
677 def.firstChild.splitText(1);
678 jkl.firstChild.splitText(2);
679
680 goog.dom.Range.clearSelection(window);
681 goog.editor.range.selectionPreservingNormalize(parent);
682
683 // Check that everything was normalized ok.
684 assertEquals(1, def.childNodes.length);
685 assertEquals(1, jkl.childNodes.length);
686 assertFalse(goog.dom.Range.hasSelection(window));
687 }
688
689 function testSelectionPreservingNormalize3() {
690 if (goog.userAgent.EDGE_OR_IE) {
691 return;
692 }
693 var parent = $('normalizeTest-2');
694 var def = $('def-2');
695 var jkl = $('jkl-2');
696 fragmentText(def.firstChild);
697 fragmentText(jkl.firstChild);
698
699 goog.dom.Range.createFromNodes(jkl, 4, def, 3).select();
700 assertTrue(goog.dom.Range.createFromWindow(window).isReversed());
701
702 var oldRangeDescription =
703 goog.testing.dom.exposeRange(goog.dom.Range.createFromWindow(window));
704 goog.editor.range.selectionPreservingNormalize(parent);
705
706 // Check that everything was normalized ok.
707 var range = goog.dom.Range.createFromWindow(window);
708 assertTrue(range.isReversed());
709
710 assertEquals(
711 'def should have 1 child; range is ' +
712 goog.testing.dom.exposeRange(range) + ', range was ' +
713 oldRangeDescription,
714 1, def.childNodes.length);
715 assertEquals(
716 'jkl should have 1 child; range is ' +
717 goog.testing.dom.exposeRange(range) + ', range was ' +
718 oldRangeDescription,
719 1, jkl.childNodes.length);
720 goog.testing.dom.assertRangeEquals(
721 def.firstChild, 1, jkl.firstChild, 2, range);
722 }
723
724 function testSelectionPreservingNormalizeAfterPlaceCursorNextTo() {
725 var parent = $('normalizeTest-with-div');
726 goog.editor.range.placeCursorNextTo(parent.firstChild);
727 goog.editor.range.selectionPreservingNormalize(parent);
728
729 // Code used to throw an exception here.
730 }
731
732
733 /** Normalize the body and return the normalized range. */
734 function normalizeBody(range) {
735 var rangeFactory = goog.editor.range.normalize(range);
736 document.body.normalize();
737 return rangeFactory();
738 }
739
740
741 /** Break a text node up into lots of little fragments. */
742 function fragmentText(text) {
743 // NOTE(nicksantos): For some reason, splitText makes IE deeply
744 // unhappy to the point where normalize and other normal DOM operations
745 // start failing. It's a useful test for Firefox though, because different
746 // versions of FireFox handle empty text nodes differently.
747 // See goog.editor.BrowserFeature.
748 if (goog.userAgent.IE) {
749 manualSplitText(text, 2);
750 manualSplitText(text, 1);
751 manualSplitText(text, 0);
752 manualSplitText(text, 0);
753 } else {
754 text.splitText(2);
755 text.splitText(1);
756
757 text.splitText(0);
758 text.splitText(0);
759 }
760 }
761
762
763 /**
764 * Clear the selection by re-parsing the DOM. Then restore the saved
765 * selection.
766 * @param {goog.dom.SavedRange} saved The saved range.
767 */
768 function clearSelectionAndRestoreSaved(saved) {
769 goog.dom.Range.clearSelection(window);
770 assertFalse(goog.dom.Range.hasSelection(window));
771 saved.restore();
772 assertTrue(goog.dom.Range.hasSelection(window));
773 }
774
775 function manualSplitText(node, pos) {
776 var newNodeString = node.nodeValue.substr(pos);
777 node.nodeValue = node.nodeValue.substr(0, pos);
778 goog.dom.insertSiblingAfter(document.createTextNode(newNodeString), node);
779 }
780
781 function testSelectNodeStartSimple() {
782 var div = $('parentNode');
783 div.innerHTML = '<p>Cursor should go in here</p>';
784
785 goog.editor.range.selectNodeStart(div);
786 var range = goog.dom.Range.createFromWindow(window);
787 // Gotta love browsers and their inconsistencies with selection
788 // representations. What we are trying to achieve is that when we type
789 // the text will go into the P node. In Gecko, the selection is at the start
790 // of the text node, as you'd expect, but in pre-530 Webkit, it has been
791 // normalized to the visible position of P:0.
792 if (goog.userAgent.GECKO || goog.userAgent.IE || goog.userAgent.EDGE ||
793 (goog.userAgent.WEBKIT && goog.userAgent.isVersionOrHigher('530'))) {
794 goog.testing.dom.assertRangeEquals(
795 div.firstChild.firstChild, 0, div.firstChild.firstChild, 0, range);
796 } else {
797 goog.testing.dom.assertRangeEquals(
798 div.firstChild, 0, div.firstChild, 0, range);
799 }
800 }
801
802 function testSelectNodeStartBr() {
803 var div = $('parentNode');
804 div.innerHTML = '<p><br>Cursor should go in here</p>';
805
806 goog.editor.range.selectNodeStart(div);
807 var range = goog.dom.Range.createFromWindow(window);
808 // We have to skip the BR since Gecko can't render a cursor at a BR.
809 goog.testing.dom.assertRangeEquals(
810 div.firstChild, 0, div.firstChild, 0, range);
811 }
812
813 function testIsEditable() {
814 var containerElement = document.getElementById('editableTest');
815 // Find editable container element's index.
816 var containerIndex = 0;
817 var currentSibling = containerElement;
818 while (currentSibling = currentSibling.previousSibling) {
819 containerIndex++;
820 }
821
822 var editableContainer = goog.dom.Range.createFromNodes(
823 containerElement.parentNode, containerIndex, containerElement.parentNode,
824 containerIndex + 1);
825 assertFalse(
826 'Range containing container element not considered editable',
827 goog.editor.range.isEditable(editableContainer));
828
829 var allEditableChildren = goog.dom.Range.createFromNodes(
830 containerElement, 0, containerElement,
831 containerElement.childNodes.length);
832 assertTrue(
833 'Range of all of container element children considered editable',
834 goog.editor.range.isEditable(allEditableChildren));
835
836 var someEditableChildren =
837 goog.dom.Range.createFromNodes(containerElement, 2, containerElement, 6);
838 assertTrue(
839 'Range of some container element children considered editable',
840 goog.editor.range.isEditable(someEditableChildren));
841
842
843 var mixedEditableNonEditable = goog.dom.Range.createFromNodes(
844 containerElement.previousSibling, 0, containerElement, 2);
845 assertFalse(
846 'Range overlapping some content not considered editable',
847 goog.editor.range.isEditable(mixedEditableNonEditable));
848 }
849
850 function testIntersectsTag() {
851 var root = $('root');
852 root.innerHTML =
853 '<b>Bold</b><p><span><code>x</code></span></p><p>y</p><i>Italic</i>';
854
855 // Select the whole thing.
856 var range = goog.dom.Range.createFromNodeContents(root);
857 assertTrue(goog.editor.range.intersectsTag(range, goog.dom.TagName.DIV));
858 assertTrue(goog.editor.range.intersectsTag(range, goog.dom.TagName.B));
859 assertTrue(goog.editor.range.intersectsTag(range, goog.dom.TagName.I));
860 assertTrue(goog.editor.range.intersectsTag(range, goog.dom.TagName.CODE));
861 assertFalse(goog.editor.range.intersectsTag(range, goog.dom.TagName.U));
862
863 // Just select italic.
864 range = goog.dom.Range.createFromNodes(root, 3, root, 4);
865 assertTrue(goog.editor.range.intersectsTag(range, goog.dom.TagName.DIV));
866 assertFalse(goog.editor.range.intersectsTag(range, goog.dom.TagName.B));
867 assertTrue(goog.editor.range.intersectsTag(range, goog.dom.TagName.I));
868 assertFalse(goog.editor.range.intersectsTag(range, goog.dom.TagName.CODE));
869 assertFalse(goog.editor.range.intersectsTag(range, goog.dom.TagName.U));
870
871 // Select "ld x y".
872 range = goog.dom.Range.createFromNodes(
873 root.firstChild.firstChild, 2, root.childNodes[2], 1);
874 assertTrue(goog.editor.range.intersectsTag(range, goog.dom.TagName.DIV));
875 assertTrue(goog.editor.range.intersectsTag(range, goog.dom.TagName.B));
876 assertFalse(goog.editor.range.intersectsTag(range, goog.dom.TagName.I));
877 assertTrue(goog.editor.range.intersectsTag(range, goog.dom.TagName.CODE));
878 assertFalse(goog.editor.range.intersectsTag(range, goog.dom.TagName.U));
879
880 // Select ol.
881 range = goog.dom.Range.createFromNodes(
882 root.firstChild.firstChild, 1, root.firstChild.firstChild, 3);
883 assertTrue(goog.editor.range.intersectsTag(range, goog.dom.TagName.DIV));
884 assertTrue(goog.editor.range.intersectsTag(range, goog.dom.TagName.B));
885 assertFalse(goog.editor.range.intersectsTag(range, goog.dom.TagName.I));
886 assertFalse(goog.editor.range.intersectsTag(range, goog.dom.TagName.CODE));
887 assertFalse(goog.editor.range.intersectsTag(range, goog.dom.TagName.U));
888 }
889
890 function testNormalizeNode() {
891 var div = goog.dom.createDom(goog.dom.TagName.DIV, null, 'a', 'b', 'c');
892 assertEquals(3, div.childNodes.length);
893 goog.editor.range.normalizeNode(div);
894 assertEquals(1, div.childNodes.length);
895 assertEquals('abc', div.firstChild.nodeValue);
896
897 div = goog.dom.createDom(
898 goog.dom.TagName.DIV, null,
899 goog.dom.createDom(goog.dom.TagName.SPAN, null, '1', '2'),
900 goog.dom.createTextNode(''), goog.dom.createDom(goog.dom.TagName.BR), 'b',
901 'c');
902 assertEquals(5, div.childNodes.length);
903 assertEquals(2, div.firstChild.childNodes.length);
904 goog.editor.range.normalizeNode(div);
905 if (goog.userAgent.GECKO && !goog.userAgent.isVersionOrHigher(1.9) ||
906 goog.userAgent.WEBKIT && !goog.userAgent.isVersionOrHigher(526)) {
907 // Old Gecko and Webkit versions don't delete the empty node.
908 assertEquals(4, div.childNodes.length);
909 } else {
910 assertEquals(3, div.childNodes.length);
911 }
912 assertEquals(1, div.firstChild.childNodes.length);
913 assertEquals('12', div.firstChild.firstChild.nodeValue);
914 assertEquals('bc', div.lastChild.nodeValue);
915 assertEquals(
916 String(goog.dom.TagName.BR), div.lastChild.previousSibling.tagName);
917 }
918
919 function testDeepestPoint() {
920 var parent = $('parentNode');
921 var def = $('def');
922
923 assertEquals(def, parent.childNodes[1]);
924
925 var deepestPoint = goog.editor.range.Point.createDeepestPoint;
926
927 var defStartLeft = deepestPoint(parent, 1, true);
928 assertPointEquals(
929 def.previousSibling, def.previousSibling.nodeValue.length, defStartLeft);
930
931 var defStartRight = deepestPoint(parent, 1, false);
932 assertPointEquals(def.firstChild, 0, defStartRight);
933
934 var defEndLeft = deepestPoint(parent, 2, true);
935 assertPointEquals(
936 def.firstChild, def.firstChild.nodeValue.length, defEndLeft);
937
938 var defEndRight = deepestPoint(parent, 2, false);
939 assertPointEquals(def.nextSibling, 0, defEndRight);
940 }
941
942 function assertPointEquals(node, offset, actualPoint) {
943 assertEquals('Point has wrong node', node, actualPoint.node);
944 assertEquals('Point has wrong offset', offset, actualPoint.offset);
945 }