Debian Codegraph @

closure-library/closure/goog/ui/sliderbase_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.ui.SliderBaseTest');
16 goog.setTestOnly('goog.ui.SliderBaseTest');
17
18 goog.require('goog.a11y.aria');
19 goog.require('goog.a11y.aria.State');
20 goog.require('goog.dom');
21 goog.require('goog.dom.TagName');
22 goog.require('goog.dom.classlist');
23 goog.require('goog.events');
24 goog.require('goog.events.EventType');
25 goog.require('goog.events.KeyCodes');
26 goog.require('goog.fx.Animation');
27 goog.require('goog.math.Coordinate');
28 goog.require('goog.style');
29 goog.require('goog.style.bidi');
30 goog.require('goog.testing.MockClock');
31 goog.require('goog.testing.MockControl');
32 goog.require('goog.testing.events');
33 goog.require('goog.testing.jsunit');
34 goog.require('goog.testing.mockmatchers');
35 goog.require('goog.testing.recordFunction');
36 goog.require('goog.ui.Component');
37 goog.require('goog.ui.SliderBase');
38 goog.require('goog.userAgent');
39
40 var oneThumbSlider;
41 var oneThumbSliderRtl;
42 var oneChangeEventCount;
43
44 var twoThumbSlider;
45 var twoThumbSliderRtl;
46 var twoChangeEventCount;
47
48 var mockClock;
49 var mockAnimation;
50
51
52
53 /**
54 * A basic class to implement the abstract goog.ui.SliderBase for testing.
55 * @constructor
56 * @extends {goog.ui.SliderBase}
57 */
58 function OneThumbSlider() {
59 goog.ui.SliderBase.call(this, undefined /* domHelper */, function(value) {
60 return value > 5 ? 'A big value.' : 'A small value.';
61 });
62 }
63 goog.inherits(OneThumbSlider, goog.ui.SliderBase);
64
65
66 /** @override */
67 OneThumbSlider.prototype.createThumbs = function() {
68 this.valueThumb = this.extentThumb = goog.dom.getElement('thumb');
69 };
70
71
72 /** @override */
73 OneThumbSlider.prototype.getCssClass = function(orientation) {
74 return goog.getCssName('test-slider', orientation);
75 };
76
77
78
79 /**
80 * A basic class to implement the abstract goog.ui.SliderBase for testing.
81 * @constructor
82 * @extends {goog.ui.SliderBase}
83 */
84 function TwoThumbSlider() {
85 goog.ui.SliderBase.call(this);
86 }
87 goog.inherits(TwoThumbSlider, goog.ui.SliderBase);
88
89
90 /** @override */
91 TwoThumbSlider.prototype.createThumbs = function() {
92 this.valueThumb = goog.dom.getElement('valueThumb');
93 this.extentThumb = goog.dom.getElement('extentThumb');
94 this.rangeHighlight = goog.dom.getElement('rangeHighlight');
95 };
96
97
98 /** @override */
99 TwoThumbSlider.prototype.getCssClass = function(orientation) {
100 return goog.getCssName('test-slider', orientation);
101 };
102
103
104
105 /**
106 * Basic class that implements the AnimationFactory interface for testing.
107 * @param {!goog.fx.Animation|!Array<!goog.fx.Animation>} testAnimations The
108 * test animations to use.
109 * @constructor
110 * @implements {goog.ui.SliderBase.AnimationFactory}
111 */
112 function AnimationFactory(testAnimations) {
113 this.testAnimations = testAnimations;
114 }
115
116
117 /** @override */
118 AnimationFactory.prototype.createAnimations = function() {
119 return this.testAnimations;
120 };
121
122
123 function setUp() {
124 var sandBox = goog.dom.getElement('sandbox');
125 mockClock = new goog.testing.MockClock(true);
126
127 var oneThumbElem = goog.dom.createDom(
128 goog.dom.TagName.DIV, {'id': 'oneThumbSlider'},
129 goog.dom.createDom(goog.dom.TagName.SPAN, {'id': 'thumb'}));
130 sandBox.appendChild(oneThumbElem);
131 oneThumbSlider = new OneThumbSlider();
132 oneThumbSlider.decorate(oneThumbElem);
133 oneChangeEventCount = 0;
134 goog.events.listen(
135 oneThumbSlider, goog.ui.Component.EventType.CHANGE,
136 function() { oneChangeEventCount++; });
137
138 var twoThumbElem = goog.dom.createDom(
139 goog.dom.TagName.DIV, {'id': 'twoThumbSlider'},
140 goog.dom.createDom(goog.dom.TagName.DIV, {'id': 'rangeHighlight'}),
141 goog.dom.createDom(goog.dom.TagName.SPAN, {'id': 'valueThumb'}),
142 goog.dom.createDom(goog.dom.TagName.SPAN, {'id': 'extentThumb'}));
143 sandBox.appendChild(twoThumbElem);
144 twoThumbSlider = new TwoThumbSlider();
145 twoThumbSlider.decorate(twoThumbElem);
146 twoChangeEventCount = 0;
147 goog.events.listen(
148 twoThumbSlider, goog.ui.Component.EventType.CHANGE,
149 function() { twoChangeEventCount++; });
150
151 var sandBoxRtl = goog.dom.createDom(
152 goog.dom.TagName.DIV, {'dir': 'rtl', 'style': 'position:absolute;'});
153 sandBox.appendChild(sandBoxRtl);
154
155 var oneThumbElemRtl = goog.dom.createDom(
156 goog.dom.TagName.DIV, {'id': 'oneThumbSliderRtl'},
157 goog.dom.createDom(goog.dom.TagName.SPAN, {'id': 'thumbRtl'}));
158 sandBoxRtl.appendChild(oneThumbElemRtl);
159 oneThumbSliderRtl = new OneThumbSlider();
160 oneThumbSliderRtl.enableFlipForRtl(true);
161 oneThumbSliderRtl.decorate(oneThumbElemRtl);
162 goog.events.listen(
163 oneThumbSliderRtl, goog.ui.Component.EventType.CHANGE,
164 function() { oneChangeEventCount++; });
165
166 var twoThumbElemRtl = goog.dom.createDom(
167 goog.dom.TagName.DIV, {'id': 'twoThumbSliderRtl'},
168 goog.dom.createDom(goog.dom.TagName.DIV, {'id': 'rangeHighlightRtl'}),
169 goog.dom.createDom(goog.dom.TagName.SPAN, {'id': 'valueThumbRtl'}),
170 goog.dom.createDom(goog.dom.TagName.SPAN, {'id': 'extentThumbRtl'}));
171 sandBoxRtl.appendChild(twoThumbElemRtl);
172 twoThumbSliderRtl = new TwoThumbSlider();
173 twoThumbSliderRtl.enableFlipForRtl(true);
174 twoThumbSliderRtl.decorate(twoThumbElemRtl);
175 twoChangeEventCount = 0;
176 goog.events.listen(
177 twoThumbSliderRtl, goog.ui.Component.EventType.CHANGE,
178 function() { twoChangeEventCount++; });
179 }
180
181 function tearDown() {
182 oneThumbSlider.dispose();
183 twoThumbSlider.dispose();
184 oneThumbSliderRtl.dispose();
185 twoThumbSliderRtl.dispose();
186 mockClock.dispose();
187 goog.dom.removeChildren(goog.dom.getElement('sandbox'));
188 }
189
190 function testGetAndSetValue() {
191 oneThumbSlider.setValue(30);
192 assertEquals(30, oneThumbSlider.getValue());
193 assertEquals(
194 'Setting valid value must dispatch only a single change event.', 1,
195 oneChangeEventCount);
196
197 oneThumbSlider.setValue(30);
198 assertEquals(30, oneThumbSlider.getValue());
199 assertEquals(
200 'Setting to same value must not dispatch change event.', 1,
201 oneChangeEventCount);
202
203 oneThumbSlider.setValue(-30);
204 assertEquals(
205 'Setting invalid value must not change value.', 30,
206 oneThumbSlider.getValue());
207 assertEquals(
208 'Setting invalid value must not dispatch change event.', 1,
209 oneChangeEventCount);
210
211
212 // Value thumb can't go past extent thumb, so we must move that first to
213 // allow setting value.
214 twoThumbSlider.setExtent(70);
215 twoChangeEventCount = 0;
216 twoThumbSlider.setValue(60);
217 assertEquals(60, twoThumbSlider.getValue());
218 assertEquals(
219 'Setting valid value must dispatch only a single change event.', 1,
220 twoChangeEventCount);
221
222 twoThumbSlider.setValue(60);
223 assertEquals(60, twoThumbSlider.getValue());
224 assertEquals(
225 'Setting to same value must not dispatch change event.', 1,
226 twoChangeEventCount);
227
228 twoThumbSlider.setValue(-60);
229 assertEquals(
230 'Setting invalid value must not change value.', 60,
231 twoThumbSlider.getValue());
232 assertEquals(
233 'Setting invalid value must not dispatch change event.', 1,
234 twoChangeEventCount);
235 }
236
237 function testGetAndSetValueRtl() {
238 var thumbElement = goog.dom.getElement('thumbRtl');
239 assertEquals(0, goog.style.bidi.getOffsetStart(thumbElement));
240 assertEquals('', thumbElement.style.left);
241 assertTrue(thumbElement.style.right >= 0);
242
243 oneThumbSliderRtl.setValue(30);
244 assertEquals(30, oneThumbSliderRtl.getValue());
245 assertEquals(
246 'Setting valid value must dispatch only a single change event.', 1,
247 oneChangeEventCount);
248
249 assertEquals('', thumbElement.style.left);
250 assertTrue(thumbElement.style.right >= 0);
251
252 oneThumbSliderRtl.setValue(30);
253 assertEquals(30, oneThumbSliderRtl.getValue());
254 assertEquals(
255 'Setting to same value must not dispatch change event.', 1,
256 oneChangeEventCount);
257
258 oneThumbSliderRtl.setValue(-30);
259 assertEquals(
260 'Setting invalid value must not change value.', 30,
261 oneThumbSliderRtl.getValue());
262 assertEquals(
263 'Setting invalid value must not dispatch change event.', 1,
264 oneChangeEventCount);
265
266
267 // Value thumb can't go past extent thumb, so we must move that first to
268 // allow setting value.
269 var valueThumbElement = goog.dom.getElement('valueThumbRtl');
270 var extentThumbElement = goog.dom.getElement('extentThumbRtl');
271 assertEquals(0, goog.style.bidi.getOffsetStart(valueThumbElement));
272 assertEquals(0, goog.style.bidi.getOffsetStart(extentThumbElement));
273 assertEquals('', valueThumbElement.style.left);
274 assertTrue(valueThumbElement.style.right >= 0);
275 assertEquals('', extentThumbElement.style.left);
276 assertTrue(extentThumbElement.style.right >= 0);
277
278 twoThumbSliderRtl.setExtent(70);
279 twoChangeEventCount = 0;
280 twoThumbSliderRtl.setValue(60);
281 assertEquals(60, twoThumbSliderRtl.getValue());
282 assertEquals(
283 'Setting valid value must dispatch only a single change event.', 1,
284 twoChangeEventCount);
285
286 twoThumbSliderRtl.setValue(60);
287 assertEquals(60, twoThumbSliderRtl.getValue());
288 assertEquals(
289 'Setting to same value must not dispatch change event.', 1,
290 twoChangeEventCount);
291
292 assertEquals('', valueThumbElement.style.left);
293 assertTrue(valueThumbElement.style.right >= 0);
294 assertEquals('', extentThumbElement.style.left);
295 assertTrue(extentThumbElement.style.right >= 0);
296
297 twoThumbSliderRtl.setValue(-60);
298 assertEquals(
299 'Setting invalid value must not change value.', 60,
300 twoThumbSliderRtl.getValue());
301 assertEquals(
302 'Setting invalid value must not dispatch change event.', 1,
303 twoChangeEventCount);
304 }
305
306 function testGetAndSetExtent() {
307 // Note(user): With a one thumb slider the API only really makes sense if you
308 // always use setValue since there is no extent.
309
310 twoThumbSlider.setExtent(7);
311 assertEquals(7, twoThumbSlider.getExtent());
312 assertEquals(
313 'Setting valid value must dispatch only a single change event.', 1,
314 twoChangeEventCount);
315
316 twoThumbSlider.setExtent(7);
317 assertEquals(7, twoThumbSlider.getExtent());
318 assertEquals(
319 'Setting to same value must not dispatch change event.', 1,
320 twoChangeEventCount);
321
322 twoThumbSlider.setExtent(-7);
323 assertEquals(
324 'Setting invalid value must not change value.', 7,
325 twoThumbSlider.getExtent());
326 assertEquals(
327 'Setting invalid value must not dispatch change event.', 1,
328 twoChangeEventCount);
329 }
330
331 function testUpdateValueExtent() {
332 twoThumbSlider.setValueAndExtent(30, 50);
333
334 assertNotNull(twoThumbSlider.getElement());
335 assertEquals(
336 'Setting value results in updating aria-valuenow', '30',
337 goog.a11y.aria.getState(
338 twoThumbSlider.getElement(), goog.a11y.aria.State.VALUENOW));
339 assertEquals(30, twoThumbSlider.getValue());
340 assertEquals(50, twoThumbSlider.getExtent());
341 }
342
343 function testValueText() {
344 oneThumbSlider.setValue(10);
345 assertEquals(
346 'Setting value results in correct aria-valuetext', 'A big value.',
347 goog.a11y.aria.getState(
348 oneThumbSlider.getElement(), goog.a11y.aria.State.VALUETEXT));
349 oneThumbSlider.setValue(2);
350 assertEquals(
351 'Updating value results in updated aria-valuetext', 'A small value.',
352 goog.a11y.aria.getState(
353 oneThumbSlider.getElement(), goog.a11y.aria.State.VALUETEXT));
354 }
355
356 function testGetValueText() {
357 oneThumbSlider.setValue(10);
358 assertEquals(
359 'Getting the text value gets the correct description', 'A big value.',
360 oneThumbSlider.getTextValue());
361 oneThumbSlider.setValue(2);
362 assertEquals(
363 'Getting the updated text value gets the correct updated description',
364 'A small value.', oneThumbSlider.getTextValue());
365 }
366
367 function testRangeListener() {
368 var slider = new goog.ui.SliderBase;
369 slider.updateUi_ = slider.updateAriaStates = function() {};
370 slider.rangeModel.setValue(0);
371
372 var f = goog.testing.recordFunction();
373 goog.events.listen(slider, goog.ui.Component.EventType.CHANGE, f);
374
375 slider.rangeModel.setValue(50);
376 assertEquals(1, f.getCallCount());
377
378 slider.exitDocument();
379 slider.rangeModel.setValue(0);
380 assertEquals(
381 'The range model listener should not have been removed so we ' +
382 'should have gotten a second event dispatch',
383 2, f.getCallCount());
384 }
385
386
387 /**
388 * Verifies that rangeHighlight position and size are correct for the given
389 * startValue and endValue. Assumes slider has default min/max values [0, 100],
390 * width of 1020px, and thumb widths of 20px, with rangeHighlight drawn from
391 * the centers of the thumbs.
392 * @param {number} rangeHighlight The range highlight.
393 * @param {number} startValue The start value.
394 * @param {number} endValue The end value.
395 */
396 function assertHighlightedRange(rangeHighlight, startValue, endValue) {
397 var rangeStr = '[' + startValue + ', ' + endValue + ']';
398 var rangeStart = 10 + 10 * startValue;
399 assertEquals(
400 'Range highlight for ' + rangeStr + ' should start at ' + rangeStart +
401 'px.',
402 rangeStart, rangeHighlight.offsetLeft);
403 var rangeSize = 10 * (endValue - startValue);
404 assertEquals(
405 'Range highlight for ' + rangeStr + ' should have size ' + rangeSize +
406 'px.',
407 rangeSize, rangeHighlight.offsetWidth);
408 }
409
410 function testKeyHandlingTests() {
411 twoThumbSlider.setValue(0);
412 twoThumbSlider.setExtent(100);
413 assertEquals(0, twoThumbSlider.getValue());
414 assertEquals(100, twoThumbSlider.getExtent());
415
416 goog.testing.events.fireKeySequence(
417 twoThumbSlider.getElement(), goog.events.KeyCodes.RIGHT);
418 assertEquals(1, twoThumbSlider.getValue());
419 assertEquals(99, twoThumbSlider.getExtent());
420
421 goog.testing.events.fireKeySequence(
422 twoThumbSlider.getElement(), goog.events.KeyCodes.RIGHT);
423 assertEquals(2, twoThumbSlider.getValue());
424 assertEquals(98, twoThumbSlider.getExtent());
425
426 goog.testing.events.fireKeySequence(
427 twoThumbSlider.getElement(), goog.events.KeyCodes.LEFT);
428 assertEquals(1, twoThumbSlider.getValue());
429 assertEquals(98, twoThumbSlider.getExtent());
430
431 goog.testing.events.fireKeySequence(
432 twoThumbSlider.getElement(), goog.events.KeyCodes.LEFT);
433 assertEquals(0, twoThumbSlider.getValue());
434 assertEquals(98, twoThumbSlider.getExtent());
435
436 goog.testing.events.fireKeySequence(
437 twoThumbSlider.getElement(), goog.events.KeyCodes.RIGHT,
438 {shiftKey: true});
439 assertEquals(10, twoThumbSlider.getValue());
440 assertEquals(90, twoThumbSlider.getExtent());
441
442 goog.testing.events.fireKeySequence(
443 twoThumbSlider.getElement(), goog.events.KeyCodes.RIGHT,
444 {shiftKey: true});
445 assertEquals(20, twoThumbSlider.getValue());
446 assertEquals(80, twoThumbSlider.getExtent());
447
448 goog.testing.events.fireKeySequence(
449 twoThumbSlider.getElement(), goog.events.KeyCodes.LEFT, {shiftKey: true});
450 assertEquals(10, twoThumbSlider.getValue());
451 assertEquals(80, twoThumbSlider.getExtent());
452
453 goog.testing.events.fireKeySequence(
454 twoThumbSlider.getElement(), goog.events.KeyCodes.LEFT, {shiftKey: true});
455 assertEquals(0, twoThumbSlider.getValue());
456 assertEquals(80, twoThumbSlider.getExtent());
457 }
458
459 function testKeyHandlingLargeStepSize() {
460 twoThumbSlider.setValue(0);
461 twoThumbSlider.setExtent(100);
462 twoThumbSlider.setStep(5);
463 assertEquals(0, twoThumbSlider.getValue());
464 assertEquals(100, twoThumbSlider.getExtent());
465
466 goog.testing.events.fireKeySequence(
467 twoThumbSlider.getElement(), goog.events.KeyCodes.RIGHT);
468 assertEquals(5, twoThumbSlider.getValue());
469 assertEquals(95, twoThumbSlider.getExtent());
470
471 goog.testing.events.fireKeySequence(
472 twoThumbSlider.getElement(), goog.events.KeyCodes.RIGHT);
473 assertEquals(10, twoThumbSlider.getValue());
474 assertEquals(90, twoThumbSlider.getExtent());
475
476 goog.testing.events.fireKeySequence(
477 twoThumbSlider.getElement(), goog.events.KeyCodes.LEFT);
478 assertEquals(5, twoThumbSlider.getValue());
479 assertEquals(90, twoThumbSlider.getExtent());
480
481 goog.testing.events.fireKeySequence(
482 twoThumbSlider.getElement(), goog.events.KeyCodes.LEFT);
483 assertEquals(0, twoThumbSlider.getValue());
484 assertEquals(90, twoThumbSlider.getExtent());
485 }
486
487 function testKeyHandlingRtl() {
488 twoThumbSliderRtl.setValue(0);
489 twoThumbSliderRtl.setExtent(100);
490 assertEquals(0, twoThumbSliderRtl.getValue());
491 assertEquals(100, twoThumbSliderRtl.getExtent());
492
493 goog.testing.events.fireKeySequence(
494 twoThumbSliderRtl.getElement(), goog.events.KeyCodes.RIGHT);
495 assertEquals(0, twoThumbSliderRtl.getValue());
496 assertEquals(99, twoThumbSliderRtl.getExtent());
497
498 goog.testing.events.fireKeySequence(
499 twoThumbSliderRtl.getElement(), goog.events.KeyCodes.RIGHT);
500 assertEquals(0, twoThumbSliderRtl.getValue());
501 assertEquals(98, twoThumbSliderRtl.getExtent());
502
503 goog.testing.events.fireKeySequence(
504 twoThumbSliderRtl.getElement(), goog.events.KeyCodes.LEFT);
505 assertEquals(1, twoThumbSliderRtl.getValue());
506 assertEquals(98, twoThumbSliderRtl.getExtent());
507
508 goog.testing.events.fireKeySequence(
509 twoThumbSliderRtl.getElement(), goog.events.KeyCodes.LEFT);
510 assertEquals(2, twoThumbSliderRtl.getValue());
511 assertEquals(98, twoThumbSliderRtl.getExtent());
512
513 goog.testing.events.fireKeySequence(
514 twoThumbSliderRtl.getElement(), goog.events.KeyCodes.RIGHT,
515 {shiftKey: true});
516 assertEquals(0, twoThumbSliderRtl.getValue());
517 assertEquals(90, twoThumbSliderRtl.getExtent());
518
519 goog.testing.events.fireKeySequence(
520 twoThumbSliderRtl.getElement(), goog.events.KeyCodes.RIGHT,
521 {shiftKey: true});
522 assertEquals(0, twoThumbSliderRtl.getValue());
523 assertEquals(80, twoThumbSliderRtl.getExtent());
524
525 goog.testing.events.fireKeySequence(
526 twoThumbSliderRtl.getElement(), goog.events.KeyCodes.LEFT,
527 {shiftKey: true});
528 assertEquals(10, twoThumbSliderRtl.getValue());
529 assertEquals(80, twoThumbSliderRtl.getExtent());
530
531 goog.testing.events.fireKeySequence(
532 twoThumbSliderRtl.getElement(), goog.events.KeyCodes.LEFT,
533 {shiftKey: true});
534 assertEquals(20, twoThumbSliderRtl.getValue());
535 assertEquals(80, twoThumbSliderRtl.getExtent());
536 }
537
538 function testRangeHighlight() {
539 var rangeHighlight = goog.dom.getElement('rangeHighlight');
540
541 // Test [0, 100]
542 twoThumbSlider.setValue(0);
543 twoThumbSlider.setExtent(100);
544 assertHighlightedRange(rangeHighlight, 0, 100);
545
546 // Test [25, 75]
547 twoThumbSlider.setValue(25);
548 twoThumbSlider.setExtent(50);
549 assertHighlightedRange(rangeHighlight, 25, 75);
550
551 // Test [50, 50]
552 twoThumbSlider.setValue(50);
553 twoThumbSlider.setExtent(0);
554 assertHighlightedRange(rangeHighlight, 50, 50);
555 }
556
557 function testRangeHighlightAnimation() {
558 var animationDelay = 160; // Delay in ms, is a bit higher than actual delay.
559 if (goog.userAgent.IE) {
560 // For some reason, (probably due to how timing works), IE7 and IE8 will not
561 // stop if we don't wait for it.
562 animationDelay = 250;
563 }
564
565 var rangeHighlight = goog.dom.getElement('rangeHighlight');
566 twoThumbSlider.setValue(0);
567 twoThumbSlider.setExtent(100);
568
569 // Animate right thumb, final range is [0, 75]
570 twoThumbSlider.animatedSetValue(75);
571 assertHighlightedRange(rangeHighlight, 0, 100);
572 mockClock.tick(animationDelay);
573 assertHighlightedRange(rangeHighlight, 0, 75);
574
575 // Animate left thumb, final range is [25, 75]
576 twoThumbSlider.animatedSetValue(25);
577 assertHighlightedRange(rangeHighlight, 0, 75);
578 mockClock.tick(animationDelay);
579 assertHighlightedRange(rangeHighlight, 25, 75);
580 }
581
582
583 /**
584 * Verifies that no error occurs and that the range highlight is sized correctly
585 * for a zero-size slider (i.e. doesn't attempt to set a negative size). The
586 * test tries to resize the slider from its original size to 0, then checks
587 * that the range highlight's size is correctly set to 0.
588 *
589 * The size verification is needed because Webkit/Gecko outright ignore calls
590 * to set negative sizes on an element, leaving it at its former size. IE
591 * throws an error in the same situation.
592 */
593 function testRangeHighlightForZeroSizeSlider() {
594 // Make sure range highlight spans whole slider before zeroing width.
595 twoThumbSlider.setExtent(100);
596 twoThumbSlider.getElement().style.width = 0;
597
598 // The setVisible call is used to force a UI update.
599 twoThumbSlider.setVisible(true);
600 assertEquals(
601 'Range highlight size should be 0 when slider size is 0', 0,
602 goog.dom.getElement('rangeHighlight').offsetWidth);
603 }
604
605 function testAnimatedSetValueAnimatesFactoryCreatedAnimations() {
606 // Create and set the factory.
607 var ignore = goog.testing.mockmatchers.ignoreArgument;
608 var mockControl = new goog.testing.MockControl();
609 var mockAnimation1 = mockControl.createLooseMock(goog.fx.Animation);
610 var mockAnimation2 = mockControl.createLooseMock(goog.fx.Animation);
611 var testAnimations = [mockAnimation1, mockAnimation2];
612 oneThumbSlider.setAdditionalAnimations(new AnimationFactory(testAnimations));
613
614 // Expect the animations to be played.
615 mockAnimation1.play(false);
616 mockAnimation2.play(false);
617 mockAnimation1.addEventListener(ignore, ignore, ignore);
618 mockAnimation2.addEventListener(ignore, ignore, ignore);
619
620 // Animate and verify.
621 mockControl.$replayAll();
622 oneThumbSlider.animatedSetValue(50);
623 mockControl.$verifyAll();
624 mockControl.$resetAll();
625 mockControl.$tearDown();
626 }
627
628 function testMouseWheelEventHandlerEnable() {
629 // Mouse wheel handling should be enabled by default.
630 assertTrue(oneThumbSlider.isHandleMouseWheel());
631
632 // Test disabling the mouse wheel handler
633 oneThumbSlider.setHandleMouseWheel(false);
634 assertFalse(oneThumbSlider.isHandleMouseWheel());
635
636 // Test that enabling again works fine.
637 oneThumbSlider.setHandleMouseWheel(true);
638 assertTrue(oneThumbSlider.isHandleMouseWheel());
639
640 // Test that mouse wheel handling can be disabled before rendering a slider.
641 var wheelDisabledElem = goog.dom.createDom(
642 goog.dom.TagName.DIV, {}, goog.dom.createDom(goog.dom.TagName.SPAN));
643 var wheelDisabledSlider = new OneThumbSlider();
644 wheelDisabledSlider.setHandleMouseWheel(false);
645 wheelDisabledSlider.decorate(wheelDisabledElem);
646 assertFalse(wheelDisabledSlider.isHandleMouseWheel());
647 }
648
649 function testDisabledAndEnabledSlider() {
650 // Check that a slider is enabled by default
651 assertTrue(oneThumbSlider.isEnabled());
652
653 var listenerCount = oneThumbSlider.getHandler().getListenerCount();
654 // Disable the slider and check its state
655 oneThumbSlider.setEnabled(false);
656 assertFalse(oneThumbSlider.isEnabled());
657 assertTrue(
658 goog.dom.classlist.contains(
659 oneThumbSlider.getElement(), 'goog-slider-disabled'));
660 assertEquals(0, oneThumbSlider.getHandler().getListenerCount());
661
662 // setValue should work unaffected even when the slider is disabled.
663 oneThumbSlider.setValue(30);
664 assertEquals(30, oneThumbSlider.getValue());
665 assertEquals(
666 'Setting valid value must dispatch a change event ' +
667 'even when slider is disabled.',
668 1, oneChangeEventCount);
669
670 // Test the transition from disabled to enabled
671 oneThumbSlider.setEnabled(true);
672 assertTrue(oneThumbSlider.isEnabled());
673 assertFalse(
674 goog.dom.classlist.contains(
675 oneThumbSlider.getElement(), 'goog-slider-disabled'));
676 assertTrue(listenerCount == oneThumbSlider.getHandler().getListenerCount());
677 }
678
679 function testBlockIncrementingWithEnableAndDisabled() {
680 var doc = goog.dom.getOwnerDocument(oneThumbSlider.getElement());
681 // Case when slider is not disabled between the mouse down and up events.
682 goog.testing.events.fireMouseDownEvent(oneThumbSlider.getElement());
683 assertEquals(
684 1, goog.events
685 .getListeners(
686 oneThumbSlider.getElement(), goog.events.EventType.MOUSEMOVE,
687 false)
688 .length);
689 assertEquals(
690 1, goog.events.getListeners(doc, goog.events.EventType.MOUSEUP, true)
691 .length);
692
693 goog.testing.events.fireMouseUpEvent(oneThumbSlider.getElement());
694
695 assertEquals(
696 0, goog.events
697 .getListeners(
698 oneThumbSlider.getElement(), goog.events.EventType.MOUSEMOVE,
699 false)
700 .length);
701 assertEquals(
702 0, goog.events.getListeners(doc, goog.events.EventType.MOUSEUP, true)
703 .length);
704
705 // Case when the slider is disabled between the mouse down and up events.
706 goog.testing.events.fireMouseDownEvent(oneThumbSlider.getElement());
707 assertEquals(
708 1, goog.events
709 .getListeners(
710 oneThumbSlider.getElement(), goog.events.EventType.MOUSEMOVE,
711 false)
712 .length);
713 assertEquals(
714 1, goog.events.getListeners(doc, goog.events.EventType.MOUSEUP, true)
715 .length);
716
717 oneThumbSlider.setEnabled(false);
718
719 assertEquals(
720 0, goog.events
721 .getListeners(
722 oneThumbSlider.getElement(), goog.events.EventType.MOUSEMOVE,
723 false)
724 .length);
725 assertEquals(
726 0, goog.events.getListeners(doc, goog.events.EventType.MOUSEUP, true)
727 .length);
728 assertEquals(1, oneThumbSlider.getHandler().getListenerCount());
729
730 goog.testing.events.fireMouseUpEvent(oneThumbSlider.getElement());
731 assertEquals(
732 0, goog.events
733 .getListeners(
734 oneThumbSlider.getElement(), goog.events.EventType.MOUSEMOVE,
735 false)
736 .length);
737 assertEquals(
738 0, goog.events.getListeners(doc, goog.events.EventType.MOUSEUP, true)
739 .length);
740 }
741
742 function testMouseClickWithMoveToPointEnabled() {
743 var stepSize = 20;
744 oneThumbSlider.setStep(stepSize);
745 oneThumbSlider.setMoveToPointEnabled(true);
746 var initialValue = oneThumbSlider.getValue();
747
748 // Figure out the number of pixels per step.
749 var numSteps = Math.round(
750 (oneThumbSlider.getMaximum() - oneThumbSlider.getMinimum()) / stepSize);
751 var size = goog.style.getSize(oneThumbSlider.getElement());
752 var pixelsPerStep = Math.round(size.width / numSteps);
753
754 var coords = goog.style.getClientPosition(oneThumbSlider.getElement());
755 coords.x += pixelsPerStep / 2;
756
757 // Case when value is increased
758 goog.testing.events.fireClickSequence(
759 oneThumbSlider.getElement(),
760 /* opt_button */ undefined, coords);
761 assertEquals(oneThumbSlider.getValue(), initialValue + stepSize);
762
763 // Case when value is decreased
764 goog.testing.events.fireClickSequence(
765 oneThumbSlider.getElement(),
766 /* opt_button */ undefined, coords);
767 assertEquals(oneThumbSlider.getValue(), initialValue);
768
769 // Case when thumb is clicked
770 goog.testing.events.fireClickSequence(oneThumbSlider.getElement());
771 assertEquals(oneThumbSlider.getValue(), initialValue);
772 }
773
774 function testNonIntegerStepSize() {
775 var stepSize = 0.02;
776 oneThumbSlider.setStep(stepSize);
777 oneThumbSlider.setMinimum(-1);
778 oneThumbSlider.setMaximum(1);
779 oneThumbSlider.setValue(0.7);
780 assertRoughlyEquals(0.7, oneThumbSlider.getValue(), 0.000001);
781 oneThumbSlider.setValue(0.3);
782 assertRoughlyEquals(0.3, oneThumbSlider.getValue(), 0.000001);
783 }
784
785 function testSingleThumbSliderHasZeroExtent() {
786 var stepSize = 0.02;
787 oneThumbSlider.setStep(stepSize);
788 oneThumbSlider.setMinimum(-1);
789 oneThumbSlider.setMaximum(1);
790 oneThumbSlider.setValue(0.7);
791 assertEquals(0, oneThumbSlider.getExtent());
792 oneThumbSlider.setValue(0.3);
793 assertEquals(0, oneThumbSlider.getExtent());
794 }
795
796
797 /**
798 * Tests getThumbCoordinateForValue method.
799 */
800 function testThumbCoordinateForValueWithHorizontalSlider() {
801 // Make sure the y-coordinate stays the same for the horizontal slider.
802 var originalY = goog.style.getPosition(oneThumbSlider.valueThumb).y;
803 var width = oneThumbSlider.getElement().clientWidth -
804 oneThumbSlider.valueThumb.offsetWidth;
805 var range = oneThumbSlider.getMaximum() - oneThumbSlider.getMinimum();
806
807 // Verify coordinate for a particular value.
808 var value = 20;
809 var expectedX = Math.round(value / range * width);
810 var expectedCoord = new goog.math.Coordinate(expectedX, originalY);
811 var coord = oneThumbSlider.getThumbCoordinateForValue(value);
812 assertObjectEquals(expectedCoord, coord);
813
814 // Verify this works regardless of current position.
815 oneThumbSlider.setValue(value / 2);
816 coord = oneThumbSlider.getThumbCoordinateForValue(value);
817 assertObjectEquals(expectedCoord, coord);
818 }
819
820 function testThumbCoordinateForValueWithVerticalSlider() {
821 // Make sure the x-coordinate stays the same for the vertical slider.
822 oneThumbSlider.setOrientation(goog.ui.SliderBase.Orientation.VERTICAL);
823 var originalX = goog.style.getPosition(oneThumbSlider.valueThumb).x;
824 var height = oneThumbSlider.getElement().clientHeight -
825 oneThumbSlider.valueThumb.offsetHeight;
826 var range = oneThumbSlider.getMaximum() - oneThumbSlider.getMinimum();
827
828 // Verify coordinate for a particular value.
829 var value = 20;
830 var expectedY = height - Math.round(value / range * height);
831 var expectedCoord = new goog.math.Coordinate(originalX, expectedY);
832 var coord = oneThumbSlider.getThumbCoordinateForValue(value);
833 assertObjectEquals(expectedCoord, coord);
834
835 // Verify this works regardless of current position.
836 oneThumbSlider.setValue(value / 2);
837 coord = oneThumbSlider.getThumbCoordinateForValue(value);
838 assertObjectEquals(expectedCoord, coord);
839 }
840
841
842 /**
843 * Tests getValueFromMousePosition method.
844 */
845 function testValueFromMousePosition() {
846 var value = 30;
847 oneThumbSlider.setValue(value);
848 var offset = goog.style.getPageOffset(oneThumbSlider.valueThumb);
849 var size = goog.style.getSize(oneThumbSlider.valueThumb);
850 offset.x += size.width / 2;
851 offset.y += size.height / 2;
852 var e = null;
853 goog.events.listen(
854 oneThumbSlider, goog.events.EventType.MOUSEMOVE,
855 function(evt) { e = evt; });
856 goog.testing.events.fireMouseMoveEvent(oneThumbSlider, offset);
857 assertNotEquals(e, null);
858 assertRoughlyEquals(
859 value, Math.round(oneThumbSlider.getValueFromMousePosition(e)), 1);
860 // Verify this works regardless of current position.
861 oneThumbSlider.setValue(value / 2);
862 assertRoughlyEquals(
863 value, Math.round(oneThumbSlider.getValueFromMousePosition(e)), 1);
864 }
865
866
867 /**
868 * Tests ignoring click event after mousedown event.
869 */
870 function testClickAfterMousedown() {
871 // Get the center of the thumb at value zero.
872 oneThumbSlider.setValue(0);
873 var offset = goog.style.getPageOffset(oneThumbSlider.valueThumb);
874 var size = goog.style.getSize(oneThumbSlider.valueThumb);
875 offset.x += size.width / 2;
876 offset.y += size.height / 2;
877
878 var sliderElement = oneThumbSlider.getElement();
879 var width = sliderElement.clientWidth - size.width;
880 var range = oneThumbSlider.getMaximum() - oneThumbSlider.getMinimum();
881 var offsetXAtZero = offset.x;
882
883 // Temporarily control time.
884 var theTime = goog.now();
885 var saveGoogNow = goog.now;
886 goog.now = function() { return theTime; };
887
888 // set coordinate for a particular value.
889 var valueOne = 10;
890 offset.x = offsetXAtZero + Math.round(valueOne / range * width);
891 goog.testing.events.fireMouseDownEvent(sliderElement, null, offset);
892 assertEquals(valueOne, oneThumbSlider.getValue());
893
894 // Verify a click event with another value that follows quickly is ignored.
895 theTime += oneThumbSlider.MOUSE_DOWN_DELAY_ / 2;
896 var valueTwo = 20;
897 offset.x = offsetXAtZero + Math.round(valueTwo / range * width);
898 goog.testing.events.fireClickEvent(sliderElement, null, offset);
899 assertEquals(valueOne, oneThumbSlider.getValue());
900
901 // Verify a click later in time does move the thumb.
902 theTime += oneThumbSlider.MOUSE_DOWN_DELAY_;
903 goog.testing.events.fireClickEvent(sliderElement, null, offset);
904 assertEquals(valueTwo, oneThumbSlider.getValue());
905
906 goog.now = saveGoogNow;
907 }
908
909
910 /**
911 * Tests dragging events.
912 */
913 function testDragEvents() {
914 var offset = goog.style.getPageOffset(oneThumbSlider.valueThumb);
915 var size = goog.style.getSize(oneThumbSlider.valueThumb);
916 offset.x += size.width / 2;
917 offset.y += size.height / 2;
918 var event_types = [];
919 var handler = function(evt) {
920 event_types.push(evt.type);
921 };
922
923 goog.events.listen(
924 oneThumbSlider,
925 [
926 goog.ui.SliderBase.EventType.DRAG_START,
927 goog.ui.SliderBase.EventType.DRAG_END,
928 goog.ui.SliderBase.EventType.DRAG_VALUE_START,
929 goog.ui.SliderBase.EventType.DRAG_VALUE_END,
930 goog.ui.SliderBase.EventType.DRAG_EXTENT_START,
931 goog.ui.SliderBase.EventType.DRAG_EXTENT_END,
932 goog.ui.Component.EventType.CHANGE
933 ],
934 handler);
935
936 // Since the order of the events between value and extent is not guaranteed
937 // across browsers, we need to allow for both here and once we have
938 // them all, make sure that they were different.
939 function isValueOrExtentDragStart(type) {
940 return type == goog.ui.SliderBase.EventType.DRAG_VALUE_START ||
941 type == goog.ui.SliderBase.EventType.DRAG_EXTENT_START;
942 }
943 function isValueOrExtentDragEnd(type) {
944 return type == goog.ui.SliderBase.EventType.DRAG_VALUE_END ||
945 type == goog.ui.SliderBase.EventType.DRAG_EXTENT_END;
946 }
947
948 // Test that dragging the thumb calls all the correct events.
949 goog.testing.events.fireMouseDownEvent(oneThumbSlider.valueThumb);
950 offset.x += 100;
951 goog.testing.events.fireMouseMoveEvent(oneThumbSlider.valueThumb, offset);
952 goog.testing.events.fireMouseUpEvent(oneThumbSlider.valueThumb);
953
954 assertEquals(9, event_types.length);
955
956 assertEquals(goog.ui.SliderBase.EventType.DRAG_START, event_types[0]);
957 assertTrue(isValueOrExtentDragStart(event_types[1]));
958
959 assertEquals(goog.ui.SliderBase.EventType.DRAG_START, event_types[2]);
960 assertTrue(isValueOrExtentDragStart(event_types[3]));
961
962 assertEquals(goog.ui.Component.EventType.CHANGE, event_types[4]);
963
964 assertEquals(goog.ui.SliderBase.EventType.DRAG_END, event_types[5]);
965 assertTrue(isValueOrExtentDragEnd(event_types[6]));
966
967 assertEquals(goog.ui.SliderBase.EventType.DRAG_END, event_types[7]);
968 assertTrue(isValueOrExtentDragEnd(event_types[8]));
969
970 assertFalse(event_types[1] == event_types[3]);
971 assertFalse(event_types[6] == event_types[8]);
972
973 // Test that clicking the thumb without moving the mouse does not cause a
974 // CHANGE event between DRAG_START/DRAG_END.
975 event_types = [];
976 goog.testing.events.fireMouseDownEvent(oneThumbSlider.valueThumb);
977 goog.testing.events.fireMouseUpEvent(oneThumbSlider.valueThumb);
978
979 assertEquals(8, event_types.length);
980
981 assertEquals(goog.ui.SliderBase.EventType.DRAG_START, event_types[0]);
982 assertTrue(isValueOrExtentDragStart(event_types[1]));
983
984 assertEquals(goog.ui.SliderBase.EventType.DRAG_START, event_types[2]);
985 assertTrue(isValueOrExtentDragStart(event_types[3]));
986
987 assertEquals(goog.ui.SliderBase.EventType.DRAG_END, event_types[4]);
988 assertTrue(isValueOrExtentDragEnd(event_types[5]));
989
990 assertEquals(goog.ui.SliderBase.EventType.DRAG_END, event_types[6]);
991 assertTrue(isValueOrExtentDragEnd(event_types[7]));
992
993 assertFalse(event_types[1] == event_types[3]);
994 assertFalse(event_types[5] == event_types[7]);
995
996 // Early listener removal, do not wait for tearDown, to avoid building up
997 // arrays of events unnecessarilly in further tests.
998 goog.events.removeAll(oneThumbSlider);
999 }
1000
1001
1002 /**
1003 * Tests dragging events updates the value correctly in LTR mode based on the
1004 * amount of space remaining to the right of the thumb.
1005 */
1006 function testDragEventsUpdatesValue() {
1007 // Get the center of the thumb at minimum value.
1008 oneThumbSlider.setMinimum(100);
1009 oneThumbSlider.setMaximum(300);
1010 oneThumbSlider.setValue(100);
1011
1012 // Need to set to (0, 0) in IE8 due to a browser bug where the
1013 // offsetWidth/height is incorrectly calculated as 0 in test files.
1014 var offset = (goog.userAgent.IE && !goog.userAgent.isVersionOrHigher('9')) ?
1015 new goog.math.Coordinate() :
1016 goog.style.getPageOffset(oneThumbSlider.valueThumb);
1017 var offsetXAtZero = offset.x;
1018
1019 var sliderElement = oneThumbSlider.getElementStrict();
1020 var thumbSize = goog.style.getSize(oneThumbSlider.valueThumb);
1021 var width = sliderElement.clientWidth - thumbSize.width;
1022 var range = oneThumbSlider.getMaximum() - oneThumbSlider.getMinimum();
1023
1024 // Test that dragging the thumb calls all the correct events.
1025 goog.testing.events.fireMouseDownEvent(oneThumbSlider.valueThumb);
1026
1027 // Scroll to 30 in the range of 0-200. Given that this is LTR mode, that means
1028 // the value will be 100 + 30 = 130.
1029 offset.x = offsetXAtZero + Math.round(30 / range * width);
1030 goog.testing.events.fireMouseMoveEvent(oneThumbSlider.valueThumb, offset);
1031 assertEquals(130, oneThumbSlider.getValue());
1032
1033 // Scroll to 70 in the range of 0-200. Given that this is LTR mode, that means
1034 // the value will be 100 + 70 = 170.
1035 offset.x = offsetXAtZero + Math.round(70 / range * width);
1036 goog.testing.events.fireMouseMoveEvent(oneThumbSlider.valueThumb, offset);
1037 assertEquals(170, oneThumbSlider.getValue());
1038
1039
1040 goog.testing.events.fireMouseUpEvent(oneThumbSlider.valueThumb);
1041 }
1042
1043
1044 /**
1045 * Tests dragging events updates the value correctly in RTL mode based on the
1046 * amount of space remaining to the left of the thumb.
1047 */
1048 function testDragEventsInRtlModeUpdatesValue() {
1049 // Get the center of the thumb at minimum value.
1050 oneThumbSliderRtl.setMinimum(100);
1051 oneThumbSliderRtl.setMaximum(300);
1052 oneThumbSliderRtl.setValue(100);
1053
1054 // Need to set to (0, 0) in IE8 due to a browser bug where the
1055 // offsetWidth/height is incorrectly calculated as 0 in test files.
1056 var offset = (goog.userAgent.IE && !goog.userAgent.isVersionOrHigher('9')) ?
1057 new goog.math.Coordinate() :
1058 goog.style.getPageOffset(oneThumbSlider.valueThumb);
1059 var offsetXAtZero = offset.x;
1060
1061 var sliderElement = oneThumbSliderRtl.getElementStrict();
1062 var thumbSize = goog.style.getSize(oneThumbSliderRtl.valueThumb);
1063 var width = sliderElement.clientWidth - thumbSize.width;
1064 var range = oneThumbSliderRtl.getMaximum() - oneThumbSliderRtl.getMinimum();
1065
1066 // Test that dragging the thumb calls all the correct events.
1067 goog.testing.events.fireMouseDownEvent(oneThumbSliderRtl.valueThumb);
1068
1069 // Scroll to 30 in the range of 0-200. Given that this is RTL mode, that means
1070 // the value will be 300 - 30 = 270.
1071 offset.x = offsetXAtZero + Math.round(30 / range * width);
1072 goog.testing.events.fireMouseMoveEvent(oneThumbSliderRtl.valueThumb, offset);
1073 assertEquals(270, oneThumbSliderRtl.getValue());
1074
1075 // Scroll to 70 in the range of 0-200. Given that this is RTL mode, that means
1076 // the value will be 300 - 70 = 230.
1077 offset.x = offsetXAtZero + Math.round(70 / range * width);
1078 goog.testing.events.fireMouseMoveEvent(oneThumbSliderRtl.valueThumb, offset);
1079 assertEquals(230, oneThumbSliderRtl.getValue());
1080
1081 goog.testing.events.fireMouseUpEvent(oneThumbSliderRtl.valueThumb);
1082 }
1083
1084
1085 /**
1086 * Tests animationend event after click.
1087 */
1088 function testAnimationEndEventAfterClick() {
1089 var offset = goog.style.getPageOffset(oneThumbSlider.valueThumb);
1090 var size = goog.style.getSize(oneThumbSlider.valueThumb);
1091 offset.x += size.width / 2;
1092 offset.y += size.height / 2;
1093 var event_types = [];
1094 var handler = function(evt) {
1095 event_types.push(evt.type);
1096 };
1097 var animationDelay = 160; // Delay in ms, is a bit higher than actual delay.
1098 if (goog.userAgent.IE) {
1099 // For some reason, (probably due to how timing works), IE7 and IE8 will not
1100 // stop if we don't wait for it.
1101 animationDelay = 250;
1102 }
1103 oneThumbSlider.setMoveToPointEnabled(true);
1104 goog.events.listen(
1105 oneThumbSlider, goog.ui.SliderBase.EventType.ANIMATION_END, handler);
1106
1107 function isAnimationEndType(type) {
1108 return type == goog.ui.SliderBase.EventType.ANIMATION_END;
1109 }
1110 offset.x += 100;
1111 goog.testing.events.fireClickSequence(
1112 oneThumbSlider.getElement(), /* opt_button */ undefined, offset);
1113
1114 mockClock.tick(animationDelay);
1115 assertEquals(1, event_types.length);
1116 assertTrue(isAnimationEndType(event_types[0]));
1117 goog.events.removeAll(oneThumbSlider);
1118 }