Update vendor/underscore.

vendor/underscore/test/functions.js

@@ -4,7 +4,7 @@
   QUnit.module('Functions');
   QUnit.config.asyncRetries = 3;
 
-  test('bind', function(assert) {
+  QUnit.test('bind', function(assert) {
     var context = {name: 'moe'};
     var func = function(arg) { return 'name: ' + (this.name || arg); };
     var bound = _.bind(func, context);
@@ -44,10 +44,10 @@
     assert.equal(boundf().hello, 'moe curly', "When called without the new operator, it's OK to be bound to the context");
     assert.ok(newBoundf instanceof F, 'a bound instance is an instance of the original function');
 
-    assert.throws(function() { _.bind('notafunction'); }, TypeError, 'throws an error when binding to a non-function');
+    assert.raises(function() { _.bind('notafunction'); }, TypeError, 'throws an error when binding to a non-function');
   });
 
-  test('partial', function(assert) {
+  QUnit.test('partial', function(assert) {
     var obj = {name: 'moe'};
     var func = function() { return this.name + ' ' + _.toArray(arguments).join(' '); };
 
@@ -89,7 +89,7 @@
     _.partial.placeholder = _;
   });
 
-  test('bindAll', function(assert) {
+  QUnit.test('bindAll', function(assert) {
     var curly = {name: 'curly'}, moe = {
       name: 'moe',
       getName: function() { return 'name: ' + this.name; },
@@ -109,9 +109,9 @@
       sayLast: function() { return this.sayHi(_.last(arguments)); }
     };
 
-    assert.throws(function() { _.bindAll(moe); }, Error, 'throws an error for bindAll with no functions named');
-    assert.throws(function() { _.bindAll(moe, 'sayBye'); }, TypeError, 'throws an error for bindAll if the given key is undefined');
-    assert.throws(function() { _.bindAll(moe, 'name'); }, TypeError, 'throws an error for bindAll if the given key is not a function');
+    assert.raises(function() { _.bindAll(moe); }, Error, 'throws an error for bindAll with no functions named');
+    assert.raises(function() { _.bindAll(moe, 'sayBye'); }, TypeError, 'throws an error for bindAll if the given key is undefined');
+    assert.raises(function() { _.bindAll(moe, 'name'); }, TypeError, 'throws an error for bindAll if the given key is not a function');
 
     _.bindAll(moe, 'sayHi', 'sayLast');
     curly.sayHi = moe.sayHi;
@@ -125,7 +125,7 @@
     assert.equal(getName(), 'name: moe', 'flattens arguments into a single list');
   });
 
-  test('memoize', function(assert) {
+  QUnit.test('memoize', function(assert) {
     var fib = function(n) {
       return n < 2 ? n : fib(n - 1) + fib(n - 2);
     };
@@ -174,59 +174,73 @@
     assert.strictEqual(myObj.value, 'a', 'object is not modified if second argument used as key');
   });
 
-  asyncTest('delay', 2, function(assert) {
+  QUnit.test('delay', function(assert) {
+    assert.expect(2);
+    var done = assert.async();
     var delayed = false;
     _.delay(function(){ delayed = true; }, 100);
     setTimeout(function(){ assert.ok(!delayed, "didn't delay the function quite yet"); }, 50);
-    setTimeout(function(){ assert.ok(delayed, 'delayed the function'); start(); }, 150);
+    setTimeout(function(){ assert.ok(delayed, 'delayed the function'); done(); }, 150);
   });
 
-  asyncTest('defer', 1, function(assert) {
+  QUnit.test('defer', function(assert) {
+    assert.expect(1);
+    var done = assert.async();
     var deferred = false;
     _.defer(function(bool){ deferred = bool; }, true);
-    _.delay(function(){ assert.ok(deferred, 'deferred the function'); start(); }, 50);
+    _.delay(function(){ assert.ok(deferred, 'deferred the function'); done(); }, 50);
   });
 
-  asyncTest('throttle', 2, function(assert) {
+  QUnit.test('throttle', function(assert) {
+    assert.expect(2);
+    var done = assert.async();
     var counter = 0;
     var incr = function(){ counter++; };
     var throttledIncr = _.throttle(incr, 32);
     throttledIncr(); throttledIncr();
 
     assert.equal(counter, 1, 'incr was called immediately');
-    _.delay(function(){ assert.equal(counter, 2, 'incr was throttled'); start(); }, 64);
+    _.delay(function(){ assert.equal(counter, 2, 'incr was throttled'); done(); }, 64);
   });
 
-  asyncTest('throttle arguments', 2, function(assert) {
+  QUnit.test('throttle arguments', function(assert) {
+    assert.expect(2);
+    var done = assert.async();
     var value = 0;
     var update = function(val){ value = val; };
     var throttledUpdate = _.throttle(update, 32);
     throttledUpdate(1); throttledUpdate(2);
     _.delay(function(){ throttledUpdate(3); }, 64);
     assert.equal(value, 1, 'updated to latest value');
-    _.delay(function(){ assert.equal(value, 3, 'updated to latest value'); start(); }, 96);
+    _.delay(function(){ assert.equal(value, 3, 'updated to latest value'); done(); }, 96);
   });
 
-  asyncTest('throttle once', 2, function(assert) {
+  QUnit.test('throttle once', function(assert) {
+    assert.expect(2);
+    var done = assert.async();
     var counter = 0;
     var incr = function(){ return ++counter; };
     var throttledIncr = _.throttle(incr, 32);
     var result = throttledIncr();
     _.delay(function(){
       assert.equal(result, 1, 'throttled functions return their value');
-      assert.equal(counter, 1, 'incr was called once'); start();
+      assert.equal(counter, 1, 'incr was called once'); done();
     }, 64);
   });
 
-  asyncTest('throttle twice', 1, function(assert) {
+  QUnit.test('throttle twice', function(assert) {
+    assert.expect(1);
+    var done = assert.async();
     var counter = 0;
     var incr = function(){ counter++; };
     var throttledIncr = _.throttle(incr, 32);
     throttledIncr(); throttledIncr();
-    _.delay(function(){ assert.equal(counter, 2, 'incr was called twice'); start(); }, 64);
+    _.delay(function(){ assert.equal(counter, 2, 'incr was called twice'); done(); }, 64);
   });
 
-  asyncTest('more throttling', 3, function(assert) {
+  QUnit.test('more throttling', function(assert) {
+    assert.expect(3);
+    var done = assert.async();
     var counter = 0;
     var incr = function(){ counter++; };
     var throttledIncr = _.throttle(incr, 30);
@@ -236,11 +250,13 @@
       assert.equal(counter, 2);
       throttledIncr();
       assert.equal(counter, 3);
-      start();
+      done();
     }, 85);
   });
 
-  asyncTest('throttle repeatedly with results', 6, function(assert) {
+  QUnit.test('throttle repeatedly with results', function(assert) {
+    assert.expect(6);
+    var done = assert.async();
     var counter = 0;
     var incr = function(){ return ++counter; };
     var throttledIncr = _.throttle(incr, 100);
@@ -258,11 +274,13 @@
       assert.equal(results[3], 2, 'incr was called twice');
       assert.equal(results[4], 2, 'incr was throttled');
       assert.equal(results[5], 3, 'incr was called trailing');
-      start();
+      done();
     }, 300);
   });
 
-  asyncTest('throttle triggers trailing call when invoked repeatedly', 2, function(assert) {
+  QUnit.test('throttle triggers trailing call when invoked repeatedly', function(assert) {
+    assert.expect(2);
+    var done = assert.async();
     var counter = 0;
     var limit = 48;
     var incr = function(){ counter++; };
@@ -277,11 +295,13 @@
 
     _.delay(function() {
       assert.ok(counter > lastCount);
-      start();
+      done();
     }, 96);
   });
 
-  asyncTest('throttle does not trigger leading call when leading is set to false', 2, function(assert) {
+  QUnit.test('throttle does not trigger leading call when leading is set to false', function(assert) {
+    assert.expect(2);
+    var done = assert.async();
     var counter = 0;
     var incr = function(){ counter++; };
     var throttledIncr = _.throttle(incr, 60, {leading: false});
@@ -291,11 +311,13 @@
 
     _.delay(function() {
       assert.equal(counter, 1);
-      start();
+      done();
     }, 96);
   });
 
-  asyncTest('more throttle does not trigger leading call when leading is set to false', 3, function(assert) {
+  QUnit.test('more throttle does not trigger leading call when leading is set to false', function(assert) {
+    assert.expect(3);
+    var done = assert.async();
     var counter = 0;
     var incr = function(){ counter++; };
     var throttledIncr = _.throttle(incr, 100, {leading: false});
@@ -312,11 +334,13 @@
 
     _.delay(function() {
       assert.equal(counter, 2);
-      start();
+      done();
     }, 350);
   });
 
-  asyncTest('one more throttle with leading: false test', 2, function(assert) {
+  QUnit.test('one more throttle with leading: false test', function(assert) {
+    assert.expect(2);
+    var done = assert.async();
     var counter = 0;
     var incr = function(){ counter++; };
     var throttledIncr = _.throttle(incr, 100, {leading: false});
@@ -327,11 +351,13 @@
 
     _.delay(function() {
       assert.ok(counter <= 4);
-      start();
+      done();
     }, 200);
   });
 
-  asyncTest('throttle does not trigger trailing call when trailing is set to false', 4, function(assert) {
+  QUnit.test('throttle does not trigger trailing call when trailing is set to false', function(assert) {
+    assert.expect(4);
+    var done = assert.async();
     var counter = 0;
     var incr = function(){ counter++; };
     var throttledIncr = _.throttle(incr, 60, {trailing: false});
@@ -347,12 +373,14 @@
 
       _.delay(function() {
         assert.equal(counter, 2);
-        start();
+        done();
       }, 96);
     }, 96);
   });
 
-  asyncTest('throttle continues to function after system time is set backwards', 2, function(assert) {
+  QUnit.test('throttle continues to function after system time is set backwards', function(assert) {
+    assert.expect(2);
+    var done = assert.async();
     var counter = 0;
     var incr = function(){ counter++; };
     var throttledIncr = _.throttle(incr, 100);
@@ -367,12 +395,14 @@
     _.delay(function() {
       throttledIncr();
       assert.equal(counter, 2);
-      start();
+      done();
       _.now = origNowFunc;
     }, 200);
   });
 
-  asyncTest('throttle re-entrant', 2, function(assert) {
+  QUnit.test('throttle re-entrant', function(assert) {
+    assert.expect(2);
+    var done = assert.async();
     var sequence = [
       ['b1', 'b2'],
       ['c1', 'c2']
@@ -391,11 +421,12 @@
     assert.equal(value, 'a1a2');
     _.delay(function(){
       assert.equal(value, 'a1a2c1c2b1b2', 'append was throttled successfully');
-      start();
+      done();
     }, 100);
   });
 
-  asyncTest('throttle cancel', function(assert) {
+  QUnit.test('throttle cancel', function(assert) {
+    var done = assert.async();
     var counter = 0;
     var incr = function(){ counter++; };
     var throttledIncr = _.throttle(incr, 32);
@@ -405,10 +436,11 @@
     throttledIncr();
 
     assert.equal(counter, 2, 'incr was called immediately');
-    _.delay(function(){ assert.equal(counter, 3, 'incr was throttled'); start(); }, 64);
+    _.delay(function(){ assert.equal(counter, 3, 'incr was throttled'); done(); }, 64);
   });
 
-  asyncTest('throttle cancel with leading: false', function(assert) {
+  QUnit.test('throttle cancel with leading: false', function(assert) {
+    var done = assert.async();
     var counter = 0;
     var incr = function(){ counter++; };
     var throttledIncr = _.throttle(incr, 32, {leading: false});
@@ -416,28 +448,34 @@
     throttledIncr.cancel();
 
     assert.equal(counter, 0, 'incr was throttled');
-    _.delay(function(){ assert.equal(counter, 0, 'incr was throttled'); start(); }, 64);
+    _.delay(function(){ assert.equal(counter, 0, 'incr was throttled'); done(); }, 64);
   });
 
-  asyncTest('debounce', 1, function(assert) {
+  QUnit.test('debounce', function(assert) {
+    assert.expect(1);
+    var done = assert.async();
     var counter = 0;
     var incr = function(){ counter++; };
     var debouncedIncr = _.debounce(incr, 32);
     debouncedIncr(); debouncedIncr();
     _.delay(debouncedIncr, 16);
-    _.delay(function(){ assert.equal(counter, 1, 'incr was debounced'); start(); }, 96);
+    _.delay(function(){ assert.equal(counter, 1, 'incr was debounced'); done(); }, 96);
   });
 
-  asyncTest('debounce cancel', 1, function(assert) {
+  QUnit.test('debounce cancel', function(assert) {
+    assert.expect(1);
+    var done = assert.async();
     var counter = 0;
     var incr = function(){ counter++; };
     var debouncedIncr = _.debounce(incr, 32);
     debouncedIncr();
     debouncedIncr.cancel();
-    _.delay(function(){ assert.equal(counter, 0, 'incr was not called'); start(); }, 96);
+    _.delay(function(){ assert.equal(counter, 0, 'incr was not called'); done(); }, 96);
   });
 
-  asyncTest('debounce asap', 4, function(assert) {
+  QUnit.test('debounce asap', function(assert) {
+    assert.expect(4);
+    var done = assert.async();
     var a, b;
     var counter = 0;
     var incr = function(){ return ++counter; };
@@ -450,10 +488,12 @@
     _.delay(debouncedIncr, 16);
     _.delay(debouncedIncr, 32);
     _.delay(debouncedIncr, 48);
-    _.delay(function(){ assert.equal(counter, 1, 'incr was debounced'); start(); }, 128);
+    _.delay(function(){ assert.equal(counter, 1, 'incr was debounced'); done(); }, 128);
   });
 
-  asyncTest('debounce asap cancel', 4, function(assert) {
+  QUnit.test('debounce asap cancel', function(assert) {
+    assert.expect(4);
+    var done = assert.async();
     var a, b;
     var counter = 0;
     var incr = function(){ return ++counter; };
@@ -467,10 +507,12 @@
     _.delay(debouncedIncr, 16);
     _.delay(debouncedIncr, 32);
     _.delay(debouncedIncr, 48);
-    _.delay(function(){ assert.equal(counter, 2, 'incr was debounced'); start(); }, 128);
+    _.delay(function(){ assert.equal(counter, 2, 'incr was debounced'); done(); }, 128);
   });
 
-  asyncTest('debounce asap recursively', 2, function(assert) {
+  QUnit.test('debounce asap recursively', function(assert) {
+    assert.expect(2);
+    var done = assert.async();
     var counter = 0;
     var debouncedIncr = _.debounce(function(){
       counter++;
@@ -478,10 +520,12 @@
     }, 32, true);
     debouncedIncr();
     assert.equal(counter, 1, 'incr was called immediately');
-    _.delay(function(){ assert.equal(counter, 1, 'incr was debounced'); start(); }, 96);
+    _.delay(function(){ assert.equal(counter, 1, 'incr was debounced'); done(); }, 96);
   });
 
-  asyncTest('debounce after system time is set backwards', 2, function(assert) {
+  QUnit.test('debounce after system time is set backwards', function(assert) {
+    assert.expect(2);
+    var done = assert.async();
     var counter = 0;
     var origNowFunc = _.now;
     var debouncedIncr = _.debounce(function(){
@@ -498,12 +542,14 @@
     _.delay(function() {
       debouncedIncr();
       assert.equal(counter, 2, 'incr was debounced successfully');
-      start();
+      done();
       _.now = origNowFunc;
     }, 200);
   });
 
-  asyncTest('debounce re-entrant', 2, function(assert) {
+  QUnit.test('debounce re-entrant', function(assert) {
+    assert.expect(2);
+    var done = assert.async();
     var sequence = [
       ['b1', 'b2']
     ];
@@ -521,11 +567,11 @@
     assert.equal(value, '');
     _.delay(function(){
       assert.equal(value, 'a1a2b1b2', 'append was debounced successfully');
-      start();
+      done();
     }, 100);
   });
 
-  test('once', function(assert) {
+  QUnit.test('once', function(assert) {
     var num = 0;
     var increment = _.once(function(){ return ++num; });
     increment();
@@ -535,7 +581,8 @@
     assert.equal(increment(), 1, 'stores a memo to the last value');
   });
 
-  test('Recursive onced function.', 1, function(assert) {
+  QUnit.test('Recursive onced function.', function(assert) {
+    assert.expect(1);
     var f = _.once(function(){
       assert.ok(true);
       f();
@@ -543,7 +590,7 @@
     f();
   });
 
-  test('wrap', function(assert) {
+  QUnit.test('wrap', function(assert) {
     var greet = function(name){ return 'hi: ' + name; };
     var backwards = _.wrap(greet, function(func, name){ return func(name) + ' ' + name.split('').reverse().join(''); });
     assert.equal(backwards('moe'), 'hi: moe eom', 'wrapped the salutation function');
@@ -559,13 +606,13 @@
     assert.deepEqual(ret, [noop, ['whats', 'your'], 'vector', 'victor']);
   });
 
-  test('negate', function(assert) {
+  QUnit.test('negate', function(assert) {
     var isOdd = function(n){ return n & 1; };
     assert.equal(_.negate(isOdd)(2), true, 'should return the complement of the given function');
     assert.equal(_.negate(isOdd)(3), false, 'should return the complement of the given function');
   });
 
-  test('compose', function(assert) {
+  QUnit.test('compose', function(assert) {
     var greet = function(name){ return 'hi: ' + name; };
     var exclaim = function(sentence){ return sentence + '!'; };
     var composed = _.compose(exclaim, greet);
@@ -591,7 +638,7 @@
     assert.equal(composed(1, 2, 3), 12);
   });
 
-  test('after', function(assert) {
+  QUnit.test('after', function(assert) {
     var testAfter = function(afterAmount, timesCalled) {
       var afterCalled = 0;
       var after = _.after(afterAmount, function() {
@@ -607,7 +654,7 @@
     assert.equal(testAfter(0, 1), 1, 'after(0) should fire when first invoked');
   });
 
-  test('before', function(assert) {
+  QUnit.test('before', function(assert) {
     var testBefore = function(beforeAmount, timesCalled) {
       var beforeCalled = 0;
       var before = _.before(beforeAmount, function() { beforeCalled++; });
@@ -627,7 +674,7 @@
     assert.equal(context.num, 2, 'provides context');
   });
 
-  test('iteratee', function(assert) {
+  QUnit.test('iteratee', function(assert) {
     var identity = _.iteratee();
     assert.equal(identity, _.identity, '_.iteratee is exposed as an external function.');
 
@@ -642,7 +689,8 @@
 
   });
 
-  test('restArgs', 10, function(assert) {
+  QUnit.test('restArgs', function(assert) {
+    assert.expect(10);
     _.restArgs(function(a, args) {
       assert.strictEqual(a, 1);
       assert.deepEqual(args, [2, 3], 'collects rest arguments into an array');