mocha 6.1.0 → 6.1.4

package/lib/runner.js

@@ -1,1049 +1,1049 @@
-'use strict';
-
-/**
- * Module dependencies.
- */
-var util = require('util');
-var EventEmitter = require('events').EventEmitter;
-var Pending = require('./pending');
-var utils = require('./utils');
-var inherits = utils.inherits;
-var debug = require('debug')('mocha:runner');
-var Runnable = require('./runnable');
-var Suite = require('./suite');
-var HOOK_TYPE_BEFORE_EACH = Suite.constants.HOOK_TYPE_BEFORE_EACH;
-var HOOK_TYPE_AFTER_EACH = Suite.constants.HOOK_TYPE_AFTER_EACH;
-var HOOK_TYPE_AFTER_ALL = Suite.constants.HOOK_TYPE_AFTER_ALL;
-var HOOK_TYPE_BEFORE_ALL = Suite.constants.HOOK_TYPE_BEFORE_ALL;
-var EVENT_ROOT_SUITE_RUN = Suite.constants.EVENT_ROOT_SUITE_RUN;
-var STATE_FAILED = Runnable.constants.STATE_FAILED;
-var STATE_PASSED = Runnable.constants.STATE_PASSED;
-var dQuote = utils.dQuote;
-var ngettext = utils.ngettext;
-var sQuote = utils.sQuote;
-var stackFilter = utils.stackTraceFilter();
-var stringify = utils.stringify;
-var type = utils.type;
-var createInvalidExceptionError = require('./errors')
-  .createInvalidExceptionError;
-
-/**
- * Non-enumerable globals.
- * @readonly
- */
-var globals = [
-  'setTimeout',
-  'clearTimeout',
-  'setInterval',
-  'clearInterval',
-  'XMLHttpRequest',
-  'Date',
-  'setImmediate',
-  'clearImmediate'
-];
-
-var constants = utils.defineConstants(
-  /**
-   * {@link Runner}-related constants.
-   * @public
-   * @memberof Runner
-   * @readonly
-   * @alias constants
-   * @static
-   * @enum {string}
-   */
-  {
-    /**
-     * Emitted when {@link Hook} execution begins
-     */
-    EVENT_HOOK_BEGIN: 'hook',
-    /**
-     * Emitted when {@link Hook} execution ends
-     */
-    EVENT_HOOK_END: 'hook end',
-    /**
-     * Emitted when Root {@link Suite} execution begins (all files have been parsed and hooks/tests are ready for execution)
-     */
-    EVENT_RUN_BEGIN: 'start',
-    /**
-     * Emitted when Root {@link Suite} execution has been delayed via `delay` option
-     */
-    EVENT_DELAY_BEGIN: 'waiting',
-    /**
-     * Emitted when delayed Root {@link Suite} execution is triggered by user via `global.run()`
-     */
-    EVENT_DELAY_END: 'ready',
-    /**
-     * Emitted when Root {@link Suite} execution ends
-     */
-    EVENT_RUN_END: 'end',
-    /**
-     * Emitted when {@link Suite} execution begins
-     */
-    EVENT_SUITE_BEGIN: 'suite',
-    /**
-     * Emitted when {@link Suite} execution ends
-     */
-    EVENT_SUITE_END: 'suite end',
-    /**
-     * Emitted when {@link Test} execution begins
-     */
-    EVENT_TEST_BEGIN: 'test',
-    /**
-     * Emitted when {@link Test} execution ends
-     */
-    EVENT_TEST_END: 'test end',
-    /**
-     * Emitted when {@link Test} execution fails
-     */
-    EVENT_TEST_FAIL: 'fail',
-    /**
-     * Emitted when {@link Test} execution succeeds
-     */
-    EVENT_TEST_PASS: 'pass',
-    /**
-     * Emitted when {@link Test} becomes pending
-     */
-    EVENT_TEST_PENDING: 'pending',
-    /**
-     * Emitted when {@link Test} execution has failed, but will retry
-     */
-    EVENT_TEST_RETRY: 'retry'
-  }
-);
-
-module.exports = Runner;
-
-/**
- * Initialize a `Runner` at the Root {@link Suite}, which represents a hierarchy of {@link Suite|Suites} and {@link Test|Tests}.
- *
- * @extends external:EventEmitter
- * @public
- * @class
- * @param {Suite} suite Root suite
- * @param {boolean} [delay] Whether or not to delay execution of root suite
- * until ready.
- */
-function Runner(suite, delay) {
-  var self = this;
-  this._globals = [];
-  this._abort = false;
-  this._delay = delay;
-  this.suite = suite;
-  this.started = false;
-  this.total = suite.total();
-  this.failures = 0;
-  this.on(constants.EVENT_TEST_END, function(test) {
-    self.checkGlobals(test);
-  });
-  this.on(constants.EVENT_HOOK_END, function(hook) {
-    self.checkGlobals(hook);
-  });
-  this._defaultGrep = /.*/;
-  this.grep(this._defaultGrep);
-  this.globals(this.globalProps().concat(extraGlobals()));
-}
-
-/**
- * Wrapper for setImmediate, process.nextTick, or browser polyfill.
- *
- * @param {Function} fn
- * @private
- */
-Runner.immediately = global.setImmediate || process.nextTick;
-
-/**
- * Inherit from `EventEmitter.prototype`.
- */
-inherits(Runner, EventEmitter);
-
-/**
- * Run tests with full titles matching `re`. Updates runner.total
- * with number of tests matched.
- *
- * @public
- * @memberof Runner
- * @param {RegExp} re
- * @param {boolean} invert
- * @return {Runner} Runner instance.
- */
-Runner.prototype.grep = function(re, invert) {
-  debug('grep %s', re);
-  this._grep = re;
-  this._invert = invert;
-  this.total = this.grepTotal(this.suite);
-  return this;
-};
-
-/**
- * Returns the number of tests matching the grep search for the
- * given suite.
- *
- * @memberof Runner
- * @public
- * @param {Suite} suite
- * @return {number}
- */
-Runner.prototype.grepTotal = function(suite) {
-  var self = this;
-  var total = 0;
-
-  suite.eachTest(function(test) {
-    var match = self._grep.test(test.fullTitle());
-    if (self._invert) {
-      match = !match;
-    }
-    if (match) {
-      total++;
-    }
-  });
-
-  return total;
-};
-
-/**
- * Return a list of global properties.
- *
- * @return {Array}
- * @private
- */
-Runner.prototype.globalProps = function() {
-  var props = Object.keys(global);
-
-  // non-enumerables
-  for (var i = 0; i < globals.length; ++i) {
-    if (~props.indexOf(globals[i])) {
-      continue;
-    }
-    props.push(globals[i]);
-  }
-
-  return props;
-};
-
-/**
- * Allow the given `arr` of globals.
- *
- * @public
- * @memberof Runner
- * @param {Array} arr
- * @return {Runner} Runner instance.
- */
-Runner.prototype.globals = function(arr) {
-  if (!arguments.length) {
-    return this._globals;
-  }
-  debug('globals %j', arr);
-  this._globals = this._globals.concat(arr);
-  return this;
-};
-
-/**
- * Check for global variable leaks.
- *
- * @private
- */
-Runner.prototype.checkGlobals = function(test) {
-  if (this.ignoreLeaks) {
-    return;
-  }
-  var ok = this._globals;
-
-  var globals = this.globalProps();
-  var leaks;
-
-  if (test) {
-    ok = ok.concat(test._allowedGlobals || []);
-  }
-
-  if (this.prevGlobalsLength === globals.length) {
-    return;
-  }
-  this.prevGlobalsLength = globals.length;
-
-  leaks = filterLeaks(ok, globals);
-  this._globals = this._globals.concat(leaks);
-
-  if (leaks.length) {
-    var format = ngettext(
-      leaks.length,
-      'global leak detected: %s',
-      'global leaks detected: %s'
-    );
-    var error = new Error(util.format(format, leaks.map(sQuote).join(', ')));
-    this.fail(test, error);
-  }
-};
-
-/**
- * Fail the given `test`.
- *
- * @private
- * @param {Test} test
- * @param {Error} err
- */
-Runner.prototype.fail = function(test, err) {
-  if (test.isPending()) {
-    return;
-  }
-
-  ++this.failures;
-  test.state = STATE_FAILED;
-
-  if (!isError(err)) {
-    err = thrown2Error(err);
-  }
-
-  try {
-    err.stack =
-      this.fullStackTrace || !err.stack ? err.stack : stackFilter(err.stack);
-  } catch (ignore) {
-    // some environments do not take kindly to monkeying with the stack
-  }
-
-  this.emit(constants.EVENT_TEST_FAIL, test, err);
-};
-
-/**
- * Fail the given `hook` with `err`.
- *
- * Hook failures work in the following pattern:
- * - If bail, run corresponding `after each` and `after` hooks,
- *   then exit
- * - Failed `before` hook skips all tests in a suite and subsuites,
- *   but jumps to corresponding `after` hook
- * - Failed `before each` hook skips remaining tests in a
- *   suite and jumps to corresponding `after each` hook,
- *   which is run only once
- * - Failed `after` hook does not alter
- *   execution order
- * - Failed `after each` hook skips remaining tests in a
- *   suite and subsuites, but executes other `after each`
- *   hooks
- *
- * @private
- * @param {Hook} hook
- * @param {Error} err
- */
-Runner.prototype.failHook = function(hook, err) {
-  hook.originalTitle = hook.originalTitle || hook.title;
-  if (hook.ctx && hook.ctx.currentTest) {
-    hook.title =
-      hook.originalTitle + ' for ' + dQuote(hook.ctx.currentTest.title);
-  } else {
-    var parentTitle;
-    if (hook.parent.title) {
-      parentTitle = hook.parent.title;
-    } else {
-      parentTitle = hook.parent.root ? '{root}' : '';
-    }
-    hook.title = hook.originalTitle + ' in ' + dQuote(parentTitle);
-  }
-
-  this.fail(hook, err);
-};
-
-/**
- * Run hook `name` callbacks and then invoke `fn()`.
- *
- * @private
- * @param {string} name
- * @param {Function} fn
- */
-
-Runner.prototype.hook = function(name, fn) {
-  var suite = this.suite;
-  var hooks = suite.getHooks(name);
-  var self = this;
-
-  function next(i) {
-    var hook = hooks[i];
-    if (!hook) {
-      return fn();
-    }
-    self.currentRunnable = hook;
-
-    if (name === HOOK_TYPE_BEFORE_ALL) {
-      hook.ctx.currentTest = hook.parent.tests[0];
-    } else if (name === HOOK_TYPE_AFTER_ALL) {
-      hook.ctx.currentTest = hook.parent.tests[hook.parent.tests.length - 1];
-    } else {
-      hook.ctx.currentTest = self.test;
-    }
-
-    hook.allowUncaught = self.allowUncaught;
-
-    self.emit(constants.EVENT_HOOK_BEGIN, hook);
-
-    if (!hook.listeners('error').length) {
-      hook.on('error', function(err) {
-        self.failHook(hook, err);
-      });
-    }
-
-    hook.run(function(err) {
-      var testError = hook.error();
-      if (testError) {
-        self.fail(self.test, testError);
-      }
-      if (err) {
-        if (err instanceof Pending) {
-          if (name === HOOK_TYPE_AFTER_ALL) {
-            utils.deprecate(
-              'Skipping a test within an "after all" hook is DEPRECATED and will throw an exception in a future version of Mocha. ' +
-                'Use a return statement or other means to abort hook execution.'
-            );
-          }
-          if (name === HOOK_TYPE_BEFORE_EACH || name === HOOK_TYPE_AFTER_EACH) {
-            if (self.test) {
-              self.test.pending = true;
-            }
-          } else {
-            suite.tests.forEach(function(test) {
-              test.pending = true;
-            });
-            suite.suites.forEach(function(suite) {
-              suite.pending = true;
-            });
-            // a pending hook won't be executed twice.
-            hook.pending = true;
-          }
-        } else {
-          self.failHook(hook, err);
-
-          // stop executing hooks, notify callee of hook err
-          return fn(err);
-        }
-      }
-      self.emit(constants.EVENT_HOOK_END, hook);
-      delete hook.ctx.currentTest;
-      next(++i);
-    });
-  }
-
-  Runner.immediately(function() {
-    next(0);
-  });
-};
-
-/**
- * Run hook `name` for the given array of `suites`
- * in order, and callback `fn(err, errSuite)`.
- *
- * @private
- * @param {string} name
- * @param {Array} suites
- * @param {Function} fn
- */
-Runner.prototype.hooks = function(name, suites, fn) {
-  var self = this;
-  var orig = this.suite;
-
-  function next(suite) {
-    self.suite = suite;
-
-    if (!suite) {
-      self.suite = orig;
-      return fn();
-    }
-
-    self.hook(name, function(err) {
-      if (err) {
-        var errSuite = self.suite;
-        self.suite = orig;
-        return fn(err, errSuite);
-      }
-
-      next(suites.pop());
-    });
-  }
-
-  next(suites.pop());
-};
-
-/**
- * Run hooks from the top level down.
- *
- * @param {String} name
- * @param {Function} fn
- * @private
- */
-Runner.prototype.hookUp = function(name, fn) {
-  var suites = [this.suite].concat(this.parents()).reverse();
-  this.hooks(name, suites, fn);
-};
-
-/**
- * Run hooks from the bottom up.
- *
- * @param {String} name
- * @param {Function} fn
- * @private
- */
-Runner.prototype.hookDown = function(name, fn) {
-  var suites = [this.suite].concat(this.parents());
-  this.hooks(name, suites, fn);
-};
-
-/**
- * Return an array of parent Suites from
- * closest to furthest.
- *
- * @return {Array}
- * @private
- */
-Runner.prototype.parents = function() {
-  var suite = this.suite;
-  var suites = [];
-  while (suite.parent) {
-    suite = suite.parent;
-    suites.push(suite);
-  }
-  return suites;
-};
-
-/**
- * Run the current test and callback `fn(err)`.
- *
- * @param {Function} fn
- * @private
- */
-Runner.prototype.runTest = function(fn) {
-  var self = this;
-  var test = this.test;
-
-  if (!test) {
-    return;
-  }
-
-  var suite = this.parents().reverse()[0] || this.suite;
-  if (this.forbidOnly && suite.hasOnly()) {
-    fn(new Error('`.only` forbidden'));
-    return;
-  }
-  if (this.asyncOnly) {
-    test.asyncOnly = true;
-  }
-  test.on('error', function(err) {
-    self.fail(test, err);
-  });
-  if (this.allowUncaught) {
-    test.allowUncaught = true;
-    return test.run(fn);
-  }
-  try {
-    test.run(fn);
-  } catch (err) {
-    fn(err);
-  }
-};
-
-/**
- * Run tests in the given `suite` and invoke the callback `fn()` when complete.
- *
- * @private
- * @param {Suite} suite
- * @param {Function} fn
- */
-Runner.prototype.runTests = function(suite, fn) {
-  var self = this;
-  var tests = suite.tests.slice();
-  var test;
-
-  function hookErr(_, errSuite, after) {
-    // before/after Each hook for errSuite failed:
-    var orig = self.suite;
-
-    // for failed 'after each' hook start from errSuite parent,
-    // otherwise start from errSuite itself
-    self.suite = after ? errSuite.parent : errSuite;
-
-    if (self.suite) {
-      // call hookUp afterEach
-      self.hookUp(HOOK_TYPE_AFTER_EACH, function(err2, errSuite2) {
-        self.suite = orig;
-        // some hooks may fail even now
-        if (err2) {
-          return hookErr(err2, errSuite2, true);
-        }
-        // report error suite
-        fn(errSuite);
-      });
-    } else {
-      // there is no need calling other 'after each' hooks
-      self.suite = orig;
-      fn(errSuite);
-    }
-  }
-
-  function next(err, errSuite) {
-    // if we bail after first err
-    if (self.failures && suite._bail) {
-      tests = [];
-    }
-
-    if (self._abort) {
-      return fn();
-    }
-
-    if (err) {
-      return hookErr(err, errSuite, true);
-    }
-
-    // next test
-    test = tests.shift();
-
-    // all done
-    if (!test) {
-      return fn();
-    }
-
-    // grep
-    var match = self._grep.test(test.fullTitle());
-    if (self._invert) {
-      match = !match;
-    }
-    if (!match) {
-      // Run immediately only if we have defined a grep. When we
-      // define a grep — It can cause maximum callstack error if
-      // the grep is doing a large recursive loop by neglecting
-      // all tests. The run immediately function also comes with
-      // a performance cost. So we don't want to run immediately
-      // if we run the whole test suite, because running the whole
-      // test suite don't do any immediate recursive loops. Thus,
-      // allowing a JS runtime to breathe.
-      if (self._grep !== self._defaultGrep) {
-        Runner.immediately(next);
-      } else {
-        next();
-      }
-      return;
-    }
-
-    if (test.isPending()) {
-      if (self.forbidPending) {
-        test.isPending = alwaysFalse;
-        self.fail(test, new Error('Pending test forbidden'));
-        delete test.isPending;
-      } else {
-        self.emit(constants.EVENT_TEST_PENDING, test);
-      }
-      self.emit(constants.EVENT_TEST_END, test);
-      return next();
-    }
-
-    // execute test and hook(s)
-    self.emit(constants.EVENT_TEST_BEGIN, (self.test = test));
-    self.hookDown(HOOK_TYPE_BEFORE_EACH, function(err, errSuite) {
-      if (test.isPending()) {
-        if (self.forbidPending) {
-          test.isPending = alwaysFalse;
-          self.fail(test, new Error('Pending test forbidden'));
-          delete test.isPending;
-        } else {
-          self.emit(constants.EVENT_TEST_PENDING, test);
-        }
-        self.emit(constants.EVENT_TEST_END, test);
-        return next();
-      }
-      if (err) {
-        return hookErr(err, errSuite, false);
-      }
-      self.currentRunnable = self.test;
-      self.runTest(function(err) {
-        test = self.test;
-        if (err) {
-          var retry = test.currentRetry();
-          if (err instanceof Pending && self.forbidPending) {
-            self.fail(test, new Error('Pending test forbidden'));
-          } else if (err instanceof Pending) {
-            test.pending = true;
-            self.emit(constants.EVENT_TEST_PENDING, test);
-          } else if (retry < test.retries()) {
-            var clonedTest = test.clone();
-            clonedTest.currentRetry(retry + 1);
-            tests.unshift(clonedTest);
-
-            self.emit(constants.EVENT_TEST_RETRY, test, err);
-
-            // Early return + hook trigger so that it doesn't
-            // increment the count wrong
-            return self.hookUp(HOOK_TYPE_AFTER_EACH, next);
-          } else {
-            self.fail(test, err);
-          }
-          self.emit(constants.EVENT_TEST_END, test);
-
-          if (err instanceof Pending) {
-            return next();
-          }
-
-          return self.hookUp(HOOK_TYPE_AFTER_EACH, next);
-        }
-
-        test.state = STATE_PASSED;
-        self.emit(constants.EVENT_TEST_PASS, test);
-        self.emit(constants.EVENT_TEST_END, test);
-        self.hookUp(HOOK_TYPE_AFTER_EACH, next);
-      });
-    });
-  }
-
-  this.next = next;
-  this.hookErr = hookErr;
-  next();
-};
-
-function alwaysFalse() {
-  return false;
-}
-
-/**
- * Run the given `suite` and invoke the callback `fn()` when complete.
- *
- * @private
- * @param {Suite} suite
- * @param {Function} fn
- */
-Runner.prototype.runSuite = function(suite, fn) {
-  var i = 0;
-  var self = this;
-  var total = this.grepTotal(suite);
-  var afterAllHookCalled = false;
-
-  debug('run suite %s', suite.fullTitle());
-
-  if (!total || (self.failures && suite._bail)) {
-    return fn();
-  }
-
-  this.emit(constants.EVENT_SUITE_BEGIN, (this.suite = suite));
-
-  function next(errSuite) {
-    if (errSuite) {
-      // current suite failed on a hook from errSuite
-      if (errSuite === suite) {
-        // if errSuite is current suite
-        // continue to the next sibling suite
-        return done();
-      }
-      // errSuite is among the parents of current suite
-      // stop execution of errSuite and all sub-suites
-      return done(errSuite);
-    }
-
-    if (self._abort) {
-      return done();
-    }
-
-    var curr = suite.suites[i++];
-    if (!curr) {
-      return done();
-    }
-
-    // Avoid grep neglecting large number of tests causing a
-    // huge recursive loop and thus a maximum call stack error.
-    // See comment in `this.runTests()` for more information.
-    if (self._grep !== self._defaultGrep) {
-      Runner.immediately(function() {
-        self.runSuite(curr, next);
-      });
-    } else {
-      self.runSuite(curr, next);
-    }
-  }
-
-  function done(errSuite) {
-    self.suite = suite;
-    self.nextSuite = next;
-
-    if (afterAllHookCalled) {
-      fn(errSuite);
-    } else {
-      // mark that the afterAll block has been called once
-      // and so can be skipped if there is an error in it.
-      afterAllHookCalled = true;
-
-      // remove reference to test
-      delete self.test;
-
-      self.hook(HOOK_TYPE_AFTER_ALL, function() {
-        self.emit(constants.EVENT_SUITE_END, suite);
-        fn(errSuite);
-      });
-    }
-  }
-
-  this.nextSuite = next;
-
-  this.hook(HOOK_TYPE_BEFORE_ALL, function(err) {
-    if (err) {
-      return done();
-    }
-    self.runTests(suite, next);
-  });
-};
-
-/**
- * Handle uncaught exceptions.
- *
- * @param {Error} err
- * @private
- */
-Runner.prototype.uncaught = function(err) {
-  if (err instanceof Pending) {
-    return;
-  }
-  if (err) {
-    debug('uncaught exception %O', err);
-  } else {
-    debug('uncaught undefined/falsy exception');
-    err = createInvalidExceptionError(
-      'Caught falsy/undefined exception which would otherwise be uncaught. No stack trace found; try a debugger',
-      err
-    );
-  }
-
-  if (!isError(err)) {
-    err = thrown2Error(err);
-  }
-  err.uncaught = true;
-
-  var runnable = this.currentRunnable;
-
-  if (!runnable) {
-    runnable = new Runnable('Uncaught error outside test suite');
-    runnable.parent = this.suite;
-
-    if (this.started) {
-      this.fail(runnable, err);
-    } else {
-      // Can't recover from this failure
-      this.emit(constants.EVENT_RUN_BEGIN);
-      this.fail(runnable, err);
-      this.emit(constants.EVENT_RUN_END);
-    }
-
-    return;
-  }
-
-  runnable.clearTimeout();
-
-  // Ignore errors if already failed or pending
-  // See #3226
-  if (runnable.isFailed() || runnable.isPending()) {
-    return;
-  }
-  // we cannot recover gracefully if a Runnable has already passed
-  // then fails asynchronously
-  var alreadyPassed = runnable.isPassed();
-  // this will change the state to "failed" regardless of the current value
-  this.fail(runnable, err);
-  if (!alreadyPassed) {
-    // recover from test
-    if (runnable.type === constants.EVENT_TEST_BEGIN) {
-      this.emit(constants.EVENT_TEST_END, runnable);
-      this.hookUp(HOOK_TYPE_AFTER_EACH, this.next);
-      return;
-    }
-    debug(runnable);
-
-    // recover from hooks
-    var errSuite = this.suite;
-
-    // XXX how about a less awful way to determine this?
-    // if hook failure is in afterEach block
-    if (runnable.fullTitle().indexOf('after each') > -1) {
-      return this.hookErr(err, errSuite, true);
-    }
-    // if hook failure is in beforeEach block
-    if (runnable.fullTitle().indexOf('before each') > -1) {
-      return this.hookErr(err, errSuite, false);
-    }
-    // if hook failure is in after or before blocks
-    return this.nextSuite(errSuite);
-  }
-
-  // bail
-  this.emit(constants.EVENT_RUN_END);
-};
-
-/**
- * Run the root suite and invoke `fn(failures)`
- * on completion.
- *
- * @public
- * @memberof Runner
- * @param {Function} fn
- * @return {Runner} Runner instance.
- */
-Runner.prototype.run = function(fn) {
-  var self = this;
-  var rootSuite = this.suite;
-
-  fn = fn || function() {};
-
-  function uncaught(err) {
-    self.uncaught(err);
-  }
-
-  function start() {
-    // If there is an `only` filter
-    if (rootSuite.hasOnly()) {
-      rootSuite.filterOnly();
-    }
-    self.started = true;
-    if (self._delay) {
-      self.emit(constants.EVENT_DELAY_END);
-    }
-    self.emit(constants.EVENT_RUN_BEGIN);
-
-    self.runSuite(rootSuite, function() {
-      debug('finished running');
-      self.emit(constants.EVENT_RUN_END);
-    });
-  }
-
-  debug(constants.EVENT_RUN_BEGIN);
-
-  // references cleanup to avoid memory leaks
-  this.on(constants.EVENT_SUITE_END, function(suite) {
-    suite.cleanReferences();
-  });
-
-  // callback
-  this.on(constants.EVENT_RUN_END, function() {
-    debug(constants.EVENT_RUN_END);
-    process.removeListener('uncaughtException', uncaught);
-    fn(self.failures);
-  });
-
-  // uncaught exception
-  process.on('uncaughtException', uncaught);
-
-  if (this._delay) {
-    // for reporters, I guess.
-    // might be nice to debounce some dots while we wait.
-    this.emit(constants.EVENT_DELAY_BEGIN, rootSuite);
-    rootSuite.once(EVENT_ROOT_SUITE_RUN, start);
-  } else {
-    start();
-  }
-
-  return this;
-};
-
-/**
- * Cleanly abort execution.
- *
- * @memberof Runner
- * @public
- * @return {Runner} Runner instance.
- */
-Runner.prototype.abort = function() {
-  debug('aborting');
-  this._abort = true;
-
-  return this;
-};
-
-/**
- * Filter leaks with the given globals flagged as `ok`.
- *
- * @private
- * @param {Array} ok
- * @param {Array} globals
- * @return {Array}
- */
-function filterLeaks(ok, globals) {
-  return globals.filter(function(key) {
-    // Firefox and Chrome exposes iframes as index inside the window object
-    if (/^\d+/.test(key)) {
-      return false;
-    }
-
-    // in firefox
-    // if runner runs in an iframe, this iframe's window.getInterface method
-    // not init at first it is assigned in some seconds
-    if (global.navigator && /^getInterface/.test(key)) {
-      return false;
-    }
-
-    // an iframe could be approached by window[iframeIndex]
-    // in ie6,7,8 and opera, iframeIndex is enumerable, this could cause leak
-    if (global.navigator && /^\d+/.test(key)) {
-      return false;
-    }
-
-    // Opera and IE expose global variables for HTML element IDs (issue #243)
-    if (/^mocha-/.test(key)) {
-      return false;
-    }
-
-    var matched = ok.filter(function(ok) {
-      if (~ok.indexOf('*')) {
-        return key.indexOf(ok.split('*')[0]) === 0;
-      }
-      return key === ok;
-    });
-    return !matched.length && (!global.navigator || key !== 'onerror');
-  });
-}
-
-/**
- * Check if argument is an instance of Error object or a duck-typed equivalent.
- *
- * @private
- * @param {Object} err - object to check
- * @param {string} err.message - error message
- * @returns {boolean}
- */
-function isError(err) {
-  return err instanceof Error || (err && typeof err.message === 'string');
-}
-
-/**
- *
- * Converts thrown non-extensible type into proper Error.
- *
- * @private
- * @param {*} thrown - Non-extensible type thrown by code
- * @return {Error}
- */
-function thrown2Error(err) {
-  return new Error(
-    'the ' + type(err) + ' ' + stringify(err) + ' was thrown, throw an Error :)'
-  );
-}
-
-/**
- * Array of globals dependent on the environment.
- *
- * @return {Array}
- * @deprecated
- * @todo remove; long since unsupported
- * @private
- */
-function extraGlobals() {
-  if (typeof process === 'object' && typeof process.version === 'string') {
-    var parts = process.version.split('.');
-    var nodeVersion = parts.reduce(function(a, v) {
-      return (a << 8) | v;
-    });
-
-    // 'errno' was renamed to process._errno in v0.9.11.
-    if (nodeVersion < 0x00090b) {
-      return ['errno'];
-    }
-  }
-
-  return [];
-}
-
-Runner.constants = constants;
-
-/**
- * Node.js' `EventEmitter`
- * @external EventEmitter
- * @see {@link https://nodejs.org/api/events.html#events_class_eventemitter}
- */
+'use strict';
+
+/**
+ * Module dependencies.
+ */
+var util = require('util');
+var EventEmitter = require('events').EventEmitter;
+var Pending = require('./pending');
+var utils = require('./utils');
+var inherits = utils.inherits;
+var debug = require('debug')('mocha:runner');
+var Runnable = require('./runnable');
+var Suite = require('./suite');
+var HOOK_TYPE_BEFORE_EACH = Suite.constants.HOOK_TYPE_BEFORE_EACH;
+var HOOK_TYPE_AFTER_EACH = Suite.constants.HOOK_TYPE_AFTER_EACH;
+var HOOK_TYPE_AFTER_ALL = Suite.constants.HOOK_TYPE_AFTER_ALL;
+var HOOK_TYPE_BEFORE_ALL = Suite.constants.HOOK_TYPE_BEFORE_ALL;
+var EVENT_ROOT_SUITE_RUN = Suite.constants.EVENT_ROOT_SUITE_RUN;
+var STATE_FAILED = Runnable.constants.STATE_FAILED;
+var STATE_PASSED = Runnable.constants.STATE_PASSED;
+var dQuote = utils.dQuote;
+var ngettext = utils.ngettext;
+var sQuote = utils.sQuote;
+var stackFilter = utils.stackTraceFilter();
+var stringify = utils.stringify;
+var type = utils.type;
+var createInvalidExceptionError = require('./errors')
+  .createInvalidExceptionError;
+
+/**
+ * Non-enumerable globals.
+ * @readonly
+ */
+var globals = [
+  'setTimeout',
+  'clearTimeout',
+  'setInterval',
+  'clearInterval',
+  'XMLHttpRequest',
+  'Date',
+  'setImmediate',
+  'clearImmediate'
+];
+
+var constants = utils.defineConstants(
+  /**
+   * {@link Runner}-related constants.
+   * @public
+   * @memberof Runner
+   * @readonly
+   * @alias constants
+   * @static
+   * @enum {string}
+   */
+  {
+    /**
+     * Emitted when {@link Hook} execution begins
+     */
+    EVENT_HOOK_BEGIN: 'hook',
+    /**
+     * Emitted when {@link Hook} execution ends
+     */
+    EVENT_HOOK_END: 'hook end',
+    /**
+     * Emitted when Root {@link Suite} execution begins (all files have been parsed and hooks/tests are ready for execution)
+     */
+    EVENT_RUN_BEGIN: 'start',
+    /**
+     * Emitted when Root {@link Suite} execution has been delayed via `delay` option
+     */
+    EVENT_DELAY_BEGIN: 'waiting',
+    /**
+     * Emitted when delayed Root {@link Suite} execution is triggered by user via `global.run()`
+     */
+    EVENT_DELAY_END: 'ready',
+    /**
+     * Emitted when Root {@link Suite} execution ends
+     */
+    EVENT_RUN_END: 'end',
+    /**
+     * Emitted when {@link Suite} execution begins
+     */
+    EVENT_SUITE_BEGIN: 'suite',
+    /**
+     * Emitted when {@link Suite} execution ends
+     */
+    EVENT_SUITE_END: 'suite end',
+    /**
+     * Emitted when {@link Test} execution begins
+     */
+    EVENT_TEST_BEGIN: 'test',
+    /**
+     * Emitted when {@link Test} execution ends
+     */
+    EVENT_TEST_END: 'test end',
+    /**
+     * Emitted when {@link Test} execution fails
+     */
+    EVENT_TEST_FAIL: 'fail',
+    /**
+     * Emitted when {@link Test} execution succeeds
+     */
+    EVENT_TEST_PASS: 'pass',
+    /**
+     * Emitted when {@link Test} becomes pending
+     */
+    EVENT_TEST_PENDING: 'pending',
+    /**
+     * Emitted when {@link Test} execution has failed, but will retry
+     */
+    EVENT_TEST_RETRY: 'retry'
+  }
+);
+
+module.exports = Runner;
+
+/**
+ * Initialize a `Runner` at the Root {@link Suite}, which represents a hierarchy of {@link Suite|Suites} and {@link Test|Tests}.
+ *
+ * @extends external:EventEmitter
+ * @public
+ * @class
+ * @param {Suite} suite Root suite
+ * @param {boolean} [delay] Whether or not to delay execution of root suite
+ * until ready.
+ */
+function Runner(suite, delay) {
+  var self = this;
+  this._globals = [];
+  this._abort = false;
+  this._delay = delay;
+  this.suite = suite;
+  this.started = false;
+  this.total = suite.total();
+  this.failures = 0;
+  this.on(constants.EVENT_TEST_END, function(test) {
+    self.checkGlobals(test);
+  });
+  this.on(constants.EVENT_HOOK_END, function(hook) {
+    self.checkGlobals(hook);
+  });
+  this._defaultGrep = /.*/;
+  this.grep(this._defaultGrep);
+  this.globals(this.globalProps().concat(extraGlobals()));
+}
+
+/**
+ * Wrapper for setImmediate, process.nextTick, or browser polyfill.
+ *
+ * @param {Function} fn
+ * @private
+ */
+Runner.immediately = global.setImmediate || process.nextTick;
+
+/**
+ * Inherit from `EventEmitter.prototype`.
+ */
+inherits(Runner, EventEmitter);
+
+/**
+ * Run tests with full titles matching `re`. Updates runner.total
+ * with number of tests matched.
+ *
+ * @public
+ * @memberof Runner
+ * @param {RegExp} re
+ * @param {boolean} invert
+ * @return {Runner} Runner instance.
+ */
+Runner.prototype.grep = function(re, invert) {
+  debug('grep %s', re);
+  this._grep = re;
+  this._invert = invert;
+  this.total = this.grepTotal(this.suite);
+  return this;
+};
+
+/**
+ * Returns the number of tests matching the grep search for the
+ * given suite.
+ *
+ * @memberof Runner
+ * @public
+ * @param {Suite} suite
+ * @return {number}
+ */
+Runner.prototype.grepTotal = function(suite) {
+  var self = this;
+  var total = 0;
+
+  suite.eachTest(function(test) {
+    var match = self._grep.test(test.fullTitle());
+    if (self._invert) {
+      match = !match;
+    }
+    if (match) {
+      total++;
+    }
+  });
+
+  return total;
+};
+
+/**
+ * Return a list of global properties.
+ *
+ * @return {Array}
+ * @private
+ */
+Runner.prototype.globalProps = function() {
+  var props = Object.keys(global);
+
+  // non-enumerables
+  for (var i = 0; i < globals.length; ++i) {
+    if (~props.indexOf(globals[i])) {
+      continue;
+    }
+    props.push(globals[i]);
+  }
+
+  return props;
+};
+
+/**
+ * Allow the given `arr` of globals.
+ *
+ * @public
+ * @memberof Runner
+ * @param {Array} arr
+ * @return {Runner} Runner instance.
+ */
+Runner.prototype.globals = function(arr) {
+  if (!arguments.length) {
+    return this._globals;
+  }
+  debug('globals %j', arr);
+  this._globals = this._globals.concat(arr);
+  return this;
+};
+
+/**
+ * Check for global variable leaks.
+ *
+ * @private
+ */
+Runner.prototype.checkGlobals = function(test) {
+  if (this.ignoreLeaks) {
+    return;
+  }
+  var ok = this._globals;
+
+  var globals = this.globalProps();
+  var leaks;
+
+  if (test) {
+    ok = ok.concat(test._allowedGlobals || []);
+  }
+
+  if (this.prevGlobalsLength === globals.length) {
+    return;
+  }
+  this.prevGlobalsLength = globals.length;
+
+  leaks = filterLeaks(ok, globals);
+  this._globals = this._globals.concat(leaks);
+
+  if (leaks.length) {
+    var format = ngettext(
+      leaks.length,
+      'global leak detected: %s',
+      'global leaks detected: %s'
+    );
+    var error = new Error(util.format(format, leaks.map(sQuote).join(', ')));
+    this.fail(test, error);
+  }
+};
+
+/**
+ * Fail the given `test`.
+ *
+ * @private
+ * @param {Test} test
+ * @param {Error} err
+ */
+Runner.prototype.fail = function(test, err) {
+  if (test.isPending()) {
+    return;
+  }
+
+  ++this.failures;
+  test.state = STATE_FAILED;
+
+  if (!isError(err)) {
+    err = thrown2Error(err);
+  }
+
+  try {
+    err.stack =
+      this.fullStackTrace || !err.stack ? err.stack : stackFilter(err.stack);
+  } catch (ignore) {
+    // some environments do not take kindly to monkeying with the stack
+  }
+
+  this.emit(constants.EVENT_TEST_FAIL, test, err);
+};
+
+/**
+ * Fail the given `hook` with `err`.
+ *
+ * Hook failures work in the following pattern:
+ * - If bail, run corresponding `after each` and `after` hooks,
+ *   then exit
+ * - Failed `before` hook skips all tests in a suite and subsuites,
+ *   but jumps to corresponding `after` hook
+ * - Failed `before each` hook skips remaining tests in a
+ *   suite and jumps to corresponding `after each` hook,
+ *   which is run only once
+ * - Failed `after` hook does not alter
+ *   execution order
+ * - Failed `after each` hook skips remaining tests in a
+ *   suite and subsuites, but executes other `after each`
+ *   hooks
+ *
+ * @private
+ * @param {Hook} hook
+ * @param {Error} err
+ */
+Runner.prototype.failHook = function(hook, err) {
+  hook.originalTitle = hook.originalTitle || hook.title;
+  if (hook.ctx && hook.ctx.currentTest) {
+    hook.title =
+      hook.originalTitle + ' for ' + dQuote(hook.ctx.currentTest.title);
+  } else {
+    var parentTitle;
+    if (hook.parent.title) {
+      parentTitle = hook.parent.title;
+    } else {
+      parentTitle = hook.parent.root ? '{root}' : '';
+    }
+    hook.title = hook.originalTitle + ' in ' + dQuote(parentTitle);
+  }
+
+  this.fail(hook, err);
+};
+
+/**
+ * Run hook `name` callbacks and then invoke `fn()`.
+ *
+ * @private
+ * @param {string} name
+ * @param {Function} fn
+ */
+
+Runner.prototype.hook = function(name, fn) {
+  var suite = this.suite;
+  var hooks = suite.getHooks(name);
+  var self = this;
+
+  function next(i) {
+    var hook = hooks[i];
+    if (!hook) {
+      return fn();
+    }
+    self.currentRunnable = hook;
+
+    if (name === HOOK_TYPE_BEFORE_ALL) {
+      hook.ctx.currentTest = hook.parent.tests[0];
+    } else if (name === HOOK_TYPE_AFTER_ALL) {
+      hook.ctx.currentTest = hook.parent.tests[hook.parent.tests.length - 1];
+    } else {
+      hook.ctx.currentTest = self.test;
+    }
+
+    hook.allowUncaught = self.allowUncaught;
+
+    self.emit(constants.EVENT_HOOK_BEGIN, hook);
+
+    if (!hook.listeners('error').length) {
+      hook.on('error', function(err) {
+        self.failHook(hook, err);
+      });
+    }
+
+    hook.run(function(err) {
+      var testError = hook.error();
+      if (testError) {
+        self.fail(self.test, testError);
+      }
+      if (err) {
+        if (err instanceof Pending) {
+          if (name === HOOK_TYPE_AFTER_ALL) {
+            utils.deprecate(
+              'Skipping a test within an "after all" hook is DEPRECATED and will throw an exception in a future version of Mocha. ' +
+                'Use a return statement or other means to abort hook execution.'
+            );
+          }
+          if (name === HOOK_TYPE_BEFORE_EACH || name === HOOK_TYPE_AFTER_EACH) {
+            if (self.test) {
+              self.test.pending = true;
+            }
+          } else {
+            suite.tests.forEach(function(test) {
+              test.pending = true;
+            });
+            suite.suites.forEach(function(suite) {
+              suite.pending = true;
+            });
+            // a pending hook won't be executed twice.
+            hook.pending = true;
+          }
+        } else {
+          self.failHook(hook, err);
+
+          // stop executing hooks, notify callee of hook err
+          return fn(err);
+        }
+      }
+      self.emit(constants.EVENT_HOOK_END, hook);
+      delete hook.ctx.currentTest;
+      next(++i);
+    });
+  }
+
+  Runner.immediately(function() {
+    next(0);
+  });
+};
+
+/**
+ * Run hook `name` for the given array of `suites`
+ * in order, and callback `fn(err, errSuite)`.
+ *
+ * @private
+ * @param {string} name
+ * @param {Array} suites
+ * @param {Function} fn
+ */
+Runner.prototype.hooks = function(name, suites, fn) {
+  var self = this;
+  var orig = this.suite;
+
+  function next(suite) {
+    self.suite = suite;
+
+    if (!suite) {
+      self.suite = orig;
+      return fn();
+    }
+
+    self.hook(name, function(err) {
+      if (err) {
+        var errSuite = self.suite;
+        self.suite = orig;
+        return fn(err, errSuite);
+      }
+
+      next(suites.pop());
+    });
+  }
+
+  next(suites.pop());
+};
+
+/**
+ * Run hooks from the top level down.
+ *
+ * @param {String} name
+ * @param {Function} fn
+ * @private
+ */
+Runner.prototype.hookUp = function(name, fn) {
+  var suites = [this.suite].concat(this.parents()).reverse();
+  this.hooks(name, suites, fn);
+};
+
+/**
+ * Run hooks from the bottom up.
+ *
+ * @param {String} name
+ * @param {Function} fn
+ * @private
+ */
+Runner.prototype.hookDown = function(name, fn) {
+  var suites = [this.suite].concat(this.parents());
+  this.hooks(name, suites, fn);
+};
+
+/**
+ * Return an array of parent Suites from
+ * closest to furthest.
+ *
+ * @return {Array}
+ * @private
+ */
+Runner.prototype.parents = function() {
+  var suite = this.suite;
+  var suites = [];
+  while (suite.parent) {
+    suite = suite.parent;
+    suites.push(suite);
+  }
+  return suites;
+};
+
+/**
+ * Run the current test and callback `fn(err)`.
+ *
+ * @param {Function} fn
+ * @private
+ */
+Runner.prototype.runTest = function(fn) {
+  var self = this;
+  var test = this.test;
+
+  if (!test) {
+    return;
+  }
+
+  var suite = this.parents().reverse()[0] || this.suite;
+  if (this.forbidOnly && suite.hasOnly()) {
+    fn(new Error('`.only` forbidden'));
+    return;
+  }
+  if (this.asyncOnly) {
+    test.asyncOnly = true;
+  }
+  test.on('error', function(err) {
+    self.fail(test, err);
+  });
+  if (this.allowUncaught) {
+    test.allowUncaught = true;
+    return test.run(fn);
+  }
+  try {
+    test.run(fn);
+  } catch (err) {
+    fn(err);
+  }
+};
+
+/**
+ * Run tests in the given `suite` and invoke the callback `fn()` when complete.
+ *
+ * @private
+ * @param {Suite} suite
+ * @param {Function} fn
+ */
+Runner.prototype.runTests = function(suite, fn) {
+  var self = this;
+  var tests = suite.tests.slice();
+  var test;
+
+  function hookErr(_, errSuite, after) {
+    // before/after Each hook for errSuite failed:
+    var orig = self.suite;
+
+    // for failed 'after each' hook start from errSuite parent,
+    // otherwise start from errSuite itself
+    self.suite = after ? errSuite.parent : errSuite;
+
+    if (self.suite) {
+      // call hookUp afterEach
+      self.hookUp(HOOK_TYPE_AFTER_EACH, function(err2, errSuite2) {
+        self.suite = orig;
+        // some hooks may fail even now
+        if (err2) {
+          return hookErr(err2, errSuite2, true);
+        }
+        // report error suite
+        fn(errSuite);
+      });
+    } else {
+      // there is no need calling other 'after each' hooks
+      self.suite = orig;
+      fn(errSuite);
+    }
+  }
+
+  function next(err, errSuite) {
+    // if we bail after first err
+    if (self.failures && suite._bail) {
+      tests = [];
+    }
+
+    if (self._abort) {
+      return fn();
+    }
+
+    if (err) {
+      return hookErr(err, errSuite, true);
+    }
+
+    // next test
+    test = tests.shift();
+
+    // all done
+    if (!test) {
+      return fn();
+    }
+
+    // grep
+    var match = self._grep.test(test.fullTitle());
+    if (self._invert) {
+      match = !match;
+    }
+    if (!match) {
+      // Run immediately only if we have defined a grep. When we
+      // define a grep — It can cause maximum callstack error if
+      // the grep is doing a large recursive loop by neglecting
+      // all tests. The run immediately function also comes with
+      // a performance cost. So we don't want to run immediately
+      // if we run the whole test suite, because running the whole
+      // test suite don't do any immediate recursive loops. Thus,
+      // allowing a JS runtime to breathe.
+      if (self._grep !== self._defaultGrep) {
+        Runner.immediately(next);
+      } else {
+        next();
+      }
+      return;
+    }
+
+    if (test.isPending()) {
+      if (self.forbidPending) {
+        test.isPending = alwaysFalse;
+        self.fail(test, new Error('Pending test forbidden'));
+        delete test.isPending;
+      } else {
+        self.emit(constants.EVENT_TEST_PENDING, test);
+      }
+      self.emit(constants.EVENT_TEST_END, test);
+      return next();
+    }
+
+    // execute test and hook(s)
+    self.emit(constants.EVENT_TEST_BEGIN, (self.test = test));
+    self.hookDown(HOOK_TYPE_BEFORE_EACH, function(err, errSuite) {
+      if (test.isPending()) {
+        if (self.forbidPending) {
+          test.isPending = alwaysFalse;
+          self.fail(test, new Error('Pending test forbidden'));
+          delete test.isPending;
+        } else {
+          self.emit(constants.EVENT_TEST_PENDING, test);
+        }
+        self.emit(constants.EVENT_TEST_END, test);
+        return next();
+      }
+      if (err) {
+        return hookErr(err, errSuite, false);
+      }
+      self.currentRunnable = self.test;
+      self.runTest(function(err) {
+        test = self.test;
+        if (err) {
+          var retry = test.currentRetry();
+          if (err instanceof Pending && self.forbidPending) {
+            self.fail(test, new Error('Pending test forbidden'));
+          } else if (err instanceof Pending) {
+            test.pending = true;
+            self.emit(constants.EVENT_TEST_PENDING, test);
+          } else if (retry < test.retries()) {
+            var clonedTest = test.clone();
+            clonedTest.currentRetry(retry + 1);
+            tests.unshift(clonedTest);
+
+            self.emit(constants.EVENT_TEST_RETRY, test, err);
+
+            // Early return + hook trigger so that it doesn't
+            // increment the count wrong
+            return self.hookUp(HOOK_TYPE_AFTER_EACH, next);
+          } else {
+            self.fail(test, err);
+          }
+          self.emit(constants.EVENT_TEST_END, test);
+
+          if (err instanceof Pending) {
+            return next();
+          }
+
+          return self.hookUp(HOOK_TYPE_AFTER_EACH, next);
+        }
+
+        test.state = STATE_PASSED;
+        self.emit(constants.EVENT_TEST_PASS, test);
+        self.emit(constants.EVENT_TEST_END, test);
+        self.hookUp(HOOK_TYPE_AFTER_EACH, next);
+      });
+    });
+  }
+
+  this.next = next;
+  this.hookErr = hookErr;
+  next();
+};
+
+function alwaysFalse() {
+  return false;
+}
+
+/**
+ * Run the given `suite` and invoke the callback `fn()` when complete.
+ *
+ * @private
+ * @param {Suite} suite
+ * @param {Function} fn
+ */
+Runner.prototype.runSuite = function(suite, fn) {
+  var i = 0;
+  var self = this;
+  var total = this.grepTotal(suite);
+  var afterAllHookCalled = false;
+
+  debug('run suite %s', suite.fullTitle());
+
+  if (!total || (self.failures && suite._bail)) {
+    return fn();
+  }
+
+  this.emit(constants.EVENT_SUITE_BEGIN, (this.suite = suite));
+
+  function next(errSuite) {
+    if (errSuite) {
+      // current suite failed on a hook from errSuite
+      if (errSuite === suite) {
+        // if errSuite is current suite
+        // continue to the next sibling suite
+        return done();
+      }
+      // errSuite is among the parents of current suite
+      // stop execution of errSuite and all sub-suites
+      return done(errSuite);
+    }
+
+    if (self._abort) {
+      return done();
+    }
+
+    var curr = suite.suites[i++];
+    if (!curr) {
+      return done();
+    }
+
+    // Avoid grep neglecting large number of tests causing a
+    // huge recursive loop and thus a maximum call stack error.
+    // See comment in `this.runTests()` for more information.
+    if (self._grep !== self._defaultGrep) {
+      Runner.immediately(function() {
+        self.runSuite(curr, next);
+      });
+    } else {
+      self.runSuite(curr, next);
+    }
+  }
+
+  function done(errSuite) {
+    self.suite = suite;
+    self.nextSuite = next;
+
+    if (afterAllHookCalled) {
+      fn(errSuite);
+    } else {
+      // mark that the afterAll block has been called once
+      // and so can be skipped if there is an error in it.
+      afterAllHookCalled = true;
+
+      // remove reference to test
+      delete self.test;
+
+      self.hook(HOOK_TYPE_AFTER_ALL, function() {
+        self.emit(constants.EVENT_SUITE_END, suite);
+        fn(errSuite);
+      });
+    }
+  }
+
+  this.nextSuite = next;
+
+  this.hook(HOOK_TYPE_BEFORE_ALL, function(err) {
+    if (err) {
+      return done();
+    }
+    self.runTests(suite, next);
+  });
+};
+
+/**
+ * Handle uncaught exceptions.
+ *
+ * @param {Error} err
+ * @private
+ */
+Runner.prototype.uncaught = function(err) {
+  if (err instanceof Pending) {
+    return;
+  }
+  if (err) {
+    debug('uncaught exception %O', err);
+  } else {
+    debug('uncaught undefined/falsy exception');
+    err = createInvalidExceptionError(
+      'Caught falsy/undefined exception which would otherwise be uncaught. No stack trace found; try a debugger',
+      err
+    );
+  }
+
+  if (!isError(err)) {
+    err = thrown2Error(err);
+  }
+  err.uncaught = true;
+
+  var runnable = this.currentRunnable;
+
+  if (!runnable) {
+    runnable = new Runnable('Uncaught error outside test suite');
+    runnable.parent = this.suite;
+
+    if (this.started) {
+      this.fail(runnable, err);
+    } else {
+      // Can't recover from this failure
+      this.emit(constants.EVENT_RUN_BEGIN);
+      this.fail(runnable, err);
+      this.emit(constants.EVENT_RUN_END);
+    }
+
+    return;
+  }
+
+  runnable.clearTimeout();
+
+  // Ignore errors if already failed or pending
+  // See #3226
+  if (runnable.isFailed() || runnable.isPending()) {
+    return;
+  }
+  // we cannot recover gracefully if a Runnable has already passed
+  // then fails asynchronously
+  var alreadyPassed = runnable.isPassed();
+  // this will change the state to "failed" regardless of the current value
+  this.fail(runnable, err);
+  if (!alreadyPassed) {
+    // recover from test
+    if (runnable.type === constants.EVENT_TEST_BEGIN) {
+      this.emit(constants.EVENT_TEST_END, runnable);
+      this.hookUp(HOOK_TYPE_AFTER_EACH, this.next);
+      return;
+    }
+    debug(runnable);
+
+    // recover from hooks
+    var errSuite = this.suite;
+
+    // XXX how about a less awful way to determine this?
+    // if hook failure is in afterEach block
+    if (runnable.fullTitle().indexOf('after each') > -1) {
+      return this.hookErr(err, errSuite, true);
+    }
+    // if hook failure is in beforeEach block
+    if (runnable.fullTitle().indexOf('before each') > -1) {
+      return this.hookErr(err, errSuite, false);
+    }
+    // if hook failure is in after or before blocks
+    return this.nextSuite(errSuite);
+  }
+
+  // bail
+  this.emit(constants.EVENT_RUN_END);
+};
+
+/**
+ * Run the root suite and invoke `fn(failures)`
+ * on completion.
+ *
+ * @public
+ * @memberof Runner
+ * @param {Function} fn
+ * @return {Runner} Runner instance.
+ */
+Runner.prototype.run = function(fn) {
+  var self = this;
+  var rootSuite = this.suite;
+
+  fn = fn || function() {};
+
+  function uncaught(err) {
+    self.uncaught(err);
+  }
+
+  function start() {
+    // If there is an `only` filter
+    if (rootSuite.hasOnly()) {
+      rootSuite.filterOnly();
+    }
+    self.started = true;
+    if (self._delay) {
+      self.emit(constants.EVENT_DELAY_END);
+    }
+    self.emit(constants.EVENT_RUN_BEGIN);
+
+    self.runSuite(rootSuite, function() {
+      debug('finished running');
+      self.emit(constants.EVENT_RUN_END);
+    });
+  }
+
+  debug(constants.EVENT_RUN_BEGIN);
+
+  // references cleanup to avoid memory leaks
+  this.on(constants.EVENT_SUITE_END, function(suite) {
+    suite.cleanReferences();
+  });
+
+  // callback
+  this.on(constants.EVENT_RUN_END, function() {
+    debug(constants.EVENT_RUN_END);
+    process.removeListener('uncaughtException', uncaught);
+    fn(self.failures);
+  });
+
+  // uncaught exception
+  process.on('uncaughtException', uncaught);
+
+  if (this._delay) {
+    // for reporters, I guess.
+    // might be nice to debounce some dots while we wait.
+    this.emit(constants.EVENT_DELAY_BEGIN, rootSuite);
+    rootSuite.once(EVENT_ROOT_SUITE_RUN, start);
+  } else {
+    start();
+  }
+
+  return this;
+};
+
+/**
+ * Cleanly abort execution.
+ *
+ * @memberof Runner
+ * @public
+ * @return {Runner} Runner instance.
+ */
+Runner.prototype.abort = function() {
+  debug('aborting');
+  this._abort = true;
+
+  return this;
+};
+
+/**
+ * Filter leaks with the given globals flagged as `ok`.
+ *
+ * @private
+ * @param {Array} ok
+ * @param {Array} globals
+ * @return {Array}
+ */
+function filterLeaks(ok, globals) {
+  return globals.filter(function(key) {
+    // Firefox and Chrome exposes iframes as index inside the window object
+    if (/^\d+/.test(key)) {
+      return false;
+    }
+
+    // in firefox
+    // if runner runs in an iframe, this iframe's window.getInterface method
+    // not init at first it is assigned in some seconds
+    if (global.navigator && /^getInterface/.test(key)) {
+      return false;
+    }
+
+    // an iframe could be approached by window[iframeIndex]
+    // in ie6,7,8 and opera, iframeIndex is enumerable, this could cause leak
+    if (global.navigator && /^\d+/.test(key)) {
+      return false;
+    }
+
+    // Opera and IE expose global variables for HTML element IDs (issue #243)
+    if (/^mocha-/.test(key)) {
+      return false;
+    }
+
+    var matched = ok.filter(function(ok) {
+      if (~ok.indexOf('*')) {
+        return key.indexOf(ok.split('*')[0]) === 0;
+      }
+      return key === ok;
+    });
+    return !matched.length && (!global.navigator || key !== 'onerror');
+  });
+}
+
+/**
+ * Check if argument is an instance of Error object or a duck-typed equivalent.
+ *
+ * @private
+ * @param {Object} err - object to check
+ * @param {string} err.message - error message
+ * @returns {boolean}
+ */
+function isError(err) {
+  return err instanceof Error || (err && typeof err.message === 'string');
+}
+
+/**
+ *
+ * Converts thrown non-extensible type into proper Error.
+ *
+ * @private
+ * @param {*} thrown - Non-extensible type thrown by code
+ * @return {Error}
+ */
+function thrown2Error(err) {
+  return new Error(
+    'the ' + type(err) + ' ' + stringify(err) + ' was thrown, throw an Error :)'
+  );
+}
+
+/**
+ * Array of globals dependent on the environment.
+ *
+ * @return {Array}
+ * @deprecated
+ * @todo remove; long since unsupported
+ * @private
+ */
+function extraGlobals() {
+  if (typeof process === 'object' && typeof process.version === 'string') {
+    var parts = process.version.split('.');
+    var nodeVersion = parts.reduce(function(a, v) {
+      return (a << 8) | v;
+    });
+
+    // 'errno' was renamed to process._errno in v0.9.11.
+    if (nodeVersion < 0x00090b) {
+      return ['errno'];
+    }
+  }
+
+  return [];
+}
+
+Runner.constants = constants;
+
+/**
+ * Node.js' `EventEmitter`
+ * @external EventEmitter
+ * @see {@link https://nodejs.org/api/events.html#events_class_eventemitter}
+ */