test/unit/callbacks.js

   1 module( "callbacks", {
   2         teardown: moduleTeardown
   3 });
   4
   5 (function() {
   6
   7 var output,
   8         addToOutput = function( string ) {
   9                 return function() {
  10                         output += string;
  11                 };
  12         },
  13         outputA = addToOutput("A"),
  14         outputB = addToOutput("B"),
  15         outputC = addToOutput("C"),
  16         tests = {
  17                 "":                   "XABC   X     XABCABCC  X  XBB X   XABA  X   XX",
  18                 "once":               "XABC   X     X         X  X   X   XABA  X   XX",
  19                 "memory":             "XABC   XABC  XABCABCCC XA XBB XB  XABA  XC  XX",
  20                 "unique":             "XABC   X     XABCA     X  XBB X   XAB   X   X",
  21                 "stopOnFalse":        "XABC   X     XABCABCC  X  XBB X   XA    X   XX",
  22                 "once memory":        "XABC   XABC  X         XA X   XA  XABA  XC  XX",
  23                 "once unique":        "XABC   X     X         X  X   X   XAB   X   X",
  24                 "once stopOnFalse":   "XABC   X     X         X  X   X   XA    X   XX",
  25                 "memory unique":      "XABC   XA    XABCA     XA XBB XB  XAB   XC  X",
  26                 "memory stopOnFalse": "XABC   XABC  XABCABCCC XA XBB XB  XA    X   XX",
  27                 "unique stopOnFalse": "XABC   X     XABCA     X  XBB X   XA    X   X"
  28         },
  29         filters = {
  30                 "no filter": undefined,
  31                 "filter": function( fn ) {
  32                         return function() {
  33                                 return fn.apply( this, arguments );
  34                         };
  35                 }
  36         };
  37
  38         function showFlags( flags ) {
  39                 if ( typeof flags === "string" ) {
  40                         return "'" + flags + "'";
  41                 }
  42                 var output = [], key;
  43                 for ( key in flags ) {
  44                         output.push( "'" + key + "': " + flags[ key ] );
  45                 }
  46                 return "{ " + output.join( ", " ) + " }";
  47         }
  48
  49 jQuery.each( tests, function( strFlags, resultString ) {
  50
  51                 var objectFlags = {};
  52
  53                 jQuery.each( strFlags.split( " " ), function() {
  54                         if ( this.length ) {
  55                                 objectFlags[ this ] = true;
  56                         }
  57                 });
  58
  59                 jQuery.each( filters, function( filterLabel ) {
  60
  61                         jQuery.each({
  62                                 "string": strFlags,
  63                                 "object": objectFlags
  64                         }, function( flagsTypes, flags ) {
  65
  66                                 test( "jQuery.Callbacks( " + showFlags( flags ) + " ) - " + filterLabel, function() {
  67
  68                                         expect( 29 );
  69
  70                                         var cblist,
  71                                                 results = resultString.split( /\s+/ );
  72
  73                                         // Basic binding and firing
  74                                         output = "X";
  75                                         cblist = jQuery.Callbacks( flags );
  76                                         strictEqual( cblist.locked(), false, ".locked() initially false" );
  77                                         strictEqual( cblist.disabled(), false, ".disabled() initially false" );
  78                                         strictEqual( cblist.fired(), false, ".fired() initially false" );
  79                                         cblist.add(function( str ) {
  80                                                 output += str;
  81                                         });
  82                                         strictEqual( cblist.fired(), false, ".fired() still false after .add" );
  83                                         cblist.fire( "A" );
  84                                         strictEqual( output, "XA", "Basic binding and firing" );
  85                                         strictEqual( cblist.fired(), true, ".fired() detects firing" );
  86                                         output = "X";
  87                                         cblist.disable();
  88                                         cblist.add(function( str ) {
  89                                                 output += str;
  90                                         });
  91                                         strictEqual( output, "X", "Adding a callback after disabling" );
  92                                         cblist.fire("A");
  93                                         strictEqual( output, "X", "Firing after disabling" );
  94                                         strictEqual( cblist.disabled(), true, ".disabled() becomes true" );
  95                                         strictEqual( cblist.locked(), true, "disabling locks" );
  96
  97                                         // Emptying while firing (#13517)
  98                                         cblist = jQuery.Callbacks( flags );
  99                                         cblist.add( cblist.empty );
 100                                         cblist.add( function() {
 101                                                 ok( false, "not emptied" );
 102                                         } );
 103                                         cblist.fire();
 104
 105                                         // Disabling while firing
 106                                         cblist = jQuery.Callbacks( flags );
 107                                         cblist.add( cblist.disable );
 108                                         cblist.add( function() {
 109                                                 ok( false, "not disabled" );
 110                                         } );
 111                                         cblist.fire();
 112
 113                                         // Basic binding and firing (context, arguments)
 114                                         output = "X";
 115                                         cblist = jQuery.Callbacks( flags );
 116                                         cblist.add(function() {
 117                                                 equal( this, window, "Basic binding and firing (context)" );
 118                                                 output += Array.prototype.join.call( arguments, "" );
 119                                         });
 120                                         cblist.fireWith( window, [ "A", "B" ] );
 121                                         strictEqual( output, "XAB", "Basic binding and firing (arguments)" );
 122
 123                                         // fireWith with no arguments
 124                                         output = "";
 125                                         cblist = jQuery.Callbacks( flags );
 126                                         cblist.add(function() {
 127                                                 equal( this, window, "fireWith with no arguments (context is window)" );
 128                                                 strictEqual( arguments.length, 0, "fireWith with no arguments (no arguments)" );
 129                                         });
 130                                         cblist.fireWith();
 131
 132                                         // Basic binding, removing and firing
 133                                         output = "X";
 134                                         cblist = jQuery.Callbacks( flags );
 135                                         cblist.add( outputA, outputB, outputC );
 136                                         cblist.remove( outputB, outputC );
 137                                         cblist.fire();
 138                                         strictEqual( output, "XA", "Basic binding, removing and firing" );
 139
 140                                         // Empty
 141                                         output = "X";
 142                                         cblist = jQuery.Callbacks( flags );
 143                                         cblist.add( outputA );
 144                                         cblist.add( outputB );
 145                                         cblist.add( outputC );
 146                                         cblist.empty();
 147                                         cblist.fire();
 148                                         strictEqual( output, "X", "Empty" );
 149
 150                                         // Locking
 151                                         output = "X";
 152                                         cblist = jQuery.Callbacks( flags );
 153                                         cblist.add(function( str ) {
 154                                                 output += str;
 155                                         });
 156                                         cblist.lock();
 157                                         cblist.add(function( str ) {
 158                                                 output += str;
 159                                         });
 160                                         cblist.fire("A");
 161                                         cblist.add(function( str ) {
 162                                                 output += str;
 163                                         });
 164                                         strictEqual( output, "X", "Lock early" );
 165                                         strictEqual( cblist.locked(), true, "Locking reflected in accessor" );
 166
 167                                         // Locking while firing (gh-1990)
 168                                         output = "X";
 169                                         cblist = jQuery.Callbacks( flags );
 170                                         cblist.add( cblist.lock );
 171                                         cblist.add(function( str ) {
 172                                                 output += str;
 173                                         });
 174                                         cblist.fire( "A" );
 175                                         strictEqual( output, "XA", "Locking doesn't abort execution (gh-1990)" );
 176
 177                                         // Ordering
 178                                         output = "X";
 179                                         cblist = jQuery.Callbacks( flags );
 180                                         cblist.add(function() {
 181                                                 cblist.add( outputC );
 182                                                 outputA();
 183                                         }, outputB );
 184                                         cblist.fire();
 185                                         strictEqual( output, results.shift(), "Proper ordering" );
 186
 187                                         // Add and fire again
 188                                         output = "X";
 189                                         cblist.add(function() {
 190                                                 cblist.add( outputC );
 191                                                 outputA();
 192                                         }, outputB );
 193                                         strictEqual( output, results.shift(), "Add after fire" );
 194
 195                                         output = "X";
 196                                         cblist.fire();
 197                                         strictEqual( output, results.shift(), "Fire again" );
 198
 199                                         // Multiple fire
 200                                         output = "X";
 201                                         cblist = jQuery.Callbacks( flags );
 202                                         cblist.add(function( str ) {
 203                                                 output += str;
 204                                         });
 205                                         cblist.fire("A");
 206                                         strictEqual( output, "XA", "Multiple fire (first fire)" );
 207                                         output = "X";
 208                                         cblist.add(function( str ) {
 209                                                 output += str;
 210                                         });
 211                                         strictEqual( output, results.shift(), "Multiple fire (first new callback)" );
 212                                         output = "X";
 213                                         cblist.fire("B");
 214                                         strictEqual( output, results.shift(), "Multiple fire (second fire)" );
 215                                         output = "X";
 216                                         cblist.add(function( str ) {
 217                                                 output += str;
 218                                         });
 219                                         strictEqual( output, results.shift(), "Multiple fire (second new callback)" );
 220
 221                                         // Return false
 222                                         output = "X";
 223                                         cblist = jQuery.Callbacks( flags );
 224                                         cblist.add( outputA, function() { return false; }, outputB );
 225                                         cblist.add( outputA );
 226                                         cblist.fire();
 227                                         strictEqual( output, results.shift(), "Callback returning false" );
 228
 229                                         // Add another callback (to control lists with memory do not fire anymore)
 230                                         output = "X";
 231                                         cblist.add( outputC );
 232                                         strictEqual( output, results.shift(), "Adding a callback after one returned false" );
 233
 234                                         // Callbacks are not iterated
 235                                         output = "";
 236                                         function handler() {
 237                                                 output += "X";
 238                                         }
 239                                         handler.method = function() {
 240                                                 output += "!";
 241                                         };
 242                                         cblist = jQuery.Callbacks( flags );
 243                                         cblist.add( handler );
 244                                         cblist.add( handler );
 245                                         cblist.fire();
 246                                         strictEqual( output, results.shift(), "No callback iteration" );
 247                                 });
 248                         });
 249                 });
 250 });
 251
 252 })();
 253
 254 test( "jQuery.Callbacks( options ) - options are copied", function() {
 255
 256         expect( 1 );
 257
 258         var options = {
 259                         "unique": true
 260                 },
 261                 cb = jQuery.Callbacks( options ),
 262                 count = 0,
 263                 fn = function() {
 264                         ok( !( count++ ), "called once" );
 265                 };
 266         options["unique"] = false;
 267         cb.add( fn, fn );
 268         cb.fire();
 269 });
 270
 271 test( "jQuery.Callbacks.fireWith - arguments are copied", function() {
 272
 273         expect( 1 );
 274
 275         var cb = jQuery.Callbacks("memory"),
 276                 args = ["hello"];
 277
 278         cb.fireWith( null, args );
 279         args[ 0 ] = "world";
 280
 281         cb.add(function( hello ) {
 282                 strictEqual( hello, "hello", "arguments are copied internally" );
 283         });
 284 });
 285
 286 test( "jQuery.Callbacks.remove - should remove all instances", function() {
 287
 288         expect( 1 );
 289
 290         var cb = jQuery.Callbacks();
 291
 292         function fn() {
 293                 ok( false, "function wasn't removed" );
 294         }
 295
 296         cb.add( fn, fn, function() {
 297                 ok( true, "end of test" );
 298         }).remove( fn ).fire();
 299 });
 300
 301 test( "jQuery.Callbacks.has", function() {
 302
 303         expect( 13 );
 304
 305         var cb = jQuery.Callbacks();
 306         function getA() {
 307                 return "A";
 308         }
 309         function getB() {
 310                 return "B";
 311         }
 312         function getC() {
 313                 return "C";
 314         }
 315         cb.add(getA, getB, getC);
 316         strictEqual( cb.has(), true, "No arguments to .has() returns whether callback function(s) are attached or not" );
 317         strictEqual( cb.has(getA), true, "Check if a specific callback function is in the Callbacks list" );
 318
 319         cb.remove(getB);
 320         strictEqual( cb.has(getB), false, "Remove a specific callback function and make sure its no longer there" );
 321         strictEqual( cb.has(getA), true, "Remove a specific callback function and make sure other callback function is still there" );
 322
 323         cb.empty();
 324         strictEqual( cb.has(), false, "Empty list and make sure there are no callback function(s)" );
 325         strictEqual( cb.has(getA), false, "Check for a specific function in an empty() list" );
 326
 327         cb.add(getA, getB, function(){
 328                 strictEqual( cb.has(), true, "Check if list has callback function(s) from within a callback function" );
 329                 strictEqual( cb.has(getA), true, "Check if list has a specific callback from within a callback function" );
 330         }).fire();
 331
 332         strictEqual( cb.has(), true, "Callbacks list has callback function(s) after firing" );
 333
 334         cb.disable();
 335         strictEqual( cb.has(), false, "disabled() list has no callback functions (returns false)" );
 336         strictEqual( cb.has(getA), false, "Check for a specific function in a disabled() list" );
 337
 338         cb = jQuery.Callbacks("unique");
 339         cb.add(getA);
 340         cb.add(getA);
 341         strictEqual( cb.has(), true, "Check if unique list has callback function(s) attached" );
 342         cb.lock();
 343         strictEqual( cb.has(), false, "locked() list is empty and returns false" );
 344 });
 345
 346 test( "jQuery.Callbacks() - adding a string doesn't cause a stack overflow", function() {
 347
 348         expect( 1 );
 349
 350         jQuery.Callbacks().add( "hello world" );
 351
 352         ok( true, "no stack overflow" );
 353 });
 354
 355 test( "jQuery.Callbacks() - disabled callback doesn't fire (gh-1790)", function() {
 356
 357         expect( 1 );
 358
 359         var cb = jQuery.Callbacks(),
 360                 fired = false,
 361                 shot = function() { fired = true; };
 362
 363         cb.disable();
 364         cb.empty();
 365         cb.add( shot );
 366         cb.fire();
 367         ok( !fired, "Disabled callback function didn't fire" );
 368 });