| 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.dom.TextRangeTest'); |
| 16 |
goog.setTestOnly('goog.dom.TextRangeTest'); |
| 17 |
|
| 18 |
goog.require('goog.dom'); |
| 19 |
goog.require('goog.dom.ControlRange'); |
| 20 |
goog.require('goog.dom.Range'); |
| 21 |
goog.require('goog.dom.TextRange'); |
| 22 |
goog.require('goog.math.Coordinate'); |
| 23 |
goog.require('goog.style'); |
| 24 |
goog.require('goog.testing.ExpectedFailures'); |
| 25 |
goog.require('goog.testing.jsunit'); |
| 26 |
goog.require('goog.userAgent'); |
| 27 |
goog.require('goog.userAgent.product'); |
| 28 |
|
| 29 |
var logo; |
| 30 |
var logo2; |
| 31 |
var logo3; |
| 32 |
var logo3Rtl; |
| 33 |
var table; |
| 34 |
var table2; |
| 35 |
var table2div; |
| 36 |
var test3; |
| 37 |
var test3Rtl; |
| 38 |
var expectedFailures; |
| 39 |
|
| 40 |
function setUpPage() { |
| 41 |
logo = goog.dom.getElement('logo'); |
| 42 |
logo2 = goog.dom.getElement('logo2'); |
| 43 |
logo3 = goog.dom.getElement('logo3'); |
| 44 |
logo3Rtl = goog.dom.getElement('logo3Rtl'); |
| 45 |
table = goog.dom.getElement('table'); |
| 46 |
table2 = goog.dom.getElement('table2'); |
| 47 |
table2div = goog.dom.getElement('table2div'); |
| 48 |
test3 = goog.dom.getElement('test3'); |
| 49 |
test3Rtl = goog.dom.getElement('test3Rtl'); |
| 50 |
expectedFailures = new goog.testing.ExpectedFailures(); |
| 51 |
} |
| 52 |
|
| 53 |
function tearDown() { |
| 54 |
expectedFailures.handleTearDown(); |
| 55 |
} |
| 56 |
|
| 57 |
function testCreateFromNodeContents() { |
| 58 |
assertNotNull( |
| 59 |
'Text range object can be created for element node', |
| 60 |
goog.dom.TextRange.createFromNodeContents(logo)); |
| 61 |
assertNotNull( |
| 62 |
'Text range object can be created for text node', |
| 63 |
goog.dom.TextRange.createFromNodeContents(logo2.previousSibling)); |
| 64 |
} |
| 65 |
|
| 66 |
function testMoveToNodes() { |
| 67 |
var range = goog.dom.TextRange.createFromNodeContents(table2); |
| 68 |
range.moveToNodes(table2div, 0, table2div, 1, false); |
| 69 |
assertEquals( |
| 70 |
'Range should start in table2div', table2div, range.getStartNode()); |
| 71 |
assertEquals('Range should end in table2div', table2div, range.getEndNode()); |
| 72 |
assertEquals('Range start offset should be 0', 0, range.getStartOffset()); |
| 73 |
assertEquals('Range end offset should be 0', 1, range.getEndOffset()); |
| 74 |
assertFalse('Range should not be reversed', range.isReversed()); |
| 75 |
range.moveToNodes(table2div, 0, table2div, 1, true); |
| 76 |
assertTrue('Range should be reversed', range.isReversed()); |
| 77 |
assertEquals('Range text should be "foo"', 'foo', range.getText()); |
| 78 |
} |
| 79 |
|
| 80 |
function testContainsTextRange() { |
| 81 |
var range = goog.dom.TextRange.createFromNodeContents(table2); |
| 82 |
var range2 = goog.dom.TextRange.createFromNodeContents(table2div); |
| 83 |
assertTrue('TextRange contains other TextRange', range.containsRange(range2)); |
| 84 |
assertFalse( |
| 85 |
'TextRange does not contain other TextRange', |
| 86 |
range2.containsRange(range)); |
| 87 |
|
| 88 |
range = goog.dom.Range.createFromNodes( |
| 89 |
table2div.firstChild, 1, table2div.lastChild, 1); |
| 90 |
range2 = goog.dom.TextRange.createFromNodes( |
| 91 |
table2div.firstChild, 0, table2div.lastChild, 0); |
| 92 |
assertTrue( |
| 93 |
'TextRange partially contains other TextRange', |
| 94 |
range2.containsRange(range, true)); |
| 95 |
assertFalse( |
| 96 |
'TextRange does not fully contain other TextRange', |
| 97 |
range2.containsRange(range, false)); |
| 98 |
} |
| 99 |
|
| 100 |
function testContainsControlRange() { |
| 101 |
if (goog.userAgent.IE) { |
| 102 |
var range = goog.dom.ControlRange.createFromElements(table2); |
| 103 |
var range2 = goog.dom.TextRange.createFromNodeContents(table2div); |
| 104 |
assertFalse( |
| 105 |
'TextRange does not contain ControlRange', range2.containsRange(range)); |
| 106 |
range = goog.dom.ControlRange.createFromElements(logo2); |
| 107 |
assertTrue('TextRange contains ControlRange', range2.containsRange(range)); |
| 108 |
range = goog.dom.TextRange.createFromNodeContents(table2); |
| 109 |
range2 = goog.dom.ControlRange.createFromElements(logo, logo2); |
| 110 |
assertTrue( |
| 111 |
'TextRange partially contains ControlRange', |
| 112 |
range2.containsRange(range, true)); |
| 113 |
assertFalse( |
| 114 |
'TextRange does not fully contain ControlRange', |
| 115 |
range2.containsRange(range, false)); |
| 116 |
} |
| 117 |
} |
| 118 |
|
| 119 |
function getTest3ElementTopLeft() { |
| 120 |
var topLeft = goog.style.getPageOffset(test3.firstChild); |
| 121 |
|
| 122 |
if (goog.userAgent.EDGE_OR_IE) { |
| 123 |
// On IE the selection is as tall as its tallest element. |
| 124 |
var logoPosition = goog.style.getPageOffset(logo3); |
| 125 |
topLeft.y = logoPosition.y; |
| 126 |
|
| 127 |
if (!goog.userAgent.isVersionOrHigher('8')) { |
| 128 |
topLeft.x += 2; |
| 129 |
topLeft.y += 2; |
| 130 |
} |
| 131 |
} |
| 132 |
return topLeft; |
| 133 |
} |
| 134 |
|
| 135 |
function testGetStartPosition() { |
| 136 |
expectedFailures.expectFailureFor( |
| 137 |
goog.userAgent.GECKO && !goog.userAgent.isVersionOrHigher('2')); |
| 138 |
|
| 139 |
// The start node is in the top left. |
| 140 |
var range = goog.dom.TextRange.createFromNodeContents(test3); |
| 141 |
|
| 142 |
try { |
| 143 |
var result = assertNotThrows(goog.bind(range.getStartPosition, range)); |
| 144 |
assertObjectRoughlyEquals(getTest3ElementTopLeft(), result, 1); |
| 145 |
} catch (e) { |
| 146 |
expectedFailures.handleException(e); |
| 147 |
} |
| 148 |
} |
| 149 |
|
| 150 |
function testGetStartPositionNotInDocument() { |
| 151 |
expectedFailures.expectFailureFor( |
| 152 |
goog.userAgent.GECKO && !goog.userAgent.isVersionOrHigher('2')); |
| 153 |
expectedFailures.expectFailureFor( |
| 154 |
goog.userAgent.IE && !goog.userAgent.isVersionOrHigher('8')); |
| 155 |
|
| 156 |
var range = goog.dom.TextRange.createFromNodeContents(test3); |
| 157 |
|
| 158 |
goog.dom.removeNode(test3); |
| 159 |
try { |
| 160 |
var result = assertNotThrows(goog.bind(range.getStartPosition, range)); |
| 161 |
assertNull(result); |
| 162 |
} catch (e) { |
| 163 |
expectedFailures.handleException(e); |
| 164 |
} finally { |
| 165 |
goog.dom.appendChild(document.body, test3); |
| 166 |
} |
| 167 |
} |
| 168 |
|
| 169 |
function testGetStartPositionReversed() { |
| 170 |
expectedFailures.expectFailureFor( |
| 171 |
goog.userAgent.GECKO && !goog.userAgent.isVersionOrHigher('2')); |
| 172 |
|
| 173 |
// Simulate the user selecting backwards from right-to-left. |
| 174 |
// The start node is now in the bottom right. |
| 175 |
var firstNode = test3.firstChild.firstChild; |
| 176 |
var lastNode = test3.lastChild.lastChild; |
| 177 |
var range = goog.dom.TextRange.createFromNodes( |
| 178 |
lastNode, lastNode.nodeValue.length, firstNode, 0); |
| 179 |
|
| 180 |
try { |
| 181 |
var result = assertNotThrows(goog.bind(range.getStartPosition, range)); |
| 182 |
assertObjectRoughlyEquals(getTest3ElementTopLeft(), result, 1); |
| 183 |
} catch (e) { |
| 184 |
expectedFailures.handleException(e); |
| 185 |
} |
| 186 |
} |
| 187 |
|
| 188 |
function testGetStartPositionRightToLeft() { |
| 189 |
if (goog.userAgent.product.SAFARI) { |
| 190 |
// TODO(b/20733468): Disabled so we can get the rest of the Closure test |
| 191 |
// suite running in a continuous build. Will investigate later. |
| 192 |
return; |
| 193 |
} |
| 194 |
|
| 195 |
expectedFailures.expectFailureFor( |
| 196 |
goog.userAgent.GECKO && !goog.userAgent.isVersionOrHigher('2')); |
| 197 |
|
| 198 |
// Even in RTL content the start node is still in the top left. |
| 199 |
var range = goog.dom.TextRange.createFromNodeContents(test3Rtl); |
| 200 |
var topLeft = goog.style.getPageOffset(test3Rtl.firstChild); |
| 201 |
|
| 202 |
if (goog.userAgent.EDGE_OR_IE) { |
| 203 |
// On IE the selection is as tall as its tallest element. |
| 204 |
var logoPosition = goog.style.getPageOffset(logo3Rtl); |
| 205 |
topLeft.y = logoPosition.y; |
| 206 |
|
| 207 |
if (!goog.userAgent.isVersionOrHigher('8')) { |
| 208 |
topLeft.x += 2; |
| 209 |
topLeft.y += 2; |
| 210 |
} |
| 211 |
} |
| 212 |
|
| 213 |
try { |
| 214 |
var result = assertNotThrows(goog.bind(range.getStartPosition, range)); |
| 215 |
assertObjectRoughlyEquals(topLeft, result, 0.1); |
| 216 |
} catch (e) { |
| 217 |
expectedFailures.handleException(e); |
| 218 |
} |
| 219 |
} |
| 220 |
|
| 221 |
function getTest3ElementBottomRight() { |
| 222 |
var pageOffset = goog.style.getPageOffset(test3.lastChild); |
| 223 |
var bottomRight = new goog.math.Coordinate( |
| 224 |
pageOffset.x + test3.lastChild.offsetWidth, |
| 225 |
pageOffset.y + test3.lastChild.offsetHeight); |
| 226 |
|
| 227 |
if (goog.userAgent.IE && !goog.userAgent.isVersionOrHigher('8')) { |
| 228 |
bottomRight.x += 6; |
| 229 |
bottomRight.y += 2; |
| 230 |
} |
| 231 |
return bottomRight; |
| 232 |
} |
| 233 |
|
| 234 |
function testGetEndPosition() { |
| 235 |
expectedFailures.expectFailureFor( |
| 236 |
goog.userAgent.GECKO && !goog.userAgent.isVersionOrHigher('2')); |
| 237 |
|
| 238 |
// The end node is in the bottom right. |
| 239 |
var range = goog.dom.TextRange.createFromNodeContents(test3); |
| 240 |
var expected = getTest3ElementBottomRight(); |
| 241 |
|
| 242 |
try { |
| 243 |
var result = assertNotThrows(goog.bind(range.getEndPosition, range)); |
| 244 |
assertObjectRoughlyEquals(expected, result, 1); |
| 245 |
} catch (e) { |
| 246 |
expectedFailures.handleException(e); |
| 247 |
} |
| 248 |
} |
| 249 |
|
| 250 |
function testGetEndPositionNotInDocument() { |
| 251 |
expectedFailures.expectFailureFor( |
| 252 |
goog.userAgent.GECKO && !goog.userAgent.isVersionOrHigher('2')); |
| 253 |
expectedFailures.expectFailureFor( |
| 254 |
goog.userAgent.IE && !goog.userAgent.isVersionOrHigher('8')); |
| 255 |
|
| 256 |
var range = goog.dom.TextRange.createFromNodeContents(test3); |
| 257 |
|
| 258 |
goog.dom.removeNode(test3); |
| 259 |
try { |
| 260 |
var result = assertNotThrows(goog.bind(range.getEndPosition, range)); |
| 261 |
assertNull(result); |
| 262 |
} catch (e) { |
| 263 |
expectedFailures.handleException(e); |
| 264 |
} finally { |
| 265 |
goog.dom.appendChild(document.body, test3); |
| 266 |
} |
| 267 |
} |
| 268 |
|
| 269 |
function testGetEndPositionReversed() { |
| 270 |
expectedFailures.expectFailureFor( |
| 271 |
goog.userAgent.GECKO && !goog.userAgent.isVersionOrHigher('2')); |
| 272 |
|
| 273 |
// Simulate the user selecting backwards from right-to-left. |
| 274 |
// The end node is still in the lower right. |
| 275 |
var range = goog.dom.TextRange.createFromNodeContents(test3, true); |
| 276 |
var expected = getTest3ElementBottomRight(); |
| 277 |
|
| 278 |
try { |
| 279 |
var result = assertNotThrows(goog.bind(range.getEndPosition, range)); |
| 280 |
|
| 281 |
// For some reason, ie7 is further off than other browsers. |
| 282 |
var estimate = |
| 283 |
(goog.userAgent.IE && !goog.userAgent.isVersionOrHigher('8')) ? 4 : 1; |
| 284 |
assertObjectRoughlyEquals(expected, result, estimate); |
| 285 |
} catch (e) { |
| 286 |
expectedFailures.handleException(e); |
| 287 |
} |
| 288 |
} |
| 289 |
|
| 290 |
function testGetEndPositionRightToLeft() { |
| 291 |
expectedFailures.expectFailureFor( |
| 292 |
goog.userAgent.GECKO && !goog.userAgent.isVersionOrHigher('2')); |
| 293 |
expectedFailures.expectFailureFor( |
| 294 |
goog.userAgent.IE && !goog.userAgent.isVersionOrHigher('8')); |
| 295 |
|
| 296 |
// Even in RTL content the end node is still in the bottom right. |
| 297 |
var range = goog.dom.TextRange.createFromNodeContents(test3Rtl); |
| 298 |
var pageOffset = goog.style.getPageOffset(test3Rtl.lastChild); |
| 299 |
var bottomRight = new goog.math.Coordinate( |
| 300 |
pageOffset.x + test3Rtl.lastChild.offsetWidth, |
| 301 |
pageOffset.y + test3Rtl.lastChild.offsetHeight); |
| 302 |
|
| 303 |
if (goog.userAgent.IE && !goog.userAgent.isVersionOrHigher('8')) { |
| 304 |
bottomRight.x += 2; |
| 305 |
bottomRight.y += 2; |
| 306 |
} |
| 307 |
|
| 308 |
try { |
| 309 |
var result = assertNotThrows(goog.bind(range.getEndPosition, range)); |
| 310 |
assertObjectRoughlyEquals(bottomRight, result, 1); |
| 311 |
} catch (e) { |
| 312 |
expectedFailures.handleException(e); |
| 313 |
} |
| 314 |
} |
| 315 |
|
| 316 |
function testCloneRangeDeep() { |
| 317 |
var range = goog.dom.TextRange.createFromNodeContents(logo); |
| 318 |
assertFalse(range.isCollapsed()); |
| 319 |
|
| 320 |
var cloned = range.clone(); |
| 321 |
cloned.collapse(); |
| 322 |
assertTrue(cloned.isCollapsed()); |
| 323 |
assertFalse(range.isCollapsed()); |
| 324 |
} |