ember-source 2.16.0.beta.1 → 2.16.0.beta.2

data/dist/ember-testing.js

@@ -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.16.0-beta.1
+ * @version   2.16.0-beta.2
  */
 
 var enifed, requireModule, Ember;

data/dist/ember-tests.js

@@ -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.16.0-beta.1
+ * @version   2.16.0-beta.2
  */
 
 var enifed, requireModule, Ember;
@@ -148,7 +148,7 @@ QUnit.test('should pass ESLint', function(assert) {
   assert.ok(true, 'container.js should pass ESLint\n\n');
 });
 
-enifed('container/tests/container_test', ['ember-babel', 'ember-utils', 'ember-environment', 'ember-metal', 'ember/features', 'container', 'internal-test-helpers'], function (_emberBabel, _emberUtils, _emberEnvironment, _emberMetal, _features, _container, _internalTestHelpers) {
+enifed('container/tests/container_test', ['ember-babel', 'ember-utils', 'ember-metal', 'ember/features', 'container', 'internal-test-helpers'], function (_emberBabel, _emberUtils, _emberMetal, _features, _container, _internalTestHelpers) {
   'use strict';
 
   QUnit.module('Container');
@@ -8616,7 +8616,7 @@ enifed('ember-glimmer/tests/integration/application/engine-test', ['ember-babel'
       return this.visit('/').then(function () {
         _this12.assertText('Application');
         return _this12.transitionTo('blog.post');
-      }).catch(function () {
+      }).then(function () {
         _this12.assertText('ApplicationError! Oh, noes!');
       });
     };
@@ -8639,7 +8639,7 @@ enifed('ember-glimmer/tests/integration/application/engine-test', ['ember-babel'
       return this.visit('/').then(function () {
         _this13.assertText('Application');
         return _this13.transitionTo('blog.post');
-      }).catch(function () {
+      }).then(function () {
         _this13.assertText('ApplicationEngineError! Oh, noes!');
       });
     };
@@ -8662,7 +8662,7 @@ enifed('ember-glimmer/tests/integration/application/engine-test', ['ember-babel'
       return this.visit('/').then(function () {
         _this14.assertText('Application');
         return _this14.transitionTo('blog.post');
-      }).catch(function () {
+      }).then(function () {
         _this14.assertText('ApplicationEngineError! Oh, noes!');
       });
     };
@@ -8685,7 +8685,7 @@ enifed('ember-glimmer/tests/integration/application/engine-test', ['ember-babel'
       return this.visit('/').then(function () {
         _this15.assertText('Application');
         return _this15.transitionTo('blog.post.comments');
-      }).catch(function () {
+      }).then(function () {
         _this15.assertText('ApplicationEngineError! Oh, noes!');
       });
     };
@@ -27170,9 +27170,31 @@ enifed('ember-glimmer/tests/integration/helpers/get-test', ['ember-babel', 'embe
       this.assertText('[First][Second][Third]');
     };
 
-    _class.prototype['@test should be able to get an object value with a bound/dynamic key'] = function testShouldBeAbleToGetAnObjectValueWithABoundDynamicKey() {
+    _class.prototype['@test should be able to get an array value with numeric keys'] = function testShouldBeAbleToGetAnArrayValueWithNumericKeys() {
       var _this5 = this;
 
+      this.render('{{#each numbers as |num index|}}[{{get numbers index}}]{{/each}}', {
+        numbers: [1, 2, 3]
+      });
+
+      this.assertText('[1][2][3]');
+
+      this.runTask(function () {
+        return _this5.rerender();
+      });
+
+      this.assertText('[1][2][3]');
+
+      this.runTask(function () {
+        return (0, _emberMetal.set)(_this5.context, 'numbers', [3, 2, 1]);
+      });
+
+      this.assertText('[3][2][1]');
+    };
+
+    _class.prototype['@test should be able to get an object value with a bound/dynamic key'] = function testShouldBeAbleToGetAnObjectValueWithABoundDynamicKey() {
+      var _this6 = this;
+
       this.render('[{{get colors key}}] [{{if true (get colors key)}}]', {
         colors: { apple: 'red', banana: 'yellow' },
         key: 'apple'
@@ -27181,39 +27203,39 @@ enifed('ember-glimmer/tests/integration/helpers/get-test', ['ember-babel', 'embe
       this.assertText('[red] [red]');
 
       this.runTask(function () {
-        return _this5.rerender();
+        return _this6.rerender();
       });
 
       this.assertText('[red] [red]');
 
       this.runTask(function () {
-        return (0, _emberMetal.set)(_this5.context, 'key', 'banana');
+        return (0, _emberMetal.set)(_this6.context, 'key', 'banana');
       });
 
       this.assertText('[yellow] [yellow]');
 
       this.runTask(function () {
-        (0, _emberMetal.set)(_this5.context, 'colors.apple', 'green');
-        (0, _emberMetal.set)(_this5.context, 'colors.banana', 'purple');
+        (0, _emberMetal.set)(_this6.context, 'colors.apple', 'green');
+        (0, _emberMetal.set)(_this6.context, 'colors.banana', 'purple');
       });
 
       this.assertText('[purple] [purple]');
 
       this.runTask(function () {
-        return (0, _emberMetal.set)(_this5.context, 'key', 'apple');
+        return (0, _emberMetal.set)(_this6.context, 'key', 'apple');
       });
 
       this.assertText('[green] [green]');
 
       this.runTask(function () {
-        return (0, _emberMetal.set)(_this5.context, 'colors', { apple: 'red' });
+        return (0, _emberMetal.set)(_this6.context, 'colors', { apple: 'red' });
       });
 
       this.assertText('[red] [red]');
     };
 
     _class.prototype['@test should be able to get an object value with nested dynamic key'] = function testShouldBeAbleToGetAnObjectValueWithNestedDynamicKey() {
-      var _this6 = this;
+      var _this7 = this;
 
       this.render('[{{get colors key}}] [{{if true (get colors key)}}]', {
         colors: {
@@ -27229,32 +27251,32 @@ enifed('ember-glimmer/tests/integration/helpers/get-test', ['ember-babel', 'embe
       this.assertText('[red and yellow] [red and yellow]');
 
       this.runTask(function () {
-        return _this6.rerender();
+        return _this7.rerender();
       });
 
       this.assertText('[red and yellow] [red and yellow]');
 
       this.runTask(function () {
-        return (0, _emberMetal.set)(_this6.context, 'key', 'apple.mcintosh');
+        return (0, _emberMetal.set)(_this7.context, 'key', 'apple.mcintosh');
       });
 
       this.assertText('[red] [red]');
 
       this.runTask(function () {
-        return (0, _emberMetal.set)(_this6.context, 'key', 'banana');
+        return (0, _emberMetal.set)(_this7.context, 'key', 'banana');
       });
 
       this.assertText('[yellow] [yellow]');
 
       this.runTask(function () {
-        return (0, _emberMetal.set)(_this6.context, 'key', 'apple.gala');
+        return (0, _emberMetal.set)(_this7.context, 'key', 'apple.gala');
       });
 
       this.assertText('[red and yellow] [red and yellow]');
     };
 
     _class.prototype['@test should be able to get an object value with subexpression returning nested key'] = function testShouldBeAbleToGetAnObjectValueWithSubexpressionReturningNestedKey() {
-      var _this7 = this;
+      var _this8 = this;
 
       this.render('[{{get colors (concat \'apple\' \'.\' \'gala\')}}] [{{if true (get colors (concat \'apple\' \'.\' \'gala\'))}}]', {
         colors: {
@@ -27269,25 +27291,25 @@ enifed('ember-glimmer/tests/integration/helpers/get-test', ['ember-babel', 'embe
       this.assertText('[red and yellow] [red and yellow]');
 
       this.runTask(function () {
-        return _this7.rerender();
+        return _this8.rerender();
       });
 
       this.assertText('[red and yellow] [red and yellow]');
 
       this.runTask(function () {
-        return (0, _emberMetal.set)(_this7.context, 'colors.apple.gala', 'yellow and red striped');
+        return (0, _emberMetal.set)(_this8.context, 'colors.apple.gala', 'yellow and red striped');
       });
 
       this.assertText('[yellow and red striped] [yellow and red striped]');
 
       this.runTask(function () {
-        return (0, _emberMetal.set)(_this7.context, 'colors.apple.gala', 'yellow-redish');
+        return (0, _emberMetal.set)(_this8.context, 'colors.apple.gala', 'yellow-redish');
       });
 
       this.assertText('[yellow-redish] [yellow-redish]');
 
       this.runTask(function () {
-        return (0, _emberMetal.set)(_this7.context, 'colors', {
+        return (0, _emberMetal.set)(_this8.context, 'colors', {
           apple: {
             gala: 'red and yellow',
             mcintosh: 'red'
@@ -27299,7 +27321,7 @@ enifed('ember-glimmer/tests/integration/helpers/get-test', ['ember-babel', 'embe
     };
 
     _class.prototype['@test should be able to get an object value with a get helper as the key'] = function testShouldBeAbleToGetAnObjectValueWithAGetHelperAsTheKey() {
-      var _this8 = this;
+      var _this9 = this;
 
       this.render('[{{get colors (get possibleKeys key)}}] [{{if true (get colors (get possibleKeys key))}}]', {
         colors: { apple: 'red', banana: 'yellow' },
@@ -27310,39 +27332,39 @@ enifed('ember-glimmer/tests/integration/helpers/get-test', ['ember-babel', 'embe
       this.assertText('[red] [red]');
 
       this.runTask(function () {
-        return _this8.rerender();
+        return _this9.rerender();
       });
 
       this.assertText('[red] [red]');
 
       this.runTask(function () {
-        return (0, _emberMetal.set)(_this8.context, 'key', 'key2');
+        return (0, _emberMetal.set)(_this9.context, 'key', 'key2');
       });
 
       this.assertText('[yellow] [yellow]');
 
       this.runTask(function () {
-        (0, _emberMetal.set)(_this8.context, 'colors.apple', 'green');
-        (0, _emberMetal.set)(_this8.context, 'colors.banana', 'purple');
+        (0, _emberMetal.set)(_this9.context, 'colors.apple', 'green');
+        (0, _emberMetal.set)(_this9.context, 'colors.banana', 'purple');
       });
 
       this.assertText('[purple] [purple]');
 
       this.runTask(function () {
-        return (0, _emberMetal.set)(_this8.context, 'key', 'key1');
+        return (0, _emberMetal.set)(_this9.context, 'key', 'key1');
       });
 
       this.assertText('[green] [green]');
 
       this.runTask(function () {
-        return (0, _emberMetal.set)(_this8.context, 'colors', { apple: 'red', banana: 'yellow' });
+        return (0, _emberMetal.set)(_this9.context, 'colors', { apple: 'red', banana: 'yellow' });
       });
 
       this.assertText('[red] [red]');
     };
 
     _class.prototype['@test should be able to get an object value with a get helper value as a bound/dynamic key'] = function testShouldBeAbleToGetAnObjectValueWithAGetHelperValueAsABoundDynamicKey() {
-      var _this9 = this;
+      var _this10 = this;
 
       this.render('[{{get (get possibleValues objectKey) key}}] [{{if true (get (get possibleValues objectKey) key)}}]', {
         possibleValues: {
@@ -27356,48 +27378,48 @@ enifed('ember-glimmer/tests/integration/helpers/get-test', ['ember-babel', 'embe
       this.assertText('[red] [red]');
 
       this.runTask(function () {
-        return _this9.rerender();
+        return _this10.rerender();
       });
 
       this.assertText('[red] [red]');
 
       this.runTask(function () {
-        return (0, _emberMetal.set)(_this9.context, 'objectKey', 'colors2');
+        return (0, _emberMetal.set)(_this10.context, 'objectKey', 'colors2');
       });
 
       this.assertText('[green] [green]');
 
       this.runTask(function () {
-        return (0, _emberMetal.set)(_this9.context, 'objectKey', 'colors1');
+        return (0, _emberMetal.set)(_this10.context, 'objectKey', 'colors1');
       });
 
       this.assertText('[red] [red]');
 
       this.runTask(function () {
-        return (0, _emberMetal.set)(_this9.context, 'key', 'banana');
+        return (0, _emberMetal.set)(_this10.context, 'key', 'banana');
       });
 
       this.assertText('[yellow] [yellow]');
 
       this.runTask(function () {
-        return (0, _emberMetal.set)(_this9.context, 'objectKey', 'colors2');
+        return (0, _emberMetal.set)(_this10.context, 'objectKey', 'colors2');
       });
 
       this.assertText('[purple] [purple]');
 
       this.runTask(function () {
-        return (0, _emberMetal.set)(_this9.context, 'objectKey', 'colors1');
+        return (0, _emberMetal.set)(_this10.context, 'objectKey', 'colors1');
       });
 
       this.assertText('[yellow] [yellow]');
 
       this.runTask(function () {
-        return (0, _emberMetal.set)(_this9.context, 'key', 'apple');
+        return (0, _emberMetal.set)(_this10.context, 'key', 'apple');
       });
     };
 
     _class.prototype['@test should be able to get an object value with a get helper as the value and a get helper as the key'] = function testShouldBeAbleToGetAnObjectValueWithAGetHelperAsTheValueAndAGetHelperAsTheKey() {
-      var _this10 = this;
+      var _this11 = this;
 
       this.render('[{{get (get possibleValues objectKey) (get possibleKeys key)}}] [{{if true (get (get possibleValues objectKey) (get possibleKeys key))}}]', {
         possibleValues: {
@@ -27415,45 +27437,45 @@ enifed('ember-glimmer/tests/integration/helpers/get-test', ['ember-babel', 'embe
       this.assertText('[red] [red]');
 
       this.runTask(function () {
-        return _this10.rerender();
+        return _this11.rerender();
       });
 
       this.assertText('[red] [red]');
 
       this.runTask(function () {
-        return (0, _emberMetal.set)(_this10.context, 'objectKey', 'colors2');
+        return (0, _emberMetal.set)(_this11.context, 'objectKey', 'colors2');
       });
 
       this.assertText('[green] [green]');
 
       this.runTask(function () {
-        return (0, _emberMetal.set)(_this10.context, 'objectKey', 'colors1');
+        return (0, _emberMetal.set)(_this11.context, 'objectKey', 'colors1');
       });
 
       this.assertText('[red] [red]');
 
       this.runTask(function () {
-        return (0, _emberMetal.set)(_this10.context, 'key', 'key2');
+        return (0, _emberMetal.set)(_this11.context, 'key', 'key2');
       });
 
       this.assertText('[yellow] [yellow]');
 
       this.runTask(function () {
-        return (0, _emberMetal.set)(_this10.context, 'objectKey', 'colors2');
+        return (0, _emberMetal.set)(_this11.context, 'objectKey', 'colors2');
       });
 
       this.assertText('[purple] [purple]');
 
       this.runTask(function () {
-        (0, _emberMetal.set)(_this10.context, 'objectKey', 'colors1');
-        (0, _emberMetal.set)(_this10.context, 'key', 'key1');
+        (0, _emberMetal.set)(_this11.context, 'objectKey', 'colors1');
+        (0, _emberMetal.set)(_this11.context, 'key', 'key1');
       });
 
       this.assertText('[red] [red]');
     };
 
     _class.prototype['@test the result of a get helper can be yielded'] = function testTheResultOfAGetHelperCanBeYielded() {
-      var _this11 = this;
+      var _this12 = this;
 
       var fooBarInstance = void 0;
       var FooBarComponent = _helpers.Component.extend({
@@ -27478,28 +27500,28 @@ enifed('ember-glimmer/tests/integration/helpers/get-test', ['ember-babel', 'embe
       this.assertText('banana');
 
       this.runTask(function () {
-        return _this11.rerender();
+        return _this12.rerender();
       });
 
       this.assertText('banana');
 
       this.runTask(function () {
         (0, _emberMetal.set)(fooBarInstance, 'mcintosh', 'yellow');
-        (0, _emberMetal.set)(_this11.context, 'colors', { yellow: 'bus' });
+        (0, _emberMetal.set)(_this12.context, 'colors', { yellow: 'bus' });
       });
 
       this.assertText('bus');
 
       this.runTask(function () {
         (0, _emberMetal.set)(fooBarInstance, 'mcintosh', 'red');
-        (0, _emberMetal.set)(_this11.context, 'colors', { red: 'banana' });
+        (0, _emberMetal.set)(_this12.context, 'colors', { red: 'banana' });
       });
 
       this.assertText('banana');
     };
 
     _class.prototype['@test should handle object values as nulls'] = function testShouldHandleObjectValuesAsNulls() {
-      var _this12 = this;
+      var _this13 = this;
 
       this.render('[{{get colors \'apple\'}}] [{{if true (get colors \'apple\')}}]', {
         colors: null
@@ -27508,26 +27530,26 @@ enifed('ember-glimmer/tests/integration/helpers/get-test', ['ember-babel', 'embe
       this.assertText('[] []');
 
       this.runTask(function () {
-        return _this12.rerender();
+        return _this13.rerender();
       });
 
       this.assertText('[] []');
 
       this.runTask(function () {
-        return (0, _emberMetal.set)(_this12.context, 'colors', { apple: 'green', banana: 'purple' });
+        return (0, _emberMetal.set)(_this13.context, 'colors', { apple: 'green', banana: 'purple' });
       });
 
       this.assertText('[green] [green]');
 
       this.runTask(function () {
-        return (0, _emberMetal.set)(_this12.context, 'colors', null);
+        return (0, _emberMetal.set)(_this13.context, 'colors', null);
       });
 
       this.assertText('[] []');
     };
 
     _class.prototype['@test should handle object keys as nulls'] = function testShouldHandleObjectKeysAsNulls() {
-      var _this13 = this;
+      var _this14 = this;
 
       this.render('[{{get colors key}}] [{{if true (get colors key)}}]', {
         colors: {
@@ -27540,19 +27562,19 @@ enifed('ember-glimmer/tests/integration/helpers/get-test', ['ember-babel', 'embe
       this.assertText('[] []');
 
       this.runTask(function () {
-        return _this13.rerender();
+        return _this14.rerender();
       });
 
       this.assertText('[] []');
 
       this.runTask(function () {
-        return (0, _emberMetal.set)(_this13.context, 'key', 'banana');
+        return (0, _emberMetal.set)(_this14.context, 'key', 'banana');
       });
 
       this.assertText('[yellow] [yellow]');
 
       this.runTask(function () {
-        return (0, _emberMetal.set)(_this13.context, 'key', null);
+        return (0, _emberMetal.set)(_this14.context, 'key', null);
       });
 
       this.assertText('[] []');
@@ -27568,7 +27590,7 @@ enifed('ember-glimmer/tests/integration/helpers/get-test', ['ember-babel', 'embe
     };
 
     _class.prototype['@test get helper value should be updatable using {{input}} and (mut) - static key'] = function testGetHelperValueShouldBeUpdatableUsingInputAndMutStaticKey(assert) {
-      var _this14 = this;
+      var _this15 = this;
 
       this.render('{{input type=\'text\' value=(mut (get source \'banana\')) id=\'get-input\'}}', {
         source: {
@@ -27579,33 +27601,33 @@ enifed('ember-glimmer/tests/integration/helpers/get-test', ['ember-babel', 'embe
       assert.strictEqual(this.$('#get-input').val(), 'banana');
 
       this.runTask(function () {
-        return _this14.rerender();
+        return _this15.rerender();
       });
 
       assert.strictEqual(this.$('#get-input').val(), 'banana');
 
       this.runTask(function () {
-        return (0, _emberMetal.set)(_this14.context, 'source.banana', 'yellow');
+        return (0, _emberMetal.set)(_this15.context, 'source.banana', 'yellow');
       });
 
       assert.strictEqual(this.$('#get-input').val(), 'yellow');
 
       this.runTask(function () {
-        return _this14.$('#get-input').val('some value').trigger('change');
+        return _this15.$('#get-input').val('some value').trigger('change');
       });
 
       assert.strictEqual(this.$('#get-input').val(), 'some value');
       assert.strictEqual((0, _emberMetal.get)(this.context, 'source.banana'), 'some value');
 
       this.runTask(function () {
-        return (0, _emberMetal.set)(_this14.context, 'source', { banana: 'banana' });
+        return (0, _emberMetal.set)(_this15.context, 'source', { banana: 'banana' });
       });
 
       assert.strictEqual(this.$('#get-input').val(), 'banana');
     };
 
     _class.prototype['@test get helper value should be updatable using {{input}} and (mut) - dynamic key'] = function testGetHelperValueShouldBeUpdatableUsingInputAndMutDynamicKey(assert) {
-      var _this15 = this;
+      var _this16 = this;
 
       this.render('{{input type=\'text\' value=(mut (get source key)) id=\'get-input\'}}', {
         source: {
@@ -27618,47 +27640,47 @@ enifed('ember-glimmer/tests/integration/helpers/get-test', ['ember-babel', 'embe
       assert.strictEqual(this.$('#get-input').val(), 'banana');
 
       this.runTask(function () {
-        return _this15.rerender();
+        return _this16.rerender();
       });
 
       assert.strictEqual(this.$('#get-input').val(), 'banana');
 
       this.runTask(function () {
-        return (0, _emberMetal.set)(_this15.context, 'source.banana', 'yellow');
+        return (0, _emberMetal.set)(_this16.context, 'source.banana', 'yellow');
       });
 
       assert.strictEqual(this.$('#get-input').val(), 'yellow');
 
       this.runTask(function () {
-        return _this15.$('#get-input').val('some value').trigger('change');
+        return _this16.$('#get-input').val('some value').trigger('change');
       });
 
       assert.strictEqual(this.$('#get-input').val(), 'some value');
       assert.strictEqual((0, _emberMetal.get)(this.context, 'source.banana'), 'some value');
 
       this.runTask(function () {
-        return (0, _emberMetal.set)(_this15.context, 'key', 'apple');
+        return (0, _emberMetal.set)(_this16.context, 'key', 'apple');
       });
 
       assert.strictEqual(this.$('#get-input').val(), 'apple');
 
       this.runTask(function () {
-        return _this15.$('#get-input').val('some other value').trigger('change');
+        return _this16.$('#get-input').val('some other value').trigger('change');
       });
 
       assert.strictEqual(this.$('#get-input').val(), 'some other value');
       assert.strictEqual((0, _emberMetal.get)(this.context, 'source.apple'), 'some other value');
 
       this.runTask(function () {
-        (0, _emberMetal.set)(_this15.context, 'key', 'banana');
-        (0, _emberMetal.set)(_this15.context, 'source', { banana: 'banana' });
+        (0, _emberMetal.set)(_this16.context, 'key', 'banana');
+        (0, _emberMetal.set)(_this16.context, 'source', { banana: 'banana' });
       });
 
       assert.strictEqual(this.$('#get-input').val(), 'banana');
     };
 
     _class.prototype['@test get helper value should be updatable using {{input}} and (mut) - dynamic nested key'] = function testGetHelperValueShouldBeUpdatableUsingInputAndMutDynamicNestedKey(assert) {
-      var _this16 = this;
+      var _this17 = this;
 
       this.render('{{input type=\'text\' value=(mut (get source key)) id=\'get-input\'}}', {
         source: {
@@ -27674,53 +27696,53 @@ enifed('ember-glimmer/tests/integration/helpers/get-test', ['ember-babel', 'embe
       assert.strictEqual(this.$('#get-input').val(), 'mcintosh');
 
       this.runTask(function () {
-        return _this16.rerender();
+        return _this17.rerender();
       });
 
       assert.strictEqual(this.$('#get-input').val(), 'mcintosh');
 
       this.runTask(function () {
-        return (0, _emberMetal.set)(_this16.context, 'source.apple.mcintosh', 'red');
+        return (0, _emberMetal.set)(_this17.context, 'source.apple.mcintosh', 'red');
       });
 
       assert.strictEqual(this.$('#get-input').val(), 'red');
 
       this.runTask(function () {
-        return _this16.$('#get-input').val('some value').trigger('change');
+        return _this17.$('#get-input').val('some value').trigger('change');
       });
 
       assert.strictEqual(this.$('#get-input').val(), 'some value');
       assert.strictEqual((0, _emberMetal.get)(this.context, 'source.apple.mcintosh'), 'some value');
 
       this.runTask(function () {
-        return (0, _emberMetal.set)(_this16.context, 'key', 'apple.gala');
+        return (0, _emberMetal.set)(_this17.context, 'key', 'apple.gala');
       });
 
       assert.strictEqual(this.$('#get-input').val(), 'gala');
 
       this.runTask(function () {
-        return _this16.$('#get-input').val('some other value').trigger('change');
+        return _this17.$('#get-input').val('some other value').trigger('change');
       });
 
       assert.strictEqual(this.$('#get-input').val(), 'some other value');
       assert.strictEqual((0, _emberMetal.get)(this.context, 'source.apple.gala'), 'some other value');
 
       this.runTask(function () {
-        return (0, _emberMetal.set)(_this16.context, 'key', 'banana');
+        return (0, _emberMetal.set)(_this17.context, 'key', 'banana');
       });
 
       assert.strictEqual(this.$('#get-input').val(), 'banana');
 
       this.runTask(function () {
-        return _this16.$('#get-input').val('yet another value').trigger('change');
+        return _this17.$('#get-input').val('yet another value').trigger('change');
       });
 
       assert.strictEqual(this.$('#get-input').val(), 'yet another value');
       assert.strictEqual((0, _emberMetal.get)(this.context, 'source.banana'), 'yet another value');
 
       this.runTask(function () {
-        (0, _emberMetal.set)(_this16.context, 'key', 'apple.mcintosh');
-        (0, _emberMetal.set)(_this16.context, 'source', {
+        (0, _emberMetal.set)(_this17.context, 'key', 'apple.mcintosh');
+        (0, _emberMetal.set)(_this17.context, 'source', {
           apple: {
             gala: 'gala',
             mcintosh: 'mcintosh'
@@ -28974,6 +28996,63 @@ enifed('ember-glimmer/tests/integration/helpers/input-test', ['ember-babel', 'em
 
     return _class4;
   }(InputRenderingTest));
+
+  // These are the permutations of the set:
+  // ['type="range"', 'min="-5" max="50"', 'value="%x"']
+  ['type="range" min="-5" max="50" value="%x"', 'type="range" value="%x" min="-5" max="50"', 'min="-5" max="50" type="range" value="%x"', 'min="-5" max="50" value="%x" type="range"', 'value="%x" min="-5" max="50" type="range"', 'value="%x" type="range" min="-5" max="50"'].forEach(function (attrs) {
+    (0, _testCase.moduleFor)('[GH#15675] Helpers test: {{input ' + attrs + '}}', function (_InputRenderingTest5) {
+      (0, _emberBabel.inherits)(_class5, _InputRenderingTest5);
+
+      function _class5() {
+        (0, _emberBabel.classCallCheck)(this, _class5);
+        return (0, _emberBabel.possibleConstructorReturn)(this, _InputRenderingTest5.apply(this, arguments));
+      }
+
+      _class5.prototype.renderInput = function renderInput() {
+        var value = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 25;
+
+        this.render('{{input ' + attrs.replace("%x", value) + '}}');
+      };
+
+      _class5.prototype.assertValue = function assertValue(expected) {
+        var type = this.$input().attr('type');
+
+        if (type !== 'range') {
+          this.assert.ok(true, 'IE9 does not support range items');
+          return;
+        }
+
+        _InputRenderingTest5.prototype.assertValue.call(this, expected);
+      };
+
+      _class5.prototype['@test value over default max but below set max is kept'] = function testValueOverDefaultMaxButBelowSetMaxIsKept(assert) {
+        this.renderInput("25");
+        this.assertValue("25");
+      };
+
+      _class5.prototype['@test value below default min but above set min is kept'] = function testValueBelowDefaultMinButAboveSetMinIsKept(assert) {
+        this.renderInput("-2");
+        this.assertValue("-2");
+      };
+
+      _class5.prototype['@test in the valid default range is kept'] = function testInTheValidDefaultRangeIsKept(assert) {
+        this.renderInput("5");
+        this.assertValue("5");
+      };
+
+      _class5.prototype['@test value above max is reset to max'] = function testValueAboveMaxIsResetToMax(assert) {
+        this.renderInput("55");
+        this.assertValue("50");
+      };
+
+      _class5.prototype['@test value below min is reset to min'] = function testValueBelowMinIsResetToMin(assert) {
+        this.renderInput("-10");
+        this.assertValue("-5");
+      };
+
+      return _class5;
+    }(InputRenderingTest));
+  });
 });
 QUnit.module('ESLint | ember-glimmer/tests/integration/helpers/input-test.js');
 QUnit.test('should pass ESLint', function(assert) {
@@ -40885,6 +40964,20 @@ enifed('ember-metal/tests/events_test', ['ember-metal'], function (_emberMetal)
     equal(triggered, 2, 'should invoke listeners');
   });
 
+  QUnit.test('Ember.on asserts for invalid arguments', function () {
+    expectAssertion(function () {
+      _emberMetal.Mixin.create({
+        foo1: (0, _emberMetal.on)('bar')
+      });
+    }, 'Ember.on expects function as last argument');
+
+    expectAssertion(function () {
+      _emberMetal.Mixin.create({
+        foo1: (0, _emberMetal.on)(function () {})
+      });
+    }, 'Ember.on called without valid event names');
+  });
+
   QUnit.test('a listener added as part of a mixin may be overridden', function () {
     var triggered = 0;
     var FirstMixin = _emberMetal.Mixin.create({
@@ -45221,7 +45314,7 @@ QUnit.test('should pass ESLint', function(assert) {
   assert.ok(true, 'ember-metal/tests/run_loop/debounce_test.js should pass ESLint\n\n');
 });
 
-enifed('ember-metal/tests/run_loop/later_test', ['ember-metal'], function (_emberMetal) {
+enifed('ember-metal/tests/run_loop/later_test', ['ember-utils', 'ember-metal'], function (_emberUtils, _emberMetal) {
   'use strict';
 
   var originalSetTimeout = window.setTimeout;
@@ -45428,7 +45521,7 @@ enifed('ember-metal/tests/run_loop/later_test', ['ember-metal'], function (_embe
     // happens when an expired timer callback takes a while to run,
     // which is what we simulate here.
     var newSetTimeoutUsed = void 0;
-    _emberMetal.run.backburner._platform = {
+    _emberMetal.run.backburner._platform = (0, _emberUtils.assign)({}, originalPlatform, {
       setTimeout: function () {
         var wait = arguments[arguments.length - 1];
         newSetTimeoutUsed = true;
@@ -45436,7 +45529,7 @@ enifed('ember-metal/tests/run_loop/later_test', ['ember-metal'], function (_embe
 
         return originalPlatform.setTimeout.apply(originalPlatform, arguments);
       }
-    };
+    });
 
     var count = 0;
     (0, _emberMetal.run)(function () {
@@ -55585,7 +55678,6 @@ enifed('ember-runtime/tests/mixins/promise_proxy_test', ['ember-metal', 'ember-r
 
     PromiseSubclass.prototype = Object.create(_rsvp2.Promise.prototype);
     PromiseSubclass.prototype.constructor = PromiseSubclass;
-    PromiseSubclass.cast = _rsvp2.Promise.cast;
 
     var proxy = ObjectPromiseProxy.create({
       promise: new PromiseSubclass(function () {})
@@ -61000,17 +61092,6 @@ enifed('ember-runtime/tests/system/object/create_test', ['ember-metal', 'ember/f
     }, 'Ember.Object.create no longer supports mixing in other definitions, use .extend & .create separately instead.');
   });
 
-  // This test is for IE8.
-  QUnit.test('property name is the same as own prototype property', function () {
-    var MyClass = _object.default.extend({
-      toString: function () {
-        return 'MyClass';
-      }
-    });
-
-    equal(MyClass.create().toString(), 'MyClass', 'should inherit property from the arguments of `EmberObject.create`');
-  });
-
   QUnit.test('inherits properties from passed in EmberObject', function () {
     var baseObj = _object.default.create({ foo: 'bar' });
     var secondaryObj = _object.default.create(baseObj);
@@ -61019,9 +61100,9 @@ enifed('ember-runtime/tests/system/object/create_test', ['ember-metal', 'ember/f
   });
 
   QUnit.test('throws if you try to pass anything a string as a parameter', function () {
-    var expected = 'EmberObject.create only accepts an objects.';
+    var expected = 'Ember.Object.create only accepts objects.';
 
-    throws(function () {
+    expectAssertion(function () {
       return _object.default.create('some-string');
     }, expected);
   });
@@ -64201,15 +64282,6 @@ enifed('ember-testing/tests/adapters/adapter_test', ['ember-metal', 'ember-testi
     }
   });
 
-  // Can't test these this way anymore since we have nothing to compare to
-  // test("asyncStart is a noop", function() {
-  //   equal(adapter.asyncStart, K);
-  // });
-
-  // test("asyncEnd is a noop", function() {
-  //   equal(adapter.asyncEnd, K);
-  // });
-
   QUnit.test('exception throws', function () {
     var error = 'Hai';
     var thrown;
@@ -67251,6 +67323,105 @@ QUnit.test('should pass ESLint', function(assert) {
   assert.ok(true, 'ember/tests/controller_test.js should pass ESLint\n\n');
 });
 
+enifed('ember/tests/error_handler_test', ['ember', 'ember-metal'], function (_ember, _emberMetal) {
+  'use strict';
+
+  var ONERROR = _ember.default.onerror;
+  var ADAPTER = _ember.default.Test && _ember.default.Test.adapter;
+  var TESTING = _ember.default.testing;
+
+  QUnit.module('error_handler', {
+    teardown: function () {
+      _ember.default.onerror = ONERROR;
+      _ember.default.testing = TESTING;
+      if (_ember.default.Test) {
+        _ember.default.Test.adapter = ADAPTER;
+      }
+    }
+  });
+
+  function runThatThrows(message) {
+    return (0, _emberMetal.run)(function () {
+      throw new Error(message);
+    });
+  }
+
+  test('by default there is no onerror', function (assert) {
+    _ember.default.onerror = undefined;
+    assert.throws(runThatThrows, Error);
+    assert.equal(_ember.default.onerror, undefined);
+  });
+
+  test('when Ember.onerror is registered', function (assert) {
+    assert.expect(2);
+    _ember.default.onerror = function (error) {
+      assert.ok(true, 'onerror called');
+      throw error;
+    };
+    assert.throws(runThatThrows, Error);
+    // Ember.onerror = ONERROR;
+  });
+
+  if (true) {
+    test('when Ember.Test.adapter is registered', function (assert) {
+      assert.expect(2);
+
+      _ember.default.Test.adapter = {
+        exception: function (error) {
+          assert.ok(true, 'adapter called');
+          throw error;
+        }
+      };
+
+      assert.throws(runThatThrows, Error);
+    });
+
+    test('when both Ember.onerror Ember.Test.adapter are registered', function (assert) {
+      assert.expect(2);
+
+      // takes precedence
+      _ember.default.Test.adapter = {
+        exception: function (error) {
+          assert.ok(true, 'adapter called');
+          throw error;
+        }
+      };
+
+      _ember.default.onerror = function (error) {
+        assert.ok(false, 'onerror was NEVER called');
+        throw error;
+      };
+
+      assert.throws(runThatThrows, Error);
+    });
+  }
+
+  QUnit.test('Ember.run does not swallow exceptions by default (Ember.testing = true)', function () {
+    _ember.default.testing = true;
+    var error = new Error('the error');
+    throws(function () {
+      _ember.default.run(function () {
+        throw error;
+      });
+    }, error);
+  });
+
+  QUnit.test('Ember.run does not swallow exceptions by default (Ember.testing = false)', function () {
+    _ember.default.testing = false;
+    var error = new Error('the error');
+    throws(function () {
+      _ember.default.run(function () {
+        throw error;
+      });
+    }, error);
+  });
+});
+QUnit.module('ESLint | ember/tests/error_handler_test.js');
+QUnit.test('should pass ESLint', function(assert) {
+  assert.expect(1);
+  assert.ok(true, 'ember/tests/error_handler_test.js should pass ESLint\n\n');
+});
+
 enifed('ember/tests/global-api-test', ['ember-metal', 'ember-runtime'], function (_emberMetal, _emberRuntime) {
   'use strict';
 
@@ -69533,7 +69704,7 @@ enifed('ember/tests/helpers/link_to_test/link_to_with_query_params_test', ['embe
 
       assert.expect(1);
 
-      assert.throws(function () {
+      expectAssertion(function () {
         _this19.runTask(function () {
           _this19.createApplication();
 
@@ -69543,7 +69714,7 @@ enifed('ember/tests/helpers/link_to_test/link_to_with_query_params_test', ['embe
 
           _this19.addTemplate('application', '{{#link-to id=\'the-link\'}}Index{{/link-to}}');
         });
-      }, /(You must provide one or more parameters to the link-to component.|undefined is not an object)/);
+      }, /You must provide one or more parameters to the link-to component/);
     };
 
     return _class2;
@@ -69912,341 +70083,6 @@ enifed('ember/tests/routing/basic_test', ['ember-utils', 'ember-console', 'ember
     }
   });
 
-  QUnit.test('warn on URLs not included in the route set', function () {
-    Router.map(function () {
-      this.route('home', { path: '/' });
-    });
-
-    bootApplication();
-
-    expectAssertion(function () {
-      return (0, _emberMetal.run)(function () {
-        return router.handleURL('/what-is-this-i-dont-even');
-      });
-    }, 'The URL \'/what-is-this-i-dont-even\' did not match any routes in your application');
-  });
-
-  QUnit.test('The Homepage', function () {
-    Router.map(function () {
-      this.route('home', { path: '/' });
-    });
-
-    App.HomeRoute = _emberRouting.Route.extend({});
-
-    var currentPath = void 0;
-
-    App.ApplicationController = _emberRuntime.Controller.extend({
-      currentPathDidChange: (0, _emberMetal.observer)('currentPath', function () {
-        currentPath = (0, _emberMetal.get)(this, 'currentPath');
-      })
-    });
-
-    bootApplication();
-
-    equal(currentPath, 'home');
-    equal((0, _emberViews.jQuery)('h3:contains(Hours)', '#qunit-fixture').length, 1, 'The home template was rendered');
-  });
-
-  QUnit.test('The Home page and the Camelot page with multiple Router.map calls', function () {
-    Router.map(function () {
-      this.route('home', { path: '/' });
-    });
-
-    Router.map(function () {
-      this.route('camelot', { path: '/camelot' });
-    });
-
-    App.HomeRoute = _emberRouting.Route.extend({});
-
-    App.CamelotRoute = _emberRouting.Route.extend({});
-
-    var currentPath = void 0;
-
-    App.ApplicationController = _emberRuntime.Controller.extend({
-      currentPathDidChange: (0, _emberMetal.observer)('currentPath', function () {
-        currentPath = (0, _emberMetal.get)(this, 'currentPath');
-      })
-    });
-
-    App.CamelotController = _emberRuntime.Controller.extend({
-      currentPathDidChange: (0, _emberMetal.observer)('currentPath', function () {
-        currentPath = (0, _emberMetal.get)(this, 'currentPath');
-      })
-    });
-
-    bootApplication();
-
-    handleURL('/camelot');
-
-    equal(currentPath, 'camelot');
-    equal((0, _emberViews.jQuery)('h3:contains(silly)', '#qunit-fixture').length, 1, 'The camelot template was rendered');
-
-    handleURL('/');
-
-    equal(currentPath, 'home');
-    equal((0, _emberViews.jQuery)('h3:contains(Hours)', '#qunit-fixture').length, 1, 'The home template was rendered');
-  });
-
-  QUnit.test('The Homepage with explicit template name in renderTemplate', function () {
-    Router.map(function () {
-      this.route('home', { path: '/' });
-    });
-
-    App.HomeRoute = _emberRouting.Route.extend({
-      renderTemplate: function () {
-        this.render('homepage');
-      }
-    });
-
-    bootApplication();
-
-    equal((0, _emberViews.jQuery)('h3:contains(Megatroll)', '#qunit-fixture').length, 1, 'The homepage template was rendered');
-  });
-
-  QUnit.test('An alternate template will pull in an alternate controller', function () {
-    Router.map(function () {
-      this.route('home', { path: '/' });
-    });
-
-    App.HomeRoute = _emberRouting.Route.extend({
-      renderTemplate: function () {
-        this.render('homepage');
-      }
-    });
-
-    App.HomepageController = _emberRuntime.Controller.extend({
-      model: {
-        home: 'Comes from homepage'
-      }
-    });
-
-    bootApplication();
-
-    equal((0, _emberViews.jQuery)('h3:contains(Megatroll) + p:contains(Comes from homepage)', '#qunit-fixture').length, 1, 'The homepage template was rendered');
-  });
-
-  QUnit.test('An alternate template will pull in an alternate controller instead of controllerName', function () {
-    Router.map(function () {
-      this.route('home', { path: '/' });
-    });
-
-    App.HomeRoute = _emberRouting.Route.extend({
-      controllerName: 'foo',
-      renderTemplate: function () {
-        this.render('homepage');
-      }
-    });
-
-    App.FooController = _emberRuntime.Controller.extend({
-      model: {
-        home: 'Comes from Foo'
-      }
-    });
-
-    App.HomepageController = _emberRuntime.Controller.extend({
-      model: {
-        home: 'Comes from homepage'
-      }
-    });
-
-    bootApplication();
-
-    equal((0, _emberViews.jQuery)('h3:contains(Megatroll) + p:contains(Comes from homepage)', '#qunit-fixture').length, 1, 'The homepage template was rendered');
-  });
-
-  QUnit.test('The template will pull in an alternate controller via key/value', function () {
-    Router.map(function () {
-      this.route('homepage', { path: '/' });
-    });
-
-    App.HomepageRoute = _emberRouting.Route.extend({
-      renderTemplate: function () {
-        this.render({ controller: 'home' });
-      }
-    });
-
-    App.HomeController = _emberRuntime.Controller.extend({
-      model: {
-        home: 'Comes from home.'
-      }
-    });
-
-    bootApplication();
-
-    equal((0, _emberViews.jQuery)('h3:contains(Megatroll) + p:contains(Comes from home.)', '#qunit-fixture').length, 1, 'The homepage template was rendered from data from the HomeController');
-  });
-
-  QUnit.test('The Homepage with explicit template name in renderTemplate and controller', function () {
-    Router.map(function () {
-      this.route('home', { path: '/' });
-    });
-
-    App.HomeController = _emberRuntime.Controller.extend({
-      model: {
-        home: 'YES I AM HOME'
-      }
-    });
-
-    App.HomeRoute = _emberRouting.Route.extend({
-      renderTemplate: function () {
-        this.render('homepage');
-      }
-    });
-
-    bootApplication();
-
-    equal((0, _emberViews.jQuery)('h3:contains(Megatroll) + p:contains(YES I AM HOME)', '#qunit-fixture').length, 1, 'The homepage template was rendered');
-  });
-
-  QUnit.test('Model passed via renderTemplate model is set as controller\'s model', function () {
-    (0, _emberGlimmer.setTemplate)('bio', (0, _emberTemplateCompiler.compile)('<p>{{model.name}}</p>'));
-
-    App.BioController = _emberRuntime.Controller.extend();
-
-    Router.map(function () {
-      this.route('home', { path: '/' });
-    });
-
-    App.HomeRoute = _emberRouting.Route.extend({
-      renderTemplate: function () {
-        this.render('bio', {
-          model: { name: 'emberjs' }
-        });
-      }
-    });
-
-    bootApplication();
-
-    equal((0, _emberViews.jQuery)('p:contains(emberjs)', '#qunit-fixture').length, 1, 'Passed model was set as controllers model');
-  });
-
-  QUnit.test('render uses templateName from route', function () {
-    Router.map(function () {
-      this.route('home', { path: '/' });
-    });
-
-    (0, _emberGlimmer.setTemplate)('the_real_home_template', (0, _emberTemplateCompiler.compile)('<p>THIS IS THE REAL HOME</p>'));
-
-    App.HomeController = _emberRuntime.Controller.extend();
-    App.HomeRoute = _emberRouting.Route.extend({
-      templateName: 'the_real_home_template'
-    });
-
-    bootApplication();
-
-    equal((0, _emberViews.jQuery)('p', '#qunit-fixture').text(), 'THIS IS THE REAL HOME', 'The homepage template was rendered');
-  });
-
-  QUnit.test('defining templateName allows other templates to be rendered', function () {
-    Router.map(function () {
-      this.route('home', { path: '/' });
-    });
-
-    (0, _emberGlimmer.setTemplate)('alert', (0, _emberTemplateCompiler.compile)('<div class=\'alert-box\'>Invader!</div>'));
-    (0, _emberGlimmer.setTemplate)('the_real_home_template', (0, _emberTemplateCompiler.compile)('<p>THIS IS THE REAL HOME</p>{{outlet \'alert\'}}'));
-
-    App.HomeController = _emberRuntime.Controller.extend();
-    App.HomeRoute = _emberRouting.Route.extend({
-      templateName: 'the_real_home_template',
-      actions: {
-        showAlert: function () {
-          this.render('alert', {
-            into: 'home',
-            outlet: 'alert'
-          });
-        }
-      }
-    });
-
-    bootApplication();
-
-    equal((0, _emberViews.jQuery)('p', '#qunit-fixture').text(), 'THIS IS THE REAL HOME', 'The homepage template was rendered');
-
-    (0, _emberMetal.run)(function () {
-      return router.send('showAlert');
-    });
-
-    equal((0, _emberViews.jQuery)('.alert-box', '#qunit-fixture').text(), 'Invader!', 'Template for alert was render into outlet');
-  });
-
-  QUnit.test('templateName is still used when calling render with no name and options', function () {
-    Router.map(function () {
-      this.route('home', { path: '/' });
-    });
-
-    (0, _emberGlimmer.setTemplate)('alert', (0, _emberTemplateCompiler.compile)('<div class=\'alert-box\'>Invader!</div>'));
-    (0, _emberGlimmer.setTemplate)('home', (0, _emberTemplateCompiler.compile)('<p>THIS IS THE REAL HOME</p>{{outlet \'alert\'}}'));
-
-    App.HomeRoute = _emberRouting.Route.extend({
-      templateName: 'alert',
-      renderTemplate: function () {
-        this.render({});
-      }
-    });
-
-    bootApplication();
-
-    equal((0, _emberViews.jQuery)('.alert-box', '#qunit-fixture').text(), 'Invader!', 'default templateName was rendered into outlet');
-  });
-
-  QUnit.test('The Homepage with a `setupController` hook', function () {
-    Router.map(function () {
-      this.route('home', { path: '/' });
-    });
-
-    App.HomeRoute = _emberRouting.Route.extend({
-      setupController: function (controller) {
-        (0, _emberMetal.set)(controller, 'hours', (0, _emberRuntime.A)(['Monday through Friday: 9am to 5pm', 'Saturday: Noon to Midnight', 'Sunday: Noon to 6pm']));
-      }
-    });
-
-    (0, _emberGlimmer.setTemplate)('home', (0, _emberTemplateCompiler.compile)('<ul>{{#each hours as |entry|}}<li>{{entry}}</li>{{/each}}</ul>'));
-
-    bootApplication();
-
-    equal((0, _emberViews.jQuery)('ul li', '#qunit-fixture').eq(2).text(), 'Sunday: Noon to 6pm', 'The template was rendered with the hours context');
-  });
-
-  QUnit.test('The route controller is still set when overriding the setupController hook', function () {
-    Router.map(function () {
-      this.route('home', { path: '/' });
-    });
-
-    App.HomeRoute = _emberRouting.Route.extend({
-      setupController: function (controller) {
-        // no-op
-        // importantly, we are not calling  this._super here
-      }
-    });
-
-    registry.register('controller:home', _emberRuntime.Controller.extend());
-
-    bootApplication();
-
-    deepEqual(container.lookup('route:home').controller, container.lookup('controller:home'), 'route controller is the home controller');
-  });
-
-  QUnit.test('The route controller can be specified via controllerName', function () {
-    Router.map(function () {
-      this.route('home', { path: '/' });
-    });
-
-    (0, _emberGlimmer.setTemplate)('home', (0, _emberTemplateCompiler.compile)('<p>{{myValue}}</p>'));
-
-    App.HomeRoute = _emberRouting.Route.extend({
-      controllerName: 'myController'
-    });
-
-    registry.register('controller:myController', _emberRuntime.Controller.extend({
-      myValue: 'foo'
-    }));
-
-    bootApplication();
-
-    deepEqual(container.lookup('route:home').controller, container.lookup('controller:myController'), 'route controller is set by controllerName');
-    equal((0, _emberViews.jQuery)('p', '#qunit-fixture').text(), 'foo', 'The homepage template was rendered with data from the custom controller');
-  });
-
   QUnit.test('The route controller specified via controllerName is used in render', function () {
     Router.map(function () {
       this.route('home', { path: '/' });
@@ -72841,9 +72677,7 @@ enifed('ember/tests/routing/basic_test', ['ember-utils', 'ember-console', 'ember
       }
     });
 
-    throws(function () {
-      return bootApplication();
-    }, /More context objects were passed/);
+    bootApplication();
 
     equal((0, _emberViews.jQuery)('#error').length, 1, 'Error template was rendered.');
   });
@@ -73632,6 +73466,341 @@ QUnit.test('should pass ESLint', function(assert) {
   assert.ok(true, 'ember/tests/routing/basic_test.js should pass ESLint\n\n');
 });
 
+enifed('ember/tests/routing/decoupled_basic_test', ['ember-babel', 'ember-routing', 'ember-runtime', 'internal-test-helpers'], function (_emberBabel, _emberRouting, _emberRuntime, _internalTestHelpers) {
+  'use strict';
+
+  (0, _internalTestHelpers.moduleFor)('Basic Routing - Decoupled from global resovler', function (_ApplicationTestCase) {
+    (0, _emberBabel.inherits)(_class, _ApplicationTestCase);
+
+    function _class() {
+      (0, _emberBabel.classCallCheck)(this, _class);
+
+      var _this = (0, _emberBabel.possibleConstructorReturn)(this, _ApplicationTestCase.call(this));
+
+      _this.addTemplate('home', '<h3 id="app">Hours</h3>');
+      _this.addTemplate('camelot', '<section id="camelot"><h3>Is a silly place</h3></section>');
+      _this.addTemplate('homepage', '<h3 id="troll">Megatroll</h3><p>{{model.home}}</p>');
+
+      _this.router.map(function () {
+        this.route('home', { path: '/' });
+      });
+      return _this;
+    }
+
+    _class.prototype.getController = function getController(name) {
+      return this.applicationInstance.lookup('controller:' + name);
+    };
+
+    _class.prototype['@test warn on URLs not included in the route set'] = function testWarnOnURLsNotIncludedInTheRouteSet(assert) {
+      var _this2 = this;
+
+      return this.visit('/').then(function () {
+        expectAssertion(function () {
+          _this2.visit('/what-is-this-i-dont-even');
+        }, /'\/what-is-this-i-dont-even' did not match any routes/);
+      });
+    };
+
+    _class.prototype['@test The Homepage'] = function testTheHomepage(assert) {
+      var _this3 = this;
+
+      return this.visit('/').then(function () {
+        assert.equal(_this3.currentPath, 'home', 'currently on the home route');
+
+        var text = _this3.$('#app').text();
+        assert.equal(text, "Hours", 'the home template was rendered');
+      });
+    };
+
+    _class.prototype['@test The Homepage and the Camelot page with multiple Router.map calls'] = function (assert) {
+      var _this4 = this;
+
+      this.router.map(function () {
+        this.route('camelot', { path: '/camelot' });
+      });
+
+      return this.visit('/camelot').then(function () {
+        assert.equal(_this4.currentPath, 'camelot');
+
+        var text = _this4.$('#camelot').text();
+        assert.equal(text, "Is a silly place", 'the camelot template was rendered');
+
+        return _this4.visit('/');
+      }).then(function () {
+        assert.equal(_this4.currentPath, 'home');
+
+        var text = _this4.$('#app').text();
+        assert.equal(text, "Hours", 'the home template was rendered');
+      });
+    };
+
+    _class.prototype['@test The Homepage with explicit template name in renderTemplate'] = function (assert) {
+      var _this5 = this;
+
+      this.add('route:home', _emberRouting.Route.extend({
+        renderTemplate: function () {
+          this.render('homepage');
+        }
+      }));
+
+      return this.visit('/').then(function () {
+        var text = _this5.$('#troll').text();
+        assert.equal(text, "Megatroll", 'the homepage template was rendered');
+      });
+    };
+
+    _class.prototype['@test an alternate template will pull in an alternate controller'] = function (assert) {
+      var _this6 = this;
+
+      this.add('route:home', _emberRouting.Route.extend({
+        renderTemplate: function () {
+          this.render('homepage');
+        }
+      }));
+      this.add('controller:homepage', _emberRuntime.Controller.extend({
+        model: {
+          home: 'Comes from homepage'
+        }
+      }));
+
+      return this.visit('/').then(function () {
+        var text = _this6.$('p').text();
+
+        assert.equal(text, 'Comes from homepage', 'the homepage template was rendered');
+      });
+    };
+
+    _class.prototype['@test An alternate template will pull in an alternate controller instead of controllerName'] = function (assert) {
+      var _this7 = this;
+
+      this.add('route:home', _emberRouting.Route.extend({
+        controllerName: 'foo',
+        renderTemplate: function () {
+          this.render('homepage');
+        }
+      }));
+      this.add('controller:foo', _emberRuntime.Controller.extend({
+        model: {
+          home: 'Comes from foo'
+        }
+      }));
+      this.add('controller:homepage', _emberRuntime.Controller.extend({
+        model: {
+          home: 'Comes from homepage'
+        }
+      }));
+
+      return this.visit('/').then(function () {
+        var text = _this7.$('p').text();
+
+        assert.equal(text, 'Comes from homepage', 'the homepage template was rendered');
+      });
+    };
+
+    _class.prototype['@test The template will pull in an alternate controller via key/value'] = function (assert) {
+      var _this8 = this;
+
+      this.router.map(function () {
+        this.route('homepage', { path: '/' });
+      });
+
+      this.add('route:homepage', _emberRouting.Route.extend({
+        renderTemplate: function () {
+          this.render({ controller: 'home' });
+        }
+      }));
+      this.add('controller:home', _emberRuntime.Controller.extend({
+        model: {
+          home: 'Comes from home.'
+        }
+      }));
+
+      return this.visit('/').then(function () {
+        var text = _this8.$('p').text();
+
+        assert.equal(text, 'Comes from home.', 'the homepage template was rendered from data from the HomeController');
+      });
+    };
+
+    _class.prototype['@test The Homepage with explicit template name in renderTemplate and controller'] = function (assert) {
+      var _this9 = this;
+
+      this.add('controller:home', _emberRuntime.Controller.extend({
+        model: {
+          home: 'YES I AM HOME'
+        }
+      }));
+      this.add('route:home', _emberRouting.Route.extend({
+        renderTemplate: function () {
+          this.render('homepage');
+        }
+      }));
+
+      return this.visit('/').then(function () {
+        var text = _this9.$('p').text();
+
+        assert.equal(text, 'YES I AM HOME', 'The homepage template was rendered');
+      });
+    };
+
+    _class.prototype['@test Model passed via renderTemplate model is set as controller\'s model'] = function (assert) {
+      var _this10 = this;
+
+      this.addTemplate('bio', '<p>{{model.name}}</p>');
+      this.add('route:home', _emberRouting.Route.extend({
+        renderTemplate: function () {
+          this.render('bio', {
+            model: { name: 'emberjs' }
+          });
+        }
+      }));
+
+      return this.visit('/').then(function () {
+        var text = _this10.$('p').text();
+
+        assert.equal(text, 'emberjs', 'Passed model was set as controller\'s model');
+      });
+    };
+
+    _class.prototype['@test render uses templateName from route'] = function testRenderUsesTemplateNameFromRoute(assert) {
+      var _this11 = this;
+
+      this.addTemplate('the_real_home_template', '<p>THIS IS THE REAL HOME</p>');
+      this.add('route:home', _emberRouting.Route.extend({
+        templateName: 'the_real_home_template'
+      }));
+
+      return this.visit('/').then(function () {
+        var text = _this11.$('p').text();
+
+        assert.equal(text, 'THIS IS THE REAL HOME', 'the homepage template was rendered');
+      });
+    };
+
+    _class.prototype['@test defining templateName allows other templates to be rendered'] = function testDefiningTemplateNameAllowsOtherTemplatesToBeRendered(assert) {
+      var _this12 = this;
+
+      this.addTemplate('alert', '<div class=\'alert-box\'>Invader!</div>');
+      this.addTemplate('the_real_home_template', '<p>THIS IS THE REAL HOME</p>{{outlet \'alert\'}}');
+      this.add('route:home', _emberRouting.Route.extend({
+        templateName: 'the_real_home_template',
+        actions: {
+          showAlert: function () {
+            this.render('alert', {
+              into: 'home',
+              outlet: 'alert'
+            });
+          }
+        }
+      }));
+
+      return this.visit('/').then(function () {
+        var text = _this12.$('p').text();
+        assert.equal(text, 'THIS IS THE REAL HOME', 'the homepage template was rendered');
+
+        return _this12.runTask(function () {
+          return _this12.appRouter.send('showAlert');
+        });
+      }).then(function () {
+        var text = _this12.$('.alert-box').text();
+
+        assert.equal(text, 'Invader!', 'Template for alert was rendered into the outlet');
+      });
+    };
+
+    _class.prototype['@test templateName is still used when calling render with no name and options'] = function testTemplateNameIsStillUsedWhenCallingRenderWithNoNameAndOptions(assert) {
+      var _this13 = this;
+
+      this.addTemplate('alert', '<div class=\'alert-box\'>Invader!</div>');
+      this.addTemplate('home', '<p>THIS IS THE REAL HOME</p>{{outlet \'alert\'}}');
+
+      this.add('route:home', _emberRouting.Route.extend({
+        templateName: 'alert',
+        renderTemplate: function () {
+          this.render({});
+        }
+      }));
+
+      return this.visit('/').then(function () {
+        var text = _this13.$('.alert-box').text();
+
+        assert.equal(text, 'Invader!', 'default templateName was rendered into outlet');
+      });
+    };
+
+    _class.prototype['@test The Homepage with a `setupController` hook'] = function testTheHomepageWithASetupControllerHook(assert) {
+      var _this14 = this;
+
+      this.addTemplate('home', '<ul>{{#each hours as |entry|}}\n        <li>{{entry}}</li>\n      {{/each}}\n      </ul>\n    ');
+
+      this.add('route:home', _emberRouting.Route.extend({
+        setupController: function (controller) {
+          controller.set('hours', (0, _emberRuntime.A)(['Monday through Friday: 9am to 5pm', 'Saturday: Noon to Midnight', 'Sunday: Noon to 6pm']));
+        }
+      }));
+      return this.visit('/').then(function () {
+        var text = _this14.$('ul li').eq(2).text();
+
+        assert.equal(text, 'Sunday: Noon to 6pm', 'The template was rendered with the hours context');
+      });
+    };
+
+    _class.prototype['@test The route controller is still set when overriding the setupController hook'] = function (assert) {
+      var _this15 = this;
+
+      this.add('route:home', _emberRouting.Route.extend({
+        setupController: function () {
+          // no-op
+          // importantly, we are not calling this._super
+        }
+      }));
+
+      this.add('controller:home', _emberRuntime.Controller.extend());
+
+      return this.visit('/').then(function () {
+        var homeRoute = _this15.applicationInstance.lookup('route:home');
+        var homeController = _this15.applicationInstance.lookup('controller:home');
+
+        assert.equal(homeRoute.controller, homeController, 'route controller is the home controller');
+      });
+    };
+
+    _class.prototype['@test the route controller can be specified via controllerName'] = function testTheRouteControllerCanBeSpecifiedViaControllerName(assert) {
+      var _this16 = this;
+
+      this.addTemplate('home', '<p>{{myValue}}</p>');
+      this.add('route:home', _emberRouting.Route.extend({
+        controllerName: 'myController'
+      }));
+      this.add('controller:myController', _emberRuntime.Controller.extend({
+        myValue: 'foo'
+      }));
+
+      return this.visit('/').then(function () {
+        var homeRoute = _this16.applicationInstance.lookup('route:home');
+        var myController = _this16.applicationInstance.lookup('controller:myController');
+        var text = _this16.$('p').text();
+
+        assert.deepEqual(homeRoute.controller, myController, 'route controller is set by controllerName');
+        assert.equal(text, 'foo', 'The homepage template was rendered with data from the custom controller');
+      });
+    };
+
+    (0, _emberBabel.createClass)(_class, [{
+      key: 'currentPath',
+      get: function () {
+        return this.getController('application').get('currentPath');
+      }
+    }]);
+    return _class;
+  }(_internalTestHelpers.ApplicationTestCase));
+});
+QUnit.module('ESLint | ember/tests/routing/decoupled_basic_test.js');
+QUnit.test('should pass ESLint', function(assert) {
+  assert.expect(1);
+  assert.ok(true, 'ember/tests/routing/decoupled_basic_test.js should pass ESLint\n\n');
+});
+
 enifed('ember/tests/routing/query_params_test', ['ember-babel', 'ember-runtime', 'ember-metal', 'ember-routing', 'ember-views', 'internal-test-helpers'], function (_emberBabel, _emberRuntime, _emberMetal, _emberRouting, _emberViews, _internalTestHelpers) {
   'use strict';
 
@@ -77643,1066 +77812,975 @@ QUnit.test('should pass ESLint', function(assert) {
   assert.ok(true, 'ember/tests/routing/router_service_test/urlFor_test.js should pass ESLint\n\n');
 });
 
-enifed('ember/tests/routing/substates_test', ['ember-runtime', 'ember-routing', 'ember-metal', 'ember-template-compiler', 'ember-application', 'ember-views', 'ember-glimmer'], function (_emberRuntime, _emberRouting, _emberMetal, _emberTemplateCompiler, _emberApplication, _emberViews, _emberGlimmer) {
+enifed('ember/tests/routing/substates_test', ['ember-babel', 'ember-runtime', 'ember-routing', 'internal-test-helpers'], function (_emberBabel, _emberRuntime, _emberRouting, _internalTestHelpers) {
   'use strict';
 
-  var Router = void 0,
-      App = void 0,
-      templates = void 0,
-      router = void 0,
-      container = void 0,
-      counter = void 0;
+  var counter = void 0;
 
   function step(expectedValue, description) {
     equal(counter, expectedValue, 'Step ' + expectedValue + ': ' + description);
     counter++;
   }
 
-  function bootApplication(startingURL) {
-    for (var name in templates) {
-      (0, _emberGlimmer.setTemplate)(name, (0, _emberTemplateCompiler.compile)(templates[name]));
-    }
+  (0, _internalTestHelpers.moduleFor)('Loading/Error Substates', function (_ApplicationTestCase) {
+    (0, _emberBabel.inherits)(_class, _ApplicationTestCase);
 
-    if (startingURL) {
-      _emberRouting.NoneLocation.reopen({
-        path: startingURL
-      });
-    }
+    function _class() {
+      (0, _emberBabel.classCallCheck)(this, _class);
 
-    startingURL = startingURL || '';
-    router = container.lookup('router:main');
-    (0, _emberMetal.run)(App, 'advanceReadiness');
-  }
+      var _this = (0, _emberBabel.possibleConstructorReturn)(this, _ApplicationTestCase.call(this));
 
-  QUnit.module('Loading/Error Substates', {
-    setup: function () {
       counter = 1;
 
-      (0, _emberMetal.run)(function () {
-        App = _emberApplication.Application.create({
-          name: 'App',
-          rootElement: '#qunit-fixture',
-          // fake a modules resolver
-          Resolver: _emberApplication.Resolver.extend({ moduleBasedResolver: true })
-        });
-
-        App.deferReadiness();
-
-        App.Router.reopen({
-          location: 'none'
-        });
-
-        Router = App.Router;
+      _this.addTemplate('application', '<div id="app">{{outlet}}</div>');
+      _this.addTemplate('index', 'INDEX');
+      return _this;
+    }
 
-        container = App.__container__;
+    _class.prototype.getController = function getController(name) {
+      return this.applicationInstance.lookup('controller:' + name);
+    };
 
-        templates = {
-          application: '<div id="app">{{outlet}}</div>',
-          index: 'INDEX',
-          loading: 'LOADING',
-          bro: 'BRO',
-          sis: 'SIS'
-        };
-      });
-    },
-    teardown: function () {
-      (0, _emberMetal.run)(function () {
-        App.destroy();
-        App = null;
+    _class.prototype['@test Slow promise from a child route of application enters nested loading state'] = function testSlowPromiseFromAChildRouteOfApplicationEntersNestedLoadingState(assert) {
+      var _this2 = this;
 
-        (0, _emberGlimmer.setTemplates)({});
-      });
+      var turtleDeferred = _emberRuntime.RSVP.defer();
 
-      _emberRouting.NoneLocation.reopen({
-        path: ''
+      this.router.map(function () {
+        this.route('turtle');
       });
-    }
-  });
-
-  QUnit.test('Slow promise from a child route of application enters nested loading state', function () {
-    var broModel = {};
-    var broDeferred = _emberRuntime.RSVP.defer();
 
-    Router.map(function () {
-      this.route('bro');
-    });
+      this.add('route:application', _emberRouting.Route.extend({
+        setupController: function () {
+          step(2, 'ApplicationRoute#setupController');
+        }
+      }));
 
-    App.ApplicationRoute = _emberRouting.Route.extend({
-      setupController: function () {
-        step(2, 'ApplicationRoute#setup');
-      }
-    });
+      this.add('route:turtle', _emberRouting.Route.extend({
+        model: function () {
+          step(1, 'TurtleRoute#model');
+          return turtleDeferred.promise;
+        }
+      }));
+      this.addTemplate('turtle', 'TURTLE');
+      this.addTemplate('loading', 'LOADING');
 
-    App.BroRoute = _emberRouting.Route.extend({
-      model: function () {
-        step(1, 'BroRoute#model');
-        return broDeferred.promise;
-      }
-    });
+      var promise = this.visit('/turtle').then(function () {
+        text = _this2.$('#app').text();
+        assert.equal(text, 'TURTLE', 'turtle template has loaded and replaced the loading template');
+      });
 
-    bootApplication('/bro');
+      var text = this.$('#app').text();
+      assert.equal(text, 'LOADING', 'The Loading template is nested in application template\'s outlet');
 
-    equal((0, _emberViews.jQuery)('#app', '#qunit-fixture').text(), 'LOADING', 'The Loading template is nested in application template\'s outlet');
+      turtleDeferred.resolve();
+      return promise;
+    };
 
-    (0, _emberMetal.run)(broDeferred, 'resolve', broModel);
+    _class.prototype['@test Slow promises returned from ApplicationRoute#model don\'t enter LoadingRoute'] = function (assert) {
+      var _this3 = this;
 
-    equal((0, _emberViews.jQuery)('#app', '#qunit-fixture').text(), 'BRO', 'bro template has loaded and replaced loading template');
-  });
+      var appDeferred = _emberRuntime.RSVP.defer();
 
-  QUnit.test('Slow promises waterfall on startup', function () {
-    expect(7);
+      this.add('route:application', _emberRouting.Route.extend({
+        model: function () {
+          return appDeferred.promise;
+        }
+      }));
+      this.add('route:loading', _emberRouting.Route.extend({
+        setupController: function () {
+          ok(false, 'shouldn\'t get here');
+        }
+      }));
 
-    var grandmaDeferred = _emberRuntime.RSVP.defer();
-    var sallyDeferred = _emberRuntime.RSVP.defer();
+      var promise = this.visit('/').then(function () {
+        text = _this3.$('#app').text();
 
-    Router.map(function () {
-      this.route('grandma', function () {
-        this.route('mom', { resetNamespace: true }, function () {
-          this.route('sally');
-        });
+        assert.equal(text, 'INDEX', 'index template has been rendered');
       });
-    });
-
-    templates.grandma = 'GRANDMA {{outlet}}';
-    templates.mom = 'MOM {{outlet}}';
-    templates['mom/loading'] = 'MOMLOADING';
-    templates['mom/sally'] = 'SALLY';
 
-    App.GrandmaRoute = _emberRouting.Route.extend({
-      model: function () {
-        step(1, 'GrandmaRoute#model');
-        return grandmaDeferred.promise;
-      }
-    });
-
-    App.MomRoute = _emberRouting.Route.extend({
-      model: function () {
-        step(2, 'Mom#model');
-        return {};
-      }
-    });
-
-    App.MomSallyRoute = _emberRouting.Route.extend({
-      model: function () {
-        step(3, 'SallyRoute#model');
-        return sallyDeferred.promise;
-      },
-      setupController: function () {
-        step(4, 'SallyRoute#setupController');
-      }
-    });
-
-    bootApplication('/grandma/mom/sally');
-
-    equal((0, _emberViews.jQuery)('#app', '#qunit-fixture').text(), 'LOADING', 'The Loading template is nested in application template\'s outlet');
+      var text = this.$('#app').text();
 
-    (0, _emberMetal.run)(grandmaDeferred, 'resolve', {});
-    equal((0, _emberViews.jQuery)('#app', '#qunit-fixture').text(), 'GRANDMA MOM MOMLOADING', 'Mom\'s child loading route is displayed due to sally\'s slow promise');
+      assert.equal(text, '', 'nothing has been rendered yet');
+      appDeferred.resolve();
 
-    (0, _emberMetal.run)(sallyDeferred, 'resolve', {});
-    equal((0, _emberViews.jQuery)('#app', '#qunit-fixture').text(), 'GRANDMA MOM SALLY', 'Sally template displayed');
-  });
+      return promise;
+    };
 
-  QUnit.test('ApplicationRoute#currentPath reflects loading state path', function () {
-    expect(4);
+    _class.prototype['@test Don\'t enter loading route unless either route or template defined'] = function (assert) {
+      var _this4 = this;
 
-    var momDeferred = _emberRuntime.RSVP.defer();
+      var deferred = _emberRuntime.RSVP.defer();
 
-    Router.map(function () {
-      this.route('grandma', function () {
-        this.route('mom');
+      this.router.map(function () {
+        this.route('dummy');
       });
-    });
-
-    templates.grandma = 'GRANDMA {{outlet}}';
-    templates['grandma/loading'] = 'GRANDMALOADING';
-    templates['grandma/mom'] = 'MOM';
-
-    App.GrandmaMomRoute = _emberRouting.Route.extend({
-      model: function () {
-        return momDeferred.promise;
-      }
-    });
-
-    bootApplication('/grandma/mom');
-
-    equal((0, _emberViews.jQuery)('#app', '#qunit-fixture').text(), 'GRANDMA GRANDMALOADING');
+      this.add('route:dummy', _emberRouting.Route.extend({
+        model: function () {
+          return deferred.promise;
+        }
+      }));
+      this.addTemplate('dummy', 'DUMMY');
 
-    var appController = container.lookup('controller:application');
-    equal(appController.get('currentPath'), 'grandma.loading', 'currentPath reflects loading state');
+      return this.visit('/').then(function () {
+        var promise = _this4.visit('/dummy').then(function () {
+          var text = _this4.$('#app').text();
 
-    (0, _emberMetal.run)(momDeferred, 'resolve', {});
-    equal((0, _emberViews.jQuery)('#app', '#qunit-fixture').text(), 'GRANDMA MOM');
-    equal(appController.get('currentPath'), 'grandma.mom', 'currentPath reflects final state');
-  });
+          assert.equal(text, 'DUMMY', 'dummy template has been rendered');
+        });
 
-  QUnit.test('Slow promises returned from ApplicationRoute#model don\'t enter LoadingRoute', function () {
-    expect(2);
+        assert.ok(_this4.currentPath !== 'loading', '\n        loading state not entered\n      ');
+        deferred.resolve();
 
-    var appDeferred = _emberRuntime.RSVP.defer();
+        return promise;
+      });
+    };
 
-    App.ApplicationRoute = _emberRouting.Route.extend({
-      model: function () {
-        return appDeferred.promise;
-      }
-    });
+    _class.prototype['@test Enter loading route only if loadingRoute is defined'] = function testEnterLoadingRouteOnlyIfLoadingRouteIsDefined(assert) {
+      var _this5 = this;
 
-    App.LoadingRoute = _emberRouting.Route.extend({
-      setupController: function () {
-        ok(false, 'shouldn\'t get here');
-      }
-    });
+      var deferred = _emberRuntime.RSVP.defer();
 
-    bootApplication();
+      this.router.map(function () {
+        this.route('dummy');
+      });
 
-    equal((0, _emberViews.jQuery)('#app', '#qunit-fixture').text(), '', 'nothing has been rendered yet');
+      this.add('route:dummy', _emberRouting.Route.extend({
+        model: function () {
+          step(1, 'DummyRoute#model');
+          return deferred.promise;
+        }
+      }));
+      this.add('route:loading', _emberRouting.Route.extend({
+        setupController: function () {
+          step(2, 'LoadingRoute#setupController');
+        }
+      }));
+      this.addTemplate('dummy', 'DUMMY');
 
-    (0, _emberMetal.run)(appDeferred, 'resolve', {});
-    equal((0, _emberViews.jQuery)('#app', '#qunit-fixture').text(), 'INDEX');
-  });
+      return this.visit('/').then(function () {
+        var promise = _this5.visit('/dummy').then(function () {
+          var text = _this5.$('#app').text();
 
-  QUnit.test('Don\'t enter loading route unless either route or template defined', function () {
-    delete templates.loading;
+          assert.equal(text, 'DUMMY', 'dummy template has been rendered');
+        });
 
-    expect(2);
+        assert.equal(_this5.currentPath, 'loading', 'loading state entered');
+        deferred.resolve();
 
-    var indexDeferred = _emberRuntime.RSVP.defer();
+        return promise;
+      });
+    };
 
-    App.ApplicationController = _emberRuntime.Controller.extend();
+    _class.prototype['@test Slow promises returned from ApplicationRoute#model enter ApplicationLoadingRoute if present'] = function testSlowPromisesReturnedFromApplicationRouteModelEnterApplicationLoadingRouteIfPresent(assert) {
+      var _this6 = this;
 
-    App.IndexRoute = _emberRouting.Route.extend({
-      model: function () {
-        return indexDeferred.promise;
-      }
-    });
+      var appDeferred = _emberRuntime.RSVP.defer();
 
-    bootApplication();
+      this.add('route:application', _emberRouting.Route.extend({
+        model: function () {
+          return appDeferred.promise;
+        }
+      }));
+      var loadingRouteEntered = false;
+      this.add('route:application_loading', _emberRouting.Route.extend({
+        setupController: function () {
+          loadingRouteEntered = true;
+        }
+      }));
 
-    var appController = container.lookup('controller:application');
-    ok(appController.get('currentPath') !== 'loading', 'loading state not entered');
+      var promise = this.visit('/').then(function () {
+        assert.equal(_this6.$('#app').text(), 'INDEX', 'index route loaded');
+      });
+      assert.ok(loadingRouteEntered, 'ApplicationLoadingRoute was entered');
+      appDeferred.resolve();
 
-    (0, _emberMetal.run)(indexDeferred, 'resolve', {});
-    equal((0, _emberViews.jQuery)('#app', '#qunit-fixture').text(), 'INDEX');
-  });
+      return promise;
+    };
 
-  QUnit.test('Enter loading route if only LoadingRoute defined', function () {
-    delete templates.loading;
+    _class.prototype['@test Slow promises returned from ApplicationRoute#model enter application_loading if template present'] = function testSlowPromisesReturnedFromApplicationRouteModelEnterApplication_loadingIfTemplatePresent(assert) {
+      var _this7 = this;
 
-    expect(4);
+      var appDeferred = _emberRuntime.RSVP.defer();
 
-    var indexDeferred = _emberRuntime.RSVP.defer();
+      this.addTemplate('application_loading', '\n      <div id="toplevel-loading">TOPLEVEL LOADING</div>\n    ');
+      this.add('route:application', _emberRouting.Route.extend({
+        model: function () {
+          return appDeferred.promise;
+        }
+      }));
 
-    App.IndexRoute = _emberRouting.Route.extend({
-      model: function () {
-        step(1, 'IndexRoute#model');
-        return indexDeferred.promise;
-      }
-    });
+      var promise = this.visit('/').then(function () {
+        var length = _this7.$('#toplevel-loading').length;
+        text = _this7.$('#app').text();
 
-    App.LoadingRoute = _emberRouting.Route.extend({
-      setupController: function () {
-        step(2, 'LoadingRoute#setupController');
-      }
-    });
+        assert.equal(length, 0, 'top-level loading view has been entirely removed from the DOM');
+        assert.equal(text, 'INDEX', 'index has fully rendered');
+      });
+      var text = this.$('#toplevel-loading').text();
 
-    bootApplication();
+      assert.equal(text, 'TOPLEVEL LOADING', 'still loading the top level');
+      appDeferred.resolve();
 
-    var appController = container.lookup('controller:application');
-    equal(appController.get('currentPath'), 'loading', 'loading state entered');
+      return promise;
+    };
 
-    (0, _emberMetal.run)(indexDeferred, 'resolve', {});
-    equal((0, _emberViews.jQuery)('#app', '#qunit-fixture').text(), 'INDEX');
-  });
+    _class.prototype['@test Prioritized substate entry works with preserved-namespace nested routes'] = function testPrioritizedSubstateEntryWorksWithPreservedNamespaceNestedRoutes(assert) {
+      var _this8 = this;
 
-  QUnit.test('Enter child loading state of pivot route', function () {
-    expect(4);
+      var deferred = _emberRuntime.RSVP.defer();
 
-    var deferred = _emberRuntime.RSVP.defer();
+      this.addTemplate('foo.bar_loading', 'FOOBAR LOADING');
+      this.addTemplate('foo.bar.index', 'YAY');
 
-    Router.map(function () {
-      this.route('grandma', function () {
-        this.route('mom', { resetNamespace: true }, function () {
-          this.route('sally');
+      this.router.map(function () {
+        this.route('foo', function () {
+          this.route('bar', { path: '/bar' }, function () {});
         });
-        this.route('smells');
       });
-    });
-
-    templates['grandma/loading'] = 'GMONEYLOADING';
-
-    App.ApplicationController = _emberRuntime.Controller.extend();
 
-    App.MomSallyRoute = _emberRouting.Route.extend({
-      setupController: function () {
-        step(1, 'SallyRoute#setupController');
-      }
-    });
-
-    App.GrandmaSmellsRoute = _emberRouting.Route.extend({
-      model: function () {
-        return deferred.promise;
-      }
-    });
-
-    bootApplication('/grandma/mom/sally');
+      this.add('route:foo.bar', _emberRouting.Route.extend({
+        model: function () {
+          return deferred.promise;
+        }
+      }));
 
-    var appController = container.lookup('controller:application');
-    equal(appController.get('currentPath'), 'grandma.mom.sally', 'Initial route fully loaded');
+      return this.visit('/').then(function () {
+        var promise = _this8.visit('/foo/bar').then(function () {
+          text = _this8.$('#app').text();
 
-    (0, _emberMetal.run)(router, 'transitionTo', 'grandma.smells');
-    equal(appController.get('currentPath'), 'grandma.loading', 'in pivot route\'s child loading state');
+          assert.equal(text, 'YAY', 'foo.bar.index fully loaded');
+        });
+        var text = _this8.$('#app').text();
 
-    (0, _emberMetal.run)(deferred, 'resolve', {});
+        assert.equal(text, 'FOOBAR LOADING', 'foo.bar_loading was entered (as opposed to something like foo/foo/bar_loading)');
+        deferred.resolve();
 
-    equal(appController.get('currentPath'), 'grandma.smells', 'Finished transition');
-  });
+        return promise;
+      });
+    };
 
-  QUnit.test('Loading actions bubble to root, but don\'t enter substates above pivot', function () {
-    expect(6);
+    _class.prototype['@test Prioritized substate entry works with reset-namespace nested routes'] = function testPrioritizedSubstateEntryWorksWithResetNamespaceNestedRoutes(assert) {
+      var _this9 = this;
 
-    delete templates.loading;
+      var deferred = _emberRuntime.RSVP.defer();
 
-    var sallyDeferred = _emberRuntime.RSVP.defer();
-    var smellsDeferred = _emberRuntime.RSVP.defer();
+      this.addTemplate('bar_loading', 'BAR LOADING');
+      this.addTemplate('bar.index', 'YAY');
 
-    Router.map(function () {
-      this.route('grandma', function () {
-        this.route('mom', { resetNamespace: true }, function () {
-          this.route('sally');
+      this.router.map(function () {
+        this.route('foo', function () {
+          this.route('bar', { path: '/bar', resetNamespace: true }, function () {});
         });
-        this.route('smells');
       });
-    });
-
-    App.ApplicationController = _emberRuntime.Controller.extend();
 
-    App.ApplicationRoute = _emberRouting.Route.extend({
-      actions: {
-        loading: function (transition, route) {
-          ok(true, 'loading action received on ApplicationRoute');
+      this.add('route:bar', _emberRouting.Route.extend({
+        model: function () {
+          return deferred.promise;
         }
-      }
-    });
-
-    App.MomSallyRoute = _emberRouting.Route.extend({
-      model: function () {
-        return sallyDeferred.promise;
-      }
-    });
-
-    App.GrandmaSmellsRoute = _emberRouting.Route.extend({
-      model: function () {
-        return smellsDeferred.promise;
-      }
-    });
+      }));
 
-    bootApplication('/grandma/mom/sally');
+      return this.visit('/').then(function () {
+        var promise = _this9.visit('/foo/bar').then(function () {
+          text = _this9.$('#app').text();
 
-    var appController = container.lookup('controller:application');
-    ok(!appController.get('currentPath'), 'Initial route fully loaded');
-    (0, _emberMetal.run)(sallyDeferred, 'resolve', {});
+          assert.equal(text, 'YAY', 'bar.index fully loaded');
+        });
 
-    equal(appController.get('currentPath'), 'grandma.mom.sally', 'transition completed');
+        var text = _this9.$('#app').text();
 
-    (0, _emberMetal.run)(router, 'transitionTo', 'grandma.smells');
-    equal(appController.get('currentPath'), 'grandma.mom.sally', 'still in initial state because the only loading state is above the pivot route');
+        assert.equal(text, 'BAR LOADING', 'foo.bar_loading was entered (as opposed to something likefoo/foo/bar_loading)');
+        deferred.resolve();
 
-    (0, _emberMetal.run)(smellsDeferred, 'resolve', {});
+        return promise;
+      });
+    };
 
-    equal(appController.get('currentPath'), 'grandma.smells', 'Finished transition');
-  });
+    _class.prototype['@test Prioritized loading substate entry works with preserved-namespace nested routes'] = function testPrioritizedLoadingSubstateEntryWorksWithPreservedNamespaceNestedRoutes(assert) {
+      var _this10 = this;
 
-  QUnit.test('Default error event moves into nested route', function () {
-    expect(6);
+      var deferred = _emberRuntime.RSVP.defer();
 
-    templates['grandma'] = 'GRANDMA {{outlet}}';
-    templates['grandma/error'] = 'ERROR: {{model.msg}}';
+      this.addTemplate('foo.bar_loading', 'FOOBAR LOADING');
+      this.addTemplate('foo.bar', 'YAY');
 
-    Router.map(function () {
-      this.route('grandma', function () {
-        this.route('mom', { resetNamespace: true }, function () {
-          this.route('sally');
+      this.router.map(function () {
+        this.route('foo', function () {
+          this.route('bar');
         });
       });
-    });
-
-    App.ApplicationController = _emberRuntime.Controller.extend();
 
-    App.MomSallyRoute = _emberRouting.Route.extend({
-      model: function () {
-        step(1, 'MomSallyRoute#model');
-
-        return _emberRuntime.RSVP.reject({
-          msg: 'did it broke?'
-        });
-      },
-
-      actions: {
-        error: function () {
-          step(2, 'MomSallyRoute#actions.error');
-          return true;
+      this.add('route:foo.bar', _emberRouting.Route.extend({
+        model: function () {
+          return deferred.promise;
         }
-      }
-    });
+      }));
 
-    throws(function () {
-      bootApplication('/grandma/mom/sally');
-    }, function (err) {
-      return err.msg === 'did it broke?';
-    });
+      var promise = this.visit('/foo/bar').then(function () {
+        text = _this10.$('#app').text();
 
-    step(3, 'App finished booting');
+        assert.equal(text, 'YAY', 'foo.bar has rendered');
+      });
+      var text = this.$('#app').text();
 
-    equal((0, _emberViews.jQuery)('#app', '#qunit-fixture').text(), 'GRANDMA ERROR: did it broke?', 'error bubbles');
+      assert.equal(text, 'FOOBAR LOADING', 'foo.bar_loading was entered (as opposed to something like foo/foo/bar_loading)');
+      deferred.resolve();
 
-    var appController = container.lookup('controller:application');
-    equal(appController.get('currentPath'), 'grandma.error', 'Initial route fully loaded');
-  });
+      return promise;
+    };
 
-  QUnit.test('Error events that aren\'t bubbled don\t throw application assertions', function () {
-    expect(2);
+    _class.prototype['@test Prioritized error substate entry works with preserved-namespaec nested routes'] = function testPrioritizedErrorSubstateEntryWorksWithPreservedNamespaecNestedRoutes(assert) {
+      var _this11 = this;
 
-    templates['grandma'] = 'GRANDMA {{outlet}}';
+      this.addTemplate('foo.bar_error', 'FOOBAR ERROR: {{model.msg}}');
+      this.addTemplate('foo.bar', 'YAY');
 
-    Router.map(function () {
-      this.route('grandma', function () {
-        this.route('mom', { resetNamespace: true }, function () {
-          this.route('sally');
+      this.router.map(function () {
+        this.route('foo', function () {
+          this.route('bar');
         });
       });
-    });
-
-    App.ApplicationController = _emberRuntime.Controller.extend();
-
-    App.MomSallyRoute = _emberRouting.Route.extend({
-      model: function () {
-        step(1, 'MomSallyRoute#model');
-
-        return _emberRuntime.RSVP.reject({
-          msg: 'did it broke?'
-        });
-      },
 
-      actions: {
-        error: function (err) {
-          equal(err.msg, 'did it broke?');
-          return false;
+      this.add('route:foo.bar', _emberRouting.Route.extend({
+        model: function () {
+          return _emberRuntime.RSVP.reject({
+            msg: 'did it broke?'
+          });
         }
-      }
-    });
-
-    bootApplication('/grandma/mom/sally');
-  });
-
-  QUnit.test('Non-bubbled errors that re-throw aren\'t swallowed', function () {
-    expect(2);
+      }));
 
-    templates['grandma'] = 'GRANDMA {{outlet}}';
+      return this.visit('/').then(function () {
+        return _this11.visit('/foo/bar').then(function () {
 
-    Router.map(function () {
-      this.route('grandma', function () {
-        this.route('mom', { resetNamespace: true }, function () {
-          this.route('sally');
+          var text = _this11.$('#app').text();
+          assert.equal(text, 'FOOBAR ERROR: did it broke?', 'foo.bar_error was entered (as opposed to something like foo/foo/bar_error)');
         });
       });
-    });
+    };
 
-    App.ApplicationController = _emberRuntime.Controller.extend();
+    _class.prototype['@test Prioritized loading substate entry works with auto-generated index routes'] = function testPrioritizedLoadingSubstateEntryWorksWithAutoGeneratedIndexRoutes(assert) {
+      var _this12 = this;
 
-    App.MomSallyRoute = _emberRouting.Route.extend({
-      model: function () {
-        step(1, 'MomSallyRoute#model');
+      var deferred = _emberRuntime.RSVP.defer();
+      this.addTemplate('foo.index_loading', 'FOO LOADING');
+      this.addTemplate('foo.index', 'YAY');
+      this.addTemplate('foo', '{{outlet}}');
 
-        return _emberRuntime.RSVP.reject({
-          msg: 'did it broke?'
+      this.router.map(function () {
+        this.route('foo', function () {
+          this.route('bar');
         });
-      },
+      });
 
-      actions: {
-        error: function (err) {
-          // returns undefined which is falsey
-          throw err;
+      this.add('route:foo.index', _emberRouting.Route.extend({
+        model: function () {
+          return deferred.promise;
         }
-      }
-    });
-
-    throws(function () {
-      bootApplication('/grandma/mom/sally');
-    }, function (err) {
-      return err.msg === 'did it broke?';
-    });
-  });
-
-  QUnit.test('Handled errors that re-throw aren\'t swallowed', function () {
-    expect(4);
-
-    var handledError = void 0;
+      }));
+      this.add('route:foo', _emberRouting.Route.extend({
+        model: function () {
+          return true;
+        }
+      }));
 
-    templates['grandma'] = 'GRANDMA {{outlet}}';
+      var promise = this.visit('/foo').then(function () {
+        text = _this12.$('#app').text();
 
-    Router.map(function () {
-      this.route('grandma', function () {
-        this.route('mom', { resetNamespace: true }, function () {
-          this.route('sally');
-          this.route('this-route-throws');
-        });
+        assert.equal(text, 'YAY', 'foo.index was rendered');
       });
-    });
-
-    App.ApplicationController = _emberRuntime.Controller.extend();
+      var text = this.$('#app').text();
+      assert.equal(text, 'FOO LOADING', 'foo.index_loading was entered');
 
-    App.MomSallyRoute = _emberRouting.Route.extend({
-      model: function () {
-        step(1, 'MomSallyRoute#model');
+      deferred.resolve();
 
-        return _emberRuntime.RSVP.reject({
-          msg: 'did it broke?'
-        });
-      },
+      return promise;
+    };
 
-      actions: {
-        error: function (err) {
-          step(2, 'MomSallyRoute#error');
+    _class.prototype['@test Prioritized error substate entry works with auto-generated index routes'] = function testPrioritizedErrorSubstateEntryWorksWithAutoGeneratedIndexRoutes(assert) {
+      var _this13 = this;
 
-          handledError = err;
+      this.addTemplate('foo.index_error', 'FOO ERROR: {{model.msg}}');
+      this.addTemplate('foo.index', 'YAY');
+      this.addTemplate('foo', '{{outlet}}');
 
-          this.transitionTo('mom.this-route-throws');
+      this.router.map(function () {
+        this.route('foo', function () {
+          this.route('bar');
+        });
+      });
 
-          // Marks error as handled
-          return false;
+      this.add('route:foo.index', _emberRouting.Route.extend({
+        model: function () {
+          return _emberRuntime.RSVP.reject({
+            msg: 'did it broke?'
+          });
         }
-      }
-    });
-
-    App.MomThisRouteThrowsRoute = _emberRouting.Route.extend({
-      model: function () {
-        step(3, 'MomThisRouteThrows#model');
-
-        throw handledError;
-      }
-    });
-
-    throws(function () {
-      bootApplication('/grandma/mom/sally');
-    }, function (err) {
-      return err.msg === 'did it broke?';
-    });
-  });
-
-  QUnit.test('Handled errors that bubble can be handled at a higher level', function () {
-    expect(4);
+      }));
+      this.add('route:foo', _emberRouting.Route.extend({
+        model: function () {
+          return true;
+        }
+      }));
 
-    var handledError = void 0;
+      return this.visit('/').then(function () {
 
-    templates['grandma'] = 'GRANDMA {{outlet}}';
+        return _this13.visit('/foo').then(function () {
+          var text = _this13.$('#app').text();
 
-    Router.map(function () {
-      this.route('grandma', function () {
-        this.route('mom', { resetNamespace: true }, function () {
-          this.route('sally');
+          assert.equal(text, 'FOO ERROR: did it broke?', 'foo.index_error was entered');
         });
       });
-    });
-
-    App.ApplicationController = _emberRuntime.Controller.extend();
-
-    App.MomRoute = _emberRouting.Route.extend({
-      actions: {
-        error: function (err) {
-          step(3, 'MomRoute#error');
+    };
 
-          equal(err, handledError, 'error handled and rebubbled is handleable at higher route');
-        }
+    (0, _emberBabel.createClass)(_class, [{
+      key: 'currentPath',
+      get: function () {
+        return this.getController('application').get('currentPath');
       }
-    });
+    }]);
+    return _class;
+  }(_internalTestHelpers.ApplicationTestCase));
 
-    App.MomSallyRoute = _emberRouting.Route.extend({
-      model: function () {
-        step(1, 'MomSallyRoute#model');
+  (0, _internalTestHelpers.moduleFor)('Loading/Error Substates - globals mode app', function (_AutobootApplicationT) {
+    (0, _emberBabel.inherits)(_class2, _AutobootApplicationT);
 
-        return _emberRuntime.RSVP.reject({
-          msg: 'did it broke?'
-        });
-      },
+    function _class2() {
+      (0, _emberBabel.classCallCheck)(this, _class2);
+      return (0, _emberBabel.possibleConstructorReturn)(this, _AutobootApplicationT.apply(this, arguments));
+    }
 
+    _class2.prototype['@test Rejected promises returned from ApplicationRoute transition into top-level application_error'] = function testRejectedPromisesReturnedFromApplicationRouteTransitionIntoTopLevelApplication_error(assert) {
+      var _this15 = this;
 
-      actions: {
-        error: function (err) {
-          step(2, 'MomSallyRoute#error');
+      var reject = true;
 
-          handledError = err;
+      this.runTask(function () {
+        _this15.createApplication();
+        _this15.addTemplate('index', '<div id="app">INDEX</div>');
+        _this15.add('route:application', _emberRouting.Route.extend({
+          init: function () {
+            this._super.apply(this, arguments);
+          },
+          model: function () {
+            if (reject) {
+              return _emberRuntime.RSVP.reject({ msg: 'BAD NEWS BEARS' });
+            } else {
+              return {};
+            }
+          }
+        }));
 
-          return true;
-        }
-      }
-    });
+        _this15.addTemplate('application_error', '\n        <p id="toplevel-error">TOPLEVEL ERROR: {{model.msg}}</p>\n      ');
+      });
 
-    bootApplication('/grandma/mom/sally');
-  });
+      var text = this.$('#toplevel-error').text();
+      assert.equal(text, 'TOPLEVEL ERROR: BAD NEWS BEARS', 'toplevel error rendered');
 
-  QUnit.test('errors that are bubbled are thrown at a higher level if not handled', function () {
-    expect(3);
+      reject = false;
 
-    templates['grandma'] = 'GRANDMA {{outlet}}';
+      return this.visit('/').then(function () {
+        var text = _this15.$('#app').text();
 
-    Router.map(function () {
-      this.route('grandma', function () {
-        this.route('mom', { resetNamespace: true }, function () {
-          this.route('sally');
-        });
+        assert.equal(text, 'INDEX', 'the index route resolved');
       });
-    });
-
-    App.ApplicationController = _emberRuntime.Controller.extend();
-
-    App.MomSallyRoute = _emberRouting.Route.extend({
-      model: function () {
-        step(1, 'MomSallyRoute#model');
-
-        return _emberRuntime.RSVP.reject({
-          msg: 'did it broke?'
-        });
-      },
+    };
 
+    return _class2;
+  }(_internalTestHelpers.AutobootApplicationTestCase));
 
-      actions: {
-        error: function (err) {
-          step(2, 'MomSallyRoute#error');
-          return true;
-        }
-      }
-    });
+  (0, _internalTestHelpers.moduleFor)('Loading/Error Substates - nested routes', function (_ApplicationTestCase2) {
+    (0, _emberBabel.inherits)(_class3, _ApplicationTestCase2);
 
-    throws(function () {
-      bootApplication('/grandma/mom/sally');
-    }, function (err) {
-      return err.msg === 'did it broke?';
-    }, 'Correct error was thrown');
-  });
+    function _class3() {
+      (0, _emberBabel.classCallCheck)(this, _class3);
 
-  QUnit.test('Handled errors that are thrown through rejection aren\'t swallowed', function () {
-    expect(4);
+      var _this16 = (0, _emberBabel.possibleConstructorReturn)(this, _ApplicationTestCase2.call(this));
 
-    var handledError = void 0;
+      counter = 1;
 
-    templates['grandma'] = 'GRANDMA {{outlet}}';
+      _this16.addTemplate('application', '<div id="app">{{outlet}}</div>');
+      _this16.addTemplate('index', 'INDEX');
+      _this16.addTemplate('grandma', 'GRANDMA {{outlet}}');
+      _this16.addTemplate('mom', 'MOM');
 
-    Router.map(function () {
-      this.route('grandma', function () {
-        this.route('mom', { resetNamespace: true }, function () {
-          this.route('sally');
-          this.route('this-route-throws');
+      _this16.router.map(function () {
+        this.route('grandma', function () {
+          this.route('mom', { resetNamespace: true }, function () {
+            this.route('sally');
+            this.route('this-route-throws');
+          });
+          this.route('puppies');
         });
+        this.route('memere', { path: '/memere/:seg' }, function () {});
       });
-    });
 
-    App.ApplicationController = _emberRuntime.Controller.extend();
-
-    App.MomSallyRoute = _emberRouting.Route.extend({
-      model: function () {
-        step(1, 'MomSallyRoute#model');
+      _this16.visit('/');
+      return _this16;
+    }
 
-        return _emberRuntime.RSVP.reject({
-          msg: 'did it broke?'
-        });
-      },
+    _class3.prototype.getController = function getController(name) {
+      return this.applicationInstance.lookup('controller:' + name);
+    };
 
-      actions: {
-        error: function (err) {
-          step(2, 'MomSallyRoute#error');
+    _class3.prototype['@test ApplicationRoute#currentPath reflects loading state path'] = function testApplicationRouteCurrentPathReflectsLoadingStatePath(assert) {
+      var _this17 = this;
 
-          handledError = err;
+      var momDeferred = _emberRuntime.RSVP.defer();
 
-          this.transitionTo('mom.this-route-throws');
+      this.addTemplate('grandma.loading', 'GRANDMALOADING');
 
-          // Marks error as handled
-          return false;
+      this.add('route:mom', _emberRouting.Route.extend({
+        model: function () {
+          return momDeferred.promise;
         }
-      }
-    });
+      }));
 
-    App.MomThisRouteThrowsRoute = _emberRouting.Route.extend({
-      model: function () {
-        step(3, 'MomThisRouteThrows#model');
+      var promise = this.visit('/grandma/mom').then(function () {
+        text = _this17.$('#app').text();
 
-        return _emberRuntime.RSVP.reject(handledError);
-      }
-    });
+        assert.equal(text, 'GRANDMA MOM', 'Grandma.mom loaded text is displayed');
+        assert.equal(_this17.currentPath, 'grandma.mom.index', 'currentPath reflects final state');
+      });
+      var text = this.$('#app').text();
 
-    throws(function () {
-      bootApplication('/grandma/mom/sally');
-    }, function (err) {
-      return err.msg === 'did it broke?';
-    });
-  });
+      assert.equal(text, 'GRANDMA GRANDMALOADING', 'Grandma.mom loading text displayed');
 
-  QUnit.test('Setting a query param during a slow transition should work', function () {
-    var deferred = _emberRuntime.RSVP.defer();
+      assert.equal(this.currentPath, 'grandma.loading', 'currentPath reflects loading state');
 
-    Router.map(function () {
-      this.route('grandma', { path: '/grandma/:seg' }, function () {});
-    });
+      momDeferred.resolve();
 
-    templates['grandma/loading'] = 'GMONEYLOADING';
+      return promise;
+    };
 
-    App.ApplicationController = _emberRuntime.Controller.extend();
+    _class3.prototype['@test Loading actions bubble to root but don\'t enter substates above pivot '] = function (assert) {
+      var _this18 = this;
 
-    App.IndexRoute = _emberRouting.Route.extend({
-      beforeModel: function () {
-        this.transitionTo('grandma', 1);
-      }
-    });
+      var sallyDeferred = _emberRuntime.RSVP.defer();
+      var puppiesDeferred = _emberRuntime.RSVP.defer();
 
-    App.GrandmaRoute = _emberRouting.Route.extend({
-      queryParams: {
-        test: { defaultValue: 1 }
-      }
-    });
+      this.add('route:application', _emberRouting.Route.extend({
+        actions: {
+          loading: function (transition, route) {
+            assert.ok(true, 'loading action received on ApplicationRoute');
+          }
+        }
+      }));
 
-    App.GrandmaIndexRoute = _emberRouting.Route.extend({
-      model: function () {
-        return deferred.promise;
-      }
-    });
+      this.add('route:mom.sally', _emberRouting.Route.extend({
+        model: function () {
+          return sallyDeferred.promise;
+        }
+      }));
 
-    bootApplication('/');
+      this.add('route:grandma.puppies', _emberRouting.Route.extend({
+        model: function () {
+          return puppiesDeferred.promise;
+        }
+      }));
 
-    var appController = container.lookup('controller:application');
-    var grandmaController = container.lookup('controller:grandma');
+      var promise = this.visit('/grandma/mom/sally');
+      assert.equal(this.currentPath, 'index', 'Initial route fully loaded');
 
-    equal(appController.get('currentPath'), 'grandma.loading', 'Initial route should be loading');
+      sallyDeferred.resolve();
 
-    (0, _emberMetal.run)(function () {
-      grandmaController.set('test', 3);
-    });
+      promise.then(function () {
+        assert.equal(_this18.currentPath, 'grandma.mom.sally', 'transition completed');
 
-    equal(appController.get('currentPath'), 'grandma.loading', 'Route should still be loading');
-    equal(grandmaController.get('test'), 3, 'Controller query param value should have changed');
+        var visit = _this18.visit('/grandma/puppies');
+        assert.equal(_this18.currentPath, 'grandma.mom.sally', 'still in initial state because the only loading state is above the pivot route');
 
-    (0, _emberMetal.run)(deferred, 'resolve', {});
+        return visit;
+      }).then(function () {
+        _this18.runTask(function () {
+          return puppiesDeferred.resolve();
+        });
 
-    equal(appController.get('currentPath'), 'grandma.index', 'Transition should be complete');
-  });
+        assert.equal(_this18.currentPath, 'grandma.puppies', 'Finished transition');
+      });
 
-  QUnit.test('Slow promises returned from ApplicationRoute#model enter ApplicationLoadingRoute if present', function () {
-    expect(2);
+      return promise;
+    };
 
-    var appDeferred = _emberRuntime.RSVP.defer();
+    _class3.prototype['@test Default error event moves into nested route'] = function testDefaultErrorEventMovesIntoNestedRoute(assert) {
+      var _this19 = this;
 
-    App.ApplicationRoute = _emberRouting.Route.extend({
-      model: function () {
-        return appDeferred.promise;
-      }
-    });
+      this.addTemplate('grandma.error', 'ERROR: {{model.msg}}');
 
-    var loadingRouteEntered = false;
-    App.ApplicationLoadingRoute = _emberRouting.Route.extend({
-      setupController: function () {
-        loadingRouteEntered = true;
-      }
-    });
+      this.add('route:mom.sally', _emberRouting.Route.extend({
+        model: function () {
+          step(1, 'MomSallyRoute#model');
+          return _emberRuntime.RSVP.reject({
+            msg: 'did it broke?'
+          });
+        },
 
-    bootApplication();
+        actions: {
+          error: function () {
+            step(2, 'MomSallyRoute#actions.error');
+            return true;
+          }
+        }
+      }));
 
-    ok(loadingRouteEntered, 'ApplicationLoadingRoute was entered');
+      return this.visit('/grandma/mom/sally').then(function () {
+        step(3, 'App finished loading');
 
-    (0, _emberMetal.run)(appDeferred, 'resolve', {});
-    equal((0, _emberViews.jQuery)('#app', '#qunit-fixture').text(), 'INDEX');
-  });
+        var text = _this19.$('#app').text();
 
-  QUnit.test('Slow promises returned from ApplicationRoute#model enter application_loading if template present', function () {
-    expect(3);
+        assert.equal(text, 'GRANDMA ERROR: did it broke?', 'error bubbles');
+        assert.equal(_this19.currentPath, 'grandma.error', 'Initial route fully loaded');
+      });
+    };
 
-    templates['application_loading'] = '<div id="toplevel-loading">TOPLEVEL LOADING</div>';
+    _class3.prototype['@test Non-bubbled errors that re-throw aren\'t swallowed'] = function (assert) {
+      var _this20 = this;
 
-    var appDeferred = _emberRuntime.RSVP.defer();
-    App.ApplicationRoute = _emberRouting.Route.extend({
-      model: function () {
-        return appDeferred.promise;
-      }
-    });
+      this.add('route:mom.sally', _emberRouting.Route.extend({
+        model: function () {
+          return _emberRuntime.RSVP.reject({
+            msg: 'did it broke?'
+          });
+        },
 
-    bootApplication();
+        actions: {
+          error: function (err) {
+            // returns undefined which is falsey
+            throw err;
+          }
+        }
+      }));
 
-    equal((0, _emberViews.jQuery)('#qunit-fixture #toplevel-loading').text(), 'TOPLEVEL LOADING');
+      assert.throws(function () {
+        _this20.visit('/grandma/mom/sally');
+      }, function (err) {
+        return err.msg === 'did it broke?';
+      }, 'it broke');
+    };
 
-    (0, _emberMetal.run)(appDeferred, 'resolve', {});
+    _class3.prototype['@test Handled errors that re-throw aren\'t swallowed'] = function (assert) {
+      var _this21 = this;
 
-    equal((0, _emberViews.jQuery)('#toplevel-loading', '#qunit-fixture').length, 0, 'top-level loading View has been entirely removed from DOM');
-    equal((0, _emberViews.jQuery)('#app', '#qunit-fixture').text(), 'INDEX');
-  });
+      var handledError = void 0;
 
-  QUnit.test('Default error event moves into nested route, prioritizing more specifically named error route', function () {
-    expect(6);
+      this.add('route:mom.sally', _emberRouting.Route.extend({
+        model: function () {
+          step(1, 'MomSallyRoute#model');
+          return _emberRuntime.RSVP.reject({
+            msg: 'did it broke?'
+          });
+        },
 
-    templates['grandma'] = 'GRANDMA {{outlet}}';
-    templates['grandma/error'] = 'ERROR: {{model.msg}}';
-    templates['mom_error'] = 'MOM ERROR: {{model.msg}}';
+        actions: {
+          error: function (err) {
+            step(2, 'MomSallyRoute#actions.error');
+            handledError = err;
+            this.transitionTo('mom.this-route-throws');
 
-    Router.map(function () {
-      this.route('grandma', function () {
-        this.route('mom', { resetNamespace: true }, function () {
-          this.route('sally');
-        });
-      });
-    });
+            return false;
+          }
+        }
+      }));
 
-    App.ApplicationController = _emberRuntime.Controller.extend();
+      this.add('route:mom.this-route-throws', _emberRouting.Route.extend({
+        model: function () {
+          step(3, 'MomThisRouteThrows#model');
+          throw handledError;
+        }
+      }));
 
-    App.MomSallyRoute = _emberRouting.Route.extend({
-      model: function () {
-        step(1, 'MomSallyRoute#model');
+      assert.throws(function () {
+        _this21.visit('/grandma/mom/sally');
+      }, function (err) {
+        return err.msg === 'did it broke?';
+      }, 'it broke');
+    };
 
-        return _emberRuntime.RSVP.reject({
-          msg: 'did it broke?'
-        });
-      },
+    _class3.prototype['@test errors that are bubbled are thrown at a higher level if not handled'] = function testErrorsThatAreBubbledAreThrownAtAHigherLevelIfNotHandled(assert) {
+      var _this22 = this;
 
-      actions: {
-        error: function () {
-          step(2, 'MomSallyRoute#actions.error');
-          return true;
-        }
-      }
-    });
+      this.add('route:mom.sally', _emberRouting.Route.extend({
+        model: function () {
+          step(1, 'MomSallyRoute#model');
+          return _emberRuntime.RSVP.reject({
+            msg: 'did it broke?'
+          });
+        },
 
-    throws(function () {
-      bootApplication('/grandma/mom/sally');
-    }, function (err) {
-      return err.msg === 'did it broke?';
-    });
+        actions: {
+          error: function (err) {
+            step(2, 'MomSallyRoute#actions.error');
+            return true;
+          }
+        }
+      }));
 
-    step(3, 'App finished booting');
+      assert.throws(function () {
+        _this22.visit('/grandma/mom/sally');
+      }, function (err) {
+        return err.msg == "did it broke?";
+      }, 'Correct error was thrown');
+    };
 
-    equal((0, _emberViews.jQuery)('#app', '#qunit-fixture').text(), 'GRANDMA MOM ERROR: did it broke?', 'the more specifically-named mom error substate was entered over the other error route');
+    _class3.prototype['@test Handled errors that are thrown through rejection aren\'t swallowed'] = function (assert) {
+      var _this23 = this;
 
-    var appController = container.lookup('controller:application');
-    equal(appController.get('currentPath'), 'grandma.mom_error', 'Initial route fully loaded');
-  });
+      var handledError = void 0;
 
-  QUnit.test('Prioritized substate entry works with preserved-namespace nested routes', function () {
-    expect(2);
+      this.add('route:mom.sally', _emberRouting.Route.extend({
+        model: function () {
+          step(1, 'MomSallyRoute#model');
+          return _emberRuntime.RSVP.reject({
+            msg: 'did it broke?'
+          });
+        },
 
-    templates['foo/bar_loading'] = 'FOOBAR LOADING';
-    templates['foo/bar/index'] = 'YAY';
+        actions: {
+          error: function (err) {
+            step(2, 'MomSallyRoute#actions.error');
+            handledError = err;
+            this.transitionTo('mom.this-route-throws');
 
-    Router.map(function () {
-      this.route('foo', function () {
-        this.route('bar', { path: '/bar' }, function () {});
-      });
-    });
+            return false;
+          }
+        }
+      }));
 
-    App.ApplicationController = _emberRuntime.Controller.extend();
+      this.add('route:mom.this-route-throws', _emberRouting.Route.extend({
+        model: function () {
+          step(3, 'MomThisRouteThrows#model');
+          return _emberRuntime.RSVP.reject(handledError);
+        }
+      }));
 
-    var deferred = _emberRuntime.RSVP.defer();
-    App.FooBarRoute = _emberRouting.Route.extend({
-      model: function () {
-        return deferred.promise;
-      }
-    });
+      assert.throws(function () {
+        _this23.visit('/grandma/mom/sally');
+      }, function (err) {
+        return err.msg === 'did it broke?';
+      }, 'it broke');
+    };
 
-    bootApplication('/foo/bar');
+    _class3.prototype['@test Default error events move into nested route, prioritizing more specifically named error routes - NEW'] = function testDefaultErrorEventsMoveIntoNestedRoutePrioritizingMoreSpecificallyNamedErrorRoutesNEW(assert) {
+      var _this24 = this;
 
-    equal((0, _emberViews.jQuery)('#app', '#qunit-fixture').text(), 'FOOBAR LOADING', 'foo.bar_loading was entered (as opposed to something like foo/foo/bar_loading)');
+      this.addTemplate('grandma.error', 'ERROR: {{model.msg}}');
+      this.addTemplate('mom_error', 'MOM ERROR: {{model.msg}}');
 
-    (0, _emberMetal.run)(deferred, 'resolve');
+      this.add('route:mom.sally', _emberRouting.Route.extend({
+        model: function () {
+          step(1, 'MomSallyRoute#model');
+          return _emberRuntime.RSVP.reject({
+            msg: 'did it broke?'
+          });
+        },
 
-    equal((0, _emberViews.jQuery)('#app', '#qunit-fixture').text(), 'YAY');
-  });
+        actions: {
+          error: function () {
+            step(2, 'MomSallyRoute#actions.error');
+            return true;
+          }
+        }
+      }));
 
-  QUnit.test('Prioritized substate entry works with reset-namespace nested routes', function () {
-    expect(2);
+      return this.visit('/grandma/mom/sally').then(function () {
+        step(3, 'Application finished booting');
 
-    templates['bar_loading'] = 'BAR LOADING';
-    templates['bar/index'] = 'YAY';
+        assert.equal(_this24.$('#app').text(), 'GRANDMA MOM ERROR: did it broke?', 'the more specifically named mome error substate was entered over the other error route');
 
-    Router.map(function () {
-      this.route('foo', function () {
-        this.route('bar', { path: '/bar', resetNamespace: true }, function () {});
+        assert.equal(_this24.currentPath, 'grandma.mom_error', 'Initial route fully loaded');
       });
-    });
-
-    App.ApplicationController = _emberRuntime.Controller.extend();
+    };
 
-    var deferred = _emberRuntime.RSVP.defer();
-    App.BarRoute = _emberRouting.Route.extend({
-      model: function () {
-        return deferred.promise;
-      }
-    });
+    _class3.prototype['@test Slow promises waterfall on startup'] = function testSlowPromisesWaterfallOnStartup(assert) {
+      var _this25 = this;
 
-    bootApplication('/foo/bar');
+      var grandmaDeferred = _emberRuntime.RSVP.defer();
+      var sallyDeferred = _emberRuntime.RSVP.defer();
 
-    equal((0, _emberViews.jQuery)('#app', '#qunit-fixture').text(), 'BAR LOADING', 'foo.bar_loading was entered (as opposed to something like foo/foo/bar_loading)');
+      this.addTemplate('loading', 'LOADING');
+      this.addTemplate('mom', 'MOM {{outlet}}');
+      this.addTemplate('mom.loading', 'MOMLOADING');
+      this.addTemplate('mom.sally', 'SALLY');
 
-    (0, _emberMetal.run)(deferred, 'resolve');
+      this.add('route:grandma', _emberRouting.Route.extend({
+        model: function () {
+          step(1, 'GrandmaRoute#model');
+          return grandmaDeferred.promise;
+        }
+      }));
 
-    equal((0, _emberViews.jQuery)('#app', '#qunit-fixture').text(), 'YAY');
-  });
+      this.add('route:mom', _emberRouting.Route.extend({
+        model: function () {
+          step(2, 'MomRoute#model');
+          return {};
+        }
+      }));
 
-  QUnit.test('Prioritized loading substate entry works with preserved-namespace nested routes', function () {
-    expect(2);
+      this.add('route:mom.sally', _emberRouting.Route.extend({
+        model: function () {
+          step(3, 'SallyRoute#model');
+          return sallyDeferred.promise;
+        },
+        setupController: function () {
+          step(4, 'SallyRoute#setupController');
+        }
+      }));
 
-    templates['foo/bar_loading'] = 'FOOBAR LOADING';
-    templates['foo/bar'] = 'YAY';
+      var promise = this.visit('/grandma/mom/sally').then(function () {
+        text = _this25.$('#app').text();
 
-    Router.map(function () {
-      this.route('foo', function () {
-        this.route('bar');
+        assert.equal(text, 'GRANDMA MOM SALLY', 'Sally template displayed');
       });
-    });
+      var text = this.$('#app').text();
 
-    App.ApplicationController = _emberRuntime.Controller.extend();
+      assert.equal(text, 'LOADING', 'The loading template is nested in application template\'s outlet');
 
-    var deferred = _emberRuntime.RSVP.defer();
-    App.FooBarRoute = _emberRouting.Route.extend({
-      model: function () {
-        return deferred.promise;
-      }
-    });
+      this.runTask(function () {
+        return grandmaDeferred.resolve();
+      });
+      text = this.$('#app').text();
 
-    bootApplication('/foo/bar');
+      assert.equal(text, 'GRANDMA MOM MOMLOADING', 'Mom\'s child loading route is displayed due to sally\'s slow promise');
 
-    equal((0, _emberViews.jQuery)('#app', '#qunit-fixture').text(), 'FOOBAR LOADING', 'foo.bar_loading was entered (as opposed to something like foo/foo/bar_loading)');
+      sallyDeferred.resolve();
 
-    (0, _emberMetal.run)(deferred, 'resolve');
+      return promise;
+    };
 
-    equal((0, _emberViews.jQuery)('#app', '#qunit-fixture').text(), 'YAY');
-  });
+    _class3.prototype['@test Enter child loading state of pivot route'] = function testEnterChildLoadingStateOfPivotRoute(assert) {
+      var _this26 = this;
 
-  QUnit.test('Prioritized error substate entry works with preserved-namespace nested routes', function () {
-    expect(2);
+      var deferred = _emberRuntime.RSVP.defer();
+      this.addTemplate('grandma.loading', 'GMONEYLOADING');
 
-    templates['foo/bar_error'] = 'FOOBAR ERROR: {{model.msg}}';
-    templates['foo/bar'] = 'YAY';
+      this.add('route:mom.sally', _emberRouting.Route.extend({
+        setupController: function () {
+          step(1, 'SallyRoute#setupController');
+        }
+      }));
 
-    Router.map(function () {
-      this.route('foo', function () {
-        this.route('bar');
-      });
-    });
+      this.add('route:grandma.puppies', _emberRouting.Route.extend({
+        model: function () {
+          return deferred.promise;
+        }
+      }));
 
-    App.ApplicationController = _emberRuntime.Controller.extend();
+      return this.visit('/grandma/mom/sally').then(function () {
+        assert.equal(_this26.currentPath, 'grandma.mom.sally', 'Initial route fully loaded');
 
-    App.FooBarRoute = _emberRouting.Route.extend({
-      model: function () {
-        return _emberRuntime.RSVP.reject({
-          msg: 'did it broke?'
+        var promise = _this26.visit('/grandma/puppies').then(function () {
+          assert.equal(_this26.currentPath, 'grandma.puppies', 'Finished transition');
         });
-      }
-    });
 
-    throws(function () {
-      bootApplication('/foo/bar');
-    }, function (err) {
-      return err.msg === 'did it broke?';
-    });
+        assert.equal(_this26.currentPath, 'grandma.loading', 'in pivot route\'s child loading state');
+        deferred.resolve();
 
-    equal((0, _emberViews.jQuery)('#app', '#qunit-fixture').text(), 'FOOBAR ERROR: did it broke?', 'foo.bar_error was entered (as opposed to something like foo/foo/bar_error)');
-  });
-
-  QUnit.test('Prioritized loading substate entry works with auto-generated index routes', function () {
-    expect(2);
-
-    templates['foo/index_loading'] = 'FOO LOADING';
-    templates['foo/index'] = 'YAY';
-    templates['foo'] = '{{outlet}}';
-
-    Router.map(function () {
-      this.route('foo', function () {
-        this.route('bar');
+        return promise;
       });
-    });
+    };
 
-    App.ApplicationController = _emberRuntime.Controller.extend();
+    _class3.prototype['@test Error events that aren\'t bubbled don\'t throw application assertions'] = function (assert) {
+      this.add('route:mom.sally', _emberRouting.Route.extend({
+        model: function () {
+          step(1, 'MomSallyRoute#model');
+          return _emberRuntime.RSVP.reject({
+            msg: 'did it broke?'
+          });
+        },
 
-    var deferred = _emberRuntime.RSVP.defer();
-    App.FooIndexRoute = _emberRouting.Route.extend({
-      model: function () {
-        return deferred.promise;
-      }
-    });
-    App.FooRoute = _emberRouting.Route.extend({
-      model: function () {
-        return true;
-      }
-    });
+        actions: {
+          error: function (err) {
+            step(2, 'MomSallyRoute#actions.error');
+            assert.equal(err.msg, 'did it broke?', 'it didn\'t break');
+            return false;
+          }
+        }
+      }));
 
-    bootApplication('/foo');
+      return this.visit('/grandma/mom/sally');
+    };
 
-    equal((0, _emberViews.jQuery)('#app', '#qunit-fixture').text(), 'FOO LOADING', 'foo.index_loading was entered');
+    _class3.prototype['@test Handled errors that bubble can be handled at a higher level'] = function testHandledErrorsThatBubbleCanBeHandledAtAHigherLevel(assert) {
+      var handledError = void 0;
 
-    (0, _emberMetal.run)(deferred, 'resolve');
+      this.add('route:mom', _emberRouting.Route.extend({
+        actions: {
+          error: function (err) {
+            step(3, 'MomRoute#actions.error');
+            assert.equal(err, handledError, 'error handled and rebubbled is handleable at higher route');
+          }
+        }
+      }));
 
-    equal((0, _emberViews.jQuery)('#app', '#qunit-fixture').text(), 'YAY');
-  });
+      this.add('route:mom.sally', _emberRouting.Route.extend({
+        model: function () {
+          step(1, 'MomSallyRoute#model');
+          return _emberRuntime.RSVP.reject({
+            msg: 'did it broke?'
+          });
+        },
 
-  QUnit.test('Prioritized error substate entry works with auto-generated index routes', function () {
-    expect(2);
+        actions: {
+          error: function (err) {
+            step(2, 'MomSallyRoute#actions.error');
+            handledError = err;
 
-    templates['foo/index_error'] = 'FOO ERROR: {{model.msg}}';
-    templates['foo/index'] = 'YAY';
-    templates['foo'] = '{{outlet}}';
+            return true;
+          }
+        }
+      }));
 
-    Router.map(function () {
-      this.route('foo', function () {
-        this.route('bar');
-      });
-    });
+      return this.visit('/grandma/mom/sally');
+    };
 
-    App.ApplicationController = _emberRuntime.Controller.extend();
+    _class3.prototype['@test Setting a query param during a slow transition should work'] = function testSettingAQueryParamDuringASlowTransitionShouldWork(assert) {
+      var _this27 = this;
 
-    App.FooIndexRoute = _emberRouting.Route.extend({
-      model: function () {
-        return _emberRuntime.RSVP.reject({
-          msg: 'did it broke?'
-        });
-      }
-    });
-    App.FooRoute = _emberRouting.Route.extend({
-      model: function () {
-        return true;
-      }
-    });
+      var deferred = _emberRuntime.RSVP.defer();
+      this.addTemplate('memere.loading', 'MMONEYLOADING');
 
-    throws(function () {
-      return bootApplication('/foo');
-    }, function (err) {
-      return err.msg === 'did it broke?';
-    });
+      this.add('route:grandma', _emberRouting.Route.extend({
+        beforeModel: function () {
+          this.transitionTo('memere', 1);
+        }
+      }));
 
-    equal((0, _emberViews.jQuery)('#app', '#qunit-fixture').text(), 'FOO ERROR: did it broke?', 'foo.index_error was entered');
-  });
+      this.add('route:memere', _emberRouting.Route.extend({
+        queryParams: {
+          test: { defaultValue: 1 }
+        }
+      }));
 
-  QUnit.test('Rejected promises returned from ApplicationRoute transition into top-level application_error', function () {
-    expect(3);
+      this.add('route:memere.index', _emberRouting.Route.extend({
+        model: function () {
+          return deferred.promise;
+        }
+      }));
 
-    templates['application_error'] = '<p id="toplevel-error">TOPLEVEL ERROR: {{model.msg}}</p>';
+      var promise = this.visit('/grandma').then(function () {
+        assert.equal(_this27.currentPath, 'memere.index', 'Transition should be complete');
+      });
+      var memereController = this.getController('memere');
 
-    var reject = true;
-    App.ApplicationRoute = _emberRouting.Route.extend({
-      model: function () {
-        if (reject) {
-          return _emberRuntime.RSVP.reject({ msg: 'BAD NEWS BEARS' });
-        } else {
-          return {};
-        }
-      }
-    });
+      assert.equal(this.currentPath, 'memere.loading', 'Initial route should be loading');
 
-    throws(function () {
-      return bootApplication();
-    }, function (err) {
-      return err.msg === 'BAD NEWS BEARS';
-    });
+      memereController.set('test', 3);
 
-    equal((0, _emberViews.jQuery)('#toplevel-error', '#qunit-fixture').text(), 'TOPLEVEL ERROR: BAD NEWS BEARS');
+      assert.equal(this.currentPath, 'memere.loading', 'Initial route should still be loading');
 
-    reject = false;
-    (0, _emberMetal.run)(router, 'transitionTo', 'index');
+      assert.equal(memereController.get('test'), 3, 'Controller query param value should have changed');
+      deferred.resolve();
 
-    equal((0, _emberViews.jQuery)('#app', '#qunit-fixture').text(), 'INDEX');
-  });
+      return promise;
+    };
+
+    (0, _emberBabel.createClass)(_class3, [{
+      key: 'currentPath',
+      get: function () {
+        return this.getController('application').get('currentPath');
+      }
+    }]);
+    return _class3;
+  }(_internalTestHelpers.ApplicationTestCase));
 });
 QUnit.module('ESLint | ember/tests/routing/substates_test.js');
 QUnit.test('should pass ESLint', function(assert) {