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

Rename _.contains to _.includes.

Browse Source
This commit is contained in:
John-David Dalton
2014-11-23 15:53:46 -08:00
parent a3083d2990
commit 82b9a0c949
4 changed files with 172 additions and 194 deletions
Download Patch File Download Diff File Expand all files Collapse all files

37
lodash.js
View File

@@ -1006,16 +1006,16 @@
* `zip`, and `zipObject` * `zip`, and `zipObject`
* *
* The non-chainable wrapper functions are: * The non-chainable wrapper functions are:
* `attempt`, `camelCase`, `capitalize`, `clone`, `cloneDeep`, `contains`, * `attempt`, `camelCase`, `capitalize`, `clone`, `cloneDeep`, `deburr`,
* `deburr`, endsWith`, `escape`, `escapeRegExp`, `every`, `find`, `findIndex`, * `endsWith`, `escape`, `escapeRegExp`, `every`, `find`, `findIndex`, `findKey`,
* `findKey`, `findLast`, `findLastIndex`, `findLastKey`, `findWhere`, `first`, * `findLast`, `findLastIndex`, `findLastKey`, `findWhere`, `first`, `has`,
* `has`, `identity`, `indexOf`, `isArguments`, `isArray`, `isBoolean`, isDate`, * `identity`, `includes`, `indexOf`, `isArguments`, `isArray`, `isBoolean`,
* `isElement`, `isEmpty`, `isEqual`, `isError`, `isFinite`, `isFunction`, * `isDate`, `isElement`, `isEmpty`, `isEqual`, `isError`, `isFinite`,
* `isNative`, `isNaN`, `isNull`, `isNumber`, `isObject`, `isPlainObject`, * `isFunction`, `isNative`, `isNaN`, `isNull`, `isNumber`, `isObject`,
* `isRegExp`, `isString`, `isUndefined`, `join`, `kebabCase`, `last`, * `isPlainObject`, `isRegExp`, `isString`, `isUndefined`, `join`, `kebabCase`,
* `lastIndexOf`, `max`, `min`, `noConflict`, `now`, `pad`, `padLeft`, `padRight`, * `last`, `lastIndexOf`, `max`, `min`, `noConflict`, `now`, `pad`, `padLeft`,
* `parseInt`, `pop`, `random`, `reduce`, `reduceRight`, `repeat`, `result`, * `padRight`, `parseInt`, `pop`, `random`, `reduce`, `reduceRight`, `repeat`,
* `runInContext`, `shift`, `size`, `snakeCase`, `some`, `sortedIndex`, * `result`, `runInContext`, `shift`, `size`, `snakeCase`, `some`, `sortedIndex`,
* `sortedLastIndex`, `startsWith`, `template`, `trim`, `trimLeft`, `trimRight`, * `sortedLastIndex`, `startsWith`, `template`, `trim`, `trimLeft`, `trimRight`,
* `trunc`, `unescape`, `uniqueId`, `value`, and `words` * `trunc`, `unescape`, `uniqueId`, `value`, and `words`
* *
@@ -5065,7 +5065,7 @@
* *
* @static * @static
* @memberOf _ * @memberOf _
* @alias include * @alias contains, include
* @category Collection * @category Collection
* @param {Array|Object|string} collection The collection to search. * @param {Array|Object|string} collection The collection to search.
* @param {*} target The value to search for. * @param {*} target The value to search for.
@@ -5073,19 +5073,19 @@
* @returns {boolean} Returns `true` if a matching element is found, else `false`. * @returns {boolean} Returns `true` if a matching element is found, else `false`.
* @example * @example
* *
* _.contains([1, 2, 3], 1); * _.includes([1, 2, 3], 1);
* // => true * // => true
* *
* _.contains([1, 2, 3], 1, 2); * _.includes([1, 2, 3], 1, 2);
* // => false * // => false
* *
* _.contains({ 'user': 'fred', 'age': 40 }, 'fred'); * _.includes({ 'user': 'fred', 'age': 40 }, 'fred');
* // => true * // => true
* *
* _.contains('pebbles', 'eb'); * _.includes('pebbles', 'eb');
* // => true * // => true
*/ */
function contains(collection, target, fromIndex) { function includes(collection, target, fromIndex) {
var length = collection ? collection.length : 0; var length = collection ? collection.length : 0;
if (!isLength(length)) { if (!isLength(length)) {
@@ -10012,7 +10012,6 @@
lodash.capitalize = capitalize; lodash.capitalize = capitalize;
lodash.clone = clone; lodash.clone = clone;
lodash.cloneDeep = cloneDeep; lodash.cloneDeep = cloneDeep;
lodash.contains = contains;
lodash.deburr = deburr; lodash.deburr = deburr;
lodash.endsWith = endsWith; lodash.endsWith = endsWith;
lodash.escape = escape; lodash.escape = escape;
@@ -10028,6 +10027,7 @@
lodash.first = first; lodash.first = first;
lodash.has = has; lodash.has = has;
lodash.identity = identity; lodash.identity = identity;
lodash.includes = includes;
lodash.indexOf = indexOf; lodash.indexOf = indexOf;
lodash.isArguments = isArguments; lodash.isArguments = isArguments;
lodash.isArray = isArray; lodash.isArray = isArray;
@@ -10084,11 +10084,12 @@
// Add aliases. // Add aliases.
lodash.all = every; lodash.all = every;
lodash.any = some; lodash.any = some;
lodash.contains = includes;
lodash.detect = find; lodash.detect = find;
lodash.foldl = reduce; lodash.foldl = reduce;
lodash.foldr = reduceRight; lodash.foldr = reduceRight;
lodash.head = first; lodash.head = first;
lodash.include = contains; lodash.include = includes;
lodash.inject = reduce; lodash.inject = reduce;
mixin(lodash, (function() { mixin(lodash, (function() {

68
perf/perf.js
View File

@@ -692,40 +692,6 @@
/*--------------------------------------------------------------------------*/ /*--------------------------------------------------------------------------*/
suites.push(
Benchmark.Suite('`_.contains` iterating an array')
.add(buildName, '\
lodash.contains(numbers, limit - 1)'
)
.add(otherName, '\
_.contains(numbers, limit - 1)'
)
);
suites.push(
Benchmark.Suite('`_.contains` iterating an object')
.add(buildName, '\
lodash.contains(object, limit - 1)'
)
.add(otherName, '\
_.contains(object, limit - 1)'
)
);
if (lodash.contains('ab', 'ab') && _.contains('ab', 'ab')) {
suites.push(
Benchmark.Suite('`_.contains` iterating a string')
.add(buildName, '\
lodash.contains(strNumbers, "," + (limit - 1))'
)
.add(otherName, '\
_.contains(strNumbers, "," + (limit - 1))'
)
);
}
/*--------------------------------------------------------------------------*/
suites.push( suites.push(
Benchmark.Suite('`_.countBy` with `callback` iterating an array') Benchmark.Suite('`_.countBy` with `callback` iterating an array')
.add(buildName, '\ .add(buildName, '\
@@ -1077,6 +1043,40 @@
/*--------------------------------------------------------------------------*/ /*--------------------------------------------------------------------------*/
suites.push(
Benchmark.Suite('`_.includes` iterating an array')
.add(buildName, '\
lodash.includes(numbers, limit - 1)'
)
.add(otherName, '\
_.includes(numbers, limit - 1)'
)
);
suites.push(
Benchmark.Suite('`_.includes` iterating an object')
.add(buildName, '\
lodash.includes(object, limit - 1)'
)
.add(otherName, '\
_.includes(object, limit - 1)'
)
);
if (lodash.includes('ab', 'ab') && _.includes('ab', 'ab')) {
suites.push(
Benchmark.Suite('`_.includes` iterating a string')
.add(buildName, '\
lodash.includes(strNumbers, "," + (limit - 1))'
)
.add(otherName, '\
_.includes(strNumbers, "," + (limit - 1))'
)
);
}
/*--------------------------------------------------------------------------*/
suites.push( suites.push(
Benchmark.Suite('`_.indexBy` with `callback` iterating an array') Benchmark.Suite('`_.indexBy` with `callback` iterating an array')
.add(buildName, '\ .add(buildName, '\

9
test/index.html
View File

@@ -112,9 +112,6 @@
setProperty(Number, '_isFinite', Number.isFinite); setProperty(Number, '_isFinite', Number.isFinite);
setProperty(Number, 'isFinite', noop); setProperty(Number, 'isFinite', noop);
setProperty(stringProto, '_contains', stringProto.contains);
setProperty(stringProto, 'contains', stringProto._contains ? noop : Boolean);
setProperty(window, '_ArrayBuffer', window.ArrayBuffer); setProperty(window, '_ArrayBuffer', window.ArrayBuffer);
if (window.ArrayBuffer && window.Uint8Array) { if (window.ArrayBuffer && window.Uint8Array) {
ArrayBuffer = (function(_ArrayBuffer) { ArrayBuffer = (function(_ArrayBuffer) {
@@ -220,11 +217,6 @@
} else { } else {
delete Number.isFinite; delete Number.isFinite;
} }
if (stringProto._contains) {
setProperty(stringProto, 'contains', stringProto._contains);
} else {
delete stringProto.contains;
}
if (window._ArrayBuffer) { if (window._ArrayBuffer) {
ArrayBuffer = _ArrayBuffer; ArrayBuffer = _ArrayBuffer;
} }
@@ -261,7 +253,6 @@
delete Object._getPrototypeOf; delete Object._getPrototypeOf;
delete Object._keys; delete Object._keys;
delete objectProto._propertyIsEnumerable; delete objectProto._propertyIsEnumerable;
delete stringProto._contains;
} }
QUnit.config.hidepassed = true; QUnit.config.hidepassed = true;

252
test/test.js
View File

@@ -453,9 +453,6 @@
var _isFinite = Number.isFinite; var _isFinite = Number.isFinite;
setProperty(Number, 'isFinite', _.noop); setProperty(Number, 'isFinite', _.noop);
var _contains = stringProto.contains;
setProperty(stringProto, 'contains', _contains ? _.noop : Boolean);
var _ArrayBuffer = ArrayBuffer; var _ArrayBuffer = ArrayBuffer;
setProperty(root, 'ArrayBuffer', (function() { setProperty(root, 'ArrayBuffer', (function() {
function ArrayBuffer(byteLength) { function ArrayBuffer(byteLength) {
@@ -543,11 +540,6 @@
} else { } else {
delete Number.isFinite; delete Number.isFinite;
} }
if (_contains) {
setProperty(stringProto, 'contains', _contains);
} else {
delete stringProto.contains;
}
if (_ArrayBuffer) { if (_ArrayBuffer) {
setProperty(root, 'ArrayBuffer', _ArrayBuffer); setProperty(root, 'ArrayBuffer', _ArrayBuffer);
} else { } else {
@@ -685,7 +677,7 @@
} }
}); });
test('should avoid overwritten native methods', 14, function() { test('should avoid overwritten native methods', 13, function() {
function Foo() {} function Foo() {}
function message(lodashMethod, nativeMethod) { function message(lodashMethod, nativeMethod) {
@@ -751,13 +743,6 @@
} }
deepEqual(actual, [[otherObject], [object], [object]], message('_.difference`, `_.intersection`, and `_.uniq', 'Set')); deepEqual(actual, [[otherObject], [object], [object]], message('_.difference`, `_.intersection`, and `_.uniq', 'Set'));
try {
actual = lodashBizarro.contains('abc', 'c');
} catch(e) {
actual = null;
}
strictEqual(actual, true, message('_.contains', 'String#contains'));
if (ArrayBuffer) { if (ArrayBuffer) {
try { try {
var buffer = new ArrayBuffer(10); var buffer = new ArrayBuffer(10);
@@ -787,7 +772,7 @@
} }
} }
else { else {
skipTest(14); skipTest(13);
} }
}); });
}()); }());
@@ -2032,100 +2017,6 @@
/*--------------------------------------------------------------------------*/ /*--------------------------------------------------------------------------*/
QUnit.module('lodash.contains');
(function() {
_.each({
'an `arguments` object': arguments,
'an array': [1, 2, 3, 4],
'an object': { 'a': 1, 'b': 2, 'c': 3, 'd': 4 },
'a string': '1234'
},
function(collection, key) {
var values = _.toArray(collection);
test('should work with ' + key + ' and return `true` for matched values', 1, function() {
strictEqual(_.contains(collection, 3), true);
});
test('should work with ' + key + ' and return `false` for unmatched values', 1, function() {
strictEqual(_.contains(collection, 5), false);
});
test('should work with ' + key + ' and a positive `fromIndex`', 2, function() {
strictEqual(_.contains(collection, values[2], 2), true);
strictEqual(_.contains(collection, values[1], 2), false);
});
test('should work with ' + key + ' and a `fromIndex` >= `collection.length`', 12, function() {
_.each([6, 8, Math.pow(2, 32), Infinity], function(fromIndex) {
strictEqual(_.contains(collection, 1, fromIndex), false);
strictEqual(_.contains(collection, undefined, fromIndex), false);
strictEqual(_.contains(collection, '', fromIndex), false);
});
});
test('should work with ' + key + ' and treat falsey `fromIndex` values as `0`', 1, function() {
var expected = _.map(falsey, _.constant(true));
var actual = _.map(falsey, function(fromIndex) {
return _.contains(collection, values[0], fromIndex);
});
deepEqual(actual, expected);
});
test('should work with ' + key + ' and treat non-number `fromIndex` values as `0`', 1, function() {
strictEqual(_.contains(collection, values[0], '1'), true);
});
test('should work with ' + key + ' and a negative `fromIndex`', 2, function() {
strictEqual(_.contains(collection, values[2], -2), true);
strictEqual(_.contains(collection, values[1], -2), false);
});
test('should work with ' + key + ' and a negative `fromIndex` <= negative `collection.length`', 3, function() {
_.each([-4, -6, -Infinity], function(fromIndex) {
strictEqual(_.contains(collection, values[0], fromIndex), true);
});
});
test('should work with ' + key + ' and return an unwrapped value when chaining', 1, function() {
if (!isNpm) {
strictEqual(_(collection).contains(3), true);
}
else {
skipTest();
}
});
});
_.each({
'literal': 'abc',
'object': Object('abc')
},
function(collection, key) {
test('should work with a string ' + key + ' for `collection`', 2, function() {
strictEqual(_.contains(collection, 'bc'), true);
strictEqual(_.contains(collection, 'd'), false);
});
});
test('should not be possible to perform a binary search', 1, function() {
strictEqual(_.contains([3, 2, 1], 3, true), true);
});
test('should match `NaN`', 1, function() {
strictEqual(_.contains([1, NaN, 3], NaN), true);
});
test('should be aliased', 1, function() {
strictEqual(_.include, _.contains);
});
}(1, 2, 3, 4));
/*--------------------------------------------------------------------------*/
QUnit.module('lodash.countBy'); QUnit.module('lodash.countBy');
(function() { (function() {
@@ -4438,11 +4329,11 @@
args || (args = slice.call(arguments)); args || (args = slice.call(arguments));
}); });
if (_.contains(rightMethods, methodName)) { if (_.includes(rightMethods, methodName)) {
expected[0] = 3; expected[0] = 3;
expected[1] = 2; expected[1] = 2;
} }
if (_.contains(objectMethods, methodName)) { if (_.includes(objectMethods, methodName)) {
expected[1] += ''; expected[1] += '';
} }
deepEqual(args, expected); deepEqual(args, expected);
@@ -4476,7 +4367,7 @@
return isEvery; return isEvery;
}); });
ok(!_.contains(keys, 'a')); ok(!_.includes(keys, 'a'));
}); });
}); });
@@ -4527,8 +4418,8 @@
_.each(iterationMethods, function(methodName) { _.each(iterationMethods, function(methodName) {
var array = [1, 2, 3], var array = [1, 2, 3],
func = _[methodName], func = _[methodName],
isEach = !_.contains(objectMethods, methodName), isEach = !_.includes(objectMethods, methodName),
isRight = _.contains(rightMethods, methodName); isRight = _.includes(rightMethods, methodName);
test('`_.' + methodName + '` should return the collection', 1, function() { test('`_.' + methodName + '` should return the collection', 1, function() {
strictEqual(func(array, Boolean), array); strictEqual(func(array, Boolean), array);
@@ -5003,6 +4894,101 @@
/*--------------------------------------------------------------------------*/ /*--------------------------------------------------------------------------*/
QUnit.module('lodash.includes');
(function() {
_.each({
'an `arguments` object': arguments,
'an array': [1, 2, 3, 4],
'an object': { 'a': 1, 'b': 2, 'c': 3, 'd': 4 },
'a string': '1234'
},
function(collection, key) {
var values = _.toArray(collection);
test('should work with ' + key + ' and return `true` for matched values', 1, function() {
strictEqual(_.includes(collection, 3), true);
});
test('should work with ' + key + ' and return `false` for unmatched values', 1, function() {
strictEqual(_.includes(collection, 5), false);
});
test('should work with ' + key + ' and a positive `fromIndex`', 2, function() {
strictEqual(_.includes(collection, values[2], 2), true);
strictEqual(_.includes(collection, values[1], 2), false);
});
test('should work with ' + key + ' and a `fromIndex` >= `collection.length`', 12, function() {
_.each([6, 8, Math.pow(2, 32), Infinity], function(fromIndex) {
strictEqual(_.includes(collection, 1, fromIndex), false);
strictEqual(_.includes(collection, undefined, fromIndex), false);
strictEqual(_.includes(collection, '', fromIndex), false);
});
});
test('should work with ' + key + ' and treat falsey `fromIndex` values as `0`', 1, function() {
var expected = _.map(falsey, _.constant(true));
var actual = _.map(falsey, function(fromIndex) {
return _.includes(collection, values[0], fromIndex);
});
deepEqual(actual, expected);
});
test('should work with ' + key + ' and treat non-number `fromIndex` values as `0`', 1, function() {
strictEqual(_.includes(collection, values[0], '1'), true);
});
test('should work with ' + key + ' and a negative `fromIndex`', 2, function() {
strictEqual(_.includes(collection, values[2], -2), true);
strictEqual(_.includes(collection, values[1], -2), false);
});
test('should work with ' + key + ' and a negative `fromIndex` <= negative `collection.length`', 3, function() {
_.each([-4, -6, -Infinity], function(fromIndex) {
strictEqual(_.includes(collection, values[0], fromIndex), true);
});
});
test('should work with ' + key + ' and return an unwrapped value when chaining', 1, function() {
if (!isNpm) {
strictEqual(_(collection).contains(3), true);
}
else {
skipTest();
}
});
});
_.each({
'literal': 'abc',
'object': Object('abc')
},
function(collection, key) {
test('should work with a string ' + key + ' for `collection`', 2, function() {
strictEqual(_.includes(collection, 'bc'), true);
strictEqual(_.includes(collection, 'd'), false);
});
});
test('should not be possible to perform a binary search', 1, function() {
strictEqual(_.includes([3, 2, 1], 3, true), true);
});
test('should match `NaN`', 1, function() {
strictEqual(_.includes([1, NaN, 3], NaN), true);
});
test('should be aliased', 2, function() {
strictEqual(_.contains, _.includes);
strictEqual(_.include, _.includes);
});
}(1, 2, 3, 4));
/*--------------------------------------------------------------------------*/
QUnit.module('lodash.indexBy'); QUnit.module('lodash.indexBy');
(function() { (function() {
@@ -5150,11 +5136,11 @@
return new Foo; return new Foo;
}); });
test('`_.contains` should work with a custom `_.indexOf` method', 2, function() { test('`_.includes` should work with a custom `_.indexOf` method', 2, function() {
if (!isModularize) { if (!isModularize) {
_.indexOf = custom; _.indexOf = custom;
ok(_.contains(array, new Foo)); ok(_.includes(array, new Foo));
ok(_.contains({ 'a': 1, 'b': new Foo, 'c': 3 }, new Foo)); ok(_.includes({ 'a': 1, 'b': new Foo, 'c': 3 }, new Foo));
_.indexOf = indexOf; _.indexOf = indexOf;
} }
else { else {
@@ -7259,7 +7245,7 @@
actual = func(object); actual = func(object);
delete proto.a; delete proto.a;
strictEqual(_.contains(actual, 'a'), !(isKeys && index), 'includes ' + message); strictEqual(_.includes(actual, 'a'), !(isKeys && index), 'includes ' + message);
if (index) { if (index) {
object.constructor = 1; object.constructor = 1;
@@ -10251,12 +10237,12 @@
test('should return a random element', 1, function() { test('should return a random element', 1, function() {
var actual = _.sample(array); var actual = _.sample(array);
ok(_.contains(array, actual)); ok(_.includes(array, actual));
}); });
test('should return two random elements', 1, function() { test('should return two random elements', 1, function() {
var actual = _.sample(array, 2); var actual = _.sample(array, 2);
ok(actual.length == 2 && actual[0] !== actual[1] && _.contains(array, actual[0]) && _.contains(array, actual[1])); ok(actual.length == 2 && actual[0] !== actual[1] && _.includes(array, actual[0]) && _.includes(array, actual[1]));
}); });
test('should contain elements of the collection', 1, function() { test('should contain elements of the collection', 1, function() {
@@ -10311,10 +10297,10 @@
var object = { 'a': 1, 'b': 2, 'c': 3 }, var object = { 'a': 1, 'b': 2, 'c': 3 },
actual = _.sample(object); actual = _.sample(object);
ok(_.contains(array, actual)); ok(_.includes(array, actual));
actual = _.sample(object, 2); actual = _.sample(object, 2);
ok(actual.length == 2 && actual[0] !== actual[1] && _.contains(array, actual[0]) && _.contains(array, actual[1])); ok(actual.length == 2 && actual[0] !== actual[1] && _.includes(array, actual[0]) && _.includes(array, actual[1]));
}); });
test('should work as an iteratee for `_.map`', 2, function() { test('should work as an iteratee for `_.map`', 2, function() {
@@ -10324,7 +10310,7 @@
c = values[2], c = values[2],
actual = _.map(values, _.sample); actual = _.map(values, _.sample);
ok(_.contains(a, actual[0]) && _.contains(b, actual[1]) && _.contains(c, actual[2])); ok(_.includes(a, actual[0]) && _.includes(b, actual[1]) && _.includes(c, actual[2]));
}); });
}); });
@@ -10334,7 +10320,7 @@
ok(wrapped instanceof _); ok(wrapped instanceof _);
var actual = wrapped.value(); var actual = wrapped.value();
ok(actual.length == 2 && actual[0] !== actual[1] && _.contains(array, actual[0]) && _.contains(array, actual[1])); ok(actual.length == 2 && actual[0] !== actual[1] && _.includes(array, actual[0]) && _.includes(array, actual[1]));
} }
else { else {
skipTest(2); skipTest(2);
@@ -10344,7 +10330,7 @@
test('should return an unwrapped value when chaining and `n` is not provided', 1, function() { test('should return an unwrapped value when chaining and `n` is not provided', 1, function() {
if (!isNpm) { if (!isNpm) {
var actual = _(array).sample(); var actual = _(array).sample();
ok(_.contains(array, actual)); ok(_.includes(array, actual));
} }
else { else {
skipTest(); skipTest();
@@ -10358,10 +10344,10 @@
function(collection, key) { function(collection, key) {
test('should work with a string ' + key + ' for `collection`', 2, function() { test('should work with a string ' + key + ' for `collection`', 2, function() {
var actual = _.sample(collection); var actual = _.sample(collection);
ok(_.contains(collection, actual)); ok(_.includes(collection, actual));
actual = _.sample(collection, 2); actual = _.sample(collection, 2);
ok(actual.length == 2 && actual[0] !== actual[1] && _.contains(collection, actual[0]) && _.contains(collection, actual[1])); ok(actual.length == 2 && actual[0] !== actual[1] && _.includes(collection, actual[0]) && _.includes(collection, actual[1]));
}); });
}); });
}()); }());
@@ -13461,7 +13447,7 @@
var acceptFalsey = _.difference(allMethods, rejectFalsey); var acceptFalsey = _.difference(allMethods, rejectFalsey);
test('should accept falsey arguments', 199, function() { test('should accept falsey arguments', 200, function() {
var emptyArrays = _.map(falsey, _.constant([])), var emptyArrays = _.map(falsey, _.constant([])),
isExposed = '_' in root, isExposed = '_' in root,
oldDash = root._; oldDash = root._;
@@ -13489,7 +13475,7 @@
else if (methodName == 'pull') { else if (methodName == 'pull') {
expected = falsey; expected = falsey;
} }
if (_.contains(returnArrays, methodName) && methodName != 'sample') { if (_.includes(returnArrays, methodName) && methodName != 'sample') {
deepEqual(actual, expected, '_.' + methodName + ' returns an array'); deepEqual(actual, expected, '_.' + methodName + ' returns an array');
} }
ok(pass, '`_.' + methodName + '` accepts falsey arguments'); ok(pass, '`_.' + methodName + '` accepts falsey arguments');
@@ -13606,9 +13592,9 @@
if (func) { if (func) {
if (/^reduce/.test(methodName) || methodName == 'transform') { if (/^reduce/.test(methodName) || methodName == 'transform') {
func(array, callback, 0, null); func(array, callback, 0, null);
} else if (_.contains(['assign', 'merge'], methodName)) { } else if (_.includes(['assign', 'merge'], methodName)) {
func(array, array, callback, null); func(array, array, callback, null);
} else if (_.contains(['isEqual', 'sortedIndex'], methodName)) { } else if (_.includes(['isEqual', 'sortedIndex'], methodName)) {
func(array, 'a', callback, null); func(array, 'a', callback, null);
} else if (methodName == 'times') { } else if (methodName == 'times') {
func(1, callback, null); func(1, callback, null);