QUnit.module( "event", { setup: function() { document.body.focus(); }, teardown: moduleTeardown } ); QUnit.test( "on() with non-null,defined data", function( assert ) { assert.expect( 2 ); var handler = function( event, data ) { assert.equal( data, 0, "non-null, defined data (zero) is correctly passed" ); }; jQuery( "#foo" ).on( "foo.on", handler ); jQuery( "div" ).on( "foo.delegate", "#foo", handler ); jQuery( "#foo" ).trigger( "foo", 0 ); jQuery( "#foo" ).off( "foo.on", handler ); jQuery( "div" ).off( "foo.delegate", "#foo" ); } ); QUnit.test( "Handler changes and .trigger() order", function( assert ) { assert.expect( 1 ); var markup = jQuery( "

b

" ), path = ""; markup .find( "*" ).addBack().on( "click", function() { path += this.nodeName.toLowerCase() + " "; } ) .filter( "b" ).on( "click", function( e ) { // Removing span should not stop propagation to original parents if ( e.target === this ) { jQuery( this ).parent().remove(); } } ); markup.find( "b" ).trigger( "click" ); assert.equal( path, "b p div div ", "Delivered all events" ); markup.remove(); } ); QUnit.test( "on(), with data", function( assert ) { assert.expect( 4 ); var test, handler, handler2; handler = function( event ) { assert.ok( event.data, "on() with data, check passed data exists" ); assert.equal( event.data[ "foo" ], "bar", "on() with data, Check value of passed data" ); }; jQuery( "#firstp" ).on( "click", { "foo": "bar" }, handler ).trigger( "click" ).off( "click", handler ); assert.ok( !jQuery._data( jQuery( "#firstp" )[ 0 ], "events" ), "Event handler unbound when using data." ); test = function() {}; handler2 = function( event ) { assert.equal( event.data, test, "on() with function data, Check value of passed data" ); }; jQuery( "#firstp" ).on( "click", test, handler2 ).trigger( "click" ).off( "click", handler2 ); } ); QUnit.test( "click(), with data", function( assert ) { assert.expect( 3 ); var handler = function( event ) { assert.ok( event.data, "on() with data, check passed data exists" ); assert.equal( event.data[ "foo" ], "bar", "on() with data, Check value of passed data" ); }; jQuery( "#firstp" ).on( "click", { "foo": "bar" }, handler ).trigger( "click" ).off( "click", handler ); assert.ok( !jQuery._data( jQuery( "#firstp" )[ 0 ], "events" ), "Event handler unbound when using data." ); } ); QUnit.test( "on(), with data, trigger with data", function( assert ) { assert.expect( 4 ); var handler = function( event, data ) { assert.ok( event.data, "check passed data exists" ); assert.equal( event.data.foo, "bar", "Check value of passed data" ); assert.ok( data, "Check trigger data" ); assert.equal( data.bar, "foo", "Check value of trigger data" ); }; jQuery( "#firstp" ).on( "click", { foo: "bar" }, handler ).trigger( "click", [ { bar: "foo" } ] ).off( "click", handler ); } ); QUnit.test( "on(), multiple events at once", function( assert ) { assert.expect( 2 ); var handler, clickCounter = 0, mouseoverCounter = 0; handler = function( event ) { if ( event.type === "click" ) { clickCounter += 1; } else if ( event.type === "mouseover" ) { mouseoverCounter += 1; } }; jQuery( "#firstp" ).on( "click mouseover", handler ).trigger( "click" ).trigger( "mouseover" ); assert.equal( clickCounter, 1, "on() with multiple events at once" ); assert.equal( mouseoverCounter, 1, "on() with multiple events at once" ); } ); QUnit.test( "on(), five events at once", function( assert ) { assert.expect( 1 ); var count = 0, handler = function() { count++; }; jQuery( "#firstp" ).on( "click mouseover foo bar baz", handler ) .trigger( "click" ).trigger( "mouseover" ) .trigger( "foo" ).trigger( "bar" ) .trigger( "baz" ); assert.equal( count, 5, "on() five events at once" ); } ); QUnit.test( "on(), multiple events at once and namespaces", function( assert ) { assert.expect( 7 ); var cur, div, obj = {}; div = jQuery( "
" ).on( "focusin.a", function( e ) { assert.equal( e.type, cur, "Verify right single event was fired." ); } ); cur = "focusin"; div.trigger( "focusin.a" ); // manually clean up detached elements div.remove(); div = jQuery( "
" ).on( "click mouseover", obj, function( e ) { assert.equal( e.type, cur, "Verify right multi event was fired." ); assert.equal( e.data, obj, "Make sure the data came in correctly." ); } ); cur = "click"; div.trigger( "click" ); cur = "mouseover"; div.trigger( "mouseover" ); // manually clean up detached elements div.remove(); div = jQuery( "
" ).on( "focusin.a focusout.b", function( e ) { assert.equal( e.type, cur, "Verify right multi event was fired." ); } ); cur = "focusin"; div.trigger( "focusin.a" ); cur = "focusout"; div.trigger( "focusout.b" ); // manually clean up detached elements div.remove(); } ); QUnit.test( "on(), namespace with special add", function( assert ) { assert.expect( 27 ); var i = 0, div = jQuery( "
" ).appendTo( "#qunit-fixture" ).on( "test", function() { assert.ok( true, "Test event fired." ); } ); jQuery.event.special[ "test" ] = { _default: function( e, data ) { assert.equal( e.type, "test", "Make sure we're dealing with a test event." ); assert.ok( data, "And that trigger data was passed." ); assert.strictEqual( e.target, div[ 0 ], "And that the target is correct." ); assert.equal( this, window, "And that the context is correct." ); }, setup: function() {}, teardown: function() { assert.ok( true, "Teardown called." ); }, add: function( handleObj ) { var handler = handleObj.handler; handleObj.handler = function( e ) { e.xyz = ++i; handler.apply( this, arguments ); }; }, remove: function() { assert.ok( true, "Remove called." ); } }; div.on( "test.a", { x: 1 }, function( e ) { assert.ok( !!e.xyz, "Make sure that the data is getting passed through." ); assert.equal( e.data[ "x" ], 1, "Make sure data is attached properly." ); } ); div.on( "test.b", { x: 2 }, function( e ) { assert.ok( !!e.xyz, "Make sure that the data is getting passed through." ); assert.equal( e.data[ "x" ], 2, "Make sure data is attached properly." ); } ); // Should trigger 5 div.trigger( "test", 33.33 ); // Should trigger 2 div.trigger( "test.a", "George Harrison" ); // Should trigger 2 div.trigger( "test.b", { year: 1982 } ); // Should trigger 4 div.off( "test" ); div = jQuery( "
" ).on( "test", function() { assert.ok( true, "Test event fired." ); } ); // Should trigger 2 div.appendTo( "#qunit-fixture" ).remove(); delete jQuery.event.special[ "test" ]; } ); QUnit.test( "on(), no data", function( assert ) { assert.expect( 1 ); var handler = function( event ) { assert.ok( !event.data, "Check that no data is added to the event object" ); }; jQuery( "#firstp" ).on( "click", handler ).trigger( "click" ); } ); QUnit.test( "on/one/off(Object)", function( assert ) { assert.expect( 6 ); var $elem, clickCounter = 0, mouseoverCounter = 0; function handler( event ) { if ( event.type === "click" ) { clickCounter++; } else if ( event.type === "mouseover" ) { mouseoverCounter++; } } function handlerWithData( event ) { if ( event.type === "click" ) { clickCounter += event.data; } else if ( event.type === "mouseover" ) { mouseoverCounter += event.data; } } function trigger() { $elem.trigger( "click" ).trigger( "mouseover" ); } $elem = jQuery( "#firstp" ) // Regular bind .on( { "click":handler, "mouseover":handler } ) // Bind with data .one( { "click":handlerWithData, "mouseover":handlerWithData }, 2 ); trigger(); assert.equal( clickCounter, 3, "on(Object)" ); assert.equal( mouseoverCounter, 3, "on(Object)" ); trigger(); assert.equal( clickCounter, 4, "on(Object)" ); assert.equal( mouseoverCounter, 4, "on(Object)" ); jQuery( "#firstp" ).off( { "click":handler, "mouseover":handler } ); trigger(); assert.equal( clickCounter, 4, "on(Object)" ); assert.equal( mouseoverCounter, 4, "on(Object)" ); } ); QUnit.test( "on/off(Object), on/off(Object, String)", function( assert ) { assert.expect( 6 ); var events, clickCounter = 0, mouseoverCounter = 0, $p = jQuery( "#firstp" ), $a = $p.find( "a" ).eq( 0 ); events = { "click": function( event ) { clickCounter += ( event.data || 1 ); }, "mouseover": function( event ) { mouseoverCounter += ( event.data || 1 ); } }; function trigger() { $a.trigger( "click" ).trigger( "mouseover" ); } jQuery( document ).on( events, "#firstp a" ); $p.on( events, "a", 2 ); trigger(); assert.equal( clickCounter, 3, "on" ); assert.equal( mouseoverCounter, 3, "on" ); $p.off( events, "a" ); trigger(); assert.equal( clickCounter, 4, "off" ); assert.equal( mouseoverCounter, 4, "off" ); jQuery( document ).off( events, "#firstp a" ); trigger(); assert.equal( clickCounter, 4, "off" ); assert.equal( mouseoverCounter, 4, "off" ); } ); QUnit.test( "on immediate propagation", function( assert ) { assert.expect( 2 ); var lastClick, $p = jQuery( "#firstp" ), $a = $p.find( "a" ).eq( 0 ); lastClick = ""; jQuery( document ).on( "click", "#firstp a", function( e ) { lastClick = "click1"; e.stopImmediatePropagation(); } ); jQuery( document ).on( "click", "#firstp a", function() { lastClick = "click2"; } ); $a.trigger( "click" ); assert.equal( lastClick, "click1", "on stopImmediatePropagation" ); jQuery( document ).off( "click", "#firstp a" ); lastClick = ""; $p.on( "click", "a", function( e ) { lastClick = "click1"; e.stopImmediatePropagation(); } ); $p.on( "click", "a", function() { lastClick = "click2"; } ); $a.trigger( "click" ); assert.equal( lastClick, "click1", "on stopImmediatePropagation" ); $p.off( "click", "**" ); } ); QUnit.test( "on bubbling, isDefaultPrevented, stopImmediatePropagation", function( assert ) { assert.expect( 3 ); var $anchor2 = jQuery( "#anchor2" ), $main = jQuery( "#qunit-fixture" ), neverCallMe = function() { assert.ok( false, "immediate propagation should have been stopped" ); }, fakeClick = function( $jq ) { // Use a native click so we don't get jQuery simulated bubbling var e = document.createEvent( "MouseEvents" ); e.initEvent( "click", true, true ); $jq[ 0 ].dispatchEvent( e ); }; $anchor2.on( "click", function( e ) { e.preventDefault(); } ); $main.on( "click", "#foo", function( e ) { assert.equal( e.isDefaultPrevented(), true, "isDefaultPrevented true passed to bubbled event" ); } ); fakeClick( $anchor2 ); $anchor2.off( "click" ); $main.off( "click", "**" ); $anchor2.on( "click", function() { // Let the default action occur } ); $main.on( "click", "#foo", function( e ) { assert.equal( e.isDefaultPrevented(), false, "isDefaultPrevented false passed to bubbled event" ); } ); fakeClick( $anchor2 ); $anchor2.off( "click" ); $main.off( "click", "**" ); // Android 2.3 doesn't support stopImmediatePropagation; jQuery fallbacks to stopPropagation // in such a case. // Support: Android 2.3 if ( /android 2\.3/i.test( navigator.userAgent ) ) { assert.ok( true, "Android 2.3, skipping native stopImmediatePropagation check" ); } else { $anchor2.on( "click", function( e ) { e.stopImmediatePropagation(); assert.ok( true, "anchor was clicked and prop stopped" ); } ); $anchor2[ 0 ].addEventListener( "click", neverCallMe, false ); fakeClick( $anchor2 ); $anchor2[ 0 ].removeEventListener( "click", neverCallMe ); } } ); QUnit.test( "on(), iframes", function( assert ) { assert.expect( 1 ); // events don't work with iframes, see #939 - this test fails in IE because of contentDocument var doc = jQuery( "#loadediframe" ).contents(); jQuery( "div", doc ).on( "click", function() { assert.ok( true, "Binding to element inside iframe" ); } ).trigger( "click" ).off( "click" ); } ); QUnit.test( "on(), trigger change on select", function( assert ) { assert.expect( 5 ); var counter = 0; function selectOnChange( event ) { assert.equal( event.data, counter++, "Event.data is not a global event object" ); } jQuery( "#form select" ).each( function( i ) { jQuery( this ).on( "change", i, selectOnChange ); } ).trigger( "change" ); } ); QUnit.test( "on(), namespaced events, cloned events", function( assert ) { assert.expect( 18 ); var firstp = jQuery( "#firstp" ); firstp.on( "custom.test", function() { assert.ok( false, "Custom event triggered" ); } ); firstp.on( "click", function( e ) { assert.ok( true, "Normal click triggered" ); assert.equal( e.type + e.namespace, "click", "Check that only click events trigger this fn" ); } ); firstp.on( "click.test", function( e ) { var check = "click"; assert.ok( true, "Namespaced click triggered" ); if ( e.namespace ) { check += "test"; } assert.equal( e.type + e.namespace, check, "Check that only click/click.test events trigger this fn" ); } ); //clone(true) element to verify events are cloned correctly firstp = firstp.add( firstp.clone( true ).attr( "id", "firstp2" ).insertBefore( firstp ) ); // Trigger both bound fn (8) firstp.trigger( "click" ); // Trigger one bound fn (4) firstp.trigger( "click.test" ); // Remove only the one fn firstp.off( "click.test" ); // Trigger the remaining fn (4) firstp.trigger( "click" ); // Remove the remaining namespaced fn firstp.off( ".test" ); // Try triggering the custom event (0) firstp.trigger( "custom" ); // using contents will get comments regular, text, and comment nodes jQuery( "#nonnodes" ).contents().on( "tester", function() { assert.equal( this.nodeType, 1, "Check node,textnode,comment on just does real nodes" ); } ).trigger( "tester" ); // Make sure events stick with appendTo'd elements (which are cloned) #2027 jQuery( "test" ).on( "click", function() { return false; } ).appendTo( "#qunit-fixture" ); assert.ok( jQuery( "a.test" ).eq( 0 ).triggerHandler( "click" ) === false, "Handler is bound to appendTo'd elements" ); } ); QUnit.test( "on(), multi-namespaced events", function( assert ) { assert.expect( 6 ); var order = [ "click.test.abc", "click.test.abc", "click.test", "click.test.abc", "click.test", "custom.test2" ]; function check( name, msg ) { assert.deepEqual( name, order.shift(), msg ); } jQuery( "#firstp" ).on( "custom.test", function() { check( "custom.test", "Custom event triggered" ); } ); jQuery( "#firstp" ).on( "custom.test2", function() { check( "custom.test2", "Custom event triggered" ); } ); jQuery( "#firstp" ).on( "click.test", function() { check( "click.test", "Normal click triggered" ); } ); jQuery( "#firstp" ).on( "click.test.abc", function() { check( "click.test.abc", "Namespaced click triggered" ); } ); // Those would not trigger/off (#5303) jQuery( "#firstp" ).trigger( "click.a.test" ); jQuery( "#firstp" ).off( "click.a.test" ); // Trigger both bound fn (1) jQuery( "#firstp" ).trigger( "click.test.abc" ); // Trigger one bound fn (1) jQuery( "#firstp" ).trigger( "click.abc" ); // Trigger two bound fn (2) jQuery( "#firstp" ).trigger( "click.test" ); // Remove only the one fn jQuery( "#firstp" ).off( "click.abc" ); // Trigger the remaining fn (1) jQuery( "#firstp" ).trigger( "click" ); // Remove the remaining fn jQuery( "#firstp" ).off( ".test" ); // Trigger the remaining fn (1) jQuery( "#firstp" ).trigger( "custom" ); } ); QUnit.test( "namespace-only event binding is a no-op", function( assert ) { assert.expect( 2 ); jQuery( "#firstp" ) .on( ".whoops", function() { assert.ok( false, "called a namespace-only event" ); } ) .on( "whoops", function() { assert.ok( true, "called whoops" ); } ) .trigger( "whoops" ) // 1 .off( ".whoops" ) .trigger( "whoops" ) // 2 .off( "whoops" ); } ); QUnit.test( "Empty namespace is ignored", function( assert ) { assert.expect( 1 ); jQuery( "#firstp" ) .on( "meow.", function( e ) { assert.equal( e.namespace, "", "triggered a namespace-less meow event" ); } ) .trigger( "meow." ) .off( "meow." ); } ); QUnit.test( "on(), with same function", function( assert ) { assert.expect( 2 ); var count = 0, func = function() { count++; }; jQuery( "#liveHandlerOrder" ).on( "foo.bar", func ).on( "foo.zar", func ); jQuery( "#liveHandlerOrder" ).trigger( "foo.bar" ); assert.equal( count, 1, "Verify binding function with multiple namespaces." ); jQuery( "#liveHandlerOrder" ).off( "foo.bar", func ).off( "foo.zar", func ); jQuery( "#liveHandlerOrder" ).trigger( "foo.bar" ); assert.equal( count, 1, "Verify that removing events still work." ); } ); QUnit.test( "on(), make sure order is maintained", function( assert ) { assert.expect( 1 ); var elem = jQuery( "#firstp" ), log = [], check = []; jQuery.each( new Array( 100 ), function( i ) { elem.on( "click", function() { log.push( i ); } ); check.push( i ); } ); elem.trigger( "click" ); assert.equal( log.join( "," ), check.join( "," ), "Make sure order was maintained." ); elem.off( "click" ); } ); QUnit.test( "on(), with different this object", function( assert ) { assert.expect( 4 ); var thisObject = { myThis: true }, data = { myData: true }, handler1 = function() { assert.equal( this, thisObject, "on() with different this object" ); }, handler2 = function( event ) { assert.equal( this, thisObject, "on() with different this object and data" ); assert.equal( event.data, data, "on() with different this object and data" ); }; jQuery( "#firstp" ) .on( "click", jQuery.proxy( handler1, thisObject ) ).trigger( "click" ).off( "click", handler1 ) .on( "click", data, jQuery.proxy( handler2, thisObject ) ).trigger( "click" ).off( "click", handler2 ); assert.ok( !jQuery._data( jQuery( "#firstp" )[ 0 ], "events" ), "Event handler unbound when using different this object and data." ); } ); QUnit.test( "on(name, false), off(name, false)", function( assert ) { assert.expect( 3 ); var main = 0; jQuery( "#qunit-fixture" ).on( "click", function() { main++; } ); jQuery( "#ap" ).trigger( "click" ); assert.equal( main, 1, "Verify that the trigger happened correctly." ); main = 0; jQuery( "#ap" ).on( "click", false ); jQuery( "#ap" ).trigger( "click" ); assert.equal( main, 0, "Verify that no bubble happened." ); main = 0; jQuery( "#ap" ).off( "click", false ); jQuery( "#ap" ).trigger( "click" ); assert.equal( main, 1, "Verify that the trigger happened correctly." ); // manually clean up events from elements outside the fixture jQuery( "#qunit-fixture" ).off( "click" ); } ); QUnit.test( "on(name, selector, false), off(name, selector, false)", function( assert ) { assert.expect( 3 ); var main = 0; jQuery( "#qunit-fixture" ).on( "click", "#ap", function() { main++; } ); jQuery( "#ap" ).trigger( "click" ); assert.equal( main, 1, "Verify that the trigger happened correctly." ); main = 0; jQuery( "#ap" ).on( "click", "#groups", false ); jQuery( "#groups" ).trigger( "click" ); assert.equal( main, 0, "Verify that no bubble happened." ); main = 0; jQuery( "#ap" ).off( "click", "#groups", false ); jQuery( "#groups" ).trigger( "click" ); assert.equal( main, 1, "Verify that the trigger happened correctly." ); jQuery( "#qunit-fixture" ).off( "click", "#ap" ); } ); QUnit.test( "on()/trigger()/off() on plain object", function( assert ) { assert.expect( 7 ); var events, obj = {}; // Make sure it doesn't complain when no events are found jQuery( obj ).trigger( "test" ); // Make sure it doesn't complain when no events are found jQuery( obj ).off( "test" ); jQuery( obj ).on( { "test": function() { assert.ok( true, "Custom event run." ); }, "submit": function() { assert.ok( true, "Custom submit event run." ); } } ); events = jQuery._data( obj, "events" ); assert.ok( events, "Object has events bound." ); assert.equal( obj[ "events" ], undefined, "Events object on plain objects is not events" ); assert.equal( obj[ "test" ], undefined, "Make sure that test event is not on the plain object." ); assert.equal( obj[ "handle" ], undefined, "Make sure that the event handler is not on the plain object." ); // Should trigger 1 jQuery( obj ).trigger( "test" ); jQuery( obj ).trigger( "submit" ); jQuery( obj ).off( "test" ); jQuery( obj ).off( "submit" ); // Should trigger 0 jQuery( obj ).trigger( "test" ); // Make sure it doesn't complain when no events are found jQuery( obj ).off( "test" ); assert.equal( obj && obj[ jQuery.expando ] && obj[ jQuery.expando ][ jQuery.expando ] && obj[ jQuery.expando ][ jQuery.expando ][ "events" ], undefined, "Make sure events object is removed" ); } ); QUnit.test( "off(type)", function( assert ) { assert.expect( 1 ); var message, func, $elem = jQuery( "#firstp" ); function error() { assert.ok( false, message ); } message = "unbind passing function"; $elem.on( "error1", error ).off( "error1", error ).triggerHandler( "error1" ); message = "unbind all from event"; $elem.on( "error1", error ).off( "error1" ).triggerHandler( "error1" ); message = "unbind all"; $elem.on( "error1", error ).off().triggerHandler( "error1" ); message = "unbind many with function"; $elem.on( "error1 error2", error ) .off( "error1 error2", error ) .trigger( "error1" ).triggerHandler( "error2" ); message = "unbind many"; // #3538 $elem.on( "error1 error2", error ) .off( "error1 error2" ) .trigger( "error1" ).triggerHandler( "error2" ); message = "unbind without a type or handler"; $elem.on( "error1 error2.test", error ) .off() .trigger( "error1" ).triggerHandler( "error2" ); // Should only unbind the specified function jQuery( document ).on( "click", function() { assert.ok( true, "called handler after selective removal" ); } ); func = function() {}; jQuery( document ) .on( "click", func ) .off( "click", func ) .trigger( "click" ) .off( "click" ); } ); QUnit.test( "off(eventObject)", function( assert ) { assert.expect( 4 ); var $elem = jQuery( "#firstp" ), num; function check( expected ) { num = 0; $elem.trigger( "foo" ).triggerHandler( "bar" ); assert.equal( num, expected, "Check the right handlers are triggered" ); } $elem // This handler shouldn't be unbound .on( "foo", function() { num += 1; } ) .on( "foo", function( e ) { $elem.off( e ); num += 2; } ) // Neither this one .on( "bar", function() { num += 4; } ); check( 7 ); check( 5 ); $elem.off( "bar" ); check( 1 ); $elem.off(); check( 0 ); } ); if ( jQuery.fn.hover ) { QUnit.test( "hover() mouseenter mouseleave", function( assert ) { assert.expect( 1 ); var times = 0, handler1 = function() { ++times; }, handler2 = function() { ++times; }; jQuery( "#firstp" ) .hover( handler1, handler2 ) .mouseenter().mouseleave() .off( "mouseenter", handler1 ) .off( "mouseleave", handler2 ) .hover( handler1 ) .mouseenter().mouseleave() .off( "mouseenter mouseleave", handler1 ) .mouseenter().mouseleave(); assert.equal( times, 4, "hover handlers fired" ); } ); } QUnit.test( "mouseover triggers mouseenter", function( assert ) { assert.expect( 1 ); var count = 0, elem = jQuery( "" ); elem.on( "mouseenter", function() { count++; } ); elem.trigger( "mouseover" ); assert.equal( count, 1, "make sure mouseover triggers a mouseenter" ); elem.remove(); } ); QUnit.test( "pointerover triggers pointerenter", function( assert ) { assert.expect( 1 ); var count = 0, elem = jQuery( "" ); elem.on( "pointerenter", function() { count++; } ); elem.trigger( "pointerover" ); assert.equal( count, 1, "make sure pointerover triggers a pointerenter" ); elem.remove(); } ); QUnit.test( "withinElement implemented with jQuery.contains()", function( assert ) { assert.expect( 1 ); jQuery( "#qunit-fixture" ).append( "
" ); jQuery( "#jc-outer" ).on( "mouseenter mouseleave", function( event ) { assert.equal( this.id, "jc-outer", this.id + " " + event.type ); } ).trigger( "mouseenter" ); jQuery( "#jc-inner" ).trigger( "mousenter" ); jQuery( "#jc-outer" ).off( "mouseenter mouseleave" ).remove(); jQuery( "#jc-inner" ).remove(); } ); QUnit.test( "mouseenter, mouseleave don't catch exceptions", function( assert ) { assert.expect( 2 ); var elem = jQuery( "#firstp" ).on( "mouseenter mouseleave", function() { throw "an Exception"; } ); try { elem.trigger( "mouseenter" ); } catch ( e ) { assert.equal( e, "an Exception", "mouseenter doesn't catch exceptions" ); } try { elem.trigger( "mouseleave" ); } catch ( e ) { assert.equal( e, "an Exception", "mouseleave doesn't catch exceptions" ); } } ); if ( jQuery.fn.click ) { QUnit.test( "trigger() shortcuts", function( assert ) { assert.expect( 5 ); var counter, clickCounter, elem = jQuery( "
  • Change location
  • " ).prependTo( "#firstUL" ); elem.find( "a" ).on( "click", function() { var close = jQuery( "spanx", this ); // same with jQuery(this).find("span"); assert.equal( close.length, 0, "Context element does not exist, length must be zero" ); assert.ok( !close[ 0 ], "Context element does not exist, direct access to element must return undefined" ); return false; } ).click(); // manually clean up detached elements elem.remove(); jQuery( "#check1" ).click( function() { assert.ok( true, "click event handler for checkbox gets fired twice, see #815" ); } ).click(); counter = 0; jQuery( "#firstp" )[ 0 ].onclick = function() { counter++; }; jQuery( "#firstp" ).click(); assert.equal( counter, 1, "Check that click, triggers onclick event handler also" ); clickCounter = 0; jQuery( "#simon1" )[ 0 ].onclick = function() { clickCounter++; }; jQuery( "#simon1" ).click(); assert.equal( clickCounter, 1, "Check that click, triggers onclick event handler on an a tag also" ); // test that special handlers do not blow up with VML elements (#7071) jQuery( "" ).appendTo( "head" ); jQuery( " " ).appendTo( "#form" ); jQuery( "#oval" ).click().keydown(); } ); } QUnit.test( "trigger() bubbling", function( assert ) { assert.expect( 18 ); var win = 0, doc = 0, html = 0, body = 0, main = 0, ap = 0; jQuery( window ).on( "click", function() { win++; } ); jQuery( document ).on( "click", function( e ) { if ( e.target !== document ) { doc++; } } ); jQuery( "html" ).on( "click", function() { html++; } ); jQuery( "body" ).on( "click", function() { body++; } ); jQuery( "#qunit-fixture" ).on( "click", function() { main++; } ); jQuery( "#ap" ).on( "click", function() { ap++; return false; } ); jQuery( "html" ).trigger( "click" ); assert.equal( win, 1, "HTML bubble" ); assert.equal( doc, 1, "HTML bubble" ); assert.equal( html, 1, "HTML bubble" ); jQuery( "body" ).trigger( "click" ); assert.equal( win, 2, "Body bubble" ); assert.equal( doc, 2, "Body bubble" ); assert.equal( html, 2, "Body bubble" ); assert.equal( body, 1, "Body bubble" ); jQuery( "#qunit-fixture" ).trigger( "click" ); assert.equal( win, 3, "Main bubble" ); assert.equal( doc, 3, "Main bubble" ); assert.equal( html, 3, "Main bubble" ); assert.equal( body, 2, "Main bubble" ); assert.equal( main, 1, "Main bubble" ); jQuery( "#ap" ).trigger( "click" ); assert.equal( doc, 3, "ap bubble" ); assert.equal( html, 3, "ap bubble" ); assert.equal( body, 2, "ap bubble" ); assert.equal( main, 1, "ap bubble" ); assert.equal( ap, 1, "ap bubble" ); jQuery( document ).trigger( "click" ); assert.equal( win, 4, "doc bubble" ); // manually clean up events from elements outside the fixture jQuery( window ).off( "click" ); jQuery( document ).off( "click" ); jQuery( "html, body, #qunit-fixture" ).off( "click" ); } ); QUnit.test( "trigger(type, [data], [fn])", function( assert ) { assert.expect( 16 ); var $elem, pass, form, elem2, handler = function( event, a, b, c ) { assert.equal( event.type, "click", "check passed data" ); assert.equal( a, 1, "check passed data" ); assert.equal( b, "2", "check passed data" ); assert.equal( c, "abc", "check passed data" ); return "test"; }; $elem = jQuery( "#firstp" ); // Simulate a "native" click $elem[ 0 ].click = function() { assert.ok( true, "Native call was triggered" ); }; jQuery( document ).on( "mouseenter", "#firstp", function() { assert.ok( true, "Trigger mouseenter bound by on" ); } ); jQuery( document ).on( "mouseleave", "#firstp", function() { assert.ok( true, "Trigger mouseleave bound by on" ); } ); $elem.trigger( "mouseenter" ); $elem.trigger( "mouseleave" ); jQuery( document ).off( "mouseenter mouseleave", "#firstp" ); // Triggers handlers and native // Trigger 5 $elem.on( "click", handler ).trigger( "click", [ 1, "2", "abc" ] ); // Simulate a "native" click $elem[ 0 ].click = function() { assert.ok( false, "Native call was triggered" ); }; // Trigger only the handlers (no native) // Triggers 5 assert.equal( $elem.triggerHandler( "click", [ 1, "2", "abc" ] ), "test", "Verify handler response" ); pass = true; try { elem2 = jQuery( "#form input" ).eq( 0 ); elem2.get( 0 ).style.display = "none"; elem2.trigger( "focus" ); } catch ( e ) { pass = false; } assert.ok( pass, "Trigger focus on hidden element" ); pass = true; try { jQuery( "#qunit-fixture table" ).eq( 0 ).on( "test:test", function() {} ).trigger( "test:test" ); } catch ( e ) { pass = false; } assert.ok( pass, "Trigger on a table with a colon in the even type, see #3533" ); form = jQuery( "
    " ).appendTo( "body" ); // Make sure it can be prevented locally form.on( "submit", function() { assert.ok( true, "Local `on` still works." ); return false; } ); // Trigger 1 form.trigger( "submit" ); form.off( "submit" ); jQuery( document ).on( "submit", function() { assert.ok( true, "Make sure bubble works up to document." ); return false; } ); // Trigger 1 form.trigger( "submit" ); jQuery( document ).off( "submit" ); form.remove(); } ); QUnit.test( "submit event bubbles on copied forms (#11649)", function( assert ) { assert.expect( 3 ); var $formByClone, $formByHTML, $testForm = jQuery( "#testForm" ), $fixture = jQuery( "#qunit-fixture" ), $wrapperDiv = jQuery( "
    " ).appendTo( $fixture ); function noSubmit( e ) { e.preventDefault(); } function delegatedSubmit() { assert.ok( true, "Make sure submit event bubbles up." ); return false; } // Attach a delegated submit handler to the parent element $fixture.on( "submit", "form", delegatedSubmit ); // Trigger form submission to introduce the _submit_attached property $testForm.on( "submit", noSubmit ).find( "input[name=sub1]" ).trigger( "click" ); // Copy the form via .clone() and .html() $formByClone = $testForm.clone( true, true ).removeAttr( "id" ); $formByHTML = jQuery( jQuery.parseHTML( $fixture.html() ) ).filter( "#testForm" ).removeAttr( "id" ); $wrapperDiv.append( $formByClone, $formByHTML ); // Check submit bubbling on the copied forms $wrapperDiv.find( "form" ).on( "submit", noSubmit ).find( "input[name=sub1]" ).trigger( "click" ); // Clean up $wrapperDiv.remove(); $fixture.off( "submit", "form", delegatedSubmit ); $testForm.off( "submit", noSubmit ); } ); QUnit.test( "change event bubbles on copied forms (#11796)", function( assert ) { assert.expect( 3 ); var $formByClone, $formByHTML, $form = jQuery( "#form" ), $fixture = jQuery( "#qunit-fixture" ), $wrapperDiv = jQuery( "
    " ).appendTo( $fixture ); function delegatedChange() { assert.ok( true, "Make sure change event bubbles up." ); return false; } // Attach a delegated change handler to the form $fixture.on( "change", "form", delegatedChange ); // Trigger change event to introduce the _change_attached property $form.find( "select[name=select1]" ).val( "1" ).trigger( "change" ); // Copy the form via .clone() and .html() $formByClone = $form.clone( true, true ).removeAttr( "id" ); $formByHTML = jQuery( jQuery.parseHTML( $fixture.html() ) ).filter( "#form" ).removeAttr( "id" ); $wrapperDiv.append( $formByClone, $formByHTML ); // Check change bubbling on the copied forms $wrapperDiv.find( "form select[name=select1]" ).val( "2" ).trigger( "change" ); // Clean up $wrapperDiv.remove(); $fixture.off( "change", "form", delegatedChange ); } ); QUnit.test( "trigger(eventObject, [data], [fn])", function( assert ) { assert.expect( 28 ); var event, $parent = jQuery( "
    " ).appendTo( "body" ), $child = jQuery( "

    foo

    " ).appendTo( $parent ); $parent.get( 0 ).style.display = "none"; event = jQuery.Event( "noNew" ); assert.ok( event !== window, "Instantiate jQuery.Event without the 'new' keyword" ); assert.equal( event.type, "noNew", "Verify its type" ); assert.equal( event.isDefaultPrevented(), false, "Verify isDefaultPrevented" ); assert.equal( event.isPropagationStopped(), false, "Verify isPropagationStopped" ); assert.equal( event.isImmediatePropagationStopped(), false, "Verify isImmediatePropagationStopped" ); event.preventDefault(); assert.equal( event.isDefaultPrevented(), true, "Verify isDefaultPrevented" ); event.stopPropagation(); assert.equal( event.isPropagationStopped(), true, "Verify isPropagationStopped" ); event.isPropagationStopped = function() { return false; }; event.stopImmediatePropagation(); assert.equal( event.isPropagationStopped(), true, "Verify isPropagationStopped" ); assert.equal( event.isImmediatePropagationStopped(), true, "Verify isPropagationStopped" ); $parent.on( "foo", function( e ) { // Tries bubbling assert.equal( e.type, "foo", "Verify event type when passed passing an event object" ); assert.equal( e.target.id, "child", "Verify event.target when passed passing an event object" ); assert.equal( e.currentTarget.id, "par", "Verify event.currentTarget when passed passing an event object" ); assert.equal( e.secret, "boo!", "Verify event object's custom attribute when passed passing an event object" ); } ); // test with an event object event = new jQuery.Event( "foo" ); event.secret = "boo!"; $child.trigger( event ); // test with a literal object $child.trigger( { "type": "foo", "secret": "boo!" } ); $parent.off(); function error() { assert.ok( false, "This assertion shouldn't be reached" ); } $parent.on( "foo", error ); $child.on( "foo", function( e, a, b, c ) { assert.equal( arguments.length, 4, "Check arguments length" ); assert.equal( a, 1, "Check first custom argument" ); assert.equal( b, 2, "Check second custom argument" ); assert.equal( c, 3, "Check third custom argument" ); assert.equal( e.isDefaultPrevented(), false, "Verify isDefaultPrevented" ); assert.equal( e.isPropagationStopped(), false, "Verify isPropagationStopped" ); assert.equal( e.isImmediatePropagationStopped(), false, "Verify isImmediatePropagationStopped" ); // Skips both errors e.stopImmediatePropagation(); return "result"; } ); // We should add this back in when we want to test the order // in which event handlers are iterated. //$child.on("foo", error ); event = new jQuery.Event( "foo" ); $child.trigger( event, [ 1,2,3 ] ).off(); assert.equal( event.result, "result", "Check event.result attribute" ); // Will error if it bubbles $child.triggerHandler( "foo" ); $child.off(); $parent.off().remove(); // Ensure triggerHandler doesn't molest its event object (#xxx) event = jQuery.Event( "zowie" ); jQuery( document ).triggerHandler( event ); assert.equal( event.type, "zowie", "Verify its type" ); assert.equal( event.isPropagationStopped(), false, "propagation not stopped" ); assert.equal( event.isDefaultPrevented(), false, "default not prevented" ); } ); QUnit.test( ".trigger() bubbling on disconnected elements (#10489)", function( assert ) { assert.expect( 2 ); jQuery( window ).on( "click", function() { assert.ok( false, "click fired on window" ); } ); jQuery( "

    hi

    " ) .on( "click", function() { assert.ok( true, "click fired on div" ); } ) .find( "p" ) .on( "click", function() { assert.ok( true, "click fired on p" ); } ) .trigger( "click" ) .off( "click" ) .end() .off( "click" ) .remove(); jQuery( window ).off( "click" ); } ); QUnit.test( ".trigger() doesn't bubble load event (#10717)", function( assert ) { assert.expect( 1 ); jQuery( window ).on( "load", function() { assert.ok( false, "load fired on window" ); } ); // It's not an image, but as long as it fires load... jQuery( "" ) .appendTo( "body" ) .on( "load", function() { assert.ok( true, "load fired on img" ); } ) .trigger( "load" ) .remove(); jQuery( window ).off( "load" ); } ); QUnit.test( "Delegated events in SVG (#10791; #13180)", function( assert ) { assert.expect( 2 ); var useElem, e, svg = jQuery( "" + "" + "" + "" + "" + "" ); jQuery( "#qunit-fixture" ) .append( svg ) .on( "click", "#svg-by-id", function() { assert.ok( true, "delegated id selector" ); } ) .on( "click", "[class~='svg-by-class']", function() { assert.ok( true, "delegated class selector" ); } ) .find( "#svg-by-id, [class~='svg-by-class']" ) .trigger( "click" ) .end(); // Fire a native click on an SVGElementInstance (the instance tree of an SVG ) // to confirm that it doesn't break our event delegation handling (#13180) useElem = svg.find( "#use" )[ 0 ]; if ( document.createEvent && useElem && useElem.instanceRoot ) { e = document.createEvent( "MouseEvents" ); e.initEvent( "click", true, true ); useElem.instanceRoot.dispatchEvent( e ); } jQuery( "#qunit-fixture" ).off( "click" ); } ); QUnit.test( "Delegated events in forms (#10844; #11145; #8165; #11382, #11764)", function( assert ) { assert.expect( 5 ); // Alias names like "id" cause havoc var form = jQuery( "
    " + "" + "
    " ) .on( "submit", function( event ) { event.preventDefault(); } ) .appendTo( "body" ); jQuery( "body" ) .on( "submit", "#myform", function() { assert.ok( true, "delegated id selector with aliased id" ); } ) .find( "#myform" ) .trigger( "submit" ) .end() .off( "submit" ); form.append( "" ); jQuery( "body" ) .on( "submit", "#myform", function() { assert.ok( true, "delegated id selector with aliased disabled" ); } ) .find( "#myform" ) .trigger( "submit" ) .end() .off( "submit" ); form .append( "" ) .on( "click", "#nestyDisabledBtn", function() { assert.ok( true, "click on enabled/disabled button with nesty elements" ); } ) .on( "mouseover", "#nestyDisabledBtn", function() { assert.ok( true, "mouse on enabled/disabled button with nesty elements" ); } ) .find( "span" ) .trigger( "click" ) // yep .trigger( "mouseover" ) // yep .end() .find( "#nestyDisabledBtn" ).prop( "disabled", true ).end() .find( "span" ) .trigger( "click" ) // nope .trigger( "mouseover" ) // yep .end() .off( "click" ); form.remove(); } ); QUnit.test( "Submit event can be stopped (#11049)", function( assert ) { assert.expect( 1 ); // Since we manually bubble in IE, make sure inner handlers get a chance to cancel var form = jQuery( "
    " + "" + "" + "
    " ) .appendTo( "body" ); jQuery( "body" ) .on( "submit", function() { assert.ok( true, "submit bubbled on first handler" ); return false; } ) .find( "#myform input[type=submit]" ) .each( function() { this.click(); } ) .end() .on( "submit", function() { assert.ok( false, "submit bubbled on second handler" ); return false; } ) .find( "#myform input[type=submit]" ) .each( function() { jQuery( this.form ).on( "submit", function( e ) { e.preventDefault(); e.stopPropagation(); } ); this.click(); } ) .end() .off( "submit" ); form.remove(); } ); // Test beforeunload event only if it supported. // Support: iOS 7+, Android<4.0 // iOS & old Android have the window.onbeforeunload field but don't support the beforeunload // handler making it impossible to feature-detect the support. if ( window.onbeforeunload === null && !/(ipad|iphone|ipod|android 2\.3)/i.test( navigator.userAgent ) ) { QUnit.test( "on(beforeunload)", 1, function( assert ) { var iframe = jQuery( jQuery.parseHTML( "