"Fossies" - the Fresh Open Source Software Archive  

Source code changes of the file "test/test-fp.js" between
lodash-4.0.0.tar.gz and lodash-4.17.21.tar.gz

About: lodash is a modern JavaScript utility library delivering modularity, performance, & extras. Tagged version.

test-fp.js  (lodash-4.0.0)	:	test-fp.js  (lodash-4.17.21)
;(function() {		;(function() {
		'use strict';
/** Used as a safe reference for `undefined` in pre-ES5 environments. */		/** Used as a safe reference for `undefined` in pre-ES5 environments. */
var undefined;		var undefined;
/** Used as the size to cover large array optimizations. */		/** Used as the size to cover large array optimizations. */
var LARGE_ARRAY_SIZE = 200;		var LARGE_ARRAY_SIZE = 200;
/** Used as a reference to the global object. */		/** Used as a reference to the global object. */
var root = (typeof global == 'object' && global) || this;		var root = (typeof global == 'object' && global) || this;
/** Used for native method references. */		/** Used for native method references. */
var arrayProto = Array.prototype;		var arrayProto = Array.prototype;
/** Method and object shortcuts. */		/** Method and object shortcuts. */
var phantom = root.phantom,		var phantom = root.phantom,
amd = root.define && define.amd,		argv = root.process && process.argv,
document = !phantom && root.document,		document = !phantom && root.document,
noop = function() {},
slice = arrayProto.slice,		slice = arrayProto.slice,
WeakMap = root.WeakMap;		WeakMap = root.WeakMap;
		/** Math helpers. */
		var add = function(x, y) { return x + y; },
		isEven = function(n) { return n % 2 == 0; },
		isEvenIndex = function(n, index) { return isEven(index); },
		square = function(n) { return n * n; };
		// Leak to avoid sporadic `noglobals` fails on Edge in Sauce Labs.
		root.msWDfn = undefined;
/*--------------------------------------------------------------------------*/		/*--------------------------------------------------------------------------*/
/** Use a single "load" function. */		/** Load QUnit and extras. */
var load = (!amd && typeof require == 'function')		var QUnit = root.QUnit || require('qunit-extras');
? require
: noop;		/** Load stable Lodash. */
		var _ = root._ || require('../lodash.js');
/** The unit testing framework. */
var QUnit = root.QUnit || (root.QUnit = (
QUnit = load('../node_modules/qunitjs/qunit/qunit.js') || root.QUnit,
QUnit = QUnit.QUnit || QUnit
));
/** Load stable Lodash and QUnit Extras. */
var _ = root._ || load('../lodash.js');
if (_) {
_ = _.runInContext(root);
}
var QUnitExtras = load('../node_modules/qunit-extras/qunit-extras.js');
if (QUnitExtras) {
QUnitExtras.runInContext(root);
}
var convert = root.fp || load('../lib/fp/convert.js'),		var convert = (function() {
mapping = root.mapping || load('../lib/fp/mapping.js'),		var baseConvert = root.fp || require('../fp/_baseConvert.js');
fp = convert(_.runInContext());		if (!root.fp) {
		return function(name, func, options) {
		return baseConvert(_, name, func, options);
		};
		}
		return function(name, func, options) {
		if (typeof name == 'function') {
		options = func;
		func = name;
		name = undefined;
		}
		return name === undefined
		? baseConvert(func, options)
		: baseConvert(_.runInContext(), options)[name];
		};
		}());
		var allFalseOptions = {
		'cap': false,
		'curry': false,
		'fixed': false,
		'immutable': false,
		'rearg': false
		};
		var fp = root.fp
		? (fp = _.noConflict(), _ = root._, fp)
		: convert(_.runInContext());
		var mapping = root.mapping || require('../fp/_mapping.js');
/*--------------------------------------------------------------------------*/		/*--------------------------------------------------------------------------*/
/**		/**
* Skips a given number of tests with a passing result.		* Skips a given number of tests with a passing result.
*		*
* @private		* @private
* @param {Object} assert The QUnit assert object.		* @param {Object} assert The QUnit assert object.
* @param {number} [count=1] The number of tests to skip.		* @param {number} [count=1] The number of tests to skip.
*/		*/
function skipTest(assert, count) {		function skipAssert(assert, count) {
count || (count = 1);		count || (count = 1);
while (count--) {		while (count--) {
assert.ok(true, 'test skipped');		assert.ok(true, 'test skipped');
}		}
}		}
/*--------------------------------------------------------------------------*/		/*--------------------------------------------------------------------------*/
		if (argv) {
		console.log('Running lodash/fp tests.');
		}
		QUnit.module('convert module');
		(function() {
		QUnit.test('should work with `name` and `func`', function(assert) {
		assert.expect(2);
		var array = [1, 2, 3, 4],
		remove = convert('remove', _.remove),
		actual = remove(isEven)(array);
		assert.deepEqual(array, [1, 2, 3, 4]);
		assert.deepEqual(actual, [1, 3]);
		});
		QUnit.test('should work with `name`, `func`, and `options`', function(assert
		) {
		assert.expect(3);
		var array = [1, 2, 3, 4],
		remove = convert('remove', _.remove, allFalseOptions);
		var actual = remove(array, function(n, index) {
		return isEven(index);
		});
		assert.deepEqual(array, [2, 4]);
		assert.deepEqual(actual, [1, 3]);
		assert.deepEqual(remove(), []);
		});
		QUnit.test('should work with an object', function(assert) {
		assert.expect(2);
		if (!document) {
		var array = [1, 2, 3, 4],
		lodash = convert({ 'remove': _.remove }),
		actual = lodash.remove(isEven)(array);
		assert.deepEqual(array, [1, 2, 3, 4]);
		assert.deepEqual(actual, [1, 3]);
		}
		else {
		skipAssert(assert, 2);
		}
		});
		QUnit.test('should work with an object and `options`', function(assert) {
		assert.expect(3);
		if (!document) {
		var array = [1, 2, 3, 4],
		lodash = convert({ 'remove': _.remove }, allFalseOptions),
		actual = lodash.remove(array, isEvenIndex);
		assert.deepEqual(array, [2, 4]);
		assert.deepEqual(actual, [1, 3]);
		assert.deepEqual(lodash.remove(), []);
		}
		else {
		skipAssert(assert, 3);
		}
		});
		QUnit.test('should work with lodash and `options`', function(assert) {
		assert.expect(3);
		var array = [1, 2, 3, 4],
		lodash = convert(_.runInContext(), allFalseOptions),
		actual = lodash.remove(array, isEvenIndex);
		assert.deepEqual(array, [2, 4]);
		assert.deepEqual(actual, [1, 3]);
		assert.deepEqual(lodash.remove(), []);
		});
		QUnit.test('should work with `runInContext` and `options`', function(assert)
		{
		assert.expect(3);
		var array = [1, 2, 3, 4],
		runInContext = convert('runInContext', _.runInContext, allFalseOptions
		),
		lodash = runInContext(),
		actual = lodash.remove(array, isEvenIndex);
		assert.deepEqual(array, [2, 4]);
		assert.deepEqual(actual, [1, 3]);
		assert.deepEqual(lodash.remove(), []);
		});
		QUnit.test('should accept a variety of options', function(assert) {
		assert.expect(8);
		var array = [1, 2, 3, 4],
		value = _.clone(array),
		remove = convert('remove', _.remove, { 'cap': false }),
		actual = remove(isEvenIndex)(value);
		assert.deepEqual(value, [1, 2, 3, 4]);
		assert.deepEqual(actual, [2, 4]);
		remove = convert('remove', _.remove, { 'curry': false });
		actual = remove(isEven);
		assert.deepEqual(actual, []);
		var trim = convert('trim', _.trim, { 'fixed': false });
		assert.strictEqual(trim('_-abc-_', '_-'), 'abc');
		value = _.clone(array);
		remove = convert('remove', _.remove, { 'immutable': false });
		actual = remove(isEven)(value);
		assert.deepEqual(value, [1, 3]);
		assert.deepEqual(actual, [2, 4]);
		value = _.clone(array);
		remove = convert('remove', _.remove, { 'rearg': false });
		actual = remove(value)(isEven);
		assert.deepEqual(value, [1, 2, 3, 4]);
		assert.deepEqual(actual, [1, 3]);
		});
		QUnit.test('should respect the `cap` option', function(assert) {
		assert.expect(1);
		var iteratee = convert('iteratee', _.iteratee, { 'cap': false });
		var func = iteratee(function(a, b, c) {
		return [a, b, c];
		}, 3);
		assert.deepEqual(func(1, 2, 3), [1, 2, 3]);
		});
		QUnit.test('should respect the `rearg` option', function(assert) {
		assert.expect(1);
		var add = convert('add', _.add, { 'rearg': true });
		assert.strictEqual(add('2')('1'), '12');
		});
		QUnit.test('should add a `placeholder` property', function(assert) {
		assert.expect(2);
		if (!document) {
		var lodash = convert({ 'add': _.add });
		assert.strictEqual(lodash.placeholder, lodash);
		assert.strictEqual(lodash.add.placeholder, lodash);
		}
		else {
		skipAssert(assert, 2);
		}
		});
		}());
		/*--------------------------------------------------------------------------*/
		QUnit.module('method.convert');
		(function() {
		QUnit.test('should exist on unconverted methods', function(assert) {
		assert.expect(2);
		var array = [],
		isArray = fp.isArray.convert({ 'curry': true });
		assert.strictEqual(fp.isArray(array), true);
		assert.strictEqual(isArray()(array), true);
		});
		QUnit.test('should convert method aliases', function(assert) {
		assert.expect(1);
		var all = fp.all.convert({ 'rearg': false }),
		actual = all([0])(_.identity);
		assert.strictEqual(actual, false);
		});
		QUnit.test('should convert remapped methods', function(assert) {
		assert.expect(1);
		var extendAll = fp.extendAll.convert({ 'immutable': false }),
		object = {};
		extendAll([object, { 'a': 1 }, { 'b': 2 }]);
		assert.deepEqual(object, { 'a': 1, 'b': 2 });
		});
		}());
		/*--------------------------------------------------------------------------*/
		QUnit.module('convert methods');
		_.each(['fp.convert', 'method.convert'], function(methodName) {
		var isFp = methodName == 'fp.convert',
		func = isFp ? fp.convert : fp.remove.convert;
		QUnit.test('`' + methodName + '` should work with an object', function(asser
		t) {
		assert.expect(3);
		var array = [1, 2, 3, 4],
		lodash = func(allFalseOptions),
		remove = isFp ? lodash.remove : lodash,
		actual = remove(array, isEvenIndex);
		assert.deepEqual(array, [2, 4]);
		assert.deepEqual(actual, [1, 3]);
		assert.deepEqual(remove(), []);
		});
		QUnit.test('`' + methodName + '` should extend existing configs', function(a
		ssert) {
		assert.expect(2);
		var array = [1, 2, 3, 4],
		lodash = func({ 'cap': false }),
		remove = (isFp ? lodash.remove : lodash).convert({ 'rearg': false }),
		actual = remove(array)(isEvenIndex);
		assert.deepEqual(array, [1, 2, 3, 4]);
		assert.deepEqual(actual, [2, 4]);
		});
		});
		/*--------------------------------------------------------------------------*/
		QUnit.module('method arity checks');
		(function() {
		QUnit.test('should wrap methods with an arity > `1`', function(assert) {
		assert.expect(1);
		var methodNames = _.filter(_.functions(fp), function(methodName) {
		return fp[methodName].length > 1;
		});
		assert.deepEqual(methodNames, []);
		});
		QUnit.test('should have >= arity of `aryMethod` designation', function(asser
		t) {
		assert.expect(4);
		_.times(4, function(index) {
		var aryCap = index + 1;
		var methodNames = _.filter(mapping.aryMethod[aryCap], function(methodNam
		e) {
		var key = _.get(mapping.remap, methodName, methodName),
		arity = _[key].length;
		return arity != 0 && arity < aryCap;
		});
		assert.deepEqual(methodNames, [], '`aryMethod[' + aryCap + ']`');
		});
		});
		}());
		/*--------------------------------------------------------------------------*/
QUnit.module('method aliases');		QUnit.module('method aliases');
(function() {		(function() {
QUnit.test('should have correct aliases', function(assert) {		QUnit.test('should have correct aliases', function(assert) {
assert.expect(1);		assert.expect(1);
var actual = _.transform(mapping.aliasMap, function(result, aliases, metho		var actual = _.transform(mapping.aliasToReal, function(result, realName, a
dName) {		lias) {
var func = fp[methodName];		result.push([alias, fp[alias] === fp[realName]]);
_.each(aliases, function(alias) {
result.push([alias, fp[alias] === func]);
});
}, []);		}, []);
assert.deepEqual(_.reject(actual, 1), []);		assert.deepEqual(_.reject(actual, 1), []);
});		});
}());		}());
/*--------------------------------------------------------------------------*/		/*--------------------------------------------------------------------------*/
QUnit.module('method ary caps');		QUnit.module('method ary caps');
(function() {		(function() {
QUnit.test('should have a cap of 1', function(assert) {		QUnit.test('should have a cap of 1', function(assert) {
assert.expect(1);		assert.expect(1);
var funcMethods = [		var funcMethods = [
'curry', 'iteratee', 'memoize', 'over', 'overEvery', 'overSome',		'curry', 'iteratee', 'memoize', 'over', 'overEvery', 'overSome',
'method', 'methodOf', 'restParam', 'runInContext'		'method', 'methodOf', 'rest', 'runInContext'
];		];
var exceptions = funcMethods.concat('mixin', 'template'),		var exceptions = funcMethods.concat('mixin', 'nthArg', 'template'),
expected = _.map(mapping.aryMethodMap[1], _.constant(true));		expected = _.map(mapping.aryMethod[1], _.constant(true));
var actual = _.map(mapping.aryMethodMap[1], function(methodName) {		var actual = _.map(mapping.aryMethod[1], function(methodName) {
var arg = _.includes(funcMethods, methodName) ? _.noop : 1,		var arg = _.includes(funcMethods, methodName) ? _.noop : 1,
result = _.attempt(function() { return fp[methodName](arg); });		result = _.attempt(function() { return fp[methodName](arg); });
if (_.includes(exceptions, methodName)		if (_.includes(exceptions, methodName)
? typeof result == 'function'		? typeof result == 'function'
: typeof result != 'function'		: typeof result != 'function'
) {		) {
return true;		return true;
}		}
console.log(methodName, result);		console.log(methodName, result);
return false;		return false;
});		});
assert.deepEqual(actual, expected);		assert.deepEqual(actual, expected);
});		});
QUnit.test('should have a cap of 2', function(assert) {		QUnit.test('should have a cap of 2', function(assert) {
assert.expect(1);		assert.expect(1);
var funcMethods = [		var funcMethods = [
'after', 'ary', 'before', 'bind', 'bindKey', 'cloneDeepWith', 'cloneWith		'after', 'ary', 'before', 'bind', 'bindKey', 'curryN', 'debounce',
',		'delay', 'overArgs', 'partial', 'partialRight', 'rearg', 'throttle',
'curryN', 'debounce', 'delay', 'overArgs', 'rearg', 'throttle', 'wrap'		'wrap'
];		];
var exceptions = _.difference(funcMethods.concat('matchesProperty'), ['clo		var exceptions = _.without(funcMethods.concat('matchesProperty'), 'delay')
neDeepWith', 'cloneWith', 'delay']),		,
expected = _.map(mapping.aryMethodMap[2], _.constant(true));		expected = _.map(mapping.aryMethod[2], _.constant(true));
var actual = _.map(mapping.aryMethodMap[2], function(methodName) {		var actual = _.map(mapping.aryMethod[2], function(methodName) {
var args = _.includes(funcMethods, methodName) ? [methodName == 'curryN' ? 1 : _.noop, _.noop] : [1, []],		var args = _.includes(funcMethods, methodName) ? [methodName == 'curryN' ? 1 : _.noop, _.noop] : [1, []],
result = _.attempt(function() { return fp[methodName](args[0])(args[ 1]); });		result = _.attempt(function() { return fp[methodName](args[0])(args[ 1]); });
if (_.includes(exceptions, methodName)		if (_.includes(exceptions, methodName)
? typeof result == 'function'		? typeof result == 'function'
: typeof result != 'function'		: typeof result != 'function'
) {		) {
return true;		return true;
}		}
console.log(methodName, result);		console.log(methodName, result);
return false;		return false;
});		});
assert.deepEqual(actual, expected);		assert.deepEqual(actual, expected);
});		});
QUnit.test('should have a cap of 3', function(assert) {		QUnit.test('should have a cap of 3', function(assert) {
assert.expect(1);		assert.expect(1);
var funcMethods = [		var funcMethods = [
'assignWith', 'extendWith', 'isEqualWith', 'isMatchWith', 'omitBy',		'assignWith', 'extendWith', 'isEqualWith', 'isMatchWith', 'reduce',
'pickBy', 'reduce', 'reduceRight', 'transform', 'zipWith'		'reduceRight', 'transform', 'zipWith'
];		];
var expected = _.map(mapping.aryMethodMap[3], _.constant(true));		var expected = _.map(mapping.aryMethod[3], _.constant(true));
var actual = _.map(mapping.aryMethodMap[3], function(methodName) {		var actual = _.map(mapping.aryMethod[3], function(methodName) {
var args = _.includes(funcMethods, methodName) ? [_.noop, 0, 1] : [0, 1, []],		var args = _.includes(funcMethods, methodName) ? [_.noop, 0, 1] : [0, 1, []],
result = _.attempt(function() { return fp[methodName](args[0])(args[ 1])(args[2]); });		result = _.attempt(function() { return fp[methodName](args[0])(args[ 1])(args[2]); });
if (typeof result != 'function') {		if (typeof result != 'function') {
return true;		return true;
}		}
console.log(methodName, result);		console.log(methodName, result);
return false;		return false;
});		});
skipping to change at line 180		skipping to change at line 465
/*--------------------------------------------------------------------------*/		/*--------------------------------------------------------------------------*/
QUnit.module('methods that use `indexOf`');		QUnit.module('methods that use `indexOf`');
(function() {		(function() {
QUnit.test('should work with `fp.indexOf`', function(assert) {		QUnit.test('should work with `fp.indexOf`', function(assert) {
assert.expect(10);		assert.expect(10);
var array = ['a', 'b', 'c'],		var array = ['a', 'b', 'c'],
other = ['b', 'b', 'd'],		other = ['b', 'd', 'b'],
object = { 'a': 1, 'b': 2, 'c': 2 },		object = { 'a': 1, 'b': 2, 'c': 2 },
actual = fp.difference(array, other);		actual = fp.difference(array)(other);
assert.deepEqual(actual, ['a', 'c'], 'fp.difference');		assert.deepEqual(actual, ['a', 'c'], 'fp.difference');
actual = fp.includes('b', array);		actual = fp.includes('b')(array);
assert.strictEqual(actual, true, 'fp.includes');		assert.strictEqual(actual, true, 'fp.includes');
actual = fp.intersection(other, array);		actual = fp.intersection(other)(array);
assert.deepEqual(actual, ['b'], 'fp.intersection');		assert.deepEqual(actual, ['b'], 'fp.intersection');
actual = fp.omit(other, object);		actual = fp.omit(other)(object);
assert.deepEqual(actual, { 'a': 1, 'c': 2 }, 'fp.omit');		assert.deepEqual(actual, { 'a': 1, 'c': 2 }, 'fp.omit');
actual = fp.union(other, array);		actual = fp.union(other)(array);
assert.deepEqual(actual, ['a', 'b', 'c', 'd'], 'fp.union');		assert.deepEqual(actual, ['a', 'b', 'c', 'd'], 'fp.union');
actual = fp.uniq(other);		actual = fp.uniq(other);
assert.deepEqual(actual, ['b', 'd'], 'fp.uniq');		assert.deepEqual(actual, ['b', 'd'], 'fp.uniq');
actual = fp.uniqBy(_.identity, other);		actual = fp.uniqBy(_.identity, other);
assert.deepEqual(actual, ['b', 'd'], 'fp.uniqBy');		assert.deepEqual(actual, ['b', 'd'], 'fp.uniqBy');
actual = fp.without('b', array);		actual = fp.without(other)(array);
assert.deepEqual(actual, ['a', 'c'], 'fp.without');		assert.deepEqual(actual, ['a', 'c'], 'fp.without');
actual = fp.xor(other, array);		actual = fp.xor(other)(array);
assert.deepEqual(actual, ['a', 'c', 'd'], 'fp.xor');		assert.deepEqual(actual, ['a', 'c', 'd'], 'fp.xor');
actual = fp.pull('b', array);		actual = fp.pull('b')(array);
assert.deepEqual(actual, ['a', 'c'], 'fp.pull');		assert.deepEqual(actual, ['a', 'c'], 'fp.pull');
});		});
}());		}());
/*--------------------------------------------------------------------------*/		/*--------------------------------------------------------------------------*/
QUnit.module('cherry-picked methods');		QUnit.module('cherry-picked methods');
(function() {		(function() {
QUnit.test('should provide the correct `iteratee` arguments', function(asser t) {		QUnit.test('should provide the correct `iteratee` arguments', function(asser t) {
assert.expect(4);		assert.expect(4);
if (!document) {		var args,
var args,		array = [1, 2, 3],
array = [1, 2, 3],		object = { 'a': 1, 'b': 2 },
object = { 'a': 1, 'b': 2 },		isFIFO = _.keys(object)[0] == 'a',
isFIFO = _.keys(object)[0] == 'a',		map = convert('map', _.map),
map = convert('map', _.map),		reduce = convert('reduce', _.reduce);
reduce = convert('reduce', _.reduce);
map(function() {
args || (args = slice.call(arguments));
})(array);
assert.deepEqual(args, [1]);
args = undefined;
map(function() {
args || (args = slice.call(arguments));
})(object);
assert.deepEqual(args, isFIFO ? [1] : [2]);
args = undefined;
reduce(function() {
args || (args = slice.call(arguments));
})(0, array);
assert.deepEqual(args, [0, 1]);
args = undefined;
reduce(function() {
args || (args = slice.call(arguments));
})(0, object);
assert.deepEqual(args, isFIFO ? [0, 1] : [0, 2]);		map(function() {
}		args || (args = slice.call(arguments));
else {		})(array);
skipTest(assert, 4);
}		assert.deepEqual(args, [1]);
		args = undefined;
		map(function() {
		args || (args = slice.call(arguments));
		})(object);
		assert.deepEqual(args, isFIFO ? [1] : [2]);
		args = undefined;
		reduce(function() {
		args || (args = slice.call(arguments));
		})(0)(array);
		assert.deepEqual(args, [0, 1]);
		args = undefined;
		reduce(function() {
		args || (args = slice.call(arguments));
		})(0)(object);
		assert.deepEqual(args, isFIFO ? [0, 1] : [0, 2]);
});		});
QUnit.test('should not support shortcut fusion', function(assert) {		QUnit.test('should not support shortcut fusion', function(assert) {
assert.expect(3);		assert.expect(3);
if (!document) {		var array = fp.range(0, LARGE_ARRAY_SIZE),
var array = fp.range(0, LARGE_ARRAY_SIZE),		filterCount = 0,
filterCount = 0,		mapCount = 0;
mapCount = 0;
		var iteratee = function(value) {
var iteratee = function(value) {		mapCount++;
mapCount++;		return value * value;
return value * value;		};
};
		var predicate = function(value) {
var predicate = function(value) {		filterCount++;
filterCount++;		return isEven(value);
return value % 2 == 0;		};
};
		var map1 = convert('map', _.map),
var map1 = convert('map', _.map),		filter1 = convert('filter', _.filter),
filter1 = convert('filter', _.filter),		take1 = convert('take', _.take);
take1 = convert('take', _.take);
		var filter2 = filter1(predicate),
var filter2 = filter1(predicate),		map2 = map1(iteratee),
map2 = map1(iteratee),		take2 = take1(2);
take2 = take1(2);
		var combined = fp.flow(map2, filter2, fp.compact, take2);
var combined = fp.flow(map2, filter2, fp.compact, take2);
		assert.deepEqual(combined(array), [4, 16]);
assert.deepEqual(combined(array), [4, 16]);		assert.strictEqual(filterCount, 200, 'filterCount');
assert.strictEqual(filterCount, 200, 'filterCount');		assert.strictEqual(mapCount, 200, 'mapCount');
assert.strictEqual(mapCount, 200, 'mapCount');		});
}		}());
else {
skipTest(assert, 3);		/*--------------------------------------------------------------------------*/
}
		QUnit.module('iteratee shorthands');
		(function() {
		var objects = [{ 'a': 1, 'b': 2 }, { 'a': 3, 'b': 4 }];
		QUnit.test('should work with "_.matches" shorthands', function(assert) {
		assert.expect(1);
		assert.deepEqual(fp.filter({ 'a': 3 })(objects), [objects[1]]);
		});
		QUnit.test('should work with "_.matchesProperty" shorthands', function(asser
		t) {
		assert.expect(1);
		assert.deepEqual(fp.filter(['a', 3])(objects), [objects[1]]);
		});
		QUnit.test('should work with "_.property" shorthands', function(assert) {
		assert.expect(1);
		assert.deepEqual(fp.map('a')(objects), [1, 3]);
		});
		}());
		/*--------------------------------------------------------------------------*/
		QUnit.module('placeholder methods');
		(function() {
		QUnit.test('should use `fp` as the default placeholder', function(assert) {
		assert.expect(3);
		var actual = fp.add(fp, 'b')('a');
		assert.strictEqual(actual, 'ab');
		actual = fp.fill(fp, 2)(1, '*')([1, 2, 3]);
		assert.deepEqual(actual, [1, '*', 3]);
		actual = fp.slice(fp, 2)(1)(['a', 'b', 'c']);
		assert.deepEqual(actual, ['b']);
		});
		QUnit.test('should support `fp.placeholder`', function(assert) {
		assert.expect(6);
		_.each([[], fp.__], function(ph) {
		fp.placeholder = ph;
		var actual = fp.add(ph, 'b')('a');
		assert.strictEqual(actual, 'ab');
		actual = fp.fill(ph, 2)(1, '*')([1, 2, 3]);
		assert.deepEqual(actual, [1, '*', 3]);
		actual = fp.slice(ph, 2)(1)(['a', 'b', 'c']);
		assert.deepEqual(actual, ['b']);
		});
		});
		var methodNames = [
		'bind',
		'bindKey',
		'curry',
		'curryRight',
		'partial',
		'partialRight'
		];
		_.each(methodNames, function(methodName) {
		var func = fp[methodName];
		QUnit.test('fp.' + methodName + '` should have a `placeholder` property',
		function(assert) {
		assert.expect(2);
		assert.ok(_.isObject(func.placeholder));
		assert.strictEqual(func.placeholder, fp.__);
		});
		});
		}());
		/*--------------------------------------------------------------------------*/
		QUnit.module('setter methods');
		(function() {
		QUnit.test('should only clone objects in `path`', function(assert) {
		assert.expect(11);
		var object = { 'a': { 'b': 2, 'c': 3 }, 'd': { 'e': 4 } },
		value = _.cloneDeep(object),
		actual = fp.set('a.b.c.d', 5, value);
		assert.ok(_.isObject(actual.a.b), 'fp.set');
		assert.ok(_.isNumber(actual.a.b), 'fp.set');
		assert.strictEqual(actual.a.b.c.d, 5, 'fp.set');
		assert.strictEqual(actual.d, value.d, 'fp.set');
		value = _.cloneDeep(object);
		actual = fp.setWith(Object)('[0][1]')('a')(value);
		assert.deepEqual(actual[0], { '1': 'a' }, 'fp.setWith');
		value = _.cloneDeep(object);
		actual = fp.unset('a.b')(value);
		assert.notOk('b' in actual.a, 'fp.unset');
		assert.strictEqual(actual.a.c, value.a.c, 'fp.unset');
		value = _.cloneDeep(object);
		actual = fp.update('a.b')(square)(value);
		assert.strictEqual(actual.a.b, 4, 'fp.update');
		assert.strictEqual(actual.d, value.d, 'fp.update');
		value = _.cloneDeep(object);
		actual = fp.updateWith(Object)('[0][1]')(_.constant('a'))(value);
		assert.deepEqual(actual[0], { '1': 'a' }, 'fp.updateWith');
		assert.strictEqual(actual.d, value.d, 'fp.updateWith');
		});
		}());
		/*--------------------------------------------------------------------------*/
		QUnit.module('fp.add and fp.subtract');
		_.each(['add', 'subtract'], function(methodName) {
		var func = fp[methodName],
		isAdd = methodName == 'add';
		QUnit.test('`fp.' + methodName + '` should not have `rearg` applied', functi
		on(assert) {
		assert.expect(1);
		assert.strictEqual(func('1')('2'), isAdd ? '12' : -1);
		});
		});
		/*--------------------------------------------------------------------------*/
		QUnit.module('object assignments');
		_.each(['assign', 'assignIn', 'defaults', 'defaultsDeep', 'merge'], function(m
		ethodName) {
		var func = fp[methodName];
		QUnit.test('`fp.' + methodName + '` should not mutate values', function(asse
		rt) {
		assert.expect(2);
		var object = { 'a': 1 },
		actual = func(object)({ 'b': 2 });
		assert.deepEqual(object, { 'a': 1 });
		assert.deepEqual(actual, { 'a': 1, 'b': 2 });
		});
		});
		_.each(['assignAll', 'assignInAll', 'defaultsAll', 'defaultsDeepAll', 'mergeAl
		l'], function(methodName) {
		var func = fp[methodName];
		QUnit.test('`fp.' + methodName + '` should not mutate values', function(asse
		rt) {
		assert.expect(2);
		var objects = [{ 'a': 1 }, { 'b': 2 }],
		actual = func(objects);
		assert.deepEqual(objects[0], { 'a': 1 });
		assert.deepEqual(actual, { 'a': 1, 'b': 2 });
		});
		});
		_.each(['assignWith', 'assignInWith', 'extendWith'], function(methodName) {
		var func = fp[methodName];
		QUnit.test('`fp.' + methodName + '` should provide the correct `customizer`
		arguments', function(assert) {
		assert.expect(1);
		var args;
		func(function() {
		args || (args = _.map(arguments, _.cloneDeep));
		})({ 'a': 1 })({ 'b': 2 });
		assert.deepEqual(args, [undefined, 2, 'b', { 'a': 1 }, { 'b': 2 }]);
		});
		});
		_.each(['assignAllWith', 'assignInAllWith', 'extendAllWith', 'mergeAllWith'],
		function(methodName) {
		var func = fp[methodName];
		QUnit.test('`fp.' + methodName + '` should not mutate values', function(asse
		rt) {
		assert.expect(2);
		var objects = [{ 'a': 1 }, { 'b': 2 }],
		actual = func(_.noop)(objects);
		assert.deepEqual(objects[0], { 'a': 1 });
		assert.deepEqual(actual, { 'a': 1, 'b': 2 });
		});
		QUnit.test('`fp.' + methodName + '` should work with more than two sources',
		function(assert) {
		assert.expect(2);
		var pass = false,
		objects = [{ 'a': 1 }, { 'b': 2 }, { 'c': 3 }],
		actual = func(function() { pass = true; })(objects);
		assert.ok(pass);
		assert.deepEqual(actual, { 'a': 1, 'b': 2, 'c': 3 });
		});
		});
		/*--------------------------------------------------------------------------*/
		QUnit.module('fp.castArray');
		(function() {
		QUnit.test('should shallow clone array values', function(assert) {
		assert.expect(2);
		var array = [1],
		actual = fp.castArray(array);
		assert.deepEqual(actual, array);
		assert.notStrictEqual(actual, array);
		});
		QUnit.test('should not shallow clone non-array values', function(assert) {
		assert.expect(2);
		var object = { 'a': 1 },
		actual = fp.castArray(object);
		assert.deepEqual(actual, [object]);
		assert.strictEqual(actual[0], object);
		});
		QUnit.test('should convert by name', function(assert) {
		assert.expect(4);
		var array = [1],
		object = { 'a': 1 },
		castArray = convert('castArray', _.castArray),
		actual = castArray(array);
		assert.deepEqual(actual, array);
		assert.notStrictEqual(actual, array);
		actual = castArray(object);
		assert.deepEqual(actual, [object]);
		assert.strictEqual(actual[0], object);
});		});
}());		}());
/*--------------------------------------------------------------------------*/		/*--------------------------------------------------------------------------*/
QUnit.module('curry methods');		QUnit.module('curry methods');
_.each(['curry', 'curryRight'], function(methodName) {		_.each(['curry', 'curryRight'], function(methodName) {
var func = fp[methodName];		var func = fp[methodName];
QUnit.test('`_.' + methodName + '` should only accept a `func` param', funct ion(assert) {		QUnit.test('fp.' + methodName + '` should only accept a `func` param', funct ion(assert) {
assert.expect(1);		assert.expect(1);
assert.raises(function() { func(1, _.noop); }, TypeError);		assert.raises(function() { func(1, _.noop); }, TypeError);
});		});
});		});
/*--------------------------------------------------------------------------*/		/*--------------------------------------------------------------------------*/
QUnit.module('curryN methods');		QUnit.module('curryN methods');
_.each(['curryN', 'curryRightN'], function(methodName) {		_.each(['curryN', 'curryRightN'], function(methodName) {
var func = fp[methodName];		var func = fp[methodName];
QUnit.test('`_.' + methodName + '` accept an `arity` param', function(assert ) {		QUnit.test('fp.' + methodName + '` should accept an `arity` param', function (assert) {
assert.expect(1);		assert.expect(1);
var actual = func(1, function(a, b) { return [a, b]; })('a');		var actual = func(1)(function(a, b) { return [a, b]; })('a');
assert.deepEqual(actual, ['a', undefined]);		assert.deepEqual(actual, ['a', undefined]);
});		});
});		});
/*--------------------------------------------------------------------------*/		/*--------------------------------------------------------------------------*/
		QUnit.module('fp.defaultTo');
		(function() {
		QUnit.test('should have an argument order of `defaultValue` then `value`', f
		unction(assert) {
		assert.expect(2);
		assert.strictEqual(fp.defaultTo(1)(0), 0);
		assert.strictEqual(fp.defaultTo(1)(undefined), 1);
		});
		}());
		/*--------------------------------------------------------------------------*/
QUnit.module('fp.difference');		QUnit.module('fp.difference');
(function() {		(function() {
QUnit.test('should return the elements of the first array not included in th e second array', function(assert) {		QUnit.test('should return the elements of the first array not included in th e second array', function(assert) {
assert.expect(1);		assert.expect(1);
assert.deepEqual(fp.difference([1, 2])([2, 3]), [1]);		var actual = fp.difference([2, 1], [2, 3]);
		assert.deepEqual(actual, [1]);
		});
		}());
		/*--------------------------------------------------------------------------*/
		QUnit.module('fp.differenceBy');
		(function() {
		QUnit.test('should have an argument order of `iteratee`, `array`, then `valu
		es`', function(assert) {
		assert.expect(1);
		var actual = fp.differenceBy(Math.floor, [2.1, 1.2], [2.3, 3.4]);
		assert.deepEqual(actual, [1.2]);
		});
		QUnit.test('should provide the correct `iteratee` arguments', function(asser
		t) {
		assert.expect(1);
		var args;
		fp.differenceBy(function() {
		args || (args = slice.call(arguments));
		})([2.1, 1.2], [2.3, 3.4]);
		assert.deepEqual(args, [2.3]);
		});
		}());
		/*--------------------------------------------------------------------------*/
		QUnit.module('fp.differenceWith');
		(function() {
		QUnit.test('should have an argument order of `comparator`, `array`, then `va
		lues`', function(assert) {
		assert.expect(1);
		var actual = fp.differenceWith(fp.eq)([2, 1])([2, 3]);
		assert.deepEqual(actual, [1]);
		});
		}());
		/*--------------------------------------------------------------------------*/
		QUnit.module('fp.divide and fp.multiply');
		_.each(['divide', 'multiply'], function(methodName) {
		var func = fp[methodName],
		isDivide = methodName == 'divide';
		QUnit.test('`fp.' + methodName + '` should not have `rearg` applied', functi
		on(assert) {
		assert.expect(1);
		assert.strictEqual(func('2')('4'), isDivide ? 0.5 : 8);
		});
		});
		/*--------------------------------------------------------------------------*/
		QUnit.module('fp.extend');
		(function() {
		QUnit.test('should convert by name', function(assert) {
		assert.expect(2);
		function Foo() {}
		Foo.prototype = { 'b': 2 };
		var object = { 'a': 1 },
		extend = convert('extend', _.extend),
		actual = extend(object)(new Foo);
		assert.deepEqual(object, { 'a': 1 });
		assert.deepEqual(actual, { 'a': 1, 'b': 2 });
});		});
}());		}());
/*--------------------------------------------------------------------------*/		/*--------------------------------------------------------------------------*/
QUnit.module('fp.fill');		QUnit.module('fp.fill');
(function() {		(function() {
QUnit.test('should have an argument order of `start`, `end`, then `value`', function(assert) {		QUnit.test('should have an argument order of `start`, `end`, then `value`', function(assert) {
assert.expect(1);		assert.expect(1);
var array = [1, 2, 3];		var array = [1, 2, 3];
assert.deepEqual(fp.fill(1)(2)('*')(array), [1, '*', 3]);		assert.deepEqual(fp.fill(1)(2)('*')(array), [1, '*', 3]);
});		});
		QUnit.test('should not mutate values', function(assert) {
		assert.expect(2);
		var array = [1, 2, 3],
		actual = fp.fill(1)(2)('*')(array);
		assert.deepEqual(array, [1, 2, 3]);
		assert.deepEqual(actual, [1, '*', 3]);
		});
		}());
		/*--------------------------------------------------------------------------*/
		QUnit.module('fp.findFrom methods');
		_.each(['findFrom', 'findIndexFrom', 'findLastFrom', 'findLastIndexFrom'], fun
		ction(methodName) {
		var func = fp[methodName];
		QUnit.test('fp.' + methodName + '` should provide the correct `predicate` ar
		guments', function(assert) {
		assert.expect(1);
		var args;
		func(function() {
		args || (args = slice.call(arguments));
		})(1)([1, 2, 3]);
		assert.deepEqual(args, [2]);
		});
		});
		/*--------------------------------------------------------------------------*/
		QUnit.module('fp.findFrom');
		(function() {
		function resolve(value) {
		return fp.flow(fp.property('a'), fp.eq(value));
		}
		QUnit.test('should have an argument order of `value`, `fromIndex`, then `arr
		ay`', function(assert) {
		assert.expect(2);
		var objects = [{ 'a': 1 }, { 'a': 2 }, { 'a': 1 }, { 'a': 2 }];
		assert.strictEqual(fp.findFrom(resolve(1))(1)(objects), objects[2]);
		assert.strictEqual(fp.findFrom(resolve(2))(-2)(objects), objects[3]);
		});
		}());
		/*--------------------------------------------------------------------------*/
		QUnit.module('fp.findLastFrom');
		(function() {
		function resolve(value) {
		return fp.flow(fp.property('a'), fp.eq(value));
		}
		QUnit.test('should have an argument order of `value`, `fromIndex`, then `arr
		ay`', function(assert) {
		assert.expect(2);
		var objects = [{ 'a': 1 }, { 'a': 2 }, { 'a': 1 }, { 'a': 2 }];
		assert.strictEqual(fp.findLastFrom(resolve(1))(1)(objects), objects[0]);
		assert.strictEqual(fp.findLastFrom(resolve(2))(-2)(objects), objects[1]);
		});
		}());
		/*--------------------------------------------------------------------------*/
		QUnit.module('fp.findIndexFrom and fp.indexOfFrom');
		_.each(['findIndexFrom', 'indexOfFrom'], function(methodName) {
		var func = fp[methodName],
		resolve = methodName == 'findIndexFrom' ? fp.eq : _.identity;
		QUnit.test('fp.' + methodName + '` should have an argument order of `value`,
		`fromIndex`, then `array`', function(assert) {
		assert.expect(2);
		var array = [1, 2, 3, 1, 2, 3];
		assert.strictEqual(func(resolve(1))(2)(array), 3);
		assert.strictEqual(func(resolve(2))(-3)(array), 4);
		});
		});
		/*--------------------------------------------------------------------------*/
		QUnit.module('fp.findLastIndexFrom and fp.lastIndexOfFrom');
		_.each(['findLastIndexFrom', 'lastIndexOfFrom'], function(methodName) {
		var func = fp[methodName],
		resolve = methodName == 'findLastIndexFrom' ? fp.eq : _.identity;
		QUnit.test('fp.' + methodName + '` should have an argument order of `value`,
		`fromIndex`, then `array`', function(assert) {
		assert.expect(2);
		var array = [1, 2, 3, 1, 2, 3];
		assert.strictEqual(func(resolve(2))(3)(array), 1);
		assert.strictEqual(func(resolve(3))(-3)(array), 2);
		});
		});
		/*--------------------------------------------------------------------------*/
		QUnit.module('fp.flatMapDepth');
		(function() {
		QUnit.test('should have an argument order of `iteratee`, `depth`, then `coll
		ection`', function(assert) {
		assert.expect(2);
		function duplicate(n) {
		return [[[n, n]]];
		}
		var array = [1, 2],
		object = { 'a': 1, 'b': 2 },
		expected = [[1, 1], [2, 2]];
		assert.deepEqual(fp.flatMapDepth(duplicate)(2)(array), expected);
		assert.deepEqual(fp.flatMapDepth(duplicate)(2)(object), expected);
		});
}());		}());
/*--------------------------------------------------------------------------*/		/*--------------------------------------------------------------------------*/
QUnit.module('fp.flow and fp.flowRight');		QUnit.module('flow methods');
_.each(['flow', 'flowRight'], function(methodName, index) {		_.each(['flow', 'flowRight'], function(methodName) {
var func = fp[methodName],		var func = fp[methodName],
isFlow = methodName == 'flow';		isFlow = methodName == 'flow';
QUnit.test('`fp.' + methodName + '` should support shortcut fusion', functio n(assert) {		QUnit.test('`fp.' + methodName + '` should support shortcut fusion', functio n(assert) {
assert.expect(6);		assert.expect(6);
var filterCount,		var filterCount,
mapCount,		mapCount,
array = fp.range(0, LARGE_ARRAY_SIZE);		array = fp.range(0, LARGE_ARRAY_SIZE);
var iteratee = function(value) {		var iteratee = function(value) {
mapCount++;		mapCount++;
return value * value;		return square(value);
};		};
var predicate = function(value) {		var predicate = function(value) {
filterCount++;		filterCount++;
return value % 2 == 0;		return isEven(value);
};		};
var filter = fp.filter(predicate),		var filter = fp.filter(predicate),
map = fp.map(iteratee),		map = fp.map(iteratee),
take = fp.take(2);		take = fp.take(2);
_.times(2, function(index) {		_.times(2, function(index) {
var combined = isFlow		var combined = isFlow
? func(map, filter, fp.compact, take)		? func(map, filter, fp.compact, take)
: func(take, fp.compact, filter, map);		: func(take, fp.compact, filter, map);
filterCount = mapCount = 0;		filterCount = mapCount = 0;
if (WeakMap && WeakMap.name) {		if (WeakMap && WeakMap.name) {
assert.deepEqual(combined(array), [4, 16]);		assert.deepEqual(combined(array), [4, 16]);
assert.strictEqual(filterCount, 5, 'filterCount');		assert.strictEqual(filterCount, 5, 'filterCount');
assert.strictEqual(mapCount, 5, 'mapCount');		assert.strictEqual(mapCount, 5, 'mapCount');
}		}
else {		else {
skipTest(assert, 3);		skipAssert(assert, 3);
}		}
});		});
});		});
});		});
/*--------------------------------------------------------------------------*/		/*--------------------------------------------------------------------------*/
		QUnit.module('forEach methods');
		_.each(['forEach', 'forEachRight', 'forIn', 'forInRight', 'forOwn', 'forOwnRig
		ht'], function(methodName) {
		var func = fp[methodName];
		QUnit.test('`fp.' + methodName + '` should provide `value` to `iteratee`', f
		unction(assert) {
		assert.expect(2);
		var args;
		func(function() {
		args || (args = slice.call(arguments));
		})(['a']);
		assert.deepEqual(args, ['a']);
		args = undefined;
		func(function() {
		args || (args = slice.call(arguments));
		})({ 'a': 1 });
		assert.deepEqual(args, [1]);
		});
		});
		/*--------------------------------------------------------------------------*/
		QUnit.module('fp.getOr');
		(function() {
		QUnit.test('should accept a `defaultValue` param', function(assert) {
		assert.expect(1);
		var actual = fp.getOr('default')('path')({});
		assert.strictEqual(actual, 'default');
		});
		}());
		/*--------------------------------------------------------------------------*/
		QUnit.module('fp.gt and fp.gte');
		_.each(['gt', 'gte'], function(methodName) {
		var func = fp[methodName];
		QUnit.test('`fp.' + methodName + '` should have `rearg` applied', function(a
		ssert) {
		assert.expect(1);
		assert.strictEqual(func(2)(1), true);
		});
		});
		/*--------------------------------------------------------------------------*/
QUnit.module('fp.inRange');		QUnit.module('fp.inRange');
(function() {		(function() {
QUnit.test('should have an argument order of `start`, `end`, then `value`', function(assert) {		QUnit.test('should have an argument order of `start`, `end`, then `value`', function(assert) {
assert.expect(1);		assert.expect(2);
assert.strictEqual(fp.inRange(2)(4)(3), true);		assert.strictEqual(fp.inRange(2)(4)(3), true);
		assert.strictEqual(fp.inRange(-2)(-6)(-3), true);
		});
		}());
		/*--------------------------------------------------------------------------*/
		QUnit.module('fp.intersectionBy');
		(function() {
		QUnit.test('should have an argument order of `iteratee`, `array`, then `valu
		es`', function(assert) {
		assert.expect(1);
		var actual = fp.intersectionBy(Math.floor, [2.1, 1.2], [2.3, 3.4]);
		assert.deepEqual(actual, [2.1]);
		});
		QUnit.test('should provide the correct `iteratee` arguments', function(asser
		t) {
		assert.expect(1);
		var args;
		fp.intersectionBy(function() {
		args || (args = slice.call(arguments));
		})([2.1, 1.2], [2.3, 3.4]);
		assert.deepEqual(args, [2.3]);
		});
		}());
		/*--------------------------------------------------------------------------*/
		QUnit.module('fp.intersectionWith');
		(function() {
		QUnit.test('should have an argument order of `comparator`, `array`, then `va
		lues`', function(assert) {
		assert.expect(1);
		var actual = fp.intersectionWith(fp.eq)([2, 1])([2, 3]);
		assert.deepEqual(actual, [2]);
		});
		}());
		/*--------------------------------------------------------------------------*/
		QUnit.module('fp.invoke');
		(function() {
		QUnit.test('should not accept an `args` param', function(assert) {
		assert.expect(1);
		var actual = fp.invoke('toUpperCase')('a');
		assert.strictEqual(actual, 'A');
		});
		}());
		/*--------------------------------------------------------------------------*/
		QUnit.module('fp.invokeMap');
		(function() {
		QUnit.test('should not accept an `args` param', function(assert) {
		assert.expect(1);
		var actual = fp.invokeMap('toUpperCase')(['a', 'b']);
		assert.deepEqual(actual, ['A', 'B']);
		});
		}());
		/*--------------------------------------------------------------------------*/
		QUnit.module('fp.invokeArgs');
		(function() {
		QUnit.test('should accept an `args` param', function(assert) {
		assert.expect(1);
		var actual = fp.invokeArgs('concat')(['b', 'c'])('a');
		assert.strictEqual(actual, 'abc');
		});
		}());
		/*--------------------------------------------------------------------------*/
		QUnit.module('fp.invokeArgsMap');
		(function() {
		QUnit.test('should accept an `args` param', function(assert) {
		assert.expect(1);
		var actual = fp.invokeArgsMap('concat')(['b', 'c'])(['a', 'A']);
		assert.deepEqual(actual, ['abc', 'Abc']);
		});
		}());
		/*--------------------------------------------------------------------------*/
		QUnit.module('fp.isEqualWith');
		(function() {
		QUnit.test('should provide the correct `customizer` arguments', function(ass
		ert) {
		assert.expect(1);
		var args,
		iteration = 0,
		objects = [{ 'a': 1 }, { 'a': 2 }],
		stack = { '__data__': { '__data__': [objects, objects.slice().reverse(
		)], 'size': 2 }, 'size': 2 },
		expected = [1, 2, 'a', objects[0], objects[1], stack];
		fp.isEqualWith(function() {
		if (++iteration == 2) {
		args = _.map(arguments, _.cloneDeep);
		}
		})(objects[0])(objects[1]);
		args[5] = _.omitBy(args[5], _.isFunction);
		args[5].__data__ = _.omitBy(args[5].__data__, _.isFunction);
		assert.deepEqual(args, expected);
		});
		}());
		/*--------------------------------------------------------------------------*/
		QUnit.module('fp.isMatchWith');
		(function() {
		QUnit.test('should provide the correct `customizer` arguments', function(ass
		ert) {
		assert.expect(1);
		var args,
		objects = [{ 'a': 1 }, { 'a': 2 }],
		stack = { '__data__': { '__data__': [], 'size': 0 }, 'size': 0 },
		expected = [2, 1, 'a', objects[1], objects[0], stack];
		fp.isMatchWith(function() {
		args || (args = _.map(arguments, _.cloneDeep));
		})(objects[0])(objects[1]);
		args[5] = _.omitBy(args[5], _.isFunction);
		args[5].__data__ = _.omitBy(args[5].__data__, _.isFunction);
		assert.deepEqual(args, expected);
});		});
}());		}());
/*--------------------------------------------------------------------------*/		/*--------------------------------------------------------------------------*/
QUnit.module('fp.iteratee');		QUnit.module('fp.iteratee');
(function() {		(function() {
QUnit.test('should return a iteratee with capped params', function(assert) {		QUnit.test('should return a iteratee with capped params', function(assert) {
assert.expect(1);		assert.expect(1);
var func = fp.iteratee(function(a, b, c) { return [a, b, c]; }, undefined, 3);		var func = fp.iteratee(function(a, b, c) { return [a, b, c]; }, 3);
assert.deepEqual(func(1, 2, 3), [1, undefined, undefined]);		assert.deepEqual(func(1, 2, 3), [1, undefined, undefined]);
});		});
QUnit.test('should convert by name', function(assert) {		QUnit.test('should convert by name', function(assert) {
assert.expect(1);		assert.expect(1);
if (!document) {		var iteratee = convert('iteratee', _.iteratee),
var iteratee = convert('iteratee', _.iteratee),		func = iteratee(function(a, b, c) { return [a, b, c]; }, 3);
func = iteratee(function(a, b, c) { return [a, b, c]; }, undefined,
3);
assert.deepEqual(func(1, 2, 3), [1, undefined, undefined]);		assert.deepEqual(func(1, 2, 3), [1, undefined, undefined]);
}		});
else {		}());
skipTest(assert);
}		/*--------------------------------------------------------------------------*/
		QUnit.module('fp.lt and fp.lte');
		_.each(['lt', 'lte'], function(methodName) {
		var func = fp[methodName];
		QUnit.test('`fp.' + methodName + '` should have `rearg` applied', function(a
		ssert) {
		assert.expect(1);
		assert.strictEqual(func(1)(2), true);
		});
		});
		/*--------------------------------------------------------------------------*/
		QUnit.module('fp.mapKeys');
		(function() {
		QUnit.test('should only provide `key` to `iteratee`', function(assert) {
		assert.expect(1);
		var args;
		fp.mapKeys(function() {
		args || (args = slice.call(arguments));
		}, { 'a': 1 });
		assert.deepEqual(args, ['a']);
});		});
}());		}());
/*--------------------------------------------------------------------------*/		/*--------------------------------------------------------------------------*/
QUnit.module('fp.maxBy and fp.minBy');		QUnit.module('fp.maxBy and fp.minBy');
_.each(['maxBy', 'minBy'], function(methodName, index) {		_.each(['maxBy', 'minBy'], function(methodName) {
var array = [1, 2, 3],		var array = [1, 2, 3],
func = fp[methodName],		func = fp[methodName],
isMax = !index;		isMax = methodName == 'maxBy';
QUnit.test('`fp.' + methodName + '` should work with an `iteratee` argument' , function(assert) {		QUnit.test('`fp.' + methodName + '` should work with an `iteratee` argument' , function(assert) {
assert.expect(1);		assert.expect(1);
var actual = func(function(num) {		var actual = func(function(num) {
return -num;		return -num;
})(array);		})(array);
assert.strictEqual(actual, isMax ? 1 : 3);		assert.strictEqual(actual, isMax ? 1 : 3);
});		});
skipping to change at line 476		skipping to change at line 1442
func(function() {		func(function() {
args || (args = slice.call(arguments));		args || (args = slice.call(arguments));
})(array);		})(array);
assert.deepEqual(args, [1]);		assert.deepEqual(args, [1]);
});		});
});		});
/*--------------------------------------------------------------------------*/		/*--------------------------------------------------------------------------*/
		QUnit.module('fp.mergeWith');
		(function() {
		QUnit.test('should provide the correct `customizer` arguments', function(ass
		ert) {
		assert.expect(1);
		var args,
		stack = { '__data__': { '__data__': [], 'size': 0 }, 'size': 0 },
		expected = [[1, 2], [3], 'a', { 'a': [1, 2] }, { 'a': [3] }, stack];
		fp.mergeWith(function() {
		args || (args = _.map(arguments, _.cloneDeep));
		})({ 'a': [1, 2] })({ 'a': [3] });
		args[5] = _.omitBy(args[5], _.isFunction);
		args[5].__data__ = _.omitBy(args[5].__data__, _.isFunction);
		assert.deepEqual(args, expected);
		});
		QUnit.test('should not mutate values', function(assert) {
		assert.expect(2);
		var objects = [{ 'a': [1, 2] }, { 'a': [3] }],
		actual = fp.mergeWith(_.noop, objects[0], objects[1]);
		assert.deepEqual(objects[0], { 'a': [1, 2] });
		assert.deepEqual(actual, { 'a': [3, 2] });
		});
		}());
		/*--------------------------------------------------------------------------*/
		QUnit.module('fp.mergeAllWith');
		(function() {
		QUnit.test('should provide the correct `customizer` arguments', function(ass
		ert) {
		assert.expect(1);
		var args,
		objects = [{ 'a': [1, 2] }, { 'a': [3] }],
		stack = { '__data__': { '__data__': [], 'size': 0 }, 'size': 0 },
		expected = [[1, 2], [3], 'a', { 'a': [1, 2] }, { 'a': [3] }, stack];
		fp.mergeAllWith(function() {
		args || (args = _.map(arguments, _.cloneDeep));
		})(objects);
		args[5] = _.omitBy(args[5], _.isFunction);
		args[5].__data__ = _.omitBy(args[5].__data__, _.isFunction);
		assert.deepEqual(args, expected);
		});
		}());
		/*--------------------------------------------------------------------------*/
QUnit.module('fp.mixin');		QUnit.module('fp.mixin');
(function() {		(function() {
var source = { 'a': _.noop };		var source = { 'a': _.noop };
QUnit.test('should mixin static methods but not prototype methods', function (assert) {		QUnit.test('should mixin static methods but not prototype methods', function (assert) {
assert.expect(2);		assert.expect(2);
fp.mixin(source);		fp.mixin(source);
skipping to change at line 545		skipping to change at line 1568
if (root[key] === fp[key]) {		if (root[key] === fp[key]) {
delete root[key];		delete root[key];
}		}
});		});
});		});
});		});
QUnit.test('should convert by name', function(assert) {		QUnit.test('should convert by name', function(assert) {
assert.expect(3);		assert.expect(3);
if (!document) {		var object = { 'mixin': convert('mixin', _.mixin) };
var object = { 'mixin': convert('mixin', _.mixin) };
function Foo() {}		function Foo() {}
Foo.mixin = object.mixin;		Foo.mixin = object.mixin;
Foo.mixin(source);		Foo.mixin(source);
assert.strictEqual(typeof Foo.a, 'function');		assert.ok('a' in Foo);
assert.notOk('a' in Foo.prototype);		assert.notOk('a' in Foo.prototype);
object.mixin(source);		object.mixin(source);
assert.strictEqual(typeof object.a, 'function');		assert.ok('a' in object);
}		});
else {		}());
skipTest(assert, 3);
		/*--------------------------------------------------------------------------*/
		QUnit.module('fp.nthArg');
		(function() {
		QUnit.test('should return a curried function', function(assert) {
		assert.expect(2);
		var func = fp.nthArg(1);
		assert.strictEqual(func(1)(2), 2);
		func = fp.nthArg(-1);
		assert.strictEqual(func(1), 1);
		});
		}());
		/*--------------------------------------------------------------------------*/
		QUnit.module('fp.over');
		(function() {
		QUnit.test('should not cap iteratee args', function(assert) {
		assert.expect(2);
		_.each([fp.over, convert('over', _.over)], function(func) {
		var over = func([Math.max, Math.min]);
		assert.deepEqual(over(1, 2, 3, 4), [4, 1]);
		});
		});
		}());
		/*--------------------------------------------------------------------------*/
		QUnit.module('fp.omitBy and fp.pickBy');
		_.each(['omitBy', 'pickBy'], function(methodName) {
		var func = fp[methodName];
		QUnit.test('`fp.' + methodName + '` should provide `value` and `key` to `ite
		ratee`', function(assert) {
		assert.expect(1);
		var args;
		func(function() {
		args || (args = slice.call(arguments));
		})({ 'a': 1 });
		assert.deepEqual(args, [1, 'a']);
		});
		});
		/*--------------------------------------------------------------------------*/
		QUnit.module('padChars methods');
		_.each(['padChars', 'padCharsStart', 'padCharsEnd'], function(methodName) {
		var func = fp[methodName],
		isPad = methodName == 'padChars',
		isStart = methodName == 'padCharsStart';
		QUnit.test('fp.' + methodName + '` should truncate pad characters to fit the
		pad length', function(assert) {
		assert.expect(1);
		if (isPad) {
		assert.strictEqual(func('_-')(8)('abc'), '_-abc_-_');
		} else {
		assert.strictEqual(func('_-')(6)('abc'), isStart ? '_-_abc' : 'abc_-_');
}		}
});		});
		});
		/*--------------------------------------------------------------------------*/
		QUnit.module('partial methods');
		_.each(['partial', 'partialRight'], function(methodName) {
		var func = fp[methodName],
		isPartial = methodName == 'partial';
		QUnit.test('fp.' + methodName + '` should accept an `args` param', function(
		assert) {
		assert.expect(1);
		var expected = isPartial ? [1, 2, 3] : [0, 1, 2];
		var actual = func(function(a, b, c) {
		return [a, b, c];
		})([1, 2])(isPartial ? 3 : 0);
		assert.deepEqual(actual, expected);
		});
		QUnit.test('fp.' + methodName + '` should convert by name', function(assert)
		{
		assert.expect(2);
		var expected = isPartial ? [1, 2, 3] : [0, 1, 2],
		par = convert(methodName, _[methodName]),
		ph = par.placeholder;
		var actual = par(function(a, b, c) {
		return [a, b, c];
		})([1, 2])(isPartial ? 3 : 0);
		assert.deepEqual(actual, expected);
		actual = par(function(a, b, c) {
		return [a, b, c];
		})([ph, 2])(isPartial ? 1 : 0, isPartial ? 3 : 1);
		assert.deepEqual(actual, expected);
		});
		});
		/*--------------------------------------------------------------------------*/
		QUnit.module('fp.propertyOf');
		(function() {
		QUnit.test('should be curried', function(assert) {
		assert.expect(2);
		var object = { 'a': 1 };
		assert.strictEqual(fp.propertyOf(object, 'a'), 1);
		assert.strictEqual(fp.propertyOf(object)('a'), 1);
		});
		}());
		/*--------------------------------------------------------------------------*/
		QUnit.module('fp.pull');
		(function() {
		QUnit.test('should not mutate values', function(assert) {
		assert.expect(2);
		var array = [1, 2, 3],
		actual = fp.pull(2)(array);
		assert.deepEqual(array, [1, 2, 3]);
		assert.deepEqual(actual, [1, 3]);
		});
		}());
		/*--------------------------------------------------------------------------*/
		QUnit.module('fp.pullAll');
		(function() {
		QUnit.test('should not mutate values', function(assert) {
		assert.expect(2);
		var array = [1, 2, 3],
		actual = fp.pullAll([1, 3])(array);
		assert.deepEqual(array, [1, 2, 3]);
		assert.deepEqual(actual, [2]);
		});
		}());
		/*--------------------------------------------------------------------------*/
		QUnit.module('fp.pullAt');
		(function() {
		QUnit.test('should not mutate values', function(assert) {
		assert.expect(2);
		var array = [1, 2, 3],
		actual = fp.pullAt([0, 2])(array);
		assert.deepEqual(array, [1, 2, 3]);
		assert.deepEqual(actual, [2]);
		});
}());		}());
/*--------------------------------------------------------------------------*/		/*--------------------------------------------------------------------------*/
QUnit.module('fp.random');		QUnit.module('fp.random');
(function() {		(function() {
var array = Array(1000);		var array = Array(1000);
QUnit.test('should support a `min` and `max` argument', function(assert) {		QUnit.test('should support a `min` and `max` argument', function(assert) {
skipping to change at line 586		skipping to change at line 1779
assert.ok(_.some(array, function() {		assert.ok(_.some(array, function() {
var result = fp.random(min)(max);		var result = fp.random(min)(max);
return result >= min && result <= max;		return result >= min && result <= max;
}));		}));
});		});
}());		}());
/*--------------------------------------------------------------------------*/		/*--------------------------------------------------------------------------*/
QUnit.module('fp.range');		QUnit.module('range methods');
		_.each(['range', 'rangeRight'], function(methodName) {
		var func = fp[methodName],
		isRange = methodName == 'range';
		QUnit.test('fp.' + methodName + '` should have an argument order of `start`
		then `end`', function(assert) {
		assert.expect(1);
		assert.deepEqual(func(1)(4), isRange ? [1, 2, 3] : [3, 2, 1]);
		});
		});
		/*--------------------------------------------------------------------------*/
		QUnit.module('rangeStep methods');
		_.each(['rangeStep', 'rangeStepRight'], function(methodName) {
		var func = fp[methodName],
		isRange = methodName == 'rangeStep';
		QUnit.test('fp.' + methodName + '` should have an argument order of `step`,
		`start`, then `end`', function(assert) {
		assert.expect(1);
		assert.deepEqual(func(2)(1)(4), isRange ? [1, 3] : [3, 1]);
		});
		});
		/*--------------------------------------------------------------------------*/
		QUnit.module('fp.rearg');
(function() {		(function() {
QUnit.test('should have an argument order of `start` then `end`', function(a		function fn(a, b, c) {
ssert) {		return [a, b, c];
		}
		QUnit.test('should be curried', function(assert) {
		assert.expect(1);
		var rearged = fp.rearg([1, 2, 0])(fn);
		assert.deepEqual(rearged('c', 'a', 'b'), ['a', 'b', 'c']);
		});
		QUnit.test('should return a curried function', function(assert) {
assert.expect(1);		assert.expect(1);
assert.deepEqual(fp.range(1)(4), [1, 2, 3]);		var rearged = fp.rearg([1, 2, 0], fn);
		assert.deepEqual(rearged('c')('a')('b'), ['a', 'b', 'c']);
});		});
}());		}());
/*--------------------------------------------------------------------------*/		/*--------------------------------------------------------------------------*/
QUnit.module('reduce methods');		QUnit.module('reduce methods');
_.each(['reduce', 'reduceRight'], function(methodName) {		_.each(['reduce', 'reduceRight'], function(methodName) {
var func = fp[methodName],		var func = fp[methodName],
isReduce = methodName == 'reduce';		isReduce = methodName == 'reduce';
QUnit.test('`_.' + methodName + '` should provide the correct `iteratee` arg uments when iterating an array', function(assert) {		QUnit.test('`fp.' + methodName + '` should provide the correct `iteratee` ar guments when iterating an array', function(assert) {
assert.expect(1);		assert.expect(1);
var args,		var args;
array = [1, 2, 3];
func(function() {		func(function() {
args || (args = slice.call(arguments));		args || (args = slice.call(arguments));
})(0, array);		})(0)([1, 2, 3]);
assert.deepEqual(args, isReduce ? [0, 1] : [0, 3]);		assert.deepEqual(args, isReduce ? [0, 1] : [3, 0]);
});		});
QUnit.test('`_.' + methodName + '` should provide the correct `iteratee` arg uments when iterating an object', function(assert) {		QUnit.test('`fp.' + methodName + '` should provide the correct `iteratee` ar guments when iterating an object', function(assert) {
assert.expect(1);		assert.expect(1);
var args,		var args,
object = { 'a': 1, 'b': 2 },		object = { 'a': 1, 'b': 2 },
isFIFO = _.keys(object)[0] == 'a';		isFIFO = _.keys(object)[0] == 'a';
var expected = isFIFO		var expected = isFIFO
? (isReduce ? [0, 1] : [0, 2])		? (isReduce ? [0, 1] : [2, 0])
: (isReduce ? [0, 2] : [0, 1]);		: (isReduce ? [0, 2] : [1, 0]);
func(function() {		func(function() {
args || (args = slice.call(arguments));		args || (args = slice.call(arguments));
})(0, object);		})(0)(object);
assert.deepEqual(args, expected);		assert.deepEqual(args, expected);
});		});
});		});
/*--------------------------------------------------------------------------*/		/*--------------------------------------------------------------------------*/
		QUnit.module('fp.remove');
		(function() {
		QUnit.test('should not mutate values', function(assert) {
		assert.expect(2);
		var array = [1, 2, 3],
		actual = fp.remove(fp.eq(2))(array);
		assert.deepEqual(array, [1, 2, 3]);
		assert.deepEqual(actual, [1, 3]);
		});
		}());
		/*--------------------------------------------------------------------------*/
		QUnit.module('fp.restFrom');
		(function() {
		QUnit.test('should accept a `start` param', function(assert) {
		assert.expect(1);
		var actual = fp.restFrom(2)(function() {
		return slice.call(arguments);
		})('a', 'b', 'c', 'd');
		assert.deepEqual(actual, ['a', 'b', ['c', 'd']]);
		});
		}());
		/*--------------------------------------------------------------------------*/
		QUnit.module('fp.reverse');
		(function() {
		QUnit.test('should not mutate values', function(assert) {
		assert.expect(2);
		var array = [1, 2, 3],
		actual = fp.reverse(array);
		assert.deepEqual(array, [1, 2, 3]);
		assert.deepEqual(actual, [3, 2, 1]);
		});
		}());
		/*--------------------------------------------------------------------------*/
QUnit.module('fp.runInContext');		QUnit.module('fp.runInContext');
(function() {		(function() {
QUnit.test('should return a converted lodash instance', function(assert) {		QUnit.test('should return a converted lodash instance', function(assert) {
assert.expect(1);		assert.expect(1);
assert.strictEqual(typeof fp.runInContext({}).curryN, 'function');		assert.strictEqual(typeof fp.runInContext({}).curryN, 'function');
});		});
QUnit.test('should convert by name', function(assert) {		QUnit.test('should convert by name', function(assert) {
assert.expect(1);		assert.expect(1);
if (!document) {		var runInContext = convert('runInContext', _.runInContext);
var runInContext = convert('runInContext', _.runInContext);		assert.strictEqual(typeof runInContext({}).curryN, 'function');
assert.strictEqual(typeof runInContext({}).curryN, 'function');		});
}		}());
else {
skipTest(assert);		/*--------------------------------------------------------------------------*/
}
		QUnit.module('fp.set');
		(function() {
		QUnit.test('should not mutate values', function(assert) {
		assert.expect(2);
		var object = { 'a': { 'b': 2, 'c': 3 } },
		actual = fp.set('a.b')(3)(object);
		assert.deepEqual(object, { 'a': { 'b': 2, 'c': 3 } });
		assert.deepEqual(actual, { 'a': { 'b': 3, 'c': 3 } });
		});
		}());
		/*--------------------------------------------------------------------------*/
		QUnit.module('fp.setWith');
		(function() {
		QUnit.test('should provide the correct `customizer` arguments', function(ass
		ert) {
		assert.expect(1);
		var args;
		fp.setWith(function() {
		args || (args = _.map(arguments, _.cloneDeep));
		})('b.c')(2)({ 'a': 1 });
		assert.deepEqual(args, [undefined, 'b', { 'a': 1 }]);
		});
		QUnit.test('should not mutate values', function(assert) {
		assert.expect(2);
		var object = { 'a': { 'b': 2, 'c': 3 } },
		actual = fp.setWith(Object)('d.e')(4)(object);
		assert.deepEqual(object, { 'a': { 'b': 2, 'c': 3 } });
		assert.deepEqual(actual, { 'a': { 'b': 2, 'c': 3 }, 'd': { 'e': 4 } });
		});
		}());
		/*--------------------------------------------------------------------------*/
		QUnit.module('fp.spreadFrom');
		(function() {
		QUnit.test('should accept a `start` param', function(assert) {
		assert.expect(1);
		var actual = fp.spreadFrom(2)(function() {
		return slice.call(arguments);
		})('a', 'b', ['c', 'd']);
		assert.deepEqual(actual, ['a', 'b', 'c', 'd']);
		});
		}());
		/*--------------------------------------------------------------------------*/
		QUnit.module('trimChars methods');
		_.each(['trimChars', 'trimCharsStart', 'trimCharsEnd'], function(methodName, i
		ndex) {
		var func = fp[methodName],
		parts = [];
		if (index != 2) {
		parts.push('leading');
		}
		if (index != 1) {
		parts.push('trailing');
		}
		parts = parts.join(' and ');
		QUnit.test('`fp.' + methodName + '` should remove ' + parts + ' `chars`', fu
		nction(assert) {
		assert.expect(1);
		var string = '-_-a-b-c-_-',
		expected = (index == 2 ? '-_-' : '') + 'a-b-c' + (index == 1 ? '-_-' :
		'');
		assert.strictEqual(func('_-')(string), expected);
		});
		});
		/*--------------------------------------------------------------------------*/
		QUnit.module('fp.unionBy');
		(function() {
		QUnit.test('should have an argument order of `iteratee`, `array`, then `othe
		r`', function(assert) {
		assert.expect(1);
		var actual = fp.unionBy(Math.floor, [2.1], [1.2, 2.3]);
		assert.deepEqual(actual, [2.1, 1.2]);
		});
		QUnit.test('should provide the correct `iteratee` arguments', function(asser
		t) {
		assert.expect(1);
		var args;
		fp.unionBy(function() {
		args || (args = slice.call(arguments));
		})([2.1], [1.2, 2.3]);
		assert.deepEqual(args, [2.1]);
		});
		}());
		/*--------------------------------------------------------------------------*/
		QUnit.module('fp.unionWith');
		(function() {
		QUnit.test('should have an argument order of `comparator`, `array`, then `va
		lues`', function(assert) {
		assert.expect(1);
		var actual = fp.unionWith(fp.eq)([2, 1])([2, 3]);
		assert.deepEqual(actual, [2, 1, 3]);
		});
		QUnit.test('should provide the correct `comparator` arguments', function(ass
		ert) {
		assert.expect(1);
		var args;
		fp.unionWith(function() {
		args || (args = slice.call(arguments));
		})([2, 1])([2, 3]);
		assert.deepEqual(args, [1, 2]);
});		});
}());		}());
/*--------------------------------------------------------------------------*/		/*--------------------------------------------------------------------------*/
QUnit.module('fp.uniqBy');		QUnit.module('fp.uniqBy');
(function() {		(function() {
var objects = [{ 'a': 2 }, { 'a': 3 }, { 'a': 1 }, { 'a': 2 }, { 'a': 3 }, { 'a': 1 }];		var objects = [{ 'a': 2 }, { 'a': 3 }, { 'a': 1 }, { 'a': 2 }, { 'a': 3 }, { 'a': 1 }];
QUnit.test('should work with an `iteratee` argument', function(assert) {		QUnit.test('should work with an `iteratee` argument', function(assert) {
assert.expect(1);		assert.expect(1);
var expected = objects.slice(0, 3);		var expected = objects.slice(0, 3),
		actual = fp.uniqBy(_.property('a'))(objects);
var actual = fp.uniqBy(function(object) {
return object.a;
})(objects);
assert.deepEqual(actual, expected);		assert.deepEqual(actual, expected);
});		});
QUnit.test('should provide the correct `iteratee` arguments', function(asser t) {		QUnit.test('should provide the correct `iteratee` arguments', function(asser t) {
assert.expect(1);		assert.expect(1);
var args;		var args;
fp.uniqBy(function() {		fp.uniqBy(function() {
args || (args = slice.call(arguments));		args || (args = slice.call(arguments));
})(objects);		})(objects);
assert.deepEqual(args, [objects[0]]);		assert.deepEqual(args, [objects[0]]);
});		});
}());		}());
/*--------------------------------------------------------------------------*/		/*--------------------------------------------------------------------------*/
QUnit.module('fp.zip');		QUnit.module('fp.uniqWith');
(function() {		(function() {
QUnit.test('should zip together two arrays', function(assert) {		QUnit.test('should have an argument order of `comparator`, `array`, then `va lues`', function(assert) {
assert.expect(1);		assert.expect(1);
assert.deepEqual(fp.zip([1, 2], [3, 4]), [[1, 3], [2, 4]]);		var actual = fp.uniqWith(fp.eq)([2, 1, 2]);
		assert.deepEqual(actual, [2, 1]);
		});
		QUnit.test('should provide the correct `comparator` arguments', function(ass
		ert) {
		assert.expect(1);
		var args;
		fp.uniqWith(function() {
		args || (args = slice.call(arguments));
		})([2, 1, 2]);
		assert.deepEqual(args, [1, 2]);
});		});
}());		}());
/*--------------------------------------------------------------------------*/		/*--------------------------------------------------------------------------*/
QUnit.module('fp.zipObject');		QUnit.module('fp.update');
(function() {		(function() {
QUnit.test('should zip together key/value arrays into an object', function(a ssert) {		QUnit.test('should not convert end of `path` to an object', function(assert) {
assert.expect(1);		assert.expect(1);
assert.deepEqual(fp.zipObject(['a', 'b'], [1, 2]), { 'a': 1, 'b': 2 });		var actual = fp.update('a.b')(_.identity)({ 'a': { 'b': 1 } });
		assert.strictEqual(typeof actual.a.b, 'number');
		});
		QUnit.test('should not convert uncloneables to objects', function(assert) {
		assert.expect(2);
		var object = { 'a': { 'b': _.constant(true) } },
		actual = fp.update('a.b')(_.identity)(object);
		assert.strictEqual(typeof object.a.b, 'function');
		assert.strictEqual(object.a.b, actual.a.b);
		});
		QUnit.test('should not mutate values', function(assert) {
		assert.expect(2);
		var object = { 'a': { 'b': 2, 'c': 3 } },
		actual = fp.update('a.b')(square)(object);
		assert.deepEqual(object, { 'a': { 'b': 2, 'c': 3 } });
		assert.deepEqual(actual, { 'a': { 'b': 4, 'c': 3 } });
});		});
}());		}());
/*--------------------------------------------------------------------------*/		/*--------------------------------------------------------------------------*/
QUnit.module('mutation methods');		QUnit.module('fp.updateWith');
(function() {		(function() {
var array = [1, 2, 3],		QUnit.test('should provide the correct `customizer` arguments', function(ass
object = { 'a': 1 },		ert) {
deepObject = { 'a': { 'b': 2, 'c': 3 } };		var args;
QUnit.test('should not mutate values', function(assert) {
assert.expect(32);
function Foo() {}		fp.updateWith(function() {
Foo.prototype = { 'b': 2 };		args || (args = _.map(arguments, _.cloneDeep));
		})('b.c')(_.constant(2))({ 'a': 1 });
var value = _.clone(object),		assert.deepEqual(args, [undefined, 'b', { 'a': 1 }]);
actual = fp.assign({ 'b': 2 }, value);		});
assert.deepEqual(value, object, 'fp.assign');		QUnit.test('should not mutate values', function(assert) {
assert.deepEqual(actual, { 'a': 1, 'b': 2 }, 'fp.assign');		assert.expect(2);
value = _.clone(object);		var object = { 'a': { 'b': 2, 'c': 3 } },
actual = fp.assignWith(function(objValue, srcValue) {		actual = fp.updateWith(Object)('d.e')(_.constant(4))(object);
return srcValue;
}, { 'b': 2 }, value);
assert.deepEqual(value, object, 'fp.assignWith');		assert.deepEqual(object, { 'a': { 'b': 2, 'c': 3 } });
assert.deepEqual(actual, { 'a': 1, 'b': 2 }, 'fp.assignWith');		assert.deepEqual(actual, { 'a': { 'b': 2, 'c': 3 }, 'd': { 'e': 4 } });
		});
		}());
value = _.clone(object);		/*--------------------------------------------------------------------------*/
actual = fp.defaults({ 'a': 2, 'b': 2 }, value);
assert.deepEqual(value, object, 'fp.defaults');		QUnit.module('fp.unset');
assert.deepEqual(actual, { 'a': 1, 'b': 2 }, 'fp.defaults');
value = _.clone(object);		(function() {
value.b = { 'c': 1 };		QUnit.test('should not mutate values', function(assert) {
actual = fp.defaultsDeep({ 'b': { 'c': 2, 'd': 2 } }, value);		assert.expect(2);
assert.deepEqual(value, { 'a': 1, 'b': { 'c': 1 } } , 'fp.defaultsDeep');		var object = { 'a': { 'b': 2, 'c': 3 } },
assert.deepEqual(actual, { 'a': 1, 'b': { 'c': 1, 'd': 2 } }, 'fp.defaults		actual = fp.unset('a.b')(object);
Deep');
value = _.clone(object);		assert.deepEqual(object, { 'a': { 'b': 2, 'c': 3 } });
actual = fp.extend(new Foo, value);		assert.deepEqual(actual, { 'a': { 'c': 3 } });
		});
		}());
assert.deepEqual(value, object, 'fp.extend');		/*--------------------------------------------------------------------------*/
assert.deepEqual(actual, { 'a': 1, 'b': 2 }, 'fp.extend');
value = _.clone(object);		QUnit.module('fp.xorBy');
actual = fp.extendWith(function(objValue, srcValue) {
return srcValue;
}, new Foo, value);
assert.deepEqual(value, object, 'fp.extendWith');		(function() {
assert.deepEqual(actual, { 'a': 1, 'b': 2 }, 'fp.extendWith');		QUnit.test('should have an argument order of `iteratee`, `array`, then `othe
		r`', function(assert) {
		assert.expect(1);
value = _.clone(array);		var actual = fp.xorBy(Math.floor, [2.1, 1.2], [2.3, 3.4]);
actual = fp.fill(1, 2, '*', value);		assert.deepEqual(actual, [1.2, 3.4]);
		});
assert.deepEqual(value, array, 'fp.fill');		QUnit.test('should provide the correct `iteratee` arguments', function(asser
assert.deepEqual(actual, [1, '*', 3], 'fp.fill');		t) {
		assert.expect(1);
value = { 'a': { 'b': 2 } };		var args;
actual = fp.merge({ 'a': { 'c': 3 } }, value);
assert.deepEqual(value, { 'a': { 'b': 2 } }, 'fp.merge');		fp.xorBy(function() {
assert.deepEqual(actual, { 'a': { 'b': 2, 'c': 3 } }, 'fp.merge');		args || (args = slice.call(arguments));
		})([2.1, 1.2], [2.3, 3.4]);
value = { 'a': [1] };		assert.deepEqual(args, [2.3]);
actual = fp.mergeWith(function(objValue, srcValue) {		});
if (_.isArray(objValue)) {		}());
return objValue.concat(srcValue);
}
}, { 'a': [2, 3] }, value);
assert.deepEqual(value, { 'a': [1] }, 'fp.mergeWith');		/*--------------------------------------------------------------------------*/
assert.deepEqual(actual, { 'a': [1, 2, 3] }, 'fp.mergeWith');
value = _.clone(array);		QUnit.module('fp.xorWith');
actual = fp.pull(2, value);
assert.deepEqual(value, array, 'fp.pull');		(function() {
assert.deepEqual(actual, [1, 3], 'fp.pull');		QUnit.test('should have an argument order of `comparator`, `array`, then `va
		lues`', function(assert) {
		assert.expect(1);
value = _.clone(array);		var actual = fp.xorWith(fp.eq)([2, 1])([2, 3]);
actual = fp.pullAll([1, 3], value);		assert.deepEqual(actual, [1, 3]);
		});
		}());
assert.deepEqual(value, array, 'fp.pullAll');		/*--------------------------------------------------------------------------*/
assert.deepEqual(actual, [2], 'fp.pullAll');
value = _.clone(array);		QUnit.module('with methods');
actual = fp.pullAt([0, 2], value);
assert.deepEqual(value, array, 'fp.pullAt');		_.each(['differenceWith', 'intersectionWith', 'xorWith'], function(methodName)
assert.deepEqual(actual, [2], 'fp.pullAt');		{
		var func = fp[methodName];
value = _.clone(array);		QUnit.test('`fp.' + methodName + '` should provide the correct `comparator`
actual = fp.remove(function(value) {		arguments', function(assert) {
return value === 2;		assert.expect(1);
}, value);
assert.deepEqual(value, array, 'fp.remove');		var args;
assert.deepEqual(actual, [1, 3], 'fp.remove');
value = _.clone(array);		func(function() {
actual = fp.reverse(value);		args || (args = slice.call(arguments));
		})([2, 1])([2, 3]);
assert.deepEqual(value, array, 'fp.reverse');		assert.deepEqual(args, [2, 2]);
assert.deepEqual(actual, [3, 2, 1], 'fp.reverse');		});
		});
value = _.cloneDeep(deepObject);		/*--------------------------------------------------------------------------*/
actual = fp.set(3, 'a.b', value);
assert.deepEqual(value, deepObject, 'fp.set');		QUnit.module('fp.zip');
assert.deepEqual(actual, { 'a': { 'b': 3, 'c': 3 } }, 'fp.set');
value = _.cloneDeep(deepObject);		(function() {
actual = fp.setWith(Object, 4, 'd.e', value);		QUnit.test('should zip together two arrays', function(assert) {
		assert.expect(1);
assert.deepEqual(value, deepObject, 'fp.setWith');		assert.deepEqual(fp.zip([1, 2])([3, 4]), [[1, 3], [2, 4]]);
assert.deepEqual(actual, { 'a': { 'b': 2, 'c': 3 }, 'd': { 'e': 4 } }, 'fp
.setWith');
});		});
}());		}());
/*--------------------------------------------------------------------------*/		/*--------------------------------------------------------------------------*/
QUnit.module('with methods');		QUnit.module('fp.zipAll');
(function() {		(function() {
var array = [1, 2, 3],		QUnit.test('should zip together an array of arrays', function(assert) {
object = { 'a': 1 };		assert.expect(1);
QUnit.test('should provide the correct `customizer` arguments', function(ass		assert.deepEqual(fp.zipAll([[1, 2], [3, 4], [5, 6]]), [[1, 3, 5], [2, 4, 6
ert) {		]]);
assert.expect(3);		});
		}());
var args,		/*--------------------------------------------------------------------------*/
value = _.clone(object);
var actual = fp.assignWith(function(objValue, srcValue) {		QUnit.module('fp.zipObject');
args || (args = _.map(arguments, _.cloneDeep));
return srcValue;
}, { 'b': 2 }, value);
assert.deepEqual(args, [undefined, 2, 'b', { 'a': 1 }, { 'b': 2 }], 'fp.as		(function() {
signWith');		QUnit.test('should zip together key/value arrays into an object', function(a
		ssert) {
		assert.expect(1);
args = undefined;		assert.deepEqual(fp.zipObject(['a', 'b'])([1, 2]), { 'a': 1, 'b': 2 });
value = _.clone(object);		});
actual = fp.extendWith(function(objValue, srcValue) {		}());
args || (args = _.map(arguments, _.cloneDeep));
return srcValue;
}, { 'b': 2 }, value);
assert.deepEqual(args, [undefined, 2, 'b', { 'a': 1 }, { 'b': 2 }], 'fp.ex tendWith');		/*--------------------------------------------------------------------------*/
var stack = { '__data__': { 'array': [], 'map': null } },		QUnit.module('fp.zipWith');
expected = [[1], [2, 3], 'a', { 'a': [ 1 ] }, { 'a': [2, 3] }, stack];
args = undefined;		(function() {
value = { 'a': [1] };		QUnit.test('should zip arrays combining grouped elements with `iteratee`', f
actual = fp.mergeWith(function(objValue, srcValue) {		unction(assert) {
args || (args = _.map(arguments, _.cloneDeep));		assert.expect(1);
if (_.isArray(objValue)) {
return objValue.concat(srcValue);
}
}, { 'a': [2, 3] }, value);
args[5] = _.omitBy(args[5], _.isFunction);		var array1 = [1, 2, 3],
assert.deepEqual(args, expected, 'fp.mergeWith');		array2 = [4, 5, 6],
		actual = fp.zipWith(add)(array1)(array2);
		assert.deepEqual(actual, [5, 7, 9]);
});		});
}());		}());
/*--------------------------------------------------------------------------*/		/*--------------------------------------------------------------------------*/
QUnit.config.asyncRetries = 10;		QUnit.config.asyncRetries = 10;
QUnit.config.hidepassed = true;		QUnit.config.hidepassed = true;
if (!document) {		if (!document) {
QUnit.config.noglobals = true;		QUnit.config.noglobals = true;
QUnit.load();		QUnit.load();
		QUnit.start();
}		}
}.call(this));		}.call(this));
End of changes. 121 change blocks.
309 lines changed or deleted		1794 lines changed or added

---