Add initial test files from lodash v4. (#4172)

* Install test dependencies.

* Add initial test files.

These files were created using a simplistic AST manipulator using `recast` to
preserve formatting. There's bound to be a huge chunk of errors, but this serves
as a good start. QUnit was replaced with Mocha, with ES2015 imports running via
`esm`.

As far as possible, QUnit-specific syntax has been replaced with Mocha's
`describe` and `it`, while the native Node.js `assert` module is used for
assertions. Files in the `test` directory ending in `.test.js` will be treated
as test files.

* Add initial passing files to test run.

test/lodash-methods.js

@@ -0,0 +1,194 @@
+import assert from 'assert';
+import lodashStable from 'lodash';
+import { _, falsey, stubArray, oldDash, stubTrue, FUNC_ERROR_TEXT } from './utils.js';
+import functions from '../functions.js';
+import bind from '../bind.js';
+
+describe('lodash methods', function() {
+  var allMethods = lodashStable.reject(functions(_).sort(), function(methodName) {
+    return lodashStable.startsWith(methodName, '_');
+  });
+
+  var checkFuncs = [
+    'after',
+    'ary',
+    'before',
+    'bind',
+    'curry',
+    'curryRight',
+    'debounce',
+    'defer',
+    'delay',
+    'flip',
+    'flow',
+    'flowRight',
+    'memoize',
+    'negate',
+    'once',
+    'partial',
+    'partialRight',
+    'rearg',
+    'rest',
+    'spread',
+    'throttle',
+    'unary'
+  ];
+
+  var noBinding = [
+    'flip',
+    'memoize',
+    'negate',
+    'once',
+    'overArgs',
+    'partial',
+    'partialRight',
+    'rearg',
+    'rest',
+    'spread'
+  ];
+
+  var rejectFalsey = [
+    'tap',
+    'thru'
+  ].concat(checkFuncs);
+
+  var returnArrays = [
+    'at',
+    'chunk',
+    'compact',
+    'difference',
+    'drop',
+    'filter',
+    'flatten',
+    'functions',
+    'initial',
+    'intersection',
+    'invokeMap',
+    'keys',
+    'map',
+    'orderBy',
+    'pull',
+    'pullAll',
+    'pullAt',
+    'range',
+    'rangeRight',
+    'reject',
+    'remove',
+    'shuffle',
+    'sortBy',
+    'tail',
+    'take',
+    'times',
+    'toArray',
+    'toPairs',
+    'toPairsIn',
+    'union',
+    'uniq',
+    'values',
+    'without',
+    'xor',
+    'zip'
+  ];
+
+  var acceptFalsey = lodashStable.difference(allMethods, rejectFalsey);
+
+  it('should accept falsey arguments', function() {
+    var arrays = lodashStable.map(falsey, stubArray);
+
+    lodashStable.each(acceptFalsey, function(methodName) {
+      var expected = arrays,
+          func = _[methodName];
+
+      var actual = lodashStable.map(falsey, function(value, index) {
+        return index ? func(value) : func();
+      });
+
+      if (methodName == 'noConflict') {
+        root._ = oldDash;
+      }
+      else if (methodName == 'pull' || methodName == 'pullAll') {
+        expected = falsey;
+      }
+      if (lodashStable.includes(returnArrays, methodName) && methodName != 'sample') {
+        assert.deepStrictEqual(actual, expected, '_.' + methodName + ' returns an array');
+      }
+      assert.ok(true, '`_.' + methodName + '` accepts falsey arguments');
+    });
+
+    // Skip tests for missing methods of modularized builds.
+    lodashStable.each(['chain', 'noConflict', 'runInContext'], function(methodName) {
+      if (!_[methodName]) {}
+    });
+  });
+
+  it('should return an array', function() {
+    var array = [1, 2, 3];
+
+    lodashStable.each(returnArrays, function(methodName) {
+      var actual,
+          func = _[methodName];
+
+      switch (methodName) {
+        case 'invokeMap':
+          actual = func(array, 'toFixed');
+          break;
+        case 'sample':
+          actual = func(array, 1);
+          break;
+        default:
+          actual = func(array);
+      }
+      assert.ok(lodashStable.isArray(actual), '_.' + methodName + ' returns an array');
+
+      var isPull = methodName == 'pull' || methodName == 'pullAll';
+      assert.strictEqual(actual === array, isPull, '_.' + methodName + ' should ' + (isPull ? '' : 'not ') + 'return the given array');
+    });
+  });
+
+  it('should throw an error for falsey arguments', function() {
+    lodashStable.each(rejectFalsey, function(methodName) {
+      var expected = lodashStable.map(falsey, stubTrue),
+          func = _[methodName];
+
+      var actual = lodashStable.map(falsey, function(value, index) {
+        var pass = !index && /^(?:backflow|compose|cond|flow(Right)?|over(?:Every|Some)?)$/.test(methodName);
+
+        try {
+          index ? func(value) : func();
+        } catch (e) {
+          pass = !pass && (e instanceof TypeError) &&
+            (!lodashStable.includes(checkFuncs, methodName) || (e.message == FUNC_ERROR_TEXT));
+        }
+        return pass;
+      });
+
+      assert.deepStrictEqual(actual, expected, '`_.' + methodName + '` rejects falsey arguments');
+    });
+  });
+
+  it('should use `this` binding of function', function() {
+    lodashStable.each(noBinding, function(methodName) {
+      var fn = function() { return this.a; },
+          func = _[methodName],
+          isNegate = methodName == 'negate',
+          object = { 'a': 1 },
+          expected = isNegate ? false : 1;
+
+      var wrapper = func(bind(fn, object));
+      assert.strictEqual(wrapper(), expected, '`_.' + methodName + '` can consume a bound function');
+
+      wrapper = bind(func(fn), object);
+      assert.strictEqual(wrapper(), expected, '`_.' + methodName + '` can be bound');
+
+      object.wrapper = func(fn);
+      assert.strictEqual(object.wrapper(), expected, '`_.' + methodName + '` uses the `this` of its parent object');
+    });
+  });
+
+  it('should not contain minified method names (test production builds)', function() {
+    var shortNames = ['_', 'at', 'eq', 'gt', 'lt'];
+    assert.ok(lodashStable.every(functions(_), function(methodName) {
+      return methodName.length > 2 || lodashStable.includes(shortNames, methodName);
+    }));
+  });
+});