1 files changed, 0 insertions, 728 deletions
diff --git a/ecomp-portal-FE/client/bower_components/lodash/vendor/underscore/test/functions.js b/ecomp-portal-FE/client/bower_components/lodash/vendor/underscore/test/functions.js
deleted file mode 100644
index f696bd64..00000000
--- a/ecomp-portal-FE/client/bower_components/lodash/vendor/underscore/test/functions.js
+++ /dev/null
@@ -1,728 +0,0 @@
-(function() {
-  var _ = typeof require == 'function' ? require('..') : window._;
-
-  QUnit.module('Functions');
-  QUnit.config.asyncRetries = 3;
-
-  QUnit.test('bind', function(assert) {
-    var context = {name: 'moe'};
-    var func = function(arg) { return 'name: ' + (this.name || arg); };
-    var bound = _.bind(func, context);
-    assert.equal(bound(), 'name: moe', 'can bind a function to a context');
-
-    bound = _(func).bind(context);
-    assert.equal(bound(), 'name: moe', 'can do OO-style binding');
-
-    bound = _.bind(func, null, 'curly');
-    var result = bound();
-    // Work around a PhantomJS bug when applying a function with null|undefined.
-    assert.ok(result === 'name: curly' || result === 'name: ' + window.name, 'can bind without specifying a context');
-
-    func = function(salutation, name) { return salutation + ': ' + name; };
-    func = _.bind(func, this, 'hello');
-    assert.equal(func('moe'), 'hello: moe', 'the function was partially applied in advance');
-
-    func = _.bind(func, this, 'curly');
-    assert.equal(func(), 'hello: curly', 'the function was completely applied in advance');
-
-    func = function(salutation, firstname, lastname) { return salutation + ': ' + firstname + ' ' + lastname; };
-    func = _.bind(func, this, 'hello', 'moe', 'curly');
-    assert.equal(func(), 'hello: moe curly', 'the function was partially applied in advance and can accept multiple arguments');
-
-    func = function(ctx, message) { assert.equal(this, ctx, message); };
-    _.bind(func, 0, 0, 'can bind a function to `0`')();
-    _.bind(func, '', '', 'can bind a function to an empty string')();
-    _.bind(func, false, false, 'can bind a function to `false`')();
-
-    // These tests are only meaningful when using a browser without a native bind function
-    // To test this with a modern browser, set underscore's nativeBind to undefined
-    var F = function() { return this; };
-    var boundf = _.bind(F, {hello: 'moe curly'});
-    var Boundf = boundf; // make eslint happy.
-    var newBoundf = new Boundf();
-    assert.equal(newBoundf.hello, void 0, 'function should not be bound to the context, to comply with ECMAScript 5');
-    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.raises(function() { _.bind('notafunction'); }, TypeError, 'throws an error when binding to a non-function');
-  });
-
-  QUnit.test('partial', function(assert) {
-    var obj = {name: 'moe'};
-    var func = function() { return this.name + ' ' + _.toArray(arguments).join(' '); };
-
-    obj.func = _.partial(func, 'a', 'b');
-    assert.equal(obj.func('c', 'd'), 'moe a b c d', 'can partially apply');
-
-    obj.func = _.partial(func, _, 'b', _, 'd');
-    assert.equal(obj.func('a', 'c'), 'moe a b c d', 'can partially apply with placeholders');
-
-    func = _.partial(function() { return arguments.length; }, _, 'b', _, 'd');
-    assert.equal(func('a', 'c', 'e'), 5, 'accepts more arguments than the number of placeholders');
-    assert.equal(func('a'), 4, 'accepts fewer arguments than the number of placeholders');
-
-    func = _.partial(function() { return typeof arguments[2]; }, _, 'b', _, 'd');
-    assert.equal(func('a'), 'undefined', 'unfilled placeholders are undefined');
-
-    // passes context
-    function MyWidget(name, options) {
-      this.name = name;
-      this.options = options;
-    }
-    MyWidget.prototype.get = function() {
-      return this.name;
-    };
-    var MyWidgetWithCoolOpts = _.partial(MyWidget, _, {a: 1});
-    var widget = new MyWidgetWithCoolOpts('foo');
-    assert.ok(widget instanceof MyWidget, 'Can partially bind a constructor');
-    assert.equal(widget.get(), 'foo', 'keeps prototype');
-    assert.deepEqual(widget.options, {a: 1});
-
-    _.partial.placeholder = obj;
-    func = _.partial(function() { return arguments.length; }, obj, 'b', obj, 'd');
-    assert.equal(func('a'), 4, 'allows the placeholder to be swapped out');
-
-    _.partial.placeholder = {};
-    func = _.partial(function() { return arguments.length; }, obj, 'b', obj, 'd');
-    assert.equal(func('a'), 5, 'swapping the placeholder preserves previously bound arguments');
-
-    _.partial.placeholder = _;
-  });
-
-  QUnit.test('bindAll', function(assert) {
-    var curly = {name: 'curly'};
-    var moe = {
-      name: 'moe',
-      getName: function() { return 'name: ' + this.name; },
-      sayHi: function() { return 'hi: ' + this.name; }
-    };
-    curly.getName = moe.getName;
-    _.bindAll(moe, 'getName', 'sayHi');
-    curly.sayHi = moe.sayHi;
-    assert.equal(curly.getName(), 'name: curly', 'unbound function is bound to current object');
-    assert.equal(curly.sayHi(), 'hi: moe', 'bound function is still bound to original object');
-
-    curly = {name: 'curly'};
-    moe = {
-      name: 'moe',
-      getName: function() { return 'name: ' + this.name; },
-      sayHi: function() { return 'hi: ' + this.name; },
-      sayLast: function() { return this.sayHi(_.last(arguments)); }
-    };
-
-    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;
-    assert.equal(curly.sayHi(), 'hi: moe');
-
-    var sayLast = moe.sayLast;
-    assert.equal(sayLast(1, 2, 3, 4, 5, 6, 7, 'Tom'), 'hi: moe', 'createCallback works with any number of arguments');
-
-    _.bindAll(moe, ['getName']);
-    var getName = moe.getName;
-    assert.equal(getName(), 'name: moe', 'flattens arguments into a single list');
-  });
-
-  QUnit.test('memoize', function(assert) {
-    var fib = function(n) {
-      return n < 2 ? n : fib(n - 1) + fib(n - 2);
-    };
-    assert.equal(fib(10), 55, 'a memoized version of fibonacci produces identical results');
-    fib = _.memoize(fib); // Redefine `fib` for memoization
-    assert.equal(fib(10), 55, 'a memoized version of fibonacci produces identical results');
-
-    var o = function(str) {
-      return str;
-    };
-    var fastO = _.memoize(o);
-    assert.equal(o('toString'), 'toString', 'checks hasOwnProperty');
-    assert.equal(fastO('toString'), 'toString', 'checks hasOwnProperty');
-
-    // Expose the cache.
-    var upper = _.memoize(function(s) {
-      return s.toUpperCase();
-    });
-    assert.equal(upper('foo'), 'FOO');
-    assert.equal(upper('bar'), 'BAR');
-    assert.deepEqual(upper.cache, {foo: 'FOO', bar: 'BAR'});
-    upper.cache = {foo: 'BAR', bar: 'FOO'};
-    assert.equal(upper('foo'), 'BAR');
-    assert.equal(upper('bar'), 'FOO');
-
-    var hashed = _.memoize(function(key) {
-      //https://github.com/jashkenas/underscore/pull/1679#discussion_r13736209
-      assert.ok(/[a-z]+/.test(key), 'hasher doesn\'t change keys');
-      return key;
-    }, function(key) {
-      return key.toUpperCase();
-    });
-    hashed('yep');
-    assert.deepEqual(hashed.cache, {YEP: 'yep'}, 'takes a hasher');
-
-    // Test that the hash function can be used to swizzle the key.
-    var objCacher = _.memoize(function(value, key) {
-      return {key: key, value: value};
-    }, function(value, key) {
-      return key;
-    });
-    var myObj = objCacher('a', 'alpha');
-    var myObjAlias = objCacher('b', 'alpha');
-    assert.notStrictEqual(myObj, void 0, 'object is created if second argument used as key');
-    assert.strictEqual(myObj, myObjAlias, 'object is cached if second argument used as key');
-    assert.strictEqual(myObj.value, 'a', 'object is not modified if second argument used as key');
-  });
-
-  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'); done(); }, 150);
-  });
-
-  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'); done(); }, 50);
-  });
-
-  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'); done(); }, 64);
-  });
-
-  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'); done(); }, 96);
-  });
-
-  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'); done();
-    }, 64);
-  });
-
-  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'); done(); }, 64);
-  });
-
-  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);
-    throttledIncr(); throttledIncr();
-    assert.equal(counter, 1);
-    _.delay(function(){
-      assert.equal(counter, 2);
-      throttledIncr();
-      assert.equal(counter, 3);
-      done();
-    }, 85);
-  });
-
-  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);
-    var results = [];
-    var saveResult = function() { results.push(throttledIncr()); };
-    saveResult(); saveResult();
-    _.delay(saveResult, 50);
-    _.delay(saveResult, 150);
-    _.delay(saveResult, 160);
-    _.delay(saveResult, 230);
-    _.delay(function() {
-      assert.equal(results[0], 1, 'incr was called once');
-      assert.equal(results[1], 1, 'incr was throttled');
-      assert.equal(results[2], 1, 'incr was throttled');
-      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');
-      done();
-    }, 300);
-  });
-
-  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++; };
-    var throttledIncr = _.throttle(incr, 32);
-
-    var stamp = new Date;
-    while (new Date - stamp < limit) {
-      throttledIncr();
-    }
-    var lastCount = counter;
-    assert.ok(counter > 1);
-
-    _.delay(function() {
-      assert.ok(counter > lastCount);
-      done();
-    }, 96);
-  });
-
-  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});
-
-    throttledIncr(); throttledIncr();
-    assert.equal(counter, 0);
-
-    _.delay(function() {
-      assert.equal(counter, 1);
-      done();
-    }, 96);
-  });
-
-  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});
-
-    throttledIncr();
-    _.delay(throttledIncr, 50);
-    _.delay(throttledIncr, 60);
-    _.delay(throttledIncr, 200);
-    assert.equal(counter, 0);
-
-    _.delay(function() {
-      assert.equal(counter, 1);
-    }, 250);
-
-    _.delay(function() {
-      assert.equal(counter, 2);
-      done();
-    }, 350);
-  });
-
-  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});
-
-    var time = new Date;
-    while (new Date - time < 350) throttledIncr();
-    assert.ok(counter <= 3);
-
-    _.delay(function() {
-      assert.ok(counter <= 4);
-      done();
-    }, 200);
-  });
-
-  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});
-
-    throttledIncr(); throttledIncr(); throttledIncr();
-    assert.equal(counter, 1);
-
-    _.delay(function() {
-      assert.equal(counter, 1);
-
-      throttledIncr(); throttledIncr();
-      assert.equal(counter, 2);
-
-      _.delay(function() {
-        assert.equal(counter, 2);
-        done();
-      }, 96);
-    }, 96);
-  });
-
-  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);
-    var origNowFunc = _.now;
-
-    throttledIncr();
-    assert.equal(counter, 1);
-    _.now = function() {
-      return new Date(2013, 0, 1, 1, 1, 1);
-    };
-
-    _.delay(function() {
-      throttledIncr();
-      assert.equal(counter, 2);
-      done();
-      _.now = origNowFunc;
-    }, 200);
-  });
-
-  QUnit.test('throttle re-entrant', function(assert) {
-    assert.expect(2);
-    var done = assert.async();
-    var sequence = [
-      ['b1', 'b2'],
-      ['c1', 'c2']
-    ];
-    var value = '';
-    var throttledAppend;
-    var append = function(arg){
-      value += this + arg;
-      var args = sequence.pop();
-      if (args) {
-        throttledAppend.call(args[0], args[1]);
-      }
-    };
-    throttledAppend = _.throttle(append, 32);
-    throttledAppend.call('a1', 'a2');
-    assert.equal(value, 'a1a2');
-    _.delay(function(){
-      assert.equal(value, 'a1a2c1c2b1b2', 'append was throttled successfully');
-      done();
-    }, 100);
-  });
-
-  QUnit.test('throttle cancel', function(assert) {
-    var done = assert.async();
-    var counter = 0;
-    var incr = function(){ counter++; };
-    var throttledIncr = _.throttle(incr, 32);
-    throttledIncr();
-    throttledIncr.cancel();
-    throttledIncr();
-    throttledIncr();
-
-    assert.equal(counter, 2, 'incr was called immediately');
-    _.delay(function(){ assert.equal(counter, 3, 'incr was throttled'); done(); }, 64);
-  });
-
-  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});
-    throttledIncr();
-    throttledIncr.cancel();
-
-    assert.equal(counter, 0, 'incr was throttled');
-    _.delay(function(){ assert.equal(counter, 0, 'incr was throttled'); done(); }, 64);
-  });
-
-  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'); done(); }, 96);
-  });
-
-  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'); done(); }, 96);
-  });
-
-  QUnit.test('debounce asap', function(assert) {
-    assert.expect(6);
-    var done = assert.async();
-    var a, b, c;
-    var counter = 0;
-    var incr = function(){ return ++counter; };
-    var debouncedIncr = _.debounce(incr, 64, true);
-    a = debouncedIncr();
-    b = debouncedIncr();
-    assert.equal(a, 1);
-    assert.equal(b, 1);
-    assert.equal(counter, 1, 'incr was called immediately');
-    _.delay(debouncedIncr, 16);
-    _.delay(debouncedIncr, 32);
-    _.delay(debouncedIncr, 48);
-    _.delay(function(){
-      assert.equal(counter, 1, 'incr was debounced');
-      c = debouncedIncr();
-      assert.equal(c, 2);
-      assert.equal(counter, 2, 'incr was called again');
-      done();
-    }, 128);
-  });
-
-  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; };
-    var debouncedIncr = _.debounce(incr, 64, true);
-    a = debouncedIncr();
-    debouncedIncr.cancel();
-    b = debouncedIncr();
-    assert.equal(a, 1);
-    assert.equal(b, 2);
-    assert.equal(counter, 2, 'incr was called immediately');
-    _.delay(debouncedIncr, 16);
-    _.delay(debouncedIncr, 32);
-    _.delay(debouncedIncr, 48);
-    _.delay(function(){ assert.equal(counter, 2, 'incr was debounced'); done(); }, 128);
-  });
-
-  QUnit.test('debounce asap recursively', function(assert) {
-    assert.expect(2);
-    var done = assert.async();
-    var counter = 0;
-    var debouncedIncr = _.debounce(function(){
-      counter++;
-      if (counter < 10) debouncedIncr();
-    }, 32, true);
-    debouncedIncr();
-    assert.equal(counter, 1, 'incr was called immediately');
-    _.delay(function(){ assert.equal(counter, 1, 'incr was debounced'); done(); }, 96);
-  });
-
-  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(){
-      counter++;
-    }, 100, true);
-
-    debouncedIncr();
-    assert.equal(counter, 1, 'incr was called immediately');
-
-    _.now = function() {
-      return new Date(2013, 0, 1, 1, 1, 1);
-    };
-
-    _.delay(function() {
-      debouncedIncr();
-      assert.equal(counter, 2, 'incr was debounced successfully');
-      done();
-      _.now = origNowFunc;
-    }, 200);
-  });
-
-  QUnit.test('debounce re-entrant', function(assert) {
-    assert.expect(2);
-    var done = assert.async();
-    var sequence = [
-      ['b1', 'b2']
-    ];
-    var value = '';
-    var debouncedAppend;
-    var append = function(arg){
-      value += this + arg;
-      var args = sequence.pop();
-      if (args) {
-        debouncedAppend.call(args[0], args[1]);
-      }
-    };
-    debouncedAppend = _.debounce(append, 32);
-    debouncedAppend.call('a1', 'a2');
-    assert.equal(value, '');
-    _.delay(function(){
-      assert.equal(value, 'a1a2b1b2', 'append was debounced successfully');
-      done();
-    }, 100);
-  });
-
-  QUnit.test('once', function(assert) {
-    var num = 0;
-    var increment = _.once(function(){ return ++num; });
-    increment();
-    increment();
-    assert.equal(num, 1);
-
-    assert.equal(increment(), 1, 'stores a memo to the last value');
-  });
-
-  QUnit.test('Recursive onced function.', function(assert) {
-    assert.expect(1);
-    var f = _.once(function(){
-      assert.ok(true);
-      f();
-    });
-    f();
-  });
-
-  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');
-
-    var inner = function(){ return 'Hello '; };
-    var obj = {name: 'Moe'};
-    obj.hi = _.wrap(inner, function(fn){ return fn() + this.name; });
-    assert.equal(obj.hi(), 'Hello Moe');
-
-    var noop = function(){};
-    var wrapped = _.wrap(noop, function(){ return Array.prototype.slice.call(arguments, 0); });
-    var ret = wrapped(['whats', 'your'], 'vector', 'victor');
-    assert.deepEqual(ret, [noop, ['whats', 'your'], 'vector', 'victor']);
-  });
-
-  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');
-  });
-
-  QUnit.test('compose', function(assert) {
-    var greet = function(name){ return 'hi: ' + name; };
-    var exclaim = function(sentence){ return sentence + '!'; };
-    var composed = _.compose(exclaim, greet);
-    assert.equal(composed('moe'), 'hi: moe!', 'can compose a function that takes another');
-
-    composed = _.compose(greet, exclaim);
-    assert.equal(composed('moe'), 'hi: moe!', 'in this case, the functions are also commutative');
-
-    // f(g(h(x, y, z)))
-    function h(x, y, z) {
-      assert.equal(arguments.length, 3, 'First function called with multiple args');
-      return z * y;
-    }
-    function g(x) {
-      assert.equal(arguments.length, 1, 'Composed function is called with 1 argument');
-      return x;
-    }
-    function f(x) {
-      assert.equal(arguments.length, 1, 'Composed function is called with 1 argument');
-      return x * 2;
-    }
-    composed = _.compose(f, g, h);
-    assert.equal(composed(1, 2, 3), 12);
-  });
-
-  QUnit.test('after', function(assert) {
-    var testAfter = function(afterAmount, timesCalled) {
-      var afterCalled = 0;
-      var after = _.after(afterAmount, function() {
-        afterCalled++;
-      });
-      while (timesCalled--) after();
-      return afterCalled;
-    };
-
-    assert.equal(testAfter(5, 5), 1, 'after(N) should fire after being called N times');
-    assert.equal(testAfter(5, 4), 0, 'after(N) should not fire unless called N times');
-    assert.equal(testAfter(0, 0), 0, 'after(0) should not fire immediately');
-    assert.equal(testAfter(0, 1), 1, 'after(0) should fire when first invoked');
-  });
-
-  QUnit.test('before', function(assert) {
-    var testBefore = function(beforeAmount, timesCalled) {
-      var beforeCalled = 0;
-      var before = _.before(beforeAmount, function() { beforeCalled++; });
-      while (timesCalled--) before();
-      return beforeCalled;
-    };
-
-    assert.equal(testBefore(5, 5), 4, 'before(N) should not fire after being called N times');
-    assert.equal(testBefore(5, 4), 4, 'before(N) should fire before being called N times');
-    assert.equal(testBefore(0, 0), 0, 'before(0) should not fire immediately');
-    assert.equal(testBefore(0, 1), 0, 'before(0) should not fire when first invoked');
-
-    var context = {num: 0};
-    var increment = _.before(3, function(){ return ++this.num; });
-    _.times(10, increment, context);
-    assert.equal(increment(), 2, 'stores a memo to the last value');
-    assert.equal(context.num, 2, 'provides context');
-  });
-
-  QUnit.test('iteratee', function(assert) {
-    var identity = _.iteratee();
-    assert.equal(identity, _.identity, '_.iteratee is exposed as an external function.');
-
-    function fn() {
-      return arguments;
-    }
-    _.each([_.iteratee(fn), _.iteratee(fn, {})], function(cb) {
-      assert.equal(cb().length, 0);
-      assert.deepEqual(_.toArray(cb(1, 2, 3)), _.range(1, 4));
-      assert.deepEqual(_.toArray(cb(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)), _.range(1, 11));
-    });
-
-  });
-
-  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');
-    })(1, 2, 3);
-
-    _.restArgs(function(a, args) {
-      assert.strictEqual(a, void 0);
-      assert.deepEqual(args, [], 'passes empty array if there are not enough arguments');
-    })();
-
-    _.restArgs(function(a, b, c, args) {
-      assert.strictEqual(arguments.length, 4);
-      assert.deepEqual(args, [4, 5], 'works on functions with many named parameters');
-    })(1, 2, 3, 4, 5);
-
-    var obj = {};
-    _.restArgs(function() {
-      assert.strictEqual(this, obj, 'invokes function with this context');
-    }).call(obj);
-
-    _.restArgs(function(array, iteratee, context) {
-      assert.deepEqual(array, [1, 2, 3, 4], 'startIndex can be used manually specify index of rest parameter');
-      assert.strictEqual(iteratee, void 0);
-      assert.strictEqual(context, void 0);
-    }, 0)(1, 2, 3, 4);
-  });
-
-}());