Debian Codegraph @

closure-library/closure/goog/dom/textrange_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.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 }