Lines Matching refs:strictEqual
770 assert.strictEqual((lodashModule || {}).moduleName, 'lodash');
781 assert.strictEqual((shimmedModule || {}).moduleName, 'shimmed');
791 assert.strictEqual((underscoreModule || {}).moduleName, 'underscore');
813 assert.strictEqual(actual, _.VERSION);
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);
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);
1015 assert.strictEqual(func(NaN, 0, [NaN]), true);
1016 assert.strictEqual(func(NaN, 'a', { 'a': NaN }), true);
1032 assert.strictEqual(actual, false, message || '');
1079 assert.strictEqual(cache.has(key), true);
1080 assert.strictEqual(cache.delete(key), true);
1081 assert.strictEqual(cache.has(key), false);
1082 assert.strictEqual(cache.get(key), undefined);
1083 assert.strictEqual(cache.delete(key), false);
1084 assert.strictEqual(cache.set(key, value), cache);
1085 assert.strictEqual(cache.has(key), true);
1088 assert.strictEqual(cache.size, isLarge ? LARGE_ARRAY_SIZE : keys.length);
1089 assert.strictEqual(cache.clear(), undefined);
1102 assert.strictEqual(cache.get(key), 2);
1175 assert.strictEqual(_.add(6, 4), 10);
1176 assert.strictEqual(_.add(-6, 4), -2);
1177 assert.strictEqual(_.add(-6, -4), -10);
1183 assert.strictEqual(_.add('6', '4'), '64');
1184 assert.strictEqual(_.add('x', 'y'), 'xy');
1202 … assert.strictEqual(after(5, 5), 1, 'after(n) should invoke `func` after being called `n` times');
1203 …assert.strictEqual(after(5, 4), 0, 'after(n) should not invoke `func` before being called `n` time…
1204 assert.strictEqual(after(0, 0), 0, 'after(0) should not invoke `func` immediately');
1205 assert.strictEqual(after(0, 1), 1, 'after(0) should invoke `func` when called once');
1211 assert.strictEqual(after(NaN, 1), 1);
1221 assert.strictEqual(object.after(), 2);
1222 assert.strictEqual(object.count, 2);
1301 assert.strictEqual(object.capped(), object);
1326 assert.strictEqual(includes('b')(array, 2), true);
1330 assert.strictEqual(includes('b')(array, 2), true);
1346 assert.strictEqual(_.extend, _.assignIn);
1461 assert.strictEqual(_.extendWith, _.assignInWith);
1625 assert.strictEqual(count, expected);
1663 assert.strictEqual(_.attempt(lodashStable.constant('x')), 'x');
1720 assert.strictEqual(_(lodashStable.constant('x')).attempt(), 'x');
1753 …assert.strictEqual(before(5, 4), 4, 'before(n) should invoke `func` before being called `n` times'…
1754 …assert.strictEqual(before(5, 6), 4, 'before(n) should not invoke `func` after being called `n - 1`…
1755 assert.strictEqual(before(0, 0), 0, 'before(0) should not invoke `func` immediately');
1756 assert.strictEqual(before(0, 1), 0, 'before(0) should not invoke `func` when called');
1762 assert.strictEqual(before(NaN, 1), 0);
1772 assert.strictEqual(object.before(), 1);
1773 assert.strictEqual(object.count, 1);
1822 assert.strictEqual(actual[1], 'a');
1829 assert.strictEqual(actual[1], 'b');
1885 assert.strictEqual(bound.length, 0);
1888 assert.strictEqual(bound.length, 0);
1901 assert.strictEqual(bound().a, 1);
1902 assert.strictEqual(newBound.a, undefined);
1951 assert.strictEqual(new bound(true), object);
2117 assert.strictEqual(array.pop, arrayProto.pop);
2150 assert.strictEqual(bound(), 'fred says: hi');
2156 assert.strictEqual(bound(), 'fred says: hi!');
2210 assert.strictEqual(new bound(true), object);
2314 assert.strictEqual(func(Object(string)), converted);
2315 assert.strictEqual(func({ 'toString': lodashStable.constant(string) }), converted);
2322 assert.strictEqual(_('foo bar')[methodName](), converted);
2351 assert.strictEqual(actual, 'enable6HFormat');
2363 assert.strictEqual(_.camelCase('12 feet'), '12Feet');
2364 assert.strictEqual(_.camelCase('enable 6h format'), 'enable6HFormat');
2365 assert.strictEqual(_.camelCase('enable 24H format'), 'enable24HFormat');
2366 assert.strictEqual(_.camelCase('too legit 2 quit'), 'tooLegit2Quit');
2367 assert.strictEqual(_.camelCase('walk 500 miles'), 'walk500Miles');
2368 assert.strictEqual(_.camelCase('xhr2 request'), 'xhr2Request');
2375 assert.strictEqual(_.camelCase(string), 'safeHtml');
2379 assert.strictEqual(_.camelCase(string), 'escapeHtmlEntities');
2383 assert.strictEqual(_.camelCase(string), 'xmlHttpRequest');
2396 assert.strictEqual(_.capitalize('fred'), 'Fred');
2397 assert.strictEqual(_.capitalize('Fred'), 'Fred');
2398 assert.strictEqual(_.capitalize(' fred'), ' fred');
2421 assert.strictEqual(_.castArray(array), array);
2453 assert.strictEqual(_.chain(wrapped), wrapped);
2454 assert.strictEqual(wrapped.chain(), wrapped);
2603 assert.strictEqual(_.clamp(5, 3), 3);
2604 assert.strictEqual(_.clamp(1, 3), 1);
2610 assert.strictEqual(_.clamp(-10, -5, 5), -5);
2611 assert.strictEqual(_.clamp(-10.2, -5.5, 5.5), -5.5);
2612 assert.strictEqual(_.clamp(-Infinity, -5, 5), -5);
2618 assert.strictEqual(_.clamp(10, -5, 5), 5);
2619 assert.strictEqual(_.clamp(10.6, -5.6, 5.4), 5.4);
2620 assert.strictEqual(_.clamp(Infinity, -5, 5), 5);
2626 assert.strictEqual(_.clamp(-4, -5, 5), -4);
2627 assert.strictEqual(_.clamp(-5, -5, 5), -5);
2628 assert.strictEqual(_.clamp(-5.5, -5.6, 5.6), -5.5);
2634 assert.strictEqual(_.clamp(4, -5, 5), 4);
2635 assert.strictEqual(_.clamp(5, -5, 5), 5);
2636 assert.strictEqual(_.clamp(4.5, -5.1, 5.2), 4.5);
2642 assert.strictEqual(1 / _.clamp(0, -5, 5), Infinity);
2648 assert.strictEqual(1 / _.clamp(-10, 0, 5), Infinity);
2654 assert.strictEqual(1 / _.clamp(-0, -5, 5), -Infinity);
2660 assert.strictEqual(1 / _.clamp(-10, -0, 5), -Infinity);
2770 assert.strictEqual(actual, clone['v' + (LARGE_ARRAY_SIZE - 1)]);
2803 assert.strictEqual(actual, object);
2813 assert.strictEqual(actual.byteLength, arrayBuffer.byteLength);
2828 assert.strictEqual(actual.byteLength, buffer.byteLength);
2829 assert.strictEqual(actual.inspect(), buffer.inspect());
2833 assert.strictEqual(actual[0], isDeep ? 2 : 1);
2846 assert.strictEqual(actual.index, 2);
2847 assert.strictEqual(actual.input, 'abcde');
2856 assert.strictEqual(func(regexp).lastIndex, 3);
2954 assert.strictEqual(actual[symbol], object[symbol]);
2955 assert.strictEqual(actual.a, object.a);
2972 assert.strictEqual(func(symbol), symbol);
2977 assert.strictEqual(typeof actual, 'object');
2978 assert.strictEqual(typeof actual.valueOf(), 'symbol');
2990 assert.strictEqual(func(symbol), symbol);
3084 assert.strictEqual(actual.buffer === view.buffer, !isDeep);
3085 assert.strictEqual(actual.byteOffset, view.byteOffset);
3086 assert.strictEqual(actual.length, view.length);
3151 assert.strictEqual(actual, value);
3322 assert.strictEqual(cond({ 'a': 1, 'b': 2, 'c': 3 }), 'a');
3323 assert.strictEqual(cond({ 'a': 0, 'b': 1, 'c': 2 }), 'b');
3324 assert.strictEqual(cond({ 'a': -1, 'b': 0, 'c': 1 }), 'c');
3354 assert.strictEqual(cond({ 'a': 1, 'b': 2, 'c': 3 }), 'a');
3355 assert.strictEqual(cond({ 'a': 0, 'b': 1, 'c': 2 }), 'b');
3356 assert.strictEqual(cond({ 'a': -1, 'b': 0, 'c': 1 }), 'c');
3363 assert.strictEqual(cond({ 'a': 1 }), undefined);
3382 assert.strictEqual(object.cond('a', 'b'), 2);
3398 assert.strictEqual(par(object), true);
3401 assert.strictEqual(par(object), true);
3476 assert.strictEqual(par({}), false);
3477 assert.strictEqual(count, 0);
3493 assert.strictEqual(par(Foo), false);
3494 assert.strictEqual(par(Bar), true);
3521 assert.strictEqual(par(new Foo), true);
3909 assert.strictEqual(curried.length, 0);
3910 assert.strictEqual(curried(1).length, 0);
3911 assert.strictEqual(curried(1, 2).length, 0);
3926 assert.strictEqual(new curried(true), object);
4068 assert.strictEqual(curried.length, 0);
4069 assert.strictEqual(curried(4).length, 0);
4070 assert.strictEqual(curried(3, 4).length, 0);
4085 assert.strictEqual(new curried(true), object);
4151 assert.strictEqual(actual, 3);
4204 assert.strictEqual(callCount, 0);
4207 assert.strictEqual(callCount, 1);
4211 assert.strictEqual(callCount, 1);
4215 assert.strictEqual(callCount, 2);
4248 assert.strictEqual(callCount, 0);
4251 assert.strictEqual(callCount, 1);
4265 assert.strictEqual(callCount, 0);
4268 assert.strictEqual(callCount, 1);
4289 assert.strictEqual(callCounts[0], 1);
4293 assert.strictEqual(callCounts[1], 1);
4299 assert.strictEqual(callCounts[0], 2);
4339 assert.strictEqual(withCount, 0);
4342 assert.strictEqual(withoutCount, 0);
4345 assert.strictEqual(withCount, 1);
4346 assert.strictEqual(withoutCount, 0);
4365 assert.strictEqual(callCount, 0);
4368 assert.strictEqual(callCount, 1);
4371 assert.strictEqual(callCount, 1);
4375 assert.strictEqual(callCount, 2);
4427 assert.strictEqual(callCount, 2);
4447 assert.strictEqual(callCount, 1);
4451 assert.strictEqual(callCount, 2);
4477 assert.strictEqual(callCount, 2);
4546 assert.strictEqual(actual.a, null);
4553 assert.strictEqual(actual.a, 1);
4631 assert.strictEqual(actual.a.b, null);
4648 assert.strictEqual(actual.a, noop);
4651 assert.strictEqual(actual.a.b, noop);
4661 assert.strictEqual(actual.a.b, 2);
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);
5060 assert.strictEqual(_.divide(6, 4), 1.5);
5061 assert.strictEqual(_.divide(-6, 4), -1.5);
5062 assert.strictEqual(_.divide(-6, -4), 1.5);
5068 assert.strictEqual(_.divide('6', '4'), 1.5);
5383 assert.strictEqual(wrapped.last(), _.last(expected));
5420 assert.strictEqual(_.endsWith(string, 'c'), true);
5426 assert.strictEqual(_.endsWith(string, 'b'), false);
5432 assert.strictEqual(_.endsWith(string, 'b', 2), true);
5439 assert.strictEqual(_.endsWith(string, 'c', position), true);
5462 assert.strictEqual(_.endsWith(string, '', position), true);
5469 assert.strictEqual(_.endsWith(string, 'ab', 2.2), true);
5481 assert.strictEqual(_.eq(), true);
5482 assert.strictEqual(_.eq(undefined), true);
5483 assert.strictEqual(_.eq(0, -0), true);
5484 assert.strictEqual(_.eq(NaN, NaN), true);
5485 assert.strictEqual(_.eq(1, 1), true);
5487 assert.strictEqual(_.eq(null, undefined), false);
5488 assert.strictEqual(_.eq(1, Object(1)), false);
5489 assert.strictEqual(_.eq(1, '1'), false);
5490 assert.strictEqual(_.eq(1, '1'), false);
5493 assert.strictEqual(_.eq(object, object), true);
5494 assert.strictEqual(_.eq(object, { 'a': 1 }), false);
5512 assert.strictEqual(_.escape(unescaped), escaped);
5518 assert.strictEqual(_.escape('abc'), 'abc');
5524 assert.strictEqual(_.escape(_.unescape(escaped)), escaped);
5531 assert.strictEqual(_.escape(chr), chr);
5547 assert.strictEqual(_.escapeRegExp(unescaped + unescaped), escaped + escaped);
5553 assert.strictEqual(_.escapeRegExp('abc'), 'abc');
5578 assert.strictEqual(lodashStable.every([true, 1, 'a'], identity), true);
5600 assert.strictEqual(_.every([true, null, true], function(value) {
5605 assert.strictEqual(count, 2);
5611 assert.strictEqual(_.every([undefined, undefined, undefined], identity), false);
5640 assert.strictEqual(_.every(objects, 'a'), false);
5641 assert.strictEqual(_.every(objects, 'b'), true);
5648 assert.strictEqual(_.every(objects, { 'a': 0 }), true);
5649 assert.strictEqual(_.every(objects, { 'b': 1 }), false);
5839 assert.strictEqual(actual, array);
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]);
5943 assert.strictEqual(_(array)[methodName](), expected);
5966 assert.strictEqual(wrapped.__wrapped__, array);
5984 assert.strictEqual(wrapped[methodName](), func(lodashStable.filter(array, isEven)));
6027 assert.strictEqual(actual, expected);
6062 assert.strictEqual(findCount, isFind ? 2 : 1);
6063 assert.strictEqual(mapCount, isFind ? 2 : 1);
6064 assert.strictEqual(actual, isFind ? 4 : square(LARGE_ARRAY_SIZE));
6198 assert.strictEqual(func(array, resolve(3)), 2);
6204 assert.strictEqual(func(array, resolve(1), 2), 3);
6227 assert.strictEqual(func(array, resolve(2), -3), 4);
6258 assert.strictEqual(func(array, resolve(2), 1.2), 1);
6686 assert.strictEqual(combined(1, 2), '9.0');
6701 assert.strictEqual(combined('a'), 'a');
6705 assert.strictEqual(combined.length, 0);
6719 assert.strictEqual(combined([1]), 1);
6752 assert.strictEqual(filterCount, 5, 'filterCount');
6753 assert.strictEqual(mapCount, 5, 'mapCount');
6799 assert.strictEqual(_.each, _.forEach);
6811 assert.strictEqual(_.eachRight, _.forEachRight);
7156 assert.strictEqual(func(array, Boolean), array);
7217 assert.strictEqual(count, 1);
7245 assert.strictEqual(count, 1);
7497 assert.strictEqual(values.length, 1);
7782 assert.strictEqual(_.gt(3, 1), true);
7783 assert.strictEqual(_.gt('def', 'abc'), true);
7789 assert.strictEqual(_.gt(1, 3), false);
7790 assert.strictEqual(_.gt(3, 3), false);
7791 assert.strictEqual(_.gt('abc', 'def'), false);
7792 assert.strictEqual(_.gt('def', 'def'), false);
7804 assert.strictEqual(_.gte(3, 1), true);
7805 assert.strictEqual(_.gte(3, 3), true);
7806 assert.strictEqual(_.gte('def', 'abc'), true);
7807 assert.strictEqual(_.gte('def', 'def'), true);
7813 assert.strictEqual(_.gte(1, 3), false);
7814 assert.strictEqual(_.gte('abc', 'def'), false);
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);
7885 assert.strictEqual(func(args, 1), true);
7894 assert.strictEqual(func(array, path), true);
7929 assert.strictEqual(func(object, symbol), true);
7930 assert.strictEqual(func(object, symbol2), true);
7943 assert.strictEqual(func(object, path), true);
7982 assert.strictEqual(func(new Foo, path), !isHas);
7993 assert.strictEqual(func(new Foo, path), !isHas);
8069 assert.strictEqual(_.head(array), 1);
8076 assert.strictEqual(_.head([]), undefined);
8092 assert.strictEqual(_.first, _.head);
8100 assert.strictEqual(wrapped.head(), 1);
8101 assert.strictEqual(wrapped.first(), 1);
8126 assert.strictEqual(wrapped.head().__wrapped__, array);
8127 assert.strictEqual(wrapped.first().__wrapped__, array);
8146 assert.strictEqual(actual, _[methodName](_.filter(array, isEven)));
8165 assert.strictEqual(_.identity(object), object);
8184 assert.strictEqual(_.includes(collection, 3), true);
8190 assert.strictEqual(_.includes(collection, 5), false);
8196 assert.strictEqual(_.includes(collection, 2, 1.2), true);
8203 assert.strictEqual(_(collection).includes(3), true);
8230 assert.strictEqual(_.includes(collection, 'bc'), true);
8231 assert.strictEqual(_.includes(collection, 'd'), false);
8274 assert.strictEqual(_.includes([1, NaN, 3], NaN), true);
8280 assert.strictEqual(_.includes([-0], 0), true);
8281 assert.strictEqual(_.includes([0], -0), true);
8378 assert.strictEqual(_.inRange(3, 5), true);
8379 assert.strictEqual(_.inRange(5, 5), false);
8380 assert.strictEqual(_.inRange(6, 5), false);
8386 assert.strictEqual(_.inRange(1, 1, 5), true);
8387 assert.strictEqual(_.inRange(3, 1, 5), true);
8388 assert.strictEqual(_.inRange(0, 1, 5), false);
8389 assert.strictEqual(_.inRange(5, 1, 5), false);
8397 assert.strictEqual(_.inRange(0, value), false);
8398 assert.strictEqual(_.inRange(0, value, 1), true);
8400 assert.strictEqual(_.inRange(0), false);
8408 assert.strictEqual(_.inRange(2, 5, 1), true);
8409 assert.strictEqual(_.inRange(-3, -2, -6), true);
8415 assert.strictEqual(_.inRange(0.5, 5), true);
8416 assert.strictEqual(_.inRange(1.2, 1, 5), true);
8417 assert.strictEqual(_.inRange(5.2, 5), false);
8418 assert.strictEqual(_.inRange(0.5, 1, 5), false);
8726 assert.strictEqual(actual, 'A');
8792 assert.strictEqual(_(object).invoke('a'), 1);
8938 assert.strictEqual(count, 1);
8955 assert.strictEqual(_.isArguments(args), true);
8956 assert.strictEqual(_.isArguments(strictArgs), true);
8970 assert.strictEqual(_.isArguments([1, 2, 3]), false);
8971 assert.strictEqual(_.isArguments(true), false);
8972 assert.strictEqual(_.isArguments(new Date), false);
8973 assert.strictEqual(_.isArguments(new Error), false);
8974 assert.strictEqual(_.isArguments(_), false);
8975 assert.strictEqual(_.isArguments(slice), false);
8976 assert.strictEqual(_.isArguments({ '0': 1, 'callee': noop, 'length': 1 }), false);
8977 assert.strictEqual(_.isArguments(1), false);
8978 assert.strictEqual(_.isArguments(/x/), false);
8979 assert.strictEqual(_.isArguments('a'), false);
8980 assert.strictEqual(_.isArguments(symbol), false);
8987 assert.strictEqual(_.isArguments(realm.arguments), true);
9003 assert.strictEqual(_.isArray([1, 2, 3]), true);
9017 assert.strictEqual(_.isArray(args), false);
9018 assert.strictEqual(_.isArray(true), false);
9019 assert.strictEqual(_.isArray(new Date), false);
9020 assert.strictEqual(_.isArray(new Error), false);
9021 assert.strictEqual(_.isArray(_), false);
9022 assert.strictEqual(_.isArray(slice), false);
9023 assert.strictEqual(_.isArray({ '0': 1, 'length': 1 }), false);
9024 assert.strictEqual(_.isArray(1), false);
9025 assert.strictEqual(_.isArray(/x/), false);
9026 assert.strictEqual(_.isArray('a'), false);
9027 assert.strictEqual(_.isArray(symbol), false);
9034 assert.strictEqual(_.isArray(realm.array), true);
9051 assert.strictEqual(_.isArrayBuffer(arrayBuffer), true);
9069 assert.strictEqual(_.isArrayBuffer(args), false);
9070 assert.strictEqual(_.isArrayBuffer([1]), false);
9071 assert.strictEqual(_.isArrayBuffer(true), false);
9072 assert.strictEqual(_.isArrayBuffer(new Date), false);
9073 assert.strictEqual(_.isArrayBuffer(new Error), false);
9074 assert.strictEqual(_.isArrayBuffer(_), false);
9075 assert.strictEqual(_.isArrayBuffer(slice), false);
9076 assert.strictEqual(_.isArrayBuffer({ 'a': 1 }), false);
9077 assert.strictEqual(_.isArrayBuffer(1), false);
9078 assert.strictEqual(_.isArrayBuffer(/x/), false);
9079 assert.strictEqual(_.isArrayBuffer('a'), false);
9080 assert.strictEqual(_.isArrayBuffer(symbol), false);
9087 assert.strictEqual(_.isArrayBuffer(realm.arrayBuffer), true);
9123 assert.strictEqual(_.isArrayLike(true), false);
9124 assert.strictEqual(_.isArrayLike(new Date), false);
9125 assert.strictEqual(_.isArrayLike(new Error), false);
9126 assert.strictEqual(_.isArrayLike(_), false);
9127 assert.strictEqual(_.isArrayLike(asyncFunc), false);
9128 assert.strictEqual(_.isArrayLike(genFunc), false);
9129 assert.strictEqual(_.isArrayLike(slice), false);
9130 assert.strictEqual(_.isArrayLike({ 'a': 1 }), false);
9131 assert.strictEqual(_.isArrayLike(1), false);
9132 assert.strictEqual(_.isArrayLike(/x/), false);
9133 assert.strictEqual(_.isArrayLike(symbol), false);
9160 assert.strictEqual(_.isBoolean(true), true);
9161 assert.strictEqual(_.isBoolean(false), true);
9162 assert.strictEqual(_.isBoolean(Object(true)), true);
9163 assert.strictEqual(_.isBoolean(Object(false)), true);
9179 assert.strictEqual(_.isBoolean(args), false);
9180 assert.strictEqual(_.isBoolean([1, 2, 3]), false);
9181 assert.strictEqual(_.isBoolean(new Date), false);
9182 assert.strictEqual(_.isBoolean(new Error), false);
9183 assert.strictEqual(_.isBoolean(_), false);
9184 assert.strictEqual(_.isBoolean(slice), false);
9185 assert.strictEqual(_.isBoolean({ 'a': 1 }), false);
9186 assert.strictEqual(_.isBoolean(1), false);
9187 assert.strictEqual(_.isBoolean(/x/), false);
9188 assert.strictEqual(_.isBoolean('a'), false);
9189 assert.strictEqual(_.isBoolean(symbol), false);
9196 assert.strictEqual(_.isBoolean(realm.boolean), true);
9213 assert.strictEqual(_.isBuffer(new Buffer(2)), true);
9231 assert.strictEqual(_.isBuffer(args), false);
9232 assert.strictEqual(_.isBuffer([1]), false);
9233 assert.strictEqual(_.isBuffer(true), false);
9234 assert.strictEqual(_.isBuffer(new Date), false);
9235 assert.strictEqual(_.isBuffer(new Error), false);
9236 assert.strictEqual(_.isBuffer(_), false);
9237 assert.strictEqual(_.isBuffer(slice), false);
9238 assert.strictEqual(_.isBuffer({ 'a': 1 }), false);
9239 assert.strictEqual(_.isBuffer(1), false);
9240 assert.strictEqual(_.isBuffer(/x/), false);
9241 assert.strictEqual(_.isBuffer('a'), false);
9242 assert.strictEqual(_.isBuffer(symbol), false);
9249 assert.strictEqual(lodashBizarro.isBuffer(new Buffer(2)), false);
9265 assert.strictEqual(_.isDate(new Date), true);
9279 assert.strictEqual(_.isDate(args), false);
9280 assert.strictEqual(_.isDate([1, 2, 3]), false);
9281 assert.strictEqual(_.isDate(true), false);
9282 assert.strictEqual(_.isDate(new Error), false);
9283 assert.strictEqual(_.isDate(_), false);
9284 assert.strictEqual(_.isDate(slice), false);
9285 assert.strictEqual(_.isDate({ 'a': 1 }), false);
9286 assert.strictEqual(_.isDate(1), false);
9287 assert.strictEqual(_.isDate(/x/), false);
9288 assert.strictEqual(_.isDate('a'), false);
9289 assert.strictEqual(_.isDate(symbol), false);
9296 assert.strictEqual(_.isDate(realm.date), true);
9313 assert.strictEqual(_.isElement(body), true);
9327 assert.strictEqual(_.isElement(new Foo), true);
9341 assert.strictEqual(_.isElement(args), false);
9342 assert.strictEqual(_.isElement([1, 2, 3]), false);
9343 assert.strictEqual(_.isElement(true), false);
9344 assert.strictEqual(_.isElement(new Date), false);
9345 assert.strictEqual(_.isElement(new Error), false);
9346 assert.strictEqual(_.isElement(_), false);
9347 assert.strictEqual(_.isElement(slice), false);
9348 assert.strictEqual(_.isElement({ 'a': 1 }), false);
9349 assert.strictEqual(_.isElement(1), false);
9350 assert.strictEqual(_.isElement(/x/), false);
9351 assert.strictEqual(_.isElement('a'), false);
9352 assert.strictEqual(_.isElement(symbol), false);
9358 assert.strictEqual(_.isElement({ 'nodeType': 1 }), false);
9359 assert.strictEqual(_.isElement({ 'nodeType': Object(1) }), false);
9360 assert.strictEqual(_.isElement({ 'nodeType': true }), false);
9361 assert.strictEqual(_.isElement({ 'nodeType': [1] }), false);
9362 assert.strictEqual(_.isElement({ 'nodeType': '1' }), false);
9363 assert.strictEqual(_.isElement({ 'nodeType': '001' }), false);
9370 assert.strictEqual(_.isElement(realm.element), true);
9391 assert.strictEqual(_.isEmpty(true), true);
9392 assert.strictEqual(_.isEmpty(slice), true);
9393 assert.strictEqual(_.isEmpty(1), true);
9394 assert.strictEqual(_.isEmpty(NaN), true);
9395 assert.strictEqual(_.isEmpty(/x/), true);
9396 assert.strictEqual(_.isEmpty(symbol), true);
9397 assert.strictEqual(_.isEmpty(), true);
9400 assert.strictEqual(_.isEmpty(new Buffer(0)), true);
9401 assert.strictEqual(_.isEmpty(new Buffer(1)), false);
9411 assert.strictEqual(_.isEmpty([0]), false);
9412 assert.strictEqual(_.isEmpty({ 'a': 0 }), false);
9413 assert.strictEqual(_.isEmpty('a'), false);
9419 assert.strictEqual(_.isEmpty({ 'length': 0 }), false);
9425 assert.strictEqual(_.isEmpty(args), false);
9434 assert.strictEqual(_.isEmpty(Foo.prototype), true);
9437 assert.strictEqual(_.isEmpty(Foo.prototype), false);
9448 assert.strictEqual(_.isEmpty(new Foo([])), true);
9456 assert.strictEqual(_.isEmpty(map), true);
9458 assert.strictEqual(_.isEmpty(map), false);
9472 assert.strictEqual(_.isEmpty(set), true);
9474 assert.strictEqual(_.isEmpty(set), false);
9489 assert.strictEqual(_.isEmpty(new Foo), true);
9498 assert.strictEqual(_.isEmpty(new Foo), true);
9504 assert.strictEqual(_.isEmpty({ 'length': '0' }), false);
9511 assert.strictEqual(_({}).isEmpty(), true);
9570 assert.strictEqual(_.isEqual(array1, array2), true);
9575 assert.strictEqual(_.isEqual(array1, array2), true);
9584 assert.strictEqual(_.isEqual(array1, array2), true);
9589 assert.strictEqual(_.isEqual(array1, array2), true);
9594 assert.strictEqual(_.isEqual(array1, array2), false);
9599 assert.strictEqual(_.isEqual(array1, array2), false);
9616 assert.strictEqual(_.isEqual(array1, array2), true);
9624 assert.strictEqual(_.isEqual(array1, array2), true);
9629 assert.strictEqual(_.isEqual(array1, array2), true);
9637 assert.strictEqual(_.isEqual(array, Array(1)), true);
9638 assert.strictEqual(_.isEqual(array, [undefined]), true);
9639 assert.strictEqual(_.isEqual(array, Array(2)), false);
9648 assert.strictEqual(_.isEqual(object1, object2), true);
9653 assert.strictEqual(_.isEqual(object1, object2), true);
9658 assert.strictEqual(_.isEqual(object1, object2), false);
9663 assert.strictEqual(_.isEqual(object1, object2), false);
9668 assert.strictEqual(_.isEqual(object1, object2), false);
9677 assert.strictEqual(_.isEqual(object1, object2), true);
9711 assert.strictEqual(_.isEqual(object1, object2), true);
9727 assert.strictEqual(_.isEqual(new Foo, new Foo), true);
9728 assert.strictEqual(_.isEqual(new Foo, new Bar), false);
9729 assert.strictEqual(_.isEqual({ 'a': 1 }, new Foo), false);
9730 assert.strictEqual(_.isEqual({ 'a': 2 }, new Bar), false);
9736 assert.strictEqual(_.isEqual({ 'constructor': 1 }, { 'constructor': 1 }), true);
9737 assert.strictEqual(_.isEqual({ 'constructor': 1 }, { 'constructor': '1' }), false);
9738 assert.strictEqual(_.isEqual({ 'constructor': [1] }, { 'constructor': [1] }), true);
9739 assert.strictEqual(_.isEqual({ 'constructor': [1] }, { 'constructor': ['1'] }), false);
9740 assert.strictEqual(_.isEqual({ 'constructor': Object }, {}), false);
9752 assert.strictEqual(_.isEqual(array1, array2), true);
9757 assert.strictEqual(_.isEqual(array1, array2), true);
9762 assert.strictEqual(_.isEqual(array1, array2), false);
9768 assert.strictEqual(_.isEqual(array1, array2), false);
9780 assert.strictEqual(_.isEqual(array1, array2), true);
9781 assert.strictEqual(_.isEqual(array2, array3), true);
9782 assert.strictEqual(_.isEqual(array1, array3), true);
9794 assert.strictEqual(_.isEqual(object1, object2), true);
9799 assert.strictEqual(_.isEqual(object1, object2), true);
9804 assert.strictEqual(_.isEqual(object1, object2), false);
9810 assert.strictEqual(_.isEqual(object1, object2), false);
9822 assert.strictEqual(_.isEqual(object1, object2), true);
9823 assert.strictEqual(_.isEqual(object2, object3), true);
9824 assert.strictEqual(_.isEqual(object1, object3), true);
9836 assert.strictEqual(_.isEqual(array1, array2), true);
9841 assert.strictEqual(_.isEqual(array1, array2), true);
9846 assert.strictEqual(_.isEqual(array1, array2), false);
9868 assert.strictEqual(_.isEqual(object1, object2), true);
9885 assert.strictEqual(_.isEqual(object1, object2), true);
9901 assert.strictEqual(_.isEqual(object1, object2), true);
9902 assert.strictEqual(_.isEqual(new Foo, object2), false);
9908 assert.strictEqual(_.isEqual(true, Object(false)), false);
9909 assert.strictEqual(_.isEqual(Object(false), Object(0)), false);
9910 assert.strictEqual(_.isEqual(false, Object('')), false);
9911 assert.strictEqual(_.isEqual(Object(36), Object('36')), false);
9912 assert.strictEqual(_.isEqual(0, ''), false);
9913 assert.strictEqual(_.isEqual(1, true), false);
9914 assert.strictEqual(_.isEqual(1337756400000, new Date(2012, 4, 23)), false);
9915 assert.strictEqual(_.isEqual('36', 36), false);
9916 assert.strictEqual(_.isEqual(36, '36'), false);
9926 assert.strictEqual(_.isEqual(args1, args2), true);
9927 assert.strictEqual(_.isEqual(args1, args3), false);
9938 assert.strictEqual(_.isEqual(args, object), true);
9939 assert.strictEqual(_.isEqual(object, args), true);
9940 assert.strictEqual(_.isEqual(args, new Foo), false);
9941 assert.strictEqual(_.isEqual(new Foo, args), false);
9950 assert.strictEqual(_.isEqual(buffer, new Uint8Array([255]).buffer), true);
9951 assert.strictEqual(_.isEqual(buffer, new ArrayBuffer(1)), false);
9991 assert.strictEqual(_.isEqual(buffer, new Buffer([1])), true);
9992 assert.strictEqual(_.isEqual(buffer, new Buffer([2])), false);
9993 assert.strictEqual(_.isEqual(buffer, new Uint8Array([1])), false);
10005 assert.strictEqual(_.isEqual(date, new Date(2012, 4, 23)), true);
10006 assert.strictEqual(_.isEqual(new Date('a'), new Date('b')), true);
10007 assert.strictEqual(_.isEqual(date, new Date(2013, 3, 25)), false);
10008 assert.strictEqual(_.isEqual(date, { 'getTime': lodashStable.constant(+date) }), false);
10045 assert.strictEqual(_.isEqual(a, a), true);
10046 assert.strictEqual(_.isEqual(a, b), false);
10059 assert.strictEqual(_.isEqual(map1, map2), false);
10063 assert.strictEqual(_.isEqual(map1, map2), true);
10067 assert.strictEqual(_.isEqual(map1, map2), true);
10070 assert.strictEqual(_.isEqual(map1, map2), false);
10090 assert.strictEqual(_.isEqual(map1, map2), true);
10094 assert.strictEqual(_.isEqual(map1, map2), false);
10109 assert.strictEqual(_.isEqual(promise1, promise2), false);
10110 assert.strictEqual(_.isEqual(promise1, promise1), true);
10121 assert.strictEqual(_.isEqual(/x/gim, /x/gim), true);
10122 assert.strictEqual(_.isEqual(/x/gim, /x/mgi), true);
10123 assert.strictEqual(_.isEqual(/x/gi, /x/g), false);
10124 assert.strictEqual(_.isEqual(/x/, /y/), false);
10125 …assert.strictEqual(_.isEqual(/x/g, { 'global': true, 'ignoreCase': false, 'multiline': false, 'sou…
10138 assert.strictEqual(_.isEqual(set1, set2), false);
10142 assert.strictEqual(_.isEqual(set1, set2), true);
10146 assert.strictEqual(_.isEqual(set1, set2), true);
10149 assert.strictEqual(_.isEqual(set1, set2), false);
10169 assert.strictEqual(_.isEqual(set1, set2), true);
10173 assert.strictEqual(_.isEqual(set1, set2), false);
10197 assert.strictEqual(_.isEqual(object1, object2), true);
10200 assert.strictEqual(_.isEqual(object1, object2), false);
10204 assert.strictEqual(_.isEqual(object1, object2), false);
10233 assert.strictEqual(actual, true);
10234 assert.strictEqual(_.isEqual(_(actual), _(true)), true);
10240 assert.strictEqual(actual, false);
10241 assert.strictEqual(_.isEqual(_(actual), _(false)), true);
10256 assert.strictEqual(object1.isEqual(object2), true);
10257 assert.strictEqual(_.isEqual(object1, object2), true);
10262 assert.strictEqual(object1.isEqual(object2), false);
10263 assert.strictEqual(_.isEqual(object1, object2), false);
10285 assert.strictEqual(_.isEqual(element1, element2), false);
10299 assert.strictEqual(_.isEqual([1], realm.array), true);
10300 assert.strictEqual(_.isEqual([2], realm.array), false);
10301 assert.strictEqual(_.isEqual({ 'a': 1 }, realm.object), true);
10302 assert.strictEqual(_.isEqual({ 'a': 2 }, realm.object), false);
10329 assert.strictEqual(_('a').isEqual('a'), true);
10384 assert.strictEqual(_.isEqualWith('a', 'a', noop), true);
10385 assert.strictEqual(_.isEqualWith(['a'], ['a'], noop), true);
10386 assert.strictEqual(_.isEqualWith({ '0': 'a' }, { '0': 'a' }, noop), true);
10396 assert.strictEqual(_.isEqualWith('a', 'b', customizer), true);
10397 assert.strictEqual(_.isEqualWith(['a'], ['b'], customizer), true);
10398 assert.strictEqual(_.isEqualWith({ '0': 'a' }, { '0': 'b' }, customizer), true);
10408 assert.strictEqual(_.isEqualWith('a', 'a', customizer), false);
10409 assert.strictEqual(_.isEqualWith(['a'], ['a'], customizer), false);
10410 assert.strictEqual(_.isEqualWith({ '0': 'a' }, { '0': 'a' }, customizer), false);
10417 assert.strictEqual(actual, true);
10510 assert.strictEqual(_.isError(new CustomError('x')), true);
10524 assert.strictEqual(_.isError(args), false);
10525 assert.strictEqual(_.isError([1, 2, 3]), false);
10526 assert.strictEqual(_.isError(true), false);
10527 assert.strictEqual(_.isError(new Date), false);
10528 assert.strictEqual(_.isError(_), false);
10529 assert.strictEqual(_.isError(slice), false);
10530 assert.strictEqual(_.isError({ 'a': 1 }), false);
10531 assert.strictEqual(_.isError(1), false);
10532 assert.strictEqual(_.isError(/x/), false);
10533 assert.strictEqual(_.isError('a'), false);
10534 assert.strictEqual(_.isError(symbol), false);
10540 assert.strictEqual(_.isError({ 'name': 'Error', 'message': '' }), false);
10595 assert.strictEqual(_.isFinite(args), false);
10596 assert.strictEqual(_.isFinite([1, 2, 3]), false);
10597 assert.strictEqual(_.isFinite(true), false);
10598 assert.strictEqual(_.isFinite(new Date), false);
10599 assert.strictEqual(_.isFinite(new Error), false);
10600 assert.strictEqual(_.isFinite({ 'a': 1 }), false);
10601 assert.strictEqual(_.isFinite(/x/), false);
10602 assert.strictEqual(_.isFinite('a'), false);
10603 assert.strictEqual(_.isFinite(symbol), false);
10625 assert.strictEqual(_.isFunction(_), true);
10626 assert.strictEqual(_.isFunction(slice), true);
10632 assert.strictEqual(_.isFunction(asyncFunc), typeof asyncFunc == 'function');
10638 assert.strictEqual(_.isFunction(genFunc), typeof genFunc == 'function');
10645 assert.strictEqual(_.isFunction(Proxy), true);
10677 assert.strictEqual(_.isFunction(args), false);
10678 assert.strictEqual(_.isFunction([1, 2, 3]), false);
10679 assert.strictEqual(_.isFunction(true), false);
10680 assert.strictEqual(_.isFunction(new Date), false);
10681 assert.strictEqual(_.isFunction(new Error), false);
10682 assert.strictEqual(_.isFunction({ 'a': 1 }), false);
10683 assert.strictEqual(_.isFunction(1), false);
10684 assert.strictEqual(_.isFunction(/x/), false);
10685 assert.strictEqual(_.isFunction('a'), false);
10686 assert.strictEqual(_.isFunction(symbol), false);
10689 assert.strictEqual(_.isFunction(document.getElementsByTagName('body')), false);
10700 assert.strictEqual(_.isFunction(realm.function), true);
10727 assert.strictEqual(func(MAX_INTEGER), !isSafe);
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);
10803 assert.strictEqual(_.isMap(map), true);
10821 assert.strictEqual(_.isMap(args), false);
10822 assert.strictEqual(_.isMap([1, 2, 3]), false);
10823 assert.strictEqual(_.isMap(true), false);
10824 assert.strictEqual(_.isMap(new Date), false);
10825 assert.strictEqual(_.isMap(new Error), false);
10826 assert.strictEqual(_.isMap(_), false);
10827 assert.strictEqual(_.isMap(slice), false);
10828 assert.strictEqual(_.isMap({ 'a': 1 }), false);
10829 assert.strictEqual(_.isMap(1), false);
10830 assert.strictEqual(_.isMap(/x/), false);
10831 assert.strictEqual(_.isMap('a'), false);
10832 assert.strictEqual(_.isMap(symbol), false);
10833 assert.strictEqual(_.isMap(weakMap), false);
10853 assert.strictEqual(_.isMap(realm.map), true);
10897 assert.strictEqual(_.isMatchWith({ 'a': 1 }, { 'a': 1 }, noop), true);
10907 assert.strictEqual(_.isMatchWith(['a'], ['b'], customizer), true);
10908 assert.strictEqual(_.isMatchWith({ '0': 'a' }, { '0': 'b' }, customizer), true);
10918 assert.strictEqual(_.isMatchWith(['a'], ['a'], customizer), false);
10919 assert.strictEqual(_.isMatchWith({ '0': 'a' }, { '0': 'a' }, customizer), false);
10928 assert.strictEqual(actual, true);
11022 assert.strictEqual(_.isNaN(NaN), true);
11023 assert.strictEqual(_.isNaN(Object(NaN)), true);
11039 assert.strictEqual(_.isNaN(args), false);
11040 assert.strictEqual(_.isNaN([1, 2, 3]), false);
11041 assert.strictEqual(_.isNaN(true), false);
11042 assert.strictEqual(_.isNaN(new Date), false);
11043 assert.strictEqual(_.isNaN(new Error), false);
11044 assert.strictEqual(_.isNaN(_), false);
11045 assert.strictEqual(_.isNaN(slice), false);
11046 assert.strictEqual(_.isNaN({ 'a': 1 }), false);
11047 assert.strictEqual(_.isNaN(1), false);
11048 assert.strictEqual(_.isNaN(Object(1)), false);
11049 assert.strictEqual(_.isNaN(/x/), false);
11050 assert.strictEqual(_.isNaN('a'), false);
11051 assert.strictEqual(_.isNaN(symbol), false);
11058 assert.strictEqual(_.isNaN(realm.nan), true);
11092 assert.strictEqual(_.isNative(args), false);
11093 assert.strictEqual(_.isNative([1, 2, 3]), false);
11094 assert.strictEqual(_.isNative(true), false);
11095 assert.strictEqual(_.isNative(new Date), false);
11096 assert.strictEqual(_.isNative(new Error), false);
11097 assert.strictEqual(_.isNative(_), false);
11098 assert.strictEqual(_.isNative({ 'a': 1 }), false);
11099 assert.strictEqual(_.isNative(1), false);
11100 assert.strictEqual(_.isNative(/x/), false);
11101 assert.strictEqual(_.isNative('a'), false);
11102 assert.strictEqual(_.isNative(symbol), false);
11109 assert.strictEqual(_.isNative(realm.element.cloneNode), true);
11115 assert.strictEqual(_.isNative(realm.object.valueOf), true);
11151 assert.strictEqual(baseIsNative(slice), true);
11154 assert.strictEqual(baseIsNative(slice), false);
11173 assert.strictEqual(_.isNil(null), true);
11174 assert.strictEqual(_.isNil(), true);
11175 assert.strictEqual(_.isNil(undefined), true);
11191 assert.strictEqual(_.isNil(args), false);
11192 assert.strictEqual(_.isNil([1, 2, 3]), false);
11193 assert.strictEqual(_.isNil(true), false);
11194 assert.strictEqual(_.isNil(new Date), false);
11195 assert.strictEqual(_.isNil(new Error), false);
11196 assert.strictEqual(_.isNil(_), false);
11197 assert.strictEqual(_.isNil(slice), false);
11198 assert.strictEqual(_.isNil({ 'a': 1 }), false);
11199 assert.strictEqual(_.isNil(1), false);
11200 assert.strictEqual(_.isNil(/x/), false);
11201 assert.strictEqual(_.isNil('a'), false);
11204 assert.strictEqual(_.isNil(symbol), false);
11215 assert.strictEqual(_.isNil(realm.null), true);
11216 assert.strictEqual(_.isNil(realm.undefined), true);
11232 assert.strictEqual(_.isNull(null), true);
11248 assert.strictEqual(_.isNull(args), false);
11249 assert.strictEqual(_.isNull([1, 2, 3]), false);
11250 assert.strictEqual(_.isNull(true), false);
11251 assert.strictEqual(_.isNull(new Date), false);
11252 assert.strictEqual(_.isNull(new Error), false);
11253 assert.strictEqual(_.isNull(_), false);
11254 assert.strictEqual(_.isNull(slice), false);
11255 assert.strictEqual(_.isNull({ 'a': 1 }), false);
11256 assert.strictEqual(_.isNull(1), false);
11257 assert.strictEqual(_.isNull(/x/), false);
11258 assert.strictEqual(_.isNull('a'), false);
11259 assert.strictEqual(_.isNull(symbol), false);
11266 assert.strictEqual(_.isNull(realm.null), true);
11282 assert.strictEqual(_.isNumber(0), true);
11283 assert.strictEqual(_.isNumber(Object(0)), true);
11284 assert.strictEqual(_.isNumber(NaN), true);
11300 assert.strictEqual(_.isNumber(args), false);
11301 assert.strictEqual(_.isNumber([1, 2, 3]), false);
11302 assert.strictEqual(_.isNumber(true), false);
11303 assert.strictEqual(_.isNumber(new Date), false);
11304 assert.strictEqual(_.isNumber(new Error), false);
11305 assert.strictEqual(_.isNumber(_), false);
11306 assert.strictEqual(_.isNumber(slice), false);
11307 assert.strictEqual(_.isNumber({ 'a': 1 }), false);
11308 assert.strictEqual(_.isNumber(/x/), false);
11309 assert.strictEqual(_.isNumber('a'), false);
11310 assert.strictEqual(_.isNumber(symbol), false);
11317 assert.strictEqual(_.isNumber(realm.number), true);
11333 assert.strictEqual(_.isObject(args), true);
11334 assert.strictEqual(_.isObject([1, 2, 3]), true);
11335 assert.strictEqual(_.isObject(Object(false)), true);
11336 assert.strictEqual(_.isObject(new Date), true);
11337 assert.strictEqual(_.isObject(new Error), true);
11338 assert.strictEqual(_.isObject(_), true);
11339 assert.strictEqual(_.isObject(slice), true);
11340 assert.strictEqual(_.isObject({ 'a': 1 }), true);
11341 assert.strictEqual(_.isObject(Object(0)), true);
11342 assert.strictEqual(_.isObject(/x/), true);
11343 assert.strictEqual(_.isObject(Object('a')), true);
11346 assert.strictEqual(_.isObject(body), true);
11352 assert.strictEqual(_.isObject(Object(symbol)), true);
11376 assert.strictEqual(_.isObject(realm.element), true);
11382 assert.strictEqual(_.isObject(realm.boolean), true);
11383 assert.strictEqual(_.isObject(realm.date), true);
11384 assert.strictEqual(_.isObject(realm.function), true);
11385 assert.strictEqual(_.isObject(realm.number), true);
11386 assert.strictEqual(_.isObject(realm.object), true);
11387 assert.strictEqual(_.isObject(realm.regexp), true);
11388 assert.strictEqual(_.isObject(realm.string), true);
11404 assert.strictEqual(_.isObjectLike(args), true);
11405 assert.strictEqual(_.isObjectLike([1, 2, 3]), true);
11406 assert.strictEqual(_.isObjectLike(Object(false)), true);
11407 assert.strictEqual(_.isObjectLike(new Date), true);
11408 assert.strictEqual(_.isObjectLike(new Error), true);
11409 assert.strictEqual(_.isObjectLike({ 'a': 1 }), true);
11410 assert.strictEqual(_.isObjectLike(Object(0)), true);
11411 assert.strictEqual(_.isObjectLike(/x/), true);
11412 assert.strictEqual(_.isObjectLike(Object('a')), true);
11432 assert.strictEqual(_.isObjectLike(realm.boolean), true);
11433 assert.strictEqual(_.isObjectLike(realm.date), true);
11434 assert.strictEqual(_.isObjectLike(realm.number), true);
11435 assert.strictEqual(_.isObjectLike(realm.object), true);
11436 assert.strictEqual(_.isObjectLike(realm.regexp), true);
11437 assert.strictEqual(_.isObjectLike(realm.string), true);
11459 assert.strictEqual(_.isPlainObject({}), true);
11460 assert.strictEqual(_.isPlainObject({ 'a': 1 }), true);
11461 assert.strictEqual(_.isPlainObject({ 'constructor': Foo }), true);
11462 assert.strictEqual(_.isPlainObject([1, 2, 3]), false);
11463 assert.strictEqual(_.isPlainObject(new Foo(1)), false);
11470 assert.strictEqual(_.isPlainObject(object), true);
11473 assert.strictEqual(_.isPlainObject(object), true);
11479 assert.strictEqual(_.isPlainObject({ 'valueOf': 0 }), true);
11500 assert.strictEqual(_.isPlainObject(object), false);
11507 assert.strictEqual(_.isPlainObject(element), false);
11516 assert.strictEqual(_.isPlainObject(arguments), false);
11517 assert.strictEqual(_.isPlainObject(Error), false);
11518 assert.strictEqual(_.isPlainObject(Math), false);
11532 assert.strictEqual(_.isPlainObject(true), false);
11533 assert.strictEqual(_.isPlainObject('a'), false);
11534 assert.strictEqual(_.isPlainObject(symbol), false);
11564 assert.strictEqual(_.isPlainObject(object), false);
11576 assert.strictEqual(_.isPlainObject(realm.object), true);
11592 assert.strictEqual(_.isRegExp(/x/), true);
11593 assert.strictEqual(_.isRegExp(RegExp('x')), true);
11607 assert.strictEqual(_.isRegExp(args), false);
11608 assert.strictEqual(_.isRegExp([1, 2, 3]), false);
11609 assert.strictEqual(_.isRegExp(true), false);
11610 assert.strictEqual(_.isRegExp(new Date), false);
11611 assert.strictEqual(_.isRegExp(new Error), false);
11612 assert.strictEqual(_.isRegExp(_), false);
11613 assert.strictEqual(_.isRegExp(slice), false);
11614 assert.strictEqual(_.isRegExp({ 'a': 1 }), false);
11615 assert.strictEqual(_.isRegExp(1), false);
11616 assert.strictEqual(_.isRegExp('a'), false);
11617 assert.strictEqual(_.isRegExp(symbol), false);
11624 assert.strictEqual(_.isRegExp(realm.regexp), true);
11641 assert.strictEqual(_.isSet(set), true);
11659 assert.strictEqual(_.isSet(args), false);
11660 assert.strictEqual(_.isSet([1, 2, 3]), false);
11661 assert.strictEqual(_.isSet(true), false);
11662 assert.strictEqual(_.isSet(new Date), false);
11663 assert.strictEqual(_.isSet(new Error), false);
11664 assert.strictEqual(_.isSet(_), false);
11665 assert.strictEqual(_.isSet(slice), false);
11666 assert.strictEqual(_.isSet({ 'a': 1 }), false);
11667 assert.strictEqual(_.isSet(1), false);
11668 assert.strictEqual(_.isSet(/x/), false);
11669 assert.strictEqual(_.isSet('a'), false);
11670 assert.strictEqual(_.isSet(symbol), false);
11671 assert.strictEqual(_.isSet(weakSet), false);
11691 assert.strictEqual(_.isSet(realm.set), true);
11707 assert.strictEqual(_.isString('a'), true);
11708 assert.strictEqual(_.isString(Object('a')), true);
11724 assert.strictEqual(_.isString(args), false);
11725 assert.strictEqual(_.isString([1, 2, 3]), false);
11726 assert.strictEqual(_.isString(true), false);
11727 assert.strictEqual(_.isString(new Date), false);
11728 assert.strictEqual(_.isString(new Error), false);
11729 assert.strictEqual(_.isString(_), false);
11730 assert.strictEqual(_.isString(slice), false);
11731 assert.strictEqual(_.isString({ '0': 1, 'length': 1 }), false);
11732 assert.strictEqual(_.isString(1), false);
11733 assert.strictEqual(_.isString(/x/), false);
11734 assert.strictEqual(_.isString(symbol), false);
11741 assert.strictEqual(_.isString(realm.string), true);
11758 assert.strictEqual(_.isSymbol(symbol), true);
11759 assert.strictEqual(_.isSymbol(Object(symbol)), true);
11777 assert.strictEqual(_.isSymbol(args), false);
11778 assert.strictEqual(_.isSymbol([1, 2, 3]), false);
11779 assert.strictEqual(_.isSymbol(true), false);
11780 assert.strictEqual(_.isSymbol(new Date), false);
11781 assert.strictEqual(_.isSymbol(new Error), false);
11782 assert.strictEqual(_.isSymbol(_), false);
11783 assert.strictEqual(_.isSymbol(slice), false);
11784 assert.strictEqual(_.isSymbol({ '0': 1, 'length': 1 }), false);
11785 assert.strictEqual(_.isSymbol(1), false);
11786 assert.strictEqual(_.isSymbol(/x/), false);
11787 assert.strictEqual(_.isSymbol('a'), false);
11794 assert.strictEqual(_.isSymbol(realm.symbol), true);
11833 assert.strictEqual(_.isTypedArray(args), false);
11834 assert.strictEqual(_.isTypedArray([1, 2, 3]), false);
11835 assert.strictEqual(_.isTypedArray(true), false);
11836 assert.strictEqual(_.isTypedArray(new Date), false);
11837 assert.strictEqual(_.isTypedArray(new Error), false);
11838 assert.strictEqual(_.isTypedArray(_), false);
11839 assert.strictEqual(_.isTypedArray(slice), false);
11840 assert.strictEqual(_.isTypedArray({ 'a': 1 }), false);
11841 assert.strictEqual(_.isTypedArray(1), false);
11842 assert.strictEqual(_.isTypedArray(/x/), false);
11843 assert.strictEqual(_.isTypedArray('a'), false);
11844 assert.strictEqual(_.isTypedArray(symbol), false);
11878 assert.strictEqual(_.isUndefined(), true);
11879 assert.strictEqual(_.isUndefined(undefined), true);
11895 assert.strictEqual(_.isUndefined(args), false);
11896 assert.strictEqual(_.isUndefined([1, 2, 3]), false);
11897 assert.strictEqual(_.isUndefined(true), false);
11898 assert.strictEqual(_.isUndefined(new Date), false);
11899 assert.strictEqual(_.isUndefined(new Error), false);
11900 assert.strictEqual(_.isUndefined(_), false);
11901 assert.strictEqual(_.isUndefined(slice), false);
11902 assert.strictEqual(_.isUndefined({ 'a': 1 }), false);
11903 assert.strictEqual(_.isUndefined(1), false);
11904 assert.strictEqual(_.isUndefined(/x/), false);
11905 assert.strictEqual(_.isUndefined('a'), false);
11908 assert.strictEqual(_.isUndefined(symbol), false);
11919 assert.strictEqual(_.isUndefined(realm.undefined), true);
11936 assert.strictEqual(_.isWeakMap(weakMap), true);
11954 assert.strictEqual(_.isWeakMap(args), false);
11955 assert.strictEqual(_.isWeakMap([1, 2, 3]), false);
11956 assert.strictEqual(_.isWeakMap(true), false);
11957 assert.strictEqual(_.isWeakMap(new Date), false);
11958 assert.strictEqual(_.isWeakMap(new Error), false);
11959 assert.strictEqual(_.isWeakMap(_), false);
11960 assert.strictEqual(_.isWeakMap(slice), false);
11961 assert.strictEqual(_.isWeakMap({ 'a': 1 }), false);
11962 assert.strictEqual(_.isWeakMap(map), false);
11963 assert.strictEqual(_.isWeakMap(1), false);
11964 assert.strictEqual(_.isWeakMap(/x/), false);
11965 assert.strictEqual(_.isWeakMap('a'), false);
11966 assert.strictEqual(_.isWeakMap(symbol), false);
11986 assert.strictEqual(_.isWeakMap(realm.weakMap), true);
12003 assert.strictEqual(_.isWeakSet(weakSet), true);
12021 assert.strictEqual(_.isWeakSet(args), false);
12022 assert.strictEqual(_.isWeakSet([1, 2, 3]), false);
12023 assert.strictEqual(_.isWeakSet(true), false);
12024 assert.strictEqual(_.isWeakSet(new Date), false);
12025 assert.strictEqual(_.isWeakSet(new Error), false);
12026 assert.strictEqual(_.isWeakSet(_), false);
12027 assert.strictEqual(_.isWeakSet(slice), false);
12028 assert.strictEqual(_.isWeakSet({ 'a': 1 }), false);
12029 assert.strictEqual(_.isWeakSet(1), false);
12030 assert.strictEqual(_.isWeakSet(/x/), false);
12031 assert.strictEqual(_.isWeakSet('a'), false);
12032 assert.strictEqual(_.isWeakSet(set), false);
12033 assert.strictEqual(_.isWeakSet(symbol), false);
12040 assert.strictEqual(_.isWeakSet(realm.weakSet), true);
12067 … assert.strictEqual(_[methodName](object), false, '`_.' + methodName + '` returns `false`');
12132 assert.strictEqual(matches({ 'a': 1, 'b': 2, 'c': 3 }), true);
12133 assert.strictEqual(matches({ 'b': 2 }), false);
12149 assert.strictEqual(matches(object), true);
12160 assert.strictEqual(matches(object), true);
12161 assert.strictEqual(matches(source), false);
12171 assert.strictEqual(matches(array), true);
12174 assert.strictEqual(matches(array), true);
12177 assert.strictEqual(matches(array), true);
12186 assert.strictEqual(matches(object), true);
12202 assert.strictEqual(matches(object), true);
12213 assert.strictEqual(matches(object), true);
12214 assert.strictEqual(matches({ 'a': source }), false);
12224 assert.strictEqual(prop(array), 'a');
12227 assert.strictEqual(prop(array), 'a');
12236 assert.strictEqual(prop(object), 2);
12364 assert.strictEqual(_.every(objects.slice(1)), true);
12392 assert.strictEqual(_.find(objects), objects[1]);
12405 assert.strictEqual(_.findIndex(objects), 1);
12418 assert.strictEqual(_.findLast(objects), objects[2]);
12431 assert.strictEqual(_.findLastIndex(objects), 2);
12444 assert.strictEqual(_.findKey(objects), '2');
12457 assert.strictEqual(_.findLastKey(objects), '2');
12561 assert.strictEqual(_.meanBy(objects), 2 / 3);
12615 assert.strictEqual(_.reduce(objects, undefined, 0), 2);
12628 assert.strictEqual(_.reduceRight(objects, undefined, 0), 2);
12672 assert.strictEqual(_.some(objects), true);
12700 assert.strictEqual(_.sortedIndexBy(objects, { 'a': 40 }), 1);
12715 assert.strictEqual(_.sortedLastIndexBy(objects, { 'a': 40 }), 1);
12728 assert.strictEqual(_.sumBy(objects), 1);
12830 assert.strictEqual(_.join(array, '~'), 'a~b~c');
12838 assert.strictEqual(wrapped.join('~'), 'a~b~c');
12839 assert.strictEqual(wrapped.value(), array);
13162 assert.strictEqual(_.last(array), 4);
13171 assert.strictEqual(_.last([]), undefined);
13187 assert.strictEqual(_(array).last(), 4);
13210 assert.strictEqual(wrapped.__wrapped__, array);
13228 assert.strictEqual(wrapped.last(), _.last(_.filter(array, isEven)));
13245 assert.strictEqual(_.lowerCase('--Foo-Bar--'), 'foo bar');
13246 assert.strictEqual(_.lowerCase('fooBar'), 'foo bar');
13247 assert.strictEqual(_.lowerCase('__FOO_BAR__'), 'foo bar');
13259 assert.strictEqual(_.lowerFirst('fred'), 'fred');
13260 assert.strictEqual(_.lowerFirst('Fred'), 'fred');
13261 assert.strictEqual(_.lowerFirst('FRED'), 'fRED');
13273 assert.strictEqual(_.lt(1, 3), true);
13274 assert.strictEqual(_.lt('abc', 'def'), true);
13280 assert.strictEqual(_.lt(3, 1), false);
13281 assert.strictEqual(_.lt(3, 3), false);
13282 assert.strictEqual(_.lt('def', 'abc'), false);
13283 assert.strictEqual(_.lt('def', 'def'), false);
13295 assert.strictEqual(_.lte(1, 3), true);
13296 assert.strictEqual(_.lte(3, 3), true);
13297 assert.strictEqual(_.lte('abc', 'def'), true);
13298 assert.strictEqual(_.lte('def', 'def'), true);
13304 assert.strictEqual(_.lt(3, 1), false);
13305 assert.strictEqual(_.lt('def', 'abc'), false);
13321 assert.strictEqual(func(array, resolve(3)), 5);
13327 assert.strictEqual(func(array, resolve(1), 2), 0);
13350 assert.strictEqual(func(array, resolve(2), -3), 1);
13383 assert.strictEqual(func(array, resolve(2), 4.2), 4);
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);
13766 assert.strictEqual(par(object), true);
13777 assert.strictEqual(par(object), true);
13778 assert.strictEqual(par(source), false);
13802 assert.strictEqual(par(object), true);
13805 assert.strictEqual(par(object), false);
13808 assert.strictEqual(par(object), true);
13811 assert.strictEqual(par(object), false);
13816 assert.strictEqual(par(object), true);
13830 assert.strictEqual(par(object), true);
13856 assert.strictEqual(par(object1), true);
13857 assert.strictEqual(par(object2), false);
13867 assert.strictEqual(par(object2), true);
13870 assert.strictEqual(par(object1), true);
13881 assert.strictEqual(par(object1), true);
13882 assert.strictEqual(par(object2), false);
13883 assert.strictEqual(par(object3), false);
13893 assert.strictEqual(par(Foo), true);
13918 assert.strictEqual(par(object), true);
14044 assert.strictEqual(par(1), true);
14050 assert.strictEqual(par(1), true);
14057 assert.strictEqual(par(1), true);
14132 assert.strictEqual(matches.length, 1);
14133 assert.strictEqual(matches(object), true);
14136 assert.strictEqual(matches(object), false);
14139 assert.strictEqual(matches({ 'a': object }), true);
14142 assert.strictEqual(matches(object), false);
14147 assert.strictEqual(matches(object), true);
14157 assert.strictEqual(matches(object), true);
14168 assert.strictEqual(matches(array), true);
14219 assert.strictEqual(matches(object), true);
14268 assert.strictEqual(matches(object), false);
14282 assert.strictEqual(matches(object), true);
14309 assert.strictEqual(matches({ 'a': object1 }), true);
14310 assert.strictEqual(matches({ 'a': object2 }), false);
14317 assert.strictEqual(matches({ 'a': 0 }), true);
14320 assert.strictEqual(matches({ 'a': -0 }), true);
14331 assert.strictEqual(matches({ 'a': object1 }), true);
14332 assert.strictEqual(matches({ 'a': object2 }), false);
14333 assert.strictEqual(matches({ 'a': object3 }), false);
14358 assert.strictEqual(matches(object), true);
14478 assert.strictEqual(matches(object), true);
14483 assert.strictEqual(matches(object), false);
14495 assert.strictEqual(matches(1), true);
14502 assert.strictEqual(matches(1), true);
14530 assert.strictEqual(matches({ 'a': object }), true);
14541 assert.strictEqual(matches({ 'a': object }), true);
14542 assert.strictEqual(matches({ 'a': source }), false);
14555 assert.strictEqual(_.max([1, 2, 3]), 3);
14576 assert.strictEqual(_.max(['a', 'b']), 'b');
14589 assert.strictEqual(_.mean(array), 5);
14635 assert.strictEqual(_.meanBy(arrays, 0), 2);
14636 assert.strictEqual(_.meanBy(objects, 'a'), 2);
14690 assert.strictEqual(memoized(1, 2, 3), 6);
14691 assert.strictEqual(memoized(1, 3, 5), 6);
14700 assert.strictEqual(memoized(1, 2, 3), 6);
14701 assert.strictEqual(memoized(1, 3, 5), 9);
14711 assert.strictEqual(object.memoized(1), 6);
14715 assert.strictEqual(object.memoized(1), 9);
14781 assert.strictEqual(count, 1);
14782 assert.strictEqual(cache.get(key), array);
14784 assert.strictEqual(cache.delete(key), true);
14802 assert.strictEqual(memoized(key1), 'a');
14803 assert.strictEqual(cache.has(key1), true);
14805 assert.strictEqual(memoized(key2), 'b');
14806 assert.strictEqual(cache.has(key2), true);
14828 assert.strictEqual(cache.has(key1), true);
14829 assert.strictEqual(cache.has(key2), true);
14850 assert.strictEqual(cache.size, MAX_MEMOIZE_SIZE);
14853 assert.strictEqual(cache.size, 1);
14919 assert.strictEqual(actual.foo.b.c.d, actual.foo.b.c.d.foo.b.c.d);
14939 assert.strictEqual(actual, Foo);
14940 assert.strictEqual(Foo.a, 1);
14986 assert.strictEqual(actual, object);
14987 assert.strictEqual(object.a, 1);
15076 assert.strictEqual(actual.a, null);
15103 assert.strictEqual(actual[0], buffer[0]);
15302 assert.strictEqual(actual.length, 3);
15348 assert.strictEqual(method.length, 1);
15349 assert.strictEqual(method(object), 1);
15360 assert.strictEqual(method(object), 2);
15371 assert.strictEqual(method(array), 1);
15403 assert.strictEqual(method(new Foo), 1);
15414 assert.strictEqual(method(object), 1);
15459 assert.strictEqual(method(object), undefined);
15485 assert.strictEqual(method(object), 1);
15502 assert.strictEqual(methodOf.length, 1);
15503 assert.strictEqual(methodOf(path), 1);
15514 assert.strictEqual(methodOf(path), 2);
15525 assert.strictEqual(methodOf(path), 1);
15557 assert.strictEqual(methodOf(path), 1);
15568 assert.strictEqual(methodOf(path), 1);
15611 assert.strictEqual(methodOf(path), undefined);
15638 assert.strictEqual(methodOf(path), 1);
15651 assert.strictEqual(_.min([1, 2, 3]), 1);
15672 assert.strictEqual(_.min(['a', 'b']), 'a');
15690 assert.strictEqual(func([curr, past]), isMax ? curr : past);
15697 assert.strictEqual(func(array), isMax ? 499999 : 0);
15705 assert.strictEqual(actual, 40);
15725 assert.strictEqual(actual, isMax ? 1 : 3);
15752 assert.strictEqual(actual, object);
15796 assert.strictEqual(_.a(array), 'a');
15797 assert.strictEqual(_(array).a().value(), 'a');
15815 assert.strictEqual(_.a(array), 'b');
15816 assert.strictEqual(_(array).a().value(), 'a');
15831 assert.strictEqual(object.a(array), 'a');
15843 assert.strictEqual(object.a(array), 'a');
15854 assert.strictEqual(actual.value(), 'a');
15864 assert.strictEqual(_.mixin(object, source), object);
15865 assert.strictEqual(_.mixin(Wrapper, source), Wrapper);
15866 assert.strictEqual(_.mixin(), _);
15878 assert.strictEqual(_.mixin(object, new Foo), object);
15900 assert.strictEqual(actual.value(), 'a', message(func, true));
15903 assert.strictEqual(actual, 'a', message(func, false));
15956 assert.strictEqual(actual.value(), _);
15998 assert.strictEqual(_.multiply(6, 4), 24);
15999 assert.strictEqual(_.multiply(-6, 4), -24);
16000 assert.strictEqual(_.multiply(-6, -4), 24);
16006 assert.strictEqual(_.multiply('6', '4'), 24);
16165 assert.strictEqual(object.over(object), 1);
16179 assert.strictEqual(negate(1), true);
16180 assert.strictEqual(negate(2), false);
16188 assert.strictEqual(negate(1), true);
16189 assert.strictEqual(negate(2), false);
16224 assert.strictEqual(_.noConflict(), oldDash);
16238 assert.strictEqual(_.noConflict(), oldDash);
16239 assert.strictEqual(root._, object);
16259 assert.strictEqual(context._, expected);
16298 assert.strictEqual(actual, 'a');
16438 assert.strictEqual(func(), undefined);
16635 assert.strictEqual(actual[symbol], 1);
16636 assert.strictEqual(actual[symbol2], 2);
16667 assert.strictEqual(actual.a, 0);
16669 assert.strictEqual(actual[symbol2], 2);
16674 assert.strictEqual(actual.a, 0);
16675 assert.strictEqual(actual[symbol], 1);
16704 assert.strictEqual(once(), 1);
16705 assert.strictEqual(count, 1);
16718 assert.strictEqual(once(), 1);
16719 assert.strictEqual(count, 1);
16821 assert.strictEqual(over(), true);
16832 assert.strictEqual(over(), false);
16833 assert.strictEqual(count, 2);
16841 assert.strictEqual(over(true), true);
16842 assert.strictEqual(over(false), false);
16850 assert.strictEqual(over({ 'a': 1, 'b': 1 }), true);
16851 assert.strictEqual(over({ 'a': 0, 'b': 1 }), false);
16859 assert.strictEqual(over({ 'a': 1, 'b': 2 }), true);
16860 assert.strictEqual(over({ 'a': 0, 'b': 2 }), false);
16868 assert.strictEqual(over({ 'a': 1, 'b': 2 }), true);
16869 assert.strictEqual(over({ 'a': 0, 'b': 2 }), false);
16877 assert.strictEqual(over({ 'a': 1, '1': 1 }), true);
16878 assert.strictEqual(over({ 'a': 1, '1': 0 }), false);
16879 assert.strictEqual(over({ 'a': 0, '1': 1 }), false);
16883 assert.strictEqual(over({ 'a': 1 }), true);
16884 assert.strictEqual(over({ 'a': 2 }), false);
16891 assert.strictEqual(over(), false);
16913 assert.strictEqual(object.over(), true);
16916 assert.strictEqual(object.over(), false);
16929 assert.strictEqual(over(), true);
16932 assert.strictEqual(over(), true);
16943 assert.strictEqual(over(), true);
16944 assert.strictEqual(count, 2);
16951 assert.strictEqual(over(), false);
16954 assert.strictEqual(over(), false);
16962 assert.strictEqual(over(true), true);
16963 assert.strictEqual(over(false), false);
16971 assert.strictEqual(over({ 'a': 1, 'b': 0 }), true);
16972 assert.strictEqual(over({ 'a': 0, 'b': 0 }), false);
16980 assert.strictEqual(over({ 'a': 0, 'b': 2 }), true);
16981 assert.strictEqual(over({ 'a': 0, 'b': 0 }), false);
16989 assert.strictEqual(over({ 'a': 0, 'b': 2 }), true);
16990 assert.strictEqual(over({ 'a': 0, 'b': 0 }), false);
16998 assert.strictEqual(over({ 'a': 0, '1': 0 }), false);
16999 assert.strictEqual(over({ 'a': 1, '1': 0 }), true);
17000 assert.strictEqual(over({ 'a': 0, '1': 1 }), true);
17004 assert.strictEqual(over({ 'a': 1 }), true);
17005 assert.strictEqual(over({ 'a': 2 }), false);
17012 assert.strictEqual(over(), true);
17034 assert.strictEqual(object.over(), true);
17037 assert.strictEqual(object.over(), false);
17064 assert.strictEqual(_.pad(string, 8), ' abc ');
17065 assert.strictEqual(_.pad(string, 8, '_-'), '_-abc_-_');
17105 assert.strictEqual(_.padEnd(string, 6, '_-'), 'abc_-_');
17145 assert.strictEqual(_.padStart(string, 6, '_-'), '_-_abc');
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);
17241 assert.strictEqual(_.parseInt('10'), 10);
17242 assert.strictEqual(_.parseInt('10', 0), 10);
17243 assert.strictEqual(_.parseInt('10', 10), 10);
17244 assert.strictEqual(_.parseInt('10', undefined), 10);
17251 assert.strictEqual(_.parseInt(string), 32);
17252 assert.strictEqual(_.parseInt(string, 0), 32);
17253 assert.strictEqual(_.parseInt(string, 16), 32);
17254 assert.strictEqual(_.parseInt(string, undefined), 32);
17261 assert.strictEqual(_.parseInt('08'), 8);
17262 assert.strictEqual(_.parseInt('08', 10), 8);
17302 assert.strictEqual(_.parseInt('08', object), 8);
17303 assert.strictEqual(_.parseInt('0x20', object), 32);
17332 assert.strictEqual(par(), 'a');
17351 assert.strictEqual(par(), 0);
17358 assert.strictEqual(par('a'), 'a');
17402 assert.strictEqual(par.length, 0);
17416 assert.strictEqual(new par(true), object);
17430 assert.strictEqual(par1('fred'), isPartial ? 'hi fred' : 'fred hi');
17431 assert.strictEqual(par2(), isPartial ? 'hi barney' : 'barney hi');
17432 assert.strictEqual(par3(), isPartial ? 'hi pebbles' : 'pebbles hi');
17441 assert.strictEqual(curried(2, 3), 6);
17442 assert.strictEqual(curried(2)(3), 6);
17542 assert.strictEqual(new combo(0), object);
17606 assert.strictEqual(c(), 1);
17912 assert.strictEqual(actual[symbol], 1);
17913 assert.strictEqual(actual[symbol2], 2);
17916 assert.strictEqual(actual[symbol3], 3);
17946 assert.strictEqual(prop.length, 1);
17947 assert.strictEqual(prop(object), 1);
17958 assert.strictEqual(prop(object), 2);
17970 assert.strictEqual(prop(new Foo), 1);
17981 assert.strictEqual(prop(array), 2);
18026 assert.strictEqual(prop(object), 1);
18071 assert.strictEqual(prop(object), undefined);
18087 assert.strictEqual(propOf.length, 1);
18089 assert.strictEqual(propOf(path), 1);
18100 assert.strictEqual(propOf(path), 2);
18115 assert.strictEqual(propOf(path), 2);
18126 assert.strictEqual(propOf(path), 2);
18171 assert.strictEqual(propOf(path), 1);
18213 assert.strictEqual(propOf(path), undefined);
18300 assert.strictEqual(actual, array);
18657 assert.strictEqual(1 / actual[0], -Infinity);
18799 assert.strictEqual(_.reduce(array), 1);
18861 assert.strictEqual(_.reduceRight(array), 3);
18929 assert.strictEqual(actual, isReduce ? 'abc' : 'cba');
18965 assert.strictEqual(actual, undefined);
18976 assert.strictEqual(func(array, noop), undefined);
18981 assert.strictEqual(func(object, noop), undefined);
18988 assert.strictEqual(_(array)[methodName](add), 6);
19254 assert.strictEqual(_.repeat('*', 3), '***');
19255 assert.strictEqual(_.repeat(string, 2), 'abcabc');
19275 assert.strictEqual(_.repeat(string, 0), '');
19276 assert.strictEqual(_.repeat(string, -2), '');
19282 assert.strictEqual(_.repeat(string, '2'), 'abcabc');
19283 assert.strictEqual(_.repeat(string, 2.6), 'abcabc');
19284 assert.strictEqual(_.repeat('*', { 'valueOf': stubThree }), '***');
19290 assert.strictEqual(_.repeat(Object(string), 2), 'abcabc');
19291 assert.strictEqual(_.repeat({ 'toString': lodashStable.constant('*') }, 3), '***');
19311 assert.strictEqual(_.replace(string, 'de', '123'), 'abc123');
19312 assert.strictEqual(_.replace(string, /[bd]/g, '-'), 'a-c-e');
19326 assert.strictEqual(_.result(object, 'b'), 'b');
19333 assert.strictEqual(actual, 'b');
19342 assert.strictEqual(_.result(value, path), 'b');
19352 assert.strictEqual(_.result(value, path), 1);
19370 assert.strictEqual(func(object, path), 1);
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);
19490 assert.strictEqual(func(object, path), undefined);
19500 assert.strictEqual(func(object, path), null);
19511 assert.strictEqual(func(0, path), 2);
19535 assert.strictEqual(func({}, [], 'a'), 'a');
19615 assert.strictEqual(actual, array);
19630 assert.strictEqual(actual, array);
19676 assert.strictEqual(actual, '1');
19720 assert.strictEqual(wrapped.value(), _.head(expected));
19743 assert.strictEqual(actual, isCeil ? 5 : 4);
19750 assert.strictEqual(actual, isCeil ? 5 : 4);
19757 assert.strictEqual(actual, isFloor ? 4.01 : 4.02);
19760 assert.strictEqual(actual, 4.1);
19767 assert.strictEqual(actual, isFloor ? 4100 : 4200);
19774 assert.strictEqual(actual, isCeil ? 5 : 4);
19779 assert.strictEqual(actual, expected);
19782 assert.strictEqual(actual, expected);
19829 assert.strictEqual(actual, Infinity);
19832 assert.strictEqual(actual, Infinity);
19835 assert.strictEqual(actual, Infinity);
19838 assert.strictEqual(actual, Infinity);
19841 assert.strictEqual(actual, isFloor ? Infinity : Infinity);
19844 assert.strictEqual(actual, isCeil ? Infinity : Infinity);
19851 assert.strictEqual(actual, -Infinity);
19854 assert.strictEqual(actual, -Infinity);
19857 assert.strictEqual(actual, -Infinity);
19860 assert.strictEqual(actual, -Infinity);
19863 assert.strictEqual(actual, isFloor ? -Infinity : -Infinity);
19866 assert.strictEqual(actual, isCeil ? -Infinity : -Infinity);
19926 assert.strictEqual(id, '1');
19985 assert.strictEqual(actual.length, 2);
20032 assert.strictEqual(actual.length, 1);
20055 assert.strictEqual(actual.length, 2);
20109 assert.strictEqual(actual, object);
20110 assert.strictEqual(object.a, value);
20136 assert.strictEqual(_.unset(object, symbol), true);
20151 assert.strictEqual(actual, object);
20152 assert.strictEqual(object.a.b, value);
20163 assert.strictEqual(actual, object);
20174 assert.strictEqual(object.a.b.c, value);
20212 assert.strictEqual(object.a[-1.23]['["b"]'].c["['d']"]['\ne\n'].f.g, value);
20225 assert.strictEqual(actual, object);
20339 assert.strictEqual(_.size({ 'one': 1, 'two': 2, 'three': 3 }), 3);
20345 assert.strictEqual(_.size(array), 3);
20365 assert.strictEqual(_.size(args), 3);
20376 assert.strictEqual(_.size(new Foo(array)), 3);
20386 assert.strictEqual(_.size(map), 2);
20402 assert.strictEqual(_.size(set), 2);
20414 assert.strictEqual(_.size({ 'length': -1 }), 1);
20420 assert.strictEqual(_.size({ 'length': MAX_SAFE_INTEGER + 1 }), 1);
20426 assert.strictEqual(_.size({ 'length': '0' }), 1);
20606 assert.strictEqual(_.some([false, 1, ''], identity), true);
20607 assert.strictEqual(_.some([null, 'a', 0], identity), true);
20629 assert.strictEqual(_.some([null, true, null], function(value) {
20634 assert.strictEqual(count, 2);
20640 assert.strictEqual(_.some([false, false, false], identity), false);
20641 assert.strictEqual(_.some([null, 0, ''], identity), false);
20670 assert.strictEqual(_.some(objects, 'a'), false);
20671 assert.strictEqual(_.some(objects, 'b'), true);
20678 assert.strictEqual(_.some(objects, { 'a': 0 }), true);
20679 assert.strictEqual(_.some(objects, { 'b': 2 }), false);
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);
20998 assert.strictEqual(actual, 1);
21023 assert.strictEqual(actual, expected);
21102 assert.strictEqual(wrapped.split('b').join(','), 'a,c');
21187 assert.strictEqual(_.startCase('--foo-bar--'), 'Foo Bar');
21188 assert.strictEqual(_.startCase('fooBar'), 'Foo Bar');
21189 assert.strictEqual(_.startCase('__FOO_BAR__'), 'FOO BAR');
21203 assert.strictEqual(_.startsWith(string, 'a'), true);
21209 assert.strictEqual(_.startsWith(string, 'b'), false);
21215 assert.strictEqual(_.startsWith(string, 'b', 1), true);
21222 assert.strictEqual(_.startsWith(string, 'a', position), false);
21242 assert.strictEqual(_.startsWith(string, 'a', position), true);
21243 assert.strictEqual(_.startsWith(string, 'b', position), false);
21250 assert.strictEqual(_.startsWith(string, 'bc', 1.2), true);
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…
21340 assert.strictEqual(_.subtract(6, 4), 2);
21341 assert.strictEqual(_.subtract(-6, 4), -10);
21342 assert.strictEqual(_.subtract(-6, -4), -2);
21348 assert.strictEqual(_.subtract('6', '4'), 2);
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);
21469 assert.strictEqual(_.sumBy(arrays, 0), 6);
21470 assert.strictEqual(_.sumBy(objects, 'a'), 6);
21485 assert.strictEqual(func(array), 12);
21503 assert.strictEqual(func([1, undefined]), 1);
21515 assert.strictEqual(func(['1', '2']), '12');
21846 assert.strictEqual(wrapped.last(), _.last(expected));
21965 assert.strictEqual(wrapped.last(), _.last(expected));
22051 assert.strictEqual(actual, array);
22052 assert.strictEqual(intercepted, array);
22074 assert.strictEqual(intercepted, array);
22105 assert.strictEqual(compiled({}), 'undefined');
22121 assert.strictEqual(actual, '<ul><li>A</li><li>B</li></ul>');
22130 assert.strictEqual(compiled(data), 'yap');
22139 assert.strictEqual(compiled(data), '1');
22162 assert.strictEqual(compiled(data), 'a="A"');
22171 assert.strictEqual(compiled(data), 'a');
22183 assert.strictEqual(actual, 'function');
22217 assert.strictEqual(compiled(data), value, key);
22225 assert.strictEqual(_.template('1${value}3')(data), '123');
22226 assert.strictEqual(_.template('${"{" + value + "\\}"}')(data), '{2}');
22233 assert.strictEqual(compiled({}), '1');
22248 assert.strictEqual(compiled(data), '123');
22270 assert.strictEqual(compiled(data), expected);
22291 assert.strictEqual(compiled(data), expected);
22302 assert.strictEqual(actual, '1b012');
22316 assert.strictEqual(compiled({ 'a': 1 }), '1');
22335 assert.strictEqual(compiled({ 'a': 1 }), '1');
22363 assert.strictEqual(compiled(data), expected);
22371 assert.strictEqual(_.template(expected)({}), expected);
22378 assert.strictEqual(compiled(), 'abc');
22382 assert.strictEqual(object.compiled(), 'ABC');
22391 assert.strictEqual(compiled(data), 'A \\b');
22398 assert.strictEqual(compiled(), "'\n\r\t\u2028\u2029\\");
22402 assert.strictEqual(compiled(data), '\'\n\r\tA\u2028\u2029\\"');
22409 assert.strictEqual(compiled(), '\u2028\u2028\u2029\u2029');
22422 assert.strictEqual(compiled(data), "'a',\"A\"");
22434 assert.strictEqual(compiled({ 'value': 3 }), '<p>6</p>');
22443 assert.strictEqual(compiled(data), '<span class="icon-12"></span>');
22461 assert.strictEqual(compiled(), '<<\n a \n>>');
22470 assert.strictEqual(compiled(data), '');
22473 assert.strictEqual(compiled(data), '');
22477 assert.strictEqual(compiled(data), '');
22502 assert.strictEqual(compiled(data), expected);
22511 assert.strictEqual(compiled(data), 'AB');
22520 assert.strictEqual(_.template(object)(data), '1');
22624 assert.strictEqual(_.truncate(string), 'hi-diddly-ho there, neighbo...');
22630 assert.strictEqual(_.truncate(string, { 'length': string.length }), string);
22631 assert.strictEqual(_.truncate(string, { 'length': string.length + 2 }), string);
22637 assert.strictEqual(_.truncate(string, { 'length': 24 }), 'hi-diddly-ho there, n...');
22643 …assert.strictEqual(_.truncate(string, { 'omission': ' [...]' }), 'hi-diddly-ho there, neig [...]');
22649 … assert.strictEqual(_.truncate(string, { 'omission': null }), 'hi-diddly-ho there, neighbnull');
22650 …assert.strictEqual(_.truncate(string, { 'omission': undefined }), 'hi-diddly-ho there, nundefined'…
22656 assert.strictEqual(_.truncate(string, { 'length': 4 }), 'h...');
22662 …assert.strictEqual(_.truncate(string, { 'length': 24, 'separator': ' ' }), 'hi-diddly-ho there,...…
22663 …assert.strictEqual(_.truncate(string, { 'length': 24, 'separator': /,? +/ }), 'hi-diddly-ho there.…
22664 …assert.strictEqual(_.truncate(string, { 'length': 24, 'separator': /,? +/g }), 'hi-diddly-ho there…
22671 assert.strictEqual(_.truncate(string, { 'length': length }), '...');
22680 …assert.strictEqual(_.truncate(string, { 'length': { 'valueOf': lodashStable.constant(length) } }),…
22687 assert.strictEqual(_.truncate(Object(string), { 'length': 4 }), 'h...');
22688 …assert.strictEqual(_.truncate({ 'toString': lodashStable.constant(string) }, { 'length': 5 }), 'hi…
22771 assert.strictEqual(callCount, 2);
22790 assert.strictEqual(callCount, 1);
22793 assert.strictEqual(callCount, 1);
22835 assert.strictEqual(callCount, 1);
22840 assert.strictEqual(callCount, 1);
22844 assert.strictEqual(callCount, 2);
22859 assert.strictEqual(callCount, 1);
22862 assert.strictEqual(callCount, 2);
22871 assert.strictEqual(withLeading('a'), 'a');
22874 assert.strictEqual(withoutLeading('a'), undefined);
22895 assert.strictEqual(withTrailing('a'), 'a');
22896 assert.strictEqual(withTrailing('b'), 'a');
22898 assert.strictEqual(withoutTrailing('a'), 'a');
22899 assert.strictEqual(withoutTrailing('b'), 'a');
22902 assert.strictEqual(withCount, 2);
22903 assert.strictEqual(withoutCount, 1);
22957 assert.strictEqual(callCount, 1);
22960 assert.strictEqual(callCount, 2);
22998 assert.strictEqual(callCount, isDebounce ? 1 : 2);
23080 assert.strictEqual(callCount, isDebounce ? 1 : 2);
23105 assert.strictEqual(callCount, 0);
23121 assert.strictEqual(funced(), 1);
23124 assert.strictEqual(funced(), 2);
23128 assert.strictEqual(callCount, 3);
23145 assert.strictEqual(funced.flush(), 1);
23148 assert.strictEqual(callCount, 1);
23162 assert.strictEqual(funced.flush(), undefined);
23165 assert.strictEqual(callCount, 0);
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);
23444 assert.strictEqual(_.toLength(-1), 0);
23445 assert.strictEqual(_.toLength('1'), 1);
23446 assert.strictEqual(_.toLength(1.1), 1);
23447 assert.strictEqual(_.toLength(MAX_INTEGER), MAX_ARRAY_LENGTH);
23453 assert.strictEqual(_.toLength(0), 0);
23454 assert.strictEqual(_.toLength(3), 3);
23455 assert.strictEqual(_.toLength(MAX_ARRAY_LENGTH), MAX_ARRAY_LENGTH);
23461 assert.strictEqual(1 / _.toLength(-0), Infinity);
23731 assert.strictEqual(_.entries, _.toPairs);
23743 assert.strictEqual(_.entriesIn, _.toPairsIn);
23982 assert.strictEqual(_.toString(symbol), 'Symbol(a)');
23997 assert.strictEqual(_.toString([symbol]), 'Symbol(a)');
24012 assert.strictEqual(wrapped.toString(), '1,2,3');
24120 assert.strictEqual(_.transform(null, null, accumulator), accumulator);
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);
24323 assert.strictEqual(_(string)[methodName](), expected);
24369 assert.strictEqual(_.camelCase(hearts + ' the ' + leafs), hearts + 'The' + leafs);
24370 assert.strictEqual(_.camelCase(string), 'a' + leafs + comboGlyph + 'And' + rocket);
24371 assert.strictEqual(_.capitalize(rocket), rocket);
24373 assert.strictEqual(_.pad(string, 16), ' ' + string + ' ');
24374 assert.strictEqual(_.padStart(string, 16), ' ' + string);
24375 assert.strictEqual(_.padEnd(string, 16), string + ' ');
24377 assert.strictEqual(_.pad(string, 16, chars), hearts + string + chars);
24378 assert.strictEqual(_.padStart(string, 16, chars), chars + hearts + string);
24379 assert.strictEqual(_.padEnd(string, 16, chars), string + chars + hearts);
24381 assert.strictEqual(_.size(string), 13);
24394 assert.strictEqual(_.trim(trimString, chars), string);
24395 assert.strictEqual(_.trimStart(trimString, chars), string + trimChars);
24396 assert.strictEqual(_.trimEnd(trimString, chars), trimChars + string);
24398 assert.strictEqual(_.truncate(string, { 'length': 13 }), string);
24399 assert.strictEqual(_.truncate(string, { 'length': 6 }), 'A ' + leafs + '...');
24410 assert.strictEqual(actual, 'A...');
24411 assert.strictEqual(actual.length, 4);
24414 assert.strictEqual(actual, hearts + '...');
24415 assert.strictEqual(actual.length, 5);
24461 assert.strictEqual(_.size(flag), 1);
24462 assert.strictEqual(_.size(regionals), 3);
24474 assert.strictEqual(_.size(heart), 1);
24503 assert.strictEqual(_.size(surrogates), 3);
24545 assert.strictEqual(object.capped(), object);
24563 assert.strictEqual(_.unescape('&lt;'), '<');
24569 assert.strictEqual(_.unescape(escaped), unescaped);
24575 assert.strictEqual(_.unescape('abc'), 'abc');
24581 assert.strictEqual(_.unescape(_.escape(unescaped)), unescaped);
24588 assert.strictEqual(_.unescape(entity), entity);
24891 assert.strictEqual(actual[0], largeArray[0]);
24985 assert.strictEqual(lodashStable.uniq(actual).length, actual.length);
24991 assert.strictEqual(typeof _.uniqueId(), 'string');
25012 assert.strictEqual(_.unset(object, path), true);
25038 assert.strictEqual(_.unset(object, symbol), true);
25051 assert.strictEqual(_.unset(object, path), true);
25066 assert.strictEqual(_.unset(object, path), true);
25077 assert.strictEqual(_.unset(object, path), true);
25110 assert.strictEqual(actual, true);
25120 assert.strictEqual(actual, true);
25139 assert.strictEqual(_.unset(object, 'a'), false);
25230 assert.strictEqual(n, oldValue);
25234 assert.strictEqual(object.a[0].b.c, expected);
25248 assert.strictEqual(_.upperCase('--foo-bar--'), 'FOO BAR');
25249 assert.strictEqual(_.upperCase('fooBar'), 'FOO BAR');
25250 assert.strictEqual(_.upperCase('__foo_bar__'), 'FOO BAR');
25262 assert.strictEqual(_.upperFirst('fred'), 'Fred');
25263 assert.strictEqual(_.upperFirst('Fred'), 'Fred');
25264 assert.strictEqual(_.upperFirst('FRED'), 'FRED');
25509 assert.strictEqual(p('fred, barney, & pebbles'), '<p>fred, barney, & pebbles</p>');
25547 assert.strictEqual(object.p(), '<p>fred, barney, & pebbles</p>');
25909 assert.strictEqual(wrapped.value(), 1);
25950 assert.strictEqual(wrapped[Symbol.iterator](), wrapped);
26085 assert.strictEqual(wrapped.pop(), 2);
26087 assert.strictEqual(wrapped.pop(), 1);
26090 assert.strictEqual(actual, array);
26132 assert.strictEqual(actual, array);
26173 assert.strictEqual(wrapped.shift(), 1);
26175 assert.strictEqual(wrapped.shift(), 2);
26178 assert.strictEqual(actual, array);
26220 assert.strictEqual(actual, array);
26266 assert.strictEqual(actual, array);
26308 assert.strictEqual(actual, array);
26364 assert.strictEqual(Number(wrapped), 123);
26376 assert.strictEqual(JSON.stringify(wrapped), '[1,2,3]');
26388 assert.strictEqual(_.prototype.toJSON, expected);
26389 assert.strictEqual(_.prototype.valueOf, expected);
26879 …assert.strictEqual(actual === array, isPull, '_.' + methodName + ' should ' + (isPull ? '' : 'not …
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…