| 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 |
} |