Mirrors/lodash
1
0
Fork 0
mirror of https://github.com/whoisclebs/lodash.git synced 2026-02-10 19:07:49 +00:00
Code Issues Packages Projects Releases Wiki Activity

Update lazy tests using larger arrays.

Browse Source
This commit is contained in:
jdalton
2015-06-06 14:53:45 -07:00
parent e143936a82
commit ab981ce15a
1 changed files with 170 additions and 211 deletions
Download Patch File Download Diff File Expand all files Collapse all files

381
test/test.js
View File

@@ -2161,10 +2161,10 @@
test('should work in a lazy chain sequence', 1, function() { test('should work in a lazy chain sequence', 1, function() {
if (!isNpm) { if (!isNpm) {
var array = [1, null, 3], var array = _.range(0, LARGE_ARRAY_SIZE).concat(null),
actual = _(array).map(square).compact().reverse().take().value(); actual = _(array).slice(1).compact().reverse().take().value();
deepEqual(actual, [9]); deepEqual(actual, _.take(_.compact(_.slice(array, 1)).reverse()));
} }
else { else {
skipTest(); skipTest();
@@ -2408,11 +2408,15 @@
test('should work in a lazy chain sequence', 1, function() { test('should work in a lazy chain sequence', 1, function() {
if (!isNpm) { if (!isNpm) {
var array = [1, 2, 1, 3], var array = _.range(LARGE_ARRAY_SIZE).concat(
predicate = function(value) { return value > 2; }, _.range(Math.floor(LARGE_ARRAY_SIZE / 2), LARGE_ARRAY_SIZE),
actual = _(array).countBy(_.identity).map(square).filter(predicate).take().value(); _.range(Math.floor(LARGE_ARRAY_SIZE / 1.5), LARGE_ARRAY_SIZE)
);
deepEqual(actual, [4]); var predicate = function(value) { return value > 2; },
actual = _(array).countBy().map(square).filter(predicate).take().value();
deepEqual(actual, _.take(_.filter(_.map(_.countBy(array), square), predicate)));
} }
else { else {
skipTest(); skipTest();
@@ -3862,25 +3866,25 @@
test('should work in a lazy chain sequence', 6, function() { test('should work in a lazy chain sequence', 6, function() {
if (!isNpm) { if (!isNpm) {
var array = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], var array = _.range(1, LARGE_ARRAY_SIZE + 1),
values = [], values = [],
predicate = function(value) { values.push(value); return value > 2; }, predicate = function(value) { values.push(value); return value > 2; },
actual = _(array).drop(2).drop().value(); actual = _(array).drop(2).drop().value();
deepEqual(actual, [4, 5, 6, 7, 8, 9, 10]); deepEqual(actual, array.slice(3));
actual = _(array).filter(predicate).drop(2).drop().value(); actual = _(array).filter(predicate).drop(2).drop().value();
deepEqual(actual, [6, 7, 8, 9, 10]);
deepEqual(values, array); deepEqual(values, array);
deepEqual(actual, _.drop(_.drop(_.filter(array, predicate), 2)));
actual = _(array).drop(2).dropRight().drop().dropRight(2).value(); actual = _(array).drop(2).dropRight().drop().dropRight(2).value();
deepEqual(actual, [4, 5, 6, 7]); deepEqual(actual, _.dropRight(_.drop(_.dropRight(_.drop(array, 2))), 2));
values = []; values = [];
actual = _(array).drop().filter(predicate).drop(2).dropRight().drop().dropRight(2).value(); actual = _(array).drop().filter(predicate).drop(2).dropRight().drop().dropRight(2).value();
deepEqual(actual, [6, 7]);
deepEqual(values, array.slice(1)); deepEqual(values, array.slice(1));
deepEqual(actual, _.dropRight(_.drop(_.dropRight(_.drop(_.filter(_.drop(array), predicate), 2))), 2));
} }
else { else {
skipTest(6); skipTest(6);
@@ -3932,25 +3936,25 @@
test('should work in a lazy chain sequence', 6, function() { test('should work in a lazy chain sequence', 6, function() {
if (!isNpm) { if (!isNpm) {
var array = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], var array = _.range(1, LARGE_ARRAY_SIZE + 1),
values = [], values = [],
predicate = function(value) { values.push(value); return value < 9; }, predicate = function(value) { values.push(value); return value < 9; },
actual = _(array).dropRight(2).dropRight().value(); actual = _(array).dropRight(2).dropRight().value();
deepEqual(actual, [1, 2, 3, 4, 5, 6, 7]); deepEqual(actual, array.slice(0, -3));
actual = _(array).filter(predicate).dropRight(2).dropRight().value(); actual = _(array).filter(predicate).dropRight(2).dropRight().value();
deepEqual(actual, [1, 2, 3, 4, 5]);
deepEqual(values, array); deepEqual(values, array);
deepEqual(actual, _.dropRight(_.dropRight(_.filter(array, predicate), 2)));
actual = _(array).dropRight(2).drop().dropRight().drop(2).value(); actual = _(array).dropRight(2).drop().dropRight().drop(2).value();
deepEqual(actual, [4, 5, 6, 7]); deepEqual(actual, _.drop(_.dropRight(_.drop(_.dropRight(array, 2))), 2));
values = []; values = [];
actual = _(array).dropRight().filter(predicate).dropRight(2).drop().dropRight().drop(2).value(); actual = _(array).dropRight().filter(predicate).dropRight(2).drop().dropRight().drop(2).value();
deepEqual(actual, [4, 5]);
deepEqual(values, array.slice(0, -1)); deepEqual(values, array.slice(0, -1));
deepEqual(actual, _.drop(_.dropRight(_.drop(_.dropRight(_.filter(_.dropRight(array), predicate), 2))), 2));
} }
else { else {
skipTest(6); skipTest(6);
@@ -4022,46 +4026,6 @@
skipTest(2); skipTest(2);
} }
}); });
test('should provide the correct `predicate` arguments in a lazy chain sequence', 5, function() {
if (!isNpm) {
var args,
expected = [16, 3, [1, 4, 9 ,16]];
_(array).dropRightWhile(function(value, index, array) {
args = slice.call(arguments);
}).value();
deepEqual(args, [4, 3, array]);
_(array).map(square).dropRightWhile(function(value, index, array) {
args = slice.call(arguments);
}).value();
deepEqual(args, expected);
_(array).map(square).dropRightWhile(function(value, index) {
args = slice.call(arguments);
}).value();
deepEqual(args, expected);
_(array).map(square).dropRightWhile(function(value) {
args = slice.call(arguments);
}).value();
deepEqual(args, expected);
_(array).map(square).dropRightWhile(function() {
args = slice.call(arguments);
}).value();
deepEqual(args, expected);
}
else {
skipTest(5);
}
});
}()); }());
/*--------------------------------------------------------------------------*/ /*--------------------------------------------------------------------------*/
@@ -4117,13 +4081,14 @@
test('should work in a lazy chain sequence', 3, function() { test('should work in a lazy chain sequence', 3, function() {
if (!isNpm) { if (!isNpm) {
var wrapped = _(array).dropWhile(function(num) { var array = _.range(1, LARGE_ARRAY_SIZE + 3),
return num < 3; predicate = function(num) { return num < 3; },
}); expected = _.dropWhile(array, predicate),
wrapped = _(array).dropWhile(predicate);
deepEqual(wrapped.value(), [3, 4]); deepEqual(wrapped.value(), expected);
deepEqual(wrapped.reverse().value(), [4, 3]); deepEqual(wrapped.reverse().value(), expected.slice().reverse());
strictEqual(wrapped.last(), 4); strictEqual(wrapped.last(), _.last(expected));
} }
else { else {
skipTest(3); skipTest(3);
@@ -4132,58 +4097,20 @@
test('should work in a lazy chain sequence with `drop`', 1, function() { test('should work in a lazy chain sequence with `drop`', 1, function() {
if (!isNpm) { if (!isNpm) {
var array = _.range(1, LARGE_ARRAY_SIZE + 3);
var actual = _(array) var actual = _(array)
.dropWhile(function(num) { return num == 1; }) .dropWhile(function(num) { return num == 1; })
.drop() .drop()
.dropWhile(function(num) { return num == 3; }) .dropWhile(function(num) { return num == 3; })
.value(); .value();
deepEqual(actual, [4]); deepEqual(actual, array.slice(3));
} }
else { else {
skipTest(); skipTest();
} }
}); });
test('should provide the correct `predicate` arguments in a lazy chain sequence', 5, function() {
if (!isNpm) {
var args,
expected = [1, 0, [1, 4, 9, 16]];
_(array).dropWhile(function(value, index, array) {
args = slice.call(arguments);
}).value();
deepEqual(args, [1, 0, array]);
_(array).map(square).dropWhile(function(value, index, array) {
args = slice.call(arguments);
}).value();
deepEqual(args, expected);
_(array).map(square).dropWhile(function(value, index) {
args = slice.call(arguments);
}).value();
deepEqual(args, expected);
_(array).map(square).dropWhile(function(index) {
args = slice.call(arguments);
}).value();
deepEqual(args, [1]);
_(array).map(square).dropWhile(function() {
args = slice.call(arguments);
}).value();
deepEqual(args, expected);
}
else {
skipTest(5);
}
});
}()); }());
/*--------------------------------------------------------------------------*/ /*--------------------------------------------------------------------------*/
@@ -4756,7 +4683,7 @@
test('should work in a lazy chain sequence', 1, function() { test('should work in a lazy chain sequence', 1, function() {
if (!isNpm) { if (!isNpm) {
var array = [1, 2, 3, 4]; var array = _.range(1, LARGE_ARRAY_SIZE + 1);
var wrapped = _(array).filter(function(value) { var wrapped = _(array).filter(function(value) {
return value % 2 == 0; return value % 2 == 0;
@@ -4818,25 +4745,25 @@
test('should work in a lazy chain sequence', 6, function() { test('should work in a lazy chain sequence', 6, function() {
if (!isNpm) { if (!isNpm) {
var array = [1, 2, 3, 4, 5, 6, 7, 8, 9 , 10], var array = _.range(1, LARGE_ARRAY_SIZE + 1),
values = [], values = [],
predicate = function(value) { values.push(value); return value > 2; }, predicate = function(value) { values.push(value); return value > 2; },
actual = _(array).take(2).take().value(); actual = _(array).take(2).take().value();
deepEqual(actual, [1]); deepEqual(actual, _.take(_.take(array, 2)));
actual = _(array).filter(predicate).take(2).take().value(); actual = _(array).filter(predicate).take(2).take().value();
deepEqual(actual, [3]); deepEqual(values, [1, 2, 3]);
deepEqual(values, array.slice(0, 3)); deepEqual(actual, _.take(_.take(_.filter(array, predicate), 2)));
actual = _(array).take(6).takeRight(4).take(2).takeRight().value(); actual = _(array).take(6).takeRight(4).take(2).takeRight().value();
deepEqual(actual, [4]); deepEqual(actual, _.takeRight(_.take(_.takeRight(_.take(array, 6), 4), 2)));
values = []; values = [];
actual = _(array).take(array.length - 1).filter(predicate).take(6).takeRight(4).take(2).takeRight().value(); actual = _(array).take(array.length - 1).filter(predicate).take(6).takeRight(4).take(2).takeRight().value();
deepEqual(actual, [6]); deepEqual(values, [1, 2, 3, 4, 5, 6, 7, 8]);
deepEqual(values, array.slice(0, -2)); deepEqual(actual, _.takeRight(_.take(_.takeRight(_.take(_.filter(_.take(array, array.length - 1), predicate), 6), 4), 2)));
} }
else { else {
skipTest(6); skipTest(6);
@@ -4888,25 +4815,25 @@
test('should work in a lazy chain sequence', 6, function() { test('should work in a lazy chain sequence', 6, function() {
if (!isNpm) { if (!isNpm) {
var array = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], var array = _.range(1, LARGE_ARRAY_SIZE + 1),
values = [], values = [],
predicate = function(value) { values.push(value); return value < 9; }, predicate = function(value) { values.push(value); return value < 9; },
actual = _(array).takeRight(2).takeRight().value(); actual = _(array).takeRight(2).takeRight().value();
deepEqual(actual, [10]); deepEqual(actual, _.takeRight(_.takeRight(array)));
actual = _(array).filter(predicate).takeRight(2).takeRight().value(); actual = _(array).filter(predicate).takeRight(2).takeRight().value();
deepEqual(actual, [8]);
deepEqual(values, array); deepEqual(values, array);
deepEqual(actual, _.takeRight(_.takeRight(_.filter(array, predicate), 2)));
actual = _(array).takeRight(6).take(4).takeRight(2).take().value(); actual = _(array).takeRight(6).take(4).takeRight(2).take().value();
deepEqual(actual, [7]); deepEqual(actual, _.take(_.takeRight(_.take(_.takeRight(array, 6), 4), 2)));
values = []; values = [];
actual = _(array).filter(predicate).takeRight(6).take(4).takeRight(2).take().value(); actual = _(array).filter(predicate).takeRight(6).take(4).takeRight(2).take().value();
deepEqual(actual, [5]);
deepEqual(values, array); deepEqual(values, array);
deepEqual(actual, _.take(_.takeRight(_.take(_.takeRight(_.filter(array, predicate), 6), 4), 2)));
} }
else { else {
skipTest(6); skipTest(6);
@@ -4967,13 +4894,14 @@
test('should work in a lazy chain sequence', 3, function() { test('should work in a lazy chain sequence', 3, function() {
if (!isNpm) { if (!isNpm) {
var wrapped = _(array).takeRightWhile(function(num) { var array = _.range(1, LARGE_ARRAY_SIZE + 1),
return num > 2; predicate = function(num) { return num > 2; },
}); expected = _.takeRightWhile(array, predicate),
wrapped = _(array).takeRightWhile(predicate);
deepEqual(wrapped.value(), [3, 4]); deepEqual(wrapped.value(), expected);
deepEqual(wrapped.reverse().value(), [4, 3]); deepEqual(wrapped.reverse().value(), expected.slice().reverse());
strictEqual(wrapped.last(), 4); strictEqual(wrapped.last(), _.last(expected));
} }
else { else {
skipTest(3); skipTest(3);
@@ -4983,13 +4911,14 @@
test('should provide the correct `predicate` arguments in a lazy chain sequence', 5, function() { test('should provide the correct `predicate` arguments in a lazy chain sequence', 5, function() {
if (!isNpm) { if (!isNpm) {
var args, var args,
expected = [16, 3, [1, 4, 9 , 16]]; array = _.range(1, LARGE_ARRAY_SIZE + 1),
expected = [square(LARGE_ARRAY_SIZE), LARGE_ARRAY_SIZE - 1, _.map(array, square)];
_(array).takeRightWhile(function(value, index, array) { _(array).takeRightWhile(function(value, index, array) {
args = slice.call(arguments) args = slice.call(arguments)
}).value(); }).value();
deepEqual(args, [4, 3, array]); deepEqual(args, [LARGE_ARRAY_SIZE, LARGE_ARRAY_SIZE - 1, array]);
_(array).map(square).takeRightWhile(function(value, index, array) { _(array).map(square).takeRightWhile(function(value, index, array) {
args = slice.call(arguments) args = slice.call(arguments)
@@ -5007,7 +4936,7 @@
args = slice.call(arguments); args = slice.call(arguments);
}).value(); }).value();
deepEqual(args, [16]); deepEqual(args, [square(LARGE_ARRAY_SIZE)]);
_(array).map(square).takeRightWhile(function() { _(array).map(square).takeRightWhile(function() {
args = slice.call(arguments); args = slice.call(arguments);
@@ -5073,13 +5002,14 @@
test('should work in a lazy chain sequence', 3, function() { test('should work in a lazy chain sequence', 3, function() {
if (!isNpm) { if (!isNpm) {
var wrapped = _(array).takeWhile(function(num) { var array = _.range(1, LARGE_ARRAY_SIZE + 1),
return num < 3; predicate = function(num) { return num < 3; },
}); expected = _.takeWhile(array, predicate),
wrapped = _(array).takeWhile(predicate);
deepEqual(wrapped.value(), [1, 2]); deepEqual(wrapped.value(), expected);
deepEqual(wrapped.reverse().value(), [2, 1]); deepEqual(wrapped.reverse().value(), expected.slice().reverse());
strictEqual(wrapped.last(), 2); strictEqual(wrapped.last(), _.last(expected));
} }
else { else {
skipTest(3); skipTest(3);
@@ -5088,6 +5018,8 @@
test('should work in a lazy chain sequence with `take`', 1, function() { test('should work in a lazy chain sequence with `take`', 1, function() {
if (!isNpm) { if (!isNpm) {
var array = _.range(1, LARGE_ARRAY_SIZE + 1);
var actual = _(array) var actual = _(array)
.takeWhile(function(num) { return num < 4; }) .takeWhile(function(num) { return num < 4; })
.take(2) .take(2)
@@ -5104,7 +5036,8 @@
test('should provide the correct `predicate` arguments in a lazy chain sequence', 5, function() { test('should provide the correct `predicate` arguments in a lazy chain sequence', 5, function() {
if (!isNpm) { if (!isNpm) {
var args, var args,
expected = [1, 0, [1, 4, 9, 16]]; array = _.range(1, LARGE_ARRAY_SIZE + 1),
expected = [1, 0, _.map(array, square)];
_(array).takeWhile(function(value, index, array) { _(array).takeWhile(function(value, index, array) {
args = slice.call(arguments); args = slice.call(arguments);
@@ -6114,12 +6047,16 @@
test('should work in a lazy chain sequence', 1, function() { test('should work in a lazy chain sequence', 1, function() {
if (!isNpm) { if (!isNpm) {
var array = [1, 2, 1, 3], var array = _.range(LARGE_ARRAY_SIZE).concat(
iteratee = function(value) { value.push(value[0]); return value; }, _.range(Math.floor(LARGE_ARRAY_SIZE / 2), LARGE_ARRAY_SIZE),
predicate = function(value) { return value[0] > 1; }, _.range(Math.floor(LARGE_ARRAY_SIZE / 1.5), LARGE_ARRAY_SIZE)
actual = _(array).groupBy(_.identity).map(iteratee).filter(predicate).take().value(); );
deepEqual(actual, [[2, 2]]); var iteratee = function(value) { value.push(value[0]); return value; },
predicate = function(value) { return value[0] > 1; },
actual = _(array).groupBy().map(iteratee).filter(predicate).take().value();
deepEqual(actual, _.take(_.filter(_.map(_.groupBy(array), iteratee), predicate)));
} }
else { else {
skipTest(); skipTest();
@@ -6483,11 +6420,15 @@
test('should work in a lazy chain sequence', 1, function() { test('should work in a lazy chain sequence', 1, function() {
if (!isNpm) { if (!isNpm) {
var array = [1, 2, 1, 3], var array = _.range(LARGE_ARRAY_SIZE).concat(
predicate = function(value) { return value > 2; }, _.range(Math.floor(LARGE_ARRAY_SIZE / 2), LARGE_ARRAY_SIZE),
actual = _(array).indexBy(_.identity).map(square).filter(predicate).take().value(); _.range(Math.floor(LARGE_ARRAY_SIZE / 1.5), LARGE_ARRAY_SIZE)
);
deepEqual(actual, [4]); var predicate = function(value) { return value > 2; },
actual = _(array).indexBy().map(square).filter(predicate).take().value();
deepEqual(actual, _.take(_.filter(_.map(_.indexBy(array), square), predicate)));
} }
else { else {
skipTest(); skipTest();
@@ -6677,7 +6618,7 @@
test('should work in a lazy chain sequence', 4, function() { test('should work in a lazy chain sequence', 4, function() {
if (!isNpm) { if (!isNpm) {
var array = [1, 2, 3], var array = _.range(1, LARGE_ARRAY_SIZE + 1),
values = []; values = [];
var actual = _(array).initial().filter(function(value) { var actual = _(array).initial().filter(function(value) {
@@ -6687,7 +6628,7 @@
.value(); .value();
deepEqual(actual, []); deepEqual(actual, []);
deepEqual(values, [1, 2]); deepEqual(values, _.initial(array));
values = []; values = [];
@@ -9205,13 +9146,11 @@
test('should work in a lazy chain sequence', 1, function() { test('should work in a lazy chain sequence', 1, function() {
if (!isNpm) { if (!isNpm) {
var array = [1, 2, 3, 4]; var array = _.range(1, LARGE_ARRAY_SIZE + 1),
predicate = function(value) { return value % 2; },
wrapped = _(array).filter(predicate);
var wrapped = _(array).filter(function(value) { strictEqual(wrapped.last(), _.last(_.filter(array, predicate)));
return value % 2;
});
strictEqual(wrapped.last(), 3);
} }
else { else {
skipTest(); skipTest();
@@ -9479,7 +9418,8 @@
test('should provide the correct `predicate` arguments in a lazy chain sequence', 5, function() { test('should provide the correct `predicate` arguments in a lazy chain sequence', 5, function() {
if (!isNpm) { if (!isNpm) {
var args, var args,
expected = [1, 0, [1, 4, 9]]; array = _.range(1, LARGE_ARRAY_SIZE + 1),
expected = [1, 0, _.map(array, square)];
_(array).map(function(value, index, array) { _(array).map(function(value, index, array) {
args || (args = slice.call(arguments)); args || (args = slice.call(arguments));
@@ -11333,10 +11273,11 @@
if (!isNpm) { if (!isNpm) {
_.mixin({ 'a': _.countBy, 'b': _.filter }); _.mixin({ 'a': _.countBy, 'b': _.filter });
var predicate = function(value) { return value > 2; }, var array = _.range(1, LARGE_ARRAY_SIZE + 1),
actual = _([1, 2, 1, 3]).a(_.identity).map(square).b(predicate).take().value(); predicate = function(value) { return value > 2; },
actual = _(array).a().map(square).b(predicate).take().value();
deepEqual(actual, [4]); deepEqual(actual, _.take(_.b(_.map(_.a(array), square), predicate)));
delete _.a; delete _.a;
delete _.prototype.a; delete _.prototype.a;
@@ -12332,13 +12273,15 @@
test('should work in a lazy chain sequence', 2, function() { test('should work in a lazy chain sequence', 2, function() {
if (!isNpm) { if (!isNpm) {
var array = [{ 'a': 1 }, null, { 'a': 3 }, { 'a': 4 }], var array = _.times(LARGE_ARRAY_SIZE, function(index) {
actual = _(array).pluck('a').value(); return index ? { 'a': index } : null;
});
deepEqual(actual, [1, undefined, 3, 4]); var actual = _(array).pluck('a').value();
deepEqual(actual, _.pluck(array, 'a'));
actual = _(array).filter(Boolean).pluck('a').value(); actual = _(array).filter().pluck('a').value();
deepEqual(actual, [1, 3, 4]); deepEqual(actual, _.pluck(_.filter(array), 'a'));
} }
else { else {
skipTest(2); skipTest(2);
@@ -13241,16 +13184,18 @@
test('`_.' + methodName + '` should work in a lazy chain sequence', 2, function() { test('`_.' + methodName + '` should work in a lazy chain sequence', 2, function() {
if (!isNpm) { if (!isNpm) {
var object = { 'a': 1, 'b': 2, 'c': 3, 'd': 4 }, var array = _.range(1, LARGE_ARRAY_SIZE + 1),
predicate = function(value) { return isFilter ? (value > 6) : (value < 6); }; predicate = function(value) { return isFilter ? (value > 6) : (value < 6); },
var expected = [9, 16],
actual = _(array).map(square)[methodName](predicate).value(); actual = _(array).map(square)[methodName](predicate).value();
deepEqual(actual, expected); deepEqual(actual, _[methodName](_.map(array, square), predicate));
var object = _.zipObject(_.times(LARGE_ARRAY_SIZE, function(index) {
return ['key' + index, index];
}));
actual = _(object).mapValues(square)[methodName](predicate).value(); actual = _(object).mapValues(square)[methodName](predicate).value();
deepEqual(actual, expected); deepEqual(actual, _[methodName](_.mapValues(object, square), predicate));
} }
else { else {
skipTest(2); skipTest(2);
@@ -13260,7 +13205,8 @@
test('`_.' + methodName + '` should provide the correct `predicate` arguments in a lazy chain sequence', 5, function() { test('`_.' + methodName + '` should provide the correct `predicate` arguments in a lazy chain sequence', 5, function() {
if (!isNpm) { if (!isNpm) {
var args, var args,
expected = [1, 0, [1, 4, 9, 16]]; array = _.range(1, LARGE_ARRAY_SIZE + 1),
expected = [1, 0, _.map(array, square)];
_(array)[methodName](function(value, index, array) { _(array)[methodName](function(value, index, array) {
args || (args = slice.call(arguments)); args || (args = slice.call(arguments));
@@ -13629,7 +13575,7 @@
test('should work in a lazy chain sequence', 4, function() { test('should work in a lazy chain sequence', 4, function() {
if (!isNpm) { if (!isNpm) {
var array = [1, 2, 3], var array = _.range(1, LARGE_ARRAY_SIZE + 1),
values = []; values = [];
var actual = _(array).rest().filter(function(value) { var actual = _(array).rest().filter(function(value) {
@@ -13639,7 +13585,7 @@
.value(); .value();
deepEqual(actual, []); deepEqual(actual, []);
deepEqual(values, [2, 3]); deepEqual(values, array.slice(1));
values = []; values = [];
@@ -13650,7 +13596,7 @@
.rest() .rest()
.value(); .value();
deepEqual(actual, [3]); deepEqual(actual, array.slice(2));
deepEqual(values, array); deepEqual(values, array);
} }
else { else {
@@ -13660,16 +13606,16 @@
test('should not execute subsequent iteratees on an empty array in a lazy chain sequence', 4, function() { test('should not execute subsequent iteratees on an empty array in a lazy chain sequence', 4, function() {
if (!isNpm) { if (!isNpm) {
var array = [1], var array = _.range(1, LARGE_ARRAY_SIZE + 1),
iteratee = function() { pass = false }, iteratee = function() { pass = false },
pass = true, pass = true,
actual = _(array).rest().map(iteratee).value(); actual = _(array).slice(0, 1).rest().map(iteratee).value();
ok(pass); ok(pass);
deepEqual(actual, []); deepEqual(actual, []);
pass = true; pass = true;
actual = _(array).filter(_.identity).rest().map(iteratee).value(); actual = _(array).filter().slice(0, 1).rest().map(iteratee).value();
ok(pass); ok(pass);
deepEqual(actual, []); deepEqual(actual, []);
@@ -14284,32 +14230,34 @@
test('should work in a lazy chain sequence', 38, function() { test('should work in a lazy chain sequence', 38, function() {
if (!isNpm) { if (!isNpm) {
var wrapped = _(array); var array = _.range(1, LARGE_ARRAY_SIZE + 1),
length = array.length,
wrapped = _(array);
_.each(['map', 'filter'], function(methodName) { _.each(['map', 'filter'], function(methodName) {
deepEqual(wrapped[methodName]().slice(0, -1).value(), [1, 2]); deepEqual(wrapped[methodName]().slice(0, -1).value(), array.slice(0, -1));
deepEqual(wrapped[methodName]().slice(1).value(), [2, 3]); deepEqual(wrapped[methodName]().slice(1).value(), array.slice(1));
deepEqual(wrapped[methodName]().slice(1, 3).value(), [2, 3]); deepEqual(wrapped[methodName]().slice(1, 3).value(), array.slice(1, 3));
deepEqual(wrapped[methodName]().slice(-1).value(), [3]); deepEqual(wrapped[methodName]().slice(-1).value(), array.slice(-1));
deepEqual(wrapped[methodName]().slice(4).value(), []); deepEqual(wrapped[methodName]().slice(length).value(), array.slice(length));
deepEqual(wrapped[methodName]().slice(3, 2).value(), []); deepEqual(wrapped[methodName]().slice(3, 2).value(), array.slice(3, 2));
deepEqual(wrapped[methodName]().slice(0, -4).value(), []); deepEqual(wrapped[methodName]().slice(0, -length).value(), array.slice(0, -length));
deepEqual(wrapped[methodName]().slice(0, null).value(), []); deepEqual(wrapped[methodName]().slice(0, null).value(), array.slice(0, null));
deepEqual(wrapped[methodName]().slice(0, 4).value(), array); deepEqual(wrapped[methodName]().slice(0, length).value(), array.slice(0, length));
deepEqual(wrapped[methodName]().slice(-4).value(), array); deepEqual(wrapped[methodName]().slice(-length).value(), array.slice(-length));
deepEqual(wrapped[methodName]().slice(null).value(), array); deepEqual(wrapped[methodName]().slice(null).value(), array.slice(null));
deepEqual(wrapped[methodName]().slice(0, 1).value(), [1]); deepEqual(wrapped[methodName]().slice(0, 1).value(), array.slice(0, 1));
deepEqual(wrapped[methodName]().slice(NaN, '1').value(), [1]); deepEqual(wrapped[methodName]().slice(NaN, '1').value(), array.slice(NaN, '1'));
deepEqual(wrapped[methodName]().slice(0.1, 1.1).value(), [1]); deepEqual(wrapped[methodName]().slice(0.1, 1.1).value(), array.slice(0.1, 1.1));
deepEqual(wrapped[methodName]().slice('0', 1).value(), [1]); deepEqual(wrapped[methodName]().slice('0', 1).value(), array.slice('0', 1));
deepEqual(wrapped[methodName]().slice(0, '1').value(), [1]); deepEqual(wrapped[methodName]().slice(0, '1').value(), array.slice(0, '1'));
deepEqual(wrapped[methodName]().slice('1').value(), [2, 3]); deepEqual(wrapped[methodName]().slice('1').value(), array.slice('1'));
deepEqual(wrapped[methodName]().slice(NaN, 1).value(), [1]); deepEqual(wrapped[methodName]().slice(NaN, 1).value(), array.slice(NaN, 1));
deepEqual(wrapped[methodName]().slice(1, NaN).value(), []); deepEqual(wrapped[methodName]().slice(1, NaN).value(), array.slice(1, NaN));
}); });
} }
else { else {
@@ -15972,11 +15920,17 @@
test('should work in a lazy chain sequence', 2, function() { test('should work in a lazy chain sequence', 2, function() {
if (!isNpm) { if (!isNpm) {
var actual = _([1, 2]).map(String).toArray().value(); var array = _.range(1, LARGE_ARRAY_SIZE + 1),
deepEqual(actual, ['1', '2']); actual = _(array).map(String).toArray().value();
actual = _({ 'a': 1, 'b': 2 }).toArray().map(String).value(); deepEqual(actual, _.map(array, String));
deepEqual(actual, ['1', '2']);
var object = _.zipObject(_.times(LARGE_ARRAY_SIZE, function(index) {
return ['key' + index, index];
}));
actual = _(object).toArray().map(String).value();
deepEqual(actual, _.map(_.toArray(object), String));
} }
else { else {
skipTest(2); skipTest(2);
@@ -16709,14 +16663,12 @@
test('should work in a lazy chain sequence', 1, function() { test('should work in a lazy chain sequence', 1, function() {
if (!isNpm) { if (!isNpm) {
var array = [ var array = _.times(LARGE_ARRAY_SIZE, function(index) {
{ 'a': 1 }, return index ? { 'a': 1, 'b': index } : { 'a': 3 };
{ 'a': 3 }, });
{ 'a': 1, 'b': 2 }
];
var actual = _(array).where({ 'a': 1 }).value(); var actual = _(array).where({ 'a': 1 }).value();
deepEqual(actual, [array[0], array[2]]); deepEqual(actual, _.where(array, { 'a': 1 }));
} }
else { else {
skipTest(); skipTest();
@@ -16888,13 +16840,14 @@
test('should work when in a lazy chain sequence before `first` or `last`', 1, function() { test('should work when in a lazy chain sequence before `first` or `last`', 1, function() {
if (!isNpm) { if (!isNpm) {
var wrapped = _([1, 2]).slice().xor([2, 3]); var array = _.range(0, LARGE_ARRAY_SIZE),
wrapped = _(array).slice(1).xor([LARGE_ARRAY_SIZE - 1, LARGE_ARRAY_SIZE]);
var actual = _.map(['first', 'last'], function(methodName) { var actual = _.map(['first', 'last'], function(methodName) {
return wrapped[methodName](); return wrapped[methodName]();
}); });
deepEqual(actual, [1, 3]); deepEqual(actual, [1, LARGE_ARRAY_SIZE]);
} }
else { else {
skipTest(); skipTest();
@@ -16952,11 +16905,14 @@
test('should work in a lazy chain sequence', 1, function() { test('should work in a lazy chain sequence', 1, function() {
if (!isNpm) { if (!isNpm) {
var array = [['a', 1], ['b', 2]], var array = _.times(LARGE_ARRAY_SIZE, function(index) {
predicate = function(value) { return value > 2; }, return ['key' + index, index];
});
var predicate = function(value) { return value > 2; },
actual = _(array).zipObject().map(square).filter(predicate).take().value(); actual = _(array).zipObject().map(square).filter(predicate).take().value();
deepEqual(actual, [4]); deepEqual(actual, _.take(_.filter(_.map(_.zipObject(array), square), predicate)));
} }
else { else {
skipTest(); skipTest();
@@ -17310,8 +17266,10 @@
test('should work in a lazy chain sequence', 1, function() { test('should work in a lazy chain sequence', 1, function() {
if (!isNpm) { if (!isNpm) {
var actual = _([1, 2, 3, null]).map(_.identity).reverse().value(); var array = _.range(0, LARGE_ARRAY_SIZE).concat(null),
deepEqual(actual, [null, 3, 2, 1]); actual = _(array).slice(1).reverse().value();
deepEqual(actual, array.slice(1).reverse());
} }
else { else {
skipTest(); skipTest();
@@ -17327,12 +17285,13 @@
}; };
try { try {
var wrapped = _(['a', spy]).map(String).reverse(), var array = _.range(1, LARGE_ARRAY_SIZE).concat(spy),
wrapped = _(array).map(String).reverse(),
actual = wrapped.last(); actual = wrapped.last();
} catch(e) {} } catch(e) {}
ok(wrapped instanceof _); ok(wrapped instanceof _);
strictEqual(actual, 'a'); strictEqual(actual, '1');
} }
else { else {
skipTest(2); skipTest(2);