mirror of
https://github.com/jquery/jquery.git
synced 2024-10-05 11:34:18 +00:00
390 lines
11 KiB
JavaScript
390 lines
11 KiB
JavaScript
QUnit.module( "callbacks", {
|
|
teardown: moduleTeardown
|
|
} );
|
|
|
|
( function() {
|
|
|
|
var output,
|
|
addToOutput = function( string ) {
|
|
return function() {
|
|
output += string;
|
|
};
|
|
},
|
|
outputA = addToOutput( "A" ),
|
|
outputB = addToOutput( "B" ),
|
|
outputC = addToOutput( "C" ),
|
|
tests = {
|
|
"": "XABC X XABCABCC X XBB X XABA X XX",
|
|
"once": "XABC X X X X X XABA X XX",
|
|
"memory": "XABC XABC XABCABCCC XA XBB XB XABA XC XX",
|
|
"unique": "XABC X XABCA X XBB X XAB X X",
|
|
"stopOnFalse": "XABC X XABCABCC X XBB X XA X XX",
|
|
"once memory": "XABC XABC X XA X XA XABA XC XX",
|
|
"once unique": "XABC X X X X X XAB X X",
|
|
"once stopOnFalse": "XABC X X X X X XA X XX",
|
|
"memory unique": "XABC XA XABCA XA XBB XB XAB XC X",
|
|
"memory stopOnFalse": "XABC XABC XABCABCCC XA XBB XB XA X XX",
|
|
"unique stopOnFalse": "XABC X XABCA X XBB X XA X X"
|
|
},
|
|
filters = {
|
|
"no filter": undefined,
|
|
"filter": function( fn ) {
|
|
return function() {
|
|
return fn.apply( this, arguments );
|
|
};
|
|
}
|
|
};
|
|
|
|
function showFlags( flags ) {
|
|
if ( typeof flags === "string" ) {
|
|
return "'" + flags + "'";
|
|
}
|
|
var output = [], key;
|
|
for ( key in flags ) {
|
|
output.push( "'" + key + "': " + flags[ key ] );
|
|
}
|
|
return "{ " + output.join( ", " ) + " }";
|
|
}
|
|
|
|
jQuery.each( tests, function( strFlags, resultString ) {
|
|
|
|
var objectFlags = {};
|
|
|
|
jQuery.each( strFlags.split( " " ), function() {
|
|
if ( this.length ) {
|
|
objectFlags[ this ] = true;
|
|
}
|
|
} );
|
|
|
|
jQuery.each( filters, function( filterLabel ) {
|
|
|
|
jQuery.each( {
|
|
"string": strFlags,
|
|
"object": objectFlags
|
|
}, function( flagsTypes, flags ) {
|
|
|
|
QUnit.test( "jQuery.Callbacks( " + showFlags( flags ) + " ) - " + filterLabel, function( assert ) {
|
|
|
|
assert.expect( 29 );
|
|
|
|
var cblist,
|
|
results = resultString.split( /\s+/ );
|
|
|
|
// Basic binding and firing
|
|
output = "X";
|
|
cblist = jQuery.Callbacks( flags );
|
|
assert.strictEqual( cblist.locked(), false, ".locked() initially false" );
|
|
assert.strictEqual( cblist.disabled(), false, ".disabled() initially false" );
|
|
assert.strictEqual( cblist.fired(), false, ".fired() initially false" );
|
|
cblist.add( function( str ) {
|
|
output += str;
|
|
} );
|
|
assert.strictEqual( cblist.fired(), false, ".fired() still false after .add" );
|
|
cblist.fire( "A" );
|
|
assert.strictEqual( output, "XA", "Basic binding and firing" );
|
|
assert.strictEqual( cblist.fired(), true, ".fired() detects firing" );
|
|
output = "X";
|
|
cblist.disable();
|
|
cblist.add( function( str ) {
|
|
output += str;
|
|
} );
|
|
assert.strictEqual( output, "X", "Adding a callback after disabling" );
|
|
cblist.fire( "A" );
|
|
assert.strictEqual( output, "X", "Firing after disabling" );
|
|
assert.strictEqual( cblist.disabled(), true, ".disabled() becomes true" );
|
|
assert.strictEqual( cblist.locked(), true, "disabling locks" );
|
|
|
|
// Emptying while firing (#13517)
|
|
cblist = jQuery.Callbacks( flags );
|
|
cblist.add( cblist.empty );
|
|
cblist.add( function() {
|
|
assert.ok( false, "not emptied" );
|
|
} );
|
|
cblist.fire();
|
|
|
|
// Disabling while firing
|
|
cblist = jQuery.Callbacks( flags );
|
|
cblist.add( cblist.disable );
|
|
cblist.add( function() {
|
|
assert.ok( false, "not disabled" );
|
|
} );
|
|
cblist.fire();
|
|
|
|
// Basic binding and firing (context, arguments)
|
|
output = "X";
|
|
cblist = jQuery.Callbacks( flags );
|
|
cblist.add( function() {
|
|
assert.equal( this, window, "Basic binding and firing (context)" );
|
|
output += Array.prototype.join.call( arguments, "" );
|
|
} );
|
|
cblist.fireWith( window, [ "A", "B" ] );
|
|
assert.strictEqual( output, "XAB", "Basic binding and firing (arguments)" );
|
|
|
|
// fireWith with no arguments
|
|
output = "";
|
|
cblist = jQuery.Callbacks( flags );
|
|
cblist.add( function() {
|
|
assert.equal( this, window, "fireWith with no arguments (context is window)" );
|
|
assert.strictEqual( arguments.length, 0, "fireWith with no arguments (no arguments)" );
|
|
} );
|
|
cblist.fireWith();
|
|
|
|
// Basic binding, removing and firing
|
|
output = "X";
|
|
cblist = jQuery.Callbacks( flags );
|
|
cblist.add( outputA, outputB, outputC );
|
|
cblist.remove( outputB, outputC );
|
|
cblist.fire();
|
|
assert.strictEqual( output, "XA", "Basic binding, removing and firing" );
|
|
|
|
// Empty
|
|
output = "X";
|
|
cblist = jQuery.Callbacks( flags );
|
|
cblist.add( outputA );
|
|
cblist.add( outputB );
|
|
cblist.add( outputC );
|
|
cblist.empty();
|
|
cblist.fire();
|
|
assert.strictEqual( output, "X", "Empty" );
|
|
|
|
// Locking
|
|
output = "X";
|
|
cblist = jQuery.Callbacks( flags );
|
|
cblist.add( function( str ) {
|
|
output += str;
|
|
} );
|
|
cblist.lock();
|
|
cblist.add( function( str ) {
|
|
output += str;
|
|
} );
|
|
cblist.fire( "A" );
|
|
cblist.add( function( str ) {
|
|
output += str;
|
|
} );
|
|
assert.strictEqual( output, "X", "Lock early" );
|
|
assert.strictEqual( cblist.locked(), true, "Locking reflected in accessor" );
|
|
|
|
// Locking while firing (gh-1990)
|
|
output = "X";
|
|
cblist = jQuery.Callbacks( flags );
|
|
cblist.add( cblist.lock );
|
|
cblist.add( function( str ) {
|
|
output += str;
|
|
} );
|
|
cblist.fire( "A" );
|
|
assert.strictEqual( output, "XA", "Locking doesn't abort execution (gh-1990)" );
|
|
|
|
// Ordering
|
|
output = "X";
|
|
cblist = jQuery.Callbacks( flags );
|
|
cblist.add( function() {
|
|
cblist.add( outputC );
|
|
outputA();
|
|
}, outputB );
|
|
cblist.fire();
|
|
assert.strictEqual( output, results.shift(), "Proper ordering" );
|
|
|
|
// Add and fire again
|
|
output = "X";
|
|
cblist.add( function() {
|
|
cblist.add( outputC );
|
|
outputA();
|
|
}, outputB );
|
|
assert.strictEqual( output, results.shift(), "Add after fire" );
|
|
|
|
output = "X";
|
|
cblist.fire();
|
|
assert.strictEqual( output, results.shift(), "Fire again" );
|
|
|
|
// Multiple fire
|
|
output = "X";
|
|
cblist = jQuery.Callbacks( flags );
|
|
cblist.add( function( str ) {
|
|
output += str;
|
|
} );
|
|
cblist.fire( "A" );
|
|
assert.strictEqual( output, "XA", "Multiple fire (first fire)" );
|
|
output = "X";
|
|
cblist.add( function( str ) {
|
|
output += str;
|
|
} );
|
|
assert.strictEqual( output, results.shift(), "Multiple fire (first new callback)" );
|
|
output = "X";
|
|
cblist.fire( "B" );
|
|
assert.strictEqual( output, results.shift(), "Multiple fire (second fire)" );
|
|
output = "X";
|
|
cblist.add( function( str ) {
|
|
output += str;
|
|
} );
|
|
assert.strictEqual( output, results.shift(), "Multiple fire (second new callback)" );
|
|
|
|
// Return false
|
|
output = "X";
|
|
cblist = jQuery.Callbacks( flags );
|
|
cblist.add( outputA, function() { return false; }, outputB );
|
|
cblist.add( outputA );
|
|
cblist.fire();
|
|
assert.strictEqual( output, results.shift(), "Callback returning false" );
|
|
|
|
// Add another callback (to control lists with memory do not fire anymore)
|
|
output = "X";
|
|
cblist.add( outputC );
|
|
assert.strictEqual( output, results.shift(), "Adding a callback after one returned false" );
|
|
|
|
// Callbacks are not iterated
|
|
output = "";
|
|
function handler() {
|
|
output += "X";
|
|
}
|
|
handler.method = function() {
|
|
output += "!";
|
|
};
|
|
cblist = jQuery.Callbacks( flags );
|
|
cblist.add( handler );
|
|
cblist.add( handler );
|
|
cblist.fire();
|
|
assert.strictEqual( output, results.shift(), "No callback iteration" );
|
|
} );
|
|
} );
|
|
} );
|
|
} );
|
|
|
|
} )();
|
|
|
|
QUnit.test( "jQuery.Callbacks( options ) - options are copied", function( assert ) {
|
|
|
|
assert.expect( 1 );
|
|
|
|
var options = {
|
|
"unique": true
|
|
},
|
|
cb = jQuery.Callbacks( options ),
|
|
count = 0,
|
|
fn = function() {
|
|
assert.ok( !( count++ ), "called once" );
|
|
};
|
|
options[ "unique" ] = false;
|
|
cb.add( fn, fn );
|
|
cb.fire();
|
|
} );
|
|
|
|
QUnit.test( "jQuery.Callbacks.fireWith - arguments are copied", function( assert ) {
|
|
|
|
assert.expect( 1 );
|
|
|
|
var cb = jQuery.Callbacks( "memory" ),
|
|
args = [ "hello" ];
|
|
|
|
cb.fireWith( null, args );
|
|
args[ 0 ] = "world";
|
|
|
|
cb.add( function( hello ) {
|
|
assert.strictEqual( hello, "hello", "arguments are copied internally" );
|
|
} );
|
|
} );
|
|
|
|
QUnit.test( "jQuery.Callbacks.remove - should remove all instances", function( assert ) {
|
|
|
|
assert.expect( 1 );
|
|
|
|
var cb = jQuery.Callbacks();
|
|
|
|
function fn() {
|
|
assert.ok( false, "function wasn't removed" );
|
|
}
|
|
|
|
cb.add( fn, fn, function() {
|
|
assert.ok( true, "end of test" );
|
|
} ).remove( fn ).fire();
|
|
} );
|
|
|
|
QUnit.test( "jQuery.Callbacks.has", function( assert ) {
|
|
|
|
assert.expect( 13 );
|
|
|
|
var cb = jQuery.Callbacks();
|
|
function getA() {
|
|
return "A";
|
|
}
|
|
function getB() {
|
|
return "B";
|
|
}
|
|
function getC() {
|
|
return "C";
|
|
}
|
|
cb.add( getA, getB, getC );
|
|
assert.strictEqual( cb.has(), true, "No arguments to .has() returns whether callback function(s) are attached or not" );
|
|
assert.strictEqual( cb.has( getA ), true, "Check if a specific callback function is in the Callbacks list" );
|
|
|
|
cb.remove( getB );
|
|
assert.strictEqual( cb.has( getB ), false, "Remove a specific callback function and make sure its no longer there" );
|
|
assert.strictEqual( cb.has( getA ), true, "Remove a specific callback function and make sure other callback function is still there" );
|
|
|
|
cb.empty();
|
|
assert.strictEqual( cb.has(), false, "Empty list and make sure there are no callback function(s)" );
|
|
assert.strictEqual( cb.has( getA ), false, "Check for a specific function in an empty() list" );
|
|
|
|
cb.add( getA, getB, function() {
|
|
assert.strictEqual( cb.has(), true, "Check if list has callback function(s) from within a callback function" );
|
|
assert.strictEqual( cb.has( getA ), true, "Check if list has a specific callback from within a callback function" );
|
|
} ).fire();
|
|
|
|
assert.strictEqual( cb.has(), true, "Callbacks list has callback function(s) after firing" );
|
|
|
|
cb.disable();
|
|
assert.strictEqual( cb.has(), false, "disabled() list has no callback functions (returns false)" );
|
|
assert.strictEqual( cb.has( getA ), false, "Check for a specific function in a disabled() list" );
|
|
|
|
cb = jQuery.Callbacks( "unique" );
|
|
cb.add( getA );
|
|
cb.add( getA );
|
|
assert.strictEqual( cb.has(), true, "Check if unique list has callback function(s) attached" );
|
|
cb.lock();
|
|
assert.strictEqual( cb.has(), false, "locked() list is empty and returns false" );
|
|
} );
|
|
|
|
QUnit.test( "jQuery.Callbacks() - adding a string doesn't cause a stack overflow", function( assert ) {
|
|
|
|
assert.expect( 1 );
|
|
|
|
jQuery.Callbacks().add( "hello world" );
|
|
|
|
assert.ok( true, "no stack overflow" );
|
|
} );
|
|
|
|
QUnit.test( "jQuery.Callbacks() - disabled callback doesn't fire (gh-1790)", function( assert ) {
|
|
|
|
assert.expect( 1 );
|
|
|
|
var cb = jQuery.Callbacks(),
|
|
fired = false,
|
|
shot = function() { fired = true; };
|
|
|
|
cb.disable();
|
|
cb.empty();
|
|
cb.add( shot );
|
|
cb.fire();
|
|
assert.ok( !fired, "Disabled callback function didn't fire" );
|
|
} );
|
|
|
|
QUnit.test( "jQuery.Callbacks() - list with memory stays locked (gh-3469)", function( assert ) {
|
|
|
|
assert.expect( 3 );
|
|
|
|
var cb = jQuery.Callbacks( "memory" ),
|
|
fired = 0,
|
|
count1 = function() { fired += 1; },
|
|
count2 = function() { fired += 10; };
|
|
|
|
cb.add( count1 );
|
|
cb.fire();
|
|
assert.equal( fired, 1, "Pre-lock() fire" );
|
|
|
|
cb.lock();
|
|
cb.add( count2 );
|
|
assert.equal( fired, 11, "Post-lock() add" );
|
|
|
|
cb.fire();
|
|
assert.equal( fired, 11, "Post-lock() fire ignored" );
|
|
} );
|