← Back to branch summary

~bac/juju-gui/trunkcopy

« back to all changes in this revision

Viewing changes to lib/yui/tests/event/tests/src/event-hover.js

  • Committer: kapil.foss at gmail
  • Date: 2012-07-13 18:45:59 UTC
  • Revision ID: kapil.foss@gmail.com-20120713184559-2xl7be17egsrz0c9
reshape

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/yui/tests/event/tests/src/event-hover.js
1
 
function setUp() {
2
 
    var testbed = Y.one('#testbed'),
3
 
        body;
4
 
 
5
 
    if (!testbed) {
6
 
        body = Y.one('body');
7
 
        testbed = body.create('<div id="testbed"></div>');
8
 
        body.prepend(testbed);
9
 
    }
10
 
 
11
 
    testbed.setContent(
12
 
    '<ul id="items">' +
13
 
        '<li id="item1">' +
14
 
            '<div id="div1"><p id="p1"># <em id="em1">1</em></p></div>' +
15
 
        '</li>' +
16
 
        '<li id="item2">' +
17
 
            '<div id="div2"><p id="p2"># <em id="em2">2</em></p></div>' +
18
 
        '</li>' +
19
 
        '<li id="item3">' +
20
 
            '<div id="div3"><p id="p3"># <em id="em3">3</em></p></div>' +
21
 
        '</li>' +
22
 
    '</ul>');
23
 
}
24
 
 
25
 
function tearDown() {
26
 
    var testbed = Y.one('#testbed');
27
 
 
28
 
    if (testbed) {
29
 
        testbed.remove().destroy(true);
30
 
    }
31
 
}
32
 
 
33
 
function mouse(target, out) {
34
 
    var eventname = (out) ? 'mouseout' : 'mouseover',
35
 
        testbed = Y.one('#testbed'),
36
 
        testbedReached = false,
37
 
        ancestors = Y.one(target).ancestors(function(node) {
38
 
            if (node === testbed) {
39
 
                testbedReached = true;
40
 
            }
41
 
            return !testbedReached;
42
 
        }, true),
43
 
        i, len;
44
 
 
45
 
    if (out) {
46
 
        for (i = ancestors.size() - 1; i >= 1; --i) {
47
 
            Y.Event.simulate(
48
 
                ancestors._nodes[i],
49
 
                eventname,
50
 
                { relatedTarget: ancestors._nodes[i - 1] });
51
 
        }
52
 
    } else {
53
 
        for (i = 1, len = ancestors.size(); i < len; ++i) {
54
 
            Y.Event.simulate(
55
 
                ancestors._nodes[i],
56
 
                eventname,
57
 
                { relatedTarget: ancestors._nodes[i - 1] });
58
 
        }
59
 
    }
60
 
}
61
 
 
62
 
var suite = new Y.Test.Suite("event-hover"),
63
 
    areSame = Y.Assert.areSame;
64
 
 
65
 
suite.add(new Y.Test.Case({
66
 
    name: 'subscribe',
67
 
 
68
 
    setUp: setUp,
69
 
    tearDown: tearDown,
70
 
 
71
 
    "test node.on('hover', over, out)": function () {
72
 
        var overCount = 0,
73
 
            outCount = 0,
74
 
            overArgCount = 0,
75
 
            outArgCount = 0,
76
 
            target = Y.one('#em1'),
77
 
            overType, outType, overPhase, outPhase, overEType, outEType,
78
 
            overTarget, outTarget, overCurrentTarget, outCurrentTarget,
79
 
            overRelTarget, outRelTarget,
80
 
            overThisObj, outThisObj;
81
 
 
82
 
        function over(e) {
83
 
            overCount++;
84
 
            overArgCount = arguments.length;
85
 
            overType = e.type;
86
 
            overPhase = e.phase;
87
 
            overEType = e._event.type;
88
 
            overThisObj = this;
89
 
            overTarget = e.target;
90
 
            overCurrentTarget = e.currentTarget;
91
 
        }
92
 
 
93
 
        function out(e) {
94
 
            outCount++;
95
 
            outArgCount = arguments.length;
96
 
            outType = e.type;
97
 
            outPhase = e.phase;
98
 
            outEType = e._event.type;
99
 
            outThisObj = this;
100
 
            outTarget = e.target;
101
 
            outCurrentTarget = e.currentTarget;
102
 
        }
103
 
 
104
 
        target.on('hover', over, out);
105
 
 
106
 
        mouse('#em1');
107
 
 
108
 
        Y.Assert.areSame(1, overCount);
109
 
        Y.Assert.areSame(1, overArgCount);
110
 
        Y.Assert.areSame('hover', overType);
111
 
        Y.Assert.areSame('over', overPhase);
112
 
        Y.Assert.areSame('mouseover', overEType);
113
 
        Y.Assert.areSame(target, overThisObj);
114
 
        Y.Assert.areSame(target, overTarget);
115
 
        Y.Assert.areSame(target, overCurrentTarget);
116
 
 
117
 
        Y.Assert.areSame(0, outCount);
118
 
        Y.Assert.areSame(0, outArgCount);
119
 
        Y.Assert.isUndefined(outType);
120
 
        Y.Assert.isUndefined(outPhase);
121
 
        Y.Assert.isUndefined(outEType);
122
 
        Y.Assert.isUndefined(outThisObj);
123
 
        Y.Assert.isUndefined(outTarget);
124
 
        Y.Assert.isUndefined(outCurrentTarget);
125
 
 
126
 
        mouse("#em1", true);
127
 
 
128
 
        Y.Assert.areSame(1, overCount);
129
 
        Y.Assert.areSame(1, overArgCount);
130
 
        Y.Assert.areSame('hover', overType);
131
 
        Y.Assert.areSame('over', overPhase);
132
 
        Y.Assert.areSame('mouseover', overEType);
133
 
        Y.Assert.areSame(target, overThisObj);
134
 
        Y.Assert.areSame(target, overTarget);
135
 
        Y.Assert.areSame(target, overCurrentTarget);
136
 
 
137
 
        Y.Assert.areSame(1, outCount);
138
 
        Y.Assert.areSame(1, outArgCount);
139
 
        Y.Assert.areSame('hover', outType);
140
 
        Y.Assert.areSame('out', outPhase);
141
 
        Y.Assert.areSame('mouseout', outEType);
142
 
        Y.Assert.areSame(target, outThisObj);
143
 
        Y.Assert.areSame(target, outTarget);
144
 
        Y.Assert.areSame(target, outCurrentTarget);
145
 
    },
146
 
 
147
 
    "test container.on('hover', over, out)": function () {
148
 
        var overCount = 0,
149
 
            outCount = 0,
150
 
            overArgCount = 0,
151
 
            outArgCount = 0,
152
 
            target = Y.one('#item1'),
153
 
            overType, outType, overPhase, outPhase, overEType, outEType,
154
 
            overTarget, outTarget, overCurrentTarget, outCurrentTarget,
155
 
            overRelTarget, outRelTarget,
156
 
            overThisObj, outThisObj;
157
 
 
158
 
        function over(e) {
159
 
            overCount++;
160
 
            overArgCount = arguments.length;
161
 
            overType = e.type;
162
 
            overPhase = e.phase;
163
 
            overEType = e._event.type;
164
 
            overThisObj = this;
165
 
            overTarget = e.target;
166
 
            overCurrentTarget = e.currentTarget;
167
 
        }
168
 
 
169
 
        function out(e) {
170
 
            outCount++;
171
 
            outArgCount = arguments.length;
172
 
            outType = e.type;
173
 
            outPhase = e.phase;
174
 
            outEType = e._event.type;
175
 
            outThisObj = this;
176
 
            outTarget = e.target;
177
 
            outCurrentTarget = e.currentTarget;
178
 
        }
179
 
 
180
 
        target.on('hover', over, out);
181
 
 
182
 
        mouse('#em1');
183
 
 
184
 
        Y.Assert.areSame(1, overCount);
185
 
        Y.Assert.areSame(1, overArgCount);
186
 
        Y.Assert.areSame('hover', overType);
187
 
        Y.Assert.areSame('over', overPhase);
188
 
        Y.Assert.areSame('mouseover', overEType);
189
 
        Y.Assert.areSame(target, overThisObj);
190
 
        Y.Assert.areSame(target, overTarget);
191
 
        Y.Assert.areSame(target, overCurrentTarget);
192
 
 
193
 
        Y.Assert.areSame(0, outCount);
194
 
        Y.Assert.areSame(0, outArgCount);
195
 
        Y.Assert.isUndefined(outType);
196
 
        Y.Assert.isUndefined(outPhase);
197
 
        Y.Assert.isUndefined(outEType);
198
 
        Y.Assert.isUndefined(outThisObj);
199
 
        Y.Assert.isUndefined(outTarget);
200
 
        Y.Assert.isUndefined(outCurrentTarget);
201
 
 
202
 
        mouse("#em1", true);
203
 
 
204
 
        Y.Assert.areSame(1, overCount);
205
 
        Y.Assert.areSame(1, overArgCount);
206
 
        Y.Assert.areSame('hover', overType);
207
 
        Y.Assert.areSame('over', overPhase);
208
 
        Y.Assert.areSame('mouseover', overEType);
209
 
        Y.Assert.areSame(target, overThisObj);
210
 
        Y.Assert.areSame(target, overTarget);
211
 
        Y.Assert.areSame(target, overCurrentTarget);
212
 
 
213
 
        Y.Assert.areSame(1, outCount);
214
 
        Y.Assert.areSame(1, outArgCount);
215
 
        Y.Assert.areSame('hover', outType);
216
 
        Y.Assert.areSame('out', outPhase);
217
 
        Y.Assert.areSame('mouseout', outEType);
218
 
        Y.Assert.areSame(target, outThisObj);
219
 
        Y.Assert.areSame(target, outTarget);
220
 
        Y.Assert.areSame(target, outCurrentTarget);
221
 
    },
222
 
 
223
 
    "test Y.on('hover', over, out, '#foo')": function () {
224
 
        var overCount = 0,
225
 
            outCount = 0,
226
 
            overArgCount = 0,
227
 
            outArgCount = 0,
228
 
            target = Y.one('#item1'),
229
 
            overType, outType, overPhase, outPhase, overEType, outEType,
230
 
            overTarget, outTarget, overCurrentTarget, outCurrentTarget,
231
 
            overRelTarget, outRelTarget,
232
 
            overThisObj, outThisObj;
233
 
 
234
 
        function over(e) {
235
 
            overCount++;
236
 
            overArgCount = arguments.length;
237
 
            overType = e.type;
238
 
            overPhase = e.phase;
239
 
            overEType = e._event.type;
240
 
            overThisObj = this;
241
 
            overTarget = e.target;
242
 
            overCurrentTarget = e.currentTarget;
243
 
        }
244
 
 
245
 
        function out(e) {
246
 
            outCount++;
247
 
            outArgCount = arguments.length;
248
 
            outType = e.type;
249
 
            outPhase = e.phase;
250
 
            outEType = e._event.type;
251
 
            outThisObj = this;
252
 
            outTarget = e.target;
253
 
            outCurrentTarget = e.currentTarget;
254
 
        }
255
 
 
256
 
        Y.on('hover', over, out, '#item1');
257
 
 
258
 
        mouse('#em1');
259
 
 
260
 
        Y.Assert.areSame(1, overCount);
261
 
        Y.Assert.areSame(1, overArgCount);
262
 
        Y.Assert.areSame('hover', overType);
263
 
        Y.Assert.areSame('over', overPhase);
264
 
        Y.Assert.areSame('mouseover', overEType);
265
 
        Y.Assert.areSame(target, overThisObj);
266
 
        Y.Assert.areSame(target, overTarget);
267
 
        Y.Assert.areSame(target, overCurrentTarget);
268
 
 
269
 
        Y.Assert.areSame(0, outCount);
270
 
        Y.Assert.areSame(0, outArgCount);
271
 
        Y.Assert.isUndefined(outType);
272
 
        Y.Assert.isUndefined(outPhase);
273
 
        Y.Assert.isUndefined(outEType);
274
 
        Y.Assert.isUndefined(outThisObj);
275
 
        Y.Assert.isUndefined(outTarget);
276
 
        Y.Assert.isUndefined(outCurrentTarget);
277
 
 
278
 
        mouse("#em1", true);
279
 
 
280
 
        Y.Assert.areSame(1, overCount);
281
 
        Y.Assert.areSame(1, overArgCount);
282
 
        Y.Assert.areSame('hover', overType);
283
 
        Y.Assert.areSame('over', overPhase);
284
 
        Y.Assert.areSame('mouseover', overEType);
285
 
        Y.Assert.areSame(target, overThisObj);
286
 
        Y.Assert.areSame(target, overTarget);
287
 
        Y.Assert.areSame(target, overCurrentTarget);
288
 
 
289
 
        Y.Assert.areSame(1, outCount);
290
 
        Y.Assert.areSame(1, outArgCount);
291
 
        Y.Assert.areSame('hover', outType);
292
 
        Y.Assert.areSame('out', outPhase);
293
 
        Y.Assert.areSame('mouseout', outEType);
294
 
        Y.Assert.areSame(target, outThisObj);
295
 
        Y.Assert.areSame(target, outTarget);
296
 
        Y.Assert.areSame(target, outCurrentTarget);
297
 
    },
298
 
 
299
 
    "test nodelist.on('hover', over, out)": function () {
300
 
        var overCount = 0,
301
 
            outCount = 0,
302
 
            overArgCount = 0,
303
 
            outArgCount = 0,
304
 
            item1 = Y.one('#item1'),
305
 
            item2 = Y.one('#item2'),
306
 
            item3 = Y.one('#item3'),
307
 
            overType = [],
308
 
            overPhase = [],
309
 
            overEType = [],
310
 
            overTarget = [],
311
 
            overCurrentTarget = [],
312
 
            overRelTarget = [],
313
 
            overThisObj = [],
314
 
            outType = [],
315
 
            outPhase = [],
316
 
            outEType = [],
317
 
            outTarget = [],
318
 
            outCurrentTarget = [],
319
 
            outRelTarget = [],
320
 
            outThisObj = [];
321
 
 
322
 
        function over(e) {
323
 
            overCount++;
324
 
            overArgCount = arguments.length;
325
 
            overType.push(e.type);
326
 
            overPhase.push(e.phase);
327
 
            overEType.push(e._event.type);
328
 
            overThisObj.push(this);
329
 
            overTarget.push(e.target);
330
 
            overCurrentTarget.push(e.currentTarget);
331
 
        }
332
 
 
333
 
        function out(e) {
334
 
            outCount++;
335
 
            outArgCount = arguments.length;
336
 
            outType.push(e.type);
337
 
            outPhase.push(e.phase);
338
 
            outEType.push(e._event.type);
339
 
            outThisObj.push(this);
340
 
            outTarget.push(e.target);
341
 
            outCurrentTarget.push(e.currentTarget);
342
 
        }
343
 
 
344
 
        Y.all('#items li').on('hover', over, out);
345
 
 
346
 
        mouse('#em1'); mouse("#em1", true);
347
 
 
348
 
        Y.Assert.areSame(1, overCount);
349
 
        Y.Assert.areSame(1, overArgCount);
350
 
        Y.ArrayAssert.itemsAreSame(['hover'], overType);
351
 
        Y.ArrayAssert.itemsAreSame(['over'], overPhase);
352
 
        Y.ArrayAssert.itemsAreSame(['mouseover'], overEType);
353
 
        Y.ArrayAssert.itemsAreSame([item1], overThisObj);
354
 
        Y.ArrayAssert.itemsAreSame([item1], overTarget);
355
 
        Y.ArrayAssert.itemsAreSame([item1], overCurrentTarget);
356
 
 
357
 
        Y.Assert.areSame(1, outCount);
358
 
        Y.Assert.areSame(1, outArgCount);
359
 
        Y.ArrayAssert.itemsAreSame(['hover'], outType);
360
 
        Y.ArrayAssert.itemsAreSame(['out'], outPhase);
361
 
        Y.ArrayAssert.itemsAreSame(['mouseout'], outEType);
362
 
        Y.ArrayAssert.itemsAreSame([item1], outThisObj);
363
 
        Y.ArrayAssert.itemsAreSame([item1], outTarget);
364
 
        Y.ArrayAssert.itemsAreSame([item1], outCurrentTarget);
365
 
 
366
 
        mouse("#em2"); mouse("#em2", true);
367
 
        mouse("#em3"); mouse("#em3", true);
368
 
 
369
 
        Y.Assert.areSame(3, overCount);
370
 
        Y.Assert.areSame(1, overArgCount);
371
 
        Y.ArrayAssert.itemsAreSame(['hover','hover','hover'], overType);
372
 
        Y.ArrayAssert.itemsAreSame(['over','over','over'], overPhase);
373
 
        Y.ArrayAssert.itemsAreSame(['mouseover','mouseover','mouseover'], overEType);
374
 
        Y.ArrayAssert.itemsAreSame([item1, item2, item3], overThisObj);
375
 
        Y.ArrayAssert.itemsAreSame([item1, item2, item3], overTarget);
376
 
        Y.ArrayAssert.itemsAreSame([item1, item2, item3], overCurrentTarget);
377
 
 
378
 
        Y.Assert.areSame(3, outCount);
379
 
        Y.Assert.areSame(1, outArgCount);
380
 
        Y.ArrayAssert.itemsAreSame(['hover','hover','hover'], outType);
381
 
        Y.ArrayAssert.itemsAreSame(['out','out','out'], outPhase);
382
 
        Y.ArrayAssert.itemsAreSame(['mouseout','mouseout','mouseout'], outEType);
383
 
        Y.ArrayAssert.itemsAreSame([item1, item2, item3], outThisObj);
384
 
        Y.ArrayAssert.itemsAreSame([item1, item2, item3], outTarget);
385
 
        Y.ArrayAssert.itemsAreSame([item1, item2, item3], outCurrentTarget);
386
 
    },
387
 
 
388
 
    "test node.delegate('hover', over, out, filter)": function () {
389
 
        var overCount = 0,
390
 
            outCount = 0,
391
 
            overArgCount = 0,
392
 
            outArgCount = 0,
393
 
            items = Y.one('#items'),
394
 
            item1 = Y.one('#item1'),
395
 
            item2 = Y.one('#item2'),
396
 
            item3 = Y.one('#item3'),
397
 
            overType = [],
398
 
            overPhase = [],
399
 
            overEType = [],
400
 
            overTarget = [],
401
 
            overCurrentTarget = [],
402
 
            overRelTarget = [],
403
 
            overThisObj = [],
404
 
            outType = [],
405
 
            outPhase = [],
406
 
            outEType = [],
407
 
            outTarget = [],
408
 
            outCurrentTarget = [],
409
 
            outRelTarget = [],
410
 
            outThisObj = [],
411
 
            overContainer = [],
412
 
            outContainer = [];
413
 
 
414
 
 
415
 
        function over(e) {
416
 
            overCount++;
417
 
            overArgCount = arguments.length;
418
 
            overType.push(e.type);
419
 
            overPhase.push(e.phase);
420
 
            overEType.push(e._event.type);
421
 
            overThisObj.push(this);
422
 
            overTarget.push(e.target);
423
 
            overCurrentTarget.push(e.currentTarget);
424
 
            overContainer.push(e.container);
425
 
        }
426
 
 
427
 
        function out(e) {
428
 
            outCount++;
429
 
            outArgCount = arguments.length;
430
 
            outType.push(e.type);
431
 
            outPhase.push(e.phase);
432
 
            outEType.push(e._event.type);
433
 
            outThisObj.push(this);
434
 
            outTarget.push(e.target);
435
 
            outCurrentTarget.push(e.currentTarget);
436
 
            outContainer.push(e.container);
437
 
        }
438
 
 
439
 
        items.delegate('hover', over, out, 'li');
440
 
 
441
 
        mouse('#em1'); mouse("#em1", true);
442
 
 
443
 
        Y.Assert.areSame(1, overCount);
444
 
        Y.Assert.areSame(1, overArgCount);
445
 
        Y.ArrayAssert.itemsAreSame(['hover'], overType);
446
 
        Y.ArrayAssert.itemsAreSame(['over'], overPhase);
447
 
        Y.ArrayAssert.itemsAreSame(['mouseover'], overEType);
448
 
        Y.ArrayAssert.itemsAreSame([item1], overThisObj);
449
 
        Y.ArrayAssert.itemsAreSame([item1], overTarget);
450
 
        Y.ArrayAssert.itemsAreSame([item1], overCurrentTarget);
451
 
        Y.ArrayAssert.itemsAreSame([items], overContainer);
452
 
 
453
 
        Y.Assert.areSame(1, outCount);
454
 
        Y.Assert.areSame(1, outArgCount);
455
 
        Y.ArrayAssert.itemsAreSame(['hover'], outType);
456
 
        Y.ArrayAssert.itemsAreSame(['out'], outPhase);
457
 
        Y.ArrayAssert.itemsAreSame(['mouseout'], outEType);
458
 
        Y.ArrayAssert.itemsAreSame([item1], outThisObj);
459
 
        Y.ArrayAssert.itemsAreSame([item1], outTarget);
460
 
        Y.ArrayAssert.itemsAreSame([item1], outCurrentTarget);
461
 
        Y.ArrayAssert.itemsAreSame([items], overContainer);
462
 
 
463
 
        mouse("#em2"); mouse("#em2", true);
464
 
        mouse("#em3"); mouse("#em3", true);
465
 
 
466
 
        Y.Assert.areSame(3, overCount);
467
 
        Y.Assert.areSame(1, overArgCount);
468
 
        Y.ArrayAssert.itemsAreSame(['hover','hover','hover'], overType);
469
 
        Y.ArrayAssert.itemsAreSame(['over','over','over'], overPhase);
470
 
        Y.ArrayAssert.itemsAreSame(['mouseover','mouseover','mouseover'], overEType);
471
 
        Y.ArrayAssert.itemsAreSame([item1, item2, item3], overThisObj);
472
 
        Y.ArrayAssert.itemsAreSame([item1, item2, item3], overTarget);
473
 
        Y.ArrayAssert.itemsAreSame([item1, item2, item3], overCurrentTarget);
474
 
        Y.ArrayAssert.itemsAreSame([items, items, items], overContainer);
475
 
 
476
 
        Y.Assert.areSame(3, outCount);
477
 
        Y.Assert.areSame(1, outArgCount);
478
 
        Y.ArrayAssert.itemsAreSame(['hover','hover','hover'], outType);
479
 
        Y.ArrayAssert.itemsAreSame(['out','out','out'], outPhase);
480
 
        Y.ArrayAssert.itemsAreSame(['mouseout','mouseout','mouseout'], outEType);
481
 
        Y.ArrayAssert.itemsAreSame([item1, item2, item3], outThisObj);
482
 
        Y.ArrayAssert.itemsAreSame([item1, item2, item3], outTarget);
483
 
        Y.ArrayAssert.itemsAreSame([item1, item2, item3], outCurrentTarget);
484
 
        Y.ArrayAssert.itemsAreSame([items, items, items], outContainer);
485
 
    },
486
 
 
487
 
    "test node.on('hover', over, out, thisObj)": function () {
488
 
        var overCount = 0,
489
 
            outCount = 0,
490
 
            overArgCount = 0,
491
 
            outArgCount = 0,
492
 
            target = Y.one('#item1'),
493
 
            obj = { foo: 'foo' },
494
 
            overType, outType, overPhase, outPhase, overEType, outEType,
495
 
            overTarget, outTarget, overCurrentTarget, outCurrentTarget,
496
 
            overRelTarget, outRelTarget,
497
 
            overThisObj, outThisObj, overFoo, outFoo;
498
 
 
499
 
        function over(e) {
500
 
            overCount++;
501
 
            overArgCount = arguments.length;
502
 
            overType = e.type;
503
 
            overPhase = e.phase;
504
 
            overEType = e._event.type;
505
 
            overThisObj = this;
506
 
            overTarget = e.target;
507
 
            overCurrentTarget = e.currentTarget;
508
 
            overFoo = this.foo;
509
 
        }
510
 
 
511
 
        function out(e) {
512
 
            outCount++;
513
 
            outArgCount = arguments.length;
514
 
            outType = e.type;
515
 
            outPhase = e.phase;
516
 
            outEType = e._event.type;
517
 
            outThisObj = this;
518
 
            outTarget = e.target;
519
 
            outCurrentTarget = e.currentTarget;
520
 
            outFoo = this.foo;
521
 
        }
522
 
 
523
 
        target.on('hover', over, out, obj);
524
 
 
525
 
        mouse('#em1'); mouse("#em1", true);
526
 
 
527
 
        Y.Assert.areSame(1, overCount);
528
 
        Y.Assert.areSame(1, overArgCount);
529
 
        Y.Assert.areSame('hover', overType);
530
 
        Y.Assert.areSame('over', overPhase);
531
 
        Y.Assert.areSame('mouseover', overEType);
532
 
        Y.Assert.areSame(obj, overThisObj);
533
 
        Y.Assert.areSame(target, overTarget);
534
 
        Y.Assert.areSame(target, overCurrentTarget);
535
 
        Y.Assert.areSame('foo', overFoo);
536
 
 
537
 
        Y.Assert.areSame(1, outCount);
538
 
        Y.Assert.areSame(1, outArgCount);
539
 
        Y.Assert.areSame('hover', outType);
540
 
        Y.Assert.areSame('out', outPhase);
541
 
        Y.Assert.areSame('mouseout', outEType);
542
 
        Y.Assert.areSame(obj, outThisObj);
543
 
        Y.Assert.areSame(target, outTarget);
544
 
        Y.Assert.areSame(target, outCurrentTarget);
545
 
        Y.Assert.areSame('foo', outFoo);
546
 
    },
547
 
 
548
 
    "test Y.on('hover', over, out, '#foo', thisObj)": function () {
549
 
        var overCount = 0,
550
 
            outCount = 0,
551
 
            overArgCount = 0,
552
 
            outArgCount = 0,
553
 
            target = Y.one('#item1'),
554
 
            obj = { foo: 'foo' },
555
 
            overType, outType, overPhase, outPhase, overEType, outEType,
556
 
            overTarget, outTarget, overCurrentTarget, outCurrentTarget,
557
 
            overRelTarget, outRelTarget,
558
 
            overThisObj, outThisObj, overFoo, outFoo;
559
 
 
560
 
        function over(e) {
561
 
            overCount++;
562
 
            overArgCount = arguments.length;
563
 
            overType = e.type;
564
 
            overPhase = e.phase;
565
 
            overEType = e._event.type;
566
 
            overThisObj = this;
567
 
            overTarget = e.target;
568
 
            overCurrentTarget = e.currentTarget;
569
 
            overFoo = this.foo;
570
 
        }
571
 
 
572
 
        function out(e) {
573
 
            outCount++;
574
 
            outArgCount = arguments.length;
575
 
            outType = e.type;
576
 
            outPhase = e.phase;
577
 
            outEType = e._event.type;
578
 
            outThisObj = this;
579
 
            outTarget = e.target;
580
 
            outCurrentTarget = e.currentTarget;
581
 
            outFoo = this.foo;
582
 
        }
583
 
 
584
 
        Y.on('hover', over, out, '#item1', obj);
585
 
 
586
 
        mouse('#em1'); mouse("#em1", true);
587
 
 
588
 
        Y.Assert.areSame(1, overCount);
589
 
        Y.Assert.areSame(1, overArgCount);
590
 
        Y.Assert.areSame('hover', overType);
591
 
        Y.Assert.areSame('over', overPhase);
592
 
        Y.Assert.areSame('mouseover', overEType);
593
 
        Y.Assert.areSame(obj, overThisObj);
594
 
        Y.Assert.areSame(target, overTarget);
595
 
        Y.Assert.areSame(target, overCurrentTarget);
596
 
        Y.Assert.areSame('foo', overFoo);
597
 
 
598
 
        Y.Assert.areSame(1, outCount);
599
 
        Y.Assert.areSame(1, outArgCount);
600
 
        Y.Assert.areSame('hover', outType);
601
 
        Y.Assert.areSame('out', outPhase);
602
 
        Y.Assert.areSame('mouseout', outEType);
603
 
        Y.Assert.areSame(obj, outThisObj);
604
 
        Y.Assert.areSame(target, outTarget);
605
 
        Y.Assert.areSame(target, outCurrentTarget);
606
 
        Y.Assert.areSame('foo', outFoo);
607
 
    },
608
 
 
609
 
    "test nodelist.on('hover', over, out, thisObj)": function () {
610
 
        var overCount = 0,
611
 
            outCount = 0,
612
 
            overArgCount = 0,
613
 
            outArgCount = 0,
614
 
            item1 = Y.one('#item1'),
615
 
            item2 = Y.one('#item2'),
616
 
            item3 = Y.one('#item3'),
617
 
            obj = { foo: 'foo' },
618
 
            overType = [],
619
 
            overPhase = [],
620
 
            overEType = [],
621
 
            overTarget = [],
622
 
            overCurrentTarget = [],
623
 
            overRelTarget = [],
624
 
            overThisObj = [],
625
 
            overFoo = [],
626
 
            outType = [],
627
 
            outPhase = [],
628
 
            outEType = [],
629
 
            outTarget = [],
630
 
            outCurrentTarget = [],
631
 
            outRelTarget = [],
632
 
            outThisObj = [],
633
 
            outFoo = [];
634
 
 
635
 
        function over(e) {
636
 
            overCount++;
637
 
            overArgCount = arguments.length;
638
 
            overType.push(e.type);
639
 
            overPhase.push(e.phase);
640
 
            overEType.push(e._event.type);
641
 
            overThisObj.push(this);
642
 
            overTarget.push(e.target);
643
 
            overCurrentTarget.push(e.currentTarget);
644
 
            overFoo.push(this.foo);
645
 
        }
646
 
 
647
 
        function out(e) {
648
 
            outCount++;
649
 
            outArgCount = arguments.length;
650
 
            outType.push(e.type);
651
 
            outPhase.push(e.phase);
652
 
            outEType.push(e._event.type);
653
 
            outThisObj.push(this);
654
 
            outTarget.push(e.target);
655
 
            outCurrentTarget.push(e.currentTarget);
656
 
            outFoo.push(this.foo);
657
 
        }
658
 
 
659
 
        Y.all('#items li').on('hover', over, out, obj);
660
 
 
661
 
        mouse('#em1'); mouse("#em1", true);
662
 
 
663
 
        Y.Assert.areSame(1, overCount);
664
 
        Y.Assert.areSame(1, overArgCount);
665
 
        Y.ArrayAssert.itemsAreSame(['hover'], overType);
666
 
        Y.ArrayAssert.itemsAreSame(['over'], overPhase);
667
 
        Y.ArrayAssert.itemsAreSame(['mouseover'], overEType);
668
 
        Y.ArrayAssert.itemsAreSame([obj], overThisObj);
669
 
        Y.ArrayAssert.itemsAreSame([item1], overTarget);
670
 
        Y.ArrayAssert.itemsAreSame([item1], overCurrentTarget);
671
 
 
672
 
        Y.Assert.areSame(1, outCount);
673
 
        Y.Assert.areSame(1, outArgCount);
674
 
        Y.ArrayAssert.itemsAreSame(['hover'], outType);
675
 
        Y.ArrayAssert.itemsAreSame(['out'], outPhase);
676
 
        Y.ArrayAssert.itemsAreSame(['mouseout'], outEType);
677
 
        Y.ArrayAssert.itemsAreSame([obj], outThisObj);
678
 
        Y.ArrayAssert.itemsAreSame([item1], outTarget);
679
 
        Y.ArrayAssert.itemsAreSame([item1], outCurrentTarget);
680
 
 
681
 
        mouse("#em2"); mouse("#em2", true);
682
 
        mouse("#em3"); mouse("#em3", true);
683
 
 
684
 
        Y.Assert.areSame(3, overCount);
685
 
        Y.Assert.areSame(1, overArgCount);
686
 
        Y.ArrayAssert.itemsAreSame(['hover','hover','hover'], overType);
687
 
        Y.ArrayAssert.itemsAreSame(['over','over','over'], overPhase);
688
 
        Y.ArrayAssert.itemsAreSame(['mouseover','mouseover','mouseover'], overEType);
689
 
        Y.ArrayAssert.itemsAreSame([obj, obj, obj], overThisObj);
690
 
        Y.ArrayAssert.itemsAreSame([item1, item2, item3], overTarget);
691
 
        Y.ArrayAssert.itemsAreSame([item1, item2, item3], overCurrentTarget);
692
 
 
693
 
        Y.Assert.areSame(3, outCount);
694
 
        Y.Assert.areSame(1, outArgCount);
695
 
        Y.ArrayAssert.itemsAreSame(['hover','hover','hover'], outType);
696
 
        Y.ArrayAssert.itemsAreSame(['out','out','out'], outPhase);
697
 
        Y.ArrayAssert.itemsAreSame(['mouseout','mouseout','mouseout'], outEType);
698
 
        Y.ArrayAssert.itemsAreSame([obj, obj, obj], outThisObj);
699
 
        Y.ArrayAssert.itemsAreSame([item1, item2, item3], outTarget);
700
 
        Y.ArrayAssert.itemsAreSame([item1, item2, item3], outCurrentTarget);
701
 
    },
702
 
 
703
 
    "test node.on('hover', over, out, thisObj, arg)": function () {
704
 
        var overCount = 0,
705
 
            outCount = 0,
706
 
            overArgCount = 0,
707
 
            outArgCount = 0,
708
 
            target = Y.one('#item1'),
709
 
            obj = { foo: 'foo' },
710
 
            overType, outType, overPhase, outPhase, overEType, outEType,
711
 
            overTarget, outTarget, overCurrentTarget, outCurrentTarget,
712
 
            overRelTarget, outRelTarget,
713
 
            overThisObj, outThisObj, overFoo, outFoo, overArg, outArg;
714
 
 
715
 
        function over(e, x) {
716
 
            overCount++;
717
 
            overArgCount = arguments.length;
718
 
            overType = e.type;
719
 
            overPhase = e.phase;
720
 
            overEType = e._event.type;
721
 
            overThisObj = this;
722
 
            overTarget = e.target;
723
 
            overCurrentTarget = e.currentTarget;
724
 
            overFoo = this.foo;
725
 
            overArg = x;
726
 
        }
727
 
 
728
 
        function out(e, x) {
729
 
            outCount++;
730
 
            outArgCount = arguments.length;
731
 
            outType = e.type;
732
 
            outPhase = e.phase;
733
 
            outEType = e._event.type;
734
 
            outThisObj = this;
735
 
            outTarget = e.target;
736
 
            outCurrentTarget = e.currentTarget;
737
 
            outFoo = this.foo;
738
 
            outArg = x;
739
 
        }
740
 
 
741
 
        target.on('hover', over, out, obj, "arg!");
742
 
 
743
 
        mouse('#em1'); mouse("#em1", true);
744
 
 
745
 
        Y.Assert.areSame(1, overCount);
746
 
        Y.Assert.areSame(2, overArgCount);
747
 
        Y.Assert.areSame('hover', overType);
748
 
        Y.Assert.areSame('over', overPhase);
749
 
        Y.Assert.areSame('mouseover', overEType);
750
 
        Y.Assert.areSame(obj, overThisObj);
751
 
        Y.Assert.areSame(target, overTarget);
752
 
        Y.Assert.areSame(target, overCurrentTarget);
753
 
        Y.Assert.areSame('foo', overFoo);
754
 
        Y.Assert.areSame('arg!', overArg);
755
 
 
756
 
        Y.Assert.areSame(1, outCount);
757
 
        Y.Assert.areSame(2, outArgCount);
758
 
        Y.Assert.areSame('hover', outType);
759
 
        Y.Assert.areSame('out', outPhase);
760
 
        Y.Assert.areSame('mouseout', outEType);
761
 
        Y.Assert.areSame(obj, outThisObj);
762
 
        Y.Assert.areSame(target, outTarget);
763
 
        Y.Assert.areSame(target, outCurrentTarget);
764
 
        Y.Assert.areSame('foo', outFoo);
765
 
        Y.Assert.areSame('arg!', outArg);
766
 
    },
767
 
 
768
 
    "test Y.on('hover', over, out, '#foo', thisObj, arg)": function () {
769
 
        var overCount = 0,
770
 
            outCount = 0,
771
 
            overArgCount = 0,
772
 
            outArgCount = 0,
773
 
            target = Y.one('#item1'),
774
 
            obj = { foo: 'foo' },
775
 
            overType, outType, overPhase, outPhase, overEType, outEType,
776
 
            overTarget, outTarget, overCurrentTarget, outCurrentTarget,
777
 
            overRelTarget, outRelTarget,
778
 
            overThisObj, outThisObj, overFoo, outFoo, overArg, outArg;
779
 
 
780
 
        function over(e, x) {
781
 
            overCount++;
782
 
            overArgCount = arguments.length;
783
 
            overType = e.type;
784
 
            overPhase = e.phase;
785
 
            overEType = e._event.type;
786
 
            overThisObj = this;
787
 
            overTarget = e.target;
788
 
            overCurrentTarget = e.currentTarget;
789
 
            overFoo = this.foo;
790
 
            overArg = x;
791
 
        }
792
 
 
793
 
        function out(e, x) {
794
 
            outCount++;
795
 
            outArgCount = arguments.length;
796
 
            outType = e.type;
797
 
            outPhase = e.phase;
798
 
            outEType = e._event.type;
799
 
            outThisObj = this;
800
 
            outTarget = e.target;
801
 
            outCurrentTarget = e.currentTarget;
802
 
            outFoo = this.foo;
803
 
            outArg = x;
804
 
        }
805
 
 
806
 
        Y.on('hover', over, out, "#item1", obj, "arg!");
807
 
 
808
 
        mouse('#em1'); mouse("#em1", true);
809
 
 
810
 
        Y.Assert.areSame(1, overCount);
811
 
        Y.Assert.areSame(2, overArgCount);
812
 
        Y.Assert.areSame('hover', overType);
813
 
        Y.Assert.areSame('over', overPhase);
814
 
        Y.Assert.areSame('mouseover', overEType);
815
 
        Y.Assert.areSame(obj, overThisObj);
816
 
        Y.Assert.areSame(target, overTarget);
817
 
        Y.Assert.areSame(target, overCurrentTarget);
818
 
        Y.Assert.areSame('foo', overFoo);
819
 
        Y.Assert.areSame('arg!', overArg);
820
 
 
821
 
        Y.Assert.areSame(1, outCount);
822
 
        Y.Assert.areSame(2, outArgCount);
823
 
        Y.Assert.areSame('hover', outType);
824
 
        Y.Assert.areSame('out', outPhase);
825
 
        Y.Assert.areSame('mouseout', outEType);
826
 
        Y.Assert.areSame(obj, outThisObj);
827
 
        Y.Assert.areSame(target, outTarget);
828
 
        Y.Assert.areSame(target, outCurrentTarget);
829
 
        Y.Assert.areSame('foo', outFoo);
830
 
        Y.Assert.areSame('arg!', outArg);
831
 
    },
832
 
 
833
 
    "test nodelist.on('hover', over, out, thisObj, arg)": function () {
834
 
        var overCount = 0,
835
 
            outCount = 0,
836
 
            overArgCount = 0,
837
 
            outArgCount = 0,
838
 
            item1 = Y.one('#item1'),
839
 
            item2 = Y.one('#item2'),
840
 
            item3 = Y.one('#item3'),
841
 
            obj = { foo: 'foo' },
842
 
            overType = [],
843
 
            overPhase = [],
844
 
            overEType = [],
845
 
            overTarget = [],
846
 
            overCurrentTarget = [],
847
 
            overRelTarget = [],
848
 
            overThisObj = [],
849
 
            overArg = [],
850
 
            overFoo = [],
851
 
            outType = [],
852
 
            outPhase = [],
853
 
            outEType = [],
854
 
            outTarget = [],
855
 
            outCurrentTarget = [],
856
 
            outRelTarget = [],
857
 
            outThisObj = [],
858
 
            outFoo = [],
859
 
            outArg = [];
860
 
 
861
 
        function over(e, x) {
862
 
            overCount++;
863
 
            overArgCount = arguments.length;
864
 
            overType.push(e.type);
865
 
            overPhase.push(e.phase);
866
 
            overEType.push(e._event.type);
867
 
            overThisObj.push(this);
868
 
            overTarget.push(e.target);
869
 
            overCurrentTarget.push(e.currentTarget);
870
 
            overFoo.push(this.foo);
871
 
            overArg.push(x);
872
 
        }
873
 
 
874
 
        function out(e, x) {
875
 
            outCount++;
876
 
            outArgCount = arguments.length;
877
 
            outType.push(e.type);
878
 
            outPhase.push(e.phase);
879
 
            outEType.push(e._event.type);
880
 
            outThisObj.push(this);
881
 
            outTarget.push(e.target);
882
 
            outCurrentTarget.push(e.currentTarget);
883
 
            outFoo.push(this.foo);
884
 
            outArg.push(x);
885
 
        }
886
 
 
887
 
        Y.all('#items li').on('hover', over, out, obj, 'arg!');
888
 
 
889
 
        mouse('#em1'); mouse("#em1", true);
890
 
 
891
 
        Y.Assert.areSame(1, overCount);
892
 
        Y.Assert.areSame(2, overArgCount);
893
 
        Y.ArrayAssert.itemsAreSame(['hover'], overType);
894
 
        Y.ArrayAssert.itemsAreSame(['over'], overPhase);
895
 
        Y.ArrayAssert.itemsAreSame(['mouseover'], overEType);
896
 
        Y.ArrayAssert.itemsAreSame([obj], overThisObj);
897
 
        Y.ArrayAssert.itemsAreSame([item1], overTarget);
898
 
        Y.ArrayAssert.itemsAreSame([item1], overCurrentTarget);
899
 
        Y.ArrayAssert.itemsAreSame(['foo'], overFoo);
900
 
        Y.ArrayAssert.itemsAreSame(['arg!'], overArg);
901
 
 
902
 
        Y.Assert.areSame(1, outCount);
903
 
        Y.Assert.areSame(2, outArgCount);
904
 
        Y.ArrayAssert.itemsAreSame(['hover'], outType);
905
 
        Y.ArrayAssert.itemsAreSame(['out'], outPhase);
906
 
        Y.ArrayAssert.itemsAreSame(['mouseout'], outEType);
907
 
        Y.ArrayAssert.itemsAreSame([obj], outThisObj);
908
 
        Y.ArrayAssert.itemsAreSame([item1], outTarget);
909
 
        Y.ArrayAssert.itemsAreSame([item1], outCurrentTarget);
910
 
        Y.ArrayAssert.itemsAreSame(['foo'], outFoo);
911
 
        Y.ArrayAssert.itemsAreSame(['arg!'], outArg);
912
 
 
913
 
        mouse("#em2"); mouse("#em2", true);
914
 
        mouse("#em3"); mouse("#em3", true);
915
 
 
916
 
        Y.Assert.areSame(3, overCount);
917
 
        Y.Assert.areSame(2, overArgCount);
918
 
        Y.ArrayAssert.itemsAreSame(['hover','hover','hover'], overType);
919
 
        Y.ArrayAssert.itemsAreSame(['over','over','over'], overPhase);
920
 
        Y.ArrayAssert.itemsAreSame(['mouseover','mouseover','mouseover'], overEType);
921
 
        Y.ArrayAssert.itemsAreSame([obj, obj, obj], overThisObj);
922
 
        Y.ArrayAssert.itemsAreSame([item1, item2, item3], overTarget);
923
 
        Y.ArrayAssert.itemsAreSame([item1, item2, item3], overCurrentTarget);
924
 
        Y.ArrayAssert.itemsAreSame(['arg!', 'arg!', 'arg!'], overArg);
925
 
 
926
 
        Y.Assert.areSame(3, outCount);
927
 
        Y.Assert.areSame(2, outArgCount);
928
 
        Y.ArrayAssert.itemsAreSame(['hover','hover','hover'], outType);
929
 
        Y.ArrayAssert.itemsAreSame(['out','out','out'], outPhase);
930
 
        Y.ArrayAssert.itemsAreSame(['mouseout','mouseout','mouseout'], outEType);
931
 
        Y.ArrayAssert.itemsAreSame([obj, obj, obj], outThisObj);
932
 
        Y.ArrayAssert.itemsAreSame([item1, item2, item3], outTarget);
933
 
        Y.ArrayAssert.itemsAreSame([item1, item2, item3], outCurrentTarget);
934
 
        Y.ArrayAssert.itemsAreSame(['arg!', 'arg!', 'arg!'], outArg);
935
 
    },
936
 
 
937
 
    "test node.on('hover', over, out, null, arg)": function () {
938
 
        var overCount = 0,
939
 
            outCount = 0,
940
 
            overArgCount = 0,
941
 
            outArgCount = 0,
942
 
            target = Y.one('#item1'),
943
 
            overType, outType, overPhase, outPhase, overEType, outEType,
944
 
            overTarget, outTarget, overCurrentTarget, outCurrentTarget,
945
 
            overRelTarget, outRelTarget,
946
 
            overThisObj, outThisObj, overArg, outArg;
947
 
 
948
 
        function over(e, x) {
949
 
            overCount++;
950
 
            overArgCount = arguments.length;
951
 
            overType = e.type;
952
 
            overPhase = e.phase;
953
 
            overEType = e._event.type;
954
 
            overThisObj = this;
955
 
            overTarget = e.target;
956
 
            overCurrentTarget = e.currentTarget;
957
 
            overArg = x;
958
 
        }
959
 
 
960
 
        function out(e, x) {
961
 
            outCount++;
962
 
            outArgCount = arguments.length;
963
 
            outType = e.type;
964
 
            outPhase = e.phase;
965
 
            outEType = e._event.type;
966
 
            outThisObj = this;
967
 
            outTarget = e.target;
968
 
            outCurrentTarget = e.currentTarget;
969
 
            outArg = x;
970
 
        }
971
 
 
972
 
        target.on('hover', over, out, null, "arg!");
973
 
 
974
 
        mouse('#em1'); mouse("#em1", true);
975
 
 
976
 
        Y.Assert.areSame(1, overCount);
977
 
        Y.Assert.areSame(2, overArgCount);
978
 
        Y.Assert.areSame('hover', overType);
979
 
        Y.Assert.areSame('over', overPhase);
980
 
        Y.Assert.areSame('mouseover', overEType);
981
 
        Y.Assert.areSame(target, overThisObj);
982
 
        Y.Assert.areSame(target, overTarget);
983
 
        Y.Assert.areSame(target, overCurrentTarget);
984
 
        Y.Assert.areSame('arg!', overArg);
985
 
 
986
 
        Y.Assert.areSame(1, outCount);
987
 
        Y.Assert.areSame(2, outArgCount);
988
 
        Y.Assert.areSame('hover', outType);
989
 
        Y.Assert.areSame('out', outPhase);
990
 
        Y.Assert.areSame('mouseout', outEType);
991
 
        Y.Assert.areSame(target, outThisObj);
992
 
        Y.Assert.areSame(target, outTarget);
993
 
        Y.Assert.areSame(target, outCurrentTarget);
994
 
        Y.Assert.areSame('arg!', outArg);
995
 
    },
996
 
 
997
 
    "test Y.on('hover', over, out, '#foo', null, arg)": function () {
998
 
        var overCount = 0,
999
 
            outCount = 0,
1000
 
            overArgCount = 0,
1001
 
            outArgCount = 0,
1002
 
            target = Y.one('#item1'),
1003
 
            overType, outType, overPhase, outPhase, overEType, outEType,
1004
 
            overTarget, outTarget, overCurrentTarget, outCurrentTarget,
1005
 
            overRelTarget, outRelTarget,
1006
 
            overThisObj, outThisObj, overArg, outArg;
1007
 
 
1008
 
        function over(e, x) {
1009
 
            overCount++;
1010
 
            overArgCount = arguments.length;
1011
 
            overType = e.type;
1012
 
            overPhase = e.phase;
1013
 
            overEType = e._event.type;
1014
 
            overThisObj = this;
1015
 
            overTarget = e.target;
1016
 
            overCurrentTarget = e.currentTarget;
1017
 
            overArg = x;
1018
 
        }
1019
 
 
1020
 
        function out(e, x) {
1021
 
            outCount++;
1022
 
            outArgCount = arguments.length;
1023
 
            outType = e.type;
1024
 
            outPhase = e.phase;
1025
 
            outEType = e._event.type;
1026
 
            outThisObj = this;
1027
 
            outTarget = e.target;
1028
 
            outCurrentTarget = e.currentTarget;
1029
 
            outArg = x;
1030
 
        }
1031
 
 
1032
 
        Y.on('hover', over, out, '#item1', null, "arg!");
1033
 
 
1034
 
        mouse('#em1'); mouse("#em1", true);
1035
 
 
1036
 
        Y.Assert.areSame(1, overCount);
1037
 
        Y.Assert.areSame(2, overArgCount);
1038
 
        Y.Assert.areSame('hover', overType);
1039
 
        Y.Assert.areSame('over', overPhase);
1040
 
        Y.Assert.areSame('mouseover', overEType);
1041
 
        Y.Assert.areSame(target, overThisObj);
1042
 
        Y.Assert.areSame(target, overTarget);
1043
 
        Y.Assert.areSame(target, overCurrentTarget);
1044
 
        Y.Assert.areSame('arg!', overArg);
1045
 
 
1046
 
        Y.Assert.areSame(1, outCount);
1047
 
        Y.Assert.areSame(2, outArgCount);
1048
 
        Y.Assert.areSame('hover', outType);
1049
 
        Y.Assert.areSame('out', outPhase);
1050
 
        Y.Assert.areSame('mouseout', outEType);
1051
 
        Y.Assert.areSame(target, outThisObj);
1052
 
        Y.Assert.areSame(target, outTarget);
1053
 
        Y.Assert.areSame(target, outCurrentTarget);
1054
 
        Y.Assert.areSame('arg!', outArg);
1055
 
    },
1056
 
 
1057
 
    "test nodelist.on('hover', over, out, null, arg": function () {
1058
 
        var overCount = 0,
1059
 
            outCount = 0,
1060
 
            overArgCount = 0,
1061
 
            outArgCount = 0,
1062
 
            item1 = Y.one('#item1'),
1063
 
            item2 = Y.one('#item2'),
1064
 
            item3 = Y.one('#item3'),
1065
 
            overType = [],
1066
 
            overPhase = [],
1067
 
            overEType = [],
1068
 
            overTarget = [],
1069
 
            overCurrentTarget = [],
1070
 
            overRelTarget = [],
1071
 
            overThisObj = [],
1072
 
            overArg = [],
1073
 
            outType = [],
1074
 
            outPhase = [],
1075
 
            outEType = [],
1076
 
            outTarget = [],
1077
 
            outCurrentTarget = [],
1078
 
            outRelTarget = [],
1079
 
            outThisObj = [],
1080
 
            outArg = [];
1081
 
 
1082
 
        function over(e, x) {
1083
 
            overCount++;
1084
 
            overArgCount = arguments.length;
1085
 
            overType.push(e.type);
1086
 
            overPhase.push(e.phase);
1087
 
            overEType.push(e._event.type);
1088
 
            overThisObj.push(this);
1089
 
            overTarget.push(e.target);
1090
 
            overCurrentTarget.push(e.currentTarget);
1091
 
            overArg.push(x);
1092
 
        }
1093
 
 
1094
 
        function out(e, x) {
1095
 
            outCount++;
1096
 
            outArgCount = arguments.length;
1097
 
            outType.push(e.type);
1098
 
            outPhase.push(e.phase);
1099
 
            outEType.push(e._event.type);
1100
 
            outThisObj.push(this);
1101
 
            outTarget.push(e.target);
1102
 
            outCurrentTarget.push(e.currentTarget);
1103
 
            outArg.push(x);
1104
 
        }
1105
 
 
1106
 
        Y.all('#items li').on('hover', over, out, null, 'arg!');
1107
 
 
1108
 
        mouse('#em1'); mouse("#em1", true);
1109
 
 
1110
 
        Y.Assert.areSame(1, overCount);
1111
 
        Y.Assert.areSame(2, overArgCount);
1112
 
        Y.ArrayAssert.itemsAreSame(['hover'], overType);
1113
 
        Y.ArrayAssert.itemsAreSame(['over'], overPhase);
1114
 
        Y.ArrayAssert.itemsAreSame(['mouseover'], overEType);
1115
 
        Y.ArrayAssert.itemsAreSame([item1], overThisObj);
1116
 
        Y.ArrayAssert.itemsAreSame([item1], overTarget);
1117
 
        Y.ArrayAssert.itemsAreSame([item1], overCurrentTarget);
1118
 
        Y.ArrayAssert.itemsAreSame(['arg!'], overArg);
1119
 
 
1120
 
        Y.Assert.areSame(1, outCount);
1121
 
        Y.Assert.areSame(2, outArgCount);
1122
 
        Y.ArrayAssert.itemsAreSame(['hover'], outType);
1123
 
        Y.ArrayAssert.itemsAreSame(['out'], outPhase);
1124
 
        Y.ArrayAssert.itemsAreSame(['mouseout'], outEType);
1125
 
        Y.ArrayAssert.itemsAreSame([item1], outThisObj);
1126
 
        Y.ArrayAssert.itemsAreSame([item1], outTarget);
1127
 
        Y.ArrayAssert.itemsAreSame([item1], outCurrentTarget);
1128
 
        Y.ArrayAssert.itemsAreSame(['arg!'], outArg);
1129
 
 
1130
 
        mouse("#em2"); mouse("#em2", true);
1131
 
        mouse("#em3"); mouse("#em3", true);
1132
 
 
1133
 
        Y.Assert.areSame(3, overCount);
1134
 
        Y.Assert.areSame(2, overArgCount);
1135
 
        Y.ArrayAssert.itemsAreSame(['hover','hover','hover'], overType);
1136
 
        Y.ArrayAssert.itemsAreSame(['over','over','over'], overPhase);
1137
 
        Y.ArrayAssert.itemsAreSame(['mouseover','mouseover','mouseover'], overEType);
1138
 
        Y.ArrayAssert.itemsAreSame([item1, item2, item3], overThisObj);
1139
 
        Y.ArrayAssert.itemsAreSame([item1, item2, item3], overTarget);
1140
 
        Y.ArrayAssert.itemsAreSame([item1, item2, item3], overCurrentTarget);
1141
 
        Y.ArrayAssert.itemsAreSame(['arg!', 'arg!', 'arg!'], overArg);
1142
 
 
1143
 
        Y.Assert.areSame(3, outCount);
1144
 
        Y.Assert.areSame(2, outArgCount);
1145
 
        Y.ArrayAssert.itemsAreSame(['hover','hover','hover'], outType);
1146
 
        Y.ArrayAssert.itemsAreSame(['out','out','out'], outPhase);
1147
 
        Y.ArrayAssert.itemsAreSame(['mouseout','mouseout','mouseout'], outEType);
1148
 
        Y.ArrayAssert.itemsAreSame([item1, item2, item3], outThisObj);
1149
 
        Y.ArrayAssert.itemsAreSame([item1, item2, item3], outTarget);
1150
 
        Y.ArrayAssert.itemsAreSame([item1, item2, item3], outCurrentTarget);
1151
 
        Y.ArrayAssert.itemsAreSame(['arg!', 'arg!', 'arg!'], outArg);
1152
 
    }
1153
 
 
1154
 
    // node.delegate + thisObj + args
1155
 
    // Y.delegate + thisObj + args
1156
 
}));
1157
 
 
1158
 
suite.add(new Y.Test.Case({
1159
 
    name: 'detach',
1160
 
 
1161
 
    setUp: setUp,
1162
 
    tearDown: tearDown,
1163
 
 
1164
 
    "test node.on('hover', over, out); node.detach('hover');": function () {
1165
 
        var overCount = 0,
1166
 
            outCount = 0,
1167
 
            target = Y.one('#item1');
1168
 
 
1169
 
        function over() { overCount++; }
1170
 
        function out() { outCount++; }
1171
 
 
1172
 
        target.on('hover', over, out);
1173
 
 
1174
 
        mouse('#item1'); mouse('#item1', true);
1175
 
 
1176
 
        Y.Assert.areSame(1, overCount);
1177
 
        Y.Assert.areSame(1, outCount);
1178
 
 
1179
 
        target.detach('hover');
1180
 
 
1181
 
        mouse('#item1'); mouse('#item1', true);
1182
 
 
1183
 
        Y.Assert.areSame(1, overCount);
1184
 
        Y.Assert.areSame(1, outCount);
1185
 
    },
1186
 
 
1187
 
    "test node.on('hover', over, out); node.detach('hover', over);": function () {
1188
 
        var overCount = 0,
1189
 
            outCount = 0,
1190
 
            target = Y.one('#item1');
1191
 
 
1192
 
        function over() { overCount++; }
1193
 
        function out() { outCount++; }
1194
 
 
1195
 
        target.on('hover', over, out);
1196
 
 
1197
 
        mouse('#item1'); mouse('#item1', true);
1198
 
 
1199
 
        Y.Assert.areSame(1, overCount);
1200
 
        Y.Assert.areSame(1, outCount);
1201
 
 
1202
 
        target.detach('hover', over);
1203
 
 
1204
 
        mouse('#item1'); mouse('#item1', true);
1205
 
 
1206
 
        Y.Assert.areSame(1, overCount);
1207
 
        Y.Assert.areSame(1, outCount);
1208
 
    },
1209
 
 
1210
 
    "test node.on('cat|hover', over, out); node.detach('cat|hover');": function () {
1211
 
        var overCount = 0,
1212
 
            outCount = 0,
1213
 
            target = Y.one('#item1');
1214
 
 
1215
 
        function over() { overCount++; }
1216
 
        function out() { outCount++; }
1217
 
 
1218
 
        target.on('cat|hover', over, out);
1219
 
 
1220
 
        mouse('#item1'); mouse('#item1', true);
1221
 
 
1222
 
        Y.Assert.areSame(1, overCount);
1223
 
        Y.Assert.areSame(1, outCount);
1224
 
 
1225
 
        target.detach('cat|hover');
1226
 
 
1227
 
        mouse('#item1'); mouse('#item1', true);
1228
 
 
1229
 
        Y.Assert.areSame(1, overCount);
1230
 
        Y.Assert.areSame(1, outCount);
1231
 
    },
1232
 
 
1233
 
    "test node.on('cat|hover', over, out); node.detach('cat|*');": function () {
1234
 
        var overCount = 0,
1235
 
            outCount = 0,
1236
 
            target = Y.one('#item1');
1237
 
 
1238
 
        function over() { overCount++; }
1239
 
        function out() { outCount++; }
1240
 
 
1241
 
        target.on('cat|hover', over, out);
1242
 
 
1243
 
        mouse('#item1'); mouse('#item1', true);
1244
 
 
1245
 
        Y.Assert.areSame(1, overCount);
1246
 
        Y.Assert.areSame(1, outCount);
1247
 
 
1248
 
        target.detach('cat|*');
1249
 
 
1250
 
        mouse('#item1'); mouse('#item1', true);
1251
 
 
1252
 
        Y.Assert.areSame(1, overCount);
1253
 
        Y.Assert.areSame(1, outCount);
1254
 
    },
1255
 
 
1256
 
    "test node.on('hover', over, out); handle.detach();": function () {
1257
 
        var overCount = 0,
1258
 
            outCount = 0,
1259
 
            over = function () { overCount++; },
1260
 
            out = function () { outCount++; },
1261
 
            handle = Y.one('#item1').on('cat|hover', over, out);
1262
 
 
1263
 
        mouse('#item1'); mouse('#item1', true);
1264
 
 
1265
 
        Y.Assert.areSame(1, overCount);
1266
 
        Y.Assert.areSame(1, outCount);
1267
 
 
1268
 
        handle.detach();
1269
 
 
1270
 
        mouse('#item1'); mouse('#item1', true);
1271
 
 
1272
 
        Y.Assert.areSame(1, overCount);
1273
 
        Y.Assert.areSame(1, outCount);
1274
 
    },
1275
 
 
1276
 
    "test node.delegate('hover', over, out, filter); node.detach('hover');": function () {
1277
 
        var overCount = 0,
1278
 
            outCount = 0,
1279
 
            target = Y.one('#items');
1280
 
 
1281
 
        function over() { overCount++; }
1282
 
        function out() { outCount++; }
1283
 
 
1284
 
        target.delegate('hover', over, out, 'li');
1285
 
 
1286
 
        mouse('#item1'); mouse('#item1', true);
1287
 
        mouse('#item2'); mouse('#item2', true);
1288
 
        mouse('#item3'); mouse('#item3', true);
1289
 
 
1290
 
        Y.Assert.areSame(3, overCount);
1291
 
        Y.Assert.areSame(3, outCount);
1292
 
 
1293
 
        target.detach('hover');
1294
 
 
1295
 
        mouse('#item1'); mouse('#item1', true);
1296
 
        mouse('#item2'); mouse('#item2', true);
1297
 
        mouse('#item3'); mouse('#item3', true);
1298
 
 
1299
 
        Y.Assert.areSame(3, overCount);
1300
 
        Y.Assert.areSame(3, outCount);
1301
 
    },
1302
 
 
1303
 
    "test node.delegate('hover', over, out, filter); node.detach('hover', over);": function () {
1304
 
        var overCount = 0,
1305
 
            outCount = 0,
1306
 
            target = Y.one('#items');
1307
 
 
1308
 
        function over() { overCount++; }
1309
 
        function out() { outCount++; }
1310
 
 
1311
 
        target.delegate('hover', over, out, 'li');
1312
 
 
1313
 
        mouse('#item1'); mouse('#item1', true);
1314
 
        mouse('#item2'); mouse('#item2', true);
1315
 
        mouse('#item3'); mouse('#item3', true);
1316
 
 
1317
 
        Y.Assert.areSame(3, overCount);
1318
 
        Y.Assert.areSame(3, outCount);
1319
 
 
1320
 
        target.detach('hover', over);
1321
 
 
1322
 
        mouse('#item1'); mouse('#item1', true);
1323
 
        mouse('#item2'); mouse('#item2', true);
1324
 
        mouse('#item3'); mouse('#item3', true);
1325
 
 
1326
 
        Y.Assert.areSame(3, overCount);
1327
 
        Y.Assert.areSame(3, outCount);
1328
 
    },
1329
 
 
1330
 
    "test node.delegate('cat|hover', over, out, filter); node.detach('cat|hover');": function () {
1331
 
        var overCount = 0,
1332
 
            outCount = 0,
1333
 
            target = Y.one('#items');
1334
 
 
1335
 
        function over() { overCount++; }
1336
 
        function out() { outCount++; }
1337
 
 
1338
 
        target.delegate('cat|hover', over, out, 'li');
1339
 
 
1340
 
        mouse('#item1'); mouse('#item1', true);
1341
 
        mouse('#item2'); mouse('#item2', true);
1342
 
        mouse('#item3'); mouse('#item3', true);
1343
 
 
1344
 
        Y.Assert.areSame(3, overCount);
1345
 
        Y.Assert.areSame(3, outCount);
1346
 
 
1347
 
        target.detach('cat|hover');
1348
 
 
1349
 
        mouse('#item1'); mouse('#item1', true);
1350
 
        mouse('#item2'); mouse('#item2', true);
1351
 
        mouse('#item3'); mouse('#item3', true);
1352
 
 
1353
 
        Y.Assert.areSame(3, overCount);
1354
 
        Y.Assert.areSame(3, outCount);
1355
 
    },
1356
 
 
1357
 
    "test node.delegate('cat|hover', over, out, filter); node.detach('cat|*');": function () {
1358
 
        var overCount = 0,
1359
 
            outCount = 0,
1360
 
            target = Y.one('#items');
1361
 
 
1362
 
        function over() { overCount++; }
1363
 
        function out() { outCount++; }
1364
 
 
1365
 
        target.delegate('cat|hover', over, out, 'li');
1366
 
 
1367
 
        mouse('#item1'); mouse('#item1', true);
1368
 
        mouse('#item2'); mouse('#item2', true);
1369
 
        mouse('#item3'); mouse('#item3', true);
1370
 
 
1371
 
        Y.Assert.areSame(3, overCount);
1372
 
        Y.Assert.areSame(3, outCount);
1373
 
 
1374
 
        target.detach('cat|*');
1375
 
 
1376
 
        mouse('#item1'); mouse('#item1', true);
1377
 
        mouse('#item2'); mouse('#item2', true);
1378
 
        mouse('#item3'); mouse('#item3', true);
1379
 
 
1380
 
        Y.Assert.areSame(3, overCount);
1381
 
        Y.Assert.areSame(3, outCount);
1382
 
    },
1383
 
 
1384
 
    "test node.delegate('hover', over, out, filter); handle.detach();": function () {
1385
 
        var overCount = 0,
1386
 
            outCount = 0,
1387
 
            over = function () { overCount++; },
1388
 
            out  = function () { outCount++; },
1389
 
            handle = Y.one('#items').delegate('cat|hover', over, out, 'li');
1390
 
 
1391
 
        mouse('#item1'); mouse('#item1', true);
1392
 
        mouse('#item2'); mouse('#item2', true);
1393
 
        mouse('#item3'); mouse('#item3', true);
1394
 
 
1395
 
        Y.Assert.areSame(3, overCount);
1396
 
        Y.Assert.areSame(3, outCount);
1397
 
 
1398
 
        handle.detach();
1399
 
 
1400
 
        mouse('#item1'); mouse('#item1', true);
1401
 
        mouse('#item2'); mouse('#item2', true);
1402
 
        mouse('#item3'); mouse('#item3', true);
1403
 
 
1404
 
        Y.Assert.areSame(3, overCount);
1405
 
        Y.Assert.areSame(3, outCount);
1406
 
    }
1407
 
}));
1408
 
 
1409
 
Y.Test.Runner.add(suite);