/** Used as the `TypeError` message for "Functions" methods. */
var FUNC_ERROR_TEXT = 'Expected a function';
- /** Used as the maximum memoize cache size. */
- var MAX_MEMOIZE_SIZE = 500;
-
/** Used as references for various `Number` constants. */
var MAX_SAFE_INTEGER = 9007199254740991,
MAX_INTEGER = 1.7976931348623157e+308;
/** Method and object shortcuts. */
var phantom = root.phantom,
process = root.process,
- amd = root.define ? define.amd : undefined,
- args = toArgs([1, 2, 3]),
- argv = process ? process.argv : undefined,
+ amd = root.define && define.amd,
+ argv = process && process.argv,
defineProperty = Object.defineProperty,
- document = phantom ? undefined : root.document,
- body = root.document ? root.document.body : undefined,
+ document = !phantom && root.document,
+ body = root.document && root.document.body,
create = Object.create,
fnToString = funcProto.toString,
freeze = Object.freeze,
getSymbols = Object.getOwnPropertySymbols,
identity = function(value) { return value; },
+ JSON = root.JSON,
noop = function() {},
objToString = objectProto.toString,
params = argv,
push = arrayProto.push,
realm = {},
- slice = arrayProto.slice,
- strictArgs = (function() { 'use strict'; return arguments; }(1, 2, 3));
+ slice = arrayProto.slice;
var ArrayBuffer = root.ArrayBuffer,
Buffer = root.Buffer,
- Map = root.Map,
Promise = root.Promise,
- Proxy = root.Proxy,
+ Map = root.Map,
Set = root.Set,
Symbol = root.Symbol,
Uint8Array = root.Uint8Array,
isEven = function(n) { return n % 2 == 0; },
square = function(n) { return n * n; };
- /** Stub functions. */
- var stubA = function() { return 'a'; },
- stubB = function() { return 'b'; },
- stubC = function() { return 'c'; };
+ /** Constant functions. */
+ var alwaysA = function() { return 'a'; },
+ alwaysB = function() { return 'b'; },
+ alwaysC = function() { return 'c'; };
- var stubTrue = function() { return true; },
- stubFalse = function() { return false; };
+ var alwaysTrue = function() { return true; },
+ alwaysFalse = function() { return false; };
- var stubNaN = function() { return NaN; },
- stubNull = function() { return null; };
+ var alwaysNaN = function() { return NaN; },
+ alwaysNull = function() { return null; };
- var stubZero = function() { return 0; },
- stubOne = function() { return 1; },
- stubTwo = function() { return 2; },
- stubThree = function() { return 3; },
- stubFour = function() { return 4; };
+ var alwaysZero = function() { return 0; },
+ alwaysOne = function() { return 1; },
+ alwaysTwo = function() { return 2; },
+ alwaysThree = function() { return 3; },
+ alwaysFour = function() { return 4; };
- var stubArray = function() { return []; },
- stubObject = function() { return {}; },
- stubString = function() { return ''; };
+ var alwaysEmptyArray = function() { return []; },
+ alwaysEmptyObject = function() { return {}; },
+ alwaysEmptyString = function() { return ''; };
- /** List of Latin Unicode letters. */
+ /** List of latin-1 supplementary letters to basic latin letters. */
var burredLetters = [
- // Latin-1 Supplement letters.
- '\xc0', '\xc1', '\xc2', '\xc3', '\xc4', '\xc5', '\xc6', '\xc7', '\xc8', '\xc9', '\xca', '\xcb', '\xcc', '\xcd', '\xce', '\xcf',
- '\xd0', '\xd1', '\xd2', '\xd3', '\xd4', '\xd5', '\xd6', '\xd8', '\xd9', '\xda', '\xdb', '\xdc', '\xdd', '\xde', '\xdf',
- '\xe0', '\xe1', '\xe2', '\xe3', '\xe4', '\xe5', '\xe6', '\xe7', '\xe8', '\xe9', '\xea', '\xeb', '\xec', '\xed', '\xee', '\xef',
- '\xf0', '\xf1', '\xf2', '\xf3', '\xf4', '\xf5', '\xf6', '\xf8', '\xf9', '\xfa', '\xfb', '\xfc', '\xfd', '\xfe', '\xff',
- // Latin Extended-A letters.
- '\u0100', '\u0101', '\u0102', '\u0103', '\u0104', '\u0105', '\u0106', '\u0107', '\u0108', '\u0109', '\u010a', '\u010b', '\u010c', '\u010d', '\u010e', '\u010f',
- '\u0110', '\u0111', '\u0112', '\u0113', '\u0114', '\u0115', '\u0116', '\u0117', '\u0118', '\u0119', '\u011a', '\u011b', '\u011c', '\u011d', '\u011e', '\u011f',
- '\u0120', '\u0121', '\u0122', '\u0123', '\u0124', '\u0125', '\u0126', '\u0127', '\u0128', '\u0129', '\u012a', '\u012b', '\u012c', '\u012d', '\u012e', '\u012f',
- '\u0130', '\u0131', '\u0132', '\u0133', '\u0134', '\u0135', '\u0136', '\u0137', '\u0138', '\u0139', '\u013a', '\u013b', '\u013c', '\u013d', '\u013e', '\u013f',
- '\u0140', '\u0141', '\u0142', '\u0143', '\u0144', '\u0145', '\u0146', '\u0147', '\u0148', '\u0149', '\u014a', '\u014b', '\u014c', '\u014d', '\u014e', '\u014f',
- '\u0150', '\u0151', '\u0152', '\u0153', '\u0154', '\u0155', '\u0156', '\u0157', '\u0158', '\u0159', '\u015a', '\u015b', '\u015c', '\u015d', '\u015e', '\u015f',
- '\u0160', '\u0161', '\u0162', '\u0163', '\u0164', '\u0165', '\u0166', '\u0167', '\u0168', '\u0169', '\u016a', '\u016b', '\u016c', '\u016d', '\u016e', '\u016f',
- '\u0170', '\u0171', '\u0172', '\u0173', '\u0174', '\u0175', '\u0176', '\u0177', '\u0178', '\u0179', '\u017a', '\u017b', '\u017c', '\u017d', '\u017e', '\u017f'
+ '\xc0', '\xc1', '\xc2', '\xc3', '\xc4', '\xc5', '\xc6', '\xc7', '\xc8', '\xc9', '\xca', '\xcb', '\xcc', '\xcd', '\xce',
+ '\xcf', '\xd0', '\xd1', '\xd2', '\xd3', '\xd4', '\xd5', '\xd6', '\xd8', '\xd9', '\xda', '\xdb', '\xdc', '\xdd', '\xde',
+ '\xdf', '\xe0', '\xe1', '\xe2', '\xe3', '\xe4', '\xe5', '\xe6', '\xe7', '\xe8', '\xe9', '\xea', '\xeb', '\xec', '\xed', '\xee',
+ '\xef', '\xf0', '\xf1', '\xf2', '\xf3', '\xf4', '\xf5', '\xf6', '\xf8', '\xf9', '\xfa', '\xfb', '\xfc', '\xfd', '\xfe', '\xff'
];
/** List of combining diacritical marks. */
'\ufe20', '\ufe21', '\ufe22', '\ufe23'
];
- /** List of converted Latin Unicode letters. */
+ /** List of `burredLetters` translated to basic latin letters. */
var deburredLetters = [
- // Converted Latin-1 Supplement letters.
'A', 'A', 'A', 'A', 'A', 'A', 'Ae', 'C', 'E', 'E', 'E', 'E', 'I', 'I', 'I',
'I', 'D', 'N', 'O', 'O', 'O', 'O', 'O', 'O', 'U', 'U', 'U', 'U', 'Y', 'Th',
'ss', 'a', 'a', 'a', 'a', 'a', 'a', 'ae', 'c', 'e', 'e', 'e', 'e', 'i', 'i', 'i',
- 'i', 'd', 'n', 'o', 'o', 'o', 'o', 'o', 'o', 'u', 'u', 'u', 'u', 'y', 'th', 'y',
- // Converted Latin Extended-A letters.
- 'A', 'a', 'A', 'a', 'A', 'a', 'C', 'c', 'C', 'c', 'C', 'c', 'C', 'c',
- 'D', 'd', 'D', 'd', 'E', 'e', 'E', 'e', 'E', 'e', 'E', 'e', 'E', 'e',
- 'G', 'g', 'G', 'g', 'G', 'g', 'G', 'g', 'H', 'h', 'H', 'h',
- 'I', 'i', 'I', 'i', 'I', 'i', 'I', 'i', 'I', 'i', 'IJ', 'ij', 'J', 'j',
- 'K', 'k', 'k', 'L', 'l', 'L', 'l', 'L', 'l', 'L', 'l', 'L', 'l',
- 'N', 'n', 'N', 'n', 'N', 'n', "'n", 'N', 'n',
- 'O', 'o', 'O', 'o', 'O', 'o', 'Oe', 'oe',
- 'R', 'r', 'R', 'r', 'R', 'r', 'S', 's', 'S', 's', 'S', 's', 'S', 's',
- 'T', 't', 'T', 't', 'T', 't',
- 'U', 'u', 'U', 'u', 'U', 'u', 'U', 'u', 'U', 'u', 'U', 'u',
- 'W', 'w', 'Y', 'y', 'Y', 'Z', 'z', 'Z', 'z', 'Z', 'z', 's'
+ 'i', 'd', 'n', 'o', 'o', 'o', 'o', 'o', 'o', 'u', 'u', 'u', 'u', 'y', 'th', 'y'
];
/** Used to provide falsey values to methods. */
'buildPath': filePath,
'loaderPath': '',
'isModularize': /\b(?:amd|commonjs|es|node|npm|(index|main)\.js)\b/.test(filePath),
- 'isStrict': /\bes\b/.test(filePath) || 'default' in require(filePath),
+ 'isStrict': /\bes\b/.test(filePath),
'urlParams': {}
});
// Leak to avoid sporadic `noglobals` fails on Edge in Sauce Labs.
root.msWDfn = undefined;
- // Assign `setTimeout` to itself to avoid being flagged as a leak.
- setProperty(root, 'setTimeout', setTimeout);
-
// Exit early if going to run tests in a PhantomJS web page.
if (phantom && isModularize) {
var page = require('webpage').create();
});
} catch (e) {}
- /** Load QUnit and extras. */
- var QUnit = root.QUnit || require('qunit-extras');
+ /** Use a single "load" function. */
+ var load = (!amd && typeof require == 'function')
+ ? require
+ : noop;
+
+ /** The unit testing framework. */
+ var QUnit = root.QUnit || (root.QUnit = load('../node_modules/qunitjs/qunit/qunit.js'));
- /** Load stable Lodash. */
+ /** Load stable Lodash and QUnit Extras. */
var lodashStable = root.lodashStable;
if (!lodashStable) {
try {
- lodashStable = interopRequire('../node_modules/lodash/lodash.js');
+ lodashStable = load('../node_modules/lodash/lodash.js');
} catch (e) {
console.log('Error: The stable lodash dev dependency should be at least a version behind master branch.');
return;
}
lodashStable = lodashStable.noConflict();
}
+ lodashStable = lodashStable.runInContext(root);
+
+ var QUnitExtras = load('../node_modules/qunit-extras/qunit-extras.js');
+ if (QUnitExtras) {
+ QUnitExtras.runInContext(root);
+ }
/** The `lodash` function to test. */
- var _ = root._ || (root._ = interopRequire(filePath));
-
- /** Used to test pseudo private map caches. */
- var mapCaches = (function() {
- var MapCache = _.memoize.Cache;
- var result = {
- 'Hash': new MapCache().__data__.hash.constructor,
- 'MapCache': MapCache
- };
- _.isMatchWith({ 'a': 1 }, { 'a': 1 }, function() {
- var stack = lodashStable.last(arguments);
- result.ListCache = stack.__data__.constructor;
- result.Stack = stack.constructor;
- });
- return result;
- }());
+ var _ = root._ || (root._ = (
+ _ = load(filePath),
+ _ = _._ || (isStrict = ui.isStrict = isStrict || 'default' in _, _['default']) || _,
+ (_.runInContext ? _.runInContext(root) : _)
+ ));
/** Used to detect instrumented istanbul code coverage runs. */
- var coverage = root.__coverage__ || root[lodashStable.find(lodashStable.keys(root), function(key) {
+ var coverage = root.__coverage__ || root[lodashStable.findKey(root, function(value, key) {
return /^(?:\$\$cov_\d+\$\$)$/.test(key);
})];
- /** Used to test async functions. */
- var asyncFunc = lodashStable.attempt(function() {
- return Function('return async () => {}');
- });
-
/** Used to test generator functions. */
- var genFunc = lodashStable.attempt(function() {
+ var generator = lodashStable.attempt(function() {
return Function('return function*(){}');
});
}
/**
- * Loads the module of `id`. If the module has an `exports.default`, the
- * exported default value is returned as the resolved module.
- *
- * @private
- * @param {string} id The identifier of the module to resolve.
- * @returns {*} Returns the resolved module.
- */
- function interopRequire(id) {
- var result = require(id);
- return 'default' in result ? result['default'] : result;
- }
-
- /**
* Sets a non-enumerable property value on `object`.
*
* Note: This function is used to avoid a bug in older versions of V8 where
}
}
- /**
- * Converts `array` to an `arguments` object.
- *
- * @private
- * @param {Array} array The array to convert.
- * @returns {Object} Returns the converted `arguments` object.
- */
- function toArgs(array) {
- return (function() { return arguments; }.apply(undefined, array));
- }
-
/*--------------------------------------------------------------------------*/
// Add bizarro values.
funcProto._method = noop;
// Set bad shims.
- setProperty(Object, 'create', undefined);
+ setProperty(Object, 'create', (function() {
+ function object() {}
+ return function(prototype) {
+ if (lodashStable.isObject(prototype)) {
+ object.prototype = prototype;
+ var result = new object;
+ object.prototype = undefined;
+ }
+ return result || {};
+ };
+ }()));
+
setProperty(Object, 'getOwnPropertySymbols', undefined);
var _propertyIsEnumerable = objectProto.propertyIsEnumerable;
emptyObject(require.cache);
// Load lodash and expose it to the bad extensions/shims.
- lodashBizarro = interopRequire(filePath);
+ lodashBizarro = (lodashBizarro = require(filePath))._ || lodashBizarro['default'] || lodashBizarro;
root._ = oldDash;
// Restore built-in methods.
' });',
'',
' return object;',
- '}());'
+ '}())'
].join('\n')));
});
var idoc = (idoc = iframe.contentDocument || iframe.contentWindow).document || idoc;
idoc.write([
- '<html>',
- '<body>',
'<script>',
- 'var _ = parent._,',
- ' noop = function() {},',
- ' root = this;',
+ 'var _ = parent._;',
+ '',
+ ' var noop = function() {},',
+ ' root = this;',
'',
'var object = {',
" 'ArrayBuffer': root.ArrayBuffer,",
" 'arrayBuffer': root.ArrayBuffer ? new root.ArrayBuffer : undefined,",
" 'boolean': Object(false),",
" 'date': new Date,",
- " 'element': document.body,",
" 'errors': [new Error, new EvalError, new RangeError, new ReferenceError, new SyntaxError, new TypeError, new URIError],",
" 'function': noop,",
" 'map': root.Map ? new root.Map : undefined,",
'});',
'',
'_.assign(_._realm, object);',
- '</script>',
- '</body>',
- '</html>'
+ '<\/script>'
].join('\n'));
idoc.close();
if (isModularize && !(amd || isNpm)) {
lodashStable.each([
- 'baseEach',
- 'isIndex',
- 'isIterateeCall',
- 'memoizeCapped'
- ], function(funcName) {
- _['_' + funcName] = interopRequire(path.join(basePath, '_' + funcName));
+ '_baseEach',
+ '_isIndex',
+ '_isIterateeCall'
+ ], function(relPath) {
+ var func = require(path.join(basePath, relPath)),
+ funcName = path.basename(relPath);
+
+ _['_' + funcName] = func[funcName] || func['default'] || func;
});
}
});
});
QUnit.test('should avoid non-native built-ins', function(assert) {
- assert.expect(6);
+ assert.expect(7);
function message(lodashMethod, nativeMethod) {
return '`' + lodashMethod + '` should avoid overwritten native `' + nativeMethod + '`';
if (lodashBizarro) {
try {
- var actual = lodashBizarro.create(Foo.prototype);
+ var actual = lodashBizarro.keysIn(new Foo).sort();
+ } catch (e) {
+ actual = null;
+ }
+ var label = message('_.keysIn', 'Object#propertyIsEnumerable');
+ assert.deepEqual(actual, ['a', 'b'], label);
+
+ try {
+ var actual = lodashBizarro.isEmpty({});
} catch (e) {
actual = null;
}
- var label = message('_.create', 'Object.create');
- assert.ok(actual instanceof Foo, label);
+ var label = message('_.isEmpty', 'Object#propertyIsEnumerable');
+ assert.strictEqual(actual, true, label);
try {
actual = [
} catch (e) {
actual = null;
}
- label = message('_.difference`, `_.intersection`, and `_.uniq', 'Map');
+ label = message('_.difference`, `_.intersection`, and `_.uniq', 'Object.create` and `Map');
assert.deepEqual(actual, [[otherObject], [object], [object]], label);
try {
assert.deepEqual(actual, [object, object], label);
try {
- // Avoid buggy symbol detection in Babel's `_typeof` helper.
- var symObject = setProperty(Object(symbol), 'constructor', Object);
+ var symObject = Object(symbol);
+
+ // Avoid symbol detection in Babel's `typeof` helper.
+ symObject.constructor = Object;
+
actual = [
- Symbol ? lodashBizarro.clone(symObject) : {},
+ Symbol ? lodashBizarro.clone(symObject) : { 'constructor': Object },
Symbol ? lodashBizarro.isEqual(symObject, Object(symbol)) : false,
Symbol ? lodashBizarro.toString(symObject) : ''
];
actual = null;
}
label = message('_.clone`, `_.isEqual`, and `_.toString', 'Symbol');
- assert.deepEqual(actual, [{}, false, ''], label);
+ assert.deepEqual(actual, [{ 'constructor': Object }, false, ''], label);
try {
var map = new lodashBizarro.memoize.Cache;
assert.deepEqual(actual, [], label);
}
else {
- skipAssert(assert, 6);
+ skipAssert(assert, 7);
}
});
}());
if (func) {
var values = [[0], ['0'], ['1'], [3, 4], [MAX_SAFE_INTEGER - 1]],
- expected = lodashStable.map(values, stubTrue);
+ expected = lodashStable.map(values, alwaysTrue);
var actual = lodashStable.map(values, function(args) {
return func.apply(undefined, args);
if (func) {
var values = [['1abc'], ['07'], ['0001'], [-1], [3, 3], [1.1], [MAX_SAFE_INTEGER]],
- expected = lodashStable.map(values, stubFalse);
+ expected = lodashStable.map(values, alwaysFalse);
var actual = lodashStable.map(values, function(args) {
return func.apply(undefined, args);
/*--------------------------------------------------------------------------*/
- QUnit.module('map caches');
-
- (function() {
- var keys = [null, undefined, false, true, 1, -Infinity, NaN, {}, 'a', symbol || noop];
-
- var pairs = lodashStable.map(keys, function(key, index) {
- var lastIndex = keys.length - 1;
- return [key, keys[lastIndex - index]];
- });
-
- function createCaches(pairs) {
- var largeStack = new mapCaches.Stack(pairs),
- length = pairs ? pairs.length : 0;
-
- lodashStable.times(LARGE_ARRAY_SIZE - length, function() {
- largeStack.set({}, {});
- });
-
- return {
- 'hashes': new mapCaches.Hash(pairs),
- 'list caches': new mapCaches.ListCache(pairs),
- 'map caches': new mapCaches.MapCache(pairs),
- 'stack caches': new mapCaches.Stack(pairs),
- 'large stacks': largeStack
- };
- }
-
- lodashStable.forOwn(createCaches(pairs), function(cache, kind) {
- var isLarge = /^large/.test(kind);
-
- QUnit.test('should implement a `Map` interface for ' + kind, function(assert) {
- assert.expect(83);
-
- lodashStable.each(keys, function(key, index) {
- var value = pairs[index][1];
-
- assert.deepEqual(cache.get(key), value);
- assert.strictEqual(cache.has(key), true);
- assert.strictEqual(cache.delete(key), true);
- assert.strictEqual(cache.has(key), false);
- assert.strictEqual(cache.get(key), undefined);
- assert.strictEqual(cache.delete(key), false);
- assert.strictEqual(cache.set(key, value), cache);
- assert.strictEqual(cache.has(key), true);
- });
-
- assert.strictEqual(cache.size, isLarge ? LARGE_ARRAY_SIZE : keys.length);
- assert.strictEqual(cache.clear(), undefined);
- assert.ok(lodashStable.every(keys, function(key) {
- return !cache.has(key);
- }));
- });
- });
-
- lodashStable.forOwn(createCaches(), function(cache, kind) {
- QUnit.test('should support changing values of ' + kind, function(assert) {
- assert.expect(10);
-
- lodashStable.each(keys, function(key) {
- cache.set(key, 1).set(key, 2);
- assert.strictEqual(cache.get(key), 2);
- });
- });
- });
- }());
-
- /*--------------------------------------------------------------------------*/
-
QUnit.module('lodash constructor');
(function() {
var values = empties.concat(true, 1, 'a'),
- expected = lodashStable.map(values, stubTrue);
+ expected = lodashStable.map(values, alwaysTrue);
QUnit.test('should create a new instance when called without the `new` operator', function(assert) {
assert.expect(1);
assert.strictEqual(after(NaN, 1), 1);
});
- QUnit.test('should use `this` binding of function', function(assert) {
+ QUnit.test('should not set a `this` binding', function(assert) {
assert.expect(2);
var after = _.after(1, function(assert) { return ++this.count; }),
assert.deepEqual(actual, expected);
});
- QUnit.test('should not force a minimum argument count', function(assert) {
+ QUnit.test('should work when given less than the capped number of arguments', function(assert) {
assert.expect(1);
- var args = ['a', 'b', 'c'],
- capped = _.ary(fn, 3);
-
- var expected = lodashStable.map(args, function(arg, index) {
- return args.slice(0, index);
- });
-
- var actual = lodashStable.map(expected, function(array) {
- return capped.apply(undefined, array);
- });
-
- assert.deepEqual(actual, expected);
- });
-
- QUnit.test('should use `this` binding of function', function(assert) {
- assert.expect(1);
-
- var capped = _.ary(function(a, b) { return this; }, 1),
- object = { 'capped': capped };
-
- assert.strictEqual(object.capped(), object);
+ var capped = _.ary(fn, 3);
+ assert.deepEqual(capped('a'), ['a']);
});
QUnit.test('should use the existing `ary` if smaller', function(assert) {
};
defineProperty(object, 'a', lodashStable.assign({}, descriptor, {
- 'get': stubOne
+ 'get': alwaysOne
}));
defineProperty(object, 'b', lodashStable.assign({}, descriptor, {
}));
defineProperty(object, 'c', lodashStable.assign({}, descriptor, {
- 'get': stubNaN
+ 'get': alwaysNaN
}));
defineProperty(object, 'constructor', lodashStable.assign({}, descriptor, {
QUnit.test('`_.' + methodName + '` should work with a `customizer` that returns `undefined`', function(assert) {
assert.expect(1);
- var expected = { 'a': 1 };
+ var expected = { 'a': undefined };
assert.deepEqual(func({}, expected, noop), expected);
});
});
QUnit.module('lodash.at');
(function() {
- var array = ['a', 'b', 'c'],
+ var args = arguments,
+ array = ['a', 'b', 'c'],
object = { 'a': [{ 'b': { 'c': 3 } }, 4] };
QUnit.test('should return the elements corresponding to the specified keys', function(assert) {
result[value] = 1;
}, []);
- var expected = lodashStable.map(values, stubOne),
+ var expected = lodashStable.map(values, alwaysOne),
actual = _.at(array, values);
assert.deepEqual(actual, expected);
assert.deepEqual(actual, ['d', 'a', 'c']);
});
- QUnit.test('should work with a falsey `object` when keys are given', function(assert) {
+ QUnit.test('should work with a falsey `object` argument when keys are given', function(assert) {
assert.expect(1);
var expected = lodashStable.map(falsey, lodashStable.constant(Array(4)));
skipAssert(assert, 2);
}
});
- }());
+ }(1, 2, 3));
/*--------------------------------------------------------------------------*/
QUnit.test('should return the caught error', function(assert) {
assert.expect(1);
- var expected = lodashStable.map(errors, stubTrue);
+ var expected = lodashStable.map(errors, alwaysTrue);
var actual = lodashStable.map(errors, function(error) {
return _.attempt(function() { throw error; }) === error;
assert.expect(1);
if (realm.errors) {
- var expected = lodashStable.map(realm.errors, stubTrue);
+ var expected = lodashStable.map(realm.errors, alwaysTrue);
var actual = lodashStable.map(realm.errors, function(error) {
return _.attempt(function() { throw error; }) === error;
assert.strictEqual(before(NaN, 1), 0);
});
- QUnit.test('should use `this` binding of function', function(assert) {
+ QUnit.test('should not set a `this` binding', function(assert) {
assert.expect(2);
var before = _.before(2, function(assert) { return ++this.count; }),
assert.deepEqual(bound('a'), [object, 'a']);
});
- QUnit.test('should accept a falsey `thisArg`', function(assert) {
+ QUnit.test('should accept a falsey `thisArg` argument', function(assert) {
assert.expect(1);
var values = lodashStable.reject(falsey.slice(1), function(value) { return value == null; }),
if (typeof createCtor == 'function') {
var bound = _.bind(createCtor()),
count = 8,
- expected = lodashStable.times(count, stubTrue);
+ expected = lodashStable.times(count, alwaysTrue);
var actual = lodashStable.times(count, function(index) {
try {
QUnit.module('lodash.bindAll');
(function() {
- var args = toArgs(['a']);
+ var args = arguments;
var source = {
'_n0': -2,
assert.deepEqual(actual, [-2, -2, -1, -1]);
});
- QUnit.test('should work with an array `object`', function(assert) {
+ QUnit.test('should work with an array `object` argument', function(assert) {
assert.expect(1);
var array = ['push', 'pop'];
assert.deepEqual(actual, [1]);
});
- }());
+ }('a'));
/*--------------------------------------------------------------------------*/
return func(string) === expected;
});
- assert.deepEqual(actual, lodashStable.map(strings, stubTrue));
+ assert.deepEqual(actual, lodashStable.map(strings, alwaysTrue));
});
QUnit.test('`_.' + methodName + '` should handle double-converting strings', function(assert) {
return func(func(string)) === expected;
});
- assert.deepEqual(actual, lodashStable.map(strings, stubTrue));
+ assert.deepEqual(actual, lodashStable.map(strings, alwaysTrue));
});
QUnit.test('`_.' + methodName + '` should deburr letters', function(assert) {
assert.expect(1);
var actual = lodashStable.map(burredLetters, function(burred, index) {
- var letter = deburredLetters[index].replace(/['\u2019]/g, '');
+ var letter = deburredLetters[index];
if (caseName == 'start') {
- letter = letter == 'IJ' ? letter : lodashStable.capitalize(letter);
+ letter = lodashStable.capitalize(letter);
} else if (caseName == 'upper') {
letter = letter.toUpperCase();
} else {
return func(burred) === letter;
});
- assert.deepEqual(actual, lodashStable.map(burredLetters, stubTrue));
+ assert.deepEqual(actual, lodashStable.map(burredLetters, alwaysTrue));
});
QUnit.test('`_.' + methodName + '` should remove contraction apostrophes', function(assert) {
});
});
- QUnit.test('`_.' + methodName + '` should remove Latin mathematical operators', function(assert) {
+ QUnit.test('`_.' + methodName + '` should remove latin-1 mathematical operators', function(assert) {
assert.expect(1);
var actual = lodashStable.map(['\xd7', '\xf7'], func);
assert.expect(1);
var values = lodashStable.reject(falsey, lodashStable.isUndefined).concat(-1, -Infinity),
- expected = lodashStable.map(values, stubArray);
+ expected = lodashStable.map(values, alwaysEmptyArray);
var actual = lodashStable.map(values, function(n) {
return _.chunk(array, n);
QUnit.module('lodash.clamp');
(function() {
- QUnit.test('should work with a `max`', function(assert) {
+ QUnit.test('should work with a `max` argument', function(assert) {
assert.expect(2);
assert.strictEqual(_.clamp(5, 3), 3);
var objects = {
'`arguments` objects': arguments,
'arrays': ['a', ''],
- 'array-like objects': { '0': 'a', 'length': 1 },
+ 'array-like-objects': { '0': 'a', '1': '', 'length': 3 },
'booleans': false,
'boolean objects': Object(false),
'date objects': new Date,
var uncloneable = {
'DOM elements': body,
'functions': Foo,
- 'async functions': asyncFunc,
- 'generator functions': genFunc,
- 'the `Proxy` constructor': Proxy
+ 'generators': generator
};
lodashStable.each(errors, function(error) {
});
QUnit.test('`_.cloneDeepWith` should provide `stack` to `customizer`', function(assert) {
- assert.expect(1);
+ assert.expect(164);
+
+ var Stack,
+ keys = [null, undefined, false, true, 1, -Infinity, NaN, {}, 'a', symbol || {}];
- var actual;
+ var pairs = lodashStable.map(keys, function(key, index) {
+ var lastIndex = keys.length - 1;
+ return [key, keys[lastIndex - index]];
+ });
_.cloneDeepWith({ 'a': 1 }, function() {
- actual = _.last(arguments);
+ if (arguments.length > 1) {
+ Stack || (Stack = _.last(arguments).constructor);
+ }
});
- assert.ok(isNpm
- ? actual.constructor.name == 'Stack'
- : actual instanceof mapCaches.Stack
- );
+ var stacks = [new Stack(pairs), new Stack(pairs)];
+
+ lodashStable.times(LARGE_ARRAY_SIZE - pairs.length + 1, function() {
+ stacks[1].set({}, {});
+ });
+
+ lodashStable.each(stacks, function(stack) {
+ lodashStable.each(keys, function(key, index) {
+ var value = pairs[index][1];
+
+ assert.deepEqual(stack.get(key), value);
+ assert.strictEqual(stack.has(key), true);
+ assert.strictEqual(stack['delete'](key), true);
+ assert.strictEqual(stack.has(key), false);
+ assert.strictEqual(stack.get(key), undefined);
+ assert.strictEqual(stack['delete'](key), false);
+ assert.strictEqual(stack.set(key, value), stack);
+ assert.strictEqual(stack.has(key), true);
+ });
+
+ assert.strictEqual(stack.clear(), undefined);
+ assert.ok(lodashStable.every(keys, function(key) {
+ return !stack.has(key);
+ }));
+ });
});
lodashStable.each(['clone', 'cloneDeep'], function(methodName) {
var func = _[methodName],
isDeep = methodName == 'cloneDeep';
- lodashStable.forOwn(objects, function(object, kind) {
- QUnit.test('`_.' + methodName + '` should clone ' + kind, function(assert) {
+ lodashStable.forOwn(objects, function(object, key) {
+ QUnit.test('`_.' + methodName + '` should clone ' + key, function(assert) {
assert.expect(2);
- var actual = func(object);
- assert.ok(lodashStable.isEqual(actual, object));
+ var isEqual = (key == 'maps' || key == 'sets') ? _.isEqual : lodashStable.isEqual,
+ actual = func(object);
+
+ assert.ok(isEqual(actual, object));
if (lodashStable.isObject(object)) {
assert.notStrictEqual(actual, object);
return object;
});
- var expected = lodashStable.map(values, stubTrue);
+ var expected = lodashStable.map(values, alwaysTrue);
var actual = lodashStable.map(values, function(value) {
return func(value).a === 1;
});
QUnit.test('`_.' + methodName + '` should clone symbol properties', function(assert) {
- assert.expect(7);
+ assert.expect(3);
function Foo() {
this[symbol] = { 'c': 1 };
var symbol2 = Symbol('b');
Foo.prototype[symbol2] = 2;
- var symbol3 = Symbol('c');
- defineProperty(Foo.prototype, symbol3, {
- 'configurable': true,
- 'enumerable': false,
- 'writable': true,
- 'value': 3
- });
-
var object = { 'a': { 'b': new Foo } };
object[symbol] = { 'b': 1 };
var actual = func(object);
+
+ assert.deepEqual(getSymbols(actual.a.b), [symbol]);
+
if (isDeep) {
- assert.notStrictEqual(actual[symbol], object[symbol]);
- assert.notStrictEqual(actual.a, object.a);
- } else {
+ assert.deepEqual(actual[symbol], object[symbol]);
+ assert.deepEqual(actual.a.b[symbol], object.a.b[symbol]);
+ }
+ else {
assert.strictEqual(actual[symbol], object[symbol]);
assert.strictEqual(actual.a, object.a);
}
- assert.deepEqual(actual[symbol], object[symbol]);
- assert.deepEqual(getSymbols(actual.a.b), [symbol]);
- assert.deepEqual(actual.a.b[symbol], object.a.b[symbol]);
- assert.deepEqual(actual.a.b[symbol2], object.a.b[symbol2]);
- assert.deepEqual(actual.a.b[symbol3], object.a.b[symbol3])
}
else {
- skipAssert(assert, 7);
+ skipAssert(assert, 3);
}
});
}
}, []);
- var expected = lodashStable.map(objects, stubTrue);
+ var expected = lodashStable.map(objects, alwaysTrue);
var actual = lodashStable.map(objects, function(object) {
var Ctor = object.constructor,
if (value) {
var object = { 'a': value, 'b': { 'c': value } },
actual = func(object),
- expected = value === Foo ? { 'c': Foo.c } : {};
+ expected = (typeof value == 'function' && !!value.c) ? { 'c': Foo.c } : {};
assert.deepEqual(actual, object);
assert.notStrictEqual(actual, object);
var func = _[methodName],
isDeep = methodName == 'cloneDeepWith';
- QUnit.test('`_.' + methodName + '` should provide correct `customizer` arguments', function(assert) {
+ QUnit.test('`_.' + methodName + '` should provide the correct `customizer` arguments', function(assert) {
assert.expect(1);
var argsList = [],
assert.deepEqual(argsList, isDeep ? [[object], [1, 'a', object]] : [[object]]);
});
- QUnit.test('`_.' + methodName + '` should handle cloning when `customizer` returns `undefined`', function(assert) {
+ QUnit.test('`_.' + methodName + '` should handle cloning if `customizer` returns `undefined`', function(assert) {
assert.expect(1);
var actual = func({ 'a': { 'b': 'c' } }, noop);
lodashStable.forOwn(uncloneable, function(value, key) {
QUnit.test('`_.' + methodName + '` should work with a `customizer` callback and ' + key, function(assert) {
- assert.expect(3);
+ assert.expect(4);
var customizer = function(value) {
return lodashStable.isPlainObject(value) ? undefined : value;
};
var actual = func(value, customizer);
+
+ assert.deepEqual(actual, value);
assert.strictEqual(actual, value);
var object = { 'a': value, 'b': { 'c': value } };
});
});
});
- }());
+ }(1, 2, 3));
/*--------------------------------------------------------------------------*/
assert.expect(3);
var cond = _.cond([
- [lodashStable.matches({ 'a': 1 }), stubA],
- [lodashStable.matchesProperty('b', 1), stubB],
- [lodashStable.property('c'), stubC]
+ [lodashStable.matches({ 'a': 1 }), alwaysA],
+ [lodashStable.matchesProperty('b', 1), alwaysB],
+ [lodashStable.property('c'), alwaysC]
]);
assert.strictEqual(cond({ 'a': 1, 'b': 2, 'c': 3 }), 'a');
assert.expect(3);
var cond = _.cond([
- [{ 'a': 1 }, stubA],
- [['b', 1], stubB],
- ['c', stubC]
+ [{ 'a': 1 }, alwaysA],
+ [['b', 1], alwaysB],
+ ['c', alwaysC]
]);
assert.strictEqual(cond({ 'a': 1, 'b': 2, 'c': 3 }), 'a');
QUnit.test('should return `undefined` when no condition is met', function(assert) {
assert.expect(1);
- var cond = _.cond([[stubFalse, stubA]]);
+ var cond = _.cond([[alwaysFalse, alwaysA]]);
assert.strictEqual(cond({ 'a': 1 }), undefined);
});
assert.expect(2);
lodashStable.each([false, true], function(value) {
- assert.raises(function() { _.cond([[stubTrue, value]])(); }, TypeError);
+ assert.raises(function() { _.cond([[alwaysTrue, value]])(); }, TypeError);
});
});
QUnit.module('lodash.conforms');
(function() {
- QUnit.test('should not change behavior if `source` is modified', function(assert) {
- assert.expect(2);
-
- var object = { 'a': 2 },
- source = { 'a': function(value) { return value > 1; } },
- par = _.conforms(source);
-
- assert.strictEqual(par(object), true);
-
- source.a = function(value) { return value < 2; };
- assert.strictEqual(par(object), true);
- });
- }());
-
- /*--------------------------------------------------------------------------*/
-
- QUnit.module('conforms methods');
-
- lodashStable.each(['conforms', 'conformsTo'], function(methodName) {
- var isConforms = methodName == 'conforms';
-
- function conforms(source) {
- return isConforms ? _.conforms(source) : function(object) {
- return _.conformsTo(object, source);
- };
- }
+ var objects = [
+ { 'a': 1, 'b': 8 },
+ { 'a': 2, 'b': 4 },
+ { 'a': 3, 'b': 16 }
+ ];
- QUnit.test('`_.' + methodName + '` should check if `object` conforms to `source`', function(assert) {
+ QUnit.test('should create a function that checks if a given object conforms to `source`', function(assert) {
assert.expect(2);
- var objects = [
- { 'a': 1, 'b': 8 },
- { 'a': 2, 'b': 4 },
- { 'a': 3, 'b': 16 }
- ];
-
- var par = conforms({
+ var conforms = _.conforms({
'b': function(value) { return value > 4; }
});
- var actual = lodashStable.filter(objects, par);
+ var actual = lodashStable.filter(objects, conforms);
assert.deepEqual(actual, [objects[0], objects[2]]);
- par = conforms({
+ conforms = _.conforms({
'b': function(value) { return value > 8; },
'a': function(value) { return value > 1; }
});
- actual = lodashStable.filter(objects, par);
+ actual = lodashStable.filter(objects, conforms);
assert.deepEqual(actual, [objects[2]]);
});
- QUnit.test('`_.' + methodName + '` should not match by inherited `source` properties', function(assert) {
+ QUnit.test('should not match by inherited `source` properties', function(assert) {
assert.expect(1);
function Foo() {
return value > 8;
};
- var objects = [
- { 'a': 1, 'b': 8 },
- { 'a': 2, 'b': 4 },
- { 'a': 3, 'b': 16 }
- ];
-
- var par = conforms(new Foo),
- actual = lodashStable.filter(objects, par);
+ var conforms = _.conforms(new Foo),
+ actual = lodashStable.filter(objects, conforms);
assert.deepEqual(actual, [objects[1], objects[2]]);
});
- QUnit.test('`_.' + methodName + '` should not invoke `source` predicates for missing `object` properties', function(assert) {
+ QUnit.test('should not invoke `source` predicates for missing `object` properties', function(assert) {
assert.expect(2);
var count = 0;
- var par = conforms({
+ var conforms = _.conforms({
'a': function() { count++; return true; }
});
- assert.strictEqual(par({}), false);
+ assert.strictEqual(conforms({}), false);
assert.strictEqual(count, 0);
});
- QUnit.test('`_.' + methodName + '` should work with a function for `object`', function(assert) {
+ QUnit.test('should work with a function for `object`', function(assert) {
assert.expect(2);
function Foo() {}
function Bar() {}
Bar.a = 2;
- var par = conforms({
+ var conforms = _.conforms({
'a': function(value) { return value > 1; }
});
- assert.strictEqual(par(Foo), false);
- assert.strictEqual(par(Bar), true);
+ assert.strictEqual(conforms(Foo), false);
+ assert.strictEqual(conforms(Bar), true);
});
- QUnit.test('`_.' + methodName + '` should work with a function for `source`', function(assert) {
+ QUnit.test('should work with a function for `source`', function(assert) {
assert.expect(1);
function Foo() {}
Foo.a = function(value) { return value > 1; };
var objects = [{ 'a': 1 }, { 'a': 2 }],
- actual = lodashStable.filter(objects, conforms(Foo));
+ actual = lodashStable.filter(objects, _.conforms(Foo));
assert.deepEqual(actual, [objects[1]]);
});
- QUnit.test('`_.' + methodName + '` should work with a non-plain `object`', function(assert) {
+ QUnit.test('should work with a non-plain `object`', function(assert) {
assert.expect(1);
function Foo() {
}
Foo.prototype.b = 2;
- var par = conforms({
+ var conforms = _.conforms({
'b': function(value) { return value > 1; }
});
- assert.strictEqual(par(new Foo), true);
+ assert.strictEqual(conforms(new Foo), true);
});
- QUnit.test('`_.' + methodName + '` should return `false` when `object` is nullish', function(assert) {
+ QUnit.test('should return `false` when `object` is nullish', function(assert) {
assert.expect(1);
var values = [, null, undefined],
- expected = lodashStable.map(values, stubFalse);
+ expected = lodashStable.map(values, alwaysFalse);
- var par = conforms({
+ var conforms = _.conforms({
'a': function(value) { return value > 1; }
});
var actual = lodashStable.map(values, function(value, index) {
try {
- return index ? par(value) : par();
+ return index ? conforms(value) : conforms();
} catch (e) {}
});
assert.deepEqual(actual, expected);
});
- QUnit.test('`_.' + methodName + '` should return `true` when comparing an empty `source` to a nullish `object`', function(assert) {
+ QUnit.test('should return `true` when comparing an empty `source` to a nullish `object`', function(assert) {
assert.expect(1);
var values = [, null, undefined],
- expected = lodashStable.map(values, stubTrue),
- par = conforms({});
+ expected = lodashStable.map(values, alwaysTrue),
+ conforms = _.conforms({});
var actual = lodashStable.map(values, function(value, index) {
try {
- return index ? par(value) : par();
+ return index ? conforms(value) : conforms();
} catch (e) {}
});
assert.deepEqual(actual, expected);
});
- QUnit.test('`_.' + methodName + '` should return `true` when comparing an empty `source`', function(assert) {
+ QUnit.test('should return `true` when comparing an empty `source`', function(assert) {
assert.expect(1);
var object = { 'a': 1 },
- expected = lodashStable.map(empties, stubTrue);
+ expected = lodashStable.map(empties, alwaysTrue);
var actual = lodashStable.map(empties, function(value) {
- var par = conforms(value);
- return par(object);
+ var conforms = _.conforms(value);
+ return conforms(object);
});
assert.deepEqual(actual, expected);
});
- });
+
+ QUnit.test('should not change behavior if `source` is modified', function(assert) {
+ assert.expect(2);
+
+ var source = {
+ 'a': function(value) { return value > 1; }
+ };
+
+ var object = { 'a': 2 },
+ conforms = _.conforms(source);
+
+ assert.strictEqual(conforms(object), true);
+
+ source.a = function(value) { return value < 2; };
+ assert.strictEqual(conforms(object), true);
+ });
+ }());
/*--------------------------------------------------------------------------*/
var object = { 'a': 1 },
values = Array(2).concat(empties, true, 1, 'a'),
- constant = _.constant(object);
+ constant = _.constant(object),
+ expected = lodashStable.map(values, function() { return true; });
- var results = lodashStable.map(values, function(value, index) {
- if (index < 2) {
- return index ? constant.call({}) : constant();
+ var actual = lodashStable.map(values, function(value, index) {
+ if (index == 0) {
+ var result = constant();
+ } else if (index == 1) {
+ result = constant.call({});
+ } else {
+ result = constant(value);
}
- return constant(value);
+ return result === object;
});
- assert.ok(lodashStable.every(results, function(result) {
- return result === object;
- }));
+ assert.deepEqual(actual, expected);
});
QUnit.test('should work with falsey values', function(assert) {
assert.expect(1);
- var expected = lodashStable.map(falsey, stubTrue);
+ var expected = lodashStable.map(falsey, function() { return true; });
var actual = lodashStable.map(falsey, function(value, index) {
var constant = index ? _.constant(value) : _.constant(),
assert.deepEqual(lodashStable.keys(object), ['a']);
});
- QUnit.test('should accept a falsey `prototype`', function(assert) {
+ QUnit.test('should accept a falsey `prototype` argument', function(assert) {
assert.expect(1);
- var expected = lodashStable.map(falsey, stubObject);
+ var expected = lodashStable.map(falsey, alwaysEmptyObject);
var actual = lodashStable.map(falsey, function(prototype, index) {
return index ? _.create(prototype) : _.create();
assert.deepEqual(actual, expected);
});
- QUnit.test('should ignore a primitive `prototype` and use an empty object instead', function(assert) {
+ QUnit.test('should ignore primitive `prototype` arguments and use an empty object instead', function(assert) {
assert.expect(1);
- var expected = lodashStable.map(primitives, stubTrue);
+ var expected = lodashStable.map(primitives, alwaysTrue);
var actual = lodashStable.map(primitives, function(value, index) {
return lodashStable.isPlainObject(index ? _.create(value) : _.create());
assert.expect(1);
var array = [{ 'a': 1 }, { 'a': 1 }, { 'a': 1 }],
- expected = lodashStable.map(array, stubTrue),
+ expected = lodashStable.map(array, alwaysTrue),
objects = lodashStable.map(array, _.create);
var actual = lodashStable.map(objects, function(object) {
assert.expect(2);
var values = ['0', 0.6, 'xyz'],
- expected = lodashStable.map(values, stubArray);
+ expected = lodashStable.map(values, alwaysEmptyArray);
var actual = lodashStable.map(values, function(arity) {
return _.curry(fn, arity)();
assert.strictEqual(new curried(true), object);
});
- QUnit.test('should use `this` binding of function', function(assert) {
+ QUnit.test('should not set a `this` binding', function(assert) {
assert.expect(9);
var fn = function(a, b, c) {
assert.expect(2);
var values = ['0', 0.6, 'xyz'],
- expected = lodashStable.map(values, stubArray);
+ expected = lodashStable.map(values, alwaysEmptyArray);
var actual = lodashStable.map(values, function(arity) {
return _.curryRight(fn, arity)();
assert.strictEqual(new curried(true), object);
});
- QUnit.test('should use `this` binding of function', function(assert) {
+ QUnit.test('should not set a `this` binding', function(assert) {
assert.expect(9);
var fn = function(a, b, c) {
return value;
}, 32);
- var results = [debounced('a'), debounced('b'), debounced('c')];
- assert.deepEqual(results, [undefined, undefined, undefined]);
+ var actual = [debounced(0), debounced(1), debounced(2)];
+ assert.deepEqual(actual, [undefined, undefined, undefined]);
assert.strictEqual(callCount, 0);
setTimeout(function() {
assert.strictEqual(callCount, 1);
- var results = [debounced('d'), debounced('e'), debounced('f')];
- assert.deepEqual(results, ['c', 'c', 'c']);
+ var actual = [debounced(3), debounced(4), debounced(5)];
+ assert.deepEqual(actual, [2, 2, 2]);
assert.strictEqual(callCount, 1);
}, 128);
var done = assert.async();
var debounced = _.debounce(identity, 32);
- debounced('a');
+ debounced('x');
setTimeout(function() {
- assert.notEqual(debounced('b'), 'b');
+ assert.notEqual(debounced('y'), 'y');
}, 64);
setTimeout(function() {
- assert.notEqual(debounced('c'), 'c');
+ assert.notEqual(debounced('z'), 'z');
done();
}, 128);
});
var done = assert.async();
var debounced = _.debounce(identity, 32, { 'leading': true, 'trailing': false }),
- results = [debounced('a'), debounced('b')];
+ result = [debounced('x'), debounced('y')];
- assert.deepEqual(results, ['a', 'a']);
+ assert.deepEqual(result, ['x', 'x']);
setTimeout(function() {
- var results = [debounced('c'), debounced('d')];
- assert.deepEqual(results, ['c', 'c']);
+ var result = [debounced('a'), debounced('b')];
+ assert.deepEqual(result, ['a', 'a']);
done();
}, 64);
});
var debounced = _.debounce(function() {
++callCount;
- }, 200, { 'maxWait': 200 });
+ }, 64, { 'maxWait': 64 });
debounced();
- setTimeout(debounced, 190);
- setTimeout(debounced, 200);
- setTimeout(debounced, 210);
+ lodashStable.times(20, function(index) {
+ setTimeout(debounced, 54 + index);
+ });
setTimeout(function() {
assert.strictEqual(callCount, 2);
done();
- }, 500);
+ }, 160);
});
QUnit.test('should cancel `maxDelayed` when `delayed` is invoked', function(assert) {
QUnit.module('lodash.deburr');
(function() {
- QUnit.test('should convert Latin Unicode letters to basic Latin', function(assert) {
+ QUnit.test('should convert latin-1 supplementary letters to basic latin', function(assert) {
assert.expect(1);
var actual = lodashStable.map(burredLetters, _.deburr);
assert.deepEqual(actual, deburredLetters);
});
- QUnit.test('should not deburr Latin mathematical operators', function(assert) {
+ QUnit.test('should not deburr latin-1 mathematical operators', function(assert) {
assert.expect(1);
var operators = ['\xd7', '\xf7'],
QUnit.test('should assign source properties if missing on `object`', function(assert) {
assert.expect(1);
- var actual = _.defaults({ 'a': 1 }, { 'a': 2, 'b': 2 });
- assert.deepEqual(actual, { 'a': 1, 'b': 2 });
+ assert.deepEqual(_.defaults({ 'a': 1 }, { 'a': 2, 'b': 2 }), { 'a': 1, 'b': 2 });
});
QUnit.test('should accept multiple sources', function(assert) {
assert.expect(2);
- var expected = { 'a': 1, 'b': 2, 'c': 3 },
- actual = _.defaults({ 'a': 1, 'b': 2 }, { 'b': 3 }, { 'c': 3 });
-
- assert.deepEqual(actual, expected);
-
- actual = _.defaults({ 'a': 1, 'b': 2 }, { 'b': 3, 'c': 3 }, { 'c': 2 });
- assert.deepEqual(actual, expected);
+ var expected = { 'a': 1, 'b': 2, 'c': 3 };
+ assert.deepEqual(_.defaults({ 'a': 1, 'b': 2 }, { 'b': 3 }, { 'c': 3 }), expected);
+ assert.deepEqual(_.defaults({ 'a': 1, 'b': 2 }, { 'b': 3, 'c': 3 }, { 'c': 2 }), expected);
});
QUnit.test('should not overwrite `null` values', function(assert) {
assert.strictEqual(actual.a, 1);
});
- QUnit.test('should assign `undefined` values', function(assert) {
- assert.expect(1);
-
- var source = { 'a': undefined, 'b': 1 },
- actual = _.defaults({}, source);
-
- assert.deepEqual(actual, { 'a': undefined, 'b': 1 });
- });
-
QUnit.test('should assign properties that shadow those on `Object.prototype`', function(assert) {
assert.expect(2);
'valueOf': 7
};
- var expected = lodashStable.clone(source);
- assert.deepEqual(_.defaults({}, source), expected);
-
- expected = lodashStable.clone(object);
- assert.deepEqual(_.defaults({}, object, source), expected);
+ assert.deepEqual(_.defaults({}, source), source);
+ assert.deepEqual(_.defaults({}, object, source), object);
});
}());
assert.expect(1);
var object = { 'a': { 'b': 2 }, 'd': 4 },
- source = { 'a': { 'b': 3, 'c': 3 }, 'e': 5 },
+ source = { 'a': { 'b': 1, 'c': 3 }, 'e': 5 },
expected = { 'a': { 'b': 2, 'c': 3 }, 'd': 4, 'e': 5 };
assert.deepEqual(_.defaultsDeep(object, source), expected);
assert.strictEqual(actual.a.b, 2);
});
- QUnit.test('should assign `undefined` values', function(assert) {
- assert.expect(1);
-
- var source = { 'a': undefined, 'b': { 'c': undefined, 'd': 1 } },
- expected = lodashStable.cloneDeep(source),
- actual = _.defaultsDeep({}, source);
-
- assert.deepEqual(actual, expected);
- });
-
QUnit.test('should merge sources containing circular references', function(assert) {
assert.expect(2);
assert.expect(1);
var actual = _.defaultsDeep({ 'a': ['abc'] }, { 'a': 'abc' });
- assert.deepEqual(actual.a, ['abc']);
- });
- }());
-
- /*--------------------------------------------------------------------------*/
-
- QUnit.module('lodash.defaultTo');
-
- (function() {
- QUnit.test('should return a default value if `value` is `NaN` or nullish', function(assert) {
- assert.expect(1);
-
- var expected = lodashStable.map(falsey, function(value) {
- return (value == null || value !== value) ? 1 : value;
- });
-
- var actual = lodashStable.map(falsey, function(value) {
- return _.defaultTo(value, 1);
- });
-
- assert.deepEqual(actual, expected);
+ assert.deepEqual(actual, { 'a': ['abc'] });
});
}());
var done = assert.async();
- var pass = true,
- timerId = _.defer(function() { pass = false; });
+ var pass = true;
+
+ var timerId = _.defer(function() {
+ pass = false;
+ });
clearTimeout(timerId);
var done = assert.async();
var pass = false;
- _.delay(function() { pass = true; });
+
+ _.delay(function() {
+ pass = true;
+ });
assert.notOk(pass);
var done = assert.async();
- var pass = true,
- timerId = _.delay(function() { pass = false; }, 32);
+ var pass = true;
+
+ var timerId = _.delay(function() {
+ pass = false;
+ }, 32);
clearTimeout(timerId);
done();
}, 64);
});
-
- QUnit.test('should work with mocked `setTimeout`', function(assert) {
- assert.expect(1);
-
- if (!isPhantom) {
- var pass = false,
- setTimeout = root.setTimeout;
-
- setProperty(root, 'setTimeout', function(func) { func(); });
- _.delay(function() { pass = true; }, 32);
- setProperty(root, 'setTimeout', setTimeout);
-
- assert.ok(pass);
- }
- else {
- skipAssert(assert);
- }
- });
}());
/*--------------------------------------------------------------------------*/
QUnit.module('difference methods');
lodashStable.each(['difference', 'differenceBy', 'differenceWith'], function(methodName) {
- var func = _[methodName];
-
- QUnit.test('`_.' + methodName + '` should return the difference of two arrays', function(assert) {
- assert.expect(1);
+ var args = (function() { return arguments; }(1, 2, 3)),
+ func = _[methodName];
- var actual = func([2, 1], [2, 3]);
- assert.deepEqual(actual, [1]);
- });
+ QUnit.test('`_.' + methodName + '` should return the difference of the given arrays', function(assert) {
+ assert.expect(2);
- QUnit.test('`_.' + methodName + '` should return the difference of multiple arrays', function(assert) {
- assert.expect(1);
+ var actual = func([1, 2, 3, 4, 5], [5, 2, 10]);
+ assert.deepEqual(actual, [1, 3, 4]);
- var actual = func([2, 1, 2, 3], [3, 4], [3, 2]);
- assert.deepEqual(actual, [1]);
+ actual = func([1, 2, 3, 4, 5], [5, 2, 10], [8, 4]);
+ assert.deepEqual(actual, [1, 3]);
});
QUnit.test('`_.' + methodName + '` should treat `-0` as `0`', function(assert) {
assert.deepEqual(actual, [[], []]);
- var largeArray = lodashStable.times(LARGE_ARRAY_SIZE, stubOne);
+ var largeArray = lodashStable.times(LARGE_ARRAY_SIZE, alwaysOne);
actual = lodashStable.map(func([-0, 1], largeArray), lodashStable.toString);
assert.deepEqual(actual, ['0']);
});
QUnit.test('`_.' + methodName + '` should work with large arrays of `NaN`', function(assert) {
assert.expect(1);
- var largeArray = lodashStable.times(LARGE_ARRAY_SIZE, stubNaN);
+ var largeArray = lodashStable.times(LARGE_ARRAY_SIZE, alwaysNaN);
assert.deepEqual(func([1, NaN, 3], largeArray), [1, 3]);
});
QUnit.module('lodash.differenceBy');
(function() {
- QUnit.test('should accept an `iteratee`', function(assert) {
+ QUnit.test('should accept an `iteratee` argument', function(assert) {
assert.expect(2);
- var actual = _.differenceBy([2.1, 1.2], [2.3, 3.4], Math.floor);
- assert.deepEqual(actual, [1.2]);
+ var actual = _.differenceBy([3.1, 2.2, 1.3], [4.4, 2.5], Math.floor);
+ assert.deepEqual(actual, [3.1, 1.3]);
actual = _.differenceBy([{ 'x': 2 }, { 'x': 1 }], [{ 'x': 1 }], 'x');
assert.deepEqual(actual, [{ 'x': 2 }]);
});
- QUnit.test('should provide correct `iteratee` arguments', function(assert) {
+ QUnit.test('should provide the correct `iteratee` arguments', function(assert) {
assert.expect(1);
var args;
- _.differenceBy([2.1, 1.2], [2.3, 3.4], function() {
+ _.differenceBy([3.1, 2.2, 1.3], [4.4, 2.5], function() {
args || (args = slice.call(arguments));
});
- assert.deepEqual(args, [2.3]);
+ assert.deepEqual(args, [4.4]);
});
}());
QUnit.module('lodash.differenceWith');
(function() {
- QUnit.test('should work with a `comparator`', function(assert) {
+ QUnit.test('should work with a `comparator` argument', function(assert) {
assert.expect(1);
var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }],
assert.expect(1);
var array = [-0, 1],
- largeArray = lodashStable.times(LARGE_ARRAY_SIZE, stubOne),
+ largeArray = lodashStable.times(LARGE_ARRAY_SIZE, alwaysOne),
others = [[1], largeArray],
expected = lodashStable.map(others, lodashStable.constant(['-0']));
});
});
- QUnit.test('should return an empty array when `n` >= `length`', function(assert) {
+ QUnit.test('should return an empty array when `n` >= `array.length`', function(assert) {
assert.expect(4);
lodashStable.each([3, 4, Math.pow(2, 32), Infinity], function(n) {
});
});
- QUnit.test('should return an empty array when `n` >= `length`', function(assert) {
+ QUnit.test('should return an empty array when `n` >= `array.length`', function(assert) {
assert.expect(4);
lodashStable.each([3, 4, Math.pow(2, 32), Infinity], function(n) {
assert.deepEqual(actual, [1, 2]);
});
- QUnit.test('should provide correct `predicate` arguments', function(assert) {
+ QUnit.test('should provide the correct `predicate` arguments', function(assert) {
assert.expect(1);
var args;
assert.deepEqual(actual, [3, 4]);
});
- QUnit.test('should provide correct `predicate` arguments', function(assert) {
+ QUnit.test('should provide the correct `predicate` arguments', function(assert) {
assert.expect(1);
var args;
assert.strictEqual(_.endsWith(string, 'b'), false);
});
- QUnit.test('should work with a `position`', function(assert) {
+ QUnit.test('should work with a `position` argument', function(assert) {
assert.expect(1);
assert.strictEqual(_.endsWith(string, 'b', 2), true);
});
- QUnit.test('should work with `position` >= `length`', function(assert) {
+ QUnit.test('should work with `position` >= `string.length`', function(assert) {
assert.expect(4);
lodashStable.each([3, 5, MAX_SAFE_INTEGER, Infinity], function(position) {
QUnit.test('should treat falsey `position` values, except `undefined`, as `0`', function(assert) {
assert.expect(1);
- var expected = lodashStable.map(falsey, stubTrue);
+ var expected = lodashStable.map(falsey, alwaysTrue);
var actual = lodashStable.map(falsey, function(position) {
return _.endsWith(string, position === undefined ? 'c' : '', position);
lodashStable.each([-1, -3, -Infinity], function(position) {
assert.ok(lodashStable.every(string, function(chr) {
- return !_.endsWith(string, chr, position);
+ return _.endsWith(string, chr, position) === false;
}));
assert.strictEqual(_.endsWith(string, '', position), true);
});
assert.strictEqual(_.endsWith(string, 'ab', 2.2), true);
});
+
+ QUnit.test('should return `true` when `target` is an empty string regardless of `position`', function(assert) {
+ assert.expect(1);
+
+ assert.ok(lodashStable.every([-Infinity, NaN, -3, -1, 0, 1, 2, 3, 5, MAX_SAFE_INTEGER, Infinity], function(position) {
+ return _.endsWith(string, '', position, true);
+ }));
+ });
}());
/*--------------------------------------------------------------------------*/
QUnit.module('lodash.escape');
(function() {
- var escaped = '&<>"'/',
- unescaped = '&<>"\'/';
+ var escaped = '&<>"'`\/',
+ unescaped = '&<>"\'`\/';
escaped += escaped;
unescaped += unescaped;
assert.strictEqual(_.escape(unescaped), escaped);
});
+ QUnit.test('should not escape the "/" character', function(assert) {
+ assert.expect(1);
+
+ assert.strictEqual(_.escape('/'), '/');
+ });
+
QUnit.test('should handle strings with nothing to escape', function(assert) {
assert.expect(1);
assert.strictEqual(_.escape(_.unescape(escaped)), escaped);
});
-
- lodashStable.each(['`', '/'], function(chr) {
- QUnit.test('should not escape the "' + chr + '" character', function(assert) {
- assert.expect(1);
-
- assert.strictEqual(_.escape(chr), chr);
- });
- });
}());
/*--------------------------------------------------------------------------*/
assert.expect(1);
var values = [, null, undefined, ''],
- expected = lodashStable.map(values, stubString);
+ expected = lodashStable.map(values, alwaysEmptyString);
var actual = lodashStable.map(values, function(value, index) {
return index ? _.escapeRegExp(value) : _.escapeRegExp();
QUnit.test('should return `true` for empty collections', function(assert) {
assert.expect(1);
- var expected = lodashStable.map(empties, stubTrue);
+ var expected = lodashStable.map(empties, alwaysTrue);
var actual = lodashStable.map(empties, function(value) {
try {
assert.expect(2);
var values = [, null, undefined],
- expected = lodashStable.map(values, stubFalse);
+ expected = lodashStable.map(values, alwaysFalse);
var actual = lodashStable.map(values, function(value, index) {
var array = [0];
assert.deepEqual(actual, expected);
- expected = lodashStable.map(values, stubTrue);
+ expected = lodashStable.map(values, alwaysTrue);
actual = lodashStable.map(values, function(value, index) {
var array = [1];
return index ? _.every(array, value) : _.every(array);
QUnit.module('strict mode checks');
- lodashStable.each(['assign', 'assignIn', 'bindAll', 'defaults', 'defaultsDeep', 'merge'], function(methodName) {
+ lodashStable.each(['assign', 'assignIn', 'bindAll', 'defaults'], function(methodName) {
var func = _[methodName],
isBindAll = methodName == 'bindAll';
QUnit.test('`_.' + methodName + '` should ' + (isStrict ? '' : 'not ') + 'throw strict mode errors', function(assert) {
assert.expect(1);
- var object = freeze({ 'a': undefined, 'b': function() {} }),
- pass = !isStrict;
+ if (freeze) {
+ var object = freeze({ 'a': undefined, 'b': function() {} }),
+ pass = !isStrict;
- try {
- func(object, isBindAll ? 'b' : { 'a': 1 });
- } catch (e) {
- pass = !pass;
+ try {
+ func(object, isBindAll ? 'b' : { 'a': 1 });
+ } catch (e) {
+ pass = !pass;
+ }
+ assert.ok(pass);
+ }
+ else {
+ skipAssert(assert);
}
- assert.ok(pass);
});
});
QUnit.module('lodash.fill');
(function() {
- QUnit.test('should use a default `start` of `0` and a default `end` of `length`', function(assert) {
+ QUnit.test('should use a default `start` of `0` and a default `end` of `array.length`', function(assert) {
assert.expect(1);
var array = [1, 2, 3];
assert.deepEqual(_.fill(array, 'a', 1), [1, 'a', 'a']);
});
- QUnit.test('should work with a `start` >= `length`', function(assert) {
+ QUnit.test('should work with a `start` >= `array.length`', function(assert) {
assert.expect(4);
lodashStable.each([3, 4, Math.pow(2, 32), Infinity], function(start) {
assert.deepEqual(_.fill(array, 'a', -1), [1, 2, 'a']);
});
- QUnit.test('should work with a negative `start` <= negative `length`', function(assert) {
+ QUnit.test('should work with a negative `start` <= negative `array.length`', function(assert) {
assert.expect(3);
lodashStable.each([-3, -4, -Infinity], function(start) {
assert.deepEqual(_.fill(array, 'a', 0, 1), ['a', 2, 3]);
});
- QUnit.test('should work with a `end` >= `length`', function(assert) {
+ QUnit.test('should work with a `end` >= `array.length`', function(assert) {
assert.expect(4);
lodashStable.each([3, 4, Math.pow(2, 32), Infinity], function(end) {
assert.deepEqual(_.fill(array, 'a', 0, -1), ['a', 'a', 3]);
});
- QUnit.test('should work with a negative `end` <= negative `length`', function(assert) {
+ QUnit.test('should work with a negative `end` <= negative `array.length`', function(assert) {
assert.expect(3);
lodashStable.each([-3, -4, -Infinity], function(end) {
actual = wrapped.value();
assert.ok(wrapped instanceof _);
- assert.strictEqual(actual, array);
assert.deepEqual(actual, ['a', 'a', 'a']);
+ assert.strictEqual(actual, array);
}
else {
skipAssert(assert, 3);
assert.deepEqual(_.filter(array, isEven), [2]);
});
+
+ QUnit.test('should iterate over an object with numeric keys (test in Mobile Safari 8)', function(assert) {
+ assert.expect(1);
+
+ // Trigger a mobile Safari 8 JIT bug.
+ // See https://github.com/lodash/lodash/issues/799.
+ var counter = 0,
+ object = { '1': 'foo', '8': 'bar', '50': 'baz' };
+
+ lodashStable.times(1000, function(assert) {
+ _.filter([], alwaysTrue);
+ });
+
+ _.filter(object, function() {
+ counter++;
+ return true;
+ });
+
+ assert.strictEqual(counter, 3);
+ });
}());
/*--------------------------------------------------------------------------*/
- lodashStable.each(['find', 'findIndex', 'findKey', 'findLast', 'findLastIndex', 'findLastKey'], function(methodName) {
+ lodashStable.each(['find', 'findLast', 'findIndex', 'findLastIndex', 'findKey', 'findLastKey'], function(methodName) {
QUnit.module('lodash.' + methodName);
- var array = [1, 2, 3, 4],
- func = _[methodName];
+ var func = _[methodName];
- var objects = [
- { 'a': 0, 'b': 0 },
- { 'a': 1, 'b': 1 },
- { 'a': 2, 'b': 2 }
- ];
+ (function() {
+ var objects = [
+ { 'a': 0, 'b': 0 },
+ { 'a': 1, 'b': 1 },
+ { 'a': 2, 'b': 2 }
+ ];
- var expected = ({
- 'find': [objects[1], undefined, objects[2]],
- 'findIndex': [1, -1, 2],
- 'findKey': ['1', undefined, '2'],
- 'findLast': [objects[2], undefined, objects[2]],
- 'findLastIndex': [2, -1, 2],
- 'findLastKey': ['2', undefined, '2']
- })[methodName];
+ var expected = ({
+ 'find': [objects[1], undefined, objects[2], objects[1]],
+ 'findLast': [objects[2], undefined, objects[2], objects[2]],
+ 'findIndex': [1, -1, 2, 1],
+ 'findLastIndex': [2, -1, 2, 2],
+ 'findKey': ['1', undefined, '2', '1'],
+ 'findLastKey': ['2', undefined, '2', '2']
+ })[methodName];
- QUnit.test('`_.' + methodName + '` should return the found value', function(assert) {
- assert.expect(1);
+ QUnit.test('`_.' + methodName + '` should return the found value', function(assert) {
+ assert.expect(1);
- assert.strictEqual(func(objects, function(object) { return object.a; }), expected[0]);
- });
+ assert.strictEqual(func(objects, function(object) { return object.a; }), expected[0]);
+ });
- QUnit.test('`_.' + methodName + '` should return `' + expected[1] + '` if value is not found', function(assert) {
- assert.expect(1);
+ QUnit.test('`_.' + methodName + '` should return `' + expected[1] + '` if value is not found', function(assert) {
+ assert.expect(1);
- assert.strictEqual(func(objects, function(object) { return object.a === 3; }), expected[1]);
- });
+ assert.strictEqual(func(objects, function(object) { return object.a === 3; }), expected[1]);
+ });
- QUnit.test('`_.' + methodName + '` should work with `_.matches` shorthands', function(assert) {
- assert.expect(1);
+ QUnit.test('`_.' + methodName + '` should work with `_.matches` shorthands', function(assert) {
+ assert.expect(1);
- assert.strictEqual(func(objects, { 'b': 2 }), expected[2]);
- });
+ assert.strictEqual(func(objects, { 'b': 2 }), expected[2]);
+ });
- QUnit.test('`_.' + methodName + '` should work with `_.matchesProperty` shorthands', function(assert) {
- assert.expect(1);
+ QUnit.test('`_.' + methodName + '` should work with `_.matchesProperty` shorthands', function(assert) {
+ assert.expect(1);
- assert.strictEqual(func(objects, ['b', 2]), expected[2]);
- });
+ assert.strictEqual(func(objects, ['b', 2]), expected[2]);
+ });
- QUnit.test('`_.' + methodName + '` should work with `_.property` shorthands', function(assert) {
- assert.expect(1);
+ QUnit.test('`_.' + methodName + '` should work with `_.property` shorthands', function(assert) {
+ assert.expect(1);
- assert.strictEqual(func(objects, 'b'), expected[0]);
- });
+ assert.strictEqual(func(objects, 'b'), expected[3]);
+ });
- QUnit.test('`_.' + methodName + '` should return `' + expected[1] + '` for empty collections', function(assert) {
- assert.expect(1);
+ QUnit.test('`_.' + methodName + '` should return `' + expected[1] + '` for empty collections', function(assert) {
+ assert.expect(1);
- var emptyValues = lodashStable.endsWith(methodName, 'Index') ? lodashStable.reject(empties, lodashStable.isPlainObject) : empties,
- expecting = lodashStable.map(emptyValues, lodashStable.constant(expected[1]));
+ var emptyValues = lodashStable.endsWith(methodName, 'Index') ? lodashStable.reject(empties, lodashStable.isPlainObject) : empties,
+ expecting = lodashStable.map(emptyValues, lodashStable.constant(expected[1]));
- var actual = lodashStable.map(emptyValues, function(value) {
- try {
- return func(value, { 'a': 3 });
- } catch (e) {}
- });
+ var actual = lodashStable.map(emptyValues, function(value) {
+ try {
+ return func(value, { 'a': 3 });
+ } catch (e) {}
+ });
- assert.deepEqual(actual, expecting);
- });
+ assert.deepEqual(actual, expecting);
+ });
+ }());
- QUnit.test('`_.' + methodName + '` should return an unwrapped value when implicitly chaining', function(assert) {
- assert.expect(1);
+ (function() {
+ var array = [1, 2, 3, 4];
var expected = ({
'find': 1,
- 'findIndex': 0,
- 'findKey': '0',
'findLast': 4,
+ 'findIndex': 0,
'findLastIndex': 3,
+ 'findKey': '0',
'findLastKey': '3'
})[methodName];
- if (!isNpm) {
- assert.strictEqual(_(array)[methodName](), expected);
- }
- else {
- skipAssert(assert);
- }
- });
-
- QUnit.test('`_.' + methodName + '` should return a wrapped value when explicitly chaining', function(assert) {
- assert.expect(1);
-
- if (!isNpm) {
- assert.ok(_(array).chain()[methodName]() instanceof _);
- }
- else {
- skipAssert(assert);
- }
- });
-
- QUnit.test('`_.' + methodName + '` should not execute immediately when explicitly chaining', function(assert) {
- assert.expect(1);
-
- if (!isNpm) {
- var wrapped = _(array).chain()[methodName]();
- assert.strictEqual(wrapped.__wrapped__, array);
- }
- else {
- skipAssert(assert);
- }
- });
-
- QUnit.test('`_.' + methodName + '` should work in a lazy sequence', function(assert) {
- assert.expect(2);
-
- if (!isNpm) {
- var largeArray = lodashStable.range(1, LARGE_ARRAY_SIZE + 1),
- smallArray = array;
-
- lodashStable.times(2, function(index) {
- var array = index ? largeArray : smallArray,
- wrapped = _(array).filter(isEven);
+ QUnit.test('`_.' + methodName + '` should return an unwrapped value when implicitly chaining', function(assert) {
+ assert.expect(1);
- assert.strictEqual(wrapped[methodName](), func(lodashStable.filter(array, isEven)));
- });
- }
- else {
- skipAssert(assert, 2);
- }
- });
- });
+ if (!isNpm) {
+ assert.strictEqual(_(array)[methodName](), expected);
+ }
+ else {
+ skipAssert(assert);
+ }
+ });
- _.each(['find', 'findIndex', 'findLast', 'findLastIndex'], function(methodName) {
- var func = _[methodName];
+ QUnit.test('`_.' + methodName + '` should return a wrapped value when explicitly chaining', function(assert) {
+ assert.expect(1);
- QUnit.test('`_.' + methodName + '` should provide correct `predicate` arguments for arrays', function(assert) {
- assert.expect(1);
+ if (!isNpm) {
+ assert.ok(_(array).chain()[methodName]() instanceof _);
+ }
+ else {
+ skipAssert(assert);
+ }
+ });
- var args,
- array = ['a'];
+ QUnit.test('`_.' + methodName + '` should not execute immediately when explicitly chaining', function(assert) {
+ assert.expect(1);
- func(array, function() {
- args || (args = slice.call(arguments));
+ if (!isNpm) {
+ var wrapped = _(array).chain()[methodName]();
+ assert.strictEqual(wrapped.__wrapped__, array);
+ }
+ else {
+ skipAssert(assert);
+ }
});
- assert.deepEqual(args, ['a', 0, array]);
- });
- });
+ QUnit.test('`_.' + methodName + '` should work in a lazy sequence', function(assert) {
+ assert.expect(2);
- _.each(['find', 'findKey', 'findLast', 'findLastKey'], function(methodName) {
- var func = _[methodName];
+ if (!isNpm) {
+ var largeArray = lodashStable.range(1, LARGE_ARRAY_SIZE + 1),
+ smallArray = array;
- QUnit.test('`_.' + methodName + '` should work with an object for `collection`', function(assert) {
- assert.expect(1);
+ lodashStable.times(2, function(index) {
+ var array = index ? largeArray : smallArray,
+ wrapped = _(array).filter(isEven);
- var actual = func({ 'a': 1, 'b': 2, 'c': 3 }, function(n) {
- return n < 3;
+ assert.strictEqual(wrapped[methodName](), func(lodashStable.filter(array, isEven)));
+ });
+ }
+ else {
+ skipAssert(assert, 2);
+ }
});
+ }());
+ (function() {
var expected = ({
'find': 1,
- 'findKey': 'a',
'findLast': 2,
+ 'findKey': 'a',
'findLastKey': 'b'
})[methodName];
- assert.strictEqual(actual, expected);
- });
+ if (expected != null) {
+ QUnit.test('`_.' + methodName + '` should work with an object for `collection`', function(assert) {
+ assert.expect(1);
- QUnit.test('`_.' + methodName + '` should provide correct `predicate` arguments for objects', function(assert) {
- assert.expect(1);
-
- var args,
- object = { 'a': 1 };
-
- func(object, function() {
- args || (args = slice.call(arguments));
- });
+ var actual = func({ 'a': 1, 'b': 2, 'c': 3 }, function(n) {
+ return n < 3;
+ });
- assert.deepEqual(args, [1, 'a', object]);
- });
+ assert.strictEqual(actual, expected);
+ });
+ }
+ }());
});
/*--------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------*/
- QUnit.module('lodash.find and lodash.includes');
-
- lodashStable.each(['includes', 'find'], function(methodName) {
- var func = _[methodName],
- isIncludes = methodName == 'includes',
- resolve = methodName == 'find' ? lodashStable.curry(lodashStable.eq) : identity;
-
- lodashStable.each({
- 'an `arguments` object': args,
- 'an array': [1, 2, 3]
- },
- function(collection, key) {
- var values = lodashStable.toArray(collection);
-
- QUnit.test('`_.' + methodName + '` should work with ' + key + ' and a positive `fromIndex`', function(assert) {
- assert.expect(1);
-
- var expected = [
- isIncludes || values[2],
- isIncludes ? false : undefined
- ];
-
- var actual = [
- func(collection, resolve(values[2]), 2),
- func(collection, resolve(values[1]), 2)
- ];
-
- assert.deepEqual(actual, expected);
- });
-
- QUnit.test('`_.' + methodName + '` should work with ' + key + ' and a `fromIndex` >= `length`', function(assert) {
- assert.expect(1);
-
- var indexes = [4, 6, Math.pow(2, 32), Infinity];
-
- var expected = lodashStable.map(indexes, function() {
- var result = isIncludes ? false : undefined;
- return [result, result, result];
- });
-
- var actual = lodashStable.map(indexes, function(fromIndex) {
- return [
- func(collection, resolve(1), fromIndex),
- func(collection, resolve(undefined), fromIndex),
- func(collection, resolve(''), fromIndex)
- ];
- });
-
- assert.deepEqual(actual, expected);
- });
-
- QUnit.test('`_.' + methodName + '` should work with ' + key + ' and treat falsey `fromIndex` values as `0`', function(assert) {
- assert.expect(1);
-
- var expected = lodashStable.map(falsey, lodashStable.constant(isIncludes || values[0]));
-
- var actual = lodashStable.map(falsey, function(fromIndex) {
- return func(collection, resolve(values[0]), fromIndex);
- });
-
- assert.deepEqual(actual, expected);
- });
-
- QUnit.test('`_.' + methodName + '` should work with ' + key + ' and coerce `fromIndex` to an integer', function(assert) {
- assert.expect(1);
-
- var expected = [
- isIncludes || values[0],
- isIncludes || values[0],
- isIncludes ? false : undefined
- ];
-
- var actual = [
- func(collection, resolve(values[0]), 0.1),
- func(collection, resolve(values[0]), NaN),
- func(collection, resolve(values[0]), '1')
- ];
-
- assert.deepEqual(actual, expected);
- });
-
- QUnit.test('`_.' + methodName + '` should work with ' + key + ' and a negative `fromIndex`', function(assert) {
- assert.expect(1);
-
- var expected = [
- isIncludes || values[2],
- isIncludes ? false : undefined
- ];
-
- var actual = [
- func(collection, resolve(values[2]), -1),
- func(collection, resolve(values[1]), -1)
- ];
-
- assert.deepEqual(actual, expected);
- });
-
- QUnit.test('`_.' + methodName + '` should work with ' + key + ' and a negative `fromIndex` <= `-length`', function(assert) {
- assert.expect(1);
-
- var indexes = [-4, -6, -Infinity],
- expected = lodashStable.map(indexes, lodashStable.constant(isIncludes || values[0]));
-
- var actual = lodashStable.map(indexes, function(fromIndex) {
- return func(collection, resolve(values[0]), fromIndex);
- });
-
- assert.deepEqual(actual, expected);
- });
- });
- });
-
- /*--------------------------------------------------------------------------*/
-
- QUnit.module('lodash.findIndex and lodash.indexOf');
-
- lodashStable.each(['findIndex', 'indexOf'], function(methodName) {
- var array = [1, 2, 3, 1, 2, 3],
- func = _[methodName],
- resolve = methodName == 'findIndex' ? lodashStable.curry(lodashStable.eq) : identity;
-
- QUnit.test('`_.' + methodName + '` should return the index of the first matched value', function(assert) {
- assert.expect(1);
-
- assert.strictEqual(func(array, resolve(3)), 2);
- });
-
- QUnit.test('`_.' + methodName + '` should work with a positive `fromIndex`', function(assert) {
- assert.expect(1);
-
- assert.strictEqual(func(array, resolve(1), 2), 3);
- });
-
- QUnit.test('`_.' + methodName + '` should work with a `fromIndex` >= `length`', function(assert) {
- assert.expect(1);
-
- var values = [6, 8, Math.pow(2, 32), Infinity],
- expected = lodashStable.map(values, lodashStable.constant([-1, -1, -1]));
-
- var actual = lodashStable.map(values, function(fromIndex) {
- return [
- func(array, resolve(undefined), fromIndex),
- func(array, resolve(1), fromIndex),
- func(array, resolve(''), fromIndex)
- ];
- });
-
- assert.deepEqual(actual, expected);
- });
-
- QUnit.test('`_.' + methodName + '` should work with a negative `fromIndex`', function(assert) {
- assert.expect(1);
-
- assert.strictEqual(func(array, resolve(2), -3), 4);
- });
-
- QUnit.test('`_.' + methodName + '` should work with a negative `fromIndex` <= `-length`', function(assert) {
- assert.expect(1);
-
- var values = [-6, -8, -Infinity],
- expected = lodashStable.map(values, stubZero);
-
- var actual = lodashStable.map(values, function(fromIndex) {
- return func(array, resolve(1), fromIndex);
- });
-
- assert.deepEqual(actual, expected);
- });
-
- QUnit.test('`_.' + methodName + '` should treat falsey `fromIndex` values as `0`', function(assert) {
- assert.expect(1);
-
- var expected = lodashStable.map(falsey, stubZero);
-
- var actual = lodashStable.map(falsey, function(fromIndex) {
- return func(array, resolve(1), fromIndex);
- });
-
- assert.deepEqual(actual, expected);
- });
-
- QUnit.test('`_.' + methodName + '` should coerce `fromIndex` to an integer', function(assert) {
- assert.expect(1);
-
- assert.strictEqual(func(array, resolve(2), 1.2), 1);
- });
- });
-
- /*--------------------------------------------------------------------------*/
-
- QUnit.module('lodash.findLast');
-
- (function() {
- var resolve = lodashStable.curry(lodashStable.eq);
-
- lodashStable.each({
- 'an `arguments` object': args,
- 'an array': [1, 2, 3]
- },
- function(collection, key) {
- var values = lodashStable.toArray(collection);
-
- QUnit.test('should work with ' + key + ' and a positive `fromIndex`', function(assert) {
- assert.expect(1);
-
- var expected = [
- values[1],
- undefined
- ];
-
- var actual = [
- _.findLast(collection, resolve(values[1]), 1),
- _.findLast(collection, resolve(values[2]), 1)
- ];
-
- assert.deepEqual(actual, expected);
- });
-
- QUnit.test('should work with ' + key + ' and a `fromIndex` >= `length`', function(assert) {
- assert.expect(1);
-
- var indexes = [4, 6, Math.pow(2, 32), Infinity];
-
- var expected = lodashStable.map(indexes, lodashStable.constant([values[0], undefined, undefined]));
-
- var actual = lodashStable.map(indexes, function(fromIndex) {
- return [
- _.findLast(collection, resolve(1), fromIndex),
- _.findLast(collection, resolve(undefined), fromIndex),
- _.findLast(collection, resolve(''), fromIndex)
- ];
- });
-
- assert.deepEqual(actual, expected);
- });
-
- QUnit.test('should work with ' + key + ' and treat falsey `fromIndex` values correctly', function(assert) {
- assert.expect(1);
-
- var expected = lodashStable.map(falsey, function(value) {
- return value === undefined ? values[3] : undefined;
- });
-
- var actual = lodashStable.map(falsey, function(fromIndex) {
- return _.findLast(collection, resolve(values[3]), fromIndex);
- });
-
- assert.deepEqual(actual, expected);
- });
-
- QUnit.test('should work with ' + key + ' and coerce `fromIndex` to an integer', function(assert) {
- assert.expect(1);
-
- var expected = [
- values[0],
- values[0],
- undefined
- ];
-
- var actual = [
- _.findLast(collection, resolve(values[0]), 0.1),
- _.findLast(collection, resolve(values[0]), NaN),
- _.findLast(collection, resolve(values[2]), '1')
- ];
-
- assert.deepEqual(actual, expected);
- });
-
- QUnit.test('should work with ' + key + ' and a negative `fromIndex`', function(assert) {
- assert.expect(1);
-
- var expected = [
- values[1],
- undefined
- ];
-
- var actual = [
- _.findLast(collection, resolve(values[1]), -2),
- _.findLast(collection, resolve(values[2]), -2)
- ];
-
- assert.deepEqual(actual, expected);
- });
-
- QUnit.test('should work with ' + key + ' and a negative `fromIndex` <= `-length`', function(assert) {
- assert.expect(1);
-
- var indexes = [-4, -6, -Infinity],
- expected = lodashStable.map(indexes, lodashStable.constant(values[0]));
-
- var actual = lodashStable.map(indexes, function(fromIndex) {
- return _.findLast(collection, resolve(values[0]), fromIndex);
- });
-
- assert.deepEqual(actual, expected);
- });
- });
- }());
-
- /*--------------------------------------------------------------------------*/
-
QUnit.module('lodash.flip');
(function() {
});
});
- QUnit.test('`_.' + methodName + '` should accept a falsey `collection`', function(assert) {
+ QUnit.test('`_.' + methodName + '` should accept a falsey `collection` argument', function(assert) {
assert.expect(1);
- var expected = lodashStable.map(falsey, stubArray);
+ var expected = lodashStable.map(falsey, alwaysEmptyArray);
var actual = lodashStable.map(falsey, function(collection, index) {
try {
QUnit.module('flatten methods');
(function() {
- var array = [1, [2, [3, [4]], 5]],
- methodNames = ['flatten', 'flattenDeep', 'flattenDepth'];
+ var args = arguments,
+ array = [1, [2, [3, [4]], 5]];
QUnit.test('should flatten `arguments` objects', function(assert) {
assert.expect(3);
expected.push(undefined, undefined, undefined);
- lodashStable.each(methodNames, function(methodName) {
- var actual = _[methodName](array);
+ lodashStable.each([_.flatten(array), _.flattenDeep(array), _.flattenDepth(array)], function(actual) {
assert.deepEqual(actual, expected);
assert.ok('4' in actual);
});
});
- QUnit.test('should flatten objects with a truthy `Symbol.isConcatSpreadable` value', function(assert) {
- assert.expect(1);
-
- if (Symbol && Symbol.isConcatSpreadable) {
- var object = { '0': 'a', 'length': 1 },
- array = [object],
- expected = lodashStable.map(methodNames, lodashStable.constant(['a']));
-
- object[Symbol.isConcatSpreadable] = true;
-
- var actual = lodashStable.map(methodNames, function(methodName) {
- return _[methodName](array);
- });
-
- assert.deepEqual(actual, expected);
- }
- else {
- skipAssert(assert);
- }
- });
-
QUnit.test('should work with extremely large arrays', function(assert) {
assert.expect(3);
assert.expect(3);
var expected = [],
- nonArray = { '0': 'a' };
+ nonArray = { 'a': 1 };
assert.deepEqual(_.flatten(nonArray), expected);
assert.deepEqual(_.flattenDeep(nonArray), expected);
skipAssert(assert, 6);
}
});
- }());
+ }(1, 2, 3));
/*--------------------------------------------------------------------------*/
isOmitPick = /^(?:omit|pick)By$/.test(methodName),
isSome = methodName == 'some';
- QUnit.test('`_.' + methodName + '` should provide correct iteratee arguments', function(assert) {
+ QUnit.test('`_.' + methodName + '` should provide the correct iteratee arguments', function(assert) {
assert.expect(1);
if (func) {
};
var values = [-1, '1', 1.1, Object(1), MAX_SAFE_INTEGER + 1],
- expected = lodashStable.map(values, stubTrue);
+ expected = lodashStable.map(values, alwaysTrue);
var actual = lodashStable.map(values, function(length) {
return isIteratedAsObject({ 'length': length });
isSome = methodName == 'some',
isReduce = /^reduce/.test(methodName);
- QUnit.test('`_.' + methodName + '` should ignore changes to `length`', function(assert) {
+ QUnit.test('`_.' + methodName + '` should ignore changes to `array.length`', function(assert) {
assert.expect(1);
if (func) {
QUnit.module('object assignments');
- lodashStable.each(['assign', 'assignIn', 'defaults', 'defaultsDeep', 'merge'], function(methodName) {
+ lodashStable.each(['assign', 'assignIn', 'defaults', 'merge'], function(methodName) {
var func = _[methodName],
isAssign = methodName == 'assign',
- isDefaults = /^defaults/.test(methodName);
+ isDefaults = methodName == 'defaults';
QUnit.test('`_.' + methodName + '` should coerce primitives to objects', function(assert) {
assert.expect(1);
assert.deepEqual(func({}, new Foo), expected);
});
- QUnit.test('`_.' + methodName + '` should not skip a trailing function source', function(assert) {
- assert.expect(1);
-
- function fn() {}
- fn.b = 2;
-
- assert.deepEqual(func({}, { 'a': 1 }, fn), { 'a': 1, 'b': 2 });
- });
-
QUnit.test('`_.' + methodName + '` should not error on nullish sources', function(assert) {
assert.expect(1);
var source = { 'a': 1 },
values = [null, undefined],
- expected = lodashStable.map(values, stubTrue);
+ expected = lodashStable.map(values, alwaysTrue);
var actual = lodashStable.map(values, function(value) {
var object = func(value, source);
var array = [{ 'a': 1 }, { 'b': 2 }, { 'c': 3 }],
expected = { 'a': isDefaults ? 0 : 1, 'b': 2, 'c': 3 };
- function fn() {};
+ assert.deepEqual(lodashStable.reduce(array, func, { 'a': 0 }), expected);
+
+ var fn = function() {};
fn.a = array[0];
fn.b = array[1];
fn.c = array[2];
- assert.deepEqual(lodashStable.reduce(array, func, { 'a': 0 }), expected);
- assert.deepEqual(lodashStable.reduce(fn, func, { 'a': 0 }), expected);
+ assert.deepEqual(_.reduce(fn, func, { 'a': 0 }), expected);
});
QUnit.test('`_.' + methodName + '` should not return the existing wrapped value when chaining', function(assert) {
});
});
- lodashStable.each(['assign', 'assignIn', 'assignInWith', 'assignWith', 'defaults', 'defaultsDeep', 'merge', 'mergeWith'], function(methodName) {
+ lodashStable.each(['assign', 'assignIn', 'assignInWith', 'assignWith', 'defaults', 'merge', 'mergeWith'], function(methodName) {
var func = _[methodName];
QUnit.test('`_.' + methodName + '` should not assign values that are the same as their destinations', function(assert) {
assert.expect(4);
lodashStable.each(['a', ['a'], { 'a': 1 }, NaN], function(value) {
- var object = {},
- pass = true;
+ if (defineProperty) {
+ var object = {},
+ pass = true;
- defineProperty(object, 'a', {
- 'configurable': true,
- 'enumerable': true,
- 'get': lodashStable.constant(value),
- 'set': function() { pass = false; }
- });
+ defineProperty(object, 'a', {
+ 'enumerable': true,
+ 'configurable': true,
+ 'get': lodashStable.constant(value),
+ 'set': function() { pass = false; }
+ });
- func(object, { 'a': value });
- assert.ok(pass);
+ func(object, { 'a': value });
+ assert.ok(pass);
+ }
+ else {
+ skipAssert(assert);
+ }
});
});
});
var func = _[methodName],
isMergeWith = methodName == 'mergeWith';
- QUnit.test('`_.' + methodName + '` should provide correct `customizer` arguments', function(assert) {
+ QUnit.test('`_.' + methodName + '` should provide the correct `customizer` arguments', function(assert) {
assert.expect(3);
var args,
args || (args = lodashStable.map(slice.call(arguments, 0, 5), lodashStable.cloneDeep));
});
- assert.deepEqual(args, expected, 'primitive values');
+ assert.deepEqual(args, expected, 'primitive property values');
+
+ args = undefined;
+ object = { 'a': 1 };
+ source = { 'b': 2 };
+ expected = lodashStable.map([undefined, 2, 'b', object, source], lodashStable.cloneDeep);
+
+ func(object, source, function() {
+ args || (args = lodashStable.map(slice.call(arguments, 0, 5), lodashStable.cloneDeep));
+ });
+
+ assert.deepEqual(args, expected, 'missing destination property');
var argsList = [],
objectValue = [1, 2],
argsList.push(lodashStable.map(slice.call(arguments, 0, 5), lodashStable.cloneDeep));
});
- assert.deepEqual(argsList, expected, 'object values');
-
- args = undefined;
- object = { 'a': 1 };
- source = { 'b': 2 };
- expected = lodashStable.map([undefined, 2, 'b', object, source], lodashStable.cloneDeep);
-
- func(object, source, function() {
- args || (args = lodashStable.map(slice.call(arguments, 0, 5), lodashStable.cloneDeep));
- });
-
- assert.deepEqual(args, expected, 'undefined properties');
+ assert.deepEqual(argsList, expected, 'object property values');
});
QUnit.test('`_.' + methodName + '` should not treat the second argument as a `customizer` callback', function(assert) {
QUnit.module('`__proto__` property bugs');
(function() {
- QUnit.test('should work with the "__proto__" key in internal data objects', function(assert) {
+ QUnit.test('internal data objects should work with the `__proto__` key', function(assert) {
assert.expect(4);
var stringLiteral = '__proto__',
assert.deepEqual(_.uniq(largeArray), expected);
assert.deepEqual(_.without.apply(_, [largeArray].concat(largeArray)), []);
});
-
- QUnit.test('should treat "__proto__" as a regular key in assignments', function(assert) {
- assert.expect(2);
-
- var methods = [
- 'assign',
- 'assignIn',
- 'defaults',
- 'defaultsDeep',
- 'merge'
- ];
-
- var source = create(null);
- source.__proto__ = [];
-
- var expected = lodashStable.map(methods, stubFalse);
-
- var actual = lodashStable.map(methods, function(methodName) {
- var result = _[methodName]({}, source);
- return result instanceof Array;
- });
-
- assert.deepEqual(actual, expected);
-
- actual = _.groupBy([{ 'a': '__proto__' }], 'a');
- assert.notOk(actual instanceof Array);
- });
}());
/*--------------------------------------------------------------------------*/
assert.deepEqual(actual, object);
});
- QUnit.test('should accept a falsey `array`', function(assert) {
+ QUnit.test('should accept a falsey `array` argument', function(assert) {
assert.expect(1);
- var expected = lodashStable.map(falsey, stubObject);
+ var expected = lodashStable.map(falsey, alwaysEmptyObject);
var actual = lodashStable.map(falsey, function(array, index) {
try {
QUnit.module('has methods');
lodashStable.each(['has', 'hasIn'], function(methodName) {
- var func = _[methodName],
- isHas = methodName == 'has',
- sparseArgs = toArgs([1]),
- sparseArray = Array(1),
- sparseString = Object('a');
-
- delete sparseArgs[0];
- delete sparseString[0];
+ var args = (function() { return arguments; }(1, 2, 3)),
+ func = _[methodName],
+ isHas = methodName == 'has';
QUnit.test('`_.' + methodName + '` should check for own properties', function(assert) {
assert.expect(2);
});
});
- QUnit.test('`_.' + methodName + '` should not use the `hasOwnProperty` method of `object`', function(assert) {
+ QUnit.test('`_.' + methodName + '` should not use the `hasOwnProperty` method of the object', function(assert) {
assert.expect(1);
var object = { 'hasOwnProperty': null, 'a': 1 };
});
QUnit.test('`_.' + methodName + '` should coerce `path` to a string', function(assert) {
- assert.expect(2);
+ assert.expect(1);
function fn() {}
fn.toString = lodashStable.constant('fn');
- var object = { 'null': 1 , 'undefined': 2, 'fn': 3, '[object Object]': 4 },
- paths = [null, undefined, fn, {}],
- expected = lodashStable.map(paths, stubTrue);
+ var expected = [1, 1, 2, 2, 3, 3, 4, 4],
+ objects = [{ 'null': 1 }, { 'undefined': 2 }, { 'fn': 3 }, { '[object Object]': 4 }],
+ values = [null, undefined, fn, {}];
- lodashStable.times(2, function(index) {
- var actual = lodashStable.map(paths, function(path) {
- return func(object, index ? [path] : path);
+ var actual = lodashStable.transform(objects, function(result, object, index) {
+ var key = values[index];
+ lodashStable.each([key, [key]], function(path) {
+ var prop = _.property(key);
+ result.push(prop(object));
});
-
- assert.deepEqual(actual, expected);
});
+
+ assert.deepEqual(actual, expected);
});
QUnit.test('`_.' + methodName + '` should work with `arguments` objects', function(assert) {
var object = { '-0': 'a', '0': 'b' },
props = [-0, Object(-0), 0, Object(0)],
- expected = lodashStable.map(props, stubTrue);
+ expected = lodashStable.map(props, alwaysTrue);
var actual = lodashStable.map(props, function(key) {
return func(object, key);
});
QUnit.test('`_.' + methodName + '` should work with a symbol `path`', function(assert) {
- assert.expect(2);
+ assert.expect(1);
- function Foo() {}
+ function Foo() {
+ this[symbol] = 1;
+ }
if (Symbol) {
- Foo.prototype[symbol] = 1;
-
var symbol2 = Symbol('b');
- defineProperty(Foo.prototype, symbol2, {
- 'configurable': true,
- 'enumerable': false,
- 'writable': true,
- 'value': 2
- });
+ Foo.prototype[symbol2] = 2;
+ var path = isHas ? symbol : symbol2;
- var object = isHas ? Foo.prototype : new Foo;
- assert.strictEqual(func(object, symbol), true);
- assert.strictEqual(func(object, symbol2), true);
+ assert.strictEqual(func(new Foo, path), true);
}
else {
- skipAssert(assert, 2);
+ skipAssert(assert);
+ }
+ });
+
+ QUnit.test('`_.' + methodName + '` should work for objects with a `[[Prototype]]` of `null`', function(assert) {
+ assert.expect(1);
+
+ if (create) {
+ var object = create(null);
+ object[1] = 'a';
+ assert.strictEqual(func(object, 1), true);
+ }
+ else {
+ skipAssert(assert);
}
});
});
});
- QUnit.test('`_.' + methodName + '` should return `true` for indexes of sparse values', function(assert) {
- assert.expect(1);
-
- var values = [sparseArgs, sparseArray, sparseString],
- expected = lodashStable.map(values, stubTrue);
-
- var actual = lodashStable.map(values, function(value) {
- return func(value, 0);
- });
-
- assert.deepEqual(actual, expected);
- });
-
- QUnit.test('`_.' + methodName + '` should return `true` for indexes of sparse values with deep paths', function(assert) {
- assert.expect(1);
-
- var values = [sparseArgs, sparseArray, sparseString],
- expected = lodashStable.map(values, lodashStable.constant([true, true]));
-
- var actual = lodashStable.map(values, function(value) {
- return lodashStable.map(['a[0]', ['a', '0']], function(path) {
- return func({ 'a': value }, path);
- });
- });
-
- assert.deepEqual(actual, expected);
- });
-
QUnit.test('`_.' + methodName + '` should return `' + (isHas ? 'false' : 'true') + '` for inherited properties', function(assert) {
assert.expect(2);
});
});
+ QUnit.test('`_.' + methodName + '` should return `true` for index values within bounds for arrays, `arguments` objects, and strings', function(assert) {
+ assert.expect(2);
+
+ var string = Object('abc');
+ delete args[0];
+ delete string[0];
+
+ var values = [Array(3), args, string],
+ expected = lodashStable.map(values, alwaysTrue);
+
+ var actual = lodashStable.map(values, function(value) {
+ return func(value, 0);
+ });
+
+ assert.deepEqual(actual, expected);
+
+ expected = lodashStable.map(values, lodashStable.constant([true, true]));
+
+ actual = lodashStable.map(values, function(value) {
+ return lodashStable.map(['a[0]', ['a', '0']], function(path) {
+ return func({ 'a': value }, path);
+ });
+ });
+
+ assert.deepEqual(actual, expected);
+ args[0] = 1;
+ });
+
QUnit.test('`_.' + methodName + '` should return `false` when `object` is nullish', function(assert) {
assert.expect(2);
var values = [null, undefined],
- expected = lodashStable.map(values, stubFalse);
+ expected = lodashStable.map(values, alwaysFalse);
lodashStable.each(['constructor', ['constructor']], function(path) {
var actual = lodashStable.map(values, function(value) {
assert.expect(2);
var values = [null, undefined],
- expected = lodashStable.map(values, stubFalse);
+ expected = lodashStable.map(values, alwaysFalse);
lodashStable.each(['constructor.prototype.valueOf', ['constructor', 'prototype', 'valueOf']], function(path) {
var actual = lodashStable.map(values, function(value) {
assert.expect(2);
var values = [, null, undefined],
- expected = lodashStable.map(values, stubFalse);
+ expected = lodashStable.map(values, alwaysFalse);
lodashStable.each(['a.b', ['a', 'b']], function(path) {
var actual = lodashStable.map(values, function(value, index) {
assert.deepEqual(actual, expected);
});
});
-
- QUnit.test('`_.' + methodName + '` should return `false` over sparse values of deep paths', function(assert) {
- assert.expect(1);
-
- var values = [sparseArgs, sparseArray, sparseString],
- expected = lodashStable.map(values, lodashStable.constant([false, false]));
-
- var actual = lodashStable.map(values, function(value) {
- return lodashStable.map(['a[0].b', ['a', '0', 'b']], function(path) {
- return func({ 'a': value }, path);
- });
- });
-
- assert.deepEqual(actual, expected);
- });
});
/*--------------------------------------------------------------------------*/
assert.deepEqual(actual, [1, 4, 7]);
});
- QUnit.test('should be aliased', function(assert) {
- assert.expect(1);
-
- assert.strictEqual(_.first, _.head);
- });
-
QUnit.test('should return an unwrapped value when implicitly chaining', function(assert) {
- assert.expect(2);
+ assert.expect(1);
if (!isNpm) {
- var wrapped = _(array);
- assert.strictEqual(wrapped.head(), 1);
- assert.strictEqual(wrapped.first(), 1);
+ assert.strictEqual(_(array).head(), 1);
}
else {
- skipAssert(assert, 2);
+ skipAssert(assert);
}
});
QUnit.test('should return a wrapped value when explicitly chaining', function(assert) {
- assert.expect(2);
+ assert.expect(1);
if (!isNpm) {
- var wrapped = _(array).chain();
- assert.ok(wrapped.head() instanceof _);
- assert.ok(wrapped.first() instanceof _);
+ assert.ok(_(array).chain().head() instanceof _);
}
else {
- skipAssert(assert, 2);
+ skipAssert(assert);
}
});
QUnit.test('should not execute immediately when explicitly chaining', function(assert) {
- assert.expect(2);
+ assert.expect(1);
if (!isNpm) {
- var wrapped = _(array).chain();
- assert.strictEqual(wrapped.head().__wrapped__, array);
- assert.strictEqual(wrapped.first().__wrapped__, array);
+ var wrapped = _(array).chain().head();
+ assert.strictEqual(wrapped.__wrapped__, array);
}
else {
- skipAssert(assert, 2);
+ skipAssert(assert);
}
});
QUnit.test('should work in a lazy sequence', function(assert) {
- assert.expect(4);
+ assert.expect(2);
if (!isNpm) {
var largeArray = lodashStable.range(LARGE_ARRAY_SIZE),
smallArray = array;
- lodashStable.each(['head', 'first'], function(methodName) {
- lodashStable.times(2, function(index) {
- var array = index ? largeArray : smallArray,
- actual = _(array).filter(isEven)[methodName]();
+ lodashStable.times(2, function(index) {
+ var array = index ? largeArray : smallArray,
+ wrapped = _(array).filter(isEven);
- assert.strictEqual(actual, _[methodName](_.filter(array, isEven)));
- });
+ assert.strictEqual(wrapped.head(), _.head(_.filter(array, isEven)));
});
}
else {
- skipAssert(assert, 4);
+ skipAssert(assert, 2);
}
});
+
+ QUnit.test('should be aliased', function(assert) {
+ assert.expect(1);
+
+ assert.strictEqual(_.first, _.head);
+ });
}());
/*--------------------------------------------------------------------------*/
'a string': '1234'
},
function(collection, key) {
+ var isStr = typeof collection == 'string',
+ values = _.toArray(collection),
+ length = values.length;
+
QUnit.test('should work with ' + key + ' and return `true` for matched values', function(assert) {
assert.expect(1);
assert.strictEqual(_.includes(collection, 5), false);
});
+ QUnit.test('should work with ' + key + ' and a positive `fromIndex`', function(assert) {
+ assert.expect(2);
+
+ assert.strictEqual(_.includes(collection, values[2], 2), true);
+ assert.strictEqual(_.includes(collection, values[1], 2), false);
+ });
+
+ QUnit.test('should work with ' + key + ' and a `fromIndex` >= `collection.length`', function(assert) {
+ assert.expect(12);
+
+ lodashStable.each([4, 6, Math.pow(2, 32), Infinity], function(fromIndex) {
+ assert.strictEqual(_.includes(collection, 1, fromIndex), false);
+ assert.strictEqual(_.includes(collection, undefined, fromIndex), false);
+ assert.strictEqual(_.includes(collection, '', fromIndex), (isStr && fromIndex == length));
+ });
+ });
+
+ QUnit.test('should work with ' + key + ' and treat falsey `fromIndex` values as `0`', function(assert) {
+ assert.expect(1);
+
+ var expected = lodashStable.map(falsey, alwaysTrue);
+
+ var actual = lodashStable.map(falsey, function(fromIndex) {
+ return _.includes(collection, values[0], fromIndex);
+ });
+
+ assert.deepEqual(actual, expected);
+ });
+
+ QUnit.test('should work with ' + key + ' and coerce non-integer `fromIndex` values to integers', function(assert) {
+ assert.expect(3);
+
+ assert.strictEqual(_.includes(collection, values[0], '1'), false);
+ assert.strictEqual(_.includes(collection, values[0], 0.1), true);
+ assert.strictEqual(_.includes(collection, values[0], NaN), true);
+ });
+
+ QUnit.test('should work with ' + key + ' and a negative `fromIndex`', function(assert) {
+ assert.expect(2);
+
+ assert.strictEqual(_.includes(collection, values[2], -2), true);
+ assert.strictEqual(_.includes(collection, values[1], -2), false);
+ });
+
+ QUnit.test('should work with ' + key + ' and a negative `fromIndex` <= negative `collection.length`', function(assert) {
+ assert.expect(3);
+
+ lodashStable.each([-4, -6, -Infinity], function(fromIndex) {
+ assert.strictEqual(_.includes(collection, values[0], fromIndex), true);
+ });
+ });
+
QUnit.test('should work with ' + key + ' and floor `position` values', function(assert) {
assert.expect(1);
QUnit.test('should return `false` for empty collections', function(assert) {
assert.expect(1);
- var expected = lodashStable.map(empties, stubFalse);
+ var expected = lodashStable.map(empties, alwaysFalse);
var actual = lodashStable.map(empties, function(value) {
try {
assert.deepEqual(actual, expected);
});
- QUnit.test('should work with a string and a `fromIndex` >= `length`', function(assert) {
+ QUnit.test('should match `NaN`', function(assert) {
assert.expect(1);
- var string = '1234',
- length = string.length,
- indexes = [4, 6, Math.pow(2, 32), Infinity];
+ assert.strictEqual(_.includes([1, NaN, 3], NaN), true);
+ });
- var expected = lodashStable.map(indexes, function(index) {
- return [false, false, index == length];
- });
+ QUnit.test('should match `-0` as `0`', function(assert) {
+ assert.expect(2);
+
+ assert.strictEqual(_.includes([-0], 0), true);
+ assert.strictEqual(_.includes([0], -0), true);
+ });
+
+ QUnit.test('should work as an iteratee for methods like `_.every`', function(assert) {
+ assert.expect(1);
+
+ var array1 = [1, 2, 3],
+ array2 = [2, 3, 1];
+
+ assert.ok(lodashStable.every(array1, lodashStable.partial(_.includes, array2)));
+ });
+ }(1, 2, 3, 4));
+
+ /*--------------------------------------------------------------------------*/
+
+ QUnit.module('lodash.indexOf');
+
+ (function() {
+ var array = [1, 2, 3, 1, 2, 3];
+
+ QUnit.test('should return the index of the first matched value', function(assert) {
+ assert.expect(1);
+
+ assert.strictEqual(_.indexOf(array, 3), 2);
+ });
+
+ QUnit.test('should work with a positive `fromIndex`', function(assert) {
+ assert.expect(1);
+
+ assert.strictEqual(_.indexOf(array, 1, 2), 3);
+ });
+
+ QUnit.test('should work with `fromIndex` >= `array.length`', function(assert) {
+ assert.expect(1);
+
+ var values = [6, 8, Math.pow(2, 32), Infinity],
+ expected = lodashStable.map(values, lodashStable.constant([-1, -1, -1]));
- var actual = lodashStable.map(indexes, function(fromIndex) {
+ var actual = lodashStable.map(values, function(fromIndex) {
return [
- _.includes(string, 1, fromIndex),
- _.includes(string, undefined, fromIndex),
- _.includes(string, '', fromIndex)
+ _.indexOf(array, undefined, fromIndex),
+ _.indexOf(array, 1, fromIndex),
+ _.indexOf(array, '', fromIndex)
];
});
assert.deepEqual(actual, expected);
});
- QUnit.test('should match `NaN`', function(assert) {
+ QUnit.test('should work with a negative `fromIndex`', function(assert) {
assert.expect(1);
- assert.strictEqual(_.includes([1, NaN, 3], NaN), true);
+ assert.strictEqual(_.indexOf(array, 2, -3), 4);
});
- QUnit.test('should match `-0` as `0`', function(assert) {
- assert.expect(2);
+ QUnit.test('should work with a negative `fromIndex` <= `-array.length`', function(assert) {
+ assert.expect(1);
- assert.strictEqual(_.includes([-0], 0), true);
- assert.strictEqual(_.includes([0], -0), true);
+ var values = [-6, -8, -Infinity],
+ expected = lodashStable.map(values, alwaysZero);
+
+ var actual = lodashStable.map(values, function(fromIndex) {
+ return _.indexOf(array, 1, fromIndex);
+ });
+
+ assert.deepEqual(actual, expected);
});
- QUnit.test('should work as an iteratee for methods like `_.every`', function(assert) {
+ QUnit.test('should treat falsey `fromIndex` values as `0`', function(assert) {
assert.expect(1);
- var array = [2, 3, 1],
- values = [1, 2, 3];
+ var expected = lodashStable.map(falsey, alwaysZero);
- assert.ok(lodashStable.every(values, lodashStable.partial(_.includes, array)));
+ var actual = lodashStable.map(falsey, function(fromIndex) {
+ return _.indexOf(array, 1, fromIndex);
+ });
+
+ assert.deepEqual(actual, expected);
});
- }(1, 2, 3, 4));
+
+ QUnit.test('should coerce `fromIndex` to an integer', function(assert) {
+ assert.expect(1);
+
+ assert.strictEqual(_.indexOf(array, 2, 1.2), 1);
+ });
+ }());
/*--------------------------------------------------------------------------*/
(function() {
var array = [1, 2, 3];
- QUnit.test('should accept a falsey `array`', function(assert) {
+ QUnit.test('should accept a falsey `array` argument', function(assert) {
assert.expect(1);
- var expected = lodashStable.map(falsey, stubArray);
+ var expected = lodashStable.map(falsey, alwaysEmptyArray);
var actual = lodashStable.map(falsey, function(array, index) {
try {
QUnit.module('lodash.inRange');
(function() {
- QUnit.test('should work with an `end`', function(assert) {
+ QUnit.test('should work with an `end` argument', function(assert) {
assert.expect(3);
assert.strictEqual(_.inRange(3, 5), true);
assert.strictEqual(_.inRange(6, 5), false);
});
- QUnit.test('should work with a `start` and `end`', function(assert) {
+ QUnit.test('should work with `start` and `end` arguments', function(assert) {
assert.expect(4);
assert.strictEqual(_.inRange(1, 1, 5), true);
assert.strictEqual(_.inRange(5, 1, 5), false);
});
- QUnit.test('should treat falsey `start` as `0`', function(assert) {
+ QUnit.test('should treat falsey `start` arguments as `0`', function(assert) {
assert.expect(13);
lodashStable.each(falsey, function(value, index) {
QUnit.test('should coerce arguments to finite numbers', function(assert) {
assert.expect(1);
- var actual = [
- _.inRange(0, '1'),
- _.inRange(0, '0', 1),
- _.inRange(0, 0, '1'),
- _.inRange(0, NaN, 1),
- _.inRange(-1, -1, NaN)
- ];
+ var actual = [_.inRange(0, '0', 1), _.inRange(0, '1'), _.inRange(0, 0, '1'), _.inRange(0, NaN, 1), _.inRange(-1, -1, NaN)],
+ expected = lodashStable.map(actual, alwaysTrue);
- assert.deepEqual(actual, lodashStable.map(actual, stubTrue));
+ assert.deepEqual(actual, expected);
});
}());
QUnit.module('intersection methods');
lodashStable.each(['intersection', 'intersectionBy', 'intersectionWith'], function(methodName) {
- var func = _[methodName];
+ var args = (function() { return arguments; }(1, 2, 3)),
+ func = _[methodName];
QUnit.test('`_.' + methodName + '` should return the intersection of two arrays', function(assert) {
- assert.expect(1);
+ assert.expect(2);
- var actual = func([2, 1], [2, 3]);
- assert.deepEqual(actual, [2]);
+ var actual = func([1, 3, 2], [5, 2, 1, 4]);
+ assert.deepEqual(actual, [1, 2]);
+
+ actual = func([5, 2, 1, 4], [1, 3, 2]);
+ assert.deepEqual(actual, [2, 1]);
});
QUnit.test('`_.' + methodName + '` should return the intersection of multiple arrays', function(assert) {
- assert.expect(1);
+ assert.expect(2);
- var actual = func([2, 1, 2, 3], [3, 4], [3, 2]);
- assert.deepEqual(actual, [3]);
+ var actual = func([1, 3, 2], [5, 2, 1, 4], [2, 1]);
+ assert.deepEqual(actual, [1, 2]);
+
+ actual = func([5, 2, 1, 4], [2, 1], [1, 3, 2]);
+ assert.deepEqual(actual, [2, 1]);
});
QUnit.test('`_.' + methodName + '` should return an array of unique values', function(assert) {
QUnit.test('`_.' + methodName + '` should work with large arrays of `NaN`', function(assert) {
assert.expect(1);
- var largeArray = lodashStable.times(LARGE_ARRAY_SIZE, stubNaN);
+ var largeArray = lodashStable.times(LARGE_ARRAY_SIZE, alwaysNaN);
assert.deepEqual(func([1, NaN, 3], largeArray), [NaN]);
});
QUnit.module('lodash.intersectionBy');
(function() {
- QUnit.test('should accept an `iteratee`', function(assert) {
+ QUnit.test('should accept an `iteratee` argument', function(assert) {
assert.expect(2);
- var actual = _.intersectionBy([2.1, 1.2], [2.3, 3.4], Math.floor);
+ var actual = _.intersectionBy([2.1, 1.2], [4.3, 2.4], Math.floor);
assert.deepEqual(actual, [2.1]);
actual = _.intersectionBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x');
assert.deepEqual(actual, [{ 'x': 1 }]);
});
- QUnit.test('should provide correct `iteratee` arguments', function(assert) {
+ QUnit.test('should provide the correct `iteratee` arguments', function(assert) {
assert.expect(1);
var args;
- _.intersectionBy([2.1, 1.2], [2.3, 3.4], function() {
+ _.intersectionBy([2.1, 1.2], [4.3, 2.4], function() {
args || (args = slice.call(arguments));
});
- assert.deepEqual(args, [2.3]);
+ assert.deepEqual(args, [4.3]);
});
}());
QUnit.module('lodash.intersectionWith');
(function() {
- QUnit.test('should work with a `comparator`', function(assert) {
+ QUnit.test('should work with a `comparator` argument', function(assert) {
assert.expect(1);
var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }],
assert.expect(1);
var array = [-0],
- largeArray = lodashStable.times(LARGE_ARRAY_SIZE, stubZero),
+ largeArray = lodashStable.times(LARGE_ARRAY_SIZE, alwaysZero),
others = [[0], largeArray],
expected = lodashStable.map(others, lodashStable.constant(['-0']));
QUnit.test('should preserve the sign of `0`', function(assert) {
assert.expect(1);
- var object = { '-0': stubA, '0': stubB },
+ var object = { '-0': alwaysA, '0': alwaysB },
props = [-0, Object(-0), 0, Object(0)];
var actual = lodashStable.map(props, function(key) {
assert.expect(1);
if (!isNpm) {
- var object = { 'a': stubOne };
+ var object = { 'a': alwaysOne };
assert.strictEqual(_(object).invoke('a'), 1);
}
else {
assert.expect(1);
if (!isNpm) {
- var object = { 'a': stubOne };
+ var object = { 'a': alwaysOne };
assert.ok(_(object).chain().invoke('a') instanceof _);
}
else {
QUnit.test('should not error on elements with missing properties', function(assert) {
assert.expect(1);
- var objects = lodashStable.map([null, undefined, stubOne], function(value) {
+ var objects = lodashStable.map([null, undefined, alwaysOne], function(value) {
return { 'a': value };
});
QUnit.module('lodash.isArguments');
(function() {
+ var args = (function() { return arguments; }(1, 2, 3)),
+ strictArgs = (function() { 'use strict'; return arguments; }(1, 2, 3));
+
QUnit.test('should return `true` for `arguments` objects', function(assert) {
assert.expect(2);
QUnit.test('should return `false` for non `arguments` objects', function(assert) {
assert.expect(12);
- var expected = lodashStable.map(falsey, stubFalse);
+ var expected = lodashStable.map(falsey, alwaysFalse);
var actual = lodashStable.map(falsey, function(value, index) {
return index ? _.isArguments(value) : _.isArguments();
QUnit.module('lodash.isArray');
(function() {
+ var args = arguments;
+
QUnit.test('should return `true` for arrays', function(assert) {
assert.expect(1);
QUnit.test('should return `false` for non-arrays', function(assert) {
assert.expect(12);
- var expected = lodashStable.map(falsey, stubFalse);
+ var expected = lodashStable.map(falsey, alwaysFalse);
var actual = lodashStable.map(falsey, function(value, index) {
return index ? _.isArray(value) : _.isArray();
skipAssert(assert);
}
});
- }());
+ }(1, 2, 3));
/*--------------------------------------------------------------------------*/
QUnit.module('lodash.isArrayBuffer');
(function() {
+ var args = arguments;
+
QUnit.test('should return `true` for array buffers', function(assert) {
assert.expect(1);
QUnit.test('should return `false` for non array buffers', function(assert) {
assert.expect(13);
- var expected = lodashStable.map(falsey, stubFalse);
+ var expected = lodashStable.map(falsey, alwaysFalse);
var actual = lodashStable.map(falsey, function(value, index) {
return index ? _.isArrayBuffer(value) : _.isArrayBuffer();
assert.deepEqual(actual, expected);
assert.strictEqual(_.isArrayBuffer(args), false);
- assert.strictEqual(_.isArrayBuffer([1]), false);
+ assert.strictEqual(_.isArrayBuffer([1, 2, 3]), false);
assert.strictEqual(_.isArrayBuffer(true), false);
assert.strictEqual(_.isArrayBuffer(new Date), false);
assert.strictEqual(_.isArrayBuffer(new Error), false);
skipAssert(assert);
}
});
- }());
+ }(1, 2, 3));
/*--------------------------------------------------------------------------*/
QUnit.module('lodash.isArrayLike');
(function() {
+ var args = arguments;
+
QUnit.test('should return `true` for array-like values', function(assert) {
assert.expect(1);
- var values = [args, [1, 2, 3], { '0': 'a', 'length': 1 }, 'a'],
- expected = lodashStable.map(values, stubTrue),
+ var values = [args, [1, 2, 3], { '0': 1, 'length': 1 }, 'a'],
+ expected = lodashStable.map(values, alwaysTrue),
actual = lodashStable.map(values, _.isArrayLike);
assert.deepEqual(actual, expected);
});
QUnit.test('should return `false` for non-arrays', function(assert) {
- assert.expect(12);
+ assert.expect(11);
var expected = lodashStable.map(falsey, function(value) {
return value === '';
assert.strictEqual(_.isArrayLike(new Date), false);
assert.strictEqual(_.isArrayLike(new Error), false);
assert.strictEqual(_.isArrayLike(_), false);
- assert.strictEqual(_.isArrayLike(asyncFunc), false);
- assert.strictEqual(_.isArrayLike(genFunc), false);
+ assert.strictEqual(_.isArrayLike(generator), false);
assert.strictEqual(_.isArrayLike(slice), false);
assert.strictEqual(_.isArrayLike({ 'a': 1 }), false);
assert.strictEqual(_.isArrayLike(1), false);
if (realm.object) {
var values = [realm.arguments, realm.array, realm.string],
- expected = lodashStable.map(values, stubTrue),
+ expected = lodashStable.map(values, alwaysTrue),
actual = lodashStable.map(values, _.isArrayLike);
assert.deepEqual(actual, expected);
skipAssert(assert);
}
});
- }());
+ }(1, 2, 3));
/*--------------------------------------------------------------------------*/
QUnit.module('lodash.isBoolean');
(function() {
+ var args = arguments;
+
QUnit.test('should return `true` for booleans', function(assert) {
assert.expect(4);
skipAssert(assert);
}
});
- }());
+ }(1, 2, 3));
/*--------------------------------------------------------------------------*/
QUnit.module('lodash.isBuffer');
(function() {
+ var args = arguments;
+
QUnit.test('should return `true` for buffers', function(assert) {
assert.expect(1);
QUnit.test('should return `false` for non-buffers', function(assert) {
assert.expect(13);
- var expected = lodashStable.map(falsey, stubFalse);
+ var expected = lodashStable.map(falsey, alwaysFalse);
var actual = lodashStable.map(falsey, function(value, index) {
return index ? _.isBuffer(value) : _.isBuffer();
assert.deepEqual(actual, expected);
assert.strictEqual(_.isBuffer(args), false);
- assert.strictEqual(_.isBuffer([1]), false);
+ assert.strictEqual(_.isBuffer([1, 2, 3]), false);
assert.strictEqual(_.isBuffer(true), false);
assert.strictEqual(_.isBuffer(new Date), false);
assert.strictEqual(_.isBuffer(new Error), false);
skipAssert(assert);
}
});
- }());
+ }(1, 2, 3));
/*--------------------------------------------------------------------------*/
QUnit.module('lodash.isDate');
(function() {
+ var args = arguments;
+
QUnit.test('should return `true` for dates', function(assert) {
assert.expect(1);
QUnit.test('should return `false` for non-dates', function(assert) {
assert.expect(12);
- var expected = lodashStable.map(falsey, stubFalse);
+ var expected = lodashStable.map(falsey, alwaysFalse);
var actual = lodashStable.map(falsey, function(value, index) {
return index ? _.isDate(value) : _.isDate();
skipAssert(assert);
}
});
- }());
+ }(1, 2, 3));
/*--------------------------------------------------------------------------*/
QUnit.module('lodash.isElement');
(function() {
- QUnit.test('should return `true` for elements', function(assert) {
- assert.expect(1);
+ var args = arguments;
- if (document) {
- assert.strictEqual(_.isElement(body), true);
- }
- else {
- skipAssert(assert);
- }
- });
+ function Element() {
+ this.nodeType = 1;
+ }
- QUnit.test('should return `true` for non-plain objects', function(assert) {
- assert.expect(1);
+ QUnit.test('should return `false` for plain objects', function(assert) {
+ assert.expect(7);
- function Foo() {
- this.nodeType = 1;
- }
+ var element = body || new Element;
- assert.strictEqual(_.isElement(new Foo), true);
+ assert.strictEqual(_.isElement(element), true);
+ assert.strictEqual(_.isElement({ 'nodeType': 1 }), false);
+ assert.strictEqual(_.isElement({ 'nodeType': Object(1) }), false);
+ assert.strictEqual(_.isElement({ 'nodeType': true }), false);
+ assert.strictEqual(_.isElement({ 'nodeType': [1] }), false);
+ assert.strictEqual(_.isElement({ 'nodeType': '1' }), false);
+ assert.strictEqual(_.isElement({ 'nodeType': '001' }), false);
});
QUnit.test('should return `false` for non DOM elements', function(assert) {
assert.expect(13);
- var expected = lodashStable.map(falsey, stubFalse);
+ var expected = lodashStable.map(falsey, alwaysFalse);
var actual = lodashStable.map(falsey, function(value, index) {
return index ? _.isElement(value) : _.isElement();
assert.strictEqual(_.isElement(symbol), false);
});
- QUnit.test('should return `false` for plain objects', function(assert) {
- assert.expect(6);
-
- assert.strictEqual(_.isElement({ 'nodeType': 1 }), false);
- assert.strictEqual(_.isElement({ 'nodeType': Object(1) }), false);
- assert.strictEqual(_.isElement({ 'nodeType': true }), false);
- assert.strictEqual(_.isElement({ 'nodeType': [1] }), false);
- assert.strictEqual(_.isElement({ 'nodeType': '1' }), false);
- assert.strictEqual(_.isElement({ 'nodeType': '001' }), false);
- });
-
QUnit.test('should work with a DOM element from another realm', function(assert) {
assert.expect(1);
skipAssert(assert);
}
});
- }());
+ }(1, 2, 3));
/*--------------------------------------------------------------------------*/
QUnit.module('lodash.isEmpty');
(function() {
+ var args = arguments;
+
QUnit.test('should return `true` for empty values', function(assert) {
assert.expect(10);
- var expected = lodashStable.map(empties, stubTrue),
+ var expected = lodashStable.map(empties, alwaysTrue),
actual = lodashStable.map(empties, _.isEmpty);
assert.deepEqual(actual, expected);
assert.strictEqual(_.isEmpty(args), false);
});
- QUnit.test('should work with prototytpe objects', function(assert) {
- assert.expect(2);
-
- function Foo() {}
- Foo.prototype = { 'constructor': Foo };
-
- assert.strictEqual(_.isEmpty(Foo.prototype), true);
-
- Foo.prototype.a = 1;
- assert.strictEqual(_.isEmpty(Foo.prototype), false);
- });
-
QUnit.test('should work with jQuery/MooTools DOM query collections', function(assert) {
assert.expect(1);
skipAssert(assert);
}
});
- }());
+ }(1, 2, 3));
/*--------------------------------------------------------------------------*/
assert.strictEqual(_.isEqual(array1, array2), false);
});
- QUnit.test('should have transitive equivalence for circular references of arrays', function(assert) {
- assert.expect(3);
-
- var array1 = [],
- array2 = [array1],
- array3 = [array2];
-
- array1[0] = array1;
-
- assert.strictEqual(_.isEqual(array1, array2), true);
- assert.strictEqual(_.isEqual(array2, array3), true);
- assert.strictEqual(_.isEqual(array1, array3), true);
- });
-
QUnit.test('should compare objects with circular references', function(assert) {
assert.expect(4);
assert.strictEqual(_.isEqual(object1, object2), false);
});
- QUnit.test('should have transitive equivalence for circular references of objects', function(assert) {
- assert.expect(3);
-
- var object1 = {},
- object2 = { 'a': object1 },
- object3 = { 'a': object2 };
-
- object1.a = object1;
-
- assert.strictEqual(_.isEqual(object1, object2), true);
- assert.strictEqual(_.isEqual(object2, object3), true);
- assert.strictEqual(_.isEqual(object1, object3), true);
- });
-
QUnit.test('should compare objects with multiple circular references', function(assert) {
assert.expect(3);
assert.strictEqual(_.isEqual(object1, object2), true);
});
- QUnit.test('should treat objects created by `Object.create(null)` like plain objects', function(assert) {
+ QUnit.test('should treat objects created by `Object.create(null)` like a plain object', function(assert) {
assert.expect(2);
function Foo() {
}
Foo.prototype.constructor = null;
- var object1 = create(null);
- object1.a = 1;
-
var object2 = { 'a': 1 };
-
- assert.strictEqual(_.isEqual(object1, object2), true);
assert.strictEqual(_.isEqual(new Foo, object2), false);
+
+ if (create) {
+ var object1 = create(null);
+ object1.a = 1;
+ assert.strictEqual(_.isEqual(object1, object2), true);
+ }
+ else {
+ skipAssert(assert);
+ }
+ });
+
+ QUnit.test('should return `false` for objects with custom `toString` methods', function(assert) {
+ assert.expect(1);
+
+ var primitive,
+ object = { 'toString': function() { return primitive; } },
+ values = [true, null, 1, 'a', undefined],
+ expected = lodashStable.map(values, alwaysFalse);
+
+ var actual = lodashStable.map(values, function(value) {
+ primitive = value;
+ return _.isEqual(object, value);
+ });
+
+ assert.deepEqual(actual, expected);
});
QUnit.test('should avoid common type coercions', function(assert) {
QUnit.test('should compare `arguments` objects', function(assert) {
assert.expect(2);
- var args1 = (function() { return arguments; }()),
- args2 = (function() { return arguments; }()),
+ var args1 = (function() { return arguments; }(1, 2, 3)),
+ args2 = (function() { return arguments; }(1, 2, 3)),
args3 = (function() { return arguments; }(1, 2));
assert.strictEqual(_.isEqual(args1, args2), true);
QUnit.test('should treat `arguments` objects like `Object` objects', function(assert) {
assert.expect(4);
- var object = { '0': 1, '1': 2, '2': 3 };
+ var args = (function() { return arguments; }(1, 2, 3)),
+ object = { '0': 1, '1': 2, '2': 3 };
function Foo() {}
Foo.prototype = object;
assert.strictEqual(_.isEqual(args, object), true);
assert.strictEqual(_.isEqual(object, args), true);
+
assert.strictEqual(_.isEqual(args, new Foo), false);
assert.strictEqual(_.isEqual(new Foo, args), false);
});
assert.expect(2);
if (ArrayBuffer) {
- var buffer = new Int8Array([-1]).buffer;
+ var buffer1 = new ArrayBuffer(4),
+ buffer2 = new ArrayBuffer(8);
+
+ assert.strictEqual(_.isEqual(buffer1, buffer2), false);
+
+ buffer1 = new Int8Array([-1]).buffer;
+ buffer2 = new Uint8Array([255]).buffer;
- assert.strictEqual(_.isEqual(buffer, new Uint8Array([255]).buffer), true);
- assert.strictEqual(_.isEqual(buffer, new ArrayBuffer(1)), false);
+ assert.strictEqual(_.isEqual(buffer1, buffer2), true);
}
else {
skipAssert(assert, 2);
});
});
- QUnit.test('should compare buffers', function(assert) {
- assert.expect(3);
-
- if (Buffer) {
- var buffer = new Buffer([1]);
-
- assert.strictEqual(_.isEqual(buffer, new Buffer([1])), true);
- assert.strictEqual(_.isEqual(buffer, new Buffer([2])), false);
- assert.strictEqual(_.isEqual(buffer, new Uint8Array([1])), false);
- }
- else {
- skipAssert(assert, 3);
- }
- });
-
QUnit.test('should compare date objects', function(assert) {
assert.expect(4);
var date = new Date(2012, 4, 23);
assert.strictEqual(_.isEqual(date, new Date(2012, 4, 23)), true);
- assert.strictEqual(_.isEqual(new Date('a'), new Date('b')), true);
assert.strictEqual(_.isEqual(date, new Date(2013, 3, 25)), false);
assert.strictEqual(_.isEqual(date, { 'getTime': lodashStable.constant(+date) }), false);
+ assert.strictEqual(_.isEqual(new Date('a'), new Date('a')), false);
});
QUnit.test('should compare error objects', function(assert) {
map2.set('a', 1);
assert.strictEqual(_.isEqual(map1, map2), true);
- map1.delete('a');
+ map1['delete']('a');
map1.set('a', 1);
assert.strictEqual(_.isEqual(map1, map2), true);
- map2.delete('a');
+ map2['delete']('a');
assert.strictEqual(_.isEqual(map1, map2), false);
map1.clear();
set2.add(1);
assert.strictEqual(_.isEqual(set1, set2), true);
- set1.delete(1);
+ set1['delete'](1);
set1.add(1);
assert.strictEqual(_.isEqual(set1, set2), true);
- set2.delete(1);
+ set2['delete'](1);
assert.strictEqual(_.isEqual(set1, set2), false);
set1.clear();
}
});
- QUnit.test('should compare symbol properties', function(assert) {
- assert.expect(3);
+ QUnit.test('should work as an iteratee for `_.every`', function(assert) {
+ assert.expect(1);
- if (Symbol) {
- var object1 = { 'a': 1 },
- object2 = { 'a': 1 };
+ var actual = lodashStable.every([1, 1, 1], lodashStable.partial(_.isEqual, 1));
+ assert.ok(actual);
+ });
- object1[symbol1] = { 'a': { 'b': 2 } };
- object2[symbol1] = { 'a': { 'b': 2 } };
+ QUnit.test('should return `true` for like-objects from different documents', function(assert) {
+ assert.expect(4);
- defineProperty(object2, symbol2, {
- 'configurable': true,
- 'enumerable': false,
- 'writable': true,
- 'value': 2
- });
+ if (realm.object) {
+ assert.strictEqual(_.isEqual([1], realm.array), true);
+ assert.strictEqual(_.isEqual([2], realm.array), false);
+ assert.strictEqual(_.isEqual({ 'a': 1 }, realm.object), true);
+ assert.strictEqual(_.isEqual({ 'a': 2 }, realm.object), false);
+ }
+ else {
+ skipAssert(assert, 4);
+ }
+ });
- assert.strictEqual(_.isEqual(object1, object2), true);
+ QUnit.test('should not error on DOM elements', function(assert) {
+ assert.expect(1);
- object2[symbol1] = { 'a': 1 };
- assert.strictEqual(_.isEqual(object1, object2), false);
+ if (document) {
+ var element1 = document.createElement('div'),
+ element2 = element1.cloneNode(true);
- delete object2[symbol1];
- object2[Symbol('a')] = { 'a': { 'b': 2 } };
- assert.strictEqual(_.isEqual(object1, object2), false);
+ try {
+ assert.strictEqual(_.isEqual(element1, element2), false);
+ } catch (e) {
+ assert.ok(false, e.message);
+ }
}
else {
- skipAssert(assert, 3);
+ skipAssert(assert);
}
});
}
});
- QUnit.test('should work as an iteratee for `_.every`', function(assert) {
- assert.expect(1);
-
- var actual = lodashStable.every([1, 1, 1], lodashStable.partial(_.isEqual, 1));
- assert.ok(actual);
- });
-
- QUnit.test('should not error on DOM elements', function(assert) {
- assert.expect(1);
-
- if (document) {
- var element1 = document.createElement('div'),
- element2 = element1.cloneNode(true);
-
- try {
- assert.strictEqual(_.isEqual(element1, element2), false);
- } catch (e) {
- assert.ok(false, e.message);
- }
- }
- else {
- skipAssert(assert);
- }
- });
-
- QUnit.test('should return `true` for like-objects from different documents', function(assert) {
- assert.expect(4);
-
- if (realm.object) {
- assert.strictEqual(_.isEqual([1], realm.array), true);
- assert.strictEqual(_.isEqual([2], realm.array), false);
- assert.strictEqual(_.isEqual({ 'a': 1 }, realm.object), true);
- assert.strictEqual(_.isEqual({ 'a': 2 }, realm.object), false);
- }
- else {
- skipAssert(assert, 4);
- }
- });
-
- QUnit.test('should return `false` for objects with custom `toString` methods', function(assert) {
- assert.expect(1);
-
- var primitive,
- object = { 'toString': function() { return primitive; } },
- values = [true, null, 1, 'a', undefined],
- expected = lodashStable.map(values, stubFalse);
-
- var actual = lodashStable.map(values, function(value) {
- primitive = value;
- return _.isEqual(object, value);
- });
-
- assert.deepEqual(actual, expected);
- });
-
QUnit.test('should return an unwrapped value when implicitly chaining', function(assert) {
assert.expect(1);
QUnit.module('lodash.isEqualWith');
(function() {
- QUnit.test('should provide correct `customizer` arguments', function(assert) {
+ QUnit.test('should provide the correct `customizer` arguments', function(assert) {
assert.expect(1);
var argsList = [],
[object1.a, object2.a, 'a', object1, object2],
[object1.a[0], object2.a[0], 0, object1.a, object2.a],
[object1.a[1], object2.a[1], 1, object1.a, object2.a],
- [object1.b, object2.b, 'b', object1.b, object2.b]
+ [object1.b, object2.b, 'b', object1.b, object2.b],
+ [object1.b.a, object2.b.a, 'a', object1.b, object2.b],
+ [object1.b.a[0], object2.b.a[0], 0, object1.b.a, object2.b.a],
+ [object1.b.a[1], object2.b.a[1], 1, object1.b.a, object2.b.a],
+ [object1.b.b, object2.b.b, 'b', object1.b.b, object2.b.b]
];
_.isEqualWith(object1, object2, function(assert) {
assert.deepEqual(argsList, expected);
});
- QUnit.test('should handle comparisons when `customizer` returns `undefined`', function(assert) {
+ QUnit.test('should handle comparisons if `customizer` returns `undefined`', function(assert) {
assert.expect(3);
assert.strictEqual(_.isEqualWith('a', 'a', noop), true);
assert.strictEqual(_.isEqualWith({ '0': 'a' }, { '0': 'a' }, noop), true);
});
- QUnit.test('should not handle comparisons when `customizer` returns `true`', function(assert) {
+ QUnit.test('should not handle comparisons if `customizer` returns `true`', function(assert) {
assert.expect(3);
var customizer = function(value) {
assert.strictEqual(_.isEqualWith({ '0': 'a' }, { '0': 'b' }, customizer), true);
});
- QUnit.test('should not handle comparisons when `customizer` returns `false`', function(assert) {
+ QUnit.test('should not handle comparisons if `customizer` returns `false`', function(assert) {
assert.expect(3);
var customizer = function(value) {
assert.strictEqual(_.isEqualWith({ '0': 'a' }, { '0': 'a' }, customizer), false);
});
- QUnit.test('should return a boolean value even when `customizer` does not', function(assert) {
+ QUnit.test('should return a boolean value even if `customizer` does not', function(assert) {
assert.expect(2);
- var actual = _.isEqualWith('a', 'b', stubC);
+ var actual = _.isEqualWith('a', 'b', alwaysC);
assert.strictEqual(actual, true);
var values = _.without(falsey, undefined),
- expected = lodashStable.map(values, stubFalse);
+ expected = lodashStable.map(values, alwaysFalse);
actual = [];
lodashStable.each(values, function(value) {
lodashStable.each([[map1, map2], [set1, set2]], function(pair, index) {
if (pair[0]) {
var argsList = [],
- array = lodashStable.toArray(pair[0]);
+ array = _.toArray(pair[0]);
var expected = [
[pair[0], pair[1]],
QUnit.module('lodash.isError');
(function() {
+ var args = arguments;
+
QUnit.test('should return `true` for error objects', function(assert) {
assert.expect(1);
- var expected = lodashStable.map(errors, stubTrue);
+ var expected = lodashStable.map(errors, alwaysTrue);
var actual = lodashStable.map(errors, function(error) {
return _.isError(error) === true;
QUnit.test('should return `false` for non error objects', function(assert) {
assert.expect(12);
- var expected = lodashStable.map(falsey, stubFalse);
+ var expected = lodashStable.map(falsey, alwaysFalse);
var actual = lodashStable.map(falsey, function(value, index) {
return index ? _.isError(value) : _.isError();
assert.strictEqual(_.isError(symbol), false);
});
- QUnit.test('should return `false` for plain objects', function(assert) {
- assert.expect(1);
-
- assert.strictEqual(_.isError({ 'name': 'Error', 'message': '' }), false);
- });
-
QUnit.test('should work with an error object from another realm', function(assert) {
assert.expect(1);
if (realm.errors) {
- var expected = lodashStable.map(realm.errors, stubTrue);
+ var expected = lodashStable.map(realm.errors, alwaysTrue);
var actual = lodashStable.map(realm.errors, function(error) {
return _.isError(error) === true;
skipAssert(assert);
}
});
- }());
+ }(1, 2, 3));
/*--------------------------------------------------------------------------*/
QUnit.module('lodash.isFinite');
(function() {
+ var args = arguments;
+
QUnit.test('should return `true` for finite values', function(assert) {
assert.expect(1);
var values = [0, 1, 3.14, -1],
- expected = lodashStable.map(values, stubTrue),
+ expected = lodashStable.map(values, alwaysTrue),
actual = lodashStable.map(values, _.isFinite);
assert.deepEqual(actual, expected);
assert.expect(1);
var values = [NaN, Infinity, -Infinity, Object(1)],
- expected = lodashStable.map(values, stubFalse),
+ expected = lodashStable.map(values, alwaysFalse),
actual = lodashStable.map(values, _.isFinite);
assert.deepEqual(actual, expected);
assert.expect(10);
var values = [undefined, [], true, '', ' ', '2px'],
- expected = lodashStable.map(values, stubFalse),
+ expected = lodashStable.map(values, alwaysFalse),
actual = lodashStable.map(values, _.isFinite);
assert.deepEqual(actual, expected);
assert.expect(1);
var values = ['2', '0', '08'],
- expected = lodashStable.map(values, stubFalse),
+ expected = lodashStable.map(values, alwaysFalse),
actual = lodashStable.map(values, _.isFinite);
assert.deepEqual(actual, expected);
});
- }());
+ }(1, 2, 3));
/*--------------------------------------------------------------------------*/
QUnit.module('lodash.isFunction');
(function() {
+ var args = arguments;
+
QUnit.test('should return `true` for functions', function(assert) {
assert.expect(2);
assert.strictEqual(_.isFunction(slice), true);
});
- QUnit.test('should return `true` for async functions', function(assert) {
- assert.expect(1);
-
- assert.strictEqual(_.isFunction(asyncFunc), typeof asyncFunc == 'function');
- });
-
QUnit.test('should return `true` for generator functions', function(assert) {
assert.expect(1);
- assert.strictEqual(_.isFunction(genFunc), typeof genFunc == 'function');
- });
-
- QUnit.test('should return `true` for the `Proxy` constructor', function(assert) {
- assert.expect(1);
-
- if (Proxy) {
- assert.strictEqual(_.isFunction(Proxy), true);
- }
- else {
- skipAssert(assert);
- }
+ assert.strictEqual(_.isFunction(generator), typeof generator == 'function');
});
QUnit.test('should return `true` for array view constructors', function(assert) {
QUnit.test('should return `false` for non-functions', function(assert) {
assert.expect(12);
- var expected = lodashStable.map(falsey, stubFalse);
+ var expected = lodashStable.map(falsey, alwaysFalse);
var actual = lodashStable.map(falsey, function(value, index) {
return index ? _.isFunction(value) : _.isFunction();
if (document) {
assert.strictEqual(_.isFunction(document.getElementsByTagName('body')), false);
- }
- else {
+ } else {
skipAssert(assert);
}
});
+ QUnit.test('should work with host objects in IE 8 document mode (test in IE 11)', function(assert) {
+ assert.expect(2);
+
+ // Trigger a Chakra JIT bug.
+ // See https://github.com/jashkenas/underscore/issues/1621.
+ lodashStable.each([body, xml], function(object) {
+ if (object) {
+ lodashStable.times(100, _.isFunction);
+ assert.strictEqual(_.isFunction(object), false);
+ }
+ else {
+ skipAssert(assert);
+ }
+ });
+ });
+
QUnit.test('should work with a function from another realm', function(assert) {
assert.expect(1);
skipAssert(assert);
}
});
- }());
+ }(1, 2, 3));
/*--------------------------------------------------------------------------*/
QUnit.module('isInteger methods');
lodashStable.each(['isInteger', 'isSafeInteger'], function(methodName) {
- var func = _[methodName],
+ var args = arguments,
+ func = _[methodName],
isSafe = methodName == 'isSafeInteger';
QUnit.test('`_.' + methodName + '` should return `true` for integer values', function(assert) {
assert.expect(2);
var values = [-1, 0, 1],
- expected = lodashStable.map(values, stubTrue);
+ expected = lodashStable.map(values, alwaysTrue);
var actual = lodashStable.map(values, function(value) {
return func(value);
assert.expect(1);
var values = [NaN, Infinity, -Infinity, Object(1), 3.14],
- expected = lodashStable.map(values, stubFalse);
+ expected = lodashStable.map(values, alwaysFalse);
var actual = lodashStable.map(values, function(value) {
return func(value);
assert.expect(1);
var values = [0, 3, MAX_SAFE_INTEGER],
- expected = lodashStable.map(values, stubTrue),
+ expected = lodashStable.map(values, alwaysTrue),
actual = lodashStable.map(values, _.isLength);
assert.deepEqual(actual, expected);
assert.expect(1);
var values = [-1, '1', 1.1, MAX_SAFE_INTEGER + 1],
- expected = lodashStable.map(values, stubFalse),
+ expected = lodashStable.map(values, alwaysFalse),
actual = lodashStable.map(values, _.isLength);
assert.deepEqual(actual, expected);
QUnit.module('lodash.isMap');
(function() {
+ var args = arguments;
+
QUnit.test('should return `true` for maps', function(assert) {
assert.expect(1);
QUnit.test('should return `false` for non-maps', function(assert) {
assert.expect(14);
- var expected = lodashStable.map(falsey, stubFalse);
+ var expected = lodashStable.map(falsey, alwaysFalse);
var actual = lodashStable.map(falsey, function(value, index) {
return index ? _.isMap(value) : _.isMap();
assert.expect(1);
var values = [false, true],
- expected = lodashStable.map(values, stubFalse);
+ expected = lodashStable.map(values, alwaysFalse);
var actual = lodashStable.map(values, function(value) {
return _.isMap({ 'constructor': value });
skipAssert(assert);
}
});
+ }(1, 2, 3));
+
+ /*--------------------------------------------------------------------------*/
+
+ QUnit.module('lodash.isMatch');
+
+ (function() {
+ QUnit.test('should perform a deep comparison between `object` and `source`', function(assert) {
+ assert.expect(5);
+
+ var object = { 'a': 1, 'b': 2, 'c': 3 };
+ assert.strictEqual(_.isMatch(object, { 'a': 1 }), true);
+ assert.strictEqual(_.isMatch(object, { 'b': 1 }), false);
+ assert.strictEqual(_.isMatch(object, { 'a': 1, 'c': 3 }), true);
+ assert.strictEqual(_.isMatch(object, { 'c': 3, 'd': 4 }), false);
+
+ object = { 'a': { 'b': { 'c': 1, 'd': 2 }, 'e': 3 }, 'f': 4 };
+ assert.strictEqual(_.isMatch(object, { 'a': { 'b': { 'c': 1 } } }), true);
+ });
+
+ QUnit.test('should match inherited string keyed `object` properties', function(assert) {
+ assert.expect(1);
+
+ function Foo() {
+ this.a = 1;
+ }
+ Foo.prototype.b = 2;
+
+ assert.strictEqual(_.isMatch({ 'a': new Foo }, { 'a': { 'b': 2 } }), true);
+ });
+
+ QUnit.test('should not match by inherited `source` properties', function(assert) {
+ assert.expect(1);
+
+ function Foo() {
+ this.a = 1;
+ }
+ Foo.prototype.b = 2;
+
+ var objects = [{ 'a': 1 }, { 'a': 1, 'b': 2 }],
+ source = new Foo,
+ expected = lodashStable.map(objects, alwaysTrue);
+
+ var actual = lodashStable.map(objects, function(object) {
+ return _.isMatch(object, source);
+ });
+
+ assert.deepEqual(actual, expected);
+ });
+
+ QUnit.test('should compare a variety of `source` property values', function(assert) {
+ assert.expect(2);
+
+ var object1 = { 'a': false, 'b': true, 'c': '3', 'd': 4, 'e': [5], 'f': { 'g': 6 } },
+ object2 = { 'a': 0, 'b': 1, 'c': 3, 'd': '4', 'e': ['5'], 'f': { 'g': '6' } };
+
+ assert.strictEqual(_.isMatch(object1, object1), true);
+ assert.strictEqual(_.isMatch(object1, object2), false);
+ });
+
+ QUnit.test('should match `-0` as `0`', function(assert) {
+ assert.expect(2);
+
+ var object1 = { 'a': -0 },
+ object2 = { 'a': 0 };
+
+ assert.strictEqual(_.isMatch(object1, object2), true);
+ assert.strictEqual(_.isMatch(object2, object1), true);
+ });
+
+ QUnit.test('should compare functions by reference', function(assert) {
+ assert.expect(3);
+
+ var object1 = { 'a': lodashStable.noop },
+ object2 = { 'a': noop },
+ object3 = { 'a': {} };
+
+ assert.strictEqual(_.isMatch(object1, object1), true);
+ assert.strictEqual(_.isMatch(object2, object1), false);
+ assert.strictEqual(_.isMatch(object3, object1), false);
+ });
+
+ QUnit.test('should work with a function for `object`', function(assert) {
+ assert.expect(1);
+
+ function Foo() {}
+ Foo.a = { 'b': 1, 'c': 2 };
+
+ assert.strictEqual(_.isMatch(Foo, { 'a': { 'b': 1 } }), true);
+ });
+
+ QUnit.test('should work with a function for `source`', function(assert) {
+ assert.expect(1);
+
+ function Foo() {}
+ Foo.a = 1;
+ Foo.b = function() {};
+ Foo.c = 3;
+
+ var objects = [{ 'a': 1 }, { 'a': 1, 'b': Foo.b, 'c': 3 }];
+
+ var actual = lodashStable.map(objects, function(object) {
+ return _.isMatch(object, Foo);
+ });
+
+ assert.deepEqual(actual, [false, true]);
+ });
+
+ QUnit.test('should work with a non-plain `object`', function(assert) {
+ assert.expect(1);
+
+ function Foo(object) { lodashStable.assign(this, object); }
+
+ var object = new Foo({ 'a': new Foo({ 'b': 1, 'c': 2 }) });
+ assert.strictEqual(_.isMatch(object, { 'a': { 'b': 1 } }), true);
+ });
+
+ QUnit.test('should partial match arrays', function(assert) {
+ assert.expect(3);
+
+ var objects = [{ 'a': ['b'] }, { 'a': ['c', 'd'] }],
+ source = { 'a': ['d'] },
+ predicate = function(object) { return _.isMatch(object, source); },
+ actual = lodashStable.filter(objects, predicate);
+
+ assert.deepEqual(actual, [objects[1]]);
+
+ source = { 'a': ['b', 'd'] };
+ actual = lodashStable.filter(objects, predicate);
+
+ assert.deepEqual(actual, []);
+
+ source = { 'a': ['d', 'b'] };
+ actual = lodashStable.filter(objects, predicate);
+ assert.deepEqual(actual, []);
+ });
+
+ QUnit.test('should partial match arrays of objects', function(assert) {
+ assert.expect(1);
+
+ var source = { 'a': [{ 'b': 1 }, { 'b': 4, 'c': 5 }] };
+
+ var objects = [
+ { 'a': [{ 'b': 1, 'c': 2 }, { 'b': 4, 'c': 5, 'd': 6 }] },
+ { 'a': [{ 'b': 1, 'c': 2 }, { 'b': 4, 'c': 6, 'd': 7 }] }
+ ];
+
+ var actual = lodashStable.filter(objects, function(object) {
+ return _.isMatch(object, source);
+ });
+
+ assert.deepEqual(actual, [objects[0]]);
+ });
+
+ QUnit.test('should partial match maps', function(assert) {
+ assert.expect(3);
+
+ if (Map) {
+ var objects = [{ 'a': new Map }, { 'a': new Map }];
+ objects[0].a.set('a', 1);
+ objects[1].a.set('a', 1);
+ objects[1].a.set('b', 2);
+
+ var map = new Map;
+ map.set('b', 2);
+
+ var source = { 'a': map },
+ predicate = function(object) { return _.isMatch(object, source); },
+ actual = lodashStable.filter(objects, predicate);
+
+ assert.deepEqual(actual, [objects[1]]);
+
+ map['delete']('b');
+ actual = lodashStable.filter(objects, predicate);
+
+ assert.deepEqual(actual, objects);
+
+ map.set('c', 3);
+ actual = lodashStable.filter(objects, predicate);
+
+ assert.deepEqual(actual, []);
+ }
+ else {
+ skipAssert(assert, 3);
+ }
+ });
+
+ QUnit.test('should partial match sets', function(assert) {
+ assert.expect(3);
+
+ if (Set) {
+ var objects = [{ 'a': new Set }, { 'a': new Set }];
+ objects[0].a.add(1);
+ objects[1].a.add(1);
+ objects[1].a.add(2);
+
+ var set = new Set;
+ set.add(2);
+
+ var source = { 'a': set },
+ predicate = function(object) { return _.isMatch(object, source); },
+ actual = lodashStable.filter(objects, predicate);
+
+ assert.deepEqual(actual, [objects[1]]);
+
+ set['delete'](2);
+ actual = lodashStable.filter(objects, predicate);
+
+ assert.deepEqual(actual, objects);
+
+ set.add(3);
+ actual = lodashStable.filter(objects, predicate);
+
+ assert.deepEqual(actual, []);
+ }
+ else {
+ skipAssert(assert, 3);
+ }
+ });
+
+ QUnit.test('should match `undefined` values', function(assert) {
+ assert.expect(3);
+
+ var objects = [{ 'a': 1 }, { 'a': 1, 'b': 1 }, { 'a': 1, 'b': undefined }],
+ source = { 'b': undefined },
+ predicate = function(object) { return _.isMatch(object, source); },
+ actual = lodashStable.map(objects, predicate),
+ expected = [false, false, true];
+
+ assert.deepEqual(actual, expected);
+
+ source = { 'a': 1, 'b': undefined };
+ actual = lodashStable.map(objects, predicate);
+
+ assert.deepEqual(actual, expected);
+
+ objects = [{ 'a': { 'b': 1 } }, { 'a': { 'b': 1, 'c': 1 } }, { 'a': { 'b': 1, 'c': undefined } }];
+ source = { 'a': { 'c': undefined } };
+ actual = lodashStable.map(objects, predicate);
+
+ assert.deepEqual(actual, expected);
+ });
+
+ QUnit.test('should match `undefined` values on primitives', function(assert) {
+ assert.expect(3);
+
+ numberProto.a = 1;
+ numberProto.b = undefined;
+
+ try {
+ assert.strictEqual(_.isMatch(1, { 'b': undefined }), true);
+ } catch (e) {
+ assert.ok(false, e.message);
+ }
+ try {
+ assert.strictEqual(_.isMatch(1, { 'a': 1, 'b': undefined }), true);
+ } catch (e) {
+ assert.ok(false, e.message);
+ }
+ numberProto.a = { 'b': 1, 'c': undefined };
+ try {
+ assert.strictEqual(_.isMatch(1, { 'a': { 'c': undefined } }), true);
+ } catch (e) {
+ assert.ok(false, e.message);
+ }
+ delete numberProto.a;
+ delete numberProto.b;
+ });
+
+ QUnit.test('should return `false` when `object` is nullish', function(assert) {
+ assert.expect(1);
+
+ var values = [null, undefined],
+ expected = lodashStable.map(values, alwaysFalse),
+ source = { 'a': 1 };
+
+ var actual = lodashStable.map(values, function(value) {
+ try {
+ return _.isMatch(value, source);
+ } catch (e) {}
+ });
+
+ assert.deepEqual(actual, expected);
+ });
+
+ QUnit.test('should return `true` when comparing an empty `source` to a nullish `object`', function(assert) {
+ assert.expect(1);
+
+ var values = [null, undefined],
+ expected = lodashStable.map(values, alwaysTrue),
+ source = {};
+
+ var actual = lodashStable.map(values, function(value) {
+ try {
+ return _.isMatch(value, source);
+ } catch (e) {}
+ });
+
+ assert.deepEqual(actual, expected);
+ });
+
+ QUnit.test('should return `true` when comparing an empty `source`', function(assert) {
+ assert.expect(1);
+
+ var object = { 'a': 1 },
+ expected = lodashStable.map(empties, alwaysTrue);
+
+ var actual = lodashStable.map(empties, function(value) {
+ return _.isMatch(object, value);
+ });
+
+ assert.deepEqual(actual, expected);
+ });
+
+ QUnit.test('should return `true` when comparing a `source` of empty arrays and objects', function(assert) {
+ assert.expect(1);
+
+ var objects = [{ 'a': [1], 'b': { 'c': 1 } }, { 'a': [2, 3], 'b': { 'd': 2 } }],
+ source = { 'a': [], 'b': {} };
+
+ var actual = lodashStable.filter(objects, function(object) {
+ return _.isMatch(object, source);
+ });
+
+ assert.deepEqual(actual, objects);
+ });
}());
/*--------------------------------------------------------------------------*/
QUnit.module('lodash.isMatchWith');
(function() {
- QUnit.test('should provide correct `customizer` arguments', function(assert) {
+ QUnit.test('should provide the correct `customizer` arguments', function(assert) {
assert.expect(1);
var argsList = [],
[object1.b.a, object2.b.a, 'a', object1.b, object2.b],
[object1.b.a[0], object2.b.a[0], 0, object1.b.a, object2.b.a],
[object1.b.a[1], object2.b.a[1], 1, object1.b.a, object2.b.a],
- [object1.b.b, object2.b.b, 'b', object1.b, object2.b]
+ [object1.b.b, object2.b.b, 'b', object1.b, object2.b],
+ [object1.b.b.a, object2.b.b.a, 'a', object1.b.b, object2.b.b],
+ [object1.b.b.a[0], object2.b.b.a[0], 0, object1.b.b.a, object2.b.b.a],
+ [object1.b.b.a[1], object2.b.b.a[1], 1, object1.b.b.a, object2.b.b.a],
+ [object1.b.b.b, object2.b.b.b, 'b', object1.b.b, object2.b.b]
];
_.isMatchWith(object1, object2, function(assert) {
assert.deepEqual(argsList, expected);
});
- QUnit.test('should handle comparisons when `customizer` returns `undefined`', function(assert) {
+ QUnit.test('should handle comparisons if `customizer` returns `undefined`', function(assert) {
assert.expect(1);
assert.strictEqual(_.isMatchWith({ 'a': 1 }, { 'a': 1 }, noop), true);
});
- QUnit.test('should not handle comparisons when `customizer` returns `true`', function(assert) {
+ QUnit.test('should not handle comparisons if `customizer` returns `true`', function(assert) {
assert.expect(2);
var customizer = function(value) {
assert.strictEqual(_.isMatchWith({ '0': 'a' }, { '0': 'b' }, customizer), true);
});
- QUnit.test('should not handle comparisons when `customizer` returns `false`', function(assert) {
+ QUnit.test('should not handle comparisons if `customizer` returns `false`', function(assert) {
assert.expect(2);
var customizer = function(value) {
assert.strictEqual(_.isMatchWith({ '0': 'a' }, { '0': 'a' }, customizer), false);
});
- QUnit.test('should return a boolean value even when `customizer` does not', function(assert) {
+ QUnit.test('should return a boolean value even if `customizer` does not', function(assert) {
assert.expect(2);
var object = { 'a': 1 },
- actual = _.isMatchWith(object, { 'a': 1 }, stubA);
+ actual = _.isMatchWith(object, { 'a': 1 }, alwaysA);
assert.strictEqual(actual, true);
- var expected = lodashStable.map(falsey, stubFalse);
+ var expected = lodashStable.map(falsey, alwaysFalse);
actual = [];
lodashStable.each(falsey, function(value) {
assert.deepEqual(actual, expected);
});
- QUnit.test('should provide `stack` to `customizer`', function(assert) {
- assert.expect(1);
-
- var actual;
-
- _.isMatchWith({ 'a': 1 }, { 'a': 1 }, function() {
- actual = _.last(arguments);
- });
-
- assert.ok(isNpm
- ? actual.constructor.name == 'Stack'
- : actual instanceof mapCaches.Stack
- );
- });
-
QUnit.test('should ensure `customizer` is a function', function(assert) {
assert.expect(1);
lodashStable.each([[map1, map2], [set1, set2]], function(pair, index) {
if (pair[0]) {
var argsList = [],
- array = lodashStable.toArray(pair[0]),
+ array = _.toArray(pair[0]),
object1 = { 'a': pair[0] },
object2 = { 'a': pair[1] };
QUnit.module('lodash.isNaN');
(function() {
+ var args = arguments;
+
QUnit.test('should return `true` for NaNs', function(assert) {
assert.expect(2);
skipAssert(assert);
}
});
- }());
+ }(1, 2, 3));
/*--------------------------------------------------------------------------*/
QUnit.module('lodash.isNative');
(function() {
+ var args = arguments;
+
QUnit.test('should return `true` for native methods', function(assert) {
assert.expect(1);
QUnit.test('should return `false` for non-native methods', function(assert) {
assert.expect(12);
- var expected = lodashStable.map(falsey, stubFalse);
+ var expected = lodashStable.map(falsey, alwaysFalse);
var actual = lodashStable.map(falsey, function(value, index) {
return index ? _.isNative(value) : _.isNative();
skipAssert(assert);
}
});
-
- QUnit.test('should throw an error if core-js is detected', function(assert) {
- assert.expect(1);
-
- if (!isModularize) {
- var lodash = _.runInContext({
- '__core-js_shared__': {}
- });
-
- assert.raises(function() { lodash.isNative(noop); });
- }
- else {
- skipAssert(assert);
- }
- });
-
- QUnit.test('should detect methods masquerading as native (test in Node.js)', function(assert) {
- assert.expect(2);
-
- if (!amd && _._baseEach) {
- var path = require('path'),
- basePath = path.dirname(filePath),
- uid = 'e0gvgyrad1jor',
- coreKey = '__core-js_shared__',
- fakeSrcKey = 'Symbol(src)_1.' + uid;
-
- root[coreKey] = { 'keys': { 'IE_PROTO': 'Symbol(IE_PROTO)_3.' + uid } };
- emptyObject(require.cache);
-
- var baseIsNative = interopRequire(path.join(basePath, '_baseIsNative'));
- assert.strictEqual(baseIsNative(slice), true);
-
- slice[fakeSrcKey] = slice + '';
- assert.strictEqual(baseIsNative(slice), false);
-
- delete slice[fakeSrcKey];
- delete root[coreKey];
- }
- else {
- skipAssert(assert, 2);
- }
- });
- }());
+ }(1, 2, 3));
/*--------------------------------------------------------------------------*/
QUnit.module('lodash.isNil');
(function() {
+ var args = arguments;
+
QUnit.test('should return `true` for nullish values', function(assert) {
assert.expect(3);
}
});
- QUnit.test('should work with nils from another realm', function(assert) {
+ QUnit.test('should work with nulls from another realm', function(assert) {
assert.expect(2);
if (realm.object) {
skipAssert(assert, 2);
}
});
- }());
+ }(1, 2, 3));
/*--------------------------------------------------------------------------*/
QUnit.module('lodash.isNull');
(function() {
+ var args = arguments;
+
QUnit.test('should return `true` for `null` values', function(assert) {
assert.expect(1);
skipAssert(assert);
}
});
- }());
+ }(1, 2, 3));
/*--------------------------------------------------------------------------*/
QUnit.module('lodash.isNumber');
(function() {
+ var args = arguments;
+
QUnit.test('should return `true` for numbers', function(assert) {
assert.expect(3);
skipAssert(assert);
}
});
- }());
+
+ QUnit.test('should avoid `[xpconnect wrapped native prototype]` in Firefox', function(assert) {
+ assert.expect(1);
+
+ assert.strictEqual(_.isNumber(+'2'), true);
+ });
+ }(1, 2, 3));
/*--------------------------------------------------------------------------*/
QUnit.module('lodash.isObject');
(function() {
+ var args = arguments;
+
QUnit.test('should return `true` for objects', function(assert) {
assert.expect(13);
assert.expect(1);
var values = falsey.concat(true, 1, 'a', symbol),
- expected = lodashStable.map(values, stubFalse);
+ expected = lodashStable.map(values, alwaysFalse);
var actual = lodashStable.map(values, function(value, index) {
return index ? _.isObject(value) : _.isObject();
skipAssert(assert, 7);
}
});
- }());
+
+ QUnit.test('should avoid V8 bug #2291 (test in Chrome 19-20)', function(assert) {
+ assert.expect(1);
+
+ // Trigger a V8 JIT bug.
+ // See https://code.google.com/p/v8/issues/detail?id=2291.
+ var object = {};
+
+ // First, have a comparison statement.
+ object == object;
+
+ // Then perform the check with `object`.
+ _.isObject(object);
+
+ assert.strictEqual(_.isObject('a'), false);
+ });
+ }(1, 2, 3));
/*--------------------------------------------------------------------------*/
QUnit.module('lodash.isObjectLike');
(function() {
+ var args = arguments;
+
QUnit.test('should return `true` for objects', function(assert) {
assert.expect(9);
assert.expect(1);
var values = falsey.concat(true, _, slice, 1, 'a', symbol),
- expected = lodashStable.map(values, stubFalse);
+ expected = lodashStable.map(values, alwaysFalse);
var actual = lodashStable.map(values, function(value, index) {
return index ? _.isObjectLike(value) : _.isObjectLike();
skipAssert(assert, 6);
}
});
- }());
+ }(1, 2, 3));
/*--------------------------------------------------------------------------*/
QUnit.test('should return `true` for objects with a `[[Prototype]]` of `null`', function(assert) {
assert.expect(2);
- var object = create(null);
- assert.strictEqual(_.isPlainObject(object), true);
+ if (create) {
+ var object = create(null);
+ assert.strictEqual(_.isPlainObject(object), true);
- object.constructor = objectProto.constructor;
- assert.strictEqual(_.isPlainObject(object), true);
+ object.constructor = objectProto.constructor;
+ assert.strictEqual(_.isPlainObject(object), true);
+ }
+ else {
+ skipAssert(assert, 2);
+ }
});
- QUnit.test('should return `true` for objects with a `valueOf` property', function(assert) {
- assert.expect(1);
+ QUnit.test('should return `true` for plain objects with a custom `valueOf` property', function(assert) {
+ assert.expect(2);
assert.strictEqual(_.isPlainObject({ 'valueOf': 0 }), true);
- });
-
- QUnit.test('should return `true` for objects with a writable `Symbol.toStringTag` property', function(assert) {
- assert.expect(1);
- if (Symbol && Symbol.toStringTag) {
- var object = {};
- object[Symbol.toStringTag] = 'X';
+ if (element) {
+ var valueOf = element.valueOf;
+ element.valueOf = 0;
- assert.deepEqual(_.isPlainObject(object), true);
+ assert.strictEqual(_.isPlainObject(element), false);
+ element.valueOf = valueOf;
}
else {
skipAssert(assert);
QUnit.test('should return `false` for objects with a custom `[[Prototype]]`', function(assert) {
assert.expect(1);
- var object = create({ 'a': 1 });
- assert.strictEqual(_.isPlainObject(object), false);
+ if (create) {
+ var object = create({ 'a': 1 });
+ assert.strictEqual(_.isPlainObject(object), false);
+ }
+ else {
+ skipAssert(assert);
+ }
});
QUnit.test('should return `false` for DOM elements', function(assert) {
}
});
- QUnit.test('should return `false` for non-Object objects', function(assert) {
+ QUnit.test('should return `false` for Object objects without a `toStringTag` of "Object"', function(assert) {
assert.expect(3);
assert.strictEqual(_.isPlainObject(arguments), false);
QUnit.test('should return `false` for non-objects', function(assert) {
assert.expect(4);
- var expected = lodashStable.map(falsey, stubFalse);
+ var expected = lodashStable.map(falsey, alwaysFalse);
var actual = lodashStable.map(falsey, function(value, index) {
return index ? _.isPlainObject(value) : _.isPlainObject();
assert.strictEqual(_.isPlainObject(symbol), false);
});
- QUnit.test('should return `false` for objects with a read-only `Symbol.toStringTag` property', function(assert) {
- assert.expect(1);
-
- if (Symbol && Symbol.toStringTag) {
- var object = {};
- defineProperty(object, Symbol.toStringTag, {
- 'configurable': true,
- 'enumerable': false,
- 'writable': false,
- 'value': 'X'
- });
-
- assert.deepEqual(_.isPlainObject(object), false);
- }
- else {
- skipAssert(assert);
- }
- });
-
- QUnit.test('should not mutate `value`', function(assert) {
- assert.expect(2);
-
- if (Symbol && Symbol.toStringTag) {
- var proto = {};
- proto[Symbol.toStringTag] = undefined;
- var object = create(proto);
-
- assert.strictEqual(_.isPlainObject(object), false);
- assert.notOk(lodashStable.has(object, Symbol.toStringTag));
- }
- else {
- skipAssert(assert, 2);
- }
- });
-
QUnit.test('should work with objects from another realm', function(assert) {
assert.expect(1);
QUnit.module('lodash.isRegExp');
(function() {
+ var args = arguments;
+
QUnit.test('should return `true` for regexes', function(assert) {
assert.expect(2);
QUnit.test('should return `false` for non-regexes', function(assert) {
assert.expect(12);
- var expected = lodashStable.map(falsey, stubFalse);
+ var expected = lodashStable.map(falsey, alwaysFalse);
var actual = lodashStable.map(falsey, function(value, index) {
return index ? _.isRegExp(value) : _.isRegExp();
skipAssert(assert);
}
});
- }());
+ }(1, 2, 3));
/*--------------------------------------------------------------------------*/
QUnit.module('lodash.isSet');
(function() {
+ var args = arguments;
+
QUnit.test('should return `true` for sets', function(assert) {
assert.expect(1);
QUnit.test('should return `false` for non-sets', function(assert) {
assert.expect(14);
- var expected = lodashStable.map(falsey, stubFalse);
+ var expected = lodashStable.map(falsey, alwaysFalse);
var actual = lodashStable.map(falsey, function(value, index) {
return index ? _.isSet(value) : _.isSet();
assert.expect(1);
var values = [false, true],
- expected = lodashStable.map(values, stubFalse);
+ expected = lodashStable.map(values, alwaysFalse);
var actual = lodashStable.map(values, function(value) {
return _.isSet({ 'constructor': value });
skipAssert(assert);
}
});
- }());
+ }(1, 2, 3));
/*--------------------------------------------------------------------------*/
QUnit.module('lodash.isString');
(function() {
+ var args = arguments;
+
QUnit.test('should return `true` for strings', function(assert) {
assert.expect(2);
skipAssert(assert);
}
});
- }());
+ }(1, 2, 3));
/*--------------------------------------------------------------------------*/
QUnit.module('lodash.isSymbol');
(function() {
+ var args = arguments;
+
QUnit.test('should return `true` for symbols', function(assert) {
assert.expect(2);
QUnit.test('should return `false` for non-symbols', function(assert) {
assert.expect(12);
- var expected = lodashStable.map(falsey, stubFalse);
+ var expected = lodashStable.map(falsey, alwaysFalse);
var actual = lodashStable.map(falsey, function(value, index) {
return index ? _.isSymbol(value) : _.isSymbol();
skipAssert(assert);
}
});
- }());
+ }(1, 2, 3));
/*--------------------------------------------------------------------------*/
QUnit.module('lodash.isTypedArray');
(function() {
+ var args = arguments;
+
QUnit.test('should return `true` for typed arrays', function(assert) {
assert.expect(1);
QUnit.test('should return `false` for non typed arrays', function(assert) {
assert.expect(13);
- var expected = lodashStable.map(falsey, stubFalse);
+ var expected = lodashStable.map(falsey, alwaysFalse);
var actual = lodashStable.map(falsey, function(value, index) {
return index ? _.isTypedArray(value) : _.isTypedArray();
skipAssert(assert);
}
});
- }());
+ }(1, 2, 3));
/*--------------------------------------------------------------------------*/
QUnit.module('lodash.isUndefined');
(function() {
+ var args = arguments;
+
QUnit.test('should return `true` for `undefined` values', function(assert) {
assert.expect(2);
skipAssert(assert);
}
});
- }());
+ }(1, 2, 3));
/*--------------------------------------------------------------------------*/
QUnit.module('lodash.isWeakMap');
(function() {
+ var args = arguments;
+
QUnit.test('should return `true` for weak maps', function(assert) {
assert.expect(1);
QUnit.test('should return `false` for non weak maps', function(assert) {
assert.expect(14);
- var expected = lodashStable.map(falsey, stubFalse);
+ var expected = lodashStable.map(falsey, alwaysFalse);
var actual = lodashStable.map(falsey, function(value, index) {
return index ? _.isWeakMap(value) : _.isWeakMap();
assert.expect(1);
var values = [false, true],
- expected = lodashStable.map(values, stubFalse);
+ expected = lodashStable.map(values, alwaysFalse);
var actual = lodashStable.map(values, function(value) {
return _.isWeakMap({ 'constructor': value });
skipAssert(assert);
}
});
- }());
+ }(1, 2, 3));
/*--------------------------------------------------------------------------*/
QUnit.module('lodash.isWeakSet');
(function() {
+ var args = arguments;
+
QUnit.test('should return `true` for weak sets', function(assert) {
assert.expect(1);
QUnit.test('should return `false` for non weak sets', function(assert) {
assert.expect(14);
- var expected = lodashStable.map(falsey, stubFalse);
+ var expected = lodashStable.map(falsey, alwaysFalse);
var actual = lodashStable.map(falsey, function(value, index) {
return index ? _.isWeakSet(value) : _.isWeakSet();
skipAssert(assert);
}
});
- }());
+ }(1, 2, 3));
/*--------------------------------------------------------------------------*/
lodashStable.each(funcs, function(methodName) {
if (xml) {
- _[methodName](xml);
- assert.ok(true, '`_.' + methodName + '` should not error');
+ var pass = true;
+
+ try {
+ _[methodName](xml);
+ } catch (e) {
+ pass = false;
+ }
+ assert.ok(pass, '`_.' + methodName + '` should not error');
}
else {
skipAssert(assert);
var fn = function() { return this instanceof Number; },
array = [fn, fn, fn],
iteratees = lodashStable.map(array, _.iteratee),
- expected = lodashStable.map(array, stubFalse);
+ expected = lodashStable.map(array, alwaysFalse);
var actual = lodashStable.map(iteratees, function(iteratee) {
return iteratee();
if (!isModularize) {
_.iteratee = getPropB;
- assert.deepEqual(_.mapKeys({ 'a': { 'b': 2 } }), { '2': { 'b': 2 } });
+ assert.deepEqual(_.mapKeys({ 'a': { 'b': 1 } }), { '1': { 'b': 1 } });
_.iteratee = iteratee;
}
else {
if (!isModularize) {
_.iteratee = getPropB;
- assert.deepEqual(_.mapValues({ 'a': { 'b': 2 } }), { 'a': 2 });
+ assert.deepEqual(_.mapValues({ 'a': { 'b': 1 } }), { 'a': 1 });
_.iteratee = iteratee;
}
else {
QUnit.module('keys methods');
lodashStable.each(['keys', 'keysIn'], function(methodName) {
- var func = _[methodName],
+ var args = (function() { return arguments; }(1, 2, 3)),
+ strictArgs = (function() { 'use strict'; return arguments; }(1, 2, 3)),
+ func = _[methodName],
isKeys = methodName == 'keys';
QUnit.test('`_.' + methodName + '` should return the string keyed property names of `object`', function(assert) {
assert.deepEqual(actual, expected);
});
+ QUnit.test('`_.' + methodName + '` should coerce primitives to objects (test in IE 9)', function(assert) {
+ assert.expect(2);
+
+ var expected = lodashStable.map(primitives, function(value) {
+ return typeof value == 'string' ? ['0'] : [];
+ });
+
+ var actual = lodashStable.map(primitives, func);
+ assert.deepEqual(actual, expected);
+
+ // IE 9 doesn't box numbers in for-in loops.
+ numberProto.a = 1;
+ assert.deepEqual(func(0), isKeys ? [] : ['a']);
+ delete numberProto.a;
+ });
+
QUnit.test('`_.' + methodName + '` should treat sparse arrays as dense', function(assert) {
assert.expect(1);
assert.deepEqual(actual, ['0', '1', '2']);
});
+ QUnit.test('`_.' + methodName + '` should not coerce nullish values to objects', function(assert) {
+ assert.expect(2);
+
+ objectProto.a = 1;
+ lodashStable.each([null, undefined], function(value) {
+ assert.deepEqual(func(value), []);
+ });
+ delete objectProto.a;
+ });
+
QUnit.test('`_.' + methodName + '` should return keys for custom properties on arrays', function(assert) {
assert.expect(1);
delete stringProto.a;
});
- QUnit.test('`_.' + methodName + '` should work with array-like objects', function(assert) {
- assert.expect(1);
-
- var object = { '0': 'a', 'length': 1 },
- actual = func(object).sort();
-
- assert.deepEqual(actual, ['0', 'length']);
- });
-
- QUnit.test('`_.' + methodName + '` should coerce primitives to objects (test in IE 9)', function(assert) {
- assert.expect(2);
-
- var expected = lodashStable.map(primitives, function(value) {
- return typeof value == 'string' ? ['0'] : [];
- });
-
- var actual = lodashStable.map(primitives, func);
- assert.deepEqual(actual, expected);
-
- // IE 9 doesn't box numbers in for-in loops.
- numberProto.a = 1;
- assert.deepEqual(func(0), isKeys ? [] : ['a']);
- delete numberProto.a;
- });
-
QUnit.test('`_.' + methodName + '` skips the `constructor` property on prototype objects', function(assert) {
assert.expect(3);
Fake.prototype.constructor = Fake;
assert.deepEqual(func(Fake.prototype), ['constructor']);
});
-
- QUnit.test('`_.' + methodName + '` should return an empty array when `object` is nullish', function(assert) {
- var values = [, null, undefined],
- expected = lodashStable.map(values, stubArray);
-
- var actual = lodashStable.map(values, function(value, index) {
- objectProto.a = 1;
- var result = index ? func(value) : func();
- delete objectProto.a;
- return result;
- });
-
- assert.deepEqual(actual, expected);
- });
});
/*--------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------*/
- QUnit.module('lodash.findLastIndex and lodash.lastIndexOf');
+ QUnit.module('lodash.lastIndexOf');
- lodashStable.each(['findLastIndex', 'lastIndexOf'], function(methodName) {
- var array = [1, 2, 3, 1, 2, 3],
- func = _[methodName],
- resolve = methodName == 'findLastIndex' ? lodashStable.curry(lodashStable.eq) : identity;
+ (function() {
+ var array = [1, 2, 3, 1, 2, 3];
- QUnit.test('`_.' + methodName + '` should return the index of the last matched value', function(assert) {
+ QUnit.test('should return the index of the last matched value', function(assert) {
assert.expect(1);
- assert.strictEqual(func(array, resolve(3)), 5);
+ assert.strictEqual(_.lastIndexOf(array, 3), 5);
});
- QUnit.test('`_.' + methodName + '` should work with a positive `fromIndex`', function(assert) {
+ QUnit.test('should work with a positive `fromIndex`', function(assert) {
assert.expect(1);
- assert.strictEqual(func(array, resolve(1), 2), 0);
+ assert.strictEqual(_.lastIndexOf(array, 1, 2), 0);
});
- QUnit.test('`_.' + methodName + '` should work with a `fromIndex` >= `length`', function(assert) {
+ QUnit.test('should work with `fromIndex` >= `array.length`', function(assert) {
assert.expect(1);
var values = [6, 8, Math.pow(2, 32), Infinity],
var actual = lodashStable.map(values, function(fromIndex) {
return [
- func(array, resolve(undefined), fromIndex),
- func(array, resolve(1), fromIndex),
- func(array, resolve(''), fromIndex)
+ _.lastIndexOf(array, undefined, fromIndex),
+ _.lastIndexOf(array, 1, fromIndex),
+ _.lastIndexOf(array, '', fromIndex)
];
});
assert.deepEqual(actual, expected);
});
- QUnit.test('`_.' + methodName + '` should work with a negative `fromIndex`', function(assert) {
+ QUnit.test('should work with a negative `fromIndex`', function(assert) {
assert.expect(1);
- assert.strictEqual(func(array, resolve(2), -3), 1);
+ assert.strictEqual(_.lastIndexOf(array, 2, -3), 1);
});
- QUnit.test('`_.' + methodName + '` should work with a negative `fromIndex` <= `-length`', function(assert) {
+ QUnit.test('should work with a negative `fromIndex` <= `-array.length`', function(assert) {
assert.expect(1);
var values = [-6, -8, -Infinity],
- expected = lodashStable.map(values, stubZero);
+ expected = lodashStable.map(values, alwaysZero);
var actual = lodashStable.map(values, function(fromIndex) {
- return func(array, resolve(1), fromIndex);
+ return _.lastIndexOf(array, 1, fromIndex);
});
assert.deepEqual(actual, expected);
});
- QUnit.test('`_.' + methodName + '` should treat falsey `fromIndex` values correctly', function(assert) {
+ QUnit.test('should treat falsey `fromIndex` values correctly', function(assert) {
assert.expect(1);
var expected = lodashStable.map(falsey, function(value) {
});
var actual = lodashStable.map(falsey, function(fromIndex) {
- return func(array, resolve(3), fromIndex);
+ return _.lastIndexOf(array, 3, fromIndex);
});
assert.deepEqual(actual, expected);
});
- QUnit.test('`_.' + methodName + '` should coerce `fromIndex` to an integer', function(assert) {
+ QUnit.test('should coerce `fromIndex` to an integer', function(assert) {
assert.expect(1);
- assert.strictEqual(func(array, resolve(2), 4.2), 4);
+ assert.strictEqual(_.lastIndexOf(array, 2, 4.2), 4);
});
- });
+ }());
/*--------------------------------------------------------------------------*/
isIndexOf = !/last/i.test(methodName),
isSorted = /^sorted/.test(methodName);
- QUnit.test('`_.' + methodName + '` should accept a falsey `array`', function(assert) {
+ QUnit.test('`_.' + methodName + '` should accept a falsey `array` argument', function(assert) {
assert.expect(1);
var expected = lodashStable.map(falsey, lodashStable.constant(-1));
});
});
- QUnit.test('should accept a falsey `collection`', function(assert) {
+ QUnit.test('should accept a falsey `collection` argument', function(assert) {
assert.expect(1);
- var expected = lodashStable.map(falsey, stubArray);
+ var expected = lodashStable.map(falsey, alwaysEmptyArray);
var actual = lodashStable.map(falsey, function(collection, index) {
try {
}
});
- QUnit.test('should provide correct `predicate` arguments in a lazy sequence', function(assert) {
+ QUnit.test('should provide the correct `predicate` arguments in a lazy sequence', function(assert) {
assert.expect(5);
if (!isNpm) {
QUnit.test('should work with `_.property` shorthands', function(assert) {
assert.expect(1);
- var actual = _.mapValues({ 'a': { 'b': 2 } }, 'b');
- assert.deepEqual(actual, { 'a': 2 });
+ var actual = _.mapValues({ 'a': { 'b': 1 } }, 'b');
+ assert.deepEqual(actual, { 'a': 1 });
});
QUnit.test('should use `_.identity` when `iteratee` is nullish', function(assert) {
assert.deepEqual(actual, { 'a': 'a' });
});
- QUnit.test('`_.' + methodName + '` should accept a falsey `object`', function(assert) {
+ QUnit.test('`_.' + methodName + '` should accept a falsey `object` argument', function(assert) {
assert.expect(1);
- var expected = lodashStable.map(falsey, stubObject);
+ var expected = lodashStable.map(falsey, alwaysEmptyObject);
var actual = lodashStable.map(falsey, function(object, index) {
try {
});
});
- QUnit.module('lodash.matches');
-
- (function() {
- QUnit.test('should not change behavior if `source` is modified', function(assert) {
- assert.expect(9);
-
- var sources = [
- { 'a': { 'b': 2, 'c': 3 } },
- { 'a': 1, 'b': 2 },
- { 'a': 1 }
- ];
-
- lodashStable.each(sources, function(source, index) {
- var object = lodashStable.cloneDeep(source),
- par = _.matches(source);
-
- assert.strictEqual(par(object), true);
-
- if (index) {
- source.a = 2;
- source.b = 1;
- source.c = 3;
- } else {
- source.a.b = 1;
- source.a.c = 2;
- source.a.d = 3;
- }
- assert.strictEqual(par(object), true);
- assert.strictEqual(par(source), false);
- });
- });
- }());
-
/*--------------------------------------------------------------------------*/
- QUnit.module('matches methods');
-
- lodashStable.each(['matches', 'isMatch'], function(methodName) {
- var isMatches = methodName == 'matches';
-
- function matches(source) {
- return isMatches ? _.matches(source) : function(object) {
- return _.isMatch(object, source);
- };
- }
+ QUnit.module('lodash.matches');
- QUnit.test('`_.' + methodName + '` should perform a deep comparison between `source` and `object`', function(assert) {
- assert.expect(5);
+ (function() {
+ QUnit.test('should create a function that performs a deep comparison between `source` and a given object', function(assert) {
+ assert.expect(6);
var object = { 'a': 1, 'b': 2, 'c': 3 },
- par = matches({ 'a': 1 });
+ matches = _.matches({ 'a': 1 });
- assert.strictEqual(par(object), true);
+ assert.strictEqual(matches.length, 1);
+ assert.strictEqual(matches(object), true);
- par = matches({ 'b': 1 });
- assert.strictEqual(par(object), false);
+ matches = _.matches({ 'b': 1 });
+ assert.strictEqual(matches(object), false);
- par = matches({ 'a': 1, 'c': 3 });
- assert.strictEqual(par(object), true);
+ matches = _.matches({ 'a': 1, 'c': 3 });
+ assert.strictEqual(matches(object), true);
- par = matches({ 'c': 3, 'd': 4 });
- assert.strictEqual(par(object), false);
+ matches = _.matches({ 'c': 3, 'd': 4 });
+ assert.strictEqual(matches(object), false);
object = { 'a': { 'b': { 'c': 1, 'd': 2 }, 'e': 3 }, 'f': 4 };
- par = matches({ 'a': { 'b': { 'c': 1 } } });
+ matches = _.matches({ 'a': { 'b': { 'c': 1 } } });
- assert.strictEqual(par(object), true);
+ assert.strictEqual(matches(object), true);
});
- QUnit.test('`_.' + methodName + '` should match inherited string keyed `object` properties', function(assert) {
+ QUnit.test('should match inherited string keyed `object` properties', function(assert) {
assert.expect(1);
function Foo() {
Foo.prototype.b = 2;
var object = { 'a': new Foo },
- par = matches({ 'a': { 'b': 2 } });
+ matches = _.matches({ 'a': { 'b': 2 } });
- assert.strictEqual(par(object), true);
+ assert.strictEqual(matches(object), true);
});
- QUnit.test('`_.' + methodName + '` should not match by inherited `source` properties', function(assert) {
+ QUnit.test('should not match by inherited `source` properties', function(assert) {
assert.expect(1);
function Foo() {
var objects = [{ 'a': 1 }, { 'a': 1, 'b': 2 }],
source = new Foo,
- actual = lodashStable.map(objects, matches(source)),
- expected = lodashStable.map(objects, stubTrue);
+ actual = lodashStable.map(objects, _.matches(source)),
+ expected = lodashStable.map(objects, alwaysTrue);
assert.deepEqual(actual, expected);
});
- QUnit.test('`_.' + methodName + '` should compare a variety of `source` property values', function(assert) {
+ QUnit.test('should compare a variety of `source` property values', function(assert) {
assert.expect(2);
var object1 = { 'a': false, 'b': true, 'c': '3', 'd': 4, 'e': [5], 'f': { 'g': 6 } },
object2 = { 'a': 0, 'b': 1, 'c': 3, 'd': '4', 'e': ['5'], 'f': { 'g': '6' } },
- par = matches(object1);
+ matches = _.matches(object1);
- assert.strictEqual(par(object1), true);
- assert.strictEqual(par(object2), false);
+ assert.strictEqual(matches(object1), true);
+ assert.strictEqual(matches(object2), false);
});
- QUnit.test('`_.' + methodName + '` should match `-0` as `0`', function(assert) {
+ QUnit.test('should match `-0` as `0`', function(assert) {
assert.expect(2);
var object1 = { 'a': -0 },
object2 = { 'a': 0 },
- par = matches(object1);
+ matches = _.matches(object1);
- assert.strictEqual(par(object2), true);
+ assert.strictEqual(matches(object2), true);
- par = matches(object2);
- assert.strictEqual(par(object1), true);
+ matches = _.matches(object2);
+ assert.strictEqual(matches(object1), true);
});
- QUnit.test('`_.' + methodName + '` should compare functions by reference', function(assert) {
+ QUnit.test('should compare functions by reference', function(assert) {
assert.expect(3);
var object1 = { 'a': lodashStable.noop },
object2 = { 'a': noop },
object3 = { 'a': {} },
- par = matches(object1);
+ matches = _.matches(object1);
- assert.strictEqual(par(object1), true);
- assert.strictEqual(par(object2), false);
- assert.strictEqual(par(object3), false);
+ assert.strictEqual(matches(object1), true);
+ assert.strictEqual(matches(object2), false);
+ assert.strictEqual(matches(object3), false);
});
- QUnit.test('`_.' + methodName + '` should work with a function for `object`', function(assert) {
+ QUnit.test('should work with a function for `object`', function(assert) {
assert.expect(1);
function Foo() {}
- Foo.a = { 'b': 2, 'c': 3 };
+ Foo.a = { 'b': 1, 'c': 2 };
- var par = matches({ 'a': { 'b': 2 } });
- assert.strictEqual(par(Foo), true);
+ var matches = _.matches({ 'a': { 'b': 1 } });
+ assert.strictEqual(matches(Foo), true);
});
- QUnit.test('`_.' + methodName + '` should work with a function for `source`', function(assert) {
+ QUnit.test('should work with a function for `source`', function(assert) {
assert.expect(1);
function Foo() {}
Foo.c = 3;
var objects = [{ 'a': 1 }, { 'a': 1, 'b': Foo.b, 'c': 3 }],
- actual = lodashStable.map(objects, matches(Foo));
+ actual = lodashStable.map(objects, _.matches(Foo));
assert.deepEqual(actual, [false, true]);
});
- QUnit.test('`_.' + methodName + '` should work with a non-plain `object`', function(assert) {
+ QUnit.test('should work with a non-plain `object`', function(assert) {
assert.expect(1);
function Foo(object) { lodashStable.assign(this, object); }
- var object = new Foo({ 'a': new Foo({ 'b': 2, 'c': 3 }) }),
- par = matches({ 'a': { 'b': 2 } });
+ var object = new Foo({ 'a': new Foo({ 'b': 1, 'c': 2 }) }),
+ matches = _.matches({ 'a': { 'b': 1 } });
- assert.strictEqual(par(object), true);
+ assert.strictEqual(matches(object), true);
});
- QUnit.test('`_.' + methodName + '` should partial match arrays', function(assert) {
+ QUnit.test('should partial match arrays', function(assert) {
assert.expect(3);
var objects = [{ 'a': ['b'] }, { 'a': ['c', 'd'] }],
- actual = lodashStable.filter(objects, matches({ 'a': ['d'] }));
+ actual = lodashStable.filter(objects, _.matches({ 'a': ['d'] }));
assert.deepEqual(actual, [objects[1]]);
- actual = lodashStable.filter(objects, matches({ 'a': ['b', 'd'] }));
+ actual = lodashStable.filter(objects, _.matches({ 'a': ['b', 'd'] }));
assert.deepEqual(actual, []);
- actual = lodashStable.filter(objects, matches({ 'a': ['d', 'b'] }));
+ actual = lodashStable.filter(objects, _.matches({ 'a': ['d', 'b'] }));
assert.deepEqual(actual, []);
});
- QUnit.test('`_.' + methodName + '` should partial match arrays with duplicate values', function(assert) {
- assert.expect(1);
-
- var objects = [{ 'a': [1, 2] }, { 'a': [2, 2] }],
- actual = lodashStable.filter(objects, matches({ 'a': [2, 2] }));
-
- assert.deepEqual(actual, [objects[1]]);
- });
-
QUnit.test('should partial match arrays of objects', function(assert) {
assert.expect(1);
{ 'a': [{ 'b': 1, 'c': 2 }, { 'b': 4, 'c': 6, 'd': 7 }] }
];
- var actual = lodashStable.filter(objects, matches({ 'a': [{ 'b': 1 }, { 'b': 4, 'c': 5 }] }));
+ var actual = lodashStable.filter(objects, _.matches({ 'a': [{ 'b': 1 }, { 'b': 4, 'c': 5 }] }));
assert.deepEqual(actual, [objects[0]]);
});
- QUnit.test('`_.' + methodName + '` should partial match maps', function(assert) {
+ QUnit.test('should partial match maps', function(assert) {
assert.expect(3);
if (Map) {
var map = new Map;
map.set('b', 2);
- var actual = lodashStable.filter(objects, matches({ 'a': map }));
+ var actual = lodashStable.filter(objects, _.matches({ 'a': map }));
assert.deepEqual(actual, [objects[1]]);
- map.delete('b');
- actual = lodashStable.filter(objects, matches({ 'a': map }));
+ map['delete']('b');
+ actual = lodashStable.filter(objects, _.matches({ 'a': map }));
assert.deepEqual(actual, objects);
map.set('c', 3);
- actual = lodashStable.filter(objects, matches({ 'a': map }));
+ actual = lodashStable.filter(objects, _.matches({ 'a': map }));
assert.deepEqual(actual, []);
}
}
});
- QUnit.test('`_.' + methodName + '` should partial match sets', function(assert) {
+ QUnit.test('should partial match sets', function(assert) {
assert.expect(3);
if (Set) {
var set = new Set;
set.add(2);
- var actual = lodashStable.filter(objects, matches({ 'a': set }));
+ var actual = lodashStable.filter(objects, _.matches({ 'a': set }));
assert.deepEqual(actual, [objects[1]]);
- set.delete(2);
- actual = lodashStable.filter(objects, matches({ 'a': set }));
+ set['delete'](2);
+ actual = lodashStable.filter(objects, _.matches({ 'a': set }));
assert.deepEqual(actual, objects);
set.add(3);
- actual = lodashStable.filter(objects, matches({ 'a': set }));
+ actual = lodashStable.filter(objects, _.matches({ 'a': set }));
assert.deepEqual(actual, []);
}
}
});
- QUnit.test('`_.' + methodName + '` should match `undefined` values', function(assert) {
+ QUnit.test('should match `undefined` values', function(assert) {
assert.expect(3);
var objects = [{ 'a': 1 }, { 'a': 1, 'b': 1 }, { 'a': 1, 'b': undefined }],
- actual = lodashStable.map(objects, matches({ 'b': undefined })),
+ actual = lodashStable.map(objects, _.matches({ 'b': undefined })),
expected = [false, false, true];
assert.deepEqual(actual, expected);
- actual = lodashStable.map(objects, matches({ 'a': 1, 'b': undefined }));
+ actual = lodashStable.map(objects, _.matches({ 'a': 1, 'b': undefined }));
assert.deepEqual(actual, expected);
- objects = [{ 'a': { 'b': 2 } }, { 'a': { 'b': 2, 'c': 3 } }, { 'a': { 'b': 2, 'c': undefined } }];
- actual = lodashStable.map(objects, matches({ 'a': { 'c': undefined } }));
+ objects = [{ 'a': { 'b': 1 } }, { 'a': { 'b': 1, 'c': 1 } }, { 'a': { 'b': 1, 'c': undefined } }];
+ actual = lodashStable.map(objects, _.matches({ 'a': { 'c': undefined } }));
assert.deepEqual(actual, expected);
});
- QUnit.test('`_.' + methodName + '` should match `undefined` values on primitives', function(assert) {
+ QUnit.test('should match `undefined` values on primitives', function(assert) {
assert.expect(3);
numberProto.a = 1;
numberProto.b = undefined;
try {
- var par = matches({ 'b': undefined });
- assert.strictEqual(par(1), true);
+ var matches = _.matches({ 'b': undefined });
+ assert.strictEqual(matches(1), true);
} catch (e) {
assert.ok(false, e.message);
}
try {
- par = matches({ 'a': 1, 'b': undefined });
- assert.strictEqual(par(1), true);
+ matches = _.matches({ 'a': 1, 'b': undefined });
+ assert.strictEqual(matches(1), true);
} catch (e) {
assert.ok(false, e.message);
}
numberProto.a = { 'b': 1, 'c': undefined };
try {
- par = matches({ 'a': { 'c': undefined } });
- assert.strictEqual(par(1), true);
+ matches = _.matches({ 'a': { 'c': undefined } });
+ assert.strictEqual(matches(1), true);
} catch (e) {
assert.ok(false, e.message);
}
delete numberProto.b;
});
- QUnit.test('`_.' + methodName + '` should return `false` when `object` is nullish', function(assert) {
+ QUnit.test('should return `false` when `object` is nullish', function(assert) {
assert.expect(1);
var values = [, null, undefined],
- expected = lodashStable.map(values, stubFalse),
- par = matches({ 'a': 1 });
+ expected = lodashStable.map(values, alwaysFalse),
+ matches = _.matches({ 'a': 1 });
var actual = lodashStable.map(values, function(value, index) {
try {
- return index ? par(value) : par();
+ return index ? matches(value) : matches();
} catch (e) {}
});
assert.deepEqual(actual, expected);
});
- QUnit.test('`_.' + methodName + '` should return `true` when comparing an empty `source`', function(assert) {
+ QUnit.test('should return `true` when comparing an empty `source` to a nullish `object`', function(assert) {
assert.expect(1);
- var object = { 'a': 1 },
- expected = lodashStable.map(empties, stubTrue);
+ var values = [, null, undefined],
+ expected = lodashStable.map(values, alwaysTrue),
+ matches = _.matches({});
- var actual = lodashStable.map(empties, function(value) {
- var par = matches(value);
- return par(object);
+ var actual = lodashStable.map(values, function(value, index) {
+ try {
+ return index ? matches(value) : matches();
+ } catch (e) {}
});
assert.deepEqual(actual, expected);
});
- QUnit.test('`_.' + methodName + '` should return `true` when comparing an empty `source` to a nullish `object`', function(assert) {
+ QUnit.test('should return `true` when comparing an empty `source`', function(assert) {
assert.expect(1);
- var values = [, null, undefined],
- expected = lodashStable.map(values, stubTrue),
- par = matches({});
+ var object = { 'a': 1 },
+ expected = lodashStable.map(empties, alwaysTrue);
- var actual = lodashStable.map(values, function(value, index) {
- try {
- return index ? par(value) : par();
- } catch (e) {}
+ var actual = lodashStable.map(empties, function(value) {
+ var matches = _.matches(value);
+ return matches(object);
});
assert.deepEqual(actual, expected);
});
- QUnit.test('`_.' + methodName + '` should return `true` when comparing a `source` of empty arrays and objects', function(assert) {
+ QUnit.test('should return `true` when comparing a `source` of empty arrays and objects', function(assert) {
assert.expect(1);
var objects = [{ 'a': [1], 'b': { 'c': 1 } }, { 'a': [2, 3], 'b': { 'd': 2 } }],
- actual = lodashStable.filter(objects, matches({ 'a': [], 'b': {} }));
+ actual = lodashStable.filter(objects, _.matches({ 'a': [], 'b': {} }));
assert.deepEqual(actual, objects);
});
- });
+
+ QUnit.test('should not change behavior if `source` is modified', function(assert) {
+ assert.expect(9);
+
+ var sources = [
+ { 'a': { 'b': 2, 'c': 3 } },
+ { 'a': 1, 'b': 2 },
+ { 'a': 1 }
+ ];
+
+ lodashStable.each(sources, function(source, index) {
+ var object = lodashStable.cloneDeep(source),
+ matches = _.matches(source);
+
+ assert.strictEqual(matches(object), true);
+
+ if (index) {
+ source.a = 2;
+ source.b = 1;
+ source.c = 3;
+ } else {
+ source.a.b = 1;
+ source.a.c = 2;
+ source.a.d = 3;
+ }
+ assert.strictEqual(matches(object), true);
+ assert.strictEqual(matches(source), false);
+ });
+ });
+ }());
/*--------------------------------------------------------------------------*/
assert.deepEqual(actual, expected);
});
- QUnit.test('should coerce `path` to a string', function(assert) {
- assert.expect(2);
+ QUnit.test('should coerce key to a string', function(assert) {
+ assert.expect(1);
function fn() {}
fn.toString = lodashStable.constant('fn');
- var object = { 'null': 1, 'undefined': 2, 'fn': 3, '[object Object]': 4 },
- paths = [null, undefined, fn, {}],
- expected = lodashStable.map(paths, stubTrue);
+ var objects = [{ 'null': 1 }, { 'undefined': 2 }, { 'fn': 3 }, { '[object Object]': 4 }],
+ values = [null, undefined, fn, {}];
- lodashStable.times(2, function(index) {
- var actual = lodashStable.map(paths, function(path) {
- var matches = _.matchesProperty(index ? [path] : path, object[path]);
- return matches(object);
- });
+ var expected = lodashStable.transform(values, function(result) {
+ result.push(true, true);
+ });
- assert.deepEqual(actual, expected);
+ var actual = lodashStable.transform(objects, function(result, object, index) {
+ var key = values[index];
+ lodashStable.each([key, [key]], function(path) {
+ var matches = _.matchesProperty(path, object[key]);
+ result.push(matches(object));
+ });
});
+
+ assert.deepEqual(actual, expected);
});
QUnit.test('should match a key over a path', function(assert) {
});
});
- QUnit.test('should return `false` when `object` is nullish', function(assert) {
- assert.expect(2);
+ QUnit.test('should return `false` if parts of `path` are missing', function(assert) {
+ assert.expect(4);
- var values = [, null, undefined],
- expected = lodashStable.map(values, stubFalse);
+ var object = {};
- lodashStable.each(['constructor', ['constructor']], function(path) {
+ lodashStable.each(['a', 'a[1].b.c', ['a'], ['a', '1', 'b', 'c']], function(path) {
var matches = _.matchesProperty(path, 1);
-
- var actual = lodashStable.map(values, function(value, index) {
- try {
- return index ? matches(value) : matches();
- } catch (e) {}
- });
-
- assert.deepEqual(actual, expected);
+ assert.strictEqual(matches(object), false);
});
});
assert.expect(2);
var values = [, null, undefined],
- expected = lodashStable.map(values, stubFalse);
+ expected = lodashStable.map(values, alwaysFalse);
lodashStable.each(['constructor.prototype.valueOf', ['constructor', 'prototype', 'valueOf']], function(path) {
var matches = _.matchesProperty(path, 1);
});
});
- QUnit.test('should return `false` if parts of `path` are missing', function(assert) {
- assert.expect(4);
-
- var object = {};
-
- lodashStable.each(['a', 'a[1].b.c', ['a'], ['a', '1', 'b', 'c']], function(path) {
- var matches = _.matchesProperty(path, 1);
- assert.strictEqual(matches(object), false);
- });
- });
-
QUnit.test('should match inherited string keyed `srcValue` properties', function(assert) {
assert.expect(2);
Foo.prototype.b = 2;
var objects = [{ 'a': { 'a': 1 } }, { 'a': { 'a': 1, 'b': 2 } }],
- expected = lodashStable.map(objects, stubTrue);
+ expected = lodashStable.map(objects, alwaysTrue);
lodashStable.each(['a', ['a']], function(path) {
assert.deepEqual(lodashStable.map(objects, _.matchesProperty(path, new Foo)), expected);
assert.deepEqual(actual, []);
});
- QUnit.test('should partial match arrays with duplicate values', function(assert) {
- assert.expect(1);
-
- var objects = [{ 'a': [1, 2] }, { 'a': [2, 2] }],
- actual = lodashStable.filter(objects, _.matchesProperty('a', [2, 2]));
-
- assert.deepEqual(actual, [objects[1]]);
- });
-
QUnit.test('should partial match arrays of objects', function(assert) {
assert.expect(1);
assert.deepEqual(actual, [objects[1]]);
- map.delete('b');
+ map['delete']('b');
actual = lodashStable.filter(objects, _.matchesProperty('a', map));
assert.deepEqual(actual, objects);
assert.deepEqual(actual, [objects[1]]);
- set.delete(2);
+ set['delete'](2);
actual = lodashStable.filter(objects, _.matchesProperty('a', set));
assert.deepEqual(actual, objects);
delete numberProto.b;
});
+ QUnit.test('should return `false` when `object` is nullish', function(assert) {
+ assert.expect(2);
+
+ var values = [, null, undefined],
+ expected = lodashStable.map(values, alwaysFalse);
+
+ lodashStable.each(['constructor', ['constructor']], function(path) {
+ var matches = _.matchesProperty(path, 1);
+
+ var actual = lodashStable.map(values, function(value, index) {
+ try {
+ return index ? matches(value) : matches();
+ } catch (e) {}
+ });
+
+ assert.deepEqual(actual, expected);
+ });
+ });
+
QUnit.test('should return `true` when comparing a `srcValue` of empty arrays and objects', function(assert) {
assert.expect(1);
QUnit.test('should return `NaN` when passing empty `array` values', function(assert) {
assert.expect(1);
- var expected = lodashStable.map(empties, stubNaN),
+ var expected = lodashStable.map(empties, alwaysNaN),
actual = lodashStable.map(empties, _.mean);
assert.deepEqual(actual, expected);
(function() {
var objects = [{ 'a': 2 }, { 'a': 3 }, { 'a': 1 }];
- QUnit.test('should work with an `iteratee`', function(assert) {
+ QUnit.test('should work with an `iteratee` argument', function(assert) {
assert.expect(1);
var actual = _.meanBy(objects, function(object) {
assert.deepEqual(actual, 2);
});
- QUnit.test('should provide correct `iteratee` arguments', function(assert) {
+ QUnit.test('should provide the correct `iteratee` arguments', function(assert) {
assert.expect(1);
var args;
QUnit.module('lodash.memoize');
(function() {
- function CustomCache() {
- this.clear();
- }
-
- CustomCache.prototype = {
- 'clear': function() {
- this.__data__ = [];
- return this;
- },
- 'get': function(key) {
- var entry = lodashStable.find(this.__data__, ['key', key]);
- return entry && entry.value;
- },
- 'has': function(key) {
- return lodashStable.some(this.__data__, ['key', key]);
- },
- 'set': function(key, value) {
- this.__data__.push({ 'key': key, 'value': value });
- return this;
- }
- };
-
- function ImmutableCache() {
- this.__data__ = [];
- }
-
- ImmutableCache.prototype = lodashStable.create(CustomCache.prototype, {
- 'constructor': ImmutableCache,
- 'clear': function() {
- return new ImmutableCache;
- },
- 'set': function(key, value) {
- var result = new ImmutableCache;
- result.__data__ = this.__data__.concat({ 'key': key, 'value': value });
- return result;
- }
- });
-
QUnit.test('should memoize results based on the first argument given', function(assert) {
assert.expect(2);
assert.strictEqual(memoized(1, 3, 5), 6);
});
- QUnit.test('should support a `resolver`', function(assert) {
+ QUnit.test('should support a `resolver` argument', function(assert) {
assert.expect(2);
var fn = function(a, b, c) { return a + b + c; },
assert.raises(function() { _.memoize(noop, true); }, TypeError);
});
- QUnit.test('should not error if `resolver` is nullish', function(assert) {
+ QUnit.test('should not error if `resolver` is falsey', function(assert) {
assert.expect(1);
- var values = [, null, undefined],
- expected = lodashStable.map(values, stubTrue);
+ var expected = lodashStable.map(falsey, alwaysTrue);
- var actual = lodashStable.map(values, function(resolver, index) {
+ var actual = lodashStable.map(falsey, function(resolver, index) {
try {
return _.isFunction(index ? _.memoize(noop, resolver) : _.memoize(noop));
} catch (e) {}
lodashStable.times(2, function(index) {
var count = 0,
- resolver = index ? identity : undefined;
+ resolver = index && identity;
var memoized = _.memoize(function() {
count++;
assert.strictEqual(count, 1);
assert.strictEqual(cache.get(key), array);
assert.notOk(cache.__data__ instanceof Array);
- assert.strictEqual(cache.delete(key), true);
+ assert.strictEqual(cache['delete'](key), true);
});
});
assert.expect(4);
var oldCache = _.memoize.Cache;
- _.memoize.Cache = CustomCache;
+
+ function Cache() {
+ this.__data__ = [];
+ }
+
+ Cache.prototype = {
+ 'get': function(key) {
+ var entry = _.find(this.__data__, function(entry) {
+ return key === entry.key;
+ });
+ return entry && entry.value;
+ },
+ 'has': function(key) {
+ return _.some(this.__data__, function(entry) {
+ return key === entry.key;
+ });
+ },
+ 'set': function(key, value) {
+ this.__data__.push({ 'key': key, 'value': value });
+ return this;
+ }
+ };
+
+ _.memoize.Cache = Cache;
var memoized = _.memoize(function(object) {
- return object.id;
+ return 'value:' + object.id;
});
var cache = memoized.cache,
key1 = { 'id': 'a' },
key2 = { 'id': 'b' };
- assert.strictEqual(memoized(key1), 'a');
+ assert.strictEqual(memoized(key1), 'value:a');
assert.strictEqual(cache.has(key1), true);
- assert.strictEqual(memoized(key2), 'b');
+ assert.strictEqual(memoized(key2), 'value:b');
assert.strictEqual(cache.has(key2), true);
_.memoize.Cache = oldCache;
assert.expect(2);
var oldCache = _.memoize.Cache;
- _.memoize.Cache = ImmutableCache;
+
+ function Cache() {
+ this.__data__ = [];
+ }
+
+ Cache.prototype = {
+ 'get': function(key) {
+ return _.find(this.__data__, function(entry) {
+ return key === entry.key;
+ }).value;
+ },
+ 'has': function(key) {
+ return _.some(this.__data__, function(entry) {
+ return key === entry.key;
+ });
+ },
+ 'set': function(key, value) {
+ var result = new Cache;
+ result.__data__ = this.__data__.concat({ 'key': key, 'value': value });
+ return result;
+ }
+ };
+
+ _.memoize.Cache = Cache;
var memoized = _.memoize(function(object) {
return object.id;
_.memoize.Cache = oldCache;
});
- }());
-
- /*--------------------------------------------------------------------------*/
- QUnit.module('memoizeCapped');
+ QUnit.test('should implement a `Map` interface on the cache object', function(assert) {
+ assert.expect(164);
- (function() {
- var func = _._memoizeCapped;
+ var keys = [null, undefined, false, true, 1, -Infinity, NaN, {}, 'a', symbol || {}];
- QUnit.test('should enforce a max cache size of `MAX_MEMOIZE_SIZE`', function(assert) {
- assert.expect(2);
+ var pairs = lodashStable.map(keys, function(key, index) {
+ var lastIndex = keys.length - 1;
+ return [key, keys[lastIndex - index]];
+ });
- if (func) {
- var memoized = func(identity),
- cache = memoized.cache;
+ lodashStable.times(2, function(index) {
+ var memoize = (index ? (lodashBizarro || {}) : _).memoize,
+ Cache = memoize ? memoize.Cache : undefined,
+ cache = Cache ? new Cache(pairs) : undefined;
- lodashStable.times(MAX_MEMOIZE_SIZE, memoized);
- assert.strictEqual(cache.size, MAX_MEMOIZE_SIZE);
+ lodashStable.each(keys, function(key, index) {
+ if (cache) {
+ var value = pairs[index][1];
+
+ assert.deepEqual(cache.get(key), value);
+ assert.strictEqual(cache.has(key), true);
+ assert.strictEqual(cache['delete'](key), true);
+ assert.strictEqual(cache.has(key), false);
+ assert.strictEqual(cache.get(key), undefined);
+ assert.strictEqual(cache['delete'](key), false);
+ assert.strictEqual(cache.set(key, value), cache);
+ assert.strictEqual(cache.has(key), true);
+ }
+ else {
+ skipAssert(assert, 8);
+ }
+ });
- memoized(MAX_MEMOIZE_SIZE);
- assert.strictEqual(cache.size, 1);
- }
- else {
- skipAssert(assert, 2);
- }
+ if (cache) {
+ assert.strictEqual(cache.clear(), undefined);
+ assert.ok(lodashStable.every(keys, function(key) {
+ return !cache.has(key);
+ }));
+ }
+ else {
+ skipAssert(assert, 2);
+ }
+ });
});
}());
QUnit.module('lodash.merge');
(function() {
+ var args = arguments;
+
QUnit.test('should merge `source` into `object`', function(assert) {
assert.expect(1);
assert.strictEqual(Foo.a, 1);
});
- QUnit.test('should not merge onto function values of sources', function(assert) {
+ QUnit.test('should not merge onto nested function values', function(assert) {
assert.expect(3);
var source1 = { 'a': function() {} },
- source2 = { 'a': { 'b': 2 } },
- actual = _.merge({}, source1, source2);
+ source2 = { 'a': { 'b': 1 } },
+ actual = _.merge({}, source1, source2),
+ expected = { 'a': { 'b': 1 } };
- assert.deepEqual(actual, { 'a': { 'b': 2 } });
+ assert.deepEqual(actual, expected);
- actual = _.merge(source1, source2);
+ source1 = { 'a': function() {} };
+ source2 = { 'a': { 'b': 1 } };
+
+ expected = { 'a': function() {} };
+ expected.a.b = 1;
+ actual = _.merge(source1, source2);
assert.strictEqual(typeof actual.a, 'function');
- assert.strictEqual(actual.a.b, 2);
+ assert.strictEqual(actual.a.b, 1);
});
QUnit.test('should merge onto non-plain `object` values', function(assert) {
var arrays = [array2, array1, array4, array3, array2, array4, array4, array3, array2],
buffer = ArrayBuffer && new ArrayBuffer(8);
+ // Juggle for `Float64Array` shim.
+ if (root.Float64Array && (new Float64Array(buffer)).length == 8) {
+ arrays[1] = array4;
+ }
var expected = lodashStable.map(typedArrays, function(type, index) {
var array = arrays[index].slice();
array[0] = 1;
assert.strictEqual(actual.a, null);
});
- QUnit.test('should assign non array/buffer/typed-array/plain-object source values directly', function(assert) {
+ QUnit.test('should assign non array/typed-array/plain-object sources directly', function(assert) {
assert.expect(1);
function Foo() {}
var values = [new Foo, new Boolean, new Date, Foo, new Number, new String, new RegExp],
- expected = lodashStable.map(values, stubTrue);
+ expected = lodashStable.map(values, alwaysTrue);
var actual = lodashStable.map(values, function(value) {
- var object = _.merge({}, { 'a': value, 'b': { 'c': value } });
- return object.a === value && object.b.c === value;
+ var object = _.merge({}, { 'value': value });
+ return object.value === value;
});
assert.deepEqual(actual, expected);
});
- QUnit.test('should clone buffer source values', function(assert) {
- assert.expect(3);
-
- if (Buffer) {
- var buffer = new Buffer([1]),
- actual = _.merge({}, { 'value': buffer }).value;
-
- assert.ok(lodashStable.isBuffer(actual));
- assert.strictEqual(actual[0], buffer[0]);
- assert.notStrictEqual(actual, buffer);
- }
- else {
- skipAssert(assert, 3);
- }
- });
-
- QUnit.test('should deep clone array/typed-array/plain-object source values', function(assert) {
+ QUnit.test('should deep clone array/typed-array/plain-object sources', function(assert) {
assert.expect(1);
var typedArray = Uint8Array
- ? new Uint8Array([1])
- : { 'buffer': [1] };
+ ? new Uint8Array(new ArrayBuffer(2))
+ : { 'buffer': [0, 0] };
- var props = ['0', 'buffer', 'a'],
- values = [[{ 'a': 1 }], typedArray, { 'a': [1] }],
- expected = lodashStable.map(values, stubTrue);
+ var props = ['0', 'a', 'buffer'],
+ values = [[{ 'a': 1 }], { 'a': [1] }, typedArray],
+ expected = lodashStable.map(values, alwaysTrue);
var actual = lodashStable.map(values, function(value, index) {
var key = props[index],
object = _.merge({}, { 'value': value }),
- subValue = value[key],
- newValue = object.value,
- newSubValue = newValue[key];
+ newValue = object.value;
return (
newValue !== value &&
- newSubValue !== subValue &&
+ newValue[key] !== value[key] &&
lodashStable.isEqual(newValue, value)
);
});
assert.deepEqual(actual.a, [[3, 4, 3]]);
});
- QUnit.test('should merge plain objects onto non-plain objects', function(assert) {
+ QUnit.test('should merge plain-objects onto non plain-objects', function(assert) {
assert.expect(4);
function Foo(object) {
assert.deepEqual(actual, [new Foo(object)]);
});
- QUnit.test('should not overwrite existing values with `undefined` values of object sources', function(assert) {
+ QUnit.test('should not assign `undefined` values', function(assert) {
assert.expect(1);
var actual = _.merge({ 'a': 1 }, { 'a': undefined, 'b': undefined });
- assert.deepEqual(actual, { 'a': 1, 'b': undefined });
+ assert.deepEqual(actual, { 'a': 1 });
});
- QUnit.test('should not overwrite existing values with `undefined` values of array sources', function(assert) {
+ QUnit.test('should skip `undefined` values in array sources if a destination value exists', function(assert) {
assert.expect(2);
var array = [1];
QUnit.test('should skip merging when `object` and `source` are the same value', function(assert) {
assert.expect(1);
- var object = {},
- pass = true;
+ if (defineProperty) {
+ var object = {},
+ pass = true;
- defineProperty(object, 'a', {
- 'configurable': true,
- 'enumerable': true,
- 'get': function() { pass = false; },
- 'set': function() { pass = false; }
- });
+ defineProperty(object, 'a', {
+ 'enumerable': true,
+ 'configurable': true,
+ 'get': function() { pass = false; },
+ 'set': function() { pass = false; }
+ });
- _.merge(object, object);
- assert.ok(pass);
+ _.merge(object, object);
+ assert.ok(pass);
+ }
+ else {
+ skipAssert(assert);
+ }
});
QUnit.test('should convert values to arrays when merging arrays of `source`', function(assert) {
var object1 = { 'el': document && document.createElement('div') },
object2 = { 'el': document && document.createElement('div') },
pairs = [[{}, object1], [object1, object2]],
- expected = lodashStable.map(pairs, stubTrue);
+ expected = lodashStable.map(pairs, alwaysTrue);
var actual = lodashStable.map(pairs, function(pair) {
try {
assert.deepEqual(actual, expected);
});
- }());
+ }(1, 2, 3));
/*--------------------------------------------------------------------------*/
QUnit.module('lodash.mergeWith');
(function() {
- QUnit.test('should handle merging when `customizer` returns `undefined`', function(assert) {
+ QUnit.test('should handle merging if `customizer` returns `undefined`', function(assert) {
assert.expect(2);
var actual = _.mergeWith({ 'a': { 'b': [1, 1] } }, { 'a': { 'b': [0] } }, noop);
assert.deepEqual(actual, [undefined]);
});
- QUnit.test('should clone sources when `customizer` returns `undefined`', function(assert) {
- assert.expect(1);
-
- var source1 = { 'a': { 'b': { 'c': 1 } } },
- source2 = { 'a': { 'b': { 'd': 2 } } };
-
- _.mergeWith({}, source1, source2, noop);
- assert.deepEqual(source1.a.b, { 'c': 1 });
- });
-
- QUnit.test('should defer to `customizer` for non `undefined` results', function(assert) {
+ QUnit.test('should defer to `customizer` when it returns a non `undefined` value', function(assert) {
assert.expect(1);
var actual = _.mergeWith({ 'a': { 'b': [0, 1] } }, { 'a': { 'b': [2] } }, function(a, b) {
assert.deepEqual(actual, { 'a': { 'b': [0, 1, 2] } });
});
- QUnit.test('should provide `stack` to `customizer`', function(assert) {
+ QUnit.test('should overwrite primitives with source object clones', function(assert) {
assert.expect(1);
- var actual;
-
- _.mergeWith({}, { 'a': { 'b': 2 } }, function() {
- actual = _.last(arguments);
+ var actual = _.mergeWith({ 'a': 0 }, { 'a': { 'b': ['c'] } }, function(a, b) {
+ return lodashStable.isArray(a) ? a.concat(b) : undefined;
});
- assert.ok(isNpm
- ? actual.constructor.name == 'Stack'
- : actual instanceof mapCaches.Stack
- );
+ assert.deepEqual(actual, { 'a': { 'b': ['c'] } });
});
- QUnit.test('should overwrite primitives with source object clones', function(assert) {
+ QUnit.test('should clone sources when `customizer` result is `undefined`', function(assert) {
assert.expect(1);
- var actual = _.mergeWith({ 'a': 0 }, { 'a': { 'b': ['c'] } }, function(a, b) {
- return lodashStable.isArray(a) ? a.concat(b) : undefined;
- });
+ var source1 = { 'a': { 'b': { 'c': 1 } } },
+ source2 = { 'a': { 'b': { 'd': 2 } } };
- assert.deepEqual(actual, { 'a': { 'b': ['c'] } });
+ _.mergeWith({}, source1, source2, noop);
+ assert.deepEqual(source1.a.b, { 'c': 1 });
});
QUnit.test('should pop the stack of sources for each sibling property', function(assert) {
QUnit.test('should create a function that calls a method of a given object', function(assert) {
assert.expect(4);
- var object = { 'a': stubOne };
+ var object = { 'a': alwaysOne };
lodashStable.each(['a', ['a']], function(path) {
var method = _.method(path);
QUnit.test('should work with deep property values', function(assert) {
assert.expect(2);
- var object = { 'a': { 'b': stubTwo } };
+ var object = { 'a': { 'b': alwaysTwo } };
lodashStable.each(['a.b', ['a', 'b']], function(path) {
var method = _.method(path);
});
});
- QUnit.test('should coerce `path` to a string', function(assert) {
- assert.expect(2);
+ QUnit.test('should coerce key to a string', function(assert) {
+ assert.expect(1);
function fn() {}
fn.toString = lodashStable.constant('fn');
- var expected = [1, 2, 3, 4],
- object = { 'null': stubOne, 'undefined': stubTwo, 'fn': stubThree, '[object Object]': stubFour },
- paths = [null, undefined, fn, {}];
+ var expected = [1, 1, 2, 2, 3, 3, 4, 4],
+ objects = [{ 'null': alwaysOne }, { 'undefined': alwaysTwo }, { 'fn': alwaysThree }, { '[object Object]': alwaysFour }],
+ values = [null, undefined, fn, {}];
- lodashStable.times(2, function(index) {
- var actual = lodashStable.map(paths, function(path) {
- var method = _.method(index ? [path] : path);
- return method(object);
+ var actual = lodashStable.transform(objects, function(result, object, index) {
+ var key = values[index];
+ lodashStable.each([key, [key]], function(path) {
+ var method = _.method(key);
+ result.push(method(object));
});
-
- assert.deepEqual(actual, expected);
});
+
+ assert.deepEqual(actual, expected);
});
QUnit.test('should work with inherited property values', function(assert) {
assert.expect(2);
function Foo() {}
- Foo.prototype.a = stubOne;
+ Foo.prototype.a = alwaysOne;
lodashStable.each(['a', ['a']], function(path) {
var method = _.method(path);
QUnit.test('should use a key over a path', function(assert) {
assert.expect(2);
- var object = { 'a.b': stubOne, 'a': { 'b': stubTwo } };
+ var object = { 'a.b': alwaysOne, 'a': { 'b': alwaysTwo } };
lodashStable.each(['a.b', ['a.b']], function(path) {
var method = _.method(path);
});
});
- QUnit.test('should return `undefined` for deep paths when `object` is nullish', function(assert) {
+ QUnit.test('should return `undefined` with deep paths when `object` is nullish', function(assert) {
assert.expect(2);
var values = [, null, undefined],
QUnit.test('should create a function that calls a method of a given key', function(assert) {
assert.expect(4);
- var object = { 'a': stubOne };
+ var object = { 'a': alwaysOne };
lodashStable.each(['a', ['a']], function(path) {
var methodOf = _.methodOf(object);
QUnit.test('should work with deep property values', function(assert) {
assert.expect(2);
- var object = { 'a': { 'b': stubTwo } };
+ var object = { 'a': { 'b': alwaysTwo } };
lodashStable.each(['a.b', ['a', 'b']], function(path) {
var methodOf = _.methodOf(object);
});
});
- QUnit.test('should coerce `path` to a string', function(assert) {
- assert.expect(2);
+ QUnit.test('should coerce key to a string', function(assert) {
+ assert.expect(1);
function fn() {}
fn.toString = lodashStable.constant('fn');
- var expected = [1, 2, 3, 4],
- object = { 'null': stubOne, 'undefined': stubTwo, 'fn': stubThree, '[object Object]': stubFour },
- paths = [null, undefined, fn, {}];
+ var expected = [1, 1, 2, 2, 3, 3, 4, 4],
+ objects = [{ 'null': alwaysOne }, { 'undefined': alwaysTwo }, { 'fn': alwaysThree }, { '[object Object]': alwaysFour }],
+ values = [null, undefined, fn, {}];
- lodashStable.times(2, function(index) {
- var actual = lodashStable.map(paths, function(path) {
+ var actual = lodashStable.transform(objects, function(result, object, index) {
+ var key = values[index];
+ lodashStable.each([key, [key]], function(path) {
var methodOf = _.methodOf(object);
- return methodOf(index ? [path] : path);
+ result.push(methodOf(key));
});
-
- assert.deepEqual(actual, expected);
});
+
+ assert.deepEqual(actual, expected);
});
QUnit.test('should work with inherited property values', function(assert) {
assert.expect(2);
function Foo() {}
- Foo.prototype.a = stubOne;
+ Foo.prototype.a = alwaysOne;
lodashStable.each(['a', ['a']], function(path) {
var methodOf = _.methodOf(new Foo);
QUnit.test('should use a key over a path', function(assert) {
assert.expect(2);
- var object = { 'a.b': stubOne, 'a': { 'b': stubTwo } };
+ var object = { 'a.b': alwaysOne, 'a': { 'b': alwaysTwo } };
lodashStable.each(['a.b', ['a.b']], function(path) {
var methodOf = _.methodOf(object);
});
});
- QUnit.test('should return `undefined` for deep paths when `object` is nullish', function(assert) {
+ QUnit.test('should return `undefined` with deep paths when `object` is nullish', function(assert) {
assert.expect(2);
var values = [, null, undefined],
func = _[methodName],
isMax = methodName == 'maxBy';
- QUnit.test('`_.' + methodName + '` should work with an `iteratee`', function(assert) {
+ QUnit.test('`_.' + methodName + '` should work with an `iteratee` argument', function(assert) {
assert.expect(1);
var actual = func(array, function(n) {
if (!isNpm) {
_.mixin(source);
- _.a = stubB;
+ _.a = alwaysB;
assert.strictEqual(_.a(array), 'b');
assert.strictEqual(_(array).a().value(), 'a');
reset(_);
});
- QUnit.test('should accept an `object`', function(assert) {
+ QUnit.test('should accept an `object` argument', function(assert) {
assert.expect(1);
var object = {};
assert.strictEqual(_.mixin(object, new Foo), object);
});
- QUnit.test('should accept an `options`', function(assert) {
+ QUnit.test('should accept an `options` argument', function(assert) {
assert.expect(8);
function message(func, chain) {
QUnit.test('should work with `_.matchesProperty` shorthands', function(assert) {
assert.expect(1);
- var over = _.overArgs(fn, [['b', 1], ['a', 1]]);
+ var over = _.overArgs(fn, ['b', 1], [['a', 1]]);
assert.deepEqual(over({ 'b': 2 }, { 'a': 1 }), [false, true]);
});
assert.strictEqual(negate(1), true);
assert.strictEqual(negate(2), false);
});
+ }());
- QUnit.test('should create a function that negates the result of `func`', function(assert) {
- assert.expect(2);
-
- var negate = _.negate(isEven);
+ /*--------------------------------------------------------------------------*/
- assert.strictEqual(negate(1), true);
- assert.strictEqual(negate(2), false);
- });
+ QUnit.module('lodash.noop');
- QUnit.test('should create a function that accepts multiple arguments', function(assert) {
+ (function() {
+ QUnit.test('should return `undefined`', function(assert) {
assert.expect(1);
- var argCount,
- count = 5,
- negate = _.negate(function() { argCount = arguments.length; }),
- expected = lodashStable.times(count, stubTrue);
+ var values = empties.concat(true, new Date, _, 1, /x/, 'a'),
+ expected = lodashStable.map(values, noop);
- var actual = lodashStable.times(count, function(index) {
- switch (index) {
- case 0: negate(); break;
- case 1: negate(1); break;
- case 2: negate(1, 2); break;
- case 3: negate(1, 2, 3); break;
- case 4: negate(1, 2, 3, 4);
- }
- return argCount == index;
+ var actual = lodashStable.map(values, function(value, index) {
+ return index ? _.noop(value) : _.noop();
});
assert.deepEqual(actual, expected);
QUnit.test('should work with a `root` of `this`', function(assert) {
assert.expect(2);
- if (!coverage && !document && !isModularize && realm.object) {
+ if (!isModularize && !coverage && (!document && realm.object)) {
var fs = require('fs'),
vm = require('vm'),
expected = {},
done();
}, 32);
});
-
- QUnit.test('should work with mocked `Date.now`', function(assert) {
- assert.expect(1);
-
- var now = Date.now;
- Date.now = stubA;
-
- var actual = _.now();
- Date.now = now;
-
- assert.strictEqual(actual, 'a');
- });
}());
/*--------------------------------------------------------------------------*/
assert.expect(2);
var values = falsey,
- expected = lodashStable.map(values, stubA);
+ expected = lodashStable.map(values, alwaysA);
var actual = lodashStable.map(values, function(n) {
return n ? _.nth(array, n) : _.nth(array);
assert.deepEqual(actual, expected);
values = ['1', 1.6];
- expected = lodashStable.map(values, stubB);
+ expected = lodashStable.map(values, alwaysB);
actual = lodashStable.map(values, function(n) {
return _.nth(array, n);
assert.expect(2);
var values = falsey,
- expected = lodashStable.map(values, stubA);
+ expected = lodashStable.map(values, alwaysA);
var actual = lodashStable.map(values, function(n) {
var func = n ? _.nthArg(n) : _.nthArg();
assert.deepEqual(actual, expected);
values = ['1', 1.6];
- expected = lodashStable.map(values, stubB);
+ expected = lodashStable.map(values, alwaysB);
actual = lodashStable.map(values, function(n) {
var func = _.nthArg(n);
QUnit.module('lodash.omit');
(function() {
- var args = toArgs(['a', 'c']),
- object = { 'a': 1, 'b': 2, 'c': 3, 'd': 4 },
- nested = { 'a': 1, 'b': { 'c': 2, 'd': 3 } };
+ var args = arguments,
+ object = { 'a': 1, 'b': 2, 'c': 3, 'd': 4 };
- QUnit.test('should flatten `paths`', function(assert) {
+ QUnit.test('should flatten `props`', function(assert) {
assert.expect(2);
assert.deepEqual(_.omit(object, 'a', 'c'), { 'b': 2, 'd': 4 });
assert.deepEqual(_.omit(object, ['a', 'd'], 'c'), { 'b': 2 });
});
- QUnit.test('should support deep paths', function(assert) {
+ QUnit.test('should work with a primitive `object` argument', function(assert) {
assert.expect(1);
- assert.deepEqual(_.omit(nested, 'b.c'), { 'a': 1, 'b': { 'd': 3} });
- });
-
- QUnit.test('should support path arrays', function(assert) {
- assert.expect(1);
-
- var object = { 'a.b': 1, 'a': { 'b': 2 } },
- actual = _.omit(object, [['a.b']]);
-
- assert.deepEqual(actual, { 'a': { 'b': 2 } });
- });
-
- QUnit.test('should omit a key over a path', function(assert) {
- assert.expect(2);
-
- var object = { 'a.b': 1, 'a': { 'b': 2 } };
-
- lodashStable.each(['a.b', ['a.b']], function(path) {
- assert.deepEqual(_.omit(object, path), { 'a': { 'b': 2 } });
- });
- });
+ stringProto.a = 1;
+ stringProto.b = 2;
- QUnit.test('should coerce `paths` to strings', function(assert) {
- assert.expect(1);
+ assert.deepEqual(_.omit('', 'b'), { 'a': 1 });
- assert.deepEqual(_.omit({ '0': 'a' }, 0), {});
+ delete stringProto.a;
+ delete stringProto.b;
});
QUnit.test('should return an empty object when `object` is nullish', function(assert) {
assert.expect(2);
+ objectProto.a = 1;
lodashStable.each([null, undefined], function(value) {
- objectProto.a = 1;
- var actual = _.omit(value, 'valueOf');
- delete objectProto.a;
- assert.deepEqual(actual, {});
+ assert.deepEqual(_.omit(value, 'valueOf'), {});
});
+ delete objectProto.a;
});
- QUnit.test('should work with a primitive `object`', function(assert) {
- assert.expect(1);
-
- stringProto.a = 1;
- stringProto.b = 2;
-
- assert.deepEqual(_.omit('', 'b'), { 'a': 1 });
-
- delete stringProto.a;
- delete stringProto.b;
- });
-
- QUnit.test('should work with `arguments` object `paths`', function(assert) {
+ QUnit.test('should work with `arguments` objects as secondary arguments', function(assert) {
assert.expect(1);
assert.deepEqual(_.omit(object, args), { 'b': 2, 'd': 4 });
});
- QUnit.test('should not mutate `object`', function(assert) {
- assert.expect(4);
+ QUnit.test('should coerce property names to strings', function(assert) {
+ assert.expect(1);
- lodashStable.each(['a', ['a'], 'a.b', ['a.b']], function(path) {
- var object = { 'a': { 'b': 2 } };
- _.omit(object, path);
- assert.deepEqual(object, { 'a': { 'b': 2 } });
- });
+ assert.deepEqual(_.omit({ '0': 'a' }, 0), {});
});
- }());
+ }('a', 'c'));
/*--------------------------------------------------------------------------*/
var expected = { 'b': 2, 'd': 4 },
func = _[methodName],
object = { 'a': 1, 'b': 2, 'c': 3, 'd': 4 },
- resolve = lodashStable.nthArg(1);
+ prop = lodashStable.nthArg(1);
if (methodName == 'omitBy') {
- resolve = function(object, props) {
+ prop = function(object, props) {
props = lodashStable.castArray(props);
return function(value) {
return lodashStable.some(props, function(key) {
QUnit.test('`_.' + methodName + '` should create an object with omitted string keyed properties', function(assert) {
assert.expect(2);
- assert.deepEqual(func(object, resolve(object, 'a')), { 'b': 2, 'c': 3, 'd': 4 });
- assert.deepEqual(func(object, resolve(object, ['a', 'c'])), expected);
+ assert.deepEqual(func(object, prop(object, 'a')), { 'b': 2, 'c': 3, 'd': 4 });
+ assert.deepEqual(func(object, prop(object, ['a', 'c'])), expected);
});
QUnit.test('`_.' + methodName + '` should include inherited string keyed properties', function(assert) {
function Foo() {}
Foo.prototype = object;
- assert.deepEqual(func(new Foo, resolve(object, ['a', 'c'])), expected);
+ assert.deepEqual(func(new Foo, prop(object, ['a', 'c'])), expected);
});
QUnit.test('`_.' + methodName + '` should preserve the sign of `0`', function(assert) {
expected = [{ '0': 'b' }, { '0': 'b' }, { '-0': 'a' }, { '-0': 'a' }];
var actual = lodashStable.map(props, function(key) {
- return func(object, resolve(object, key));
+ return func(object, prop(object, key));
});
assert.deepEqual(actual, expected);
});
- QUnit.test('`_.' + methodName + '` should include symbols', function(assert) {
- assert.expect(3);
+ QUnit.test('`_.' + methodName + '` should include symbol properties', function(assert) {
+ assert.expect(2);
function Foo() {
this.a = 0;
var symbol2 = Symbol('b');
Foo.prototype[symbol2] = 2;
- var symbol3 = Symbol('c');
- defineProperty(Foo.prototype, symbol3, {
- 'configurable': true,
- 'enumerable': false,
- 'writable': true,
- 'value': 3
- });
-
var foo = new Foo,
- actual = func(foo, resolve(foo, 'a'));
+ actual = func(foo, prop(foo, 'a'));
assert.strictEqual(actual[symbol], 1);
assert.strictEqual(actual[symbol2], 2);
- assert.notOk(symbol3 in actual);
}
else {
- skipAssert(assert, 3);
+ skipAssert(assert, 2);
}
});
- QUnit.test('`_.' + methodName + '` should create an object with omitted symbols', function(assert) {
- assert.expect(8);
+ QUnit.test('`_.' + methodName + '` should create an object with omitted symbol properties', function(assert) {
+ assert.expect(6);
function Foo() {
this.a = 0;
var symbol2 = Symbol('b');
Foo.prototype[symbol2] = 2;
- var symbol3 = Symbol('c');
- defineProperty(Foo.prototype, symbol3, {
- 'configurable': true,
- 'enumerable': false,
- 'writable': true,
- 'value': 3
- });
-
var foo = new Foo,
- actual = func(foo, resolve(foo, symbol));
+ actual = func(foo, prop(foo, symbol));
assert.strictEqual(actual.a, 0);
- assert.notOk(symbol in actual);
+ assert.strictEqual(actual[symbol], undefined);
assert.strictEqual(actual[symbol2], 2);
- assert.notOk(symbol3 in actual);
- actual = func(foo, resolve(foo, symbol2));
+ actual = func(foo, prop(foo, symbol2));
assert.strictEqual(actual.a, 0);
assert.strictEqual(actual[symbol], 1);
- assert.notOk(symbol2 in actual);
- assert.notOk(symbol3 in actual);
+ assert.strictEqual(actual[symbol2], undefined);
}
else {
- skipAssert(assert, 8);
+ skipAssert(assert, 6);
}
});
- QUnit.test('`_.' + methodName + '` should work with an array `object`', function(assert) {
+ QUnit.test('`_.' + methodName + '` should work with an array `object` argument', function(assert) {
assert.expect(1);
var array = [1, 2, 3];
- assert.deepEqual(func(array, resolve(array, ['0', '2'])), { '1': 2 });
+ assert.deepEqual(func(array, prop(array, ['0', '2'])), { '1': 2 });
});
});
QUnit.test('should not throw more than once', function(assert) {
assert.expect(2);
+ var pass = true;
+
var once = _.once(function() {
throw new Error;
});
assert.raises(once);
- once();
- assert.ok(true);
+ try {
+ once();
+ } catch (e) {
+ pass = false;
+ }
+ assert.ok(pass);
});
}());
QUnit.test('should work with `_.matchesProperty` shorthands', function(assert) {
assert.expect(2);
- var over = _.over([['b', 2], ['a', 2]]);
+ var over = _.over(['b', 2], [['a', 2]]);
assert.deepEqual(over({ 'a': 1, 'b': 2 }), [true, false]);
assert.deepEqual(over({ 'a': 2, 'b': 1 }), [false, true]);
QUnit.test('should create a function that returns `true` if all predicates return truthy', function(assert) {
assert.expect(1);
- var over = _.overEvery(stubTrue, stubOne, stubA);
+ var over = _.overEvery(alwaysTrue, alwaysOne, alwaysA);
assert.strictEqual(over(), true);
});
QUnit.test('should work with `_.matchesProperty` shorthands', function(assert) {
assert.expect(2);
- var over = _.overEvery([['b', 2], ['a', 1]]);
+ var over = _.overEvery(['b', 2], [['a', 1]]);
assert.strictEqual(over({ 'a': 1, 'b': 2 }), true);
assert.strictEqual(over({ 'a': 0, 'b': 2 }), false);
QUnit.test('should flatten `predicates`', function(assert) {
assert.expect(1);
- var over = _.overEvery(stubTrue, [stubFalse]);
+ var over = _.overEvery(alwaysTrue, [alwaysFalse]);
assert.strictEqual(over(), false);
});
QUnit.test('should create a function that returns `true` if any predicates return truthy', function(assert) {
assert.expect(2);
- var over = _.overSome(stubFalse, stubOne, stubString);
+ var over = _.overSome(alwaysFalse, alwaysOne, alwaysEmptyString);
assert.strictEqual(over(), true);
- over = _.overSome(stubNull, stubA, stubZero);
+ over = _.overSome(alwaysNull, alwaysA, alwaysZero);
assert.strictEqual(over(), true);
});
QUnit.test('should return `false` if all predicates return falsey', function(assert) {
assert.expect(2);
- var over = _.overSome(stubFalse, stubFalse, stubFalse);
+ var over = _.overSome(alwaysFalse, alwaysFalse, alwaysFalse);
assert.strictEqual(over(), false);
- over = _.overSome(stubNull, stubZero, stubString);
+ over = _.overSome(alwaysNull, alwaysZero, alwaysEmptyString);
assert.strictEqual(over(), false);
});
QUnit.test('should work with `_.matchesProperty` shorthands', function(assert) {
assert.expect(2);
- var over = _.overSome([['b', 2], ['a', 1]]);
+ var over = _.overSome(['a', 1], [['b', 2]]);
assert.strictEqual(over({ 'a': 0, 'b': 2 }), true);
assert.strictEqual(over({ 'a': 0, 'b': 0 }), false);
QUnit.test('should flatten `predicates`', function(assert) {
assert.expect(1);
- var over = _.overSome(stubFalse, [stubTrue]);
+ var over = _.overSome(alwaysFalse, [alwaysTrue]);
assert.strictEqual(over(), true);
});
assert.expect(1);
var values = [Object(string), { 'toString': lodashStable.constant(string) }],
- expected = lodashStable.map(values, stubTrue);
+ expected = lodashStable.map(values, alwaysTrue);
var actual = lodashStable.map(values, function(value) {
return _.pad(value, 6) === ' abc ';
assert.expect(1);
var values = [Object(string), { 'toString': lodashStable.constant(string) }],
- expected = lodashStable.map(values, stubTrue);
+ expected = lodashStable.map(values, alwaysTrue);
var actual = lodashStable.map(values, function(value) {
return _.padEnd(value, 6) === 'abc ';
assert.expect(1);
var values = [Object(string), { 'toString': lodashStable.constant(string) }],
- expected = lodashStable.map(values, stubTrue);
+ expected = lodashStable.map(values, alwaysTrue);
var actual = lodashStable.map(values, function(value) {
return _.padStart(value, 6) === ' abc';
QUnit.module('lodash.parseInt');
(function() {
- QUnit.test('should accept a `radix`', function(assert) {
+ QUnit.test('should accept a `radix` argument', function(assert) {
assert.expect(1);
var expected = lodashStable.range(2, 37);
assert.strictEqual(_.parseInt('08', 10), 8);
});
- QUnit.test('should parse strings with leading whitespace', function(assert) {
+ QUnit.test('should parse strings with leading whitespace (test in Chrome and Firefox)', function(assert) {
assert.expect(2);
var expected = [8, 8, 10, 10, 32, 32, 32, 32];
QUnit.test('should coerce `radix` to a number', function(assert) {
assert.expect(2);
- var object = { 'valueOf': stubZero };
+ var object = { 'valueOf': alwaysZero };
assert.strictEqual(_.parseInt('08', object), 8);
assert.strictEqual(_.parseInt('0x20', object), 32);
});
QUnit.test('should work as a deep `_.defaults`', function(assert) {
assert.expect(1);
- var object = { 'a': { 'b': 2 } },
- source = { 'a': { 'b': 3, 'c': 3 } },
- expected = { 'a': { 'b': 2, 'c': 3 } };
+ var object = { 'a': { 'b': 1 } },
+ source = { 'a': { 'b': 2, 'c': 3 } },
+ expected = { 'a': { 'b': 1, 'c': 3 } };
var defaultsDeep = _.partialRight(_.mergeWith, function deep(value, other) {
return lodashStable.isObject(value) ? _.mergeWith(value, other, deep) : value;
assert.expect(3);
assert.deepEqual(_.partition([], identity), [[], []]);
- assert.deepEqual(_.partition(array, stubTrue), [array, []]);
- assert.deepEqual(_.partition(array, stubFalse), [[], array]);
+ assert.deepEqual(_.partition(array, alwaysTrue), [array, []]);
+ assert.deepEqual(_.partition(array, alwaysFalse), [[], array]);
});
QUnit.test('should use `_.identity` when `predicate` is nullish', function(assert) {
QUnit.module('lodash.pick');
(function() {
- var args = toArgs(['a', 'c']),
- object = { 'a': 1, 'b': 2, 'c': 3, 'd': 4 },
- nested = { 'a': 1, 'b': { 'c': 2, 'd': 3 } };
+ var args = arguments,
+ object = { 'a': 1, 'b': 2, 'c': 3, 'd': 4 };
- QUnit.test('should flatten `paths`', function(assert) {
+ QUnit.test('should flatten `props`', function(assert) {
assert.expect(2);
assert.deepEqual(_.pick(object, 'a', 'c'), { 'a': 1, 'c': 3 });
assert.deepEqual(_.pick(object, ['a', 'd'], 'c'), { 'a': 1, 'c': 3, 'd': 4 });
});
- QUnit.test('should support deep paths', function(assert) {
+ QUnit.test('should work with a primitive `object` argument', function(assert) {
assert.expect(1);
- assert.deepEqual(_.pick(nested, 'b.c'), { 'b': { 'c': 2 } });
- });
-
- QUnit.test('should support path arrays', function(assert) {
- assert.expect(1);
-
- var object = { 'a.b': 1, 'a': { 'b': 2 } },
- actual = _.pick(object, [['a.b']]);
-
- assert.deepEqual(actual, { 'a.b': 1 });
- });
-
- QUnit.test('should pick a key over a path', function(assert) {
- assert.expect(2);
-
- var object = { 'a.b': 1, 'a': { 'b': 2 } };
-
- lodashStable.each(['a.b', ['a.b']], function(path) {
- assert.deepEqual(_.pick(object, path), { 'a.b': 1 });
- });
- });
-
- QUnit.test('should coerce `paths` to strings', function(assert) {
- assert.expect(1);
-
- assert.deepEqual(_.pick({ '0': 'a', '1': 'b' }, 0), { '0': 'a' });
+ assert.deepEqual(_.pick('', 'slice'), { 'slice': ''.slice });
});
QUnit.test('should return an empty object when `object` is nullish', function(assert) {
});
});
- QUnit.test('should work with a primitive `object`', function(assert) {
+ QUnit.test('should work with `arguments` objects as secondary arguments', function(assert) {
assert.expect(1);
- assert.deepEqual(_.pick('', 'slice'), { 'slice': ''.slice });
+ assert.deepEqual(_.pick(object, args), { 'a': 1, 'c': 3 });
});
- QUnit.test('should work with `arguments` object `paths`', function(assert) {
+ QUnit.test('should coerce property names to strings', function(assert) {
assert.expect(1);
- assert.deepEqual(_.pick(object, args), { 'a': 1, 'c': 3 });
+ assert.deepEqual(_.pick({ '0': 'a', '1': 'b' }, 0), { '0': 'a' });
});
- }());
+ }('a', 'c'));
/*--------------------------------------------------------------------------*/
assert.deepEqual(actual, { 'a': 1, 'c': 3 });
});
-
- QUnit.test('should not treat keys with dots as deep paths', function(assert) {
- assert.expect(1);
-
- var object = { 'a.b.c': 1 },
- actual = _.pickBy(object, stubTrue);
-
- assert.deepEqual(actual, { 'a.b.c': 1 });
- });
}());
/*--------------------------------------------------------------------------*/
lodashStable.each(['pick', 'pickBy'], function(methodName) {
var expected = { 'a': 1, 'c': 3 },
func = _[methodName],
- isPick = methodName == 'pick',
object = { 'a': 1, 'b': 2, 'c': 3, 'd': 4 },
- resolve = lodashStable.nthArg(1);
+ prop = lodashStable.nthArg(1);
if (methodName == 'pickBy') {
- resolve = function(object, props) {
+ prop = function(object, props) {
props = lodashStable.castArray(props);
return function(value) {
return lodashStable.some(props, function(key) {
QUnit.test('`_.' + methodName + '` should create an object of picked string keyed properties', function(assert) {
assert.expect(2);
- assert.deepEqual(func(object, resolve(object, 'a')), { 'a': 1 });
- assert.deepEqual(func(object, resolve(object, ['a', 'c'])), expected);
+ assert.deepEqual(func(object, prop(object, 'a')), { 'a': 1 });
+ assert.deepEqual(func(object, prop(object, ['a', 'c'])), expected);
});
QUnit.test('`_.' + methodName + '` should pick inherited string keyed properties', function(assert) {
Foo.prototype = object;
var foo = new Foo;
- assert.deepEqual(func(foo, resolve(foo, ['a', 'c'])), expected);
+ assert.deepEqual(func(foo, prop(foo, ['a', 'c'])), expected);
});
QUnit.test('`_.' + methodName + '` should preserve the sign of `0`', function(assert) {
expected = [{ '-0': 'a' }, { '-0': 'a' }, { '0': 'b' }, { '0': 'b' }];
var actual = lodashStable.map(props, function(key) {
- return func(object, resolve(object, key));
+ return func(object, prop(object, key));
});
assert.deepEqual(actual, expected);
});
- QUnit.test('`_.' + methodName + '` should pick symbols', function(assert) {
- assert.expect(3);
+ QUnit.test('`_.' + methodName + '` should pick symbol properties', function(assert) {
+ assert.expect(2);
function Foo() {
this[symbol] = 1;
var symbol2 = Symbol('b');
Foo.prototype[symbol2] = 2;
- var symbol3 = Symbol('c');
- defineProperty(Foo.prototype, symbol3, {
- 'configurable': true,
- 'enumerable': false,
- 'writable': true,
- 'value': 3
- });
-
var foo = new Foo,
- actual = func(foo, resolve(foo, [symbol, symbol2, symbol3]));
+ actual = func(foo, prop(foo, [symbol, symbol2]));
assert.strictEqual(actual[symbol], 1);
assert.strictEqual(actual[symbol2], 2);
-
- if (isPick) {
- assert.strictEqual(actual[symbol3], 3);
- } else {
- assert.notOk(symbol3 in actual);
- }
}
else {
- skipAssert(assert, 3);
+ skipAssert(assert, 2);
}
});
- QUnit.test('`_.' + methodName + '` should work with an array `object`', function(assert) {
+ QUnit.test('`_.' + methodName + '` should work with an array `object` argument', function(assert) {
assert.expect(1);
var array = [1, 2, 3];
- assert.deepEqual(func(array, resolve(array, '1')), { '1': 2 });
+ assert.deepEqual(func(array, prop(array, '1')), { '1': 2 });
});
});
assert.deepEqual(actual, ['a', 'a', 'b', 'b']);
});
- QUnit.test('should coerce `path` to a string', function(assert) {
- assert.expect(2);
+ QUnit.test('should coerce key to a string', function(assert) {
+ assert.expect(1);
function fn() {}
fn.toString = lodashStable.constant('fn');
- var expected = [1, 2, 3, 4],
- object = { 'null': 1, 'undefined': 2, 'fn': 3, '[object Object]': 4 },
- paths = [null, undefined, fn, {}];
+ var objects = [{ 'null': 1 }, { 'undefined': 2 }, { 'fn': 3 }, { '[object Object]': 4 }],
+ values = [null, undefined, fn, {}];
- lodashStable.times(2, function(index) {
- var actual = lodashStable.map(paths, function(path) {
- var prop = _.property(index ? [path] : path);
- return prop(object);
+ var actual = lodashStable.transform(objects, function(result, object, index) {
+ var key = values[index];
+ lodashStable.each([key, [key]], function(path) {
+ var prop = _.property(key);
+ result.push(prop(object));
});
-
- assert.deepEqual(actual, expected);
});
+
+ assert.deepEqual(actual, [1, 1, 2, 2, 3, 3, 4, 4]);
});
QUnit.test('should pluck a key over a path', function(assert) {
});
});
- QUnit.test('should return `undefined` for deep paths when `object` is nullish', function(assert) {
+ QUnit.test('should return `undefined` with deep paths when `object` is nullish', function(assert) {
assert.expect(2);
var values = [, null, undefined],
assert.deepEqual(actual, ['a', 'a', 'b', 'b']);
});
- QUnit.test('should coerce `path` to a string', function(assert) {
- assert.expect(2);
+ QUnit.test('should coerce key to a string', function(assert) {
+ assert.expect(1);
function fn() {}
fn.toString = lodashStable.constant('fn');
- var expected = [1, 2, 3, 4],
- object = { 'null': 1, 'undefined': 2, 'fn': 3, '[object Object]': 4 },
- paths = [null, undefined, fn, {}];
+ var objects = [{ 'null': 1 }, { 'undefined': 2 }, { 'fn': 3 }, { '[object Object]': 4 }],
+ values = [null, undefined, fn, {}];
- lodashStable.times(2, function(index) {
- var actual = lodashStable.map(paths, function(path) {
+ var actual = lodashStable.transform(objects, function(result, object, index) {
+ var key = values[index];
+ lodashStable.each([key, [key]], function(path) {
var propOf = _.propertyOf(object);
- return propOf(index ? [path] : path);
+ result.push(propOf(key));
});
-
- assert.deepEqual(actual, expected);
});
+
+ assert.deepEqual(actual, [1, 1, 2, 2, 3, 3, 4, 4]);
});
QUnit.test('should pluck a key over a path', function(assert) {
});
});
- QUnit.test('should return `undefined` for deep paths when `object` is nullish', function(assert) {
+ QUnit.test('should return `undefined` with deep paths when `object` is nullish', function(assert) {
assert.expect(2);
var values = [, null, undefined],
/*--------------------------------------------------------------------------*/
- QUnit.module('lodash.pullAll');
-
- (function() {
- QUnit.test('should work with the same value for `array` and `values`', function(assert) {
- assert.expect(1);
-
- var array = [{ 'a': 1 }, { 'b': 2 }],
- actual = _.pullAll(array, array);
-
- assert.deepEqual(actual, []);
- });
- }());
-
- /*--------------------------------------------------------------------------*/
-
QUnit.module('lodash.pullAllBy');
(function() {
- QUnit.test('should accept an `iteratee`', function(assert) {
+ QUnit.test('should accept an `iteratee` argument', function(assert) {
assert.expect(1);
var array = [{ 'x': 1 }, { 'x': 2 }, { 'x': 3 }, { 'x': 1 }];
assert.deepEqual(actual, [{ 'x': 2 }]);
});
- QUnit.test('should provide correct `iteratee` arguments', function(assert) {
+ QUnit.test('should provide the correct `iteratee` arguments', function(assert) {
assert.expect(1);
var args,
QUnit.module('lodash.pullAllWith');
(function() {
- QUnit.test('should work with a `comparator`', function(assert) {
+ QUnit.test('should work with a `comparator` argument', function(assert) {
assert.expect(1);
var objects = [{ 'x': 1, 'y': 1 }, { 'x': 2, 'y': 2 }, { 'x': 3, 'y': 3 }],
var array = [1, 2, 3],
actual = pull(array, [1, 3]);
- assert.strictEqual(actual, array);
assert.deepEqual(array, [2]);
+ assert.ok(actual === array);
});
QUnit.test('`_.' + methodName + '` should preserve holes in arrays', function(assert) {
result[value] = 1;
}, []);
- var expected = lodashStable.map(values, stubOne),
+ var expected = lodashStable.map(values, alwaysOne),
actual = _.pullAt(array, values);
assert.deepEqual(actual, expected);
- expected = lodashStable.map(values, noop);
+ expected = lodashStable.map(values, noop),
actual = lodashStable.at(array, values);
assert.deepEqual(actual, expected);
assert.deepEqual(actual, [[-2], [-2], [-1], [-1]]);
});
- QUnit.test('should support deep paths', function(assert) {
+ QUnit.test('should work with deep paths', function(assert) {
assert.expect(3);
var array = [];
assert.deepEqual(actual, [undefined]);
});
- QUnit.test('should work with a falsey `array` when keys are given', function(assert) {
+ QUnit.test('should work with a falsey `array` argument when keys are given', function(assert) {
assert.expect(1);
var values = falsey.slice(),
assert.deepEqual(actual, [0, 1]);
});
- QUnit.test('should support a `min` and `max`', function(assert) {
+ QUnit.test('should support a `min` and `max` argument', function(assert) {
assert.expect(1);
var min = 5,
max = 10;
- assert.ok(lodashStable.some(array, function() {
+ assert.ok(_.some(array, function() {
var result = _.random(min, max);
return result >= min && result <= max;
}));
});
- QUnit.test('should support not providing a `max`', function(assert) {
+ QUnit.test('should support not providing a `max` argument', function(assert) {
assert.expect(1);
var min = 0,
max = 5;
- assert.ok(lodashStable.some(array, function() {
+ assert.ok(_.some(array, function() {
var result = _.random(max);
return result >= min && result <= max;
}));
return result >= min && result <= max;
}));
- assert.ok(lodashStable.some(array, function() {
- return _.random(MAX_INTEGER);
+ assert.ok(_.some(array, function() {
+ return _.random(MAX_INTEGER) > 0;
}));
});
QUnit.test('should coerce arguments to finite numbers', function(assert) {
- assert.expect(1);
-
- var actual = [
- _.random(NaN, NaN),
- _.random('1', '1'),
- _.random(Infinity, Infinity)
- ];
+ assert.expect(2);
- assert.deepEqual(actual, [0, 1, MAX_INTEGER]);
+ assert.strictEqual(_.random('1', '1'), 1);
+ assert.strictEqual(_.random(NaN, NaN), 0);
});
QUnit.test('should support floats', function(assert) {
assert.ok(actual >= min && actual <= max);
});
- QUnit.test('should support providing a `floating`', function(assert) {
+ QUnit.test('should support providing a `floating` argument', function(assert) {
assert.expect(3);
var actual = _.random(true);
assert.expect(1);
var array = [1, 2, 3],
- expected = lodashStable.map(array, stubTrue),
+ expected = lodashStable.map(array, alwaysTrue),
randoms = lodashStable.map(array, _.random);
var actual = lodashStable.map(randoms, function(result, index) {
assert.deepEqual(func(5, 1), resolve([5, 4, 3, 2]));
});
- QUnit.test('`_.' + methodName + '` should work with a `start`, `end`, and `step`', function(assert) {
+ QUnit.test('`_.' + methodName + '` should work with `start`, `end`, and `step` arguments', function(assert) {
assert.expect(3);
assert.deepEqual(func(0, -4, -1), resolve([0, -1, -2, -3]));
assert.strictEqual(1 / actual[0], -Infinity);
});
- QUnit.test('`_.' + methodName + '` should treat falsey `start` as `0`', function(assert) {
+ QUnit.test('`_.' + methodName + '` should treat falsey `start` arguments as `0`', function(assert) {
assert.expect(13);
lodashStable.each(falsey, function(value, index) {
QUnit.test('`_.' + methodName + '` should coerce arguments to finite numbers', function(assert) {
assert.expect(1);
- var actual = [
- func('1'),
- func('0', 1),
- func(0, 1, '1'),
- func(NaN),
- func(NaN, NaN)
- ];
-
+ var actual = [func('0', 1), func('1'), func(0, 1, '1'), func(NaN), func(NaN, NaN)];
assert.deepEqual(actual, [[0], [0], [0], [], []]);
});
assert.strictEqual(_.reduce(array), 1);
});
- QUnit.test('should provide correct `iteratee` arguments when iterating an array', function(assert) {
+ QUnit.test('should provide the correct `iteratee` arguments when iterating an array', function(assert) {
assert.expect(2);
var args;
assert.deepEqual(args, [1, 2, 1, array]);
});
- QUnit.test('should provide correct `iteratee` arguments when iterating an object', function(assert) {
+ QUnit.test('should provide the correct `iteratee` arguments when iterating an object', function(assert) {
assert.expect(2);
var args,
assert.strictEqual(_.reduceRight(array), 3);
});
- QUnit.test('should provide correct `iteratee` arguments when iterating an array', function(assert) {
+ QUnit.test('should provide the correct `iteratee` arguments when iterating an array', function(assert) {
assert.expect(2);
var args;
assert.deepEqual(args, [3, 2, 1, array]);
});
- QUnit.test('should provide correct `iteratee` arguments when iterating an object', function(assert) {
+ QUnit.test('should provide the correct `iteratee` arguments when iterating an object', function(assert) {
assert.expect(2);
var args,
if (!isNpm) {
var array = lodashStable.range(LARGE_ARRAY_SIZE + 1),
- predicate = function(value) { return isFilter ? isEven(value) : !isEven(value); };
+ predicate = function(value) { return isFilter ? isEven(value) : !isEven(value); },
+ actual = _(array).slice(1).map(square)[methodName](predicate).value();
+
+ assert.deepEqual(actual, _[methodName](lodashStable.map(array.slice(1), square), predicate));
var object = lodashStable.zipObject(lodashStable.times(LARGE_ARRAY_SIZE, function(index) {
return ['key' + index, index];
}));
- var actual = _(array).slice(1).map(square)[methodName](predicate).value();
- assert.deepEqual(actual, _[methodName](lodashStable.map(array.slice(1), square), predicate));
-
actual = _(object).mapValues(square)[methodName](predicate).value();
assert.deepEqual(actual, _[methodName](lodashStable.mapValues(object, square), predicate));
}
}
});
- QUnit.test('`_.' + methodName + '` should provide correct `predicate` arguments in a lazy sequence', function(assert) {
+ QUnit.test('`_.' + methodName + '` should provide the correct `predicate` arguments in a lazy sequence', function(assert) {
assert.expect(5);
if (!isNpm) {
QUnit.test('should modify the array and return removed elements', function(assert) {
assert.expect(2);
- var array = [1, 2, 3, 4],
- actual = _.remove(array, isEven);
+ var array = [1, 2, 3, 4];
+
+ var actual = _.remove(array, function(n) {
+ return n % 2 == 0;
+ });
assert.deepEqual(array, [1, 3]);
assert.deepEqual(actual, [2, 4]);
});
- QUnit.test('should provide correct `predicate` arguments', function(assert) {
+ QUnit.test('should provide the correct `predicate` arguments', function(assert) {
assert.expect(1);
var argsList = [],
assert.strictEqual(_.repeat(string, '2'), 'abcabc');
assert.strictEqual(_.repeat(string, 2.6), 'abcabc');
- assert.strictEqual(_.repeat('*', { 'valueOf': stubThree }), '***');
+ assert.strictEqual(_.repeat('*', { 'valueOf': alwaysThree }), '***');
});
QUnit.test('should coerce `string` to a string', function(assert) {
QUnit.module('lodash.result');
(function() {
- var object = { 'a': 1, 'b': stubB };
+ var object = { 'a': 1, 'b': alwaysB };
QUnit.test('should invoke function values', function(assert) {
assert.expect(1);
QUnit.test('should invoke nested function values', function(assert) {
assert.expect(2);
- var value = { 'a': lodashStable.constant({ 'b': stubB }) };
+ var value = { 'a': lodashStable.constant({ 'b': alwaysB }) };
lodashStable.each(['a.b', ['a', 'b']], function(path) {
assert.strictEqual(_.result(value, path), 'b');
assert.strictEqual(func(object, ['a', 'b', 'c']), 4);
});
- QUnit.test('`_.' + methodName + '` should not ignore empty brackets', function(assert) {
+ QUnit.test('`_.' + methodName + '` should ignore empty brackets', function(assert) {
assert.expect(1);
- var object = { 'a': { '': 1 } };
+ var object = { 'a': 1 };
assert.strictEqual(func(object, 'a[]'), 1);
});
});
});
- QUnit.test('`_.' + methodName + '` should return `undefined` for deep paths when `object` is nullish', function(assert) {
+ QUnit.test('`_.' + methodName + '` should return `undefined` with deep paths when `object` is nullish', function(assert) {
assert.expect(2);
var values = [null, undefined],
});
QUnit.test('`_.' + methodName + '` should return the default value for `undefined` values', function(assert) {
- assert.expect(2);
+ assert.expect(1);
var object = { 'a': {} },
- values = empties.concat(true, new Date, 1, /x/, 'a'),
- expected = lodashStable.map(values, function(value) { return [value, value]; });
+ values = empties.concat(true, new Date, 1, /x/, 'a');
- lodashStable.each(['a.b', ['a', 'b']], function(path) {
- var actual = lodashStable.map(values, function(value) {
- return [func(object, path, value), func(null, path, value)];
- });
+ var expected = lodashStable.transform(values, function(result, value) {
+ result.push(value, value, value, value);
+ });
- assert.deepEqual(actual, expected);
+ var actual = lodashStable.transform(values, function(result, value) {
+ lodashStable.each(['a.b', ['a', 'b']], function(path) {
+ result.push(
+ func(object, path, value),
+ func(null, path, value)
+ );
+ });
});
+
+ assert.deepEqual(actual, expected);
});
QUnit.test('`_.' + methodName + '` should return the default value when `path` is empty', function(assert) {
assert.deepEqual(rest(1, 2, 3, 4), [1, [2, 3, 4]]);
});
- QUnit.test('should treat `start` as `0` for `NaN` or negative values', function(assert) {
+ QUnit.test('should treat `start` as `0` for negative or `NaN` values', function(assert) {
assert.expect(1);
var values = [-1, NaN, 'a'],
var array = [1, 2, 3],
actual = _.reverse(array);
- assert.strictEqual(actual, array);
assert.deepEqual(array, [3, 2, 1]);
+ assert.strictEqual(actual, array);
});
QUnit.test('should return the wrapped reversed `array`', function(assert) {
assert.deepEqual(actual, expected);
});
-
- QUnit.test('`_.' + methodName + '` should not return `NaN` for large `precision` values', function(assert) {
- assert.expect(1);
-
- var results = [
- _.round(10.0000001, 1000),
- _.round(MAX_SAFE_INTEGER, 293)
- ];
-
- var expected = lodashStable.map(results, stubFalse),
- actual = lodashStable.map(results, lodashStable.isNaN);
-
- assert.deepEqual(actual, expected);
- });
});
/*--------------------------------------------------------------------------*/
if (!isModularize) {
var lodash = _.runInContext({
- 'setTimeout': function(func) { func(); }
+ 'setTimeout': function(callback) {
+ callback();
+ }
});
var pass = false;
});
});
- QUnit.test('should return all elements when `n` >= `length`', function(assert) {
+ QUnit.test('should return all elements when `n` >= `array.length`', function(assert) {
assert.expect(4);
lodashStable.each([3, 4, Math.pow(2, 32), Infinity], function(n) {
QUnit.test('should return an empty array for empty collections', function(assert) {
assert.expect(1);
- var expected = lodashStable.map(empties, stubArray);
+ var expected = lodashStable.map(empties, alwaysEmptyArray);
var actual = lodashStable.transform(empties, function(result, value) {
try {
lodashStable.each(['update', 'updateWith', 'set', 'setWith'], function(methodName) {
var func = _[methodName],
- isUpdate = /^update/.test(methodName);
+ isUpdate = methodName == 'update' || methodName == 'updateWith';
var oldValue = 1,
value = 2,
assert.strictEqual(object.a.b.c, value);
});
- QUnit.test('`_.' + methodName + '` should not ignore empty brackets', function(assert) {
+ QUnit.test('`_.' + methodName + '` should ignore empty brackets', function(assert) {
assert.expect(1);
var object = {};
func(object, 'a[]', updater);
- assert.deepEqual(object, { 'a': { '': value } });
+ assert.deepEqual(object, { 'a': value });
});
QUnit.test('`_.' + methodName + '` should handle empty paths', function(assert) {
assert.deepEqual(actual, expected);
});
- QUnit.test('`_.' + methodName + '` should overwrite primitives in the path', function(assert) {
- assert.expect(2);
+ QUnit.test('`_.' + methodName + '` should follow `path` over non-plain objects', function(assert) {
+ assert.expect(4);
- lodashStable.each(['a.b', ['a', 'b']], function(path) {
- var object = { 'a': '' };
+ var object = { 'a': '' },
+ paths = ['constructor.prototype.a', ['constructor', 'prototype', 'a']];
+
+ lodashStable.each(paths, function(path) {
+ func(0, path, updater);
+ assert.strictEqual(0..a, value);
+ delete numberProto.a;
+ });
+ lodashStable.each(['a.replace.b', ['a', 'replace', 'b']], function(path) {
func(object, path, updater);
- assert.deepEqual(object, { 'a': { 'b': 2 } });
- });;
+ assert.strictEqual(stringProto.replace.b, value);
+ delete stringProto.replace.b;
+ });
+ });
+
+ QUnit.test('`_.' + methodName + '` should not error on paths over primitives in strict mode', function(assert) {
+ 'use strict';
+
+ assert.expect(2);
+
+ lodashStable.each(['a', 'a.a.a'], function(path) {
+ numberProto.a = oldValue;
+ try {
+ func(0, path, updater);
+ assert.strictEqual(0..a, oldValue);
+ } catch (e) {
+ assert.ok(false, e.message);
+ }
+ });
+
+ delete numberProto.a;
});
QUnit.test('`_.' + methodName + '` should not create an array for missing non-index property names that start with numbers', function(assert) {
assert.expect(4);
lodashStable.each(['a', ['a'], { 'a': 1 }, NaN], function(value) {
- var object = {},
- pass = true,
- updater = isUpdate ? lodashStable.constant(value) : value;
+ if (defineProperty) {
+ var object = {},
+ pass = true,
+ updater = isUpdate ? lodashStable.constant(value) : value;
- defineProperty(object, 'a', {
- 'configurable': true,
- 'enumerable': true,
- 'get': lodashStable.constant(value),
- 'set': function() { pass = false; }
- });
+ defineProperty(object, 'a', {
+ 'enumerable': true,
+ 'configurable': true,
+ 'get': lodashStable.constant(value),
+ 'set': function() { pass = false; }
+ });
- func(object, 'a', updater);
- assert.ok(pass);
+ func(object, 'a', updater);
+ assert.ok(pass);
+ }
+ else {
+ skipAssert(assert);
+ }
});
});
});
QUnit.module('lodash.size');
(function() {
- var array = [1, 2, 3];
+ var args = arguments,
+ array = [1, 2, 3];
QUnit.test('should return the number of own enumerable string keyed properties of an object', function(assert) {
assert.expect(1);
assert.strictEqual(_.size(array), 3);
});
- QUnit.test('should accept a falsey `object`', function(assert) {
+ QUnit.test('should accept a falsey `object` argument', function(assert) {
assert.expect(1);
- var expected = lodashStable.map(falsey, stubZero);
+ var expected = lodashStable.map(falsey, alwaysZero);
var actual = lodashStable.map(falsey, function(object, index) {
try {
assert.strictEqual(_.size({ 'length': '0' }), 1);
});
- }());
+ }(1, 2, 3));
/*--------------------------------------------------------------------------*/
(function() {
var array = [1, 2, 3];
- QUnit.test('should use a default `start` of `0` and a default `end` of `length`', function(assert) {
+ QUnit.test('should use a default `start` of `0` and a default `end` of `array.length`', function(assert) {
assert.expect(2);
var actual = _.slice(array);
assert.deepEqual(_.slice(array, 1, 3), [2, 3]);
});
- QUnit.test('should work with a `start` >= `length`', function(assert) {
+ QUnit.test('should work with a `start` >= `array.length`', function(assert) {
assert.expect(4);
lodashStable.each([3, 4, Math.pow(2, 32), Infinity], function(start) {
assert.deepEqual(_.slice(array, -1), [3]);
});
- QUnit.test('should work with a negative `start` <= negative `length`', function(assert) {
+ QUnit.test('should work with a negative `start` <= negative `array.length`', function(assert) {
assert.expect(3);
lodashStable.each([-3, -4, -Infinity], function(start) {
assert.deepEqual(_.slice(array, 0, 1), [1]);
});
- QUnit.test('should work with a `end` >= `length`', function(assert) {
+ QUnit.test('should work with a `end` >= `array.length`', function(assert) {
assert.expect(4);
lodashStable.each([3, 4, Math.pow(2, 32), Infinity], function(end) {
assert.deepEqual(_.slice(array, 0, -1), [1, 2]);
});
- QUnit.test('should work with a negative `end` <= negative `length`', function(assert) {
+ QUnit.test('should work with a negative `end` <= negative `array.length`', function(assert) {
assert.expect(3);
lodashStable.each([-3, -4, -Infinity], function(end) {
QUnit.test('should return `false` for empty collections', function(assert) {
assert.expect(1);
- var expected = lodashStable.map(empties, stubFalse);
+ var expected = lodashStable.map(empties, alwaysFalse);
var actual = lodashStable.map(empties, function(value) {
try {
assert.expect(2);
var values = [, null, undefined],
- expected = lodashStable.map(values, stubFalse);
+ expected = lodashStable.map(values, alwaysFalse);
var actual = lodashStable.map(values, function(value, index) {
var array = [0, 0];
assert.deepEqual(actual, expected);
- expected = lodashStable.map(values, stubTrue);
+ expected = lodashStable.map(values, alwaysTrue);
actual = lodashStable.map(values, function(value, index) {
var array = [0, 1];
return index ? _.some(array, value) : _.some(array);
assert.deepEqual(actual, [3, 1, 2]);
});
- QUnit.test('should move `NaN`, nullish, and symbol values to the end', function(assert) {
+ QUnit.test('should move symbol, `null`, `undefined`, and `NaN` values to the end', function(assert) {
assert.expect(2);
var symbol1 = Symbol ? Symbol('a') : null,
assert.deepEqual(actual, expected);
});
- QUnit.test('`_.' + methodName + '` should accept a nullish `array` and a `value`', function(assert) {
+ QUnit.test('`_.' + methodName + '` should accept a falsey `array` argument and a `value`', function(assert) {
assert.expect(1);
- var values = [null, undefined],
- expected = lodashStable.map(values, lodashStable.constant([0, 0, 0]));
+ var expected = lodashStable.map(falsey, lodashStable.constant([0, 0, 0]));
- var actual = lodashStable.map(values, function(array) {
+ var actual = lodashStable.map(falsey, function(array) {
return [func(array, 1), func(array, undefined), func(array, NaN)];
});
var symbol1 = Symbol ? Symbol('a') : null,
symbol2 = Symbol ? Symbol('b') : null,
- symbol3 = Symbol ? Symbol('c') : null,
expected = [1, '2', {}, symbol1, symbol2, null, undefined, NaN, NaN];
lodashStable.each([
], function(array) {
assert.deepEqual(_.sortBy(array), expected);
assert.strictEqual(func(expected, 3), 2);
- assert.strictEqual(func(expected, symbol3), isSortedIndex ? 3 : (Symbol ? 5 : 6));
- assert.strictEqual(func(expected, null), isSortedIndex ? (Symbol ? 5 : 3) : 6);
+ assert.strictEqual(func(expected, symbol1), (isSortedIndex ? 3 : (Symbol ? 5 : 6)));
+ assert.strictEqual(func(expected, null), (isSortedIndex ? (Symbol ? 5 : 3) : 6));
assert.strictEqual(func(expected, undefined), isSortedIndex ? 6 : 7);
assert.strictEqual(func(expected, NaN), isSortedIndex ? 7 : 9);
});
});
-
- QUnit.test('`_.' + methodName + '` should align with `_.sortBy` for nulls', function(assert) {
- assert.expect(3);
-
- var array = [null, null];
-
- assert.strictEqual(func(array, null), isSortedIndex ? 0 : 2);
- assert.strictEqual(func(array, 1), 0);
- assert.strictEqual(func(array, 'a'), 0);
- });
-
- QUnit.test('`_.' + methodName + '` should align with `_.sortBy` for symbols', function(assert) {
- assert.expect(3);
-
- var symbol1 = Symbol ? Symbol('a') : null,
- symbol2 = Symbol ? Symbol('b') : null,
- symbol3 = Symbol ? Symbol('c') : null,
- array = [symbol1, symbol2];
-
- assert.strictEqual(func(array, symbol3), isSortedIndex ? 0 : 2);
- assert.strictEqual(func(array, 1), 0);
- assert.strictEqual(func(array, 'a'), 0);
- });
});
/*--------------------------------------------------------------------------*/
var func = _[methodName],
isSortedIndexBy = methodName == 'sortedIndexBy';
- QUnit.test('`_.' + methodName + '` should provide correct `iteratee` arguments', function(assert) {
+ QUnit.test('`_.' + methodName + '` should provide the correct `iteratee` arguments', function(assert) {
assert.expect(1);
var args;
? 0
: Math.min(length, MAX_ARRAY_INDEX);
- assert.ok(steps == 32 || steps == 33);
- assert.strictEqual(actual, expected);
+ // Avoid false fails in older Firefox.
+ if (array.length == length) {
+ assert.ok(steps == 32 || steps == 33);
+ assert.strictEqual(actual, expected);
+ }
+ else {
+ skipAssert(assert, 2);
+ }
});
});
});
}
QUnit.test('should spread arguments to `func`', function(assert) {
- assert.expect(2);
-
- var spread = _.spread(fn),
- expected = [1, 2];
+ assert.expect(1);
- assert.deepEqual(spread([1, 2]), expected);
- assert.deepEqual(spread([1, 2], 3), expected);
+ var spread = _.spread(fn);
+ assert.deepEqual(spread([4, 2]), [4, 2]);
});
- QUnit.test('should accept a falsey `array`', function(assert) {
+ QUnit.test('should accept a falsey `array` argument', function(assert) {
assert.expect(1);
- var spread = _.spread(stubTrue),
- expected = lodashStable.map(falsey, stubTrue);
+ var spread = _.spread(alwaysTrue),
+ expected = lodashStable.map(falsey, alwaysTrue);
var actual = lodashStable.map(falsey, function(array, index) {
try {
assert.deepEqual(actual, expected);
});
- QUnit.test('should work with `start`', function(assert) {
- assert.expect(2);
+ QUnit.test('should provide the correct `func` arguments', function(assert) {
+ assert.expect(1);
- var spread = _.spread(fn, 1),
- expected = [1, 2, 3];
+ var args;
- assert.deepEqual(spread(1, [2, 3]), expected);
- assert.deepEqual(spread(1, [2, 3], 4), expected);
+ var spread = _.spread(function() {
+ args = slice.call(arguments);
+ });
+
+ spread([4, 2], 'ignored');
+ assert.deepEqual(args, [4, 2]);
+ });
+
+ QUnit.test('should work with `start`', function(assert) {
+ assert.expect(1);
+
+ var spread = _.spread(fn, 1);
+ assert.deepEqual(spread(1, [2, 3, 4]), [1, 2, 3, 4]);
});
QUnit.test('should treat `start` as `0` for negative or `NaN` values', function(assert) {
assert.expect(1);
var values = [-1, NaN, 'a'],
- expected = lodashStable.map(values, lodashStable.constant([1, 2]));
+ expected = lodashStable.map(values, lodashStable.constant([1, 2, 3, 4]));
var actual = lodashStable.map(values, function(value) {
var spread = _.spread(fn, value);
- return spread([1, 2]);
+ return spread([1, 2, 3, 4]);
});
assert.deepEqual(actual, expected);
});
QUnit.test('should coerce `start` to an integer', function(assert) {
- assert.expect(2);
-
- var spread = _.spread(fn, 1.6),
- expected = [1, 2, 3];
+ assert.expect(1);
- assert.deepEqual(spread(1, [2, 3]), expected);
- assert.deepEqual(spread(1, [2, 3], 4), expected);
+ var spread = _.spread(fn, 1.6);
+ assert.deepEqual(spread(1, [2, 3]), [1, 2, 3]);
});
}());
assert.strictEqual(_.startsWith(string, 'b'), false);
});
- QUnit.test('should work with a `position`', function(assert) {
+ QUnit.test('should work with a `position` argument', function(assert) {
assert.expect(1);
assert.strictEqual(_.startsWith(string, 'b', 1), true);
});
- QUnit.test('should work with `position` >= `length`', function(assert) {
+ QUnit.test('should work with `position` >= `string.length`', function(assert) {
assert.expect(4);
lodashStable.each([3, 5, MAX_SAFE_INTEGER, Infinity], function(position) {
QUnit.test('should treat falsey `position` values as `0`', function(assert) {
assert.expect(1);
- var expected = lodashStable.map(falsey, stubTrue);
+ var expected = lodashStable.map(falsey, alwaysTrue);
var actual = lodashStable.map(falsey, function(position) {
return _.startsWith(string, 'a', position);
assert.strictEqual(_.startsWith(string, 'bc', 1.2), true);
});
+
+ QUnit.test('should return `true` when `target` is an empty string regardless of `position`', function(assert) {
+ assert.expect(1);
+
+ assert.ok(lodashStable.every([-Infinity, NaN, -3, -1, 0, 1, 2, 3, 5, MAX_SAFE_INTEGER, Infinity], function(position) {
+ return _.startsWith(string, '', position, true);
+ }));
+ });
}());
/*--------------------------------------------------------------------------*/
assert.expect(2);
var position = isStartsWith ? 1 : 2;
-
assert.strictEqual(func(string, 'b', Object(position)), true);
assert.strictEqual(func(string, 'b', { 'toString': lodashStable.constant(String(position)) }), true);
});
-
- QUnit.test('should return `true` when `target` is an empty string regardless of `position`', function(assert) {
- assert.expect(1);
-
- var positions = [-Infinity, NaN, -3, -1, 0, 1, 2, 3, 5, MAX_SAFE_INTEGER, Infinity];
-
- assert.ok(lodashStable.every(positions, function(position) {
- return func(string, '', position);
- }));
- });
- });
-
- /*--------------------------------------------------------------------------*/
-
- QUnit.module('stub methods');
-
- lodashStable.each(['noop', 'stubTrue', 'stubFalse', 'stubArray', 'stubObject', 'stubString'], function(methodName) {
- var func = _[methodName];
-
- var pair = ({
- 'stubArray': [[], 'an empty array'],
- 'stubFalse': [false, '`false`'],
- 'stubObject': [{}, 'an empty object'],
- 'stubString': ['', 'an empty string'],
- 'stubTrue': [true, '`true`'],
- 'noop': [undefined, '`undefined`']
- })[methodName];
-
- var values = Array(2).concat(empties, true, 1, 'a'),
- expected = lodashStable.map(values, lodashStable.constant(pair[0]));
-
- QUnit.test('`_.' + methodName + '` should return ' + pair[1], function(assert) {
- assert.expect(1);
-
- var actual = lodashStable.map(values, function(value, index) {
- if (index < 2) {
- return index ? func.call({}) : func();
- }
- return func(value);
- });
-
- assert.deepEqual(actual, expected);
- });
});
/*--------------------------------------------------------------------------*/
QUnit.module('math operator methods');
lodashStable.each(['add', 'divide', 'multiply', 'subtract'], function(methodName) {
- var func = _[methodName],
- isAddSub = methodName == 'add' || methodName == 'subtract';
+ var func = _[methodName];
- QUnit.test('`_.' + methodName + '` should return `' + (isAddSub ? 0 : 1) + '` when no arguments are given', function(assert) {
+ QUnit.test('`_.' + methodName + '` should return `0` when no arguments are given', function(assert) {
assert.expect(1);
- assert.strictEqual(func(), isAddSub ? 0 : 1);
+ assert.strictEqual(func(), 0);
});
QUnit.test('`_.' + methodName + '` should work with only one defined argument', function(assert) {
var array = [6, 4, 2],
objects = [{ 'a': 2 }, { 'a': 3 }, { 'a': 1 }];
- QUnit.test('should work with an `iteratee`', function(assert) {
+ QUnit.test('should work with an `iteratee` argument', function(assert) {
assert.expect(1);
var actual = _.sumBy(objects, function(object) {
assert.deepEqual(actual, 6);
});
- QUnit.test('should provide correct `iteratee` arguments', function(assert) {
+ QUnit.test('should provide the correct `iteratee` arguments', function(assert) {
assert.expect(1);
var args;
QUnit.test('`_.' + methodName + '` should return `0` when passing empty `array` values', function(assert) {
assert.expect(1);
- var expected = lodashStable.map(empties, stubZero);
+ var expected = lodashStable.map(empties, alwaysZero);
var actual = lodashStable.map(empties, function(value) {
return func(value);
(function() {
var array = [1, 2, 3];
- QUnit.test('should accept a falsey `array`', function(assert) {
+ QUnit.test('should accept a falsey `array` argument', function(assert) {
assert.expect(1);
- var expected = lodashStable.map(falsey, stubArray);
+ var expected = lodashStable.map(falsey, alwaysEmptyArray);
var actual = lodashStable.map(falsey, function(array, index) {
try {
});
});
- QUnit.test('should return all elements when `n` >= `length`', function(assert) {
+ QUnit.test('should return all elements when `n` >= `array.length`', function(assert) {
assert.expect(4);
lodashStable.each([3, 4, Math.pow(2, 32), Infinity], function(n) {
});
});
- QUnit.test('should return all elements when `n` >= `length`', function(assert) {
+ QUnit.test('should return all elements when `n` >= `array.length`', function(assert) {
assert.expect(4);
lodashStable.each([3, 4, Math.pow(2, 32), Infinity], function(n) {
assert.deepEqual(actual, [3, 4]);
});
- QUnit.test('should provide correct `predicate` arguments', function(assert) {
+ QUnit.test('should provide the correct `predicate` arguments', function(assert) {
assert.expect(1);
var args;
}
});
- QUnit.test('should provide correct `predicate` arguments in a lazy sequence', function(assert) {
+ QUnit.test('should provide the correct `predicate` arguments in a lazy sequence', function(assert) {
assert.expect(5);
if (!isNpm) {
var args,
- array = lodashStable.range(LARGE_ARRAY_SIZE + 1);
-
- var expected = [
- square(LARGE_ARRAY_SIZE),
- LARGE_ARRAY_SIZE - 1,
- lodashStable.map(array.slice(1), square)
- ];
+ array = lodashStable.range(LARGE_ARRAY_SIZE + 1),
+ expected = [square(LARGE_ARRAY_SIZE), LARGE_ARRAY_SIZE - 1, lodashStable.map(array.slice(1), square)];
_(array).slice(1).takeRightWhile(function(value, index, array) {
args = slice.call(arguments);
assert.deepEqual(actual, [1, 2]);
});
- QUnit.test('should provide correct `predicate` arguments', function(assert) {
+ QUnit.test('should provide the correct `predicate` arguments', function(assert) {
assert.expect(1);
var args;
}
});
- QUnit.test('should provide correct `predicate` arguments in a lazy sequence', function(assert) {
+ QUnit.test('should provide the correct `predicate` arguments in a lazy sequence', function(assert) {
assert.expect(5);
if (!isNpm) {
assert.expect(1);
var strings = ['<p><%- value %></p>', '<p><%-value%></p>', '<p><%-\nvalue\n%></p>'],
- expected = lodashStable.map(strings, lodashStable.constant('<p>&<>"'/</p>')),
- data = { 'value': '&<>"\'/' };
+ expected = lodashStable.map(strings, lodashStable.constant('<p>&<>"'`\/</p>')),
+ data = { 'value': '&<>"\'`\/' };
var actual = lodashStable.map(strings, function(string) {
return _.template(string)(data);
assert.strictEqual(compiled({ 'value': 3 }), '<p>6</p>');
});
+ QUnit.test('should not error with IE conditional comments enabled (test with development build)', function(assert) {
+ assert.expect(1);
+
+ var compiled = _.template(''),
+ pass = true;
+
+ /*@cc_on @*/
+ try {
+ compiled();
+ } catch (e) {
+ pass = false;
+ }
+ assert.ok(pass);
+ });
+
QUnit.test('should tokenize delimiters', function(assert) {
assert.expect(1);
assert.expect(1);
var values = [, null, undefined, ''],
- expected = lodashStable.map(values, stubString),
+ expected = lodashStable.map(values, alwaysEmptyString),
data = { 'a': 1 };
var actual = lodashStable.map(values, function(value, index) {
assert.strictEqual(compiled(data), 'AB');
});
- QUnit.test('should coerce `text` to a string', function(assert) {
+ QUnit.test('should coerce `text` argument to a string', function(assert) {
assert.expect(1);
var object = { 'toString': lodashStable.constant('<%= a %>') },
QUnit.test('should not error for non-object `data` and `options` values', function(assert) {
assert.expect(2);
- _.template('')(1);
- assert.ok(true, '`data` value');
+ var pass = true;
- _.template('', 1)(1);
- assert.ok(true, '`options` value');
+ try {
+ _.template('')(1);
+ } catch (e) {
+ pass = false;
+ }
+ assert.ok(pass, '`data` value');
+
+ pass = true;
+
+ try {
+ _.template('', 1)(1);
+ } catch (e) {
+ pass = false;
+ }
+ assert.ok(pass, '`options` value');
});
QUnit.test('should expose the source on compiled templates', function(assert) {
var compiled = _.template('x'),
values = [String(compiled), compiled.source],
- expected = lodashStable.map(values, stubTrue);
+ expected = lodashStable.map(values, alwaysTrue);
var actual = lodashStable.map(values, function(value) {
return lodashStable.includes(value, '__p');
} catch (e) {
values[1] = e.source;
}
- var expected = lodashStable.map(values, stubFalse);
+ var expected = lodashStable.map(values, alwaysFalse);
var actual = lodashStable.map(values, function(value) {
return lodashStable.includes(value, 'sourceURL');
var array = ['<%= a %>', '<%- b %>', '<% print(c) %>'],
compiles = lodashStable.map(array, _.template),
- data = { 'a': 'one', 'b': '"two"', 'c': 'three' };
+ data = { 'a': 'one', 'b': '`two`', 'c': 'three' };
var actual = lodashStable.map(compiles, function(compiled) {
return compiled(data);
});
- assert.deepEqual(actual, ['one', '"two"', 'three']);
+ assert.deepEqual(actual, ['one', '`two`', 'three']);
});
}());
throttled();
var lastCount = callCount;
- assert.ok(callCount);
+ assert.ok(callCount > 0);
setTimeout(function() {
assert.ok(callCount > lastCount);
var done = assert.async();
var throttled = _.throttle(identity, 32),
- results = [throttled('a'), throttled('b')];
+ result = [throttled('a'), throttled('b')];
- assert.deepEqual(results, ['a', 'a']);
+ assert.deepEqual(result, ['a', 'a']);
setTimeout(function() {
- var results = [throttled('c'), throttled('d')];
- assert.notEqual(results[0], 'a');
- assert.notStrictEqual(results[0], undefined);
+ var result = [throttled('x'), throttled('y')];
+ assert.notEqual(result[0], 'a');
+ assert.notStrictEqual(result[0], undefined);
- assert.notEqual(results[1], 'd');
- assert.notStrictEqual(results[1], undefined);
+ assert.notEqual(result[1], 'y');
+ assert.notStrictEqual(result[1], undefined);
done();
}, 64);
});
var callCount = 0,
dateCount = 0;
- var lodash = _.runInContext({
- 'Date': {
- 'now': function() {
- return ++dateCount == 5 ? Infinity : +new Date;
- }
- }
- });
+ var getTime = function() {
+ return ++dateCount == 5
+ ? Infinity
+ : +new Date;
+ };
+
+ var lodash = _.runInContext(lodashStable.assign({}, root, {
+ 'Date': lodashStable.assign(function() {
+ return { 'getTime': getTime };
+ }, {
+ 'now': Date.now
+ })
+ }));
var throttled = lodash.throttle(function() { callCount++; }, 32);
done();
}, 192);
});
-
- QUnit.test('should work with a system time of `0`', function(assert) {
- assert.expect(3);
-
- var done = assert.async();
-
- if (!isModularize) {
- var callCount = 0,
- dateCount = 0;
-
- var lodash = _.runInContext({
- 'Date': {
- 'now': function() {
- return ++dateCount < 4 ? 0 : +new Date;
- }
- }
- });
-
- var throttled = lodash.throttle(function(value) {
- callCount++;
- return value;
- }, 32);
-
- var results = [throttled('a'), throttled('b'), throttled('c')];
- assert.deepEqual(results, ['a', 'a', 'a']);
- assert.strictEqual(callCount, 1);
-
- setTimeout(function() {
- assert.strictEqual(callCount, 2);
- done();
- }, 64);
- }
- else {
- skipAssert(assert, 3);
- done();
- }
- });
}());
/*--------------------------------------------------------------------------*/
QUnit.test('`_.' + methodName + '` should not error for non-object `options` values', function(assert) {
assert.expect(1);
- func(noop, 32, 1);
- assert.ok(true);
+ var pass = true;
+
+ try {
+ func(noop, 32, 1);
+ } catch (e) {
+ pass = false;
+ }
+ assert.ok(pass);
});
QUnit.test('`_.' + methodName + '` should use a default `wait` of `0`', function(assert) {
var callCount = 0,
dateCount = 0;
- var lodash = _.runInContext({
- 'Date': {
- 'now': function() {
- return ++dateCount == 4
- ? +new Date(2012, 3, 23, 23, 27, 18)
- : +new Date;
- }
- }
- });
+ var getTime = function() {
+ return ++dateCount === 4
+ ? +new Date(2012, 3, 23, 23, 27, 18)
+ : +new Date;
+ };
+
+ var lodash = _.runInContext(lodashStable.assign({}, root, {
+ 'Date': lodashStable.assign(function() {
+ return { 'getTime': getTime, 'valueOf': getTime };
+ }, {
+ 'now': Date.now
+ })
+ }));
var funced = lodash[methodName](function() {
callCount++;
QUnit.test('should coerce `n` to an integer', function(assert) {
assert.expect(1);
- var actual = _.times(2.6, _.identity);
+ var actual = _.times(2.6, _.indentify);
assert.deepEqual(actual, [0, 1]);
});
- QUnit.test('should provide correct `iteratee` arguments', function(assert) {
+ QUnit.test('should provide the correct `iteratee` arguments', function(assert) {
assert.expect(1);
var args;
assert.deepEqual(_.times(3, doubled), [0, 2, 4]);
});
- QUnit.test('should return an empty array for falsey and negative `n` values', function(assert) {
+ QUnit.test('should return an empty array for falsey and negative `n` arguments', function(assert) {
assert.expect(1);
var values = falsey.concat(-1, -Infinity),
- expected = lodashStable.map(values, stubArray);
+ expected = lodashStable.map(values, alwaysEmptyArray);
var actual = lodashStable.map(values, function(value, index) {
return index ? _.times(value) : _.times();
assert.deepEqual(_.toArray({ 'a': 1, 'b': 2 }), [1, 2]);
});
+ QUnit.test('should convert strings to arrays', function(assert) {
+ assert.expect(3);
+
+ assert.deepEqual(_.toArray(''), []);
+ assert.deepEqual(_.toArray('ab'), ['a', 'b']);
+ assert.deepEqual(_.toArray(Object('ab')), ['a', 'b']);
+ });
+
QUnit.test('should convert iterables to arrays', function(assert) {
assert.expect(1);
- if (Symbol && Symbol.iterator) {
+ if (!isNpm && Symbol && Symbol.iterator) {
var object = { '0': 'a', 'length': 1 };
object[Symbol.iterator] = arrayProto[Symbol.iterator];
}
});
- QUnit.test('should convert maps to arrays', function(assert) {
- assert.expect(1);
-
- if (Map) {
- var map = new Map;
- map.set('a', 1);
- map.set('b', 2);
- assert.deepEqual(_.toArray(map), [['a', 1], ['b', 2]]);
- }
- else {
- skipAssert(assert);
- }
- });
-
- QUnit.test('should convert strings to arrays', function(assert) {
- assert.expect(3);
-
- assert.deepEqual(_.toArray(''), []);
- assert.deepEqual(_.toArray('ab'), ['a', 'b']);
- assert.deepEqual(_.toArray(Object('ab')), ['a', 'b']);
- });
-
QUnit.test('should work in a lazy sequence', function(assert) {
assert.expect(2);
if (!isNpm) {
- var array = lodashStable.range(LARGE_ARRAY_SIZE + 1);
+ var array = lodashStable.range(LARGE_ARRAY_SIZE + 1),
+ actual = _(array).slice(1).map(String).toArray().value();
+
+ assert.deepEqual(actual, lodashStable.map(array.slice(1), String));
var object = lodashStable.zipObject(lodashStable.times(LARGE_ARRAY_SIZE, function(index) {
return ['key' + index, index];
}));
- var actual = _(array).slice(1).map(String).toArray().value();
- assert.deepEqual(actual, lodashStable.map(array.slice(1), String));
-
actual = _(object).toArray().slice(1).map(String).value();
assert.deepEqual(actual, _.map(_.toArray(object).slice(1), String));
}
QUnit.module('lodash.slice and lodash.toArray');
lodashStable.each(['slice', 'toArray'], function(methodName) {
- var array = [1, 2, 3],
+ var args = (function() { return arguments; }(1, 2, 3)),
+ array = [1, 2, 3],
func = _[methodName];
QUnit.test('`_.' + methodName + '` should return a dense array', function(assert) {
QUnit.test('`_.' + methodName + '` should treat array-like objects like arrays', function(assert) {
assert.expect(2);
- var object = { '0': 'a', 'length': 1 };
- assert.deepEqual(func(object), ['a']);
+ var object = { '0': 'a', '1': 'b', '2': 'c', 'length': 3 };
+ assert.deepEqual(func(object), ['a', 'b', 'c']);
assert.deepEqual(func(args), array);
});
QUnit.module('number coercion methods');
- lodashStable.each(['toFinite', 'toInteger', 'toNumber', 'toSafeInteger'], function(methodName) {
+ lodashStable.each(['toInteger', 'toNumber', 'toSafeInteger'], function(methodName) {
var func = _[methodName];
QUnit.test('`_.' + methodName + '` should preserve the sign of `0`', function(assert) {
});
});
- lodashStable.each(['toFinite', 'toInteger', 'toLength', 'toNumber', 'toSafeInteger'], function(methodName) {
+ lodashStable.each(['toInteger', 'toLength', 'toNumber', 'toSafeInteger'], function(methodName) {
var func = _[methodName],
- isToFinite = methodName == 'toFinite',
isToLength = methodName == 'toLength',
isToNumber = methodName == 'toNumber',
isToSafeInteger = methodName == 'toSafeInteger';
var expected = lodashStable.map(values, function(value) {
if (!isToNumber) {
- if (!isToFinite && value == 1.2) {
+ if (value == 1.2) {
value = 1;
}
else if (value == Infinity) {
var expected = lodashStable.map(values, function(value) {
var n = +value;
if (!isToNumber) {
- if (!isToFinite && n == 1.234567890) {
+ if (n == 1.234567890) {
n = 1;
}
else if (n == Infinity) {
n = MAX_INTEGER;
}
- else if ((!isToFinite && n == Number.MIN_VALUE) || n !== n) {
+ else if (n == Number.MIN_VALUE || n !== n) {
n = 0;
}
if (isToLength || isToSafeInteger) {
];
var expected = [
- NaN, 0, 1, NaN,
- NaN, 2.2, 1.1, 1.1,
+ NaN, 0, 1, NaN,
+ NaN, 2.2, 1.1, 1.1,
NaN, NaN,
5349, 5349,
42, 42
];
- if (isToFinite) {
+ if (!isToNumber) {
expected = [
- 0, 0, 1, 0,
- 0, 2.2, 1.1, 1.1,
- 0, 0,
+ 0, 0, 1, 0,
+ 0, 2, 1, 1,
+ 0, 0,
5349, 5349,
- 42, 42
- ];
- }
- else if (!isToNumber) {
- expected = [
- 0, 0, 1, 0,
- 0, 2, 1, 1,
- 0, 0,
- 5349, 5349,
- 42, 42
+ 42, 42
];
}
var actual = lodashStable.map(values, func);
assert.deepEqual(actual, [['a', 1], ['b', 2]]);
});
- QUnit.test('`_.' + methodName + '` should ' + (isToPairs ? 'not ' : '') + 'include inherited string keyed property values', function(assert) {
- assert.expect(1);
-
- function Foo() {
- this.a = 1;
- }
- Foo.prototype.b = 2;
-
- var expected = isToPairs ? [['a', 1]] : [['a', 1], ['b', 2]],
- actual = lodashStable.sortBy(func(new Foo), 0);
-
- assert.deepEqual(actual, expected);
- });
-
- QUnit.test('`_.' + methodName + '` should convert objects with a `length` property', function(assert) {
+ QUnit.test('`_.' + methodName + '` should work with an object that has a `length` property', function(assert) {
assert.expect(1);
var object = { '0': 'a', '1': 'b', 'length': 2 },
assert.deepEqual(actual, [['0', 'a'], ['1', 'b'], ['length', 2]]);
});
- QUnit.test('`_.' + methodName + '` should convert maps', function(assert) {
+ QUnit.test('`_.' + methodName + '` should ' + (isToPairs ? 'not ' : '') + 'include inherited string keyed property values', function(assert) {
assert.expect(1);
- if (Map) {
- var map = new Map;
- map.set('a', 1);
- map.set('b', 2);
- assert.deepEqual(func(map), [['a', 1], ['b', 2]]);
- }
- else {
- skipAssert(assert);
+ function Foo() {
+ this.a = 1;
}
- });
+ Foo.prototype.b = 2;
- QUnit.test('`_.' + methodName + '` should convert sets', function(assert) {
- assert.expect(1);
+ var expected = isToPairs ? [['a', 1]] : [['a', 1], ['b', 2]],
+ actual = lodashStable.sortBy(func(new Foo), 0);
- if (Set) {
- var set = new Set;
- set.add(1);
- set.add(2);
- assert.deepEqual(func(set), [[1, 1], [2, 2]]);
- }
- else {
- skipAssert(assert);
- }
+ assert.deepEqual(actual, expected);
});
- QUnit.test('`_.' + methodName + '` should convert strings', function(assert) {
+ QUnit.test('`_.' + methodName + '` should work with strings', function(assert) {
assert.expect(2);
lodashStable.each(['xo', Object('xo')], function(string) {
});
});
- QUnit.test('should return new path array', function(assert) {
+ QUnit.test('should a new path array', function(assert) {
assert.expect(1);
assert.notStrictEqual(_.toPath('a.b.c'), _.toPath('a.b.c'));
assert.deepEqual(actual, ['a', '-1.23', '["b"]', 'c', "['d']", '\ne\n', 'f', 'g']);
});
- QUnit.test('should handle consecutive empty brackets and dots', function(assert) {
- assert.expect(12);
-
- var expected = ['', 'a'];
- assert.deepEqual(_.toPath('.a'), expected);
- assert.deepEqual(_.toPath('[].a'), expected);
-
- expected = ['', '', 'a'];
- assert.deepEqual(_.toPath('..a'), expected);
- assert.deepEqual(_.toPath('[][].a'), expected);
-
- expected = ['a', '', 'b'];
- assert.deepEqual(_.toPath('a..b'), expected);
- assert.deepEqual(_.toPath('a[].b'), expected);
-
- expected = ['a', '', '', 'b'];
- assert.deepEqual(_.toPath('a...b'), expected);
- assert.deepEqual(_.toPath('a[][].b'), expected);
+ QUnit.test('should ignore consecutive brackets and dots', function(assert) {
+ assert.expect(4);
- expected = ['a', ''];
+ var expected = ['a'];
assert.deepEqual(_.toPath('a.'), expected);
assert.deepEqual(_.toPath('a[]'), expected);
- expected = ['a', '', ''];
- assert.deepEqual(_.toPath('a..'), expected);
- assert.deepEqual(_.toPath('a[][]'), expected);
+ expected = ['a', 'b'];
+ assert.deepEqual(_.toPath('a..b'), expected);
+ assert.deepEqual(_.toPath('a[][]b'), expected);
});
}());
QUnit.module('lodash.toPlainObject');
(function() {
+ var args = arguments;
+
QUnit.test('should flatten inherited string keyed properties', function(assert) {
assert.expect(1);
assert.deepEqual(actual, expected);
});
- }());
+ }(1, 2, 3));
/*--------------------------------------------------------------------------*/
assert.expect(1);
var values = [, null, undefined],
- expected = lodashStable.map(values, stubString);
+ expected = lodashStable.map(values, alwaysEmptyString);
var actual = lodashStable.map(values, function(value, index) {
return index ? _.toString(value) : _.toString();
assert.deepEqual(actual, expected);
});
- QUnit.test('should preserve the sign of `0` in an array', function(assert) {
- assert.expect(1);
-
- var values = [-0, Object(-0), 0, Object(0)];
- assert.deepEqual(_.toString(values), '-0,-0,0,0');
- });
-
QUnit.test('should not error on symbols', function(assert) {
assert.expect(1);
}
});
- QUnit.test('should not error on an array of symbols', function(assert) {
- assert.expect(1);
-
- if (Symbol) {
- try {
- assert.strictEqual(_.toString([symbol]), 'Symbol(a)');
- } catch (e) {
- assert.ok(false, e.message);
- }
- }
- else {
- skipAssert(assert);
- }
- });
-
QUnit.test('should return the `toString` result of the wrapped value', function(assert) {
assert.expect(1);
var accumulators = [, null, undefined],
object = new Foo,
- expected = lodashStable.map(accumulators, stubTrue);
+ expected = lodashStable.map(accumulators, alwaysTrue);
var iteratee = function(result, value, key) {
result[key] = square(value);
QUnit.test('should create regular arrays from typed arrays', function(assert) {
assert.expect(1);
- var expected = lodashStable.map(typedArrays, stubTrue);
+ var expected = lodashStable.map(typedArrays, alwaysTrue);
var actual = lodashStable.map(typedArrays, function(type) {
var Ctor = root[type],
assert.deepEqual(actual, ['undefined']);
});
- QUnit.test('should work without an `iteratee`', function(assert) {
+ QUnit.test('should work without an `iteratee` argument', function(assert) {
assert.expect(1);
assert.ok(_.transform(new Foo) instanceof Foo);
var Ctors = [Boolean, Boolean, Number, Number, Number, String, String],
values = [false, true, 0, 1, NaN, '', 'a'],
- expected = lodashStable.map(values, stubObject);
+ expected = lodashStable.map(values, alwaysEmptyObject);
var results = lodashStable.map(values, function(value) {
return _.transform(value);
assert.deepEqual(results, expected);
- expected = lodashStable.map(values, stubFalse);
+ expected = lodashStable.map(values, alwaysFalse);
var actual = lodashStable.map(results, function(value, index) {
return value instanceof Ctors[index];
Foo.prototype.constructor = Foo;
});
- QUnit.test('should create an empty object when given a falsey `object`', function(assert) {
+ QUnit.test('should create an empty object when given a falsey `object` argument', function(assert) {
assert.expect(1);
- var expected = lodashStable.map(falsey, stubObject);
+ var expected = lodashStable.map(falsey, alwaysEmptyObject);
var actual = lodashStable.map(falsey, function(object, index) {
return index ? _.transform(object) : _.transform();
'object': { 'a': 1, 'b': 2, 'c': 3 }
},
function(object, key) {
- QUnit.test('should provide correct `iteratee` arguments when transforming an ' + key, function(assert) {
+ QUnit.test('should provide the correct `iteratee` arguments when transforming an ' + key, function(assert) {
assert.expect(2);
var args;
return lodashStable.isObject(value) && !lodashStable.isElement(value);
});
- var expected = lodashStable.map(objects, stubTrue);
+ var expected = lodashStable.map(objects, alwaysTrue);
var actual = lodashStable.map(objects, function(object) {
var Ctor = object.constructor,
assert.deepEqual(actual, [6, 8, 10]);
});
- QUnit.test('should not force a minimum argument count', function(assert) {
+ QUnit.test('should work when provided less than the capped number of arguments', function(assert) {
assert.expect(1);
var capped = _.unary(fn);
assert.deepEqual(capped(), []);
});
-
- QUnit.test('should use `this` binding of function', function(assert) {
- assert.expect(1);
-
- var capped = _.unary(function(a, b) { return this; }),
- object = { 'capped': capped };
-
- assert.strictEqual(object.capped(), object);
- });
}());
/*--------------------------------------------------------------------------*/
QUnit.module('lodash.unescape');
(function() {
- var escaped = '&<>"'/',
- unescaped = '&<>"\'/';
+ var escaped = '&<>"'\/',
+ unescaped = '&<>"\'\/';
escaped += escaped;
unescaped += unescaped;
assert.strictEqual(_.unescape(escaped), unescaped);
});
+ QUnit.test('should not unescape the "/" entity', function(assert) {
+ assert.expect(1);
+
+ assert.strictEqual(_.unescape('/'), '/');
+ });
+
QUnit.test('should handle strings with nothing to unescape', function(assert) {
assert.expect(1);
assert.strictEqual(_.unescape(_.escape(unescaped)), unescaped);
});
+ }());
- lodashStable.each(['`', '/'], function(entity) {
- QUnit.test('should not unescape the "' + entity + '" entity', function(assert) {
- assert.expect(1);
+ /*--------------------------------------------------------------------------*/
- assert.strictEqual(_.unescape(entity), entity);
+ QUnit.module('lodash.unionBy');
+
+ (function() {
+ QUnit.test('should accept an `iteratee` argument', function(assert) {
+ assert.expect(2);
+
+ var actual = _.unionBy([2.1, 1.2], [4.3, 2.4], Math.floor);
+ assert.deepEqual(actual, [2.1, 1.2, 4.3]);
+
+ actual = _.unionBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x');
+ assert.deepEqual(actual, [{ 'x': 1 }, { 'x': 2 }]);
+ });
+
+ QUnit.test('should provide the correct `iteratee` arguments', function(assert) {
+ assert.expect(1);
+
+ var args;
+
+ _.unionBy([2.1, 1.2], [4.3, 2.4], function() {
+ args || (args = slice.call(arguments));
});
+
+ assert.deepEqual(args, [2.1]);
});
}());
/*--------------------------------------------------------------------------*/
- QUnit.module('union methods');
-
- lodashStable.each(['union', 'unionBy', 'unionWith'], function(methodName) {
- var func = _[methodName];
+ QUnit.module('lodash.unionWith');
- QUnit.test('`_.' + methodName + '` should return the union of two arrays', function(assert) {
+ (function() {
+ QUnit.test('should work with a `comparator` argument', function(assert) {
assert.expect(1);
- var actual = func([2], [1, 2]);
- assert.deepEqual(actual, [2, 1]);
+ var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }],
+ others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }],
+ actual = _.unionWith(objects, others, lodashStable.isEqual);
+
+ assert.deepEqual(actual, [objects[0], objects[1], others[0]]);
});
+ }());
+
+ /*--------------------------------------------------------------------------*/
- QUnit.test('`_.' + methodName + '` should return the union of multiple arrays', function(assert) {
+ QUnit.module('union methods');
+
+ lodashStable.each(['union', 'unionBy', 'unionWith'], function(methodName) {
+ var args = (function() { return arguments; }(1, 2, 3)),
+ func = _[methodName];
+
+ QUnit.test('`_.' + methodName + '` should return the union of the given arrays', function(assert) {
assert.expect(1);
- var actual = func([2], [1, 2], [2, 3]);
- assert.deepEqual(actual, [2, 1, 3]);
+ var actual = func([1, 3, 2], [5, 2, 1, 4], [2, 1]);
+ assert.deepEqual(actual, [1, 3, 2, 5, 4]);
});
QUnit.test('`_.' + methodName + '` should not flatten nested arrays', function(assert) {
/*--------------------------------------------------------------------------*/
- QUnit.module('lodash.unionBy');
+ QUnit.module('lodash.uniq');
(function() {
- QUnit.test('should accept an `iteratee`', function(assert) {
+ QUnit.test('should perform an unsorted uniq when used as an iteratee for methods like `_.map`', function(assert) {
+ assert.expect(1);
+
+ var array = [[2, 1, 2], [1, 2, 1]],
+ actual = lodashStable.map(array, lodashStable.uniq);
+
+ assert.deepEqual(actual, [[2, 1], [1, 2]]);
+ });
+ }());
+
+ /*--------------------------------------------------------------------------*/
+
+ QUnit.module('uniqBy methods');
+
+ lodashStable.each(['uniqBy', 'sortedUniqBy'], function(methodName) {
+ var func = _[methodName],
+ isSorted = methodName == 'sortedUniqBy',
+ objects = [{ 'a': 2 }, { 'a': 3 }, { 'a': 1 }, { 'a': 2 }, { 'a': 3 }, { 'a': 1 }];
+
+ if (isSorted) {
+ objects = _.sortBy(objects, 'a');
+ }
+ QUnit.test('`_.' + methodName + '` should work with an `iteratee` argument', function(assert) {
+ assert.expect(1);
+
+ var expected = isSorted ? [{ 'a': 1 }, { 'a': 2 }, { 'a': 3 }] : objects.slice(0, 3);
+
+ var actual = func(objects, function(object) {
+ return object.a;
+ });
+
+ assert.deepEqual(actual, expected);
+ });
+
+ QUnit.test('should work with large arrays', function(assert) {
assert.expect(2);
- var actual = _.unionBy([2.1], [1.2, 2.3], Math.floor);
- assert.deepEqual(actual, [2.1, 1.2]);
+ var largeArray = lodashStable.times(LARGE_ARRAY_SIZE, function() {
+ return [1, 2];
+ });
- actual = _.unionBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x');
- assert.deepEqual(actual, [{ 'x': 1 }, { 'x': 2 }]);
+ var actual = func(largeArray, String);
+
+ assert.deepEqual(actual, [[1, 2]]);
+ assert.strictEqual(actual[0], largeArray[0]);
});
- QUnit.test('should provide correct `iteratee` arguments', function(assert) {
+ QUnit.test('`_.' + methodName + '` should provide the correct `iteratee` arguments', function(assert) {
assert.expect(1);
var args;
- _.unionBy([2.1], [1.2, 2.3], function() {
+ func(objects, function() {
args || (args = slice.call(arguments));
});
- assert.deepEqual(args, [2.1]);
+ assert.deepEqual(args, [objects[0]]);
});
- QUnit.test('should output values from the first possible array', function(assert) {
- assert.expect(1);
+ QUnit.test('`_.' + methodName + '` should work with `_.property` shorthands', function(assert) {
+ assert.expect(2);
- var actual = _.unionBy([{ 'x': 1, 'y': 1 }], [{ 'x': 1, 'y': 2 }], 'x');
- assert.deepEqual(actual, [{ 'x': 1, 'y': 1 }]);
+ var expected = isSorted ? [{ 'a': 1 }, { 'a': 2 }, { 'a': 3 }] : objects.slice(0, 3),
+ actual = func(objects, 'a');
+
+ assert.deepEqual(actual, expected);
+
+ var arrays = [[2], [3], [1], [2], [3], [1]];
+ if (isSorted) {
+ arrays = lodashStable.sortBy(arrays, 0);
+ }
+ expected = isSorted ? [[1], [2], [3]] : arrays.slice(0, 3);
+ actual = func(arrays, 0);
+
+ assert.deepEqual(actual, expected);
});
- }());
+
+ lodashStable.each({
+ 'an array': [0, 'a'],
+ 'an object': { '0': 'a' },
+ 'a number': 0,
+ 'a string': '0'
+ },
+ function(iteratee, key) {
+ QUnit.test('`_.' + methodName + '` should work with ' + key + ' for `iteratee`', function(assert) {
+ assert.expect(1);
+
+ var actual = func([['a'], ['a'], ['b']], iteratee);
+ assert.deepEqual(actual, [['a'], ['b']]);
+ });
+ });
+ });
/*--------------------------------------------------------------------------*/
- QUnit.module('lodash.unionWith');
+ QUnit.module('lodash.uniqWith');
(function() {
- QUnit.test('should work with a `comparator`', function(assert) {
+ QUnit.test('should work with a `comparator` argument', function(assert) {
assert.expect(1);
- var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }],
- others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }],
- actual = _.unionWith(objects, others, lodashStable.isEqual);
+ var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }, { 'x': 1, 'y': 2 }],
+ actual = _.uniqWith(objects, lodashStable.isEqual);
- assert.deepEqual(actual, [objects[0], objects[1], others[0]]);
+ assert.deepEqual(actual, [objects[0], objects[1]]);
});
- QUnit.test('should output values from the first possible array', function(assert) {
+ QUnit.test('should preserve the sign of `0`', function(assert) {
assert.expect(1);
- var objects = [{ 'x': 1, 'y': 1 }],
- others = [{ 'x': 1, 'y': 2 }];
+ var largeArray = lodashStable.times(LARGE_ARRAY_SIZE, function(index) {
+ return isEven(index) ? -0 : 0;
+ });
+
+ var arrays = [[-0, 0], largeArray],
+ expected = lodashStable.map(arrays, lodashStable.constant(['-0']));
- var actual = _.unionWith(objects, others, function(a, b) {
- return a.x == b.x;
+ var actual = lodashStable.map(arrays, function(array) {
+ return lodashStable.map(_.uniqWith(array, lodashStable.eq), lodashStable.toString);
});
- assert.deepEqual(actual, [{ 'x': 1, 'y': 1 }]);
+ assert.deepEqual(actual, expected);
});
}());
QUnit.test('`_.' + methodName + '` should return unique values of an unsorted array', function(assert) {
assert.expect(1);
- var array = [2, 1, 2];
- assert.deepEqual(func(array), [2, 1]);
+ var array = [2, 3, 1, 2, 3, 1];
+ assert.deepEqual(func(array), [2, 3, 1]);
});
}
QUnit.test('`_.' + methodName + '` should return unique values of a sorted array', function(assert) {
assert.expect(1);
- var array = [1, 2, 2];
- assert.deepEqual(func(array), [1, 2]);
+ var array = [1, 1, 2, 2, 3];
+ assert.deepEqual(func(array), [1, 2, 3]);
});
QUnit.test('`_.' + methodName + '` should treat object instances as unique', function(assert) {
/*--------------------------------------------------------------------------*/
- QUnit.module('lodash.uniq');
-
- (function() {
- QUnit.test('should perform an unsorted uniq when used as an iteratee for methods like `_.map`', function(assert) {
- assert.expect(1);
-
- var array = [[2, 1, 2], [1, 2, 1]],
- actual = lodashStable.map(array, lodashStable.uniq);
-
- assert.deepEqual(actual, [[2, 1], [1, 2]]);
- });
- }());
-
- /*--------------------------------------------------------------------------*/
-
- QUnit.module('uniqBy methods');
-
- lodashStable.each(['uniqBy', 'sortedUniqBy'], function(methodName) {
- var func = _[methodName],
- isSorted = methodName == 'sortedUniqBy',
- objects = [{ 'a': 2 }, { 'a': 3 }, { 'a': 1 }, { 'a': 2 }, { 'a': 3 }, { 'a': 1 }];
-
- if (isSorted) {
- objects = _.sortBy(objects, 'a');
- }
- QUnit.test('`_.' + methodName + '` should work with an `iteratee`', function(assert) {
- assert.expect(1);
-
- var expected = isSorted ? [{ 'a': 1 }, { 'a': 2 }, { 'a': 3 }] : objects.slice(0, 3);
-
- var actual = func(objects, function(object) {
- return object.a;
- });
-
- assert.deepEqual(actual, expected);
- });
-
- QUnit.test('should work with large arrays', function(assert) {
- assert.expect(2);
-
- var largeArray = lodashStable.times(LARGE_ARRAY_SIZE, function() {
- return [1, 2];
- });
-
- var actual = func(largeArray, String);
- assert.strictEqual(actual[0], largeArray[0]);
- assert.deepEqual(actual, [[1, 2]]);
- });
-
- QUnit.test('`_.' + methodName + '` should provide correct `iteratee` arguments', function(assert) {
- assert.expect(1);
-
- var args;
-
- func(objects, function() {
- args || (args = slice.call(arguments));
- });
-
- assert.deepEqual(args, [objects[0]]);
- });
-
- QUnit.test('`_.' + methodName + '` should work with `_.property` shorthands', function(assert) {
- assert.expect(2);
-
- var expected = isSorted ? [{ 'a': 1 }, { 'a': 2 }, { 'a': 3 }] : objects.slice(0, 3),
- actual = func(objects, 'a');
-
- assert.deepEqual(actual, expected);
-
- var arrays = [[2], [3], [1], [2], [3], [1]];
- if (isSorted) {
- arrays = lodashStable.sortBy(arrays, 0);
- }
- expected = isSorted ? [[1], [2], [3]] : arrays.slice(0, 3);
- actual = func(arrays, 0);
-
- assert.deepEqual(actual, expected);
- });
-
- lodashStable.each({
- 'an array': [0, 'a'],
- 'an object': { '0': 'a' },
- 'a number': 0,
- 'a string': '0'
- },
- function(iteratee, key) {
- QUnit.test('`_.' + methodName + '` should work with ' + key + ' for `iteratee`', function(assert) {
- assert.expect(1);
-
- var actual = func([['a'], ['a'], ['b']], iteratee);
- assert.deepEqual(actual, [['a'], ['b']]);
- });
- });
- });
-
- /*--------------------------------------------------------------------------*/
-
- QUnit.module('lodash.uniqWith');
-
- (function() {
- QUnit.test('should work with a `comparator`', function(assert) {
- assert.expect(1);
-
- var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }, { 'x': 1, 'y': 2 }],
- actual = _.uniqWith(objects, lodashStable.isEqual);
-
- assert.deepEqual(actual, [objects[0], objects[1]]);
- });
-
- QUnit.test('should preserve the sign of `0`', function(assert) {
- assert.expect(1);
-
- var largeArray = lodashStable.times(LARGE_ARRAY_SIZE, function(index) {
- return isEven(index) ? -0 : 0;
- });
-
- var arrays = [[-0, 0], largeArray],
- expected = lodashStable.map(arrays, lodashStable.constant(['-0']));
-
- var actual = lodashStable.map(arrays, function(array) {
- return lodashStable.map(_.uniqWith(array, lodashStable.eq), lodashStable.toString);
- });
-
- assert.deepEqual(actual, expected);
- });
- }());
-
- /*--------------------------------------------------------------------------*/
-
QUnit.module('lodash.uniqueId');
(function() {
assert.strictEqual(lodashStable.uniq(actual).length, actual.length);
});
- QUnit.test('should return a string value when not providing a `prefix`', function(assert) {
+ QUnit.test('should return a string value when not providing a prefix argument', function(assert) {
assert.expect(1);
assert.strictEqual(typeof _.uniqueId(), 'string');
var object = {};
- if (!isStrict) {
+ if (!isStrict && defineProperty) {
defineProperty(object, 'a', {
'configurable': false,
'enumerable': true,
assert.deepEqual(actual, [6, 15]);
});
- QUnit.test('should provide correct `iteratee` arguments', function(assert) {
+ QUnit.test('should provide the correct `iteratee` arguments', function(assert) {
assert.expect(1);
var args;
QUnit.test('should work with a `customizer` callback', function(assert) {
assert.expect(1);
- var actual = _.updateWith({ '0': {} }, '[0][1][2]', stubThree, function(value) {
+ var actual = _.updateWith({ '0': {} }, '[0][1][2]', alwaysThree, function(value) {
return lodashStable.isObject(value) ? undefined : {};
});
QUnit.test('should work with a `customizer` that returns `undefined`', function(assert) {
assert.expect(1);
- var actual = _.updateWith({}, 'a[0].b.c', stubFour, noop);
+ var actual = _.updateWith({}, 'a[0].b.c', alwaysFour, noop);
assert.deepEqual(actual, { 'a': [{ 'b': { 'c': 4 } }] });
});
}());
QUnit.module('values methods');
lodashStable.each(['values', 'valuesIn'], function(methodName) {
- var func = _[methodName],
+ var args = (function() { return arguments; }(1, 2, 3)),
+ strictArgs = (function() { 'use strict'; return arguments; }(1, 2, 3)),
+ func = _[methodName],
isValues = methodName == 'values';
QUnit.test('`_.' + methodName + '` should get string keyed values of `object`', function(assert) {
QUnit.module('lodash.without');
(function() {
- QUnit.test('should return the difference of values', function(assert) {
- assert.expect(1);
-
- var actual = _.without([2, 1, 2, 3], 1, 2);
- assert.deepEqual(actual, [3]);
- });
-
QUnit.test('should use strict equality to determine the values to reject', function(assert) {
assert.expect(2);
var array = [1, 2, 3, 1, 2, 3];
assert.deepEqual(_.without(array, 1, 2), [3, 3]);
});
- }());
+ }(1, 2, 3));
/*--------------------------------------------------------------------------*/
QUnit.module('lodash.words');
(function() {
- QUnit.test('should match words containing Latin Unicode letters', function(assert) {
+ QUnit.test('should treat latin-1 supplementary letters as words', function(assert) {
assert.expect(1);
var expected = lodashStable.map(burredLetters, function(letter) {
assert.deepEqual(actual, expected);
});
- QUnit.test('should support a `pattern`', function(assert) {
+ QUnit.test('should not treat mathematical operators as words', function(assert) {
+ assert.expect(1);
+
+ var operators = ['\xac', '\xb1', '\xd7', '\xf7'],
+ expected = lodashStable.map(operators, alwaysEmptyArray),
+ actual = lodashStable.map(operators, _.words);
+
+ assert.deepEqual(actual, expected);
+ });
+
+ QUnit.test('should not treat punctuation as words', function(assert) {
+ assert.expect(1);
+
+ var marks = [
+ '\u2012', '\u2013', '\u2014', '\u2015',
+ '\u2024', '\u2025', '\u2026',
+ '\u205d', '\u205e'
+ ];
+
+ var expected = lodashStable.map(marks, alwaysEmptyArray),
+ actual = lodashStable.map(marks, _.words);
+
+ assert.deepEqual(actual, expected);
+ });
+
+ QUnit.test('should support a `pattern` argument', function(assert) {
assert.expect(2);
assert.deepEqual(_.words('abcd', /ab|cd/g), ['ab', 'cd']);
QUnit.test('should work with compound words', function(assert) {
assert.expect(12);
- assert.deepEqual(_.words('12ft'), ['12', 'ft']);
+ assert.deepEqual(_.words('12Feet'), ['12', 'Feet']);
assert.deepEqual(_.words('aeiouAreVowels'), ['aeiou', 'Are', 'Vowels']);
assert.deepEqual(_.words('enable 6h format'), ['enable', '6', 'h', 'format']);
assert.deepEqual(_.words('enable 24H format'), ['enable', '24', 'H', 'format']);
assert.deepEqual(_.words('æiou2Consonants'), ['æiou', '2', 'Consonants']);
});
- QUnit.test('should not treat contractions as separate words', function(assert) {
- assert.expect(4);
+ QUnit.test('should work with contractions', function(assert) {
+ assert.expect(2);
var postfixes = ['d', 'll', 'm', 're', 's', 't', 've'];
lodashStable.each(["'", '\u2019'], function(apos) {
- lodashStable.times(2, function(index) {
- var actual = lodashStable.map(postfixes, function(postfix) {
- var string = 'a b' + apos + postfix + ' c';
- return _.words(string[index ? 'toUpperCase' : 'toLowerCase']());
- });
-
- var expected = lodashStable.map(postfixes, function(postfix) {
- var words = ['a', 'b' + apos + postfix, 'c'];
- return lodashStable.map(words, function(word) {
- return word[index ? 'toUpperCase' : 'toLowerCase']();
- });
- });
-
- assert.deepEqual(actual, expected);
- });
- });
- });
-
- QUnit.test('should not treat ordinal numbers as separate words', function(assert) {
- assert.expect(2);
-
- var ordinals = ['1st', '2nd', '3rd', '4th'];
-
- lodashStable.times(2, function(index) {
- var expected = lodashStable.map(ordinals, function(ordinal) {
- return [ordinal[index ? 'toUpperCase' : 'toLowerCase']()];
+ var actual = lodashStable.map(postfixes, function(postfix) {
+ return _.words('a b' + apos + postfix + ' c');
});
- var actual = lodashStable.map(expected, function(words) {
- return _.words(words[0]);
+ var expected = lodashStable.map(postfixes, function(postfix) {
+ return ['a', 'b' + apos + postfix, 'c'];
});
assert.deepEqual(actual, expected);
});
});
- QUnit.test('should not treat mathematical operators as words', function(assert) {
- assert.expect(1);
-
- var operators = ['\xac', '\xb1', '\xd7', '\xf7'],
- expected = lodashStable.map(operators, stubArray),
- actual = lodashStable.map(operators, _.words);
-
- assert.deepEqual(actual, expected);
- });
-
- QUnit.test('should not treat punctuation as words', function(assert) {
- assert.expect(1);
-
- var marks = [
- '\u2012', '\u2013', '\u2014', '\u2015',
- '\u2024', '\u2025', '\u2026',
- '\u205d', '\u205e'
- ];
-
- var expected = lodashStable.map(marks, stubArray),
- actual = lodashStable.map(marks, _.words);
-
- assert.deepEqual(actual, expected);
- });
-
QUnit.test('should work as an iteratee for methods like `_.map`', function(assert) {
assert.expect(1);
QUnit.test('should create a wrapped function', function(assert) {
assert.expect(1);
- var p = _.wrap(lodashStable.escape, function(func, text) {
+ var p = _.wrap(_.escape, function(func, text) {
return '<p>' + func(text) + '</p>';
});
assert.strictEqual(p('fred, barney, & pebbles'), '<p>fred, barney, & pebbles</p>');
});
- QUnit.test('should provide correct `wrapper` arguments', function(assert) {
+ QUnit.test('should provide the correct `wrapper` arguments', function(assert) {
assert.expect(1);
var args;
assert.expect(1);
var values = [, null, undefined],
- expected = lodashStable.map(values, stubA);
+ expected = lodashStable.map(values, alwaysA);
var actual = lodashStable.map(values, function(value, index) {
var wrapped = index ? _.wrap('a', value) : _.wrap('a');
assert.deepEqual(actual, expected);
});
- QUnit.test('should use `this` binding of function', function(assert) {
+ QUnit.test('should not set a `this` binding', function(assert) {
assert.expect(1);
- var p = _.wrap(lodashStable.escape, function(func) {
+ var p = _.wrap(_.escape, function(func) {
return '<p>' + func(this.text) + '</p>';
});
QUnit.module('xor methods');
lodashStable.each(['xor', 'xorBy', 'xorWith'], function(methodName) {
- var func = _[methodName];
-
- QUnit.test('`_.' + methodName + '` should return the symmetric difference of two arrays', function(assert) {
- assert.expect(1);
-
- var actual = func([2, 1], [2, 3]);
- assert.deepEqual(actual, [1, 3]);
- });
-
- QUnit.test('`_.' + methodName + '` should return the symmetric difference of multiple arrays', function(assert) {
- assert.expect(2);
-
- var actual = func([2, 1], [2, 3], [3, 4]);
- assert.deepEqual(actual, [1, 4]);
-
- actual = func([1, 2], [2, 1], [1, 2]);
- assert.deepEqual(actual, []);
- });
+ var args = (function() { return arguments; }(1, 2, 3)),
+ func = _[methodName];
- QUnit.test('`_.' + methodName + '` should return an empty array when comparing the same array', function(assert) {
+ QUnit.test('`_.' + methodName + '` should return the symmetric difference of the given arrays', function(assert) {
assert.expect(1);
- var array = [1],
- actual = func(array, array, array);
-
- assert.deepEqual(actual, []);
+ var actual = func([1, 2, 5], [2, 3, 5], [3, 4, 5]);
+ assert.deepEqual(actual, [1, 4, 5]);
});
QUnit.test('`_.' + methodName + '` should return an array of unique values', function(assert) {
assert.expect(2);
var actual = func([1, 1, 2, 5], [2, 2, 3, 5], [3, 4, 5, 5]);
- assert.deepEqual(actual, [1, 4]);
+ assert.deepEqual(actual, [1, 4, 5]);
actual = func([1, 1]);
assert.deepEqual(actual, [1]);
QUnit.module('lodash.xorBy');
(function() {
- QUnit.test('should accept an `iteratee`', function(assert) {
+ QUnit.test('should accept an `iteratee` argument', function(assert) {
assert.expect(2);
- var actual = _.xorBy([2.1, 1.2], [2.3, 3.4], Math.floor);
- assert.deepEqual(actual, [1.2, 3.4]);
+ var actual = _.xorBy([2.1, 1.2], [4.3, 2.4], Math.floor);
+ assert.deepEqual(actual, [1.2, 4.3]);
actual = _.xorBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x');
assert.deepEqual(actual, [{ 'x': 2 }]);
});
- QUnit.test('should provide correct `iteratee` arguments', function(assert) {
+ QUnit.test('should provide the correct `iteratee` arguments', function(assert) {
assert.expect(1);
var args;
- _.xorBy([2.1, 1.2], [2.3, 3.4], function() {
+ _.xorBy([2.1, 1.2], [4.3, 2.4], function() {
args || (args = slice.call(arguments));
});
- assert.deepEqual(args, [2.3]);
+ assert.deepEqual(args, [4.3]);
});
}());
QUnit.module('lodash.xorWith');
(function() {
- QUnit.test('should work with a `comparator`', function(assert) {
+ QUnit.test('should work with a `comparator` argument', function(assert) {
assert.expect(1);
var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }],
assert.deepEqual(actual, [1, 2, 3]);
});
- QUnit.test('should provide correct `iteratee` arguments', function(assert) {
+ QUnit.test('should provide the correct `iteratee` arguments', function(assert) {
assert.expect(1);
var args;
QUnit.test('`_.' + methodName + '` should treat falsey values as empty arrays', function(assert) {
assert.expect(1);
- var expected = lodashStable.map(falsey, stubArray);
+ var expected = lodashStable.map(falsey, alwaysEmptyArray);
var actual = lodashStable.map(falsey, function(value) {
return func([value, value, value]);
QUnit.module('lodash(...).next');
- lodashStable.each([false, true], function(implicit) {
+ lodashStable.each([false, true], function(implict) {
function chain(value) {
- return implicit ? _(value) : _.chain(value);
+ return implict ? _(value) : _.chain(value);
}
- var chainType = 'in an ' + (implicit ? 'implicit' : 'explict') + ' chain';
+ var chainType = 'in an ' + (implict ? 'implict' : 'explict') + ' chain';
QUnit.test('should follow the iterator protocol ' + chainType, function(assert) {
assert.expect(3);
wrapped = chain(array);
assert.strictEqual(wrapped[Symbol.iterator](), wrapped);
- assert.deepEqual(lodashStable.toArray(wrapped), array);
+ assert.deepEqual(_.toArray(wrapped), array);
}
else {
skipAssert(assert, 2);
var array = [1, 2],
wrapped = chain(array);
- assert.deepEqual(lodashStable.toArray(wrapped), array);
- assert.deepEqual(lodashStable.toArray(wrapped), [], 'produces an empty array for exhausted iterator');
+ assert.deepEqual(_.toArray(wrapped), array);
+ assert.deepEqual(_.toArray(wrapped), [], 'produces an empty array for exhausted iterator');
var other = wrapped.filter();
- assert.deepEqual(lodashStable.toArray(other), array, 'reset for new chain segments');
- assert.deepEqual(lodashStable.toArray(wrapped), [], 'iterator is still exhausted');
+ assert.deepEqual(_.toArray(other), array, 'reset for new chain segments');
+ assert.deepEqual(_.toArray(wrapped), [], 'iterator is still exhausted');
}
else {
skipAssert(assert, 4);
values = [],
wrapped = chain(array);
- assert.deepEqual(lodashStable.toArray(wrapped), array);
+ assert.deepEqual(_.toArray(wrapped), array);
wrapped = wrapped.filter(predicate);
- assert.deepEqual(lodashStable.toArray(wrapped), _.filter(array, isEven), 'reset for new lazy chain segments');
+ assert.deepEqual(_.toArray(wrapped), _.filter(array, isEven), 'reset for new lazy chain segments');
assert.deepEqual(values, array, 'memoizes iterator values');
}
else {
array2 = [6, 8],
wrapped1 = _(array1).map(square);
- assert.deepEqual(lodashStable.toArray(wrapped1), [4, 16]);
- assert.deepEqual(lodashStable.toArray(wrapped1), []);
+ assert.deepEqual(_.toArray(wrapped1), [4, 16]);
+ assert.deepEqual(_.toArray(wrapped1), []);
var wrapped2 = wrapped1.plant(array2);
- assert.deepEqual(lodashStable.toArray(wrapped2), [36, 64]);
+ assert.deepEqual(_.toArray(wrapped2), [36, 64]);
}
else {
skipAssert(assert, 3);
assert.strictEqual(wrapped.pop(), 1);
var actual = wrapped.value();
- assert.strictEqual(actual, array);
assert.deepEqual(actual, []);
+ assert.strictEqual(actual, array);
}
else {
skipAssert(assert, 5);
assert.expect(1);
if (!isNpm) {
- var expected = lodashStable.map(falsey, stubTrue);
+ var expected = lodashStable.map(falsey, alwaysTrue);
var actual = lodashStable.map(falsey, function(value, index) {
try {
assert.expect(1);
if (!isNpm) {
- var expected = lodashStable.map(falsey, stubTrue);
+ var expected = lodashStable.map(falsey, alwaysTrue);
var actual = lodashStable.map(falsey, function(value, index) {
try {
assert.strictEqual(wrapped.shift(), 2);
var actual = wrapped.value();
- assert.strictEqual(actual, array);
assert.deepEqual(actual, []);
+ assert.strictEqual(actual, array);
}
else {
skipAssert(assert, 5);
assert.expect(1);
if (!isNpm) {
- var expected = lodashStable.map(falsey, stubTrue);
+ var expected = lodashStable.map(falsey, alwaysTrue);
var actual = lodashStable.map(falsey, function(value, index) {
try {
assert.expect(1);
if (!isNpm) {
- var expected = lodashStable.map(falsey, stubTrue);
+ var expected = lodashStable.map(falsey, alwaysTrue);
var actual = lodashStable.map(falsey, function(value, index) {
try {
assert.deepEqual(wrapped.splice(0, 2).value(), [1, 3]);
var actual = wrapped.value();
- assert.strictEqual(actual, array);
assert.deepEqual(actual, []);
+ assert.strictEqual(actual, array);
}
else {
skipAssert(assert, 5);
assert.expect(1);
if (!isNpm) {
- var expected = lodashStable.map(falsey, stubTrue);
+ var expected = lodashStable.map(falsey, alwaysTrue);
var actual = lodashStable.map(falsey, function(value, index) {
try {
assert.expect(1);
if (!isNpm) {
- var expected = lodashStable.map(falsey, stubTrue);
+ var expected = lodashStable.map(falsey, alwaysTrue);
var actual = lodashStable.map(falsey, function(value, index) {
try {
'ceil',
'clone',
'deburr',
- 'defaultTo',
'divide',
'endsWith',
'escape',
'startsWith',
'subtract',
'sum',
- 'toFinite',
'toInteger',
'toLower',
'toNumber',
QUnit.module('"Arrays" category methods');
(function() {
- var args = toArgs([1, null, [3], null, 5]),
- sortedArgs = toArgs([1, [3], 5, null, null]),
+ var args = (function() { return arguments; }(1, null, [3], null, 5)),
+ sortedArgs = (function() { return arguments; }(1, [3], 5, null, null)),
array = [1, 2, 3, 4, 5, 6];
QUnit.test('should work with `arguments` objects', function(assert) {
assert.expect(1);
var values = [, null, undefined, ''],
- expected = lodashStable.map(values, stubString);
+ expected = lodashStable.map(values, alwaysEmptyString);
var actual = lodashStable.map(values, function(value, index) {
return index ? func(value) : func();
var acceptFalsey = lodashStable.difference(allMethods, rejectFalsey);
QUnit.test('should accept falsey arguments', function(assert) {
- assert.expect(316);
+ assert.expect(308);
- var arrays = lodashStable.map(falsey, stubArray);
+ var emptyArrays = lodashStable.map(falsey, alwaysEmptyArray);
lodashStable.each(acceptFalsey, function(methodName) {
- var expected = arrays,
- func = _[methodName];
+ var expected = emptyArrays,
+ func = _[methodName],
+ pass = true;
var actual = lodashStable.map(falsey, function(value, index) {
- return index ? func(value) : func();
+ try {
+ return index ? func(value) : func();
+ } catch (e) {
+ pass = false;
+ }
});
if (methodName == 'noConflict') {
if (lodashStable.includes(returnArrays, methodName) && methodName != 'sample') {
assert.deepEqual(actual, expected, '_.' + methodName + ' returns an array');
}
- assert.ok(true, '`_.' + methodName + '` accepts falsey arguments');
+ assert.ok(pass, '`_.' + methodName + '` accepts falsey arguments');
});
// Skip tests for missing methods of modularized builds.
assert.expect(24);
lodashStable.each(rejectFalsey, function(methodName) {
- var expected = lodashStable.map(falsey, stubTrue),
+ var expected = lodashStable.map(falsey, alwaysTrue),
func = _[methodName];
var actual = lodashStable.map(falsey, function(value, index) {
});
});
- QUnit.test('should use `this` binding of function', function(assert) {
+ QUnit.test('should not set a `this` binding', function(assert) {
assert.expect(30);
lodashStable.each(noBinding, function(methodName) {
if (!document) {
QUnit.config.noglobals = true;
QUnit.load();
- QUnit.start();
}
}.call(this));
git://repos.xcallymotion.com / motion.git / blobdiff