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