ember-source 2.13.4 → 2.14.0.beta.1

data/dist/ember-testing.js

@@ -1,4 +1,4 @@
-;(function() {
+(function() {
 /*!
  * @overview  Ember - JavaScript Application Framework
  * @copyright Copyright 2011-2017 Tilde Inc. and contributors
@@ -6,7 +6,7 @@
  *            Portions Copyright 2008-2011 Apple Inc. All rights reserved.
  * @license   Licensed under MIT license
  *            See https://raw.github.com/emberjs/ember.js/master/LICENSE
- * @version   2.13.4
+ * @version   2.14.0-beta.1
  */
 
 var enifed, requireModule, Ember;
@@ -94,96 +94,867 @@ var mainContext = this; // Used in ember-environment/lib/global.js
         }
       }
 
-      callback.apply(this, reified);
+      callback.apply(this, reified);
+
+      return exports;
+    }
+
+    requireModule._eak_seen = registry;
+
+    Ember.__loader = {
+      define: enifed,
+      require: requireModule,
+      registry: registry
+    };
+  } else {
+    enifed = Ember.__loader.define;
+    requireModule = Ember.__loader.require;
+  }
+})();
+
+enifed('ember-babel', ['exports'], function (exports) {
+  'use strict';
+
+  exports.classCallCheck = classCallCheck;
+  exports.inherits = inherits;
+  exports.taggedTemplateLiteralLoose = taggedTemplateLiteralLoose;
+  exports.createClass = createClass;
+  exports.defaults = defaults;
+  function classCallCheck(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+      throw new TypeError('Cannot call a class as a function');
+    }
+  }
+
+  function inherits(subClass, superClass) {
+    if (typeof superClass !== 'function' && superClass !== null) {
+      throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass);
+    }
+
+    subClass.prototype = Object.create(superClass && superClass.prototype, {
+      constructor: {
+        value: subClass,
+        enumerable: false,
+        writable: true,
+        configurable: true
+      }
+    });
+
+    if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : defaults(subClass, superClass);
+  }
+
+  function taggedTemplateLiteralLoose(strings, raw) {
+    strings.raw = raw;
+    return strings;
+  }
+
+  function defineProperties(target, props) {
+    for (var i = 0; i < props.length; i++) {
+      var descriptor = props[i];
+      descriptor.enumerable = descriptor.enumerable || false;
+      descriptor.configurable = true;
+      if ('value' in descriptor) descriptor.writable = true;
+      Object.defineProperty(target, descriptor.key, descriptor);
+    }
+  }
+
+  function createClass(Constructor, protoProps, staticProps) {
+    if (protoProps) defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) defineProperties(Constructor, staticProps);
+    return Constructor;
+  }
+
+  function defaults(obj, defaults) {
+    var keys = Object.getOwnPropertyNames(defaults);
+    for (var i = 0; i < keys.length; i++) {
+      var key = keys[i];
+      var value = Object.getOwnPropertyDescriptor(defaults, key);
+      if (value && value.configurable && obj[key] === undefined) {
+        Object.defineProperty(obj, key, value);
+      }
+    }
+    return obj;
+  }
+
+  var possibleConstructorReturn = exports.possibleConstructorReturn = function (self, call) {
+    if (!self) {
+      throw new ReferenceError('this hasn\'t been initialised - super() hasn\'t been called');
+    }
+    return call && (typeof call === 'object' || typeof call === 'function') ? call : self;
+  };
+
+  var slice = exports.slice = Array.prototype.slice;
+});
+enifed('ember-debug/deprecate', ['exports', 'ember-debug/error', 'ember-console', 'ember-environment', 'ember-debug/handlers'], function (exports, _error, _emberConsole, _emberEnvironment, _handlers) {
+  'use strict';
+
+  exports.missingOptionsUntilDeprecation = exports.missingOptionsIdDeprecation = exports.missingOptionsDeprecation = undefined;
+  exports.registerHandler = registerHandler;
+  exports.default = deprecate;
+
+
+  /**
+    Allows for runtime registration of handler functions that override the default deprecation behavior.
+    Deprecations are invoked by calls to [Ember.deprecate](http://emberjs.com/api/classes/Ember.html#method_deprecate).
+    The following example demonstrates its usage by registering a handler that throws an error if the
+    message contains the word "should", otherwise defers to the default handler.
+  
+    ```javascript
+    Ember.Debug.registerDeprecationHandler((message, options, next) => {
+      if (message.indexOf('should') !== -1) {
+        throw new Error(`Deprecation message with should: ${message}`);
+      } else {
+        // defer to whatever handler was registered before this one
+        next(message, options);
+      }
+    });
+    ```
+  
+    The handler function takes the following arguments:
+  
+    <ul>
+      <li> <code>message</code> - The message received from the deprecation call.</li>
+      <li> <code>options</code> - An object passed in with the deprecation call containing additional information including:</li>
+        <ul>
+          <li> <code>id</code> - An id of the deprecation in the form of <code>package-name.specific-deprecation</code>.</li>
+          <li> <code>until</code> - The Ember version number the feature and deprecation will be removed in.</li>
+        </ul>
+      <li> <code>next</code> - A function that calls into the previously registered handler.</li>
+    </ul>
+  
+    @public
+    @static
+    @method registerDeprecationHandler
+    @param handler {Function} A function to handle deprecation calls.
+    @since 2.1.0
+  */
+  /*global __fail__*/
+
+  function registerHandler(handler) {
+    (0, _handlers.registerHandler)('deprecate', handler);
+  }
+
+  function formatMessage(_message, options) {
+    var message = _message;
+
+    if (options && options.id) {
+      message = message + (' [deprecation id: ' + options.id + ']');
+    }
+
+    if (options && options.url) {
+      message += ' See ' + options.url + ' for more details.';
+    }
+
+    return message;
+  }
+
+  registerHandler(function logDeprecationToConsole(message, options) {
+    var updatedMessage = formatMessage(message, options);
+
+    _emberConsole.default.warn('DEPRECATION: ' + updatedMessage);
+  });
+
+  var captureErrorForStack = void 0;
+
+  if (new Error().stack) {
+    captureErrorForStack = function () {
+      return new Error();
+    };
+  } else {
+    captureErrorForStack = function () {
+      try {
+        __fail__.fail();
+      } catch (e) {
+        return e;
+      }
+    };
+  }
+
+  registerHandler(function logDeprecationStackTrace(message, options, next) {
+    if (_emberEnvironment.ENV.LOG_STACKTRACE_ON_DEPRECATION) {
+      var stackStr = '';
+      var error = captureErrorForStack();
+      var stack = void 0;
+
+      if (error.stack) {
+        if (error['arguments']) {
+          // Chrome
+          stack = error.stack.replace(/^\s+at\s+/gm, '').replace(/^([^\(]+?)([\n$])/gm, '{anonymous}($1)$2').replace(/^Object.<anonymous>\s*\(([^\)]+)\)/gm, '{anonymous}($1)').split('\n');
+          stack.shift();
+        } else {
+          // Firefox
+          stack = error.stack.replace(/(?:\n@:0)?\s+$/m, '').replace(/^\(/gm, '{anonymous}(').split('\n');
+        }
+
+        stackStr = '\n    ' + stack.slice(2).join('\n    ');
+      }
+
+      var updatedMessage = formatMessage(message, options);
+
+      _emberConsole.default.warn('DEPRECATION: ' + updatedMessage + stackStr);
+    } else {
+      next.apply(undefined, arguments);
+    }
+  });
+
+  registerHandler(function raiseOnDeprecation(message, options, next) {
+    if (_emberEnvironment.ENV.RAISE_ON_DEPRECATION) {
+      var updatedMessage = formatMessage(message);
+
+      throw new _error.default(updatedMessage);
+    } else {
+      next.apply(undefined, arguments);
+    }
+  });
+
+  var missingOptionsDeprecation = exports.missingOptionsDeprecation = 'When calling `Ember.deprecate` you ' + 'must provide an `options` hash as the third parameter.  ' + '`options` should include `id` and `until` properties.';
+  var missingOptionsIdDeprecation = exports.missingOptionsIdDeprecation = 'When calling `Ember.deprecate` you must provide `id` in options.';
+  var missingOptionsUntilDeprecation = exports.missingOptionsUntilDeprecation = 'When calling `Ember.deprecate` you must provide `until` in options.';
+
+  /**
+  @module ember
+  @submodule ember-debug
+  */
+
+  /**
+    Display a deprecation warning with the provided message and a stack trace
+    (Chrome and Firefox only).
+  
+    * In a production build, this method is defined as an empty function (NOP).
+    Uses of this method in Ember itself are stripped from the ember.prod.js build.
+  
+    @method deprecate
+    @param {String} message A description of the deprecation.
+    @param {Boolean} test A boolean. If falsy, the deprecation will be displayed.
+    @param {Object} options
+    @param {String} options.id A unique id for this deprecation. The id can be
+      used by Ember debugging tools to change the behavior (raise, log or silence)
+      for that specific deprecation. The id should be namespaced by dots, e.g.
+      "view.helper.select".
+    @param {string} options.until The version of Ember when this deprecation
+      warning will be removed.
+    @param {String} [options.url] An optional url to the transition guide on the
+      emberjs.com website.
+    @for Ember
+    @public
+    @since 1.0.0
+  */
+  function deprecate(message, test, options) {
+    if (!options || !options.id && !options.until) {
+      deprecate(missingOptionsDeprecation, false, {
+        id: 'ember-debug.deprecate-options-missing',
+        until: '3.0.0',
+        url: 'http://emberjs.com/deprecations/v2.x/#toc_ember-debug-function-options'
+      });
+    }
+
+    if (options && !options.id) {
+      deprecate(missingOptionsIdDeprecation, false, {
+        id: 'ember-debug.deprecate-id-missing',
+        until: '3.0.0',
+        url: 'http://emberjs.com/deprecations/v2.x/#toc_ember-debug-function-options'
+      });
+    }
+
+    if (options && !options.until) {
+      deprecate(missingOptionsUntilDeprecation, options && options.until, {
+        id: 'ember-debug.deprecate-until-missing',
+        until: '3.0.0',
+        url: 'http://emberjs.com/deprecations/v2.x/#toc_ember-debug-function-options'
+      });
+    }
+
+    _handlers.invoke.apply(undefined, ['deprecate'].concat(Array.prototype.slice.call(arguments)));
+  }
+});
+enifed("ember-debug/error", ["exports", "ember-babel"], function (exports, _emberBabel) {
+  "use strict";
+
+  function ExtendBuiltin(klass) {
+    function ExtendableBuiltin() {
+      klass.apply(this, arguments);
+    }
+
+    ExtendableBuiltin.prototype = Object.create(klass.prototype);
+    ExtendableBuiltin.prototype.constructor = ExtendableBuiltin;
+    return ExtendableBuiltin;
+  }
+
+  /**
+    A subclass of the JavaScript Error object for use in Ember.
+  
+    @class Error
+    @namespace Ember
+    @extends Error
+    @constructor
+    @public
+  */
+
+  var EmberError = function (_ExtendBuiltin) {
+    (0, _emberBabel.inherits)(EmberError, _ExtendBuiltin);
+
+    function EmberError(message) {
+      (0, _emberBabel.classCallCheck)(this, EmberError);
+
+      var _this = (0, _emberBabel.possibleConstructorReturn)(this, _ExtendBuiltin.call(this));
+
+      if (!(_this instanceof EmberError)) {
+        var _ret;
+
+        return _ret = new EmberError(message), (0, _emberBabel.possibleConstructorReturn)(_this, _ret);
+      }
+
+      var error = Error.call(_this, message);
+
+      if (Error.captureStackTrace) {
+        Error.captureStackTrace(_this, EmberError);
+      } else {
+        _this.stack = error.stack;
+      }
+
+      _this.description = error.description;
+      _this.fileName = error.fileName;
+      _this.lineNumber = error.lineNumber;
+      _this.message = error.message;
+      _this.name = error.name;
+      _this.number = error.number;
+      _this.code = error.code;
+      return _this;
+    }
+
+    return EmberError;
+  }(ExtendBuiltin(Error));
+
+  exports.default = EmberError;
+});
+enifed('ember-debug/features', ['exports', 'ember-environment', 'ember/features'], function (exports, _emberEnvironment, _features) {
+  'use strict';
+
+  exports.default = isEnabled;
+  var FEATURES = _features.FEATURES;
+
+
+  /**
+    The hash of enabled Canary features. Add to this, any canary features
+    before creating your application.
+  
+    Alternatively (and recommended), you can also define `EmberENV.FEATURES`
+    if you need to enable features flagged at runtime.
+  
+    @class FEATURES
+    @namespace Ember
+    @static
+    @since 1.1.0
+    @public
+  */
+
+  // Auto-generated
+
+  /**
+    Determine whether the specified `feature` is enabled. Used by Ember's
+    build tools to exclude experimental features from beta/stable builds.
+  
+    You can define the following configuration options:
+  
+    * `EmberENV.ENABLE_OPTIONAL_FEATURES` - enable any features that have not been explicitly
+      enabled/disabled.
+  
+    @method isEnabled
+    @param {String} feature The feature to check
+    @return {Boolean}
+    @for Ember.FEATURES
+    @since 1.1.0
+    @public
+  */
+  function isEnabled(feature) {
+    var featureValue = FEATURES[feature];
+
+    if (featureValue === true || featureValue === false || featureValue === undefined) {
+      return featureValue;
+    } else if (_emberEnvironment.ENV.ENABLE_OPTIONAL_FEATURES) {
+      return true;
+    } else {
+      return false;
+    }
+  }
+});
+enifed("ember-debug/handlers", ["exports"], function (exports) {
+  "use strict";
+
+  exports.registerHandler = registerHandler;
+  exports.invoke = invoke;
+  var HANDLERS = exports.HANDLERS = {};
+
+  function registerHandler(type, callback) {
+    var nextHandler = HANDLERS[type] || function () {};
+
+    HANDLERS[type] = function (message, options) {
+      callback(message, options, nextHandler);
+    };
+  }
+
+  function invoke(type, message, test, options) {
+    if (test) {
+      return;
+    }
+
+    var handlerForType = HANDLERS[type];
+
+    if (handlerForType) {
+      handlerForType(message, options);
+    }
+  }
+});
+enifed('ember-debug/index', ['exports', 'ember-debug/warn', 'ember-debug/deprecate', 'ember-debug/features', 'ember-debug/error', 'ember-debug/testing', 'ember-environment', 'ember-console', 'ember/features'], function (exports, _warn2, _deprecate2, _features, _error, _testing, _emberEnvironment, _emberConsole, _features2) {
+  'use strict';
+
+  exports.runningNonEmberDebugJS = exports.debugFunctions = exports.setTesting = exports.isTesting = exports.Error = exports.isFeatureEnabled = exports.registerDeprecationHandler = exports.registerWarnHandler = undefined;
+  Object.defineProperty(exports, 'registerWarnHandler', {
+    enumerable: true,
+    get: function () {
+      return _warn2.registerHandler;
+    }
+  });
+  Object.defineProperty(exports, 'registerDeprecationHandler', {
+    enumerable: true,
+    get: function () {
+      return _deprecate2.registerHandler;
+    }
+  });
+  Object.defineProperty(exports, 'isFeatureEnabled', {
+    enumerable: true,
+    get: function () {
+      return _features.default;
+    }
+  });
+  Object.defineProperty(exports, 'Error', {
+    enumerable: true,
+    get: function () {
+      return _error.default;
+    }
+  });
+  Object.defineProperty(exports, 'isTesting', {
+    enumerable: true,
+    get: function () {
+      return _testing.isTesting;
+    }
+  });
+  Object.defineProperty(exports, 'setTesting', {
+    enumerable: true,
+    get: function () {
+      return _testing.setTesting;
+    }
+  });
+  exports._warnIfUsingStrippedFeatureFlags = _warnIfUsingStrippedFeatureFlags;
+  exports.getDebugFunction = getDebugFunction;
+  exports.setDebugFunction = setDebugFunction;
+  exports.assert = assert;
+  exports.info = info;
+  exports.warn = warn;
+  exports.debug = debug;
+  exports.deprecate = deprecate;
+  exports.deprecateFunc = deprecateFunc;
+  exports.runInDebug = runInDebug;
+  exports.debugSeal = debugSeal;
+  exports.debugFreeze = debugFreeze;
+  var DEFAULT_FEATURES = _features2.DEFAULT_FEATURES,
+      FEATURES = _features2.FEATURES;
+  var debugFunctions = exports.debugFunctions = {
+    assert: function () {},
+    info: function () {},
+    warn: function () {},
+    debug: function () {},
+    deprecate: function () {},
+    deprecateFunc: function () {
+      var _ref;
+
+      return _ref = arguments.length - 1, arguments.length <= _ref ? undefined : arguments[_ref];
+    },
+    debugSeal: function () {},
+    debugFreeze: function () {}
+  };
+
+  /**
+  @module ember
+  @submodule ember-debug
+  */
+
+  /**
+  @class Ember
+  @public
+  */
+
+  /**
+    Define an assertion that will throw an exception if the condition is not met.
+  
+    * In a production build, this method is defined as an empty function (NOP).
+    Uses of this method in Ember itself are stripped from the ember.prod.js build.
+  
+    ```javascript
+    // Test for truthiness
+    Ember.assert('Must pass a valid object', obj);
+  
+    // Fail unconditionally
+    Ember.assert('This code path should never be run');
+    ```
+  
+    @method assert
+    @param {String} desc A description of the assertion. This will become
+      the text of the Error thrown if the assertion fails.
+    @param {Boolean} test Must be truthy for the assertion to pass. If
+      falsy, an exception will be thrown.
+    @public
+    @since 1.0.0
+  */
+  setDebugFunction('assert', function assert(desc, test) {
+    if (!test) {
+      throw new _error.default('Assertion Failed: ' + desc);
+    }
+  });
+
+  /**
+    Display a debug notice.
+  
+    * In a production build, this method is defined as an empty function (NOP).
+    Uses of this method in Ember itself are stripped from the ember.prod.js build.
+  
+    ```javascript
+    Ember.debug('I\'m a debug notice!');
+    ```
+  
+    @method debug
+    @param {String} message A debug message to display.
+    @public
+  */
+  setDebugFunction('debug', function debug(message) {
+    _emberConsole.default.debug('DEBUG: ' + message);
+  });
+
+  /**
+    Display an info notice.
+  
+    * In a production build, this method is defined as an empty function (NOP).
+    Uses of this method in Ember itself are stripped from the ember.prod.js build.
+  
+    @method info
+    @private
+  */
+  setDebugFunction('info', function info() {
+    _emberConsole.default.info.apply(undefined, arguments);
+  });
+
+  /**
+    Alias an old, deprecated method with its new counterpart.
+  
+    Display a deprecation warning with the provided message and a stack trace
+    (Chrome and Firefox only) when the assigned method is called.
+  
+    * In a production build, this method is defined as an empty function (NOP).
+  
+    ```javascript
+    Ember.oldMethod = Ember.deprecateFunc('Please use the new, updated method', Ember.newMethod);
+    ```
+  
+    @method deprecateFunc
+    @param {String} message A description of the deprecation.
+    @param {Object} [options] The options object for Ember.deprecate.
+    @param {Function} func The new function called to replace its deprecated counterpart.
+    @return {Function} A new function that wraps the original function with a deprecation warning
+    @private
+  */
+  setDebugFunction('deprecateFunc', function deprecateFunc() {
+    for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+
+    if (args.length === 3) {
+      var message = args[0],
+          options = args[1],
+          func = args[2];
+
+      return function () {
+        deprecate(message, false, options);
+        return func.apply(this, arguments);
+      };
+    } else {
+      var _message = args[0],
+          _func = args[1];
+
+      return function () {
+        deprecate(_message);
+        return _func.apply(this, arguments);
+      };
+    }
+  });
+
+  /**
+    Run a function meant for debugging.
+  
+    * In a production build, this method is defined as an empty function (NOP).
+    Uses of this method in Ember itself are stripped from the ember.prod.js build.
+  
+    ```javascript
+    Ember.runInDebug(() => {
+      Ember.Component.reopen({
+        didInsertElement() {
+          console.log("I'm happy");
+        }
+      });
+    });
+    ```
+  
+    @method runInDebug
+    @param {Function} func The function to be executed.
+    @since 1.5.0
+    @public
+  */
+  setDebugFunction('runInDebug', function runInDebug(func) {
+    func();
+  });
+
+  setDebugFunction('debugSeal', function debugSeal(obj) {
+    Object.seal(obj);
+  });
+
+  setDebugFunction('debugFreeze', function debugFreeze(obj) {
+    Object.freeze(obj);
+  });
+
+  setDebugFunction('deprecate', _deprecate2.default);
+
+  setDebugFunction('warn', _warn2.default);
+
+  /**
+    Will call `Ember.warn()` if ENABLE_OPTIONAL_FEATURES or
+    any specific FEATURES flag is truthy.
+  
+    This method is called automatically in debug canary builds.
+  
+    @private
+    @method _warnIfUsingStrippedFeatureFlags
+    @return {void}
+  */
+  function _warnIfUsingStrippedFeatureFlags(FEATURES, knownFeatures, featuresWereStripped) {
+    if (featuresWereStripped) {
+      warn('Ember.ENV.ENABLE_OPTIONAL_FEATURES is only available in canary builds.', !_emberEnvironment.ENV.ENABLE_OPTIONAL_FEATURES, { id: 'ember-debug.feature-flag-with-features-stripped' });
+
+      var keys = Object.keys(FEATURES || {});
+      for (var i = 0; i < keys.length; i++) {
+        var key = keys[i];
+        if (key === 'isEnabled' || !(key in knownFeatures)) {
+          continue;
+        }
+
+        warn('FEATURE["' + key + '"] is set as enabled, but FEATURE flags are only available in canary builds.', !FEATURES[key], { id: 'ember-debug.feature-flag-with-features-stripped' });
+      }
+    }
+  }
+
+  if (!(0, _testing.isTesting)()) {
+    // Complain if they're using FEATURE flags in builds other than canary
+    FEATURES['features-stripped-test'] = true;
+    var featuresWereStripped = true;
+
+    if ((0, _features.default)('features-stripped-test')) {
+      featuresWereStripped = false;
+    }
+
+    delete FEATURES['features-stripped-test'];
+    _warnIfUsingStrippedFeatureFlags(_emberEnvironment.ENV.FEATURES, DEFAULT_FEATURES, featuresWereStripped);
+
+    // Inform the developer about the Ember Inspector if not installed.
+    var isFirefox = _emberEnvironment.environment.isFirefox;
+    var isChrome = _emberEnvironment.environment.isChrome;
+
+    if (typeof window !== 'undefined' && (isFirefox || isChrome) && window.addEventListener) {
+      window.addEventListener('load', function () {
+        if (document.documentElement && document.documentElement.dataset && !document.documentElement.dataset.emberExtension) {
+          var downloadURL = void 0;
+
+          if (isChrome) {
+            downloadURL = 'https://chrome.google.com/webstore/detail/ember-inspector/bmdblncegkenkacieihfhpjfppoconhi';
+          } else if (isFirefox) {
+            downloadURL = 'https://addons.mozilla.org/en-US/firefox/addon/ember-inspector/';
+          }
+
+          debug('For more advanced debugging, install the Ember Inspector from ' + downloadURL);
+        }
+      }, false);
+    }
+  }
+
+  /*
+    We are transitioning away from `ember.js` to `ember.debug.js` to make
+    it much clearer that it is only for local development purposes.
+  
+    This flag value is changed by the tooling (by a simple string replacement)
+    so that if `ember.js` (which must be output for backwards compat reasons) is
+    used a nice helpful warning message will be printed out.
+  */
+  var runningNonEmberDebugJS = exports.runningNonEmberDebugJS = false;
+  if (runningNonEmberDebugJS) {
+    warn('Please use `ember.debug.js` instead of `ember.js` for development and debugging.');
+  }
+
+  function getDebugFunction(name) {
+    return debugFunctions[name];
+  }
+
+  function setDebugFunction(name, fn) {
+    debugFunctions[name] = fn;
+  }
+
+  function assert() {
+    return debugFunctions.assert.apply(undefined, arguments);
+  }
+
+  function info() {
+    return debugFunctions.info.apply(undefined, arguments);
+  }
+
+  function warn() {
+    return debugFunctions.warn.apply(undefined, arguments);
+  }
+
+  function debug() {
+    return debugFunctions.debug.apply(undefined, arguments);
+  }
+
+  function deprecate() {
+    return debugFunctions.deprecate.apply(undefined, arguments);
+  }
 
-      return exports;
-    }
+  function deprecateFunc() {
+    return debugFunctions.deprecateFunc.apply(undefined, arguments);
+  }
 
-    requireModule._eak_seen = registry;
+  function runInDebug() {
+    return debugFunctions.runInDebug.apply(undefined, arguments);
+  }
 
-    Ember.__loader = {
-      define: enifed,
-      require: requireModule,
-      registry: registry
-    };
-  } else {
-    enifed = Ember.__loader.define;
-    requireModule = Ember.__loader.require;
+  function debugSeal() {
+    return debugFunctions.debugSeal.apply(undefined, arguments);
   }
-})();
 
-function classCallCheck(instance, Constructor) {
-  if (!(instance instanceof Constructor)) {
-    throw new TypeError('Cannot call a class as a function');
+  function debugFreeze() {
+    return debugFunctions.debugFreeze.apply(undefined, arguments);
+  }
+});
+enifed("ember-debug/run-in-debug", [], function () {
+  "use strict";
+});
+enifed("ember-debug/testing", ["exports"], function (exports) {
+  "use strict";
+
+  exports.isTesting = isTesting;
+  exports.setTesting = setTesting;
+  var testing = false;
+
+  function isTesting() {
+    return testing;
   }
-}
 
-function inherits(subClass, superClass) {
-  if (typeof superClass !== 'function' && superClass !== null) {
-    throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass);
+  function setTesting(value) {
+    testing = !!value;
+  }
+});
+enifed('ember-debug/warn', ['exports', 'ember-console', 'ember-debug/deprecate', 'ember-debug/handlers'], function (exports, _emberConsole, _deprecate, _handlers) {
+  'use strict';
+
+  exports.missingOptionsIdDeprecation = exports.missingOptionsDeprecation = undefined;
+  exports.registerHandler = registerHandler;
+  exports.default = warn;
+
+
+  /**
+    Allows for runtime registration of handler functions that override the default warning behavior.
+    Warnings are invoked by calls made to [Ember.warn](http://emberjs.com/api/classes/Ember.html#method_warn).
+    The following example demonstrates its usage by registering a handler that does nothing overriding Ember's
+    default warning behavior.
+  
+    ```javascript
+    // next is not called, so no warnings get the default behavior
+    Ember.Debug.registerWarnHandler(() => {});
+    ```
+  
+    The handler function takes the following arguments:
+  
+    <ul>
+      <li> <code>message</code> - The message received from the warn call. </li>
+      <li> <code>options</code> - An object passed in with the warn call containing additional information including:</li>
+        <ul>
+          <li> <code>id</code> - An id of the warning in the form of <code>package-name.specific-warning</code>.</li>
+        </ul>
+      <li> <code>next</code> - A function that calls into the previously registered handler.</li>
+    </ul>
+  
+    @public
+    @static
+    @method registerWarnHandler
+    @param handler {Function} A function to handle warnings.
+    @since 2.1.0
+  */
+  function registerHandler(handler) {
+    (0, _handlers.registerHandler)('warn', handler);
   }
 
-  subClass.prototype = Object.create(superClass && superClass.prototype, {
-    constructor: {
-      value: subClass,
-      enumerable: false,
-      writable: true,
-      configurable: true
+  registerHandler(function logWarning(message, options) {
+    _emberConsole.default.warn('WARNING: ' + message);
+    if ('trace' in _emberConsole.default) {
+      _emberConsole.default.trace();
     }
   });
 
-  if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : defaults(subClass, superClass);
-}
-
-function taggedTemplateLiteralLoose(strings, raw) {
-  strings.raw = raw;
-  return strings;
-}
-
-function defineProperties(target, props) {
-  for (var i = 0; i < props.length; i++) {
-    var descriptor = props[i];
-    descriptor.enumerable = descriptor.enumerable || false;
-    descriptor.configurable = true;
-    if ('value' in descriptor) descriptor.writable = true;
-    Object.defineProperty(target, descriptor.key, descriptor);
-  }
-}
-
-function createClass(Constructor, protoProps, staticProps) {
-  if (protoProps) defineProperties(Constructor.prototype, protoProps);
-  if (staticProps) defineProperties(Constructor, staticProps);
-  return Constructor;
-}
-
-function interopExportWildcard(obj, defaults) {
-  var newObj = defaults({}, obj);
-  delete newObj['default'];
-  return newObj;
-}
-
-function defaults(obj, defaults) {
-  var keys = Object.getOwnPropertyNames(defaults);
-  for (var i = 0; i < keys.length; i++) {
-    var key = keys[i];
-    var value = Object.getOwnPropertyDescriptor(defaults, key);
-    if (value && value.configurable && obj[key] === undefined) {
-      Object.defineProperty(obj, key, value);
-    }
-  }
-  return obj;
-}
-
-var babelHelpers = {
-  classCallCheck: classCallCheck,
-  inherits: inherits,
-  taggedTemplateLiteralLoose: taggedTemplateLiteralLoose,
-  slice: Array.prototype.slice,
-  createClass: createClass,
-  interopExportWildcard: interopExportWildcard,
-  defaults: defaults
-};
+  var missingOptionsDeprecation = exports.missingOptionsDeprecation = 'When calling `Ember.warn` you ' + 'must provide an `options` hash as the third parameter.  ' + '`options` should include an `id` property.';
+  var missingOptionsIdDeprecation = exports.missingOptionsIdDeprecation = 'When calling `Ember.warn` you must provide `id` in options.';
+
+  /**
+  @module ember
+  @submodule ember-debug
+  */
+
+  /**
+    Display a warning with the provided message.
+  
+    * In a production build, this method is defined as an empty function (NOP).
+    Uses of this method in Ember itself are stripped from the ember.prod.js build.
+  
+    @method warn
+    @param {String} message A warning to display.
+    @param {Boolean} test An optional boolean. If falsy, the warning
+      will be displayed.
+    @param {Object} options An object that can be used to pass a unique
+      `id` for this warning.  The `id` can be used by Ember debugging tools
+      to change the behavior (raise, log, or silence) for that specific warning.
+      The `id` should be namespaced by dots, e.g. "ember-debug.feature-flag-with-features-stripped"
+    @for Ember
+    @public
+    @since 1.0.0
+  */
+  function warn(message, test, options) {
+    if (arguments.length === 2 && typeof test === 'object') {
+      options = test;
+      test = false;
+    }
+    if (!options) {
+      (0, _deprecate.default)(missingOptionsDeprecation, false, {
+        id: 'ember-debug.warn-options-missing',
+        until: '3.0.0',
+        url: 'http://emberjs.com/deprecations/v2.x/#toc_ember-debug-function-options'
+      });
+    }
+
+    if (options && !options.id) {
+      (0, _deprecate.default)(missingOptionsIdDeprecation, false, {
+        id: 'ember-debug.warn-id-missing',
+        until: '3.0.0',
+        url: 'http://emberjs.com/deprecations/v2.x/#toc_ember-debug-function-options'
+      });
+    }
 
+    (0, _handlers.invoke)('warn', message, test, options);
+  }
+});
 enifed('ember-testing/adapters/adapter', ['exports', 'ember-runtime'], function (exports, _emberRuntime) {
   'use strict';
 
@@ -240,19 +1011,10 @@ enifed('ember-testing/adapters/adapter', ['exports', 'ember-runtime'], function
     }
   });
 });
-enifed('ember-testing/adapters/qunit', ['exports', 'ember-utils', 'ember-testing/adapters/adapter'], function (exports, _emberUtils, _emberTestingAdaptersAdapter) {
+enifed('ember-testing/adapters/qunit', ['exports', 'ember-utils', 'ember-testing/adapters/adapter'], function (exports, _emberUtils, _adapter) {
   'use strict';
 
-  /**
-    This class implements the methods defined by Ember.Test.Adapter for the
-    QUnit testing framework.
-  
-    @class QUnitAdapter
-    @namespace Ember.Test
-    @extends Ember.Test.Adapter
-    @public
-  */
-  exports.default = _emberTestingAdaptersAdapter.default.extend({
+  exports.default = _adapter.default.extend({
     asyncStart: function () {
       QUnit.stop();
     },
@@ -260,7 +1022,7 @@ enifed('ember-testing/adapters/qunit', ['exports', 'ember-utils', 'ember-testing
       QUnit.start();
     },
     exception: function (error) {
-      ok(false, _emberUtils.inspect(error));
+      ok(false, (0, _emberUtils.inspect)(error));
     }
   });
 });
@@ -270,6 +1032,7 @@ enifed('ember-testing/events', ['exports', 'ember-views', 'ember-metal'], functi
   exports.focus = focus;
   exports.fireEvent = fireEvent;
 
+
   var DEFAULT_EVENT_OPTIONS = { canBubble: true, cancelable: true };
   var KEYBOARD_EVENT_TYPES = ['keydown', 'keypress', 'keyup'];
   var MOUSE_EVENT_TYPES = ['click', 'mousedown', 'mouseup', 'dblclick', 'mouseenter', 'mouseleave', 'mousemove', 'mouseout', 'mouseover'];
@@ -278,11 +1041,11 @@ enifed('ember-testing/events', ['exports', 'ember-views', 'ember-metal'], functi
     if (!el) {
       return;
     }
-    var $el = _emberViews.jQuery(el);
+    var $el = (0, _emberViews.jQuery)(el);
     if ($el.is(':input, [contenteditable=true]')) {
       var type = $el.prop('type');
       if (type !== 'checkbox' && type !== 'radio' && type !== 'hidden') {
-        _emberMetal.run(null, function () {
+        (0, _emberMetal.run)(null, function () {
           // Firefox does not trigger the `focusin` event if the window
           // does not have focus. If the document doesn't have focus just
           // use trigger('focusin') instead.
@@ -298,12 +1061,12 @@ enifed('ember-testing/events', ['exports', 'ember-views', 'ember-metal'], functi
   }
 
   function fireEvent(element, type) {
-    var options = arguments.length <= 2 || arguments[2] === undefined ? {} : arguments[2];
+    var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
 
     if (!element) {
       return;
     }
-    var event = undefined;
+    var event = void 0;
     if (KEYBOARD_EVENT_TYPES.indexOf(type) > -1) {
       event = buildKeyboardEvent(type, options);
     } else if (MOUSE_EVENT_TYPES.indexOf(type) > -1) {
@@ -324,7 +1087,7 @@ enifed('ember-testing/events', ['exports', 'ember-views', 'ember-metal'], functi
   }
 
   function buildBasicEvent(type) {
-    var options = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];
+    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
 
     var event = document.createEvent('Events');
     event.initEvent(type, true, true);
@@ -333,9 +1096,9 @@ enifed('ember-testing/events', ['exports', 'ember-views', 'ember-metal'], functi
   }
 
   function buildMouseEvent(type) {
-    var options = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];
+    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
 
-    var event = undefined;
+    var event = void 0;
     try {
       event = document.createEvent('MouseEvents');
       var eventOpts = _emberViews.jQuery.extend({}, DEFAULT_EVENT_OPTIONS, options);
@@ -347,9 +1110,9 @@ enifed('ember-testing/events', ['exports', 'ember-views', 'ember-metal'], functi
   }
 
   function buildKeyboardEvent(type) {
-    var options = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];
+    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
 
-    var event = undefined;
+    var event = void 0;
     try {
       event = document.createEvent('KeyEvents');
       var eventOpts = _emberViews.jQuery.extend({}, DEFAULT_EVENT_OPTIONS, options);
@@ -360,7 +1123,7 @@ enifed('ember-testing/events', ['exports', 'ember-views', 'ember-metal'], functi
     return event;
   }
 });
-enifed('ember-testing/ext/application', ['exports', 'ember-application', 'ember-testing/setup_for_testing', 'ember-testing/test/helpers', 'ember-testing/test/promise', 'ember-testing/test/run', 'ember-testing/test/on_inject_helpers', 'ember-testing/test/adapter'], function (exports, _emberApplication, _emberTestingSetup_for_testing, _emberTestingTestHelpers, _emberTestingTestPromise, _emberTestingTestRun, _emberTestingTestOn_inject_helpers, _emberTestingTestAdapter) {
+enifed('ember-testing/ext/application', ['ember-application', 'ember-testing/setup_for_testing', 'ember-testing/test/helpers', 'ember-testing/test/promise', 'ember-testing/test/run', 'ember-testing/test/on_inject_helpers', 'ember-testing/test/adapter'], function (_emberApplication, _setup_for_testing, _helpers, _promise, _run, _on_inject_helpers, _adapter) {
   'use strict';
 
   _emberApplication.Application.reopen({
@@ -401,21 +1164,8 @@ enifed('ember-testing/ext/application', ['exports', 'ember-application', 'ember-
     */
     testing: false,
 
-    /**
-      This hook defers the readiness of the application, so that you can start
-      the app when your tests are ready to run. It also sets the router's
-      location to 'none', so that the window's location will not be modified
-      (preventing both accidental leaking of state between tests and interference
-      with your testing framework).
-       Example:
-       ```
-      App.setupForTesting();
-      ```
-       @method setupForTesting
-      @public
-    */
     setupForTesting: function () {
-      _emberTestingSetup_for_testing.default();
+      (0, _setup_for_testing.default)();
 
       this.testing = true;
 
@@ -424,6 +1174,7 @@ enifed('ember-testing/ext/application', ['exports', 'ember-application', 'ember-
       });
     },
 
+
     /**
       This will be used as the container to inject the test helpers into. By
       default the helpers are injected into `window`.
@@ -435,21 +1186,6 @@ enifed('ember-testing/ext/application', ['exports', 'ember-application', 'ember-
     */
     helperContainer: null,
 
-    /**
-      This injects the test helpers into the `helperContainer` object. If an object is provided
-      it will be used as the helperContainer. If `helperContainer` is not set it will default
-      to `window`. If a function of the same name has already been defined it will be cached
-      (so that it can be reset if the helper is removed with `unregisterHelper` or
-      `removeTestHelpers`).
-       Any callbacks registered with `onInjectHelpers` will be called once the
-      helpers have been injected.
-       Example:
-      ```
-      App.injectTestHelpers();
-      ```
-       @method injectTestHelpers
-      @public
-    */
     injectTestHelpers: function (helperContainer) {
       if (helperContainer) {
         this.helperContainer = helperContainer;
@@ -465,35 +1201,24 @@ enifed('ember-testing/ext/application', ['exports', 'ember-application', 'ember-
       });
 
       this.testHelpers = {};
-      for (var _name in _emberTestingTestHelpers.helpers) {
-        this.originalMethods[_name] = this.helperContainer[_name];
-        this.testHelpers[_name] = this.helperContainer[_name] = helper(this, _name);
-        protoWrap(_emberTestingTestPromise.default.prototype, _name, helper(this, _name), _emberTestingTestHelpers.helpers[_name].meta.wait);
+      for (var name in _helpers.helpers) {
+        this.originalMethods[name] = this.helperContainer[name];
+        this.testHelpers[name] = this.helperContainer[name] = helper(this, name);
+        protoWrap(_promise.default.prototype, name, helper(this, name), _helpers.helpers[name].meta.wait);
       }
 
-      _emberTestingTestOn_inject_helpers.invokeInjectHelpersCallbacks(this);
+      (0, _on_inject_helpers.invokeInjectHelpersCallbacks)(this);
     },
-
-    /**
-      This removes all helpers that have been registered, and resets and functions
-      that were overridden by the helpers.
-       Example:
-       ```javascript
-      App.removeTestHelpers();
-      ```
-       @public
-      @method removeTestHelpers
-    */
     removeTestHelpers: function () {
       if (!this.helperContainer) {
         return;
       }
 
-      for (var _name2 in _emberTestingTestHelpers.helpers) {
-        this.helperContainer[_name2] = this.originalMethods[_name2];
-        delete _emberTestingTestPromise.default.prototype[_name2];
-        delete this.testHelpers[_name2];
-        delete this.originalMethods[_name2];
+      for (var name in _helpers.helpers) {
+        this.helperContainer[name] = this.originalMethods[name];
+        delete _promise.default.prototype[name];
+        delete this.testHelpers[name];
+        delete this.originalMethods[name];
       }
     }
   });
@@ -518,8 +1243,8 @@ enifed('ember-testing/ext/application', ['exports', 'ember-application', 'ember-
   }
 
   function helper(app, name) {
-    var fn = _emberTestingTestHelpers.helpers[name].method;
-    var meta = _emberTestingTestHelpers.helpers[name].meta;
+    var fn = _helpers.helpers[name].method;
+    var meta = _helpers.helpers[name].meta;
     if (!meta.wait) {
       return function () {
         for (var _len2 = arguments.length, args = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
@@ -535,30 +1260,30 @@ enifed('ember-testing/ext/application', ['exports', 'ember-application', 'ember-
         args[_key3] = arguments[_key3];
       }
 
-      var lastPromise = _emberTestingTestRun.default(function () {
-        return _emberTestingTestPromise.resolve(_emberTestingTestPromise.getLastPromise());
+      var lastPromise = (0, _run.default)(function () {
+        return (0, _promise.resolve)((0, _promise.getLastPromise)());
       });
 
       // wait for last helper's promise to resolve and then
       // execute. To be safe, we need to tell the adapter we're going
       // asynchronous here, because fn may not be invoked before we
       // return.
-      _emberTestingTestAdapter.asyncStart();
+      (0, _adapter.asyncStart)();
       return lastPromise.then(function () {
         return fn.apply(app, [app].concat(args));
-      }).finally(_emberTestingTestAdapter.asyncEnd);
+      }).finally(_adapter.asyncEnd);
     };
   }
 });
-enifed('ember-testing/ext/rsvp', ['exports', 'ember-runtime', 'ember-metal', 'ember-debug', 'ember-testing/test/adapter'], function (exports, _emberRuntime, _emberMetal, _emberDebug, _emberTestingTestAdapter) {
+enifed('ember-testing/ext/rsvp', ['exports', 'ember-runtime', 'ember-metal', 'ember-debug', 'ember-testing/test/adapter'], function (exports, _emberRuntime, _emberMetal, _emberDebug, _adapter) {
   'use strict';
 
   _emberRuntime.RSVP.configure('async', function (callback, promise) {
     // if schedule will cause autorun, we need to inform adapter
-    if (_emberDebug.isTesting() && !_emberMetal.run.backburner.currentInstance) {
-      _emberTestingTestAdapter.asyncStart();
+    if ((0, _emberDebug.isTesting)() && !_emberMetal.run.backburner.currentInstance) {
+      (0, _adapter.asyncStart)();
       _emberMetal.run.backburner.schedule('actions', function () {
-        _emberTestingTestAdapter.asyncEnd();
+        (0, _adapter.asyncEnd)();
         callback(promise);
       });
     } else {
@@ -570,50 +1295,43 @@ enifed('ember-testing/ext/rsvp', ['exports', 'ember-runtime', 'ember-metal', 'em
 
   exports.default = _emberRuntime.RSVP;
 });
-enifed('ember-testing/helpers', ['exports', 'ember-debug', 'ember-testing/test/helpers', 'ember-testing/helpers/and_then', 'ember-testing/helpers/click', 'ember-testing/helpers/current_path', 'ember-testing/helpers/current_route_name', 'ember-testing/helpers/current_url', 'ember-testing/helpers/fill_in', 'ember-testing/helpers/find', 'ember-testing/helpers/find_with_assert', 'ember-testing/helpers/key_event', 'ember-testing/helpers/pause_test', 'ember-testing/helpers/trigger_event', 'ember-testing/helpers/visit', 'ember-testing/helpers/wait'], function (exports, _emberDebug, _emberTestingTestHelpers, _emberTestingHelpersAnd_then, _emberTestingHelpersClick, _emberTestingHelpersCurrent_path, _emberTestingHelpersCurrent_route_name, _emberTestingHelpersCurrent_url, _emberTestingHelpersFill_in, _emberTestingHelpersFind, _emberTestingHelpersFind_with_assert, _emberTestingHelpersKey_event, _emberTestingHelpersPause_test, _emberTestingHelpersTrigger_event, _emberTestingHelpersVisit, _emberTestingHelpersWait) {
+enifed('ember-testing/helpers', ['ember-testing/test/helpers', 'ember-testing/helpers/and_then', 'ember-testing/helpers/click', 'ember-testing/helpers/current_path', 'ember-testing/helpers/current_route_name', 'ember-testing/helpers/current_url', 'ember-testing/helpers/fill_in', 'ember-testing/helpers/find', 'ember-testing/helpers/find_with_assert', 'ember-testing/helpers/key_event', 'ember-testing/helpers/pause_test', 'ember-testing/helpers/trigger_event', 'ember-testing/helpers/visit', 'ember-testing/helpers/wait'], function (_helpers, _and_then, _click, _current_path, _current_route_name, _current_url, _fill_in, _find, _find_with_assert, _key_event, _pause_test, _trigger_event, _visit, _wait) {
   'use strict';
 
-  _emberTestingTestHelpers.registerAsyncHelper('visit', _emberTestingHelpersVisit.default);
-  _emberTestingTestHelpers.registerAsyncHelper('click', _emberTestingHelpersClick.default);
-  _emberTestingTestHelpers.registerAsyncHelper('keyEvent', _emberTestingHelpersKey_event.default);
-  _emberTestingTestHelpers.registerAsyncHelper('fillIn', _emberTestingHelpersFill_in.default);
-  _emberTestingTestHelpers.registerAsyncHelper('wait', _emberTestingHelpersWait.default);
-  _emberTestingTestHelpers.registerAsyncHelper('andThen', _emberTestingHelpersAnd_then.default);
-  _emberTestingTestHelpers.registerAsyncHelper('pauseTest', _emberTestingHelpersPause_test.pauseTest);
-  _emberTestingTestHelpers.registerAsyncHelper('triggerEvent', _emberTestingHelpersTrigger_event.default);
-
-  _emberTestingTestHelpers.registerHelper('find', _emberTestingHelpersFind.default);
-  _emberTestingTestHelpers.registerHelper('findWithAssert', _emberTestingHelpersFind_with_assert.default);
-  _emberTestingTestHelpers.registerHelper('currentRouteName', _emberTestingHelpersCurrent_route_name.default);
-  _emberTestingTestHelpers.registerHelper('currentPath', _emberTestingHelpersCurrent_path.default);
-  _emberTestingTestHelpers.registerHelper('currentURL', _emberTestingHelpersCurrent_url.default);
-
-  if (true) {
-    _emberTestingTestHelpers.registerHelper('resumeTest', _emberTestingHelpersPause_test.resumeTest);
-  }
+  (0, _helpers.registerAsyncHelper)('visit', _visit.default);
+  (0, _helpers.registerAsyncHelper)('click', _click.default);
+  (0, _helpers.registerAsyncHelper)('keyEvent', _key_event.default);
+  (0, _helpers.registerAsyncHelper)('fillIn', _fill_in.default);
+  (0, _helpers.registerAsyncHelper)('wait', _wait.default);
+  (0, _helpers.registerAsyncHelper)('andThen', _and_then.default);
+  (0, _helpers.registerAsyncHelper)('pauseTest', _pause_test.pauseTest);
+  (0, _helpers.registerAsyncHelper)('triggerEvent', _trigger_event.default);
+
+  (0, _helpers.registerHelper)('find', _find.default);
+  (0, _helpers.registerHelper)('findWithAssert', _find_with_assert.default);
+  (0, _helpers.registerHelper)('currentRouteName', _current_route_name.default);
+  (0, _helpers.registerHelper)('currentPath', _current_path.default);
+  (0, _helpers.registerHelper)('currentURL', _current_url.default);
+  (0, _helpers.registerHelper)('resumeTest', _pause_test.resumeTest);
 });
 enifed("ember-testing/helpers/and_then", ["exports"], function (exports) {
+  "use strict";
+
+  exports.default = andThen;
   /**
   @module ember
   @submodule ember-testing
   */
-  "use strict";
-
-  exports.default = andThen;
-
   function andThen(app, callback) {
     return app.testHelpers.wait(callback(app));
   }
 });
-enifed('ember-testing/helpers/click', ['exports', 'ember-testing/events'], function (exports, _emberTestingEvents) {
-  /**
-  @module ember
-  @submodule ember-testing
-  */
+enifed('ember-testing/helpers/click', ['exports', 'ember-testing/events'], function (exports, _events) {
   'use strict';
 
   exports.default = click;
 
+
   /**
     Clicks an element and triggers any actions triggered by the element's `click`
     event.
@@ -632,30 +1350,29 @@ enifed('ember-testing/helpers/click', ['exports', 'ember-testing/events'], funct
     @return {RSVP.Promise}
     @public
   */
-
   function click(app, selector, context) {
     var $el = app.testHelpers.findWithAssert(selector, context);
     var el = $el[0];
 
-    _emberTestingEvents.fireEvent(el, 'mousedown');
+    (0, _events.fireEvent)(el, 'mousedown');
 
-    _emberTestingEvents.focus(el);
+    (0, _events.focus)(el);
 
-    _emberTestingEvents.fireEvent(el, 'mouseup');
-    _emberTestingEvents.fireEvent(el, 'click');
+    (0, _events.fireEvent)(el, 'mouseup');
+    (0, _events.fireEvent)(el, 'click');
 
     return app.testHelpers.wait();
-  }
+  } /**
+    @module ember
+    @submodule ember-testing
+    */
 });
 enifed('ember-testing/helpers/current_path', ['exports', 'ember-metal'], function (exports, _emberMetal) {
-  /**
-  @module ember
-  @submodule ember-testing
-  */
   'use strict';
 
   exports.default = currentPath;
 
+
   /**
     Returns the current path.
   
@@ -674,17 +1391,15 @@ enifed('ember-testing/helpers/current_path', ['exports', 'ember-metal'], functio
   @since 1.5.0
   @public
   */
-
   function currentPath(app) {
     var routingService = app.__container__.lookup('service:-routing');
-    return _emberMetal.get(routingService, 'currentPath');
-  }
+    return (0, _emberMetal.get)(routingService, 'currentPath');
+  } /**
+    @module ember
+    @submodule ember-testing
+    */
 });
 enifed('ember-testing/helpers/current_route_name', ['exports', 'ember-metal'], function (exports, _emberMetal) {
-  /**
-  @module ember
-  @submodule ember-testing
-  */
   'use strict';
 
   exports.default = currentRouteName;
@@ -703,21 +1418,20 @@ enifed('ember-testing/helpers/current_route_name', ['exports', 'ember-metal'], f
   @since 1.5.0
   @public
   */
-
   function currentRouteName(app) {
     var routingService = app.__container__.lookup('service:-routing');
-    return _emberMetal.get(routingService, 'currentRouteName');
-  }
+    return (0, _emberMetal.get)(routingService, 'currentRouteName');
+  } /**
+    @module ember
+    @submodule ember-testing
+    */
 });
 enifed('ember-testing/helpers/current_url', ['exports', 'ember-metal'], function (exports, _emberMetal) {
-  /**
-  @module ember
-  @submodule ember-testing
-  */
   'use strict';
 
   exports.default = currentURL;
 
+
   /**
     Returns the current URL.
   
@@ -736,21 +1450,20 @@ enifed('ember-testing/helpers/current_url', ['exports', 'ember-metal'], function
   @since 1.5.0
   @public
   */
-
   function currentURL(app) {
     var router = app.__container__.lookup('router:main');
-    return _emberMetal.get(router, 'location').getURL();
-  }
+    return (0, _emberMetal.get)(router, 'location').getURL();
+  } /**
+    @module ember
+    @submodule ember-testing
+    */
 });
-enifed('ember-testing/helpers/fill_in', ['exports', 'ember-testing/events'], function (exports, _emberTestingEvents) {
-  /**
-  @module ember
-  @submodule ember-testing
-  */
+enifed('ember-testing/helpers/fill_in', ['exports', 'ember-testing/events'], function (exports, _events) {
   'use strict';
 
   exports.default = fillIn;
 
+
   /**
     Fills in an input element with some text.
   
@@ -769,11 +1482,10 @@ enifed('ember-testing/helpers/fill_in', ['exports', 'ember-testing/events'], fun
     @return {RSVP.Promise}
     @public
   */
-
   function fillIn(app, selector, contextOrText, text) {
-    var $el = undefined,
-        el = undefined,
-        context = undefined;
+    var $el = void 0,
+        el = void 0,
+        context = void 0;
     if (typeof text === 'undefined') {
       text = contextOrText;
     } else {
@@ -781,24 +1493,24 @@ enifed('ember-testing/helpers/fill_in', ['exports', 'ember-testing/events'], fun
     }
     $el = app.testHelpers.findWithAssert(selector, context);
     el = $el[0];
-    _emberTestingEvents.focus(el);
+    (0, _events.focus)(el);
 
     $el.eq(0).val(text);
-    _emberTestingEvents.fireEvent(el, 'input');
-    _emberTestingEvents.fireEvent(el, 'change');
+    (0, _events.fireEvent)(el, 'input');
+    (0, _events.fireEvent)(el, 'change');
 
     return app.testHelpers.wait();
-  }
+  } /**
+    @module ember
+    @submodule ember-testing
+    */
 });
 enifed('ember-testing/helpers/find', ['exports', 'ember-metal'], function (exports, _emberMetal) {
-  /**
-  @module ember
-  @submodule ember-testing
-  */
   'use strict';
 
   exports.default = find;
 
+
   /**
     Finds an element in the context of the app's container element. A simple alias
     for `app.$(selector)`.
@@ -822,15 +1534,20 @@ enifed('ember-testing/helpers/find', ['exports', 'ember-metal'], function (expor
     @return {Object} jQuery object representing the results of the query
     @public
   */
-
   function find(app, selector, context) {
-    var $el = undefined;
-    context = context || _emberMetal.get(app, 'rootElement');
+    var $el = void 0;
+    context = context || (0, _emberMetal.get)(app, 'rootElement');
     $el = app.$(selector, context);
     return $el;
-  }
+  } /**
+    @module ember
+    @submodule ember-testing
+    */
 });
 enifed('ember-testing/helpers/find_with_assert', ['exports'], function (exports) {
+  'use strict';
+
+  exports.default = findWithAssert;
   /**
   @module ember
   @submodule ember-testing
@@ -859,10 +1576,6 @@ enifed('ember-testing/helpers/find_with_assert', ['exports'], function (exports)
     @throws {Error} throws error if jQuery object returned has a length of 0
     @public
   */
-  'use strict';
-
-  exports.default = findWithAssert;
-
   function findWithAssert(app, selector, context) {
     var $el = app.testHelpers.find(selector, context);
     if ($el.length === 0) {
@@ -872,6 +1585,9 @@ enifed('ember-testing/helpers/find_with_assert', ['exports'], function (exports)
   }
 });
 enifed('ember-testing/helpers/key_event', ['exports'], function (exports) {
+  'use strict';
+
+  exports.default = keyEvent;
   /**
   @module ember
   @submodule ember-testing
@@ -892,13 +1608,9 @@ enifed('ember-testing/helpers/key_event', ['exports'], function (exports) {
     @since 1.5.0
     @public
   */
-  'use strict';
-
-  exports.default = keyEvent;
-
   function keyEvent(app, selector, contextOrType, typeOrKeyCode, keyCode) {
-    var context = undefined,
-        type = undefined;
+    var context = void 0,
+        type = void 0;
 
     if (typeof keyCode === 'undefined') {
       context = null;
@@ -913,16 +1625,13 @@ enifed('ember-testing/helpers/key_event', ['exports'], function (exports) {
   }
 });
 enifed('ember-testing/helpers/pause_test', ['exports', 'ember-runtime', 'ember-console', 'ember-debug'], function (exports, _emberRuntime, _emberConsole, _emberDebug) {
-  /**
-  @module ember
-  @submodule ember-testing
-  */
   'use strict';
 
   exports.resumeTest = resumeTest;
   exports.pauseTest = pauseTest;
 
-  var resume = undefined;
+
+  var resume = void 0;
 
   /**
    Resumes a test paused by `pauseTest`.
@@ -931,9 +1640,13 @@ enifed('ember-testing/helpers/pause_test', ['exports', 'ember-runtime', 'ember-c
    @return {void}
    @public
   */
-
+  /**
+  @module ember
+  @submodule ember-testing
+  */
   function resumeTest() {
-    _emberDebug.assert('Testing has not been paused. There is nothing to resume.', resume);
+    (true && (0, _emberDebug.assert)('Testing has not been paused. There is nothing to resume.', resume));
+
     resume();
     resume = undefined;
   }
@@ -953,24 +1666,15 @@ enifed('ember-testing/helpers/pause_test', ['exports', 'ember-runtime', 'ember-c
    @return {Object} A promise that will never resolve
    @public
   */
-
   function pauseTest() {
-    if (true) {
-      _emberConsole.default.info('Testing paused. Use `resumeTest()` to continue.');
-    }
+    _emberConsole.default.info('Testing paused. Use `resumeTest()` to continue.');
 
     return new _emberRuntime.RSVP.Promise(function (resolve) {
-      if (true) {
-        resume = resolve;
-      }
+      resume = resolve;
     }, 'TestAdapter paused promise');
   }
 });
-enifed('ember-testing/helpers/trigger_event', ['exports', 'ember-testing/events'], function (exports, _emberTestingEvents) {
-  /**
-  @module ember
-  @submodule ember-testing
-  */
+enifed('ember-testing/helpers/trigger_event', ['exports', 'ember-testing/events'], function (exports, _events) {
   'use strict';
 
   exports.default = triggerEvent;
@@ -995,12 +1699,11 @@ enifed('ember-testing/helpers/trigger_event', ['exports', 'ember-testing/events'
    @since 1.5.0
    @public
   */
-
   function triggerEvent(app, selector, contextOrType, typeOrOptions, possibleOptions) {
     var arity = arguments.length;
-    var context = undefined,
-        type = undefined,
-        options = undefined;
+    var context = void 0,
+        type = void 0,
+        options = void 0;
 
     if (arity === 3) {
       // context and options are optional, so this is
@@ -1032,20 +1735,20 @@ enifed('ember-testing/helpers/trigger_event', ['exports', 'ember-testing/events'
     var $el = app.testHelpers.findWithAssert(selector, context);
     var el = $el[0];
 
-    _emberTestingEvents.fireEvent(el, type, options);
+    (0, _events.fireEvent)(el, type, options);
 
     return app.testHelpers.wait();
-  }
+  } /**
+    @module ember
+    @submodule ember-testing
+    */
 });
 enifed('ember-testing/helpers/visit', ['exports', 'ember-metal'], function (exports, _emberMetal) {
-  /**
-  @module ember
-  @submodule ember-testing
-  */
   'use strict';
 
   exports.default = visit;
 
+
   /**
     Loads a route, sets up any controllers, and renders any templates associated
     with the route as though a real user had triggered the route change while
@@ -1064,7 +1767,6 @@ enifed('ember-testing/helpers/visit', ['exports', 'ember-metal'], function (expo
     @return {RSVP.Promise}
     @public
   */
-
   function visit(app, url) {
     var router = app.__container__.lookup('router:main');
     var shouldHandleURL = false;
@@ -1073,30 +1775,30 @@ enifed('ember-testing/helpers/visit', ['exports', 'ember-metal'], function (expo
       router.location.setURL(url);
 
       if (shouldHandleURL) {
-        _emberMetal.run(app.__deprecatedInstance__, 'handleURL', url);
+        (0, _emberMetal.run)(app.__deprecatedInstance__, 'handleURL', url);
       }
     });
 
     if (app._readinessDeferrals > 0) {
       router['initialURL'] = url;
-      _emberMetal.run(app, 'advanceReadiness');
+      (0, _emberMetal.run)(app, 'advanceReadiness');
       delete router['initialURL'];
     } else {
       shouldHandleURL = true;
     }
 
     return app.testHelpers.wait();
-  }
+  } /**
+    @module ember
+    @submodule ember-testing
+    */
 });
-enifed('ember-testing/helpers/wait', ['exports', 'ember-testing/test/waiters', 'ember-runtime', 'ember-metal', 'ember-testing/test/pending_requests'], function (exports, _emberTestingTestWaiters, _emberRuntime, _emberMetal, _emberTestingTestPending_requests) {
-  /**
-  @module ember
-  @submodule ember-testing
-  */
+enifed('ember-testing/helpers/wait', ['exports', 'ember-testing/test/waiters', 'ember-runtime', 'ember-metal', 'ember-testing/test/pending_requests'], function (exports, _waiters, _emberRuntime, _emberMetal, _pending_requests) {
   'use strict';
 
   exports.default = wait;
 
+
   /**
     Causes the run loop to process any pending events. This is used to ensure that
     any async operations from other helpers (or your assertions) have been processed.
@@ -1124,7 +1826,10 @@ enifed('ember-testing/helpers/wait', ['exports', 'ember-testing/test/waiters', '
     @public
     @since 1.0.0
   */
-
+  /**
+  @module ember
+  @submodule ember-testing
+  */
   function wait(app, value) {
     return new _emberRuntime.RSVP.Promise(function (resolve) {
       var router = app.__container__.lookup('router:main');
@@ -1138,7 +1843,7 @@ enifed('ember-testing/helpers/wait', ['exports', 'ember-testing/test/waiters', '
         }
 
         // 2. If there are pending Ajax requests, keep polling
-        if (_emberTestingTestPending_requests.pendingRequests()) {
+        if ((0, _pending_requests.pendingRequests)()) {
           return;
         }
 
@@ -1147,7 +1852,7 @@ enifed('ember-testing/helpers/wait', ['exports', 'ember-testing/test/waiters', '
           return;
         }
 
-        if (_emberTestingTestWaiters.checkWaiters()) {
+        if ((0, _waiters.checkWaiters)()) {
           return;
         }
 
@@ -1155,34 +1860,46 @@ enifed('ember-testing/helpers/wait', ['exports', 'ember-testing/test/waiters', '
         clearInterval(watcher);
 
         // Synchronously resolve the promise
-        _emberMetal.run(null, resolve, value);
+        (0, _emberMetal.run)(null, resolve, value);
       }, 10);
     });
   }
 });
-enifed('ember-testing/index', ['exports', 'ember-testing/support', 'ember-testing/ext/application', 'ember-testing/ext/rsvp', 'ember-testing/helpers', 'ember-testing/initializers', 'ember-testing/test', 'ember-testing/adapters/adapter', 'ember-testing/setup_for_testing', 'ember-testing/adapters/qunit'], function (exports, _emberTestingSupport, _emberTestingExtApplication, _emberTestingExtRsvp, _emberTestingHelpers, _emberTestingInitializers, _emberTestingTest, _emberTestingAdaptersAdapter, _emberTestingSetup_for_testing, _emberTestingAdaptersQunit) {
+enifed('ember-testing/index', ['exports', 'ember-testing/test', 'ember-testing/adapters/adapter', 'ember-testing/setup_for_testing', 'ember-testing/adapters/qunit', 'ember-testing/support', 'ember-testing/ext/application', 'ember-testing/ext/rsvp', 'ember-testing/helpers', 'ember-testing/initializers'], function (exports, _test, _adapter, _setup_for_testing, _qunit) {
   'use strict';
 
-  exports.Test = _emberTestingTest.default;
-  exports.Adapter = _emberTestingAdaptersAdapter.default;
-  exports.setupForTesting = _emberTestingSetup_for_testing.default;
-  exports.QUnitAdapter = _emberTestingAdaptersQunit.default;
+  exports.QUnitAdapter = exports.setupForTesting = exports.Adapter = exports.Test = undefined;
+  Object.defineProperty(exports, 'Test', {
+    enumerable: true,
+    get: function () {
+      return _test.default;
+    }
+  });
+  Object.defineProperty(exports, 'Adapter', {
+    enumerable: true,
+    get: function () {
+      return _adapter.default;
+    }
+  });
+  Object.defineProperty(exports, 'setupForTesting', {
+    enumerable: true,
+    get: function () {
+      return _setup_for_testing.default;
+    }
+  });
+  Object.defineProperty(exports, 'QUnitAdapter', {
+    enumerable: true,
+    get: function () {
+      return _qunit.default;
+    }
+  });
 });
-// to handle various edge cases
-// setup RSVP + run loop integration
-// adds helpers to helpers object in Test
-// to setup initializer
-
-/**
-  @module ember
-  @submodule ember-testing
-*/
-enifed('ember-testing/initializers', ['exports', 'ember-runtime'], function (exports, _emberRuntime) {
+enifed('ember-testing/initializers', ['ember-runtime'], function (_emberRuntime) {
   'use strict';
 
   var name = 'deferReadiness in `testing` mode';
 
-  _emberRuntime.onLoad('Ember.Application', function (Application) {
+  (0, _emberRuntime.onLoad)('Ember.Application', function (Application) {
     if (!Application.initializers[name]) {
       Application.initializer({
         name: name,
@@ -1196,13 +1913,12 @@ enifed('ember-testing/initializers', ['exports', 'ember-runtime'], function (exp
     }
   });
 });
-enifed('ember-testing/setup_for_testing', ['exports', 'ember-debug', 'ember-views', 'ember-testing/test/adapter', 'ember-testing/test/pending_requests', 'ember-testing/adapters/adapter', 'ember-testing/adapters/qunit'], function (exports, _emberDebug, _emberViews, _emberTestingTestAdapter, _emberTestingTestPending_requests, _emberTestingAdaptersAdapter, _emberTestingAdaptersQunit) {
-  /* global self */
-
+enifed('ember-testing/setup_for_testing', ['exports', 'ember-debug', 'ember-views', 'ember-testing/test/adapter', 'ember-testing/test/pending_requests', 'ember-testing/adapters/adapter', 'ember-testing/adapters/qunit'], function (exports, _emberDebug, _emberViews, _adapter, _pending_requests, _adapter2, _qunit) {
   'use strict';
 
   exports.default = setupForTesting;
 
+
   /**
     Sets Ember up for testing. This is useful to perform
     basic setup steps in order to unit test.
@@ -1215,28 +1931,29 @@ enifed('ember-testing/setup_for_testing', ['exports', 'ember-debug', 'ember-view
     @since 1.5.0
     @private
   */
+  /* global self */
 
   function setupForTesting() {
-    _emberDebug.setTesting(true);
+    (0, _emberDebug.setTesting)(true);
 
-    var adapter = _emberTestingTestAdapter.getAdapter();
+    var adapter = (0, _adapter.getAdapter)();
     // if adapter is not manually set default to QUnit
     if (!adapter) {
-      _emberTestingTestAdapter.setAdapter(typeof self.QUnit === 'undefined' ? new _emberTestingAdaptersAdapter.default() : new _emberTestingAdaptersQunit.default());
+      (0, _adapter.setAdapter)(typeof self.QUnit === 'undefined' ? new _adapter2.default() : new _qunit.default());
     }
 
     if (_emberViews.jQuery) {
-      _emberViews.jQuery(document).off('ajaxSend', _emberTestingTestPending_requests.incrementPendingRequests);
-      _emberViews.jQuery(document).off('ajaxComplete', _emberTestingTestPending_requests.decrementPendingRequests);
+      (0, _emberViews.jQuery)(document).off('ajaxSend', _pending_requests.incrementPendingRequests);
+      (0, _emberViews.jQuery)(document).off('ajaxComplete', _pending_requests.decrementPendingRequests);
 
-      _emberTestingTestPending_requests.clearPendingRequests();
+      (0, _pending_requests.clearPendingRequests)();
 
-      _emberViews.jQuery(document).on('ajaxSend', _emberTestingTestPending_requests.incrementPendingRequests);
-      _emberViews.jQuery(document).on('ajaxComplete', _emberTestingTestPending_requests.decrementPendingRequests);
+      (0, _emberViews.jQuery)(document).on('ajaxSend', _pending_requests.incrementPendingRequests);
+      (0, _emberViews.jQuery)(document).on('ajaxComplete', _pending_requests.decrementPendingRequests);
     }
   }
 });
-enifed('ember-testing/support', ['exports', 'ember-debug', 'ember-views', 'ember-environment'], function (exports, _emberDebug, _emberViews, _emberEnvironment) {
+enifed('ember-testing/support', ['ember-debug', 'ember-views', 'ember-environment'], function (_emberDebug, _emberViews, _emberEnvironment) {
   'use strict';
 
   /**
@@ -1271,7 +1988,6 @@ enifed('ember-testing/support', ['exports', 'ember-debug', 'ember-views', 'ember
       testCheckboxClick(function () {
         if (!this.checked && !$.event.special.click) {
           $.event.special.click = {
-            // For checkbox, fire native event so checked state will be right
             trigger: function () {
               if ($.nodeName(this, 'input') && this.type === 'checkbox' && this.click) {
                 this.click();
@@ -1284,16 +2000,12 @@ enifed('ember-testing/support', ['exports', 'ember-debug', 'ember-views', 'ember
 
       // Try again to verify that the patch took effect or blow up.
       testCheckboxClick(function () {
-        _emberDebug.warn('clicked checkboxes should be checked! the jQuery patch didn\'t work', this.checked, { id: 'ember-testing.test-checkbox-click' });
+        (true && (0, _emberDebug.warn)('clicked checkboxes should be checked! the jQuery patch didn\'t work', this.checked, { id: 'ember-testing.test-checkbox-click' }));
       });
     });
   }
 });
-enifed('ember-testing/test', ['exports', 'ember-testing/test/helpers', 'ember-testing/test/on_inject_helpers', 'ember-testing/test/promise', 'ember-testing/test/waiters', 'ember-testing/test/adapter'], function (exports, _emberTestingTestHelpers, _emberTestingTestOn_inject_helpers, _emberTestingTestPromise, _emberTestingTestWaiters, _emberTestingTestAdapter) {
-  /**
-    @module ember
-    @submodule ember-testing
-  */
+enifed('ember-testing/test', ['exports', 'ember-testing/test/helpers', 'ember-testing/test/on_inject_helpers', 'ember-testing/test/promise', 'ember-testing/test/waiters', 'ember-testing/test/adapter'], function (exports, _helpers, _on_inject_helpers, _promise, _waiters, _adapter) {
   'use strict';
 
   /**
@@ -1315,18 +2027,18 @@ enifed('ember-testing/test', ['exports', 'ember-testing/test/helpers', 'ember-te
       @private
       @since 1.7.0
     */
-    _helpers: _emberTestingTestHelpers.helpers,
-
-    registerHelper: _emberTestingTestHelpers.registerHelper,
-    registerAsyncHelper: _emberTestingTestHelpers.registerAsyncHelper,
-    unregisterHelper: _emberTestingTestHelpers.unregisterHelper,
-    onInjectHelpers: _emberTestingTestOn_inject_helpers.onInjectHelpers,
-    Promise: _emberTestingTestPromise.default,
-    promise: _emberTestingTestPromise.promise,
-    resolve: _emberTestingTestPromise.resolve,
-    registerWaiter: _emberTestingTestWaiters.registerWaiter,
-    unregisterWaiter: _emberTestingTestWaiters.unregisterWaiter,
-    checkWaiters: _emberTestingTestWaiters.checkWaiters
+    _helpers: _helpers.helpers,
+
+    registerHelper: _helpers.registerHelper,
+    registerAsyncHelper: _helpers.registerAsyncHelper,
+    unregisterHelper: _helpers.unregisterHelper,
+    onInjectHelpers: _on_inject_helpers.onInjectHelpers,
+    Promise: _promise.default,
+    promise: _promise.promise,
+    resolve: _promise.resolve,
+    registerWaiter: _waiters.registerWaiter,
+    unregisterWaiter: _waiters.unregisterWaiter,
+    checkWaiters: _waiters.checkWaiters
   };
 
   /**
@@ -1349,13 +2061,17 @@ enifed('ember-testing/test', ['exports', 'ember-testing/test/helpers', 'ember-te
    @type {Class} The adapter to be used.
    @default Ember.Test.QUnitAdapter
   */
+  /**
+    @module ember
+    @submodule ember-testing
+  */
   Object.defineProperty(Test, 'adapter', {
-    get: _emberTestingTestAdapter.getAdapter,
-    set: _emberTestingTestAdapter.setAdapter
+    get: _adapter.getAdapter,
+    set: _adapter.setAdapter
   });
 
   Object.defineProperty(Test, 'waiters', {
-    get: _emberTestingTestWaiters.generateDeprecatedWaitersArray
+    get: _waiters.generateDeprecatedWaitersArray
   });
 
   exports.default = Test;
@@ -1368,8 +2084,8 @@ enifed('ember-testing/test/adapter', ['exports', 'ember-console', 'ember-metal']
   exports.asyncStart = asyncStart;
   exports.asyncEnd = asyncEnd;
 
-  var adapter = undefined;
 
+  var adapter = void 0;
   function getAdapter() {
     return adapter;
   }
@@ -1377,9 +2093,9 @@ enifed('ember-testing/test/adapter', ['exports', 'ember-console', 'ember-metal']
   function setAdapter(value) {
     adapter = value;
     if (value) {
-      _emberMetal.setDispatchOverride(adapterDispatch);
+      (0, _emberMetal.setDispatchOverride)(adapterDispatch);
     } else {
-      _emberMetal.setDispatchOverride(null);
+      (0, _emberMetal.setDispatchOverride)(null);
     }
   }
 
@@ -1400,15 +2116,15 @@ enifed('ember-testing/test/adapter', ['exports', 'ember-console', 'ember-metal']
     _emberConsole.default.error(error.stack);
   }
 });
-enifed('ember-testing/test/helpers', ['exports', 'ember-testing/test/promise'], function (exports, _emberTestingTestPromise) {
+enifed('ember-testing/test/helpers', ['exports', 'ember-testing/test/promise'], function (exports, _promise) {
   'use strict';
 
+  exports.helpers = undefined;
   exports.registerHelper = registerHelper;
   exports.registerAsyncHelper = registerAsyncHelper;
   exports.unregisterHelper = unregisterHelper;
-  var helpers = {};
+  var helpers = exports.helpers = {};
 
-  exports.helpers = helpers;
   /**
     `registerHelper` is used to register a test helper that will be injected
     when `App.injectTestHelpers` is called.
@@ -1440,7 +2156,6 @@ enifed('ember-testing/test/helpers', ['exports', 'ember-testing/test/promise'],
     @param {Function} helperMethod
     @param options {Object}
   */
-
   function registerHelper(name, helperMethod) {
     helpers[name] = {
       method: helperMethod,
@@ -1489,7 +2204,6 @@ enifed('ember-testing/test/helpers', ['exports', 'ember-testing/test/promise'],
     @param {Function} helperMethod
     @since 1.2.0
   */
-
   function registerAsyncHelper(name, helperMethod) {
     helpers[name] = {
       method: helperMethod,
@@ -1510,10 +2224,9 @@ enifed('ember-testing/test/helpers', ['exports', 'ember-testing/test/promise'],
     @method unregisterHelper
     @param {String} name The helper to remove.
   */
-
   function unregisterHelper(name) {
     delete helpers[name];
-    delete _emberTestingTestPromise.default.prototype[name];
+    delete _promise.default.prototype[name];
   }
 });
 enifed("ember-testing/test/on_inject_helpers", ["exports"], function (exports) {
@@ -1521,9 +2234,8 @@ enifed("ember-testing/test/on_inject_helpers", ["exports"], function (exports) {
 
   exports.onInjectHelpers = onInjectHelpers;
   exports.invokeInjectHelpersCallbacks = invokeInjectHelpersCallbacks;
-  var callbacks = [];
+  var callbacks = exports.callbacks = [];
 
-  exports.callbacks = callbacks;
   /**
     Used to register callbacks to be fired whenever `App.injectTestHelpers`
     is called.
@@ -1549,7 +2261,6 @@ enifed("ember-testing/test/on_inject_helpers", ["exports"], function (exports) {
     @method onInjectHelpers
     @param {Function} callback The function to be called.
   */
-
   function onInjectHelpers(callback) {
     callbacks.push(callback);
   }
@@ -1590,56 +2301,59 @@ enifed("ember-testing/test/pending_requests", ["exports"], function (exports) {
     }
   }
 });
-enifed('ember-testing/test/promise', ['exports', 'ember-runtime', 'ember-testing/test/run'], function (exports, _emberRuntime, _emberTestingTestRun) {
+enifed('ember-testing/test/promise', ['exports', 'ember-babel', 'ember-runtime', 'ember-testing/test/run'], function (exports, _emberBabel, _emberRuntime, _run) {
   'use strict';
 
   exports.promise = promise;
   exports.resolve = resolve;
   exports.getLastPromise = getLastPromise;
 
-  var lastPromise = undefined;
 
-  var TestPromise = (function (_RSVP$Promise) {
-    babelHelpers.inherits(TestPromise, _RSVP$Promise);
+  var lastPromise = void 0;
+
+  var TestPromise = function (_RSVP$Promise) {
+    (0, _emberBabel.inherits)(TestPromise, _RSVP$Promise);
 
     function TestPromise() {
-      babelHelpers.classCallCheck(this, TestPromise);
+      (0, _emberBabel.classCallCheck)(this, TestPromise);
 
-      _RSVP$Promise.apply(this, arguments);
-      lastPromise = this;
-    }
+      var _this = (0, _emberBabel.possibleConstructorReturn)(this, _RSVP$Promise.apply(this, arguments));
 
-    /**
-      This returns a thenable tailored for testing.  It catches failed
-      `onSuccess` callbacks and invokes the `Ember.Test.adapter.exception`
-      callback in the last chained then.
-    
-      This method should be returned by async helpers such as `wait`.
-    
-      @public
-      @for Ember.Test
-      @method promise
-      @param {Function} resolver The function used to resolve the promise.
-      @param {String} label An optional string for identifying the promise.
-    */
+      lastPromise = _this;
+      return _this;
+    }
 
     TestPromise.prototype.then = function then(onFulfillment) {
-      var _RSVP$Promise$prototype$then;
+      var _RSVP$Promise$prototy;
 
       for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
         args[_key - 1] = arguments[_key];
       }
 
-      return (_RSVP$Promise$prototype$then = _RSVP$Promise.prototype.then).call.apply(_RSVP$Promise$prototype$then, [this, function (result) {
+      return (_RSVP$Promise$prototy = _RSVP$Promise.prototype.then).call.apply(_RSVP$Promise$prototy, [this, function (result) {
         return isolate(onFulfillment, result);
       }].concat(args));
     };
 
     return TestPromise;
-  })(_emberRuntime.RSVP.Promise);
+  }(_emberRuntime.RSVP.Promise);
 
   exports.default = TestPromise;
 
+
+  /**
+    This returns a thenable tailored for testing.  It catches failed
+    `onSuccess` callbacks and invokes the `Ember.Test.adapter.exception`
+    callback in the last chained then.
+  
+    This method should be returned by async helpers such as `wait`.
+  
+    @public
+    @for Ember.Test
+    @method promise
+    @param {Function} resolver The function used to resolve the promise.
+    @param {String} label An optional string for identifying the promise.
+  */
   function promise(resolver, label) {
     var fullLabel = 'Ember.Test.promise: ' + (label || '<Unknown Promise>');
     return new TestPromise(resolver, fullLabel);
@@ -1656,7 +2370,6 @@ enifed('ember-testing/test/promise', ['exports', 'ember-runtime', 'ember-testing
     @param {Mixed} The value to resolve
     @since 1.2.0
   */
-
   function resolve(result, label) {
     return TestPromise.resolve(result, label);
   }
@@ -1686,7 +2399,7 @@ enifed('ember-testing/test/promise', ['exports', 'ember-runtime', 'ember-testing
     if (value && value instanceof TestPromise || !promise) {
       return value;
     } else {
-      return _emberTestingTestRun.default(function () {
+      return (0, _run.default)(function () {
         return resolve(promise).then(function () {
           return value;
         });
@@ -1698,10 +2411,9 @@ enifed('ember-testing/test/run', ['exports', 'ember-metal'], function (exports,
   'use strict';
 
   exports.default = run;
-
   function run(fn) {
     if (!_emberMetal.run.currentRunLoop) {
-      return _emberMetal.run(fn);
+      return (0, _emberMetal.run)(fn);
     } else {
       return fn();
     }
@@ -1715,6 +2427,7 @@ enifed('ember-testing/test/waiters', ['exports', 'ember-debug'], function (expor
   exports.checkWaiters = checkWaiters;
   exports.generateDeprecatedWaitersArray = generateDeprecatedWaitersArray;
 
+
   var contexts = [];
   var callbacks = [];
 
@@ -1749,7 +2462,6 @@ enifed('ember-testing/test/waiters', ['exports', 'ember-debug'], function (expor
      @param {Function} callback
      @since 1.2.0
   */
-
   function registerWaiter(context, callback) {
     if (arguments.length === 1) {
       callback = context;
@@ -1773,7 +2485,6 @@ enifed('ember-testing/test/waiters', ['exports', 'ember-debug'], function (expor
      @param {Function} callback
      @since 1.2.0
   */
-
   function unregisterWaiter(context, callback) {
     if (!callbacks.length) {
       return;
@@ -1803,7 +2514,6 @@ enifed('ember-testing/test/waiters', ['exports', 'ember-debug'], function (expor
     @static
     @method checkWaiters
   */
-
   function checkWaiters() {
     if (!callbacks.length) {
       return false;
@@ -1828,7 +2538,8 @@ enifed('ember-testing/test/waiters', ['exports', 'ember-debug'], function (expor
   }
 
   function generateDeprecatedWaitersArray() {
-    _emberDebug.deprecate('Usage of `Ember.Test.waiters` is deprecated. Please refactor to `Ember.Test.checkWaiters`.', false, { until: '2.8.0', id: 'ember-testing.test-waiters' });
+    (true && !(false) && (0, _emberDebug.deprecate)('Usage of `Ember.Test.waiters` is deprecated. Please refactor to `Ember.Test.checkWaiters`.', false, { until: '2.8.0', id: 'ember-testing.test-waiters' }));
+
 
     var array = new Array(callbacks.length);
     for (var i = 0; i < callbacks.length; i++) {
@@ -1841,9 +2552,22 @@ enifed('ember-testing/test/waiters', ['exports', 'ember-debug'], function (expor
     return array;
   }
 });
+enifed('node-module', ['exports'], function(_exports) {
+  var IS_NODE = typeof module === 'object' && typeof module.require === 'function';
+  if (IS_NODE) {
+    _exports.require = module.require;
+    _exports.module = module;
+    _exports.IS_NODE = IS_NODE
+  } else {
+    _exports.require = null;
+    _exports.module = null;
+    _exports.IS_NODE = IS_NODE
+  }
+});
 var testing = requireModule('ember-testing');
 Ember.Test = testing.Test;
 Ember.Test.Adapter = testing.Adapter;
 Ember.Test.QUnitAdapter = testing.QUnitAdapter;
 Ember.setupForTesting = testing.setupForTesting;
 }());
+//# sourceMappingURL=ember-testing.map