Debian Codegraph @

closure-library/closure/goog/events/wheelhandler_test.js

raw
1 // Copyright 2014 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.events.WheelHandlerTest');
16 goog.setTestOnly('goog.events.WheelHandlerTest');
17
18 goog.require('goog.dom');
19 goog.require('goog.events');
20 goog.require('goog.events.BrowserEvent');
21 goog.require('goog.events.WheelEvent');
22 goog.require('goog.events.WheelHandler');
23 goog.require('goog.string');
24 goog.require('goog.testing.PropertyReplacer');
25 goog.require('goog.testing.events');
26 goog.require('goog.testing.jsunit');
27 goog.require('goog.userAgent');
28 goog.require('goog.userAgent.product');
29
30 var log;
31 var stubs = new goog.testing.PropertyReplacer();
32
33 var PREFERRED_TYPE = 'wheel';
34 var LEGACY_TYPE = 'mousewheel';
35 var GECKO_TYPE = 'DOMMouseScroll';
36
37 var HORIZONTAL = 'h';
38 var VERTICAL = 'v';
39
40 var DeltaMode = goog.events.WheelEvent.DeltaMode;
41
42 var mouseWheelEvent;
43 var mouseWheelEventRtl;
44 var mouseWheelHandler;
45 var mouseWheelHandlerRtl;
46
47 function setUpPage() {
48 log = goog.dom.getElement('log');
49 }
50
51 function setUp() {
52 stubs.remove(goog, 'userAgent');
53 goog.userAgent = {
54 product: {
55 CHROME: false,
56 version: 0,
57 isVersion: function(version) {
58 return goog.string.compareVersions(this.version, version) >= 0;
59 }
60 },
61 GECKO: false,
62 IE: false,
63 version: 0,
64 isVersionOrHigher: function(version) {
65 return goog.string.compareVersions(this.version, version) >= 0;
66 }
67 };
68 }
69
70 function tearDown() {
71 stubs.reset();
72 goog.dispose(mouseWheelHandler);
73 goog.dispose(mouseWheelHandlerRtl);
74 mouseWheelHandlerRtl = null;
75 mouseWheelHandler = null;
76 mouseWheelEvent = null;
77 mouseWheelEventRtl = null;
78 }
79
80 function tearDownPage() {
81 // Create interactive demo.
82 mouseWheelHandler = new goog.events.WheelHandler(document.body);
83
84 goog.events.listen(
85 mouseWheelHandler, goog.events.WheelEvent.EventType.WHEEL, function(e) {
86 log.innerHTML += goog.string.subs(
87 '<br />(deltaX, deltaY): (%s, %s)', e.deltaX, e.deltaY);
88 });
89 }
90
91 function testGetDomEventType() {
92 // Defaults to legacy non-gecko event.
93 assertEquals(LEGACY_TYPE, goog.events.WheelHandler.getDomEventType());
94
95 // Gecko start to support wheel with version 17.
96 goog.userAgent.GECKO = true;
97 goog.userAgent.version = 16;
98 assertEquals(GECKO_TYPE, goog.events.WheelHandler.getDomEventType());
99 goog.userAgent.version = 17;
100 assertEquals(PREFERRED_TYPE, goog.events.WheelHandler.getDomEventType());
101 goog.userAgent.GECKO = false;
102
103 // IE started with version 9.
104 goog.userAgent.IE = true;
105 goog.userAgent.version = 8;
106 assertEquals(LEGACY_TYPE, goog.events.WheelHandler.getDomEventType());
107 goog.userAgent.version = 9;
108 assertEquals(PREFERRED_TYPE, goog.events.WheelHandler.getDomEventType());
109 goog.userAgent.IE = false;
110
111 // Chrome started with version 31.
112 goog.userAgent.product.CHROME = true;
113 goog.userAgent.product.version = 30;
114 assertEquals(LEGACY_TYPE, goog.events.WheelHandler.getDomEventType());
115 goog.userAgent.product.version = 31;
116 assertEquals(PREFERRED_TYPE, goog.events.WheelHandler.getDomEventType());
117 goog.userAgent.product.CHROME = false;
118 }
119
120 function testPreferredStyleWheel() {
121 // Enable 'wheel'
122 goog.userAgent.IE = true;
123 goog.userAgent.version = 9;
124 createHandlerAndListen();
125
126 handleEvent(createFakePreferredEvent(DeltaMode.PIXEL, 10, 20, 30));
127 assertWheelEvent(DeltaMode.PIXEL, 10, 20, 30);
128 assertPixelDeltas(1);
129
130 handleEvent(createFakePreferredEvent(DeltaMode.LINE, 10, 20, 30));
131 assertWheelEvent(DeltaMode.LINE, 10, 20, 30);
132 assertPixelDeltas(15);
133
134 handleEvent(createFakePreferredEvent(DeltaMode.PAGE, 10, 20, 30));
135 assertWheelEvent(DeltaMode.PAGE, 10, 20, 30);
136 assertPixelDeltas(30 * 15);
137 }
138
139 function testLegacyStyleWheel() {
140 // 'mousewheel' enabled by default
141 createHandlerAndListen();
142
143 // Test one dimensional.
144 handleEvent(createFakeLegacyEvent(10));
145 assertWheelEvent(DeltaMode.PIXEL, 0, -10, 0);
146 assertPixelDeltas(1);
147
148 // Test two dimensional.
149 handleEvent(createFakeLegacyEvent(/* ignored */ 10, 20, 30));
150 assertWheelEvent(DeltaMode.PIXEL, -20, -30, 0);
151 assertPixelDeltas(1);
152 }
153
154 function testLegacyGeckoStyleWheel() {
155 goog.userAgent.GECKO = true;
156 createHandlerAndListen();
157
158 // Test no axis.
159 handleEvent(createFakeGeckoEvent(10));
160 assertWheelEvent(DeltaMode.LINE, 0, 10, 0);
161 assertPixelDeltas(15);
162
163 // Vertical axis.
164 handleEvent(createFakeGeckoEvent(10, VERTICAL));
165 assertWheelEvent(DeltaMode.LINE, 0, 10, 0);
166 assertPixelDeltas(15);
167
168 // Horizontal axis.
169 handleEvent(createFakeGeckoEvent(10, HORIZONTAL));
170 assertWheelEvent(DeltaMode.LINE, 10, 0, 0);
171 assertPixelDeltas(15);
172 }
173
174 function testLegacyIeStyleWheel() {
175 goog.userAgent.IE = true;
176
177 createHandlerAndListen();
178
179 // Non-gecko, non-webkit events get wheelDelta divided by -40 to get detail.
180 handleEvent(createFakeLegacyEvent(120));
181 assertWheelEvent(DeltaMode.PIXEL, 0, -120, 0);
182
183 handleEvent(createFakeLegacyEvent(-120));
184 assertWheelEvent(DeltaMode.PIXEL, 0, 120, 0);
185
186 handleEvent(createFakeLegacyEvent(1200));
187 assertWheelEvent(DeltaMode.PIXEL, 0, -1200, 0);
188 }
189
190 function testNullBody() {
191 goog.userAgent.IE = true;
192 var documentObjectWithNoBody = {};
193 goog.testing.events.mixinListenable(documentObjectWithNoBody);
194 mouseWheelHandler = new goog.events.WheelHandler(documentObjectWithNoBody);
195 }
196
197 // Be sure to call this after setting up goog.userAgent mock and not before.
198 function createHandlerAndListen() {
199 mouseWheelHandler = new goog.events.WheelHandler(goog.dom.getElement('foo'));
200
201 goog.events.listen(
202 mouseWheelHandler, goog.events.WheelEvent.EventType.WHEEL,
203 function(e) { mouseWheelEvent = e; });
204
205 mouseWheelHandlerRtl =
206 new goog.events.WheelHandler(goog.dom.getElement('fooRtl'));
207
208 goog.events.listen(
209 mouseWheelHandlerRtl, goog.events.WheelEvent.EventType.WHEEL,
210 function(e) { mouseWheelEventRtl = e; });
211 }
212
213 function handleEvent(event) {
214 mouseWheelHandler.handleEvent(event);
215 mouseWheelHandlerRtl.handleEvent(event);
216 }
217
218 function assertWheelEvent(deltaMode, deltaX, deltaY, deltaZ) {
219 assertTrue('event should be non-null', !!mouseWheelEvent);
220 assertTrue(
221 'event should have correct JS type',
222 mouseWheelEvent instanceof goog.events.WheelEvent);
223 assertEquals(
224 'event should have correct deltaMode property', deltaMode,
225 mouseWheelEvent.deltaMode);
226 assertEquals(
227 'event should have correct deltaX property', deltaX,
228 mouseWheelEvent.deltaX);
229 assertEquals(
230 'event should have correct deltaY property', deltaY,
231 mouseWheelEvent.deltaY);
232 assertEquals(
233 'event should have correct deltaZ property', deltaZ,
234 mouseWheelEvent.deltaZ);
235
236 // RTL
237 assertTrue('event should be non-null', !!mouseWheelEventRtl);
238 assertTrue(
239 'event should have correct JS type',
240 mouseWheelEventRtl instanceof goog.events.WheelEvent);
241 assertEquals(
242 'event should have correct deltaMode property', deltaMode,
243 mouseWheelEventRtl.deltaMode);
244 assertEquals(
245 'event should have correct deltaX property', -deltaX,
246 mouseWheelEventRtl.deltaX);
247 assertEquals(
248 'event should have correct deltaY property', deltaY,
249 mouseWheelEventRtl.deltaY);
250 assertEquals(
251 'event should have correct deltaZ property', deltaZ,
252 mouseWheelEventRtl.deltaZ);
253 }
254
255 function assertPixelDeltas(scale) {
256 assertEquals(mouseWheelEvent.deltaX * scale, mouseWheelEvent.pixelDeltaX);
257 assertEquals(mouseWheelEvent.deltaY * scale, mouseWheelEvent.pixelDeltaY);
258 assertEquals(mouseWheelEvent.deltaZ * scale, mouseWheelEvent.pixelDeltaZ);
259
260 // RTL
261 assertEquals(
262 mouseWheelEventRtl.deltaX * scale, mouseWheelEventRtl.pixelDeltaX);
263 assertEquals(
264 mouseWheelEventRtl.deltaY * scale, mouseWheelEventRtl.pixelDeltaY);
265 assertEquals(
266 mouseWheelEventRtl.deltaZ * scale, mouseWheelEventRtl.pixelDeltaZ);
267 }
268
269 function createFakePreferredEvent(
270 opt_deltaMode, opt_deltaX, opt_deltaY, opt_deltaZ) {
271 var event = {
272 type: PREFERRED_TYPE,
273 deltaMode: opt_deltaMode,
274 deltaX: opt_deltaX,
275 deltaY: opt_deltaY,
276 deltaZ: opt_deltaZ
277 };
278 return new goog.events.BrowserEvent(event);
279 }
280
281
282 function createFakeLegacyEvent(
283 opt_wheelDelta, opt_wheelDeltaX, opt_wheelDeltaY) {
284 var event = {
285 type: LEGACY_TYPE,
286 wheelDelta: opt_wheelDelta,
287 wheelDeltaX: opt_wheelDeltaX,
288 wheelDeltaY: opt_wheelDeltaY
289 };
290 return new goog.events.BrowserEvent(event);
291 }
292
293 function createFakeGeckoEvent(opt_detail, opt_axis) {
294 var event = {
295 type: GECKO_TYPE,
296 detail: opt_detail,
297 axis: opt_axis,
298 HORIZONTAL_AXIS: HORIZONTAL,
299 VERTICAL_AXIS: VERTICAL
300 };
301 return new goog.events.BrowserEvent(event);
302 }