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

Add more tests for _.differenceBy, _.intersectionBy, _.unionBy, and _.xorBy.

Browse Source
This commit is contained in:
John-David Dalton
2015-10-10 15:25:47 -07:00
parent e961505e0a
commit 414ad602f2
2 changed files with 102 additions and 81 deletions
Download Patch File Download Diff File Expand all files Collapse all files

27
lodash.js
View File

@@ -5025,8 +5025,12 @@
* // => [{ 'x': 1 }, { 'x': 2 }] * // => [{ 'x': 1 }, { 'x': 2 }]
*/ */
var differenceBy = restParam(function(array, values) { var differenceBy = restParam(function(array, values) {
var iteratee = last(values);
if (isArrayLikeObject(iteratee)) {
iteratee = undefined;
}
return isArrayLikeObject(array) return isArrayLikeObject(array)
? baseDifferenceBy(array, baseFlatten(values, false, true), getIteratee(last(values))) ? baseDifferenceBy(array, baseFlatten(values, false, true), getIteratee(iteratee))
: []; : [];
}); });
@@ -5448,9 +5452,14 @@
* // => [{ 'x': 1 }] * // => [{ 'x': 1 }]
*/ */
var intersectionBy = restParam(function(arrays) { var intersectionBy = restParam(function(arrays) {
var mapped = arrayMap(arrays, toArrayLikeObject); var iteratee = last(arrays),
mapped = arrayMap(arrays, toArrayLikeObject);
if (iteratee === last(mapped)) {
iteratee = undefined;
}
return (mapped.length && mapped[0] === arrays[0]) return (mapped.length && mapped[0] === arrays[0])
? baseIntersectionBy(mapped, getIteratee(last(arrays))) ? baseIntersectionBy(mapped, getIteratee(iteratee))
: []; : [];
}); });
@@ -6088,7 +6097,11 @@
* // => [{ 'x': 1 }, { 'x': 2 }] * // => [{ 'x': 1 }, { 'x': 2 }]
*/ */
var unionBy = restParam(function(arrays) { var unionBy = restParam(function(arrays) {
return baseUniqBy(baseFlatten(arrays, false, true), getIteratee(last(arrays))); var iteratee = last(arrays);
if (isArrayLikeObject(iteratee)) {
iteratee = undefined;
}
return baseUniqBy(baseFlatten(arrays, false, true), getIteratee(iteratee));
}); });
/** /**
@@ -6267,7 +6280,11 @@
* // => [{ 'x': 2 }] * // => [{ 'x': 2 }]
*/ */
var xorBy = restParam(function(arrays) { var xorBy = restParam(function(arrays) {
return baseXorBy(arrayFilter(arrays, isArrayLikeObject), getIteratee(last(arrays))); var iteratee = last(arrays);
if (isArrayLikeObject(iteratee)) {
iteratee = undefined;
}
return baseXorBy(arrayFilter(arrays, isArrayLikeObject), getIteratee(iteratee));
}); });
/** /**

156
test/test.js
View File

@@ -3720,28 +3720,29 @@
/*--------------------------------------------------------------------------*/ /*--------------------------------------------------------------------------*/
QUnit.module('lodash.difference'); QUnit.module('difference methods');
(function() { _.each(['difference', 'differenceBy'], function(methodName) {
var args = arguments; var args = (function() { return arguments; }(1, 2, 3)),
func = _[methodName];
QUnit.test('should return the difference of the given arrays', function(assert) { QUnit.test('`_.' + methodName + '` should return the difference of the given arrays', function(assert) {
assert.expect(2); assert.expect(2);
var actual = _.difference([1, 2, 3, 4, 5], [5, 2, 10]); var actual = func([1, 2, 3, 4, 5], [5, 2, 10]);
assert.deepEqual(actual, [1, 3, 4]); assert.deepEqual(actual, [1, 3, 4]);
actual = _.difference([1, 2, 3, 4, 5], [5, 2, 10], [8, 4]); actual = func([1, 2, 3, 4, 5], [5, 2, 10], [8, 4]);
assert.deepEqual(actual, [1, 3]); assert.deepEqual(actual, [1, 3]);
}); });
QUnit.test('should match `NaN`', function(assert) { QUnit.test('`_.' + methodName + '` should match `NaN`', function(assert) {
assert.expect(1); assert.expect(1);
assert.deepEqual(_.difference([1, NaN, 3], [NaN, 5, NaN]), [1, 3]); assert.deepEqual(func([1, NaN, 3], [NaN, 5, NaN]), [1, 3]);
}); });
QUnit.test('should work with large arrays', function(assert) { QUnit.test('`_.' + methodName + '` should work with large arrays', function(assert) {
assert.expect(1); assert.expect(1);
var array1 = _.range(LARGE_ARRAY_SIZE + 1), var array1 = _.range(LARGE_ARRAY_SIZE + 1),
@@ -3753,35 +3754,35 @@
array1.push(a, b, c); array1.push(a, b, c);
array2.push(b, c, a); array2.push(b, c, a);
assert.deepEqual(_.difference(array1, array2), [LARGE_ARRAY_SIZE]); assert.deepEqual(func(array1, array2), [LARGE_ARRAY_SIZE]);
}); });
QUnit.test('should work with large arrays of objects', function(assert) { QUnit.test('`_.' + methodName + '` should work with large arrays of objects', function(assert) {
assert.expect(1); assert.expect(1);
var object1 = {}, var object1 = {},
object2 = {}, object2 = {},
largeArray = _.times(LARGE_ARRAY_SIZE, _.constant(object1)); largeArray = _.times(LARGE_ARRAY_SIZE, _.constant(object1));
assert.deepEqual(_.difference([object1, object2], largeArray), [object2]); assert.deepEqual(func([object1, object2], largeArray), [object2]);
}); });
QUnit.test('should work with large arrays of `NaN`', function(assert) { QUnit.test('`_.' + methodName + '` should work with large arrays of `NaN`', function(assert) {
assert.expect(1); assert.expect(1);
var largeArray = _.times(LARGE_ARRAY_SIZE, _.constant(NaN)); var largeArray = _.times(LARGE_ARRAY_SIZE, _.constant(NaN));
assert.deepEqual(_.difference([1, NaN, 3], largeArray), [1, 3]); assert.deepEqual(func([1, NaN, 3], largeArray), [1, 3]);
}); });
QUnit.test('should ignore values that are not array-like', function(assert) { QUnit.test('`_.' + methodName + '` should ignore values that are not array-like', function(assert) {
assert.expect(3); assert.expect(3);
var array = [1, null, 3]; var array = [1, null, 3];
assert.deepEqual(_.difference(args, 3, { '0': 1 }), [1, 2, 3]); assert.deepEqual(func(args, 3, { '0': 1 }), [1, 2, 3]);
assert.deepEqual(_.difference(null, array, 1), []); assert.deepEqual(func(null, array, 1), []);
assert.deepEqual(_.difference(array, args, null), [null]); assert.deepEqual(func(array, args, null), [null]);
}); });
}(1, 2, 3)); });
/*--------------------------------------------------------------------------*/ /*--------------------------------------------------------------------------*/
@@ -6900,82 +6901,83 @@
/*--------------------------------------------------------------------------*/ /*--------------------------------------------------------------------------*/
QUnit.module('lodash.intersection'); QUnit.module('intersection methods');
(function() { _.each(['intersection', 'intersectionBy'], function(methodName) {
var args = arguments; var args = (function() { return arguments; }(1, 2, 3)),
func = _[methodName];
QUnit.test('should return the intersection of the given arrays', function(assert) { QUnit.test('`_.' + methodName + '` should return the intersection of the given arrays', function(assert) {
assert.expect(1); assert.expect(1);
var actual = _.intersection([1, 3, 2], [5, 2, 1, 4], [2, 1]); var actual = func([1, 3, 2], [5, 2, 1, 4], [2, 1]);
assert.deepEqual(actual, [1, 2]); assert.deepEqual(actual, [1, 2]);
}); });
QUnit.test('should return an array of unique values', function(assert) { QUnit.test('`_.' + methodName + '` should return an array of unique values', function(assert) {
assert.expect(1); assert.expect(1);
var actual = _.intersection([1, 1, 3, 2, 2], [5, 2, 2, 1, 4], [2, 1, 1]); var actual = func([1, 1, 3, 2, 2], [5, 2, 2, 1, 4], [2, 1, 1]);
assert.deepEqual(actual, [1, 2]); assert.deepEqual(actual, [1, 2]);
}); });
QUnit.test('should match `NaN`', function(assert) { QUnit.test('`_.' + methodName + '` should match `NaN`', function(assert) {
assert.expect(1); assert.expect(1);
var actual = _.intersection([1, NaN, 3], [NaN, 5, NaN]); var actual = func([1, NaN, 3], [NaN, 5, NaN]);
assert.deepEqual(actual, [NaN]); assert.deepEqual(actual, [NaN]);
}); });
QUnit.test('should work with large arrays of objects', function(assert) { QUnit.test('`_.' + methodName + '` should work with large arrays of objects', function(assert) {
assert.expect(2); assert.expect(2);
var object = {}, var object = {},
largeArray = _.times(LARGE_ARRAY_SIZE, _.constant(object)); largeArray = _.times(LARGE_ARRAY_SIZE, _.constant(object));
assert.deepEqual(_.intersection([object], largeArray), [object]); assert.deepEqual(func([object], largeArray), [object]);
assert.deepEqual(_.intersection(_.range(LARGE_ARRAY_SIZE), [1]), [1]); assert.deepEqual(func(_.range(LARGE_ARRAY_SIZE), [1]), [1]);
}); });
QUnit.test('should work with large arrays of `NaN`', function(assert) { QUnit.test('`_.' + methodName + '` should work with large arrays of `NaN`', function(assert) {
assert.expect(1); assert.expect(1);
var largeArray = _.times(LARGE_ARRAY_SIZE, _.constant(NaN)); var largeArray = _.times(LARGE_ARRAY_SIZE, _.constant(NaN));
assert.deepEqual(_.intersection([1, NaN, 3], largeArray), [NaN]); assert.deepEqual(func([1, NaN, 3], largeArray), [NaN]);
}); });
QUnit.test('should work with `arguments` objects', function(assert) { QUnit.test('`_.' + methodName + '` should work with `arguments` objects', function(assert) {
assert.expect(2); assert.expect(2);
var array = [0, 1, null, 3], var array = [0, 1, null, 3],
expected = [1, 3]; expected = [1, 3];
assert.deepEqual(_.intersection(array, args), expected); assert.deepEqual(func(array, args), expected);
assert.deepEqual(_.intersection(args, array), expected); assert.deepEqual(func(args, array), expected);
}); });
QUnit.test('should work with a single array', function(assert) { QUnit.test('`_.' + methodName + '` should work with a single array', function(assert) {
assert.expect(1); assert.expect(1);
var actual = _.intersection([1, 1, 3, 2, 2]); var actual = func([1, 1, 3, 2, 2]);
assert.deepEqual(actual, [1, 3, 2]); assert.deepEqual(actual, [1, 3, 2]);
}); });
QUnit.test('should treat values that are not arrays or `arguments` objects as empty', function(assert) { QUnit.test('`_.' + methodName + '` should treat values that are not arrays or `arguments` objects as empty', function(assert) {
assert.expect(3); assert.expect(3);
var array = [0, 1, null, 3], var array = [0, 1, null, 3],
values = [3, null, { '0': 1 }]; values = [3, null, { '0': 1 }];
_.each(values, function(value) { _.each(values, function(value) {
assert.deepEqual(_.intersection(array, value), []); assert.deepEqual(func(array, value), []);
}); });
}); });
QUnit.test('should return a wrapped value when chaining', function(assert) { QUnit.test('`_.' + methodName + '` should return a wrapped value when chaining', function(assert) {
assert.expect(2); assert.expect(2);
if (!isNpm) { if (!isNpm) {
var wrapped = _([1, 3, 2]).intersection([5, 2, 1, 4]); var wrapped = _([1, 3, 2])[methodName]([5, 2, 1, 4]);
assert.ok(wrapped instanceof _); assert.ok(wrapped instanceof _);
assert.deepEqual(wrapped.value(), [1, 2]); assert.deepEqual(wrapped.value(), [1, 2]);
} }
@@ -6983,7 +6985,7 @@
skipTest(assert, 2); skipTest(assert, 2);
} }
}); });
}(1, 2, 3)); });
/*--------------------------------------------------------------------------*/ /*--------------------------------------------------------------------------*/
@@ -19253,34 +19255,35 @@
/*--------------------------------------------------------------------------*/ /*--------------------------------------------------------------------------*/
QUnit.module('lodash.union'); QUnit.module('union methods');
(function() { _.each(['union', 'unionBy'], function(methodName) {
var args = arguments; var args = (function() { return arguments; }(1, 2, 3)),
func = _[methodName];
QUnit.test('should return the union of the given arrays', function(assert) { QUnit.test('`_.' + methodName + '` should return the union of the given arrays', function(assert) {
assert.expect(1); assert.expect(1);
var actual = _.union([1, 3, 2], [5, 2, 1, 4], [2, 1]); var actual = func([1, 3, 2], [5, 2, 1, 4], [2, 1]);
assert.deepEqual(actual, [1, 3, 2, 5, 4]); assert.deepEqual(actual, [1, 3, 2, 5, 4]);
}); });
QUnit.test('should not flatten nested arrays', function(assert) { QUnit.test('`_.' + methodName + '` should not flatten nested arrays', function(assert) {
assert.expect(1); assert.expect(1);
var actual = _.union([1, 3, 2], [1, [5]], [2, [4]]); var actual = func([1, 3, 2], [1, [5]], [2, [4]]);
assert.deepEqual(actual, [1, 3, 2, [5], [4]]); assert.deepEqual(actual, [1, 3, 2, [5], [4]]);
}); });
QUnit.test('should ignore values that are not arrays or `arguments` objects', function(assert) { QUnit.test('`_.' + methodName + '` should ignore values that are not arrays or `arguments` objects', function(assert) {
assert.expect(3); assert.expect(3);
var array = [0]; var array = [0];
assert.deepEqual(_.union(array, 3, null, { '0': 1 }), array); assert.deepEqual(func(array, 3, { '0': 1 }, null), array);
assert.deepEqual(_.union(null, array, null, [2, 1]), [0, 2, 1]); assert.deepEqual(func(null, array, null, [2, 1]), [0, 2, 1]);
assert.deepEqual(_.union(array, null, args, null), [0, 1, 2, 3]); assert.deepEqual(func(array, null, args, null), [0, 1, 2, 3]);
}); });
}(1, 2, 3)); });
/*--------------------------------------------------------------------------*/ /*--------------------------------------------------------------------------*/
@@ -19851,56 +19854,57 @@
/*--------------------------------------------------------------------------*/ /*--------------------------------------------------------------------------*/
QUnit.module('lodash.xor'); QUnit.module('xor methods');
(function() { _.each(['xor', 'xorBy'], function(methodName) {
var args = arguments; var args = (function() { return arguments; }(1, 2, 3)),
func = _[methodName];
QUnit.test('should return the symmetric difference of the given arrays', function(assert) { QUnit.test('`_.' + methodName + '` should return the symmetric difference of the given arrays', function(assert) {
assert.expect(1); assert.expect(1);
var actual = _.xor([1, 2, 5], [2, 3, 5], [3, 4, 5]); var actual = func([1, 2, 5], [2, 3, 5], [3, 4, 5]);
assert.deepEqual(actual, [1, 4, 5]); assert.deepEqual(actual, [1, 4, 5]);
}); });
QUnit.test('should return an array of unique values', function(assert) { QUnit.test('`_.' + methodName + '` should return an array of unique values', function(assert) {
assert.expect(2); assert.expect(2);
var actual = _.xor([1, 1, 2, 5], [2, 2, 3, 5], [3, 4, 5, 5]); var actual = func([1, 1, 2, 5], [2, 2, 3, 5], [3, 4, 5, 5]);
assert.deepEqual(actual, [1, 4, 5]); assert.deepEqual(actual, [1, 4, 5]);
actual = _.xor([1, 1]); actual = func([1, 1]);
assert.deepEqual(actual, [1]); assert.deepEqual(actual, [1]);
}); });
QUnit.test('should return a new array when a single array is provided', function(assert) { QUnit.test('`_.' + methodName + '` should return a new array when a single array is provided', function(assert) {
assert.expect(1); assert.expect(1);
var array = [1]; var array = [1];
assert.notStrictEqual(_.xor(array), array); assert.notStrictEqual(func(array), array);
}); });
QUnit.test('should ignore individual secondary arguments', function(assert) { QUnit.test('`_.' + methodName + '` should ignore individual secondary arguments', function(assert) {
assert.expect(1); assert.expect(1);
var array = [0]; var array = [0];
assert.deepEqual(_.xor(array, 3, null, { '0': 1 }), array); assert.deepEqual(func(array, 3, null, { '0': 1 }), array);
}); });
QUnit.test('should ignore values that are not arrays or `arguments` objects', function(assert) { QUnit.test('`_.' + methodName + '` should ignore values that are not arrays or `arguments` objects', function(assert) {
assert.expect(3); assert.expect(3);
var array = [1, 2]; var array = [1, 2];
assert.deepEqual(_.xor(array, 3, null, { '0': 1 }), array); assert.deepEqual(func(array, 3, { '0': 1 }, null), array);
assert.deepEqual(_.xor(null, array, null, [2, 3]), [1, 3]); assert.deepEqual(func(null, array, null, [2, 3]), [1, 3]);
assert.deepEqual(_.xor(array, null, args, null), [3]); assert.deepEqual(func(array, null, args, null), [3]);
}); });
QUnit.test('should return a wrapped value when chaining', function(assert) { QUnit.test('`_.' + methodName + '` should return a wrapped value when chaining', function(assert) {
assert.expect(2); assert.expect(2);
if (!isNpm) { if (!isNpm) {
var wrapped = _([1, 2, 3]).xor([5, 2, 1, 4]); var wrapped = _([1, 2, 3])[methodName]([5, 2, 1, 4]);
assert.ok(wrapped instanceof _); assert.ok(wrapped instanceof _);
assert.deepEqual(wrapped.value(), [3, 5, 4]); assert.deepEqual(wrapped.value(), [3, 5, 4]);
} }
@@ -19909,12 +19913,12 @@
} }
}); });
QUnit.test('should work when in a lazy chain sequence before `first` or `last`', function(assert) { QUnit.test('`_.' + methodName + '` should work when in a lazy chain sequence before `first` or `last`', function(assert) {
assert.expect(1); assert.expect(1);
if (!isNpm) { if (!isNpm) {
var array = _.range(LARGE_ARRAY_SIZE + 1), var array = _.range(LARGE_ARRAY_SIZE + 1),
wrapped = _(array).slice(1).xor([LARGE_ARRAY_SIZE, LARGE_ARRAY_SIZE + 1]); wrapped = _(array).slice(1)[methodName]([LARGE_ARRAY_SIZE, LARGE_ARRAY_SIZE + 1]);
var actual = _.map(['first', 'last'], function(methodName) { var actual = _.map(['first', 'last'], function(methodName) {
return wrapped[methodName](); return wrapped[methodName]();
@@ -19926,7 +19930,7 @@
skipTest(assert); skipTest(assert);
} }
}); });
}(1, 2, 3)); });
/*--------------------------------------------------------------------------*/ /*--------------------------------------------------------------------------*/