mirror of
https://github.com/whoisclebs/lodash.git
synced 2026-02-14 20:57:49 +00:00
Update vendor/backbone and vendor/underscore.
This commit is contained in:
John-David Dalton
486
vendor/underscore/test/arrays.js
vendored
486
vendor/underscore/test/arrays.js
vendored
@@ -3,161 +3,159 @@
|
||||
|
||||
QUnit.module('Arrays');
|
||||
|
||||
test('first', function() {
|
||||
equal(_.first([1, 2, 3]), 1, 'can pull out the first element of an array');
|
||||
equal(_([1, 2, 3]).first(), 1, 'can perform OO-style "first()"');
|
||||
deepEqual(_.first([1, 2, 3], 0), [], 'can pass an index to first');
|
||||
deepEqual(_.first([1, 2, 3], 2), [1, 2], 'can pass an index to first');
|
||||
deepEqual(_.first([1, 2, 3], 5), [1, 2, 3], 'can pass an index to first');
|
||||
test('first', function(assert) {
|
||||
assert.equal(_.first([1, 2, 3]), 1, 'can pull out the first element of an array');
|
||||
assert.equal(_([1, 2, 3]).first(), 1, 'can perform OO-style "first()"');
|
||||
assert.deepEqual(_.first([1, 2, 3], 0), [], 'returns an empty array when n <= 0 (0 case)');
|
||||
assert.deepEqual(_.first([1, 2, 3], -1), [], 'returns an empty array when n <= 0 (negative case)');
|
||||
assert.deepEqual(_.first([1, 2, 3], 2), [1, 2], 'can fetch the first n elements');
|
||||
assert.deepEqual(_.first([1, 2, 3], 5), [1, 2, 3], 'returns the whole array if n > length');
|
||||
var result = (function(){ return _.first(arguments); }(4, 3, 2, 1));
|
||||
equal(result, 4, 'works on an arguments object.');
|
||||
assert.equal(result, 4, 'works on an arguments object');
|
||||
result = _.map([[1, 2, 3], [1, 2, 3]], _.first);
|
||||
deepEqual(result, [1, 1], 'works well with _.map');
|
||||
result = (function() { return _.first([1, 2, 3], 2); }());
|
||||
deepEqual(result, [1, 2]);
|
||||
|
||||
equal(_.first(null), void 0, 'handles nulls');
|
||||
strictEqual(_.first([1, 2, 3], -1).length, 0);
|
||||
assert.deepEqual(result, [1, 1], 'works well with _.map');
|
||||
assert.equal(_.first(null), void 0, 'returns undefined when called on null');
|
||||
});
|
||||
|
||||
test('head', function() {
|
||||
strictEqual(_.first, _.head, 'alias for first');
|
||||
test('head', function(assert) {
|
||||
assert.strictEqual(_.head, _.first, 'is an alias for first');
|
||||
});
|
||||
|
||||
test('take', function() {
|
||||
strictEqual(_.first, _.take, 'alias for first');
|
||||
test('take', function(assert) {
|
||||
assert.strictEqual(_.take, _.first, 'is an alias for first');
|
||||
});
|
||||
|
||||
test('rest', function() {
|
||||
test('rest', function(assert) {
|
||||
var numbers = [1, 2, 3, 4];
|
||||
deepEqual(_.rest(numbers), [2, 3, 4], 'working rest()');
|
||||
deepEqual(_.rest(numbers, 0), [1, 2, 3, 4], 'working rest(0)');
|
||||
deepEqual(_.rest(numbers, 2), [3, 4], 'rest can take an index');
|
||||
assert.deepEqual(_.rest(numbers), [2, 3, 4], 'fetches all but the first element');
|
||||
assert.deepEqual(_.rest(numbers, 0), [1, 2, 3, 4], 'returns the whole array when index is 0');
|
||||
assert.deepEqual(_.rest(numbers, 2), [3, 4], 'returns elements starting at the given index');
|
||||
var result = (function(){ return _(arguments).rest(); }(1, 2, 3, 4));
|
||||
deepEqual(result, [2, 3, 4], 'works on arguments object');
|
||||
assert.deepEqual(result, [2, 3, 4], 'works on an arguments object');
|
||||
result = _.map([[1, 2, 3], [1, 2, 3]], _.rest);
|
||||
deepEqual(_.flatten(result), [2, 3, 2, 3], 'works well with _.map');
|
||||
result = (function(){ return _(arguments).rest(); }(1, 2, 3, 4));
|
||||
deepEqual(result, [2, 3, 4], 'works on arguments object');
|
||||
assert.deepEqual(_.flatten(result), [2, 3, 2, 3], 'works well with _.map');
|
||||
});
|
||||
|
||||
test('tail', function() {
|
||||
strictEqual(_.rest, _.tail, 'alias for rest');
|
||||
test('tail', function(assert) {
|
||||
assert.strictEqual(_.tail, _.rest, 'is an alias for rest');
|
||||
});
|
||||
|
||||
test('drop', function() {
|
||||
strictEqual(_.rest, _.drop, 'alias for rest');
|
||||
test('drop', function(assert) {
|
||||
assert.strictEqual(_.drop, _.rest, 'is an alias for rest');
|
||||
});
|
||||
|
||||
test('initial', function() {
|
||||
deepEqual(_.initial([1, 2, 3, 4, 5]), [1, 2, 3, 4], 'working initial()');
|
||||
deepEqual(_.initial([1, 2, 3, 4], 2), [1, 2], 'initial can take an index');
|
||||
deepEqual(_.initial([1, 2, 3, 4], 6), [], 'initial can take a large index');
|
||||
test('initial', function(assert) {
|
||||
assert.deepEqual(_.initial([1, 2, 3, 4, 5]), [1, 2, 3, 4], 'returns all but the last element');
|
||||
assert.deepEqual(_.initial([1, 2, 3, 4], 2), [1, 2], 'returns all but the last n elements');
|
||||
assert.deepEqual(_.initial([1, 2, 3, 4], 6), [], 'returns an empty array when n > length');
|
||||
var result = (function(){ return _(arguments).initial(); }(1, 2, 3, 4));
|
||||
deepEqual(result, [1, 2, 3], 'initial works on arguments object');
|
||||
assert.deepEqual(result, [1, 2, 3], 'works on an arguments object');
|
||||
result = _.map([[1, 2, 3], [1, 2, 3]], _.initial);
|
||||
deepEqual(_.flatten(result), [1, 2, 1, 2], 'initial works with _.map');
|
||||
assert.deepEqual(_.flatten(result), [1, 2, 1, 2], 'works well with _.map');
|
||||
});
|
||||
|
||||
test('last', function() {
|
||||
equal(_.last([1, 2, 3]), 3, 'can pull out the last element of an array');
|
||||
deepEqual(_.last([1, 2, 3], 0), [], 'can pass an index to last');
|
||||
deepEqual(_.last([1, 2, 3], 2), [2, 3], 'can pass an index to last');
|
||||
deepEqual(_.last([1, 2, 3], 5), [1, 2, 3], 'can pass an index to last');
|
||||
test('last', function(assert) {
|
||||
assert.equal(_.last([1, 2, 3]), 3, 'can pull out the last element of an array');
|
||||
assert.equal(_([1, 2, 3]).last(), 3, 'can perform OO-style "last()"');
|
||||
assert.deepEqual(_.last([1, 2, 3], 0), [], 'returns an empty array when n <= 0 (0 case)');
|
||||
assert.deepEqual(_.last([1, 2, 3], -1), [], 'returns an empty array when n <= 0 (negative case)');
|
||||
assert.deepEqual(_.last([1, 2, 3], 2), [2, 3], 'can fetch the last n elements');
|
||||
assert.deepEqual(_.last([1, 2, 3], 5), [1, 2, 3], 'returns the whole array if n > length');
|
||||
var result = (function(){ return _(arguments).last(); }(1, 2, 3, 4));
|
||||
equal(result, 4, 'works on an arguments object');
|
||||
assert.equal(result, 4, 'works on an arguments object');
|
||||
result = _.map([[1, 2, 3], [1, 2, 3]], _.last);
|
||||
deepEqual(result, [3, 3], 'works well with _.map');
|
||||
|
||||
equal(_.last(null), void 0, 'handles nulls');
|
||||
strictEqual(_.last([1, 2, 3], -1).length, 0);
|
||||
assert.deepEqual(result, [3, 3], 'works well with _.map');
|
||||
assert.equal(_.last(null), void 0, 'returns undefined when called on null');
|
||||
});
|
||||
|
||||
test('compact', function() {
|
||||
equal(_.compact([0, 1, false, 2, false, 3]).length, 3, 'can trim out all falsy values');
|
||||
var result = (function(){ return _.compact(arguments).length; }(0, 1, false, 2, false, 3));
|
||||
equal(result, 3, 'works on an arguments object');
|
||||
test('compact', function(assert) {
|
||||
assert.deepEqual(_.compact([1, false, null, 0, '', void 0, NaN, 2]), [1, 2], 'removes all falsy values');
|
||||
var result = (function(){ return _.compact(arguments); }(0, 1, false, 2, false, 3));
|
||||
assert.deepEqual(result, [1, 2, 3], 'works on an arguments object');
|
||||
result = _.map([[1, false, false], [false, false, 3]], _.compact);
|
||||
assert.deepEqual(result, [[1], [3]], 'works well with _.map');
|
||||
});
|
||||
|
||||
test('flatten', function() {
|
||||
deepEqual(_.flatten(null), [], 'Flattens supports null');
|
||||
deepEqual(_.flatten(void 0), [], 'Flattens supports undefined');
|
||||
test('flatten', function(assert) {
|
||||
assert.deepEqual(_.flatten(null), [], 'supports null');
|
||||
assert.deepEqual(_.flatten(void 0), [], 'supports undefined');
|
||||
|
||||
deepEqual(_.flatten([[], [[]], []]), [], 'Flattens empty arrays');
|
||||
deepEqual(_.flatten([[], [[]], []], true), [[]], 'Flattens empty arrays');
|
||||
assert.deepEqual(_.flatten([[], [[]], []]), [], 'supports empty arrays');
|
||||
assert.deepEqual(_.flatten([[], [[]], []], true), [[]], 'can shallowly flatten empty arrays');
|
||||
|
||||
var list = [1, [2], [3, [[[4]]]]];
|
||||
deepEqual(_.flatten(list), [1, 2, 3, 4], 'can flatten nested arrays');
|
||||
deepEqual(_.flatten(list, true), [1, 2, 3, [[[4]]]], 'can shallowly flatten nested arrays');
|
||||
assert.deepEqual(_.flatten(list), [1, 2, 3, 4], 'can flatten nested arrays');
|
||||
assert.deepEqual(_.flatten(list, true), [1, 2, 3, [[[4]]]], 'can shallowly flatten nested arrays');
|
||||
var result = (function(){ return _.flatten(arguments); }(1, [2], [3, [[[4]]]]));
|
||||
deepEqual(result, [1, 2, 3, 4], 'works on an arguments object');
|
||||
assert.deepEqual(result, [1, 2, 3, 4], 'works on an arguments object');
|
||||
list = [[1], [2], [3], [[4]]];
|
||||
deepEqual(_.flatten(list, true), [1, 2, 3, [4]], 'can shallowly flatten arrays containing only other arrays');
|
||||
assert.deepEqual(_.flatten(list, true), [1, 2, 3, [4]], 'can shallowly flatten arrays containing only other arrays');
|
||||
|
||||
equal(_.flatten([_.range(10), _.range(10), 5, 1, 3], true).length, 23);
|
||||
equal(_.flatten([_.range(10), _.range(10), 5, 1, 3]).length, 23);
|
||||
equal(_.flatten([new Array(1000000), _.range(56000), 5, 1, 3]).length, 1056003, 'Flatten can handle massive collections');
|
||||
equal(_.flatten([new Array(1000000), _.range(56000), 5, 1, 3], true).length, 1056003, 'Flatten can handle massive collections');
|
||||
assert.equal(_.flatten([_.range(10), _.range(10), 5, 1, 3], true).length, 23, 'can flatten medium length arrays');
|
||||
assert.equal(_.flatten([_.range(10), _.range(10), 5, 1, 3]).length, 23, 'can shallowly flatten medium length arrays');
|
||||
assert.equal(_.flatten([new Array(1000000), _.range(56000), 5, 1, 3]).length, 1056003, 'can handle massive arrays');
|
||||
assert.equal(_.flatten([new Array(1000000), _.range(56000), 5, 1, 3], true).length, 1056003, 'can handle massive arrays in shallow mode');
|
||||
|
||||
var x = _.range(100000);
|
||||
for (var i = 0; i < 1000; i++) x = [x];
|
||||
deepEqual(_.flatten(x), _.range(100000), 'Flatten can handle very deep arrays');
|
||||
deepEqual(_.flatten(x, true), x[0], 'Flatten can handle very deep arrays with shallow');
|
||||
assert.deepEqual(_.flatten(x), _.range(100000), 'can handle very deep arrays');
|
||||
assert.deepEqual(_.flatten(x, true), x[0], 'can handle very deep arrays in shallow mode');
|
||||
});
|
||||
|
||||
test('without', function() {
|
||||
test('without', function(assert) {
|
||||
var list = [1, 2, 1, 0, 3, 1, 4];
|
||||
deepEqual(_.without(list, 0, 1), [2, 3, 4], 'can remove all instances of an object');
|
||||
assert.deepEqual(_.without(list, 0, 1), [2, 3, 4], 'removes all instances of the given values');
|
||||
var result = (function(){ return _.without(arguments, 0, 1); }(1, 2, 1, 0, 3, 1, 4));
|
||||
deepEqual(result, [2, 3, 4], 'works on an arguments object');
|
||||
assert.deepEqual(result, [2, 3, 4], 'works on an arguments object');
|
||||
|
||||
list = [{one: 1}, {two: 2}];
|
||||
equal(_.without(list, {one: 1}).length, 2, 'uses real object identity for comparisons.');
|
||||
equal(_.without(list, list[0]).length, 1, 'ditto.');
|
||||
assert.deepEqual(_.without(list, {one: 1}), list, 'compares objects by reference (value case)');
|
||||
assert.deepEqual(_.without(list, list[0]), [{two: 2}], 'compares objects by reference (reference case)');
|
||||
});
|
||||
|
||||
test('sortedIndex', function() {
|
||||
var numbers = [10, 20, 30, 40, 50], num = 35;
|
||||
var indexForNum = _.sortedIndex(numbers, num);
|
||||
equal(indexForNum, 3, '35 should be inserted at index 3');
|
||||
|
||||
test('sortedIndex', function(assert) {
|
||||
var numbers = [10, 20, 30, 40, 50];
|
||||
var indexFor35 = _.sortedIndex(numbers, 35);
|
||||
assert.equal(indexFor35, 3, 'finds the index at which a value should be inserted to retain order');
|
||||
var indexFor30 = _.sortedIndex(numbers, 30);
|
||||
equal(indexFor30, 2, '30 should be inserted at index 2');
|
||||
assert.equal(indexFor30, 2, 'finds the smallest index at which a value could be inserted to retain order');
|
||||
|
||||
var objects = [{x: 10}, {x: 20}, {x: 30}, {x: 40}];
|
||||
var iterator = function(obj){ return obj.x; };
|
||||
strictEqual(_.sortedIndex(objects, {x: 25}, iterator), 2);
|
||||
strictEqual(_.sortedIndex(objects, {x: 35}, 'x'), 3);
|
||||
assert.strictEqual(_.sortedIndex(objects, {x: 25}, iterator), 2, 'uses the result of `iterator` for order comparisons');
|
||||
assert.strictEqual(_.sortedIndex(objects, {x: 35}, 'x'), 3, 'when `iterator` is a string, uses that key for order comparisons');
|
||||
|
||||
var context = {1: 2, 2: 3, 3: 4};
|
||||
iterator = function(obj){ return this[obj]; };
|
||||
strictEqual(_.sortedIndex([1, 3], 2, iterator, context), 1);
|
||||
assert.strictEqual(_.sortedIndex([1, 3], 2, iterator, context), 1, 'can execute its iterator in the given context');
|
||||
|
||||
var values = [0, 1, 3, 7, 15, 31, 63, 127, 255, 511, 1023, 2047, 4095, 8191, 16383, 32767, 65535, 131071, 262143, 524287, 1048575, 2097151, 4194303, 8388607, 16777215, 33554431, 67108863, 134217727, 268435455, 536870911, 1073741823, 2147483647];
|
||||
var array = Array(Math.pow(2, 32) - 1);
|
||||
var values = [0, 1, 3, 7, 15, 31, 63, 127, 255, 511, 1023, 2047, 4095, 8191, 16383, 32767, 65535, 131071, 262143, 524287,
|
||||
1048575, 2097151, 4194303, 8388607, 16777215, 33554431, 67108863, 134217727, 268435455, 536870911, 1073741823, 2147483647];
|
||||
var largeArray = Array(Math.pow(2, 32) - 1);
|
||||
var length = values.length;
|
||||
// Sparsely populate `array`
|
||||
while (length--) {
|
||||
array[values[length]] = values[length];
|
||||
largeArray[values[length]] = values[length];
|
||||
}
|
||||
equal(_.sortedIndex(array, 2147483648), 2147483648, 'should work with large indexes');
|
||||
assert.equal(_.sortedIndex(largeArray, 2147483648), 2147483648, 'works with large indexes');
|
||||
});
|
||||
|
||||
test('uniq', function() {
|
||||
test('uniq', function(assert) {
|
||||
var list = [1, 2, 1, 3, 1, 4];
|
||||
deepEqual(_.uniq(list), [1, 2, 3, 4], 'can find the unique values of an unsorted array');
|
||||
assert.deepEqual(_.uniq(list), [1, 2, 3, 4], 'can find the unique values of an unsorted array');
|
||||
|
||||
list = [1, 1, 1, 2, 2, 3];
|
||||
deepEqual(_.uniq(list, true), [1, 2, 3], 'can find the unique values of a sorted array faster');
|
||||
assert.deepEqual(_.uniq(list, true), [1, 2, 3], 'can find the unique values of a sorted array faster');
|
||||
|
||||
list = [{name: 'moe'}, {name: 'curly'}, {name: 'larry'}, {name: 'curly'}];
|
||||
var iterator = function(value) { return value.name; };
|
||||
deepEqual(_.map(_.uniq(list, false, iterator), iterator), ['moe', 'curly', 'larry'], 'can find the unique values of an array using a custom iterator');
|
||||
assert.deepEqual(_.map(_.uniq(list, false, iterator), iterator), ['moe', 'curly', 'larry'], 'can find the unique values of an array using a custom iterator');
|
||||
|
||||
deepEqual(_.map(_.uniq(list, iterator), iterator), ['moe', 'curly', 'larry'], 'can find the unique values of an array using a custom iterator without specifying whether array is sorted');
|
||||
assert.deepEqual(_.map(_.uniq(list, iterator), iterator), ['moe', 'curly', 'larry'], 'can find the unique values of an array using a custom iterator without specifying whether array is sorted');
|
||||
|
||||
iterator = function(value) { return value + 1; };
|
||||
list = [1, 2, 2, 3, 4, 4];
|
||||
deepEqual(_.uniq(list, true, iterator), [1, 2, 3, 4], 'iterator works with sorted array');
|
||||
assert.deepEqual(_.uniq(list, true, iterator), [1, 2, 3, 4], 'iterator works with sorted array');
|
||||
|
||||
var kittens = [
|
||||
{kitten: 'Celery', cuteness: 8},
|
||||
@@ -170,236 +168,236 @@
|
||||
{kitten: 'Juniper', cuteness: 10}
|
||||
];
|
||||
|
||||
deepEqual(_.uniq(kittens, true, 'cuteness'), expected, 'string iterator works with sorted array');
|
||||
assert.deepEqual(_.uniq(kittens, true, 'cuteness'), expected, 'string iterator works with sorted array');
|
||||
|
||||
|
||||
var result = (function(){ return _.uniq(arguments); }(1, 2, 1, 3, 1, 4));
|
||||
deepEqual(result, [1, 2, 3, 4], 'works on an arguments object');
|
||||
assert.deepEqual(result, [1, 2, 3, 4], 'works on an arguments object');
|
||||
|
||||
var a = {}, b = {}, c = {};
|
||||
deepEqual(_.uniq([a, b, a, b, c]), [a, b, c], 'works on values that can be tested for equivalency but not ordered');
|
||||
assert.deepEqual(_.uniq([a, b, a, b, c]), [a, b, c], 'works on values that can be tested for equivalency but not ordered');
|
||||
|
||||
deepEqual(_.uniq(null), []);
|
||||
assert.deepEqual(_.uniq(null), []);
|
||||
|
||||
var context = {};
|
||||
list = [3];
|
||||
_.uniq(list, function(value, index, array) {
|
||||
strictEqual(this, context);
|
||||
strictEqual(value, 3);
|
||||
strictEqual(index, 0);
|
||||
strictEqual(array, list);
|
||||
assert.strictEqual(this, context);
|
||||
assert.strictEqual(value, 3);
|
||||
assert.strictEqual(index, 0);
|
||||
assert.strictEqual(array, list);
|
||||
}, context);
|
||||
|
||||
deepEqual(_.uniq([{a: 1, b: 1}, {a: 1, b: 2}, {a: 1, b: 3}, {a: 2, b: 1}], 'a'), [{a: 1, b: 1}, {a: 2, b: 1}], 'can use pluck like iterator');
|
||||
deepEqual(_.uniq([{0: 1, b: 1}, {0: 1, b: 2}, {0: 1, b: 3}, {0: 2, b: 1}], 0), [{0: 1, b: 1}, {0: 2, b: 1}], 'can use falsey pluck like iterator');
|
||||
assert.deepEqual(_.uniq([{a: 1, b: 1}, {a: 1, b: 2}, {a: 1, b: 3}, {a: 2, b: 1}], 'a'), [{a: 1, b: 1}, {a: 2, b: 1}], 'can use pluck like iterator');
|
||||
assert.deepEqual(_.uniq([{0: 1, b: 1}, {0: 1, b: 2}, {0: 1, b: 3}, {0: 2, b: 1}], 0), [{0: 1, b: 1}, {0: 2, b: 1}], 'can use falsey pluck like iterator');
|
||||
});
|
||||
|
||||
test('unique', function() {
|
||||
strictEqual(_.uniq, _.unique, 'alias for uniq');
|
||||
test('unique', function(assert) {
|
||||
assert.strictEqual(_.unique, _.uniq, 'is an alias for uniq');
|
||||
});
|
||||
|
||||
test('intersection', function() {
|
||||
test('intersection', function(assert) {
|
||||
var stooges = ['moe', 'curly', 'larry'], leaders = ['moe', 'groucho'];
|
||||
deepEqual(_.intersection(stooges, leaders), ['moe'], 'can take the set intersection of two arrays');
|
||||
deepEqual(_(stooges).intersection(leaders), ['moe'], 'can perform an OO-style intersection');
|
||||
assert.deepEqual(_.intersection(stooges, leaders), ['moe'], 'can take the set intersection of two arrays');
|
||||
assert.deepEqual(_(stooges).intersection(leaders), ['moe'], 'can perform an OO-style intersection');
|
||||
var result = (function(){ return _.intersection(arguments, leaders); }('moe', 'curly', 'larry'));
|
||||
deepEqual(result, ['moe'], 'works on an arguments object');
|
||||
assert.deepEqual(result, ['moe'], 'works on an arguments object');
|
||||
var theSixStooges = ['moe', 'moe', 'curly', 'curly', 'larry', 'larry'];
|
||||
deepEqual(_.intersection(theSixStooges, leaders), ['moe'], 'returns a duplicate-free array');
|
||||
assert.deepEqual(_.intersection(theSixStooges, leaders), ['moe'], 'returns a duplicate-free array');
|
||||
result = _.intersection([2, 4, 3, 1], [1, 2, 3]);
|
||||
deepEqual(result, [2, 3, 1], 'preserves order of first array');
|
||||
assert.deepEqual(result, [2, 3, 1], 'preserves order of first array');
|
||||
result = _.intersection(null, [1, 2, 3]);
|
||||
equal(Object.prototype.toString.call(result), '[object Array]', 'returns an empty array when passed null as first argument');
|
||||
equal(result.length, 0, 'returns an empty array when passed null as first argument');
|
||||
assert.equal(Object.prototype.toString.call(result), '[object Array]', 'returns an empty array when passed null as first argument');
|
||||
assert.equal(result.length, 0, 'returns an empty array when passed null as first argument');
|
||||
result = _.intersection([1, 2, 3], null);
|
||||
equal(Object.prototype.toString.call(result), '[object Array]', 'returns an empty array when passed null as argument beyond the first');
|
||||
equal(result.length, 0, 'returns an empty array when passed null as argument beyond the first');
|
||||
assert.equal(Object.prototype.toString.call(result), '[object Array]', 'returns an empty array when passed null as argument beyond the first');
|
||||
assert.equal(result.length, 0, 'returns an empty array when passed null as argument beyond the first');
|
||||
});
|
||||
|
||||
test('union', function() {
|
||||
test('union', function(assert) {
|
||||
var result = _.union([1, 2, 3], [2, 30, 1], [1, 40]);
|
||||
deepEqual(result, [1, 2, 3, 30, 40], 'takes the union of a list of arrays');
|
||||
assert.deepEqual(result, [1, 2, 3, 30, 40], 'takes the union of a list of arrays');
|
||||
|
||||
result = _.union([1, 2, 3], [2, 30, 1], [1, 40, [1]]);
|
||||
deepEqual(result, [1, 2, 3, 30, 40, [1]], 'takes the union of a list of nested arrays');
|
||||
assert.deepEqual(result, [1, 2, 3, 30, 40, [1]], 'takes the union of a list of nested arrays');
|
||||
|
||||
var args = null;
|
||||
(function(){ args = arguments; }(1, 2, 3));
|
||||
result = _.union(args, [2, 30, 1], [1, 40]);
|
||||
deepEqual(result, [1, 2, 3, 30, 40], 'takes the union of a list of arrays');
|
||||
assert.deepEqual(result, [1, 2, 3, 30, 40], 'takes the union of a list of arrays');
|
||||
|
||||
result = _.union([1, 2, 3], 4);
|
||||
deepEqual(result, [1, 2, 3], 'restrict the union to arrays only');
|
||||
assert.deepEqual(result, [1, 2, 3], 'restrict the union to arrays only');
|
||||
});
|
||||
|
||||
test('difference', function() {
|
||||
test('difference', function(assert) {
|
||||
var result = _.difference([1, 2, 3], [2, 30, 40]);
|
||||
deepEqual(result, [1, 3], 'takes the difference of two arrays');
|
||||
assert.deepEqual(result, [1, 3], 'takes the difference of two arrays');
|
||||
|
||||
result = _.difference([1, 2, 3, 4], [2, 30, 40], [1, 11, 111]);
|
||||
deepEqual(result, [3, 4], 'takes the difference of three arrays');
|
||||
assert.deepEqual(result, [3, 4], 'takes the difference of three arrays');
|
||||
|
||||
result = _.difference([1, 2, 3], 1);
|
||||
deepEqual(result, [1, 2, 3], 'restrict the difference to arrays only');
|
||||
assert.deepEqual(result, [1, 2, 3], 'restrict the difference to arrays only');
|
||||
});
|
||||
|
||||
test('zip', function() {
|
||||
test('zip', function(assert) {
|
||||
var names = ['moe', 'larry', 'curly'], ages = [30, 40, 50], leaders = [true];
|
||||
deepEqual(_.zip(names, ages, leaders), [
|
||||
assert.deepEqual(_.zip(names, ages, leaders), [
|
||||
['moe', 30, true],
|
||||
['larry', 40, void 0],
|
||||
['curly', 50, void 0]
|
||||
], 'zipped together arrays of different lengths');
|
||||
|
||||
var stooges = _.zip(['moe', 30, 'stooge 1'], ['larry', 40, 'stooge 2'], ['curly', 50, 'stooge 3']);
|
||||
deepEqual(stooges, [['moe', 'larry', 'curly'], [30, 40, 50], ['stooge 1', 'stooge 2', 'stooge 3']], 'zipped pairs');
|
||||
assert.deepEqual(stooges, [['moe', 'larry', 'curly'], [30, 40, 50], ['stooge 1', 'stooge 2', 'stooge 3']], 'zipped pairs');
|
||||
|
||||
// In the case of difference lengths of the tuples undefineds
|
||||
// In the case of different lengths of the tuples, undefined values
|
||||
// should be used as placeholder
|
||||
stooges = _.zip(['moe', 30], ['larry', 40], ['curly', 50, 'extra data']);
|
||||
deepEqual(stooges, [['moe', 'larry', 'curly'], [30, 40, 50], [void 0, void 0, 'extra data']], 'zipped pairs with empties');
|
||||
assert.deepEqual(stooges, [['moe', 'larry', 'curly'], [30, 40, 50], [void 0, void 0, 'extra data']], 'zipped pairs with empties');
|
||||
|
||||
var empty = _.zip([]);
|
||||
deepEqual(empty, [], 'unzipped empty');
|
||||
assert.deepEqual(empty, [], 'unzipped empty');
|
||||
|
||||
deepEqual(_.zip(null), [], 'handles null');
|
||||
deepEqual(_.zip(), [], '_.zip() returns []');
|
||||
assert.deepEqual(_.zip(null), [], 'handles null');
|
||||
assert.deepEqual(_.zip(), [], '_.zip() returns []');
|
||||
});
|
||||
|
||||
test('unzip', function() {
|
||||
deepEqual(_.unzip(null), [], 'handles null');
|
||||
test('unzip', function(assert) {
|
||||
assert.deepEqual(_.unzip(null), [], 'handles null');
|
||||
|
||||
deepEqual(_.unzip([['a', 'b'], [1, 2]]), [['a', 1], ['b', 2]]);
|
||||
assert.deepEqual(_.unzip([['a', 'b'], [1, 2]]), [['a', 1], ['b', 2]]);
|
||||
|
||||
// complements zip
|
||||
var zipped = _.zip(['fred', 'barney'], [30, 40], [true, false]);
|
||||
deepEqual(_.unzip(zipped), [['fred', 'barney'], [30, 40], [true, false]]);
|
||||
assert.deepEqual(_.unzip(zipped), [['fred', 'barney'], [30, 40], [true, false]]);
|
||||
|
||||
zipped = _.zip(['moe', 30], ['larry', 40], ['curly', 50, 'extra data']);
|
||||
deepEqual(_.unzip(zipped), [['moe', 30, void 0], ['larry', 40, void 0], ['curly', 50, 'extra data']], 'Uses length of largest array');
|
||||
assert.deepEqual(_.unzip(zipped), [['moe', 30, void 0], ['larry', 40, void 0], ['curly', 50, 'extra data']], 'Uses length of largest array');
|
||||
});
|
||||
|
||||
test('object', function() {
|
||||
test('object', function(assert) {
|
||||
var result = _.object(['moe', 'larry', 'curly'], [30, 40, 50]);
|
||||
var shouldBe = {moe: 30, larry: 40, curly: 50};
|
||||
deepEqual(result, shouldBe, 'two arrays zipped together into an object');
|
||||
assert.deepEqual(result, shouldBe, 'two arrays zipped together into an object');
|
||||
|
||||
result = _.object([['one', 1], ['two', 2], ['three', 3]]);
|
||||
shouldBe = {one: 1, two: 2, three: 3};
|
||||
deepEqual(result, shouldBe, 'an array of pairs zipped together into an object');
|
||||
assert.deepEqual(result, shouldBe, 'an array of pairs zipped together into an object');
|
||||
|
||||
var stooges = {moe: 30, larry: 40, curly: 50};
|
||||
deepEqual(_.object(_.pairs(stooges)), stooges, 'an object converted to pairs and back to an object');
|
||||
assert.deepEqual(_.object(_.pairs(stooges)), stooges, 'an object converted to pairs and back to an object');
|
||||
|
||||
deepEqual(_.object(null), {}, 'handles nulls');
|
||||
assert.deepEqual(_.object(null), {}, 'handles nulls');
|
||||
});
|
||||
|
||||
test('indexOf', function() {
|
||||
test('indexOf', function(assert) {
|
||||
var numbers = [1, 2, 3];
|
||||
equal(_.indexOf(numbers, 2), 1, 'can compute indexOf');
|
||||
assert.equal(_.indexOf(numbers, 2), 1, 'can compute indexOf');
|
||||
var result = (function(){ return _.indexOf(arguments, 2); }(1, 2, 3));
|
||||
equal(result, 1, 'works on an arguments object');
|
||||
assert.equal(result, 1, 'works on an arguments object');
|
||||
|
||||
_.each([null, void 0, [], false], function(val) {
|
||||
var msg = 'Handles: ' + (_.isArray(val) ? '[]' : val);
|
||||
equal(_.indexOf(val, 2), -1, msg);
|
||||
equal(_.indexOf(val, 2, -1), -1, msg);
|
||||
equal(_.indexOf(val, 2, -20), -1, msg);
|
||||
equal(_.indexOf(val, 2, 15), -1, msg);
|
||||
assert.equal(_.indexOf(val, 2), -1, msg);
|
||||
assert.equal(_.indexOf(val, 2, -1), -1, msg);
|
||||
assert.equal(_.indexOf(val, 2, -20), -1, msg);
|
||||
assert.equal(_.indexOf(val, 2, 15), -1, msg);
|
||||
});
|
||||
|
||||
var num = 35;
|
||||
numbers = [10, 20, 30, 40, 50];
|
||||
var index = _.indexOf(numbers, num, true);
|
||||
equal(index, -1, '35 is not in the list');
|
||||
assert.equal(index, -1, '35 is not in the list');
|
||||
|
||||
numbers = [10, 20, 30, 40, 50]; num = 40;
|
||||
index = _.indexOf(numbers, num, true);
|
||||
equal(index, 3, '40 is in the list');
|
||||
assert.equal(index, 3, '40 is in the list');
|
||||
|
||||
numbers = [1, 40, 40, 40, 40, 40, 40, 40, 50, 60, 70]; num = 40;
|
||||
equal(_.indexOf(numbers, num, true), 1, '40 is in the list');
|
||||
equal(_.indexOf(numbers, 6, true), -1, '6 isnt in the list');
|
||||
equal(_.indexOf([1, 2, 5, 4, 6, 7], 5, true), -1, 'sorted indexOf doesn\'t uses binary search');
|
||||
ok(_.every(['1', [], {}, null], function() {
|
||||
assert.equal(_.indexOf(numbers, num, true), 1, '40 is in the list');
|
||||
assert.equal(_.indexOf(numbers, 6, true), -1, '6 isnt in the list');
|
||||
assert.equal(_.indexOf([1, 2, 5, 4, 6, 7], 5, true), -1, 'sorted indexOf doesn\'t uses binary search');
|
||||
assert.ok(_.every(['1', [], {}, null], function() {
|
||||
return _.indexOf(numbers, num, {}) === 1;
|
||||
}), 'non-nums as fromIndex make indexOf assume sorted');
|
||||
|
||||
numbers = [1, 2, 3, 1, 2, 3, 1, 2, 3];
|
||||
index = _.indexOf(numbers, 2, 5);
|
||||
equal(index, 7, 'supports the fromIndex argument');
|
||||
assert.equal(index, 7, 'supports the fromIndex argument');
|
||||
|
||||
index = _.indexOf([,,, 0], void 0);
|
||||
equal(index, 0, 'treats sparse arrays as if they were dense');
|
||||
assert.equal(index, 0, 'treats sparse arrays as if they were dense');
|
||||
|
||||
var array = [1, 2, 3, 1, 2, 3];
|
||||
strictEqual(_.indexOf(array, 1, -3), 3, 'neg `fromIndex` starts at the right index');
|
||||
strictEqual(_.indexOf(array, 1, -2), -1, 'neg `fromIndex` starts at the right index');
|
||||
strictEqual(_.indexOf(array, 2, -3), 4);
|
||||
assert.strictEqual(_.indexOf(array, 1, -3), 3, 'neg `fromIndex` starts at the right index');
|
||||
assert.strictEqual(_.indexOf(array, 1, -2), -1, 'neg `fromIndex` starts at the right index');
|
||||
assert.strictEqual(_.indexOf(array, 2, -3), 4);
|
||||
_.each([-6, -8, -Infinity], function(fromIndex) {
|
||||
strictEqual(_.indexOf(array, 1, fromIndex), 0);
|
||||
assert.strictEqual(_.indexOf(array, 1, fromIndex), 0);
|
||||
});
|
||||
strictEqual(_.indexOf([1, 2, 3], 1, true), 0);
|
||||
assert.strictEqual(_.indexOf([1, 2, 3], 1, true), 0);
|
||||
|
||||
index = _.indexOf([], void 0, true);
|
||||
equal(index, -1, 'empty array with truthy `isSorted` returns -1');
|
||||
assert.equal(index, -1, 'empty array with truthy `isSorted` returns -1');
|
||||
});
|
||||
|
||||
test('indexOf with NaN', function() {
|
||||
strictEqual(_.indexOf([1, 2, NaN, NaN], NaN), 2, 'Expected [1, 2, NaN] to contain NaN');
|
||||
strictEqual(_.indexOf([1, 2, Infinity], NaN), -1, 'Expected [1, 2, NaN] to contain NaN');
|
||||
test('indexOf with NaN', function(assert) {
|
||||
assert.strictEqual(_.indexOf([1, 2, NaN, NaN], NaN), 2, 'Expected [1, 2, NaN] to contain NaN');
|
||||
assert.strictEqual(_.indexOf([1, 2, Infinity], NaN), -1, 'Expected [1, 2, NaN] to contain NaN');
|
||||
|
||||
strictEqual(_.indexOf([1, 2, NaN, NaN], NaN, 1), 2, 'startIndex does not affect result');
|
||||
strictEqual(_.indexOf([1, 2, NaN, NaN], NaN, -2), 2, 'startIndex does not affect result');
|
||||
assert.strictEqual(_.indexOf([1, 2, NaN, NaN], NaN, 1), 2, 'startIndex does not affect result');
|
||||
assert.strictEqual(_.indexOf([1, 2, NaN, NaN], NaN, -2), 2, 'startIndex does not affect result');
|
||||
|
||||
(function() {
|
||||
strictEqual(_.indexOf(arguments, NaN), 2, 'Expected arguments [1, 2, NaN] to contain NaN');
|
||||
assert.strictEqual(_.indexOf(arguments, NaN), 2, 'Expected arguments [1, 2, NaN] to contain NaN');
|
||||
}(1, 2, NaN, NaN));
|
||||
});
|
||||
|
||||
test('indexOf with +- 0', function() {
|
||||
test('indexOf with +- 0', function(assert) {
|
||||
_.each([-0, +0], function(val) {
|
||||
strictEqual(_.indexOf([1, 2, val, val], val), 2);
|
||||
strictEqual(_.indexOf([1, 2, val, val], -val), 2);
|
||||
assert.strictEqual(_.indexOf([1, 2, val, val], val), 2);
|
||||
assert.strictEqual(_.indexOf([1, 2, val, val], -val), 2);
|
||||
});
|
||||
});
|
||||
|
||||
test('lastIndexOf', function() {
|
||||
test('lastIndexOf', function(assert) {
|
||||
var numbers = [1, 0, 1];
|
||||
var falsey = [void 0, '', 0, false, NaN, null, void 0];
|
||||
equal(_.lastIndexOf(numbers, 1), 2);
|
||||
assert.equal(_.lastIndexOf(numbers, 1), 2);
|
||||
|
||||
numbers = [1, 0, 1, 0, 0, 1, 0, 0, 0];
|
||||
numbers.lastIndexOf = null;
|
||||
equal(_.lastIndexOf(numbers, 1), 5, 'can compute lastIndexOf, even without the native function');
|
||||
equal(_.lastIndexOf(numbers, 0), 8, 'lastIndexOf the other element');
|
||||
assert.equal(_.lastIndexOf(numbers, 1), 5, 'can compute lastIndexOf, even without the native function');
|
||||
assert.equal(_.lastIndexOf(numbers, 0), 8, 'lastIndexOf the other element');
|
||||
var result = (function(){ return _.lastIndexOf(arguments, 1); }(1, 0, 1, 0, 0, 1, 0, 0, 0));
|
||||
equal(result, 5, 'works on an arguments object');
|
||||
assert.equal(result, 5, 'works on an arguments object');
|
||||
|
||||
_.each([null, void 0, [], false], function(val) {
|
||||
var msg = 'Handles: ' + (_.isArray(val) ? '[]' : val);
|
||||
equal(_.lastIndexOf(val, 2), -1, msg);
|
||||
equal(_.lastIndexOf(val, 2, -1), -1, msg);
|
||||
equal(_.lastIndexOf(val, 2, -20), -1, msg);
|
||||
equal(_.lastIndexOf(val, 2, 15), -1, msg);
|
||||
assert.equal(_.lastIndexOf(val, 2), -1, msg);
|
||||
assert.equal(_.lastIndexOf(val, 2, -1), -1, msg);
|
||||
assert.equal(_.lastIndexOf(val, 2, -20), -1, msg);
|
||||
assert.equal(_.lastIndexOf(val, 2, 15), -1, msg);
|
||||
});
|
||||
|
||||
numbers = [1, 2, 3, 1, 2, 3, 1, 2, 3];
|
||||
var index = _.lastIndexOf(numbers, 2, 2);
|
||||
equal(index, 1, 'supports the fromIndex argument');
|
||||
assert.equal(index, 1, 'supports the fromIndex argument');
|
||||
|
||||
var array = [1, 2, 3, 1, 2, 3];
|
||||
|
||||
strictEqual(_.lastIndexOf(array, 1, 0), 0, 'starts at the correct from idx');
|
||||
strictEqual(_.lastIndexOf(array, 3), 5, 'should return the index of the last matched value');
|
||||
strictEqual(_.lastIndexOf(array, 4), -1, 'should return `-1` for an unmatched value');
|
||||
assert.strictEqual(_.lastIndexOf(array, 1, 0), 0, 'starts at the correct from idx');
|
||||
assert.strictEqual(_.lastIndexOf(array, 3), 5, 'should return the index of the last matched value');
|
||||
assert.strictEqual(_.lastIndexOf(array, 4), -1, 'should return `-1` for an unmatched value');
|
||||
|
||||
strictEqual(_.lastIndexOf(array, 1, 2), 0, 'should work with a positive `fromIndex`');
|
||||
assert.strictEqual(_.lastIndexOf(array, 1, 2), 0, 'should work with a positive `fromIndex`');
|
||||
|
||||
_.each([6, 8, Math.pow(2, 32), Infinity], function(fromIndex) {
|
||||
strictEqual(_.lastIndexOf(array, void 0, fromIndex), -1);
|
||||
strictEqual(_.lastIndexOf(array, 1, fromIndex), 3);
|
||||
strictEqual(_.lastIndexOf(array, '', fromIndex), -1);
|
||||
assert.strictEqual(_.lastIndexOf(array, void 0, fromIndex), -1);
|
||||
assert.strictEqual(_.lastIndexOf(array, 1, fromIndex), 3);
|
||||
assert.strictEqual(_.lastIndexOf(array, '', fromIndex), -1);
|
||||
});
|
||||
|
||||
var expected = _.map(falsey, function(value) {
|
||||
@@ -410,39 +408,39 @@
|
||||
return _.lastIndexOf(array, 3, fromIndex);
|
||||
});
|
||||
|
||||
deepEqual(actual, expected, 'should treat falsey `fromIndex` values, except `0` and `NaN`, as `array.length`');
|
||||
strictEqual(_.lastIndexOf(array, 3, '1'), 5, 'should treat non-number `fromIndex` values as `array.length`');
|
||||
strictEqual(_.lastIndexOf(array, 3, true), 5, 'should treat non-number `fromIndex` values as `array.length`');
|
||||
assert.deepEqual(actual, expected, 'should treat falsey `fromIndex` values, except `0` and `NaN`, as `array.length`');
|
||||
assert.strictEqual(_.lastIndexOf(array, 3, '1'), 5, 'should treat non-number `fromIndex` values as `array.length`');
|
||||
assert.strictEqual(_.lastIndexOf(array, 3, true), 5, 'should treat non-number `fromIndex` values as `array.length`');
|
||||
|
||||
strictEqual(_.lastIndexOf(array, 2, -3), 1, 'should work with a negative `fromIndex`');
|
||||
strictEqual(_.lastIndexOf(array, 1, -3), 3, 'neg `fromIndex` starts at the right index');
|
||||
assert.strictEqual(_.lastIndexOf(array, 2, -3), 1, 'should work with a negative `fromIndex`');
|
||||
assert.strictEqual(_.lastIndexOf(array, 1, -3), 3, 'neg `fromIndex` starts at the right index');
|
||||
|
||||
deepEqual(_.map([-6, -8, -Infinity], function(fromIndex) {
|
||||
assert.deepEqual(_.map([-6, -8, -Infinity], function(fromIndex) {
|
||||
return _.lastIndexOf(array, 1, fromIndex);
|
||||
}), [0, -1, -1]);
|
||||
});
|
||||
|
||||
test('lastIndexOf with NaN', function() {
|
||||
strictEqual(_.lastIndexOf([1, 2, NaN, NaN], NaN), 3, 'Expected [1, 2, NaN] to contain NaN');
|
||||
strictEqual(_.lastIndexOf([1, 2, Infinity], NaN), -1, 'Expected [1, 2, NaN] to contain NaN');
|
||||
test('lastIndexOf with NaN', function(assert) {
|
||||
assert.strictEqual(_.lastIndexOf([1, 2, NaN, NaN], NaN), 3, 'Expected [1, 2, NaN] to contain NaN');
|
||||
assert.strictEqual(_.lastIndexOf([1, 2, Infinity], NaN), -1, 'Expected [1, 2, NaN] to contain NaN');
|
||||
|
||||
strictEqual(_.lastIndexOf([1, 2, NaN, NaN], NaN, 2), 2, 'fromIndex does not affect result');
|
||||
strictEqual(_.lastIndexOf([1, 2, NaN, NaN], NaN, -2), 2, 'fromIndex does not affect result');
|
||||
assert.strictEqual(_.lastIndexOf([1, 2, NaN, NaN], NaN, 2), 2, 'fromIndex does not affect result');
|
||||
assert.strictEqual(_.lastIndexOf([1, 2, NaN, NaN], NaN, -2), 2, 'fromIndex does not affect result');
|
||||
|
||||
(function() {
|
||||
strictEqual(_.lastIndexOf(arguments, NaN), 3, 'Expected arguments [1, 2, NaN] to contain NaN');
|
||||
assert.strictEqual(_.lastIndexOf(arguments, NaN), 3, 'Expected arguments [1, 2, NaN] to contain NaN');
|
||||
}(1, 2, NaN, NaN));
|
||||
});
|
||||
|
||||
test('lastIndexOf with +- 0', function() {
|
||||
test('lastIndexOf with +- 0', function(assert) {
|
||||
_.each([-0, +0], function(val) {
|
||||
strictEqual(_.lastIndexOf([1, 2, val, val], val), 3);
|
||||
strictEqual(_.lastIndexOf([1, 2, val, val], -val), 3);
|
||||
strictEqual(_.lastIndexOf([-1, 1, 2], -val), -1);
|
||||
assert.strictEqual(_.lastIndexOf([1, 2, val, val], val), 3);
|
||||
assert.strictEqual(_.lastIndexOf([1, 2, val, val], -val), 3);
|
||||
assert.strictEqual(_.lastIndexOf([-1, 1, 2], -val), -1);
|
||||
});
|
||||
});
|
||||
|
||||
test('findIndex', function() {
|
||||
test('findIndex', function(assert) {
|
||||
var objects = [
|
||||
{a: 0, b: 0},
|
||||
{a: 1, b: 1},
|
||||
@@ -450,42 +448,42 @@
|
||||
{a: 0, b: 0}
|
||||
];
|
||||
|
||||
equal(_.findIndex(objects, function(obj) {
|
||||
assert.equal(_.findIndex(objects, function(obj) {
|
||||
return obj.a === 0;
|
||||
}), 0);
|
||||
|
||||
equal(_.findIndex(objects, function(obj) {
|
||||
assert.equal(_.findIndex(objects, function(obj) {
|
||||
return obj.b * obj.a === 4;
|
||||
}), 2);
|
||||
|
||||
equal(_.findIndex(objects, 'a'), 1, 'Uses lookupIterator');
|
||||
assert.equal(_.findIndex(objects, 'a'), 1, 'Uses lookupIterator');
|
||||
|
||||
equal(_.findIndex(objects, function(obj) {
|
||||
assert.equal(_.findIndex(objects, function(obj) {
|
||||
return obj.b * obj.a === 5;
|
||||
}), -1);
|
||||
|
||||
equal(_.findIndex(null, _.noop), -1);
|
||||
strictEqual(_.findIndex(objects, function(a) {
|
||||
assert.equal(_.findIndex(null, _.noop), -1);
|
||||
assert.strictEqual(_.findIndex(objects, function(a) {
|
||||
return a.foo === null;
|
||||
}), -1);
|
||||
_.findIndex([{a: 1}], function(a, key, obj) {
|
||||
equal(key, 0);
|
||||
deepEqual(obj, [{a: 1}]);
|
||||
strictEqual(this, objects, 'called with context');
|
||||
assert.equal(key, 0);
|
||||
assert.deepEqual(obj, [{a: 1}]);
|
||||
assert.strictEqual(this, objects, 'called with context');
|
||||
}, objects);
|
||||
|
||||
var sparse = [];
|
||||
sparse[20] = {a: 2, b: 2};
|
||||
equal(_.findIndex(sparse, function(obj) {
|
||||
assert.equal(_.findIndex(sparse, function(obj) {
|
||||
return obj && obj.b * obj.a === 4;
|
||||
}), 20, 'Works with sparse arrays');
|
||||
|
||||
var array = [1, 2, 3, 4];
|
||||
array.match = 55;
|
||||
strictEqual(_.findIndex(array, function(x) { return x === 55; }), -1, 'doesn\'t match array-likes keys');
|
||||
assert.strictEqual(_.findIndex(array, function(x) { return x === 55; }), -1, 'doesn\'t match array-likes keys');
|
||||
});
|
||||
|
||||
test('findLastIndex', function() {
|
||||
test('findLastIndex', function(assert) {
|
||||
var objects = [
|
||||
{a: 0, b: 0},
|
||||
{a: 1, b: 1},
|
||||
@@ -493,65 +491,67 @@
|
||||
{a: 0, b: 0}
|
||||
];
|
||||
|
||||
equal(_.findLastIndex(objects, function(obj) {
|
||||
assert.equal(_.findLastIndex(objects, function(obj) {
|
||||
return obj.a === 0;
|
||||
}), 3);
|
||||
|
||||
equal(_.findLastIndex(objects, function(obj) {
|
||||
assert.equal(_.findLastIndex(objects, function(obj) {
|
||||
return obj.b * obj.a === 4;
|
||||
}), 2);
|
||||
|
||||
equal(_.findLastIndex(objects, 'a'), 2, 'Uses lookupIterator');
|
||||
assert.equal(_.findLastIndex(objects, 'a'), 2, 'Uses lookupIterator');
|
||||
|
||||
equal(_.findLastIndex(objects, function(obj) {
|
||||
assert.equal(_.findLastIndex(objects, function(obj) {
|
||||
return obj.b * obj.a === 5;
|
||||
}), -1);
|
||||
|
||||
equal(_.findLastIndex(null, _.noop), -1);
|
||||
strictEqual(_.findLastIndex(objects, function(a) {
|
||||
assert.equal(_.findLastIndex(null, _.noop), -1);
|
||||
assert.strictEqual(_.findLastIndex(objects, function(a) {
|
||||
return a.foo === null;
|
||||
}), -1);
|
||||
_.findLastIndex([{a: 1}], function(a, key, obj) {
|
||||
equal(key, 0);
|
||||
deepEqual(obj, [{a: 1}]);
|
||||
strictEqual(this, objects, 'called with context');
|
||||
assert.equal(key, 0);
|
||||
assert.deepEqual(obj, [{a: 1}]);
|
||||
assert.strictEqual(this, objects, 'called with context');
|
||||
}, objects);
|
||||
|
||||
var sparse = [];
|
||||
sparse[20] = {a: 2, b: 2};
|
||||
equal(_.findLastIndex(sparse, function(obj) {
|
||||
assert.equal(_.findLastIndex(sparse, function(obj) {
|
||||
return obj && obj.b * obj.a === 4;
|
||||
}), 20, 'Works with sparse arrays');
|
||||
|
||||
var array = [1, 2, 3, 4];
|
||||
array.match = 55;
|
||||
strictEqual(_.findLastIndex(array, function(x) { return x === 55; }), -1, 'doesn\'t match array-likes keys');
|
||||
assert.strictEqual(_.findLastIndex(array, function(x) { return x === 55; }), -1, 'doesn\'t match array-likes keys');
|
||||
});
|
||||
|
||||
test('range', function() {
|
||||
deepEqual(_.range(0), [], 'range with 0 as a first argument generates an empty array');
|
||||
deepEqual(_.range(4), [0, 1, 2, 3], 'range with a single positive argument generates an array of elements 0,1,2,...,n-1');
|
||||
deepEqual(_.range(5, 8), [5, 6, 7], 'range with two arguments a & b, a<b generates an array of elements a,a+1,a+2,...,b-2,b-1');
|
||||
deepEqual(_.range(8, 5), [], 'range with two arguments a & b, b<a generates an empty array');
|
||||
deepEqual(_.range(3, 10, 3), [3, 6, 9], 'range with three arguments a & b & c, c < b-a, a < b generates an array of elements a,a+c,a+2c,...,b - (multiplier of a) < c');
|
||||
deepEqual(_.range(3, 10, 15), [3], 'range with three arguments a & b & c, c > b-a, a < b generates an array with a single element, equal to a');
|
||||
deepEqual(_.range(12, 7, -2), [12, 10, 8], 'range with three arguments a & b & c, a > b, c < 0 generates an array of elements a,a-c,a-2c and ends with the number not less than b');
|
||||
deepEqual(_.range(0, -10, -1), [0, -1, -2, -3, -4, -5, -6, -7, -8, -9], 'final example in the Python docs');
|
||||
test('range', function(assert) {
|
||||
assert.deepEqual(_.range(0), [], 'range with 0 as a first argument generates an empty array');
|
||||
assert.deepEqual(_.range(4), [0, 1, 2, 3], 'range with a single positive argument generates an array of elements 0,1,2,...,n-1');
|
||||
assert.deepEqual(_.range(5, 8), [5, 6, 7], 'range with two arguments a & b, a<b generates an array of elements a,a+1,a+2,...,b-2,b-1');
|
||||
assert.deepEqual(_.range(3, 10, 3), [3, 6, 9], 'range with three arguments a & b & c, c < b-a, a < b generates an array of elements a,a+c,a+2c,...,b - (multiplier of a) < c');
|
||||
assert.deepEqual(_.range(3, 10, 15), [3], 'range with three arguments a & b & c, c > b-a, a < b generates an array with a single element, equal to a');
|
||||
assert.deepEqual(_.range(12, 7, -2), [12, 10, 8], 'range with three arguments a & b & c, a > b, c < 0 generates an array of elements a,a-c,a-2c and ends with the number not less than b');
|
||||
assert.deepEqual(_.range(0, -10, -1), [0, -1, -2, -3, -4, -5, -6, -7, -8, -9], 'final example in the Python docs');
|
||||
assert.strictEqual(1 / _.range(-0, 1)[0], -Infinity, 'should preserve -0');
|
||||
assert.deepEqual(_.range(8, 5), [8, 7, 6], 'negative range generates descending array');
|
||||
assert.deepEqual(_.range(-3), [0, -1, -2], 'negative range generates descending array');
|
||||
});
|
||||
|
||||
test('chunk', function() {
|
||||
deepEqual(_.chunk([], 2), [], 'chunk for empty array returns an empty array');
|
||||
test('chunk', function(assert) {
|
||||
assert.deepEqual(_.chunk([], 2), [], 'chunk for empty array returns an empty array');
|
||||
|
||||
deepEqual(_.chunk([1, 2, 3], 0), [], 'chunk into parts of 0 elements returns empty array');
|
||||
deepEqual(_.chunk([1, 2, 3], -1), [], 'chunk into parts of negative amount of elements returns an empty array');
|
||||
deepEqual(_.chunk([1, 2, 3]), [], 'defaults to empty array (chunk size 0)');
|
||||
assert.deepEqual(_.chunk([1, 2, 3], 0), [], 'chunk into parts of 0 elements returns empty array');
|
||||
assert.deepEqual(_.chunk([1, 2, 3], -1), [], 'chunk into parts of negative amount of elements returns an empty array');
|
||||
assert.deepEqual(_.chunk([1, 2, 3]), [], 'defaults to empty array (chunk size 0)');
|
||||
|
||||
deepEqual(_.chunk([1, 2, 3], 1), [[1], [2], [3]], 'chunk into parts of 1 elements returns original array');
|
||||
assert.deepEqual(_.chunk([1, 2, 3], 1), [[1], [2], [3]], 'chunk into parts of 1 elements returns original array');
|
||||
|
||||
deepEqual(_.chunk([1, 2, 3], 3), [[1, 2, 3]], 'chunk into parts of current array length elements returns the original array');
|
||||
deepEqual(_.chunk([1, 2, 3], 5), [[1, 2, 3]], 'chunk into parts of more then current array length elements returns the original array');
|
||||
assert.deepEqual(_.chunk([1, 2, 3], 3), [[1, 2, 3]], 'chunk into parts of current array length elements returns the original array');
|
||||
assert.deepEqual(_.chunk([1, 2, 3], 5), [[1, 2, 3]], 'chunk into parts of more then current array length elements returns the original array');
|
||||
|
||||
deepEqual(_.chunk([10, 20, 30, 40, 50, 60, 70], 2), [[10, 20], [30, 40], [50, 60], [70]], 'chunk into parts of less then current array length elements');
|
||||
deepEqual(_.chunk([10, 20, 30, 40, 50, 60, 70], 3), [[10, 20, 30], [40, 50, 60], [70]], 'chunk into parts of less then current array length elements');
|
||||
assert.deepEqual(_.chunk([10, 20, 30, 40, 50, 60, 70], 2), [[10, 20], [30, 40], [50, 60], [70]], 'chunk into parts of less then current array length elements');
|
||||
assert.deepEqual(_.chunk([10, 20, 30, 40, 50, 60, 70], 3), [[10, 20, 30], [40, 50, 60], [70]], 'chunk into parts of less then current array length elements');
|
||||
});
|
||||
}());
|
||||
|
||||
62
vendor/underscore/test/chaining.js
vendored
62
vendor/underscore/test/chaining.js
vendored
@@ -3,7 +3,7 @@
|
||||
|
||||
QUnit.module('Chaining');
|
||||
|
||||
test('map/flatten/reduce', function() {
|
||||
test('map/flatten/reduce', function(assert) {
|
||||
var lyrics = [
|
||||
'I\'m a lumberjack and I\'m okay',
|
||||
'I sleep all night and I work all day',
|
||||
@@ -19,11 +19,11 @@
|
||||
return hash;
|
||||
}, {})
|
||||
.value();
|
||||
equal(counts.a, 16, 'counted all the letters in the song');
|
||||
equal(counts.e, 10, 'counted all the letters in the song');
|
||||
assert.equal(counts.a, 16, 'counted all the letters in the song');
|
||||
assert.equal(counts.e, 10, 'counted all the letters in the song');
|
||||
});
|
||||
|
||||
test('select/reject/sortBy', function() {
|
||||
test('select/reject/sortBy', function(assert) {
|
||||
var numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
|
||||
numbers = _(numbers).chain().select(function(n) {
|
||||
return n % 2 === 0;
|
||||
@@ -32,10 +32,10 @@
|
||||
}).sortBy(function(n) {
|
||||
return -n;
|
||||
}).value();
|
||||
deepEqual(numbers, [10, 6, 2], 'filtered and reversed the numbers');
|
||||
assert.deepEqual(numbers, [10, 6, 2], 'filtered and reversed the numbers');
|
||||
});
|
||||
|
||||
test('select/reject/sortBy in functional style', function() {
|
||||
test('select/reject/sortBy in functional style', function(assert) {
|
||||
var numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
|
||||
numbers = _.chain(numbers).select(function(n) {
|
||||
return n % 2 === 0;
|
||||
@@ -44,10 +44,10 @@
|
||||
}).sortBy(function(n) {
|
||||
return -n;
|
||||
}).value();
|
||||
deepEqual(numbers, [10, 6, 2], 'filtered and reversed the numbers');
|
||||
assert.deepEqual(numbers, [10, 6, 2], 'filtered and reversed the numbers');
|
||||
});
|
||||
|
||||
test('reverse/concat/unshift/pop/map', function() {
|
||||
test('reverse/concat/unshift/pop/map', function(assert) {
|
||||
var numbers = [1, 2, 3, 4, 5];
|
||||
numbers = _(numbers).chain()
|
||||
.reverse()
|
||||
@@ -56,44 +56,44 @@
|
||||
.pop()
|
||||
.map(function(n){ return n * 2; })
|
||||
.value();
|
||||
deepEqual(numbers, [34, 10, 8, 6, 4, 2, 10, 10], 'can chain together array functions.');
|
||||
assert.deepEqual(numbers, [34, 10, 8, 6, 4, 2, 10, 10], 'can chain together array functions.');
|
||||
});
|
||||
|
||||
test('splice', function() {
|
||||
test('splice', function(assert) {
|
||||
var instance = _([1, 2, 3, 4, 5]).chain();
|
||||
deepEqual(instance.splice(1, 3).value(), [1, 5]);
|
||||
deepEqual(instance.splice(1, 0).value(), [1, 5]);
|
||||
deepEqual(instance.splice(1, 1).value(), [1]);
|
||||
deepEqual(instance.splice(0, 1).value(), [], '#397 Can create empty array');
|
||||
assert.deepEqual(instance.splice(1, 3).value(), [1, 5]);
|
||||
assert.deepEqual(instance.splice(1, 0).value(), [1, 5]);
|
||||
assert.deepEqual(instance.splice(1, 1).value(), [1]);
|
||||
assert.deepEqual(instance.splice(0, 1).value(), [], '#397 Can create empty array');
|
||||
});
|
||||
|
||||
test('shift', function() {
|
||||
test('shift', function(assert) {
|
||||
var instance = _([1, 2, 3]).chain();
|
||||
deepEqual(instance.shift().value(), [2, 3]);
|
||||
deepEqual(instance.shift().value(), [3]);
|
||||
deepEqual(instance.shift().value(), [], '#397 Can create empty array');
|
||||
assert.deepEqual(instance.shift().value(), [2, 3]);
|
||||
assert.deepEqual(instance.shift().value(), [3]);
|
||||
assert.deepEqual(instance.shift().value(), [], '#397 Can create empty array');
|
||||
});
|
||||
|
||||
test('pop', function() {
|
||||
test('pop', function(assert) {
|
||||
var instance = _([1, 2, 3]).chain();
|
||||
deepEqual(instance.pop().value(), [1, 2]);
|
||||
deepEqual(instance.pop().value(), [1]);
|
||||
deepEqual(instance.pop().value(), [], '#397 Can create empty array');
|
||||
assert.deepEqual(instance.pop().value(), [1, 2]);
|
||||
assert.deepEqual(instance.pop().value(), [1]);
|
||||
assert.deepEqual(instance.pop().value(), [], '#397 Can create empty array');
|
||||
});
|
||||
|
||||
test('chaining works in small stages', function() {
|
||||
test('chaining works in small stages', function(assert) {
|
||||
var o = _([1, 2, 3, 4]).chain();
|
||||
deepEqual(o.filter(function(i) { return i < 3; }).value(), [1, 2]);
|
||||
deepEqual(o.filter(function(i) { return i > 2; }).value(), [3, 4]);
|
||||
assert.deepEqual(o.filter(function(i) { return i < 3; }).value(), [1, 2]);
|
||||
assert.deepEqual(o.filter(function(i) { return i > 2; }).value(), [3, 4]);
|
||||
});
|
||||
|
||||
test('#1562: Engine proxies for chained functions', function() {
|
||||
test('#1562: Engine proxies for chained functions', function(assert) {
|
||||
var wrapped = _(512);
|
||||
strictEqual(wrapped.toJSON(), 512);
|
||||
strictEqual(wrapped.valueOf(), 512);
|
||||
strictEqual(+wrapped, 512);
|
||||
strictEqual(wrapped.toString(), '512');
|
||||
strictEqual('' + wrapped, '512');
|
||||
assert.strictEqual(wrapped.toJSON(), 512);
|
||||
assert.strictEqual(wrapped.valueOf(), 512);
|
||||
assert.strictEqual(+wrapped, 512);
|
||||
assert.strictEqual(wrapped.toString(), '512');
|
||||
assert.strictEqual('' + wrapped, '512');
|
||||
});
|
||||
|
||||
}());
|
||||
|
||||
710
vendor/underscore/test/collections.js
vendored
710
vendor/underscore/test/collections.js
vendored
File diff suppressed because it is too large
Load Diff
102
vendor/underscore/test/cross-document.js
vendored
102
vendor/underscore/test/cross-document.js
vendored
@@ -33,95 +33,95 @@
|
||||
);
|
||||
iDoc.close();
|
||||
|
||||
test('isEqual', function() {
|
||||
test('isEqual', function(assert) {
|
||||
|
||||
ok(!_.isEqual(iNumber, 101));
|
||||
ok(_.isEqual(iNumber, 100));
|
||||
assert.ok(!_.isEqual(iNumber, 101));
|
||||
assert.ok(_.isEqual(iNumber, 100));
|
||||
|
||||
// Objects from another frame.
|
||||
ok(_.isEqual({}, iObject), 'Objects with equivalent members created in different documents are equal');
|
||||
assert.ok(_.isEqual({}, iObject), 'Objects with equivalent members created in different documents are equal');
|
||||
|
||||
// Array from another frame.
|
||||
ok(_.isEqual([1, 2, 3], iArray), 'Arrays with equivalent elements created in different documents are equal');
|
||||
assert.ok(_.isEqual([1, 2, 3], iArray), 'Arrays with equivalent elements created in different documents are equal');
|
||||
});
|
||||
|
||||
test('isEmpty', function() {
|
||||
ok(!_([iNumber]).isEmpty(), '[1] is not empty');
|
||||
ok(!_.isEmpty(iArray), '[] is empty');
|
||||
ok(_.isEmpty(iObject), '{} is empty');
|
||||
test('isEmpty', function(assert) {
|
||||
assert.ok(!_([iNumber]).isEmpty(), '[1] is not empty');
|
||||
assert.ok(!_.isEmpty(iArray), '[] is empty');
|
||||
assert.ok(_.isEmpty(iObject), '{} is empty');
|
||||
});
|
||||
|
||||
test('isElement', function() {
|
||||
ok(!_.isElement('div'), 'strings are not dom elements');
|
||||
ok(_.isElement(document.body), 'the body tag is a DOM element');
|
||||
ok(_.isElement(iElement), 'even from another frame');
|
||||
test('isElement', function(assert) {
|
||||
assert.ok(!_.isElement('div'), 'strings are not dom elements');
|
||||
assert.ok(_.isElement(document.body), 'the body tag is a DOM element');
|
||||
assert.ok(_.isElement(iElement), 'even from another frame');
|
||||
});
|
||||
|
||||
test('isArguments', function() {
|
||||
ok(_.isArguments(iArguments), 'even from another frame');
|
||||
test('isArguments', function(assert) {
|
||||
assert.ok(_.isArguments(iArguments), 'even from another frame');
|
||||
});
|
||||
|
||||
test('isObject', function() {
|
||||
ok(_.isObject(iElement), 'even from another frame');
|
||||
ok(_.isObject(iFunction), 'even from another frame');
|
||||
test('isObject', function(assert) {
|
||||
assert.ok(_.isObject(iElement), 'even from another frame');
|
||||
assert.ok(_.isObject(iFunction), 'even from another frame');
|
||||
});
|
||||
|
||||
test('isArray', function() {
|
||||
ok(_.isArray(iArray), 'even from another frame');
|
||||
test('isArray', function(assert) {
|
||||
assert.ok(_.isArray(iArray), 'even from another frame');
|
||||
});
|
||||
|
||||
test('isString', function() {
|
||||
ok(_.isString(iString), 'even from another frame');
|
||||
test('isString', function(assert) {
|
||||
assert.ok(_.isString(iString), 'even from another frame');
|
||||
});
|
||||
|
||||
test('isNumber', function() {
|
||||
ok(_.isNumber(iNumber), 'even from another frame');
|
||||
test('isNumber', function(assert) {
|
||||
assert.ok(_.isNumber(iNumber), 'even from another frame');
|
||||
});
|
||||
|
||||
test('isBoolean', function() {
|
||||
ok(_.isBoolean(iBoolean), 'even from another frame');
|
||||
test('isBoolean', function(assert) {
|
||||
assert.ok(_.isBoolean(iBoolean), 'even from another frame');
|
||||
});
|
||||
|
||||
test('isFunction', function() {
|
||||
ok(_.isFunction(iFunction), 'even from another frame');
|
||||
test('isFunction', function(assert) {
|
||||
assert.ok(_.isFunction(iFunction), 'even from another frame');
|
||||
});
|
||||
|
||||
test('isDate', function() {
|
||||
ok(_.isDate(iDate), 'even from another frame');
|
||||
test('isDate', function(assert) {
|
||||
assert.ok(_.isDate(iDate), 'even from another frame');
|
||||
});
|
||||
|
||||
test('isRegExp', function() {
|
||||
ok(_.isRegExp(iRegExp), 'even from another frame');
|
||||
test('isRegExp', function(assert) {
|
||||
assert.ok(_.isRegExp(iRegExp), 'even from another frame');
|
||||
});
|
||||
|
||||
test('isNaN', function() {
|
||||
ok(_.isNaN(iNaN), 'even from another frame');
|
||||
test('isNaN', function(assert) {
|
||||
assert.ok(_.isNaN(iNaN), 'even from another frame');
|
||||
});
|
||||
|
||||
test('isNull', function() {
|
||||
ok(_.isNull(iNull), 'even from another frame');
|
||||
test('isNull', function(assert) {
|
||||
assert.ok(_.isNull(iNull), 'even from another frame');
|
||||
});
|
||||
|
||||
test('isUndefined', function() {
|
||||
ok(_.isUndefined(iUndefined), 'even from another frame');
|
||||
test('isUndefined', function(assert) {
|
||||
assert.ok(_.isUndefined(iUndefined), 'even from another frame');
|
||||
});
|
||||
|
||||
test('isError', function() {
|
||||
ok(_.isError(iError), 'even from another frame');
|
||||
test('isError', function(assert) {
|
||||
assert.ok(_.isError(iError), 'even from another frame');
|
||||
});
|
||||
|
||||
if (typeof ActiveXObject != 'undefined') {
|
||||
test('IE host objects', function() {
|
||||
test('IE host objects', function(assert) {
|
||||
var xml = new ActiveXObject('Msxml2.DOMDocument.3.0');
|
||||
ok(!_.isNumber(xml));
|
||||
ok(!_.isBoolean(xml));
|
||||
ok(!_.isNaN(xml));
|
||||
ok(!_.isFunction(xml));
|
||||
ok(!_.isNull(xml));
|
||||
ok(!_.isUndefined(xml));
|
||||
assert.ok(!_.isNumber(xml));
|
||||
assert.ok(!_.isBoolean(xml));
|
||||
assert.ok(!_.isNaN(xml));
|
||||
assert.ok(!_.isFunction(xml));
|
||||
assert.ok(!_.isNull(xml));
|
||||
assert.ok(!_.isUndefined(xml));
|
||||
});
|
||||
|
||||
test('#1621 IE 11 compat mode DOM elements are not functions', function() {
|
||||
test('#1621 IE 11 compat mode DOM elements are not functions', function(assert) {
|
||||
var fn = function() {};
|
||||
var xml = new ActiveXObject('Msxml2.DOMDocument.3.0');
|
||||
var div = document.createElement('div');
|
||||
@@ -132,9 +132,9 @@
|
||||
_.isFunction(fn);
|
||||
}
|
||||
|
||||
equal(_.isFunction(xml), false);
|
||||
equal(_.isFunction(div), false);
|
||||
equal(_.isFunction(fn), true);
|
||||
assert.equal(_.isFunction(xml), false);
|
||||
assert.equal(_.isFunction(div), false);
|
||||
assert.equal(_.isFunction(fn), true);
|
||||
});
|
||||
}
|
||||
|
||||
|
||||
372
vendor/underscore/test/functions.js
vendored
372
vendor/underscore/test/functions.js
vendored
@@ -4,32 +4,32 @@
|
||||
QUnit.module('Functions');
|
||||
QUnit.config.asyncRetries = 3;
|
||||
|
||||
test('bind', function() {
|
||||
test('bind', function(assert) {
|
||||
var context = {name: 'moe'};
|
||||
var func = function(arg) { return 'name: ' + (this.name || arg); };
|
||||
var bound = _.bind(func, context);
|
||||
equal(bound(), 'name: moe', 'can bind a function to a context');
|
||||
assert.equal(bound(), 'name: moe', 'can bind a function to a context');
|
||||
|
||||
bound = _(func).bind(context);
|
||||
equal(bound(), 'name: moe', 'can do OO-style binding');
|
||||
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.
|
||||
ok(result === 'name: curly' || result === 'name: ' + window.name, 'can bind without specifying a context');
|
||||
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');
|
||||
equal(func('moe'), 'hello: moe', 'the function was partially applied in advance');
|
||||
assert.equal(func('moe'), 'hello: moe', 'the function was partially applied in advance');
|
||||
|
||||
func = _.bind(func, this, 'curly');
|
||||
equal(func(), 'hello: curly', 'the function was completely applied in advance');
|
||||
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');
|
||||
equal(func(), 'hello: moe curly', 'the function was partially applied in advance and can accept multiple arguments');
|
||||
assert.equal(func(), 'hello: moe curly', 'the function was partially applied in advance and can accept multiple arguments');
|
||||
|
||||
func = function(ctx, message) { equal(this, ctx, message); };
|
||||
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`')();
|
||||
@@ -40,29 +40,29 @@
|
||||
var boundf = _.bind(F, {hello: 'moe curly'});
|
||||
var Boundf = boundf; // make eslint happy.
|
||||
var newBoundf = new Boundf();
|
||||
equal(newBoundf.hello, void 0, 'function should not be bound to the context, to comply with ECMAScript 5');
|
||||
equal(boundf().hello, 'moe curly', "When called without the new operator, it's OK to be bound to the context");
|
||||
ok(newBoundf instanceof F, 'a bound instance is an instance of the original function');
|
||||
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');
|
||||
|
||||
throws(function() { _.bind('notafunction'); }, TypeError, 'throws an error when binding to a non-function');
|
||||
assert.throws(function() { _.bind('notafunction'); }, TypeError, 'throws an error when binding to a non-function');
|
||||
});
|
||||
|
||||
test('partial', function() {
|
||||
test('partial', function(assert) {
|
||||
var obj = {name: 'moe'};
|
||||
var func = function() { return this.name + ' ' + _.toArray(arguments).join(' '); };
|
||||
|
||||
obj.func = _.partial(func, 'a', 'b');
|
||||
equal(obj.func('c', 'd'), 'moe a b c d', 'can partially apply');
|
||||
assert.equal(obj.func('c', 'd'), 'moe a b c d', 'can partially apply');
|
||||
|
||||
obj.func = _.partial(func, _, 'b', _, 'd');
|
||||
equal(obj.func('a', 'c'), 'moe a b c d', 'can partially apply with placeholders');
|
||||
assert.equal(obj.func('a', 'c'), 'moe a b c d', 'can partially apply with placeholders');
|
||||
|
||||
func = _.partial(function() { return arguments.length; }, _, 'b', _, 'd');
|
||||
equal(func('a', 'c', 'e'), 5, 'accepts more arguments than the number of placeholders');
|
||||
equal(func('a'), 4, 'accepts fewer arguments than the number of placeholders');
|
||||
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');
|
||||
equal(func('a'), 'undefined', 'unfilled placeholders are undefined');
|
||||
assert.equal(func('a'), 'undefined', 'unfilled placeholders are undefined');
|
||||
|
||||
// passes context
|
||||
function MyWidget(name, options) {
|
||||
@@ -74,22 +74,22 @@
|
||||
};
|
||||
var MyWidgetWithCoolOpts = _.partial(MyWidget, _, {a: 1});
|
||||
var widget = new MyWidgetWithCoolOpts('foo');
|
||||
ok(widget instanceof MyWidget, 'Can partially bind a constructor');
|
||||
equal(widget.get(), 'foo', 'keeps prototype');
|
||||
deepEqual(widget.options, {a: 1});
|
||||
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');
|
||||
equal(func('a'), 4, 'allows the placeholder to be swapped out');
|
||||
assert.equal(func('a'), 4, 'allows the placeholder to be swapped out');
|
||||
|
||||
_.partial.placeholder = {};
|
||||
func = _.partial(function() { return arguments.length; }, obj, 'b', obj, 'd');
|
||||
equal(func('a'), 5, 'swapping the placeholder preserves previously bound arguments');
|
||||
assert.equal(func('a'), 5, 'swapping the placeholder preserves previously bound arguments');
|
||||
|
||||
_.partial.placeholder = _;
|
||||
});
|
||||
|
||||
test('bindAll', function() {
|
||||
test('bindAll', function(assert) {
|
||||
var curly = {name: 'curly'}, moe = {
|
||||
name: 'moe',
|
||||
getName: function() { return 'name: ' + this.name; },
|
||||
@@ -98,8 +98,8 @@
|
||||
curly.getName = moe.getName;
|
||||
_.bindAll(moe, 'getName', 'sayHi');
|
||||
curly.sayHi = moe.sayHi;
|
||||
equal(curly.getName(), 'name: curly', 'unbound function is bound to current object');
|
||||
equal(curly.sayHi(), 'hi: moe', 'bound function is still bound to original object');
|
||||
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 = {
|
||||
@@ -109,57 +109,57 @@
|
||||
sayLast: function() { return this.sayHi(_.last(arguments)); }
|
||||
};
|
||||
|
||||
throws(function() { _.bindAll(moe); }, Error, 'throws an error for bindAll with no functions named');
|
||||
throws(function() { _.bindAll(moe, 'sayBye'); }, TypeError, 'throws an error for bindAll if the given key is undefined');
|
||||
throws(function() { _.bindAll(moe, 'name'); }, TypeError, 'throws an error for bindAll if the given key is not a function');
|
||||
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');
|
||||
|
||||
_.bindAll(moe, 'sayHi', 'sayLast');
|
||||
curly.sayHi = moe.sayHi;
|
||||
equal(curly.sayHi(), 'hi: moe');
|
||||
assert.equal(curly.sayHi(), 'hi: moe');
|
||||
|
||||
var sayLast = moe.sayLast;
|
||||
equal(sayLast(1, 2, 3, 4, 5, 6, 7, 'Tom'), 'hi: moe', 'createCallback works with any number of arguments');
|
||||
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;
|
||||
equal(getName(), 'name: moe', 'flattens arguments into a single list');
|
||||
assert.equal(getName(), 'name: moe', 'flattens arguments into a single list');
|
||||
});
|
||||
|
||||
test('memoize', function() {
|
||||
test('memoize', function(assert) {
|
||||
var fib = function(n) {
|
||||
return n < 2 ? n : fib(n - 1) + fib(n - 2);
|
||||
};
|
||||
equal(fib(10), 55, 'a memoized version of fibonacci produces identical results');
|
||||
assert.equal(fib(10), 55, 'a memoized version of fibonacci produces identical results');
|
||||
fib = _.memoize(fib); // Redefine `fib` for memoization
|
||||
equal(fib(10), 55, 'a memoized version of fibonacci produces identical results');
|
||||
assert.equal(fib(10), 55, 'a memoized version of fibonacci produces identical results');
|
||||
|
||||
var o = function(str) {
|
||||
return str;
|
||||
};
|
||||
var fastO = _.memoize(o);
|
||||
equal(o('toString'), 'toString', 'checks hasOwnProperty');
|
||||
equal(fastO('toString'), 'toString', 'checks hasOwnProperty');
|
||||
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();
|
||||
});
|
||||
equal(upper('foo'), 'FOO');
|
||||
equal(upper('bar'), 'BAR');
|
||||
deepEqual(upper.cache, {foo: 'FOO', bar: 'BAR'});
|
||||
assert.equal(upper('foo'), 'FOO');
|
||||
assert.equal(upper('bar'), 'BAR');
|
||||
assert.deepEqual(upper.cache, {foo: 'FOO', bar: 'BAR'});
|
||||
upper.cache = {foo: 'BAR', bar: 'FOO'};
|
||||
equal(upper('foo'), 'BAR');
|
||||
equal(upper('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
|
||||
ok(/[a-z]+/.test(key), 'hasher doesn\'t change keys');
|
||||
assert.ok(/[a-z]+/.test(key), 'hasher doesn\'t change keys');
|
||||
return key;
|
||||
}, function(key) {
|
||||
return key.toUpperCase();
|
||||
});
|
||||
hashed('yep');
|
||||
deepEqual(hashed.cache, {YEP: 'yep'}, 'takes a hasher');
|
||||
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) {
|
||||
@@ -169,78 +169,78 @@
|
||||
});
|
||||
var myObj = objCacher('a', 'alpha');
|
||||
var myObjAlias = objCacher('b', 'alpha');
|
||||
notStrictEqual(myObj, void 0, 'object is created if second argument used as key');
|
||||
strictEqual(myObj, myObjAlias, 'object is cached if second argument used as key');
|
||||
strictEqual(myObj.value, 'a', 'object is not modified if second argument used as key');
|
||||
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');
|
||||
});
|
||||
|
||||
asyncTest('delay', 2, function() {
|
||||
asyncTest('delay', 2, function(assert) {
|
||||
var delayed = false;
|
||||
_.delay(function(){ delayed = true; }, 100);
|
||||
setTimeout(function(){ ok(!delayed, "didn't delay the function quite yet"); }, 50);
|
||||
setTimeout(function(){ ok(delayed, 'delayed the function'); start(); }, 150);
|
||||
setTimeout(function(){ assert.ok(!delayed, "didn't delay the function quite yet"); }, 50);
|
||||
setTimeout(function(){ assert.ok(delayed, 'delayed the function'); start(); }, 150);
|
||||
});
|
||||
|
||||
asyncTest('defer', 1, function() {
|
||||
asyncTest('defer', 1, function(assert) {
|
||||
var deferred = false;
|
||||
_.defer(function(bool){ deferred = bool; }, true);
|
||||
_.delay(function(){ ok(deferred, 'deferred the function'); start(); }, 50);
|
||||
_.delay(function(){ assert.ok(deferred, 'deferred the function'); start(); }, 50);
|
||||
});
|
||||
|
||||
asyncTest('throttle', 2, function() {
|
||||
asyncTest('throttle', 2, function(assert) {
|
||||
var counter = 0;
|
||||
var incr = function(){ counter++; };
|
||||
var throttledIncr = _.throttle(incr, 32);
|
||||
throttledIncr(); throttledIncr();
|
||||
|
||||
equal(counter, 1, 'incr was called immediately');
|
||||
_.delay(function(){ equal(counter, 2, 'incr was throttled'); start(); }, 64);
|
||||
assert.equal(counter, 1, 'incr was called immediately');
|
||||
_.delay(function(){ assert.equal(counter, 2, 'incr was throttled'); start(); }, 64);
|
||||
});
|
||||
|
||||
asyncTest('throttle arguments', 2, function() {
|
||||
asyncTest('throttle arguments', 2, function(assert) {
|
||||
var value = 0;
|
||||
var update = function(val){ value = val; };
|
||||
var throttledUpdate = _.throttle(update, 32);
|
||||
throttledUpdate(1); throttledUpdate(2);
|
||||
_.delay(function(){ throttledUpdate(3); }, 64);
|
||||
equal(value, 1, 'updated to latest value');
|
||||
_.delay(function(){ equal(value, 3, 'updated to latest value'); start(); }, 96);
|
||||
assert.equal(value, 1, 'updated to latest value');
|
||||
_.delay(function(){ assert.equal(value, 3, 'updated to latest value'); start(); }, 96);
|
||||
});
|
||||
|
||||
asyncTest('throttle once', 2, function() {
|
||||
asyncTest('throttle once', 2, function(assert) {
|
||||
var counter = 0;
|
||||
var incr = function(){ return ++counter; };
|
||||
var throttledIncr = _.throttle(incr, 32);
|
||||
var result = throttledIncr();
|
||||
_.delay(function(){
|
||||
equal(result, 1, 'throttled functions return their value');
|
||||
equal(counter, 1, 'incr was called once'); start();
|
||||
assert.equal(result, 1, 'throttled functions return their value');
|
||||
assert.equal(counter, 1, 'incr was called once'); start();
|
||||
}, 64);
|
||||
});
|
||||
|
||||
asyncTest('throttle twice', 1, function() {
|
||||
asyncTest('throttle twice', 1, function(assert) {
|
||||
var counter = 0;
|
||||
var incr = function(){ counter++; };
|
||||
var throttledIncr = _.throttle(incr, 32);
|
||||
throttledIncr(); throttledIncr();
|
||||
_.delay(function(){ equal(counter, 2, 'incr was called twice'); start(); }, 64);
|
||||
_.delay(function(){ assert.equal(counter, 2, 'incr was called twice'); start(); }, 64);
|
||||
});
|
||||
|
||||
asyncTest('more throttling', 3, function() {
|
||||
asyncTest('more throttling', 3, function(assert) {
|
||||
var counter = 0;
|
||||
var incr = function(){ counter++; };
|
||||
var throttledIncr = _.throttle(incr, 30);
|
||||
throttledIncr(); throttledIncr();
|
||||
equal(counter, 1);
|
||||
assert.equal(counter, 1);
|
||||
_.delay(function(){
|
||||
equal(counter, 2);
|
||||
assert.equal(counter, 2);
|
||||
throttledIncr();
|
||||
equal(counter, 3);
|
||||
assert.equal(counter, 3);
|
||||
start();
|
||||
}, 85);
|
||||
});
|
||||
|
||||
asyncTest('throttle repeatedly with results', 6, function() {
|
||||
asyncTest('throttle repeatedly with results', 6, function(assert) {
|
||||
var counter = 0;
|
||||
var incr = function(){ return ++counter; };
|
||||
var throttledIncr = _.throttle(incr, 100);
|
||||
@@ -252,17 +252,17 @@
|
||||
_.delay(saveResult, 160);
|
||||
_.delay(saveResult, 230);
|
||||
_.delay(function() {
|
||||
equal(results[0], 1, 'incr was called once');
|
||||
equal(results[1], 1, 'incr was throttled');
|
||||
equal(results[2], 1, 'incr was throttled');
|
||||
equal(results[3], 2, 'incr was called twice');
|
||||
equal(results[4], 2, 'incr was throttled');
|
||||
equal(results[5], 3, 'incr was called trailing');
|
||||
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');
|
||||
start();
|
||||
}, 300);
|
||||
});
|
||||
|
||||
asyncTest('throttle triggers trailing call when invoked repeatedly', 2, function() {
|
||||
asyncTest('throttle triggers trailing call when invoked repeatedly', 2, function(assert) {
|
||||
var counter = 0;
|
||||
var limit = 48;
|
||||
var incr = function(){ counter++; };
|
||||
@@ -273,29 +273,29 @@
|
||||
throttledIncr();
|
||||
}
|
||||
var lastCount = counter;
|
||||
ok(counter > 1);
|
||||
assert.ok(counter > 1);
|
||||
|
||||
_.delay(function() {
|
||||
ok(counter > lastCount);
|
||||
assert.ok(counter > lastCount);
|
||||
start();
|
||||
}, 96);
|
||||
});
|
||||
|
||||
asyncTest('throttle does not trigger leading call when leading is set to false', 2, function() {
|
||||
asyncTest('throttle does not trigger leading call when leading is set to false', 2, function(assert) {
|
||||
var counter = 0;
|
||||
var incr = function(){ counter++; };
|
||||
var throttledIncr = _.throttle(incr, 60, {leading: false});
|
||||
|
||||
throttledIncr(); throttledIncr();
|
||||
equal(counter, 0);
|
||||
assert.equal(counter, 0);
|
||||
|
||||
_.delay(function() {
|
||||
equal(counter, 1);
|
||||
assert.equal(counter, 1);
|
||||
start();
|
||||
}, 96);
|
||||
});
|
||||
|
||||
asyncTest('more throttle does not trigger leading call when leading is set to false', 3, function() {
|
||||
asyncTest('more throttle does not trigger leading call when leading is set to false', 3, function(assert) {
|
||||
var counter = 0;
|
||||
var incr = function(){ counter++; };
|
||||
var throttledIncr = _.throttle(incr, 100, {leading: false});
|
||||
@@ -304,75 +304,75 @@
|
||||
_.delay(throttledIncr, 50);
|
||||
_.delay(throttledIncr, 60);
|
||||
_.delay(throttledIncr, 200);
|
||||
equal(counter, 0);
|
||||
assert.equal(counter, 0);
|
||||
|
||||
_.delay(function() {
|
||||
equal(counter, 1);
|
||||
assert.equal(counter, 1);
|
||||
}, 250);
|
||||
|
||||
_.delay(function() {
|
||||
equal(counter, 2);
|
||||
assert.equal(counter, 2);
|
||||
start();
|
||||
}, 350);
|
||||
});
|
||||
|
||||
asyncTest('one more throttle with leading: false test', 2, function() {
|
||||
asyncTest('one more throttle with leading: false test', 2, function(assert) {
|
||||
var counter = 0;
|
||||
var incr = function(){ counter++; };
|
||||
var throttledIncr = _.throttle(incr, 100, {leading: false});
|
||||
|
||||
var time = new Date;
|
||||
while (new Date - time < 350) throttledIncr();
|
||||
ok(counter <= 3);
|
||||
assert.ok(counter <= 3);
|
||||
|
||||
_.delay(function() {
|
||||
ok(counter <= 4);
|
||||
assert.ok(counter <= 4);
|
||||
start();
|
||||
}, 200);
|
||||
});
|
||||
|
||||
asyncTest('throttle does not trigger trailing call when trailing is set to false', 4, function() {
|
||||
asyncTest('throttle does not trigger trailing call when trailing is set to false', 4, function(assert) {
|
||||
var counter = 0;
|
||||
var incr = function(){ counter++; };
|
||||
var throttledIncr = _.throttle(incr, 60, {trailing: false});
|
||||
|
||||
throttledIncr(); throttledIncr(); throttledIncr();
|
||||
equal(counter, 1);
|
||||
assert.equal(counter, 1);
|
||||
|
||||
_.delay(function() {
|
||||
equal(counter, 1);
|
||||
assert.equal(counter, 1);
|
||||
|
||||
throttledIncr(); throttledIncr();
|
||||
equal(counter, 2);
|
||||
assert.equal(counter, 2);
|
||||
|
||||
_.delay(function() {
|
||||
equal(counter, 2);
|
||||
assert.equal(counter, 2);
|
||||
start();
|
||||
}, 96);
|
||||
}, 96);
|
||||
});
|
||||
|
||||
asyncTest('throttle continues to function after system time is set backwards', 2, function() {
|
||||
asyncTest('throttle continues to function after system time is set backwards', 2, function(assert) {
|
||||
var counter = 0;
|
||||
var incr = function(){ counter++; };
|
||||
var throttledIncr = _.throttle(incr, 100);
|
||||
var origNowFunc = _.now;
|
||||
|
||||
throttledIncr();
|
||||
equal(counter, 1);
|
||||
assert.equal(counter, 1);
|
||||
_.now = function() {
|
||||
return new Date(2013, 0, 1, 1, 1, 1);
|
||||
};
|
||||
|
||||
_.delay(function() {
|
||||
throttledIncr();
|
||||
equal(counter, 2);
|
||||
assert.equal(counter, 2);
|
||||
start();
|
||||
_.now = origNowFunc;
|
||||
}, 200);
|
||||
});
|
||||
|
||||
asyncTest('throttle re-entrant', 2, function() {
|
||||
asyncTest('throttle re-entrant', 2, function(assert) {
|
||||
var sequence = [
|
||||
['b1', 'b2'],
|
||||
['c1', 'c2']
|
||||
@@ -388,50 +388,100 @@
|
||||
};
|
||||
throttledAppend = _.throttle(append, 32);
|
||||
throttledAppend.call('a1', 'a2');
|
||||
equal(value, 'a1a2');
|
||||
assert.equal(value, 'a1a2');
|
||||
_.delay(function(){
|
||||
equal(value, 'a1a2c1c2b1b2', 'append was throttled successfully');
|
||||
assert.equal(value, 'a1a2c1c2b1b2', 'append was throttled successfully');
|
||||
start();
|
||||
}, 100);
|
||||
});
|
||||
|
||||
asyncTest('debounce', 1, function() {
|
||||
asyncTest('throttle cancel', function(assert) {
|
||||
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'); start(); }, 64);
|
||||
});
|
||||
|
||||
asyncTest('throttle cancel with leading: false', function(assert) {
|
||||
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'); start(); }, 64);
|
||||
});
|
||||
|
||||
asyncTest('debounce', 1, function(assert) {
|
||||
var counter = 0;
|
||||
var incr = function(){ counter++; };
|
||||
var debouncedIncr = _.debounce(incr, 32);
|
||||
debouncedIncr(); debouncedIncr();
|
||||
_.delay(debouncedIncr, 16);
|
||||
_.delay(function(){ equal(counter, 1, 'incr was debounced'); start(); }, 96);
|
||||
_.delay(function(){ assert.equal(counter, 1, 'incr was debounced'); start(); }, 96);
|
||||
});
|
||||
|
||||
asyncTest('debounce asap', 4, function() {
|
||||
asyncTest('debounce cancel', 1, function(assert) {
|
||||
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);
|
||||
});
|
||||
|
||||
asyncTest('debounce asap', 4, function(assert) {
|
||||
var a, b;
|
||||
var counter = 0;
|
||||
var incr = function(){ return ++counter; };
|
||||
var debouncedIncr = _.debounce(incr, 64, true);
|
||||
a = debouncedIncr();
|
||||
b = debouncedIncr();
|
||||
equal(a, 1);
|
||||
equal(b, 1);
|
||||
equal(counter, 1, 'incr was called immediately');
|
||||
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(){ equal(counter, 1, 'incr was debounced'); start(); }, 128);
|
||||
_.delay(function(){ assert.equal(counter, 1, 'incr was debounced'); start(); }, 128);
|
||||
});
|
||||
|
||||
asyncTest('debounce asap recursively', 2, function() {
|
||||
asyncTest('debounce asap cancel', 4, function(assert) {
|
||||
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'); start(); }, 128);
|
||||
});
|
||||
|
||||
asyncTest('debounce asap recursively', 2, function(assert) {
|
||||
var counter = 0;
|
||||
var debouncedIncr = _.debounce(function(){
|
||||
counter++;
|
||||
if (counter < 10) debouncedIncr();
|
||||
}, 32, true);
|
||||
debouncedIncr();
|
||||
equal(counter, 1, 'incr was called immediately');
|
||||
_.delay(function(){ equal(counter, 1, 'incr was debounced'); start(); }, 96);
|
||||
assert.equal(counter, 1, 'incr was called immediately');
|
||||
_.delay(function(){ assert.equal(counter, 1, 'incr was debounced'); start(); }, 96);
|
||||
});
|
||||
|
||||
asyncTest('debounce after system time is set backwards', 2, function() {
|
||||
asyncTest('debounce after system time is set backwards', 2, function(assert) {
|
||||
var counter = 0;
|
||||
var origNowFunc = _.now;
|
||||
var debouncedIncr = _.debounce(function(){
|
||||
@@ -439,7 +489,7 @@
|
||||
}, 100, true);
|
||||
|
||||
debouncedIncr();
|
||||
equal(counter, 1, 'incr was called immediately');
|
||||
assert.equal(counter, 1, 'incr was called immediately');
|
||||
|
||||
_.now = function() {
|
||||
return new Date(2013, 0, 1, 1, 1, 1);
|
||||
@@ -447,13 +497,13 @@
|
||||
|
||||
_.delay(function() {
|
||||
debouncedIncr();
|
||||
equal(counter, 2, 'incr was debounced successfully');
|
||||
assert.equal(counter, 2, 'incr was debounced successfully');
|
||||
start();
|
||||
_.now = origNowFunc;
|
||||
}, 200);
|
||||
});
|
||||
|
||||
asyncTest('debounce re-entrant', 2, function() {
|
||||
asyncTest('debounce re-entrant', 2, function(assert) {
|
||||
var sequence = [
|
||||
['b1', 'b2']
|
||||
];
|
||||
@@ -468,80 +518,80 @@
|
||||
};
|
||||
debouncedAppend = _.debounce(append, 32);
|
||||
debouncedAppend.call('a1', 'a2');
|
||||
equal(value, '');
|
||||
assert.equal(value, '');
|
||||
_.delay(function(){
|
||||
equal(value, 'a1a2b1b2', 'append was debounced successfully');
|
||||
assert.equal(value, 'a1a2b1b2', 'append was debounced successfully');
|
||||
start();
|
||||
}, 100);
|
||||
});
|
||||
|
||||
test('once', function() {
|
||||
test('once', function(assert) {
|
||||
var num = 0;
|
||||
var increment = _.once(function(){ return ++num; });
|
||||
increment();
|
||||
increment();
|
||||
equal(num, 1);
|
||||
assert.equal(num, 1);
|
||||
|
||||
equal(increment(), 1, 'stores a memo to the last value');
|
||||
assert.equal(increment(), 1, 'stores a memo to the last value');
|
||||
});
|
||||
|
||||
test('Recursive onced function.', 1, function() {
|
||||
test('Recursive onced function.', 1, function(assert) {
|
||||
var f = _.once(function(){
|
||||
ok(true);
|
||||
assert.ok(true);
|
||||
f();
|
||||
});
|
||||
f();
|
||||
});
|
||||
|
||||
test('wrap', function() {
|
||||
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(''); });
|
||||
equal(backwards('moe'), 'hi: moe eom', 'wrapped the salutation function');
|
||||
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; });
|
||||
equal(obj.hi(), 'Hello Moe');
|
||||
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');
|
||||
deepEqual(ret, [noop, ['whats', 'your'], 'vector', 'victor']);
|
||||
assert.deepEqual(ret, [noop, ['whats', 'your'], 'vector', 'victor']);
|
||||
});
|
||||
|
||||
test('negate', function() {
|
||||
test('negate', function(assert) {
|
||||
var isOdd = function(n){ return n & 1; };
|
||||
equal(_.negate(isOdd)(2), true, 'should return the complement of the given function');
|
||||
equal(_.negate(isOdd)(3), false, 'should return the complement of the given function');
|
||||
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() {
|
||||
test('compose', function(assert) {
|
||||
var greet = function(name){ return 'hi: ' + name; };
|
||||
var exclaim = function(sentence){ return sentence + '!'; };
|
||||
var composed = _.compose(exclaim, greet);
|
||||
equal(composed('moe'), 'hi: moe!', 'can compose a function that takes another');
|
||||
assert.equal(composed('moe'), 'hi: moe!', 'can compose a function that takes another');
|
||||
|
||||
composed = _.compose(greet, exclaim);
|
||||
equal(composed('moe'), 'hi: moe!', 'in this case, the functions are also commutative');
|
||||
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) {
|
||||
equal(arguments.length, 3, 'First function called with multiple args');
|
||||
assert.equal(arguments.length, 3, 'First function called with multiple args');
|
||||
return z * y;
|
||||
}
|
||||
function g(x) {
|
||||
equal(arguments.length, 1, 'Composed function is called with 1 argument');
|
||||
assert.equal(arguments.length, 1, 'Composed function is called with 1 argument');
|
||||
return x;
|
||||
}
|
||||
function f(x) {
|
||||
equal(arguments.length, 1, 'Composed function is called with 1 argument');
|
||||
assert.equal(arguments.length, 1, 'Composed function is called with 1 argument');
|
||||
return x * 2;
|
||||
}
|
||||
composed = _.compose(f, g, h);
|
||||
equal(composed(1, 2, 3), 12);
|
||||
assert.equal(composed(1, 2, 3), 12);
|
||||
});
|
||||
|
||||
test('after', function() {
|
||||
test('after', function(assert) {
|
||||
var testAfter = function(afterAmount, timesCalled) {
|
||||
var afterCalled = 0;
|
||||
var after = _.after(afterAmount, function() {
|
||||
@@ -551,13 +601,13 @@
|
||||
return afterCalled;
|
||||
};
|
||||
|
||||
equal(testAfter(5, 5), 1, 'after(N) should fire after being called N times');
|
||||
equal(testAfter(5, 4), 0, 'after(N) should not fire unless called N times');
|
||||
equal(testAfter(0, 0), 0, 'after(0) should not fire immediately');
|
||||
equal(testAfter(0, 1), 1, 'after(0) should fire when first invoked');
|
||||
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');
|
||||
});
|
||||
|
||||
test('before', function() {
|
||||
test('before', function(assert) {
|
||||
var testBefore = function(beforeAmount, timesCalled) {
|
||||
var beforeCalled = 0;
|
||||
var before = _.before(beforeAmount, function() { beforeCalled++; });
|
||||
@@ -565,58 +615,58 @@
|
||||
return beforeCalled;
|
||||
};
|
||||
|
||||
equal(testBefore(5, 5), 4, 'before(N) should not fire after being called N times');
|
||||
equal(testBefore(5, 4), 4, 'before(N) should fire before being called N times');
|
||||
equal(testBefore(0, 0), 0, 'before(0) should not fire immediately');
|
||||
equal(testBefore(0, 1), 0, 'before(0) should not fire when first invoked');
|
||||
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);
|
||||
equal(increment(), 2, 'stores a memo to the last value');
|
||||
equal(context.num, 2, 'provides context');
|
||||
assert.equal(increment(), 2, 'stores a memo to the last value');
|
||||
assert.equal(context.num, 2, 'provides context');
|
||||
});
|
||||
|
||||
test('iteratee', function() {
|
||||
test('iteratee', function(assert) {
|
||||
var identity = _.iteratee();
|
||||
equal(identity, _.identity, '_.iteratee is exposed as an external function.');
|
||||
assert.equal(identity, _.identity, '_.iteratee is exposed as an external function.');
|
||||
|
||||
function fn() {
|
||||
return arguments;
|
||||
}
|
||||
_.each([_.iteratee(fn), _.iteratee(fn, {})], function(cb) {
|
||||
equal(cb().length, 0);
|
||||
deepEqual(_.toArray(cb(1, 2, 3)), _.range(1, 4));
|
||||
deepEqual(_.toArray(cb(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)), _.range(1, 11));
|
||||
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));
|
||||
});
|
||||
|
||||
});
|
||||
|
||||
test('restArgs', 10, function() {
|
||||
test('restArgs', 10, function(assert) {
|
||||
_.restArgs(function(a, args) {
|
||||
strictEqual(a, 1);
|
||||
deepEqual(args, [2, 3], 'collects rest arguments into an array');
|
||||
assert.strictEqual(a, 1);
|
||||
assert.deepEqual(args, [2, 3], 'collects rest arguments into an array');
|
||||
})(1, 2, 3);
|
||||
|
||||
_.restArgs(function(a, args) {
|
||||
strictEqual(a, void 0);
|
||||
deepEqual(args, [], 'passes empty array if there are not enough arguments');
|
||||
assert.strictEqual(a, void 0);
|
||||
assert.deepEqual(args, [], 'passes empty array if there are not enough arguments');
|
||||
})();
|
||||
|
||||
_.restArgs(function(a, b, c, args) {
|
||||
strictEqual(arguments.length, 4);
|
||||
deepEqual(args, [4, 5], 'works on functions with many named parameters');
|
||||
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() {
|
||||
strictEqual(this, obj, 'invokes function with this context');
|
||||
assert.strictEqual(this, obj, 'invokes function with this context');
|
||||
}).call(obj);
|
||||
|
||||
_.restArgs(function(array, iteratee, context) {
|
||||
deepEqual(array, [1, 2, 3, 4], 'startIndex can be used manually specify index of rest parameter');
|
||||
strictEqual(iteratee, void 0);
|
||||
strictEqual(context, void 0);
|
||||
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);
|
||||
});
|
||||
|
||||
|
||||
820
vendor/underscore/test/objects.js
vendored
820
vendor/underscore/test/objects.js
vendored
File diff suppressed because it is too large
Load Diff
262
vendor/underscore/test/utility.js
vendored
262
vendor/underscore/test/utility.js
vendored
@@ -15,18 +15,20 @@
|
||||
});
|
||||
|
||||
if (typeof this == 'object') {
|
||||
test('noConflict', function() {
|
||||
test('noConflict', function(assert) {
|
||||
var underscore = _.noConflict();
|
||||
equal(underscore.identity(1), 1);
|
||||
assert.equal(underscore.identity(1), 1);
|
||||
if (typeof require != 'function') {
|
||||
equal(this._, void 0, 'global underscore is removed');
|
||||
assert.equal(this._, void 0, 'global underscore is removed');
|
||||
this._ = underscore;
|
||||
} else if (typeof global !== 'undefined') {
|
||||
delete global._;
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
if (typeof require == 'function') {
|
||||
asyncTest('noConflict (node vm)', 2, function() {
|
||||
asyncTest('noConflict (node vm)', 2, function(assert) {
|
||||
var fs = require('fs');
|
||||
var vm = require('vm');
|
||||
var filename = __dirname + '/../underscore.js';
|
||||
@@ -37,179 +39,179 @@
|
||||
);
|
||||
var context = {_: 'oldvalue'};
|
||||
sandbox.runInNewContext(context);
|
||||
equal(context._, 'oldvalue');
|
||||
equal(context.underscore.VERSION, _.VERSION);
|
||||
assert.equal(context._, 'oldvalue');
|
||||
assert.equal(context.underscore.VERSION, _.VERSION);
|
||||
|
||||
start();
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
test('#750 - Return _ instance.', 2, function() {
|
||||
test('#750 - Return _ instance.', 2, function(assert) {
|
||||
var instance = _([]);
|
||||
ok(_(instance) === instance);
|
||||
ok(new _(instance) === instance);
|
||||
assert.ok(_(instance) === instance);
|
||||
assert.ok(new _(instance) === instance);
|
||||
});
|
||||
|
||||
test('identity', function() {
|
||||
test('identity', function(assert) {
|
||||
var stooge = {name: 'moe'};
|
||||
equal(_.identity(stooge), stooge, 'stooge is the same as his identity');
|
||||
assert.equal(_.identity(stooge), stooge, 'stooge is the same as his identity');
|
||||
});
|
||||
|
||||
test('constant', function() {
|
||||
test('constant', function(assert) {
|
||||
var stooge = {name: 'moe'};
|
||||
equal(_.constant(stooge)(), stooge, 'should create a function that returns stooge');
|
||||
assert.equal(_.constant(stooge)(), stooge, 'should create a function that returns stooge');
|
||||
});
|
||||
|
||||
test('noop', function() {
|
||||
strictEqual(_.noop('curly', 'larry', 'moe'), void 0, 'should always return undefined');
|
||||
test('noop', function(assert) {
|
||||
assert.strictEqual(_.noop('curly', 'larry', 'moe'), void 0, 'should always return undefined');
|
||||
});
|
||||
|
||||
test('property', function() {
|
||||
test('property', function(assert) {
|
||||
var stooge = {name: 'moe'};
|
||||
equal(_.property('name')(stooge), 'moe', 'should return the property with the given name');
|
||||
equal(_.property('name')(null), void 0, 'should return undefined for null values');
|
||||
equal(_.property('name')(void 0), void 0, 'should return undefined for undefined values');
|
||||
assert.equal(_.property('name')(stooge), 'moe', 'should return the property with the given name');
|
||||
assert.equal(_.property('name')(null), void 0, 'should return undefined for null values');
|
||||
assert.equal(_.property('name')(void 0), void 0, 'should return undefined for undefined values');
|
||||
});
|
||||
|
||||
test('propertyOf', function() {
|
||||
test('propertyOf', function(assert) {
|
||||
var stoogeRanks = _.propertyOf({curly: 2, moe: 1, larry: 3});
|
||||
equal(stoogeRanks('curly'), 2, 'should return the property with the given name');
|
||||
equal(stoogeRanks(null), void 0, 'should return undefined for null values');
|
||||
equal(stoogeRanks(void 0), void 0, 'should return undefined for undefined values');
|
||||
assert.equal(stoogeRanks('curly'), 2, 'should return the property with the given name');
|
||||
assert.equal(stoogeRanks(null), void 0, 'should return undefined for null values');
|
||||
assert.equal(stoogeRanks(void 0), void 0, 'should return undefined for undefined values');
|
||||
|
||||
function MoreStooges() { this.shemp = 87; }
|
||||
MoreStooges.prototype = {curly: 2, moe: 1, larry: 3};
|
||||
var moreStoogeRanks = _.propertyOf(new MoreStooges());
|
||||
equal(moreStoogeRanks('curly'), 2, 'should return properties from further up the prototype chain');
|
||||
assert.equal(moreStoogeRanks('curly'), 2, 'should return properties from further up the prototype chain');
|
||||
|
||||
var nullPropertyOf = _.propertyOf(null);
|
||||
equal(nullPropertyOf('curly'), void 0, 'should return undefined when obj is null');
|
||||
assert.equal(nullPropertyOf('curly'), void 0, 'should return undefined when obj is null');
|
||||
|
||||
var undefPropertyOf = _.propertyOf(void 0);
|
||||
equal(undefPropertyOf('curly'), void 0, 'should return undefined when obj is undefined');
|
||||
assert.equal(undefPropertyOf('curly'), void 0, 'should return undefined when obj is undefined');
|
||||
});
|
||||
|
||||
test('random', function() {
|
||||
test('random', function(assert) {
|
||||
var array = _.range(1000);
|
||||
var min = Math.pow(2, 31);
|
||||
var max = Math.pow(2, 62);
|
||||
|
||||
ok(_.every(array, function() {
|
||||
assert.ok(_.every(array, function() {
|
||||
return _.random(min, max) >= min;
|
||||
}), 'should produce a random number greater than or equal to the minimum number');
|
||||
|
||||
ok(_.some(array, function() {
|
||||
assert.ok(_.some(array, function() {
|
||||
return _.random(Number.MAX_VALUE) > 0;
|
||||
}), 'should produce a random number when passed `Number.MAX_VALUE`');
|
||||
});
|
||||
|
||||
test('now', function() {
|
||||
test('now', function(assert) {
|
||||
var diff = _.now() - new Date().getTime();
|
||||
ok(diff <= 0 && diff > -5, 'Produces the correct time in milliseconds');//within 5ms
|
||||
assert.ok(diff <= 0 && diff > -5, 'Produces the correct time in milliseconds');//within 5ms
|
||||
});
|
||||
|
||||
test('uniqueId', function() {
|
||||
test('uniqueId', function(assert) {
|
||||
var ids = [], i = 0;
|
||||
while (i++ < 100) ids.push(_.uniqueId());
|
||||
equal(_.uniq(ids).length, ids.length, 'can generate a globally-unique stream of ids');
|
||||
assert.equal(_.uniq(ids).length, ids.length, 'can generate a globally-unique stream of ids');
|
||||
});
|
||||
|
||||
test('times', function() {
|
||||
test('times', function(assert) {
|
||||
var vals = [];
|
||||
_.times(3, function(i) { vals.push(i); });
|
||||
deepEqual(vals, [0, 1, 2], 'is 0 indexed');
|
||||
assert.deepEqual(vals, [0, 1, 2], 'is 0 indexed');
|
||||
//
|
||||
vals = [];
|
||||
_(3).times(function(i) { vals.push(i); });
|
||||
deepEqual(vals, [0, 1, 2], 'works as a wrapper');
|
||||
assert.deepEqual(vals, [0, 1, 2], 'works as a wrapper');
|
||||
// collects return values
|
||||
deepEqual([0, 1, 2], _.times(3, function(i) { return i; }), 'collects return values');
|
||||
assert.deepEqual([0, 1, 2], _.times(3, function(i) { return i; }), 'collects return values');
|
||||
|
||||
deepEqual(_.times(0, _.identity), []);
|
||||
deepEqual(_.times(-1, _.identity), []);
|
||||
deepEqual(_.times(parseFloat('-Infinity'), _.identity), []);
|
||||
assert.deepEqual(_.times(0, _.identity), []);
|
||||
assert.deepEqual(_.times(-1, _.identity), []);
|
||||
assert.deepEqual(_.times(parseFloat('-Infinity'), _.identity), []);
|
||||
});
|
||||
|
||||
test('mixin', function() {
|
||||
test('mixin', function(assert) {
|
||||
_.mixin({
|
||||
myReverse: function(string) {
|
||||
return string.split('').reverse().join('');
|
||||
}
|
||||
});
|
||||
equal(_.myReverse('panacea'), 'aecanap', 'mixed in a function to _');
|
||||
equal(_('champ').myReverse(), 'pmahc', 'mixed in a function to the OOP wrapper');
|
||||
assert.equal(_.myReverse('panacea'), 'aecanap', 'mixed in a function to _');
|
||||
assert.equal(_('champ').myReverse(), 'pmahc', 'mixed in a function to the OOP wrapper');
|
||||
});
|
||||
|
||||
test('_.escape', function() {
|
||||
equal(_.escape(null), '');
|
||||
test('_.escape', function(assert) {
|
||||
assert.equal(_.escape(null), '');
|
||||
});
|
||||
|
||||
test('_.unescape', function() {
|
||||
test('_.unescape', function(assert) {
|
||||
var string = 'Curly & Moe';
|
||||
equal(_.unescape(null), '');
|
||||
equal(_.unescape(_.escape(string)), string);
|
||||
equal(_.unescape(string), string, 'don\'t unescape unnecessarily');
|
||||
assert.equal(_.unescape(null), '');
|
||||
assert.equal(_.unescape(_.escape(string)), string);
|
||||
assert.equal(_.unescape(string), string, 'don\'t unescape unnecessarily');
|
||||
});
|
||||
|
||||
// Don't care what they escape them to just that they're escaped and can be unescaped
|
||||
test('_.escape & unescape', function() {
|
||||
test('_.escape & unescape', function(assert) {
|
||||
// test & (&) seperately obviously
|
||||
var escapeCharacters = ['<', '>', '"', '\'', '`'];
|
||||
|
||||
_.each(escapeCharacters, function(escapeChar) {
|
||||
var s = 'a ' + escapeChar + ' string escaped';
|
||||
var e = _.escape(s);
|
||||
notEqual(s, e, escapeChar + ' is escaped');
|
||||
equal(s, _.unescape(e), escapeChar + ' can be unescaped');
|
||||
assert.notEqual(s, e, escapeChar + ' is escaped');
|
||||
assert.equal(s, _.unescape(e), escapeChar + ' can be unescaped');
|
||||
|
||||
s = 'a ' + escapeChar + escapeChar + escapeChar + 'some more string' + escapeChar;
|
||||
e = _.escape(s);
|
||||
|
||||
equal(e.indexOf(escapeChar), -1, 'can escape multiple occurances of ' + escapeChar);
|
||||
equal(_.unescape(e), s, 'multiple occurrences of ' + escapeChar + ' can be unescaped');
|
||||
assert.equal(e.indexOf(escapeChar), -1, 'can escape multiple occurances of ' + escapeChar);
|
||||
assert.equal(_.unescape(e), s, 'multiple occurrences of ' + escapeChar + ' can be unescaped');
|
||||
});
|
||||
|
||||
// handles multiple escape characters at once
|
||||
var joiner = ' other stuff ';
|
||||
var allEscaped = escapeCharacters.join(joiner);
|
||||
allEscaped += allEscaped;
|
||||
ok(_.every(escapeCharacters, function(escapeChar) {
|
||||
assert.ok(_.every(escapeCharacters, function(escapeChar) {
|
||||
return allEscaped.indexOf(escapeChar) !== -1;
|
||||
}), 'handles multiple characters');
|
||||
ok(allEscaped.indexOf(joiner) >= 0, 'can escape multiple escape characters at the same time');
|
||||
assert.ok(allEscaped.indexOf(joiner) >= 0, 'can escape multiple escape characters at the same time');
|
||||
|
||||
// test & -> &
|
||||
var str = 'some string & another string & yet another';
|
||||
var escaped = _.escape(str);
|
||||
|
||||
ok(escaped.indexOf('&') !== -1, 'handles & aka &');
|
||||
equal(_.unescape(str), str, 'can unescape &');
|
||||
assert.ok(escaped.indexOf('&') !== -1, 'handles & aka &');
|
||||
assert.equal(_.unescape(str), str, 'can unescape &');
|
||||
});
|
||||
|
||||
test('template', function() {
|
||||
test('template', function(assert) {
|
||||
var basicTemplate = _.template("<%= thing %> is gettin' on my noives!");
|
||||
var result = basicTemplate({thing: 'This'});
|
||||
equal(result, "This is gettin' on my noives!", 'can do basic attribute interpolation');
|
||||
assert.equal(result, "This is gettin' on my noives!", 'can do basic attribute interpolation');
|
||||
|
||||
var sansSemicolonTemplate = _.template('A <% this %> B');
|
||||
equal(sansSemicolonTemplate(), 'A B');
|
||||
assert.equal(sansSemicolonTemplate(), 'A B');
|
||||
|
||||
var backslashTemplate = _.template('<%= thing %> is \\ridanculous');
|
||||
equal(backslashTemplate({thing: 'This'}), 'This is \\ridanculous');
|
||||
assert.equal(backslashTemplate({thing: 'This'}), 'This is \\ridanculous');
|
||||
|
||||
var escapeTemplate = _.template('<%= a ? "checked=\\"checked\\"" : "" %>');
|
||||
equal(escapeTemplate({a: true}), 'checked="checked"', 'can handle slash escapes in interpolations.');
|
||||
assert.equal(escapeTemplate({a: true}), 'checked="checked"', 'can handle slash escapes in interpolations.');
|
||||
|
||||
var fancyTemplate = _.template('<ul><% ' +
|
||||
' for (var key in people) { ' +
|
||||
'%><li><%= people[key] %></li><% } %></ul>');
|
||||
result = fancyTemplate({people: {moe: 'Moe', larry: 'Larry', curly: 'Curly'}});
|
||||
equal(result, '<ul><li>Moe</li><li>Larry</li><li>Curly</li></ul>', 'can run arbitrary javascript in templates');
|
||||
assert.equal(result, '<ul><li>Moe</li><li>Larry</li><li>Curly</li></ul>', 'can run arbitrary javascript in templates');
|
||||
|
||||
var escapedCharsInJavascriptTemplate = _.template('<ul><% _.each(numbers.split("\\n"), function(item) { %><li><%= item %></li><% }) %></ul>');
|
||||
result = escapedCharsInJavascriptTemplate({numbers: 'one\ntwo\nthree\nfour'});
|
||||
equal(result, '<ul><li>one</li><li>two</li><li>three</li><li>four</li></ul>', 'Can use escaped characters (e.g. \\n) in JavaScript');
|
||||
assert.equal(result, '<ul><li>one</li><li>two</li><li>three</li><li>four</li></ul>', 'Can use escaped characters (e.g. \\n) in JavaScript');
|
||||
|
||||
var namespaceCollisionTemplate = _.template('<%= pageCount %> <%= thumbnails[pageCount] %> <% _.each(thumbnails, function(p) { %><div class="thumbnail" rel="<%= p %>"></div><% }); %>');
|
||||
result = namespaceCollisionTemplate({
|
||||
@@ -220,32 +222,32 @@
|
||||
3: 'p3-thumbnail.gif'
|
||||
}
|
||||
});
|
||||
equal(result, '3 p3-thumbnail.gif <div class="thumbnail" rel="p1-thumbnail.gif"></div><div class="thumbnail" rel="p2-thumbnail.gif"></div><div class="thumbnail" rel="p3-thumbnail.gif"></div>');
|
||||
assert.equal(result, '3 p3-thumbnail.gif <div class="thumbnail" rel="p1-thumbnail.gif"></div><div class="thumbnail" rel="p2-thumbnail.gif"></div><div class="thumbnail" rel="p3-thumbnail.gif"></div>');
|
||||
|
||||
var noInterpolateTemplate = _.template('<div><p>Just some text. Hey, I know this is silly but it aids consistency.</p></div>');
|
||||
result = noInterpolateTemplate();
|
||||
equal(result, '<div><p>Just some text. Hey, I know this is silly but it aids consistency.</p></div>');
|
||||
assert.equal(result, '<div><p>Just some text. Hey, I know this is silly but it aids consistency.</p></div>');
|
||||
|
||||
var quoteTemplate = _.template("It's its, not it's");
|
||||
equal(quoteTemplate({}), "It's its, not it's");
|
||||
assert.equal(quoteTemplate({}), "It's its, not it's");
|
||||
|
||||
var quoteInStatementAndBody = _.template('<% ' +
|
||||
" if(foo == 'bar'){ " +
|
||||
"%>Statement quotes and 'quotes'.<% } %>");
|
||||
equal(quoteInStatementAndBody({foo: 'bar'}), "Statement quotes and 'quotes'.");
|
||||
assert.equal(quoteInStatementAndBody({foo: 'bar'}), "Statement quotes and 'quotes'.");
|
||||
|
||||
var withNewlinesAndTabs = _.template('This\n\t\tis: <%= x %>.\n\tok.\nend.');
|
||||
equal(withNewlinesAndTabs({x: 'that'}), 'This\n\t\tis: that.\n\tok.\nend.');
|
||||
assert.equal(withNewlinesAndTabs({x: 'that'}), 'This\n\t\tis: that.\n\tok.\nend.');
|
||||
|
||||
var template = _.template('<i><%- value %></i>');
|
||||
result = template({value: '<script>'});
|
||||
equal(result, '<i><script></i>');
|
||||
assert.equal(result, '<i><script></i>');
|
||||
|
||||
var stooge = {
|
||||
name: 'Moe',
|
||||
template: _.template("I'm <%= this.name %>")
|
||||
};
|
||||
equal(stooge.template(), "I'm Moe");
|
||||
assert.equal(stooge.template(), "I'm Moe");
|
||||
|
||||
template = _.template('\n ' +
|
||||
' <%\n ' +
|
||||
@@ -253,7 +255,7 @@
|
||||
' if (data) { data += 12345; }; %>\n ' +
|
||||
' <li><%= data %></li>\n '
|
||||
);
|
||||
equal(template({data: 12345}).replace(/\s/g, ''), '<li>24690</li>');
|
||||
assert.equal(template({data: 12345}).replace(/\s/g, ''), '<li>24690</li>');
|
||||
|
||||
_.templateSettings = {
|
||||
evaluate: /\{\{([\s\S]+?)\}\}/g,
|
||||
@@ -262,13 +264,13 @@
|
||||
|
||||
var custom = _.template('<ul>{{ for (var key in people) { }}<li>{{= people[key] }}</li>{{ } }}</ul>');
|
||||
result = custom({people: {moe: 'Moe', larry: 'Larry', curly: 'Curly'}});
|
||||
equal(result, '<ul><li>Moe</li><li>Larry</li><li>Curly</li></ul>', 'can run arbitrary javascript in templates');
|
||||
assert.equal(result, '<ul><li>Moe</li><li>Larry</li><li>Curly</li></ul>', 'can run arbitrary javascript in templates');
|
||||
|
||||
var customQuote = _.template("It's its, not it's");
|
||||
equal(customQuote({}), "It's its, not it's");
|
||||
assert.equal(customQuote({}), "It's its, not it's");
|
||||
|
||||
quoteInStatementAndBody = _.template("{{ if(foo == 'bar'){ }}Statement quotes and 'quotes'.{{ } }}");
|
||||
equal(quoteInStatementAndBody({foo: 'bar'}), "Statement quotes and 'quotes'.");
|
||||
assert.equal(quoteInStatementAndBody({foo: 'bar'}), "Statement quotes and 'quotes'.");
|
||||
|
||||
_.templateSettings = {
|
||||
evaluate: /<\?([\s\S]+?)\?>/g,
|
||||
@@ -277,136 +279,136 @@
|
||||
|
||||
var customWithSpecialChars = _.template('<ul><? for (var key in people) { ?><li><?= people[key] ?></li><? } ?></ul>');
|
||||
result = customWithSpecialChars({people: {moe: 'Moe', larry: 'Larry', curly: 'Curly'}});
|
||||
equal(result, '<ul><li>Moe</li><li>Larry</li><li>Curly</li></ul>', 'can run arbitrary javascript in templates');
|
||||
assert.equal(result, '<ul><li>Moe</li><li>Larry</li><li>Curly</li></ul>', 'can run arbitrary javascript in templates');
|
||||
|
||||
var customWithSpecialCharsQuote = _.template("It's its, not it's");
|
||||
equal(customWithSpecialCharsQuote({}), "It's its, not it's");
|
||||
assert.equal(customWithSpecialCharsQuote({}), "It's its, not it's");
|
||||
|
||||
quoteInStatementAndBody = _.template("<? if(foo == 'bar'){ ?>Statement quotes and 'quotes'.<? } ?>");
|
||||
equal(quoteInStatementAndBody({foo: 'bar'}), "Statement quotes and 'quotes'.");
|
||||
assert.equal(quoteInStatementAndBody({foo: 'bar'}), "Statement quotes and 'quotes'.");
|
||||
|
||||
_.templateSettings = {
|
||||
interpolate: /\{\{(.+?)\}\}/g
|
||||
};
|
||||
|
||||
var mustache = _.template('Hello {{planet}}!');
|
||||
equal(mustache({planet: 'World'}), 'Hello World!', 'can mimic mustache.js');
|
||||
assert.equal(mustache({planet: 'World'}), 'Hello World!', 'can mimic mustache.js');
|
||||
|
||||
var templateWithNull = _.template('a null undefined {{planet}}');
|
||||
equal(templateWithNull({planet: 'world'}), 'a null undefined world', 'can handle missing escape and evaluate settings');
|
||||
assert.equal(templateWithNull({planet: 'world'}), 'a null undefined world', 'can handle missing escape and evaluate settings');
|
||||
});
|
||||
|
||||
test('_.template provides the generated function source, when a SyntaxError occurs', function() {
|
||||
test('_.template provides the generated function source, when a SyntaxError occurs', function(assert) {
|
||||
var source;
|
||||
try {
|
||||
_.template('<b><%= if x %></b>');
|
||||
} catch (ex) {
|
||||
source = ex.source;
|
||||
}
|
||||
ok(/__p/.test(source));
|
||||
assert.ok(/__p/.test(source));
|
||||
});
|
||||
|
||||
test('_.template handles \\u2028 & \\u2029', function() {
|
||||
test('_.template handles \\u2028 & \\u2029', function(assert) {
|
||||
var tmpl = _.template('<p>\u2028<%= "\\u2028\\u2029" %>\u2029</p>');
|
||||
strictEqual(tmpl(), '<p>\u2028\u2028\u2029\u2029</p>');
|
||||
assert.strictEqual(tmpl(), '<p>\u2028\u2028\u2029\u2029</p>');
|
||||
});
|
||||
|
||||
test('result calls functions and returns primitives', function() {
|
||||
test('result calls functions and returns primitives', function(assert) {
|
||||
var obj = {w: '', x: 'x', y: function(){ return this.x; }};
|
||||
strictEqual(_.result(obj, 'w'), '');
|
||||
strictEqual(_.result(obj, 'x'), 'x');
|
||||
strictEqual(_.result(obj, 'y'), 'x');
|
||||
strictEqual(_.result(obj, 'z'), void 0);
|
||||
strictEqual(_.result(null, 'x'), void 0);
|
||||
assert.strictEqual(_.result(obj, 'w'), '');
|
||||
assert.strictEqual(_.result(obj, 'x'), 'x');
|
||||
assert.strictEqual(_.result(obj, 'y'), 'x');
|
||||
assert.strictEqual(_.result(obj, 'z'), void 0);
|
||||
assert.strictEqual(_.result(null, 'x'), void 0);
|
||||
});
|
||||
|
||||
test('result returns a default value if object is null or undefined', function() {
|
||||
strictEqual(_.result(null, 'b', 'default'), 'default');
|
||||
strictEqual(_.result(void 0, 'c', 'default'), 'default');
|
||||
strictEqual(_.result(''.match('missing'), 1, 'default'), 'default');
|
||||
test('result returns a default value if object is null or undefined', function(assert) {
|
||||
assert.strictEqual(_.result(null, 'b', 'default'), 'default');
|
||||
assert.strictEqual(_.result(void 0, 'c', 'default'), 'default');
|
||||
assert.strictEqual(_.result(''.match('missing'), 1, 'default'), 'default');
|
||||
});
|
||||
|
||||
test('result returns a default value if property of object is missing', function() {
|
||||
strictEqual(_.result({d: null}, 'd', 'default'), null);
|
||||
strictEqual(_.result({e: false}, 'e', 'default'), false);
|
||||
test('result returns a default value if property of object is missing', function(assert) {
|
||||
assert.strictEqual(_.result({d: null}, 'd', 'default'), null);
|
||||
assert.strictEqual(_.result({e: false}, 'e', 'default'), false);
|
||||
});
|
||||
|
||||
test('result only returns the default value if the object does not have the property or is undefined', function() {
|
||||
strictEqual(_.result({}, 'b', 'default'), 'default');
|
||||
strictEqual(_.result({d: void 0}, 'd', 'default'), 'default');
|
||||
test('result only returns the default value if the object does not have the property or is undefined', function(assert) {
|
||||
assert.strictEqual(_.result({}, 'b', 'default'), 'default');
|
||||
assert.strictEqual(_.result({d: void 0}, 'd', 'default'), 'default');
|
||||
});
|
||||
|
||||
test('result does not return the default if the property of an object is found in the prototype', function() {
|
||||
test('result does not return the default if the property of an object is found in the prototype', function(assert) {
|
||||
var Foo = function(){};
|
||||
Foo.prototype.bar = 1;
|
||||
strictEqual(_.result(new Foo, 'bar', 2), 1);
|
||||
assert.strictEqual(_.result(new Foo, 'bar', 2), 1);
|
||||
});
|
||||
|
||||
test('result does use the fallback when the result of invoking the property is undefined', function() {
|
||||
test('result does use the fallback when the result of invoking the property is undefined', function(assert) {
|
||||
var obj = {a: function() {}};
|
||||
strictEqual(_.result(obj, 'a', 'failed'), void 0);
|
||||
assert.strictEqual(_.result(obj, 'a', 'failed'), void 0);
|
||||
});
|
||||
|
||||
test('result fallback can use a function', function() {
|
||||
test('result fallback can use a function', function(assert) {
|
||||
var obj = {a: [1, 2, 3]};
|
||||
strictEqual(_.result(obj, 'b', _.constant(5)), 5);
|
||||
strictEqual(_.result(obj, 'b', function() {
|
||||
assert.strictEqual(_.result(obj, 'b', _.constant(5)), 5);
|
||||
assert.strictEqual(_.result(obj, 'b', function() {
|
||||
return this.a;
|
||||
}), obj.a, 'called with context');
|
||||
});
|
||||
|
||||
test('_.templateSettings.variable', function() {
|
||||
test('_.templateSettings.variable', function(assert) {
|
||||
var s = '<%=data.x%>';
|
||||
var data = {x: 'x'};
|
||||
var tmp = _.template(s, {variable: 'data'});
|
||||
strictEqual(tmp(data), 'x');
|
||||
assert.strictEqual(tmp(data), 'x');
|
||||
_.templateSettings.variable = 'data';
|
||||
strictEqual(_.template(s)(data), 'x');
|
||||
assert.strictEqual(_.template(s)(data), 'x');
|
||||
});
|
||||
|
||||
test('#547 - _.templateSettings is unchanged by custom settings.', function() {
|
||||
ok(!_.templateSettings.variable);
|
||||
test('#547 - _.templateSettings is unchanged by custom settings.', function(assert) {
|
||||
assert.ok(!_.templateSettings.variable);
|
||||
_.template('', {}, {variable: 'x'});
|
||||
ok(!_.templateSettings.variable);
|
||||
assert.ok(!_.templateSettings.variable);
|
||||
});
|
||||
|
||||
test('#556 - undefined template variables.', function() {
|
||||
test('#556 - undefined template variables.', function(assert) {
|
||||
var template = _.template('<%=x%>');
|
||||
strictEqual(template({x: null}), '');
|
||||
strictEqual(template({x: void 0}), '');
|
||||
assert.strictEqual(template({x: null}), '');
|
||||
assert.strictEqual(template({x: void 0}), '');
|
||||
|
||||
var templateEscaped = _.template('<%-x%>');
|
||||
strictEqual(templateEscaped({x: null}), '');
|
||||
strictEqual(templateEscaped({x: void 0}), '');
|
||||
assert.strictEqual(templateEscaped({x: null}), '');
|
||||
assert.strictEqual(templateEscaped({x: void 0}), '');
|
||||
|
||||
var templateWithProperty = _.template('<%=x.foo%>');
|
||||
strictEqual(templateWithProperty({x: {}}), '');
|
||||
strictEqual(templateWithProperty({x: {}}), '');
|
||||
assert.strictEqual(templateWithProperty({x: {}}), '');
|
||||
assert.strictEqual(templateWithProperty({x: {}}), '');
|
||||
|
||||
var templateWithPropertyEscaped = _.template('<%-x.foo%>');
|
||||
strictEqual(templateWithPropertyEscaped({x: {}}), '');
|
||||
strictEqual(templateWithPropertyEscaped({x: {}}), '');
|
||||
assert.strictEqual(templateWithPropertyEscaped({x: {}}), '');
|
||||
assert.strictEqual(templateWithPropertyEscaped({x: {}}), '');
|
||||
});
|
||||
|
||||
test('interpolate evaluates code only once.', 2, function() {
|
||||
test('interpolate evaluates code only once.', 2, function(assert) {
|
||||
var count = 0;
|
||||
var template = _.template('<%= f() %>');
|
||||
template({f: function(){ ok(!count++); }});
|
||||
template({f: function(){ assert.ok(!count++); }});
|
||||
|
||||
var countEscaped = 0;
|
||||
var templateEscaped = _.template('<%- f() %>');
|
||||
templateEscaped({f: function(){ ok(!countEscaped++); }});
|
||||
templateEscaped({f: function(){ assert.ok(!countEscaped++); }});
|
||||
});
|
||||
|
||||
test('#746 - _.template settings are not modified.', 1, function() {
|
||||
test('#746 - _.template settings are not modified.', 1, function(assert) {
|
||||
var settings = {};
|
||||
_.template('', null, settings);
|
||||
deepEqual(settings, {});
|
||||
assert.deepEqual(settings, {});
|
||||
});
|
||||
|
||||
test('#779 - delimeters are applied to unescaped text.', 1, function() {
|
||||
test('#779 - delimeters are applied to unescaped text.', 1, function(assert) {
|
||||
var template = _.template('<<\nx\n>>', null, {evaluate: /<<(.*?)>>/g});
|
||||
strictEqual(template(), '<<\nx\n>>');
|
||||
assert.strictEqual(template(), '<<\nx\n>>');
|
||||
});
|
||||
|
||||
}());
|
||||
|
||||
97
vendor/underscore/underscore.js
vendored
97
vendor/underscore/underscore.js
vendored
@@ -11,8 +11,8 @@
|
||||
// Establish the root object, `window` (`self`) in the browser, `global`
|
||||
// on the server, or `this` in some virtual machines. We use `self`
|
||||
// instead of `window` for `WebWorker` support.
|
||||
var root = typeof self === 'object' && self.self === self && self ||
|
||||
typeof global === 'object' && global.global === global && global ||
|
||||
var root = typeof self == 'object' && self.self === self && self ||
|
||||
typeof global == 'object' && global.global === global && global ||
|
||||
this;
|
||||
|
||||
// Save the previous value of the `_` variable.
|
||||
@@ -48,8 +48,10 @@
|
||||
// Export the Underscore object for **Node.js**, with
|
||||
// backwards-compatibility for their old module API. If we're in
|
||||
// the browser, add `_` as a global object.
|
||||
if (typeof exports !== 'undefined') {
|
||||
if (typeof module !== 'undefined' && module.exports) {
|
||||
// (`nodeType` is checked to ensure that `module`
|
||||
// and `exports` are not HTML elements.)
|
||||
if (typeof exports != 'undefined' && !exports.nodeType) {
|
||||
if (typeof module != 'undefined' && !module.nodeType && module.exports) {
|
||||
exports = module.exports = _;
|
||||
}
|
||||
exports._ = _;
|
||||
@@ -83,15 +85,17 @@
|
||||
};
|
||||
};
|
||||
|
||||
// A mostly-internal function to generate callbacks that can be applied
|
||||
// to each element in a collection, returning the desired result — either
|
||||
// identity, an arbitrary callback, a property matcher, or a property accessor.
|
||||
// An internal function to generate callbacks that can be applied to each
|
||||
// element in a collection, returning the desired result — either `identity`,
|
||||
// an arbitrary callback, a property matcher, or a property accessor.
|
||||
var cb = function(value, context, argCount) {
|
||||
if (value == null) return _.identity;
|
||||
if (_.isFunction(value)) return optimizeCb(value, context, argCount);
|
||||
if (_.isObject(value)) return _.matcher(value);
|
||||
return _.property(value);
|
||||
};
|
||||
|
||||
// An external wrapper for the internal callback generator
|
||||
_.iteratee = function(value, context) {
|
||||
return cb(value, context, Infinity);
|
||||
};
|
||||
@@ -137,7 +141,7 @@
|
||||
};
|
||||
|
||||
// Helper for collection methods to determine whether a collection
|
||||
// should be iterated as an array or as an object
|
||||
// should be iterated as an array or as an object.
|
||||
// Related: http://people.mozilla.org/~jorendorff/es6-draft.html#sec-tolength
|
||||
// Avoids a very nasty iOS 8 JIT bug on ARM-64. #2094
|
||||
var MAX_ARRAY_INDEX = Math.pow(2, 53) - 1;
|
||||
@@ -184,8 +188,8 @@
|
||||
|
||||
// Create a reducing function iterating left or right.
|
||||
var createReduce = function(dir) {
|
||||
// Optimized iterator function as using arguments.length
|
||||
// in the main function will deoptimize the, see #1991.
|
||||
// Wrap code that reassigns argument variables in a separate function than
|
||||
// the one that accesses `arguments.length` to avoid a perf hit. (#1191)
|
||||
var reducer = function(obj, iteratee, memo, initial) {
|
||||
var keys = !isArrayLike(obj) && _.keys(obj),
|
||||
length = (keys || obj).length,
|
||||
@@ -309,7 +313,7 @@
|
||||
obj = isArrayLike(obj) ? obj : _.values(obj);
|
||||
for (var i = 0, length = obj.length; i < length; i++) {
|
||||
value = obj[i];
|
||||
if (value > result) {
|
||||
if (value != null && value > result) {
|
||||
result = value;
|
||||
}
|
||||
}
|
||||
@@ -334,7 +338,7 @@
|
||||
obj = isArrayLike(obj) ? obj : _.values(obj);
|
||||
for (var i = 0, length = obj.length; i < length; i++) {
|
||||
value = obj[i];
|
||||
if (value < result) {
|
||||
if (value != null && value < result) {
|
||||
result = value;
|
||||
}
|
||||
}
|
||||
@@ -431,10 +435,15 @@
|
||||
if (_.has(result, key)) result[key]++; else result[key] = 1;
|
||||
});
|
||||
|
||||
var reStrSymbol = /[^\ud800-\udfff]|[\ud800-\udbff][\udc00-\udfff]|[\ud800-\udfff]/g;
|
||||
// Safely create a real, live array from anything iterable.
|
||||
_.toArray = function(obj) {
|
||||
if (!obj) return [];
|
||||
if (_.isArray(obj)) return slice.call(obj);
|
||||
if (_.isString(obj)) {
|
||||
// Keep surrogate pair characters together
|
||||
return obj.match(reStrSymbol);
|
||||
}
|
||||
if (isArrayLike(obj)) return _.map(obj, _.identity);
|
||||
return _.values(obj);
|
||||
};
|
||||
@@ -497,7 +506,7 @@
|
||||
for (var i = 0, length = getLength(input); i < length; i++) {
|
||||
var value = input[i];
|
||||
if (isArrayLike(value) && (_.isArray(value) || _.isArguments(value))) {
|
||||
//flatten current level of array or arguments object
|
||||
// Flatten current level of array or arguments object
|
||||
if (shallow) {
|
||||
var j = 0, len = value.length;
|
||||
while (j < len) output[idx++] = value[j++];
|
||||
@@ -685,7 +694,9 @@
|
||||
stop = start || 0;
|
||||
start = 0;
|
||||
}
|
||||
step = step || 1;
|
||||
if (!step) {
|
||||
step = stop < start ? -1 : 1;
|
||||
}
|
||||
|
||||
var length = Math.max(Math.ceil((stop - start) / step), 0);
|
||||
var range = Array(length);
|
||||
@@ -782,7 +793,7 @@
|
||||
// Delays a function for the given number of milliseconds, and then calls
|
||||
// it with the arguments supplied.
|
||||
_.delay = restArgs(function(func, wait, args) {
|
||||
return setTimeout(function(){
|
||||
return setTimeout(function() {
|
||||
return func.apply(null, args);
|
||||
}, wait);
|
||||
});
|
||||
@@ -797,17 +808,18 @@
|
||||
// but if you'd like to disable the execution on the leading edge, pass
|
||||
// `{leading: false}`. To disable execution on the trailing edge, ditto.
|
||||
_.throttle = function(func, wait, options) {
|
||||
var context, args, result;
|
||||
var timeout = null;
|
||||
var timeout, context, args, result;
|
||||
var previous = 0;
|
||||
if (!options) options = {};
|
||||
|
||||
var later = function() {
|
||||
previous = options.leading === false ? 0 : _.now();
|
||||
timeout = null;
|
||||
result = func.apply(context, args);
|
||||
if (!timeout) context = args = null;
|
||||
};
|
||||
return function() {
|
||||
|
||||
var throttled = function() {
|
||||
var now = _.now();
|
||||
if (!previous && options.leading === false) previous = now;
|
||||
var remaining = wait - (now - previous);
|
||||
@@ -826,6 +838,14 @@
|
||||
}
|
||||
return result;
|
||||
};
|
||||
|
||||
throttled.cancel = function() {
|
||||
clearTimeout(timeout);
|
||||
previous = 0;
|
||||
timeout = context = args = null;
|
||||
};
|
||||
|
||||
return throttled;
|
||||
};
|
||||
|
||||
// Returns a function, that, as long as it continues to be invoked, will not
|
||||
@@ -833,35 +853,32 @@
|
||||
// N milliseconds. If `immediate` is passed, trigger the function on the
|
||||
// leading edge, instead of the trailing.
|
||||
_.debounce = function(func, wait, immediate) {
|
||||
var timeout, args, context, timestamp, result;
|
||||
var timeout, result;
|
||||
|
||||
var later = function() {
|
||||
var last = _.now() - timestamp;
|
||||
|
||||
if (last < wait && last >= 0) {
|
||||
timeout = setTimeout(later, wait - last);
|
||||
} else {
|
||||
timeout = null;
|
||||
if (!immediate) {
|
||||
result = func.apply(context, args);
|
||||
if (!timeout) context = args = null;
|
||||
}
|
||||
}
|
||||
var later = function(context, args) {
|
||||
timeout = null;
|
||||
if (args) result = func.apply(context, args);
|
||||
};
|
||||
|
||||
return function() {
|
||||
context = this;
|
||||
args = arguments;
|
||||
timestamp = _.now();
|
||||
var debounced = restArgs(function(args) {
|
||||
var callNow = immediate && !timeout;
|
||||
if (!timeout) timeout = setTimeout(later, wait);
|
||||
if (timeout) clearTimeout(timeout);
|
||||
if (callNow) {
|
||||
result = func.apply(context, args);
|
||||
context = args = null;
|
||||
timeout = setTimeout(later, wait);
|
||||
result = func.apply(this, args);
|
||||
} else if (!immediate) {
|
||||
timeout = _.delay(later, wait, this, args);
|
||||
}
|
||||
|
||||
return result;
|
||||
});
|
||||
|
||||
debounced.cancel = function() {
|
||||
clearTimeout(timeout);
|
||||
timeout = null;
|
||||
};
|
||||
|
||||
return debounced;
|
||||
};
|
||||
|
||||
// Returns the first function passed as an argument to the second,
|
||||
@@ -1148,7 +1165,7 @@
|
||||
if (a !== a) return b !== b;
|
||||
// Exhaust primitive checks
|
||||
var type = typeof a;
|
||||
if (type !== 'function' && type !== 'object' && typeof b !== 'object') return false;
|
||||
if (type !== 'function' && type !== 'object' && typeof b != 'object') return false;
|
||||
return deepEq(a, b, aStack, bStack);
|
||||
};
|
||||
|
||||
@@ -1598,7 +1615,7 @@
|
||||
// popular enough to be bundled in a third party lib, but not be part of
|
||||
// an AMD load request. Those cases could generate an error when an
|
||||
// anonymous define() is called outside of a loader request.
|
||||
if (typeof define === 'function' && define.amd) {
|
||||
if (typeof define == 'function' && define.amd) {
|
||||
define('underscore', [], function() {
|
||||
return _;
|
||||
});
|
||||
|
||||
Reference in New Issue
Block a user