ember-source 1.11.3 → 1.11.3.1

data/dist/ember-testing.js

@@ -109,20 +109,12 @@ enifed('ember-debug', ['exports', 'ember-metal/core', 'ember-metal/error', 'embe
 
   exports._warnIfUsingStrippedFeatureFlags = _warnIfUsingStrippedFeatureFlags;
 
-  /**
-    Will call `Ember.warn()` if ENABLE_ALL_FEATURES, ENABLE_OPTIONAL_FEATURES, or
-    any specific FEATURES flag is truthy.
+  /*global __fail__*/
 
-    This method is called automatically in debug canary builds.
-
-    @private
-    @method _warnIfUsingStrippedFeatureFlags
-    @return {void}
-  */
-  Ember['default'].assert = function (desc, test) {
+  Ember['default'].assert = function(desc, test) {
     var throwAssertion;
 
-    if (Ember['default'].typeOf(test) === "function") {
+    if (Ember['default'].typeOf(test) === 'function') {
       throwAssertion = !test();
     } else {
       throwAssertion = !test;
@@ -133,6 +125,7 @@ enifed('ember-debug', ['exports', 'ember-metal/core', 'ember-metal/error', 'embe
     }
   };
 
+
   /**
     Display a warning with the provided message. Ember build tools will
     remove any calls to `Ember.warn()` when doing a production build.
@@ -142,10 +135,10 @@ enifed('ember-debug', ['exports', 'ember-metal/core', 'ember-metal/error', 'embe
     @param {Boolean} test An optional boolean. If falsy, the warning
       will be displayed.
   */
-  Ember['default'].warn = function (message, test) {
+  Ember['default'].warn = function(message, test) {
     if (!test) {
-      Logger['default'].warn("WARNING: " + message);
-      if ("trace" in Logger['default']) {
+      Logger['default'].warn("WARNING: "+message);
+      if ('trace' in Logger['default']) {
         Logger['default'].trace();
       }
     }
@@ -162,8 +155,8 @@ enifed('ember-debug', ['exports', 'ember-metal/core', 'ember-metal/error', 'embe
     @method debug
     @param {String} message A debug message to display.
   */
-  Ember['default'].debug = function (message) {
-    Logger['default'].debug("DEBUG: " + message);
+  Ember['default'].debug = function(message) {
+    Logger['default'].debug("DEBUG: "+message);
   };
 
   /**
@@ -178,59 +171,56 @@ enifed('ember-debug', ['exports', 'ember-metal/core', 'ember-metal/error', 'embe
     @param {Object} options An optional object that can be used to pass
       in a `url` to the transition guide on the emberjs.com website.
   */
-  Ember['default'].deprecate = function (message, test, options) {
+  Ember['default'].deprecate = function(message, test, options) {
     var noDeprecation;
 
-    if (typeof test === "function") {
+    if (typeof test === 'function') {
       noDeprecation = test();
     } else {
       noDeprecation = test;
     }
 
-    if (noDeprecation) {
-      return;
-    }
+    if (noDeprecation) { return; }
 
-    if (Ember['default'].ENV.RAISE_ON_DEPRECATION) {
-      throw new EmberError['default'](message);
-    }
+    if (Ember['default'].ENV.RAISE_ON_DEPRECATION) { throw new EmberError['default'](message); }
 
     var error;
 
     // When using new Error, we can't do the arguments check for Chrome. Alternatives are welcome
-    try {
-      __fail__.fail();
-    } catch (e) {
-      error = e;
-    }
+    try { __fail__.fail(); } catch (e) { error = e; }
 
     if (arguments.length === 3) {
-      Ember['default'].assert("options argument to Ember.deprecate should be an object", options && typeof options === "object");
+      Ember['default'].assert('options argument to Ember.deprecate should be an object', options && typeof options === 'object');
       if (options.url) {
-        message += " See " + options.url + " for more details.";
+        message += ' See ' + options.url + ' for more details.';
       }
     }
 
     if (Ember['default'].LOG_STACKTRACE_ON_DEPRECATION && error.stack) {
       var stack;
-      var stackStr = "";
+      var stackStr = '';
 
-      if (error["arguments"]) {
+      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 = 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");
+        stack = error.stack.replace(/(?:\n@:0)?\s+$/m, '').
+                            replace(/^\(/gm, '{anonymous}(').split('\n');
       }
 
       stackStr = "\n    " + stack.slice(2).join("\n    ");
       message = message + stackStr;
     }
 
-    Logger['default'].warn("DEPRECATION: " + message);
+    Logger['default'].warn("DEPRECATION: "+message);
   };
 
+
+
   /**
     Alias an old, deprecated method with its new counterpart.
 
@@ -249,13 +239,14 @@ enifed('ember-debug', ['exports', 'ember-metal/core', 'ember-metal/error', 'embe
     @param {Function} func The new function called to replace its deprecated counterpart.
     @return {Function} a new function that wrapped the original function with a deprecation warning
   */
-  Ember['default'].deprecateFunc = function (message, func) {
-    return function () {
+  Ember['default'].deprecateFunc = function(message, func) {
+    return function() {
       Ember['default'].deprecate(message);
       return func.apply(this, arguments);
     };
   };
 
+
   /**
     Run a function meant for debugging. Ember build tools will remove any calls to
     `Ember.runInDebug()` when doing a production build.
@@ -274,17 +265,28 @@ enifed('ember-debug', ['exports', 'ember-metal/core', 'ember-metal/error', 'embe
     @param {Function} func The function to be executed.
     @since 1.5.0
   */
-  Ember['default'].runInDebug = function (func) {
+  Ember['default'].runInDebug = function(func) {
     func();
   };
+
+  /**
+    Will call `Ember.warn()` if ENABLE_ALL_FEATURES, 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, featuresWereStripped) {
     if (featuresWereStripped) {
-      Ember['default'].warn("Ember.ENV.ENABLE_ALL_FEATURES is only available in canary builds.", !Ember['default'].ENV.ENABLE_ALL_FEATURES);
-      Ember['default'].warn("Ember.ENV.ENABLE_OPTIONAL_FEATURES is only available in canary builds.", !Ember['default'].ENV.ENABLE_OPTIONAL_FEATURES);
+      Ember['default'].warn('Ember.ENV.ENABLE_ALL_FEATURES is only available in canary builds.', !Ember['default'].ENV.ENABLE_ALL_FEATURES);
+      Ember['default'].warn('Ember.ENV.ENABLE_OPTIONAL_FEATURES is only available in canary builds.', !Ember['default'].ENV.ENABLE_OPTIONAL_FEATURES);
 
       for (var key in FEATURES) {
-        if (FEATURES.hasOwnProperty(key) && key !== "isEnabled") {
-          Ember['default'].warn("FEATURE[\"" + key + "\"] is set as enabled, but FEATURE flags are only available in canary builds.", !FEATURES[key]);
+        if (FEATURES.hasOwnProperty(key) && key !== 'isEnabled') {
+          Ember['default'].warn('FEATURE["' + key + '"] is set as enabled, but FEATURE flags are only available in canary builds.', !FEATURES[key]);
         }
       }
     }
@@ -292,29 +294,29 @@ enifed('ember-debug', ['exports', 'ember-metal/core', 'ember-metal/error', 'embe
 
   if (!Ember['default'].testing) {
     // Complain if they're using FEATURE flags in builds other than canary
-    Ember['default'].FEATURES["features-stripped-test"] = true;
+    Ember['default'].FEATURES['features-stripped-test'] = true;
     var featuresWereStripped = true;
 
     
-    delete Ember['default'].FEATURES["features-stripped-test"];
+    delete Ember['default'].FEATURES['features-stripped-test'];
     _warnIfUsingStrippedFeatureFlags(Ember['default'].ENV.FEATURES, featuresWereStripped);
 
     // Inform the developer about the Ember Inspector if not installed.
-    var isFirefox = typeof InstallTrigger !== "undefined";
+    var isFirefox = typeof InstallTrigger !== 'undefined';
     var isChrome = environment['default'].isChrome;
 
-    if (typeof window !== "undefined" && (isFirefox || isChrome) && window.addEventListener) {
-      window.addEventListener("load", function () {
+    if (typeof window !== 'undefined' && (isFirefox || isChrome) && window.addEventListener) {
+      window.addEventListener("load", function() {
         if (document.documentElement && document.documentElement.dataset && !document.documentElement.dataset.emberExtension) {
           var downloadURL;
 
           if (isChrome) {
-            downloadURL = "https://chrome.google.com/webstore/detail/ember-inspector/bmdblncegkenkacieihfhpjfppoconhi";
+            downloadURL = 'https://chrome.google.com/webstore/detail/ember-inspector/bmdblncegkenkacieihfhpjfppoconhi';
           } else if (isFirefox) {
-            downloadURL = "https://addons.mozilla.org/en-US/firefox/addon/ember-inspector/";
+            downloadURL = 'https://addons.mozilla.org/en-US/firefox/addon/ember-inspector/';
           }
 
-          Ember['default'].debug("For more advanced debugging, install the Ember Inspector from " + downloadURL);
+          Ember['default'].debug('For more advanced debugging, install the Ember Inspector from ' + downloadURL);
         }
       }, false);
     }
@@ -330,7 +332,7 @@ enifed('ember-debug', ['exports', 'ember-metal/core', 'ember-metal/error', 'embe
   */
   var runningNonEmberDebugJS = false;
   if (runningNonEmberDebugJS) {
-    Ember['default'].warn("Please use `ember.debug.js` instead of `ember.js` for development and debugging.");
+    Ember['default'].warn('Please use `ember.debug.js` instead of `ember.js` for development and debugging.');
   }
 
   exports.runningNonEmberDebugJS = runningNonEmberDebugJS;
@@ -350,9 +352,7 @@ enifed('ember-testing/adapters/adapter', ['exports', 'ember-runtime/system/objec
 
   'use strict';
 
-  function K() {
-    return this;
-  }
+  function K() { return this; }
 
   /**
    @module ember
@@ -369,16 +369,19 @@ enifed('ember-testing/adapters/adapter', ['exports', 'ember-runtime/system/objec
   var Adapter = EmberObject['default'].extend({
     /**
       This callback will be called whenever an async operation is about to start.
-       Override this to call your framework's methods that handle async
+
+      Override this to call your framework's methods that handle async
       operations.
-       @public
+
+      @public
       @method asyncStart
     */
     asyncStart: K,
 
     /**
       This callback will be called whenever an async operation has completed.
-       @public
+
+      @public
       @method asyncEnd
     */
     asyncEnd: K,
@@ -387,17 +390,20 @@ enifed('ember-testing/adapters/adapter', ['exports', 'ember-runtime/system/objec
       Override this method with your testing framework's false assertion.
       This function is called whenever an exception occurs causing the testing
       promise to fail.
-       QUnit example:
-       ```javascript
+
+      QUnit example:
+
+      ```javascript
         exception: function(error) {
           ok(false, error);
         };
       ```
-       @public
+
+      @public
       @method exception
       @param {String} error The exception to be raised.
     */
-    exception: function (error) {
+    exception: function(error) {
       throw error;
     }
   });
@@ -410,13 +416,13 @@ enifed('ember-testing/adapters/qunit', ['exports', 'ember-testing/adapters/adapt
   'use strict';
 
   exports['default'] = Adapter['default'].extend({
-    asyncStart: function () {
+    asyncStart: function() {
       QUnit.stop();
     },
-    asyncEnd: function () {
+    asyncEnd: function() {
       QUnit.start();
     },
-    exception: function (error) {
+    exception: function(error) {
       ok(false, utils.inspect(error));
     }
   });
@@ -430,40 +436,40 @@ enifed('ember-testing/helpers', ['ember-metal/core', 'ember-metal/property_get',
   var asyncHelper = Test['default'].registerAsyncHelper;
 
   function currentRouteName(app) {
-    var appController = app.__container__.lookup("controller:application");
+    var appController = app.__container__.lookup('controller:application');
 
-    return property_get.get(appController, "currentRouteName");
+    return property_get.get(appController, 'currentRouteName');
   }
 
   function currentPath(app) {
-    var appController = app.__container__.lookup("controller:application");
+    var appController = app.__container__.lookup('controller:application');
 
-    return property_get.get(appController, "currentPath");
+    return property_get.get(appController, 'currentPath');
   }
 
   function currentURL(app) {
-    var router = app.__container__.lookup("router:main");
+    var router = app.__container__.lookup('router:main');
 
-    return property_get.get(router, "location").getURL();
+    return property_get.get(router, 'location').getURL();
   }
 
   function pauseTest() {
     Test['default'].adapter.asyncStart();
-    return new Ember['default'].RSVP.Promise(function () {}, "TestAdapter paused promise");
+    return new Ember['default'].RSVP.Promise(function() { }, 'TestAdapter paused promise');
   }
 
   function focus(el) {
-    if (el && el.is(":input, [contenteditable=true]")) {
-      var type = el.prop("type");
-      if (type !== "checkbox" && type !== "radio" && type !== "hidden") {
-        run['default'](el, function () {
+    if (el && el.is(':input, [contenteditable=true]')) {
+      var type = el.prop('type');
+      if (type !== 'checkbox' && type !== 'radio' && type !== 'hidden') {
+        run['default'](el, 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.
           if (!document.hasFocus || document.hasFocus()) {
             this.focus();
           } else {
-            this.trigger("focusin");
+            this.trigger('focusin');
           }
         });
       }
@@ -471,15 +477,15 @@ enifed('ember-testing/helpers', ['ember-metal/core', 'ember-metal/property_get',
   }
 
   function visit(app, url) {
-    var router = app.__container__.lookup("router:main");
+    var router = app.__container__.lookup('router:main');
     router.location.setURL(url);
 
     if (app._readinessDeferrals > 0) {
-      router["initialURL"] = url;
-      run['default'](app, "advanceReadiness");
-      delete router["initialURL"];
+      router['initialURL'] = url;
+      run['default'](app, 'advanceReadiness');
+      delete router['initialURL'];
     } else {
-      run['default'](app.__deprecatedInstance__, "handleURL", url);
+      run['default'](app.__deprecatedInstance__, 'handleURL', url);
     }
 
     return app.testHelpers.wait();
@@ -487,23 +493,24 @@ enifed('ember-testing/helpers', ['ember-metal/core', 'ember-metal/property_get',
 
   function click(app, selector, context) {
     var $el = app.testHelpers.findWithAssert(selector, context);
-    run['default']($el, "mousedown");
+    run['default']($el, 'mousedown');
 
     focus($el);
 
-    run['default']($el, "mouseup");
-    run['default']($el, "click");
+    run['default']($el, 'mouseup');
+    run['default']($el, 'click');
 
     return app.testHelpers.wait();
   }
 
   function check(app, selector, context) {
     var $el = app.testHelpers.findWithAssert(selector, context);
-    var type = $el.prop("type");
+    var type = $el.prop('type');
 
-    Ember['default'].assert("To check '" + selector + "', the input must be a checkbox", type === "checkbox");
+    Ember['default'].assert('To check \'' + selector +
+        '\', the input must be a checkbox', type === 'checkbox');
 
-    if (!$el.prop("checked")) {
+    if (!$el.prop('checked')) {
       app.testHelpers.click(selector, context);
     }
 
@@ -512,11 +519,12 @@ enifed('ember-testing/helpers', ['ember-metal/core', 'ember-metal/property_get',
 
   function uncheck(app, selector, context) {
     var $el = app.testHelpers.findWithAssert(selector, context);
-    var type = $el.prop("type");
+    var type = $el.prop('type');
 
-    Ember['default'].assert("To uncheck '" + selector + "', the input must be a checkbox", type === "checkbox");
+    Ember['default'].assert('To uncheck \'' + selector +
+        '\', the input must be a checkbox', type === 'checkbox');
 
-    if ($el.prop("checked")) {
+    if ($el.prop('checked')) {
       app.testHelpers.click(selector, context);
     }
 
@@ -535,14 +543,12 @@ enifed('ember-testing/helpers', ['ember-metal/core', 'ember-metal/property_get',
       options = {};
     } else if (arity === 4) {
       // context and options are optional, so this is
-      if (typeof typeOrOptions === "object") {
-        // either
+      if (typeof typeOrOptions === "object") {  // either
         // app, selector, type, options
         context = null;
         type = contextOrType;
         options = typeOrOptions;
-      } else {
-        // or
+      } else { // or
         // app, selector, context, type
         context = contextOrType;
         type = typeOrOptions;
@@ -558,7 +564,7 @@ enifed('ember-testing/helpers', ['ember-metal/core', 'ember-metal/property_get',
 
     var event = jQuery['default'].Event(type, options);
 
-    run['default']($el, "trigger", event);
+    run['default']($el, 'trigger', event);
 
     return app.testHelpers.wait();
   }
@@ -566,7 +572,7 @@ enifed('ember-testing/helpers', ['ember-metal/core', 'ember-metal/property_get',
   function keyEvent(app, selector, contextOrType, typeOrKeyCode, keyCode) {
     var context, type;
 
-    if (typeof keyCode === "undefined") {
+    if (typeof keyCode === 'undefined') {
       context = null;
       keyCode = typeOrKeyCode;
       type = contextOrType;
@@ -580,14 +586,14 @@ enifed('ember-testing/helpers', ['ember-metal/core', 'ember-metal/property_get',
 
   function fillIn(app, selector, contextOrText, text) {
     var $el, context;
-    if (typeof text === "undefined") {
+    if (typeof text === 'undefined') {
       text = contextOrText;
     } else {
       context = contextOrText;
     }
     $el = app.testHelpers.findWithAssert(selector, context);
     focus($el);
-    run['default'](function () {
+    run['default'](function() {
       $el.val(text).change();
     });
     return app.testHelpers.wait();
@@ -603,7 +609,7 @@ enifed('ember-testing/helpers', ['ember-metal/core', 'ember-metal/property_get',
 
   function find(app, selector, context) {
     var $el;
-    context = context || property_get.get(app, "rootElement");
+    context = context || property_get.get(app, 'rootElement');
     $el = app.$(selector, context);
 
     return $el;
@@ -614,27 +620,21 @@ enifed('ember-testing/helpers', ['ember-metal/core', 'ember-metal/property_get',
   }
 
   function wait(app, value) {
-    return new RSVP['default'].Promise(function (resolve) {
+    return new RSVP['default'].Promise(function(resolve) {
       // Every 10ms, poll for the async thing to have finished
-      var watcher = setInterval(function () {
-        var router = app.__container__.lookup("router:main");
+      var watcher = setInterval(function() {
+        var router = app.__container__.lookup('router:main');
 
         // 1. If the router is loading, keep polling
         var routerIsLoading = router.router && !!router.router.activeTransition;
-        if (routerIsLoading) {
-          return;
-        }
+        if (routerIsLoading) { return; }
 
         // 2. If there are pending Ajax requests, keep polling
-        if (Test['default'].pendingAjaxRequests) {
-          return;
-        }
+        if (Test['default'].pendingAjaxRequests) { return; }
 
         // 3. If there are scheduled timers or we are inside of a run loop, keep polling
-        if (run['default'].hasScheduledTimers() || run['default'].currentRunLoop) {
-          return;
-        }
-        if (Test['default'].waiters && Test['default'].waiters.any(function (waiter) {
+        if (run['default'].hasScheduledTimers() || run['default'].currentRunLoop) { return; }
+        if (Test['default'].waiters && Test['default'].waiters.any(function(waiter) {
           var context = waiter[0];
           var callback = waiter[1];
           return !callback.call(context);
@@ -648,8 +648,10 @@ enifed('ember-testing/helpers', ['ember-metal/core', 'ember-metal/property_get',
         run['default'](null, resolve, value);
       }, 10);
     });
+
   }
 
+
   /**
   * 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
@@ -667,7 +669,7 @@ enifed('ember-testing/helpers', ['ember-metal/core', 'ember-metal/property_get',
   * @param {String} url the name of the route
   * @return {RSVP.Promise}
   */
-  asyncHelper("visit", visit);
+  asyncHelper('visit', visit);
 
   /**
   * Clicks an element and triggers any actions triggered by the element's `click`
@@ -685,7 +687,7 @@ enifed('ember-testing/helpers', ['ember-metal/core', 'ember-metal/property_get',
   * @param {String} selector jQuery selector for finding element on the DOM
   * @return {RSVP.Promise}
   */
-  asyncHelper("click", click);
+  asyncHelper('click', click);
 
     /**
   * Simulates a key event, e.g. `keypress`, `keydown`, `keyup` with the desired keyCode
@@ -705,7 +707,7 @@ enifed('ember-testing/helpers', ['ember-metal/core', 'ember-metal/property_get',
   * @return {RSVP.Promise}
   * @since 1.5.0
   */
-  asyncHelper("keyEvent", keyEvent);
+  asyncHelper('keyEvent', keyEvent);
 
   /**
   * Fills in an input element with some text.
@@ -724,7 +726,7 @@ enifed('ember-testing/helpers', ['ember-metal/core', 'ember-metal/property_get',
   * @param {String} text text to place inside the input element
   * @return {RSVP.Promise}
   */
-  asyncHelper("fillIn", fillIn);
+  asyncHelper('fillIn', fillIn);
 
   /**
   * Finds an element in the context of the app's container element. A simple alias
@@ -740,7 +742,7 @@ enifed('ember-testing/helpers', ['ember-metal/core', 'ember-metal/property_get',
   * @param {String} selector jQuery string selector for element lookup
   * @return {Object} jQuery object representing the results of the query
   */
-  helper("find", find);
+  helper('find', find);
 
   /**
   * Like `find`, but throws an error if the element selector returns no results.
@@ -757,7 +759,7 @@ enifed('ember-testing/helpers', ['ember-metal/core', 'ember-metal/property_get',
   * @return {Object} jQuery object representing the results of the query
   * @throws {Error} throws error if jQuery object returned has a length of 0
   */
-  helper("findWithAssert", findWithAssert);
+  helper('findWithAssert', findWithAssert);
 
   /**
     Causes the run loop to process any pending events. This is used to ensure that
@@ -782,8 +784,9 @@ enifed('ember-testing/helpers', ['ember-metal/core', 'ember-metal/property_get',
     @param {Object} value The value to be returned.
     @return {RSVP.Promise}
   */
-  asyncHelper("wait", wait);
-  asyncHelper("andThen", andThen);
+  asyncHelper('wait', wait);
+  asyncHelper('andThen', andThen);
+
 
   /**
     Returns the currently active route name.
@@ -802,7 +805,7 @@ enifed('ember-testing/helpers', ['ember-metal/core', 'ember-metal/property_get',
   @return {Object} The name of the currently active route.
   @since 1.5.0
   */
-  helper("currentRouteName", currentRouteName);
+  helper('currentRouteName', currentRouteName);
 
   /**
     Returns the current path.
@@ -821,7 +824,7 @@ enifed('ember-testing/helpers', ['ember-metal/core', 'ember-metal/property_get',
   @return {Object} The currently active path.
   @since 1.5.0
   */
-  helper("currentPath", currentPath);
+  helper('currentPath', currentPath);
 
   /**
     Returns the current URL.
@@ -840,7 +843,7 @@ enifed('ember-testing/helpers', ['ember-metal/core', 'ember-metal/property_get',
   @return {Object} The currently active URL.
   @since 1.5.0
   */
-  helper("currentURL", currentURL);
+  helper('currentURL', currentURL);
 
   /**
    Pauses the current test - this is useful for debugging while testing or for test-driving.
@@ -859,7 +862,7 @@ enifed('ember-testing/helpers', ['ember-metal/core', 'ember-metal/property_get',
    @method pauseTest
    @return {Object} A promise that will never resolve
    */
-  helper("pauseTest", pauseTest);
+  helper('pauseTest', pauseTest);
 
   /**
     Triggers the given DOM event on the element identified by the provided selector.
@@ -885,21 +888,21 @@ enifed('ember-testing/helpers', ['ember-metal/core', 'ember-metal/property_get',
    @return {RSVP.Promise}
    @since 1.5.0
   */
-  asyncHelper("triggerEvent", triggerEvent);
+  asyncHelper('triggerEvent', triggerEvent);
 
 });
 enifed('ember-testing/initializers', ['ember-runtime/system/lazy_load'], function (lazy_load) {
 
   'use strict';
 
-  var name = "deferReadiness in `testing` mode";
+  var name = 'deferReadiness in `testing` mode';
 
-  lazy_load.onLoad("Ember.Application", function (Application) {
+  lazy_load.onLoad('Ember.Application', function(Application) {
     if (!Application.initializers[name]) {
       Application.initializer({
         name: name,
 
-        initialize: function (registry, application) {
+        initialize: function(registry, application) {
           if (application.testing) {
             application.deferReadiness();
           }
@@ -913,20 +916,6 @@ enifed('ember-testing/setup_for_testing', ['exports', 'ember-metal/core', 'ember
 
   'use strict';
 
-
-
-  /**
-    Sets Ember up for testing. This is useful to perform
-    basic setup steps in order to unit test.
-
-    Use `App.setupForTesting` to perform integration tests (full
-    application testing).
-
-    @method setupForTesting
-    @namespace Ember
-    @since 1.5.0
-  */
-  exports['default'] = setupForTesting;
   var Test, requests;
 
   function incrementAjaxPendingRequests(_, xhr) {
@@ -935,17 +924,27 @@ enifed('ember-testing/setup_for_testing', ['exports', 'ember-metal/core', 'ember
   }
 
   function decrementAjaxPendingRequests(_, xhr) {
-    for (var i = 0; i < requests.length; i++) {
+    for (var i=0;i<requests.length;i++) {
       if (xhr === requests[i]) {
         requests.splice(i, 1);
       }
     }
     Test.pendingAjaxRequests = requests.length;
   }
+
+  /**
+    Sets Ember up for testing. This is useful to perform
+    basic setup steps in order to unit test.
+
+    Use `App.setupForTesting` to perform integration tests (full
+    application testing).
+
+    @method setupForTesting
+    @namespace Ember
+    @since 1.5.0
+  */
   function setupForTesting() {
-    if (!Test) {
-      Test = requireModule("ember-testing/test")["default"];
-    }
+    if (!Test) { Test = requireModule('ember-testing/test')['default']; }
 
     Ember['default'].testing = true;
 
@@ -957,11 +956,12 @@ enifed('ember-testing/setup_for_testing', ['exports', 'ember-metal/core', 'ember
     requests = [];
     Test.pendingAjaxRequests = requests.length;
 
-    jQuery['default'](document).off("ajaxSend", incrementAjaxPendingRequests);
-    jQuery['default'](document).off("ajaxComplete", decrementAjaxPendingRequests);
-    jQuery['default'](document).on("ajaxSend", incrementAjaxPendingRequests);
-    jQuery['default'](document).on("ajaxComplete", decrementAjaxPendingRequests);
+    jQuery['default'](document).off('ajaxSend', incrementAjaxPendingRequests);
+    jQuery['default'](document).off('ajaxComplete', decrementAjaxPendingRequests);
+    jQuery['default'](document).on('ajaxSend', incrementAjaxPendingRequests);
+    jQuery['default'](document).on('ajaxComplete', decrementAjaxPendingRequests);
   }
+  exports['default'] = setupForTesting;
 
 });
 enifed('ember-testing/support', ['ember-metal/core', 'ember-views/system/jquery', 'ember-metal/environment'], function (Ember, jQuery, environment) {
@@ -979,23 +979,29 @@ enifed('ember-testing/support', ['ember-metal/core', 'ember-views/system/jquery'
     @method testCheckboxClick
   */
   function testCheckboxClick(handler) {
-    $("<input type=\"checkbox\">").css({ position: "absolute", left: "-1000px", top: "-1000px" }).appendTo("body").on("click", handler).trigger("click").remove();
+    $('<input type="checkbox">')
+      .css({ position: 'absolute', left: '-1000px', top: '-1000px' })
+      .appendTo('body')
+      .on('click', handler)
+      .trigger('click')
+      .remove();
   }
 
   if (environment['default'].hasDOM) {
-    $(function () {
+    $(function() {
       /*
         Determine whether a checkbox checked using jQuery's "click" method will have
         the correct value for its checked property.
-         If we determine that the current jQuery version exhibits this behavior,
+
+        If we determine that the current jQuery version exhibits this behavior,
         patch it to work correctly as in the commit for the actual fix:
         https://github.com/jquery/jquery/commit/1fb2f92.
       */
-      testCheckboxClick(function () {
+      testCheckboxClick(function() {
         if (!this.checked && !$.event.special.click) {
           $.event.special.click = {
             // For checkbox, fire native event so checked state will be right
-            trigger: function () {
+            trigger: function() {
               if ($.nodeName(this, "input") && this.type === "checkbox" && this.click) {
                 this.click();
                 return false;
@@ -1006,7 +1012,7 @@ enifed('ember-testing/support', ['ember-metal/core', 'ember-views/system/jquery'
       });
 
       // Try again to verify that the patch took effect or blow up.
-      testCheckboxClick(function () {
+      testCheckboxClick(function() {
         Ember['default'].warn("clicked checkboxes should be checked! the jQuery patch didn't work", this.checked);
       });
     });
@@ -1035,7 +1041,8 @@ enifed('ember-testing/test', ['exports', 'ember-metal/core', 'ember-metal/run_lo
   var Test = {
     /**
       Hash containing all known test helpers.
-       @property _helpers
+
+      @property _helpers
       @private
       @since 1.7.0
     */
@@ -1044,28 +1051,34 @@ enifed('ember-testing/test', ['exports', 'ember-metal/core', 'ember-metal/run_lo
     /**
       `registerHelper` is used to register a test helper that will be injected
       when `App.injectTestHelpers` is called.
-       The helper method will always be called with the current Application as
+
+      The helper method will always be called with the current Application as
       the first parameter.
-       For example:
-       ```javascript
+
+      For example:
+
+      ```javascript
       Ember.Test.registerHelper('boot', function(app) {
         Ember.run(app, app.advanceReadiness);
       });
       ```
-       This helper can later be called without arguments because it will be
+
+      This helper can later be called without arguments because it will be
       called with `app` as the first parameter.
-       ```javascript
+
+      ```javascript
       App = Ember.Application.create();
       App.injectTestHelpers();
       boot();
       ```
-       @public
+
+      @public
       @method registerHelper
       @param {String} name The name of the helper method to add.
       @param {Function} helperMethod
       @param options {Object}
     */
-    registerHelper: function (name, helperMethod) {
+    registerHelper: function(name, helperMethod) {
       helpers[name] = {
         method: helperMethod,
         meta: { wait: false }
@@ -1075,35 +1088,44 @@ enifed('ember-testing/test', ['exports', 'ember-metal/core', 'ember-metal/run_lo
     /**
       `registerAsyncHelper` is used to register an async test helper that will be injected
       when `App.injectTestHelpers` is called.
-       The helper method will always be called with the current Application as
+
+      The helper method will always be called with the current Application as
       the first parameter.
-       For example:
-       ```javascript
+
+      For example:
+
+      ```javascript
       Ember.Test.registerAsyncHelper('boot', function(app) {
         Ember.run(app, app.advanceReadiness);
       });
       ```
-       The advantage of an async helper is that it will not run
+
+      The advantage of an async helper is that it will not run
       until the last async helper has completed.  All async helpers
       after it will wait for it complete before running.
-        For example:
-       ```javascript
+
+
+      For example:
+
+      ```javascript
       Ember.Test.registerAsyncHelper('deletePost', function(app, postId) {
         click('.delete-' + postId);
       });
-       // ... in your test
+
+      // ... in your test
       visit('/post/2');
       deletePost(2);
       visit('/post/3');
       deletePost(3);
       ```
-       @public
+
+      @public
       @method registerAsyncHelper
       @param {String} name The name of the helper method to add.
       @param {Function} helperMethod
       @since 1.2.0
     */
-    registerAsyncHelper: function (name, helperMethod) {
+    registerAsyncHelper: function(name, helperMethod) {
       helpers[name] = {
         method: helperMethod,
         meta: { wait: true }
@@ -1112,15 +1134,18 @@ enifed('ember-testing/test', ['exports', 'ember-metal/core', 'ember-metal/run_lo
 
     /**
       Remove a previously added helper method.
-       Example:
-       ```javascript
+
+      Example:
+
+      ```javascript
       Ember.Test.unregisterHelper('wait');
       ```
-       @public
+
+      @public
       @method unregisterHelper
       @param {String} name The helper to remove.
     */
-    unregisterHelper: function (name) {
+    unregisterHelper: function(name) {
       delete helpers[name];
       delete Test.Promise.prototype[name];
     },
@@ -1128,23 +1153,28 @@ enifed('ember-testing/test', ['exports', 'ember-metal/core', 'ember-metal/run_lo
     /**
       Used to register callbacks to be fired whenever `App.injectTestHelpers`
       is called.
-       The callback will receive the current application as an argument.
-       Example:
-       ```javascript
+
+      The callback will receive the current application as an argument.
+
+      Example:
+
+      ```javascript
       Ember.Test.onInjectHelpers(function() {
         Ember.$(document).ajaxSend(function() {
           Test.pendingAjaxRequests++;
         });
-         Ember.$(document).ajaxComplete(function() {
+
+        Ember.$(document).ajaxComplete(function() {
           Test.pendingAjaxRequests--;
         });
       });
       ```
-       @public
+
+      @public
       @method onInjectHelpers
       @param {Function} callback The function to be called.
     */
-    onInjectHelpers: function (callback) {
+    onInjectHelpers: function(callback) {
       injectHelpersCallbacks.push(callback);
     },
 
@@ -1152,25 +1182,32 @@ enifed('ember-testing/test', ['exports', 'ember-metal/core', 'ember-metal/run_lo
       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
+
+      This method should be returned by async helpers such as `wait`.
+
+      @public
       @method promise
       @param {Function} resolver The function used to resolve the promise.
     */
-    promise: function (resolver) {
+    promise: function(resolver) {
       return new Test.Promise(resolver);
     },
 
     /**
      Used to allow ember-testing to communicate with a specific testing
      framework.
-      You can manually set it before calling `App.setupForTesting()`.
-      Example:
-      ```javascript
+
+     You can manually set it before calling `App.setupForTesting()`.
+
+     Example:
+
+     ```javascript
      Ember.Test.adapter = MyCustomAdapter.create()
      ```
-      If you do not set it, ember-testing will default to `Ember.Test.QUnitAdapter`.
-      @public
+
+     If you do not set it, ember-testing will default to `Ember.Test.QUnitAdapter`.
+
+     @public
      @property adapter
      @type {Class} The adapter to be used.
      @default Ember.Test.QUnitAdapter
@@ -1181,13 +1218,14 @@ enifed('ember-testing/test', ['exports', 'ember-metal/core', 'ember-metal/run_lo
       Replacement for `Ember.RSVP.resolve`
       The only difference is this uses
       an instance of `Ember.Test.Promise`
-       @public
+
+      @public
       @method resolve
       @param {Mixed} The value to resolve
       @since 1.2.0
     */
-    resolve: function (val) {
-      return Test.promise(function (resolve) {
+    resolve: function(val) {
+      return Test.promise(function(resolve) {
         return resolve(val);
       });
     },
@@ -1196,25 +1234,30 @@ enifed('ember-testing/test', ['exports', 'ember-metal/core', 'ember-metal/run_lo
        This allows ember-testing to play nicely with other asynchronous
        events, such as an application that is waiting for a CSS3
        transition or an IndexDB transaction.
-        For example:
-        ```javascript
+
+       For example:
+
+       ```javascript
        Ember.Test.registerWaiter(function() {
          return myPendingTransactions() == 0;
        });
        ```
        The `context` argument allows you to optionally specify the `this`
        with which your callback will be invoked.
-        For example:
-        ```javascript
+
+       For example:
+
+       ```javascript
        Ember.Test.registerWaiter(MyDB, MyDB.hasPendingTransactions);
        ```
-        @public
+
+       @public
        @method registerWaiter
        @param {Object} context (optional)
        @param {Function} callback
        @since 1.2.0
     */
-    registerWaiter: function (context, callback) {
+    registerWaiter: function(context, callback) {
       if (arguments.length === 1) {
         callback = context;
         context = null;
@@ -1227,21 +1270,20 @@ enifed('ember-testing/test', ['exports', 'ember-metal/core', 'ember-metal/run_lo
     /**
        `unregisterWaiter` is used to unregister a callback that was
        registered with `registerWaiter`.
-        @public
+
+       @public
        @method unregisterWaiter
        @param {Object} context (optional)
        @param {Function} callback
        @since 1.2.0
     */
-    unregisterWaiter: function (context, callback) {
-      if (!this.waiters) {
-        return;
-      }
+    unregisterWaiter: function(context, callback) {
+      if (!this.waiters) { return; }
       if (arguments.length === 1) {
         callback = context;
         context = null;
       }
-      this.waiters = Ember['default'].A(this.waiters.filter(function (elt) {
+      this.waiters = Ember['default'].A(this.waiters.filter(function(elt) {
         return !(elt[0] === context && elt[1] === callback);
       }));
     }
@@ -1251,7 +1293,7 @@ enifed('ember-testing/test', ['exports', 'ember-metal/core', 'ember-metal/run_lo
     var fn = helpers[name].method;
     var meta = helpers[name].meta;
 
-    return function () {
+    return function() {
       var args = slice.call(arguments);
       var lastPromise;
 
@@ -1264,7 +1306,7 @@ enifed('ember-testing/test', ['exports', 'ember-metal/core', 'ember-metal/run_lo
         return fn.apply(app, args);
       }
 
-      lastPromise = run(function () {
+      lastPromise = run(function() {
         return Test.resolve(Test.lastPromise);
       });
 
@@ -1273,9 +1315,9 @@ enifed('ember-testing/test', ['exports', 'ember-metal/core', 'ember-metal/run_lo
       // asynchronous here, because fn may not be invoked before we
       // return.
       Test.adapter.asyncStart();
-      return lastPromise.then(function () {
+      return lastPromise.then(function() {
         return fn.apply(app, args);
-      })["finally"](function () {
+      })["finally"](function() {
         Test.adapter.asyncEnd();
       });
     };
@@ -1295,7 +1337,8 @@ enifed('ember-testing/test', ['exports', 'ember-metal/core', 'ember-metal/run_lo
      are created once you call `injectTestHelpers` on your `Ember.Application`
      instance. The included helpers are also available on the `window` object by
      default, but can be used from this object on the individual application also.
-       @property testHelpers
+
+      @property testHelpers
       @type {Object}
       @default {}
     */
@@ -1304,9 +1347,11 @@ enifed('ember-testing/test', ['exports', 'ember-metal/core', 'ember-metal/run_lo
     /**
      This property will contain the original methods that were registered
      on the `helperContainer` before `injectTestHelpers` is called.
-      When `removeTestHelpers` is called, these methods are restored to the
+
+     When `removeTestHelpers` is called, these methods are restored to the
      `helperContainer`.
-       @property originalMethods
+
+      @property originalMethods
       @type {Object}
       @default {}
       @private
@@ -1314,11 +1359,13 @@ enifed('ember-testing/test', ['exports', 'ember-metal/core', 'ember-metal/run_lo
     */
     originalMethods: {},
 
+
     /**
     This property indicates whether or not this application is currently in
     testing mode. This is set when `setupForTesting` is called on the current
     application.
-     @property testing
+
+    @property testing
     @type {Boolean}
     @default false
     @since 1.3.0
@@ -1331,26 +1378,30 @@ enifed('ember-testing/test', ['exports', 'ember-metal/core', 'ember-metal/run_lo
      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:
-     ```
+
+     Example:
+
+    ```
     App.setupForTesting();
     ```
-       @method setupForTesting
+
+      @method setupForTesting
     */
-    setupForTesting: function () {
+    setupForTesting: function() {
       setupForTesting['default']();
 
       this.testing = true;
 
       this.Router.reopen({
-        location: "none"
+        location: 'none'
       });
     },
 
     /**
       This will be used as the container to inject the test helpers into. By
       default the helpers are injected into `window`.
-       @property helperContainer
+
+      @property helperContainer
       @type {Object} The object to be used for test helpers.
       @default window
       @since 1.2.0
@@ -1363,15 +1414,18 @@ enifed('ember-testing/test', ['exports', 'ember-metal/core', 'ember-metal/run_lo
       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
+
+     Any callbacks registered with `onInjectHelpers` will be called once the
      helpers have been injected.
-     Example:
+
+    Example:
     ```
     App.injectTestHelpers();
     ```
-       @method injectTestHelpers
+
+      @method injectTestHelpers
     */
-    injectTestHelpers: function (helperContainer) {
+    injectTestHelpers: function(helperContainer) {
       if (helperContainer) {
         this.helperContainer = helperContainer;
       } else {
@@ -1393,17 +1447,18 @@ enifed('ember-testing/test', ['exports', 'ember-metal/core', 'ember-metal/run_lo
     /**
       This removes all helpers that have been registered, and resets and functions
       that were overridden by the helpers.
-       Example:
-       ```javascript
+
+      Example:
+
+      ```javascript
       App.removeTestHelpers();
       ```
-       @public
+
+      @public
       @method removeTestHelpers
     */
-    removeTestHelpers: function () {
-      if (!this.helperContainer) {
-        return;
-      }
+    removeTestHelpers: function() {
+      if (!this.helperContainer) { return; }
 
       for (var name in helpers) {
         this.helperContainer[name] = this.originalMethods[name];
@@ -1417,19 +1472,19 @@ enifed('ember-testing/test', ['exports', 'ember-metal/core', 'ember-metal/run_lo
   // But still here for backwards compatibility
   // of helper chaining
   function protoWrap(proto, name, callback, isAsync) {
-    proto[name] = function () {
+    proto[name] = function() {
       var args = arguments;
       if (isAsync) {
         return callback.apply(this, args);
       } else {
-        return this.then(function () {
+        return this.then(function() {
           return callback.apply(this, args);
         });
       }
     };
   }
 
-  Test.Promise = function () {
+  Test.Promise = function() {
     RSVP['default'].Promise.apply(this, arguments);
     Test.lastPromise = this;
   };
@@ -1441,8 +1496,8 @@ enifed('ember-testing/test', ['exports', 'ember-metal/core', 'ember-metal/run_lo
   // Patch `then` to isolate async methods
   // specifically `Ember.Test.lastPromise`
   var originalThen = RSVP['default'].Promise.prototype.then;
-  Test.Promise.prototype.then = function (onSuccess, onFailure) {
-    return originalThen.call(this, function (val) {
+  Test.Promise.prototype.then = function(onSuccess, onFailure) {
+    return originalThen.call(this, function(val) {
       return isolate(onSuccess, val);
     }, onFailure);
   };
@@ -1467,11 +1522,11 @@ enifed('ember-testing/test', ['exports', 'ember-metal/core', 'ember-metal/run_lo
     // If the method returned a promise
     // return that promise. If not,
     // return the last async helper's promise
-    if (value && value instanceof Test.Promise || !lastPromise) {
+    if ((value && (value instanceof Test.Promise)) || !lastPromise) {
       return value;
     } else {
-      return run(function () {
-        return Test.resolve(lastPromise).then(function () {
+      return run(function() {
+        return Test.resolve(lastPromise).then(function() {
           return value;
         });
       });
@@ -1481,6 +1536,118 @@ enifed('ember-testing/test', ['exports', 'ember-metal/core', 'ember-metal/run_lo
   exports['default'] = Test;
 
 });
+enifed("htmlbars-test-helpers",
+  ["exports"],
+  function(__exports__) {
+    "use strict";
+    function equalInnerHTML(fragment, html) {
+      var actualHTML = normalizeInnerHTML(fragment.innerHTML);
+      QUnit.push(actualHTML === html, actualHTML, html);
+    }
+
+    __exports__.equalInnerHTML = equalInnerHTML;function equalHTML(node, html) {
+      var fragment;
+      if (!node.nodeType && node.length) {
+        fragment = document.createDocumentFragment();
+        while (node[0]) {
+          fragment.appendChild(node[0]);
+        }
+      } else {
+        fragment = node;
+      }
+
+      var div = document.createElement("div");
+      div.appendChild(fragment.cloneNode(true));
+
+      equalInnerHTML(div, html);
+    }
+
+    __exports__.equalHTML = equalHTML;// detect weird IE8 html strings
+    var ie8InnerHTMLTestElement = document.createElement('div');
+    ie8InnerHTMLTestElement.setAttribute('id', 'womp');
+    var ie8InnerHTML = (ie8InnerHTMLTestElement.outerHTML.indexOf('id=womp') > -1);
+
+    // detect side-effects of cloning svg elements in IE9-11
+    var ieSVGInnerHTML = (function () {
+      if (!document.createElementNS) {
+        return false;
+      }
+      var div = document.createElement('div');
+      var node = document.createElementNS('http://www.w3.org/2000/svg', 'svg');
+      div.appendChild(node);
+      var clone = div.cloneNode(true);
+      return clone.innerHTML === '<svg xmlns="http://www.w3.org/2000/svg" />';
+    })();
+
+    function normalizeInnerHTML(actualHTML) {
+      if (ie8InnerHTML) {
+        // drop newlines in IE8
+        actualHTML = actualHTML.replace(/\r\n/gm, '');
+        // downcase ALLCAPS tags in IE8
+        actualHTML = actualHTML.replace(/<\/?[A-Z\-]+/gi, function(tag){
+          return tag.toLowerCase();
+        });
+        // quote ids in IE8
+        actualHTML = actualHTML.replace(/id=([^ >]+)/gi, function(match, id){
+          return 'id="'+id+'"';
+        });
+        // IE8 adds ':' to some tags
+        // <keygen> becomes <:keygen>
+        actualHTML = actualHTML.replace(/<(\/?):([^ >]+)/gi, function(match, slash, tag){
+          return '<'+slash+tag;
+        });
+
+        // Normalize the style attribute
+        actualHTML = actualHTML.replace(/style="(.+?)"/gi, function(match, val){
+          return 'style="'+val.toLowerCase()+';"';
+        });
+
+      }
+      if (ieSVGInnerHTML) {
+        // Replace `<svg xmlns="http://www.w3.org/2000/svg" height="50%" />` with `<svg height="50%"></svg>`, etc.
+        // drop namespace attribute
+        actualHTML = actualHTML.replace(/ xmlns="[^"]+"/, '');
+        // replace self-closing elements
+        actualHTML = actualHTML.replace(/<([^ >]+) [^\/>]*\/>/gi, function(tag, tagName) {
+          return tag.slice(0, tag.length - 3) + '></' + tagName + '>';
+        });
+      }
+
+      return actualHTML;
+    }
+
+    __exports__.normalizeInnerHTML = normalizeInnerHTML;// detect weird IE8 checked element string
+    var checkedInput = document.createElement('input');
+    checkedInput.setAttribute('checked', 'checked');
+    var checkedInputString = checkedInput.outerHTML;
+    function isCheckedInputHTML(element) {
+      equal(element.outerHTML, checkedInputString);
+    }
+
+    __exports__.isCheckedInputHTML = isCheckedInputHTML;// check which property has the node's text content
+    var textProperty = document.createElement('div').textContent === undefined ? 'innerText' : 'textContent';
+    function getTextContent(el) {
+      // textNode
+      if (el.nodeType === 3) {
+        return el.nodeValue;
+      } else {
+        return el[textProperty];
+      }
+    }
+
+    __exports__.getTextContent = getTextContent;// IE8 does not have Object.create, so use a polyfill if needed.
+    // Polyfill based on Mozilla's (MDN)
+    function createObject(obj) {
+      if (typeof Object.create === 'function') {
+        return Object.create(obj);
+      } else {
+        var Temp = function() {};
+        Temp.prototype = obj;
+        return new Temp();
+      }
+    }
+    __exports__.createObject = createObject;
+  });
 requireModule("ember-testing");
 
 })();