Lines Matching refs:func

444       result = action.func.apply(action.thisArg, args);
933 var func = _._isIndex; variable
938 if (func) {
943 return func.apply(undefined, args);
956 if (func) {
961 return func.apply(undefined, args);
978 func = _._isIterateeCall, variable
987 if (func) {
988 assert.strictEqual(func(1, 0, array), true);
989 assert.strictEqual(func(1, 'a', object), true);
990 assert.strictEqual(func(1, 'a', new Foo), true);
1000 if (func) {
1001 assert.strictEqual(func(2, 0, array), false);
1002 assert.strictEqual(func(1, 1.1, array), false);
1003 assert.strictEqual(func(1, 0, { 'length': MAX_SAFE_INTEGER + 1 }), false);
1004 assert.strictEqual(func(1, 'b', object), false);
1014 if (func) {
1015 assert.strictEqual(func(NaN, 0, [NaN]), true);
1016 assert.strictEqual(func(NaN, 'a', { 'a': NaN }), true);
1026 if (func) {
1028 var actual = func(1, { 'toString': null }, [1]);
1355 var func = _[methodName];
1360 assert.deepEqual(func({ 'a': 1 }, { 'b': 2 }), { 'a': 1, 'b': 2 });
1367 assert.deepEqual(func({ 'a': 1 }, { 'b': 2 }, { 'c': 3 }), expected);
1368 assert.deepEqual(func({ 'a': 1 }, { 'b': 2, 'c': 2 }, { 'c': 3 }), expected);
1375 assert.deepEqual(func({ 'a': 1, 'b': 2 }, expected), expected);
1382 assert.deepEqual(func({ 'a': 1, 'b': 2 }, expected), expected);
1422 var actual = func(object, source);
1434 assert.deepEqual(func({}, array), { '0': 1, '1': undefined, '2': 3 });
1443 assert.deepEqual(func({}, Foo.prototype), { 'a': 1 });
1449 assert.deepEqual(func({}, 'a'), { '0': 'a' });
1470 var func = _[methodName];
1475 var actual = func({ 'a': 1, 'b': 2 }, { 'a': 3, 'c': 3 }, function(a, b) {
1486 assert.deepEqual(func({}, expected, noop), expected);
2220 func = _[methodName];
2243 return func(string) === expected;
2254 return func(func(string)) === expected;
2272 return func(burred) === letter;
2285 return func('a b' + apos + postfix + ' c');
2306 var actual = lodashStable.map(['\xd7', '\xf7'], func);
2314 assert.strictEqual(func(Object(string)), converted);
2315 assert.strictEqual(func({ 'toString': lodashStable.constant(string) }), converted);
2347 var actual = lodashStable.reduce(funcs, function(result, func) { argument
2348 return func(result);
2790 var func = _[methodName],
2797 var actual = func(object);
2812 var actual = func(arrayBuffer);
2826 actual = func(buffer);
2844 actual = func(array);
2856 assert.strictEqual(func(regexp).lastIndex, 3);
2871 return func(value).a === 1;
2880 var actual = func(Foo.prototype);
2889 assert.ok(func(new Foo) instanceof Foo);
2896 assert.ok(func(new Foo) instanceof Foo);
2904 assert.notOk(func(new Foo) instanceof Foo);
2921 var actual = func(object);
2949 var actual = func(object);
2972 assert.strictEqual(func(symbol), symbol);
2975 actual = func(object);
2990 assert.strictEqual(func(symbol), symbol);
3004 assert.deepEqual(func(element), {});
3032 result = func(object);
3044 actual = lodashStable.map(expected, func);
3080 actual = func(view);
3101 actual = func(object),
3106 assert.deepEqual(func(value), expected);
3116 var func = _[methodName],
3125 func(object, function() {
3138 var actual = func({ 'a': { 'b': 'c' } }, noop);
3150 var actual = func(value, customizer);
3154 actual = func(object, customizer);
4134 var func = _[methodName],
4145 var curried = func(run);
4173 var curries = lodashStable.map(collection, func),
4880 setProperty(root, 'setTimeout', function(func) { func(); }); argument
4897 var func = _[methodName];
4902 var actual = func([2, 1], [2, 3]);
4909 var actual = func([2, 1, 2, 3], [3, 4], [3, 2]);
4919 return func(array, [value]);
4924 actual = lodashStable.map(func([-0, 1], [1]), lodashStable.toString);
4931 assert.deepEqual(func([1, NaN, 3], [NaN, 5, NaN]), [1, 3]);
4946 assert.deepEqual(func(array1, array2), [LARGE_ARRAY_SIZE]);
4956 return func(array, largeArray);
4962 actual = lodashStable.map(func([-0, 1], largeArray), lodashStable.toString);
4970 assert.deepEqual(func([1, NaN, 3], largeArray), [1, 3]);
4980 assert.deepEqual(func([object1, object2], largeArray), [object2]);
4988 assert.deepEqual(func(args, 3, { '0': 1 }), [1, 2, 3]);
4989 assert.deepEqual(func(null, array, 1), []);
4990 assert.deepEqual(func(array, args, null), [null]);
5665 var func = _[methodName],
5675 func(object, isBindAll ? 'b' : { 'a': 1 });
5868 func = _[methodName];
5888 assert.strictEqual(func(objects, function(object) { return object.a; }), expected[0]);
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]);
5923 return func(value, { 'a': 3 });
5984 assert.strictEqual(wrapped[methodName](), func(lodashStable.filter(array, isEven)));
5994 var func = _[methodName];
6002 func(array, function() {
6011 var func = _[methodName];
6016 var actual = func({ 'a': 1, 'b': 2, 'c': 3 }, function(n) {
6036 func(object, function() {
6077 var func = _[methodName],
6097 func(collection, resolve(values[2]), 2),
6098 func(collection, resolve(values[1]), 2)
6116 func(collection, resolve(1), fromIndex),
6117 func(collection, resolve(undefined), fromIndex),
6118 func(collection, resolve(''), fromIndex)
6131 return func(collection, resolve(values[0]), fromIndex);
6147 func(collection, resolve(values[0]), 0.1),
6148 func(collection, resolve(values[0]), NaN),
6149 func(collection, resolve(values[0]), '1')
6164 func(collection, resolve(values[2]), -1),
6165 func(collection, resolve(values[1]), -1)
6178 return func(collection, resolve(values[0]), fromIndex);
6192 func = _[methodName],
6198 assert.strictEqual(func(array, resolve(3)), 2);
6204 assert.strictEqual(func(array, resolve(1), 2), 3);
6215 func(array, resolve(undefined), fromIndex),
6216 func(array, resolve(1), fromIndex),
6217 func(array, resolve(''), fromIndex)
6227 assert.strictEqual(func(array, resolve(2), -3), 4);
6237 return func(array, resolve(1), fromIndex);
6249 return func(array, resolve(1), fromIndex);
6258 assert.strictEqual(func(array, resolve(2), 1.2), 1);
6436 var func = _[methodName],
6446 var actual = func(array, duplicate),
6456 assert.deepEqual(func(objects, 'a'), array);
6467 var actual = func(new Foo, identity);
6481 return index ? func(collection, value) : func(collection);
6495 return index ? func(collection) : func();
6505 assert.deepEqual(func(1), []);
6512 assert.deepEqual(func(object, identity), [1, 2]);
6604 var func = _.flatten;
6606 func = _.flattenDeep;
6608 func = _.flattenDepth;
6610 assert.deepEqual(func([expected]), expected);
6677 var func = _[methodName],
6684 combined = isFlow ? func(add, square, fixed) : func(fixed, square, add);
6692 assert.notStrictEqual(func(noop), noop);
6700 var combined = index ? func([]) : func();
6716 ? func(_.head, curried)
6717 : func(curried, _.head);
6745 ? func(map3, filter3, _.compact, take3)
6746 : func(take3, _.compact, filter3, map3);
6772 ? func(getProp, _.uniq)
6773 : func(_.uniq, getProp);
6820 var func = _[methodName];
6831 func(new Foo, function(value, key) { keys.push(key); });
6841 var func = _[methodName];
6849 func(object, function(value, prop) { props.push(prop); });
6980 func = _[methodName],
6989 if (func) {
6993 func(array, function() {
7017 if (func) {
7040 func(array, function() {
7055 func = _[methodName],
7063 if (func) {
7065 func(array, function(value, key) {
7127 var func = _[methodName];
7137 if (func) {
7139 func(new Foo, function(value) { values.push(value); });
7150 func = _[methodName];
7155 if (func) {
7156 assert.strictEqual(func(array, Boolean), array);
7165 var func = _[methodName];
7170 if (func) {
7173 func(object, function() { result = true; }, 0);
7198 var func = _[methodName],
7206 if (func) {
7210 func(array, function() {
7226 var func = _[methodName],
7234 if (func) {
7238 func(object, function() {
7259 var func = _[methodName],
7273 return func(value, { 'a': 1 });
7288 assert.deepEqual(func({}, new Foo), expected);
7297 assert.deepEqual(func({}, { 'a': 1 }, fn), { 'a': 1, 'b': 2 });
7304 assert.deepEqual(func({ 'a': 1 }, undefined, { 'b': 2 }, null), { 'a': 1, 'b': 2 });
7318 var object = func(value, source);
7325 return lodashStable.isEqual(func(value), {});
7342 assert.deepEqual(lodashStable.reduce(array, func, { 'a': 0 }), expected);
7343 assert.deepEqual(lodashStable.reduce(fn, func, { 'a': 0 }), expected);
7362 var func = _[methodName];
7370 var actual = func(new Foo, { 'b': 2 });
7376 var func = _[methodName];
7392 func(object, { 'a': value });
7399 var func = _[methodName],
7410 func(object, source, function() {
7427 func(object, source, function() {
7438 func(object, source, function() {
7451 var actual = func({ 'a': 1 }, callback);
7454 actual = func({ 'a': 1 }, callback, { 'c': 3 });
7464 var func = _[methodName];
7469 if (func) {
7473 func(array, function(value, other) {
7488 if (func) {
7492 func(object, function(value, other) {
7823 var func = _[methodName],
7838 assert.strictEqual(func(object, path), true);
7846 assert.strictEqual(func(object, 'a'), true);
7855 assert.strictEqual(func(object, path), true);
7859 assert.strictEqual(func(object, path), false);
7875 return func(object, index ? [path] : path);
7885 assert.strictEqual(func(args, 1), true);
7894 assert.strictEqual(func(array, path), true);
7906 return func(object, key);
7929 assert.strictEqual(func(object, symbol), true);
7930 assert.strictEqual(func(object, symbol2), true);
7943 assert.strictEqual(func(object, path), true);
7954 return func(value, 0);
7968 return func({ 'a': value }, path);
7982 assert.strictEqual(func(new Foo, path), !isHas);
7993 assert.strictEqual(func(new Foo, path), !isHas);
8005 return func(value, path);
8020 return func(value, path);
8036 return func(object, path);
8051 return func({ 'a': value }, path);
8441 var func = _[methodName];
8446 var actual = func([2, 1], [2, 3]);
8453 var actual = func([2, 1, 2, 3], [3, 4], [3, 2]);
8460 var actual = func([1, 1, 3, 2, 2], [5, 2, 2, 1, 4], [2, 1, 1]);
8467 var actual = func([1, 1, 3, 2, 2]);
8477 assert.deepEqual(func(array, args), expected);
8478 assert.deepEqual(func(args, array), expected);
8488 return lodashStable.map(func(values, [value]), lodashStable.toString);
8497 var actual = func([1, NaN, 3], [NaN, 5, NaN]);
8509 return lodashStable.map(func(values, largeArray), lodashStable.toString);
8519 assert.deepEqual(func([1, NaN, 3], largeArray), [NaN]);
8528 assert.deepEqual(func([object], largeArray), [object]);
8529 assert.deepEqual(func(lodashStable.range(LARGE_ARRAY_SIZE), [1]), [1]);
8536 assert.deepEqual(func(array, 3, { '0': 1 }, null), []);
8537 assert.deepEqual(func(null, array, null, [2, 3]), []);
8538 assert.deepEqual(func(array, null, args, null), []);
10713 var func = _[methodName],
10723 return func(value);
10727 assert.strictEqual(func(MAX_INTEGER), !isSafe);
10737 return func(value);
10751 return index ? func(value) : func();
10756 assert.strictEqual(func(args), false);
10757 assert.strictEqual(func([1, 2, 3]), false);
10758 assert.strictEqual(func(true), false);
10759 assert.strictEqual(func(new Date), false);
10760 assert.strictEqual(func(new Error), false);
10761 assert.strictEqual(func({ 'a': 1 }), false);
10762 assert.strictEqual(func(/x/), false);
10763 assert.strictEqual(func('a'), false);
10764 assert.strictEqual(func(symbol), false);
12958 var func = _[methodName],
12964 var actual = func({ 'a': 1, 'b': 1 }).sort();
12978 actual = func(new Foo).sort();
12989 var actual = func(array).sort();
13000 var actual = func(array).sort();
13011 actual = func([1]).sort();
13025 return func(value).sort();
13039 var result = func(value).sort();
13055 var result = func(value).sort();
13066 var actual = func(Object('abc')).sort();
13077 var actual = func(object).sort();
13088 actual = func(Object('a')).sort();
13099 actual = func(object).sort();
13111 var actual = lodashStable.map(primitives, func);
13116 assert.deepEqual(func(0), isKeys ? [] : ['a']);
13127 assert.deepEqual(func(Foo.prototype), expected);
13130 assert.deepEqual(func(Foo.prototype), expected);
13134 assert.deepEqual(func(Fake.prototype), ['constructor']);
13143 var result = index ? func(value) : func();
13315 func = _[methodName],
13321 assert.strictEqual(func(array, resolve(3)), 5);
13327 assert.strictEqual(func(array, resolve(1), 2), 0);
13338 func(array, resolve(undefined), fromIndex),
13339 func(array, resolve(1), fromIndex),
13340 func(array, resolve(''), fromIndex)
13350 assert.strictEqual(func(array, resolve(2), -3), 1);
13360 return func(array, resolve(1), fromIndex);
13374 return func(array, resolve(3), fromIndex);
13383 assert.strictEqual(func(array, resolve(2), 4.2), 4);
13392 var func = _[methodName],
13403 return index ? func(array) : func();
13416 assert.strictEqual(func(array, 4), -1);
13417 assert.strictEqual(func(array, 4, true), -1);
13418 assert.strictEqual(func(array, undefined, true), -1);
13420 assert.strictEqual(func(empty, undefined), -1);
13421 assert.strictEqual(func(empty, undefined, true), -1);
13430 assert.strictEqual(func(array, undefined), -1);
13431 assert.strictEqual(func(array, 0, true), -1);
13442 assert.strictEqual(func(array, NaN, true), isIndexOf ? 2 : 3);
13446 assert.strictEqual(func(array, NaN), isIndexOf ? 1 : 5);
13447 assert.strictEqual(func(array, NaN, 2), isIndexOf ? 3 : 1);
13448 assert.strictEqual(func(array, NaN, -2), isIndexOf ? 5 : 3);
13455 assert.strictEqual(func([-0], 0), 0);
13456 assert.strictEqual(func([0], -0), 0);
13709 var func = _[methodName],
13720 var actual = func(new Foo, function(value, key) { return key; });
13731 return index ? func(object) : func();
14840 var func = _._memoizeCapped;
14845 if (func) {
14846 var memoized = func(identity),
15681 var func = _[methodName],
15690 assert.strictEqual(func([curr, past]), isMax ? curr : past);
15697 assert.strictEqual(func(array), isMax ? 499999 : 0);
15715 func = _[methodName],
15721 var actual = func(array, function(n) {
15732 actual = func(objects, 'a');
15737 actual = func(arrays, 0);
15748 var actual = func([object, { 'a': value }], function(object) {
15884 function message(func, chain) { argument
15885 … return (func === _ ? 'lodash' : 'given') + ' function should ' + (chain ? '' : 'not ') + 'chain';
15888 lodashStable.each([_, Wrapper], function(func) { argument
15891 if (func === _) {
15894 _.mixin(func, source, options);
15896 var wrapped = func(array),
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));
15906 reset(func);
15950 lodashStable.each([_, Wrapper], function(func) { argument
15952 if (func === _) {
15959 wrapped = _(func);
15963 reset(func);
16392 var func = _.nthArg(index);
16393 return func.apply(undefined, args);
16403 var func = _.nthArg(-n);
16404 return func.apply(undefined, args);
16417 var func = n ? _.nthArg(n) : _.nthArg();
16418 return func.apply(undefined, args);
16427 var func = _.nthArg(n);
16428 return func.apply(undefined, args);
16437 var func = _.nthArg(1);
16438 assert.strictEqual(func(), undefined);
16448 var func = _.nthArg(n);
16449 return func.apply(undefined, args);
16567 func = _[methodName],
16585 assert.deepEqual(func(object, resolve(object, 'a')), { 'b': 2, 'c': 3, 'd': 4 });
16586 assert.deepEqual(func(object, resolve(object, ['a', 'c'])), expected);
16595 assert.deepEqual(func(new Foo, resolve(object, ['a', 'c'])), expected);
16606 return func(object, resolve(object, key));
16633 actual = func(foo, resolve(foo, 'a'));
16665 actual = func(foo, resolve(foo, symbol));
16672 actual = func(foo, resolve(foo, symbol2));
16688 assert.deepEqual(func(array, resolve(array, ['0', '2'])), { '1': 2 });
17167 var func = _[methodName],
17175 assert.strictEqual(func(string, 2), string);
17176 assert.strictEqual(func(string, 3), string);
17183 assert.strictEqual(func(string, length), string);
17192 assert.strictEqual(func(string, length), actual);
17201 assert.strictEqual(func(null, 2, chars), expected);
17202 assert.strictEqual(func(undefined, 2, chars), expected);
17203 assert.strictEqual(func('', 2, chars), expected);
17272 func = (index ? (lodashBizarro || {}) : _).parseInt;
17274 if (func) {
17278 func(whitespace + string, 10),
17279 func(whitespace + string)
17285 func(whitespace + string),
17286 func(whitespace + string, 16)
17324 var func = _[methodName],
17326 ph = func.placeholder;
17331 var par = func(identity, 'a');
17339 par = func(fn, 'a'),
17349 par = func(fn);
17357 var par = func(identity);
17365 par = func(fn, ph, 'b', ph);
17374 par = func(fn, ph, 'c', ph);
17385 par = func(fn, _ph, 'b', ph),
17400 par = func(fn, 'a');
17413 par = func(Foo);
17426 var par1 = func(greet, 'hi'),
17427 par2 = func(par1, 'barney'),
17428 par3 = func(par1, 'pebbles');
17439 curried = _.curry(func(fn, 1), 2);
17450 par = func(curried, ph, 'b', ph, 'd');
17660 var func = _[methodName],
17662 par1 = func(fn, 1),
17666 var par2 = func(par1, 2);
17673 var par1 = func(fn, 1),
17674 par2 = func(par1, 2);
17843 func = _[methodName],
17862 assert.deepEqual(func(object, resolve(object, 'a')), { 'a': 1 });
17863 assert.deepEqual(func(object, resolve(object, ['a', 'c'])), expected);
17873 assert.deepEqual(func(foo, resolve(foo, ['a', 'c'])), expected);
17884 return func(object, resolve(object, key));
17910 actual = func(foo, resolve(foo, [symbol, symbol2, symbol3]));
17930 assert.deepEqual(func(array, resolve(array, '1')), { '1': 2 });
18285 var func = _[methodName],
18290 ? func.apply(undefined, [array].concat(values))
18291 : func(array, values);
18605 var func = _[methodName],
18615 assert.deepEqual(func(4), resolve([0, 1, 2, 3]));
18616 assert.deepEqual(func(-4), resolve([0, -1, -2, -3]));
18622 assert.deepEqual(func(1, 5), resolve([1, 2, 3, 4]));
18623 assert.deepEqual(func(5, 1), resolve([5, 4, 3, 2]));
18629 assert.deepEqual(func(0, -4, -1), resolve([0, -1, -2, -3]));
18630 assert.deepEqual(func(5, 1, -1), resolve([5, 4, 3, 2]));
18631 assert.deepEqual(func(0, 20, 5), resolve([0, 5, 10, 15]));
18637 assert.deepEqual(func(1, 4, 0), [1, 1, 1]);
18643 assert.deepEqual(func(1, 5, 20), [1]);
18649 assert.deepEqual(func(0, -4, -1), resolve([0, -1, -2, -3]));
18650 assert.deepEqual(func(21, 10, -3), resolve([21, 18, 15, 12]));
18656 var actual = func(-0, 1);
18665 assert.deepEqual(func(value), []);
18666 assert.deepEqual(func(value, 1), [0]);
18668 assert.deepEqual(func(), []);
18677 func('1'),
18678 func('0', 1),
18679 func(0, 1, '1'),
18680 func(NaN),
18681 func(NaN, NaN)
18695 var actual = lodashStable.map(collection, func);
18918 var func = _[methodName],
18925 var actual = func(['a', 'b', 'c'], function(accumulator, value) {
18940 actual.push(func(value, noop));
18954 return func(value, noop, 'x');
18964 var actual = func([], noop, undefined);
18976 assert.strictEqual(func(array, noop), undefined);
18981 assert.strictEqual(func(object, noop), undefined);
19027 func = _[methodName],
19034 var actual = func([0], function(value, index, array) {
19045 assert.deepEqual(func(objects, 'a'), [objects[isFilter ? 1 : 0]]);
19051 assert.deepEqual(func(objects, objects[1]), [objects[isFilter ? 1 : 0]]);
19362 var func = _[methodName];
19370 assert.strictEqual(func(object, path), 1);
19381 return func(object, key);
19394 assert.strictEqual(func(object, symbol), 1);
19407 assert.strictEqual(func(object, path), 2);
19417 assert.strictEqual(func(object, path), 1);
19425 assert.strictEqual(func(object, ['a', 'b', 'c']), 4);
19432 assert.strictEqual(func(object, 'a[]'), 1);
19439 assert.strictEqual(func({}, pair[0]), undefined);
19440 assert.strictEqual(func({ '': 3 }, pair[1]), 3);
19455 assert.strictEqual(func(object, path), 8);
19463 assert.strictEqual(func(null, path), undefined);
19464 assert.strictEqual(func(undefined, path), undefined);
19477 return func(value, path);
19490 assert.strictEqual(func(object, path), undefined);
19500 assert.strictEqual(func(object, path), null);
19511 assert.strictEqual(func(0, path), 2);
19525 return [func(object, path, value), func(null, path, value)];
19535 assert.strictEqual(func({}, [], 'a'), 'a');
19735 var func = _[methodName],
19742 var actual = func(4.006);
19749 var actual = func(4.006, 0);
19756 var actual = func(4.016, 2);
19759 actual = func(4.1, 2);
19766 var actual = func(4160, -2);
19773 var actual = func(4.006, NaN);
19778 actual = func(4.016, 2.6);
19781 actual = func(4.016, '+2');
19788 var actual = func(5e1, 2);
19791 actual = func('5e', 1);
19794 actual = func('5e1e1', 1);
19805 return 1 / func.apply(undefined, args);
19828 var actual = func(Infinity);
19831 actual = func(Infinity, 0);
19834 actual = func(Infinity, 2);
19837 actual = func(Infinity, -2);
19840 actual = func(Infinity, 2);
19843 actual = func(Infinity, 2);
19850 var actual = func(-Infinity);
19853 actual = func(-Infinity, 0);
19856 actual = func(-Infinity, 2);
19859 actual = func(-Infinity, -2);
19862 actual = func(-Infinity, 2);
19865 actual = func(-Infinity, 2);
19872 var actual = func(NaN);
19875 actual = func(NaN, 0);
19878 actual = func(NaN, 2);
19881 actual = func(NaN, -2);
19884 actual = func(NaN, 2);
19887 actual = func(NaN, 2);
19902 'setTimeout': function(func) { func(); } argument
20095 var func = _[methodName],
20107 actual = func(object, path, updater);
20122 func(object, key, updater);
20149 actual = func(object, path, updater);
20161 actual = func(object, path, updater);
20173 func(object, ['a', 'b', 'c'], updater);
20182 func(object, 'a[]', updater);
20192 func(object, pair[0], updater);
20195 func(object, pair[1], updater);
20211 func(object, path, updater);
20223 var actual = func(object, path, updater);
20241 return [func(value, 'a.b', updater), func(value, ['a', 'b'], updater)];
20256 func(object, path, updater);
20266 func(object, ['1a', '2b', '3c'], updater);
20285 func(object, 'a', updater);
20787 var func = _[methodName];
20820 var actual = func(objects, ['a', 'b']);
20827 var actual = func(objects, ['a', function(object) { return object.b; }]);
20835 var actual = func(value, ['a', 'c']);
20844 var actual = func(objects.concat(null, undefined), ['a', 'b']);
20860 var funcs = [func, lodashStable.partialRight(func, 'bogus')];
20869 var actual = lodashStable.map(funcs, function(func) { argument
20870 return lodashStable.reduce([props], func, objects);
20883 var func = _[methodName],
20894 return func(array, value);
20908 return func(array, value);
20921 return [func(array, 1), func(array, undefined), func(array, NaN)];
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);
20953 assert.strictEqual(func(array, null), isSortedIndex ? 0 : 2);
20954 assert.strictEqual(func(array, 1), 0);
20955 assert.strictEqual(func(array, 'a'), 0);
20966 assert.strictEqual(func(array, symbol3), isSortedIndex ? 0 : 2);
20967 assert.strictEqual(func(array, 1), 0);
20968 assert.strictEqual(func(array, 'a'), 0);
20977 var func = _[methodName],
20985 func([30, 50], 40, function(assert) {
20996 actual = func(objects, { 'x': 40 }, 'x');
21013 var actual = func(array, value, function(value) {
21034 var func = _[methodName],
21041 assert.deepEqual(func(sorted, 5), isSortedIndexOf ? 2 : 3);
21259 var func = _[methodName],
21268 assert.strictEqual(func(Object(string), chr), true);
21269 assert.strictEqual(func({ 'toString': lodashStable.constant(string) }, chr), true);
21275 assert.strictEqual(func(string, Object(chr)), true);
21276 assert.strictEqual(func(string, { 'toString': lodashStable.constant(chr) }), true);
21284 assert.strictEqual(func(string, 'b', Object(position)), true);
21285 …assert.strictEqual(func(string, 'b', { 'toString': lodashStable.constant(String(position)) }), tru…
21294 return func(string, '', position);
21304 var func = _[methodName];
21323 return index ? func.call({}) : func();
21325 return func(value);
21358 var func = _[methodName],
21364 assert.strictEqual(func(), isAddSub ? 0 : 1);
21370 assert.strictEqual(func(6), 6);
21371 assert.strictEqual(func(6, undefined), 6);
21372 assert.strictEqual(func(undefined, 4), 4);
21383 var result = index ? func(undefined, value) : func(value);
21394 assert.deepEqual(func(0, {}), NaN);
21395 assert.deepEqual(func({}, 0), NaN);
21402 assert.deepEqual(func(0, symbol), NaN);
21403 assert.deepEqual(func(symbol, 0), NaN);
21480 func = _[methodName];
21485 assert.strictEqual(func(array), 12);
21494 return func(value);
21503 assert.strictEqual(func([1, undefined]), 1);
21509 assert.deepEqual(func([1, NaN]), NaN);
21515 assert.strictEqual(func(['1', '2']), '12');
22976 var func = _[methodName],
22982 func(noop, 32, 1);
22992 funced = func(function() { callCount++; });
23009 object = { 'funced': func(function() { actual.push(this); }, 32) },
23032 var funced = func(function() {
23097 var funced = func(function() {
23117 var funced = func(function() {
23140 var funced = func(function() {
23159 funced = func(function() { callCount++; }, 32);
23361 func = _[methodName];
23369 var actual = func(sparse);
23380 assert.deepEqual(func(object), ['a']);
23381 assert.deepEqual(func(args), array);
23387 var actual = func(array);
23397 var actual = func(document.getElementsByTagName('body'));
23413 var func = _[methodName],
23419 assert.strictEqual(func(-5.6), -5);
23420 assert.strictEqual(func('5.6'), 5);
23421 assert.strictEqual(func(), 0);
23422 assert.strictEqual(func(NaN), 0);
23425 assert.strictEqual(func(Infinity), expected);
23426 assert.strictEqual(func(-Infinity), -expected);
23432 assert.strictEqual(1 / func(-0), -Infinity);
23470 var func = _[methodName];
23482 var result = func(value);
23492 var func = _[methodName],
23519 var actual = lodashStable.map(values, func);
23549 return [func(value), func(Object(value)), func(-value), func(Object(-value))];
23589 return [func(mod(value)), func(Object(mod(value)))];
23610 … return [func(mod(value)), func(Object(mod(value))), func(mod(upper)), func(Object(mod(upper)))];
23629 return [func(mod(value)), func(Object(mod(value)))];
23646 var actual = lodashStable.map(values, func);
23665 return index ? func(value) : func();
23717 var actual = lodashStable.map(values, func);
23752 var func = _[methodName],
23759 actual = lodashStable.sortBy(func(object), 0);
23773 actual = lodashStable.sortBy(func(new Foo), 0);
23782 actual = lodashStable.sortBy(func(object), 0);
23794 assert.deepEqual(func(map), [['a', 1], ['b', 2]]);
23808 assert.deepEqual(func(set), [[1, 1], [2, 2]]);
23819 var actual = lodashStable.sortBy(func(string), 0);
24238 var func = _[methodName],
24255 assert.strictEqual(func(string), expected);
24264 assert.strictEqual(func(object), expected);
24273 assert.strictEqual(func(string, '_-'), expected);
24283 assert.strictEqual(func(string, object), expected);
24290 assert.strictEqual(func(null, chars), '');
24291 assert.strictEqual(func(undefined, chars), '');
24292 assert.strictEqual(func('', chars), '');
24302 assert.strictEqual(func(string, undefined), expected);
24303 assert.strictEqual(func(string, ''), string);
24311 actual = lodashStable.map([string, string, string], func);
24598 var func = _[methodName];
24603 var actual = func([2], [1, 2]);
24610 var actual = func([2], [1, 2], [2, 3]);
24617 var actual = func([1, 3, 2], [1, [5]], [2, [4]]);
24625 assert.deepEqual(func(array, 3, { '0': 1 }, null), array);
24626 assert.deepEqual(func(null, array, null, [2, 1]), [0, 2, 1]);
24627 assert.deepEqual(func(array, null, args, null), [0, 1, 2, 3]);
24700 var func = _[methodName],
24712 assert.deepEqual(func(array), [2, 1]);
24719 assert.deepEqual(func(array), [1, 2]);
24725 assert.deepEqual(func(objects), objects);
24731 var actual = lodashStable.map(func([-0, 0]), lodashStable.toString);
24738 assert.deepEqual(func([NaN, NaN]), [NaN]);
24754 assert.deepEqual(func(largeArray), expected);
24764 var actual = lodashStable.map(func(largeArray), lodashStable.toString);
24781 assert.deepEqual(func(largeArray), expected);
24789 assert.deepEqual(func(largeArray), largeArray);
24820 assert.deepEqual(func(largeArray), expected);
24840 assert.deepEqual(func(largeArray), expected);
24864 var func = _[methodName],
24876 var actual = func(objects, function(object) {
24890 var actual = func(largeArray, String);
24900 func(objects, function() {
24911 actual = func(objects, 'a');
24920 actual = func(arrays, 0);
24935 var actual = func([['a'], ['a'], ['b']], iteratee);
25219 var func = _[methodName],
25229 func(object, path, function(n) {
25273 var func = _[methodName],
25280 actual = func(object).sort();
25289 actual = func(object).sort();
25303 actual = func(new Foo).sort();
25315 return func(value).sort();
25505 var p = _.wrap(lodashStable.escape, function(func, text) { argument
25506 return '<p>' + func(text) + '</p>';
25542 var p = _.wrap(lodashStable.escape, function(func) { argument
25543 return '<p>' + func(this.text) + '</p>';
25556 var func = _[methodName];
25561 var actual = func([2, 1], [2, 3]);
25568 var actual = func([2, 1], [2, 3], [3, 4]);
25571 actual = func([1, 2], [2, 1], [1, 2]);
25579 actual = func(array, array, array);
25587 var actual = func([1, 1, 2, 5], [2, 2, 3, 5], [3, 4, 5, 5]);
25590 actual = func([1, 1]);
25598 assert.notStrictEqual(func(array), array);
25605 assert.deepEqual(func(array, 3, null, { '0': 1 }), array);
25612 assert.deepEqual(func(array, 3, { '0': 1 }, null), array);
25613 assert.deepEqual(func(null, array, null, [2, 3]), [1, 3]);
25614 assert.deepEqual(func(array, null, args, null), [3]);
25697 var func = _[methodName],
25704 var actual = func(['barney', 'fred'], [36, 40]);
25711 assert.deepEqual(func(['a'], [1, 2]), { 'a': 1 });
25717 assert.deepEqual(func(['a', 'b'], [1]), { 'a': 1, 'b': undefined });
25725 assert.deepEqual(func([path], [1]), expected);
25737 assert.deepEqual(actual, _.take(_.filter(_.map(func(props, values), square), isEven)));
25803 var func = _[methodName];
25804 func = lodashStable.bind(index ? func.apply : func.call, func, null);
25829 var actual = func(pair[0]);
25831 assert.deepEqual(func(actual), actual.length ? pair[0] : []);
25843 var actual = func(pair[0]);
25847 actual = func(actual);
25858 return func([value, value, value]);
25868 assert.deepEqual(func(array), [[1, 3], [2, 4]]);
25875 assert.deepEqual(func(func(func(func(expected)))), expected);
26715 var func = _[methodName];
26724 return index ? func(value) : func();
26831 func = _[methodName];
26834 return index ? func(value) : func();
26864 func = _[methodName];
26868 actual = func(array, 'toFixed');
26871 actual = func(array, 1);
26874 actual = func(array);
26888 func = _[methodName];
26894 index ? func(value) : func();
26911 func = _[methodName],
26916 var wrapper = func(_.bind(fn, object));
26919 wrapper = _.bind(func(fn), object);
26922 object.wrapper = func(fn);