Lines Matching refs:expected
940 expected = lodashStable.map(values, stubTrue);
946 assert.deepEqual(actual, expected);
958 expected = lodashStable.map(values, stubFalse);
964 assert.deepEqual(actual, expected);
1114 expected = lodashStable.map(values, stubTrue); variable
1124 assert.deepEqual(actual, expected);
1140 assert.deepEqual(actual, expected);
1159 assert.deepEqual(actual, expected);
1268 expected = [['a'], ['a'], []];
1275 assert.deepEqual(actual, expected);
1284 var expected = lodashStable.map(args, function(arg, index) {
1288 var actual = lodashStable.map(expected, function(array) {
1292 assert.deepEqual(actual, expected);
1366 var expected = { 'a': 1, 'b': 2, 'c': 3 }; class in AnonymousFunction0cd48b514800
1367 assert.deepEqual(func({ 'a': 1 }, { 'b': 2 }, { 'c': 3 }), expected);
1368 assert.deepEqual(func({ 'a': 1 }, { 'b': 2, 'c': 2 }, { 'c': 3 }), expected);
1374 var expected = { 'a': 3, 'b': 2, 'c': 1 }; class in AnonymousFunction0cd48b514900
1375 assert.deepEqual(func({ 'a': 1, 'b': 2 }, expected), expected);
1381 var expected = { 'a': null, 'b': undefined, 'c': null }; class in AnonymousFunction0cd48b514a00
1382 assert.deepEqual(func({ 'a': 1, 'b': 2 }, expected), expected);
1485 var expected = { 'a': 1 }; class in AnonymousFunction0cd48b515300
1486 assert.deepEqual(func({}, expected, noop), expected);
1523 var expected = lodashStable.map(values, stubOne),
1526 assert.deepEqual(actual, expected);
1546 var expected = lodashStable.map(falsey, lodashStable.constant(Array(4)));
1554 assert.deepEqual(actual, expected);
1623 expected = index < 2 ? 1 : 0;
1625 assert.strictEqual(count, expected);
1627 expected = index == 3 ? [] : [index == 2 ? undefined : square(lastIndex)];
1628 assert.deepEqual(actual, expected);
1676 var expected = lodashStable.map(errors, stubTrue);
1682 assert.deepEqual(actual, expected);
1703 var expected = lodashStable.map(realm.errors, stubTrue);
1709 assert.deepEqual(actual, expected);
1801 expected = lodashStable.map(values, function(value) { return [value]; });
1811 return lodashStable.isEqual(value, expected[index]);
1919 expected = lodashStable.times(count, lodashStable.constant([undefined, undefined]));
1937 assert.deepEqual(actual, expected);
1983 expected = new Date(2012, 4, 23, 0, 0, 0, 0);
1989 assert.deepEqual(actual, expected);
1997 assert.deepEqual(actual, expected);
2008 expected = lodashStable.times(count, stubTrue);
2025 assert.deepEqual(actual, expected);
2242 var expected = (caseName == 'start' && string == 'FOO BAR') ? string : converted;
2243 return func(string) === expected;
2253 var expected = (caseName == 'start' && string == 'FOO BAR') ? string : converted;
2254 return func(func(string)) === expected;
2288 var expected = lodashStable.map(postfixes, function(postfix) {
2299 assert.deepEqual(actual, expected);
2411 expected = lodashStable.map(values, function(value) { return [value]; }),
2414 assert.deepEqual(actual, expected);
2487 …expected = { ' ': 9, 'e': 14, 'f': 2, 'g': 1, 'h': 2, 'i': 4, 'l': 2, 'n': 6, 'o': 3, 'r': 2, 's':… class in AnonymousFunction0cd48b51bd00
2501 assert.deepEqual(actual, expected);
2557 var expected = lodashStable.map(falsey, function(value) {
2565 assert.deepEqual(actual, expected);
2572 expected = lodashStable.map(values, stubArray);
2578 assert.deepEqual(actual, expected);
2868 var expected = lodashStable.map(values, stubTrue);
2874 assert.deepEqual(actual, expected);
3028 var expected = lodashStable.map(objects, stubTrue);
3037 assert.deepEqual(actual, expected, props.join(', '));
3043 var expected = [{ 'a': [0] }, { 'b': [1] }],
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…
3102 expected = value === Foo ? { 'c': Foo.c } : {};
3106 assert.deepEqual(func(value), expected);
3257 var expected = lodashStable.map(values, function(value, index) {
3265 assert.deepEqual(actual, expected);
3267 expected = lodashStable.map(values, function(value) {
3275 assert.deepEqual(actual, expected);
3281 var expected = [],
3284 expected.push(undefined, undefined);
3288 assert.deepEqual(actual, expected);
3332 expected = ['a', 'b', 'c'];
3341 assert.deepEqual(args1, expected);
3342 assert.deepEqual(args2, expected);
3528 expected = lodashStable.map(values, stubFalse);
3540 assert.deepEqual(actual, expected);
3547 expected = lodashStable.map(values, stubTrue),
3556 assert.deepEqual(actual, expected);
3563 expected = lodashStable.map(empties, stubTrue);
3570 assert.deepEqual(actual, expected);
3601 var expected = lodashStable.map(falsey, stubTrue);
3610 assert.deepEqual(actual, expected);
3645 expected = lodashStable.map(values, lodashStable.constant({ '4': 1, '6': 2 }));
3651 assert.deepEqual(actual, expected);
3741 var expected = { 'constructor': Circle, 'radius': 0 }; class in AnonymousFunction0cd48b5114100
3742 Circle.prototype = _.create(Shape.prototype, expected);
3748 assert.deepEqual(Circle.prototype, expected);
3776 var expected = lodashStable.map(falsey, stubObject);
3782 assert.deepEqual(actual, expected);
3788 var expected = lodashStable.map(primitives, stubTrue);
3794 assert.deepEqual(actual, expected);
3801 expected = lodashStable.map(array, stubTrue),
3808 assert.deepEqual(actual, expected);
3825 expected = [1, 2, 3, 4];
3827 assert.deepEqual(curried(1)(2)(3)(4), expected);
3828 assert.deepEqual(curried(1, 2)(3, 4), expected);
3829 assert.deepEqual(curried(1, 2, 3, 4), expected);
3836 expected = [1, 2, 3];
3838 assert.deepEqual(curried(1)(2, 3), expected);
3839 assert.deepEqual(curried(1, 2)(3), expected);
3840 assert.deepEqual(curried(1, 2, 3), expected);
3847 expected = lodashStable.map(values, stubArray);
3853 assert.deepEqual(actual, expected);
3938 expected = [1, 2, 3];
3940 assert.deepEqual(_.curry(_.bind(fn, object), 3)('a')('b')('c'), expected);
3941 assert.deepEqual(_.curry(_.bind(fn, object), 3)('a', 'b')('c'), expected);
3942 assert.deepEqual(_.curry(_.bind(fn, object), 3)('a', 'b', 'c'), expected);
3946 assert.deepEqual(_.bind(_.curry(fn), object)('a', 'b', 'c'), expected);
3951 assert.deepEqual(object.curried('a', 'b', 'c'), expected);
3958 expected = [1, 2, 3, 4];
3965 assert.deepEqual(c(3), expected);
3966 assert.deepEqual(d(), expected);
3983 expected = [1, 2, 3, 4];
3985 assert.deepEqual(curried(4)(3)(2)(1), expected);
3986 assert.deepEqual(curried(3, 4)(1, 2), expected);
3987 assert.deepEqual(curried(1, 2, 3, 4), expected);
3994 expected = [1, 2, 3];
3996 assert.deepEqual(curried(3)(1, 2), expected);
3997 assert.deepEqual(curried(2, 3)(1), expected);
3998 assert.deepEqual(curried(1, 2, 3), expected);
4005 expected = lodashStable.map(values, stubArray);
4011 assert.deepEqual(actual, expected);
4019 expected = [1, 2, 3, 4],
4022 assert.deepEqual(curried(4)(2, ph)(1, ph)(3), expected);
4023 assert.deepEqual(curried(3, ph)(4)(1, ph)(2), expected);
4024 assert.deepEqual(curried(ph, ph, 4)(ph, 3)(ph, 2)(1), expected);
4025 assert.deepEqual(curried(ph, ph, ph, 4)(ph, ph, 3)(ph, 2)(1), expected);
4097 expected = [1, 2, 3];
4099 assert.deepEqual(_.curryRight(_.bind(fn, object), 3)('c')('b')('a'), expected);
4100 assert.deepEqual(_.curryRight(_.bind(fn, object), 3)('b', 'c')('a'), expected);
4101 assert.deepEqual(_.curryRight(_.bind(fn, object), 3)('a', 'b', 'c'), expected);
4105 assert.deepEqual(_.bind(_.curryRight(fn), object)('a', 'b', 'c'), expected);
4110 assert.deepEqual(object.curried('a', 'b', 'c'), expected);
4117 expected = [1, 2, 3, 4];
4124 assert.deepEqual(c(2), expected);
4125 assert.deepEqual(d(), expected);
4161 var expected = [1, 2, 3];
4163 assert.deepEqual(curried(1)(2)(3), expected);
4174 … expected = lodashStable.map(collection, lodashStable.constant(isCurry ? ['a', 'b'] : ['b', 'a']));
4180 assert.deepEqual(actual, expected);
4508 var expected = lodashStable.map(comboMarks, lodashStable.constant('ei'));
4514 assert.deepEqual(actual, expected);
4533 var expected = { 'a': 1, 'b': 2, 'c': 3 }, class in AnonymousFunction0cd48b5119800
4536 assert.deepEqual(actual, expected);
4539 assert.deepEqual(actual, expected);
4588 var expected = lodashStable.clone(source);
4589 assert.deepEqual(_.defaults({}, source), expected);
4591 expected = lodashStable.clone(object);
4592 assert.deepEqual(_.defaults({}, object, source), expected);
4606 expected = { 'a': { 'b': 2, 'c': 3 }, 'd': 4, 'e': 5 }; class in AnonymousFunction0cd48b5119d00
4608 assert.deepEqual(_.defaultsDeep(object, source), expected);
4618 expected = { 'a': { 'b': 2, 'c': 3 } }; class in AnonymousFunction0cd48b5119e00
4620 assert.deepEqual(_.defaultsDeep({ 'a': { 'b': 2 } }, source1, source2), expected);
4621 assert.deepEqual(_.defaultsDeep({ 'a': { 'b': 2 } }, source3, source4), expected);
4668 expected = lodashStable.cloneDeep(source),
4671 assert.deepEqual(actual, expected);
4736 var expected = lodashStable.map(falsey, function(value) {
4744 assert.deepEqual(actual, expected);
5042 expected = lodashStable.map(others, lodashStable.constant(['-0']));
5048 assert.deepEqual(actual, expected);
5089 var expected = lodashStable.map(falsey, function(value) {
5097 assert.deepEqual(actual, expected);
5177 var expected = lodashStable.map(falsey, function(value) {
5185 assert.deepEqual(actual, expected);
5378 expected = _.dropWhile(array, predicate),
5381 assert.deepEqual(wrapped.value(), expected);
5382 assert.deepEqual(wrapped.reverse().value(), expected.slice().reverse());
5383 assert.strictEqual(wrapped.last(), _.last(expected));
5446 var expected = lodashStable.map(falsey, stubTrue);
5452 assert.deepEqual(actual, expected);
5560 expected = lodashStable.map(values, stubString);
5566 assert.deepEqual(actual, expected);
5584 var expected = lodashStable.map(empties, stubTrue);
5592 assert.deepEqual(actual, expected);
5618 expected = lodashStable.map(values, stubFalse);
5625 assert.deepEqual(actual, expected);
5627 expected = lodashStable.map(values, stubTrue);
5633 assert.deepEqual(actual, expected);
5726 var expected = lodashStable.map(falsey, lodashStable.constant(['a', 'a', 'a']));
5733 assert.deepEqual(actual, expected);
5780 var expected = lodashStable.map(falsey, function(value) {
5789 assert.deepEqual(actual, expected);
5876 var expected = ({ class in AnonymousFunction0cd48b5124100
5888 assert.strictEqual(func(objects, function(object) { return object.a; }), expected[0]);
5891 …QUnit.test('`_.' + methodName + '` should return `' + expected[1] + '` if value is not found', fun…
5894 assert.strictEqual(func(objects, function(object) { return object.a === 3; }), expected[1]);
5900 assert.strictEqual(func(objects, { 'b': 2 }), expected[2]);
5906 assert.strictEqual(func(objects, ['b', 2]), expected[2]);
5912 assert.strictEqual(func(objects, 'b'), expected[0]);
5915 …QUnit.test('`_.' + methodName + '` should return `' + expected[1] + '` for empty collections', fun…
5919 expecting = lodashStable.map(emptyValues, lodashStable.constant(expected[1]));
5933 var expected = ({ class in AnonymousFunction0cd48b5124b00
5943 assert.strictEqual(_(array)[methodName](), expected);
6020 var expected = ({ class in AnonymousFunction0cd48b5125400
6027 assert.strictEqual(actual, expected);
6091 var expected = [
6101 assert.deepEqual(actual, expected);
6109 var expected = lodashStable.map(indexes, function() {
6122 assert.deepEqual(actual, expected);
6128 var expected = lodashStable.map(falsey, lodashStable.constant(isIncludes || values[0]));
6134 assert.deepEqual(actual, expected);
6140 var expected = [
6152 assert.deepEqual(actual, expected);
6158 var expected = [
6168 assert.deepEqual(actual, expected);
6175 expected = lodashStable.map(indexes, lodashStable.constant(isIncludes || values[0]));
6181 assert.deepEqual(actual, expected);
6211 expected = lodashStable.map(values, lodashStable.constant([-1, -1, -1]));
6221 assert.deepEqual(actual, expected);
6234 expected = lodashStable.map(values, stubZero);
6240 assert.deepEqual(actual, expected);
6246 var expected = lodashStable.map(falsey, stubZero);
6252 assert.deepEqual(actual, expected);
6279 var expected = [
6289 assert.deepEqual(actual, expected);
6297 …var expected = lodashStable.map(indexes, lodashStable.constant([values[0], undefined, undefined]));
6307 assert.deepEqual(actual, expected);
6313 var expected = lodashStable.map(falsey, function(value) {
6321 assert.deepEqual(actual, expected);
6327 var expected = [
6339 assert.deepEqual(actual, expected);
6345 var expected = [
6355 assert.deepEqual(actual, expected);
6362 expected = lodashStable.map(indexes, lodashStable.constant(values[0]));
6368 assert.deepEqual(actual, expected);
6407 expected = lodashStable.map(values, lodashStable.constant([1, 2, [3, [4]], 5]));
6413 assert.deepEqual(actual, expected);
6447 expected = lodashStable.flatten(lodashStable.map(array, duplicate));
6449 assert.deepEqual(actual, expected);
6477 expected = lodashStable.map(values, lodashStable.constant([1, 2, 3, 4]));
6484 assert.deepEqual(actual, expected);
6491 var expected = lodashStable.map(falsey, stubArray);
6499 assert.deepEqual(actual, expected);
6566 expected = [1, 2, 3];
6568 expected.push(undefined, undefined, undefined);
6572 assert.deepEqual(actual, expected);
6583 expected = lodashStable.map(methodNames, lodashStable.constant(['a']));
6591 assert.deepEqual(actual, expected);
6602 var expected = Array(5e5);
6610 assert.deepEqual(func([expected]), expected);
6638 var expected = [],
6641 assert.deepEqual(_.flatten(nonArray), expected);
6642 assert.deepEqual(_.flattenDeep(nonArray), expected);
6643 assert.deepEqual(_.flattenDepth(nonArray, 2), expected);
6991 expected = [1, 0, array];
6998 expected[0] = 3;
6999 expected[1] = 2;
7002 expected[1] += '';
7005 expected.length = isOmitPick ? 2 : 1;
7007 assert.deepEqual(args, expected);
7021 var expected = lodashStable.includes(objectMethods, methodName)
7026 expected = lodashStable.map(expected, function(args) {
7031 expected = lodashStable.map(expected, function(args) {
7037 expected.reverse();
7045 assert.deepEqual(argsList, expected);
7178 expected = lodashStable.map(values, stubTrue);
7187 assert.deepEqual(actual, expected);
7266 var expected = lodashStable.map(primitives, function(value) {
7276 assert.deepEqual(actual, expected);
7287 var expected = isAssign ? { 'a': 1 } : { 'a': 1, 'b': 2 };
7288 assert.deepEqual(func({}, new Foo), expected);
7315 expected = lodashStable.map(values, stubTrue);
7322 assert.deepEqual(actual, expected);
7328 assert.deepEqual(actual, expected);
7335 expected = { 'a': isDefaults ? 0 : 1, 'b': 2, 'c': 3 }; class in AnonymousFunction0cd48b512d800
7342 assert.deepEqual(lodashStable.reduce(array, func, { 'a': 0 }), expected);
7343 assert.deepEqual(lodashStable.reduce(fn, func, { 'a': 0 }), expected);
7408 expected = lodashStable.map([1, 2, 'a', object, source], lodashStable.cloneDeep);
7414 assert.deepEqual(args, expected, 'primitive values');
7422 …expected = [lodashStable.map([objectValue, sourceValue, 'a', object, source], lodashStable.cloneDe…
7425 …expected.push(lodashStable.map([undefined, 2, 'b', objectValue, sourceValue], lodashStable.cloneDe…
7431 assert.deepEqual(argsList, expected, 'object values');
7436 expected = lodashStable.map([undefined, 2, 'b', object, source], lodashStable.cloneDeep);
7442 assert.deepEqual(args, expected, 'undefined properties');
7515 expected = [stringLiteral, stringObject];
7522 assert.deepEqual(_.intersection(largeArray, largeArray), expected);
7523 assert.deepEqual(_.uniq(largeArray), expected);
7541 var expected = lodashStable.map(methods, stubFalse);
7548 assert.deepEqual(actual, expected);
7617 var expected = lodashStable.map(falsey, stubObject);
7625 assert.deepEqual(actual, expected);
7706 expected = lodashStable.map(values, lodashStable.constant({ '4': [4], '6': [6, 6] }));
7712 assert.deepEqual(actual, expected);
7871 expected = lodashStable.map(paths, stubTrue);
7878 assert.deepEqual(actual, expected);
7903 expected = lodashStable.map(props, stubTrue);
7909 assert.deepEqual(actual, expected);
7951 expected = lodashStable.map(values, stubTrue);
7957 assert.deepEqual(actual, expected);
7964 expected = lodashStable.map(values, lodashStable.constant([true, true]));
7972 assert.deepEqual(actual, expected);
8001 expected = lodashStable.map(values, stubFalse);
8008 assert.deepEqual(actual, expected);
8016 expected = lodashStable.map(values, stubFalse);
8023 assert.deepEqual(actual, expected);
8031 expected = lodashStable.map(values, stubFalse);
8039 assert.deepEqual(actual, expected);
8047 expected = lodashStable.map(values, lodashStable.constant([false, false]));
8055 assert.deepEqual(actual, expected);
8238 var expected = lodashStable.map(empties, stubFalse);
8246 assert.deepEqual(actual, expected);
8256 var expected = lodashStable.map(indexes, function(index) {
8268 assert.deepEqual(actual, expected);
8304 var expected = lodashStable.map(falsey, stubArray);
8312 assert.deepEqual(actual, expected);
8475 expected = [1, 3];
8477 assert.deepEqual(func(array, args), expected);
8478 assert.deepEqual(func(args, array), expected);
8485 expected = lodashStable.map(values, lodashStable.constant(['0']));
8491 assert.deepEqual(actual, expected);
8505 expected = lodashStable.map(values, lodashStable.constant(['0']));
8512 assert.deepEqual(actual, expected);
8604 expected = lodashStable.map(others, lodashStable.constant(['-0']));
8610 assert.deepEqual(actual, expected);
8669 var expected = { 'group1': ['a', 'c'], 'group2': ['b'] }; class in AnonymousFunction0cd48b5137200
8675 assert.deepEqual(actual, expected);
8682 … expected = lodashStable.map(values, lodashStable.constant({ '1': ['a', 'c'], '2': ['b'] }));
8688 assert.deepEqual(actual, expected);
8695 expected = { 'hasOwnProperty': ['a'], 'constructor': ['b'] }; class in AnonymousFunction0cd48b5137600
8697 assert.ok(lodashStable.isEqual(_.invertBy(object), expected));
8742 expected = lodashStable.map(values, noop);
8750 assert.deepEqual(actual, expected);
8881 var expected = lodashStable.map(objects, function(object) {
8889 assert.deepEqual(actual, expected);
8962 var expected = lodashStable.map(falsey, stubFalse);
8968 assert.deepEqual(actual, expected);
9009 var expected = lodashStable.map(falsey, stubFalse);
9015 assert.deepEqual(actual, expected);
9061 var expected = lodashStable.map(falsey, stubFalse);
9067 assert.deepEqual(actual, expected);
9104 expected = lodashStable.map(values, stubTrue),
9107 assert.deepEqual(actual, expected);
9113 var expected = lodashStable.map(falsey, function(value) {
9121 assert.deepEqual(actual, expected);
9141 expected = lodashStable.map(values, stubTrue),
9144 assert.deepEqual(actual, expected);
9169 var expected = lodashStable.map(falsey, function(value) {
9177 assert.deepEqual(actual, expected);
9223 var expected = lodashStable.map(falsey, stubFalse);
9229 assert.deepEqual(actual, expected);
9271 var expected = lodashStable.map(falsey, stubFalse);
9277 assert.deepEqual(actual, expected);
9333 var expected = lodashStable.map(falsey, stubFalse);
9339 assert.deepEqual(actual, expected);
9386 var expected = lodashStable.map(empties, stubTrue),
9389 assert.deepEqual(actual, expected);
9553 var expected = lodashStable.map(pairs, function(pair) {
9561 assert.deepEqual(actual, expected);
9975 var expected = lodashStable.map(pairs, lodashStable.constant([true, false, false]));
9981 assert.deepEqual(actual, expected);
10030 var expected = lodashStable.map(pairs, lodashStable.constant([true, false, false]));
10036 assert.deepEqual(actual, expected);
10315 expected = lodashStable.map(values, stubFalse);
10322 assert.deepEqual(actual, expected);
10363 var expected = [
10378 assert.deepEqual(argsList, expected);
10420 expected = lodashStable.map(values, stubFalse);
10427 assert.deepEqual(actual, expected);
10464 var expected = [
10472 expected.length = 2;
10481 assert.deepEqual(argsList, expected, index ? 'Set' : 'Map');
10498 var expected = lodashStable.map(errors, stubTrue);
10504 assert.deepEqual(actual, expected);
10516 var expected = lodashStable.map(falsey, stubFalse);
10522 assert.deepEqual(actual, expected);
10547 var expected = lodashStable.map(realm.errors, stubTrue);
10553 assert.deepEqual(actual, expected);
10570 expected = lodashStable.map(values, stubTrue),
10573 assert.deepEqual(actual, expected);
10580 expected = lodashStable.map(values, stubFalse),
10583 assert.deepEqual(actual, expected);
10590 expected = lodashStable.map(values, stubFalse),
10593 assert.deepEqual(actual, expected);
10610 expected = lodashStable.map(values, stubFalse),
10613 assert.deepEqual(actual, expected);
10655 var expected = lodashStable.map(arrayViews, function(type) {
10663 assert.deepEqual(actual, expected);
10669 var expected = lodashStable.map(falsey, stubFalse);
10675 assert.deepEqual(actual, expected);
10720 expected = lodashStable.map(values, stubTrue);
10726 assert.deepEqual(actual, expected);
10734 expected = lodashStable.map(values, stubFalse);
10740 assert.deepEqual(actual, expected);
10746 var expected = lodashStable.map(falsey, function(value) {
10754 assert.deepEqual(actual, expected);
10777 expected = lodashStable.map(values, stubTrue),
10780 assert.deepEqual(actual, expected);
10787 expected = lodashStable.map(values, stubFalse),
10790 assert.deepEqual(actual, expected);
10813 var expected = lodashStable.map(falsey, stubFalse);
10819 assert.deepEqual(actual, expected);
10840 expected = lodashStable.map(values, stubFalse);
10846 assert.deepEqual(actual, expected);
10876 var expected = [
10891 assert.deepEqual(argsList, expected);
10930 var expected = lodashStable.map(falsey, stubFalse);
10937 assert.deepEqual(actual, expected);
10991 var expected = [
10999 expected.length = 2;
11005 assert.deepEqual(argsList, expected, index ? 'Set' : 'Map');
11029 var expected = lodashStable.map(falsey, function(value) {
11037 assert.deepEqual(actual, expected);
11075 expected = lodashStable.map(values, Boolean),
11078 assert.deepEqual(actual, expected);
11084 var expected = lodashStable.map(falsey, stubFalse);
11090 assert.deepEqual(actual, expected);
11181 var expected = lodashStable.map(falsey, function(value) {
11189 assert.deepEqual(actual, expected);
11238 var expected = lodashStable.map(falsey, function(value) {
11246 assert.deepEqual(actual, expected);
11290 var expected = lodashStable.map(falsey, function(value) {
11298 assert.deepEqual(actual, expected);
11363 expected = lodashStable.map(values, stubFalse);
11369 assert.deepEqual(actual, expected);
11419 expected = lodashStable.map(values, stubFalse);
11425 assert.deepEqual(actual, expected);
11524 var expected = lodashStable.map(falsey, stubFalse);
11530 assert.deepEqual(actual, expected);
11599 var expected = lodashStable.map(falsey, stubFalse);
11605 assert.deepEqual(actual, expected);
11651 var expected = lodashStable.map(falsey, stubFalse);
11657 assert.deepEqual(actual, expected);
11678 expected = lodashStable.map(values, stubFalse);
11684 assert.deepEqual(actual, expected);
11714 var expected = lodashStable.map(falsey, function(value) {
11722 assert.deepEqual(actual, expected);
11769 var expected = lodashStable.map(falsey, stubFalse);
11775 assert.deepEqual(actual, expected);
11810 var expected = lodashStable.map(typedArrays, function(type) {
11819 assert.deepEqual(actual, expected);
11825 var expected = lodashStable.map(falsey, stubFalse);
11831 assert.deepEqual(actual, expected);
11853 var expected = lodashStable.map(props, function(key) {
11862 assert.deepEqual(actual, expected);
11885 var expected = lodashStable.map(falsey, function(value) {
11893 assert.deepEqual(actual, expected);
11946 var expected = lodashStable.map(falsey, stubFalse);
11952 assert.deepEqual(actual, expected);
11973 expected = lodashStable.map(values, stubFalse);
11979 assert.deepEqual(actual, expected);
12013 var expected = lodashStable.map(falsey, stubFalse);
12019 assert.deepEqual(actual, expected);
12118 … expected = lodashStable.map(values, lodashStable.constant([!isNpm && _.identity, object]));
12125 assert.deepEqual(actual, expected);
12248 var expected = [1, 2, 3],
12251 assert.deepEqual(object.iteratee(3), expected);
12254 assert.deepEqual(object.iteratee(2), expected);
12274 expected = lodashStable.map(array, stubFalse);
12280 assert.deepEqual(actual, expected);
12871 var expected = { 'a': { 'dir': 'left', 'code': 97 }, 'd': { 'dir': 'right', 'code': 100 } }; class in AnonymousFunction0cd48b514d200
12877 assert.deepEqual(actual, expected);
12885 expected = lodashStable.map(values, lodashStable.constant({ '4': 4, '6': 6 }));
12891 assert.deepEqual(actual, expected);
12897 …var expected = { 'left': { 'dir': 'left', 'code': 97 }, 'right': { 'dir': 'right', 'code': 100 } }, class in AnonymousFunction0cd48b514d600
12900 assert.deepEqual(actual, expected);
12977 var expected = isKeys ? ['a'] : ['a', 'b'],
12980 assert.deepEqual(actual, expected);
13010 var expected = isKeys ? ['0'] : ['0', 'a'],
13013 assert.deepEqual(actual, expected);
13022 expected = lodashStable.map(values, lodashStable.constant(['0', '1', '2']));
13028 assert.deepEqual(actual, expected);
13035 expected = lodashStable.map(values, lodashStable.constant(['0', '1', '2', 'a']));
13044 assert.deepEqual(actual, expected);
13051 …expected = lodashStable.map(values, lodashStable.constant(isKeys ? ['0', '1', '2'] : ['0', '1', '2…
13060 assert.deepEqual(actual, expected);
13087 var expected = isKeys ? ['0'] : ['0', 'a'],
13090 assert.deepEqual(actual, expected);
13107 var expected = lodashStable.map(primitives, function(value) {
13112 assert.deepEqual(actual, expected);
13126 var expected = ['a'];
13127 assert.deepEqual(func(Foo.prototype), expected);
13130 assert.deepEqual(func(Foo.prototype), expected);
13139 expected = lodashStable.map(values, stubArray);
13148 assert.deepEqual(actual, expected);
13334 expected = lodashStable.map(values, lodashStable.constant([-1, 3, -1]));
13344 assert.deepEqual(actual, expected);
13357 expected = lodashStable.map(values, stubZero);
13363 assert.deepEqual(actual, expected);
13369 var expected = lodashStable.map(falsey, function(value) {
13377 assert.deepEqual(actual, expected);
13399 var expected = lodashStable.map(falsey, lodashStable.constant(-1));
13407 assert.deepEqual(actual, expected);
13471 expected = ['1', '2'];
13473 assert.deepEqual(_.map(array, String), expected);
13474 assert.deepEqual(_.map(object, String), expected);
13501 expected = lodashStable.map(values, lodashStable.constant([1, 2]));
13508 assert.deepEqual(actual, expected);
13515 var expected = lodashStable.map(falsey, stubArray);
13523 assert.deepEqual(actual, expected);
13573 expected = [1, 0, _.map(array.slice(1), square)];
13586 assert.deepEqual(args, expected);
13593 assert.deepEqual(args, expected);
13607 assert.deepEqual(args, expected);
13649 expected = lodashStable.map(values, lodashStable.constant({ '1': 1, '2': 2 }));
13655 assert.deepEqual(actual, expected);
13693 expected = lodashStable.map(values, lodashStable.constant([true, false]));
13700 assert.deepEqual(actual, expected);
13727 var expected = lodashStable.map(falsey, stubObject);
13735 assert.deepEqual(actual, expected);
13844 expected = lodashStable.map(objects, stubTrue);
13846 assert.deepEqual(actual, expected);
14022 expected = [false, false, true];
14024 assert.deepEqual(actual, expected);
14028 assert.deepEqual(actual, expected);
14033 assert.deepEqual(actual, expected);
14069 expected = lodashStable.map(values, stubFalse),
14078 assert.deepEqual(actual, expected);
14085 expected = lodashStable.map(empties, stubTrue);
14092 assert.deepEqual(actual, expected);
14099 expected = lodashStable.map(values, stubTrue),
14108 assert.deepEqual(actual, expected);
14180 expected = lodashStable.map(props, lodashStable.constant([true, false]));
14189 assert.deepEqual(actual, expected);
14200 expected = lodashStable.map(paths, stubTrue);
14208 assert.deepEqual(actual, expected);
14227 expected = lodashStable.map(values, stubFalse);
14238 assert.deepEqual(actual, expected);
14246 expected = lodashStable.map(values, stubFalse);
14257 assert.deepEqual(actual, expected);
14295 expected = lodashStable.map(objects, stubTrue);
14298 assert.deepEqual(lodashStable.map(objects, _.matchesProperty(path, new Foo)), expected);
14461 expected = [false, false, true];
14463 assert.deepEqual(actual, expected);
14468 assert.deepEqual(actual, expected);
14562 expected = lodashStable.map(values, noop);
14570 assert.deepEqual(actual, expected);
14595 var expected = lodashStable.map(empties, stubNaN),
14598 assert.deepEqual(actual, expected);
14728 expected = lodashStable.map(values, stubTrue);
14736 assert.deepEqual(actual, expected);
14890 var expected = { class in AnonymousFunction0cd48b5159900
14897 assert.deepEqual(_.merge(names, ages, heights), expected);
14925 var expected = { 'a': 4 }, class in AnonymousFunction0cd48b5159b00
14926 actual = _.merge({ 'a': 1 }, { 'a': 2 }, { 'a': 3 }, expected);
14928 assert.deepEqual(actual, expected);
14968 expected = { 'a': { 'b': 2 } }, class in AnonymousFunction0cd48b5159f00
14971 assert.deepEqual(actual, expected);
14975 assert.deepEqual(actual, expected);
14997 expected = array.slice();
14999 expected[1] = undefined;
15002 assert.deepEqual(actual, expected);
15010 expected = { '0': 1, '1': 2, '2': 3, '3': 4 }, class in AnonymousFunction0cd48b515a200
15015 assert.deepEqual(actual.value, expected);
15020 assert.deepEqual(actual.value, expected);
15022 expected = { '0': 1, '1': 2, '2': 3 }; class in AnonymousFunction0cd48b515a200
15026 assert.deepEqual(actual.value, expected);
15040 var expected = lodashStable.map(typedArrays, function(type, index) {
15052 assert.deepEqual(actual, expected);
15054 expected = lodashStable.map(typedArrays, function(type, index) {
15069 assert.deepEqual(actual, expected);
15085 expected = lodashStable.map(values, stubTrue);
15092 assert.deepEqual(actual, expected);
15120 expected = lodashStable.map(values, stubTrue);
15136 assert.deepEqual(actual, expected);
15191 expected = [1, 5, 3];
15193 assert.deepEqual(actual, expected);
15199 assert.deepEqual(actual, expected);
15246 expected = lodashStable.map(pairs, stubTrue);
15254 assert.deepEqual(actual, expected);
15381 var expected = [1, 2, 3, 4],
15391 assert.deepEqual(actual, expected);
15422 expected = lodashStable.map(values, noop);
15431 assert.deepEqual(actual, expected);
15439 expected = lodashStable.map(values, noop);
15448 assert.deepEqual(actual, expected);
15535 var expected = [1, 2, 3, 4],
15545 assert.deepEqual(actual, expected);
15576 expected = lodashStable.map(values, noop);
15584 assert.deepEqual(actual, expected);
15592 expected = lodashStable.map(values, noop);
15600 assert.deepEqual(actual, expected);
15658 expected = lodashStable.map(values, noop);
15666 assert.deepEqual(actual, expected);
16040 var expected = [objects[2], objects[0], objects[3], objects[1]],
16043 assert.deepEqual(actual, expected);
16045 …expected = lodashStable.map(falsey, lodashStable.constant([objects[3], objects[1], objects[2], obj…
16051 assert.deepEqual(actual, expected);
16198 expected = lodashStable.times(count, stubTrue);
16211 assert.deepEqual(actual, expected);
16253 expected = {},
16254 context = vm.createContext({ '_': expected, 'console': console }),
16259 assert.strictEqual(context._, expected);
16333 expected = lodashStable.map(values, stubA);
16339 assert.deepEqual(actual, expected);
16342 expected = lodashStable.map(values, stubB);
16348 assert.deepEqual(actual, expected);
16355 expected = lodashStable.map(values, noop);
16361 assert.deepEqual(actual, expected);
16369 expected = lodashStable.map(values, noop);
16377 assert.deepEqual(actual, expected);
16414 expected = lodashStable.map(values, stubA);
16421 assert.deepEqual(actual, expected);
16424 expected = lodashStable.map(values, stubB);
16431 assert.deepEqual(actual, expected);
16445 expected = lodashStable.map(values, noop);
16452 assert.deepEqual(actual, expected);
16566 var expected = { 'b': 2, 'd': 4 }, class in AnonymousFunction0cd48b5165600
16586 assert.deepEqual(func(object, resolve(object, ['a', 'c'])), expected);
16595 assert.deepEqual(func(new Foo, resolve(object, ['a', 'c'])), expected);
16603 expected = [{ '0': 'b' }, { '0': 'b' }, { '-0': 'a' }, { '-0': 'a' }];
16609 assert.deepEqual(actual, expected);
17052 expected = lodashStable.map(values, lodashStable.constant(' abc '));
17058 assert.deepEqual(actual, expected);
17072 expected = lodashStable.map(values, stubTrue);
17078 assert.deepEqual(actual, expected);
17093 expected = lodashStable.map(values, lodashStable.constant('abc '));
17099 assert.deepEqual(actual, expected);
17112 expected = lodashStable.map(values, stubTrue);
17118 assert.deepEqual(actual, expected);
17133 expected = lodashStable.map(values, lodashStable.constant(' abc'));
17139 assert.deepEqual(actual, expected);
17152 expected = lodashStable.map(values, stubTrue);
17158 assert.deepEqual(actual, expected);
17200 var expected = chars ? (isPad ? '__' : chars) : ' ';
17201 assert.strictEqual(func(null, 2, chars), expected);
17202 assert.strictEqual(func(undefined, 2, chars), expected);
17203 assert.strictEqual(func('', 2, chars), expected);
17211 expected = lodashStable.map(values, lodashStable.constant(string));
17217 assert.deepEqual(actual, expected);
17229 var expected = lodashStable.range(2, 37);
17231 var actual = lodashStable.map(expected, function(radix) {
17235 assert.deepEqual(actual, expected);
17268 var expected = [8, 8, 10, 10, 32, 32, 32, 32];
17290 assert.deepEqual(actual, expected);
17340 expected = isPartial ? ['a', 'b'] : ['b', 'a'];
17342 assert.deepEqual(par('b'), expected);
17386 expected = isPartial ? ['a', 'b', ph, 'c'] : ['a', 'c', 'b', ph];
17388 assert.deepEqual(par('a', 'c'), expected);
17466 expected = { 'a': { 'b': 2, 'c': 3 } }; class in AnonymousFunction0cd48b516bf00
17472 assert.deepEqual(defaultsDeep(object, source), expected);
17509 var expected = [1, 2, 3, 4],
17516 assert.deepEqual(c(3), expected);
17522 assert.deepEqual(c(3), expected);
17528 assert.deepEqual(c(3), expected);
17548 var expected = [1, 2, 3, 4, 5, 6],
17555 assert.deepEqual(c(3, 5), expected);
17561 assert.deepEqual(c(3, 5), expected);
17567 assert.deepEqual(c(3, 5), expected);
17573 var expected = [1, 2, 3, 4],
17580 assert.deepEqual(c(1), expected);
17586 assert.deepEqual(c(1), expected);
17592 assert.deepEqual(c(1), expected);
17621 expected = [object, 1, 2, 3];
17628 assert.deepEqual(actual, expected);
17637 assert.deepEqual(actual, expected);
17643 expected = index ? [3, 2, 1] : [1, 2, 3];
17649 assert.deepEqual(actual, expected);
17656 assert.deepEqual(actual, expected);
17663 expected = index ? [3, 2, 1] : [1, 2, 3];
17670 assert.deepEqual(actual, expected);
17679 assert.deepEqual(actual, expected);
17703 expected = lodashStable.map(values, lodashStable.constant([[1, 1], [0]]));
17709 assert.deepEqual(actual, expected);
17842 var expected = { 'a': 1, 'c': 3 }, class in AnonymousFunction0cd48b516e300
17863 assert.deepEqual(func(object, resolve(object, ['a', 'c'])), expected);
17873 assert.deepEqual(func(foo, resolve(foo, ['a', 'c'])), expected);
17881 expected = [{ '-0': 'a' }, { '-0': 'a' }, { '0': 'b' }, { '0': 'b' }];
17887 assert.deepEqual(actual, expected);
18005 var expected = [1, 2, 3, 4],
18015 assert.deepEqual(actual, expected);
18034 expected = lodashStable.map(values, noop);
18043 assert.deepEqual(actual, expected);
18051 expected = lodashStable.map(values, noop);
18060 assert.deepEqual(actual, expected);
18150 var expected = [1, 2, 3, 4],
18160 assert.deepEqual(actual, expected);
18179 expected = lodashStable.map(values, noop);
18187 assert.deepEqual(actual, expected);
18195 expected = lodashStable.map(values, noop);
18203 assert.deepEqual(actual, expected);
18273 expected = [objects[0], objects[2]],
18276 assert.deepEqual(actual, expected);
18419 var expected = lodashStable.map(values, stubOne),
18422 assert.deepEqual(actual, expected);
18424 expected = lodashStable.map(values, noop);
18427 assert.deepEqual(actual, expected);
18466 expected = lodashStable.map(values, lodashStable.constant(Array(4)));
18474 assert.deepEqual(actual, expected);
18524 expected = [2, 3, 4];
18530 assert.deepEqual(actual, expected);
18589 expected = lodashStable.map(array, stubTrue),
18596 assert.deepEqual(actual, expected);
18692 expected = lodashStable.map([[0], [0, 1], [0, 1, 2]], resolve);
18696 assert.deepEqual(actual, expected);
18738 var expected = lodashStable.map(values, lodashStable.constant([undefined, 'b', 'c']));
18745 assert.deepEqual(actual, expected);
18828 var expected = firstKey == 'a'
18836 assert.deepEqual(args, expected);
18839 expected = firstKey == 'a'
18847 assert.deepEqual(args, expected);
18890 var expected = isFIFO
18898 assert.deepEqual(args, expected);
18901 expected = isFIFO
18909 assert.deepEqual(args, expected);
18936 expected = lodashStable.map(empties, noop);
18944 assert.deepEqual(actual, expected);
18950 var expected = lodashStable.map(empties, lodashStable.constant('x'));
18958 assert.deepEqual(actual, expected);
19105 expected = [1, 0, lodashStable.map(array.slice(1), square)];
19118 assert.deepEqual(args, expected);
19125 assert.deepEqual(args, expected);
19139 assert.deepEqual(args, expected);
19261 var expected = lodashStable.map(falsey, function(value) {
19269 assert.deepEqual(actual, expected);
19472 expected = lodashStable.map(values, noop),
19480 assert.deepEqual(actual, expected);
19521 expected = lodashStable.map(values, function(value) { return [value, value]; });
19528 assert.deepEqual(actual, expected);
19566 expected = lodashStable.map(values, lodashStable.constant([[1, 2, 3, 4]]));
19573 assert.deepEqual(actual, expected);
19645 expected = array.slice(),
19648 assert.deepEqual(actual, expected.slice(1).reverse());
19649 assert.deepEqual(array, expected);
19668 expected = array.slice();
19677 assert.deepEqual(array, expected);
19693 expected = clone.slice(1, -1).reverse(),
19696 assert.deepEqual(actual, expected);
19701 assert.deepEqual(actual, [3].concat(expected.slice(0, -1)));
19716 expected = array.slice().reverse(),
19720 assert.strictEqual(wrapped.value(), _.head(expected));
19721 assert.deepEqual(array, expected);
19776 var expected = isFloor ? 4.01 : 4.02;
19779 assert.strictEqual(actual, expected);
19782 assert.strictEqual(actual, expected);
19802 … expected = [Infinity, -Infinity, Infinity, -Infinity, Infinity, -Infinity, Infinity, -Infinity];
19808 assert.deepEqual(actual, expected);
19819 var expected = lodashStable.map(results, stubFalse),
19822 assert.deepEqual(actual, expected);
19952 var expected = lodashStable.map(empties, noop);
19960 assert.deepEqual(actual, expected);
20000 var expected = lodashStable.map(falsey, function(value) {
20008 assert.deepEqual(actual, expected);
20038 var expected = lodashStable.map(empties, stubArray);
20046 assert.deepEqual(actual, expected);
20118 expected = lodashStable.map(props, lodashStable.constant(value));
20126 assert.deepEqual(actual, expected);
20237 expected = [[null, null], [undefined, undefined]];
20247 assert.deepEqual(actual, expected);
20351 var expected = lodashStable.map(falsey, stubZero);
20359 assert.deepEqual(actual, expected);
20463 var expected = lodashStable.map(falsey, lodashStable.constant(array));
20469 assert.deepEqual(actual, expected);
20511 var expected = lodashStable.map(falsey, function(value) {
20519 assert.deepEqual(actual, expected);
20613 var expected = lodashStable.map(empties, stubFalse);
20621 assert.deepEqual(actual, expected);
20648 expected = lodashStable.map(values, stubFalse);
20655 assert.deepEqual(actual, expected);
20657 expected = lodashStable.map(values, stubTrue);
20663 assert.deepEqual(actual, expected);
20717 expected = lodashStable.map(values, lodashStable.constant([1, 2, 3]));
20723 assert.deepEqual(actual, expected);
20746 expected = [1, 2, 3, 4, symbol1, symbol2, null, null, undefined, undefined, NaN, NaN];
20748 assert.deepEqual(_.sortBy(array), expected);
20751 expected = ['a', 'b', 'c', 'd', symbol1, symbol2, null, null, undefined, undefined, NaN, NaN];
20753 assert.deepEqual(_.sortBy(array), expected);
20863 var expected = lodashStable.map(funcs, lodashStable.constant(
20873 assert.deepEqual(actual, expected);
20891 expected = isSortedIndex ? [0, 1, 1] : [1, 1, 2];
20897 assert.deepEqual(actual, expected);
20905 expected = isSortedIndex ? [0, 1, 1] : [1, 1, 2];
20911 assert.deepEqual(actual, expected);
20918 expected = lodashStable.map(values, lodashStable.constant([0, 0, 0]));
20924 assert.deepEqual(actual, expected);
20933 expected = [1, '2', {}, symbol1, symbol2, null, undefined, NaN, NaN];
20939 assert.deepEqual(_.sortBy(array), expected);
20940 assert.strictEqual(func(expected, 3), 2);
20941 assert.strictEqual(func(expected, symbol3), isSortedIndex ? 3 : (Symbol ? 5 : 6));
20942 assert.strictEqual(func(expected, null), isSortedIndex ? (Symbol ? 5 : 3) : 6);
20943 assert.strictEqual(func(expected, undefined), isSortedIndex ? 6 : 7);
20944 assert.strictEqual(func(expected, NaN), isSortedIndex ? 7 : 9);
21018 … var expected = (isSortedIndexBy ? !lodashStable.isNaN(value) : lodashStable.isFinite(value))
21023 assert.strictEqual(actual, expected);
21053 var expected = [1, 2, 3];
21056 assert.deepEqual(_.sortedUniq(array), expected);
21079 expected = lodashStable.map(values, lodashStable.constant(['']));
21085 assert.deepEqual(actual, expected);
21123 expected = [1, 2];
21125 assert.deepEqual(spread([1, 2]), expected);
21126 assert.deepEqual(spread([1, 2], 3), expected);
21133 expected = lodashStable.map(falsey, stubTrue);
21141 assert.deepEqual(actual, expected);
21148 expected = [1, 2, 3];
21150 assert.deepEqual(spread(1, [2, 3]), expected);
21151 assert.deepEqual(spread(1, [2, 3], 4), expected);
21158 expected = lodashStable.map(values, lodashStable.constant([1, 2]));
21165 assert.deepEqual(actual, expected);
21172 expected = [1, 2, 3];
21174 assert.deepEqual(spread(1, [2, 3]), expected);
21175 assert.deepEqual(spread(1, [2, 3], 4), expected);
21229 var expected = lodashStable.map(falsey, stubTrue);
21235 assert.deepEqual(actual, expected);
21316 expected = lodashStable.map(values, lodashStable.constant(pair[0]));
21328 assert.deepEqual(actual, expected);
21379 expected = [[0, Infinity], ['0', Infinity], [-0, -Infinity], ['-0', -Infinity]];
21387 assert.deepEqual(actual, expected);
21491 var expected = lodashStable.map(empties, stubZero);
21497 assert.deepEqual(actual, expected);
21529 var expected = lodashStable.map(falsey, stubArray);
21537 assert.deepEqual(actual, expected);
21634 var expected = lodashStable.map(falsey, function(value) {
21642 assert.deepEqual(actual, expected);
21716 var expected = lodashStable.map(falsey, function(value) {
21724 assert.deepEqual(actual, expected);
21841 expected = _.takeRightWhile(array, predicate),
21844 assert.deepEqual(wrapped.value(), expected);
21845 assert.deepEqual(wrapped.reverse().value(), expected.slice().reverse());
21846 assert.strictEqual(wrapped.last(), _.last(expected));
21860 var expected = [
21876 assert.deepEqual(args, expected);
21882 assert.deepEqual(args, expected);
21894 assert.deepEqual(args, expected);
21960 expected = _.takeWhile(array, predicate),
21963 assert.deepEqual(wrapped.value(), expected);
21964 assert.deepEqual(wrapped.reverse().value(), expected.slice().reverse());
21965 assert.strictEqual(wrapped.last(), _.last(expected));
21997 expected = [1, 0, lodashStable.map(array.slice(1), square)];
22009 assert.deepEqual(args, expected);
22015 assert.deepEqual(args, expected);
22027 assert.deepEqual(args, expected);
22091 … expected = lodashStable.map(strings, lodashStable.constant('<p>&<>"'/</p>')),
22098 assert.deepEqual(actual, expected);
22146 expected = lodashStable.map(strings, lodashStable.constant('ABC')),
22153 assert.deepEqual(actual, expected);
22266 var expected = '<ul><li>0: a & A</li><li>1: b & B</li></ul>',
22270 assert.strictEqual(compiled(data), expected);
22287 var expected = '<ul><li>0: a & A</li><li>1: b & B</li></ul>',
22291 assert.strictEqual(compiled(data), expected);
22359 var expected = '1 <%- a %> <% print(a) %> <%= a %>',
22363 assert.strictEqual(compiled(data), expected);
22370 var expected = 'abc';
22371 assert.strictEqual(_.template(expected)({}), expected);
22484 expected = lodashStable.map(values, stubString),
22492 assert.deepEqual(actual, expected);
22498 var expected = '<<\nprint("<p>" + (value ? "yes" : "no") + "</p>")\n>>',
22499 compiled = _.template(expected, { 'evaluate': /<<(.+?)>>/g }),
22502 assert.strictEqual(compiled(data), expected);
22558 expected = lodashStable.map(values, stubTrue);
22564 assert.deepEqual(actual, expected);
22590 var expected = lodashStable.map(values, stubFalse);
22596 assert.deepEqual(actual, expected);
23010 expected = lodashStable.times(isDebounce ? 1 : 2, lodashStable.constant(object));
23017 assert.deepEqual(actual, expected);
23029 expected = args.slice(),
23045 assert.deepEqual(actual, expected.slice(0, isDebounce ? 0 : 1));
23048 assert.deepEqual(actual, expected.slice(0, actual.length));
23207 expected = lodashStable.map(values, lodashStable.constant([0, 1, 2]));
23213 assert.deepEqual(actual, expected);
23226 expected = lodashStable.map(values, stubArray);
23232 assert.deepEqual(actual, expected);
23424 var expected = isSafe ? MAX_SAFE_INTEGER : MAX_INTEGER;
23425 assert.strictEqual(func(Infinity), expected);
23426 assert.strictEqual(func(-Infinity), -expected);
23476 expected = [[0, Infinity], [0, Infinity], [-0, -Infinity], [-0, -Infinity]];
23486 assert.deepEqual(actual, expected);
23515 var expected = lodashStable.map(values, function(value) {
23521 assert.deepEqual(actual, expected);
23529 var expected = lodashStable.map(values, function(value) {
23552 assert.deepEqual(actual, expected);
23567 var expected = lodashStable.map(values, function(value) {
23593 assert.deepEqual(actual, expected);
23603 var expected = lodashStable.map(numbers, function(n) {
23614 assert.deepEqual(actual, expected);
23623 var expected = lodashStable.map(values, function(n) {
23633 assert.deepEqual(actual, expected);
23643 expected = lodashStable.map(values, lodashStable.constant(isToNumber ? NaN : 0));
23648 assert.deepEqual(actual, expected);
23660 var expected = lodashStable.map(values, function(value) {
23668 assert.deepEqual(actual, expected);
23691 var expected = [
23700 expected = [
23709 expected = [
23719 assert.deepEqual(actual, expected);
23772 var expected = isToPairs ? [['a', 1]] : [['a', 1], ['b', 2]],
23775 assert.deepEqual(actual, expected);
23880 var expected = ['', 'a'];
23881 assert.deepEqual(_.toPath('.a'), expected);
23882 assert.deepEqual(_.toPath('[].a'), expected);
23884 expected = ['', '', 'a'];
23885 assert.deepEqual(_.toPath('..a'), expected);
23886 assert.deepEqual(_.toPath('[][].a'), expected);
23888 expected = ['a', '', 'b'];
23889 assert.deepEqual(_.toPath('a..b'), expected);
23890 assert.deepEqual(_.toPath('a[].b'), expected);
23892 expected = ['a', '', '', 'b'];
23893 assert.deepEqual(_.toPath('a...b'), expected);
23894 assert.deepEqual(_.toPath('a[][].b'), expected);
23896 expected = ['a', ''];
23897 assert.deepEqual(_.toPath('a.'), expected);
23898 assert.deepEqual(_.toPath('a[]'), expected);
23900 expected = ['a', '', ''];
23901 assert.deepEqual(_.toPath('a..'), expected);
23902 assert.deepEqual(_.toPath('a[][]'), expected);
23927 expected = { '0': 1, '1': 2, '2': 3 }; class in AnonymousFunction0cd48b519b700
23929 assert.deepEqual(actual, expected);
23936 expected = { '0': 'a', '1': 'b', '2': 'c' }; class in AnonymousFunction0cd48b519b800
23938 assert.deepEqual(actual, expected);
23951 expected = lodashStable.map(values, stubString);
23957 assert.deepEqual(actual, expected);
23964 expected = ['-0', '-0', '0', '0'],
23967 assert.deepEqual(actual, expected);
24036 expected = lodashStable.map(accumulators, stubTrue);
24052 assert.deepEqual(actual, expected);
24054 expected = lodashStable.map(accumulators, lodashStable.constant({ 'a': 1, 'b': 4, 'c': 9 }));
24057 assert.deepEqual(actual, expected);
24062 assert.deepEqual(actual, expected);
24065 expected = lodashStable.map(accumulators, lodashStable.constant([1, 4, 9]));
24068 assert.deepEqual(actual, expected);
24074 var expected = lodashStable.map(typedArrays, stubTrue);
24083 assert.deepEqual(actual, expected);
24090 expected = lodashStable.map(values, lodashStable.constant([1, 4, 9]));
24098 assert.deepEqual(actual, expected);
24101 expected = [object, { '0': 1, '1': 4, '2': 9 }, object];
24109 assert.deepEqual(actual, expected);
24145 expected = lodashStable.map(values, stubObject);
24151 assert.deepEqual(results, expected);
24153 expected = lodashStable.map(values, stubFalse);
24159 assert.deepEqual(actual, expected);
24173 var expected = lodashStable.map(falsey, stubObject);
24179 assert.deepEqual(actual, expected);
24214 var expected = lodashStable.map(objects, stubTrue);
24229 assert.deepEqual(actual, expected);
24253 expected = (index == 2 ? whitespace : '') + 'a b c' + (index == 1 ? whitespace : '');
24255 assert.strictEqual(func(string), expected);
24262 expected = (index == 2 ? whitespace : '') + 'a b c' + (index == 1 ? whitespace : '');
24264 assert.strictEqual(func(object), expected);
24271 expected = (index == 2 ? '-_-' : '') + 'a-b-c' + (index == 1 ? '-_-' : '');
24273 assert.strictEqual(func(string, '_-'), expected);
24281 expected = (index == 2 ? '-_-' : '') + 'a-b-c' + (index == 1 ? '-_-' : '');
24283 assert.strictEqual(func(string, object), expected);
24300 expected = (index == 2 ? whitespace : '') + 'a b c' + (index == 1 ? whitespace : '');
24302 assert.strictEqual(func(string, undefined), expected);
24321 expected = (index == 2 ? whitespace : '') + 'a b c' + (index == 1 ? whitespace : '');
24323 assert.strictEqual(_(string)[methodName](), expected);
24388 var expected = ['A', ' ', leafs, ',', ' ', comboGlyph, ',', ' ', 'a', 'n', 'd', ' ', rocket];
24390 assert.deepEqual(_.split(string, ''), expected);
24391 assert.deepEqual(_.split(string, '', 6), expected.slice(0, 6));
24392 assert.deepEqual(_.toArray(string), expected);
24426 var expected = lodashStable.map(values, function(value) {
24434 assert.deepEqual(actual, expected);
24444 var expected = lodashStable.map(values, function(value) {
24452 assert.deepEqual(actual, expected);
24486 var expected = lodashStable.map(values, function(value) {
24494 assert.deepEqual(actual, expected);
24745 expected = [0, {}, 'a'],
24746 count = Math.ceil(LARGE_ARRAY_SIZE / expected.length);
24748 lodashStable.each(expected, function(value) {
24754 assert.deepEqual(func(largeArray), expected);
24772 expected = [null, undefined, false, true, NaN],
24773 count = Math.ceil(LARGE_ARRAY_SIZE / expected.length);
24775 lodashStable.each(expected, function(value) {
24781 assert.deepEqual(func(largeArray), expected);
24801 var expected = [
24808 count = Math.ceil(LARGE_ARRAY_SIZE / expected.length);
24810 expected = lodashStable.map(expected, function(symbol) {
24814 lodashStable.each(expected, function(value) {
24820 assert.deepEqual(func(largeArray), expected);
24831 expected = ['2', 2, Object('2'), Object(2)],
24832 count = Math.ceil(LARGE_ARRAY_SIZE / expected.length);
24834 lodashStable.each(expected, function(value) {
24840 assert.deepEqual(func(largeArray), expected);
24874 var expected = isSorted ? [{ 'a': 1 }, { 'a': 2 }, { 'a': 3 }] : objects.slice(0, 3);
24880 assert.deepEqual(actual, expected);
24910 var expected = isSorted ? [{ 'a': 1 }, { 'a': 2 }, { 'a': 3 }] : objects.slice(0, 3),
24913 assert.deepEqual(actual, expected);
24919 expected = isSorted ? [[1], [2], [3]] : arrays.slice(0, 3);
24922 assert.deepEqual(actual, expected);
24963 expected = lodashStable.map(arrays, lodashStable.constant(['-0']));
24969 assert.deepEqual(actual, expected);
25021 expected = lodashStable.map(props, lodashStable.constant([true, false]));
25028 assert.deepEqual(actual, expected);
25087 expected = [[true, true], [true, true]];
25097 assert.deepEqual(actual, expected);
25181 expected = lodashStable.map(values, lodashStable.constant(_.unzip(array)));
25187 assert.deepEqual(actual, expected);
25226 expected = oldValue + 1;
25234 assert.strictEqual(object.a[0].b.c, expected);
25302 var expected = isValues ? [1] : [1, 2],
25305 assert.deepEqual(actual, expected);
25312 expected = lodashStable.map(values, lodashStable.constant([1, 2, 3]));
25318 assert.deepEqual(actual, expected);
25361 var expected = lodashStable.map(burredLetters, function(letter) {
25369 assert.deepEqual(actual, expected);
25416 var expected = lodashStable.map(postfixes, function(postfix) {
25423 assert.deepEqual(actual, expected);
25434 var expected = lodashStable.map(ordinals, function(ordinal) {
25438 var actual = lodashStable.map(expected, function(words) {
25442 assert.deepEqual(actual, expected);
25450 expected = lodashStable.map(operators, stubArray),
25453 assert.deepEqual(actual, expected);
25465 var expected = lodashStable.map(marks, stubArray),
25468 assert.deepEqual(actual, expected);
25529 expected = lodashStable.map(values, stubA);
25536 assert.deepEqual(actual, expected);
25724 …var expected = isDeep ? ({ 'a': { 'b': { 'c': 1 } } }) : (index ? { 'a,b,c': 1 } : { 'a.b.c': 1 });
25725 assert.deepEqual(func([path], [1]), expected);
25788 expected = lodashStable.map(values, lodashStable.constant(_.zip(array1, array2)));
25794 assert.deepEqual(actual, expected);
25855 var expected = lodashStable.map(falsey, stubArray);
25861 assert.deepEqual(actual, expected);
25874 var expected = [['barney', 'fred'], [36, 40]];
25875 assert.deepEqual(func(func(func(func(expected)))), expected);
26102 var expected = lodashStable.map(falsey, stubTrue);
26111 assert.deepEqual(actual, expected);
26144 var expected = lodashStable.map(falsey, stubTrue);
26153 assert.deepEqual(actual, expected);
26190 var expected = lodashStable.map(falsey, stubTrue);
26199 assert.deepEqual(actual, expected);
26232 var expected = lodashStable.map(falsey, stubTrue);
26241 assert.deepEqual(actual, expected);
26278 var expected = lodashStable.map(falsey, stubTrue);
26287 assert.deepEqual(actual, expected);
26320 var expected = lodashStable.map(falsey, stubTrue);
26329 assert.deepEqual(actual, expected);
26387 var expected = _.prototype.value;
26388 assert.strictEqual(_.prototype.toJSON, expected);
26389 assert.strictEqual(_.prototype.valueOf, expected);
26721 expected = lodashStable.map(values, stubString);
26727 assert.deepEqual(actual, expected);
26830 var expected = arrays,
26841 expected = falsey;
26844 assert.deepEqual(actual, expected, '_.' + methodName + ' returns an array');
26887 var expected = lodashStable.map(falsey, stubTrue),
26902 assert.deepEqual(actual, expected, '`_.' + methodName + '` rejects falsey arguments');
26914 expected = isNegate ? false : 1;
26917 … assert.strictEqual(wrapper(), expected, '`_.' + methodName + '` can consume a bound function');
26920 assert.strictEqual(wrapper(), expected, '`_.' + methodName + '` can be bound');
26923 …assert.strictEqual(object.wrapper(), expected, '`_.' + methodName + '` uses the `this` of its pare…