Lines Matching refs:actual
808 var actual = _._VERSION;
809 if ((new Date - start) < limit && typeof actual != 'string') {
813 assert.strictEqual(actual, _.VERSION);
854 var actual = lodashBizarro.create(Foo.prototype);
856 actual = null;
859 assert.ok(actual instanceof Foo, label);
862 actual = [
868 actual = null;
871 assert.deepEqual(actual, [[otherObject], [object], [object]], label);
877 actual = [
882 actual = null;
885 assert.deepEqual(actual, [object, object], label);
890 actual = [
896 actual = null;
899 assert.deepEqual(actual, [{}, false, ''], label);
903 actual = map.set('a', 1).get('a');
905 actual = null;
908 assert.deepEqual(actual, 1, label);
915 actual = lodashBizarro.toArray(map);
917 actual = null;
920 assert.deepEqual(actual, [], label);
942 var actual = lodashStable.map(values, function(args) {
946 assert.deepEqual(actual, expected);
960 var actual = lodashStable.map(values, function(args) {
964 assert.deepEqual(actual, expected);
1028 var actual = func(1, { 'toString': null }, [1]);
1032 assert.strictEqual(actual, false, message || '');
1120 var actual = lodashStable.map(values, function(value) {
1124 assert.deepEqual(actual, expected);
1135 var actual = lodashStable.map(values, function(value) {
1140 assert.deepEqual(actual, expected);
1151 var actual = lodashStable.map(values, function(value) {
1159 assert.deepEqual(actual, expected);
1238 var actual = lodashStable.map(['6', '8', '10'], _.ary(parseInt, 1));
1239 assert.deepEqual(actual, [6, 8, 10]);
1258 var actual = capped('a');
1261 assert.deepEqual(actual, []);
1270 var actual = lodashStable.map(values, function(n) {
1275 assert.deepEqual(actual, expected);
1288 var actual = lodashStable.map(expected, function(array) {
1292 assert.deepEqual(actual, expected);
1315 actual = funcs[0]('a', 'b', 'c');
1317 assert.deepEqual(actual, ['a', 'b', 'c']);
1422 var actual = func(object, source);
1425 assert.deepEqual(actual, source);
1475 var actual = func({ 'a': 1, 'b': 2 }, { 'a': 3, 'c': 3 }, function(a, b) {
1479 assert.deepEqual(actual, { 'a': 1, 'b': 2, 'c': 3 });
1501 var actual = _.at(array, [0, 2]);
1502 assert.deepEqual(actual, ['a', 'c']);
1508 var actual = _.at(array, [2, 4, 0]);
1509 assert.deepEqual(actual, ['c', undefined, 'a']);
1524 actual = _.at(array, values);
1526 assert.deepEqual(actual, expected);
1539 var actual = _.at(['a', 'b', 'c', 'd'], 3, 0, 2);
1540 assert.deepEqual(actual, ['d', 'a', 'c']);
1548 var actual = lodashStable.map(falsey, function(object) {
1554 assert.deepEqual(actual, expected);
1560 var actual = _.at(args, [2, 0]);
1561 assert.deepEqual(actual, [3, 1]);
1567 var actual = _.at([1, 2, 3, 4, 5], args);
1568 assert.deepEqual(actual, [2, 3, 4]);
1574 var actual = _.at(object, ['a[0].b.c', 'a[1]']);
1575 assert.deepEqual(actual, [3, 4]);
1586 var actual = _.at(new Foo, 'b');
1587 assert.deepEqual(actual, [2]);
1622 var actual = _(array).map(iteratee).at(n).value(),
1628 assert.deepEqual(actual, expected);
1641 actual = _(object).map(identity).at(paths).value();
1643 assert.deepEqual(actual, _.at(_.map(object, identity), paths));
1646 actual = _(indexObject).at(0).value();
1647 assert.deepEqual(actual, _.at(indexObject, 0));
1669 var actual = _.attempt(function() { return slice.call(arguments); }, 1, 2);
1670 assert.deepEqual(actual, [1, 2]);
1678 var actual = lodashStable.map(errors, function(error) {
1682 assert.deepEqual(actual, expected);
1688 var actual = _.attempt(function() { throw 'x'; });
1689 assert.ok(lodashStable.isEqual(actual, Error('x')));
1695 var actual = _.attempt(function() { throw new CustomError('x'); });
1696 assert.ok(actual instanceof CustomError);
1705 var actual = lodashStable.map(realm.errors, function(error) {
1709 assert.deepEqual(actual, expected);
1803 var actual = lodashStable.map(values, function(value) {
1810 assert.ok(lodashStable.every(actual, function(value, index) {
1819 actual = bound('a');
1821 assert.ok((actual[0] === null) || (actual[0] && actual[0].Array));
1822 assert.strictEqual(actual[1], 'a');
1826 actual = bound('b');
1828 assert.ok((actual[0] === undefined) || (actual[0] && actual[0].Array));
1829 assert.strictEqual(actual[1], 'b');
1921 var actual = lodashStable.times(count, function(index) {
1937 assert.deepEqual(actual, expected);
1986 var actual = new Ctor(2012, 4, 23, 0, 0, 0, 0);
1989 assert.deepEqual(actual, expected);
1994 actual = new Ctor(0, 0, 0, 0);
1997 assert.deepEqual(actual, expected);
2010 var actual = lodashStable.times(count, function(index) {
2025 assert.deepEqual(actual, expected);
2041 var actual = bound.value()('c');
2042 assert.deepEqual(actual, [object, 'a', 'b', 'c']);
2078 var actual = lodashStable.map(['a', 'b', 'c'], function(key) {
2082 assert.deepEqual(actual, [1, 2, undefined]);
2091 var actual = lodashStable.map(['a', 'b', 'c', 'd'], function(key) {
2095 assert.deepEqual(actual, [1, 2, 3, undefined]);
2103 var actual = lodashStable.map(props, function(key) {
2109 assert.deepEqual(actual, [-2, -2, -1, -1]);
2126 var actual = lodashStable.map(args, function(key) {
2130 assert.deepEqual(actual, [1]);
2241 var actual = lodashStable.map(strings, function(string) {
2246 assert.deepEqual(actual, lodashStable.map(strings, stubTrue));
2252 var actual = lodashStable.map(strings, function(string) {
2257 assert.deepEqual(actual, lodashStable.map(strings, stubTrue));
2263 var actual = lodashStable.map(burredLetters, function(burred, index) {
2275 assert.deepEqual(actual, lodashStable.map(burredLetters, stubTrue));
2284 var actual = lodashStable.map(postfixes, function(postfix) {
2299 assert.deepEqual(actual, expected);
2306 var actual = lodashStable.map(['\xd7', '\xf7'], func);
2307 assert.deepEqual(actual, ['', '']);
2347 var actual = lodashStable.reduce(funcs, function(result, func) {
2351 assert.strictEqual(actual, 'enable6HFormat');
2412 actual = lodashStable.map(values, _.castArray);
2414 assert.deepEqual(actual, expected);
2440 var actual = _.chain({ 'a': 0 });
2441 assert.ok(actual instanceof _);
2490 var actual = wrapped
2501 assert.deepEqual(actual, expected);
2505 actual = wrapped
2512 assert.deepEqual(actual, [5, 1]);
2516 actual = wrapped
2524 assert.deepEqual(actual, [25, 16, 9, 4]);
2543 var actual = _.chunk(array, 3);
2544 assert.deepEqual(actual, [[0, 1, 2], [3, 4, 5]]);
2550 var actual = _.chunk(array, 4);
2551 assert.deepEqual(actual, [[0, 1, 2, 3], [4, 5]]);
2561 var actual = lodashStable.map(falsey, function(size, index) {
2565 assert.deepEqual(actual, expected);
2574 var actual = lodashStable.map(values, function(n) {
2578 assert.deepEqual(actual, expected);
2590 var actual = lodashStable.map([[1, 2], [3, 4]], _.chunk);
2591 assert.deepEqual(actual, [[[1], [2]], [[3], [4]]]);
2738 actual = _.clone(array);
2740 assert.deepEqual(actual, array);
2741 assert.ok(actual !== array && actual[0] === array[0]);
2755 var actual = _.cloneDeep(object);
2756 assert.ok(actual.bar.b === actual.foo.b && actual === actual.foo.b.c.d && actual !== object);
2768 actual = clone['v' + LARGE_ARRAY_SIZE][0];
2770 assert.strictEqual(actual, clone['v' + (LARGE_ARRAY_SIZE - 1)]);
2771 assert.notStrictEqual(actual, cyclical['v' + (LARGE_ARRAY_SIZE - 1)]);
2777 var actual;
2780 actual = _.last(arguments);
2784 ? actual.constructor.name == 'Stack'
2785 : actual instanceof mapCaches.Stack
2797 var actual = func(object);
2798 assert.ok(lodashStable.isEqual(actual, object));
2801 assert.notStrictEqual(actual, object);
2803 assert.strictEqual(actual, object);
2812 var actual = func(arrayBuffer);
2813 assert.strictEqual(actual.byteLength, arrayBuffer.byteLength);
2814 assert.notStrictEqual(actual, arrayBuffer);
2826 actual = func(buffer);
2828 assert.strictEqual(actual.byteLength, buffer.byteLength);
2829 assert.strictEqual(actual.inspect(), buffer.inspect());
2830 assert.notStrictEqual(actual, buffer);
2833 assert.strictEqual(actual[0], isDeep ? 2 : 1);
2844 actual = func(array);
2846 assert.strictEqual(actual.index, 2);
2847 assert.strictEqual(actual.input, 'abcde');
2870 var actual = lodashStable.map(values, function(value) {
2874 assert.deepEqual(actual, expected);
2880 var actual = func(Foo.prototype);
2882 assert.notOk(actual instanceof Foo);
2883 assert.deepEqual(actual, { 'b': 1 });
2921 var actual = func(object);
2923 assert.deepEqual(actual, object);
2924 assert.notStrictEqual(actual, object);
2949 var actual = func(object);
2951 assert.notStrictEqual(actual[symbol], object[symbol]);
2952 assert.notStrictEqual(actual.a, object.a);
2954 assert.strictEqual(actual[symbol], object[symbol]);
2955 assert.strictEqual(actual.a, object.a);
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]);
2975 actual = func(object);
2977 assert.strictEqual(typeof actual, 'object');
2978 assert.strictEqual(typeof actual.valueOf(), 'symbol');
2979 assert.notStrictEqual(actual, object);
3030 var actual = lodashStable.map(objects, function(object) {
3037 assert.deepEqual(actual, expected, props.join(', '));
3044 actual = lodashStable.map(expected, func);
3046 assert.deepEqual(actual, expected);
3049 …assert.ok(actual[0] !== expected[0] && actual[0].a !== expected[0].a && actual[1].b !== expected[1…
3051 …assert.ok(actual[0] !== expected[0] && actual[0].a === expected[0].a && actual[1].b === expected[1…
3060 actual = _(object)[methodName]();
3062 assert.deepEqual(actual, object);
3063 assert.notStrictEqual(actual, object);
3080 actual = func(view);
3082 assert.deepEqual(actual, view);
3083 assert.notStrictEqual(actual, view);
3084 assert.strictEqual(actual.buffer === view.buffer, !isDeep);
3085 assert.strictEqual(actual.byteOffset, view.byteOffset);
3086 assert.strictEqual(actual.length, view.length);
3101 actual = func(object),
3104 assert.deepEqual(actual, object);
3105 assert.notStrictEqual(actual, object);
3138 var actual = func({ 'a': { 'b': 'c' } }, noop);
3139 assert.deepEqual(actual, { 'a': { 'b': 'c' } });
3150 var actual = func(value, customizer);
3151 assert.strictEqual(actual, value);
3154 actual = func(object, customizer);
3156 assert.deepEqual(actual, object);
3157 assert.notStrictEqual(actual, object);
3181 var actual = _(falsey).thru(_.slice).compact().thru(_.slice).value();
3182 assert.deepEqual(actual, []);
3184 actual = _(falsey).thru(_.slice).push(true, 1).compact().push('a').value();
3185 assert.deepEqual(actual, [true, 1, 'a']);
3196 var actual = _(largeArray).slice(1).compact().reverse().take().value();
3197 assert.deepEqual(actual, _.take(_.compact(_.slice(largeArray, 1)).reverse()));
3214 var actual = _(largeArray).slice(1).compact().value();
3215 pass = lodashStable.isEqual(actual, _.compact(_.slice(largeArray, 1)));
3236 actual = _.concat(array);
3238 assert.deepEqual(actual, array);
3239 assert.notStrictEqual(actual, array);
3246 actual = _.concat(array, 2, [3], [[4]]);
3248 assert.deepEqual(actual, [1, 2, 3, [4]]);
3261 var actual = lodashStable.map(values, function(value, index) {
3265 assert.deepEqual(actual, expected);
3271 actual = lodashStable.map(values, function(value) {
3275 assert.deepEqual(actual, expected);
3282 actual = _.concat(Array(1), Array(1));
3286 assert.ok('0'in actual);
3287 assert.ok('1' in actual);
3288 assert.deepEqual(actual, expected);
3297 actual = wrapped.value();
3300 assert.deepEqual(actual, [1, 2, 3]);
3431 var actual = lodashStable.filter(objects, par);
3432 assert.deepEqual(actual, [objects[0], objects[2]]);
3439 actual = lodashStable.filter(objects, par);
3440 assert.deepEqual(actual, [objects[2]]);
3462 actual = lodashStable.filter(objects, par);
3464 assert.deepEqual(actual, [objects[1], objects[2]]);
3504 actual = lodashStable.filter(objects, conforms(Foo));
3506 assert.deepEqual(actual, [objects[1]]);
3534 var actual = lodashStable.map(values, function(value, index) {
3540 assert.deepEqual(actual, expected);
3550 var actual = lodashStable.map(values, function(value, index) {
3556 assert.deepEqual(actual, expected);
3565 var actual = lodashStable.map(empties, function(value) {
3570 assert.deepEqual(actual, expected);
3603 var actual = lodashStable.map(falsey, function(value, index) {
3610 assert.deepEqual(actual, expected);
3636 var actual = _.countBy(array, Math.floor);
3637 assert.deepEqual(actual, { '4': 1, '6': 2 });
3647 var actual = lodashStable.map(values, function(value, index) {
3651 assert.deepEqual(actual, expected);
3657 var actual = _.countBy(['one', 'two', 'three'], 'length');
3658 assert.deepEqual(actual, { '3': 2, '5': 1 });
3664 var actual = _.countBy(array, function(n) {
3668 assert.deepEqual(actual.constructor, 1);
3669 assert.deepEqual(actual.hasOwnProperty, 2);
3688 var actual = _.countBy({ 'a': 6.1, 'b': 4.2, 'c': 6.3 }, Math.floor);
3689 assert.deepEqual(actual, { '4': 1, '6': 2 });
3701 var actual = _(array).countBy().map(square).filter(isEven).take().value();
3703 assert.deepEqual(actual, _.take(_.filter(_.map(_.countBy(array), square), isEven)));
3731 var actual = new Circle;
3733 assert.ok(actual instanceof Circle);
3734 assert.ok(actual instanceof Shape);
3744 var actual = new Circle;
3746 assert.ok(actual instanceof Circle);
3747 assert.ok(actual instanceof Shape);
3778 var actual = lodashStable.map(falsey, function(prototype, index) {
3782 assert.deepEqual(actual, expected);
3790 var actual = lodashStable.map(primitives, function(value, index) {
3794 assert.deepEqual(actual, expected);
3804 var actual = lodashStable.map(objects, function(object) {
3808 assert.deepEqual(actual, expected);
3849 var actual = lodashStable.map(values, function(arity) {
3853 assert.deepEqual(actual, expected);
3874 actual = curried(ph, ph, ph, 'd')('a')(ph)('b')('c');
3876 assert.deepEqual(actual, ['a', 'b', 'c', 'd']);
4007 var actual = lodashStable.map(values, function(arity) {
4011 assert.deepEqual(actual, expected);
4033 actual = curried('a', ph, ph, ph)('b')(ph)('c')('d');
4035 assert.deepEqual(actual, ['a', 'b', 'c', 'd']);
4148 var actual = curried(1)(2);
4151 assert.strictEqual(actual, 3);
4176 var actual = lodashStable.map(curries, function(curried) {
4180 assert.deepEqual(actual, expected);
4402 var actual = [Boolean(withoutCount), Boolean(withCount)];
4404 assert.deepEqual(actual, [false, true]);
4461 var actual,
4466 actual = [this];
4467 push.apply(actual, arguments);
4478 assert.deepEqual(actual, [object, 'a']);
4492 var actual = lodashStable.map(burredLetters, _.deburr);
4493 assert.deepEqual(actual, deburredLetters);
4500 actual = lodashStable.map(operators, _.deburr);
4502 assert.deepEqual(actual, operators);
4510 var actual = lodashStable.map(comboMarks, function(chr) {
4514 assert.deepEqual(actual, expected);
4526 var actual = _.defaults({ 'a': 1 }, { 'a': 2, 'b': 2 });
4527 assert.deepEqual(actual, { 'a': 1, 'b': 2 });
4534 actual = _.defaults({ 'a': 1, 'b': 2 }, { 'b': 3 }, { 'c': 3 });
4536 assert.deepEqual(actual, expected);
4538 actual = _.defaults({ 'a': 1, 'b': 2 }, { 'b': 3, 'c': 3 }, { 'c': 2 });
4539 assert.deepEqual(actual, expected);
4545 var actual = _.defaults({ 'a': null }, { 'a': 1 });
4546 assert.strictEqual(actual.a, null);
4552 var actual = _.defaults({ 'a': undefined }, { 'a': 1 });
4553 assert.strictEqual(actual.a, 1);
4560 actual = _.defaults({}, source);
4562 assert.deepEqual(actual, { 'a': undefined, 'b': 1 });
4629 actual = _.defaultsDeep(object, source);
4631 assert.strictEqual(actual.a.b, null);
4639 actual = _.defaultsDeep(object, source);
4641 assert.deepEqual(actual.a.b, /x/);
4647 var actual = _.defaultsDeep({}, { 'a': noop });
4648 assert.strictEqual(actual.a, noop);
4650 actual = _.defaultsDeep({}, { 'a': { 'b': noop } });
4651 assert.strictEqual(actual.a.b, noop);
4659 actual = _.defaultsDeep(object, source);
4661 assert.strictEqual(actual.a.b, 2);
4669 actual = _.defaultsDeep({}, source);
4671 assert.deepEqual(actual, expected);
4691 var actual = _.defaultsDeep(object, source);
4693 assert.strictEqual(actual.bar.b, actual.foo.b);
4694 assert.strictEqual(actual.foo.b.c.d, actual.foo.b.c.d.foo.b.c.d);
4702 actual = _.defaultsDeep({}, source1, source2);
4704 assert.deepEqual(actual, { 'a': 1, 'b': { 'c': 2, 'd': 3 } });
4712 var actual = _.defaultsDeep({ 'a': ['abc'] }, { 'a': 'abc' });
4713 assert.deepEqual(actual.a, ['abc']);
4721 var actual = 'a' in Object;
4724 assert.notOk(actual);
4740 var actual = lodashStable.map(falsey, function(value) {
4744 assert.deepEqual(actual, expected);
4902 var actual = func([2, 1], [2, 3]);
4903 assert.deepEqual(actual, [1]);
4909 var actual = func([2, 1, 2, 3], [3, 4], [3, 2]);
4910 assert.deepEqual(actual, [1]);
4918 var actual = lodashStable.map(array, function(value) {
4922 assert.deepEqual(actual, [[], []]);
4924 actual = lodashStable.map(func([-0, 1], [1]), lodashStable.toString);
4925 assert.deepEqual(actual, ['0']);
4954 var actual = lodashStable.map(array, function(value) {
4959 assert.deepEqual(actual, [[], []]);
4962 actual = lodashStable.map(func([-0, 1], largeArray), lodashStable.toString);
4963 assert.deepEqual(actual, ['0']);
5002 var actual = _.differenceBy([2.1, 1.2], [2.3, 3.4], Math.floor);
5003 assert.deepEqual(actual, [1.2]);
5005 actual = _.differenceBy([{ 'x': 2 }, { 'x': 1 }], [{ 'x': 1 }], 'x');
5006 assert.deepEqual(actual, [{ 'x': 2 }]);
5031 actual = _.differenceWith(objects, [{ 'x': 1, 'y': 2 }], lodashStable.isEqual);
5033 assert.deepEqual(actual, [objects[1]]);
5044 var actual = lodashStable.map(others, function(other) {
5048 assert.deepEqual(actual, expected);
5093 var actual = lodashStable.map(falsey, function(n) {
5097 assert.deepEqual(actual, expected);
5126 actual = lodashStable.map(array, _.drop);
5128 assert.deepEqual(actual, [[2, 3], [5, 6], [8, 9]]);
5138 actual = _(array).drop(2).drop().value();
5140 assert.deepEqual(actual, array.slice(3));
5142 actual = _(array).filter(predicate).drop(2).drop().value();
5144 assert.deepEqual(actual, _.drop(_.drop(_.filter(array, predicate), 2)));
5146 actual = _(array).drop(2).dropRight().drop().dropRight(2).value();
5147 assert.deepEqual(actual, _.dropRight(_.drop(_.dropRight(_.drop(array, 2))), 2));
5151 actual = _(array).drop().filter(predicate).drop(2).dropRight().drop().dropRight(2).value();
5153 …assert.deepEqual(actual, _.dropRight(_.drop(_.dropRight(_.drop(_.filter(_.drop(array), predicate),…
5181 var actual = lodashStable.map(falsey, function(n) {
5185 assert.deepEqual(actual, expected);
5214 actual = lodashStable.map(array, _.dropRight);
5216 assert.deepEqual(actual, [[1, 2], [4, 5], [7, 8]]);
5226 actual = _(array).dropRight(2).dropRight().value();
5228 assert.deepEqual(actual, array.slice(0, -3));
5230 actual = _(array).filter(predicate).dropRight(2).dropRight().value();
5232 assert.deepEqual(actual, _.dropRight(_.dropRight(_.filter(array, predicate), 2)));
5234 actual = _(array).dropRight(2).drop().dropRight().drop(2).value();
5235 assert.deepEqual(actual, _.drop(_.dropRight(_.drop(_.dropRight(array, 2))), 2));
5239 … actual = _(array).dropRight().filter(predicate).dropRight(2).drop().dropRight().drop(2).value();
5241 …assert.deepEqual(actual, _.drop(_.dropRight(_.drop(_.dropRight(_.filter(_.dropRight(array), predic…
5265 var actual = _.dropRightWhile(array, function(n) {
5269 assert.deepEqual(actual, [1, 2]);
5335 var actual = _.dropWhile(array, function(n) {
5339 assert.deepEqual(actual, [3, 4]);
5396 var actual = _(array)
5402 assert.deepEqual(actual, array.slice(3));
5448 var actual = lodashStable.map(falsey, function(position) {
5452 assert.deepEqual(actual, expected);
5562 var actual = lodashStable.map(values, function(value, index) {
5566 assert.deepEqual(actual, expected);
5586 var actual = lodashStable.map(empties, function(value) {
5592 assert.deepEqual(actual, expected);
5620 var actual = lodashStable.map(values, function(value, index) {
5625 assert.deepEqual(actual, expected);
5628 actual = lodashStable.map(values, function(value, index) {
5633 assert.deepEqual(actual, expected);
5655 var actual = lodashStable.map([[1]], _.every);
5656 assert.deepEqual(actual, [true]);
5699 actual = _.fill(array);
5701 assert.deepEqual(actual, Array(3));
5702 assert.ok(lodashStable.every(actual, function(value, index) {
5703 return index in actual;
5728 var actual = lodashStable.map(falsey, function(start) {
5733 assert.deepEqual(actual, expected);
5784 var actual = lodashStable.map(falsey, function(end) {
5789 assert.deepEqual(actual, expected);
5813 var actual = lodashStable.map(positions, function(pos) {
5818 …assert.deepEqual(actual, [['a', 2, 3], ['a', 2, 3], ['a', 2, 3], [1, 'a', 'a'], ['a', 2, 3], [1, 2…
5825 actual = lodashStable.map(array, _.fill);
5827 assert.deepEqual(actual, [[0, 0], [1, 1]]);
5836 actual = wrapped.value();
5839 assert.strictEqual(actual, array);
5840 assert.deepEqual(actual, ['a', 'a', 'a']);
5921 var actual = lodashStable.map(emptyValues, function(value) {
5927 assert.deepEqual(actual, expecting);
6016 var actual = func({ 'a': 1, 'b': 2, 'c': 3 }, function(n) {
6027 assert.strictEqual(actual, expected);
6060 actual = _(array).map(iteratee)[methodName](predicate);
6064 assert.strictEqual(actual, isFind ? 4 : square(LARGE_ARRAY_SIZE));
6096 var actual = [
6101 assert.deepEqual(actual, expected);
6114 var actual = lodashStable.map(indexes, function(fromIndex) {
6122 assert.deepEqual(actual, expected);
6130 var actual = lodashStable.map(falsey, function(fromIndex) {
6134 assert.deepEqual(actual, expected);
6146 var actual = [
6152 assert.deepEqual(actual, expected);
6163 var actual = [
6168 assert.deepEqual(actual, expected);
6177 var actual = lodashStable.map(indexes, function(fromIndex) {
6181 assert.deepEqual(actual, expected);
6213 var actual = lodashStable.map(values, function(fromIndex) {
6221 assert.deepEqual(actual, expected);
6236 var actual = lodashStable.map(values, function(fromIndex) {
6240 assert.deepEqual(actual, expected);
6248 var actual = lodashStable.map(falsey, function(fromIndex) {
6252 assert.deepEqual(actual, expected);
6284 var actual = [
6289 assert.deepEqual(actual, expected);
6299 var actual = lodashStable.map(indexes, function(fromIndex) {
6307 assert.deepEqual(actual, expected);
6317 var actual = lodashStable.map(falsey, function(fromIndex) {
6321 assert.deepEqual(actual, expected);
6333 var actual = [
6339 assert.deepEqual(actual, expected);
6350 var actual = [
6355 assert.deepEqual(actual, expected);
6364 var actual = lodashStable.map(indexes, function(fromIndex) {
6368 assert.deepEqual(actual, expected);
6409 var actual = lodashStable.map(values, function(value, index) {
6413 assert.deepEqual(actual, expected);
6446 var actual = func(array, duplicate),
6449 assert.deepEqual(actual, expected);
6467 var actual = func(new Foo, identity);
6468 assert.deepEqual(actual, [1, 2]);
6480 var actual = lodashStable.map(values, function(value, index) {
6484 assert.deepEqual(actual, expected);
6493 var actual = lodashStable.map(falsey, function(collection, index) {
6499 assert.deepEqual(actual, expected);
6571 var actual = _[methodName](array);
6572 assert.deepEqual(actual, expected);
6573 assert.ok('4' in actual);
6587 var actual = lodashStable.map(methodNames, function(methodName) {
6591 assert.deepEqual(actual, expected);
6651 actual = wrapped.flatten();
6653 assert.ok(actual instanceof _);
6654 assert.deepEqual(actual.value(), [1, 2, [3, [4]], 5]);
6656 actual = wrapped.flattenDeep();
6658 assert.ok(actual instanceof _);
6659 assert.deepEqual(actual.value(), [1, 2, 3, 4, 5]);
6661 actual = wrapped.flattenDepth(2);
6663 assert.ok(actual instanceof _);
6664 assert.deepEqual(actual.value(), [1, 2, 3, [4], 5]);
7102 var actual = _(array)[methodName](noop);
7103 assert.notOk(actual instanceof _);
7115 actual = wrapped[methodName](noop);
7117 assert.ok(actual instanceof _);
7118 assert.notStrictEqual(actual, wrapped);
7180 var actual = lodashStable.map(values, function(length) {
7187 assert.deepEqual(actual, expected);
7272 var actual = lodashStable.map(primitives, function(value) {
7276 assert.deepEqual(actual, expected);
7317 var actual = lodashStable.map(values, function(value) {
7322 assert.deepEqual(actual, expected);
7324 actual = lodashStable.map(values, function(value) {
7328 assert.deepEqual(actual, expected);
7351 actual = wrapped[methodName]({ 'b': 2 });
7353 assert.notStrictEqual(actual, wrapped);
7370 var actual = func(new Foo, { 'b': 2 });
7371 assert.notOk(_.has(actual, 'a'));
7451 var actual = func({ 'a': 1 }, callback);
7452 assert.deepEqual(actual, { 'a': 1, 'b': 2 });
7454 actual = func({ 'a': 1 }, callback, { 'c': 3 });
7455 assert.deepEqual(actual, { 'a': 1, 'b': 2, 'c': 3 });
7543 var actual = lodashStable.map(methods, function(methodName) {
7548 assert.deepEqual(actual, expected);
7550 actual = _.groupBy([{ 'a': '__proto__' }], 'a');
7551 assert.notOk(actual instanceof Array);
7560 var actual = 'a' in objectProto;
7563 assert.notOk(actual);
7574 var actual = 'a' in funcProto;
7577 assert.notOk(actual);
7581 actual = 'a' in objectProto;
7584 assert.notOk(actual);
7592 var actual = 'a' in Object;
7595 assert.notOk(actual);
7609 actual = _.fromPairs(array);
7611 assert.deepEqual(actual, object);
7619 var actual = lodashStable.map(falsey, function(array, index) {
7625 assert.deepEqual(actual, expected);
7631 var actual = _.fromPairs([['a.b', 1]]);
7632 assert.deepEqual(actual, { 'a.b': 1 });
7650 var actual = _(array).fromPairs().map(square).filter(isEven).take().value();
7652 assert.deepEqual(actual, _.take(_.filter(_.map(_.fromPairs(array), square), isEven)));
7669 actual = _.functions(object).sort();
7671 assert.deepEqual(actual, ['b', 'd']);
7697 var actual = _.groupBy(array, Math.floor);
7698 assert.deepEqual(actual, { '4': [4.2], '6': [6.1, 6.3] });
7708 var actual = lodashStable.map(values, function(value, index) {
7712 assert.deepEqual(actual, expected);
7718 var actual = _.groupBy(['one', 'two', 'three'], 'length');
7719 assert.deepEqual(actual, { '3': ['one', 'two'], '5': ['three'] });
7725 var actual = _.groupBy(array, function(n) {
7729 assert.deepEqual(actual.constructor, [4.2]);
7730 assert.deepEqual(actual.hasOwnProperty, [6.1, 6.3]);
7749 var actual = _.groupBy({ 'a': 6.1, 'b': 4.2, 'c': 6.3 }, Math.floor);
7750 assert.deepEqual(actual, { '4': [4.2], '6': [6.1, 6.3] });
7764 actual = _(array).groupBy().map(iteratee).filter(predicate).take().value();
7766 …assert.deepEqual(actual, _.take(_.filter(lodashStable.map(_.groupBy(array), iteratee), predicate))…
7874 var actual = lodashStable.map(paths, function(path) {
7878 assert.deepEqual(actual, expected);
7905 var actual = lodashStable.map(props, function(key) {
7909 assert.deepEqual(actual, expected);
7953 var actual = lodashStable.map(values, function(value) {
7957 assert.deepEqual(actual, expected);
7966 var actual = lodashStable.map(values, function(value) {
7972 assert.deepEqual(actual, expected);
8004 var actual = lodashStable.map(values, function(value) {
8008 assert.deepEqual(actual, expected);
8019 var actual = lodashStable.map(values, function(value) {
8023 assert.deepEqual(actual, expected);
8034 var actual = lodashStable.map(values, function(value, index) {
8039 assert.deepEqual(actual, expected);
8049 var actual = lodashStable.map(values, function(value) {
8055 assert.deepEqual(actual, expected);
8084 actual = lodashStable.map(array, _.head);
8086 assert.deepEqual(actual, [1, 4, 7]);
8144 actual = _(array).filter(isEven)[methodName]();
8146 assert.strictEqual(actual, _[methodName](_.filter(array, isEven)));
8240 var actual = lodashStable.map(empties, function(value) {
8246 assert.deepEqual(actual, expected);
8260 var actual = lodashStable.map(indexes, function(fromIndex) {
8268 assert.deepEqual(actual, expected);
8306 var actual = lodashStable.map(falsey, function(array, index) {
8312 assert.deepEqual(actual, expected);
8331 actual = lodashStable.map(array, _.initial);
8333 assert.deepEqual(actual, [[1, 2], [4, 5], [7, 8]]);
8343 var actual = _(array).initial().filter(function(value) {
8349 assert.deepEqual(actual, []);
8354 actual = _(array).filter(function(value) {
8361 assert.deepEqual(actual, _.initial(lodashStable.filter(array, isEven)));
8424 var actual = [
8432 assert.deepEqual(actual, lodashStable.map(actual, stubTrue));
8446 var actual = func([2, 1], [2, 3]);
8447 assert.deepEqual(actual, [2]);
8453 var actual = func([2, 1, 2, 3], [3, 4], [3, 2]);
8454 assert.deepEqual(actual, [3]);
8460 var actual = func([1, 1, 3, 2, 2], [5, 2, 2, 1, 4], [2, 1, 1]);
8461 assert.deepEqual(actual, [1, 2]);
8467 var actual = func([1, 1, 3, 2, 2]);
8468 assert.deepEqual(actual, [1, 3, 2]);
8487 var actual = lodashStable.map(values, function(value) {
8491 assert.deepEqual(actual, expected);
8497 var actual = func([1, NaN, 3], [NaN, 5, NaN]);
8498 assert.deepEqual(actual, [NaN]);
8507 var actual = lodashStable.map(values, function(value) {
8512 assert.deepEqual(actual, expected);
8563 var actual = _.intersectionBy([2.1, 1.2], [2.3, 3.4], Math.floor);
8564 assert.deepEqual(actual, [2.1]);
8566 actual = _.intersectionBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x');
8567 assert.deepEqual(actual, [{ 'x': 1 }]);
8593 actual = _.intersectionWith(objects, others, lodashStable.isEqual);
8595 assert.deepEqual(actual, [objects[0]]);
8606 var actual = lodashStable.map(others, function(other) {
8610 assert.deepEqual(actual, expected);
8623 actual = _.invert(object);
8625 assert.deepEqual(actual, { '1': 'a', '2': 'b' });
8626 assert.deepEqual(_.invert(actual), { 'a': '1', 'b': '2' });
8671 var actual = _.invertBy(object, function(value) {
8675 assert.deepEqual(actual, expected);
8684 var actual = lodashStable.map(values, function(value, index) {
8688 assert.deepEqual(actual, expected);
8724 actual = _.invoke(object, 'a');
8726 assert.strictEqual(actual, 'A');
8733 actual = _.invoke(object, 'a', 1, 2);
8735 assert.deepEqual(actual, [1, 2]);
8744 var actual = lodashStable.map(values, function(value) {
8750 assert.deepEqual(actual, expected);
8759 var actual = lodashStable.map(props, function(key) {
8763 assert.deepEqual(actual, ['a', 'a', 'b', 'b']);
8772 var actual = _.invoke(object, path, 1, 2);
8773 assert.deepEqual(actual, [1, 2]);
8821 actual = _.invokeMap(array, 'toUpperCase');
8823 assert.deepEqual(actual, ['A', 'B', 'C']);
8830 actual = _.invokeMap(array, 'call', null, 'a', 'b', 'c');
8832 assert.deepEqual(actual, [['a', 'b', 'c']]);
8840 var actual = _.invokeMap(array, function(left, right) {
8844 assert.deepEqual(actual, ['(A)', '(B)', '(C)']);
8851 actual = _.invokeMap(object, 'toFixed', 1);
8853 assert.deepEqual(actual, ['1.0', '2.0', '3.0']);
8868 var actual = _.invokeMap(array, 'toUpperCase');
8871 assert.deepEqual(actual, ['A', undefined, undefined, 'D']);
8886 var actual = _.invokeMap(objects, 'a');
8889 assert.deepEqual(actual, expected);
8908 actual = wrapped.invokeMap('toUpperCase');
8910 assert.ok(actual instanceof _);
8911 assert.deepEqual(actual.valueOf(), ['A', 'B', 'C']);
8913 actual = wrapped.invokeMap(function(left, right) {
8917 assert.ok(actual instanceof _);
8918 assert.deepEqual(actual.valueOf(), ['(A)', '(B)', '(C)']);
8936 var actual = _(array).invokeMap('method').take(1).value();
8939 assert.deepEqual(actual, [0]);
8964 var actual = lodashStable.map(falsey, function(value, index) {
8968 assert.deepEqual(actual, expected);
9011 var actual = lodashStable.map(falsey, function(value, index) {
9015 assert.deepEqual(actual, expected);
9063 var actual = lodashStable.map(falsey, function(value, index) {
9067 assert.deepEqual(actual, expected);
9105 actual = lodashStable.map(values, _.isArrayLike);
9107 assert.deepEqual(actual, expected);
9117 var actual = lodashStable.map(falsey, function(value, index) {
9121 assert.deepEqual(actual, expected);
9142 actual = lodashStable.map(values, _.isArrayLike);
9144 assert.deepEqual(actual, expected);
9173 var actual = lodashStable.map(falsey, function(value, index) {
9177 assert.deepEqual(actual, expected);
9225 var actual = lodashStable.map(falsey, function(value, index) {
9229 assert.deepEqual(actual, expected);
9273 var actual = lodashStable.map(falsey, function(value, index) {
9277 assert.deepEqual(actual, expected);
9335 var actual = lodashStable.map(falsey, function(value, index) {
9339 assert.deepEqual(actual, expected);
9387 actual = lodashStable.map(empties, _.isEmpty);
9389 assert.deepEqual(actual, expected);
9557 var actual = lodashStable.map(pairs, function(pair) {
9561 assert.deepEqual(actual, expected);
9977 var actual = lodashStable.map(pairs, function(pair) {
9981 assert.deepEqual(actual, expected);
10032 var actual = lodashStable.map(pairs, function(pair) {
10036 assert.deepEqual(actual, expected);
10231 actual = wrapped1.isEqual(wrapped2);
10233 assert.strictEqual(actual, true);
10234 assert.strictEqual(_.isEqual(_(actual), _(true)), true);
10239 actual = wrapped1.isEqual(wrapped2);
10240 assert.strictEqual(actual, false);
10241 assert.strictEqual(_.isEqual(_(actual), _(false)), true);
10273 var actual = lodashStable.every([1, 1, 1], lodashStable.partial(_.isEqual, 1));
10274 assert.ok(actual);
10317 var actual = lodashStable.map(values, function(value) {
10322 assert.deepEqual(actual, expected);
10416 var actual = _.isEqualWith('a', 'b', stubC);
10417 assert.strictEqual(actual, true);
10422 actual = [];
10424 actual.push(_.isEqualWith('a', 'a', lodashStable.constant(value)));
10427 assert.deepEqual(actual, expected);
10435 actual = lodashStable.map([array, [1, 0, 3]], eq);
10437 assert.deepEqual(actual, [true, false]);
10500 var actual = lodashStable.map(errors, function(error) {
10504 assert.deepEqual(actual, expected);
10518 var actual = lodashStable.map(falsey, function(value, index) {
10522 assert.deepEqual(actual, expected);
10549 var actual = lodashStable.map(realm.errors, function(error) {
10553 assert.deepEqual(actual, expected);
10571 actual = lodashStable.map(values, _.isFinite);
10573 assert.deepEqual(actual, expected);
10581 actual = lodashStable.map(values, _.isFinite);
10583 assert.deepEqual(actual, expected);
10591 actual = lodashStable.map(values, _.isFinite);
10593 assert.deepEqual(actual, expected);
10611 actual = lodashStable.map(values, _.isFinite);
10613 assert.deepEqual(actual, expected);
10659 var actual = lodashStable.map(arrayViews, function(type) {
10663 assert.deepEqual(actual, expected);
10671 var actual = lodashStable.map(falsey, function(value, index) {
10675 assert.deepEqual(actual, expected);
10722 var actual = lodashStable.map(values, function(value) {
10726 assert.deepEqual(actual, expected);
10736 var actual = lodashStable.map(values, function(value) {
10740 assert.deepEqual(actual, expected);
10750 var actual = lodashStable.map(falsey, function(value, index) {
10754 assert.deepEqual(actual, expected);
10778 actual = lodashStable.map(values, _.isLength);
10780 assert.deepEqual(actual, expected);
10788 actual = lodashStable.map(values, _.isLength);
10790 assert.deepEqual(actual, expected);
10815 var actual = lodashStable.map(falsey, function(value, index) {
10819 assert.deepEqual(actual, expected);
10842 var actual = lodashStable.map(values, function(value) {
10846 assert.deepEqual(actual, expected);
10926 actual = _.isMatchWith(object, { 'a': 1 }, stubA);
10928 assert.strictEqual(actual, true);
10932 actual = [];
10934 actual.push(_.isMatchWith(object, { 'a': 2 }, lodashStable.constant(value)));
10937 assert.deepEqual(actual, expected);
10943 var actual;
10946 actual = _.last(arguments);
10950 ? actual.constructor.name == 'Stack'
10951 : actual instanceof mapCaches.Stack
10960 actual = lodashStable.map([object, { 'a': 2 }], matches);
10962 assert.deepEqual(actual, [true, false]);
11033 var actual = lodashStable.map(falsey, function(value, index) {
11037 assert.deepEqual(actual, expected);
11076 actual = lodashStable.map(values, _.isNative);
11078 assert.deepEqual(actual, expected);
11086 var actual = lodashStable.map(falsey, function(value, index) {
11090 assert.deepEqual(actual, expected);
11185 var actual = lodashStable.map(falsey, function(value, index) {
11189 assert.deepEqual(actual, expected);
11242 var actual = lodashStable.map(falsey, function(value, index) {
11246 assert.deepEqual(actual, expected);
11294 var actual = lodashStable.map(falsey, function(value, index) {
11298 assert.deepEqual(actual, expected);
11365 var actual = lodashStable.map(values, function(value, index) {
11369 assert.deepEqual(actual, expected);
11421 var actual = lodashStable.map(values, function(value, index) {
11425 assert.deepEqual(actual, expected);
11526 var actual = lodashStable.map(falsey, function(value, index) {
11530 assert.deepEqual(actual, expected);
11601 var actual = lodashStable.map(falsey, function(value, index) {
11605 assert.deepEqual(actual, expected);
11653 var actual = lodashStable.map(falsey, function(value, index) {
11657 assert.deepEqual(actual, expected);
11680 var actual = lodashStable.map(values, function(value) {
11684 assert.deepEqual(actual, expected);
11718 var actual = lodashStable.map(falsey, function(value, index) {
11722 assert.deepEqual(actual, expected);
11771 var actual = lodashStable.map(falsey, function(value, index) {
11775 assert.deepEqual(actual, expected);
11814 var actual = lodashStable.map(typedArrays, function(type) {
11819 assert.deepEqual(actual, expected);
11827 var actual = lodashStable.map(falsey, function(value, index) {
11831 assert.deepEqual(actual, expected);
11857 var actual = lodashStable.map(props, function(key) {
11862 assert.deepEqual(actual, expected);
11889 var actual = lodashStable.map(falsey, function(value, index) {
11893 assert.deepEqual(actual, expected);
11948 var actual = lodashStable.map(falsey, function(value, index) {
11952 assert.deepEqual(actual, expected);
11975 var actual = lodashStable.map(values, function(value) {
11979 assert.deepEqual(actual, expected);
12015 var actual = lodashStable.map(falsey, function(value, index) {
12019 assert.deepEqual(actual, expected);
12108 actual = iteratee('a', 'b', 'c', 'd', 'e', 'f');
12110 assert.deepEqual(actual, ['a', 'b', 'c', 'd', 'e', 'f']);
12120 var actual = lodashStable.map(values, function(value, index) {
12125 assert.deepEqual(actual, expected);
12276 var actual = lodashStable.map(iteratees, function(iteratee) {
12280 assert.deepEqual(actual, expected);
12873 var actual = _.keyBy(array, function(object) {
12877 assert.deepEqual(actual, expected);
12887 var actual = lodashStable.map(values, function(value, index) {
12891 assert.deepEqual(actual, expected);
12898 actual = _.keyBy(array, 'dir');
12900 assert.deepEqual(actual, expected);
12906 var actual = _.keyBy([6.1, 4.2, 6.3], function(n) {
12910 assert.deepEqual(actual.constructor, 4.2);
12911 assert.deepEqual(actual.hasOwnProperty, 6.3);
12930 var actual = _.keyBy({ 'a': 6.1, 'b': 4.2, 'c': 6.3 }, Math.floor);
12931 assert.deepEqual(actual, { '4': 4.2, '6': 6.3 });
12943 var actual = _(array).keyBy().map(square).filter(isEven).take().value();
12945 assert.deepEqual(actual, _.take(_.filter(_.map(_.keyBy(array), square), isEven)));
12964 var actual = func({ 'a': 1, 'b': 1 }).sort();
12966 assert.deepEqual(actual, ['a', 'b']);
12978 actual = func(new Foo).sort();
12980 assert.deepEqual(actual, expected);
12989 var actual = func(array).sort();
12991 assert.deepEqual(actual, ['0', '1', '2']);
13000 var actual = func(array).sort();
13002 assert.deepEqual(actual, ['0', 'a']);
13011 actual = func([1]).sort();
13013 assert.deepEqual(actual, expected);
13024 var actual = lodashStable.map(values, function(value) {
13028 assert.deepEqual(actual, expected);
13037 var actual = lodashStable.map(values, function(value) {
13044 assert.deepEqual(actual, expected);
13053 var actual = lodashStable.map(values, function(value) {
13060 assert.deepEqual(actual, expected);
13066 var actual = func(Object('abc')).sort();
13068 assert.deepEqual(actual, ['0', '1', '2']);
13077 var actual = func(object).sort();
13079 assert.deepEqual(actual, ['0', 'a']);
13088 actual = func(Object('a')).sort();
13090 assert.deepEqual(actual, expected);
13099 actual = func(object).sort();
13101 assert.deepEqual(actual, ['0', 'length']);
13111 var actual = lodashStable.map(primitives, func);
13112 assert.deepEqual(actual, expected);
13141 var actual = lodashStable.map(values, function(value, index) {
13148 assert.deepEqual(actual, expected);
13178 actual = lodashStable.map(array, _.last);
13180 assert.deepEqual(actual, [3, 6, 9]);
13336 var actual = lodashStable.map(values, function(fromIndex) {
13344 assert.deepEqual(actual, expected);
13359 var actual = lodashStable.map(values, function(fromIndex) {
13363 assert.deepEqual(actual, expected);
13373 var actual = lodashStable.map(falsey, function(fromIndex) {
13377 assert.deepEqual(actual, expected);
13401 var actual = lodashStable.map(falsey, function(array, index) {
13407 assert.deepEqual(actual, expected);
13492 var actual = _.map(new Foo, identity);
13493 assert.deepEqual(actual, [1]);
13504 var actual = lodashStable.map(values, function(value, index) {
13508 assert.deepEqual(actual, expected);
13517 var actual = lodashStable.map(falsey, function(collection, index) {
13523 assert.deepEqual(actual, expected);
13536 var actual = _.map(document.getElementsByTagName('body'), function(element) {
13540 assert.deepEqual(actual, ['body']);
13626 var actual = _.mapKeys(object, String);
13627 assert.deepEqual(actual, { '1': 1, '2': 2 });
13633 var actual = _.mapKeys(array, String);
13634 assert.deepEqual(actual, { '1': 1, '2': 2 });
13640 var actual = _.mapKeys({ 'a': { 'b': 'c' } }, 'b');
13641 assert.deepEqual(actual, { 'c': { 'b': 'c' } });
13651 var actual = lodashStable.map(values, function(value, index) {
13655 assert.deepEqual(actual, expected);
13670 var actual = _.mapValues(object, String);
13671 assert.deepEqual(actual, { 'a': '1', 'b': '2' });
13677 var actual = _.mapValues(array, String);
13678 assert.deepEqual(actual, { '0': '1', '1': '2' });
13684 var actual = _.mapValues({ 'a': { 'b': 2 } }, 'b');
13685 assert.deepEqual(actual, { 'a': 2 });
13695 var actual = lodashStable.map(values, function(value, index) {
13700 assert.deepEqual(actual, expected);
13720 var actual = func(new Foo, function(value, key) { return key; });
13721 assert.deepEqual(actual, { 'a': 'a' });
13729 var actual = lodashStable.map(falsey, function(object, index) {
13735 assert.deepEqual(actual, expected);
13843 actual = lodashStable.map(objects, matches(source)),
13846 assert.deepEqual(actual, expected);
13905 actual = lodashStable.map(objects, matches(Foo));
13907 assert.deepEqual(actual, [false, true]);
13925 actual = lodashStable.filter(objects, matches({ 'a': ['d'] }));
13927 assert.deepEqual(actual, [objects[1]]);
13929 actual = lodashStable.filter(objects, matches({ 'a': ['b', 'd'] }));
13930 assert.deepEqual(actual, []);
13932 actual = lodashStable.filter(objects, matches({ 'a': ['d', 'b'] }));
13933 assert.deepEqual(actual, []);
13940 actual = lodashStable.filter(objects, matches({ 'a': [2, 2] }));
13942 assert.deepEqual(actual, [objects[1]]);
13953 var actual = lodashStable.filter(objects, matches({ 'a': [{ 'b': 1 }, { 'b': 4, 'c': 5 }] }));
13954 assert.deepEqual(actual, [objects[0]]);
13968 var actual = lodashStable.filter(objects, matches({ 'a': map }));
13970 assert.deepEqual(actual, [objects[1]]);
13973 actual = lodashStable.filter(objects, matches({ 'a': map }));
13975 assert.deepEqual(actual, objects);
13978 actual = lodashStable.filter(objects, matches({ 'a': map }));
13980 assert.deepEqual(actual, []);
13998 var actual = lodashStable.filter(objects, matches({ 'a': set }));
14000 assert.deepEqual(actual, [objects[1]]);
14003 actual = lodashStable.filter(objects, matches({ 'a': set }));
14005 assert.deepEqual(actual, objects);
14008 actual = lodashStable.filter(objects, matches({ 'a': set }));
14010 assert.deepEqual(actual, []);
14021 actual = lodashStable.map(objects, matches({ 'b': undefined })),
14024 assert.deepEqual(actual, expected);
14026 actual = lodashStable.map(objects, matches({ 'a': 1, 'b': undefined }));
14028 assert.deepEqual(actual, expected);
14031 actual = lodashStable.map(objects, matches({ 'a': { 'c': undefined } }));
14033 assert.deepEqual(actual, expected);
14072 var actual = lodashStable.map(values, function(value, index) {
14078 assert.deepEqual(actual, expected);
14087 var actual = lodashStable.map(empties, function(value) {
14092 assert.deepEqual(actual, expected);
14102 var actual = lodashStable.map(values, function(value, index) {
14108 assert.deepEqual(actual, expected);
14115 actual = lodashStable.filter(objects, matches({ 'a': [], 'b': {} }));
14117 assert.deepEqual(actual, objects);
14182 var actual = lodashStable.map(props, function(key, index) {
14189 assert.deepEqual(actual, expected);
14203 var actual = lodashStable.map(paths, function(path) {
14208 assert.deepEqual(actual, expected);
14232 var actual = lodashStable.map(values, function(value, index) {
14238 assert.deepEqual(actual, expected);
14251 var actual = lodashStable.map(values, function(value, index) {
14257 assert.deepEqual(actual, expected);
14345 actual = lodashStable.map(objects, _.matchesProperty('a', Foo));
14347 assert.deepEqual(actual, [false, true]);
14365 actual = lodashStable.filter(objects, _.matchesProperty('a', ['d']));
14367 assert.deepEqual(actual, [objects[1]]);
14369 actual = lodashStable.filter(objects, _.matchesProperty('a', ['b', 'd']));
14370 assert.deepEqual(actual, []);
14372 actual = lodashStable.filter(objects, _.matchesProperty('a', ['d', 'b']));
14373 assert.deepEqual(actual, []);
14380 actual = lodashStable.filter(objects, _.matchesProperty('a', [2, 2]));
14382 assert.deepEqual(actual, [objects[1]]);
14393 …var actual = lodashStable.filter(objects, _.matchesProperty('a', [{ 'a': 1 }, { 'a': 4, 'b': 5 }])…
14394 assert.deepEqual(actual, [objects[0]]);
14407 var actual = lodashStable.filter(objects, _.matchesProperty('a', map));
14409 assert.deepEqual(actual, [objects[1]]);
14412 actual = lodashStable.filter(objects, _.matchesProperty('a', map));
14414 assert.deepEqual(actual, objects);
14417 actual = lodashStable.filter(objects, _.matchesProperty('a', map));
14419 assert.deepEqual(actual, []);
14437 var actual = lodashStable.filter(objects, _.matchesProperty('a', set));
14439 assert.deepEqual(actual, [objects[1]]);
14442 actual = lodashStable.filter(objects, _.matchesProperty('a', set));
14444 assert.deepEqual(actual, objects);
14447 actual = lodashStable.filter(objects, _.matchesProperty('a', set));
14449 assert.deepEqual(actual, []);
14460 actual = lodashStable.map(objects, _.matchesProperty('b', undefined)),
14463 assert.deepEqual(actual, expected);
14466 actual = lodashStable.map(objects, _.matchesProperty('a', { 'b': undefined }));
14468 assert.deepEqual(actual, expected);
14516 var actual = lodashStable.filter(objects, function(object) {
14520 assert.deepEqual(actual, objects);
14564 var actual = lodashStable.map(values, function(value, index) {
14570 assert.deepEqual(actual, expected);
14596 actual = lodashStable.map(empties, _.mean);
14598 assert.deepEqual(actual, expected);
14612 var actual = _.meanBy(objects, function(object) {
14616 assert.deepEqual(actual, 2);
14730 var actual = lodashStable.map(values, function(resolver, index) {
14736 assert.deepEqual(actual, expected);
14754 var actual = lodashStable.map(props, function(value) {
14758 assert.deepEqual(actual, props);
14916 var actual = _.merge(object, source);
14918 assert.notStrictEqual(actual.bar.b, actual.foo.b);
14919 assert.strictEqual(actual.foo.b.c.d, actual.foo.b.c.d.foo.b.c.d);
14926 actual = _.merge({ 'a': 1 }, { 'a': 2 }, { 'a': 3 }, expected);
14928 assert.deepEqual(actual, expected);
14937 actual = _.merge(Foo, source);
14939 assert.strictEqual(actual, Foo);
14948 actual = _.merge({ 'prop': fn }, object);
14950 assert.deepEqual(actual, object);
14958 actual = _.merge({ 'prop': fn }, { 'prop': fn }, object);
14960 assert.deepEqual(actual, object);
14969 actual = _.merge({}, source1, source2);
14971 assert.deepEqual(actual, expected);
14974 actual = _.merge(source1, source2);
14975 assert.deepEqual(actual, expected);
14984 actual = _.merge(object, { 'a': 1 });
14986 assert.strictEqual(actual, object);
14996 var actual = _.merge([], array),
15001 assert.ok('1' in actual);
15002 assert.deepEqual(actual, expected);
15011 actual = _.merge(object1, object2);
15014 assert.notOk(_.isArguments(actual.value));
15015 assert.deepEqual(actual.value, expected);
15018 actual = _.merge(object2, object1);
15019 assert.notOk(_.isArguments(actual.value));
15020 assert.deepEqual(actual.value, expected);
15024 actual = _.merge({}, object1);
15025 assert.notOk(_.isArguments(actual.value));
15026 assert.deepEqual(actual.value, expected);
15046 var actual = lodashStable.map(typedArrays, function(type) {
15051 assert.ok(lodashStable.isArray(actual));
15052 assert.deepEqual(actual, expected);
15060 actual = lodashStable.map(typedArrays, function(type, index) {
15068 assert.ok(lodashStable.isArray(actual));
15069 assert.deepEqual(actual, expected);
15075 var actual = _.merge({ 'a': 1 }, { 'a': null });
15076 assert.strictEqual(actual.a, null);
15087 var actual = lodashStable.map(values, function(value) {
15092 assert.deepEqual(actual, expected);
15100 actual = _.merge({}, { 'value': buffer }).value;
15102 assert.ok(lodashStable.isBuffer(actual));
15103 assert.strictEqual(actual[0], buffer[0]);
15104 assert.notStrictEqual(actual, buffer);
15122 var actual = lodashStable.map(values, function(value, index) {
15136 assert.deepEqual(actual, expected);
15144 actual = _.merge({}, source1, source2);
15148 assert.deepEqual(actual.a, [{ 'a': 1, 'b': 2 }]);
15152 actual = _.merge({}, source1, source2);
15156 assert.deepEqual(actual.a, [[3, 4, 3]]);
15167 actual = _.merge(new Foo, object);
15169 assert.ok(actual instanceof Foo);
15170 assert.deepEqual(actual, new Foo(object));
15172 actual = _.merge([new Foo], [object]);
15173 assert.ok(actual[0] instanceof Foo);
15174 assert.deepEqual(actual, [new Foo(object)]);
15180 var actual = _.merge({ 'a': 1 }, { 'a': undefined, 'b': undefined });
15181 assert.deepEqual(actual, { 'a': 1, 'b': undefined });
15190 var actual = _.merge([4, 5, 6], array),
15193 assert.deepEqual(actual, expected);
15198 actual = _.merge([4, 5, 6], array);
15199 assert.deepEqual(actual, expected);
15223 actual = _.merge(object, { 'a': ['x'] });
15225 assert.deepEqual(actual, { 'a': ['x', 'y'] });
15227 actual = _.merge({ 'a': {} }, { 'a': [] });
15228 assert.deepEqual(actual, { 'a': [] });
15235 actual = _.merge(object, { 'a': ['x', 'y', 'z'] });
15237 assert.deepEqual(actual, { 'a': ['x', 'y', 'z'] });
15248 var actual = lodashStable.map(pairs, function(pair) {
15254 assert.deepEqual(actual, expected);
15266 var actual = _.mergeWith({ 'a': { 'b': [1, 1] } }, { 'a': { 'b': [0] } }, noop);
15267 assert.deepEqual(actual, { 'a': { 'b': [0, 1] } });
15269 actual = _.mergeWith([], [undefined], identity);
15270 assert.deepEqual(actual, [undefined]);
15286 var actual = _.mergeWith({ 'a': { 'b': [0, 1] } }, { 'a': { 'b': [2] } }, function(a, b) {
15290 assert.deepEqual(actual, { 'a': { 'b': [0, 1, 2] } });
15296 var actual = [];
15299 actual.push(_.last(arguments));
15302 assert.strictEqual(actual.length, 3);
15303 _.each(actual, function(a) {
15314 var actual = _.mergeWith({ 'a': 0 }, { 'a': { 'b': ['c'] } }, function(a, b) {
15318 assert.deepEqual(actual, { 'a': { 'b': ['c'] } });
15328 var actual = _.mergeWith(object, source, function(a, b) {
15332 assert.deepEqual(actual, { 'a': ['a', 'b', 'c'], 'b': ['b', 'c'] });
15386 var actual = lodashStable.map(paths, function(path) {
15391 assert.deepEqual(actual, expected);
15427 var actual = lodashStable.map(values, function(value, index) {
15431 assert.deepEqual(actual, expected);
15444 var actual = lodashStable.map(values, function(value, index) {
15448 assert.deepEqual(actual, expected);
15540 var actual = lodashStable.map(paths, function(path) {
15545 assert.deepEqual(actual, expected);
15579 var actual = lodashStable.map(values, function(value, index) {
15584 assert.deepEqual(actual, expected);
15595 var actual = lodashStable.map(values, function(value, index) {
15600 assert.deepEqual(actual, expected);
15660 var actual = lodashStable.map(values, function(value, index) {
15666 assert.deepEqual(actual, expected);
15704 var actual = _([40])[methodName]();
15705 assert.strictEqual(actual, 40);
15721 var actual = func(array, function(n) {
15725 assert.strictEqual(actual, isMax ? 1 : 3);
15732 actual = func(objects, 'a');
15734 assert.deepEqual(actual, objects[isMax ? 1 : 2]);
15737 actual = func(arrays, 0);
15739 assert.deepEqual(actual, arrays[isMax ? 1 : 2]);
15748 var actual = func([object, { 'a': value }], function(object) {
15752 assert.strictEqual(actual, object);
15852 actual = wrapped.a();
15854 assert.strictEqual(actual.value(), 'a');
15855 assert.ok(actual instanceof Wrapper);
15897 actual = wrapped.a();
15900 assert.strictEqual(actual.value(), 'a', message(func, true));
15901 assert.ok(actual instanceof func, message(func, true));
15903 assert.strictEqual(actual, 'a', message(func, false));
15904 assert.notOk(actual instanceof func, message(func, false));
15954 actual = wrapped.mixin();
15956 assert.strictEqual(actual.value(), _);
15960 actual = wrapped.mixin(source);
15961 assert.notStrictEqual(actual, wrapped);
15978 actual = _(array).a().map(square).b(isEven).take().value();
15980 assert.deepEqual(actual, _.take(_.b(_.map(_.a(array), square), isEven)));
16026 var actual = _.orderBy(objects, 'a', 'desc');
16027 assert.deepEqual(actual, [objects[1], objects[3], objects[0], objects[2]]);
16033 var actual = _.orderBy(objects, ['a', 'b'], ['desc', 'asc']);
16034 assert.deepEqual(actual, [objects[3], objects[1], objects[2], objects[0]]);
16041 actual = _.orderBy(objects, ['a', 'b']);
16043 assert.deepEqual(actual, expected);
16047 actual = lodashStable.map(falsey, function(order, index) {
16051 assert.deepEqual(actual, expected);
16057 var actual = _.orderBy(objects, ['a'], [Object('desc')]);
16058 assert.deepEqual(actual, [objects[1], objects[3], objects[0], objects[2]]);
16200 var actual = lodashStable.times(count, function(index) {
16211 assert.deepEqual(actual, expected);
16279 actual = _.now();
16281 assert.ok(actual >= stamp);
16284 assert.ok(_.now() > actual);
16295 var actual = _.now();
16298 assert.strictEqual(actual, 'a');
16312 var actual = lodashStable.map(array, function(value, index) {
16316 assert.deepEqual(actual, array);
16322 var actual = lodashStable.map(lodashStable.range(1, array.length + 1), function(n) {
16326 assert.deepEqual(actual, ['d', 'c', 'b', 'a']);
16335 var actual = lodashStable.map(values, function(n) {
16339 assert.deepEqual(actual, expected);
16344 actual = lodashStable.map(values, function(n) {
16348 assert.deepEqual(actual, expected);
16357 var actual = lodashStable.map(values, function(array) {
16361 assert.deepEqual(actual, expected);
16373 var actual = lodashStable.map(values, function(n) {
16377 assert.deepEqual(actual, expected);
16391 var actual = lodashStable.map(args, function(value, index) {
16396 assert.deepEqual(actual, args);
16402 var actual = lodashStable.map(lodashStable.range(1, args.length + 1), function(n) {
16407 assert.deepEqual(actual, ['d', 'c', 'b', 'a']);
16416 var actual = lodashStable.map(values, function(n) {
16421 assert.deepEqual(actual, expected);
16426 actual = lodashStable.map(values, function(n) {
16431 assert.deepEqual(actual, expected);
16447 var actual = lodashStable.map(values, function(n) {
16452 assert.deepEqual(actual, expected);
16482 actual = _.omit(object, [['a.b']]);
16484 assert.deepEqual(actual, { 'a': { 'b': 2 } });
16508 var actual = _.omit(value, 'valueOf');
16510 assert.deepEqual(actual, {});
16553 var actual = _.omitBy(object, function(n) {
16557 assert.deepEqual(actual, { 'b': 2, 'd': 4 });
16605 var actual = lodashStable.map(props, function(key) {
16609 assert.deepEqual(actual, expected);
16633 actual = func(foo, resolve(foo, 'a'));
16635 assert.strictEqual(actual[symbol], 1);
16636 assert.strictEqual(actual[symbol2], 2);
16637 assert.notOk(symbol3 in actual);
16665 actual = func(foo, resolve(foo, symbol));
16667 assert.strictEqual(actual.a, 0);
16668 assert.notOk(symbol in actual);
16669 assert.strictEqual(actual[symbol2], 2);
16670 assert.notOk(symbol3 in actual);
16672 actual = func(foo, resolve(foo, symbol2));
16674 assert.strictEqual(actual.a, 0);
16675 assert.strictEqual(actual[symbol], 1);
16676 assert.notOk(symbol2 in actual);
16677 assert.notOk(symbol3 in actual);
17054 var actual = lodashStable.map(values, function(value, index) {
17058 assert.deepEqual(actual, expected);
17074 var actual = lodashStable.map(values, function(value) {
17078 assert.deepEqual(actual, expected);
17095 var actual = lodashStable.map(values, function(value, index) {
17099 assert.deepEqual(actual, expected);
17114 var actual = lodashStable.map(values, function(value) {
17118 assert.deepEqual(actual, expected);
17135 var actual = lodashStable.map(values, function(value, index) {
17139 assert.deepEqual(actual, expected);
17154 var actual = lodashStable.map(values, function(value) {
17158 assert.deepEqual(actual, expected);
17191 var actual = length ? (isStart ? ' abc' : 'abc ') : string;
17192 assert.strictEqual(func(string, length), actual);
17213 var actual = lodashStable.map(values, function(value) {
17217 assert.deepEqual(actual, expected);
17231 var actual = lodashStable.map(expected, function(radix) {
17235 assert.deepEqual(actual, expected);
17271 var actual = [],
17277 actual.push(
17284 actual.push(
17290 assert.deepEqual(actual, expected);
17310 actual = lodashStable.map(strings, _.parseInt);
17312 assert.deepEqual(actual, [6, 8, 10]);
17314 actual = lodashStable.map('123', _.parseInt);
17315 assert.deepEqual(actual, [1, 2, 3]);
17623 var actual = _.last(lodashStable.times(HOT_COUNT, function() {
17628 assert.deepEqual(actual, expected);
17630 actual = _.last(lodashStable.times(HOT_COUNT, function() {
17637 assert.deepEqual(actual, expected);
17645 var actual = _.last(lodashStable.times(HOT_COUNT, function() {
17649 assert.deepEqual(actual, expected);
17651 actual = _.last(lodashStable.times(HOT_COUNT, function() {
17656 assert.deepEqual(actual, expected);
17665 var actual = _.last(lodashStable.times(HOT_COUNT, function() {
17670 assert.deepEqual(actual, expected);
17672 actual = _.last(lodashStable.times(HOT_COUNT, function() {
17679 assert.deepEqual(actual, expected);
17705 var actual = lodashStable.map(values, function(value, index) {
17709 assert.deepEqual(actual, expected);
17716 actual = _.partition(objects, 'a');
17718 assert.deepEqual(actual, [objects.slice(0, 2), objects.slice(2)]);
17737 var actual = _.partition({ 'a': 1.1, 'b': 0.2, 'c': 1.3 }, Math.floor);
17738 assert.deepEqual(actual, [[1.1, 1.3], [0.2]]);
17768 actual = _.pick(object, [['a.b']]);
17770 assert.deepEqual(actual, { 'a.b': 1 });
17820 var actual = _.pickBy(object, function(n) {
17824 assert.deepEqual(actual, { 'a': 1, 'c': 3 });
17831 actual = _.pickBy(object, stubTrue);
17833 assert.deepEqual(actual, { 'a.b.c': 1 });
17883 var actual = lodashStable.map(props, function(key) {
17887 assert.deepEqual(actual, expected);
17910 actual = func(foo, resolve(foo, [symbol, symbol2, symbol3]));
17912 assert.strictEqual(actual[symbol], 1);
17913 assert.strictEqual(actual[symbol2], 2);
17916 assert.strictEqual(actual[symbol3], 3);
17918 assert.notOk(symbol3 in actual);
17991 var actual = lodashStable.map(props, function(key) {
17996 assert.deepEqual(actual, ['a', 'a', 'b', 'b']);
18010 var actual = lodashStable.map(paths, function(path) {
18015 assert.deepEqual(actual, expected);
18039 var actual = lodashStable.map(values, function(value, index) {
18043 assert.deepEqual(actual, expected);
18056 var actual = lodashStable.map(values, function(value, index) {
18060 assert.deepEqual(actual, expected);
18136 var actual = lodashStable.map(props, function(key) {
18141 assert.deepEqual(actual, ['a', 'a', 'b', 'b']);
18155 var actual = lodashStable.map(paths, function(path) {
18160 assert.deepEqual(actual, expected);
18182 var actual = lodashStable.map(values, function(value, index) {
18187 assert.deepEqual(actual, expected);
18198 var actual = lodashStable.map(values, function(value, index) {
18203 assert.deepEqual(actual, expected);
18227 actual = _.pullAll(array, array);
18229 assert.deepEqual(actual, []);
18243 var actual = _.pullAllBy(array, [{ 'x': 1 }, { 'x': 3 }], function(object) {
18247 assert.deepEqual(actual, [{ 'x': 2 }]);
18274 actual = _.pullAllWith(objects, [{ 'x': 2, 'y': 2 }], lodashStable.isEqual);
18276 assert.deepEqual(actual, expected);
18298 actual = pull(array, [1, 3]);
18300 assert.strictEqual(actual, array);
18345 actual = _.pullAt(array, [0, 1]);
18348 assert.deepEqual(actual, [1, 2]);
18355 actual = _.pullAt(array, [1, 3, 11, 7, 5, 9]);
18358 assert.deepEqual(actual, [2, 4, 12, 8, 6, 10]);
18365 actual = _.pullAt(array, [0, 2, 0, 1, 0, 2]);
18368 assert.deepEqual(actual, [1, 3, 1, 2, 1, 3]);
18375 actual = _.pullAt(array, [2, 4, 0]);
18378 assert.deepEqual(actual, ['c', undefined, 'a']);
18397 actual = _.pullAt(array);
18400 assert.deepEqual(actual, []);
18402 actual = _.pullAt(array, [], []);
18405 assert.deepEqual(actual, []);
18420 actual = _.pullAt(array, values);
18422 assert.deepEqual(actual, expected);
18425 actual = lodashStable.at(array, values);
18427 assert.deepEqual(actual, expected);
18435 var actual = lodashStable.map(props, function(key) {
18441 assert.deepEqual(actual, [[-2], [-2], [-1], [-1]]);
18450 var actual = _.pullAt(array, 'a.b');
18452 assert.deepEqual(actual, [2]);
18456 actual = _.pullAt(array, 'a.b.c');
18459 assert.deepEqual(actual, [undefined]);
18468 var actual = lodashStable.map(values, function(array) {
18474 assert.deepEqual(actual, expected);
18488 var actual = lodashStable.uniq(lodashStable.map(array, function() {
18492 assert.deepEqual(actual, [0, 1]);
18526 var actual = lodashStable.uniq(lodashStable.map(array, function() {
18530 assert.deepEqual(actual, expected);
18552 var actual = [
18558 assert.deepEqual(actual, [0, 1, MAX_INTEGER]);
18566 actual = _.random(min, max);
18568 assert.ok(actual % 1);
18569 assert.ok(actual >= min && actual <= max);
18575 var actual = _.random(true);
18576 assert.ok(actual % 1 && actual >= 0 && actual <= 1);
18578 actual = _.random(2, true);
18579 assert.ok(actual % 1 && actual >= 0 && actual <= 2);
18581 actual = _.random(2, 4, true);
18582 assert.ok(actual % 1 && actual >= 2 && actual <= 4);
18592 var actual = lodashStable.map(randoms, function(result, index) {
18596 assert.deepEqual(actual, expected);
18656 var actual = func(-0, 1);
18657 assert.strictEqual(1 / actual[0], -Infinity);
18676 var actual = [
18684 assert.deepEqual(actual, [[0], [0], [0], [], []]);
18695 var actual = lodashStable.map(collection, func);
18696 assert.deepEqual(actual, expected);
18740 var actual = lodashStable.map(values, function(value) {
18745 assert.deepEqual(actual, expected);
18925 var actual = func(['a', 'b', 'c'], function(accumulator, value) {
18929 assert.strictEqual(actual, isReduce ? 'abc' : 'cba');
18935 var actual = [],
18940 actual.push(func(value, noop));
18944 assert.deepEqual(actual, expected);
18952 var actual = lodashStable.map(empties, function(value) {
18958 assert.deepEqual(actual, expected);
18964 var actual = func([], noop, undefined);
18965 assert.strictEqual(actual, undefined);
19034 var actual = func([0], function(value, index, array) {
19039 assert.deepEqual(actual, [0]);
19060 var actual = wrapped[methodName](function(n) {
19064 assert.deepEqual(actual.value(), isFilter ? [1, 2] : [3, 4]);
19066 actual = wrapped[methodName](function(n) {
19070 assert.deepEqual(actual.value(), isFilter ? [3, 4] : [1, 2]);
19088 var actual = _(array).slice(1).map(square)[methodName](predicate).value();
19089 … assert.deepEqual(actual, _[methodName](lodashStable.map(array.slice(1), square), predicate));
19091 actual = _(object).mapValues(square)[methodName](predicate).value();
19092 assert.deepEqual(actual, _[methodName](lodashStable.mapValues(object, square), predicate));
19156 actual = _.remove(array, isEven);
19159 assert.deepEqual(actual, [2, 4]);
19265 var actual = lodashStable.map(falsey, function(n, index) {
19269 assert.deepEqual(actual, expected);
19297 var actual = lodashStable.map(['a', 'b', 'c'], _.repeat);
19298 assert.deepEqual(actual, ['a', 'b', 'c']);
19332 var actual = _.result(object, 'c', object.b);
19333 assert.strictEqual(actual, 'b');
19380 var actual = lodashStable.map(props, function(key) {
19384 assert.deepEqual(actual, ['a', 'a', 'b', 'b']);
19476 var actual = lodashStable.map(values, function(value) {
19480 assert.deepEqual(actual, expected);
19524 var actual = lodashStable.map(values, function(value) {
19528 assert.deepEqual(actual, expected);
19568 var actual = lodashStable.map(values, function(value) {
19573 assert.deepEqual(actual, expected);
19613 actual = _.reverse(array);
19615 assert.strictEqual(actual, array);
19627 actual = wrapped.value();
19630 assert.strictEqual(actual, array);
19631 assert.deepEqual(actual, clone.slice().reverse());
19646 actual = _(array).slice(1).reverse().value();
19648 assert.deepEqual(actual, expected.slice(1).reverse());
19672 actual = wrapped.last();
19676 assert.strictEqual(actual, '1');
19694 actual = _(array)[methodName](identity).thru(_.compact).reverse().value();
19696 assert.deepEqual(actual, expected);
19699 … actual = _(array).thru(_.compact)[methodName](identity).pull(1).push(3).reverse().value();
19701 assert.deepEqual(actual, [3].concat(expected.slice(0, -1)));
19742 var actual = func(4.006);
19743 assert.strictEqual(actual, isCeil ? 5 : 4);
19749 var actual = func(4.006, 0);
19750 assert.strictEqual(actual, isCeil ? 5 : 4);
19756 var actual = func(4.016, 2);
19757 assert.strictEqual(actual, isFloor ? 4.01 : 4.02);
19759 actual = func(4.1, 2);
19760 assert.strictEqual(actual, 4.1);
19766 var actual = func(4160, -2);
19767 assert.strictEqual(actual, isFloor ? 4100 : 4200);
19773 var actual = func(4.006, NaN);
19774 assert.strictEqual(actual, isCeil ? 5 : 4);
19778 actual = func(4.016, 2.6);
19779 assert.strictEqual(actual, expected);
19781 actual = func(4.016, '+2');
19782 assert.strictEqual(actual, expected);
19788 var actual = func(5e1, 2);
19789 assert.deepEqual(actual, 50);
19791 actual = func('5e', 1);
19792 assert.deepEqual(actual, NaN);
19794 actual = func('5e1e1', 1);
19795 assert.deepEqual(actual, NaN);
19804 var actual = lodashStable.map(values, function(args) {
19808 assert.deepEqual(actual, expected);
19820 actual = lodashStable.map(results, lodashStable.isNaN);
19822 assert.deepEqual(actual, expected);
19828 var actual = func(Infinity);
19829 assert.strictEqual(actual, Infinity);
19831 actual = func(Infinity, 0);
19832 assert.strictEqual(actual, Infinity);
19834 actual = func(Infinity, 2);
19835 assert.strictEqual(actual, Infinity);
19837 actual = func(Infinity, -2);
19838 assert.strictEqual(actual, Infinity);
19840 actual = func(Infinity, 2);
19841 assert.strictEqual(actual, isFloor ? Infinity : Infinity);
19843 actual = func(Infinity, 2);
19844 assert.strictEqual(actual, isCeil ? Infinity : Infinity);
19850 var actual = func(-Infinity);
19851 assert.strictEqual(actual, -Infinity);
19853 actual = func(-Infinity, 0);
19854 assert.strictEqual(actual, -Infinity);
19856 actual = func(-Infinity, 2);
19857 assert.strictEqual(actual, -Infinity);
19859 actual = func(-Infinity, -2);
19860 assert.strictEqual(actual, -Infinity);
19862 actual = func(-Infinity, 2);
19863 assert.strictEqual(actual, isFloor ? -Infinity : -Infinity);
19865 actual = func(-Infinity, 2);
19866 assert.strictEqual(actual, isCeil ? -Infinity : -Infinity);
19872 var actual = func(NaN);
19873 assert.deepEqual(actual, NaN);
19875 actual = func(NaN, 0);
19876 assert.deepEqual(actual, NaN);
19878 actual = func(NaN, 2);
19879 assert.deepEqual(actual, NaN);
19881 actual = func(NaN, -2);
19882 assert.deepEqual(actual, NaN);
19884 actual = func(NaN, 2);
19885 assert.deepEqual(actual, isFloor ? NaN : NaN);
19887 actual = func(NaN, 2);
19888 assert.deepEqual(actual, isCeil ? NaN : NaN);
19945 var actual = _.sample(array);
19946 assert.ok(lodashStable.includes(array, actual));
19954 var actual = lodashStable.transform(empties, function(result, value) {
19960 assert.deepEqual(actual, expected);
19967 actual = _.sample(object);
19969 assert.ok(lodashStable.includes(array, actual));
19983 var actual = _.sampleSize(array, 2);
19985 assert.strictEqual(actual.length, 2);
19986 assert.deepEqual(lodashStable.difference(actual, array), []);
19992 var actual = _.sampleSize(array, array.length).sort();
19994 assert.deepEqual(actual, array);
20004 var actual = lodashStable.map(falsey, function(size, index) {
20008 assert.deepEqual(actual, expected);
20023 var actual = _.sampleSize(array, n).sort();
20024 assert.deepEqual(actual, array);
20031 var actual = _.sampleSize(array, 1.6);
20032 assert.strictEqual(actual.length, 1);
20040 var actual = lodashStable.transform(empties, function(result, value) {
20046 assert.deepEqual(actual, expected);
20053 actual = _.sampleSize(object, 2);
20055 assert.strictEqual(actual.length, 2);
20056 assert.deepEqual(lodashStable.difference(actual, lodashStable.values(object)), []);
20062 var actual = lodashStable.map([['a']], _.sampleSize);
20063 assert.deepEqual(actual, [['a']]);
20075 var actual = _.setWith({ '0': {} }, '[0][1][2]', 3, function(value) {
20079 assert.deepEqual(actual, { '0': { '1': { '2': 3 } } });
20085 var actual = _.setWith({}, 'a[0].b.c', 4, noop);
20086 assert.deepEqual(actual, { 'a': [{ 'b': { 'c': 4 } }] });
20107 actual = func(object, path, updater);
20109 assert.strictEqual(actual, object);
20120 var actual = lodashStable.map(props, function(key) {
20126 assert.deepEqual(actual, expected);
20149 actual = func(object, path, updater);
20151 assert.strictEqual(actual, object);
20161 actual = func(object, path, updater);
20163 assert.strictEqual(actual, object);
20223 var actual = func(object, path, updater);
20225 assert.strictEqual(actual, object);
20226 assert.deepEqual(actual, { 'a': [undefined, { 'b': { 'c': value } }] });
20239 var actual = lodashStable.map(values, function(value) {
20247 assert.deepEqual(actual, expected);
20315 var actual = lodashStable.times(1000, function(assert) {
20319 … assert.deepEqual(lodashStable.sortBy(lodashStable.uniqBy(actual, String), '0'), [[1, 2], [2, 1]]);
20353 var actual = lodashStable.map(falsey, function(object, index) {
20359 assert.deepEqual(actual, expected);
20440 var actual = _.slice(array);
20441 assert.deepEqual(actual, array);
20442 assert.notStrictEqual(actual, array);
20465 var actual = lodashStable.map(falsey, function(start) {
20469 assert.deepEqual(actual, expected);
20515 var actual = lodashStable.map(falsey, function(end, index) {
20519 assert.deepEqual(actual, expected);
20541 var actual = lodashStable.map(positions, function(pos) {
20545 assert.deepEqual(actual, [[1], [1], [1], [2, 3], [1], []]);
20552 actual = lodashStable.map(array, _.slice);
20554 assert.deepEqual(actual, array);
20555 assert.notStrictEqual(actual, array);
20615 var actual = lodashStable.map(empties, function(value) {
20621 assert.deepEqual(actual, expected);
20650 var actual = lodashStable.map(values, function(value, index) {
20655 assert.deepEqual(actual, expected);
20658 actual = lodashStable.map(values, function(value, index) {
20663 assert.deepEqual(actual, expected);
20685 var actual = lodashStable.map([[1]], _.some);
20686 assert.deepEqual(actual, [true]);
20705 var actual = lodashStable.map(_.sortBy(objects, function(object) {
20709 assert.deepEqual(actual, [1, 2, 3, 4]);
20719 var actual = lodashStable.map(values, function(value, index) {
20723 assert.deepEqual(actual, expected);
20729 var actual = lodashStable.map(_.sortBy(objects.concat(undefined), 'b'), 'b');
20730 assert.deepEqual(actual, [1, 2, 3, 4, undefined]);
20736 var actual = _.sortBy({ 'a': 1, 'b': 2, 'c': 3 }, Math.sin);
20737 assert.deepEqual(actual, [3, 1, 2]);
20765 var actual = _.sortBy(objects, function(object) {
20771 assert.deepEqual(actual, [objects[0], objects[2], objects[1], objects[3]]);
20777 var actual = lodashStable.map([[2, 1, 3], [3, 2, 1]], _.sortBy);
20778 assert.deepEqual(actual, [[1, 2, 3], [1, 2, 3]]);
20820 var actual = func(objects, ['a', 'b']);
20821 assert.deepEqual(actual, [objects[2], objects[0], objects[3], objects[1]]);
20827 var actual = func(objects, ['a', function(object) { return object.b; }]);
20828 assert.deepEqual(actual, [objects[2], objects[0], objects[3], objects[1]]);
20835 var actual = func(value, ['a', 'c']);
20836 assert.deepEqual(actual, stableArray, index ? 'object' : 'array');
20844 var actual = func(objects.concat(null, undefined), ['a', 'b']);
20847 assert.deepEqual(actual, [objects[2], objects[0], objects[3], objects[1], null, undefined]);
20869 var actual = lodashStable.map(funcs, function(func) {
20873 assert.deepEqual(actual, expected);
20893 var actual = lodashStable.map(values, function(value) {
20897 assert.deepEqual(actual, expected);
20907 var actual = lodashStable.map(values, function(value) {
20911 assert.deepEqual(actual, expected);
20920 var actual = lodashStable.map(values, function(array) {
20924 assert.deepEqual(actual, expected);
20996 actual = func(objects, { 'x': 40 }, 'x');
20998 assert.strictEqual(actual, 1);
21013 var actual = func(array, value, function(value) {
21023 assert.strictEqual(actual, expected);
21081 var actual = lodashStable.map(values, function(value, index) {
21085 assert.deepEqual(actual, expected);
21092 actual = lodashStable.map(strings, _.split);
21094 assert.deepEqual(actual, [['abc'], ['def'], ['ghi']]);
21135 var actual = lodashStable.map(falsey, function(array, index) {
21141 assert.deepEqual(actual, expected);
21160 var actual = lodashStable.map(values, function(value) {
21165 assert.deepEqual(actual, expected);
21231 var actual = lodashStable.map(falsey, function(position) {
21235 assert.deepEqual(actual, expected);
21321 var actual = lodashStable.map(values, function(value, index) {
21328 assert.deepEqual(actual, expected);
21382 var actual = lodashStable.map(values, function(value) {
21387 assert.deepEqual(actual, expected);
21414 var actual = _(1)[methodName](2);
21415 assert.notOk(actual instanceof _);
21426 var actual = _(1).chain()[methodName](2);
21427 assert.ok(actual instanceof _);
21446 var actual = _.sumBy(objects, function(object) {
21450 assert.deepEqual(actual, 6);
21493 var actual = lodashStable.map(empties, function(value) {
21497 assert.deepEqual(actual, expected);
21531 var actual = lodashStable.map(falsey, function(array, index) {
21537 assert.deepEqual(actual, expected);
21556 actual = lodashStable.map(array, _.tail);
21558 assert.deepEqual(actual, [[2, 3], [5, 6], [8, 9]]);
21568 var actual = _(array).tail().filter(function(value) {
21574 assert.deepEqual(actual, []);
21579 actual = _(array).filter(function(value) {
21586 assert.deepEqual(actual, _.tail(_.filter(array, isEven)));
21601 actual = _(array).slice(0, 1).tail().map(iteratee).value();
21604 assert.deepEqual(actual, []);
21607 actual = _(array).filter().slice(0, 1).tail().map(iteratee).value();
21610 assert.deepEqual(actual, []);
21638 var actual = lodashStable.map(falsey, function(n) {
21642 assert.deepEqual(actual, expected);
21665 actual = lodashStable.map(array, _.take);
21667 assert.deepEqual(actual, [[1], [4], [7]]);
21677 actual = _(array).take(2).take().value();
21679 assert.deepEqual(actual, _.take(_.take(array, 2)));
21681 actual = _(array).filter(predicate).take(2).take().value();
21683 assert.deepEqual(actual, _.take(_.take(_.filter(array, predicate), 2)));
21685 actual = _(array).take(6).takeRight(4).take(2).takeRight().value();
21686 assert.deepEqual(actual, _.takeRight(_.take(_.takeRight(_.take(array, 6), 4), 2)));
21690 …actual = _(array).take(array.length - 1).filter(predicate).take(6).takeRight(4).take(2).takeRight(…
21692 …assert.deepEqual(actual, _.takeRight(_.take(_.takeRight(_.take(_.filter(_.take(array, array.length…
21720 var actual = lodashStable.map(falsey, function(n) {
21724 assert.deepEqual(actual, expected);
21747 actual = lodashStable.map(array, _.takeRight);
21749 assert.deepEqual(actual, [[3], [6], [9]]);
21759 actual = _(array).takeRight(2).takeRight().value();
21761 assert.deepEqual(actual, _.takeRight(_.takeRight(array)));
21763 actual = _(array).filter(predicate).takeRight(2).takeRight().value();
21765 assert.deepEqual(actual, _.takeRight(_.takeRight(_.filter(array, predicate), 2)));
21767 actual = _(array).takeRight(6).take(4).takeRight(2).take().value();
21768 assert.deepEqual(actual, _.take(_.takeRight(_.take(_.takeRight(array, 6), 4), 2)));
21772 actual = _(array).filter(predicate).takeRight(6).take(4).takeRight(2).take().value();
21774 …assert.deepEqual(actual, _.take(_.takeRight(_.take(_.takeRight(_.filter(array, predicate), 6), 4),…
21798 var actual = _.takeRightWhile(array, function(n) {
21802 assert.deepEqual(actual, [3, 4]);
21918 var actual = _.takeWhile(array, function(n) {
21922 assert.deepEqual(actual, [1, 2]);
21978 var actual = _(array)
21984 assert.deepEqual(actual, [0]);
22047 var actual = _.tap(array, function(value) {
22051 assert.strictEqual(actual, array);
22094 var actual = lodashStable.map(strings, function(string) {
22098 assert.deepEqual(actual, expected);
22119 actual = compiled(data);
22121 assert.strictEqual(actual, '<ul><li>A</li><li>B</li></ul>');
22149 var actual = lodashStable.map(strings, function(string) {
22153 assert.deepEqual(actual, expected);
22180 var actual = compiled();
22183 assert.strictEqual(actual, 'function');
22300 actual = compiled({ 'index': 1, 'collection': ['a', 'b', 'c'] });
22302 assert.strictEqual(actual, '1b012');
22449 var actual = [],
22451 data = { 'func': function(value) { actual.push(value); } };
22454 assert.deepEqual(actual, ['a', 'b', 'c']);
22487 var actual = lodashStable.map(values, function(value, index) {
22492 assert.deepEqual(actual, expected);
22560 var actual = lodashStable.map(values, function(value) {
22564 assert.deepEqual(actual, expected);
22592 var actual = lodashStable.map(values, function(value) {
22596 assert.deepEqual(actual, expected);
22606 var actual = lodashStable.map(compiles, function(compiled) {
22610 assert.deepEqual(actual, ['one', '"two"', 'three']);
22679 var actual = index > 1 ? 'h...' : '...';
22680 …trictEqual(_.truncate(string, { 'length': { 'valueOf': lodashStable.constant(length) } }), actual);
22694 var actual = lodashStable.map([string, string, string], _.truncate),
22697 assert.deepEqual(actual, [truncated, truncated, truncated]);
22813 var actual = callCount > 1;
22815 assert.ok(actual);
23008 var actual = [],
23009 object = { 'funced': func(function() { actual.push(this); }, 32) },
23017 assert.deepEqual(actual, expected);
23027 var actual = [],
23035 actual.push(current);
23045 assert.deepEqual(actual, expected.slice(0, isDebounce ? 0 : 1));
23048 assert.deepEqual(actual, expected.slice(0, actual.length));
23187 var actual = _.times(2.6, _.identity);
23188 assert.deepEqual(actual, [0, 1]);
23209 var actual = lodashStable.map(values, function(value, index) {
23213 assert.deepEqual(actual, expected);
23228 var actual = lodashStable.map(values, function(value, index) {
23232 assert.deepEqual(actual, expected);
23315 var actual = _(array).slice(1).map(String).toArray().value();
23316 assert.deepEqual(actual, lodashStable.map(array.slice(1), String));
23318 actual = _(object).toArray().slice(1).map(String).value();
23319 assert.deepEqual(actual, _.map(_.toArray(object).slice(1), String));
23369 var actual = func(sparse);
23371 assert.ok('0' in actual);
23372 assert.ok('2' in actual);
23373 assert.deepEqual(actual, sparse);
23387 var actual = func(array);
23388 assert.deepEqual(actual, array);
23389 assert.notStrictEqual(actual, array);
23397 var actual = func(document.getElementsByTagName('body'));
23400 assert.deepEqual(actual, [body]);
23481 var actual = lodashStable.map(others, function(value) {
23486 assert.deepEqual(actual, expected);
23519 var actual = lodashStable.map(values, func);
23521 assert.deepEqual(actual, expected);
23548 var actual = lodashStable.map(values, function(value) {
23552 assert.deepEqual(actual, expected);
23587 var actual = lodashStable.map(values, function(value) {
23593 assert.deepEqual(actual, expected);
23607 var actual = lodashStable.map(values, function(value) {
23614 assert.deepEqual(actual, expected);
23627 var actual = lodashStable.map(values, function(value) {
23633 assert.deepEqual(actual, expected);
23646 var actual = lodashStable.map(values, func);
23648 assert.deepEqual(actual, expected);
23664 var actual = lodashStable.map(values, function(value, index) {
23668 assert.deepEqual(actual, expected);
23717 var actual = lodashStable.map(values, func);
23719 assert.deepEqual(actual, expected);
23759 actual = lodashStable.sortBy(func(object), 0);
23761 assert.deepEqual(actual, [['a', 1], ['b', 2]]);
23773 actual = lodashStable.sortBy(func(new Foo), 0);
23775 assert.deepEqual(actual, expected);
23782 actual = lodashStable.sortBy(func(object), 0);
23784 assert.deepEqual(actual, [['0', 'a'], ['1', 'b'], ['length', 2]]);
23819 var actual = lodashStable.sortBy(func(string), 0);
23820 assert.deepEqual(actual, [['0', 'x'], ['1', 'o']]);
23843 var actual = _.toPath(value);
23844 assert.deepEqual(actual, array);
23845 assert.notStrictEqual(actual, array);
23861 var actual = _.toPath(value);
23862 assert.ok(lodashStable.isSymbol(actual[0]));
23873 var actual = _.toPath('a[-1.23]["[\\"b\\"]"].c[\'[\\\'d\\\']\'][\ne\n][f].g');
23874 assert.deepEqual(actual, ['a', '-1.23', '["b"]', 'c', "['d']", '\ne\n', 'f', 'g']);
23919 var actual = lodashStable.assign({ 'a': 1 }, _.toPlainObject(new Foo));
23920 assert.deepEqual(actual, { 'a': 1, 'b': 2, 'c': 3 });
23926 var actual = _.toPlainObject(args),
23929 assert.deepEqual(actual, expected);
23935 var actual = _.toPlainObject(['a', 'b', 'c']),
23938 assert.deepEqual(actual, expected);
23953 var actual = lodashStable.map(values, function(value, index) {
23957 assert.deepEqual(actual, expected);
23965 actual = lodashStable.map(values, _.toString);
23967 assert.deepEqual(actual, expected);
24048 var actual = lodashStable.map(results, function(result) {
24052 assert.deepEqual(actual, expected);
24055 actual = lodashStable.map(results, lodashStable.toPlainObject);
24057 assert.deepEqual(actual, expected);
24060 actual = lodashStable.map(accumulators, mapper);
24062 assert.deepEqual(actual, expected);
24066 actual = lodashStable.map(accumulators, mapper);
24068 assert.deepEqual(actual, expected);
24076 var actual = lodashStable.map(typedArrays, function(type) {
24083 assert.deepEqual(actual, expected);
24092 var actual = lodashStable.map(values, function(value) {
24098 assert.deepEqual(actual, expected);
24103 actual = lodashStable.map(values, function(value) {
24109 assert.deepEqual(actual, expected);
24112 var actual = lodashStable.map(values, function(value) {
24116 assert.ok(lodashStable.every(actual, function(result) {
24127 var actual = _.transform(Array(1), function(result, value, index) {
24131 assert.deepEqual(actual, ['undefined']);
24155 var actual = lodashStable.map(results, function(value, index) {
24159 assert.deepEqual(actual, expected);
24175 var actual = lodashStable.map(falsey, function(object, index) {
24179 assert.deepEqual(actual, expected);
24216 var actual = lodashStable.map(objects, function(object) {
24229 assert.deepEqual(actual, expected);
24311 actual = lodashStable.map([string, string, string], func);
24313 assert.deepEqual(actual, [trimmed, trimmed, trimmed]);
24408 actual = _.truncate(string, options);
24410 assert.strictEqual(actual, 'A...');
24411 assert.strictEqual(actual.length, 4);
24413 actual = _.truncate(allHearts, options);
24414 assert.strictEqual(actual, hearts + '...');
24415 assert.strictEqual(actual.length, 5);
24430 var actual = lodashStable.map(values, function(value) {
24434 assert.deepEqual(actual, expected);
24448 var actual = lodashStable.map(values, function(value) {
24452 assert.deepEqual(actual, expected);
24490 var actual = lodashStable.map(values, function(value) {
24494 assert.deepEqual(actual, expected);
24528 var actual = lodashStable.map(['6', '8', '10'], _.unary(parseInt));
24529 assert.deepEqual(actual, [6, 8, 10]);
24603 var actual = func([2], [1, 2]);
24604 assert.deepEqual(actual, [2, 1]);
24610 var actual = func([2], [1, 2], [2, 3]);
24611 assert.deepEqual(actual, [2, 1, 3]);
24617 var actual = func([1, 3, 2], [1, [5]], [2, [4]]);
24618 assert.deepEqual(actual, [1, 3, 2, [5], [4]]);
24639 var actual = _.unionBy([2.1], [1.2, 2.3], Math.floor);
24640 assert.deepEqual(actual, [2.1, 1.2]);
24642 actual = _.unionBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x');
24643 assert.deepEqual(actual, [{ 'x': 1 }, { 'x': 2 }]);
24661 var actual = _.unionBy([{ 'x': 1, 'y': 1 }], [{ 'x': 1, 'y': 2 }], 'x');
24662 assert.deepEqual(actual, [{ 'x': 1, 'y': 1 }]);
24676 actual = _.unionWith(objects, others, lodashStable.isEqual);
24678 assert.deepEqual(actual, [objects[0], objects[1], others[0]]);
24687 var actual = _.unionWith(objects, others, function(a, b) {
24691 assert.deepEqual(actual, [{ 'x': 1, 'y': 1 }]);
24731 var actual = lodashStable.map(func([-0, 0]), lodashStable.toString);
24732 assert.deepEqual(actual, ['0']);
24764 var actual = lodashStable.map(func(largeArray), lodashStable.toString);
24765 assert.deepEqual(actual, ['0']);
24853 actual = lodashStable.map(array, lodashStable.uniq);
24855 assert.deepEqual(actual, [[2, 1], [1, 2]]);
24876 var actual = func(objects, function(object) {
24880 assert.deepEqual(actual, expected);
24890 var actual = func(largeArray, String);
24891 assert.strictEqual(actual[0], largeArray[0]);
24892 assert.deepEqual(actual, [[1, 2]]);
24911 actual = func(objects, 'a');
24913 assert.deepEqual(actual, expected);
24920 actual = func(arrays, 0);
24922 assert.deepEqual(actual, expected);
24935 var actual = func([['a'], ['a'], ['b']], iteratee);
24936 assert.deepEqual(actual, [['a'], ['b']]);
24950 actual = _.uniqWith(objects, lodashStable.isEqual);
24952 assert.deepEqual(actual, [objects[0], objects[1]]);
24965 var actual = lodashStable.map(arrays, function(array) {
24969 assert.deepEqual(actual, expected);
24981 var actual = lodashStable.times(1000, function(assert) {
24985 assert.strictEqual(lodashStable.uniq(actual).length, actual.length);
24997 var actual = [_.uniqueId(3), _.uniqueId(2), _.uniqueId(1)];
24998 assert.ok(/3\d+,2\d+,1\d+/.test(actual));
25023 var actual = lodashStable.map(props, function(key) {
25028 assert.deepEqual(actual, expected);
25089 var actual = lodashStable.map(values, function(value) {
25097 assert.deepEqual(actual, expected);
25109 var actual = _.unset(0, path);
25110 assert.strictEqual(actual, true);
25119 var actual = _.unset(object, path);
25120 assert.strictEqual(actual, true);
25157 var actual = _.unzipWith(array, function(a, b, c) {
25161 assert.deepEqual(actual, [6, 15]);
25183 var actual = lodashStable.map(values, function(value, index) {
25187 assert.deepEqual(actual, expected);
25199 var actual = _.updateWith({ '0': {} }, '[0][1][2]', stubThree, function(value) {
25203 assert.deepEqual(actual, { '0': { '1': { '2': 3 } } });
25209 var actual = _.updateWith({}, 'a[0].b.c', stubFour, noop);
25210 assert.deepEqual(actual, { 'a': [{ 'b': { 'c': 4 } }] });
25280 actual = func(object).sort();
25282 assert.deepEqual(actual, [1, 2]);
25289 actual = func(object).sort();
25291 assert.deepEqual(actual, [2, 'a', 'b']);
25303 actual = func(new Foo).sort();
25305 assert.deepEqual(actual, expected);
25314 var actual = lodashStable.map(values, function(value) {
25318 assert.deepEqual(actual, expected);
25330 var actual = _.without([2, 1, 2, 3], 1, 2);
25331 assert.deepEqual(actual, [3]);
25365 var actual = lodashStable.map(burredLetters, function(letter) {
25369 assert.deepEqual(actual, expected);
25411 var actual = lodashStable.map(postfixes, function(postfix) {
25423 assert.deepEqual(actual, expected);
25438 var actual = lodashStable.map(expected, function(words) {
25442 assert.deepEqual(actual, expected);
25451 actual = lodashStable.map(operators, _.words);
25453 assert.deepEqual(actual, expected);
25466 actual = lodashStable.map(marks, _.words);
25468 assert.deepEqual(actual, expected);
25475 actual = lodashStable.map(strings, _.words);
25477 assert.deepEqual(actual, [['a'], ['b'], ['c']]);
25531 var actual = lodashStable.map(values, function(value, index) {
25536 assert.deepEqual(actual, expected);
25561 var actual = func([2, 1], [2, 3]);
25562 assert.deepEqual(actual, [1, 3]);
25568 var actual = func([2, 1], [2, 3], [3, 4]);
25569 assert.deepEqual(actual, [1, 4]);
25571 actual = func([1, 2], [2, 1], [1, 2]);
25572 assert.deepEqual(actual, []);
25579 actual = func(array, array, array);
25581 assert.deepEqual(actual, []);
25587 var actual = func([1, 1, 2, 5], [2, 2, 3, 5], [3, 4, 5, 5]);
25588 assert.deepEqual(actual, [1, 4]);
25590 actual = func([1, 1]);
25591 assert.deepEqual(actual, [1]);
25636 var actual = lodashStable.map(['head', 'last'], function(methodName) {
25640 assert.deepEqual(actual, [1, LARGE_ARRAY_SIZE + 1]);
25656 var actual = _.xorBy([2.1, 1.2], [2.3, 3.4], Math.floor);
25657 assert.deepEqual(actual, [1.2, 3.4]);
25659 actual = _.xorBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x');
25660 assert.deepEqual(actual, [{ 'x': 2 }]);
25686 actual = _.xorWith(objects, others, lodashStable.isEqual);
25688 assert.deepEqual(actual, [objects[1], others[0]]);
25704 var actual = func(['barney', 'fred'], [36, 40]);
25705 assert.deepEqual(actual, object);
25735 actual = _(props)[methodName](values).map(square).filter(isEven).take().value();
25737 assert.deepEqual(actual, _.take(_.filter(_.map(func(props, values), square), isEven)));
25757 var actual = _.zipWith(array1, array2, array3, function(a, b, c) {
25761 assert.deepEqual(actual, [12, 15, 18]);
25763 var actual = _.zipWith(array1, [], function(a, b) {
25767 assert.deepEqual(actual, [1, 2, 3]);
25790 var actual = lodashStable.map(values, function(value, index) {
25794 assert.deepEqual(actual, expected);
25829 var actual = func(pair[0]);
25830 assert.deepEqual(actual, pair[1]);
25831 assert.deepEqual(func(actual), actual.length ? pair[0] : []);
25843 var actual = func(pair[0]);
25844 assert.ok('0' in actual[2]);
25845 assert.deepEqual(actual, pair[1]);
25847 actual = func(actual);
25848 assert.ok('2' in actual[0]);
25849 assert.deepEqual(actual, [['barney', 36, undefined], ['fred', 40, false]]);
25857 var actual = lodashStable.map(falsey, function(value) {
25861 assert.deepEqual(actual, expected);
26089 var actual = wrapped.value();
26090 assert.strictEqual(actual, array);
26091 assert.deepEqual(actual, []);
26104 var actual = lodashStable.map(falsey, function(value, index) {
26111 assert.deepEqual(actual, expected);
26130 actual = wrapped.value();
26132 assert.strictEqual(actual, array);
26133 assert.deepEqual(actual, [1, 2, 3]);
26146 var actual = lodashStable.map(falsey, function(value, index) {
26153 assert.deepEqual(actual, expected);
26177 var actual = wrapped.value();
26178 assert.strictEqual(actual, array);
26179 assert.deepEqual(actual, []);
26192 var actual = lodashStable.map(falsey, function(value, index) {
26199 assert.deepEqual(actual, expected);
26218 actual = wrapped.value();
26220 assert.strictEqual(actual, array);
26221 assert.deepEqual(actual, [1, 2, 3]);
26234 var actual = lodashStable.map(falsey, function(value, index) {
26241 assert.deepEqual(actual, expected);
26265 var actual = wrapped.value();
26266 assert.strictEqual(actual, array);
26267 assert.deepEqual(actual, []);
26280 var actual = lodashStable.map(falsey, function(value, index) {
26287 assert.deepEqual(actual, expected);
26306 actual = wrapped.value();
26308 assert.strictEqual(actual, array);
26309 assert.deepEqual(actual, [1, 2, 3]);
26322 var actual = lodashStable.map(falsey, function(value, index) {
26329 assert.deepEqual(actual, expected);
26416 actual = wrapped[methodName]();
26418 assert.ok(actual instanceof _);
26419 assert.notStrictEqual(actual, wrapped);
26470 actual = wrapped[methodName]();
26472 assert.ok(actual instanceof _);
26473 assert.notStrictEqual(actual, wrapped);
26588 var actual = _()[methodName]();
26589 assert.notOk(actual instanceof _);
26600 var actual = _().chain()[methodName]();
26601 assert.ok(actual instanceof _);
26723 var actual = lodashStable.map(values, function(value, index) {
26727 assert.deepEqual(actual, expected);
26833 var actual = lodashStable.map(falsey, function(value, index) {
26844 assert.deepEqual(actual, expected, '_.' + methodName + ' returns an array');
26863 var actual,
26868 actual = func(array, 'toFixed');
26871 actual = func(array, 1);
26874 actual = func(array);
26876 assert.ok(lodashStable.isArray(actual), '_.' + methodName + ' returns an array');
26879 …assert.strictEqual(actual === array, isPull, '_.' + methodName + ' should ' + (isPull ? '' : 'not …
26890 var actual = lodashStable.map(falsey, function(value, index) {
26902 assert.deepEqual(actual, expected, '`_.' + methodName + '` rejects falsey arguments');