82   function skipAssert(assert, count) {  argument
85       assert.ok(true, 'test skipped');
98     QUnit.test('should work with `name` and `func`', function(assert) {  argument
99       assert.expect(2);
105       assert.deepEqual(array, [1, 2, 3, 4]);
106       assert.deepEqual(actual, [1, 3]);
109     QUnit.test('should work with `name`, `func`, and `options`', function(assert) {  argument
110       assert.expect(3);
119       assert.deepEqual(array, [2, 4]);
120       assert.deepEqual(actual, [1, 3]);
121       assert.deepEqual(remove(), []);
124     QUnit.test('should work with an object', function(assert) {  argument
125       assert.expect(2);
132         assert.deepEqual(array, [1, 2, 3, 4]);
133         assert.deepEqual(actual, [1, 3]);
136         skipAssert(assert, 2);
140     QUnit.test('should work with an object and `options`', function(assert) {  argument
141       assert.expect(3);
148         assert.deepEqual(array, [2, 4]);
149         assert.deepEqual(actual, [1, 3]);
150         assert.deepEqual(lodash.remove(), []);
153         skipAssert(assert, 3);
157     QUnit.test('should work with lodash and `options`', function(assert) {  argument
158       assert.expect(3);
164       assert.deepEqual(array, [2, 4]);
165       assert.deepEqual(actual, [1, 3]);
166       assert.deepEqual(lodash.remove(), []);
169     QUnit.test('should work with `runInContext` and `options`', function(assert) {  argument
170       assert.expect(3);
177       assert.deepEqual(array, [2, 4]);
178       assert.deepEqual(actual, [1, 3]);
179       assert.deepEqual(lodash.remove(), []);
182     QUnit.test('should accept a variety of options', function(assert) {  argument
183       assert.expect(8);
190       assert.deepEqual(value, [1, 2, 3, 4]);
191       assert.deepEqual(actual, [2, 4]);
196       assert.deepEqual(actual, []);
199       assert.strictEqual(trim('_-abc-_', '_-'), 'abc');
205       assert.deepEqual(value, [1, 3]);
206       assert.deepEqual(actual, [2, 4]);
212       assert.deepEqual(value, [1, 2, 3, 4]);
213       assert.deepEqual(actual, [1, 3]);
216     QUnit.test('should respect the `cap` option', function(assert) {  argument
217       assert.expect(1);
225       assert.deepEqual(func(1, 2, 3), [1, 2, 3]);
228     QUnit.test('should respect the `rearg` option', function(assert) {  argument
229       assert.expect(1);
233       assert.strictEqual(add('2')('1'), '12');
236     QUnit.test('should add a `placeholder` property', function(assert) {  argument
237       assert.expect(2);
242         assert.strictEqual(lodash.placeholder, lodash);
243         assert.strictEqual(lodash.add.placeholder, lodash);
246         skipAssert(assert, 2);
256     QUnit.test('should exist on unconverted methods', function(assert) {  argument
257       assert.expect(2);
262       assert.strictEqual(fp.isArray(array), true);
263       assert.strictEqual(isArray()(array), true);
266     QUnit.test('should convert method aliases', function(assert) {  argument
267       assert.expect(1);
272       assert.strictEqual(actual, false);
275     QUnit.test('should convert remapped methods', function(assert) {  argument
276       assert.expect(1);
282       assert.deepEqual(object, { 'a': 1, 'b': 2 });
294     QUnit.test('`' + methodName + '` should work with an object', function(assert) {  argument
295       assert.expect(3);
302       assert.deepEqual(array, [2, 4]);
303       assert.deepEqual(actual, [1, 3]);
304       assert.deepEqual(remove(), []);
307     QUnit.test('`' + methodName + '` should extend existing configs', function(assert) {  argument
308       assert.expect(2);
315       assert.deepEqual(array, [1, 2, 3, 4]);
316       assert.deepEqual(actual, [2, 4]);
325     QUnit.test('should wrap methods with an arity > `1`', function(assert) {  argument
326       assert.expect(1);
332       assert.deepEqual(methodNames, []);
335     QUnit.test('should have >= arity of `aryMethod` designation', function(assert) {  argument
336       assert.expect(4);
348         assert.deepEqual(methodNames, [], '`aryMethod[' + aryCap + ']`');
358     QUnit.test('should have correct aliases', function(assert) {  argument
359       assert.expect(1);
365       assert.deepEqual(_.reject(actual, 1), []);
374     QUnit.test('should have a cap of 1', function(assert) {  argument
375       assert.expect(1);
399       assert.deepEqual(actual, expected);
402     QUnit.test('should have a cap of 2', function(assert) {  argument
403       assert.expect(1);
428       assert.deepEqual(actual, expected);
431     QUnit.test('should have a cap of 3', function(assert) {  argument
432       assert.expect(1);
452       assert.deepEqual(actual, expected);
461     QUnit.test('should work with `fp.indexOf`', function(assert) {  argument
462       assert.expect(10);
469       assert.deepEqual(actual, ['a', 'c'], 'fp.difference');
472       assert.strictEqual(actual, true, 'fp.includes');
475       assert.deepEqual(actual, ['b'], 'fp.intersection');
478       assert.deepEqual(actual, { 'a': 1, 'c': 2 }, 'fp.omit');
481       assert.deepEqual(actual, ['a', 'b', 'c', 'd'], 'fp.union');
484       assert.deepEqual(actual, ['b', 'd'], 'fp.uniq');
487       assert.deepEqual(actual, ['b', 'd'], 'fp.uniqBy');
490       assert.deepEqual(actual, ['a', 'c'], 'fp.without');
493       assert.deepEqual(actual, ['a', 'c', 'd'], 'fp.xor');
496       assert.deepEqual(actual, ['a', 'c'], 'fp.pull');
505     QUnit.test('should provide the correct `iteratee` arguments', function(assert) {  argument
506       assert.expect(4);
519       assert.deepEqual(args, [1]);
526       assert.deepEqual(args, isFIFO ? [1] : [2]);
533       assert.deepEqual(args, [0, 1]);
540       assert.deepEqual(args, isFIFO ? [0, 1] : [0, 2]);
543     QUnit.test('should not support shortcut fusion', function(assert) {  argument
544       assert.expect(3);
570       assert.deepEqual(combined(array), [4, 16]);
571       assert.strictEqual(filterCount, 200, 'filterCount');
572       assert.strictEqual(mapCount, 200, 'mapCount');
583     QUnit.test('should work with "_.matches" shorthands', function(assert) {  argument
584       assert.expect(1);
586       assert.deepEqual(fp.filter({ 'a': 3 })(objects), [objects[1]]);
589     QUnit.test('should work with "_.matchesProperty" shorthands', function(assert) {  argument
590       assert.expect(1);
592       assert.deepEqual(fp.filter(['a', 3])(objects), [objects[1]]);
595     QUnit.test('should work with "_.property" shorthands', function(assert) {  argument
596       assert.expect(1);
598       assert.deepEqual(fp.map('a')(objects), [1, 3]);
607     QUnit.test('should use `fp` as the default placeholder', function(assert) {  argument
608       assert.expect(3);
611       assert.strictEqual(actual, 'ab');
614       assert.deepEqual(actual, [1, '*', 3]);
617       assert.deepEqual(actual, ['b']);
620     QUnit.test('should support `fp.placeholder`', function(assert) {  argument
621       assert.expect(6);
627         assert.strictEqual(actual, 'ab');
630         assert.deepEqual(actual, [1, '*', 3]);
633         assert.deepEqual(actual, ['b']);
649       QUnit.test('fp.' + methodName + '` should have a `placeholder` property', function(assert) {  argument
650         assert.expect(2);
652         assert.ok(_.isObject(func.placeholder));
653         assert.strictEqual(func.placeholder, fp.__);
663     QUnit.test('should only clone objects in `path`', function(assert) {  argument
664       assert.expect(11);
670       assert.ok(_.isObject(actual.a.b), 'fp.set');
671       assert.ok(_.isNumber(actual.a.b), 'fp.set');
673       assert.strictEqual(actual.a.b.c.d, 5, 'fp.set');
674       assert.strictEqual(actual.d, value.d, 'fp.set');
679       assert.deepEqual(actual[0], { '1': 'a' }, 'fp.setWith');
684       assert.notOk('b' in actual.a, 'fp.unset');
685       assert.strictEqual(actual.a.c, value.a.c, 'fp.unset');
690       assert.strictEqual(actual.a.b, 4, 'fp.update');
691       assert.strictEqual(actual.d, value.d, 'fp.update');
696       assert.deepEqual(actual[0], { '1': 'a' }, 'fp.updateWith');
697       assert.strictEqual(actual.d, value.d, 'fp.updateWith');
709     QUnit.test('`fp.' + methodName + '` should not have `rearg` applied', function(assert) {  argument
710       assert.expect(1);
712       assert.strictEqual(func('1')('2'), isAdd ? '12' : -1);
723     QUnit.test('`fp.' + methodName + '` should not mutate values', function(assert) {  argument
724       assert.expect(2);
729       assert.deepEqual(object, { 'a': 1 });
730       assert.deepEqual(actual, { 'a': 1, 'b': 2 });
737     QUnit.test('`fp.' + methodName + '` should not mutate values', function(assert) {  argument
738       assert.expect(2);
743       assert.deepEqual(objects[0], { 'a': 1 });
744       assert.deepEqual(actual, { 'a': 1, 'b': 2 });
751 …est('`fp.' + methodName + '` should provide the correct `customizer` arguments', function(assert) {  argument
752       assert.expect(1);
760       assert.deepEqual(args, [undefined, 2, 'b', { 'a': 1 }, { 'b': 2 }]);
767     QUnit.test('`fp.' + methodName + '` should not mutate values', function(assert) {  argument
768       assert.expect(2);
773       assert.deepEqual(objects[0], { 'a': 1 });
774       assert.deepEqual(actual, { 'a': 1, 'b': 2 });
777     QUnit.test('`fp.' + methodName + '` should work with more than two sources', function(assert) {  argument
778       assert.expect(2);
784       assert.ok(pass);
785       assert.deepEqual(actual, { 'a': 1, 'b': 2, 'c': 3 });
794     QUnit.test('should shallow clone array values', function(assert) {  argument
795       assert.expect(2);
800       assert.deepEqual(actual, array);
801       assert.notStrictEqual(actual, array);
804     QUnit.test('should not shallow clone non-array values', function(assert) {  argument
805       assert.expect(2);
810       assert.deepEqual(actual, [object]);
811       assert.strictEqual(actual[0], object);
814     QUnit.test('should convert by name', function(assert) {  argument
815       assert.expect(4);
822       assert.deepEqual(actual, array);
823       assert.notStrictEqual(actual, array);
826       assert.deepEqual(actual, [object]);
827       assert.strictEqual(actual[0], object);
838     QUnit.test('fp.' + methodName + '` should only accept a `func` param', function(assert) {  argument
839       assert.expect(1);
841       assert.raises(function() { func(1, _.noop); }, TypeError);
852     QUnit.test('fp.' + methodName + '` should accept an `arity` param', function(assert) {  argument
853       assert.expect(1);
856       assert.deepEqual(actual, ['a', undefined]);
865     QUnit.test('should have an argument order of `defaultValue` then `value`', function(assert) {  argument
866       assert.expect(2);
868       assert.strictEqual(fp.defaultTo(1)(0), 0);
869       assert.strictEqual(fp.defaultTo(1)(undefined), 1);
878 …should return the elements of the first array not included in the second array', function(assert) {  argument
879       assert.expect(1);
882       assert.deepEqual(actual, [1]);
891 …Unit.test('should have an argument order of `iteratee`, `array`, then `values`', function(assert) {  argument
892       assert.expect(1);
895       assert.deepEqual(actual, [1.2]);
898     QUnit.test('should provide the correct `iteratee` arguments', function(assert) {  argument
899       assert.expect(1);
907       assert.deepEqual(args, [2.3]);
916 …it.test('should have an argument order of `comparator`, `array`, then `values`', function(assert) {  argument
917       assert.expect(1);
920       assert.deepEqual(actual, [1]);
932     QUnit.test('`fp.' + methodName + '` should not have `rearg` applied', function(assert) {  argument
933       assert.expect(1);
935       assert.strictEqual(func('2')('4'), isDivide ? 0.5 : 8);
944     QUnit.test('should convert by name', function(assert) {  argument
945       assert.expect(2);
954       assert.deepEqual(object, { 'a': 1 });
955       assert.deepEqual(actual, { 'a': 1, 'b': 2 });
964     QUnit.test('should have an argument order of `start`, `end`, then `value`', function(assert) {  argument
965       assert.expect(1);
968       assert.deepEqual(fp.fill(1)(2)('*')(array), [1, '*', 3]);
971     QUnit.test('should not mutate values', function(assert) {  argument
972       assert.expect(2);
977       assert.deepEqual(array, [1, 2, 3]);
978       assert.deepEqual(actual, [1, '*', 3]);
989 ….test('fp.' + methodName + '` should provide the correct `predicate` arguments', function(assert) {  argument
990       assert.expect(1);
998       assert.deepEqual(args, [2]);
1011 …Unit.test('should have an argument order of `value`, `fromIndex`, then `array`', function(assert) {  argument
1012       assert.expect(2);
1016       assert.strictEqual(fp.findFrom(resolve(1))(1)(objects), objects[2]);
1017       assert.strictEqual(fp.findFrom(resolve(2))(-2)(objects), objects[3]);
1030 …Unit.test('should have an argument order of `value`, `fromIndex`, then `array`', function(assert) {  argument
1031       assert.expect(2);
1035       assert.strictEqual(fp.findLastFrom(resolve(1))(1)(objects), objects[0]);
1036       assert.strictEqual(fp.findLastFrom(resolve(2))(-2)(objects), objects[1]);
1048 …dName + '` should have an argument order of `value`, `fromIndex`, then `array`', function(assert) {  argument
1049       assert.expect(2);
1053       assert.strictEqual(func(resolve(1))(2)(array), 3);
1054       assert.strictEqual(func(resolve(2))(-3)(array), 4);
1066 …dName + '` should have an argument order of `value`, `fromIndex`, then `array`', function(assert) {  argument
1067       assert.expect(2);
1071       assert.strictEqual(func(resolve(2))(3)(array), 1);
1072       assert.strictEqual(func(resolve(3))(-3)(array), 2);
1081 ….test('should have an argument order of `iteratee`, `depth`, then `collection`', function(assert) {  argument
1082       assert.expect(2);
1092       assert.deepEqual(fp.flatMapDepth(duplicate)(2)(array), expected);
1093       assert.deepEqual(fp.flatMapDepth(duplicate)(2)(object), expected);
1105     QUnit.test('`fp.' + methodName + '` should support shortcut fusion', function(assert) {  argument
1106       assert.expect(6);
1134           assert.deepEqual(combined(array), [4, 16]);
1135           assert.strictEqual(filterCount, 5, 'filterCount');
1136           assert.strictEqual(mapCount, 5, 'mapCount');
1139           skipAssert(assert, 3);
1152     QUnit.test('`fp.' + methodName + '` should provide `value` to `iteratee`', function(assert) {  argument
1153       assert.expect(2);
1161       assert.deepEqual(args, ['a']);
1169       assert.deepEqual(args, [1]);
1178     QUnit.test('should accept a `defaultValue` param', function(assert) {  argument
1179       assert.expect(1);
1182       assert.strictEqual(actual, 'default');
1193     QUnit.test('`fp.' + methodName + '` should have `rearg` applied', function(assert) {  argument
1194       assert.expect(1);
1196       assert.strictEqual(func(2)(1), true);
1205     QUnit.test('should have an argument order of `start`, `end`, then `value`', function(assert) {  argument
1206       assert.expect(2);
1208       assert.strictEqual(fp.inRange(2)(4)(3), true);
1209       assert.strictEqual(fp.inRange(-2)(-6)(-3), true);
1218 …Unit.test('should have an argument order of `iteratee`, `array`, then `values`', function(assert) {  argument
1219       assert.expect(1);
1222       assert.deepEqual(actual, [2.1]);
1225     QUnit.test('should provide the correct `iteratee` arguments', function(assert) {  argument
1226       assert.expect(1);
1234       assert.deepEqual(args, [2.3]);
1243 …it.test('should have an argument order of `comparator`, `array`, then `values`', function(assert) {  argument
1244       assert.expect(1);
1247       assert.deepEqual(actual, [2]);
1256     QUnit.test('should not accept an `args` param', function(assert) {  argument
1257       assert.expect(1);
1260       assert.strictEqual(actual, 'A');
1269     QUnit.test('should not accept an `args` param', function(assert) {  argument
1270       assert.expect(1);
1273       assert.deepEqual(actual, ['A', 'B']);
1282     QUnit.test('should accept an `args` param', function(assert) {  argument
1283       assert.expect(1);
1286       assert.strictEqual(actual, 'abc');
1295     QUnit.test('should accept an `args` param', function(assert) {  argument
1296       assert.expect(1);
1299       assert.deepEqual(actual, ['abc', 'Abc']);
1308     QUnit.test('should provide the correct `customizer` arguments', function(assert) {  argument
1309       assert.expect(1);
1326       assert.deepEqual(args, expected);
1335     QUnit.test('should provide the correct `customizer` arguments', function(assert) {  argument
1336       assert.expect(1);
1350       assert.deepEqual(args, expected);
1359     QUnit.test('should return a iteratee with capped params', function(assert) {  argument
1360       assert.expect(1);
1363       assert.deepEqual(func(1, 2, 3), [1, undefined, undefined]);
1366     QUnit.test('should convert by name', function(assert) {  argument
1367       assert.expect(1);
1372       assert.deepEqual(func(1, 2, 3), [1, undefined, undefined]);
1383     QUnit.test('`fp.' + methodName + '` should have `rearg` applied', function(assert) {  argument
1384       assert.expect(1);
1386       assert.strictEqual(func(1)(2), true);
1395     QUnit.test('should only provide `key` to `iteratee`', function(assert) {  argument
1396       assert.expect(1);
1404       assert.deepEqual(args, ['a']);
1417     QUnit.test('`fp.' + methodName + '` should work with an `iteratee` argument', function(assert) {  argument
1418       assert.expect(1);
1424       assert.strictEqual(actual, isMax ? 1 : 3);
1427 ….test('`fp.' + methodName + '` should provide the correct `iteratee` arguments', function(assert) {  argument
1428       assert.expect(1);
1436       assert.deepEqual(args, [1]);
1445     QUnit.test('should provide the correct `customizer` arguments', function(assert) {  argument
1446       assert.expect(1);
1459       assert.deepEqual(args, expected);
1462     QUnit.test('should not mutate values', function(assert) {  argument
1463       assert.expect(2);
1468       assert.deepEqual(objects[0], { 'a': [1, 2] });
1469       assert.deepEqual(actual, { 'a': [3, 2] });
1478     QUnit.test('should provide the correct `customizer` arguments', function(assert) {  argument
1479       assert.expect(1);
1493       assert.deepEqual(args, expected);
1504     QUnit.test('should mixin static methods but not prototype methods', function(assert) {  argument
1505       assert.expect(2);
1509       assert.strictEqual(typeof fp.a, 'function');
1510       assert.notOk('a' in fp.prototype);
1516     QUnit.test('should not assign inherited `source` methods', function(assert) {  argument
1517       assert.expect(2);
1523       assert.notOk('a' in fp);
1524       assert.notOk('a' in fp.prototype);
1530     QUnit.test('should not remove existing prototype methods', function(assert) {  argument
1531       assert.expect(2);
1538       assert.strictEqual(fp.each, source.a);
1539       assert.strictEqual(fp.prototype.each, each2);
1545     QUnit.test('should not export to the global when `source` is not an object', function(assert) {  argument
1546       assert.expect(2);
1553         assert.ok(_.every(props, function(key) {
1565     QUnit.test('should convert by name', function(assert) {  argument
1566       assert.expect(3);
1574       assert.ok('a' in Foo);
1575       assert.notOk('a' in Foo.prototype);
1578       assert.ok('a' in object);
1587     QUnit.test('should return a curried function', function(assert) {  argument
1588       assert.expect(2);
1591       assert.strictEqual(func(1)(2), 2);
1594       assert.strictEqual(func(1), 1);
1603     QUnit.test('should not cap iteratee args', function(assert) {  argument
1604       assert.expect(2);
1608         assert.deepEqual(over(1, 2, 3, 4), [4, 1]);
1620 …t.test('`fp.' + methodName + '` should provide `value` and `key` to `iteratee`', function(assert) {  argument
1621       assert.expect(1);
1629       assert.deepEqual(args, [1, 'a']);
1642 …t('fp.' + methodName + '` should truncate pad characters to fit the pad length', function(assert) {  argument
1643       assert.expect(1);
1646         assert.strictEqual(func('_-')(8)('abc'), '_-abc_-_');
1648         assert.strictEqual(func('_-')(6)('abc'), isStart ? '_-_abc' : 'abc_-_');
1661     QUnit.test('fp.' + methodName + '` should accept an `args` param', function(assert) {  argument
1662       assert.expect(1);
1670       assert.deepEqual(actual, expected);
1673     QUnit.test('fp.' + methodName + '` should convert by name', function(assert) {  argument
1674       assert.expect(2);
1684       assert.deepEqual(actual, expected);
1690       assert.deepEqual(actual, expected);
1699     QUnit.test('should be curried', function(assert) {  argument
1700       assert.expect(2);
1704       assert.strictEqual(fp.propertyOf(object, 'a'), 1);
1705       assert.strictEqual(fp.propertyOf(object)('a'), 1);
1714     QUnit.test('should not mutate values', function(assert) {  argument
1715       assert.expect(2);
1720       assert.deepEqual(array, [1, 2, 3]);
1721       assert.deepEqual(actual, [1, 3]);
1730     QUnit.test('should not mutate values', function(assert) {  argument
1731       assert.expect(2);
1736       assert.deepEqual(array, [1, 2, 3]);
1737       assert.deepEqual(actual, [2]);
1746     QUnit.test('should not mutate values', function(assert) {  argument
1747       assert.expect(2);
1752       assert.deepEqual(array, [1, 2, 3]);
1753       assert.deepEqual(actual, [2]);
1764     QUnit.test('should support a `min` and `max` argument', function(assert) {  argument
1765       assert.expect(1);
1770       assert.ok(_.some(array, function() {
1785 …st('fp.' + methodName + '` should have an argument order of `start` then `end`', function(assert) {  argument
1786       assert.expect(1);
1788       assert.deepEqual(func(1)(4), isRange ? [1, 2, 3] : [3, 2, 1]);
1800 …+ methodName + '` should have an argument order of `step`, `start`, then `end`', function(assert) {  argument
1801       assert.expect(1);
1803       assert.deepEqual(func(2)(1)(4), isRange ? [1, 3] : [3, 1]);
1816     QUnit.test('should be curried', function(assert) {  argument
1817       assert.expect(1);
1820       assert.deepEqual(rearged('c', 'a', 'b'), ['a', 'b', 'c']);
1823     QUnit.test('should return a curried function', function(assert) {  argument
1824       assert.expect(1);
1827       assert.deepEqual(rearged('c')('a')('b'), ['a', 'b', 'c']);
1839 …e + '` should provide the correct `iteratee` arguments when iterating an array', function(assert) {  argument
1840       assert.expect(1);
1848       assert.deepEqual(args, isReduce ? [0, 1] : [3, 0]);
1851 … + '` should provide the correct `iteratee` arguments when iterating an object', function(assert) {  argument
1852       assert.expect(1);
1866       assert.deepEqual(args, expected);
1875     QUnit.test('should not mutate values', function(assert) {  argument
1876       assert.expect(2);
1881       assert.deepEqual(array, [1, 2, 3]);
1882       assert.deepEqual(actual, [1, 3]);
1891     QUnit.test('should accept a `start` param', function(assert) {  argument
1892       assert.expect(1);
1898       assert.deepEqual(actual, ['a', 'b', ['c', 'd']]);
1907     QUnit.test('should not mutate values', function(assert) {  argument
1908       assert.expect(2);
1913       assert.deepEqual(array, [1, 2, 3]);
1914       assert.deepEqual(actual, [3, 2, 1]);
1923     QUnit.test('should return a converted lodash instance', function(assert) {  argument
1924       assert.expect(1);
1926       assert.strictEqual(typeof fp.runInContext({}).curryN, 'function');
1929     QUnit.test('should convert by name', function(assert) {  argument
1930       assert.expect(1);
1933       assert.strictEqual(typeof runInContext({}).curryN, 'function');
1942     QUnit.test('should not mutate values', function(assert) {  argument
1943       assert.expect(2);
1948       assert.deepEqual(object, { 'a': { 'b': 2, 'c': 3 } });
1949       assert.deepEqual(actual, { 'a': { 'b': 3, 'c': 3 } });
1958     QUnit.test('should provide the correct `customizer` arguments', function(assert) {  argument
1959       assert.expect(1);
1967       assert.deepEqual(args, [undefined, 'b', { 'a': 1 }]);
1970     QUnit.test('should not mutate values', function(assert) {  argument
1971       assert.expect(2);
1976       assert.deepEqual(object, { 'a': { 'b': 2, 'c': 3 } });
1977       assert.deepEqual(actual, { 'a': { 'b': 2, 'c': 3 }, 'd': { 'e': 4 } });
1986     QUnit.test('should accept a `start` param', function(assert) {  argument
1987       assert.expect(1);
1993       assert.deepEqual(actual, ['a', 'b', 'c', 'd']);
2013     QUnit.test('`fp.' + methodName + '` should remove ' + parts + ' `chars`', function(assert) {  argument
2014       assert.expect(1);
2019       assert.strictEqual(func('_-')(string), expected);
2028 …QUnit.test('should have an argument order of `iteratee`, `array`, then `other`', function(assert) {  argument
2029       assert.expect(1);
2032       assert.deepEqual(actual, [2.1, 1.2]);
2035     QUnit.test('should provide the correct `iteratee` arguments', function(assert) {  argument
2036       assert.expect(1);
2044       assert.deepEqual(args, [2.1]);
2053 …it.test('should have an argument order of `comparator`, `array`, then `values`', function(assert) {  argument
2054       assert.expect(1);
2057       assert.deepEqual(actual, [2, 1, 3]);
2060     QUnit.test('should provide the correct `comparator` arguments', function(assert) {  argument
2061       assert.expect(1);
2069       assert.deepEqual(args, [1, 2]);
2080     QUnit.test('should work with an `iteratee` argument', function(assert) {  argument
2081       assert.expect(1);
2086       assert.deepEqual(actual, expected);
2089     QUnit.test('should provide the correct `iteratee` arguments', function(assert) {  argument
2090       assert.expect(1);
2098       assert.deepEqual(args, [objects[0]]);
2107 …it.test('should have an argument order of `comparator`, `array`, then `values`', function(assert) {  argument
2108       assert.expect(1);
2111       assert.deepEqual(actual, [2, 1]);
2114     QUnit.test('should provide the correct `comparator` arguments', function(assert) {  argument
2115       assert.expect(1);
2123       assert.deepEqual(args, [1, 2]);
2132     QUnit.test('should not convert end of `path` to an object', function(assert) {  argument
2133       assert.expect(1);
2136       assert.strictEqual(typeof actual.a.b, 'number');
2139     QUnit.test('should not convert uncloneables to objects', function(assert) {  argument
2140       assert.expect(2);
2145       assert.strictEqual(typeof object.a.b, 'function');
2146       assert.strictEqual(object.a.b, actual.a.b);
2149     QUnit.test('should not mutate values', function(assert) {  argument
2150       assert.expect(2);
2155       assert.deepEqual(object, { 'a': { 'b': 2, 'c': 3 } });
2156       assert.deepEqual(actual, { 'a': { 'b': 4, 'c': 3 } });
2165     QUnit.test('should provide the correct `customizer` arguments', function(assert) {  argument
2172       assert.deepEqual(args, [undefined, 'b', { 'a': 1 }]);
2175     QUnit.test('should not mutate values', function(assert) {  argument
2176       assert.expect(2);
2181       assert.deepEqual(object, { 'a': { 'b': 2, 'c': 3 } });
2182       assert.deepEqual(actual, { 'a': { 'b': 2, 'c': 3 }, 'd': { 'e': 4 } });
2191     QUnit.test('should not mutate values', function(assert) {  argument
2192       assert.expect(2);
2197       assert.deepEqual(object, { 'a': { 'b': 2, 'c': 3 } });
2198       assert.deepEqual(actual, { 'a': { 'c': 3 } });
2207 …QUnit.test('should have an argument order of `iteratee`, `array`, then `other`', function(assert) {  argument
2208       assert.expect(1);
2211       assert.deepEqual(actual, [1.2, 3.4]);
2214     QUnit.test('should provide the correct `iteratee` arguments', function(assert) {  argument
2215       assert.expect(1);
2223       assert.deepEqual(args, [2.3]);
2232 …it.test('should have an argument order of `comparator`, `array`, then `values`', function(assert) {  argument
2233       assert.expect(1);
2236       assert.deepEqual(actual, [1, 3]);
2247 …est('`fp.' + methodName + '` should provide the correct `comparator` arguments', function(assert) {  argument
2248       assert.expect(1);
2256       assert.deepEqual(args, [2, 2]);
2265     QUnit.test('should zip together two arrays', function(assert) {  argument
2266       assert.expect(1);
2268       assert.deepEqual(fp.zip([1, 2])([3, 4]), [[1, 3], [2, 4]]);
2277     QUnit.test('should zip together an array of arrays', function(assert) {  argument
2278       assert.expect(1);
2280       assert.deepEqual(fp.zipAll([[1, 2], [3, 4], [5, 6]]), [[1, 3, 5], [2, 4, 6]]);
2289     QUnit.test('should zip together key/value arrays into an object', function(assert) {  argument
2290       assert.expect(1);
2292       assert.deepEqual(fp.zipObject(['a', 'b'])([1, 2]), { 'a': 1, 'b': 2 });
2301     QUnit.test('should zip arrays combining grouped elements with `iteratee`', function(assert) {  argument
2302       assert.expect(1);
2308       assert.deepEqual(actual, [5, 7, 9]);