Lines Matching refs:deepEqual
871 assert.deepEqual(actual, [[otherObject], [object], [object]], label);
885 assert.deepEqual(actual, [object, object], label);
899 assert.deepEqual(actual, [{}, false, ''], label);
908 assert.deepEqual(actual, 1, label);
920 assert.deepEqual(actual, [], label);
946 assert.deepEqual(actual, expected);
964 assert.deepEqual(actual, expected);
1078 assert.deepEqual(cache.get(key), value);
1124 assert.deepEqual(actual, expected);
1140 assert.deepEqual(actual, expected);
1159 assert.deepEqual(actual, expected);
1239 assert.deepEqual(actual, [6, 8, 10]);
1242 assert.deepEqual(capped('a', 'b', 'c', 'd'), ['a', 'b']);
1249 assert.deepEqual(capped('a', 'b', 'c', 'd'), ['a', 'b', 'c']);
1261 assert.deepEqual(actual, []);
1275 assert.deepEqual(actual, expected);
1292 assert.deepEqual(actual, expected);
1308 assert.deepEqual(capped('a', 'b', 'c'), ['a']);
1317 assert.deepEqual(actual, ['a', 'b', 'c']);
1360 assert.deepEqual(func({ 'a': 1 }, { 'b': 2 }), { 'a': 1, 'b': 2 });
1367 assert.deepEqual(func({ 'a': 1 }, { 'b': 2 }, { 'c': 3 }), expected);
1368 assert.deepEqual(func({ 'a': 1 }, { 'b': 2, 'c': 2 }, { 'c': 3 }), expected);
1375 assert.deepEqual(func({ 'a': 1, 'b': 2 }, expected), expected);
1382 assert.deepEqual(func({ 'a': 1, 'b': 2 }, expected), expected);
1425 assert.deepEqual(actual, source);
1434 assert.deepEqual(func({}, array), { '0': 1, '1': undefined, '2': 3 });
1443 assert.deepEqual(func({}, Foo.prototype), { 'a': 1 });
1449 assert.deepEqual(func({}, 'a'), { '0': 'a' });
1479 assert.deepEqual(actual, { 'a': 1, 'b': 2, 'c': 3 });
1486 assert.deepEqual(func({}, expected, noop), expected);
1502 assert.deepEqual(actual, ['a', 'c']);
1509 assert.deepEqual(actual, ['c', undefined, 'a']);
1526 assert.deepEqual(actual, expected);
1532 assert.deepEqual(_.at(array), []);
1533 assert.deepEqual(_.at(array, [], []), []);
1540 assert.deepEqual(actual, ['d', 'a', 'c']);
1554 assert.deepEqual(actual, expected);
1561 assert.deepEqual(actual, [3, 1]);
1568 assert.deepEqual(actual, [2, 3, 4]);
1575 assert.deepEqual(actual, [3, 4]);
1587 assert.deepEqual(actual, [2]);
1602 assert.deepEqual(wrapped.value(), _.at(_.map(array, identity), paths));
1628 assert.deepEqual(actual, expected);
1643 assert.deepEqual(actual, _.at(_.map(object, identity), paths));
1647 assert.deepEqual(actual, _.at(indexObject, 0));
1670 assert.deepEqual(actual, [1, 2]);
1682 assert.deepEqual(actual, expected);
1709 assert.deepEqual(actual, expected);
1794 assert.deepEqual(bound('a'), [object, 'a']);
1839 assert.deepEqual(bound(), [object, 'a']);
1842 assert.deepEqual(bound('b'), [object, 'a', 'b']);
1845 assert.deepEqual(bound(), [object, 'a', 'b']);
1846 assert.deepEqual(bound('c', 'd'), [object, 'a', 'b', 'c', 'd']);
1856 assert.deepEqual(bound('a', 'c'), [object, 'a', 'b', 'c']);
1857 assert.deepEqual(bound('a'), [object, 'a', 'b', undefined]);
1858 assert.deepEqual(bound('a', 'c', 'd'), [object, 'a', 'b', 'c', 'd']);
1859 assert.deepEqual(bound(), [object, undefined, 'b', undefined]);
1871 assert.deepEqual(bound('a', 'c'), [object, 'a', 'b', ph, 'c']);
1937 assert.deepEqual(actual, expected);
1960 assert.deepEqual(bound(['b'], 'c'), [object, 'a', ['b'], 'c']);
1974 assert.deepEqual(bound1(), [object1]);
1975 assert.deepEqual(bound2(), [object1, 'a']);
1976 assert.deepEqual(bound3(), [object1, 'b']);
1989 assert.deepEqual(actual, expected);
1997 assert.deepEqual(actual, expected);
2025 assert.deepEqual(actual, expected);
2042 assert.deepEqual(actual, [object, 'a', 'b', 'c']);
2082 assert.deepEqual(actual, [1, 2, undefined]);
2095 assert.deepEqual(actual, [1, 2, 3, undefined]);
2109 assert.deepEqual(actual, [-2, -2, -1, -1]);
2130 assert.deepEqual(actual, [1]);
2171 assert.deepEqual(bound('a', 'c'), ['a', 'b', 'c']);
2172 assert.deepEqual(bound('a'), ['a', 'b', undefined]);
2173 assert.deepEqual(bound('a', 'c', 'd'), ['a', 'b', 'c', 'd']);
2174 assert.deepEqual(bound(), [undefined, 'b', undefined]);
2191 assert.deepEqual(bound('a', 'c'), ['a', 'b', ph, 'c']);
2246 assert.deepEqual(actual, lodashStable.map(strings, stubTrue));
2257 assert.deepEqual(actual, lodashStable.map(strings, stubTrue));
2275 assert.deepEqual(actual, lodashStable.map(burredLetters, stubTrue));
2299 assert.deepEqual(actual, expected);
2307 assert.deepEqual(actual, ['', '']);
2414 assert.deepEqual(actual, expected);
2427 assert.deepEqual(_.castArray(), []);
2501 assert.deepEqual(actual, expected);
2512 assert.deepEqual(actual, [5, 1]);
2524 assert.deepEqual(actual, [25, 16, 9, 4]);
2544 assert.deepEqual(actual, [[0, 1, 2], [3, 4, 5]]);
2551 assert.deepEqual(actual, [[0, 1, 2, 3], [4, 5]]);
2565 assert.deepEqual(actual, expected);
2578 assert.deepEqual(actual, expected);
2584 assert.deepEqual(_.chunk(array, array.length / 4), [[0], [1], [2], [3], [4], [5]]);
2591 assert.deepEqual(actual, [[[1], [2]], [[3], [4]]]);
2666 assert.deepEqual(_.clamp(NaN, -5, 5), NaN);
2672 assert.deepEqual(_.clamp(1, -5, NaN), 0);
2673 assert.deepEqual(_.clamp(-1, NaN, 5), 0);
2740 assert.deepEqual(actual, array);
2874 assert.deepEqual(actual, expected);
2883 assert.deepEqual(actual, { 'b': 1 });
2923 assert.deepEqual(actual, object);
2957 assert.deepEqual(actual[symbol], object[symbol]);
2958 assert.deepEqual(getSymbols(actual.a.b), [symbol]);
2959 assert.deepEqual(actual.a.b[symbol], object.a.b[symbol]);
2960 assert.deepEqual(actual.a.b[symbol2], object.a.b[symbol2]);
2961 assert.deepEqual(actual.a.b[symbol3], object.a.b[symbol3]);
3004 assert.deepEqual(func(element), {});
3037 assert.deepEqual(actual, expected, props.join(', '));
3046 assert.deepEqual(actual, expected);
3062 assert.deepEqual(actual, object);
3082 assert.deepEqual(actual, view);
3104 assert.deepEqual(actual, object);
3106 assert.deepEqual(func(value), expected);
3132 assert.deepEqual(argsList, isDeep ? [[object], [1, 'a', object]] : [[object]]);
3139 assert.deepEqual(actual, { 'a': { 'b': 'c' } });
3156 assert.deepEqual(actual, object);
3174 assert.deepEqual(_.compact(falsey.concat(array)), array);
3182 assert.deepEqual(actual, []);
3185 assert.deepEqual(actual, [true, 1, 'a']);
3197 assert.deepEqual(actual, _.take(_.compact(_.slice(largeArray, 1)).reverse()));
3238 assert.deepEqual(actual, array);
3248 assert.deepEqual(actual, [1, 2, 3, [4]]);
3249 assert.deepEqual(array, [1]);
3265 assert.deepEqual(actual, expected);
3275 assert.deepEqual(actual, expected);
3288 assert.deepEqual(actual, expected);
3299 assert.deepEqual(array, [1]);
3300 assert.deepEqual(actual, [1, 2, 3]);
3341 assert.deepEqual(args1, expected);
3342 assert.deepEqual(args2, expected);
3432 assert.deepEqual(actual, [objects[0], objects[2]]);
3440 assert.deepEqual(actual, [objects[2]]);
3464 assert.deepEqual(actual, [objects[1], objects[2]]);
3506 assert.deepEqual(actual, [objects[1]]);
3540 assert.deepEqual(actual, expected);
3556 assert.deepEqual(actual, expected);
3570 assert.deepEqual(actual, expected);
3610 assert.deepEqual(actual, expected);
3637 assert.deepEqual(actual, { '4': 1, '6': 2 });
3651 assert.deepEqual(actual, expected);
3658 assert.deepEqual(actual, { '3': 2, '5': 1 });
3668 assert.deepEqual(actual.constructor, 1);
3669 assert.deepEqual(actual.hasOwnProperty, 2);
3681 assert.deepEqual(_.countBy(array, 0), { '1': 1, '2': 2 });
3682 assert.deepEqual(_.countBy(array, 1), { 'a': 2, 'b': 1 });
3689 assert.deepEqual(actual, { '4': 1, '6': 2 });
3703 assert.deepEqual(actual, _.take(_.filter(_.map(_.countBy(array), square), isEven)));
3748 assert.deepEqual(Circle.prototype, expected);
3760 assert.deepEqual(_.create({}, new Foo), { 'a': 1, 'c': 3 });
3770 assert.deepEqual(lodashStable.keys(object), ['a']);
3782 assert.deepEqual(actual, expected);
3794 assert.deepEqual(actual, expected);
3808 assert.deepEqual(actual, expected);
3827 assert.deepEqual(curried(1)(2)(3)(4), expected);
3828 assert.deepEqual(curried(1, 2)(3, 4), expected);
3829 assert.deepEqual(curried(1, 2, 3, 4), expected);
3838 assert.deepEqual(curried(1)(2, 3), expected);
3839 assert.deepEqual(curried(1, 2)(3), expected);
3840 assert.deepEqual(curried(1, 2, 3), expected);
3853 assert.deepEqual(actual, expected);
3854 assert.deepEqual(_.curry(fn, '2')(1)(2), [1, 2]);
3863 assert.deepEqual(curried(1)(ph, 3)(ph, 4)(2), [1, 2, 3, 4]);
3864 assert.deepEqual(curried(ph, 2)(1)(ph, 4)(3), [1, 2, 3, 4]);
3865 assert.deepEqual(curried(ph, ph, 3)(ph, 2)(ph, 4)(1), [1, 2, 3, 4]);
3866 assert.deepEqual(curried(ph, ph, ph, 4)(ph, ph, 3)(ph, 2)(1), [1, 2, 3, 4]);
3876 assert.deepEqual(actual, ['a', 'b', 'c', 'd']);
3887 assert.deepEqual(curried(1)(_ph, 3)(ph, 4), [1, ph, 3, 4]);
3899 assert.deepEqual(curried(1)(2, 3, 4), [1, 2, 3, 4]);
3900 assert.deepEqual(curried(1, 2)(3, 4, 5), [1, 2, 3, 4, 5]);
3901 assert.deepEqual(curried(1, 2, 3, 4, 5, 6), [1, 2, 3, 4, 5, 6]);
3940 assert.deepEqual(_.curry(_.bind(fn, object), 3)('a')('b')('c'), expected);
3941 assert.deepEqual(_.curry(_.bind(fn, object), 3)('a', 'b')('c'), expected);
3942 assert.deepEqual(_.curry(_.bind(fn, object), 3)('a', 'b', 'c'), expected);
3944 assert.deepEqual(_.bind(_.curry(fn), object)('a')('b')('c'), Array(3));
3945 assert.deepEqual(_.bind(_.curry(fn), object)('a', 'b')('c'), Array(3));
3946 assert.deepEqual(_.bind(_.curry(fn), object)('a', 'b', 'c'), expected);
3949 assert.deepEqual(object.curried('a')('b')('c'), Array(3));
3950 assert.deepEqual(object.curried('a', 'b')('c'), Array(3));
3951 assert.deepEqual(object.curried('a', 'b', 'c'), expected);
3965 assert.deepEqual(c(3), expected);
3966 assert.deepEqual(d(), expected);
3985 assert.deepEqual(curried(4)(3)(2)(1), expected);
3986 assert.deepEqual(curried(3, 4)(1, 2), expected);
3987 assert.deepEqual(curried(1, 2, 3, 4), expected);
3996 assert.deepEqual(curried(3)(1, 2), expected);
3997 assert.deepEqual(curried(2, 3)(1), expected);
3998 assert.deepEqual(curried(1, 2, 3), expected);
4011 assert.deepEqual(actual, expected);
4012 assert.deepEqual(_.curryRight(fn, '2')(1)(2), [2, 1]);
4022 assert.deepEqual(curried(4)(2, ph)(1, ph)(3), expected);
4023 assert.deepEqual(curried(3, ph)(4)(1, ph)(2), expected);
4024 assert.deepEqual(curried(ph, ph, 4)(ph, 3)(ph, 2)(1), expected);
4025 assert.deepEqual(curried(ph, ph, ph, 4)(ph, ph, 3)(ph, 2)(1), expected);
4035 assert.deepEqual(actual, ['a', 'b', 'c', 'd']);
4046 assert.deepEqual(curried(4)(2, _ph)(1, ph), [1, 2, ph, 4]);
4058 assert.deepEqual(curried(4)(1, 2, 3), [1, 2, 3, 4]);
4059 assert.deepEqual(curried(4, 5)(1, 2, 3), [1, 2, 3, 4, 5]);
4060 assert.deepEqual(curried(1, 2, 3, 4, 5, 6), [1, 2, 3, 4, 5, 6]);
4099 assert.deepEqual(_.curryRight(_.bind(fn, object), 3)('c')('b')('a'), expected);
4100 assert.deepEqual(_.curryRight(_.bind(fn, object), 3)('b', 'c')('a'), expected);
4101 assert.deepEqual(_.curryRight(_.bind(fn, object), 3)('a', 'b', 'c'), expected);
4103 assert.deepEqual(_.bind(_.curryRight(fn), object)('c')('b')('a'), Array(3));
4104 assert.deepEqual(_.bind(_.curryRight(fn), object)('b', 'c')('a'), Array(3));
4105 assert.deepEqual(_.bind(_.curryRight(fn), object)('a', 'b', 'c'), expected);
4108 assert.deepEqual(object.curried('c')('b')('a'), Array(3));
4109 assert.deepEqual(object.curried('b', 'c')('a'), Array(3));
4110 assert.deepEqual(object.curried('a', 'b', 'c'), expected);
4124 assert.deepEqual(c(2), expected);
4125 assert.deepEqual(d(), expected);
4163 assert.deepEqual(curried(1)(2)(3), expected);
4180 assert.deepEqual(actual, expected);
4203 assert.deepEqual(results, [undefined, undefined, undefined]);
4210 assert.deepEqual(results, ['c', 'c', 'c']);
4296 assert.deepEqual(callCounts, [1, 2]);
4313 assert.deepEqual(results, ['a', 'a']);
4317 assert.deepEqual(results, ['c', 'c']);
4404 assert.deepEqual(actual, [false, true]);
4478 assert.deepEqual(actual, [object, 'a']);
4493 assert.deepEqual(actual, deburredLetters);
4502 assert.deepEqual(actual, operators);
4514 assert.deepEqual(actual, expected);
4527 assert.deepEqual(actual, { 'a': 1, 'b': 2 });
4536 assert.deepEqual(actual, expected);
4539 assert.deepEqual(actual, expected);
4562 assert.deepEqual(actual, { 'a': undefined, 'b': 1 });
4589 assert.deepEqual(_.defaults({}, source), expected);
4592 assert.deepEqual(_.defaults({}, object, source), expected);
4608 assert.deepEqual(_.defaultsDeep(object, source), expected);
4620 assert.deepEqual(_.defaultsDeep({ 'a': { 'b': 2 } }, source1, source2), expected);
4621 assert.deepEqual(_.defaultsDeep({ 'a': { 'b': 2 } }, source3, source4), expected);
4641 assert.deepEqual(actual.a.b, /x/);
4671 assert.deepEqual(actual, expected);
4704 assert.deepEqual(actual, { 'a': 1, 'b': { 'c': 2, 'd': 3 } });
4705 assert.deepEqual(source1, { 'a': 1, 'b': { 'c': 2 } });
4706 assert.deepEqual(source2, { 'b': { 'c': 3, 'd': 3 } });
4713 assert.deepEqual(actual.a, ['abc']);
4744 assert.deepEqual(actual, expected);
4779 assert.deepEqual(args, [1, 2]);
4836 assert.deepEqual(args, [1, 2]);
4903 assert.deepEqual(actual, [1]);
4910 assert.deepEqual(actual, [1]);
4922 assert.deepEqual(actual, [[], []]);
4925 assert.deepEqual(actual, ['0']);
4931 assert.deepEqual(func([1, NaN, 3], [NaN, 5, NaN]), [1, 3]);
4946 assert.deepEqual(func(array1, array2), [LARGE_ARRAY_SIZE]);
4959 assert.deepEqual(actual, [[], []]);
4963 assert.deepEqual(actual, ['0']);
4970 assert.deepEqual(func([1, NaN, 3], largeArray), [1, 3]);
4980 assert.deepEqual(func([object1, object2], largeArray), [object2]);
4988 assert.deepEqual(func(args, 3, { '0': 1 }), [1, 2, 3]);
4989 assert.deepEqual(func(null, array, 1), []);
4990 assert.deepEqual(func(array, args, null), [null]);
5003 assert.deepEqual(actual, [1.2]);
5006 assert.deepEqual(actual, [{ 'x': 2 }]);
5018 assert.deepEqual(args, [2.3]);
5033 assert.deepEqual(actual, [objects[1]]);
5048 assert.deepEqual(actual, expected);
5069 assert.deepEqual(_.divide('x', 'y'), NaN);
5083 assert.deepEqual(_.drop(array, 2), [3]);
5097 assert.deepEqual(actual, expected);
5104 assert.deepEqual(_.drop(array, n), array);
5112 assert.deepEqual(_.drop(array, n), []);
5119 assert.deepEqual(_.drop(array, 1.6), [2, 3]);
5128 assert.deepEqual(actual, [[2, 3], [5, 6], [8, 9]]);
5140 assert.deepEqual(actual, array.slice(3));
5143 assert.deepEqual(values, array);
5144 assert.deepEqual(actual, _.drop(_.drop(_.filter(array, predicate), 2)));
5147 assert.deepEqual(actual, _.dropRight(_.drop(_.dropRight(_.drop(array, 2))), 2));
5152 assert.deepEqual(values, array.slice(1));
5153 …assert.deepEqual(actual, _.dropRight(_.drop(_.dropRight(_.drop(_.filter(_.drop(array), predicate),…
5171 assert.deepEqual(_.dropRight(array, 2), [1]);
5185 assert.deepEqual(actual, expected);
5192 assert.deepEqual(_.dropRight(array, n), array);
5200 assert.deepEqual(_.dropRight(array, n), []);
5207 assert.deepEqual(_.dropRight(array, 1.6), [1, 2]);
5216 assert.deepEqual(actual, [[1, 2], [4, 5], [7, 8]]);
5228 assert.deepEqual(actual, array.slice(0, -3));
5231 assert.deepEqual(values, array);
5232 assert.deepEqual(actual, _.dropRight(_.dropRight(_.filter(array, predicate), 2)));
5235 assert.deepEqual(actual, _.drop(_.dropRight(_.drop(_.dropRight(array, 2))), 2));
5240 assert.deepEqual(values, array.slice(0, -1));
5241 …assert.deepEqual(actual, _.drop(_.dropRight(_.drop(_.dropRight(_.filter(_.dropRight(array), predic…
5269 assert.deepEqual(actual, [1, 2]);
5281 assert.deepEqual(args, [4, 3, array]);
5287 assert.deepEqual(_.dropRightWhile(objects, { 'b': 2 }), objects.slice(0, 2));
5293 assert.deepEqual(_.dropRightWhile(objects, ['b', 2]), objects.slice(0, 2));
5299 assert.deepEqual(_.dropRightWhile(objects, 'b'), objects.slice(0, 1));
5311 assert.deepEqual(wrapped.value(), [1, 2]);
5339 assert.deepEqual(actual, [3, 4]);
5351 assert.deepEqual(args, [1, 0, array]);
5357 assert.deepEqual(_.dropWhile(objects, { 'b': 2 }), objects.slice(1));
5363 assert.deepEqual(_.dropWhile(objects, ['b', 2]), objects.slice(1));
5369 assert.deepEqual(_.dropWhile(objects, 'b'), objects.slice(2));
5381 assert.deepEqual(wrapped.value(), expected);
5382 assert.deepEqual(wrapped.reverse().value(), expected.slice().reverse());
5402 assert.deepEqual(actual, array.slice(3));
5452 assert.deepEqual(actual, expected);
5566 assert.deepEqual(actual, expected);
5592 assert.deepEqual(actual, expected);
5625 assert.deepEqual(actual, expected);
5633 assert.deepEqual(actual, expected);
5656 assert.deepEqual(actual, [true]);
5692 assert.deepEqual(_.fill(array, 'a'), ['a', 'a', 'a']);
5701 assert.deepEqual(actual, Array(3));
5711 assert.deepEqual(_.fill(array, 'a', 1), [1, 'a', 'a']);
5719 assert.deepEqual(_.fill(array, 'a', start), [1, 2, 3]);
5733 assert.deepEqual(actual, expected);
5740 assert.deepEqual(_.fill(array, 'a', -1), [1, 2, 'a']);
5748 assert.deepEqual(_.fill(array, 'a', start), ['a', 'a', 'a']);
5757 assert.deepEqual(_.fill(array, 'a', start, 2), [1, 2, 3]);
5765 assert.deepEqual(_.fill(array, 'a', 0, 1), ['a', 2, 3]);
5773 assert.deepEqual(_.fill(array, 'a', 0, end), ['a', 'a', 'a']);
5789 assert.deepEqual(actual, expected);
5796 assert.deepEqual(_.fill(array, 'a', 0, -1), ['a', 'a', 3]);
5804 assert.deepEqual(_.fill(array, 'a', 0, end), [1, 2, 3]);
5818 …assert.deepEqual(actual, [['a', 2, 3], ['a', 2, 3], ['a', 2, 3], [1, 'a', 'a'], ['a', 2, 3], [1, 2…
5827 assert.deepEqual(actual, [[0, 0], [1, 1]]);
5840 assert.deepEqual(actual, ['a', 'a', 'a']);
5858 assert.deepEqual(_.filter(array, isEven), [2]);
5927 assert.deepEqual(actual, expecting);
6006 assert.deepEqual(args, ['a', 0, array]);
6040 assert.deepEqual(args, [1, 'a', object]);
6101 assert.deepEqual(actual, expected);
6122 assert.deepEqual(actual, expected);
6134 assert.deepEqual(actual, expected);
6152 assert.deepEqual(actual, expected);
6168 assert.deepEqual(actual, expected);
6181 assert.deepEqual(actual, expected);
6221 assert.deepEqual(actual, expected);
6240 assert.deepEqual(actual, expected);
6252 assert.deepEqual(actual, expected);
6289 assert.deepEqual(actual, expected);
6307 assert.deepEqual(actual, expected);
6321 assert.deepEqual(actual, expected);
6339 assert.deepEqual(actual, expected);
6355 assert.deepEqual(actual, expected);
6368 assert.deepEqual(actual, expected);
6386 assert.deepEqual(flipped('a', 'b', 'c', 'd'), ['d', 'c', 'b', 'a']);
6400 assert.deepEqual(_.flatMapDepth(array, identity), [1, 2, [3, [4]], 5]);
6413 assert.deepEqual(actual, expected);
6420 assert.deepEqual(_.flatMapDepth(array, identity, depth), [1, [2, [3, [4]], 5]]);
6427 assert.deepEqual(_.flatMapDepth(array, identity, 2.2), [1, 2, 3, [4], 5]);
6449 assert.deepEqual(actual, expected);
6456 assert.deepEqual(func(objects, 'a'), array);
6468 assert.deepEqual(actual, [1, 2]);
6484 assert.deepEqual(actual, expected);
6499 assert.deepEqual(actual, expected);
6505 assert.deepEqual(func(1), []);
6512 assert.deepEqual(func(object, identity), [1, 2]);
6526 assert.deepEqual(_.flattenDepth(array), [1, 2, [3, [4]], 5]);
6533 assert.deepEqual(_.flattenDepth(array, depth), [1, [2, [3, [4]], 5]]);
6540 assert.deepEqual(_.flattenDepth(array, 2.2), [1, 2, 3, [4], 5]);
6557 assert.deepEqual(_.flatten(array), [1, 2, 3, args]);
6558 assert.deepEqual(_.flattenDeep(array), [1, 2, 3, 1, 2, 3]);
6559 assert.deepEqual(_.flattenDepth(array, 2), [1, 2, 3, 1, 2, 3]);
6572 assert.deepEqual(actual, expected);
6591 assert.deepEqual(actual, expected);
6610 assert.deepEqual(func([expected]), expected);
6622 assert.deepEqual(_.flatten(array), [[], [], [[[]]]]);
6623 assert.deepEqual(_.flattenDeep(array), []);
6624 assert.deepEqual(_.flattenDepth(array, 2), [[[]]]);
6630 assert.deepEqual(_.flatten(array), [1, 2, [3, [4]], 5]);
6631 assert.deepEqual(_.flattenDeep(array), [1, 2, 3, 4, 5]);
6632 assert.deepEqual(_.flattenDepth(array, 2), [1, 2, 3, [4], 5]);
6641 assert.deepEqual(_.flatten(nonArray), expected);
6642 assert.deepEqual(_.flattenDeep(nonArray), expected);
6643 assert.deepEqual(_.flattenDepth(nonArray, 2), expected);
6654 assert.deepEqual(actual.value(), [1, 2, [3, [4]], 5]);
6659 assert.deepEqual(actual.value(), [1, 2, 3, 4, 5]);
6664 assert.deepEqual(actual.value(), [1, 2, 3, [4], 5]);
6749 assert.deepEqual(combined(array), [4, 16]);
6775 assert.deepEqual(combined(objects), [1, 2]);
6832 assert.deepEqual(keys.sort(), ['a', 'b']);
6850 assert.deepEqual(props.sort(), ['0', '1', 'length']);
7007 assert.deepEqual(args, expected);
7045 assert.deepEqual(argsList, expected);
7140 assert.deepEqual(values, [1]);
7187 assert.deepEqual(actual, expected);
7276 assert.deepEqual(actual, expected);
7288 assert.deepEqual(func({}, new Foo), expected);
7297 assert.deepEqual(func({}, { 'a': 1 }, fn), { 'a': 1, 'b': 2 });
7304 assert.deepEqual(func({ 'a': 1 }, undefined, { 'b': 2 }, null), { 'a': 1, 'b': 2 });
7322 assert.deepEqual(actual, expected);
7328 assert.deepEqual(actual, expected);
7342 assert.deepEqual(lodashStable.reduce(array, func, { 'a': 0 }), expected);
7343 assert.deepEqual(lodashStable.reduce(fn, func, { 'a': 0 }), expected);
7414 assert.deepEqual(args, expected, 'primitive values');
7431 assert.deepEqual(argsList, expected, 'object values');
7442 assert.deepEqual(args, expected, 'undefined properties');
7452 assert.deepEqual(actual, { 'a': 1, 'b': 2 });
7455 assert.deepEqual(actual, { 'a': 1, 'b': 2, 'c': 3 });
7478 assert.deepEqual(values, [lodashStable.endsWith(methodName, 'Right') ? 3 : 1]);
7521 assert.deepEqual(_.difference(largeArray, largeArray), []);
7522 assert.deepEqual(_.intersection(largeArray, largeArray), expected);
7523 assert.deepEqual(_.uniq(largeArray), expected);
7524 assert.deepEqual(_.without.apply(_, [largeArray].concat(largeArray)), []);
7548 assert.deepEqual(actual, expected);
7611 assert.deepEqual(actual, object);
7625 assert.deepEqual(actual, expected);
7632 assert.deepEqual(actual, { 'a.b': 1 });
7639 assert.deepEqual(_.fromPairs(_.toPairs(object)), object);
7652 assert.deepEqual(actual, _.take(_.filter(_.map(_.fromPairs(array), square), isEven)));
7671 assert.deepEqual(actual, ['b', 'd']);
7683 assert.deepEqual(_.functions(new Foo), ['a']);
7698 assert.deepEqual(actual, { '4': [4.2], '6': [6.1, 6.3] });
7712 assert.deepEqual(actual, expected);
7719 assert.deepEqual(actual, { '3': ['one', 'two'], '5': ['three'] });
7729 assert.deepEqual(actual.constructor, [4.2]);
7730 assert.deepEqual(actual.hasOwnProperty, [6.1, 6.3]);
7742 assert.deepEqual(_.groupBy(array, 0), { '1': [[1, 'a']], '2': [[2, 'a'], [2, 'b']] });
7743 assert.deepEqual(_.groupBy(array, 1), { 'a': [[1, 'a'], [2, 'a']], 'b': [[2, 'b']] });
7750 assert.deepEqual(actual, { '4': [4.2], '6': [6.1, 6.3] });
7766 …assert.deepEqual(actual, _.take(_.filter(lodashStable.map(_.groupBy(array), iteratee), predicate))…
7878 assert.deepEqual(actual, expected);
7909 assert.deepEqual(actual, expected);
7957 assert.deepEqual(actual, expected);
7972 assert.deepEqual(actual, expected);
8008 assert.deepEqual(actual, expected);
8023 assert.deepEqual(actual, expected);
8039 assert.deepEqual(actual, expected);
8055 assert.deepEqual(actual, expected);
8086 assert.deepEqual(actual, [1, 4, 7]);
8246 assert.deepEqual(actual, expected);
8268 assert.deepEqual(actual, expected);
8312 assert.deepEqual(actual, expected);
8318 assert.deepEqual(_.initial(array), [1, 2]);
8324 assert.deepEqual(_.initial([]), []);
8333 assert.deepEqual(actual, [[1, 2], [4, 5], [7, 8]]);
8349 assert.deepEqual(actual, []);
8350 assert.deepEqual(values, _.initial(array));
8361 assert.deepEqual(actual, _.initial(lodashStable.filter(array, isEven)));
8362 assert.deepEqual(values, array);
8432 assert.deepEqual(actual, lodashStable.map(actual, stubTrue));
8447 assert.deepEqual(actual, [2]);
8454 assert.deepEqual(actual, [3]);
8461 assert.deepEqual(actual, [1, 2]);
8468 assert.deepEqual(actual, [1, 3, 2]);
8477 assert.deepEqual(func(array, args), expected);
8478 assert.deepEqual(func(args, array), expected);
8491 assert.deepEqual(actual, expected);
8498 assert.deepEqual(actual, [NaN]);
8512 assert.deepEqual(actual, expected);
8519 assert.deepEqual(func([1, NaN, 3], largeArray), [NaN]);
8528 assert.deepEqual(func([object], largeArray), [object]);
8529 assert.deepEqual(func(lodashStable.range(LARGE_ARRAY_SIZE), [1]), [1]);
8536 assert.deepEqual(func(array, 3, { '0': 1 }, null), []);
8537 assert.deepEqual(func(null, array, null, [2, 3]), []);
8538 assert.deepEqual(func(array, null, args, null), []);
8547 assert.deepEqual(wrapped.value(), [1, 2]);
8564 assert.deepEqual(actual, [2.1]);
8567 assert.deepEqual(actual, [{ 'x': 1 }]);
8579 assert.deepEqual(args, [2.3]);
8595 assert.deepEqual(actual, [objects[0]]);
8610 assert.deepEqual(actual, expected);
8625 assert.deepEqual(actual, { '1': 'a', '2': 'b' });
8626 assert.deepEqual(_.invert(actual), { 'a': '1', 'b': '2' });
8633 assert.deepEqual(_.invert(object), { 'hasOwnProperty': 'a', 'constructor': 'b' });
8640 assert.deepEqual(_.invert(object), { 'a': '0', 'b': '1', '2': 'length' });
8651 assert.deepEqual(wrapped.value(), { '1': 'a', '2': 'b' });
8675 assert.deepEqual(actual, expected);
8688 assert.deepEqual(actual, expected);
8707 assert.deepEqual(wrapped.value(), { '1': ['a', 'c'], '2': ['b'] });
8735 assert.deepEqual(actual, [1, 2]);
8750 assert.deepEqual(actual, expected);
8763 assert.deepEqual(actual, ['a', 'a', 'b', 'b']);
8773 assert.deepEqual(actual, [1, 2]);
8783 assert.deepEqual(_.invoke(object, path), 1);
8823 assert.deepEqual(actual, ['A', 'B', 'C']);
8832 assert.deepEqual(actual, [['a', 'b', 'c']]);
8844 assert.deepEqual(actual, ['(A)', '(B)', '(C)']);
8853 assert.deepEqual(actual, ['1.0', '2.0', '3.0']);
8859 assert.deepEqual(_.invokeMap(1), []);
8871 assert.deepEqual(actual, ['A', undefined, undefined, 'D']);
8889 assert.deepEqual(actual, expected);
8898 assert.deepEqual(_.invokeMap([object], path), [1]);
8911 assert.deepEqual(actual.valueOf(), ['A', 'B', 'C']);
8918 assert.deepEqual(actual.valueOf(), ['(A)', '(B)', '(C)']);
8939 assert.deepEqual(actual, [0]);
8968 assert.deepEqual(actual, expected);
9015 assert.deepEqual(actual, expected);
9067 assert.deepEqual(actual, expected);
9107 assert.deepEqual(actual, expected);
9121 assert.deepEqual(actual, expected);
9144 assert.deepEqual(actual, expected);
9177 assert.deepEqual(actual, expected);
9229 assert.deepEqual(actual, expected);
9277 assert.deepEqual(actual, expected);
9339 assert.deepEqual(actual, expected);
9389 assert.deepEqual(actual, expected);
9561 assert.deepEqual(actual, expected);
9981 assert.deepEqual(actual, expected);
10036 assert.deepEqual(actual, expected);
10322 assert.deepEqual(actual, expected);
10378 assert.deepEqual(argsList, expected);
10427 assert.deepEqual(actual, expected);
10437 assert.deepEqual(actual, [true, false]);
10481 assert.deepEqual(argsList, expected, index ? 'Set' : 'Map');
10504 assert.deepEqual(actual, expected);
10522 assert.deepEqual(actual, expected);
10553 assert.deepEqual(actual, expected);
10573 assert.deepEqual(actual, expected);
10583 assert.deepEqual(actual, expected);
10593 assert.deepEqual(actual, expected);
10613 assert.deepEqual(actual, expected);
10663 assert.deepEqual(actual, expected);
10675 assert.deepEqual(actual, expected);
10726 assert.deepEqual(actual, expected);
10740 assert.deepEqual(actual, expected);
10754 assert.deepEqual(actual, expected);
10780 assert.deepEqual(actual, expected);
10790 assert.deepEqual(actual, expected);
10819 assert.deepEqual(actual, expected);
10846 assert.deepEqual(actual, expected);
10891 assert.deepEqual(argsList, expected);
10937 assert.deepEqual(actual, expected);
10962 assert.deepEqual(actual, [true, false]);
11005 assert.deepEqual(argsList, expected, index ? 'Set' : 'Map');
11037 assert.deepEqual(actual, expected);
11078 assert.deepEqual(actual, expected);
11090 assert.deepEqual(actual, expected);
11189 assert.deepEqual(actual, expected);
11246 assert.deepEqual(actual, expected);
11298 assert.deepEqual(actual, expected);
11369 assert.deepEqual(actual, expected);
11425 assert.deepEqual(actual, expected);
11489 assert.deepEqual(_.isPlainObject(object), true);
11530 assert.deepEqual(actual, expected);
11549 assert.deepEqual(_.isPlainObject(object), false);
11605 assert.deepEqual(actual, expected);
11657 assert.deepEqual(actual, expected);
11684 assert.deepEqual(actual, expected);
11722 assert.deepEqual(actual, expected);
11775 assert.deepEqual(actual, expected);
11819 assert.deepEqual(actual, expected);
11831 assert.deepEqual(actual, expected);
11862 assert.deepEqual(actual, expected);
11893 assert.deepEqual(actual, expected);
11952 assert.deepEqual(actual, expected);
11979 assert.deepEqual(actual, expected);
12019 assert.deepEqual(actual, expected);
12110 assert.deepEqual(actual, ['a', 'b', 'c', 'd', 'e', 'f']);
12125 assert.deepEqual(actual, expected);
12251 assert.deepEqual(object.iteratee(3), expected);
12254 assert.deepEqual(object.iteratee(2), expected);
12263 assert.deepEqual(_.map([{ 'a': 1 }], 'a'), [1]);
12280 assert.deepEqual(actual, expected);
12312 assert.deepEqual(_.countBy(array), { '3': 2, '5': 1 });
12325 assert.deepEqual(_.differenceBy(objects, [objects[1]]), [objects[0]]);
12338 assert.deepEqual(_.dropRightWhile(objects), objects.slice(0, 2));
12351 assert.deepEqual(_.dropWhile(objects.reverse()).reverse(), objects.reverse().slice(0, 2));
12379 assert.deepEqual(_.filter(objects), [objects[1]]);
12470 assert.deepEqual(_.groupBy(array), { '3': ['one', 'two'], '5': ['three'] });
12483 assert.deepEqual(_.intersectionBy(objects, [objects[2]]), [objects[1]]);
12496 assert.deepEqual(_.keyBy(array), { '3': 'two', '5': 'three' });
12509 assert.deepEqual(_.map(objects), [0, 1, 1]);
12522 assert.deepEqual(_.mapKeys({ 'a': { 'b': 2 } }), { '2': { 'b': 2 } });
12535 assert.deepEqual(_.mapValues({ 'a': { 'b': 2 } }), { 'a': 2 });
12548 assert.deepEqual(_.maxBy(objects), objects[2]);
12574 assert.deepEqual(_.minBy(objects), objects[0]);
12589 assert.deepEqual(_.partition(objects), [objects.slice(0, 2), objects.slice(2)]);
12602 assert.deepEqual(_.pullAllBy(objects.slice(), [{ 'a': 1, 'b': 0 }]), [objects[0]]);
12643 assert.deepEqual(_.reject(objects), [objects[0]]);
12659 assert.deepEqual(objects, [{ 'a': 0 }]);
12685 assert.deepEqual(_.sortBy(objects.slice().reverse()), [objects[0], objects[2], objects[1]]);
12741 assert.deepEqual(_.takeRightWhile(objects), objects.slice(2));
12754 assert.deepEqual(_.takeWhile(objects.reverse()), objects.reverse().slice(2));
12772 assert.deepEqual(_.transform(objects, undefined, { 'sum': 0 }), { 'sum': 2 });
12785 assert.deepEqual(_.uniqBy(objects), [objects[0], objects[2]]);
12798 assert.deepEqual(_.unionBy(objects.slice(0, 1), [objects[2]]), [objects[0], objects[2]]);
12811 assert.deepEqual(_.xorBy(objects, objects.slice(1)), [objects[0]]);
12877 assert.deepEqual(actual, expected);
12891 assert.deepEqual(actual, expected);
12900 assert.deepEqual(actual, expected);
12910 assert.deepEqual(actual.constructor, 4.2);
12911 assert.deepEqual(actual.hasOwnProperty, 6.3);
12923 assert.deepEqual(_.keyBy(array, 0), { '1': [1, 'a'], '2': [2, 'b'] });
12924 assert.deepEqual(_.keyBy(array, 1), { 'a': [2, 'a'], 'b': [2, 'b'] });
12931 assert.deepEqual(actual, { '4': 4.2, '6': 6.3 });
12945 assert.deepEqual(actual, _.take(_.filter(_.map(_.keyBy(array), square), isEven)));
12966 assert.deepEqual(actual, ['a', 'b']);
12980 assert.deepEqual(actual, expected);
12991 assert.deepEqual(actual, ['0', '1', '2']);
13002 assert.deepEqual(actual, ['0', 'a']);
13013 assert.deepEqual(actual, expected);
13028 assert.deepEqual(actual, expected);
13044 assert.deepEqual(actual, expected);
13060 assert.deepEqual(actual, expected);
13068 assert.deepEqual(actual, ['0', '1', '2']);
13079 assert.deepEqual(actual, ['0', 'a']);
13090 assert.deepEqual(actual, expected);
13101 assert.deepEqual(actual, ['0', 'length']);
13112 assert.deepEqual(actual, expected);
13116 assert.deepEqual(func(0), isKeys ? [] : ['a']);
13127 assert.deepEqual(func(Foo.prototype), expected);
13130 assert.deepEqual(func(Foo.prototype), expected);
13134 assert.deepEqual(func(Fake.prototype), ['constructor']);
13148 assert.deepEqual(actual, expected);
13180 assert.deepEqual(actual, [3, 6, 9]);
13344 assert.deepEqual(actual, expected);
13363 assert.deepEqual(actual, expected);
13377 assert.deepEqual(actual, expected);
13407 assert.deepEqual(actual, expected);
13473 assert.deepEqual(_.map(array, String), expected);
13474 assert.deepEqual(_.map(object, String), expected);
13481 assert.deepEqual(_.map(objects, 'a'), ['x', 'y']);
13493 assert.deepEqual(actual, [1]);
13508 assert.deepEqual(actual, expected);
13523 assert.deepEqual(actual, expected);
13529 assert.deepEqual(_.map(1), []);
13540 assert.deepEqual(actual, ['body']);
13553 assert.deepEqual(_.map(object, identity), [value]);
13579 assert.deepEqual(args, [1, 0, array.slice(1)]);
13586 assert.deepEqual(args, expected);
13593 assert.deepEqual(args, expected);
13600 assert.deepEqual(args, [1]);
13607 assert.deepEqual(args, expected);
13627 assert.deepEqual(actual, { '1': 1, '2': 2 });
13634 assert.deepEqual(actual, { '1': 1, '2': 2 });
13641 assert.deepEqual(actual, { 'c': { 'b': 'c' } });
13655 assert.deepEqual(actual, expected);
13671 assert.deepEqual(actual, { 'a': '1', 'b': '2' });
13678 assert.deepEqual(actual, { '0': '1', '1': '2' });
13685 assert.deepEqual(actual, { 'a': 2 });
13700 assert.deepEqual(actual, expected);
13721 assert.deepEqual(actual, { 'a': 'a' });
13735 assert.deepEqual(actual, expected);
13846 assert.deepEqual(actual, expected);
13907 assert.deepEqual(actual, [false, true]);
13927 assert.deepEqual(actual, [objects[1]]);
13930 assert.deepEqual(actual, []);
13933 assert.deepEqual(actual, []);
13942 assert.deepEqual(actual, [objects[1]]);
13954 assert.deepEqual(actual, [objects[0]]);
13970 assert.deepEqual(actual, [objects[1]]);
13975 assert.deepEqual(actual, objects);
13980 assert.deepEqual(actual, []);
14000 assert.deepEqual(actual, [objects[1]]);
14005 assert.deepEqual(actual, objects);
14010 assert.deepEqual(actual, []);
14024 assert.deepEqual(actual, expected);
14028 assert.deepEqual(actual, expected);
14033 assert.deepEqual(actual, expected);
14078 assert.deepEqual(actual, expected);
14092 assert.deepEqual(actual, expected);
14108 assert.deepEqual(actual, expected);
14117 assert.deepEqual(actual, objects);
14189 assert.deepEqual(actual, expected);
14208 assert.deepEqual(actual, expected);
14238 assert.deepEqual(actual, expected);
14257 assert.deepEqual(actual, expected);
14298 assert.deepEqual(lodashStable.map(objects, _.matchesProperty(path, new Foo)), expected);
14347 assert.deepEqual(actual, [false, true]);
14367 assert.deepEqual(actual, [objects[1]]);
14370 assert.deepEqual(actual, []);
14373 assert.deepEqual(actual, []);
14382 assert.deepEqual(actual, [objects[1]]);
14394 assert.deepEqual(actual, [objects[0]]);
14409 assert.deepEqual(actual, [objects[1]]);
14414 assert.deepEqual(actual, objects);
14419 assert.deepEqual(actual, []);
14439 assert.deepEqual(actual, [objects[1]]);
14444 assert.deepEqual(actual, objects);
14449 assert.deepEqual(actual, []);
14463 assert.deepEqual(actual, expected);
14468 assert.deepEqual(actual, expected);
14520 assert.deepEqual(actual, objects);
14570 assert.deepEqual(actual, expected);
14598 assert.deepEqual(actual, expected);
14616 assert.deepEqual(actual, 2);
14628 assert.deepEqual(args, [{ 'a': 2 }]);
14736 assert.deepEqual(actual, expected);
14758 assert.deepEqual(actual, props);
14897 assert.deepEqual(_.merge(names, ages, heights), expected);
14928 assert.deepEqual(actual, expected);
14950 assert.deepEqual(actual, object);
14960 assert.deepEqual(actual, object);
14971 assert.deepEqual(actual, expected);
14975 assert.deepEqual(actual, expected);
15002 assert.deepEqual(actual, expected);
15015 assert.deepEqual(actual.value, expected);
15020 assert.deepEqual(actual.value, expected);
15026 assert.deepEqual(actual.value, expected);
15052 assert.deepEqual(actual, expected);
15069 assert.deepEqual(actual, expected);
15092 assert.deepEqual(actual, expected);
15136 assert.deepEqual(actual, expected);
15146 assert.deepEqual(source1.a, [{ 'a': 1 }]);
15147 assert.deepEqual(source2.a, [{ 'b': 2 }]);
15148 assert.deepEqual(actual.a, [{ 'a': 1, 'b': 2 }]);
15154 assert.deepEqual(source1.a, [[1, 2, 3]]);
15155 assert.deepEqual(source2.a, [[3, 4]]);
15156 assert.deepEqual(actual.a, [[3, 4, 3]]);
15170 assert.deepEqual(actual, new Foo(object));
15174 assert.deepEqual(actual, [new Foo(object)]);
15181 assert.deepEqual(actual, { 'a': 1, 'b': undefined });
15193 assert.deepEqual(actual, expected);
15199 assert.deepEqual(actual, expected);
15225 assert.deepEqual(actual, { 'a': ['x', 'y'] });
15228 assert.deepEqual(actual, { 'a': [] });
15237 assert.deepEqual(actual, { 'a': ['x', 'y', 'z'] });
15254 assert.deepEqual(actual, expected);
15267 assert.deepEqual(actual, { 'a': { 'b': [0, 1] } });
15270 assert.deepEqual(actual, [undefined]);
15280 assert.deepEqual(source1.a.b, { 'c': 1 });
15290 assert.deepEqual(actual, { 'a': { 'b': [0, 1, 2] } });
15318 assert.deepEqual(actual, { 'a': { 'b': ['c'] } });
15332 assert.deepEqual(actual, { 'a': ['a', 'b', 'c'], 'b': ['b', 'c'] });
15391 assert.deepEqual(actual, expected);
15431 assert.deepEqual(actual, expected);
15448 assert.deepEqual(actual, expected);
15474 assert.deepEqual(method(object), [1, 2, 3]);
15545 assert.deepEqual(actual, expected);
15584 assert.deepEqual(actual, expected);
15600 assert.deepEqual(actual, expected);
15627 assert.deepEqual(methodOf(path), [1, 2, 3]);
15666 assert.deepEqual(actual, expected);
15734 assert.deepEqual(actual, objects[isMax ? 1 : 2]);
15739 assert.deepEqual(actual, arrays[isMax ? 1 : 2]);
15980 assert.deepEqual(actual, _.take(_.b(_.map(_.a(array), square), isEven)));
16007 assert.deepEqual(_.multiply('x', 'y'), NaN);
16027 assert.deepEqual(actual, [objects[1], objects[3], objects[0], objects[2]]);
16034 assert.deepEqual(actual, [objects[3], objects[1], objects[2], objects[0]]);
16043 assert.deepEqual(actual, expected);
16051 assert.deepEqual(actual, expected);
16058 assert.deepEqual(actual, [objects[1], objects[3], objects[0], objects[2]]);
16075 assert.deepEqual(over(5, 10), [10, 100]);
16082 assert.deepEqual(over('a', 'b'), ['a', 'b']);
16089 assert.deepEqual(over({ 'b': 2 }, { 'a': 1 }), [2, 1]);
16096 assert.deepEqual(over({ 'b': 2 }, { 'a': 1 }), [false, true]);
16103 assert.deepEqual(over({ 'b': 2 }, { 'a': 1 }), [false, true]);
16110 assert.deepEqual(over({ 'a': 1 }, { '1': 2 }), [1, 2]);
16113 assert.deepEqual(over({ 'a': 1 }), [true]);
16120 assert.deepEqual(over(5, 10, 15), [10, 100, '15']);
16127 assert.deepEqual(over(5, 10, 18), [10, 100, 18]);
16134 assert.deepEqual(over(5, 10, 18), [5, 10, 18]);
16141 assert.deepEqual(over(5), [10]);
16152 assert.deepEqual(argsList, [['a'], ['b']]);
16211 assert.deepEqual(actual, expected);
16316 assert.deepEqual(actual, array);
16326 assert.deepEqual(actual, ['d', 'c', 'b', 'a']);
16339 assert.deepEqual(actual, expected);
16348 assert.deepEqual(actual, expected);
16361 assert.deepEqual(actual, expected);
16377 assert.deepEqual(actual, expected);
16396 assert.deepEqual(actual, args);
16407 assert.deepEqual(actual, ['d', 'c', 'b', 'a']);
16421 assert.deepEqual(actual, expected);
16431 assert.deepEqual(actual, expected);
16452 assert.deepEqual(actual, expected);
16468 assert.deepEqual(_.omit(object, 'a', 'c'), { 'b': 2, 'd': 4 });
16469 assert.deepEqual(_.omit(object, ['a', 'd'], 'c'), { 'b': 2 });
16475 assert.deepEqual(_.omit(nested, 'b.c'), { 'a': 1, 'b': { 'd': 3} });
16484 assert.deepEqual(actual, { 'a': { 'b': 2 } });
16493 assert.deepEqual(_.omit(object, path), { 'a': { 'b': 2 } });
16500 assert.deepEqual(_.omit({ '0': 'a' }, 0), {});
16510 assert.deepEqual(actual, {});
16520 assert.deepEqual(_.omit('', 'b'), { 'a': 1 });
16529 assert.deepEqual(_.omit(object, args), { 'b': 2, 'd': 4 });
16538 assert.deepEqual(object, { 'a': { 'b': 2 } });
16557 assert.deepEqual(actual, { 'b': 2, 'd': 4 });
16585 assert.deepEqual(func(object, resolve(object, 'a')), { 'b': 2, 'c': 3, 'd': 4 });
16586 assert.deepEqual(func(object, resolve(object, ['a', 'c'])), expected);
16595 assert.deepEqual(func(new Foo, resolve(object, ['a', 'c'])), expected);
16609 assert.deepEqual(actual, expected);
16688 assert.deepEqual(func(array, resolve(array, ['0', '2'])), { '1': 2 });
16745 assert.deepEqual(over(1, 2, 3, 4), [4, 1]);
16752 assert.deepEqual(over('a', 'b', 'c'), ['a', 'a']);
16759 assert.deepEqual(over({ 'a': 1, 'b': 2 }), [2, 1]);
16766 assert.deepEqual(over({ 'a': 1, 'b': 2 }), [false, true]);
16774 assert.deepEqual(over({ 'a': 1, 'b': 2 }), [true, false]);
16775 assert.deepEqual(over({ 'a': 2, 'b': 1 }), [false, true]);
16783 assert.deepEqual(over({ 'a': 1, '1': 2 }), [1, 2]);
16784 assert.deepEqual(over({ 'a': 2, '1': 1 }), [2, 1]);
16788 assert.deepEqual(over({ 'a': 1 }), [true]);
16789 assert.deepEqual(over({ 'a': 2 }), [false]);
16799 assert.deepEqual(over('a', 'b', 'c'), [['a', 'b', 'c']]);
16808 assert.deepEqual(object.over(), [2, 1]);
16904 assert.deepEqual(args, ['a', 'b', 'c']);
17025 assert.deepEqual(args, ['a', 'b', 'c']);
17058 assert.deepEqual(actual, expected);
17078 assert.deepEqual(actual, expected);
17099 assert.deepEqual(actual, expected);
17118 assert.deepEqual(actual, expected);
17139 assert.deepEqual(actual, expected);
17158 assert.deepEqual(actual, expected);
17217 assert.deepEqual(actual, expected);
17235 assert.deepEqual(actual, expected);
17290 assert.deepEqual(actual, expected);
17312 assert.deepEqual(actual, [6, 8, 10]);
17315 assert.deepEqual(actual, [1, 2, 3]);
17342 assert.deepEqual(par('b'), expected);
17367 assert.deepEqual(par('a', 'c'), ['a', 'b', 'c']);
17368 assert.deepEqual(par('a'), ['a', 'b', undefined]);
17369 assert.deepEqual(par(), [undefined, 'b', undefined]);
17372 assert.deepEqual(par('a', 'c', 'd'), ['a', 'b', 'c', 'd']);
17375 assert.deepEqual(par('a', 'b', 'd'), ['a', 'b', 'c', 'd']);
17388 assert.deepEqual(par('a', 'c'), expected);
17452 assert.deepEqual(par('a', 'c'), ['a', 'b', 'c', 'd']);
17472 assert.deepEqual(defaultsDeep(object, source), expected);
17497 assert.deepEqual(c(2), [1, 2, 3]);
17516 assert.deepEqual(c(3), expected);
17522 assert.deepEqual(c(3), expected);
17528 assert.deepEqual(c(3), expected);
17555 assert.deepEqual(c(3, 5), expected);
17561 assert.deepEqual(c(3, 5), expected);
17567 assert.deepEqual(c(3, 5), expected);
17580 assert.deepEqual(c(1), expected);
17586 assert.deepEqual(c(1), expected);
17592 assert.deepEqual(c(1), expected);
17628 assert.deepEqual(actual, expected);
17637 assert.deepEqual(actual, expected);
17649 assert.deepEqual(actual, expected);
17656 assert.deepEqual(actual, expected);
17670 assert.deepEqual(actual, expected);
17679 assert.deepEqual(actual, expected);
17694 assert.deepEqual(_.partition([], identity), [[], []]);
17695 assert.deepEqual(_.partition(array, stubTrue), [array, []]);
17696 assert.deepEqual(_.partition(array, stubFalse), [[], array]);
17709 assert.deepEqual(actual, expected);
17718 assert.deepEqual(actual, [objects.slice(0, 2), objects.slice(2)]);
17730 assert.deepEqual(_.partition(array, 0), [[array[0], array[2]], [array[1]]]);
17731 assert.deepEqual(_.partition(array, 1), [[array[1]], [array[0], array[2]]]);
17738 assert.deepEqual(actual, [[1.1, 1.3], [0.2]]);
17754 assert.deepEqual(_.pick(object, 'a', 'c'), { 'a': 1, 'c': 3 });
17755 assert.deepEqual(_.pick(object, ['a', 'd'], 'c'), { 'a': 1, 'c': 3, 'd': 4 });
17761 assert.deepEqual(_.pick(nested, 'b.c'), { 'b': { 'c': 2 } });
17770 assert.deepEqual(actual, { 'a.b': 1 });
17779 assert.deepEqual(_.pick(object, path), { 'a.b': 1 });
17786 assert.deepEqual(_.pick({ '0': 'a', '1': 'b' }, 0), { '0': 'a' });
17793 assert.deepEqual(_.pick(value, 'valueOf'), {});
17800 assert.deepEqual(_.pick('', 'slice'), { 'slice': ''.slice });
17806 assert.deepEqual(_.pick(object, args), { 'a': 1, 'c': 3 });
17824 assert.deepEqual(actual, { 'a': 1, 'c': 3 });
17833 assert.deepEqual(actual, { 'a.b.c': 1 });
17862 assert.deepEqual(func(object, resolve(object, 'a')), { 'a': 1 });
17863 assert.deepEqual(func(object, resolve(object, ['a', 'c'])), expected);
17873 assert.deepEqual(func(foo, resolve(foo, ['a', 'c'])), expected);
17887 assert.deepEqual(actual, expected);
17930 assert.deepEqual(func(array, resolve(array, '1')), { '1': 2 });
17996 assert.deepEqual(actual, ['a', 'a', 'b', 'b']);
18015 assert.deepEqual(actual, expected);
18043 assert.deepEqual(actual, expected);
18060 assert.deepEqual(actual, expected);
18141 assert.deepEqual(actual, ['a', 'a', 'b', 'b']);
18160 assert.deepEqual(actual, expected);
18187 assert.deepEqual(actual, expected);
18203 assert.deepEqual(actual, expected);
18229 assert.deepEqual(actual, []);
18247 assert.deepEqual(actual, [{ 'x': 2 }]);
18260 assert.deepEqual(args, [{ 'x': 1 }]);
18276 assert.deepEqual(actual, expected);
18301 assert.deepEqual(array, [2]);
18323 assert.deepEqual(array, [1, 3]);
18332 assert.deepEqual(array, [1, 3]);
18347 assert.deepEqual(array, [3]);
18348 assert.deepEqual(actual, [1, 2]);
18357 assert.deepEqual(array, [1, 3, 5, 7, 9, 11]);
18358 assert.deepEqual(actual, [2, 4, 12, 8, 6, 10]);
18367 assert.deepEqual(array, [4]);
18368 assert.deepEqual(actual, [1, 3, 1, 2, 1, 3]);
18377 assert.deepEqual(array, ['b']);
18378 assert.deepEqual(actual, ['c', undefined, 'a']);
18385 assert.deepEqual(_.pullAt(array, 2, 0), ['c', 'a']);
18386 assert.deepEqual(array, ['b']);
18389 assert.deepEqual(_.pullAt(array, [3, 0], 2), ['d', 'a', 'c']);
18390 assert.deepEqual(array, ['b']);
18399 assert.deepEqual(array, ['a', 'b', 'c']);
18400 assert.deepEqual(actual, []);
18404 assert.deepEqual(array, ['a', 'b', 'c']);
18405 assert.deepEqual(actual, []);
18422 assert.deepEqual(actual, expected);
18427 assert.deepEqual(actual, expected);
18441 assert.deepEqual(actual, [[-2], [-2], [-1], [-1]]);
18452 assert.deepEqual(actual, [2]);
18453 assert.deepEqual(array.a, {});
18459 assert.deepEqual(actual, [undefined]);
18474 assert.deepEqual(actual, expected);
18492 assert.deepEqual(actual, [0, 1]);
18530 assert.deepEqual(actual, expected);
18558 assert.deepEqual(actual, [0, 1, MAX_INTEGER]);
18596 assert.deepEqual(actual, expected);
18615 assert.deepEqual(func(4), resolve([0, 1, 2, 3]));
18616 assert.deepEqual(func(-4), resolve([0, -1, -2, -3]));
18622 assert.deepEqual(func(1, 5), resolve([1, 2, 3, 4]));
18623 assert.deepEqual(func(5, 1), resolve([5, 4, 3, 2]));
18629 assert.deepEqual(func(0, -4, -1), resolve([0, -1, -2, -3]));
18630 assert.deepEqual(func(5, 1, -1), resolve([5, 4, 3, 2]));
18631 assert.deepEqual(func(0, 20, 5), resolve([0, 5, 10, 15]));
18637 assert.deepEqual(func(1, 4, 0), [1, 1, 1]);
18643 assert.deepEqual(func(1, 5, 20), [1]);
18649 assert.deepEqual(func(0, -4, -1), resolve([0, -1, -2, -3]));
18650 assert.deepEqual(func(21, 10, -3), resolve([21, 18, 15, 12]));
18665 assert.deepEqual(func(value), []);
18666 assert.deepEqual(func(value, 1), [0]);
18668 assert.deepEqual(func(), []);
18684 assert.deepEqual(actual, [[0], [0], [0], [], []]);
18696 assert.deepEqual(actual, expected);
18714 assert.deepEqual(rearged('b', 'c', 'a'), ['a', 'b', 'c']);
18721 assert.deepEqual(rearged('c', 'a', 'b'), ['a', 'a', 'a']);
18728 assert.deepEqual(rearged('b', 'a', 'c'), ['a', undefined, 'c']);
18745 assert.deepEqual(actual, expected);
18752 assert.deepEqual(rearged('a', 'b', 'c'), ['a', 'b', 'c']);
18755 assert.deepEqual(rearged('a', 'b', 'c'), ['a', 'b', 'c']);
18762 assert.deepEqual(rearged('b', 'c', 'a'), ['a', 'b', 'c']);
18769 assert.deepEqual(rearged('b', 'c', 'a'), ['a', 'b', 'c']);
18776 assert.deepEqual(rearged('b', 'a', 'c'), ['a', 'b', 'c']);
18785 assert.deepEqual(rearged2('b', 'c', 'a'), ['a', 'b', 'c']);
18811 assert.deepEqual(args, [0, 1, 0, array]);
18818 assert.deepEqual(args, [1, 2, 1, array]);
18836 assert.deepEqual(args, expected);
18847 assert.deepEqual(args, expected);
18873 assert.deepEqual(args, [0, 3, 2, array]);
18880 assert.deepEqual(args, [3, 2, 1, array]);
18898 assert.deepEqual(args, expected);
18909 assert.deepEqual(args, expected);
18944 assert.deepEqual(actual, expected);
18958 assert.deepEqual(actual, expected);
19017 assert.deepEqual(_.reject(array, isEven), [1, 3]);
19039 assert.deepEqual(actual, [0]);
19045 assert.deepEqual(func(objects, 'a'), [objects[isFilter ? 1 : 0]]);
19051 assert.deepEqual(func(objects, objects[1]), [objects[isFilter ? 1 : 0]]);
19064 assert.deepEqual(actual.value(), isFilter ? [1, 2] : [3, 4]);
19070 assert.deepEqual(actual.value(), isFilter ? [3, 4] : [1, 2]);
19089 … assert.deepEqual(actual, _[methodName](lodashStable.map(array.slice(1), square), predicate));
19092 assert.deepEqual(actual, _[methodName](lodashStable.mapValues(object, square), predicate));
19111 assert.deepEqual(args, [1, 0, array.slice(1)]);
19118 assert.deepEqual(args, expected);
19125 assert.deepEqual(args, expected);
19132 assert.deepEqual(args, [1]);
19139 assert.deepEqual(args, expected);
19158 assert.deepEqual(array, [1, 3]);
19159 assert.deepEqual(actual, [2, 4]);
19176 assert.deepEqual(argsList, [[1, 0, clone], [2, 1, clone], [3, 2, clone]]);
19184 assert.deepEqual(objects, [{ 'a': 0, 'b': 1 }]);
19192 assert.deepEqual(objects, [{ 'a': 0, 'b': 1 }]);
19200 assert.deepEqual(objects, [{ 'a': 0 }]);
19228 assert.deepEqual(array, [1, 3]);
19240 assert.deepEqual(array, [2]);
19269 assert.deepEqual(actual, expected);
19298 assert.deepEqual(actual, ['a', 'b', 'c']);
19384 assert.deepEqual(actual, ['a', 'a', 'b', 'b']);
19480 assert.deepEqual(actual, expected);
19528 assert.deepEqual(actual, expected);
19552 assert.deepEqual(rest(1, 2, 3, 4), [1, 2, [3, 4]]);
19559 assert.deepEqual(rest(1, 2, 3, 4), [1, [2, 3, 4]]);
19573 assert.deepEqual(actual, expected);
19580 assert.deepEqual(rest(1, 2, 3), [1, [2, 3]]);
19587 assert.deepEqual(rest(1), [1, undefined, []]);
19597 assert.deepEqual(rest(1, 2, 3, 4, 5), [1, 2, 3, [4, 5]]);
19616 assert.deepEqual(array, [3, 2, 1]);
19631 assert.deepEqual(actual, clone.slice().reverse());
19648 assert.deepEqual(actual, expected.slice(1).reverse());
19649 assert.deepEqual(array, expected);
19677 assert.deepEqual(array, expected);
19696 assert.deepEqual(actual, expected);
19701 assert.deepEqual(actual, [3].concat(expected.slice(0, -1)));
19721 assert.deepEqual(array, expected);
19789 assert.deepEqual(actual, 50);
19792 assert.deepEqual(actual, NaN);
19795 assert.deepEqual(actual, NaN);
19808 assert.deepEqual(actual, expected);
19822 assert.deepEqual(actual, expected);
19873 assert.deepEqual(actual, NaN);
19876 assert.deepEqual(actual, NaN);
19879 assert.deepEqual(actual, NaN);
19882 assert.deepEqual(actual, NaN);
19885 assert.deepEqual(actual, isFloor ? NaN : NaN);
19888 assert.deepEqual(actual, isCeil ? NaN : NaN);
19960 assert.deepEqual(actual, expected);
19986 assert.deepEqual(lodashStable.difference(actual, array), []);
19994 assert.deepEqual(actual, array);
20008 assert.deepEqual(actual, expected);
20015 assert.deepEqual(_.sampleSize(array, n), []);
20024 assert.deepEqual(actual, array);
20046 assert.deepEqual(actual, expected);
20056 assert.deepEqual(lodashStable.difference(actual, lodashStable.values(object)), []);
20063 assert.deepEqual(actual, [['a']]);
20079 assert.deepEqual(actual, { '0': { '1': { '2': 3 } } });
20086 assert.deepEqual(actual, { 'a': [{ 'b': { 'c': 4 } }] });
20126 assert.deepEqual(actual, expected);
20164 assert.deepEqual(object, { 'a.b': value });
20183 assert.deepEqual(object, { 'a': { '': value } });
20193 assert.deepEqual(object, index ? {} : { '': value });
20196 assert.deepEqual(object, { '': value });
20226 assert.deepEqual(actual, { 'a': [undefined, { 'b': { 'c': value } }] });
20247 assert.deepEqual(actual, expected);
20257 assert.deepEqual(object, { 'a': { 'b': 2 } });
20267 assert.deepEqual(object, { '1a': { '2b': { '3c': value } } });
20308 assert.deepEqual(_.shuffle(array).sort(), array);
20309 assert.deepEqual(_.shuffle(object).sort(), array);
20319 … assert.deepEqual(lodashStable.sortBy(lodashStable.uniqBy(actual, String), '0'), [[1, 2], [2, 1]]);
20325 assert.deepEqual(_.shuffle(1), []);
20359 assert.deepEqual(actual, expected);
20441 assert.deepEqual(actual, array);
20448 assert.deepEqual(_.slice(array, 1), [2, 3]);
20449 assert.deepEqual(_.slice(array, 1, 3), [2, 3]);
20456 assert.deepEqual(_.slice(array, start), []);
20469 assert.deepEqual(actual, expected);
20475 assert.deepEqual(_.slice(array, -1), [3]);
20482 assert.deepEqual(_.slice(array, start), array);
20490 assert.deepEqual(_.slice(array, start, 2), []);
20497 assert.deepEqual(_.slice(array, 0, 1), [1]);
20504 assert.deepEqual(_.slice(array, 0, end), array);
20519 assert.deepEqual(actual, expected);
20525 assert.deepEqual(_.slice(array, 0, -1), [1, 2]);
20532 assert.deepEqual(_.slice(array, 0, end), []);
20545 assert.deepEqual(actual, [[1], [1], [1], [2, 3], [1], []]);
20554 assert.deepEqual(actual, array);
20567 assert.deepEqual(wrapped[methodName]().slice(0, -1).value(), array.slice(0, -1));
20568 assert.deepEqual(wrapped[methodName]().slice(1).value(), array.slice(1));
20569 assert.deepEqual(wrapped[methodName]().slice(1, 3).value(), array.slice(1, 3));
20570 assert.deepEqual(wrapped[methodName]().slice(-1).value(), array.slice(-1));
20572 assert.deepEqual(wrapped[methodName]().slice(length).value(), array.slice(length));
20573 assert.deepEqual(wrapped[methodName]().slice(3, 2).value(), array.slice(3, 2));
20574 … assert.deepEqual(wrapped[methodName]().slice(0, -length).value(), array.slice(0, -length));
20575 assert.deepEqual(wrapped[methodName]().slice(0, null).value(), array.slice(0, null));
20577 assert.deepEqual(wrapped[methodName]().slice(0, length).value(), array.slice(0, length));
20578 assert.deepEqual(wrapped[methodName]().slice(-length).value(), array.slice(-length));
20579 assert.deepEqual(wrapped[methodName]().slice(null).value(), array.slice(null));
20581 assert.deepEqual(wrapped[methodName]().slice(0, 1).value(), array.slice(0, 1));
20582 assert.deepEqual(wrapped[methodName]().slice(NaN, '1').value(), array.slice(NaN, '1'));
20584 assert.deepEqual(wrapped[methodName]().slice(0.1, 1.1).value(), array.slice(0.1, 1.1));
20585 assert.deepEqual(wrapped[methodName]().slice('0', 1).value(), array.slice('0', 1));
20586 assert.deepEqual(wrapped[methodName]().slice(0, '1').value(), array.slice(0, '1'));
20587 assert.deepEqual(wrapped[methodName]().slice('1').value(), array.slice('1'));
20588 assert.deepEqual(wrapped[methodName]().slice(NaN, 1).value(), array.slice(NaN, 1));
20589 assert.deepEqual(wrapped[methodName]().slice(1, NaN).value(), array.slice(1, NaN));
20621 assert.deepEqual(actual, expected);
20655 assert.deepEqual(actual, expected);
20663 assert.deepEqual(actual, expected);
20686 assert.deepEqual(actual, [true]);
20709 assert.deepEqual(actual, [1, 2, 3, 4]);
20723 assert.deepEqual(actual, expected);
20730 assert.deepEqual(actual, [1, 2, 3, 4, undefined]);
20737 assert.deepEqual(actual, [3, 1, 2]);
20748 assert.deepEqual(_.sortBy(array), expected);
20753 assert.deepEqual(_.sortBy(array), expected);
20759 assert.deepEqual(_.sortBy(1), []);
20771 assert.deepEqual(actual, [objects[0], objects[2], objects[1], objects[3]]);
20778 assert.deepEqual(actual, [[1, 2, 3], [1, 2, 3]]);
20821 assert.deepEqual(actual, [objects[2], objects[0], objects[3], objects[1]]);
20828 assert.deepEqual(actual, [objects[2], objects[0], objects[3], objects[1]]);
20836 assert.deepEqual(actual, stableArray, index ? 'object' : 'array');
20847 assert.deepEqual(actual, [objects[2], objects[0], objects[3], objects[1], null, undefined]);
20873 assert.deepEqual(actual, expected);
20897 assert.deepEqual(actual, expected);
20911 assert.deepEqual(actual, expected);
20924 assert.deepEqual(actual, expected);
20939 assert.deepEqual(_.sortBy(array), expected);
20989 assert.deepEqual(args, [40]);
21041 assert.deepEqual(func(sorted, 5), isSortedIndexOf ? 2 : 3);
21056 assert.deepEqual(_.sortedUniq(array), expected);
21070 assert.deepEqual(_.split(string, 'c'), ['ab', 'de']);
21071 assert.deepEqual(_.split(string, /[bd]/), ['a', 'c', 'e']);
21072 assert.deepEqual(_.split(string, '', 2), ['a', 'b']);
21085 assert.deepEqual(actual, expected);
21094 assert.deepEqual(actual, [['abc'], ['def'], ['ghi']]);
21125 assert.deepEqual(spread([1, 2]), expected);
21126 assert.deepEqual(spread([1, 2], 3), expected);
21141 assert.deepEqual(actual, expected);
21150 assert.deepEqual(spread(1, [2, 3]), expected);
21151 assert.deepEqual(spread(1, [2, 3], 4), expected);
21165 assert.deepEqual(actual, expected);
21174 assert.deepEqual(spread(1, [2, 3]), expected);
21175 assert.deepEqual(spread(1, [2, 3], 4), expected);
21235 assert.deepEqual(actual, expected);
21328 assert.deepEqual(actual, expected);
21349 assert.deepEqual(_.subtract('x', 'y'), NaN);
21387 assert.deepEqual(actual, expected);
21394 assert.deepEqual(func(0, {}), NaN);
21395 assert.deepEqual(func({}, 0), NaN);
21402 assert.deepEqual(func(0, symbol), NaN);
21403 assert.deepEqual(func(symbol, 0), NaN);
21450 assert.deepEqual(actual, 6);
21462 assert.deepEqual(args, [6]);
21497 assert.deepEqual(actual, expected);
21509 assert.deepEqual(func([1, NaN]), NaN);
21537 assert.deepEqual(actual, expected);
21543 assert.deepEqual(_.tail(array), [2, 3]);
21549 assert.deepEqual(_.tail([]), []);
21558 assert.deepEqual(actual, [[2, 3], [5, 6], [8, 9]]);
21574 assert.deepEqual(actual, []);
21575 assert.deepEqual(values, array.slice(1));
21586 assert.deepEqual(actual, _.tail(_.filter(array, isEven)));
21587 assert.deepEqual(values, array);
21604 assert.deepEqual(actual, []);
21610 assert.deepEqual(actual, []);
21628 assert.deepEqual(_.take(array, 2), [1, 2]);
21642 assert.deepEqual(actual, expected);
21649 assert.deepEqual(_.take(array, n), []);
21657 assert.deepEqual(_.take(array, n), array);
21667 assert.deepEqual(actual, [[1], [4], [7]]);
21679 assert.deepEqual(actual, _.take(_.take(array, 2)));
21682 assert.deepEqual(values, [1, 2]);
21683 assert.deepEqual(actual, _.take(_.take(_.filter(array, predicate), 2)));
21686 assert.deepEqual(actual, _.takeRight(_.take(_.takeRight(_.take(array, 6), 4), 2)));
21691 assert.deepEqual(values, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]);
21692 …assert.deepEqual(actual, _.takeRight(_.take(_.takeRight(_.take(_.filter(_.take(array, array.length…
21710 assert.deepEqual(_.takeRight(array, 2), [2, 3]);
21724 assert.deepEqual(actual, expected);
21731 assert.deepEqual(_.takeRight(array, n), []);
21739 assert.deepEqual(_.takeRight(array, n), array);
21749 assert.deepEqual(actual, [[3], [6], [9]]);
21761 assert.deepEqual(actual, _.takeRight(_.takeRight(array)));
21764 assert.deepEqual(values, array);
21765 assert.deepEqual(actual, _.takeRight(_.takeRight(_.filter(array, predicate), 2)));
21768 assert.deepEqual(actual, _.take(_.takeRight(_.take(_.takeRight(array, 6), 4), 2)));
21773 assert.deepEqual(values, array);
21774 …assert.deepEqual(actual, _.take(_.takeRight(_.take(_.takeRight(_.filter(array, predicate), 6), 4),…
21802 assert.deepEqual(actual, [3, 4]);
21814 assert.deepEqual(args, [4, 3, array]);
21820 assert.deepEqual(_.takeRightWhile(objects, { 'b': 2 }), objects.slice(2));
21826 assert.deepEqual(_.takeRightWhile(objects, ['b', 2]), objects.slice(2));
21832 assert.deepEqual(_.takeRightWhile(objects, 'b'), objects.slice(1));
21844 assert.deepEqual(wrapped.value(), expected);
21845 assert.deepEqual(wrapped.reverse().value(), expected.slice().reverse());
21870 assert.deepEqual(args, [LARGE_ARRAY_SIZE, LARGE_ARRAY_SIZE - 1, array.slice(1)]);
21876 assert.deepEqual(args, expected);
21882 assert.deepEqual(args, expected);
21888 assert.deepEqual(args, [square(LARGE_ARRAY_SIZE)]);
21894 assert.deepEqual(args, expected);
21922 assert.deepEqual(actual, [1, 2]);
21934 assert.deepEqual(args, [1, 0, array]);
21940 assert.deepEqual(_.takeWhile(objects, { 'b': 2 }), objects.slice(0, 1));
21946 assert.deepEqual(_.takeWhile(objects, ['b', 2]), objects.slice(0, 1));
21951 assert.deepEqual(_.takeWhile(objects, 'b'), objects.slice(0, 2));
21963 assert.deepEqual(wrapped.value(), expected);
21964 assert.deepEqual(wrapped.reverse().value(), expected.slice().reverse());
21984 assert.deepEqual(actual, [0]);
22003 assert.deepEqual(args, [1, 0, array.slice(1)]);
22009 assert.deepEqual(args, expected);
22015 assert.deepEqual(args, expected);
22021 assert.deepEqual(args, [1]);
22027 assert.deepEqual(args, expected);
22098 assert.deepEqual(actual, expected);
22153 assert.deepEqual(actual, expected);
22454 assert.deepEqual(actual, ['a', 'b', 'c']);
22492 assert.deepEqual(actual, expected);
22528 assert.deepEqual(options, {});
22564 assert.deepEqual(actual, expected);
22596 assert.deepEqual(actual, expected);
22610 assert.deepEqual(actual, ['one', '"two"', 'three']);
22697 assert.deepEqual(actual, [truncated, truncated, truncated]);
22735 assert.deepEqual(results, ['a', 'a']);
22956 assert.deepEqual(results, ['a', 'a', 'a']);
23017 assert.deepEqual(actual, expected);
23045 assert.deepEqual(actual, expected.slice(0, isDebounce ? 0 : 1));
23048 assert.deepEqual(actual, expected.slice(0, actual.length));
23180 assert.deepEqual(_.times(n), []);
23188 assert.deepEqual(actual, [0, 1]);
23200 assert.deepEqual(args, [0]);
23213 assert.deepEqual(actual, expected);
23219 assert.deepEqual(_.times(3, doubled), [0, 2, 4]);
23232 assert.deepEqual(actual, expected);
23239 assert.deepEqual(_(3).times(), [0, 1, 2]);
23266 assert.deepEqual(_.toArray({ 'a': 1, 'b': 2 }), [1, 2]);
23276 assert.deepEqual(_.toArray(object), ['a']);
23290 assert.deepEqual(_.toArray(map), [['a', 1], ['b', 2]]);
23300 assert.deepEqual(_.toArray(''), []);
23301 assert.deepEqual(_.toArray('ab'), ['a', 'b']);
23302 assert.deepEqual(_.toArray(Object('ab')), ['a', 'b']);
23316 assert.deepEqual(actual, lodashStable.map(array.slice(1), String));
23319 assert.deepEqual(actual, _.map(_.toArray(object).slice(1), String));
23335 assert.deepEqual(_.toLower('--Foo-Bar--'), '--foo-bar--');
23336 assert.deepEqual(_.toLower('fooBar'), 'foobar');
23337 assert.deepEqual(_.toLower('__FOO_BAR__'), '__foo_bar__');
23349 assert.deepEqual(_.toUpper('--Foo-Bar'), '--FOO-BAR');
23350 assert.deepEqual(_.toUpper('fooBar'), 'FOOBAR');
23351 assert.deepEqual(_.toUpper('__FOO_BAR__'), '__FOO_BAR__');
23373 assert.deepEqual(actual, sparse);
23380 assert.deepEqual(func(object), ['a']);
23381 assert.deepEqual(func(args), array);
23388 assert.deepEqual(actual, array);
23400 assert.deepEqual(actual, [body]);
23486 assert.deepEqual(actual, expected);
23521 assert.deepEqual(actual, expected);
23552 assert.deepEqual(actual, expected);
23593 assert.deepEqual(actual, expected);
23614 assert.deepEqual(actual, expected);
23633 assert.deepEqual(actual, expected);
23648 assert.deepEqual(actual, expected);
23668 assert.deepEqual(actual, expected);
23719 assert.deepEqual(actual, expected);
23761 assert.deepEqual(actual, [['a', 1], ['b', 2]]);
23775 assert.deepEqual(actual, expected);
23784 assert.deepEqual(actual, [['0', 'a'], ['1', 'b'], ['length', 2]]);
23794 assert.deepEqual(func(map), [['a', 1], ['b', 2]]);
23808 assert.deepEqual(func(set), [[1, 1], [2, 2]]);
23820 assert.deepEqual(actual, [['0', 'x'], ['1', 'o']]);
23833 assert.deepEqual(_.toPath('a.b.c'), ['a', 'b', 'c']);
23834 assert.deepEqual(_.toPath('a[0].b.c'), ['a', '0', 'b', 'c']);
23844 assert.deepEqual(actual, array);
23874 assert.deepEqual(actual, ['a', '-1.23', '["b"]', 'c', "['d']", '\ne\n', 'f', 'g']);
23881 assert.deepEqual(_.toPath('.a'), expected);
23882 assert.deepEqual(_.toPath('[].a'), expected);
23885 assert.deepEqual(_.toPath('..a'), expected);
23886 assert.deepEqual(_.toPath('[][].a'), expected);
23889 assert.deepEqual(_.toPath('a..b'), expected);
23890 assert.deepEqual(_.toPath('a[].b'), expected);
23893 assert.deepEqual(_.toPath('a...b'), expected);
23894 assert.deepEqual(_.toPath('a[][].b'), expected);
23897 assert.deepEqual(_.toPath('a.'), expected);
23898 assert.deepEqual(_.toPath('a[]'), expected);
23901 assert.deepEqual(_.toPath('a..'), expected);
23902 assert.deepEqual(_.toPath('a[][]'), expected);
23920 assert.deepEqual(actual, { 'a': 1, 'b': 2, 'c': 3 });
23929 assert.deepEqual(actual, expected);
23938 assert.deepEqual(actual, expected);
23957 assert.deepEqual(actual, expected);
23967 assert.deepEqual(actual, expected);
23974 assert.deepEqual(_.toString(values), '-0,-0,0,0');
24052 assert.deepEqual(actual, expected);
24057 assert.deepEqual(actual, expected);
24062 assert.deepEqual(actual, expected);
24068 assert.deepEqual(actual, expected);
24083 assert.deepEqual(actual, expected);
24098 assert.deepEqual(actual, expected);
24109 assert.deepEqual(actual, expected);
24131 assert.deepEqual(actual, ['undefined']);
24151 assert.deepEqual(results, expected);
24159 assert.deepEqual(actual, expected);
24179 assert.deepEqual(actual, expected);
24199 assert.deepEqual(args, [first, 1, 0, object]);
24202 assert.deepEqual(args, [first, 1, 'a', object]);
24229 assert.deepEqual(actual, expected);
24313 assert.deepEqual(actual, [trimmed, trimmed, trimmed]);
24382 assert.deepEqual(_.split(string, ' '), ['A', leafs + ',', comboGlyph + ',', 'and', rocket]);
24383 assert.deepEqual(_.split(string, ' ', 3), ['A', leafs + ',', comboGlyph + ',']);
24384 assert.deepEqual(_.split(string, undefined), [string]);
24385 assert.deepEqual(_.split(string, undefined, -1), [string]);
24386 assert.deepEqual(_.split(string, undefined, 0), []);
24390 assert.deepEqual(_.split(string, ''), expected);
24391 assert.deepEqual(_.split(string, '', 6), expected.slice(0, 6));
24392 assert.deepEqual(_.toArray(string), expected);
24401 assert.deepEqual(_.words(string), ['A', leafs, comboGlyph, 'and', rocket]);
24402 assert.deepEqual(_.toArray(hashKeycap), [hashKeycap]);
24403 assert.deepEqual(_.toArray(noMic), [noMic]);
24434 assert.deepEqual(actual, expected);
24452 assert.deepEqual(actual, expected);
24464 assert.deepEqual(_.toArray(flag), [flag]);
24465 assert.deepEqual(_.toArray(regionals), [pair[0], ' ', pair[1]]);
24467 assert.deepEqual(_.words(flag), [flag]);
24468 assert.deepEqual(_.words(regionals), [pair[0], pair[1]]);
24475 assert.deepEqual(_.toArray(heart), [heart]);
24476 assert.deepEqual(_.words(heart), [heart]);
24494 assert.deepEqual(actual, expected);
24504 assert.deepEqual(_.toArray(surrogates), [pair[0], ' ', pair[1]]);
24505 assert.deepEqual(_.words(surrogates), []);
24512 assert.deepEqual(_.toArray(string), [fitzModifiers[0], fitzModifiers[0]]);
24529 assert.deepEqual(actual, [6, 8, 10]);
24536 assert.deepEqual(capped(), []);
24604 assert.deepEqual(actual, [2, 1]);
24611 assert.deepEqual(actual, [2, 1, 3]);
24618 assert.deepEqual(actual, [1, 3, 2, [5], [4]]);
24625 assert.deepEqual(func(array, 3, { '0': 1 }, null), array);
24626 assert.deepEqual(func(null, array, null, [2, 1]), [0, 2, 1]);
24627 assert.deepEqual(func(array, null, args, null), [0, 1, 2, 3]);
24640 assert.deepEqual(actual, [2.1, 1.2]);
24643 assert.deepEqual(actual, [{ 'x': 1 }, { 'x': 2 }]);
24655 assert.deepEqual(args, [2.1]);
24662 assert.deepEqual(actual, [{ 'x': 1, 'y': 1 }]);
24678 assert.deepEqual(actual, [objects[0], objects[1], others[0]]);
24691 assert.deepEqual(actual, [{ 'x': 1, 'y': 1 }]);
24712 assert.deepEqual(func(array), [2, 1]);
24719 assert.deepEqual(func(array), [1, 2]);
24725 assert.deepEqual(func(objects), objects);
24732 assert.deepEqual(actual, ['0']);
24738 assert.deepEqual(func([NaN, NaN]), [NaN]);
24754 assert.deepEqual(func(largeArray), expected);
24765 assert.deepEqual(actual, ['0']);
24781 assert.deepEqual(func(largeArray), expected);
24789 assert.deepEqual(func(largeArray), largeArray);
24820 assert.deepEqual(func(largeArray), expected);
24840 assert.deepEqual(func(largeArray), expected);
24855 assert.deepEqual(actual, [[2, 1], [1, 2]]);
24880 assert.deepEqual(actual, expected);
24892 assert.deepEqual(actual, [[1, 2]]);
24904 assert.deepEqual(args, [objects[0]]);
24913 assert.deepEqual(actual, expected);
24922 assert.deepEqual(actual, expected);
24936 assert.deepEqual(actual, [['a'], ['b']]);
24952 assert.deepEqual(actual, [objects[0], objects[1]]);
24969 assert.deepEqual(actual, expected);
25013 assert.deepEqual(object, { 'c': 2 });
25028 assert.deepEqual(actual, expected);
25052 assert.deepEqual(object, { 'a': {} });
25080 assert.deepEqual(object, { 'a': { 'b': { 'c': null } } });
25097 assert.deepEqual(actual, expected);
25161 assert.deepEqual(actual, [6, 15]);
25173 assert.deepEqual(args, [1, 2]);
25187 assert.deepEqual(actual, expected);
25203 assert.deepEqual(actual, { '0': { '1': { '2': 3 } } });
25210 assert.deepEqual(actual, { 'a': [{ 'b': { 'c': 4 } }] });
25282 assert.deepEqual(actual, [1, 2]);
25291 assert.deepEqual(actual, [2, 'a', 'b']);
25305 assert.deepEqual(actual, expected);
25318 assert.deepEqual(actual, expected);
25331 assert.deepEqual(actual, [3]);
25341 assert.deepEqual(_.without(array, { 'a': 1 }), array);
25342 assert.deepEqual(_.without(array, object1), [object2]);
25349 assert.deepEqual(_.without(array, 1, 2), [3, 3]);
25369 assert.deepEqual(actual, expected);
25375 assert.deepEqual(_.words('abcd', /ab|cd/g), ['ab', 'cd']);
25376 assert.deepEqual(_.words('abcd', 'ab|cd'), ['ab']);
25382 assert.deepEqual(_.words('12ft'), ['12', 'ft']);
25383 assert.deepEqual(_.words('aeiouAreVowels'), ['aeiou', 'Are', 'Vowels']);
25384 assert.deepEqual(_.words('enable 6h format'), ['enable', '6', 'h', 'format']);
25385 assert.deepEqual(_.words('enable 24H format'), ['enable', '24', 'H', 'format']);
25386 assert.deepEqual(_.words('isISO8601'), ['is', 'ISO', '8601']);
25387 assert.deepEqual(_.words('LETTERSAeiouAreVowels'), ['LETTERS', 'Aeiou', 'Are', 'Vowels']);
25388 assert.deepEqual(_.words('tooLegit2Quit'), ['too', 'Legit', '2', 'Quit']);
25389 assert.deepEqual(_.words('walk500Miles'), ['walk', '500', 'Miles']);
25390 assert.deepEqual(_.words('xhr2Request'), ['xhr', '2', 'Request']);
25391 assert.deepEqual(_.words('XMLHttp'), ['XML', 'Http']);
25392 assert.deepEqual(_.words('XmlHTTP'), ['Xml', 'HTTP']);
25393 assert.deepEqual(_.words('XmlHttp'), ['Xml', 'Http']);
25399 assert.deepEqual(_.words('LETTERSÆiouAreVowels'), ['LETTERS', 'Æiou', 'Are', 'Vowels']);
25400 assert.deepEqual(_.words('æiouAreVowels'), ['æiou', 'Are', 'Vowels']);
25401 assert.deepEqual(_.words('æiou2Consonants'), ['æiou', '2', 'Consonants']);
25423 assert.deepEqual(actual, expected);
25442 assert.deepEqual(actual, expected);
25453 assert.deepEqual(actual, expected);
25468 assert.deepEqual(actual, expected);
25477 assert.deepEqual(actual, [['a'], ['b'], ['c']]);
25488 assert.deepEqual(_.words(largeWord + 'ÆiouAreVowels'), [largeWord, 'Æiou', 'Are', 'Vowels']);
25522 assert.deepEqual(args, [noop, 1, 2, 3]);
25536 assert.deepEqual(actual, expected);
25562 assert.deepEqual(actual, [1, 3]);
25569 assert.deepEqual(actual, [1, 4]);
25572 assert.deepEqual(actual, []);
25581 assert.deepEqual(actual, []);
25588 assert.deepEqual(actual, [1, 4]);
25591 assert.deepEqual(actual, [1]);
25605 assert.deepEqual(func(array, 3, null, { '0': 1 }), array);
25612 assert.deepEqual(func(array, 3, { '0': 1 }, null), array);
25613 assert.deepEqual(func(null, array, null, [2, 3]), [1, 3]);
25614 assert.deepEqual(func(array, null, args, null), [3]);
25640 assert.deepEqual(actual, [1, LARGE_ARRAY_SIZE + 1]);
25657 assert.deepEqual(actual, [1.2, 3.4]);
25660 assert.deepEqual(actual, [{ 'x': 2 }]);
25672 assert.deepEqual(args, [2.3]);
25688 assert.deepEqual(actual, [objects[1], others[0]]);
25705 assert.deepEqual(actual, object);
25711 assert.deepEqual(func(['a'], [1, 2]), { 'a': 1 });
25717 assert.deepEqual(func(['a', 'b'], [1]), { 'a': 1, 'b': undefined });
25725 assert.deepEqual(func([path], [1]), expected);
25737 assert.deepEqual(actual, _.take(_.filter(_.map(func(props, values), square), isEven)));
25761 assert.deepEqual(actual, [12, 15, 18]);
25767 assert.deepEqual(actual, [1, 2, 3]);
25779 assert.deepEqual(args, [1, 3, 5]);
25794 assert.deepEqual(actual, expected);
25830 assert.deepEqual(actual, pair[1]);
25831 assert.deepEqual(func(actual), actual.length ? pair[0] : []);
25845 assert.deepEqual(actual, pair[1]);
25849 assert.deepEqual(actual, [['barney', 36, undefined], ['fred', 40, false]]);
25861 assert.deepEqual(actual, expected);
25868 assert.deepEqual(func(array), [[1, 3], [2, 4]]);
25875 assert.deepEqual(func(func(func(func(expected)))), expected);
25891 assert.deepEqual(array, [1]);
25895 assert.deepEqual(otherWrapper.value(), [1, 2, 3]);
25896 assert.deepEqual(wrapped.value(), [1, 2, 3, 2, 3]);
25934 assert.deepEqual(wrapped.next(), { 'done': false, 'value': 1 });
25935 assert.deepEqual(wrapped.next(), { 'done': false, 'value': 2 });
25936 assert.deepEqual(wrapped.next(), { 'done': true, 'value': undefined });
25951 assert.deepEqual(lodashStable.toArray(wrapped), array);
25967 assert.deepEqual(Array.from(wrapped), _.toArray(value));
25982 assert.deepEqual(lodashStable.toArray(wrapped), array);
25983 …assert.deepEqual(lodashStable.toArray(wrapped), [], 'produces an empty array for exhausted iterato…
25986 assert.deepEqual(lodashStable.toArray(other), array, 'reset for new chain segments');
25987 assert.deepEqual(lodashStable.toArray(wrapped), [], 'iterator is still exhausted');
26003 assert.deepEqual(lodashStable.toArray(wrapped), array);
26006 …assert.deepEqual(lodashStable.toArray(wrapped), _.filter(array, isEven), 'reset for new lazy chain…
26007 assert.deepEqual(values, array, 'memoizes iterator values');
26029 assert.deepEqual(wrapped2.value(), [36, 64]);
26030 assert.deepEqual(wrapped1.value(), [1, 9]);
26046 assert.deepEqual(wrapped2.head().value(), 36);
26061 assert.deepEqual(lodashStable.toArray(wrapped1), [4, 16]);
26062 assert.deepEqual(lodashStable.toArray(wrapped1), []);
26065 assert.deepEqual(lodashStable.toArray(wrapped2), [36, 64]);
26086 assert.deepEqual(wrapped.value(), [1]);
26091 assert.deepEqual(actual, []);
26111 assert.deepEqual(actual, expected);
26133 assert.deepEqual(actual, [1, 2, 3]);
26153 assert.deepEqual(actual, expected);
26174 assert.deepEqual(wrapped.value(), [2]);
26179 assert.deepEqual(actual, []);
26199 assert.deepEqual(actual, expected);
26221 assert.deepEqual(actual, [1, 2, 3]);
26241 assert.deepEqual(actual, expected);
26261 assert.deepEqual(wrapped.splice(1, 1, 3).value(), [2]);
26262 assert.deepEqual(wrapped.value(), [1, 3]);
26263 assert.deepEqual(wrapped.splice(0, 2).value(), [1, 3]);
26267 assert.deepEqual(actual, []);
26287 assert.deepEqual(actual, expected);
26309 assert.deepEqual(actual, [1, 2, 3]);
26329 assert.deepEqual(actual, expected);
26349 assert.deepEqual(array, [1]);
26350 assert.deepEqual(wrapped.value(), [1, 2, 3]);
26351 assert.deepEqual(wrapped.value(), [1, 2, 3, 2, 3]);
26352 assert.deepEqual(array, [1, 2, 3, 2, 3]);
26626 assert.deepEqual(_.difference(args, [null]), [1, [3], 5], message('difference'));
26627 …assert.deepEqual(_.difference(array, args), [2, 3, 4, 6], '_.difference should work with `argument…
26629 assert.deepEqual(_.union(args, [null, 6]), [1, null, [3], 5, 6], message('union'));
26630 …assert.deepEqual(_.union(array, args), array.concat([null, [3]]), '_.union should work with `argum…
26632 assert.deepEqual(_.compact(args), [1, [3], 5], message('compact'));
26633 assert.deepEqual(_.drop(args, 3), [null, 5], message('drop'));
26634 assert.deepEqual(_.dropRight(args, 3), [1, null], message('dropRight'));
26635 …assert.deepEqual(_.dropRightWhile(args,identity), [1, null, [3], null], message('dropRightWhile'));
26636 assert.deepEqual(_.dropWhile(args,identity), [null, [3], null, 5], message('dropWhile'));
26637 assert.deepEqual(_.findIndex(args, identity), 0, message('findIndex'));
26638 assert.deepEqual(_.findLastIndex(args, identity), 4, message('findLastIndex'));
26639 assert.deepEqual(_.flatten(args), [1, null, 3, null, 5], message('flatten'));
26640 assert.deepEqual(_.head(args), 1, message('head'));
26641 assert.deepEqual(_.indexOf(args, 5), 4, message('indexOf'));
26642 assert.deepEqual(_.initial(args), [1, null, [3], null], message('initial'));
26643 assert.deepEqual(_.intersection(args, [1]), [1], message('intersection'));
26644 assert.deepEqual(_.last(args), 5, message('last'));
26645 assert.deepEqual(_.lastIndexOf(args, 1), 0, message('lastIndexOf'));
26646 assert.deepEqual(_.sortedIndex(sortedArgs, 6), 3, message('sortedIndex'));
26647 assert.deepEqual(_.sortedIndexOf(sortedArgs, 5), 2, message('sortedIndexOf'));
26648 assert.deepEqual(_.sortedLastIndex(sortedArgs, 5), 3, message('sortedLastIndex'));
26649 assert.deepEqual(_.sortedLastIndexOf(sortedArgs, 1), 0, message('sortedLastIndexOf'));
26650 assert.deepEqual(_.tail(args, 4), [null, [3], null, 5], message('tail'));
26651 assert.deepEqual(_.take(args, 2), [1, null], message('take'));
26652 assert.deepEqual(_.takeRight(args, 1), [5], message('takeRight'));
26653 assert.deepEqual(_.takeRightWhile(args, identity), [5], message('takeRightWhile'));
26654 assert.deepEqual(_.takeWhile(args, identity), [1], message('takeWhile'));
26655 assert.deepEqual(_.uniq(args), [1, null, [3], 5], message('uniq'));
26656 assert.deepEqual(_.without(args, null), [1, [3], 5], message('without'));
26657 …assert.deepEqual(_.zip(args, args), [[1, 1], [null, null], [[3], [3]], [null, null], [5, 5]], mess…
26667 assert.deepEqual(_.difference(null, array), [], message('difference'));
26668 assert.deepEqual(_.intersection(null, array), [], message('intersection'));
26669 assert.deepEqual(_.union(null, array), array, message('union'));
26670 assert.deepEqual(_.xor(null, array), array, message('xor'));
26680 assert.deepEqual(_.difference(array, null), array, message('difference'));
26681 assert.deepEqual(_.intersection(array, null), [], message('intersection'));
26682 assert.deepEqual(_.union(array, null), array, message('union'));
26727 assert.deepEqual(actual, expected);
26844 assert.deepEqual(actual, expected, '_.' + methodName + ' returns an array');
26902 assert.deepEqual(actual, expected, '`_.' + methodName + '` rejects falsey arguments');