diff --git a/.eslintrc.js b/.eslintrc.js
index 795298849..bd87baa9b 100644
--- a/.eslintrc.js
+++ b/.eslintrc.js
@@ -27,6 +27,7 @@ module.exports = {
         'testem.js',
         'testem.multiple-test-page.js',
         'testem.no-test-page.js',
+        'testem.simple-test-page.js',
         'blueprints/*/index.js',
         'config/**/*.js',
         'tests/dummy/config/**/*.js',
diff --git a/README.md b/README.md
index c935d55c7..86ad44043 100644
--- a/README.md
+++ b/README.md
@@ -115,10 +115,14 @@ $ ember exam --split=<num> --partition=<num>
 The `partition` option allows you to specify which test group to run after using the `split` option. It is one-indexed, so if you specify a split of 3, the last group you could run is 3 as well. You can also run multiple partitions, e.g.:
 
 ```bash
-$ ember exam --split=4 --partition=1 --partition=2
+# comma delimited
+$ ember exam --split=4 --partition=1,2
+
+# ranged input
+$ ember exam --split=4 --partition=2..4
 ```
 
-_Note: Ember Exam splits test by modifying the Ember-CLI `TestLoader`, which means that tests are split up according to AMD modules, so it is possible to have unbalanced partitions. For more info, see [issue #60](https://github.com/trentmwillis/ember-exam/issues/60)._
+_Note: Ember Exam splits test by modifying the Ember-QUnit's `TestLoader`, which means that tests are split up according to AMD modules, so it is possible to have unbalanced partitions. For more info, see [issue #60](https://github.com/trentmwillis/ember-exam/issues/60)._
 
 <!--```bash
 $ ember exam --split=<num> --weighted
@@ -146,7 +150,7 @@ For example, if you wanted to run your tests across two containers, but have one
 
 ```bash
 # container 1
-ember exam --split=3 --partition=1 --partition=2 --parallel
+ember exam --split=3 --partition=1,2 --parallel
 ```
 
 ```bash
@@ -188,8 +192,8 @@ module.exports = {
 If you are working with [Travis CI](https://travis-ci.org/) then you can also easily set up seeded-random runs based on PR numbers. Similar to the following:
 
 ```js
-var command = [ 'ember', 'exam', '--random' ];
-var pr = process.env.TRAVIS_PULL_REQUEST;
+const command = [ 'ember', 'exam', '--random' ];
+const pr = process.env.TRAVIS_PULL_REQUEST;
 
 if (pr) {
   command.push(pr);
diff --git a/addon-test-support/-private/async-iterator.js b/addon-test-support/-private/async-iterator.js
new file mode 100644
index 000000000..52a2c037e
--- /dev/null
+++ b/addon-test-support/-private/async-iterator.js
@@ -0,0 +1,141 @@
+'use strict';
+
+import getUrlParams from './get-url-params';
+
+/**
+ * A class to iterate a sequencial set of asynchronous events.
+ *
+ * @class AsyncIterator
+ */
+export default class AsyncIterator {
+  constructor(testem, options) {
+    this._testem = testem;
+    this._request = options.request;
+    this._response = options.response;
+    this._done = false;
+    this._current = null;
+    this._boundHandleResponse = this.handleResponse.bind(this);
+    this._waiting = false;
+    // Set a timeout value from either url parameter or default timeout value, 2 s.
+    this._timeout = getUrlParams().get('asyncTimeout') || 2;
+    this._browserId = getUrlParams().get('browser');
+
+    testem.on(this._response, this._boundHandleResponse);
+  }
+
+  /**
+   * Return whether the response queue is done.
+   */
+  get done() {
+    return this._done;
+  }
+
+  toString() {
+    return `<AsyncIterator (request: ${this._request} response: ${
+      this._response
+    })>`;
+  }
+
+  /**
+   * Handle a response when it's waiting for a response
+   *
+   * @param {*} response
+   */
+  handleResponse(response) {
+    if (this._waiting === false) {
+      throw new Error(
+        `${this.toString()} Was not expecting a response, but got a response`
+      );
+    } else {
+      this._waiting = false;
+    }
+
+    try {
+      if (response.done) {
+        this.dispose();
+      }
+      this._current.resolve(response);
+    } catch (e) {
+      this._current.reject(e);
+    } finally {
+      this._current = null;
+
+      if (this.timer) {
+        clearTimeout(this.timer);
+      }
+    }
+  }
+
+  /**
+   * Dispose when an iteration is finished.
+   *
+   */
+  dispose() {
+    this._done = true;
+    this._testem.removeEventCallbacks(
+      this._response,
+      this._boundHandleResponse
+    );
+  }
+
+  /**
+   * Emit the current request.
+   *
+   */
+  _makeNextRequest() {
+    this._waiting = true;
+    this._testem.emit(this._request, this._browserId);
+  }
+
+  /**
+   * Set a timeout to reject a promise if it doesn't get response within the timeout threshold.
+   *
+   * @param {*} reject
+   */
+  _setTimeout(reject) {
+    clearTimeout(this.timeout);
+    this.timer = setTimeout(() => {
+      if (!this._waiting) {
+        return;
+      }
+      let err = new Error(
+        `EmberExam: Promise timed out after ${
+          this._timeout
+        } s while waiting for response for ${this._request}`
+      );
+      reject(err);
+    }, this._timeout * 1000);
+  }
+
+  /**
+   * Gets the next response from the request and resolve the promise.
+   * if it's end of the iteration resolve the promise with done being true.
+   *
+   * @return {Promise}
+   */
+  next() {
+    if (this._done) {
+      return Promise.resolve({ done: true, value: null });
+    }
+    if (this._current) {
+      return this._current.promise;
+    }
+
+    let resolve, reject;
+    let promise = new Promise((_resolve, _reject) => {
+      resolve = _resolve;
+      reject = _reject;
+      this._setTimeout(reject);
+    });
+
+    this._current = {
+      resolve,
+      reject,
+      promise
+    };
+
+    this._makeNextRequest();
+
+    return promise;
+  }
+}
diff --git a/addon-test-support/-private/ember-exam-mocha-test-loader.js b/addon-test-support/-private/ember-exam-mocha-test-loader.js
new file mode 100644
index 000000000..d14bcb778
--- /dev/null
+++ b/addon-test-support/-private/ember-exam-mocha-test-loader.js
@@ -0,0 +1,69 @@
+import getUrlParams from './get-url-params';
+import splitTestModules from './split-test-modules';
+import { TestLoader } from 'ember-mocha/test-loader';
+
+/**
+ * EmberExamMochaTestLoader extends ember-mocha/test-loader used by `ember test`, since it
+ * overrides moduleLoadFailure() to log a test failure when a module fails to load
+ * @class EmberExamMochaTestLoader
+ * @extends {TestLoader}
+ */
+export default class EmberExamMochaTestLoader extends TestLoader {
+  constructor(testem, urlParams) {
+    super();
+    this._testModules = [];
+    this._testem = testem;
+    this._urlParams = urlParams || getUrlParams();
+  }
+
+  get urlParams() {
+    return this._urlParams;
+  }
+
+  /**
+   * Ember-cli-test-loader instantiates a new TestLoader instance and calls loadModules.
+   * EmberExamMochaTestLoader does not support load() in favor of loadModules().
+   */
+  static load() {
+    throw new Error('`EmberExamMochaTestLoader` doesn\'t support `load()`.');
+  }
+
+  /**
+   * require() collects the full list of modules before requiring each module with
+   * super.require, instead of requiring and unseeing a module when each gets loaded.
+   *
+   * @param {string} moduleName
+   */
+  require(moduleName) {
+    this._testModules.push(moduleName);
+  }
+
+  /**
+   * Make unsee a no-op to avoid any unwanted resets
+   */
+  unsee() {}
+
+  /**
+   * Loads the test modules depending on the urlParam
+   */
+  loadModules() {
+    let partitions = this._urlParams.get('partition');
+    let split = parseInt(this._urlParams.get('split'), 10);
+
+    split = isNaN(split) ? 1 : split;
+
+    if (partitions === undefined) {
+      partitions = [1];
+    } else if (!Array.isArray(partitions)) {
+      partitions = [partitions];
+    }
+
+    super.loadModules();
+
+    this._testModules = splitTestModules(this._testModules, split, partitions);
+    this._testModules.forEach((moduleName) => {
+      super.require(moduleName);
+      super.unsee(moduleName);
+    });
+  }
+}
diff --git a/addon-test-support/-private/ember-exam-qunit-test-loader.js b/addon-test-support/-private/ember-exam-qunit-test-loader.js
new file mode 100644
index 000000000..7aada1013
--- /dev/null
+++ b/addon-test-support/-private/ember-exam-qunit-test-loader.js
@@ -0,0 +1,153 @@
+import getUrlParams from './get-url-params';
+import splitTestModules from './split-test-modules';
+import weightTestModules from './weight-test-modules';
+import { TestLoader } from 'ember-qunit/test-loader';
+import AsyncIterator from './async-iterator';
+import QUnit from 'qunit';
+
+/**
+ * EmberExamQUnitTestLoader allows delayed requiring of test modules to enable test load balancing
+ * It extends ember-qunit/test-loader used by `ember test`, since it overrides moduleLoadFailure()
+ * to log a test failure when a module fails to load
+ * @class EmberExamQUnitTestLoader
+ * @extends {TestLoader}
+ */
+export default class EmberExamQUnitTestLoader extends TestLoader {
+  constructor(testem, urlParams, qunit = QUnit) {
+    super();
+    this._testModules = [];
+    this._testem = testem;
+    this._qunit = qunit;
+    this._urlParams = urlParams || getUrlParams();
+  }
+
+  get urlParams() {
+    return this._urlParams;
+  }
+
+  /**
+   * ember-cli-test-loader instantiates a new TestLoader instance and calls loadModules.
+   * EmberExamQUnitTestLoader does not support load() in favor of loadModules().
+   */
+  static load() {
+    throw new Error('`EmberExamQUnitTestLoader` doesn\'t support `load()`.');
+  }
+
+  /**
+   * require() collects the full list of modules before requiring each module with
+   * super.require(), instead of requiring and unseeing a module when each gets loaded.
+   *
+   * @param {string} moduleName
+   */
+  require(moduleName) {
+    this._testModules.push(moduleName);
+  }
+
+  /**
+   * Make unsee a no-op to avoid any unwanted resets
+   */
+  unsee() {}
+
+  /**
+   * Loads the test modules depending on the urlParam
+   */
+  loadModules() {
+    const loadBalance = this._urlParams.get('loadBalance');
+    const browserId = this._urlParams.get('browser');
+    let partitions = this._urlParams.get('partition');
+    let split = parseInt(this._urlParams.get('split'), 10);
+
+    split = isNaN(split) ? 1 : split;
+
+    if (partitions === undefined) {
+      partitions = [1];
+    } else if (!Array.isArray(partitions)) {
+      partitions = [partitions];
+    }
+
+    super.loadModules();
+
+    if (loadBalance && this._testem) {
+      this.setupLoadBalanceHandlers();
+      this._testModules = splitTestModules(
+        weightTestModules(this._testModules),
+        split,
+        partitions
+      );
+      this._testem.emit(
+        'testem:set-modules-queue',
+        this._testModules,
+        browserId
+      );
+    } else {
+      this._testModules = splitTestModules(
+        this._testModules,
+        split,
+        partitions
+      );
+      this._testModules.forEach((moduleName) => {
+        super.require(moduleName);
+        super.unsee(moduleName);
+      });
+    }
+  }
+
+  /**
+   * Allow loading one module at a time.
+   *
+   * @param {string} moduleName
+   */
+  loadIndividualModule(moduleName) {
+    if (moduleName === undefined) {
+      throw new Error(
+        'Failed to load a test module. `moduleName` is undefined in `loadIndividualModule`.'
+      );
+    }
+    super.require(moduleName);
+    super.unsee(moduleName);
+  }
+
+  /**
+   * setupLoadBalanceHandlers() registers QUnit callbacks needed for the load-balance option.
+   */
+  setupLoadBalanceHandlers() {
+    // nextModuleAsyncIterator handles the async testem events
+    // it returns an element of {value: <moduleName>, done: boolean}
+    const nextModuleAsyncIterator = new AsyncIterator(this._testem, {
+      request: 'testem:next-module-request',
+      response: 'testem:next-module-response'
+    });
+
+    const nextModuleHandler = () => {
+      return nextModuleAsyncIterator
+        .next()
+        .then((response) => {
+          if (!response.done) {
+            const moduleName = response.value;
+            this.loadIndividualModule(moduleName);
+
+            // if no tests were added, request the next module
+            if (this._qunit.config.queue.length === 0) {
+              return nextModuleHandler();
+            }
+          }
+        }).catch(e => {
+          if (typeof e === 'object' && e !== null && typeof e.message === 'string') {
+            e.message = `EmberExam: Failed to get next test module: ${e.message}`;
+          }
+          throw new Error(`EmberExam: Failed to get next test module: ${e}`);
+        });
+    };
+
+    // it registers qunit begin callback to ask for a next test moudle to execute when the test suite begins.
+    // By default ember-qunit adds `Ember.onerror` test to a qunit processing queue and once the test is complete it execute _qunit.moduleDone callback.
+    // However, when `setupEmberOnerrorValidation: false` is passed the test is disabled and _qunit.begin callback needs to request a next test module to run.
+    this._qunit.begin(() => {
+      return nextModuleHandler();
+    });
+
+    this._qunit.moduleDone(() => {
+      return nextModuleHandler();
+    });
+  }
+}
diff --git a/addon-test-support/-private/get-test-loader.js b/addon-test-support/-private/get-test-loader.js
index faffa42d6..5785b7997 100644
--- a/addon-test-support/-private/get-test-loader.js
+++ b/addon-test-support/-private/get-test-loader.js
@@ -1,12 +1,21 @@
 /* globals require, requirejs */
 
+/**
+ * Returns ember-exam-qunit-test-loader or ember-exam-mocha-test-loader
+ *
+ * @export
+ * @returns {Object}
+ */
 export default function getTestLoader() {
-  let testLoaderModulePath = 'ember-cli-test-loader/test-support/index';
-
-  if (!requirejs.entries[testLoaderModulePath]) {
-    testLoaderModulePath = 'ember-cli/test-loader';
+  if (requirejs.entries['ember-qunit/test-loader']) {
+    const EmberExamQUnitTestLoader = require('./ember-exam-qunit-test-loader');
+    return EmberExamQUnitTestLoader['default'];
+  } else if (requirejs.entries['ember-mocha/test-loader']) {
+    const EmberExamMochaTestLoader = require('./ember-exam-mocha-test-loader');
+    return EmberExamMochaTestLoader['default'];
   }
 
-  const TestLoaderModule = require(testLoaderModulePath);
-  return TestLoaderModule['default'];
+  throw new Error(
+    'Unable to find a suitable test loader. You should ensure that one of `ember-qunit` or `ember-mocha` are added as dependencies.'
+  );
 }
diff --git a/addon-test-support/-private/get-url-params.js b/addon-test-support/-private/get-url-params.js
index 8576470dc..cc7428a1e 100644
--- a/addon-test-support/-private/get-url-params.js
+++ b/addon-test-support/-private/get-url-params.js
@@ -2,8 +2,14 @@ function decodeQueryParam(param) {
   return decodeURIComponent(param.replace(/\+/g, '%20'));
 }
 
+/**
+ * Parses the url and return an object containing a param's key and value
+ *
+ * @export
+ * @returns {Object} urlParams
+ */
 export default function getUrlParams() {
-  const urlParams = Object.create(null);
+  const urlParams = new Map();
   const params = location.search.slice(1).split('&');
 
   for (let i = 0; i < params.length; i++) {
@@ -12,12 +18,12 @@ export default function getUrlParams() {
       const name = decodeQueryParam(param[0]);
 
       // Allow just a key to turn on a flag, e.g., test.html?noglobals
-      const value = param.length === 1 ||
-        decodeQueryParam(param.slice(1).join('='));
-      if (name in urlParams) {
-        urlParams[name] = [].concat(urlParams[name], value);
+      const value =
+        param.length === 1 || decodeQueryParam(param.slice(1).join('='));
+      if (urlParams.has(name)) {
+        urlParams.set(name, [].concat(urlParams.get(name), value));
       } else {
-        urlParams[name] = value;
+        urlParams.set(name, value);
       }
     }
   }
diff --git a/addon-test-support/-private/patch-test-loader.js b/addon-test-support/-private/patch-test-loader.js
deleted file mode 100644
index 7c5d5870c..000000000
--- a/addon-test-support/-private/patch-test-loader.js
+++ /dev/null
@@ -1,46 +0,0 @@
-import getUrlParams from './get-url-params';
-import splitTestModules from './split-test-modules';
-
-export default function patchTestLoader(TestLoader) {
-  TestLoader._urlParams = getUrlParams();
-
-  const _super = {
-    require: TestLoader.prototype.require,
-    unsee: TestLoader.prototype.unsee,
-    loadModules: TestLoader.prototype.loadModules,
-  };
-
-  // "Require" the module by adding it to the array of test modules to load
-  TestLoader.prototype.require = function _emberExamRequire(name) {
-    this._testModules.push(name);
-  };
-
-  // Make unsee a no-op to avoid any unwanted resets
-  TestLoader.prototype.unsee = function _emberExamUnsee() {};
-
-  TestLoader.prototype.loadModules = function _emberExamLoadModules() {
-    const urlParams = TestLoader._urlParams;
-    let partitions = urlParams._partition;
-    let split = parseInt(urlParams._split, 10);
-
-    split = isNaN(split) ? 1 : split;
-
-    if (partitions === undefined) {
-      partitions = [1];
-    } else if (!Array.isArray(partitions)) {
-      partitions = [partitions];
-    }
-
-    const testLoader = this;
-
-    testLoader._testModules = [];
-    _super.loadModules.apply(testLoader, arguments);
-
-    const splitModules = splitTestModules(testLoader._testModules, split, partitions);
-
-    splitModules.forEach((moduleName) => {
-      _super.require.call(testLoader, moduleName);
-      _super.unsee.call(testLoader, moduleName);
-    });
-  };
-}
diff --git a/addon-test-support/-private/patch-testem-output.js b/addon-test-support/-private/patch-testem-output.js
index e16101459..dba92cf64 100644
--- a/addon-test-support/-private/patch-testem-output.js
+++ b/addon-test-support/-private/patch-testem-output.js
@@ -1,14 +1,37 @@
 /* globals Testem */
 
-// Add the partition number for better debugging when reading the reporter
-export default function patchTestemOutput(TestLoader) {
-  Testem.on('test-result', function prependPartition(test) {
-    const urlParams = TestLoader._urlParams;
-    const split = urlParams._split;
-
-    if (split) {
-      const partition = urlParams._partition || 1;
-      test.name = `Exam Partition ${partition} - ${test.name}`;
-    }
+/**
+ * Returns a modified test name including browser or partition information
+ *
+ * @param {Map} urlParams
+ * @param {string} testName
+ * @returns {string} testName
+ */
+export function updateTestName(urlParams, testName) {
+  const split = urlParams.get('split');
+  const loadBalance = urlParams.get('loadBalance');
+
+  const partition = urlParams.get('partition') || 1;
+  const browser = urlParams.get('browser') || 1;
+
+  if (split && loadBalance) {
+    testName = `Exam Partition ${partition} - Browser Id ${browser} - ${testName}`;
+  } else if (split) {
+    testName = `Exam Partition ${partition} - ${testName}`;
+  } else if (loadBalance) {
+    testName = `Browser Id ${browser} - ${testName}`;
+  }
+
+  return testName;
+}
+
+/**
+ * Setup testem test-result event to update the test name when a test completes
+ *
+ * @param {Map} urlParams
+ */
+export function patchTestemOutput(urlParams) {
+  Testem.on('test-result', (test) => {
+    test.name = updateTestName(urlParams, test.name);
   });
 }
diff --git a/addon-test-support/-private/split-test-modules.js b/addon-test-support/-private/split-test-modules.js
index 73821769f..92e66dca5 100644
--- a/addon-test-support/-private/split-test-modules.js
+++ b/addon-test-support/-private/split-test-modules.js
@@ -27,6 +27,16 @@ function isNotLintTest(name) {
   return !isLintTest(name);
 }
 
+/**
+ * splits the list of modules into unique subset of modules
+ * return the subset indexed by the partition
+ *
+ * @export
+ * @param {Array<string>} modules
+ * @param {number} split
+ * @param {number} partitions
+ * @returns {Array<string>} tests
+ */
 export default function splitTestModules(modules, split, partitions) {
   if (split < 1) {
     throw new Error('You must specify a split greater than 0');
@@ -39,12 +49,19 @@ export default function splitTestModules(modules, split, partitions) {
   for (let i = 0; i < partitions.length; i++) {
     const partition = parseInt(partitions[i], 10);
     if (isNaN(partition)) {
-      throw new Error('You must specify numbers for partition (you specified \'' + partitions + '\')');
+      throw new Error(
+        'You must specify numbers for partition (you specified \'' +
+          partitions +
+          '\')'
+      );
     }
 
     if (split < partition) {
-      throw new Error('You must specify partitions numbered less than or equal to your split value of ' + split);
-    } else  if (partition < 1) {
+      throw new Error(
+        'You must specify partitions numbered less than or equal to your split value of ' +
+          split
+      );
+    } else if (partition < 1) {
       throw new Error('You must specify partitions numbered greater than 0');
     }
 
diff --git a/addon-test-support/-private/weight-test-modules.js b/addon-test-support/-private/weight-test-modules.js
new file mode 100644
index 000000000..b7e911ad7
--- /dev/null
+++ b/addon-test-support/-private/weight-test-modules.js
@@ -0,0 +1,58 @@
+const TEST_TYPE_WEIGHT = {
+  eslint: 1,
+  unit: 10,
+  integration: 20,
+  acceptance: 150
+};
+const WEIGHT_REGEX = /\/(eslint|unit|integration|acceptance)\//;
+const DEFAULT_WEIGHT = 50;
+
+/**
+ * Return the weight for a given module name, a file path to the module
+ * Ember tests consist of Acceptance, Integration, Unit, and lint tests. In general, acceptance takes
+ * longest time to execute, followed by integration and unit.
+ * The weight assigned to a module corresponds to its test type execution speed, with slowest being the highest in weight.
+ * If the test type is not identifiable from the modulePath, weight default to 50 (ordered after acceptance, but before integration)
+ *
+ * @param {string} modulePath File path to a module
+ */
+function getWeight(modulePath) {
+  const [, key] = WEIGHT_REGEX.exec(modulePath) || [];
+  if (typeof TEST_TYPE_WEIGHT[key] === 'number') {
+    return TEST_TYPE_WEIGHT[key];
+  } else {
+    return DEFAULT_WEIGHT;
+  }
+}
+
+/**
+ * Returns the list of modules sorted by its weight
+ *
+ * @export
+ * @param {Array<string>} modules
+ * @returns {Array<string>}
+ */
+export default function weightTestModules(modules) {
+  const groups = new Map();
+
+  modules.forEach((module) => {
+    const moduleWeight = getWeight(module);
+    let moduleWeightGroup = groups.get(moduleWeight);
+
+    if (Array.isArray(moduleWeightGroup)) {
+      moduleWeightGroup.push(module);
+    } else {
+      moduleWeightGroup = [module];
+    }
+
+    groups.set(moduleWeight, moduleWeightGroup);
+  });
+
+  // return modules sorted by weight and alphabetically within its weighted groups
+  return Array.from(groups.keys())
+    .sort((a, b) => b - a)
+    .reduce((accumulatedArray, weight) => {
+      const sortedModuleArr = groups.get(weight).sort();
+      return accumulatedArray.concat(sortedModuleArr);
+    }, []);
+}
diff --git a/addon-test-support/load.js b/addon-test-support/load.js
index 74c8a3e70..5cac62c2e 100644
--- a/addon-test-support/load.js
+++ b/addon-test-support/load.js
@@ -1,10 +1,13 @@
+import TestemOutput from './-private/patch-testem-output';
 import getTestLoader from './-private/get-test-loader';
-import patchTestLoader from './-private/patch-test-loader';
-import patchTestemOutput from './-private/patch-testem-output';
 
 let loaded = false;
+let testLoader;
 
-export default function loadEmberExam() {
+/**
+ * Setup EmberExamTestLoader to enable ember exam functionalities
+ */
+function loadEmberExam() {
   if (loaded) {
     // eslint-disable-next-line no-console
     console.warn('Attempted to load Ember Exam more than once.');
@@ -12,11 +15,28 @@ export default function loadEmberExam() {
   }
 
   loaded = true;
-
-  const TestLoader = getTestLoader();
-  patchTestLoader(TestLoader);
+  const EmberExamTestLoader = getTestLoader();
+  testLoader = new EmberExamTestLoader(window.Testem);
 
   if (window.Testem) {
-    patchTestemOutput(TestLoader);
+    TestemOutput.patchTestemOutput(testLoader.urlParams);
+  }
+}
+
+/**
+ * Equivalent to ember-qunit or ember-mocha's loadTest() except this does not create a new TestLoader instance
+ */
+function loadTests() {
+  if (testLoader === undefined) {
+    throw new Error(
+      'A testLoader instance has not been created. You must call `loadEmberExam()` before calling `loadTest()`.'
+    );
   }
+
+  testLoader.loadModules();
 }
+
+export default {
+  loadEmberExam,
+  loadTests
+};
diff --git a/addon-test-support/start.js b/addon-test-support/start.js
new file mode 100644
index 000000000..e3d0e3b3d
--- /dev/null
+++ b/addon-test-support/start.js
@@ -0,0 +1,23 @@
+/* globals require */
+
+import emberExam from 'ember-exam/test-support/load';
+
+/**
+ * Ember-exam's own start function to set up EmberExamTestLoader and disable `loadTest` to enable load-balancing
+ *
+ * @param {*} qunitOptions
+ */
+export default function start(qunitOptions) {
+  const framework = require.has('ember-qunit') ? 'qunit' : 'mocha';
+  const modifiedOptions = qunitOptions || Object.create(null);
+  modifiedOptions.loadTests = false;
+
+  emberExam.loadEmberExam();
+  emberExam.loadTests();
+
+  const emberTestFramework = require(`ember-${framework}`);
+
+  if (emberTestFramework.start) {
+    emberTestFramework.start(modifiedOptions);
+  }
+}
diff --git a/index.js b/index.js
index 5ca73fe5a..9d9d426a5 100644
--- a/index.js
+++ b/index.js
@@ -5,7 +5,7 @@
 module.exports = {
   name: require('./package').name,
 
-  includedCommands: function() {
+  includedCommands() {
     return require('./lib/commands');
   }
 };
diff --git a/lib/commands/exam.js b/lib/commands/exam.js
index 71c86eed6..460341aad 100644
--- a/lib/commands/exam.js
+++ b/lib/commands/exam.js
@@ -1,62 +1,109 @@
 'use strict';
 
-const fs = require('fs-extra');
-const path = require('path');
+const { addToQuery } = require('../utils/query-helper');
+const {
+  combineOptionValueIntoArray,
+  getBrowserId,
+  getMultipleTestPages
+} = require('../utils/test-page-helper');
+const TestemEvents = require('../utils/testem-events');
 const TestCommand = require('ember-cli/lib/commands/test'); // eslint-disable-line node/no-unpublished-require
-const debug = require('debug')('exam');
-
-function addToQuery(query, param, value) {
-  if (!value) {
-    return query;
-  }
-
-  const queryAddParam = query ? query + '&' + param : param;
-
-  return value !== true ?
-    queryAddParam + '=' + value :
-    queryAddParam;
-}
-
-function addToUrl(url, param, value) {
-  const urlParts = url.split('?');
-  const base = urlParts[0];
-  const query = urlParts[1];
-
-  return base + '?' + addToQuery(query, param, value);
-}
+const TestServerTask = require('./task/test-server');
+const TestTask = require('./task/test');
 
 module.exports = TestCommand.extend({
   name: 'exam',
 
-  description: 'Runs your app\'s test suite with more options than \'test\'.',
+  description: `Runs your app's test suite with more options than 'test'.`,
 
   works: 'insideProject',
 
   availableOptions: [
-    { name: 'split',        type: Number,                  description: 'A number of files to split your tests across.' },
-    { name: 'partition',    type: [Array, Number],         description: 'The number of the partition(s) to run after splitting.' },
-    { name: 'weighted',     type: Boolean,                 description: 'Weights the type of tests to help equal splits.' },
-    { name: 'parallel',     type: Boolean, default: false, description: 'Runs your split tests on parallel child processes.' },
-    { name: 'random',       type: String,  default: false, description: 'Randomizes your modules and tests while running your test suite.' }
+    {
+      name: 'split',
+      type: Number,
+      description: 'A number of files to split your tests across.'
+    },
+    {
+      name: 'partition',
+      type: [Array, Number, String],
+      description: 'The number of the partition(s) to run after splitting.'
+    },
+    {
+      name: 'parallel',
+      type: Number,
+      description: 'Runs your split tests on parallel child processes.'
+    },
+    {
+      name: 'load-balance',
+      type: Boolean,
+      default: false,
+      description:
+        'Load balance test modules. Test modules will be sorted by weight from slowest (acceptance) to fastest (eslint).'
+    },
+    {
+      name: 'random',
+      type: String,
+      default: false,
+      description:
+        'Randomizes your modules and tests while running your test suite.'
+    },
+    {
+      name: 'replay-execution',
+      type: String,
+      default: false,
+      aliases: ['re'],
+      description:
+        'A JSON file path which maps from browser id(s) to a list of modules'
+    },
+    {
+      name: 'replay-browser',
+      type: [Array, Number, String],
+      aliases: ['rb'],
+      description: 'The browser id(s) to replay from the replay-execution file'
+    },
+    {
+      name: 'write-execution-file',
+      type: Boolean,
+      default: false,
+      aliases: ['wef'],
+      description:
+        'Allows writing a test-execution json file after running your test suite'
+    }
   ].concat(TestCommand.prototype.availableOptions),
 
+  init() {
+    this._super(...arguments);
+    this.tasks.Test = TestTask;
+    this.tasks.TestServer = TestServerTask;
+    this.testemEvents = new TestemEvents(this.project.root);
+    this.emberCliVersion =
+      this.project.pkg.devDependencies['ember-cli'] ||
+      this.project.pkg.dependencies['ember-cli'];
+  },
+
   /**
-   * Creates an options validator object.
+   *  Validates commandOptions
    *
    * @private
-   * @param {Object} options
-   * @return {TestOptionsValidator}
+   * @param {Object} commandOptions
+   * @return {Object} A map of what switches are enabled
    */
-  _createValidator(options) {
+  _validateOptions(commandOptions) {
     const Validator = require('../utils/tests-options-validator');
-    return new Validator(options, this._getTestFramework());
+    const validator = new Validator(
+      commandOptions,
+      this._getTestFramework(),
+      this.emberCliVersion
+    );
+    return validator.validateCommands();
   },
 
   /**
    * Gets the name of the test framework being used by the project.
    *
    * @private
-   * @return {String}
+   * @return {string}
    */
   _getTestFramework() {
     const pkg = this.project.pkg;
@@ -73,31 +120,56 @@ module.exports = TestCommand.extend({
   /**
    * Validates the command options and then runs the original test command.
    *
+   * @param {Object} commandOptions
    * @override
    */
   run(commandOptions) {
-    this.validator = this._createValidator(commandOptions);
+    this.commands = this._validateOptions(commandOptions);
 
-    if (this.validator.shouldSplit) {
-      commandOptions.query = addToQuery(commandOptions.query, '_split', commandOptions.split);
+    // TODO: explore not mutating the commandOptions input
+    if (commandOptions.split) {
+      commandOptions.query = addToQuery(
+        commandOptions.query,
+        'split',
+        commandOptions.split
+      );
 
       process.env.EMBER_EXAM_SPLIT_COUNT = commandOptions.split;
 
       // Ignore the partition option when paralleling (we'll fill it in later)
-      if (!this.validator.shouldParallelize) {
-        const partitions = commandOptions.partition;
-        if (partitions) {
-          for (let i = 0; i < partitions.length; i++) {
-            commandOptions.query = addToQuery(commandOptions.query, '_partition', partitions[i]);
-          }
+      if (!commandOptions.parallel && commandOptions.partition) {
+        const partitions = combineOptionValueIntoArray(
+          commandOptions.partition
+        );
+        for (let i = 0; i < partitions.length; i++) {
+          commandOptions.query = addToQuery(
+            commandOptions.query,
+            'partition',
+            partitions[i]
+          );
         }
       }
+    }
 
-      commandOptions.query = addToQuery(commandOptions.query, '_weighted', commandOptions.weighted);
+    if (commandOptions.loadBalance) {
+      commandOptions.query = addToQuery(
+        commandOptions.query,
+        'loadBalance',
+        commandOptions.loadBalance
+      );
     }
 
-    if (this.validator.shouldRandomize) {
-      commandOptions.query = this._randomize(commandOptions.random, commandOptions.query);
+    if (commandOptions.replayBrowser) {
+      commandOptions.replayBrowser = combineOptionValueIntoArray(
+        commandOptions.replayBrowser
+      );
+    }
+
+    if (typeof commandOptions.random !== 'undefined') {
+      commandOptions.query = this._randomize(
+        commandOptions.random,
+        commandOptions.query
+      );
     }
 
     return this._super.run.apply(this, arguments);
@@ -107,11 +179,17 @@ module.exports = TestCommand.extend({
    * Adds a `seed` param to the `query` to support randomization. Currently
    * only works with QUnit.
    *
-   * @param {Object} commandOptions
-   * @return {Void}
+   * @param {string} random
+   * @param {string} query
+   * @return {string}
    */
   _randomize(random, query) {
-    const seed = random !== '' ? random : Math.random().toString(36).slice(2);
+    const seed =
+      random !== ''
+        ? random
+        : Math.random()
+            .toString(36)
+            .slice(2);
 
     this.ui.writeLine('Randomizing tests with seed: ' + seed);
 
@@ -120,35 +198,29 @@ module.exports = TestCommand.extend({
 
   /**
    * Customizes the Testem config to have multiple test pages if attempting to
-   * run in parallel. It is important that the user specifies the number of
-   * launchers to run in parallel in their testem.json config.
+   * run in parallel or load-balance. It is important that the user specifies
+   * the number of launchers to run in parallel in their testem.json config.
    *
+   * @param {Object} commandOptions
    * @override
    */
   _generateCustomConfigs(commandOptions) {
     const config = this._super._generateCustomConfigs.apply(this, arguments);
 
-    if (this.validator.shouldParallelize) {
-      // Get the testPage from the generated config or the Testem config and
-      // use it as the baseUrl for the parallelized test pages
-      const baseUrl = config.testPage || this._getTestPage(commandOptions.configFile);
-      const count = commandOptions.split;
-      let partitions = commandOptions.partition;
+    if (!commandOptions.loadBalance && !commandOptions.replayExecution && !commandOptions.parallel )
+      return config;
 
-      if (!partitions) {
-        partitions = [];
-        for (let i = 0; i < commandOptions.split; i++) {
-          partitions.push(i + 1);
-        }
-      }
+    config.testPage = getMultipleTestPages(config, commandOptions);
 
-      if (Array.isArray(baseUrl)) {
-        const command = this;
-        config.testPage = baseUrl.reduce(function(testPages, baseUrl) {
-          return testPages.concat(command._generateTestPages(baseUrl, partitions, count));
-        }, []);
-      } else {
-        config.testPage = this._generateTestPages(baseUrl, partitions, count);
+    if (commandOptions.loadBalance || commandOptions.replayExecution) {
+      config.custom_browser_socket_events = this._addLoadBalancingBrowserSocketEvents(
+        config
+      );
+      if (commandOptions.replayExecution) {
+        this.testemEvents.setReplayExecutionMap(
+          commandOptions.replayExecution,
+          commandOptions.replayBrowser
+        );
       }
     }
 
@@ -156,105 +228,72 @@ module.exports = TestCommand.extend({
   },
 
   /**
-   * Gets the test page specified by the application's Testem config.
-   *
-   * @param {String} [configFile] - Path to the config file to use
-   * @return {String} testPage
-   */
-  _getTestPage(configFile) {
-    // Attempt to read in the testem config and use the test_page definition
-    const testemConfig = this._readTestemConfig(configFile);
-    let testPage = testemConfig && testemConfig.test_page;
-
-    // If there is no test_page to use as the testPage, we warn that we're using
-    // a default value
-    if (!testPage) {
-      // eslint-disable-next-line no-console
-      console.warn('No test_page value found in the config. Defaulting to "tests/index.html?hidepassed"');
-      testPage = 'tests/index.html?hidepassed';
-    }
-
-    return testPage;
-  },
-
-  /**
-   * Generates the test pages to use for parallel runs. For a given baseUrl,
-   * it appends the total split count and the partition numbers each page is
-   * running as query params.
-   *
-   * @param {String} baseUrl
-   * @param {Array<Number>} partitions
-   * @param {Number} count
-   * @return {Array<String>} testPages
-   */
-  _generateTestPages(baseUrl, partitions, count) {
-    const splitUrl = addToUrl(baseUrl, '_split', count);
-    const testPages = [];
-
-    for (let i = 0; i < partitions.length; i++) {
-      testPages.push(addToUrl(splitUrl, '_partition', partitions[i]));
-    }
-
-    return testPages;
-  },
-
-  /**
-   * Gets the application's testem config by trying a custom file first and then
-   * defaulting to either `testem.js` or `testem.json`.
+   * Returns a object of event handlers which enables load balancing.
+   * These event handlers will be registered on Testem's browserTestRunner socket instance
    *
-   * @param {String} file
-   * @return {Object} config
+   * @param {Object} config
+   * @return {Object} events
    */
-  _readTestemConfig(file) {
-    const potentialFiles = [
-      'testem.js',
-      'testem.json'
-    ];
-
-    if (file) {
-      potentialFiles.unshift(file);
-    }
+  _addLoadBalancingBrowserSocketEvents(config) {
+    const commands = this.commands;
+    const testemEvents = this.testemEvents;
+    const ui = this.ui;
+    const events = config.custom_browser_socket_events || {};
+    const testExecutionFileName = `test-execution-${Date.now()}.json`;
+    const browserExitHandler = function() {
+      const browserCount = Object.keys(config.testPage).length;
+      testemEvents.completedBrowsersHandler(
+        browserCount,
+        ui,
+        commands.get('loadBalance'),
+        testExecutionFileName,
+        commands.get('writeExecutionFile')
+      );
+    };
+    const browserFailureHandler = function() {
+      if (this.finished) {
+        return;
+      } else if (commands.get('writeExecutionFile')) {
+        const browserId = getBrowserId(this.launcher.settings.test_page);
+        testemEvents.recoredFailedBrowserId(browserId);
+      }
 
-    const configFile = this._findValidFile(potentialFiles);
+      browserExitHandler();
+    };
 
-    return configFile && this._readFileByType(configFile);
-  },
+    let init = false;
 
-  /**
-   * Given an array of file paths, returns the first one that exists and is
-   * accessible. Paths are relative to the process' cwd.
-   *
-   * @param {Array<String>} files
-   * @return {String} file
-   */
-  _findValidFile(files) {
-    for (let i = 0; i < files.length; i++) {
-      // TODO: investigate this cwd() usually they are in-error...
-      const file = path.join(process.cwd(), files[i]);
-      try {
-        fs.accessSync(file, fs.F_OK);
-        return file;
-      } catch (error) {
-        debug('Failed to find ' + file + ' due to error: ' + error);
-        continue;
+    events['tests-start'] = function() {
+      if (!init) {
+        this.process.on('processExit', browserFailureHandler.bind(this));
+        this.process.on('processError', browserFailureHandler.bind(this));
+        init = true;
       }
-    }
-  },
+    };
+    events['testem:set-modules-queue'] = function(modules, browserId) {
+      testemEvents.setModuleQueue(
+        browserId,
+        modules,
+        commands.get('loadBalance'),
+        commands.get('replayExecution')
+      );
+    };
+    events['testem:next-module-request'] = function(browserId) {
+      testemEvents.nextModuleResponse(
+        browserId,
+        this.socket,
+        commands.get('writeExecutionFile')
+      );
+    };
+    events['test-result'] = function(result) {
+      if (result.failed && commands.get('writeExecutionFile')) {
+        const browserId = getBrowserId(this.launcher.settings.test_page);
+        testemEvents.recoredFailedBrowserId(browserId);
+      }
+    };
+    events['after-tests-complete'] = browserExitHandler;
+    events['disconnect'] = browserFailureHandler;
 
-  /**
-   * Reads in a given file according to it's "type" as determined by file
-   * extension. Supported types are `js` and `json`.
-   *
-   * @param {String} file
-   * @return {Object} fileContents
-   */
-  _readFileByType(file) {
-    const fileType = file.split('.').pop();
-    switch (fileType) {
-      case 'js':
-        return require(file);
-      case 'json':
-        return fs.readJsonSync(file);
-    }
+    return events;
   }
 });
diff --git a/lib/commands/exam/iterate.js b/lib/commands/exam/iterate.js
index 87875f2aa..0f30ef840 100644
--- a/lib/commands/exam/iterate.js
+++ b/lib/commands/exam/iterate.js
@@ -1,19 +1,30 @@
 'use strict';
 
+const execa = require('execa');
+
 module.exports = {
   name: 'exam:iterate',
 
-  description: 'Runs your app\'s test suite in a random order for a number of iterations with the \'exam\' command.',
+  description:
+    'Runs your app\'s test suite in a random order for a number of iterations with the \'exam\' command.',
 
   works: 'insideProject',
 
-  anonymousOptions: [
-    '<iterations>'
-  ],
+  anonymousOptions: ['<iterations>'],
 
   availableOptions: [
-    { name: 'options', type: String, default: '', description: 'A string of options to passthrough to the exam command' },
-    { name: 'path',    type: String, default: '', description: 'The output path of a previous build to run tests against' }
+    {
+      name: 'options',
+      type: String,
+      default: '',
+      description: 'A string of options to passthrough to the exam command'
+    },
+    {
+      name: 'path',
+      type: String,
+      default: '',
+      description: 'The output path of a previous build to run tests against'
+    }
   ],
 
   /**
@@ -70,22 +81,20 @@ module.exports = {
    * against repeatedly without rebuilding.
    */
   _buildForTests() {
-    // TODO: execa
-    var execSync = require('child_process').execSync;
-
     this._write('\nBuilding app for test iterations.');
-    execSync('./node_modules/.bin/ember build --output-path ' + this._outputDir, { stdio: 'inherit' });
+    execa.sync(
+      './node_modules/.bin/ember', ['build', '--output-path', `${this._outputDir}`], ['stdio', 'inherit']
+    );
   },
 
   /**
    * Cleans up the build artifacts used for the test iterations.
    */
   _cleanupBuild() {
-    // TODO: execa
-    var rimraf = require('rimraf');
-
     this._write('\nCleaning up test iterations.\n');
-    rimraf.sync(this._outputDir);
+    execa.sync(
+      'rm', ['-rf', `${this._outputDir}`]
+    );
   },
 
   /**
@@ -130,8 +139,16 @@ module.exports = {
     const chalk = require('chalk');
     const execSync = require('child_process').execSync;
 
-    const seed = Math.random().toString(36).slice(2);
-    const command = './node_modules/.bin/ember exam --random ' + seed + ' --path ' + this._outputDir + ' ' + options;
+    const seed = Math.random()
+      .toString(36)
+      .slice(2);
+    const command =
+      './node_modules/.bin/ember exam --random ' +
+      seed +
+      ' --path ' +
+      this._outputDir +
+      ' ' +
+      options;
     let exitCode;
 
     try {
@@ -144,10 +161,6 @@ module.exports = {
     }
 
     const color = exitCode ? chalk.red : chalk.green;
-    return [
-      color(seed),
-      color(exitCode),
-      color(command)
-    ];
+    return [color(seed), color(exitCode), color(command)];
   }
 };
diff --git a/lib/commands/index.js b/lib/commands/index.js
index 5dd84559a..3448fef7e 100644
--- a/lib/commands/index.js
+++ b/lib/commands/index.js
@@ -1,6 +1,6 @@
 'use strict';
 
 module.exports = {
-  'exam': require('./exam'),
+  exam: require('./exam'),
   'exam:iterate': require('./exam/iterate')
 };
diff --git a/lib/commands/task/test-server.js b/lib/commands/task/test-server.js
new file mode 100644
index 000000000..1106a95bb
--- /dev/null
+++ b/lib/commands/task/test-server.js
@@ -0,0 +1,13 @@
+// eslint-disable-next-line node/no-unpublished-require
+const TestServerTask = require('ember-cli/lib/tasks/test-server');
+
+module.exports = TestServerTask.extend({
+  transformOptions(options) {
+    const transformOptions = this._super(...arguments);
+    transformOptions.custom_browser_socket_events =
+      options.custom_browser_socket_events;
+    transformOptions.browser_module_mapping = options.browser_module_mapping;
+
+    return transformOptions;
+  }
+});
diff --git a/lib/commands/task/test.js b/lib/commands/task/test.js
new file mode 100644
index 000000000..f6bdf8178
--- /dev/null
+++ b/lib/commands/task/test.js
@@ -0,0 +1,13 @@
+// eslint-disable-next-line node/no-unpublished-require
+const TestTask = require('ember-cli/lib/tasks/test');
+
+module.exports = TestTask.extend({
+  transformOptions(options) {
+    const transformOptions = this._super(...arguments);
+    transformOptions.custom_browser_socket_events =
+      options.custom_browser_socket_events;
+    transformOptions.browser_module_mapping = options.browser_module_mapping;
+
+    return transformOptions;
+  }
+});
diff --git a/lib/utils/config-reader.js b/lib/utils/config-reader.js
new file mode 100644
index 000000000..af455aeff
--- /dev/null
+++ b/lib/utils/config-reader.js
@@ -0,0 +1,65 @@
+'use strict';
+
+const fs = require('fs-extra');
+const path = require('path');
+const debug = require('debug')('exam:config-reader');
+
+const potentialConfigFiles = ['testem.js', 'testem.json'];
+
+/**
+ * Given an array of file paths, returns the first one that exists and is
+ * accessible. Paths are relative to the process' cwd.
+ *
+ * @param {Array<string>} files
+ * @return {string} file
+ */
+function _findValidFile(files) {
+  for (let i = 0; i < files.length; i++) {
+    // TODO: investigate this cwd() usually they are in-error...
+    const file = path.join(process.cwd(), files[i]);
+    try {
+      fs.accessSync(file, fs.F_OK);
+      return file;
+    } catch (error) {
+      debug(`Failed to find ${file} due to error: ${error}`);
+      continue;
+    }
+  }
+}
+
+/**
+ * Reads in a given file according to it's 'type' as determined by file
+ * extension. Supported types are `js` and `json`.
+ *
+ * @param {string} file
+ * @return {Object} fileContents
+ */
+function _readFileByType(file) {
+  if (typeof file === 'string') {
+    const fileType = file.split('.').pop();
+    switch (fileType) {
+      case 'js':
+        return require(file);
+      case 'json':
+        return fs.readJsonSync(file);
+    }
+  }
+}
+
+/**
+ * Gets the application's testem config by trying a custom file first and then
+ * defaulting to either `testem.js` or `testem.json`.
+ *
+ * @param {string} file
+ * @param {Array<string>} potentialFiles
+ * @return {Object} config
+ */
+module.exports = function readTestemConfig(file, potentialFiles = potentialConfigFiles) {
+  if (file) {
+    potentialFiles.unshift(file);
+  }
+
+  const configFile = _findValidFile(potentialFiles);
+
+  return configFile && _readFileByType(configFile);
+};
diff --git a/lib/utils/execution-state-manager.js b/lib/utils/execution-state-manager.js
new file mode 100644
index 000000000..b544f05c7
--- /dev/null
+++ b/lib/utils/execution-state-manager.js
@@ -0,0 +1,185 @@
+'use strict';
+
+/**
+ * A class to store the state of an execution.
+ *
+ * @class ExecutionStateManager
+ */
+class ExecutionStateManager {
+  constructor(replayExecutionMap) {
+    // A map of browerId to test modules executed on that browser read from test-execution.json.
+    this._replayExecutionMap = replayExecutionMap || null;
+
+    // A map of browerId to test modules executed for the current test execution.
+    this._browserToModuleMap = new Map();
+
+    // An array keeping the browserId of a browser with failing test
+    this._failedBrowsers = [];
+    this._completedBrowsers = 0;
+
+    // An array of modules to be load balanced to a number of browsers
+    this._sharedModuleQueue = null;
+
+    // A map of browserId to an array of modules to be passed to the browser
+    this._browserModuleQueue = null;
+  }
+
+  /**
+   * Returns the replayExecutionMap
+   *
+   * @returns {Object}
+   */
+  getReplayExecutionMap() {
+    return this._replayExecutionMap;
+  }
+
+  /**
+   * Sets the replayExecutionMap
+   *
+   * @param {Object} replayModuleMap
+   */
+  setReplayExecutionMap(replayModuleMap) {
+    this._replayExecutionMap = replayModuleMap;
+  }
+
+  /**
+   * Returns the SharedModuleQueue
+   *
+   * @returns {Object}
+   */
+  getSharedModuleQueue() {
+    return this._sharedModuleQueue;
+  }
+
+  /**
+   * Sets the shared module queue.
+   *
+   * @param {Object} moduleQueue
+   */
+  setSharedModuleQueue(moduleQueue) {
+    this._sharedModuleQueue = moduleQueue;
+  }
+
+  /**
+   * Gets the next module from the shared module queue
+   *
+   * @returns {string}
+   */
+  getNextModuleSharedModuleQueue() {
+    if (this._sharedModuleQueue) {
+      return this._sharedModuleQueue.shift();
+    }
+    return null;
+  }
+
+  /**
+   * Returns the array of modules belonging to browserId
+   *
+   * @param {number} browserId
+   * @returns {Array<number>}
+   */
+  getBrowserModuleQueue(browserId) {
+    if (this._browserModuleQueue) {
+      return this._browserModuleQueue.get(browserId);
+    }
+    return null;
+  }
+
+  /**
+   * Sets the array of modules in browser module queue for browserId
+   *
+   * @param {Array<string>} moduleQueue
+   * @param {number} browserId
+   */
+  setBrowserModuleQueue(moduleQueue, browserId) {
+    if (!this._browserModuleQueue) {
+      this._browserModuleQueue = new Map();
+    }
+    this._browserModuleQueue.set(browserId, moduleQueue.slice());
+  }
+
+  /**
+   * Gets the next module from the module array of browserId
+   *
+   * @param {number} browserId
+   * @returns {string}
+   */
+  getNextModuleBrowserModuleQueue(browserId) {
+    if (this._browserModuleQueue && this._browserModuleQueue.get(browserId)) {
+      return this._browserModuleQueue.get(browserId).shift();
+    }
+    return null;
+  }
+
+  /**
+   * Returns the SharedModuleQueue
+   *
+   * @returns {Array<number>}
+   */
+  getFailedBrowsers() {
+    return this._failedBrowsers;
+  }
+
+  /**
+   * Returns the whether or not the browserId is contained in the failBrowsers array.
+   *
+   * @param {number} browserId
+   * @returns {Boolean}
+   */
+  containsFailedBrowser(browserId) {
+    return this._failedBrowsers.includes(browserId);
+  }
+
+  /**
+   * Add a new browserId to the failedBrowser array.
+   *
+   * @param {number} browserId
+   * @returns {Boolean}
+   */
+  addFailedBrowsers(browserId) {
+    return this._failedBrowsers.push(browserId);
+  }
+
+  /**
+   * Returns the a map of browserId to modules array
+   *
+   * @returns {Object}
+   */
+  getModuleMap() {
+    return this._browserToModuleMap;
+  }
+
+  /**
+   * Pushes the moduleName into the moduleArray of browserId
+   *
+   * @param {string} moduleName
+   * @param {number} browserId
+   */
+  addModuleNameToModuleMap(moduleName, browserId) {
+    let browserModuleList = this._browserToModuleMap.get(browserId);
+    if (Array.isArray(browserModuleList)) {
+      browserModuleList.push(moduleName);
+    } else {
+      browserModuleList = [moduleName];
+    }
+    this._browserToModuleMap.set(browserId, browserModuleList);
+  }
+
+  /**
+   * Returns the number of completed browsers
+   *
+   * @returns {number}
+   */
+  completedBrowsers() {
+    return this._completedBrowsers;
+  }
+
+  /**
+   * Increment the number of completed browsers
+   */
+  incrementCompletedBrowsers() {
+    this._completedBrowsers = this._completedBrowsers + 1;
+  }
+}
+
+module.exports = ExecutionStateManager;
diff --git a/lib/utils/query-helper.js b/lib/utils/query-helper.js
new file mode 100644
index 000000000..f62285dbd
--- /dev/null
+++ b/lib/utils/query-helper.js
@@ -0,0 +1,38 @@
+'use strict';
+
+/**
+ * Creates a valid query string by appending a given param and value to query.
+ *
+ * @param {string} query
+ * @param {string} param
+ * @param {string} value
+ */
+function addToQuery(query, param, value) {
+  if (!value) {
+    return query;
+  }
+
+  const queryAddParam = query ? query + '&' + param : param;
+
+  return value !== true ? queryAddParam + '=' + value : queryAddParam;
+}
+
+/**
+ * Adds a valid query string to a given url.
+ *
+ * @param {string} url
+ * @param {string} param
+ * @param {string} value
+ */
+function addToUrl(url, param, value) {
+  const urlParts = url.split('?');
+  const base = urlParts[0];
+  const query = urlParts[1];
+
+  return base + '?' + addToQuery(query, param, value);
+}
+
+module.exports = {
+  addToQuery,
+  addToUrl
+};
diff --git a/lib/utils/test-page-helper.js b/lib/utils/test-page-helper.js
new file mode 100644
index 000000000..d9c2bc5fd
--- /dev/null
+++ b/lib/utils/test-page-helper.js
@@ -0,0 +1,233 @@
+'use strict';
+
+const fs = require('fs-extra');
+const readTestemConfig = require('../utils/config-reader');
+const { addToUrl } = require('./query-helper');
+
+/**
+ * Add paramater such as split, loadbalance or partition to a base url if options are valid.
+ *
+ * @param {Object} commandOptions
+ * @param {string} baseUrl
+ * @return {string} baseUrl
+ */
+function _appendParamToBaseUrl(commandOptions, baseUrl) {
+  if (commandOptions.parallel || commandOptions.split) {
+    baseUrl = addToUrl(baseUrl, 'split', commandOptions.split);
+  }
+  // `loadBalance` is added to url when running replay-execution in order to emit `set-module-queue` in patch-test-loader.
+  if (commandOptions.loadBalance || commandOptions.replayExecution) {
+    const partitions = commandOptions.partition;
+    baseUrl = addToUrl(baseUrl, 'loadBalance', true);
+    if (partitions) {
+      for (let i = 0; i < partitions.length; i++) {
+        baseUrl = addToUrl(baseUrl, 'partition', partitions[i]);
+      }
+    }
+  }
+
+  return baseUrl;
+}
+
+/**
+ * Generates an array by parsing optionValue. optionValue can be in a string form of '1,2', '3..5'
+ * or '1,3..5' where '3..5' indicates a number sequence starting from 2 to 5.
+ *
+ * @param {string} optionValue
+ * @return {Array<number>}
+ */
+function _formatStringOptionValue(optionValue) {
+  let valueArray = [];
+
+  optionValue.split(',').forEach(function(val) {
+    if (val.indexOf('..') > 0) {
+      const arr = val.split('..');
+      const filledArray = _getFilledArray(arr.shift(), arr.pop());
+      valueArray = valueArray.concat(filledArray);
+    } else {
+      valueArray.push(val);
+    }
+  });
+
+  return valueArray;
+}
+
+/**
+ * Generates multiple test pages: for a given baseUrl, it appends the partition numbers
+ * or the browserId each page is running as query params.
+ *
+ * @param {string} customBaseUrl
+ * @param {string} appendingParam
+ * @param {Array<number} browserIds
+ * @return {Array<string>} testPages
+ */
+function _generateTestPages(customBaseUrl, appendingParam, browserIds) {
+  const testPages = [];
+  for (let i = 0; i < browserIds.length; i++) {
+    const url = addToUrl(customBaseUrl, appendingParam, browserIds[i]);
+    testPages.push(url);
+  }
+
+  return testPages;
+}
+
+/**
+ * Creates an array of numbers between the range of start to end.
+ *
+ * @param {number} start
+ * @param {number} end
+ * @return {Array}
+ */
+function _getFilledArray(start, end) {
+  const length = end - start + 1;
+  return Array.from(
+    { length },
+    (_, i) => i + Number(start)
+  );
+}
+
+/**
+ * returns the failed browsers from the test execution json defined in executionJsonPath
+ * other wise return an array of 1 to number of browsers spawned during the execution
+ *
+ * @param {string} executionJsonPath
+ * @return {Array<number>} testPages
+ */
+function _getReplayBrowsers(executionJsonPath) {
+  const executionJson = fs.readJsonSync(executionJsonPath);
+
+  if (executionJson.failedBrowsers.length > 0) {
+    return executionJson.failedBrowsers;
+  }
+  return _getFilledArray(1, executionJson.numberOfBrowsers);
+}
+
+/**
+ * Returns an array populated with numeric values represented by the optionValue.
+ * e.g. [1, '2,3'] => [1, 2, 3], [1, '3..6'] => [1, 3, 4, 5, 6]
+ *
+ * @param {*} optionValue
+ * @return {Array<number}
+ */
+function combineOptionValueIntoArray(optionValue) {
+  if (!optionValue) return [];
+
+  let optionArray = Array.isArray(optionValue) ? optionValue : [optionValue];
+
+  return optionArray.reduce((result, element) => {
+    if (typeof element === 'string') {
+      return result.concat(_formatStringOptionValue(element));
+    }
+    return result.concat(element);
+  }, []);
+}
+
+/**
+ * Returns the browserId within the testPage string
+ *
+ * @param {string} testPage
+ * @return {string}
+ */
+function getBrowserId(testPage) {
+  const browserId = /browser=\s*([0-9]*)/.exec(testPage);
+
+  if (Array.isArray(browserId) !== null && browserId !== null) {
+    return browserId[1];
+  } else {
+    throw new Error('Browser Id can\'t be found.');
+  }
+}
+
+/**
+ * Gets a test url in testem config to modify the url in order to generate multiple test pages
+ *
+ * @param {Object} configFile
+ * @return {string} testPage
+ */
+function getTestUrlFromTestemConfig(configFile) {
+  // Attempt to read in the testem config and use the test_page definition
+  const testemConfig = readTestemConfig(configFile);
+  let testPage = testemConfig && testemConfig.test_page;
+
+  // If there is no test_page to use as the testPage, we warn that we're using
+  // a default value
+  if (!testPage) {
+    // eslint-disable-next-line no-console
+    console.warn(
+      'No test_page value found in the config. Defaulting to "tests/index.html?hidepassed"'
+    );
+    testPage = 'tests/index.html?hidepassed';
+  }
+
+  // Get the testPage from the generated config or the Testem config and
+  // use it as the baseUrl to customize for the parallelized test pages or test load balancing
+  return testPage;
+}
+
+/**
+ * Creates an array of custom base urls by appending options that are specified
+ *
+ * @param {Object} commandOptions
+ * @param {*} baseUrl
+ * @return {string}
+ */
+function getCustomBaseUrl(commandOptions, baseUrl) {
+  if (Array.isArray(baseUrl)) {
+    return baseUrl.map(currentUrl => {
+      return _appendParamToBaseUrl(commandOptions, currentUrl);
+    });
+  } else {
+    return _appendParamToBaseUrl(commandOptions, baseUrl);
+  }
+}
+
+/**
+ * Ember-exam allows serving multiple browsers to run test suite. In order to acheive that test_page in testem config
+ * has to be set with an array of multiple urls reflecting to command passed.
+ *
+ * @param {Object} config
+ * @param {Object} commandOptions
+ * @return {Array<string>} testPages
+ */
+function getMultipleTestPages(config, commandOptions) {
+  let testPages = Object.create(null);
+  let browserIds = combineOptionValueIntoArray(commandOptions.partition);
+  let appendingParam = 'partition';
+
+  if (commandOptions.loadBalance) {
+    appendingParam = 'browser';
+    browserIds = _getFilledArray(1, commandOptions.parallel);
+  } else if (commandOptions.parallel === 1 && browserIds.length === 0) {
+    browserIds = _getFilledArray(1, commandOptions.split);
+  } else if (commandOptions.replayExecution) {
+    appendingParam = 'browser';
+    browserIds = combineOptionValueIntoArray(commandOptions.replayBrowser);
+    if (browserIds.length === 0) {
+      browserIds = _getReplayBrowsers(commandOptions.replayExecution);
+    }
+  }
+
+  const baseUrl =
+    config.testPage || getTestUrlFromTestemConfig(config.configFile);
+  const customBaseUrl = getCustomBaseUrl(commandOptions, baseUrl);
+
+  if (Array.isArray(customBaseUrl)) {
+    testPages = customBaseUrl.reduce(function(testPages, customBaseUrl) {
+      return testPages.concat(
+        _generateTestPages(customBaseUrl, appendingParam, browserIds)
+      );
+    }, []);
+  } else {
+    testPages = _generateTestPages(customBaseUrl, appendingParam, browserIds);
+  }
+
+  return testPages;
+}
+
+module.exports = {
+  combineOptionValueIntoArray,
+  getBrowserId,
+  getCustomBaseUrl,
+  getMultipleTestPages,
+  getTestUrlFromTestemConfig
+};
diff --git a/lib/utils/testem-events.js b/lib/utils/testem-events.js
new file mode 100644
index 000000000..6d35788c1
--- /dev/null
+++ b/lib/utils/testem-events.js
@@ -0,0 +1,193 @@
+'use strict';
+
+const fs = require('fs-extra');
+const path = require('path');
+const ExecutionStateManager = require('./execution-state-manager');
+
+/**
+ * A class to coordinate testem events to enable load-balance functionality.
+ *
+ * @class TestemEvents
+ */
+class TestemEvents {
+  constructor(root) {
+    this.stateManager = new ExecutionStateManager();
+    this.root = root;
+  }
+
+  /**
+   * Read the executionFilePath then:
+   * if failed browsers are available, set the module map to the modules from the failed browsers.
+   * else if replay-browser param is passed, set the module map specified browser id
+   * else set module map to all the browser ran, effectively rerunning the same execution
+   *
+   * @param {string} executionFilePath
+   * @param {Array<number>} browserIdsToReplay
+   * @return {Object}
+   */
+  setReplayExecutionMap(executionFilePath, browserIdsToReplay) {
+    const browserModuleMap = new Map();
+    let executionJson;
+
+    try {
+      executionJson = fs.readJsonSync(executionFilePath);
+    } catch (err) {
+      throw new Error(`Error reading reply execution JSON file - ${err}`);
+    }
+
+    if (browserIdsToReplay && browserIdsToReplay.length > 0) {
+      browserIdsToReplay.forEach(browserId => {
+        browserModuleMap.set(
+          browserId,
+          executionJson.executionMapping[browserId]
+        );
+      });
+    } else if (executionJson.failedBrowsers.length > 0) {
+      executionJson.failedBrowsers.forEach(browserId => {
+        browserModuleMap.set(
+          browserId,
+          executionJson.executionMapping[browserId]
+        );
+      });
+    } else {
+      for (let browserId = 1; browserId <= executionJson.numberOfBrowsers; browserId++) {
+        browserModuleMap.set(
+          browserId,
+          executionJson.executionMapping[browserId]
+        );
+      }
+    }
+
+    this.stateManager.setReplayExecutionMap(browserModuleMap);
+  }
+
+  /**
+   * Set the moduleQueue, a list of test modules to be passed to browsers to execute.
+   *
+   * @param {number} browserId
+   * @param {Array<string>} modules
+   * @param {boolean} loadBalance
+   * @param {boolean} replayExecution
+   * @param {string} writeExecutionFile
+   */
+  setModuleQueue(browserId, modules, loadBalance, replayExecution) {
+    const replayExecutionMap = this.stateManager.getReplayExecutionMap();
+
+    if (replayExecution) {
+      if (!replayExecutionMap) {
+        throw new Error('No replay execution map was set on the stateManager.');
+      } else if (!this.stateManager.getBrowserModuleQueue(browserId)) {
+        // Only set the moduleQueue once, ignore repeated requests
+        this.stateManager.setBrowserModuleQueue(
+          replayExecutionMap.get(parseInt(browserId)),
+          browserId
+        );
+      }
+    } else if (loadBalance && !this.stateManager.getSharedModuleQueue()) {
+      // Only set the moduleQueue once, ignore repeated requests
+      this.stateManager.setSharedModuleQueue(modules);
+    }
+  }
+
+  /**
+   * Gets the next test module from the moduleQueue and emit back to the browser.
+   * If moduleQueue is already empty, emit the module-queue-complete event,
+   * signaling no more test module to run.
+   *
+   * @param {number} browserId
+   * @param {Object} socket
+   * @param {boolean} loadBalance
+   * @param {boolean} writeExecutionFile
+   */
+  nextModuleResponse(browserId, socket, writeExecutionFile) {
+    const moduleQueue =
+      this.stateManager.getSharedModuleQueue() ||
+      this.stateManager.getBrowserModuleQueue(browserId);
+    if (!moduleQueue) {
+      throw new Error('No moduleQueue was set.');
+    }
+
+    const moduleName = moduleQueue.shift();
+    socket.emit('testem:next-module-response', {
+      done: !moduleQueue.length && !moduleName,
+      value: moduleName
+    });
+
+    // Keep track of the modules executed per browserId when running test suite with load-balance.
+    // In replay-execution mode, we are already running a predefined set of modules, so no need
+    // to save this again
+    if (moduleName && writeExecutionFile) {
+      this.stateManager.addModuleNameToModuleMap(moduleName, browserId);
+    }
+  }
+
+  /**
+   * Record the failed browserId to the stateManager
+   *
+   * @param {number} browserId
+   */
+  recoredFailedBrowserId(browserId) {
+    if (!this.stateManager.containsFailedBrowser(browserId)) {
+      this.stateManager.addFailedBrowsers(browserId);
+    }
+  }
+
+  /**
+   * Generates an object for test execution
+   *
+   * @param {*} browserCount
+   */
+  _generatesModuleMapJsonObject(browserCount) {
+    return {
+      numberOfBrowsers: browserCount,
+      failedBrowsers: this.stateManager.getFailedBrowsers(),
+      executionMapping: (() => {
+        let executionMapping = Object.create(null);
+        for (const [browserId, moduleList] of this.stateManager.getModuleMap()) {
+          executionMapping[browserId] = moduleList;
+        }
+
+        return executionMapping;
+      })()
+    };
+  }
+
+  /**
+   * Keep track of the number of browsers that completed executing its tests.
+   * When all browsers complete, write test-execution.json to disk and clean up the stateManager
+   *
+   * @param {number} browserCount
+   * @param {Object} ui
+   * @param {boolean} loadBalance
+   * @param {string} fileName
+   * @param {string} writeExecutionFile
+   */
+  completedBrowsersHandler(browserCount, ui, loadBalance, fileName, writeExecutionFile) {
+    let browsersCompleted = false;
+
+    this.stateManager.incrementCompletedBrowsers();
+    if (this.stateManager.completedBrowsers() === browserCount) {
+      if (writeExecutionFile && loadBalance) {
+        const moduleMapJson = this._generatesModuleMapJsonObject(browserCount);
+        const testExecutionPath = path.join(this.root, fileName);
+        try {
+          fs.writeJsonSync(testExecutionPath, moduleMapJson);
+          ui.writeLine(`\nThis execution was recorded at ${fileName}`);
+        } catch (err) {
+          err.file = err.file || testExecutionPath;
+          throw err;
+        }
+      }
+
+      // --server mode allows rerun of tests by refreshing the browser
+      // replayExecutionMap should be reused so the test-execution json
+      // does not need to be reread
+      const replayExecutionMap = this.stateManager.getReplayExecutionMap();
+      this.stateManager = new ExecutionStateManager(replayExecutionMap);
+      browsersCompleted = true;
+    }
+    return browsersCompleted;
+  }
+}
+
+module.exports = TestemEvents;
diff --git a/lib/utils/tests-options-validator.js b/lib/utils/tests-options-validator.js
index a7635931f..d82831cf1 100644
--- a/lib/utils/tests-options-validator.js
+++ b/lib/utils/tests-options-validator.js
@@ -1,95 +1,203 @@
 'use strict';
+
+const fs = require('fs-extra');
+const SilentError = require('silent-error');
+const semver = require('semver');
+
 /**
  * Validates the specified partitions
  *
  * @private
- * @param {Array} partitions
+ * @param {Array<Number>} partitions
  * @param {Number} split
  */
 function validatePartitions(partitions, split) {
   validatePartitionSplit(partitions, split);
-  validatePartitionsUnique(partitions);
+  validateElementsUnique(partitions, 'partition');
+}
+
+/**
+ * Returns thr number of browsers defined within the test execution file.
+ *
+ * @param {*} fileName
+ */
+function getNumberOfBrowser(fileName) {
+  const executionJson = fs.readJsonSync(fileName);
+  return executionJson.numberOfBrowsers;
+}
+
+/**
+ * Validates the specified replay-browser
+ *
+ * @param {String} replayExecution
+ * @param {Array<Number>} replayBrowser
+ */
+function validateReplayBrowser(replayExecution, replayBrowser) {
+  if (!replayExecution) {
+    throw new SilentError(
+      'EmberExam: You must specify replay-execution when using the replay-browser option.'
+    );
+  }
+
+  const numberOfBrowsers = getNumberOfBrowser(replayExecution);
+
+  for (const i in replayBrowser) {
+    const browserId = replayBrowser[i];
+    if (browserId < 1) {
+      throw new SilentError(
+        'EmberExam: You must specify replay-browser values greater than or equal to 1.'
+      );
+    }
+    if (browserId > numberOfBrowsers) {
+      throw new SilentError(
+        'EmberExam: You must specify replayBrowser value smaller than a number of browsers in the specified json file.'
+      );
+    }
+  }
+
+  validateElementsUnique(replayBrowser, 'replayBrowser');
 }
 
 /**
  * Determines if the specified partitions value makes sense for a given split.
  *
  * @private
- * @param {Array} partitions
+ * @param {Array<Number>} partitions
  * @param {Number} split
  */
 function validatePartitionSplit(partitions, split) {
   if (!split) {
-    throw new Error('You must specify a \'split\' value in order to use \'partition\'.');
+    throw new SilentError(
+      'EmberExam: You must specify a `split` value in order to use `partition`.'
+    );
   }
 
   for (let i = 0; i < partitions.length; i++) {
     const partition = partitions[i];
     if (partition < 1) {
-      throw new Error('Split tests are one-indexed, so you must specify partition values greater than or equal to 1.');
+      throw new SilentError(
+        'EmberExam: Split tests are one-indexed, so you must specify partition values greater than or equal to 1.'
+      );
     }
     if (partition > split) {
-      throw new Error('You must specify \'partition\' values that are less than or equal to your \'split\' value.');
+      throw new SilentError(
+        'EmberExam: You must specify `partition` values that are less than or equal to your `split` value.'
+      );
     }
   }
 }
 
 /**
- * Ensures that there is no partition listed twice
+ * Ensures that there is no value duplicated in a given array.
  *
  * @private
- * @param {Array} partitions
+ * @param {Array} arr
+ * @param {String} typeOfValue
  */
-function validatePartitionsUnique(partitions) {
-  partitions = partitions.sort();
-  for (let i = 0; i < partitions.length - 1; i++) {
-    if (partitions[i] === partitions[i + 1]) {
-      throw new Error('You cannot specify the same partition twice.');
+function validateElementsUnique(arr, typeOfValue) {
+  const sorted = arr.slice().sort();
+  for (let i = 0; i < sorted.length - 1; i++) {
+    if (sorted[i] === sorted[i + 1]) {
+      const errorMsg = `EmberExam: You cannot specify the same ${typeOfValue} value twice. ${
+        sorted[i]
+      } is repeated.`;
+      throw new SilentError(errorMsg);
     }
   }
 }
 
-
 /**
  * Performs logic related to validating command options for testing and
  * determining which functions to run on the tests.
  *
  * @class TestsOptionsValidator
  */
-
 module.exports = class TestsOptionsValidator {
-  constructor(options, framework) {
+  constructor(options, framework, emberCliVersion) {
     this.options = options;
     this.framework = framework;
+    this.emberCliVersion = emberCliVersion;
   }
 
   /**
-   * Determines if we should split the tests file and validates associated options
-   * (`split`, `partition`, `weighted`).
+   * Validates the command and returns a map of the options and whether they are enabled or not.
    *
    * @public
-   * @type {Boolean}
+   * @return {Object} Map of the options and whether they are enabled or not.
+   */
+  validateCommands() {
+    const validatedOptions = new Map();
+    if (this.options.split || this.options.partition) {
+      validatedOptions.set('split', this.validateSplit());
+    }
+
+    // The parallel option accepts a number, which can be 0
+    if (this.options.parallel !== undefined) {
+      validatedOptions.set('parallel', this.validateParallel());
+    }
+
+    // As random option can be an empty string it should check a type of random option rather than the option is not empty.
+    if (typeof this.options.random !== 'undefined') {
+      validatedOptions.set('random', this.validateRandom());
+    }
+
+    if (typeof this.options.writeExecutionFile !== 'undefined') {
+      validatedOptions.set(
+        'writeExecutionFile',
+        this.validateWriteExecutionFile()
+      );
+    }
+
+    if (this.options.loadBalance) {
+      validatedOptions.set('loadBalance', this.validateLoadBalance());
+    }
+
+    if (this.options.replayExecution || this.options.replayBrowser) {
+      validatedOptions.set('replayExecution', this.validateReplayExecution());
+    }
+
+    return validatedOptions;
+  }
+
+  /**
+   * Determines if we should split the tests file and validates associated options
+   * (`split`, `partition`).
+   *
+   * @return {boolean}
    */
-  get shouldSplit() {
+  validateSplit() {
     const options = this.options;
     let split = options.split;
 
     if (typeof split !== 'undefined' && split < 2) {
       // eslint-disable-next-line no-console
-      console.warn('You should specify a number of files greater than 1 to split your tests across. Defaulting to 1 split which is the same as not using `--split`.');
+      console.warn(
+        'You should specify a number of files greater than 1 to split your tests across. Defaulting to 1 split which is the same as not using `split`.'
+      );
       split = 1;
     }
 
+    if (
+      typeof split !== 'undefined' &&
+      typeof this.options.replayBrowser !== 'undefined'
+    ) {
+      throw new SilentError(
+        'EmberExam: You must not use the `replay-browser` option with the `split` option.'
+      );
+    }
+
+    if (typeof split !== 'undefined' && this.options.replayExecution) {
+      throw new SilentError(
+        'EmberExam: You must not use the `replay-execution` option with the `split` option.'
+      );
+    }
+
     const partitions = options.partition;
 
     if (typeof partitions !== 'undefined') {
       validatePartitions(partitions, split);
     }
 
-    if (options.weighted && !split) {
-      throw new Error('You used the \'weighted\' option but are not splitting your tests.');
-    }
-
     return !!split;
   }
 
@@ -97,36 +205,150 @@ module.exports = class TestsOptionsValidator {
    * Determines if we should randomize the tests and validates associated options
    * (`random`).
    *
-   * @public
-   * @type {Boolean}
+   * @return {boolean}
    */
-  get shouldRandomize() {
-    var shouldRandomize = (typeof this.options.random === 'string');
+  validateRandom() {
+    const shouldRandomize = typeof this.options.random === 'string';
 
     if (shouldRandomize && this.framework === 'mocha') {
       // eslint-disable-next-line no-console
-      console.warn('Mocha does not currently support randomizing test order, so tests will run in normal order. Please see https://github.com/mochajs/mocha/issues/902 for more info.');
+      console.warn(
+        'Mocha does not currently support randomizing test order, so tests will run in normal order. Please see https://github.com/mochajs/mocha/issues/902 for more info.'
+      );
     }
 
     return shouldRandomize;
   }
 
+  /**
+   * Determines if a test execution json file should be written after running a test suite and validates associated
+   *
+   *  @return {boolean}
+   */
+  validateWriteExecutionFile() {
+    if (!this.options.writeExecutionFile) {
+      return false;
+    }
+
+    if (!this.options.loadBalance) {
+      throw new SilentError(
+        'EmberExam: You must run test suite with the `load-balance` option in order to use the `write-execution-file` option.'
+      );
+    } else if (this.options.launch === 'false') {
+      //When `--no-launch` option is passed, a value for launch in testem config is set to be string false.
+      throw new SilentError(
+        'EmberExam: You must not use no-launch with write-execution-file option.'
+      );
+    }
+
+    return true;
+  }
+
   /**
    * Determines if we should run split tests in parallel and validates associated
    * options (`parallel`).
    *
-   * @public
-   * @type {Boolean}
+   * @return {boolean}
    */
-  get shouldParallelize() {
-    const parallel = this.options.parallel;
+  validateParallel() {
+    if (typeof this.options.replayBrowser !== 'undefined') {
+      throw new SilentError(
+        'EmberExam: You must not use the `replay-browser` option with the `parallel` option.'
+      );
+    }
+
+    if (this.options.replayExecution) {
+      throw new SilentError(
+        'EmberExam: You must not use the `replay-execution` option with the `parallel` option.'
+      );
+    }
+
+    if (!this.options.loadBalance) {
+      if (!this.options.split) {
+        throw new SilentError(
+          'EmberExam: You must specify the `split` option in order to run your tests in parallel.'
+        );
+      } else if (this.options.parallel !== 1) {
+        throw new SilentError(
+          'EmberExam: When used with `split` or `partition`, `parallel` does not accept a value other than 1.'
+        );
+      }
+    }
+
+    if (this.options.parallel < 1) {
+      throw new SilentError(
+        'EmberExam: You must specify a value greater than 1 to `parallel`.'
+      );
+    }
+
+    return true;
+  }
 
-    if (!parallel) {
+  /**
+   * Determines if we should run tests in load balance mode.
+   * options (`load-balance`).
+   *
+   * @return {boolean}
+   */
+  validateLoadBalance() {
+    // It's required to use ember-cli version 3.2.0 or greater to support the `load-balance` feature.
+    const emberCliVersionRange = semver.validRange(this.emberCliVersion);
+    if (semver.gtr('3.2.0', emberCliVersionRange)) {
+      throw new SilentError(
+        'EmberExam: You must be using ember-cli version ^3.2.0 for this feature to work properly.'
+      );
+    }
+
+    if (typeof this.options.replayBrowser !== 'undefined') {
+      throw new SilentError(
+        'EmberExam: You must not use the `replay-browser` option with the `load-balance` option.'
+      );
+    }
+
+    if (this.options.replayExecution) {
+      throw new SilentError(
+        'EmberExam: You must not use the `replay-execution` option with the `load-balance` option.'
+      );
+    }
+
+    //When `--no-launch` option is passed, a value for launch in testem config is set to be string false.
+    if (this.options.launch === 'false') {
+      throw new SilentError(
+        'EmberExam: You must not use `no-launch` option with the `load-balance` option.'
+      );
+    }
+
+    if (!this.options.parallel) {
+      throw new SilentError(
+        'EmberExam: You should specify the number of browsers to load-balance against using `parallel` when using `load-balance`.'
+      );
+    }
+
+    return true;
+  }
+
+  /**
+   * Determines if we should replay execution for reproduction.
+   * options (`replay-execution`).
+   *
+   * @return {boolean}
+   */
+  validateReplayExecution() {
+    const replayBrowser = this.options.replayBrowser;
+    const replayExecution = this.options.replayExecution;
+
+    if (!replayExecution) {
       return false;
     }
 
-    if (!this.shouldSplit) {
-      throw new Error('You must specify the `split` option in order to run your tests in parallel.');
+    if (this.options.launch === 'false') {
+      throw new SilentError(
+        'EmberExam: You must not use `no-launch` option with the `replay-execution` option.'
+      );
+    }
+
+    if (replayBrowser) {
+      validateReplayBrowser(replayExecution, replayBrowser, this.options);
     }
 
     return true;
diff --git a/node-tests/acceptance/exam-iterate-test.js b/node-tests/acceptance/exam-iterate-test.js
index ee4d6baf1..589b575d9 100644
--- a/node-tests/acceptance/exam-iterate-test.js
+++ b/node-tests/acceptance/exam-iterate-test.js
@@ -16,33 +16,62 @@ describe('Acceptance | Exam Iterate Command', function() {
   it('should build the app, test it a number of times, and clean it up', function() {
     return execa('ember', ['exam:iterate', '2'], child => {
       const stdout = child.stdout;
-      assert.ok(stdout.includes('Building app for test iterations.'), 'Logged building message from command');
-      assert.ok(stdout.includes('Built project successfully.'), 'Built successfully according to Ember-CLI');
-
-      assert.ok(stdout.includes('Running iteration #1.'), 'Logs first iteration');
-      assert.ok(stdout.includes('Running iteration #2.'), 'Logs second iteration');
-
-      var seedRE = /Randomizing tests with seed: (.*)/g;
-
-      var firstSeed = seedRE.exec(stdout)[1];
-      var secondSeed = seedRE.exec(stdout)[1];
+      assert.ok(
+        stdout.includes('Building app for test iterations.'),
+        'Logged building message from command'
+      );
+      assert.ok(
+        stdout.includes('Built project successfully.'),
+        'Built successfully according to Ember-CLI'
+      );
+
+      assert.ok(
+        stdout.includes('Running iteration #1.'),
+        'Logs first iteration'
+      );
+      assert.ok(
+        stdout.includes('Running iteration #2.'),
+        'Logs second iteration'
+      );
+
+      const seedRE = /Randomizing tests with seed: (.*)/g;
+
+      const firstSeed = seedRE.exec(stdout)[1];
+      const secondSeed = seedRE.exec(stdout)[1];
 
       assert.ok(firstSeed, 'first seed exists');
       assert.ok(secondSeed, 'second seed exists');
-      assert.notEqual(firstSeed, secondSeed, 'the first and second seeds are not the same');
-
-      assert.ok(stdout.includes('Cleaning up test iterations.'), 'Logged cleaning up message from command');
-      assert.throws(() => fs.accessSync('iteration-dist', fs.F_OK), 'iteration-dist is cleaned up');
+      assert.notEqual(
+        firstSeed,
+        secondSeed,
+        'the first and second seeds are not the same'
+      );
+
+      assert.ok(
+        stdout.includes('Cleaning up test iterations.'),
+        'Logged cleaning up message from command'
+      );
+      assert.throws(
+        () => fs.accessSync('iteration-dist', fs.F_OK),
+        'iteration-dist is cleaned up'
+      );
     });
   });
 
   it('should test the app with additional options passed in and catch failure cases', function() {
-    const execution = execa('ember', ['exam:iterate', '2' ,'--options' ,'--parallel']);
-
+    const execution = execa('ember', [
+      'exam:iterate',
+      '2',
+      '--options',
+      '--parallel'
+    ]);
     return execution.then(assertExpectRejection, error => {
       const splitErrorRE = /You must specify the `split` option in order to run your tests in parallel./g;
 
-      assert.ok(splitErrorRE.test(error.stderr), 'expected stderr to contain the appropriate error message');
+      assert.ok(
+        splitErrorRE.test(error.stderr),
+        'expected stderr to contain the appropriate error message'
+      );
       assert.equal(error.code, 1);
       assert.equal(error.failed, true);
       assert.equal(error.killed, false);
@@ -57,37 +86,76 @@ describe('Acceptance | Exam Iterate Command', function() {
     it('should not build the app or clean it up, but use an existing build to test', function() {
       execa.sync('ember', ['build']);
 
-      return execa('ember', ['exam:iterate', '2', '--path', 'dist']).then(child => {
-        const stdout = child.stdout;
-
-        assert.ok(!stdout.includes('Building app for test iterations.'), 'No logged building message from command');
-        assert.ok(!stdout.includes('Built project successfully.'), 'Not built successfully according to Ember-CLI');
-
-        assert.ok(stdout.includes('Running iteration #1.'), 'Logs first iteration');
-        assert.ok(stdout.includes('Running iteration #2.'), 'Logs second iteration');
-
-        var seedRE = /Randomizing tests with seed: (.*)/g;
-
-        var firstSeed = seedRE.exec(stdout)[1];
-        var secondSeed = seedRE.exec(stdout)[1];
-
-        assert.ok(firstSeed, 'first seed exists');
-        assert.ok(secondSeed, 'second seed exists');
-        assert.notEqual(firstSeed, secondSeed, 'the first and second seeds are not the same');
-
-        assert.ok(!stdout.includes('Cleaning up test iterations.'), 'No logged cleaning up message from command');
-        assert.throws(() => fs.accessSync('iteration-dist', fs.F_OK), 'iteration-dist is non-existent');
-
-        assert.doesNotThrow(() => fs.accessSync(buildDir, fs.F_OK), 'dist is not cleaned up');
-      });
+      return execa('ember', ['exam:iterate', '2', '--path', 'dist']).then(
+        child => {
+          const stdout = child.stdout;
+
+          assert.ok(
+            !stdout.includes('Building app for test iterations.'),
+            'No logged building message from command'
+          );
+          assert.ok(
+            !stdout.includes('Built project successfully.'),
+            'Not built successfully according to Ember-CLI'
+          );
+
+          assert.ok(
+            stdout.includes('Running iteration #1.'),
+            'Logs first iteration'
+          );
+          assert.ok(
+            stdout.includes('Running iteration #2.'),
+            'Logs second iteration'
+          );
+
+          const seedRE = /Randomizing tests with seed: (.*)/g;
+
+          const firstSeed = seedRE.exec(stdout)[1];
+          const secondSeed = seedRE.exec(stdout)[1];
+
+          assert.ok(firstSeed, 'first seed exists');
+          assert.ok(secondSeed, 'second seed exists');
+          assert.notEqual(
+            firstSeed,
+            secondSeed,
+            'the first and second seeds are not the same'
+          );
+
+          assert.ok(
+            !stdout.includes('Cleaning up test iterations.'),
+            'No logged cleaning up message from command'
+          );
+          assert.throws(
+            () => fs.accessSync('iteration-dist', fs.F_OK),
+            'iteration-dist is non-existent'
+          );
+
+          assert.doesNotThrow(
+            () => fs.accessSync(buildDir, fs.F_OK),
+            'dist is not cleaned up'
+          );
+        }
+      );
     });
   });
 
   describe('Exit Code', function() {
-    const destPath = path.join(__dirname, '..', '..', 'tests', 'unit', 'failing-test.js');
+    const destPath = path.join(
+      __dirname,
+      '..',
+      '..',
+      'tests',
+      'unit',
+      'failing-test.js'
+    );
 
     beforeEach(function() {
-      const failingTestPath = path.join(__dirname, '..', 'fixtures', 'failure.js');
+      const failingTestPath = path.join(
+        __dirname,
+        '..',
+        'fixtures',
+        'failure.js'
+      );
       fs.copySync(failingTestPath, destPath);
     });
 
@@ -96,10 +164,13 @@ describe('Acceptance | Exam Iterate Command', function() {
     });
 
     it('should have an exitCode of 1 when a test fails', function() {
-      return execa('ember', ['exam:iterate','1']).then(assertExpectRejection, error => {
-        assert.equal(error.code, 1);
-        assert.equal(error.killed, false);
-      });
+      return execa('ember', ['exam:iterate', '1']).then(
+        assertExpectRejection,
+        error => {
+          assert.equal(error.code, 1);
+          assert.equal(error.killed, false);
+        }
+      );
     });
   });
 });
diff --git a/node-tests/acceptance/exam-test.js b/node-tests/acceptance/exam-test.js
index aa15155ee..31770581c 100644
--- a/node-tests/acceptance/exam-test.js
+++ b/node-tests/acceptance/exam-test.js
@@ -1,8 +1,11 @@
 'use strict';
 
 const assert = require('assert');
-const rimraf = require('rimraf');
 const execa = require('execa');
+const fixturify = require('fixturify');
+const fs = require('fs-extra');
+const path = require('path');
+const rimraf = require('rimraf');
 
 function assertExpectRejection() {
   assert.ok(false, 'Expected promise to reject, but it fullfilled');
@@ -13,14 +16,16 @@ function getNumberOfTests(str) {
   return match && parseInt(match[1], 10);
 }
 
-const TOTAL_NUM_TESTS = 33; // Total Number of tests without the global "Ember.onerror validation tests"
+const TOTAL_NUM_TESTS = 47; // Total Number of tests without the global 'Ember.onerror validation tests'
 
 function getTotalNumberOfTests(output) {
   // In ember-qunit 3.4.0, this new check was added: https://github.com/emberjs/ember-qunit/commit/a7e93c4b4b535dae62fed992b46c00b62bfc83f4
   // which adds this Ember.onerror validation test.
   // As Ember.onerror validation test is added per browser the total number of tests executed should be the sum of TOTAL_NUM_TESTS defined and a number of browsers.
-  const emberOnerror = output.match(/ember-qunit: Ember.onerror validation: Ember.onerror is functioning properly/g)
-  return TOTAL_NUM_TESTS + (emberOnerror? emberOnerror.length : 0);
+  const emberOnerror = output.match(
+    /ember-qunit: Ember.onerror validation: Ember.onerror is functioning properly/g
+  );
+  return TOTAL_NUM_TESTS + (emberOnerror ? emberOnerror.length : 0);
 }
 
 describe('Acceptance | Exam Command', function() {
@@ -38,76 +43,156 @@ describe('Acceptance | Exam Command', function() {
     rimraf.sync('acceptance-dist');
   });
 
-  function assertPartitions(output, good, bad) {
+  function assertOutput(output, text, good, bad) {
     good.forEach(function(partition) {
-      assert.ok(output.includes('Exam Partition ' + partition + ' '), 'output has Partition ' + partition);
+      assert.ok(
+        output.includes(`${text} ${partition} `),
+        `output has ${text} ${partition}`
+      );
     });
 
     (bad || []).forEach(function(partition) {
-      assert.ok(!output.includes('Exam Partition ' + partition + ' '), 'output does not have Partition ' + partition);
+      assert.ok(
+        !output.includes(`${text} ${partition} `),
+        `output does not have ${text} ${partition}`
+      );
     });
   }
 
   function assertAllPartitions(output) {
-    assertPartitions(output, [1, 2, 3]);
-    assert.equal(getNumberOfTests(output), getTotalNumberOfTests(output), 'ran all of the tests in the suite');
+    assertOutput(output, 'Exam Partition', [1, 2, 3]);
+    assert.equal(
+      getNumberOfTests(output),
+      getTotalNumberOfTests(output),
+      'ran all of the tests in the suite'
+    );
   }
 
   function assertSomePartitions(output, good, bad) {
-    assertPartitions(output, good, bad);
-    assert.ok(getNumberOfTests(output) < getTotalNumberOfTests(output), 'did not run all of the tests in the suite');
+    assertOutput(output, 'Exam Partition', good, bad);
+    assert.ok(
+      getNumberOfTests(output) < getTotalNumberOfTests(output),
+      'did not run all of the tests in the suite'
+    );
   }
 
   it('runs all tests normally', function() {
     return execa('ember', ['exam', '--path', 'acceptance-dist']).then(child => {
       const stdout = child.stdout;
-      assert.ok(!stdout.includes('Exam Partition'), 'does not add any sort of partition info');
-      assert.equal(getNumberOfTests(stdout), getTotalNumberOfTests(stdout), 'ran all of the tests in the suite');
+      assert.ok(
+        !stdout.includes('Exam Partition'),
+        'does not add any sort of partition info'
+      );
+      assert.equal(
+        getNumberOfTests(stdout),
+        getTotalNumberOfTests(stdout),
+        'ran all of the tests in the suite'
+      );
     });
   });
 
   describe('Split', function() {
     it('splits the test suite but only runs the first partition', function() {
-      return execa('ember', ['exam', '--split', '3', '--path', 'acceptance-dist']).then(child => {
+      return execa('ember', [
+        'exam',
+        '--split',
+        '3',
+        '--path',
+        'acceptance-dist'
+      ]).then(child => {
         assertSomePartitions(child.stdout, [1], [2, 3]);
       });
     });
 
     describe('Partition', function() {
       it('splits the test suite and runs a specified partition', function() {
-        return execa('ember', ['exam', '--split', '3', '--partition', '2', '--path', 'acceptance-dist']).then(child => {
+        return execa('ember', [
+          'exam',
+          '--split',
+          '3',
+          '--partition',
+          '2',
+          '--path',
+          'acceptance-dist'
+        ]).then(child => {
           assertSomePartitions(child.stdout, [2], [1, 3]);
         });
       });
 
       it('splits the test suite and runs multiple specified partitions', function() {
-        return execa('ember', ['exam', '--split', '3', '--partition', '1', '--partition', '3', '--path', 'acceptance-dist']).then(child => {
+        return execa('ember', [
+          'exam',
+          '--split',
+          '3',
+          '--partition',
+          '1,3',
+          '--path',
+          'acceptance-dist'
+        ]).then(child => {
           assertSomePartitions(child.stdout, ['1,3'], [1, 2, 3]);
         });
       });
 
       it('errors when running an invalid partition', function() {
-        return execa('ember', ['exam', '--split', '3','--partition', '4', '--path', 'acceptance-dist']).then(assertExpectRejection, error => {
-          assert.ok(error.message.includes('You must specify \'partition\' values that are less than or equal to your \'split\' value.'));
+        return execa('ember', [
+          'exam',
+          '--split',
+          '3',
+          '--partition',
+          '4',
+          '--path',
+          'acceptance-dist'
+        ]).then(assertExpectRejection, error => {
+          assert.ok(
+            error.message.includes(
+              'You must specify `partition` values that are less than or equal to your `split` value.'
+            )
+          );
         });
       });
 
       it('errors when specifying a partition but no split count', function() {
-        return execa('ember', ['exam', '--partition', '2', '--path', 'acceptance-dist']).then(assertExpectRejection, error => {
-          assert.ok(error.message.includes('You must specify a \'split\' value in order to use \'partition\'.'));
+        return execa('ember', [
+          'exam',
+          '--partition',
+          '2',
+          '--path',
+          'acceptance-dist'
+        ]).then(assertExpectRejection, error => {
+          assert.ok(
+            error.message.includes(
+              'You must specify a `split` value in order to use `partition`.'
+            )
+          );
         });
       });
     });
 
     describe('Parallel', function() {
       it('runs multiple partitions in parallel', function() {
-        return execa('ember', ['exam', '--split', '3', '--parallel', '--path', 'acceptance-dist']).then(child => {
+        return execa('ember', [
+          'exam',
+          '--path',
+          'acceptance-dist',
+          '--split',
+          '3',
+          '--parallel'
+        ]).then(child => {
           assertAllPartitions(child.stdout);
         });
       });
 
       it('runs multiple specified partitions in parallel', function() {
-        return execa('ember', ['exam', '--split', '3', '--parallel', '--partition', '1', '--partition', '3', '--path', 'acceptance-dist']).then(child => {
+        return execa('ember', [
+          'exam',
+          '--split',
+          '3',
+          '--partition',
+          '1,3',
+          '--path',
+          'acceptance-dist',
+          '--parallel'
+        ]).then(child => {
           assertSomePartitions(child.stdout, [1, 3], [2]);
         });
       });
@@ -116,10 +201,290 @@ describe('Acceptance | Exam Command', function() {
 
   describe('Random', function() {
     it('runs tests with the passed in seeds', function() {
-      return execa('ember', ['exam', '--random', '1337', '--path', 'acceptance-dist']).then(child => {
+      return execa('ember', [
+        'exam',
+        '--random',
+        '1337',
+        '--path',
+        'acceptance-dist'
+      ]).then(child => {
         const stdout = child.stdout;
-        assert.ok(stdout.includes('Randomizing tests with seed: 1337'), 'logged the seed value');
-        assert.equal(getNumberOfTests(stdout), getTotalNumberOfTests(stdout), 'ran all of the tests in the suite');
+        assert.ok(
+          stdout.includes('Randomizing tests with seed: 1337'),
+          'logged the seed value'
+        );
+        assert.equal(
+          getNumberOfTests(stdout),
+          getTotalNumberOfTests(stdout),
+          'ran all of the tests in the suite'
+        );
+      });
+    });
+  });
+
+  describe('Load Balance', function() {
+    const unlinkFiles = [];
+
+    function assertTestExecutionJson(output) {
+      let testExecutionJsonPath = path.join(
+        process.cwd(),
+        output.match(/test-execution-([0-9]*).json/g)[0]
+      );
+      assert.ok(
+        fs.existsSync(testExecutionJsonPath),
+        'test execution json written to root'
+      );
+      unlinkFiles.push(testExecutionJsonPath);
+    }
+
+    afterEach(() => {
+      unlinkFiles.forEach(path => {
+        fs.unlinkSync(path);
+      });
+
+      unlinkFiles.length = 0;
+    });
+
+    it('errors if `--parallel` is not passed', function() {
+      return execa('ember', [
+        'exam',
+        '--path',
+        'acceptance-dist',
+        '--load-balance'
+      ]).then(assertExpectRejection, error => {
+        assert.ok(
+          error.message.includes(
+            'You should specify the number of browsers to load-balance against using `parallel` when using `load-balance`.'
+          )
+        );
+      });
+    });
+
+    it('load balances the test suite with one browser', function() {
+      return execa('ember', [
+        'exam',
+        '--path',
+        'acceptance-dist',
+        '--write-execution-file',
+        '--load-balance',
+        '--parallel'
+      ]).then(child => {
+        const output = child.stdout;
+        assertTestExecutionJson(output);
+        assertOutput(output, 'Browser Id', [1]);
+        assert.equal(
+          getNumberOfTests(output),
+          getTotalNumberOfTests(output),
+          'ran all of the tests in the suite'
+        );
+      });
+    });
+
+    it('load balances the test suite with 3 browsers', function() {
+      return execa('ember', [
+        'exam',
+        '--path',
+        'acceptance-dist',
+        '--load-balance',
+        '--parallel',
+        '3',
+        '--write-execution-file'
+      ]).then(child => {
+        const output = child.stdout;
+        assertTestExecutionJson(output);
+        assertOutput(output, 'Browser Id', [1, 2, 3]);
+        assert.equal(
+          getNumberOfTests(output),
+          getTotalNumberOfTests(output),
+          'ran all of the tests in the suite'
+        );
+      });
+    });
+
+    it('load balances partition 1\'s test suite with 3 browsers', function() {
+      return execa('ember', [
+        'exam',
+        '--path',
+        'acceptance-dist',
+        '--load-balance',
+        '--split',
+        '2',
+        '--partition',
+        '1',
+        '--parallel',
+        '3',
+        '--write-execution-file'
+      ]).then(child => {
+        const output = child.stdout;
+        assertTestExecutionJson(output);
+        assertOutput(output, 'Exam Partition', [1], [2]);
+        assertOutput(output, 'Browser Id', [1, 2, 3]);
+        assert.ok(
+          getNumberOfTests(output) < getTotalNumberOfTests(output),
+          'did not run all of the tests in the suite'
+        );
+      });
+    });
+
+    describe('Failure Cases', function() {
+      const destPath = path.join(
+        __dirname,
+        '..',
+        '..',
+        'tests',
+        'unit',
+        'browser-exit-test.js'
+      );
+      beforeEach(function() {
+        const failingTestPath = path.join(
+          __dirname,
+          '..',
+          'fixtures',
+          'browser-exit.js'
+        );
+        fs.copySync(failingTestPath, destPath);
+        return execa('ember', ['build', '--output-path', 'failure-dist']);
+      });
+
+      afterEach(function() {
+        rimraf.sync('failure-dist');
+        fs.removeSync(destPath);
+      });
+
+      it('should write test-execution json when browser exits', function() {
+        return execa('ember', [
+          'exam',
+          '--path',
+          'failure-dist',
+          '--load-balance',
+          '--parallel',
+          '2',
+          '--write-execution-file'
+        ]).then(assertExpectRejection, error => {
+          assert.ok(
+            error.message.includes(
+              'Error: Browser exited on request from test driver'
+            ),
+            `browser exited during the test execution:\n${error.message}`
+          );
+          assertTestExecutionJson(error.message);
+        });
+      });
+    });
+  });
+
+  describe('Replay Execution', function() {
+    let testExecutionJson = {};
+
+    beforeEach(() => {
+      testExecutionJson = {
+        numberOfBrowsers: 2,
+        failedBrowsers: [],
+        executionMapping: {
+          '1': [
+            'ember-test',
+            'dummy/tests/unit/qunit/test-loader-test',
+            'dummy/tests/unit/qunit/multiple-edge-cases-test',
+            'dummy/tests/unit/qunit/multiple-ember-tests-test'
+          ],
+          '2': [
+            'dummy/tests/unit/qunit/multiple-tests-test',
+            'dummy/tests/unit/qunit/testem-output-test',
+            'dummy/tests/unit/qunit/weight-test-modules-test',
+            'dummy/tests/unit/qunit/async-iterator-test'
+          ]
+        }
+      };
+    });
+
+    afterEach(() => {
+      fs.unlinkSync(path.join(process.cwd(), 'test-execution-123.json'));
+    });
+
+    it('replay only the failed browsers defined in failedBrowsers array', function() {
+      testExecutionJson.failedBrowsers.push(1);
+      fixturify.writeSync(process.cwd(), {
+        'test-execution-123.json': JSON.stringify(testExecutionJson)
+      });
+
+      return execa('ember', [
+        'exam',
+        '--replay-execution',
+        'test-execution-123.json',
+        '--path',
+        'acceptance-dist'
+      ]).then(child => {
+        const output = child.stdout;
+        assert.equal(
+          output.match(/test-execution-([0-9]*).json/g),
+          null,
+          'no test execution json should be written'
+        );
+
+        assertOutput(output, 'Browser Id', [1]);
+        assert.equal(
+          getNumberOfTests(output),
+          26,
+          'ran all of the tests for browser one'
+        );
+      });
+    });
+
+    it('replay the full execution if failedBrowsers is empty', function() {
+      fixturify.writeSync(process.cwd(), {
+        'test-execution-123.json': JSON.stringify(testExecutionJson)
+      });
+
+      return execa('ember', [
+        'exam',
+        '--replay-execution',
+        'test-execution-123.json',
+        '--path',
+        'acceptance-dist'
+      ]).then(child => {
+        const output = child.stdout;
+        assert.equal(
+          output.match(/test-execution-([0-9]*).json/g),
+          null,
+          'no test execution json should be written'
+        );
+
+        assertOutput(output, 'Browser Id', [1, 2]);
+        assert.equal(
+          getNumberOfTests(output),
+          getTotalNumberOfTests(output),
+          'ran all of the tests in the suite'
+        );
+      });
+    });
+
+    it('replay only the specified execution by --replay-browser', function() {
+      fixturify.writeSync(process.cwd(), {
+        'test-execution-123.json': JSON.stringify(testExecutionJson)
+      });
+
+      return execa('ember', [
+        'exam',
+        '--replay-execution',
+        'test-execution-123.json',
+        '--replay-browser',
+        '2',
+        '--path',
+        'acceptance-dist'
+      ]).then(child => {
+        const output = child.stdout;
+        assert.equal(
+          output.match(/test-execution-([0-9]*).json/g),
+          null,
+          'no test execution json should be written'
+        );
+
+        assertOutput(output, 'Browser Id', [2]);
+        assert.equal(
+          getNumberOfTests(output),
+          23,
+          'ran all of the tests for browser two'
+        );
       });
     });
   });
diff --git a/node-tests/fixtures/browser-exit.js b/node-tests/fixtures/browser-exit.js
new file mode 100644
index 000000000..21f9bdd47
--- /dev/null
+++ b/node-tests/fixtures/browser-exit.js
@@ -0,0 +1,12 @@
+import { module, test } from 'qunit';
+
+module('Module With Infinite Loop');
+
+test('Infinite loop test #1', function(assert) {
+  assert.expect(1);
+  let condition = true;
+  while (condition) {
+    condition = condition || true;
+  }
+  assert.ok(true);
+});
diff --git a/node-tests/unit/commands/exam-test.js b/node-tests/unit/commands/exam-test.js
index 578638e22..3332d31a4 100644
--- a/node-tests/unit/commands/exam-test.js
+++ b/node-tests/unit/commands/exam-test.js
@@ -1,22 +1,30 @@
-var assert = require('assert');
-var MockProject = require('ember-cli/tests/helpers/mock-project');
-var Task = require('ember-cli/lib/models/task');
-var RSVP = require('rsvp');
-var sinon = require('sinon');
+'use strict';
 
-var ExamCommand = require('../../../lib/commands/exam');
-var TestOptionsValidator = require('../../../lib/utils/tests-options-validator');
+const assert = require('assert');
+const MockProject = require('ember-cli/tests/helpers/mock-project');
+const Task = require('ember-cli/lib/models/task');
+const RSVP = require('rsvp');
+const sinon = require('sinon');
+
+const ExamCommand = require('../../../lib/commands/exam');
 
 describe('ExamCommand', function() {
   function createCommand() {
-    var tasks = {
+    const tasks = {
       Build: Task.extend(),
       Test: Task.extend()
     };
 
-    var project = new MockProject();
+    const project = new MockProject();
 
-    project.isEmberCLIProject = function() { return true; };
+    project.isEmberCLIProject = function() {
+      return true;
+    };
+    project.pkg = {
+      devDependencies: {
+        'ember-cli': '3.7.0'
+      }
+    };
 
     return new ExamCommand({
       project: project,
@@ -28,8 +36,8 @@ describe('ExamCommand', function() {
   }
 
   describe('run', function() {
-    var command;
-    var called;
+    let command;
+    let called;
 
     beforeEach(function() {
       command = createCommand();
@@ -55,62 +63,77 @@ describe('ExamCommand', function() {
       });
     });
 
-    it('should set \'partition\' on the query option with one partition', function() {
+    it('should set `partition` in the query option with one partition', function() {
       return command.run({ split: 2, partition: [2] }).then(function() {
-        assert.equal(called.testRunOptions.query, '_split=2&_partition=2');
+        assert.equal(called.testRunOptions.query, 'split=2&partition=2');
       });
     });
 
-    it('should set \'partition\' on the query option with multiple partitions', function() {
-      return command.run({ split: 2, partition: [1, 2] }).then(function() {
-        assert.equal(called.testRunOptions.query, '_split=2&_partition=1&_partition=2');
+    it('should set `load-balance` in the query option', function() {
+      return command.run({ loadBalance: true, parallel: 1 }).then(function() {
+        assert.equal(called.testRunOptions.query, 'loadBalance');
       });
     });
 
-    it('should append \'partition\' to the query option', function() {
-      return command.run({ split: 2, partition: [2], query: 'someQuery=derp&hidepassed' }).then(function() {
-        assert.equal(called.testRunOptions.query, 'someQuery=derp&hidepassed&_split=2&_partition=2');
+    it('should set `partition` in the query option with multiple partitions', function() {
+      return command.run({ split: 2, partition: [1, 2] }).then(function() {
+        assert.equal(
+          called.testRunOptions.query,
+          'split=2&partition=1&partition=2'
+        );
       });
     });
 
-    it('should not append \'partition\' to the query option when parallelizing', function() {
-      return command.run({ split: 2, partition: [1, 2], parallel: true }).then(function() {
-        assert.equal(called.testRunOptions.query, '_split=2');
-      });
+    it('should append `partition` to the query option', function() {
+      return command
+        .run({ split: 2, partition: [2], query: 'someQuery=derp&hidepassed' })
+        .then(function() {
+          assert.equal(
+            called.testRunOptions.query,
+            'someQuery=derp&hidepassed&split=2&partition=2'
+          );
+        });
     });
 
-    it('should not append \'partition\' to the query option when not parallelizing without partitions', function() {
+    it('should not append `partition` to the query option when parallelizing', function() {
+      return command
+        .run({ split: 2, partition: [1, 2], parallel: 1 })
+        .then(function() {
+          assert.equal(called.testRunOptions.query, 'split=2');
+        });
+    });
+
+    it('should not append `partition` to the query option when not parallelizing without partitions', function() {
       return command.run({ split: 2 }).then(function() {
-        assert.equal(called.testRunOptions.query, '_split=2');
+        assert.equal(called.testRunOptions.query, 'split=2');
       });
     });
 
-    it('should set \'seed=1337\' on the query option', function() {
+    it('should set  `seed=1337` in the query option', function() {
       return command.run({ random: '1337' }).then(function() {
         assert.equal(called.testRunOptions.query, 'seed=1337');
       });
     });
 
-    it('should append \'seed=1337\' to the query option', function() {
-      return command.run({ random: '1337', query: 'someQuery=derp&hidepassed' }).then(function() {
-        assert.equal(called.testRunOptions.query, 'someQuery=derp&hidepassed&seed=1337');
-      });
+    it('should append `seed=1337` to the query option', function() {
+      return command
+        .run({ random: '1337', query: 'someQuery=derp&hidepassed' })
+        .then(function() {
+          assert.equal(
+            called.testRunOptions.query,
+            'someQuery=derp&hidepassed&seed=1337'
+          );
+        });
     });
 
-    it('should set \'seed=random_seed\' on the query option', function() {
-      var randomStub = sinon.stub(Math, 'random').returns('  random_seed');
+    it('should set `seed=random_seed` in the query option', function() {
+      const randomStub = sinon.stub(Math, 'random').returns('  random_seed');
       return command.run({ random: '' }).then(function() {
         assert.equal(called.testRunOptions.query, 'seed=random_seed');
         randomStub.restore();
       });
     });
 
-    it('should set \'weighted\' on the query option', function() {
-      return command.run({ split: 2, partition: [2], weighted: true }).then(function() {
-        assert.equal(called.testRunOptions.query, '_split=2&_partition=2&_weighted');
-      });
-    });
-
     it('should set split env var', function() {
       return command.run({ split: 5 }).then(function() {
         assert.equal(process.env.EMBER_EXAM_SPLIT_COUNT, '5');
@@ -118,129 +141,8 @@ describe('ExamCommand', function() {
     });
   });
 
-  describe('_generateCustomConfigs', function() {
-    function generateConfig(options) {
-      var project = new MockProject();
-
-      project.isEmberCLIProject = function() { return true; };
-
-      var command = new ExamCommand({
-        project: project
-      });
-
-      command.validator = new TestOptionsValidator(options);
-
-      return command._generateCustomConfigs(options);
-    }
-
-    it('should have a null test page when not parallelizing', function() {
-      var config = generateConfig({});
-
-      assert.deepEqual(config.testPage, undefined);
-    });
-
-    it('should modify the config to have multiple test pages with no partitions specified', function() {
-      var config = generateConfig({
-        parallel: true,
-        split: 2
-      });
-
-      assert.deepEqual(config.testPage, [
-        'tests/index.html?hidepassed&_split=2&_partition=1',
-        'tests/index.html?hidepassed&_split=2&_partition=2'
-      ]);
-    });
-
-    it('should modify the config to have multiple test pages with specified partitions', function() {
-      var config = generateConfig({
-        parallel: true,
-        split: 4,
-        partition: [3, 4]
-      });
-
-      assert.deepEqual(config.testPage, [
-        'tests/index.html?hidepassed&_split=4&_partition=3',
-        'tests/index.html?hidepassed&_split=4&_partition=4'
-      ]);
-    });
-
-    it('should modify the config to have multiple test pages for each test_page in the config file with no partitions specified', function() {
-      var config = generateConfig({
-        parallel: true,
-        split: 2,
-        configFile: 'testem.multiple-test-page.js'
-      });
-
-      assert.deepEqual(config.testPage, [
-        'tests/index.html?hidepassed&derp=herp&_split=2&_partition=1',
-        'tests/index.html?hidepassed&derp=herp&_split=2&_partition=2',
-        'tests/index.html?hidepassed&foo=bar&_split=2&_partition=1',
-        'tests/index.html?hidepassed&foo=bar&_split=2&_partition=2'
-      ]);
-    });
-
-    it('should modify the config to have multiple test pages for each test_page in the config file with partitions specified', function() {
-      var config = generateConfig({
-        parallel: true,
-        split: 4,
-        partition: [3, 4],
-        configFile: 'testem.multiple-test-page.js'
-      });
-
-      assert.deepEqual(config.testPage, [
-        'tests/index.html?hidepassed&derp=herp&_split=4&_partition=3',
-        'tests/index.html?hidepassed&derp=herp&_split=4&_partition=4',
-        'tests/index.html?hidepassed&foo=bar&_split=4&_partition=3',
-        'tests/index.html?hidepassed&foo=bar&_split=4&_partition=4'
-      ]);
-    });
-
-    it('should have a custom test page', function() {
-      var config = generateConfig({
-        query: 'foo=bar',
-        'test-page': 'tests.html'
-      });
-
-      assert.equal(config.testPage, 'tests.html?foo=bar');
-    });
-
-    it('should modify the config to have multiple test pages with a custom base url', function() {
-      var config = generateConfig({
-        parallel: true,
-        split: 2,
-        query: 'foo=bar',
-        'test-page': 'tests.html'
-      });
-
-      assert.deepEqual(config.testPage, [
-        'tests.html?foo=bar&_split=2&_partition=1',
-        'tests.html?foo=bar&_split=2&_partition=2'
-      ]);
-    });
-
-    it('should warn if no test_page is defined but use a default', function() {
-      var warnStub = sinon.stub(console, 'warn');
-
-      var config = generateConfig({
-        parallel: true,
-        split: 2,
-        configFile: 'testem.no-test-page.js'
-      });
-
-      assert.deepEqual(config.testPage, [
-        'tests/index.html?hidepassed&_split=2&_partition=1',
-        'tests/index.html?hidepassed&_split=2&_partition=2'
-      ]);
-
-      sinon.assert.calledOnce(warnStub);
-      sinon.assert.calledWithExactly(warnStub, 'No test_page value found in the config. Defaulting to "tests/index.html?hidepassed"');
-
-      warnStub.restore();
-    });
-  });
-
   describe('_getTestFramework', function() {
-    var command;
+    let command;
 
     function assertFramework(command, name) {
       assert.equal(command._getTestFramework(), name);
@@ -265,7 +167,7 @@ describe('ExamCommand', function() {
     });
 
     it('returns qunit if ember-cli-mocha is not a dependency of any kind', function() {
-      var command = createCommand();
+      command = createCommand();
       assertFramework(command, 'qunit');
     });
   });
diff --git a/node-tests/unit/lint-test.js b/node-tests/unit/lint-test.js
index 585eb4187..9e9a74246 100644
--- a/node-tests/unit/lint-test.js
+++ b/node-tests/unit/lint-test.js
@@ -1,7 +1,5 @@
-var lint = require('mocha-eslint');
+'use strict';
 
-lint([
-  'lib',
-  'node-tests',
-  'index.js'
-]);
+const lint = require('mocha-eslint');
+
+lint(['lib', 'node-tests', 'index.js']);
diff --git a/node-tests/unit/utils/config-reader-test.js b/node-tests/unit/utils/config-reader-test.js
new file mode 100644
index 000000000..571370a6c
--- /dev/null
+++ b/node-tests/unit/utils/config-reader-test.js
@@ -0,0 +1,29 @@
+'use strict';
+
+const assert = require('assert');
+const readTestemConfig = require('../../../lib/utils/config-reader');
+
+describe('ConfigReader | readTestemConfig', function() {
+  it('should find `testem.js` file by default and return `true` when no file name and no potential files specified', function() {
+    assert.ok(readTestemConfig());
+  });
+
+  it('should return `false` if file doesn\'t exsit when potential files are empty list', function() {
+    assert.ok(!readTestemConfig('this-file-do-not-exsit.json', []));
+  });
+
+  it('should find `testem.js` file by default and return `true` when file specified doesn\'t exist', function() {
+    assert.ok(readTestemConfig('this-file-do-not-exsit.json'));
+  });
+
+  it('should require a specified `js` file and return an object in the module when no potential files specified', function() {
+    assert.deepEqual(readTestemConfig('testem.simple-test-page.js').foo, 'bar');
+  });
+
+  it('should require a specified `js` file and return an object in the module when the file exsits and potential files are empty list', function() {
+    assert.deepEqual(
+      readTestemConfig('testem.simple-test-page.js', []).foo,
+      'bar'
+    );
+  });
+});
diff --git a/node-tests/unit/utils/execution-state-manager-test.js b/node-tests/unit/utils/execution-state-manager-test.js
new file mode 100644
index 000000000..18b5a680f
--- /dev/null
+++ b/node-tests/unit/utils/execution-state-manager-test.js
@@ -0,0 +1,92 @@
+'use strict';
+
+const assert = require('assert');
+const ExecutionStateManager = require('../../../lib/utils/execution-state-manager');
+
+describe('ExecutionStateManager', function() {
+  beforeEach(function() {
+    this.stateManager = new ExecutionStateManager();
+    this.moduleQueue = ['foo', 'bar', 'baz', 'boo', 'far', 'faz'];
+  });
+
+  describe('initializeStates', function() {
+    it('initialize states', function() {
+      assert.deepEqual(this.stateManager.getModuleMap().size, 0);
+      assert.deepEqual(this.stateManager.getSharedModuleQueue(), null);
+      assert.deepEqual(this.stateManager.getBrowserModuleQueue(), null);
+    });
+  });
+
+  describe('moduleQueue', function() {
+    it('is shared when no browserId passed to setModuleQueue', function() {
+      this.stateManager.setSharedModuleQueue(this.moduleQueue);
+
+      assert.deepEqual(
+        this.stateManager.getSharedModuleQueue(),
+        this.moduleQueue,
+        'the correct moduleQueue was returned'
+      );
+    });
+
+    it('returns the next module from the shared moduleQueue and state is preserved', function() {
+      this.stateManager.setSharedModuleQueue(this.moduleQueue);
+
+      assert.equal(
+        this.stateManager.getNextModuleSharedModuleQueue(),
+        'foo',
+        'correctly returns the next module'
+      );
+      assert.deepEqual(
+        this.stateManager.getSharedModuleQueue(),
+        ['bar', 'baz', 'boo', 'far', 'faz'],
+        'the moduleQueue state was updated'
+      );
+    });
+
+    it('get next module returns null if shared moduleQueue is not set', function() {
+      assert.equal(
+        this.stateManager.getNextModuleSharedModuleQueue(),
+        null,
+        'returns null when moduleQueue has not been set'
+      );
+    });
+
+    it('had different queue set when when browserId is specified', function() {
+      const anotherQueue = ['1', '2', '3', '4'];
+      this.stateManager.setBrowserModuleQueue(this.moduleQueue, 1);
+      this.stateManager.setBrowserModuleQueue(anotherQueue, 2);
+
+      assert.deepEqual(
+        this.stateManager.getBrowserModuleQueue(1),
+        this.moduleQueue
+      );
+      assert.deepEqual(
+        this.stateManager.getBrowserModuleQueue(2),
+        anotherQueue
+      );
+    });
+
+    it('returns the next module from the browser specific moduleQueue and state is preserved', function() {
+      this.stateManager.setBrowserModuleQueue(this.moduleQueue, 1);
+
+      assert.equal(
+        this.stateManager.getNextModuleBrowserModuleQueue(1),
+        'foo',
+        'correctly returns the next module'
+      );
+      assert.deepEqual(
+        this.stateManager.getBrowserModuleQueue(1),
+        ['bar', 'baz', 'boo', 'far', 'faz'],
+        'the moduleQueue state was updated'
+      );
+    });
+
+    it('get next module returns null if browser moduleQueue is not set', function() {
+      assert.equal(
+        this.stateManager.getNextModuleBrowserModuleQueue(1),
+        null,
+        'returns null when moduleQueue has not been set'
+      );
+    });
+  });
+});
diff --git a/node-tests/unit/utils/query-helper-test.js b/node-tests/unit/utils/query-helper-test.js
new file mode 100644
index 000000000..791b23580
--- /dev/null
+++ b/node-tests/unit/utils/query-helper-test.js
@@ -0,0 +1,58 @@
+'use strict';
+
+const assert = require('assert');
+const { addToQuery, addToUrl } = require('../../../lib/utils/query-helper');
+
+describe('QueryHelper', function() {
+  describe('addToQuery', function() {
+    it('should add param when no query and value is true', function() {
+      const validQuery = addToQuery(null, 'foo', true);
+
+      assert.deepEqual(validQuery, 'foo');
+    });
+
+    it('should add param and value when no query and value is string', function() {
+      const validQuery = addToQuery(null, 'foo', 'bar');
+
+      assert.deepEqual(validQuery, 'foo=bar');
+    });
+
+    it('should add param to query when value is boolean', function() {
+      const validQuery = addToQuery('foo', 'bar', true);
+
+      assert.deepEqual(validQuery, 'foo&bar');
+    });
+
+    it('should add param and value to query when value is string', function() {
+      const validQuery = addToQuery('foo', 'bar', 'baz');
+
+      assert.deepEqual(validQuery, 'foo&bar=baz');
+    });
+
+    it('should not add param when value is false', function() {
+      const validQuery = addToQuery('foo', 'bar', false);
+
+      assert.deepEqual(validQuery, 'foo');
+    });
+  });
+
+  describe('addToUrl', function() {
+    it('should add param to url when value is true', function() {
+      const url = addToUrl('tests/index.html?hidepassed', 'foo', true);
+
+      assert.deepEqual(url, 'tests/index.html?hidepassed&foo');
+    });
+
+    it('should not add param to url when value is false', function() {
+      const url = addToUrl('tests/index.html?hidepassed', 'foo', false);
+
+      assert.deepEqual(url, 'tests/index.html?hidepassed');
+    });
+
+    it('should add param and value to url when value is string', function() {
+      const url = addToUrl('tests/index.html?hidepassed', 'foo', 'bar');
+
+      assert.deepEqual(url, 'tests/index.html?hidepassed&foo=bar');
+    });
+  });
+});
diff --git a/node-tests/unit/utils/test-page-helper-test.js b/node-tests/unit/utils/test-page-helper-test.js
new file mode 100644
index 000000000..d69e7f988
--- /dev/null
+++ b/node-tests/unit/utils/test-page-helper-test.js
@@ -0,0 +1,330 @@
+'use strict';
+
+const assert = require('assert');
+const sinon = require('sinon');
+const {
+  combineOptionValueIntoArray,
+  getBrowserId,
+  getCustomBaseUrl,
+  getMultipleTestPages,
+  getTestUrlFromTestemConfig
+} = require('../../../lib/utils/test-page-helper');
+
+describe('TestPageHelper', function() {
+  describe('combineOptionValueIntoArray', function() {
+    it('should return empty array when no optionValue specified', function() {
+      assert.deepEqual(combineOptionValueIntoArray(), []);
+    });
+
+    it('should have a specified option number when the option is number', function() {
+      assert.deepEqual(combineOptionValueIntoArray(3), [3]);
+    });
+
+    it('should have a number of array when a specified option is string', function() {
+      assert.deepEqual(combineOptionValueIntoArray('2,3'), [2, 3]);
+    });
+
+    it('should have a numbe of array when a specified option is a combination of number and string ', function() {
+      assert.deepEqual(combineOptionValueIntoArray([1, '2,3']), [1, 2, 3]);
+    });
+
+    it('should have a sequence number of array when a specified option is in range', function() {
+      assert.deepEqual(combineOptionValueIntoArray('1..5'), [1, 2, 3, 4, 5]);
+    });
+
+    it('should have a number of array when a specified option is a combination of number and string in range', function() {
+      assert.deepEqual(combineOptionValueIntoArray([1, '3..6']), [1, 3, 4, 5, 6]);
+    });
+  });
+
+  describe('getBrowserId', function() {
+    it('should return the correct browserId', function() {
+      assert.equal(getBrowserId('loadBalance&browser=1'), 1);
+    });
+
+    it('should return 0 if no browser param is found in the test page', function() {
+      assert.throws(() => {
+        getBrowserId('loadBalance');
+      }, /Browser Id can't be found./);
+    });
+  });
+
+  describe('getTestUrlFromTestemConfig', function() {
+    it('should have a default test page with no config file', function() {
+      const testPage = getTestUrlFromTestemConfig('');
+
+      assert.deepEqual(testPage, 'tests/index.html?hidepassed');
+    });
+
+    it('should have a default test page with no test-page specified in a testem config file', function() {
+      const warnStub = sinon.stub(console, 'warn');
+      const testPage = getTestUrlFromTestemConfig('testem.no-test-page.js');
+
+      assert.deepEqual(testPage, 'tests/index.html?hidepassed');
+
+      sinon.assert.calledOnce(warnStub);
+      sinon.assert.calledWithExactly(
+        warnStub,
+        'No test_page value found in the config. Defaulting to "tests/index.html?hidepassed"'
+      );
+
+      warnStub.restore();
+    });
+
+    it('should have multiple test pages specified in testem config file with test-page specified in the file', function() {
+      const testPages = getTestUrlFromTestemConfig(
+        'testem.multiple-test-page.js'
+      );
+
+      assert.deepEqual(testPages, [
+        'tests/index.html?hidepassed&derp=herp',
+        'tests/index.html?hidepassed&foo=bar'
+      ]);
+    });
+  });
+
+  describe('getCustomBaseUrl', function() {
+    it('should add `split` when `split` option is used', function() {
+      const appendedUrl = getCustomBaseUrl(
+        { split: 3 },
+        'tests/index.html?hidepassed'
+      );
+
+      assert.deepEqual(appendedUrl, 'tests/index.html?hidepassed&split=3');
+    });
+
+    it('should add `split` when `split` and `parallel` option are used', function() {
+      const appendedUrl = getCustomBaseUrl(
+        { split: 5, parallel: true },
+        'tests/index.html?hidepassed'
+      );
+
+      assert.deepEqual(appendedUrl, 'tests/index.html?hidepassed&split=5');
+    });
+
+    it('should add `loadBalance` when `load-balance` option is used', function() {
+      const appendedUrl = getCustomBaseUrl(
+        { loadBalance: 2 },
+        'tests/index.html?hidepassed'
+      );
+
+      assert.deepEqual(appendedUrl, 'tests/index.html?hidepassed&loadBalance');
+    });
+
+    it('should add `split`, `loadBalance`, and `partition` when `split`, `loadBalance`, and `partition` are used.', function() {
+      const appendedUrl = getCustomBaseUrl(
+        { split: 5, partition: [1, 2, 3], loadBalance: 2 },
+        'tests/index.html?hidepassed'
+      );
+
+      assert.deepEqual(
+        appendedUrl,
+        'tests/index.html?hidepassed&split=5&loadBalance&partition=1&partition=2&partition=3'
+      );
+    });
+
+    it('should add `loadBalance` when `replay-execution` and `replay-browser` are used', function() {
+      const appendedUrl = getCustomBaseUrl(
+        {
+          replayExecution: 'test-execution-0000000.json',
+          replayBrowser: [1, 2]
+        },
+        'tests/index.html?hidepassed'
+      );
+
+      assert.deepEqual(appendedUrl, 'tests/index.html?hidepassed&loadBalance');
+    });
+
+    it('should add `split` to multiple test pages when `split` option is used', function() {
+      const appendedUrl = getCustomBaseUrl({ split: 3 }, [
+        'tests/index.html?hidepassed&derp=herp',
+        'tests/index.html?hidepassed&foo=bar'
+      ]);
+
+      assert.deepEqual(appendedUrl, [
+        'tests/index.html?hidepassed&derp=herp&split=3',
+        'tests/index.html?hidepassed&foo=bar&split=3'
+      ]);
+    });
+
+    it('should add `split` when `split` to multiple test pages and `parallel` option are used', function() {
+      const appendedUrl = getCustomBaseUrl({ split: 5, parallel: true }, [
+        'tests/index.html?hidepassed&derp=herp',
+        'tests/index.html?hidepassed&foo=bar'
+      ]);
+
+      assert.deepEqual(appendedUrl, [
+        'tests/index.html?hidepassed&derp=herp&split=5',
+        'tests/index.html?hidepassed&foo=bar&split=5'
+      ]);
+    });
+
+    it('should add `loadBalance` to multiple test pages when `load-balance` option is used', function() {
+      const appendedUrl = getCustomBaseUrl({ loadBalance: 2 }, [
+        'tests/index.html?hidepassed&derp=herp',
+        'tests/index.html?hidepassed&foo=bar'
+      ]);
+
+      assert.deepEqual(appendedUrl, [
+        'tests/index.html?hidepassed&derp=herp&loadBalance',
+        'tests/index.html?hidepassed&foo=bar&loadBalance'
+      ]);
+    });
+
+    it('should add `split`, `loadBalance`, and `partition` to multiple test pages when `split`, `loadBalance`, and `partition` are used.', function() {
+      const appendedUrl = getCustomBaseUrl(
+        { split: 5, partition: [1, 2, 3], loadBalance: 2 },
+        [
+          'tests/index.html?hidepassed&derp=herp',
+          'tests/index.html?hidepassed&foo=bar'
+        ]
+      );
+
+      assert.deepEqual(appendedUrl, [
+        'tests/index.html?hidepassed&derp=herp&split=5&loadBalance&partition=1&partition=2&partition=3',
+        'tests/index.html?hidepassed&foo=bar&split=5&loadBalance&partition=1&partition=2&partition=3'
+      ]);
+    });
+
+    it('should add `loadBalance` to multiple test pages when `replay-execution` and `replay-browser` are used', function() {
+      const appendedUrl = getCustomBaseUrl(
+        {
+          replayExecution: 'test-execution-0000000.json',
+          replayBrowser: [1, 2]
+        },
+        [
+          'tests/index.html?hidepassed&derp=herp',
+          'tests/index.html?hidepassed&foo=bar'
+        ]
+      );
+
+      assert.deepEqual(appendedUrl, [
+        'tests/index.html?hidepassed&derp=herp&loadBalance',
+        'tests/index.html?hidepassed&foo=bar&loadBalance'
+      ]);
+    });
+  });
+
+  describe('getMultipleTestPages', function() {
+    it('should have multiple test pages with no partitions specified', function() {
+      const testPages = getMultipleTestPages(
+        { testPage: 'tests/index.html?hidepassed' },
+        { parallel: 1, split: 2 }
+      );
+
+      assert.deepEqual(testPages, [
+        'tests/index.html?hidepassed&split=2&partition=1',
+        'tests/index.html?hidepassed&split=2&partition=2'
+      ]);
+    });
+
+    it('should have multiple test pages with specified partitions', function() {
+      const testPages = getMultipleTestPages(
+        { testPage: 'tests/index.html?hidepassed' },
+        { parallel: 1, split: 4, partition: [3, 4] }
+      );
+
+      assert.deepEqual(testPages, [
+        'tests/index.html?hidepassed&split=4&partition=3',
+        'tests/index.html?hidepassed&split=4&partition=4'
+      ]);
+    });
+
+    it('should have multiple test pages for each test_page in the config file with no partitions specified', function() {
+      const testPages = getMultipleTestPages(
+        { configFile: 'testem.multiple-test-page.js' },
+        { parallel: 1, split: 2 }
+      );
+
+      assert.deepEqual(testPages, [
+        'tests/index.html?hidepassed&derp=herp&split=2&partition=1',
+        'tests/index.html?hidepassed&derp=herp&split=2&partition=2',
+        'tests/index.html?hidepassed&foo=bar&split=2&partition=1',
+        'tests/index.html?hidepassed&foo=bar&split=2&partition=2'
+      ]);
+    });
+
+    it('should have multiple test pages for each test_page in the config file with partitions specified', function() {
+      const testPages = getMultipleTestPages(
+        { configFile: 'testem.multiple-test-page.js' },
+        { parallel: 1, split: 4, partition: [3, 4] }
+      );
+
+      assert.deepEqual(testPages, [
+        'tests/index.html?hidepassed&derp=herp&split=4&partition=3',
+        'tests/index.html?hidepassed&derp=herp&split=4&partition=4',
+        'tests/index.html?hidepassed&foo=bar&split=4&partition=3',
+        'tests/index.html?hidepassed&foo=bar&split=4&partition=4'
+      ]);
+    });
+
+    it('should have a test page with `loadBalance` when no specified number of browser', function() {
+      const testPages = getMultipleTestPages(
+        { testPage: 'tests/index.html?hidepassed' },
+        { loadBalance: true, parallel: 1 }
+      );
+
+      assert.deepEqual(testPages, [
+        'tests/index.html?hidepassed&loadBalance&browser=1'
+      ]);
+    });
+
+    it('should have multiple test page with `loadBalance` with splitting when no specified number of browser', function() {
+      const testPages = getMultipleTestPages(
+        { testPage: 'tests/index.html?hidepassed' },
+        { loadBalance: true, parallel: 1, split: 2 }
+      );
+
+      assert.deepEqual(testPages, [
+        'tests/index.html?hidepassed&split=2&loadBalance&browser=1'
+      ]);
+    });
+
+    it('should have multiple test pages with test loading balanced, no specified partitions and no splitting', function() {
+      const testPages = getMultipleTestPages(
+        { testPage: 'tests/index.html?hidepassed' },
+        { loadBalance: true, parallel: 2 }
+      );
+
+      assert.deepEqual(testPages, [
+        'tests/index.html?hidepassed&loadBalance&browser=1',
+        'tests/index.html?hidepassed&loadBalance&browser=2'
+      ]);
+    });
+
+    it('should have multiple test pages with test loading balanced, no specified partitions and no splitting', function() {
+      const testPages = getMultipleTestPages(
+        { testPage: 'tests/index.html?hidepassed' },
+        { loadBalance: true, parallel: 2, split: 3, partition: [2, 3] }
+      );
+
+      assert.deepEqual(testPages, [
+        'tests/index.html?hidepassed&split=3&loadBalance&partition=2&partition=3&browser=1',
+        'tests/index.html?hidepassed&split=3&loadBalance&partition=2&partition=3&browser=2'
+      ]);
+    });
+
+    it('should have multiple test pages for each test_page in the config file with partitions specified and test loading balanced', function() {
+      const testPages = getMultipleTestPages(
+        { configFile: 'testem.multiple-test-page.js' },
+        { loadBalance: true, parallel: 1, split: 4, partition: [3, 4] }
+      );
+
+      assert.deepEqual(testPages, [
+        'tests/index.html?hidepassed&derp=herp&split=4&loadBalance&partition=3&partition=4&browser=1',
+        'tests/index.html?hidepassed&foo=bar&split=4&loadBalance&partition=3&partition=4&browser=1'
+      ]);
+    });
+
+    it('should have multiple test pages with test replay execution', function() {
+      const testPages = getMultipleTestPages(
+        { testPage: 'tests/index.html?hidepassed' },
+        { replayExecution: 'abc.json', replayBrowser: [2] }
+      );
+
+      assert.deepEqual(testPages, [
+        'tests/index.html?hidepassed&loadBalance&browser=2'
+      ]);
+    });
+  });
+});
diff --git a/node-tests/unit/utils/testem-events-test.js b/node-tests/unit/utils/testem-events-test.js
new file mode 100644
index 000000000..ced35fdfb
--- /dev/null
+++ b/node-tests/unit/utils/testem-events-test.js
@@ -0,0 +1,279 @@
+'use strict';
+
+const assert = require('assert');
+const fixturify = require('fixturify');
+const fs = require('fs-extra');
+const path = require('path');
+const TestemEvents = require('../../../lib/utils/testem-events');
+
+const fixtureDir = 'tmp/fixture';
+const testExecutionJsonPath = path.join(fixtureDir, 'test-execution-123.json');
+const testExecutionJson = {
+  numberOfBrowsers: 1,
+  failedBrowsers: [],
+  executionMapping: {
+    1: ['path/to/testmodule', 'path/to/another/testmodule']
+  }
+};
+
+describe('TestemEvents', function() {
+  beforeEach(function() {
+    fs.mkdirpSync(fixtureDir);
+    this.testemEvents = new TestemEvents(fixtureDir);
+    this.moduleQueue = ['foo', 'bar', 'baz', 'boo', 'far', 'faz'];
+  });
+
+  afterEach(function() {
+    fs.removeSync(fixtureDir);
+  });
+
+  describe('setModuleQueue', function() {
+    beforeEach(function() {
+      fixturify.writeSync(fixtureDir, {
+        'test-execution-123.json': JSON.stringify(testExecutionJson)
+      });
+    });
+
+    it('set sharedModuleQueue for load-balance mode', function() {
+      this.testemEvents.setModuleQueue(1, this.moduleQueue, true, false);
+
+      assert.deepEqual(
+        this.testemEvents.stateManager.getSharedModuleQueue(),
+        this.moduleQueue
+      );
+    });
+
+    it('ignore subsequent setModuleQueue if moduleQueue is already set for load-balance mode', function() {
+      const anotherModuleQueue = ['a', 'b', 'c'];
+      this.testemEvents.setModuleQueue(1, this.moduleQueue, true, false);
+      this.testemEvents.setModuleQueue(2, anotherModuleQueue, true, false);
+
+      assert.deepEqual(
+        this.testemEvents.stateManager.getSharedModuleQueue(),
+        this.moduleQueue
+      );
+    });
+
+    it('set browserModuleQueue for replay-execution mode', function() {
+      this.testemEvents.setReplayExecutionMap(testExecutionJsonPath, [1]);
+      this.testemEvents.setModuleQueue(1, this.moduleQueue, false, true);
+
+      assert.deepEqual(
+        this.testemEvents.stateManager.getBrowserModuleQueue(1),
+        testExecutionJson.executionMapping[1]
+      );
+    });
+
+    it('set browserModuleQueue for replay-execution mode when replay-browser is undefined', function() {
+      this.testemEvents.setReplayExecutionMap(testExecutionJsonPath);
+      this.testemEvents.setModuleQueue(1, this.moduleQueue, false, true);
+
+      assert.deepEqual(
+        this.testemEvents.stateManager.getBrowserModuleQueue(1),
+        testExecutionJson.executionMapping[1]
+      );
+    });
+
+    it('throws error if ReplayExecutionMap is not set when setting browserModuleQueue for replay-execution mode', function() {
+      assert.throws(
+        () =>
+          this.testemEvents.setModuleQueue(1, this.moduleQueue, false, true),
+        /No replay execution map was set on the stateManager/,
+        'Error is thrown'
+      );
+    });
+  });
+
+  describe('nextModuleResponse', function() {
+    const socket = {
+      events: [],
+      emit: function(event, payload) {
+        this.events.push(event);
+
+        if (payload) {
+          this.events.push(payload);
+        }
+      },
+      reset: function() {
+        this.events.length = 0;
+      }
+    };
+
+    const fooResponse = {
+      done: false,
+      value: 'foo'
+    };
+
+    const emptyMap = new Map();
+
+    afterEach(function() {
+      socket.reset();
+    });
+
+    it('should fire next-module-response event and save the moduleName to stateManager.moduleMap when write-execution-file is true', function() {
+      this.testemEvents.stateManager.setSharedModuleQueue(this.moduleQueue);
+      this.testemEvents.nextModuleResponse(1, socket, true);
+
+      assert.deepEqual(
+        socket.events,
+        ['testem:next-module-response', fooResponse],
+        'testem:next-module-response event was emitted with payload foo'
+      );
+      assert.deepEqual(
+        this.testemEvents.stateManager
+          .getModuleMap()
+          .values()
+          .next().value,
+        ['foo'],
+        'module was correctly saved to the moduleMap'
+      );
+    });
+
+    it('should not save the moduleName to stateManager.moduleMap when write-execution-file is false', function() {
+      this.testemEvents.stateManager.setBrowserModuleQueue([], 1);
+      this.testemEvents.nextModuleResponse(1, socket, false);
+
+      assert.deepEqual(
+        this.testemEvents.stateManager.getModuleMap(),
+        emptyMap,
+        'moduleMap should be in its initial state'
+      );
+    });
+
+    it('should throw error if no moduleQueues were set', function() {
+      assert.throws(
+        () => this.testemEvents.nextModuleResponse(1, socket, false, 'dev'),
+        /No moduleQueue was set/,
+        'No moduleQueue error was thrown'
+      );
+    });
+  });
+
+  describe('recoredFailedBrowserId', function() {
+    it('record new browserId if test failed', function() {
+      this.testemEvents.recoredFailedBrowserId(1);
+
+      assert.deepEqual(
+        this.testemEvents.stateManager.getFailedBrowsers(),
+        [1],
+        'failed browserId 1 is correctly recorded'
+      );
+    });
+
+    it('does not record browserId that has already been recorded', function() {
+      this.testemEvents.recoredFailedBrowserId(1);
+      this.testemEvents.recoredFailedBrowserId(1);
+
+      assert.deepEqual(
+        this.testemEvents.stateManager.getFailedBrowsers(),
+        [1],
+        'failed browserId 1 is correctly recorded only once'
+      );
+    });
+  });
+
+  describe('completedBrowsersHandler', function() {
+    const mockUi = {
+      writeLine: () => {}
+    };
+
+    it('should increment completedBrowsers only when completedBrowsers is less than browserCount', function() {
+      this.testemEvents.completedBrowsersHandler(
+        2,
+        mockUi,
+        true,
+        'test-execution.json',
+        false
+      );
+
+      assert.equal(
+        this.testemEvents.stateManager.completedBrowsers(),
+        1,
+        'completedBrowsers was incremented'
+      );
+    });
+
+    it('should write test-execution file and cleanup state when completedBrowsers equals browserCount and load-balance is true', function() {
+      this.testemEvents.stateManager.addModuleNameToModuleMap('a', 1);
+      this.testemEvents.completedBrowsersHandler(
+        1,
+        mockUi,
+        true,
+        'test-execution.json',
+        true
+      );
+
+      const actual = fs.readFileSync(
+        path.join(fixtureDir, 'test-execution.json')
+      );
+
+      assert.deepEqual(JSON.parse(actual), {
+        numberOfBrowsers: 1,
+        failedBrowsers: [],
+        executionMapping: {
+          1: ['a']
+        }
+      });
+    });
+
+    it('should increment completedBrowsers when load-balance is false', function() {
+      this.testemEvents.completedBrowsersHandler(
+        2,
+        mockUi,
+        false,
+        'test-execution.json',
+        false
+      );
+
+      assert.equal(
+        this.testemEvents.stateManager.completedBrowsers(),
+        1,
+        'completedBrowsers was incremented'
+      );
+    });
+
+    it('should not clean up states from stateManager when test execution is not completed', function() {
+      this.testemEvents.stateManager.addModuleNameToModuleMap('a', 1);
+      this.testemEvents.stateManager.addModuleNameToModuleMap('b', 2);
+
+      this.testemEvents.completedBrowsersHandler(
+        2,
+        mockUi,
+        true,
+        'test-execution.json',
+        false
+      );
+
+      assert.deepEqual(this.testemEvents.stateManager.getModuleMap().size, 2);
+    });
+
+    it('should clean up states from stateManager when test execution is completed', function() {
+      const mockReplayExecutionMap = { 1: ['a'] };
+      this.testemEvents.stateManager.addModuleNameToModuleMap('a', 1);
+      this.testemEvents.stateManager.setReplayExecutionMap(
+        mockReplayExecutionMap
+      );
+      this.testemEvents.completedBrowsersHandler(
+        1,
+        mockUi,
+        true,
+        'test-execution.json',
+        false
+      );
+
+      assert.deepEqual(this.testemEvents.stateManager.getModuleMap().size, 0);
+      assert.deepEqual(
+        this.testemEvents.stateManager.getSharedModuleQueue(),
+        null
+      );
+      assert.deepEqual(
+        this.testemEvents.stateManager.getBrowserModuleQueue(),
+        null
+      );
+      assert.deepEqual(
+        this.testemEvents.stateManager.getReplayExecutionMap(),
+        mockReplayExecutionMap
+      );
+    });
+  });
+});
diff --git a/node-tests/unit/utils/tests-options-validator-test.js b/node-tests/unit/utils/tests-options-validator-test.js
index 7c5ba4cae..3f35761fd 100644
--- a/node-tests/unit/utils/tests-options-validator-test.js
+++ b/node-tests/unit/utils/tests-options-validator-test.js
@@ -1,30 +1,71 @@
-var assert = require('assert');
+'use strict';
 
-var TestOptionsValidator = require('../../../lib/utils/tests-options-validator');
+const assert = require('assert');
+const fixturify = require('fixturify');
+const fs = require('fs-extra');
+const TestOptionsValidator = require('../../../lib/utils/tests-options-validator');
+const TestExecutionJson = {
+  numberOfBrowsers: 2,
+  browserToModuleMap: {
+    '1': ['/tests/integration/components/my-component-test'],
+    '2': ['/tests/integration/components/navigating-component-test']
+  }
+};
 
 describe('TestOptionsValidator', function() {
-  function shouldThrow(prop, options, message) {
-    var validator = new TestOptionsValidator(options);
-    assert.throws(function() { return validator['should' + prop]; }, message);
+  function validateCommand(validator, cmd) {
+    switch (cmd) {
+      case 'Split':
+        return validator.validateSplit();
+      case 'Random':
+        return validator.validateRandom();
+      case 'Parallel':
+        return validator.validateParallel();
+      case 'writeExecutionFile':
+        return validator.validateWriteExecutionFile();
+      case 'LoadBalance':
+        return validator.validateLoadBalance();
+      case 'ReplayExecution':
+        return validator.validateReplayExecution();
+      default:
+        throw new Error('invalid command passed');
+    }
+  }
+
+  function shouldThrow(cmd, options, message, emberCliVer = '3.7.0') {
+    const validator = new TestOptionsValidator(
+      options,
+      options.framework,
+      emberCliVer
+    );
+    assert.throws(() => validateCommand(validator, cmd), message);
   }
 
-  function shouldEqual(prop, options, value) {
-    var validator = new TestOptionsValidator(options);
-    assert.equal(validator['should' + prop], value);
+  function shouldEqual(cmd, options, value, emberCliVer = '3.7.0') {
+    const validator = new TestOptionsValidator(
+      options,
+      options.framework,
+      emberCliVer
+    );
+    assert.equal(validateCommand(validator, cmd), value);
   }
 
-  function shouldWarn(prop, options, value) {
+  function shouldWarn(cmd, options, value, emberCliVer = '3.7.0') {
     /* eslint-disable no-console */
-    var originalWarn = console.warn;
-    var warnCalled = 0;
-    var warnMessage = '';
+    let originalWarn = console.warn;
+    let warnCalled = 0;
+    let warnMessage = '';
     console.warn = function(message) {
       warnCalled++;
       warnMessage = message;
     };
 
-    var validator = new TestOptionsValidator(options, options.framework);
-    assert.notEqual(validator['should' + prop], undefined);
+    const validator = new TestOptionsValidator(
+      options,
+      options.framework,
+      emberCliVer
+    );
+    assert.notEqual(validateCommand(validator, cmd), undefined);
     assert.equal(warnCalled, 1);
     assert.equal(warnMessage, value);
 
@@ -42,27 +83,39 @@ describe('TestOptionsValidator', function() {
     }
 
     it('should log a warning if `split` is less than 2', function() {
-      shouldWarn('Split', { split: 1 }, 'You should specify a number of files greater than 1 to split your tests across. Defaulting to 1 split which is the same as not using `--split`.');
+      shouldWarn(
+        'Split',
+        { split: 1 },
+        'You should specify a number of files greater than 1 to split your tests across. Defaulting to 1 split which is the same as not using `split`.'
+      );
     });
 
     it('should throw an error if `partition` is used without `split`', function() {
-      shouldSplitThrows({ partition: [1] }, /You must specify a 'split' value in order to use 'partition'/);
+      shouldSplitThrows(
+        { partition: [1] },
+        /You must specify a `split` value in order to use `partition`/
+      );
     });
 
     it('should throw an error if `partition` contains a value less than 1', function() {
-      shouldSplitThrows({ split: 2, partition: [1, 0] }, /Split tests are one-indexed, so you must specify partition values greater than or equal to 1./);
+      shouldSplitThrows(
+        { split: 2, partition: [1, 0] },
+        /Split tests are one-indexed, so you must specify partition values greater than or equal to 1./
+      );
     });
 
     it('should throw an error if `partition` contains a value greater than `split`', function() {
-      shouldSplitThrows({ split: 2, partition: [1, 3] }, /You must specify 'partition' values that are less than or equal to your 'split' value./);
+      shouldSplitThrows(
+        { split: 2, partition: [1, 3] },
+        /You must specify `partition` values that are less than or equal to your `split` value./
+      );
     });
 
     it('should throw an error if `partition` contains duplicate values', function() {
-      shouldSplitThrows({ split: 2, partition: [1, 2, 1] }, /You cannot specify the same partition twice./);
-    });
-
-    it('should throw an error if `weighted` is being used without `split`', function() {
-      shouldSplitThrows({ weighted: true }, /You used the 'weighted' option but are not splitting your tests/);
+      shouldSplitThrows(
+        { split: 2, partition: [1, 2, 1] },
+        /You cannot specify the same partition value twice. 1 is repeated./
+      );
     });
 
     it('should return true if using `split`', function() {
@@ -80,7 +133,7 @@ describe('TestOptionsValidator', function() {
 
   describe('shouldRandomize', function() {
     function shouldRandomizeEqual(options, message) {
-      shouldEqual('Randomize', options, message);
+      shouldEqual('Random', options, message);
     }
 
     it('should return true if `random` is an empty string', function() {
@@ -100,21 +153,258 @@ describe('TestOptionsValidator', function() {
     });
 
     it('should warn that randomization is not supported in mocha', function() {
-      shouldWarn('Randomize', { random: '', framework: 'mocha' }, 'Mocha does not currently support randomizing test order, so tests will run in normal order. Please see https://github.com/mochajs/mocha/issues/902 for more info.');
+      shouldWarn(
+        'Random',
+        { random: '', framework: 'mocha' },
+        'Mocha does not currently support randomizing test order, so tests will run in normal order. Please see https://github.com/mochajs/mocha/issues/902 for more info.'
+      );
     });
   });
 
   describe('shouldParallelize', function() {
     it('should throw an error if `split` is not being used', function() {
-      shouldThrow('Parallelize', { parallel: true }, /You must specify the `split` option in order to run your tests in parallel/);
+      shouldThrow(
+        'Parallel',
+        { parallel: 1 },
+        /You must specify the `split` option in order to run your tests in parallel/
+      );
+    });
+
+    it('should throw an error if used with `replay-execution`', function() {
+      shouldThrow(
+        'Parallel',
+        { replayExecution: 'abc', parallel: 1 },
+        /You must not use the `replay-execution` option with the `parallel` option./
+      );
+    });
+
+    it('should throw an error if used with `replay-browser`', function() {
+      shouldThrow(
+        'Parallel',
+        { replayBrowser: 2, parallel: 1 },
+        /You must not use the `replay-browser` option with the `parallel` option./
+      );
+    });
+
+    it('should throw an error if parallel is > 1 when used with `split`', function() {
+      shouldThrow(
+        'Parallel',
+        { split: 2, parallel: 2 },
+        /When used with `split` or `partition`, `parallel` does not accept a value other than 1./
+      );
+    });
+
+    it('should throw an error if 0 is passed while loadBalance is specified', function() {
+      shouldThrow(
+        'Parallel',
+        { loadBalance: 2, parallel: 0 },
+        /You must specify a value greater than 1 to `parallel`./
+      );
+    });
+
+    it('should return true', function() {
+      shouldEqual('Parallel', { split: 2, parallel: 1 }, true);
+    });
+  });
+
+  describe('ShouldWriteExecutionFile', function() {
+    it('should return false when not passed', function() {
+      shouldEqual(
+        'writeExecutionFile',
+        {
+          loadBalance: true,
+          parallel: 2,
+          launch: 'false'
+        },
+        false
+      );
+    });
+
+    it('should throw an error if `write-execution-file` is used without `load-balance`', function() {
+      shouldThrow(
+        'writeExecutionFile',
+        { writeExecutionFile: true },
+        /You must run test suite with the `load-balance` option in order to use the `write-execution-file` option./
+      );
+    });
+
+    it('should throw an error if `write-execution-file` is used without `load-balance`', function() {
+      shouldThrow(
+        'writeExecutionFile',
+        {
+          split: 2,
+          partition: 1,
+          writeExecutionFile: true
+        },
+        /You must run test suite with the `load-balance` option in order to use the `write-execution-file` option./
+      );
+    });
+
+    it('should throw an error if `write-execution-file` is used without `load-balance`', function() {
+      shouldThrow(
+        'writeExecutionFile',
+        {
+          replayExecution: 'test-execution-0000000.json',
+          replayBrowser: [1, 2],
+          writeExecutionFile: true
+        },
+        /You must run test suite with the `load-balance` option in order to use the `write-execution-file` option./
+      );
+    });
+
+    it('should throw an error if `write-execution-file` is used with `no-launch`', function() {
+      shouldThrow(
+        'writeExecutionFile',
+        {
+          loadBalance: true,
+          parallel: 1,
+          launch: 'false',
+          writeExecutionFile: true
+        },
+        /You must not use no-launch with write-execution-file option./
+      );
+    });
+
+    it('should return true', function() {
+      shouldEqual(
+        'writeExecutionFile',
+        {
+          loadBalance: true,
+          parallel: 2,
+          writeExecutionFile: true
+        },
+        true
+      );
+    });
+  });
+
+  describe('shouldLoadBalance', function() {
+    it('should throw an error if ember-cli version is below 3.2.0', function() {
+      shouldThrow(
+        'LoadBalance',
+        { loadBalance: true, replayExecution: 'abc' },
+        /You must be using ember-cli version \^3.2.0 for this feature to work properly./,
+        '3.0.0'
+      );
+    });
+
+    it('should throw an error if ember-cli version is ~3.1.0', function() {
+      shouldThrow(
+        'LoadBalance',
+        { loadBalance: true, replayExecution: 'abc' },
+        /You must be using ember-cli version \^3.2.0 for this feature to work properly./,
+        '~3.1.0'
+      );
+    });
+
+    it('should throw an error if `replayExecution` is passed', function() {
+      shouldThrow(
+        'LoadBalance',
+        { loadBalance: true, replayExecution: 'abc' },
+        /You must not use the `replay-execution` option with the `load-balance` option./
+      );
+    });
+
+    it('should throw an error if `replayBrowser` is passed', function() {
+      shouldThrow(
+        'LoadBalance',
+        { loadBalance: true, replayBrowser: 3 },
+        /You must not use the `replay-browser` option with the `load-balance` option./
+      );
+    });
+
+    it('should throw an error if `parallel` is not defined', function() {
+      shouldThrow(
+        'LoadBalance',
+        { loadBalance: true },
+        /You should specify the number of browsers to load-balance against using `parallel` when using `load-balance`./
+      );
+    });
+
+    it('should throw an error if `parallel` has a value less than 1', function() {
+      shouldThrow(
+        'LoadBalance',
+        { loadBalance: true, parallel: 0 },
+        /You should specify the number of browsers to load-balance against using `parallel` when using `load-balance`./
+      );
+    });
+
+    it('should throw an error if `no-launch` is passed', function() {
+      shouldThrow(
+        'LoadBalance',
+        { loadBalance: true, parallel: 0, launch: 'false' },
+        /You must not use `no-launch` option with the `load-balance` option./
+      );
+    });
+
+    it('should return true', function() {
+      shouldEqual('LoadBalance', { loadBalance: true, parallel: 3 }, true);
+    });
+  });
+
+  describe('shouldReplayExecution', function() {
+    before(function() {
+      fixturify.writeSync(process.cwd(), {
+        'test-execution-0000000.json': JSON.stringify(TestExecutionJson)
+      });
+    });
+    after(function() {
+      fs.unlink('test-execution-0000000.json');
+    });
+
+    it('should throw an error if `replay-browser` contains a value less than 1', function() {
+      shouldThrow(
+        'ReplayExecution',
+        {
+          replayExecution: 'test-execution-0000000.json',
+          replayBrowser: [1, 0]
+        },
+        /You must specify replay-browser values greater than or equal to 1./
+      );
+    });
+
+    it('should throw an error if `replay-browser` contains duplicate values', function() {
+      shouldThrow(
+        'ReplayExecution',
+        {
+          replayExecution: 'test-execution-0000000.json',
+          replayBrowser: [1, 2, 1]
+        },
+        /You cannot specify the same replayBrowser value twice. 1 is repeated./
+      );
+    });
+
+    it('should throw an error if `replay-browser` contains an invalid browser number', function() {
+      shouldThrow(
+        'ReplayExecution',
+        {
+          replayExecution: 'test-execution-0000000.json',
+          replayBrowser: [3, 1]
+        },
+        /You must specify replayBrowser value smaller than a number of browsers in the specified json file./
+      );
     });
 
-    it('should return false', function() {
-      shouldEqual('Parallelize', { parallel: false }, false);
+    it('should throw an error if `no-launch` is used with `replay-execution`.', function() {
+      shouldThrow(
+        'ReplayExecution',
+        {
+          replayExecution: 'test-execution-0000000.json',
+          launch: 'false'
+        },
+        /You must not use `no-launch` option with the `replay-execution` option./
+      );
     });
 
     it('should return true', function() {
-      shouldEqual('Parallelize', { split: 2, parallel: true }, true);
+      shouldEqual(
+        'ReplayExecution',
+        {
+          replayExecution: 'test-execution-0000000.json',
+          replayBrowser: [1, 2]
+        },
+        true
+      );
     });
   });
 });
diff --git a/package.json b/package.json
index 80f422ef8..aabf2f890 100644
--- a/package.json
+++ b/package.json
@@ -32,7 +32,9 @@
     "ember-cli-babel": "^7.5.0",
     "execa": "^1.0.0",
     "fs-extra": "^7.0.1",
-    "rimraf": "^2.6.2"
+    "rimraf": "^2.6.2",
+    "semver": "^5.6.0",
+    "silent-error": "^1.1.1"
   },
   "devDependencies": {
     "@ember/optional-features": "^0.7.0",
@@ -54,6 +56,7 @@
     "ember-try": "^1.1.0",
     "eslint-plugin-ember": "^6.2.0",
     "eslint-plugin-node": "^8.0.0",
+    "fixturify": "^0.3.4",
     "istanbul": "^0.4.3",
     "loader.js": "^4.7.0",
     "mocha": "^6.0.1",
diff --git a/testem.js b/testem.js
index 726d18799..4c225e1d5 100644
--- a/testem.js
+++ b/testem.js
@@ -7,6 +7,7 @@ module.exports = {
   launch_in_dev: [
     'Chrome'
   ],
+  timeout: 15,
   browser_args: {
     Chrome: {
       ci: [
@@ -21,5 +22,6 @@ module.exports = {
         '--window-size=1440,900'
       ].filter(Boolean)
     }
-  }
+  },
+  'parallel': -1
 };
diff --git a/testem.simple-test-page.js b/testem.simple-test-page.js
new file mode 100644
index 000000000..76741b558
--- /dev/null
+++ b/testem.simple-test-page.js
@@ -0,0 +1,3 @@
+module.exports = {
+  'foo': 'bar'
+};
\ No newline at end of file
diff --git a/tests/test-helper.js b/tests/test-helper.js
index 50817fd61..ad7ff8be0 100644
--- a/tests/test-helper.js
+++ b/tests/test-helper.js
@@ -2,9 +2,8 @@
 
 import { setResolver } from '@ember/test-helpers';
 import resolver from './helpers/resolver';
-import loadEmberExam from 'ember-exam/test-support/load';
+import start from 'ember-exam/test-support/start';
 
-const framework = require.has('ember-qunit') ? 'qunit' : 'mocha';
 const oppositeFramework = !require.has('ember-qunit') ? 'qunit' : 'mocha';
 
 Object.keys(require.entries).forEach((entry) => {
@@ -14,12 +13,4 @@ Object.keys(require.entries).forEach((entry) => {
 });
 
 setResolver(resolver);
-
-loadEmberExam();
-
-// ember-qunit >= v3 support
-if (framework === 'qunit') {
-  // Use string literal to prevent Babel to transpile this into ES6 import
-  // that would break when tests run with Mocha framework.
-  require(`ember-${framework}`).start();
-}
+start();
diff --git a/tests/unit/mocha/multiple-ember-tests-test.js b/tests/unit/mocha/multiple-ember-tests-test.js
index be1decfec..e397fad6f 100644
--- a/tests/unit/mocha/multiple-ember-tests-test.js
+++ b/tests/unit/mocha/multiple-ember-tests-test.js
@@ -1,14 +1,36 @@
 import { describeModule, it } from 'ember-mocha';
 import { expect } from 'chai';
 
-describeModule('component:herp-derp', '#1: Module-For With Multiple Tests', function() {
-  it('#1', function() { expect(true).to.be.ok; });
-  it('#2', function() { expect(true).to.be.ok; });
-  it('#3', function() { expect(true).to.be.ok; });
-  it('#4', function() { expect(true).to.be.ok; });
-  it('#5', function() { expect(true).to.be.ok; });
-  it('#6', function() { expect(true).to.be.ok; });
-  it('#7', function() { expect(true).to.be.ok; });
-  it('#8', function() { expect(true).to.be.ok; });
-  it('#9', function() { expect(true).to.be.ok; });
-});
+describeModule(
+  'component:herp-derp',
+  '#1: Module-For With Multiple Tests',
+  function() {
+    it('#1', function() {
+      expect(true).to.be.ok;
+    });
+    it('#2', function() {
+      expect(true).to.be.ok;
+    });
+    it('#3', function() {
+      expect(true).to.be.ok;
+    });
+    it('#4', function() {
+      expect(true).to.be.ok;
+    });
+    it('#5', function() {
+      expect(true).to.be.ok;
+    });
+    it('#6', function() {
+      expect(true).to.be.ok;
+    });
+    it('#7', function() {
+      expect(true).to.be.ok;
+    });
+    it('#8', function() {
+      expect(true).to.be.ok;
+    });
+    it('#9', function() {
+      expect(true).to.be.ok;
+    });
+  }
+);
diff --git a/tests/unit/mocha/multiple-tests-test.js b/tests/unit/mocha/multiple-tests-test.js
index 38569fa13..c87bc2fed 100644
--- a/tests/unit/mocha/multiple-tests-test.js
+++ b/tests/unit/mocha/multiple-tests-test.js
@@ -2,13 +2,31 @@ import { describe, it } from 'mocha';
 import { expect } from 'chai';
 
 describe('#2: Module With Multiple Tests', function() {
-  it('#1', function() { expect(true).to.be.ok; });
-  it('#2', function() { expect(true).to.be.ok; });
-  it('#3', function() { expect(true).to.be.ok; });
-  it('#4', function() { expect(true).to.be.ok; });
-  it('#5', function() { expect(true).to.be.ok; });
-  it('#6', function() { expect(true).to.be.ok; });
-  it('#7', function() { expect(true).to.be.ok; });
-  it('#8', function() { expect(true).to.be.ok; });
-  it('#9', function() { expect(true).to.be.ok; });
+  it('#1', function() {
+    expect(true).to.be.ok;
+  });
+  it('#2', function() {
+    expect(true).to.be.ok;
+  });
+  it('#3', function() {
+    expect(true).to.be.ok;
+  });
+  it('#4', function() {
+    expect(true).to.be.ok;
+  });
+  it('#5', function() {
+    expect(true).to.be.ok;
+  });
+  it('#6', function() {
+    expect(true).to.be.ok;
+  });
+  it('#7', function() {
+    expect(true).to.be.ok;
+  });
+  it('#8', function() {
+    expect(true).to.be.ok;
+  });
+  it('#9', function() {
+    expect(true).to.be.ok;
+  });
 });
diff --git a/tests/unit/mocha/test-loader-test.js b/tests/unit/mocha/test-loader-test.js
index 4e73632d7..52280179b 100644
--- a/tests/unit/mocha/test-loader-test.js
+++ b/tests/unit/mocha/test-loader-test.js
@@ -1,4 +1,4 @@
-import TestLoader from 'ember-cli-test-loader/test-support/index';
+import EmberExamTestLoader from 'ember-exam/test-support/-private/ember-exam-mocha-test-loader';
 import { describe, it, beforeEach, afterEach } from 'mocha';
 import { expect } from 'chai';
 
@@ -6,7 +6,7 @@ describe('Unit | test-loader', function() {
   beforeEach(function() {
     this.originalRequire = window.require;
     this.requiredModules = [];
-    window.require = (name) => {
+    window.require = name => {
       this.requiredModules.push(name);
     };
 
@@ -18,21 +18,18 @@ describe('Unit | test-loader', function() {
       'test-3-test': true,
       'test-3-test.jshint': true,
       'test-4-test': true,
-      'test-4-test.jshint': true,
+      'test-4-test.jshint': true
     };
-
-    this.originalURLParams = TestLoader._urlParams;
+    this.originalURLParams = EmberExamTestLoader._urlParams;
   });
 
   afterEach(function() {
-    TestLoader._urlParams = this.originalURLParams;
     window.require = this.originalRequire;
   });
 
   it('loads all test modules by default', function() {
-    TestLoader._urlParams = {};
-
-    TestLoader.load();
+    const testLoader = new EmberExamTestLoader(this.testem, new Map());
+    testLoader.loadModules();
 
     expect(this.requiredModules).to.deep.equal([
       'test-1-test.jshint',
@@ -42,140 +39,147 @@ describe('Unit | test-loader', function() {
       'test-1-test',
       'test-2-test',
       'test-3-test',
-      'test-4-test',
+      'test-4-test'
     ]);
   });
 
   it('loads modules from a specified partition', function() {
-    TestLoader._urlParams = {
-      _partition: 3,
-      _split: 4,
-    };
-
-    TestLoader.load();
+    const testLoader = new EmberExamTestLoader(
+      this.testem,
+      new Map().set('partition', 3).set('split', 4)
+    );
+    testLoader.loadModules();
 
     expect(this.requiredModules).to.deep.equal([
       'test-3-test.jshint',
-      'test-3-test',
+      'test-3-test'
     ]);
   });
 
   it('loads modules from multiple specified partitions', function() {
-    TestLoader._urlParams = {
-      _partition: [1, 3],
-      _split: 4,
-    };
-
-    TestLoader.load();
+    const testLoader = new EmberExamTestLoader(
+      this.testem,
+      new Map().set('partition', [1, 3]).set('split', 4)
+    );
+    testLoader.loadModules();
 
     expect(this.requiredModules).to.deep.equal([
       'test-1-test.jshint',
       'test-1-test',
       'test-3-test.jshint',
-      'test-3-test',
+      'test-3-test'
     ]);
   });
 
   it('loads modules from the first partition by default', function() {
-    TestLoader._urlParams = {
-      _split: 4,
-    };
-
-    TestLoader.load();
+    const testLoader = new EmberExamTestLoader(
+      this.testem,
+      new Map().set('split', 4)
+    );
+    testLoader.loadModules();
 
     expect(this.requiredModules).to.deep.equal([
       'test-1-test.jshint',
-      'test-1-test',
+      'test-1-test'
     ]);
   });
 
   it('handles params as strings', function() {
-    TestLoader._urlParams = {
-      _partition: '3',
-      _split: '4',
-    };
-
-    TestLoader.load();
+    const testLoader = new EmberExamTestLoader(
+      this.testem,
+      new Map().set('partition', '3').set('split', '4')
+    );
+    testLoader.loadModules();
 
     expect(this.requiredModules).to.deep.equal([
       'test-3-test.jshint',
-      'test-3-test',
+      'test-3-test'
     ]);
   });
 
   it('throws an error if splitting less than one', function() {
-    TestLoader._urlParams = {
-      _split: 0,
-    };
+    const testLoader = new EmberExamTestLoader(
+      this.testem,
+      new Map().set('split', 0)
+    );
 
     expect(() => {
-      TestLoader.load();
+      testLoader.loadModules();
     }).to.throw(/You must specify a split greater than 0/);
   });
 
   it('throws an error if partition isn\'t a number', function() {
-    TestLoader._urlParams = {
-      _split: 2,
-      _partition: 'foo',
-    };
+    const testLoader = new EmberExamTestLoader(
+      this.testem,
+      new Map().set('split', 2).set('partition', 'foo')
+    );
 
     expect(() => {
-      TestLoader.load();
-    }).to.throw(/You must specify numbers for partition \(you specified 'foo'\)/);
+      testLoader.loadModules();
+    }).to.throw(
+      /You must specify numbers for partition \(you specified 'foo'\)/
+    );
   });
 
   it('throws an error if partition isn\'t a number with multiple partitions', function() {
-    TestLoader._urlParams = {
-      _split: 2,
-      _partition: [1, 'foo'],
-    };
+    const testLoader = new EmberExamTestLoader(
+      this.testem,
+      new Map().set('split', 2).set('partition', [1, 'foo'])
+    );
 
     expect(() => {
-      TestLoader.load();
-    }).to.throw(/You must specify numbers for partition \(you specified '1,foo'\)/);
+      testLoader.loadModules();
+    }).to.throw(
+      /You must specify numbers for partition \(you specified '1,foo'\)/
+    );
   });
 
   it('throws an error if loading partition greater than split number', function() {
-    TestLoader._urlParams = {
-      _split: 2,
-      _partition: 3,
-    };
+    const testLoader = new EmberExamTestLoader(
+      this.testem,
+      new Map().set('split', 2).set('partition', 3)
+    );
 
     expect(() => {
-      TestLoader.load();
-    }).to.throw(/You must specify partitions numbered less than or equal to your split value/);
+      testLoader.loadModules();
+    }).to.throw(
+      /You must specify partitions numbered less than or equal to your split value/
+    );
   });
 
   it('throws an error if loading partition greater than split number with multiple partitions', function() {
-    TestLoader._urlParams = {
-      _split: 2,
-      _partition: [2, 3],
-    };
+    const testLoader = new EmberExamTestLoader(
+      this.testem,
+      new Map().set('split', 2).set('partition', [2, 3])
+    );
 
     expect(() => {
-      TestLoader.load();
-    }).to.throw(/You must specify partitions numbered less than or equal to your split value/);
+      testLoader.loadModules();
+    }).to.throw(
+      /You must specify partitions numbered less than or equal to your split value/
+    );
   });
 
   it('throws an error if loading partition less than one', function() {
-    TestLoader._urlParams = {
-      _split: 2,
-      _partition: 0,
-    };
+    const testLoader = new EmberExamTestLoader(
+      this.testem,
+      new Map().set('split', 2).set('partition', 0)
+    );
 
     expect(() => {
-      TestLoader.load();
+      testLoader.loadModules();
     }).to.throw(/You must specify partitions numbered greater than 0/);
   });
 
   it('load works without lint tests', function() {
-    TestLoader._urlParams = {
-      nolint: true,
-      _partition: 4,
-      _split: 4,
-    };
-
-    TestLoader.load();
+    const testLoader = new EmberExamTestLoader(
+      this.testem,
+      new Map()
+        .set('nolint', true)
+        .set('partition', 4)
+        .set('split', 4)
+    );
+    testLoader.loadModules();
 
     // ember-cli-mocha doesn't support disabling linting by url param
     expect(this.requiredModules).to.deep.equal([
@@ -185,26 +189,29 @@ describe('Unit | test-loader', function() {
   });
 
   it('load works without non-lint tests', function() {
+    const testLoader = new EmberExamTestLoader(
+      this.testem,
+      new Map().set('partition', 4).set('split', 4)
+    );
+
     window.requirejs.entries = {
       'test-1-test.jshint': true,
       'test-2-test.jshint': true,
       'test-3-test.jshint': true,
-      'test-4-test.jshint': true,
-    };
-
-    TestLoader._urlParams = {
-      _partition: 4,
-      _split: 4,
+      'test-4-test.jshint': true
     };
 
-    TestLoader.load();
+    testLoader.loadModules();
 
-    expect(this.requiredModules).to.deep.equal([
-      'test-4-test.jshint',
-    ]);
+    expect(this.requiredModules).to.deep.equal(['test-4-test.jshint']);
   });
 
   it('load works with a double-digit single partition', function() {
+    const testLoader = new EmberExamTestLoader(
+      this.testem,
+      new Map().set('partition', '10').set('split', 10)
+    );
+
     window.requirejs.entries = {
       'test-1-test': true,
       'test-2-test': true,
@@ -215,19 +222,15 @@ describe('Unit | test-loader', function() {
       'test-7-test': true,
       'test-8-test': true,
       'test-9-test': true,
-      'test-10-test': true,
+      'test-10-test': true
     };
 
-    TestLoader._urlParams = {
-      _partition: '10',
-      _split: 10,
-    };
+    testLoader.loadModules();
 
-    TestLoader.load();
+    expect(this.requiredModules).to.deep.equal(['test-10-test']);
+  });
 
-    expect(this.requiredModules).to.deep.equal([
-      'test-10-test',
-    ]);
+  it('dummy test to even out the number of tests', function() {
+    expect(true).to.be.ok;
   });
 });
-
diff --git a/tests/unit/mocha/testem-output-test.js b/tests/unit/mocha/testem-output-test.js
new file mode 100644
index 000000000..a62b0c20e
--- /dev/null
+++ b/tests/unit/mocha/testem-output-test.js
@@ -0,0 +1,45 @@
+import { describe, it } from 'mocha';
+import { expect } from 'chai';
+import TestemOutput from 'ember-exam/test-support/-private/patch-testem-output';
+
+describe('Unit | patch-testem-output', () => {
+  it('add partition number to test name when `split` is passed', function() {
+    expect(
+      TestemOutput.updateTestName(
+        new Map().set('split', 2),
+        'test_module | test_name'
+      )
+    ).to.deepEqual('Exam Partition 1 - test_module | test_name');
+  });
+
+  it('add partition number to test name when `split` and `partition` are passed', function() {
+    expect(
+      TestemOutput.updateTestName(
+        new Map().set('split', 2).set('partition', 2),
+        'test_module | test_name'
+      )
+    ).to.deepEqual('Exam Partition 2 - test_module | test_name');
+  });
+
+  it('add browser number to test name when `loadBalance` and `browser` are passed', function() {
+    expect(
+      TestemOutput.updateTestName(
+        new Map().set('loadBalance', 2).set('browser', 1),
+        'test_module | test_name'
+      )
+    ).to.deepEqual('Browser Id 1 - test_module | test_name');
+  });
+
+  it('add partition number, browser number to test name when `split`, `partition`, `browser`, and `loadBalance` are  passed', function() {
+    expect(
+      TestemOutput.updateTestName(
+        new Map()
+          .set('split', 2)
+          .set('partition', 2)
+          .set('browser', 1)
+          .set('loadBalance', 2),
+        'test_module | test_name'
+      )
+    ).to.deepEqual('Exam Partition 2 - Browser Id 1 - test_module | test_name');
+  });
+});
diff --git a/tests/unit/mocha/weight-test-modules-test.js b/tests/unit/mocha/weight-test-modules-test.js
new file mode 100644
index 000000000..8894258f9
--- /dev/null
+++ b/tests/unit/mocha/weight-test-modules-test.js
@@ -0,0 +1,51 @@
+import weightTestModules from 'ember-exam/test-support/-private/weight-test-modules';
+import { describe, it } from 'mocha';
+import { expect } from 'chai';
+
+describe('Unit | weight-test-modules', () => {
+  it('should sort a list of file paths by weight', function() {
+    const listOfModules = [
+      '/eslint/test-1-test',
+      '/acceptance/test-1-test',
+      '/unit/test-1-test',
+      '/integration/test-1-test',
+      'test-1-test'
+    ];
+
+    expect(weightTestModules(listOfModules)).to.deep.equal([
+      '/acceptance/test-1-test',
+      'test-1-test',
+      '/integration/test-1-test',
+      '/unit/test-1-test',
+      '/eslint/test-1-test'
+    ]);
+  });
+
+  it('should sort a list of file paths by weight and alphbetical order', function() {
+    const listOfModules = [
+      'test-b-test',
+      'test-a-test',
+      '/eslint/test-b-test',
+      '/integration/test-b-test',
+      '/integration/test-a-test',
+      '/unit/test-b-test',
+      '/acceptance/test-b-test',
+      '/acceptance/test-a-test',
+      '/unit/test-a-test',
+      '/eslint/test-a-test'
+    ];
+
+    expect(weightTestModules(listOfModules)).to.deep.equal([
+      '/acceptance/test-a-test',
+      '/acceptance/test-b-test',
+      'test-a-test',
+      'test-b-test',
+      '/integration/test-a-test',
+      '/integration/test-b-test',
+      '/unit/test-a-test',
+      '/unit/test-b-test',
+      '/eslint/test-a-test',
+      '/eslint/test-b-test'
+    ]);
+  });
+});
diff --git a/tests/unit/qunit/async-iterator-test.js b/tests/unit/qunit/async-iterator-test.js
new file mode 100644
index 000000000..3e40e4479
--- /dev/null
+++ b/tests/unit/qunit/async-iterator-test.js
@@ -0,0 +1,176 @@
+import AsyncIterator from 'ember-exam/test-support/-private/async-iterator';
+import { module, test } from 'qunit';
+
+module('Unit | async-iterator', {
+  beforeEach() {
+    this.testem = {
+      eventHandler: new Array(),
+      emit: function(event) {
+        const argsWithoutFirst = Array.prototype.slice.call(arguments, 1);
+        if (this.eventHandler && this.eventHandler[event]) {
+          let handlers = this.eventHandler[event];
+          for (let i = 0; i < handlers.length; i++) {
+            handlers[i].apply(this, argsWithoutFirst);
+          }
+        }
+      },
+      on: function(event, callBack) {
+        if (!this.eventHandler) {
+          this.eventHandler = {};
+        }
+        if (!this.eventHandler[event]) {
+          this.eventHandler[event] = [];
+        }
+        this.eventHandler[event].push(callBack);
+      },
+      removeEventCallbacks: () => {}
+    };
+  }
+});
+
+test('should instantiate', function(assert) {
+  let iteratorOfPromises = new AsyncIterator(this.testem, {
+    request: 'next-module-request',
+    response: 'next-module-response'
+  });
+
+  assert.deepEqual(iteratorOfPromises.done, false);
+  assert.deepEqual(typeof iteratorOfPromises.next, 'function');
+  assert.deepEqual(typeof iteratorOfPromises.dispose, 'function');
+});
+
+test('should get the value from response.', function(assert) {
+  assert.expect(1);
+  const done = assert.async();
+  this.testem.on('next-module-request', () => {
+    this.testem.emit('next-module-response', {
+      done: false,
+      value: 'a'
+    });
+  });
+
+  const iteratorOfPromises = new AsyncIterator(this.testem, {
+    request: 'next-module-request',
+    response: 'next-module-response'
+  });
+
+  iteratorOfPromises.next().then(result => {
+    assert.deepEqual('a', result.value);
+    done();
+  });
+});
+
+test('should iterate promises until there is no response.', function(assert) {
+  assert.expect(1);
+  const done = assert.async();
+  const testem = this.testem;
+  const responses = ['a', 'b', 'c'];
+
+  testem.on('next-module-request', () => {
+    testem.emit('next-module-response', {
+      done: responses.length === 0,
+      value: responses.shift()
+    });
+  });
+
+  const iteratorOfPromises = new AsyncIterator(testem, {
+    request: 'next-module-request',
+    response: 'next-module-response'
+  });
+
+  let values = [];
+
+  iteratorOfPromises
+    .next()
+    .then(res => {
+      values.push(res.value);
+      return iteratorOfPromises.next();
+    })
+    .then(res => {
+      values.push(res.value);
+      return iteratorOfPromises.next();
+    })
+    .then(res => {
+      values.push(res.value);
+      assert.deepEqual(values, ['a', 'b', 'c']);
+      done();
+    });
+});
+
+test('should return false after disposing', function(assert) {
+  const iteratorOfPromises = new AsyncIterator(this.testem, {
+    request: 'next-module-request',
+    response: 'next-module-response'
+  });
+
+  iteratorOfPromises.dispose();
+
+  assert.deepEqual(iteratorOfPromises.done, true);
+});
+
+test('should dispose after iteration.', function(assert) {
+  assert.expect(4);
+  const done = assert.async();
+  const testem = this.testem;
+  const responses = ['a', 'b', 'c'];
+
+  testem.on('next-module-request', () => {
+    testem.emit('next-module-response', {
+      done: responses.length === 0,
+      value: responses.shift()
+    });
+  });
+
+  const iteratorOfPromises = new AsyncIterator(testem, {
+    request: 'next-module-request',
+    response: 'next-module-response'
+  });
+
+  iteratorOfPromises
+    .next()
+    .then(res => {
+      assert.deepEqual(res.done, false);
+      return iteratorOfPromises.next();
+    })
+    .then(res => {
+      assert.deepEqual(res.done, false);
+      return iteratorOfPromises.next();
+    })
+    .then(res => {
+      assert.deepEqual(res.done, false);
+      return iteratorOfPromises.next();
+    })
+    .then(res => {
+      assert.deepEqual(res.done, true);
+      done();
+    });
+});
+
+test('should throw a timout error if request is not handled within 2s', function(assert) {
+  assert.expect(1);
+  const done = assert.async();
+  const iteratorOfPromises = new AsyncIterator(this.testem, {
+    request: 'next-module-request',
+    response: 'next-module-response'
+  });
+
+  iteratorOfPromises.next().catch(err => {
+    assert.deepEqual(
+      err.message,
+      'EmberExam: Promise timed out after 2 s while waiting for response for next-module-request'
+    );
+    done();
+  });
+});
+
+test('should throw an error if handleResponse is invoked while not waiting for a response', function(assert) {
+  const iteratorOfPromises = new AsyncIterator(this.testem, {
+    request: 'next-module-request',
+    response: 'next-module-response'
+  });
+
+  assert.throws(
+    () => iteratorOfPromises.handleResponse({}),
+    /Was not expecting a response, but got a response/
+  );
+});
diff --git a/tests/unit/qunit/multiple-edge-cases-test.js b/tests/unit/qunit/multiple-edge-cases-test.js
index ded488435..0ac1bec74 100644
--- a/tests/unit/qunit/multiple-edge-cases-test.js
+++ b/tests/unit/qunit/multiple-edge-cases-test.js
@@ -2,4 +2,6 @@ import { module, test } from 'qunit';
 
 module('#3: Module With Multiple Edge Case Tests');
 
-test('#1 RegExp test', function(assert) { assert.ok(/derp/.test('derp')); });
+test('#1 RegExp test', function(assert) {
+  assert.ok(/derp/.test('derp'));
+});
diff --git a/tests/unit/qunit/multiple-ember-tests-test.js b/tests/unit/qunit/multiple-ember-tests-test.js
index f8f465650..de11933ac 100644
--- a/tests/unit/qunit/multiple-ember-tests-test.js
+++ b/tests/unit/qunit/multiple-ember-tests-test.js
@@ -2,12 +2,30 @@ import { moduleFor, test } from 'ember-qunit';
 
 moduleFor('component:herp-derp', '#1: Module-For With Multiple Tests');
 
-test('#1', function(assert) { assert.ok(true); });
-test('#2', function(assert) { assert.ok(true); });
-test('#3', function(assert) { assert.ok(true); });
-test('#4', function(assert) { assert.ok(true); });
-test('#5', function(assert) { assert.ok(true); });
-test('#6', function(assert) { assert.ok(true); });
-test('#7', function(assert) { assert.ok(true); });
-test('#8', function(assert) { assert.ok(true); });
-test('#9', function(assert) { assert.ok(true); });
+test('#1', function(assert) {
+  assert.ok(true);
+});
+test('#2', function(assert) {
+  assert.ok(true);
+});
+test('#3', function(assert) {
+  assert.ok(true);
+});
+test('#4', function(assert) {
+  assert.ok(true);
+});
+test('#5', function(assert) {
+  assert.ok(true);
+});
+test('#6', function(assert) {
+  assert.ok(true);
+});
+test('#7', function(assert) {
+  assert.ok(true);
+});
+test('#8', function(assert) {
+  assert.ok(true);
+});
+test('#9', function(assert) {
+  assert.ok(true);
+});
diff --git a/tests/unit/qunit/multiple-tests-test.js b/tests/unit/qunit/multiple-tests-test.js
index 105ed63b1..bfb480181 100644
--- a/tests/unit/qunit/multiple-tests-test.js
+++ b/tests/unit/qunit/multiple-tests-test.js
@@ -2,12 +2,30 @@ import { module, test } from 'qunit';
 
 module('#2: Module With Multiple Tests');
 
-test('#1', function(assert) { assert.ok(true); });
-test('#2', function(assert) { assert.ok(true); });
-test('#3', function(assert) { assert.ok(true); });
-test('#4', function(assert) { assert.ok(true); });
-test('#5', function(assert) { assert.ok(true); });
-test('#6', function(assert) { assert.ok(true); });
-test('#7', function(assert) { assert.ok(true); });
-test('#8', function(assert) { assert.ok(true); });
-test('#9', function(assert) { assert.ok(true); });
+test('#1', function(assert) {
+  assert.ok(true);
+});
+test('#2', function(assert) {
+  assert.ok(true);
+});
+test('#3', function(assert) {
+  assert.ok(true);
+});
+test('#4', function(assert) {
+  assert.ok(true);
+});
+test('#5', function(assert) {
+  assert.ok(true);
+});
+test('#6', function(assert) {
+  assert.ok(true);
+});
+test('#7', function(assert) {
+  assert.ok(true);
+});
+test('#8', function(assert) {
+  assert.ok(true);
+});
+test('#9', function(assert) {
+  assert.ok(true);
+});
diff --git a/tests/unit/qunit/test-loader-test.js b/tests/unit/qunit/test-loader-test.js
index c8e01fe22..f8e8d314a 100644
--- a/tests/unit/qunit/test-loader-test.js
+++ b/tests/unit/qunit/test-loader-test.js
@@ -1,11 +1,11 @@
-import TestLoader from 'ember-cli-test-loader/test-support/index';
+import EmberExamTestLoader from 'ember-exam/test-support/-private/ember-exam-qunit-test-loader';
 import QUnit, { module, test } from 'qunit';
 
 module('Unit | test-loader', {
   beforeEach() {
     this.originalRequire = window.require;
     this.requiredModules = [];
-    window.require = (name) => {
+    window.require = name => {
       this.requiredModules.push(name);
     };
 
@@ -17,22 +17,36 @@ module('Unit | test-loader', {
       'test-3-test': true,
       'test-3-test.jshint': true,
       'test-4-test': true,
-      'test-4-test.jshint': true,
+      'test-4-test.jshint': true
+    };
+    this.testem = {
+      eventQueue: new Array(),
+      emit: function(event) {
+        this.eventQueue.push(event);
+      },
+      on: () => {}
+    };
+    this.qunit = {
+      config: {
+        queue: []
+      },
+      begin: () => {},
+      moduleDone: () => {}
     };
-
-    this.originalURLParams = TestLoader._urlParams;
   },
 
   afterEach() {
-    TestLoader._urlParams = this.originalURLParams;
     window.require = this.originalRequire;
   }
 });
 
 test('loads all test modules by default', function(assert) {
-  TestLoader._urlParams = {};
-
-  TestLoader.load();
+  const testLoader = new EmberExamTestLoader(
+    this.testem,
+    new Map(),
+    this.qunit
+  );
+  testLoader.loadModules();
 
   assert.deepEqual(this.requiredModules, [
     'test-1-test.jshint',
@@ -42,144 +56,142 @@ test('loads all test modules by default', function(assert) {
     'test-1-test',
     'test-2-test',
     'test-3-test',
-    'test-4-test',
+    'test-4-test'
   ]);
 });
 
 test('loads modules from a specified partition', function(assert) {
-  TestLoader._urlParams = {
-    _partition: 3,
-    _split: 4,
-  };
-
-  TestLoader.load();
-
-  assert.deepEqual(this.requiredModules, [
-    'test-3-test.jshint',
-    'test-3-test',
-  ]);
+  const testLoader = new EmberExamTestLoader(
+    this.testem,
+    new Map().set('partition', 3).set('split', 4),
+    this.qunit
+  );
+  testLoader.loadModules();
+
+  assert.deepEqual(this.requiredModules, ['test-3-test.jshint', 'test-3-test']);
 });
 
 test('loads modules from multiple specified partitions', function(assert) {
-  TestLoader._urlParams = {
-    _partition: [1, 3],
-    _split: 4,
-  };
-
-  TestLoader.load();
+  const testLoader = new EmberExamTestLoader(
+    this.testem,
+    new Map().set('partition', [1, 3]).set('split', 4),
+    this.qunit
+  );
+  testLoader.loadModules();
 
   assert.deepEqual(this.requiredModules, [
     'test-1-test.jshint',
     'test-1-test',
     'test-3-test.jshint',
-    'test-3-test',
+    'test-3-test'
   ]);
 });
 
 test('loads modules from the first partition by default', function(assert) {
-  TestLoader._urlParams = {
-    _split: 4,
-  };
-
-  TestLoader.load();
-
-  assert.deepEqual(this.requiredModules, [
-    'test-1-test.jshint',
-    'test-1-test',
-  ]);
+  const testLoader = new EmberExamTestLoader(
+    this.testem,
+    new Map().set('split', 4),
+    this.qunit
+  );
+  testLoader.loadModules();
+
+  assert.deepEqual(this.requiredModules, ['test-1-test.jshint', 'test-1-test']);
 });
 
 test('handles params as strings', function(assert) {
-  TestLoader._urlParams = {
-    _partition: '3',
-    _split: '4',
-  };
-
-  TestLoader.load();
-
-  assert.deepEqual(this.requiredModules, [
-    'test-3-test.jshint',
-    'test-3-test',
-  ]);
+  const testLoader = new EmberExamTestLoader(
+    this.testem,
+    new Map().set('partition', 3).set('split', 4),
+    this.qunit
+  );
+  testLoader.loadModules();
+
+  assert.deepEqual(this.requiredModules, ['test-3-test.jshint', 'test-3-test']);
 });
 
 test('throws an error if splitting less than one', function(assert) {
-  TestLoader._urlParams = {
-    _split: 0,
-  };
+  const testLoader = new EmberExamTestLoader(
+    this.testem,
+    new Map().set('split', 0),
+    this.qunit
+  );
 
   assert.throws(() => {
-    TestLoader.load();
+    testLoader.loadModules();
   }, /You must specify a split greater than 0/);
 });
 
 test('throws an error if partition isn\'t a number', function(assert) {
-  TestLoader._urlParams = {
-    _split: 2,
-    _partition: 'foo',
-  };
+  const testLoader = new EmberExamTestLoader(
+    this.testem,
+    new Map().set('split', 2).set('partition', 'foo'),
+    this.qunit
+  );
 
   assert.throws(() => {
-    TestLoader.load();
+    testLoader.loadModules();
   }, /You must specify numbers for partition \(you specified 'foo'\)/);
 });
 
 test('throws an error if partition isn\'t a number with multiple partitions', function(assert) {
-  TestLoader._urlParams = {
-    _split: 2,
-    _partition: [1, 'foo'],
-  };
+  const testLoader = new EmberExamTestLoader(
+    this.testem,
+    new Map().set('split', 2).set('partition', [1, 'foo']),
+    this.qunit
+  );
 
   assert.throws(() => {
-    TestLoader.load();
+    testLoader.loadModules();
   }, /You must specify numbers for partition \(you specified '1,foo'\)/);
 });
 
 test('throws an error if loading partition greater than split number', function(assert) {
-  TestLoader._urlParams = {
-    _split: 2,
-    _partition: 3,
-  };
+  const testLoader = new EmberExamTestLoader(
+    this.testem,
+    new Map().set('split', 2).set('partition', 3),
+    this.qunit
+  );
 
   assert.throws(() => {
-    TestLoader.load();
+    testLoader.loadModules();
   }, /You must specify partitions numbered less than or equal to your split value/);
 });
 
 test('throws an error if loading partition greater than split number with multiple partitions', function(assert) {
-  TestLoader._urlParams = {
-    _split: 2,
-    _partition: [2, 3],
-  };
+  const testLoader = new EmberExamTestLoader(
+    this.testem,
+    new Map().set('split', 2).set('partition', [2, 3]),
+    this.qunit
+  );
 
   assert.throws(() => {
-    TestLoader.load();
+    testLoader.loadModules();
   }, /You must specify partitions numbered less than or equal to your split value/);
 });
 
 test('throws an error if loading partition less than one', function(assert) {
-  TestLoader._urlParams = {
-    _split: 2,
-    _partition: 0,
-  };
+  const testLoader = new EmberExamTestLoader(
+    this.testem,
+    new Map().set('split', 2).set('partition', 0),
+    this.qunit
+  );
 
   assert.throws(() => {
-    TestLoader.load();
+    testLoader.loadModules();
   }, /You must specify partitions numbered greater than 0/);
 });
 
 test('load works without lint tests', function(assert) {
   QUnit.urlParams.nolint = true;
-  TestLoader._urlParams = {
-    _partition: 4,
-    _split: 4,
-  };
+  const testLoader = new EmberExamTestLoader(
+    this.testem,
+    new Map().set('partition', 4).set('split', 4),
+    this.qunit
+  );
 
-  TestLoader.load();
+  testLoader.loadModules();
 
-  assert.deepEqual(this.requiredModules, [
-    'test-4-test',
-  ]);
+  assert.deepEqual(this.requiredModules, ['test-4-test']);
 
   QUnit.urlParams.nolint = false;
 });
@@ -189,19 +201,18 @@ test('load works without non-lint tests', function(assert) {
     'test-1-test.jshint': true,
     'test-2-test.jshint': true,
     'test-3-test.jshint': true,
-    'test-4-test.jshint': true,
+    'test-4-test.jshint': true
   };
 
-  TestLoader._urlParams = {
-    _partition: 4,
-    _split: 4,
-  };
+  const testLoader = new EmberExamTestLoader(
+    this.testem,
+    new Map().set('partition', 4).set('split', 4),
+    this.qunit
+  );
 
-  TestLoader.load();
+  testLoader.loadModules();
 
-  assert.deepEqual(this.requiredModules, [
-    'test-4-test.jshint',
-  ]);
+  assert.deepEqual(this.requiredModules, ['test-4-test.jshint']);
 });
 
 test('load works with a double-digit single partition', function(assert) {
@@ -215,17 +226,32 @@ test('load works with a double-digit single partition', function(assert) {
     'test-7-test': true,
     'test-8-test': true,
     'test-9-test': true,
-    'test-10-test': true,
+    'test-10-test': true
   };
 
-  TestLoader._urlParams = {
-    _partition: '10',
-    _split: 10,
-  };
+  const testLoader = new EmberExamTestLoader(
+    this.testem,
+    new Map().set('partition', '10').set('split', 10),
+    this.qunit
+  );
 
-  TestLoader.load();
+  testLoader.loadModules();
 
-  assert.deepEqual(this.requiredModules, [
-    'test-10-test',
-  ]);
+  assert.deepEqual(this.requiredModules, ['test-10-test']);
+});
+
+test('emit then `set-modules-queue` event when load balance option is true', function(assert) {
+  const testLoader = new EmberExamTestLoader(
+    this.testem,
+    new Map().set('loadBalance', true),
+    this.qunit
+  );
+
+  testLoader.loadModules();
+
+  assert.deepEqual(
+    this.testem.eventQueue,
+    ['testem:set-modules-queue'],
+    'testem:set-modules-queue event was fired'
+  );
 });
diff --git a/tests/unit/qunit/testem-output-test.js b/tests/unit/qunit/testem-output-test.js
new file mode 100644
index 000000000..d90efd011
--- /dev/null
+++ b/tests/unit/qunit/testem-output-test.js
@@ -0,0 +1,48 @@
+import { module, test } from 'qunit';
+import TestemOutput from 'ember-exam/test-support/-private/patch-testem-output';
+
+module('Unit | patch-testem-output', () => {
+  test('add partition number to test name when `split` is passed', function(assert) {
+    assert.deepEqual(
+      'Exam Partition 1 - test_module | test_name',
+      TestemOutput.updateTestName(
+        new Map().set('split', 2),
+        'test_module | test_name'
+      )
+    );
+  });
+
+  test('add partition number to test name when `split` and `partition` are passed', function(assert) {
+    assert.deepEqual(
+      'Exam Partition 2 - test_module | test_name',
+      TestemOutput.updateTestName(
+        new Map().set('split', 2).set('partition', 2),
+        'test_module | test_name'
+      )
+    );
+  });
+
+  test('add browser number to test name when `loadBalance` and `browser` are passed', function(assert) {
+    assert.deepEqual(
+      'Browser Id 1 - test_module | test_name',
+      TestemOutput.updateTestName(
+        new Map().set('loadBalance', 2).set('browser', 1),
+        'test_module | test_name'
+      )
+    );
+  });
+
+  test('add partition number, browser number to test name when `split`, `partition`, `browser`, and `loadBalance` are  passed', function(assert) {
+    assert.deepEqual(
+      'Exam Partition 2 - Browser Id 1 - test_module | test_name',
+      TestemOutput.updateTestName(
+        new Map()
+          .set('split', 2)
+          .set('partition', 2)
+          .set('browser', 1)
+          .set('loadBalance', 2),
+        'test_module | test_name'
+      )
+    );
+  });
+});
diff --git a/tests/unit/qunit/weight-test-modules-test.js b/tests/unit/qunit/weight-test-modules-test.js
new file mode 100644
index 000000000..4181fa79b
--- /dev/null
+++ b/tests/unit/qunit/weight-test-modules-test.js
@@ -0,0 +1,56 @@
+import { module, test } from 'qunit';
+import weightTestModules from 'ember-exam/test-support/-private/weight-test-modules';
+
+module('Unit | weight-test-modules', () => {
+  test('should sort a list of file paths by weight', function(assert) {
+    const listOfModules = [
+      '/eslint/test-1-test',
+      '/acceptance/test-1-test',
+      '/unit/test-1-test',
+      '/integration/test-1-test',
+      'test-1-test'
+    ];
+
+    assert.deepEqual(
+      [
+        '/acceptance/test-1-test',
+        'test-1-test',
+        '/integration/test-1-test',
+        '/unit/test-1-test',
+        '/eslint/test-1-test'
+      ],
+      weightTestModules(listOfModules)
+    );
+  });
+
+  test('should sort a list of file paths by weight and alphbetical order', function(assert) {
+    const listOfModules = [
+      'test-b-test',
+      'test-a-test',
+      '/eslint/test-b-test',
+      '/integration/test-b-test',
+      '/integration/test-a-test',
+      '/unit/test-b-test',
+      '/acceptance/test-b-test',
+      '/acceptance/test-a-test',
+      '/unit/test-a-test',
+      '/eslint/test-a-test'
+    ];
+
+    assert.deepEqual(
+      [
+        '/acceptance/test-a-test',
+        '/acceptance/test-b-test',
+        'test-a-test',
+        'test-b-test',
+        '/integration/test-a-test',
+        '/integration/test-b-test',
+        '/unit/test-a-test',
+        '/unit/test-b-test',
+        '/eslint/test-a-test',
+        '/eslint/test-b-test'
+      ],
+      weightTestModules(listOfModules)
+    );
+  });
+});
diff --git a/yarn.lock b/yarn.lock
index 8941d3cee..4db1633be 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -10,17 +10,17 @@
     "@babel/highlight" "^7.0.0"
 
 "@babel/core@^7.0.0":
-  version "7.1.6"
-  resolved "https://registry.yarnpkg.com/@babel/core/-/core-7.1.6.tgz#3733cbee4317429bc87c62b29cf8587dba7baeb3"
-  integrity sha512-Hz6PJT6e44iUNpAn8AoyAs6B3bl60g7MJQaI0rZEar6ECzh6+srYO1xlIdssio34mPaUtAb1y+XlkkSJzok3yw==
+  version "7.2.0"
+  resolved "https://registry.yarnpkg.com/@babel/core/-/core-7.2.0.tgz#a4dd3814901998e93340f0086e9867fefa163ada"
+  integrity sha512-7pvAdC4B+iKjFFp9Ztj0QgBndJ++qaMeonT185wAqUnhipw8idm9Rv1UMyBuKtYjfl6ORNkgEgcsYLfHX/GpLw==
   dependencies:
     "@babel/code-frame" "^7.0.0"
-    "@babel/generator" "^7.1.6"
-    "@babel/helpers" "^7.1.5"
-    "@babel/parser" "^7.1.6"
+    "@babel/generator" "^7.2.0"
+    "@babel/helpers" "^7.2.0"
+    "@babel/parser" "^7.2.0"
     "@babel/template" "^7.1.2"
     "@babel/traverse" "^7.1.6"
-    "@babel/types" "^7.1.6"
+    "@babel/types" "^7.2.0"
     convert-source-map "^1.1.0"
     debug "^4.1.0"
     json5 "^2.1.0"
@@ -29,12 +29,12 @@
     semver "^5.4.1"
     source-map "^0.5.0"
 
-"@babel/generator@^7.0.0", "@babel/generator@^7.1.6":
-  version "7.1.6"
-  resolved "https://registry.yarnpkg.com/@babel/generator/-/generator-7.1.6.tgz#001303cf87a5b9d093494a4bf251d7b5d03d3999"
-  integrity sha512-brwPBtVvdYdGxtenbQgfCdDPmtkmUBZPjUoK5SXJEBuHaA5BCubh9ly65fzXz7R6o5rA76Rs22ES8Z+HCc0YIQ==
+"@babel/generator@^7.0.0", "@babel/generator@^7.1.6", "@babel/generator@^7.2.0":
+  version "7.2.0"
+  resolved "https://registry.yarnpkg.com/@babel/generator/-/generator-7.2.0.tgz#eaf3821fa0301d9d4aef88e63d4bcc19b73ba16c"
+  integrity sha512-BA75MVfRlFQG2EZgFYIwyT1r6xSkwfP2bdkY/kLZusEYWiJs4xCowab/alaEaT0wSvmVuXGqiefeBlP+7V1yKg==
   dependencies:
-    "@babel/types" "^7.1.6"
+    "@babel/types" "^7.2.0"
     jsesc "^2.5.1"
     lodash "^4.17.10"
     source-map "^0.5.0"
@@ -186,23 +186,23 @@
     "@babel/types" "^7.0.0"
 
 "@babel/helper-wrap-function@^7.1.0":
-  version "7.1.0"
-  resolved "https://registry.yarnpkg.com/@babel/helper-wrap-function/-/helper-wrap-function-7.1.0.tgz#8cf54e9190706067f016af8f75cb3df829cc8c66"
-  integrity sha512-R6HU3dete+rwsdAfrOzTlE9Mcpk4RjU3aX3gi9grtmugQY0u79X7eogUvfXA5sI81Mfq1cn6AgxihfN33STjJA==
+  version "7.2.0"
+  resolved "https://registry.yarnpkg.com/@babel/helper-wrap-function/-/helper-wrap-function-7.2.0.tgz#c4e0012445769e2815b55296ead43a958549f6fa"
+  integrity sha512-o9fP1BZLLSrYlxYEYyl2aS+Flun5gtjTIG8iln+XuEzQTs0PLagAGSXUcqruJwD5fM48jzIEggCKpIfWTcR7pQ==
   dependencies:
     "@babel/helper-function-name" "^7.1.0"
     "@babel/template" "^7.1.0"
     "@babel/traverse" "^7.1.0"
-    "@babel/types" "^7.0.0"
+    "@babel/types" "^7.2.0"
 
-"@babel/helpers@^7.1.5":
-  version "7.1.5"
-  resolved "https://registry.yarnpkg.com/@babel/helpers/-/helpers-7.1.5.tgz#68bfc1895d685f2b8f1995e788dbfe1f6ccb1996"
-  integrity sha512-2jkcdL02ywNBry1YNFAH/fViq4fXG0vdckHqeJk+75fpQ2OH+Az6076tX/M0835zA45E0Cqa6pV5Kiv9YOqjEg==
+"@babel/helpers@^7.2.0":
+  version "7.2.0"
+  resolved "https://registry.yarnpkg.com/@babel/helpers/-/helpers-7.2.0.tgz#8335f3140f3144270dc63c4732a4f8b0a50b7a21"
+  integrity sha512-Fr07N+ea0dMcMN8nFpuK6dUIT7/ivt9yKQdEEnjVS83tG2pHwPi03gYmk/tyuwONnZ+sY+GFFPlWGgCtW1hF9A==
   dependencies:
     "@babel/template" "^7.1.2"
     "@babel/traverse" "^7.1.5"
-    "@babel/types" "^7.1.5"
+    "@babel/types" "^7.2.0"
 
 "@babel/highlight@^7.0.0":
   version "7.0.0"
@@ -213,116 +213,116 @@
     esutils "^2.0.2"
     js-tokens "^4.0.0"
 
-"@babel/parser@^7.0.0", "@babel/parser@^7.1.2", "@babel/parser@^7.1.6":
-  version "7.1.6"
-  resolved "https://registry.yarnpkg.com/@babel/parser/-/parser-7.1.6.tgz#16e97aca1ec1062324a01c5a6a7d0df8dd189854"
-  integrity sha512-dWP6LJm9nKT6ALaa+bnL247GHHMWir3vSlZ2+IHgHgktZQx0L3Uvq2uAWcuzIe+fujRsYWBW2q622C5UvGK9iQ==
+"@babel/parser@^7.0.0", "@babel/parser@^7.1.2", "@babel/parser@^7.1.6", "@babel/parser@^7.2.0":
+  version "7.2.0"
+  resolved "https://registry.yarnpkg.com/@babel/parser/-/parser-7.2.0.tgz#02d01dbc330b6cbf36b76ac93c50752c69027065"
+  integrity sha512-M74+GvK4hn1eejD9lZ7967qAwvqTZayQa3g10ag4s9uewgR7TKjeaT0YMyoq+gVfKYABiWZ4MQD701/t5e1Jhg==
 
-"@babel/plugin-proposal-async-generator-functions@^7.1.0":
-  version "7.1.0"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-proposal-async-generator-functions/-/plugin-proposal-async-generator-functions-7.1.0.tgz#41c1a702e10081456e23a7b74d891922dd1bb6ce"
-  integrity sha512-Fq803F3Jcxo20MXUSDdmZZXrPe6BWyGcWBPPNB/M7WaUYESKDeKMOGIxEzQOjGSmW/NWb6UaPZrtTB2ekhB/ew==
+"@babel/plugin-proposal-async-generator-functions@^7.2.0":
+  version "7.2.0"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-proposal-async-generator-functions/-/plugin-proposal-async-generator-functions-7.2.0.tgz#b289b306669dce4ad20b0252889a15768c9d417e"
+  integrity sha512-+Dfo/SCQqrwx48ptLVGLdE39YtWRuKc/Y9I5Fy0P1DDBB9lsAHpjcEJQt+4IifuSOSTLBKJObJqMvaO1pIE8LQ==
   dependencies:
     "@babel/helper-plugin-utils" "^7.0.0"
     "@babel/helper-remap-async-to-generator" "^7.1.0"
-    "@babel/plugin-syntax-async-generators" "^7.0.0"
+    "@babel/plugin-syntax-async-generators" "^7.2.0"
 
-"@babel/plugin-proposal-json-strings@^7.0.0":
-  version "7.0.0"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-proposal-json-strings/-/plugin-proposal-json-strings-7.0.0.tgz#3b4d7b5cf51e1f2e70f52351d28d44fc2970d01e"
-  integrity sha512-kfVdUkIAGJIVmHmtS/40i/fg/AGnw/rsZBCaapY5yjeO5RA9m165Xbw9KMOu2nqXP5dTFjEjHdfNdoVcHv133Q==
+"@babel/plugin-proposal-json-strings@^7.2.0":
+  version "7.2.0"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-proposal-json-strings/-/plugin-proposal-json-strings-7.2.0.tgz#568ecc446c6148ae6b267f02551130891e29f317"
+  integrity sha512-MAFV1CA/YVmYwZG0fBQyXhmj0BHCB5egZHCKWIFVv/XCxAeVGIHfos3SwDck4LvCllENIAg7xMKOG5kH0dzyUg==
   dependencies:
     "@babel/helper-plugin-utils" "^7.0.0"
-    "@babel/plugin-syntax-json-strings" "^7.0.0"
+    "@babel/plugin-syntax-json-strings" "^7.2.0"
 
-"@babel/plugin-proposal-object-rest-spread@^7.0.0":
-  version "7.0.0"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-proposal-object-rest-spread/-/plugin-proposal-object-rest-spread-7.0.0.tgz#9a17b547f64d0676b6c9cecd4edf74a82ab85e7e"
-  integrity sha512-14fhfoPcNu7itSen7Py1iGN0gEm87hX/B+8nZPqkdmANyyYWYMY2pjA3r8WXbWVKMzfnSNS0xY8GVS0IjXi/iw==
+"@babel/plugin-proposal-object-rest-spread@^7.2.0":
+  version "7.2.0"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-proposal-object-rest-spread/-/plugin-proposal-object-rest-spread-7.2.0.tgz#88f5fec3e7ad019014c97f7ee3c992f0adbf7fb8"
+  integrity sha512-1L5mWLSvR76XYUQJXkd/EEQgjq8HHRP6lQuZTTg0VA4tTGPpGemmCdAfQIz1rzEuWAm+ecP8PyyEm30jC1eQCg==
   dependencies:
     "@babel/helper-plugin-utils" "^7.0.0"
-    "@babel/plugin-syntax-object-rest-spread" "^7.0.0"
+    "@babel/plugin-syntax-object-rest-spread" "^7.2.0"
 
-"@babel/plugin-proposal-optional-catch-binding@^7.0.0":
-  version "7.0.0"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-proposal-optional-catch-binding/-/plugin-proposal-optional-catch-binding-7.0.0.tgz#b610d928fe551ff7117d42c8bb410eec312a6425"
-  integrity sha512-JPqAvLG1s13B/AuoBjdBYvn38RqW6n1TzrQO839/sIpqLpbnXKacsAgpZHzLD83Sm8SDXMkkrAvEnJ25+0yIpw==
+"@babel/plugin-proposal-optional-catch-binding@^7.2.0":
+  version "7.2.0"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-proposal-optional-catch-binding/-/plugin-proposal-optional-catch-binding-7.2.0.tgz#135d81edb68a081e55e56ec48541ece8065c38f5"
+  integrity sha512-mgYj3jCcxug6KUcX4OBoOJz3CMrwRfQELPQ5560F70YQUBZB7uac9fqaWamKR1iWUzGiK2t0ygzjTScZnVz75g==
   dependencies:
     "@babel/helper-plugin-utils" "^7.0.0"
-    "@babel/plugin-syntax-optional-catch-binding" "^7.0.0"
+    "@babel/plugin-syntax-optional-catch-binding" "^7.2.0"
 
-"@babel/plugin-proposal-unicode-property-regex@^7.0.0":
-  version "7.0.0"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-proposal-unicode-property-regex/-/plugin-proposal-unicode-property-regex-7.0.0.tgz#498b39cd72536cd7c4b26177d030226eba08cd33"
-  integrity sha512-tM3icA6GhC3ch2SkmSxv7J/hCWKISzwycub6eGsDrFDgukD4dZ/I+x81XgW0YslS6mzNuQ1Cbzh5osjIMgepPQ==
+"@babel/plugin-proposal-unicode-property-regex@^7.2.0":
+  version "7.2.0"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-proposal-unicode-property-regex/-/plugin-proposal-unicode-property-regex-7.2.0.tgz#abe7281fe46c95ddc143a65e5358647792039520"
+  integrity sha512-LvRVYb7kikuOtIoUeWTkOxQEV1kYvL5B6U3iWEGCzPNRus1MzJweFqORTj+0jkxozkTSYNJozPOddxmqdqsRpw==
   dependencies:
     "@babel/helper-plugin-utils" "^7.0.0"
     "@babel/helper-regex" "^7.0.0"
     regexpu-core "^4.2.0"
 
-"@babel/plugin-syntax-async-generators@^7.0.0":
-  version "7.0.0"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-async-generators/-/plugin-syntax-async-generators-7.0.0.tgz#bf0891dcdbf59558359d0c626fdc9490e20bc13c"
-  integrity sha512-im7ged00ddGKAjcZgewXmp1vxSZQQywuQXe2B1A7kajjZmDeY/ekMPmWr9zJgveSaQH0k7BcGrojQhcK06l0zA==
+"@babel/plugin-syntax-async-generators@^7.2.0":
+  version "7.2.0"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-async-generators/-/plugin-syntax-async-generators-7.2.0.tgz#69e1f0db34c6f5a0cf7e2b3323bf159a76c8cb7f"
+  integrity sha512-1ZrIRBv2t0GSlcwVoQ6VgSLpLgiN/FVQUzt9znxo7v2Ov4jJrs8RY8tv0wvDmFN3qIdMKWrmMMW6yZ0G19MfGg==
   dependencies:
     "@babel/helper-plugin-utils" "^7.0.0"
 
-"@babel/plugin-syntax-json-strings@^7.0.0":
-  version "7.0.0"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-json-strings/-/plugin-syntax-json-strings-7.0.0.tgz#0d259a68090e15b383ce3710e01d5b23f3770cbd"
-  integrity sha512-UlSfNydC+XLj4bw7ijpldc1uZ/HB84vw+U6BTuqMdIEmz/LDe63w/GHtpQMdXWdqQZFeAI9PjnHe/vDhwirhKA==
+"@babel/plugin-syntax-json-strings@^7.2.0":
+  version "7.2.0"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-json-strings/-/plugin-syntax-json-strings-7.2.0.tgz#72bd13f6ffe1d25938129d2a186b11fd62951470"
+  integrity sha512-5UGYnMSLRE1dqqZwug+1LISpA403HzlSfsg6P9VXU6TBjcSHeNlw4DxDx7LgpF+iKZoOG/+uzqoRHTdcUpiZNg==
   dependencies:
     "@babel/helper-plugin-utils" "^7.0.0"
 
-"@babel/plugin-syntax-object-rest-spread@^7.0.0":
-  version "7.0.0"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-object-rest-spread/-/plugin-syntax-object-rest-spread-7.0.0.tgz#37d8fbcaf216bd658ea1aebbeb8b75e88ebc549b"
-  integrity sha512-5A0n4p6bIiVe5OvQPxBnesezsgFJdHhSs3uFSvaPdMqtsovajLZ+G2vZyvNe10EzJBWWo3AcHGKhAFUxqwp2dw==
+"@babel/plugin-syntax-object-rest-spread@^7.2.0":
+  version "7.2.0"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-object-rest-spread/-/plugin-syntax-object-rest-spread-7.2.0.tgz#3b7a3e733510c57e820b9142a6579ac8b0dfad2e"
+  integrity sha512-t0JKGgqk2We+9may3t0xDdmneaXmyxq0xieYcKHxIsrJO64n1OiMWNUtc5gQK1PA0NpdCRrtZp4z+IUaKugrSA==
   dependencies:
     "@babel/helper-plugin-utils" "^7.0.0"
 
-"@babel/plugin-syntax-optional-catch-binding@^7.0.0":
-  version "7.0.0"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-optional-catch-binding/-/plugin-syntax-optional-catch-binding-7.0.0.tgz#886f72008b3a8b185977f7cb70713b45e51ee475"
-  integrity sha512-Wc+HVvwjcq5qBg1w5RG9o9RVzmCaAg/Vp0erHCKpAYV8La6I94o4GQAmFYNmkzoMO6gzoOSulpKeSSz6mPEoZw==
+"@babel/plugin-syntax-optional-catch-binding@^7.2.0":
+  version "7.2.0"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-optional-catch-binding/-/plugin-syntax-optional-catch-binding-7.2.0.tgz#a94013d6eda8908dfe6a477e7f9eda85656ecf5c"
+  integrity sha512-bDe4xKNhb0LI7IvZHiA13kff0KEfaGX/Hv4lMA9+7TEc63hMNvfKo6ZFpXhKuEp+II/q35Gc4NoMeDZyaUbj9w==
   dependencies:
     "@babel/helper-plugin-utils" "^7.0.0"
 
-"@babel/plugin-transform-arrow-functions@^7.0.0":
-  version "7.0.0"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-arrow-functions/-/plugin-transform-arrow-functions-7.0.0.tgz#a6c14875848c68a3b4b3163a486535ef25c7e749"
-  integrity sha512-2EZDBl1WIO/q4DIkIp4s86sdp4ZifL51MoIviLY/gG/mLSuOIEg7J8o6mhbxOTvUJkaN50n+8u41FVsr5KLy/w==
+"@babel/plugin-transform-arrow-functions@^7.2.0":
+  version "7.2.0"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-arrow-functions/-/plugin-transform-arrow-functions-7.2.0.tgz#9aeafbe4d6ffc6563bf8f8372091628f00779550"
+  integrity sha512-ER77Cax1+8/8jCB9fo4Ud161OZzWN5qawi4GusDuRLcDbDG+bIGYY20zb2dfAFdTRGzrfq2xZPvF0R64EHnimg==
   dependencies:
     "@babel/helper-plugin-utils" "^7.0.0"
 
-"@babel/plugin-transform-async-to-generator@^7.1.0":
-  version "7.1.0"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-async-to-generator/-/plugin-transform-async-to-generator-7.1.0.tgz#109e036496c51dd65857e16acab3bafdf3c57811"
-  integrity sha512-rNmcmoQ78IrvNCIt/R9U+cixUHeYAzgusTFgIAv+wQb9HJU4szhpDD6e5GCACmj/JP5KxuCwM96bX3L9v4ZN/g==
+"@babel/plugin-transform-async-to-generator@^7.2.0":
+  version "7.2.0"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-async-to-generator/-/plugin-transform-async-to-generator-7.2.0.tgz#68b8a438663e88519e65b776f8938f3445b1a2ff"
+  integrity sha512-CEHzg4g5UraReozI9D4fblBYABs7IM6UerAVG7EJVrTLC5keh00aEuLUT+O40+mJCEzaXkYfTCUKIyeDfMOFFQ==
   dependencies:
     "@babel/helper-module-imports" "^7.0.0"
     "@babel/helper-plugin-utils" "^7.0.0"
     "@babel/helper-remap-async-to-generator" "^7.1.0"
 
-"@babel/plugin-transform-block-scoped-functions@^7.0.0":
-  version "7.0.0"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-block-scoped-functions/-/plugin-transform-block-scoped-functions-7.0.0.tgz#482b3f75103927e37288b3b67b65f848e2aa0d07"
-  integrity sha512-AOBiyUp7vYTqz2Jibe1UaAWL0Hl9JUXEgjFvvvcSc9MVDItv46ViXFw2F7SVt1B5k+KWjl44eeXOAk3UDEaJjQ==
+"@babel/plugin-transform-block-scoped-functions@^7.2.0":
+  version "7.2.0"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-block-scoped-functions/-/plugin-transform-block-scoped-functions-7.2.0.tgz#5d3cc11e8d5ddd752aa64c9148d0db6cb79fd190"
+  integrity sha512-ntQPR6q1/NKuphly49+QiQiTN0O63uOwjdD6dhIjSWBI5xlrbUFh720TIpzBhpnrLfv2tNH/BXvLIab1+BAI0w==
   dependencies:
     "@babel/helper-plugin-utils" "^7.0.0"
 
-"@babel/plugin-transform-block-scoping@^7.1.5":
-  version "7.1.5"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-block-scoping/-/plugin-transform-block-scoping-7.1.5.tgz#3e8e0bc9a5104519923302a24f748f72f2f61f37"
-  integrity sha512-jlYcDrz+5ayWC7mxgpn1Wj8zj0mmjCT2w0mPIMSwO926eXBRxpEgoN/uQVRBfjtr8ayjcmS+xk2G1jaP8JjMJQ==
+"@babel/plugin-transform-block-scoping@^7.2.0":
+  version "7.2.0"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-block-scoping/-/plugin-transform-block-scoping-7.2.0.tgz#f17c49d91eedbcdf5dd50597d16f5f2f770132d4"
+  integrity sha512-vDTgf19ZEV6mx35yiPJe4fS02mPQUUcBNwWQSZFXSzTSbsJFQvHt7DqyS3LK8oOWALFOsJ+8bbqBgkirZteD5Q==
   dependencies:
     "@babel/helper-plugin-utils" "^7.0.0"
     lodash "^4.17.10"
 
-"@babel/plugin-transform-classes@^7.1.0":
-  version "7.1.0"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-classes/-/plugin-transform-classes-7.1.0.tgz#ab3f8a564361800cbc8ab1ca6f21108038432249"
-  integrity sha512-rNaqoD+4OCBZjM7VaskladgqnZ1LO6o2UxuWSDzljzW21pN1KXkB7BstAVweZdxQkHAujps5QMNOTWesBciKFg==
+"@babel/plugin-transform-classes@^7.2.0":
+  version "7.2.0"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-classes/-/plugin-transform-classes-7.2.0.tgz#374f8876075d7d21fea55aeb5c53561259163f96"
+  integrity sha512-aPCEkrhJYebDXcGTAP+cdUENkH7zqOlgbKwLbghjjHpJRJBWM/FSlCjMoPGA8oUdiMfOrk3+8EFPLLb5r7zj2w==
   dependencies:
     "@babel/helper-annotate-as-pure" "^7.0.0"
     "@babel/helper-define-map" "^7.1.0"
@@ -333,67 +333,67 @@
     "@babel/helper-split-export-declaration" "^7.0.0"
     globals "^11.1.0"
 
-"@babel/plugin-transform-computed-properties@^7.0.0":
-  version "7.0.0"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-computed-properties/-/plugin-transform-computed-properties-7.0.0.tgz#2fbb8900cd3e8258f2a2ede909b90e7556185e31"
-  integrity sha512-ubouZdChNAv4AAWAgU7QKbB93NU5sHwInEWfp+/OzJKA02E6Woh9RVoX4sZrbRwtybky/d7baTUqwFx+HgbvMA==
+"@babel/plugin-transform-computed-properties@^7.2.0":
+  version "7.2.0"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-computed-properties/-/plugin-transform-computed-properties-7.2.0.tgz#83a7df6a658865b1c8f641d510c6f3af220216da"
+  integrity sha512-kP/drqTxY6Xt3NNpKiMomfgkNn4o7+vKxK2DDKcBG9sHj51vHqMBGy8wbDS/J4lMxnqs153/T3+DmCEAkC5cpA==
   dependencies:
     "@babel/helper-plugin-utils" "^7.0.0"
 
-"@babel/plugin-transform-destructuring@^7.0.0":
-  version "7.1.3"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-destructuring/-/plugin-transform-destructuring-7.1.3.tgz#e69ff50ca01fac6cb72863c544e516c2b193012f"
-  integrity sha512-Mb9M4DGIOspH1ExHOUnn2UUXFOyVTiX84fXCd+6B5iWrQg/QMeeRmSwpZ9lnjYLSXtZwiw80ytVMr3zue0ucYw==
+"@babel/plugin-transform-destructuring@^7.2.0":
+  version "7.2.0"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-destructuring/-/plugin-transform-destructuring-7.2.0.tgz#e75269b4b7889ec3a332cd0d0c8cff8fed0dc6f3"
+  integrity sha512-coVO2Ayv7g0qdDbrNiadE4bU7lvCd9H539m2gMknyVjjMdwF/iCOM7R+E8PkntoqLkltO0rk+3axhpp/0v68VQ==
   dependencies:
     "@babel/helper-plugin-utils" "^7.0.0"
 
-"@babel/plugin-transform-dotall-regex@^7.0.0":
-  version "7.0.0"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-dotall-regex/-/plugin-transform-dotall-regex-7.0.0.tgz#73a24da69bc3c370251f43a3d048198546115e58"
-  integrity sha512-00THs8eJxOJUFVx1w8i1MBF4XH4PsAjKjQ1eqN/uCH3YKwP21GCKfrn6YZFZswbOk9+0cw1zGQPHVc1KBlSxig==
+"@babel/plugin-transform-dotall-regex@^7.2.0":
+  version "7.2.0"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-dotall-regex/-/plugin-transform-dotall-regex-7.2.0.tgz#f0aabb93d120a8ac61e925ea0ba440812dbe0e49"
+  integrity sha512-sKxnyHfizweTgKZf7XsXu/CNupKhzijptfTM+bozonIuyVrLWVUvYjE2bhuSBML8VQeMxq4Mm63Q9qvcvUcciQ==
   dependencies:
     "@babel/helper-plugin-utils" "^7.0.0"
     "@babel/helper-regex" "^7.0.0"
     regexpu-core "^4.1.3"
 
-"@babel/plugin-transform-duplicate-keys@^7.0.0":
-  version "7.0.0"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-duplicate-keys/-/plugin-transform-duplicate-keys-7.0.0.tgz#a0601e580991e7cace080e4cf919cfd58da74e86"
-  integrity sha512-w2vfPkMqRkdxx+C71ATLJG30PpwtTpW7DDdLqYt2acXU7YjztzeWW2Jk1T6hKqCLYCcEA5UQM/+xTAm+QCSnuQ==
+"@babel/plugin-transform-duplicate-keys@^7.2.0":
+  version "7.2.0"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-duplicate-keys/-/plugin-transform-duplicate-keys-7.2.0.tgz#d952c4930f312a4dbfff18f0b2914e60c35530b3"
+  integrity sha512-q+yuxW4DsTjNceUiTzK0L+AfQ0zD9rWaTLiUqHA8p0gxx7lu1EylenfzjeIWNkPy6e/0VG/Wjw9uf9LueQwLOw==
   dependencies:
     "@babel/helper-plugin-utils" "^7.0.0"
 
-"@babel/plugin-transform-exponentiation-operator@^7.1.0":
-  version "7.1.0"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-exponentiation-operator/-/plugin-transform-exponentiation-operator-7.1.0.tgz#9c34c2ee7fd77e02779cfa37e403a2e1003ccc73"
-  integrity sha512-uZt9kD1Pp/JubkukOGQml9tqAeI8NkE98oZnHZ2qHRElmeKCodbTZgOEUtujSCSLhHSBWbzNiFSDIMC4/RBTLQ==
+"@babel/plugin-transform-exponentiation-operator@^7.2.0":
+  version "7.2.0"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-exponentiation-operator/-/plugin-transform-exponentiation-operator-7.2.0.tgz#a63868289e5b4007f7054d46491af51435766008"
+  integrity sha512-umh4hR6N7mu4Elq9GG8TOu9M0bakvlsREEC+ialrQN6ABS4oDQ69qJv1VtR3uxlKMCQMCvzk7vr17RHKcjx68A==
   dependencies:
     "@babel/helper-builder-binary-assignment-operator-visitor" "^7.1.0"
     "@babel/helper-plugin-utils" "^7.0.0"
 
-"@babel/plugin-transform-for-of@^7.0.0":
-  version "7.0.0"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-for-of/-/plugin-transform-for-of-7.0.0.tgz#f2ba4eadb83bd17dc3c7e9b30f4707365e1c3e39"
-  integrity sha512-TlxKecN20X2tt2UEr2LNE6aqA0oPeMT1Y3cgz8k4Dn1j5ObT8M3nl9aA37LLklx0PBZKETC9ZAf9n/6SujTuXA==
+"@babel/plugin-transform-for-of@^7.2.0":
+  version "7.2.0"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-for-of/-/plugin-transform-for-of-7.2.0.tgz#ab7468befa80f764bb03d3cb5eef8cc998e1cad9"
+  integrity sha512-Kz7Mt0SsV2tQk6jG5bBv5phVbkd0gd27SgYD4hH1aLMJRchM0dzHaXvrWhVZ+WxAlDoAKZ7Uy3jVTW2mKXQ1WQ==
   dependencies:
     "@babel/helper-plugin-utils" "^7.0.0"
 
-"@babel/plugin-transform-function-name@^7.1.0":
-  version "7.1.0"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-function-name/-/plugin-transform-function-name-7.1.0.tgz#29c5550d5c46208e7f730516d41eeddd4affadbb"
-  integrity sha512-VxOa1TMlFMtqPW2IDYZQaHsFrq/dDoIjgN098NowhexhZcz3UGlvPgZXuE1jEvNygyWyxRacqDpCZt+par1FNg==
+"@babel/plugin-transform-function-name@^7.2.0":
+  version "7.2.0"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-function-name/-/plugin-transform-function-name-7.2.0.tgz#f7930362829ff99a3174c39f0afcc024ef59731a"
+  integrity sha512-kWgksow9lHdvBC2Z4mxTsvc7YdY7w/V6B2vy9cTIPtLEE9NhwoWivaxdNM/S37elu5bqlLP/qOY906LukO9lkQ==
   dependencies:
     "@babel/helper-function-name" "^7.1.0"
     "@babel/helper-plugin-utils" "^7.0.0"
 
-"@babel/plugin-transform-literals@^7.0.0":
-  version "7.0.0"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-literals/-/plugin-transform-literals-7.0.0.tgz#2aec1d29cdd24c407359c930cdd89e914ee8ff86"
-  integrity sha512-1NTDBWkeNXgpUcyoVFxbr9hS57EpZYXpje92zv0SUzjdu3enaRwF/l3cmyRnXLtIdyJASyiS6PtybK+CgKf7jA==
+"@babel/plugin-transform-literals@^7.2.0":
+  version "7.2.0"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-literals/-/plugin-transform-literals-7.2.0.tgz#690353e81f9267dad4fd8cfd77eafa86aba53ea1"
+  integrity sha512-2ThDhm4lI4oV7fVQ6pNNK+sx+c/GM5/SaML0w/r4ZB7sAneD/piDJtwdKlNckXeyGK7wlwg2E2w33C/Hh+VFCg==
   dependencies:
     "@babel/helper-plugin-utils" "^7.0.0"
 
-"@babel/plugin-transform-modules-amd@^7.0.0", "@babel/plugin-transform-modules-amd@^7.1.0", "@babel/plugin-transform-modules-amd@^7.2.0":
+"@babel/plugin-transform-modules-amd@^7.0.0", "@babel/plugin-transform-modules-amd@^7.2.0":
   version "7.2.0"
   resolved "https://registry.yarnpkg.com/@babel/plugin-transform-modules-amd/-/plugin-transform-modules-amd-7.2.0.tgz#82a9bce45b95441f617a24011dc89d12da7f4ee6"
   integrity sha512-mK2A8ucqz1qhrdqjS9VMIDfIvvT2thrEsIQzbaTdc5QFzhDjQv2CkJJ5f6BXIkgbmaoax3zBr2RyvV/8zeoUZw==
@@ -401,27 +401,27 @@
     "@babel/helper-module-transforms" "^7.1.0"
     "@babel/helper-plugin-utils" "^7.0.0"
 
-"@babel/plugin-transform-modules-commonjs@^7.1.0":
-  version "7.1.0"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-modules-commonjs/-/plugin-transform-modules-commonjs-7.1.0.tgz#0a9d86451cbbfb29bd15186306897c67f6f9a05c"
-  integrity sha512-wtNwtMjn1XGwM0AXPspQgvmE6msSJP15CX2RVfpTSTNPLhKhaOjaIfBaVfj4iUZ/VrFSodcFedwtPg/NxwQlPA==
+"@babel/plugin-transform-modules-commonjs@^7.2.0":
+  version "7.2.0"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-modules-commonjs/-/plugin-transform-modules-commonjs-7.2.0.tgz#c4f1933f5991d5145e9cfad1dfd848ea1727f404"
+  integrity sha512-V6y0uaUQrQPXUrmj+hgnks8va2L0zcZymeU7TtWEgdRLNkceafKXEduv7QzgQAE4lT+suwooG9dC7LFhdRAbVQ==
   dependencies:
     "@babel/helper-module-transforms" "^7.1.0"
     "@babel/helper-plugin-utils" "^7.0.0"
     "@babel/helper-simple-access" "^7.1.0"
 
-"@babel/plugin-transform-modules-systemjs@^7.0.0":
-  version "7.1.3"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-modules-systemjs/-/plugin-transform-modules-systemjs-7.1.3.tgz#2119a3e3db612fd74a19d88652efbfe9613a5db0"
-  integrity sha512-PvTxgjxQAq4pvVUZF3mD5gEtVDuId8NtWkJsZLEJZMZAW3TvgQl1pmydLLN1bM8huHFVVU43lf0uvjQj9FRkKw==
+"@babel/plugin-transform-modules-systemjs@^7.2.0":
+  version "7.2.0"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-modules-systemjs/-/plugin-transform-modules-systemjs-7.2.0.tgz#912bfe9e5ff982924c81d0937c92d24994bb9068"
+  integrity sha512-aYJwpAhoK9a+1+O625WIjvMY11wkB/ok0WClVwmeo3mCjcNRjt+/8gHWrB5i+00mUju0gWsBkQnPpdvQ7PImmQ==
   dependencies:
     "@babel/helper-hoist-variables" "^7.0.0"
     "@babel/helper-plugin-utils" "^7.0.0"
 
-"@babel/plugin-transform-modules-umd@^7.1.0":
-  version "7.1.0"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-modules-umd/-/plugin-transform-modules-umd-7.1.0.tgz#a29a7d85d6f28c3561c33964442257cc6a21f2a8"
-  integrity sha512-enrRtn5TfRhMmbRwm7F8qOj0qEYByqUvTttPEGimcBH4CJHphjyK1Vg7sdU7JjeEmgSpM890IT/efS2nMHwYig==
+"@babel/plugin-transform-modules-umd@^7.2.0":
+  version "7.2.0"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-modules-umd/-/plugin-transform-modules-umd-7.2.0.tgz#7678ce75169f0877b8eb2235538c074268dd01ae"
+  integrity sha512-BV3bw6MyUH1iIsGhXlOK6sXhmSarZjtJ/vMiD9dNmpY8QXFFQTj+6v92pcfy1iqa8DeAfJFwoxcrS/TUZda6sw==
   dependencies:
     "@babel/helper-module-transforms" "^7.1.0"
     "@babel/helper-plugin-utils" "^7.0.0"
@@ -433,18 +433,18 @@
   dependencies:
     "@babel/helper-plugin-utils" "^7.0.0"
 
-"@babel/plugin-transform-object-super@^7.1.0":
-  version "7.1.0"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-object-super/-/plugin-transform-object-super-7.1.0.tgz#b1ae194a054b826d8d4ba7ca91486d4ada0f91bb"
-  integrity sha512-/O02Je1CRTSk2SSJaq0xjwQ8hG4zhZGNjE8psTsSNPXyLRCODv7/PBozqT5AmQMzp7MI3ndvMhGdqp9c96tTEw==
+"@babel/plugin-transform-object-super@^7.2.0":
+  version "7.2.0"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-object-super/-/plugin-transform-object-super-7.2.0.tgz#b35d4c10f56bab5d650047dad0f1d8e8814b6598"
+  integrity sha512-VMyhPYZISFZAqAPVkiYb7dUe2AsVi2/wCT5+wZdsNO31FojQJa9ns40hzZ6U9f50Jlq4w6qwzdBB2uwqZ00ebg==
   dependencies:
     "@babel/helper-plugin-utils" "^7.0.0"
     "@babel/helper-replace-supers" "^7.1.0"
 
-"@babel/plugin-transform-parameters@^7.1.0":
-  version "7.1.0"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-parameters/-/plugin-transform-parameters-7.1.0.tgz#44f492f9d618c9124026e62301c296bf606a7aed"
-  integrity sha512-vHV7oxkEJ8IHxTfRr3hNGzV446GAb+0hgbA7o/0Jd76s+YzccdWuTU296FOCOl/xweU4t/Ya4g41yWz80RFCRw==
+"@babel/plugin-transform-parameters@^7.2.0":
+  version "7.2.0"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-parameters/-/plugin-transform-parameters-7.2.0.tgz#0d5ad15dc805e2ea866df4dd6682bfe76d1408c2"
+  integrity sha512-kB9+hhUidIgUoBQ0MsxMewhzr8i60nMa2KgeJKQWYrqQpqcBYtnpR+JgkadZVZoaEZ/eKu9mclFaVwhRpLNSzA==
   dependencies:
     "@babel/helper-call-delegate" "^7.1.0"
     "@babel/helper-get-function-arity" "^7.0.0"
@@ -467,47 +467,47 @@
     resolve "^1.8.1"
     semver "^5.5.1"
 
-"@babel/plugin-transform-shorthand-properties@^7.0.0":
-  version "7.0.0"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-shorthand-properties/-/plugin-transform-shorthand-properties-7.0.0.tgz#85f8af592dcc07647541a0350e8c95c7bf419d15"
-  integrity sha512-g/99LI4vm5iOf5r1Gdxq5Xmu91zvjhEG5+yZDJW268AZELAu4J1EiFLnkSG3yuUsZyOipVOVUKoGPYwfsTymhw==
+"@babel/plugin-transform-shorthand-properties@^7.2.0":
+  version "7.2.0"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-shorthand-properties/-/plugin-transform-shorthand-properties-7.2.0.tgz#6333aee2f8d6ee7e28615457298934a3b46198f0"
+  integrity sha512-QP4eUM83ha9zmYtpbnyjTLAGKQritA5XW/iG9cjtuOI8s1RuL/3V6a3DeSHfKutJQ+ayUfeZJPcnCYEQzaPQqg==
   dependencies:
     "@babel/helper-plugin-utils" "^7.0.0"
 
-"@babel/plugin-transform-spread@^7.0.0":
-  version "7.0.0"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-spread/-/plugin-transform-spread-7.0.0.tgz#93583ce48dd8c85e53f3a46056c856e4af30b49b"
-  integrity sha512-L702YFy2EvirrR4shTj0g2xQp7aNwZoWNCkNu2mcoU0uyzMl0XRwDSwzB/xp6DSUFiBmEXuyAyEN16LsgVqGGQ==
+"@babel/plugin-transform-spread@^7.2.0":
+  version "7.2.0"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-spread/-/plugin-transform-spread-7.2.0.tgz#0c76c12a3b5826130078ee8ec84a7a8e4afd79c4"
+  integrity sha512-7TtPIdwjS/i5ZBlNiQePQCovDh9pAhVbp/nGVRBZuUdBiVRThyyLend3OHobc0G+RLCPPAN70+z/MAMhsgJd/A==
   dependencies:
     "@babel/helper-plugin-utils" "^7.0.0"
 
-"@babel/plugin-transform-sticky-regex@^7.0.0":
-  version "7.0.0"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-sticky-regex/-/plugin-transform-sticky-regex-7.0.0.tgz#30a9d64ac2ab46eec087b8530535becd90e73366"
-  integrity sha512-LFUToxiyS/WD+XEWpkx/XJBrUXKewSZpzX68s+yEOtIbdnsRjpryDw9U06gYc6klYEij/+KQVRnD3nz3AoKmjw==
+"@babel/plugin-transform-sticky-regex@^7.2.0":
+  version "7.2.0"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-sticky-regex/-/plugin-transform-sticky-regex-7.2.0.tgz#a1e454b5995560a9c1e0d537dfc15061fd2687e1"
+  integrity sha512-KKYCoGaRAf+ckH8gEL3JHUaFVyNHKe3ASNsZ+AlktgHevvxGigoIttrEJb8iKN03Q7Eazlv1s6cx2B2cQ3Jabw==
   dependencies:
     "@babel/helper-plugin-utils" "^7.0.0"
     "@babel/helper-regex" "^7.0.0"
 
-"@babel/plugin-transform-template-literals@^7.0.0":
-  version "7.0.0"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-template-literals/-/plugin-transform-template-literals-7.0.0.tgz#084f1952efe5b153ddae69eb8945f882c7a97c65"
-  integrity sha512-vA6rkTCabRZu7Nbl9DfLZE1imj4tzdWcg5vtdQGvj+OH9itNNB6hxuRMHuIY8SGnEt1T9g5foqs9LnrHzsqEFg==
+"@babel/plugin-transform-template-literals@^7.2.0":
+  version "7.2.0"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-template-literals/-/plugin-transform-template-literals-7.2.0.tgz#d87ed01b8eaac7a92473f608c97c089de2ba1e5b"
+  integrity sha512-FkPix00J9A/XWXv4VoKJBMeSkyY9x/TqIh76wzcdfl57RJJcf8CehQ08uwfhCDNtRQYtHQKBTwKZDEyjE13Lwg==
   dependencies:
     "@babel/helper-annotate-as-pure" "^7.0.0"
     "@babel/helper-plugin-utils" "^7.0.0"
 
-"@babel/plugin-transform-typeof-symbol@^7.0.0":
-  version "7.0.0"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-typeof-symbol/-/plugin-transform-typeof-symbol-7.0.0.tgz#4dcf1e52e943e5267b7313bff347fdbe0f81cec9"
-  integrity sha512-1r1X5DO78WnaAIvs5uC48t41LLckxsYklJrZjNKcevyz83sF2l4RHbw29qrCPr/6ksFsdfRpT/ZgxNWHXRnffg==
+"@babel/plugin-transform-typeof-symbol@^7.2.0":
+  version "7.2.0"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-typeof-symbol/-/plugin-transform-typeof-symbol-7.2.0.tgz#117d2bcec2fbf64b4b59d1f9819894682d29f2b2"
+  integrity sha512-2LNhETWYxiYysBtrBTqL8+La0jIoQQnIScUJc74OYvUGRmkskNY4EzLCnjHBzdmb38wqtTaixpo1NctEcvMDZw==
   dependencies:
     "@babel/helper-plugin-utils" "^7.0.0"
 
-"@babel/plugin-transform-unicode-regex@^7.0.0":
-  version "7.0.0"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-unicode-regex/-/plugin-transform-unicode-regex-7.0.0.tgz#c6780e5b1863a76fe792d90eded9fcd5b51d68fc"
-  integrity sha512-uJBrJhBOEa3D033P95nPHu3nbFwFE9ZgXsfEitzoIXIwqAZWk7uXcg06yFKXz9FSxBH5ucgU/cYdX0IV8ldHKw==
+"@babel/plugin-transform-unicode-regex@^7.2.0":
+  version "7.2.0"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-unicode-regex/-/plugin-transform-unicode-regex-7.2.0.tgz#4eb8db16f972f8abb5062c161b8b115546ade08b"
+  integrity sha512-m48Y0lMhrbXEJnVUaYly29jRXbQ3ksxPrS1Tg8t+MHqzXhtBYAvI51euOBaoAlZLPHsieY9XPVMf80a5x0cPcA==
   dependencies:
     "@babel/helper-plugin-utils" "^7.0.0"
     "@babel/helper-regex" "^7.0.0"
@@ -522,48 +522,48 @@
     regenerator-runtime "^0.11.1"
 
 "@babel/preset-env@^7.0.0":
-  version "7.1.6"
-  resolved "https://registry.yarnpkg.com/@babel/preset-env/-/preset-env-7.1.6.tgz#a0bf4b96b6bfcf6e000afc5b72b4abe7cc13ae97"
-  integrity sha512-YIBfpJNQMBkb6MCkjz/A9J76SNCSuGVamOVBgoUkLzpJD/z8ghHi9I42LQ4pulVX68N/MmImz6ZTixt7Azgexw==
+  version "7.2.0"
+  resolved "https://registry.yarnpkg.com/@babel/preset-env/-/preset-env-7.2.0.tgz#a5030e7e4306af5a295dd5d7c78dc5464af3fee2"
+  integrity sha512-haGR38j5vOGVeBatrQPr3l0xHbs14505DcM57cbJy48kgMFvvHHoYEhHuRV+7vi559yyAUAVbTWzbK/B/pzJng==
   dependencies:
     "@babel/helper-module-imports" "^7.0.0"
     "@babel/helper-plugin-utils" "^7.0.0"
-    "@babel/plugin-proposal-async-generator-functions" "^7.1.0"
-    "@babel/plugin-proposal-json-strings" "^7.0.0"
-    "@babel/plugin-proposal-object-rest-spread" "^7.0.0"
-    "@babel/plugin-proposal-optional-catch-binding" "^7.0.0"
-    "@babel/plugin-proposal-unicode-property-regex" "^7.0.0"
-    "@babel/plugin-syntax-async-generators" "^7.0.0"
-    "@babel/plugin-syntax-object-rest-spread" "^7.0.0"
-    "@babel/plugin-syntax-optional-catch-binding" "^7.0.0"
-    "@babel/plugin-transform-arrow-functions" "^7.0.0"
-    "@babel/plugin-transform-async-to-generator" "^7.1.0"
-    "@babel/plugin-transform-block-scoped-functions" "^7.0.0"
-    "@babel/plugin-transform-block-scoping" "^7.1.5"
-    "@babel/plugin-transform-classes" "^7.1.0"
-    "@babel/plugin-transform-computed-properties" "^7.0.0"
-    "@babel/plugin-transform-destructuring" "^7.0.0"
-    "@babel/plugin-transform-dotall-regex" "^7.0.0"
-    "@babel/plugin-transform-duplicate-keys" "^7.0.0"
-    "@babel/plugin-transform-exponentiation-operator" "^7.1.0"
-    "@babel/plugin-transform-for-of" "^7.0.0"
-    "@babel/plugin-transform-function-name" "^7.1.0"
-    "@babel/plugin-transform-literals" "^7.0.0"
-    "@babel/plugin-transform-modules-amd" "^7.1.0"
-    "@babel/plugin-transform-modules-commonjs" "^7.1.0"
-    "@babel/plugin-transform-modules-systemjs" "^7.0.0"
-    "@babel/plugin-transform-modules-umd" "^7.1.0"
+    "@babel/plugin-proposal-async-generator-functions" "^7.2.0"
+    "@babel/plugin-proposal-json-strings" "^7.2.0"
+    "@babel/plugin-proposal-object-rest-spread" "^7.2.0"
+    "@babel/plugin-proposal-optional-catch-binding" "^7.2.0"
+    "@babel/plugin-proposal-unicode-property-regex" "^7.2.0"
+    "@babel/plugin-syntax-async-generators" "^7.2.0"
+    "@babel/plugin-syntax-object-rest-spread" "^7.2.0"
+    "@babel/plugin-syntax-optional-catch-binding" "^7.2.0"
+    "@babel/plugin-transform-arrow-functions" "^7.2.0"
+    "@babel/plugin-transform-async-to-generator" "^7.2.0"
+    "@babel/plugin-transform-block-scoped-functions" "^7.2.0"
+    "@babel/plugin-transform-block-scoping" "^7.2.0"
+    "@babel/plugin-transform-classes" "^7.2.0"
+    "@babel/plugin-transform-computed-properties" "^7.2.0"
+    "@babel/plugin-transform-destructuring" "^7.2.0"
+    "@babel/plugin-transform-dotall-regex" "^7.2.0"
+    "@babel/plugin-transform-duplicate-keys" "^7.2.0"
+    "@babel/plugin-transform-exponentiation-operator" "^7.2.0"
+    "@babel/plugin-transform-for-of" "^7.2.0"
+    "@babel/plugin-transform-function-name" "^7.2.0"
+    "@babel/plugin-transform-literals" "^7.2.0"
+    "@babel/plugin-transform-modules-amd" "^7.2.0"
+    "@babel/plugin-transform-modules-commonjs" "^7.2.0"
+    "@babel/plugin-transform-modules-systemjs" "^7.2.0"
+    "@babel/plugin-transform-modules-umd" "^7.2.0"
     "@babel/plugin-transform-new-target" "^7.0.0"
-    "@babel/plugin-transform-object-super" "^7.1.0"
-    "@babel/plugin-transform-parameters" "^7.1.0"
+    "@babel/plugin-transform-object-super" "^7.2.0"
+    "@babel/plugin-transform-parameters" "^7.2.0"
     "@babel/plugin-transform-regenerator" "^7.0.0"
-    "@babel/plugin-transform-shorthand-properties" "^7.0.0"
-    "@babel/plugin-transform-spread" "^7.0.0"
-    "@babel/plugin-transform-sticky-regex" "^7.0.0"
-    "@babel/plugin-transform-template-literals" "^7.0.0"
-    "@babel/plugin-transform-typeof-symbol" "^7.0.0"
-    "@babel/plugin-transform-unicode-regex" "^7.0.0"
-    browserslist "^4.1.0"
+    "@babel/plugin-transform-shorthand-properties" "^7.2.0"
+    "@babel/plugin-transform-spread" "^7.2.0"
+    "@babel/plugin-transform-sticky-regex" "^7.2.0"
+    "@babel/plugin-transform-template-literals" "^7.2.0"
+    "@babel/plugin-transform-typeof-symbol" "^7.2.0"
+    "@babel/plugin-transform-unicode-regex" "^7.2.0"
+    browserslist "^4.3.4"
     invariant "^2.2.2"
     js-levenshtein "^1.1.3"
     semver "^5.3.0"
@@ -599,10 +599,10 @@
     globals "^11.1.0"
     lodash "^4.17.10"
 
-"@babel/types@^7.0.0", "@babel/types@^7.1.2", "@babel/types@^7.1.5", "@babel/types@^7.1.6":
-  version "7.1.6"
-  resolved "https://registry.yarnpkg.com/@babel/types/-/types-7.1.6.tgz#0adb330c3a281348a190263aceb540e10f04bcce"
-  integrity sha512-DMiUzlY9DSjVsOylJssxLHSgj6tWM9PRFJOGW/RaOglVOK9nzTxoOMfTfRQXGUCUQ/HmlG2efwC+XqUEJ5ay4w==
+"@babel/types@^7.0.0", "@babel/types@^7.1.2", "@babel/types@^7.1.6", "@babel/types@^7.2.0":
+  version "7.2.0"
+  resolved "https://registry.yarnpkg.com/@babel/types/-/types-7.2.0.tgz#7941c5b2d8060e06f9601d6be7c223eef906d5d8"
+  integrity sha512-b4v7dyfApuKDvmPb+O488UlGuR1WbwMXFsO/cyqMrnfvRAChZKJAYeeglWTjUO1b9UghKKgepAQM5tsvBJca6A==
   dependencies:
     esutils "^2.0.2"
     lodash "^4.17.10"
@@ -1795,9 +1795,9 @@ broccoli-amd-funnel@^2.0.1:
     symlink-or-copy "^1.2.0"
 
 broccoli-babel-transpiler@^6.5.0:
-  version "6.5.0"
-  resolved "https://registry.yarnpkg.com/broccoli-babel-transpiler/-/broccoli-babel-transpiler-6.5.0.tgz#aa501a227b298a99742fdd0309b1eaad7124bba0"
-  integrity sha512-c5OLGY40Sdmv6rP230Jt8yoK49BHfOw1LXiDMu9EC9k2U6sqlpNRK78SzvByQ8IzKtBYUfeWCxeZHcvW+gH7VQ==
+  version "6.5.1"
+  resolved "https://registry.yarnpkg.com/broccoli-babel-transpiler/-/broccoli-babel-transpiler-6.5.1.tgz#a4afc8d3b59b441518eb9a07bd44149476e30738"
+  integrity sha512-w6GcnkxvHcNCte5FcLGEG1hUdQvlfvSN/6PtGWU/otg69Ugk8rUk51h41R0Ugoc+TNxyeFG1opRt2RlA87XzNw==
   dependencies:
     babel-core "^6.26.0"
     broccoli-funnel "^2.0.1"
@@ -2148,14 +2148,14 @@ browserslist@^3.2.6:
     caniuse-lite "^1.0.30000844"
     electron-to-chromium "^1.3.47"
 
-browserslist@^4.1.0:
-  version "4.3.4"
-  resolved "https://registry.yarnpkg.com/browserslist/-/browserslist-4.3.4.tgz#4477b737db6a1b07077275b24791e680d4300425"
-  integrity sha512-u5iz+ijIMUlmV8blX82VGFrB9ecnUg5qEt55CMZ/YJEhha+d8qpBfOFuutJ6F/VKRXjZoD33b6uvarpPxcl3RA==
+browserslist@^4.3.4:
+  version "4.3.5"
+  resolved "https://registry.yarnpkg.com/browserslist/-/browserslist-4.3.5.tgz#1a917678acc07b55606748ea1adf9846ea8920f7"
+  integrity sha512-z9ZhGc3d9e/sJ9dIx5NFXkKoaiQTnrvrMsN3R1fGb1tkWWNSz12UewJn9TNxGo1l7J23h0MRaPmk7jfeTZYs1w==
   dependencies:
-    caniuse-lite "^1.0.30000899"
-    electron-to-chromium "^1.3.82"
-    node-releases "^1.0.1"
+    caniuse-lite "^1.0.30000912"
+    electron-to-chromium "^1.3.86"
+    node-releases "^1.0.5"
 
 bser@^2.0.0:
   version "2.0.0"
@@ -2299,10 +2299,10 @@ can-symlink@^1.0.0:
   dependencies:
     tmp "0.0.28"
 
-caniuse-lite@^1.0.30000844, caniuse-lite@^1.0.30000899:
-  version "1.0.30000912"
-  resolved "https://registry.yarnpkg.com/caniuse-lite/-/caniuse-lite-1.0.30000912.tgz#08e650d4090a9c0ab06bfd2b46b7d3ad6dcaea28"
-  integrity sha512-M3zAtV36U+xw5mMROlTXpAHClmPAor6GPKAMD5Yi7glCB5sbMPFtnQ3rGpk4XqPdUrrTIaVYSJZxREZWNy8QJg==
+caniuse-lite@^1.0.30000844, caniuse-lite@^1.0.30000912:
+  version "1.0.30000916"
+  resolved "https://registry.yarnpkg.com/caniuse-lite/-/caniuse-lite-1.0.30000916.tgz#3428d3f529f0a7b2bfaaec65e796037bdd433aab"
+  integrity sha512-D6J9jloPm2MPkg0PXcODLMQAJKkeixKO9xhqTUMvtd44MtTYMyyDXPQ2Lk9IgBq5FH0frwiPa/N/w8ncQf7kIQ==
 
 capture-exit@^1.2.0:
   version "1.2.0"
@@ -2705,9 +2705,9 @@ copy-descriptor@^0.1.0:
   integrity sha1-Z29us8OZl8LuGsOpJP1hJHSPV40=
 
 core-js@^2.4.0, core-js@^2.5.0, core-js@^2.5.7:
-  version "2.5.7"
-  resolved "https://registry.yarnpkg.com/core-js/-/core-js-2.5.7.tgz#f972608ff0cead68b841a16a932d0b183791814e"
-  integrity sha512-RszJCAxg/PP6uzXVXL6BsxSXx/B05oJAQ2vkJRjyjrEcNVycaqOmNb5OTxZPE3xa5gwZduqza6L9JOCenh/Ecw==
+  version "2.6.0"
+  resolved "https://registry.yarnpkg.com/core-js/-/core-js-2.6.0.tgz#1e30793e9ee5782b307e37ffa22da0eacddd84d4"
+  integrity sha512-kLRC6ncVpuEW/1kwrOXYX6KQASCVtrh1gQr/UiaVgFlf9WE5Vp+lNe5+h3LuMr5PAucWnnEXwH0nQHRH/gpGtw==
 
 core-object@^3.1.5:
   version "3.1.5"
@@ -2969,10 +2969,10 @@ ee-first@1.1.1:
   resolved "https://registry.yarnpkg.com/ee-first/-/ee-first-1.1.1.tgz#590c61156b0ae2f4f0255732a158b266bc56b21d"
   integrity sha1-WQxhFWsK4vTwJVcyoViyZrxWsh0=
 
-electron-to-chromium@^1.3.47, electron-to-chromium@^1.3.82:
-  version "1.3.85"
-  resolved "https://registry.yarnpkg.com/electron-to-chromium/-/electron-to-chromium-1.3.85.tgz#5c46f790aa96445cabc57eb9d17346b1e46476fe"
-  integrity sha512-kWSDVVF9t3mft2OHVZy4K85X2beP6c6mFm3teFS/mLSDJpQwuFIWHrULCX+w6H1E55ZYmFRlT+ATAFRwhrYzsw==
+electron-to-chromium@^1.3.47, electron-to-chromium@^1.3.86:
+  version "1.3.88"
+  resolved "https://registry.yarnpkg.com/electron-to-chromium/-/electron-to-chromium-1.3.88.tgz#f36ab32634f49ef2b0fdc1e82e2d1cc17feb29e7"
+  integrity sha512-UPV4NuQMKeUh1S0OWRvwg0PI8ASHN9kBC8yDTk1ROXLC85W5GnhTRu/MZu3Teqx3JjlQYuckuHYXSUSgtb3J+A==
 
 ember-assign-polyfill@^2.6.0:
   version "2.6.0"
@@ -3434,9 +3434,9 @@ engine.io-parser@~2.1.0, engine.io-parser@~2.1.1:
     has-binary2 "~1.0.2"
 
 engine.io@~3.3.1:
-  version "3.3.1"
-  resolved "https://registry.yarnpkg.com/engine.io/-/engine.io-3.3.1.tgz#e076d9d2d6c075dda4623253b80fa045c81dd3a4"
-  integrity sha512-p0njqQo5QWVxJauKcnp5IO+LBeE5JD1tAf+UxPU8ASEUHSpsSSfYR+kVb8XGGH8AEDUa1Dk5jCvPQShNBL5BdQ==
+  version "3.3.2"
+  resolved "https://registry.yarnpkg.com/engine.io/-/engine.io-3.3.2.tgz#18cbc8b6f36e9461c5c0f81df2b830de16058a59"
+  integrity sha512-AsaA9KG7cWPXWHp5FvHdDWY3AMWeZ8x+2pUVLcn71qE5AtAzgGbxuclOytygskw8XGmiQafTmnI9Bix3uihu2w==
   dependencies:
     accepts "~1.3.4"
     base64id "1.0.0"
@@ -6336,10 +6336,10 @@ node-notifier@^5.0.1:
     shellwords "^0.1.1"
     which "^1.3.0"
 
-node-releases@^1.0.1:
-  version "1.0.5"
-  resolved "https://registry.yarnpkg.com/node-releases/-/node-releases-1.0.5.tgz#a641adcc968b039a27345d92ef10b093e5cbd41d"
-  integrity sha512-Ky7q0BO1BBkG/rQz6PkEZ59rwo+aSfhczHP1wwq8IowoVdN/FpiP7qp0XW0P2+BVCWe5fQUBozdbVd54q1RbCQ==
+node-releases@^1.0.5:
+  version "1.1.7"
+  resolved "https://registry.yarnpkg.com/node-releases/-/node-releases-1.1.7.tgz#b09a10394d0ed8f7778f72bb861dde68b146303b"
+  integrity sha512-bKdrwaqJUPHqlCzDD7so/R+Nk0jGv9a11ZhLrD9f6i947qGLrGAhU3OxRENa19QQmwzGy/g6zCDEuLGDO8HPvA==
   dependencies:
     semver "^5.3.0"
 
@@ -6872,9 +6872,9 @@ pluralize@^7.0.0:
   integrity sha512-ARhBOdzS3e41FbkW/XWrTEtukqqLoK5+Z/4UeDaLuSW+39JPeFgs4gCGqsrJHVZX0fUrx//4OF0K1CUGwlIFow==
 
 portfinder@^1.0.15:
-  version "1.0.19"
-  resolved "https://registry.yarnpkg.com/portfinder/-/portfinder-1.0.19.tgz#07e87914a55242dcda5b833d42f018d6875b595f"
-  integrity sha512-23aeQKW9KgHe6citUrG3r9HjeX6vls0h713TAa+CwTKZwNIr/pD2ApaxYF4Um3ZZyq4ar+Siv3+fhoHaIwSOSw==
+  version "1.0.20"
+  resolved "https://registry.yarnpkg.com/portfinder/-/portfinder-1.0.20.tgz#bea68632e54b2e13ab7b0c4775e9b41bf270e44a"
+  integrity sha512-Yxe4mTyDzTd59PZJY4ojZR8F+E5e97iq2ZOHPz3HDgSvYC5siNad2tLooQ5y5QHyQhc3xVqvyk/eNA3wuoa7Sw==
   dependencies:
     async "^1.5.2"
     debug "^2.2.0"
@@ -6923,9 +6923,9 @@ process-relative-require@^1.0.0:
     node-modules-path "^1.0.0"
 
 progress@^2.0.0:
-  version "2.0.1"
-  resolved "https://registry.yarnpkg.com/progress/-/progress-2.0.1.tgz#c9242169342b1c29d275889c95734621b1952e31"
-  integrity sha512-OE+a6vzqazc+K6LxJrX5UPyKFvGnL5CYmq2jFGNIBWHpc4QyE49/YOumcrpQFJpfejmvRtbJzgO1zPmMCqlbBg==
+  version "2.0.3"
+  resolved "https://registry.yarnpkg.com/progress/-/progress-2.0.3.tgz#7e8cf8d8f5b8f239c1bc68beb4eb78567d572ef8"
+  integrity sha512-7PiHtLll5LdnKIMw100I+8xJXR5gW2QwWYkT6iJva0bXitZKa/XMrSbdmg3r2Xnaidz9Qumd0VPaMrZlF9V9sA==
 
 promise-map-series@^0.2.1, promise-map-series@^0.2.3:
   version "0.2.3"
@@ -7212,14 +7212,14 @@ regexpu-core@^2.0.0:
     regjsparser "^0.1.4"
 
 regexpu-core@^4.1.3, regexpu-core@^4.2.0:
-  version "4.2.0"
-  resolved "https://registry.yarnpkg.com/regexpu-core/-/regexpu-core-4.2.0.tgz#a3744fa03806cffe146dea4421a3e73bdcc47b1d"
-  integrity sha512-Z835VSnJJ46CNBttalHD/dB+Sj2ezmY6Xp38npwU87peK6mqOzOpV8eYktdkLTEkzzD+JsTcxd84ozd8I14+rw==
+  version "4.4.0"
+  resolved "https://registry.yarnpkg.com/regexpu-core/-/regexpu-core-4.4.0.tgz#8d43e0d1266883969720345e70c275ee0aec0d32"
+  integrity sha512-eDDWElbwwI3K0Lo6CqbQbA6FwgtCz4kYTarrri1okfkRLZAqstU+B3voZBCjg8Fl6iq0gXrJG6MvRgLthfvgOA==
   dependencies:
     regenerate "^1.4.0"
     regenerate-unicode-properties "^7.0.0"
-    regjsgen "^0.4.0"
-    regjsparser "^0.3.0"
+    regjsgen "^0.5.0"
+    regjsparser "^0.6.0"
     unicode-match-property-ecmascript "^1.0.4"
     unicode-match-property-value-ecmascript "^1.0.2"
 
@@ -7243,10 +7243,10 @@ regjsgen@^0.2.0:
   resolved "https://registry.yarnpkg.com/regjsgen/-/regjsgen-0.2.0.tgz#6c016adeac554f75823fe37ac05b92d5a4edb1f7"
   integrity sha1-bAFq3qxVT3WCP+N6wFuS1aTtsfc=
 
-regjsgen@^0.4.0:
-  version "0.4.0"
-  resolved "https://registry.yarnpkg.com/regjsgen/-/regjsgen-0.4.0.tgz#c1eb4c89a209263f8717c782591523913ede2561"
-  integrity sha512-X51Lte1gCYUdlwhF28+2YMO0U6WeN0GLpgpA7LK7mbdDnkQYiwvEpmpe0F/cv5L14EbxgrdayAG3JETBv0dbXA==
+regjsgen@^0.5.0:
+  version "0.5.0"
+  resolved "https://registry.yarnpkg.com/regjsgen/-/regjsgen-0.5.0.tgz#a7634dc08f89209c2049adda3525711fb97265dd"
+  integrity sha512-RnIrLhrXCX5ow/E5/Mh2O4e/oa1/jW0eaBKTSy3LaCj+M3Bqvm97GWDp2yUtzIs4LEn65zR2yiYGFqb2ApnzDA==
 
 regjsparser@^0.1.4:
   version "0.1.5"
@@ -7255,10 +7255,10 @@ regjsparser@^0.1.4:
   dependencies:
     jsesc "~0.5.0"
 
-regjsparser@^0.3.0:
-  version "0.3.0"
-  resolved "https://registry.yarnpkg.com/regjsparser/-/regjsparser-0.3.0.tgz#3c326da7fcfd69fa0d332575a41c8c0cdf588c96"
-  integrity sha512-zza72oZBBHzt64G7DxdqrOo/30bhHkwMUoT0WqfGu98XLd7N+1tsy5MJ96Bk4MD0y74n629RhmrGW6XlnLLwCA==
+regjsparser@^0.6.0:
+  version "0.6.0"
+  resolved "https://registry.yarnpkg.com/regjsparser/-/regjsparser-0.6.0.tgz#f1e6ae8b7da2bae96c99399b868cd6c933a2ba9c"
+  integrity sha512-RQ7YyokLiQBomUJuUG8iGVvkgOLxwyZM8k6d3q5SAXpg4r5TZJZigKFvC6PpD+qQ98bCDC5YelPeA3EucDoNeQ==
   dependencies:
     jsesc "~0.5.0"
 
@@ -7610,7 +7610,7 @@ signal-exit@^3.0.0, signal-exit@^3.0.2:
   resolved "https://registry.yarnpkg.com/signal-exit/-/signal-exit-3.0.2.tgz#b5fdc08f1287ea1178628e415e25132b73646c6d"
   integrity sha1-tf3AjxKH6hF4Yo5BXiUTK3NkbG0=
 
-silent-error@^1.0.0, silent-error@^1.0.1, silent-error@^1.1.0:
+silent-error@^1.0.0, silent-error@^1.0.1, silent-error@^1.1.0, silent-error@^1.1.1:
   version "1.1.1"
   resolved "https://registry.yarnpkg.com/silent-error/-/silent-error-1.1.1.tgz#f72af5b0d73682a2ba1778b7e32cd8aa7c2d8662"
   integrity sha512-n4iEKyNcg4v6/jpb3c0/iyH2G1nzUNl7Gpqtn/mHIJK9S/q/7MCfoO4rwVOoO59qPFIc0hVHvMbiOJ0NdtxKKw==
@@ -7748,9 +7748,9 @@ sort-object-keys@^1.1.2:
   integrity sha1-06bEjcKsl+a8lDZ2luA/bQnTeVI=
 
 sort-package-json@^1.15.0:
-  version "1.16.0"
-  resolved "https://registry.yarnpkg.com/sort-package-json/-/sort-package-json-1.16.0.tgz#087f5ce05b6faca373312e7124918e0d68492d7b"
-  integrity sha512-QFJNxdpp7zZgSkmAIaMrteqqxGP4TkooKrGtslM2qYiML92PTYDOFOk+lG+TdvJzjheD502UFIys2qSvQljKaw==
+  version "1.17.0"
+  resolved "https://registry.yarnpkg.com/sort-package-json/-/sort-package-json-1.17.0.tgz#1dfe40b5632e28919a09e80f3da555090ec30cd7"
+  integrity sha512-pVEdEI3w5dlXVJ1N0W/SwSfdrUFWVeB/zcRruQVf999TlCAZ1fS+Aw+EPZpdoHjoALPx6jNNtU9batTrbeVlYg==
   dependencies:
     detect-indent "^5.0.0"
     sort-object-keys "^1.1.2"
@@ -7850,9 +7850,9 @@ spawn-wrap@^1.4.2:
     which "^1.3.0"
 
 spdx-correct@^3.0.0:
-  version "3.0.2"
-  resolved "https://registry.yarnpkg.com/spdx-correct/-/spdx-correct-3.0.2.tgz#19bb409e91b47b1ad54159243f7312a858db3c2e"
-  integrity sha512-q9hedtzyXHr5S0A1vEPoK/7l8NpfkFYTq6iCY+Pno2ZbdZR6WexZFtqeVGkGxW3TEJMN914Z55EnAGMmenlIQQ==
+  version "3.1.0"
+  resolved "https://registry.yarnpkg.com/spdx-correct/-/spdx-correct-3.1.0.tgz#fb83e504445268f154b074e218c87c003cd31df4"
+  integrity sha512-lr2EZCctC2BNR7j7WzJ2FpDznxky1sjfxvvYEyzxNyb6lZXHODmEoJeFu4JupYlkfha1KZpJyoqiJ7pgA1qq8Q==
   dependencies:
     spdx-expression-parse "^3.0.0"
     spdx-license-ids "^3.0.0"
@@ -8275,15 +8275,15 @@ tough-cookie@~2.4.3:
     punycode "^1.4.1"
 
 tree-sync@^1.2.2:
-  version "1.2.2"
-  resolved "https://registry.yarnpkg.com/tree-sync/-/tree-sync-1.2.2.tgz#2cf76b8589f59ffedb58db5a3ac7cb013d0158b7"
-  integrity sha1-LPdrhYn1n/7bWNtaOsfLAT0BWLc=
+  version "1.4.0"
+  resolved "https://registry.yarnpkg.com/tree-sync/-/tree-sync-1.4.0.tgz#314598d13abaf752547d9335b8f95d9a137100d6"
+  integrity sha512-YvYllqh3qrR5TAYZZTXdspnIhlKAYezPYw11ntmweoceu4VK+keN356phHRIIo1d+RDmLpHZrUlmxga2gc9kSQ==
   dependencies:
     debug "^2.2.0"
     fs-tree-diff "^0.5.6"
     mkdirp "^0.5.1"
     quick-temp "^0.1.5"
-    walk-sync "^0.2.7"
+    walk-sync "^0.3.3"
 
 trim-newlines@^1.0.0:
   version "1.0.0"
@@ -8537,18 +8537,10 @@ verror@1.10.0:
     core-util-is "1.0.2"
     extsprintf "^1.2.0"
 
-walk-sync@^0.2.7:
-  version "0.2.7"
-  resolved "https://registry.yarnpkg.com/walk-sync/-/walk-sync-0.2.7.tgz#b49be4ee6867657aeb736978b56a29d10fa39969"
-  integrity sha1-tJvk7mhnZXrrc2l4tWop0Q+jmWk=
-  dependencies:
-    ensure-posix-path "^1.0.0"
-    matcher-collection "^1.0.0"
-
 walk-sync@^0.3.0, walk-sync@^0.3.1, walk-sync@^0.3.2, walk-sync@^0.3.3:
-  version "0.3.3"
-  resolved "https://registry.yarnpkg.com/walk-sync/-/walk-sync-0.3.3.tgz#1e9f12cd4fe6e0e6d4a0715b5cc7e30711d43cd1"
-  integrity sha512-jQgTHmCazUngGqvHZFlr30u2VLKEKErBMLFe+fBl5mn4rh9aI/QVRog8PT1hv2vaOu4EBwigfmpRTyZrbnpRVA==
+  version "0.3.4"
+  resolved "https://registry.yarnpkg.com/walk-sync/-/walk-sync-0.3.4.tgz#cf78486cc567d3a96b5b2237c6108017a5ffb9a4"
+  integrity sha512-ttGcuHA/OBnN2pcM6johpYlEms7XpO5/fyKIr48541xXedan4roO8cS1Q2S/zbbjGH/BarYDAMeS2Mi9HE5Tig==
   dependencies:
     ensure-posix-path "^1.0.0"
     matcher-collection "^1.0.0"