diff --git a/bower.json b/bower.json
index 64890a08ff1..f646c98dea2 100644
--- a/bower.json
+++ b/bower.json
@@ -3,7 +3,7 @@
   "private": true,
   "dependencies": {
     "ember": "~1.9.0",
-    "jquery": "~1.11.0",
+    "jquery": "~1.10.x",
     "qunit": "~1.12.0",
     "qunit-phantom-runner": "jonkemp/qunit-phantomjs-runner#1.2.0"
   },
diff --git a/package.json b/package.json
index 39146b327a3..04397ebfce2 100644
--- a/package.json
+++ b/package.json
@@ -28,7 +28,7 @@
     "chalk": "~0.4.0",
     "defeatureify": "~0.1.4",
     "ejs": "^1.0.0",
-    "ember-cli": "0.0.46",
+    "ember-cli": "~0.1.11",
     "ember-publisher": "0.0.6",
     "emberjs-build": "file:../emberjs-build",
     "git-repo-version": "0.0.2",
diff --git a/packages/activemodel-adapter/tests/integration/active_model_adapter_test.js b/packages/activemodel-adapter/tests/integration/active_model_adapter_test.js
index c5eccb1d248..b98df9b6e97 100644
--- a/packages/activemodel-adapter/tests/integration/active_model_adapter_test.js
+++ b/packages/activemodel-adapter/tests/integration/active_model_adapter_test.js
@@ -1,5 +1,3 @@
-import { setupStore } from "ember-data/tests/helpers/integration";
-
 var env, store, adapter, SuperUser;
 var passedUrl, passedVerb, passedHash;
 module("integration/active_model_adapter - AMS Adapter", {
diff --git a/packages/activemodel-adapter/tests/integration/active_model_serializer_test.js b/packages/activemodel-adapter/tests/integration/active_model_serializer_test.js
index 7e06fa0e35f..e5f2a3b54bb 100644
--- a/packages/activemodel-adapter/tests/integration/active_model_serializer_test.js
+++ b/packages/activemodel-adapter/tests/integration/active_model_serializer_test.js
@@ -1,5 +1,3 @@
-import { setupStore } from "ember-data/tests/helpers/integration";
-
 var get = Ember.get;
 var HomePlanet, league, SuperVillain, EvilMinion, YellowMinion, DoomsdayDevice, MediocreVillain, env;
 var run = Ember.run;
diff --git a/packages/activemodel-adapter/tests/unit/adapter/path_for_type_test.js b/packages/activemodel-adapter/tests/unit/adapter/path_for_type_test.js
index 4ec1650188f..6e533376cae 100644
--- a/packages/activemodel-adapter/tests/unit/adapter/path_for_type_test.js
+++ b/packages/activemodel-adapter/tests/unit/adapter/path_for_type_test.js
@@ -1,5 +1,3 @@
-import { setupStore } from "ember-data/tests/helpers/integration";
-
 var env, adapter;
 module("unit/adapter/path_for_type - DS.ActiveModelAdapter#pathForType", {
   setup: function() {
diff --git a/packages/ember-data/tests/helpers/assertions.js b/packages/ember-data/tests/helpers/assertions.js
deleted file mode 100644
index b3c122e87a9..00000000000
--- a/packages/ember-data/tests/helpers/assertions.js
+++ /dev/null
@@ -1,15 +0,0 @@
-import AssertExpectation from "ember-data/tests/support/assert-expectation";
-
-// Looks for an exception raised within the fn.
-//
-// expectAssertion(function(){
-//   Ember.assert("Homie don't roll like that");
-// } /* , optionalMessageStringOrRegex */);
-//
-function expectAssertion(fn, message){
-  (new AssertExpectation(message)).assert(fn);
-}
-
-export {
-  expectAssertion
-};
diff --git a/packages/ember-data/tests/helpers/integration.js b/packages/ember-data/tests/helpers/integration.js
deleted file mode 100644
index 727a3bf295e..00000000000
--- a/packages/ember-data/tests/helpers/integration.js
+++ /dev/null
@@ -1,59 +0,0 @@
-function setupStore(options) {
-  var env = {};
-  options = options || {};
-
-  var container = env.container = new Ember.Container();
-
-  // We have to currently work around some container refactors until
-  // https://github.com/emberjs/ember.js/pull/9981 is on the stable release
-  // of ember
-  if (typeof Ember.Registry !== 'undefined') {
-    var registry = new Ember.Registry();
-    container._registry = registry;
-    env.registry = registry;
-  }
-  env.replaceContainerNormalize = function replaceContainerNormalize(fn) {
-    if (env.registry) {
-      env.registry.normalize = fn;
-    } else {
-      env.container.normalize = fn;
-    }
-  };
-
-  var adapter = env.adapter = (options.adapter || DS.Adapter);
-  delete options.adapter;
-
-  for (var prop in options) {
-    container.register('model:' + prop, options[prop]);
-  }
-
-  container.register('store:main', DS.Store.extend({
-    adapter: adapter
-  }));
-
-  container.register('serializer:-default', DS.JSONSerializer);
-  container.register('serializer:-rest', DS.RESTSerializer);
-  container.register('adapter:-rest', DS.RESTAdapter);
-  container.register('transform:boolean', DS.BooleanTransform);
-  container.register('transform:date', DS.DateTransform);
-  container.register('transform:number', DS.NumberTransform);
-  container.register('transform:string', DS.StringTransform);
-
-  container.injection('serializer', 'store', 'store:main');
-
-  env.serializer = container.lookup('serializer:-default');
-  env.restSerializer = container.lookup('serializer:-rest');
-  env.store = container.lookup('store:main');
-  env.adapter = env.store.get('defaultAdapter');
-
-  return env;
-}
-
-function createStore(options) {
-  return setupStore(options).store;
-}
-
-export {
-  setupStore,
-  createStore
-};
diff --git a/packages/ember-data/tests/integration/adapter/find_all_test.js b/packages/ember-data/tests/integration/adapter/find_all_test.js
index 4b9fa528ad2..695fb5638b6 100644
--- a/packages/ember-data/tests/integration/adapter/find_all_test.js
+++ b/packages/ember-data/tests/integration/adapter/find_all_test.js
@@ -1,5 +1,3 @@
-import { createStore } from "ember-data/tests/helpers/integration";
-
 var get = Ember.get;
 var Person, store, allRecords;
 var run = Ember.run;
diff --git a/packages/ember-data/tests/integration/adapter/find_test.js b/packages/ember-data/tests/integration/adapter/find_test.js
index 6145108a52e..57eaec5f9ed 100644
--- a/packages/ember-data/tests/integration/adapter/find_test.js
+++ b/packages/ember-data/tests/integration/adapter/find_test.js
@@ -1,5 +1,3 @@
-import { createStore } from "ember-data/tests/helpers/integration";
-
 var Person, store;
 var run = Ember.run;
 
diff --git a/packages/ember-data/tests/unit/adapters/rest_adapter/path_for_type_test.js b/packages/ember-data/tests/unit/adapters/rest_adapter/path_for_type_test.js
index a430739933c..092f12738c4 100644
--- a/packages/ember-data/tests/unit/adapters/rest_adapter/path_for_type_test.js
+++ b/packages/ember-data/tests/unit/adapters/rest_adapter/path_for_type_test.js
@@ -1,5 +1,3 @@
-import { setupStore } from "ember-data/tests/helpers/integration";
-
 var env, adapter;
 module("unit/adapters/rest_adapter/path_for_type - DS.RESTAdapter#pathForType", {
   setup: function() {
diff --git a/server/index.js b/server/index.js
deleted file mode 100644
index 62fe83ad1b8..00000000000
--- a/server/index.js
+++ /dev/null
@@ -1,5 +0,0 @@
-module.exports = function(app) {
-  app.get('/', function(req, res){
-    res.redirect('/tests/index.html');
-  });
-}
diff --git a/tests/ember-data-setup.js b/tests/ember-data-setup.js
deleted file mode 100644
index 7f57db55d0a..00000000000
--- a/tests/ember-data-setup.js
+++ /dev/null
@@ -1,29 +0,0 @@
-/* globals syncForTest */
-
-;(function(){
-
-  Ember.RSVP.configure('onerror', function(reason) {
-    // only print error messages if they're exceptions;
-    // otherwise, let a future turn of the event loop
-    // handle the error.
-    if (reason && reason instanceof Error) {
-      Ember.Logger.log(reason, reason.stack);
-      throw reason;
-    }
-  });
-
-  var transforms = {
-    'boolean': DS.BooleanTransform.create(),
-    'date': DS.DateTransform.create(),
-    'number': DS.NumberTransform.create(),
-    'string': DS.StringTransform.create()
-  };
-
-  // Prevent all tests involving serialization to require a container
-  DS.JSONSerializer.reopen({
-    transformFor: function(attributeType) {
-      return this._super(attributeType, true) || transforms[attributeType];
-    }
-  });
-
-})();
diff --git a/tests/ember_configuration.js b/tests/ember_configuration.js
deleted file mode 100644
index dccd15084f4..00000000000
--- a/tests/ember_configuration.js
+++ /dev/null
@@ -1,98 +0,0 @@
-/* globals ENV, QUnit */
-
-(function (){
-  window.Ember = window.Ember || {};
-
-  Ember.config = {};
-  Ember.testing = true;
-  Ember.LOG_VERSION = false;
-
-  window.ENV = { TESTING: true, LOG_VERSION: false };
-
-  var extendPrototypes = QUnit.urlParams.extendprototypes;
-  ENV['EXTEND_PROTOTYPES'] = !!extendPrototypes;
-
-  window.async = function(callback, timeout) {
-    var timer;
-    stop();
-
-    timer = setTimeout(function() {
-      start();
-      ok(false, "Timeout was reached");
-    }, timeout || 200);
-
-    return function() {
-      clearTimeout(timer);
-
-      start();
-
-      var args = arguments;
-      return Ember.run(function() {
-        return callback.apply(this, args);
-      });
-    };
-  };
-
-  window.asyncEqual = function(a, b, message) {
-    Ember.RSVP.all([ Ember.RSVP.resolve(a), Ember.RSVP.resolve(b) ]).then(async(function(array) {
-      /*globals QUnit*/
-      QUnit.push(array[0] === array[1], array[0], array[1], message);
-    }));
-  };
-
-  window.invokeAsync = function(callback, timeout) {
-    timeout = timeout || 1;
-
-    setTimeout(async(callback, timeout+100), timeout);
-  };
-
-  QUnit.begin(function(){
-    Ember.RSVP.configure('onerror', function(reason) {
-      // only print error messages if they're exceptions;
-      // otherwise, let a future turn of the event loop
-      // handle the error.
-      if (reason && reason instanceof Error) {
-        Ember.Logger.log(reason, reason.stack);
-        throw reason;
-      }
-    });
-  });
-
-  // Generate the jQuery expando on window ahead of time
-  // to make the QUnit global check run clean
-  jQuery(window).data('testing', true);
-
-  window.warns = function(callback, regex){
-    var warnWasCalled = false;
-    var oldWarn = Ember.warn;
-    Ember.warn = function Ember_assertWarning(message, test){
-      if (!test) {
-        warnWasCalled = true;
-        if (regex) {
-          ok(regex.test(message), 'the call to Ember.warn got an unexpected message: ' + message);
-        }
-      }
-    };
-    try {
-      callback();
-      ok(warnWasCalled, 'expected Ember.warn to warn, but was not called');
-    } finally {
-      Ember.warn = oldWarn;
-    }
-  };
-
-  window.noWarns = function(callback){
-    var oldWarn = Ember.warn;
-    var warnWasCalled = false;
-    Ember.warn = function Ember_noWarn(message, test){
-      warnWasCalled = !test;
-    };
-    try {
-      callback();
-    } finally {
-      ok(!warnWasCalled, 'Ember.warn warned when it should not have warned');
-      Ember.warn = oldWarn;
-    }
-  };
-
-})();
diff --git a/tests/index.html b/tests/index.html
index 5bca85214c6..ae087aaf36c 100644
--- a/tests/index.html
+++ b/tests/index.html
@@ -79,6 +79,7 @@
         var setupQUnit = window.Ember.__loader.require('ember-dev/test-helper/setup-qunit')['default'];
         var testHelpers = new EmberDevTestHelperAssert(window.Ember, EmberDev.runningProdBuild);
         setupQUnit(testHelpers, QUnit);
+        window.module = QUnit.module;
 
         // Tests should time out after 5 seconds
         QUnit.config.testTimeout = 5000;
@@ -112,6 +113,559 @@
         }
       }
     </script>
+
+    <script>
+      (function() {
+        window.EmberDev = window.EmberDev || {};
+
+        EmberDev.afterEach = function() {
+            if (Ember && Ember.View) {
+              var viewIds = [], id;
+              for (id in Ember.View.views) {
+                if (Ember.View.views[id] != null) {
+                  viewIds.push(id);
+                }
+              }
+
+              if (viewIds.length > 0) {
+                deepEqual(viewIds, [], "Ember.View.views should be empty");
+                Ember.View.views = [];
+              }
+            }
+
+            if (Ember && Ember.TEMPLATES) {
+              var templateNames = [], name;
+              for (name in Ember.TEMPLATES) {
+                if (Ember.TEMPLATES[name] != null) {
+                  templateNames.push(name);
+                }
+              }
+
+              if (templateNames.length > 0) {
+                deepEqual(templateNames, [], "Ember.TEMPLATES should be empty");
+                Ember.TEMPLATES = {};
+              }
+            }
+          };
+
+        window.globalFailedTests  = [];
+            window.globalTestResults = null;
+            window.lastAssertionTime = new Date().getTime();
+
+            var currentTest, assertCount;
+
+            QUnit.testStart(function(data) {
+              // Reset the assertion count
+              assertCount = 0;
+
+              currentTest = {
+                name: data.name,
+                failedAssertions: [],
+                total: 0,
+                passed: 0,
+                failed: 0,
+                start: new Date(),
+                time: 0
+              };
+
+            })
+
+            QUnit.log(function(data) {
+              assertCount++;
+              lastAssertionTime = new Date().getTime();
+
+              // Ignore passing assertions
+              if (!data.result) {
+                currentTest.failedAssertions.push(data);
+              }
+            });
+
+            QUnit.testDone(function(data) {
+              currentTest.time = (new Date()).getTime() - currentTest.start.getTime();  // ms
+              currentTest.total = data.total;
+              currentTest.passed = data.passed;
+              currentTest.failed = data.failed;
+
+              if (currentTest.failed > 0)
+                window.globalFailedTests.push(currentTest)
+
+              currentTest = null;
+            });
+
+            QUnit.done(function( details ) {
+              details.failedTests = globalFailedTests;
+
+              window.globalTestResults = details;
+            });
+
+        // hack qunit to not suck for Ember objects
+        var originalTypeof = QUnit.jsDump.typeOf;
+
+        QUnit.jsDump.typeOf = function(obj) {
+          if (Ember && Ember.Object && Ember.Object.detectInstance(obj)) {
+            return "emberObject";
+          }
+
+          return originalTypeof.call(this, obj);
+        };
+
+        // raises is deprecated, but we likely want to keep it around for our es3
+        // test runs.
+        // taken from emberjs/ember-dev here: http://git.io/sQhl3A
+        QUnit.raises = QUnit['throws'];
+        window.raises = QUnit['throws'];
+
+        QUnit.jsDump.parsers.emberObject = function(obj) {
+          return obj.toString();
+        };
+
+        var originalModule = module;
+        module = function(name, origOpts) {
+          var opts = {};
+          if (origOpts && origOpts.setup) { opts.setup = origOpts.setup; }
+          opts.teardown = function() {
+            if (origOpts && origOpts.teardown) { origOpts.teardown(); }
+
+            if (Ember && Ember.run) {
+              if (Ember.run.currentRunLoop) {
+                ok(false, "Should not be in a run loop at end of test");
+                while (Ember.run.currentRunLoop) {
+                  Ember.run.end();
+                }
+              }
+              if (Ember.run.hasScheduledTimers()) {
+                // Use `ok` so we get full description.
+                // Gate inside of `if` so that we don't mess up `expects` counts
+                ok(false, "Ember run should not have scheduled timers at end of test");
+                Ember.run.cancelTimers();
+              }
+            }
+
+            if (EmberDev.afterEach) {
+              EmberDev.afterEach();
+            }
+          };
+          return originalModule(name, opts);
+        };
+
+        // Tests should time out after 5 seconds
+        QUnit.config.testTimeout = 5000;
+
+        // Handle JSHint
+        QUnit.config.urlConfig.push('nojshint');
+
+        EmberDev.jsHint = !QUnit.urlParams.nojshint;
+
+        EmberDev.jsHintReporter = function (file, errors) {
+          if (!errors) { return ''; }
+
+          var len = errors.length,
+              str = '',
+              error, idx;
+
+          if (len === 0) { return ''; }
+
+          for (idx=0; idx<len; idx++) {
+            error = errors[idx];
+            str += file  + ': line ' + error.line + ', col ' +
+                error.character + ', ' + error.reason + '\n';
+          }
+
+          return str + "\n" + len + ' error' + ((len === 1) ? '' : 's');
+        };
+
+        var o_create = Object.create || (function(){
+          function F(){}
+
+          return function(o) {
+            if (arguments.length !== 1) {
+              throw new Error('Object.create implementation only accepts one parameter.');
+            }
+            F.prototype = o;
+            return new F();
+          };
+        }());
+
+        // A light class for stubbing
+        //
+        function MethodCallExpectation(target, property){
+          this.target = target;
+          this.property = property;
+        };
+
+        MethodCallExpectation.prototype = {
+          handleCall: function(){
+            this.sawCall = true;
+            return this.originalMethod.apply(this.target, arguments);
+          },
+          stubMethod: function(fn){
+            var context = this;
+            this.originalMethod = this.target[this.property];
+            this.target[this.property] = function(){
+              return context.handleCall.apply(context, arguments);
+            };
+          },
+          restoreMethod: function(){
+            this.target[this.property] = this.originalMethod;
+          },
+          runWithStub: function(fn){
+            try {
+              this.stubMethod();
+              fn();
+            } finally {
+              this.restoreMethod();
+            }
+          },
+          assert: function(fn) {
+            this.runWithStub();
+            ok(this.sawCall, "Expected "+this.property+" to be called.");
+          }
+        };
+
+        function AssertExpectation(message){
+          MethodCallExpectation.call(this, Ember, 'assert');
+          this.expectedMessage = message;
+        };
+        AssertExpectation.Error = function(){};
+        AssertExpectation.prototype = o_create(MethodCallExpectation.prototype);
+        AssertExpectation.prototype.handleCall = function(message, test){
+          this.sawCall = true;
+          if (test) return; // Only get message for failures
+          this.actualMessage = message;
+          // Halt execution
+          throw new AssertExpectation.Error();
+        };
+        AssertExpectation.prototype.assert = function(fn){
+          try {
+            this.runWithStub(fn);
+          } catch (e) {
+            if (!(e instanceof AssertExpectation.Error))
+              throw e;
+          }
+
+          // Run assertions in an order that is useful when debugging a test failure.
+          //
+          if (!this.sawCall) {
+            ok(false, "Expected Ember.assert to be called (Not called with any value).");
+          } else if (!this.actualMessage) {
+            ok(false, 'Expected a failing Ember.assert (Ember.assert called, but without a failing test).');
+          } else {
+            if (this.expectedMessage) {
+              if (this.expectedMessage instanceof RegExp) {
+                ok(this.expectedMessage.test(this.actualMessage), "Expected failing Ember.assert: '" + this.expectedMessage + "', but got '" + this.actualMessage + "'.");
+              } else {
+                equal(this.actualMessage, this.expectedMessage, "Expected failing Ember.assert: '" + this.expectedMessage + "', but got '" + this.actualMessage + "'.");
+              }
+            } else {
+              // Positive assertion that assert was called
+              ok(true, 'Expected a failing Ember.assert.');
+            }
+          }
+        };
+
+        // Looks for an exception raised within the fn.
+        //
+        // expectAssertion(function(){
+        //   Ember.assert("Homie don't roll like that");
+        // } /* , optionalMessageStringOrRegex */);
+        //
+        window.expectAssertion = function expectAssertion(fn, message){
+          (new AssertExpectation(message)).assert(fn);
+        };
+
+        EmberDev.deprecations = {
+          NONE: 99, // 99 problems and a deprecation ain't one
+          expecteds: null,
+          actuals: null,
+          stubEmber: function(){
+            if (!EmberDev.deprecations.originalEmberDeprecate && Ember.deprecate !== EmberDev.deprecations.originalEmberDeprecate) {
+              EmberDev.deprecations.originalEmberDeprecate = Ember.deprecate;
+            }
+            Ember.deprecate = function(msg, test) {
+              EmberDev.deprecations.actuals = EmberDev.deprecations.actuals || [];
+              EmberDev.deprecations.actuals.push([msg, test]);
+            };
+          },
+          restoreEmber: function(){
+            Ember.deprecate = EmberDev.deprecations.originalEmberDeprecate;
+          }
+        };
+
+        // Expects no deprecation to happen from the time of calling until
+        // the end of the test.
+        //
+        // expectNoDeprecation(/* optionalStringOrRegex */);
+        // Ember.deprecate("Old And Busted");
+        //
+        window.expectNoDeprecation = function(message) {
+          if (typeof EmberDev.deprecations.expecteds === 'array') {
+            throw("No deprecation was expected after expectDeprecation was called!");
+          }
+          EmberDev.deprecations.stubEmber();
+          EmberDev.deprecations.expecteds = EmberDev.deprecations.NONE;
+        };
+
+        // Expect a deprecation to happen within a function, or if no function
+        // is pass, from the time of calling until the end of the test. Can be called
+        // multiple times to assert deprecations with different specific messages
+        // were fired.
+        //
+        // expectDeprecation(function(){
+        //   Ember.deprecate("Old And Busted");
+        // }, /* optionalStringOrRegex */);
+        //
+        // expectDeprecation(/* optionalStringOrRegex */);
+        // Ember.deprecate("Old And Busted");
+        //
+        window.expectDeprecation = function(fn, message) {
+          if (EmberDev.deprecations.expecteds === EmberDev.deprecations.NONE) {
+            throw("A deprecation was expected after expectNoDeprecation was called!");
+          }
+          EmberDev.deprecations.stubEmber();
+          EmberDev.deprecations.expecteds = EmberDev.deprecations.expecteds || [];
+          if (fn && typeof fn !== 'function') {
+            // fn is a message
+            EmberDev.deprecations.expecteds.push(fn);
+          } else {
+            EmberDev.deprecations.expecteds.push(message || /.*/);
+            if (fn) {
+              fn();
+              window.assertDeprecation();
+            }
+          }
+        };
+
+        // Forces an assert the deprecations occurred, and resets the globals
+        // storing asserts for the next run.
+        //
+        // expectNoDeprecation(/Old/);
+        // setTimeout(function(){
+        //   Ember.deprecate("Old And Busted");
+        //   assertDeprecation();
+        // });
+        //
+        // assertDeprecation is called after each test run to catch any expectations
+        // without explicit asserts.
+        //
+        window.assertDeprecation = function() {
+          var expecteds = EmberDev.deprecations.expecteds,
+              actuals   = EmberDev.deprecations.actuals || [];
+          if (!expecteds) {
+            EmberDev.deprecations.actuals = null;
+            return;
+          }
+
+          EmberDev.deprecations.restoreEmber();
+          EmberDev.deprecations.actuals = null;
+          EmberDev.deprecations.expecteds = null;
+
+          if (expecteds === EmberDev.deprecations.NONE) {
+            var actualMessages = [];
+            for (var actual in actuals) {
+              actualMessages.push(actual[0]);
+            }
+            ok(actuals.length === 0, "Expected no deprecation call, got: "+actualMessages.join(', '));
+          } else {
+            for (var o=0;o < expecteds.length; o++) {
+              var expected = expecteds[o], match;
+              for (var i=0;i < actuals.length; i++) {
+                var actual = actuals[i];
+                if (!actual[1]) {
+                  if (expected instanceof RegExp) {
+                    if (expected.test(actual[0])) {
+                      match = actual;
+                      break;
+                    }
+                  } else {
+                    if (expected === actual[0]) {
+                      match = actual;
+                      break;
+                    }
+                  }
+                }
+              }
+
+              if (!actual)
+                ok(false, "Recieved no deprecate calls at all, expecting: "+expected);
+              else if (match && !match[1])
+                ok(true, "Recieved failing deprecation with message: "+match[0]);
+              else if (match && match[1])
+                ok(false, "Expected failing deprecation, got succeeding with message: "+match[0]);
+              else if (actual[1])
+                ok(false, "Did not receive failing deprecation matching '"+expected+"', last was success with '"+actual[0]+"'");
+              else if (!actual[1])
+                ok(false, "Did not receive failing deprecation matching '"+expected+"', last was failure with '"+actual[0]+"'");
+            }
+          }
+        };
+      })();
+    </script>
+    <script>
+      /* globals ENV, QUnit */
+
+      (function (){
+        window.Ember = window.Ember || {};
+
+        Ember.config = {};
+        Ember.testing = true;
+        Ember.LOG_VERSION = false;
+
+        window.ENV = { TESTING: true, LOG_VERSION: false };
+
+        var extendPrototypes = QUnit.urlParams.extendprototypes;
+        ENV['EXTEND_PROTOTYPES'] = !!extendPrototypes;
+
+        window.async = function(callback, timeout) {
+          var timer;
+          stop();
+
+          timer = setTimeout(function() {
+            start();
+            ok(false, "Timeout was reached");
+          }, timeout || 200);
+
+          return function() {
+            clearTimeout(timer);
+
+            start();
+
+            var args = arguments;
+            return Ember.run(function() {
+              return callback.apply(this, args);
+            });
+          };
+        };
+
+        window.asyncEqual = function(a, b, message) {
+          Ember.RSVP.all([ Ember.RSVP.resolve(a), Ember.RSVP.resolve(b) ]).then(async(function(array) {
+            /*globals QUnit*/
+            QUnit.push(array[0] === array[1], array[0], array[1], message);
+          }));
+        };
+
+        window.invokeAsync = function(callback, timeout) {
+          timeout = timeout || 1;
+
+          setTimeout(async(callback, timeout+100), timeout);
+        };
+
+        window.setupStore = function(options) {
+          var env = {};
+          options = options || {};
+
+          var container = env.container = new Ember.Container();
+
+          // We have to currently work around some container refactors until
+          // https://github.com/emberjs/ember.js/pull/9981 is on the stable release
+          // of ember
+          if (typeof Ember.Registry !== 'undefined') {
+            var registry = new Ember.Registry();
+            container._registry = registry;
+            env.registry = registry;
+          }
+          env.replaceContainerNormalize = function replaceContainerNormalize(fn) {
+            if (env.registry) {
+              env.registry.normalize = fn;
+            } else {
+              env.container.normalize = fn;
+            }
+          }
+
+          var adapter = env.adapter = (options.adapter || DS.Adapter);
+          delete options.adapter;
+
+          for (var prop in options) {
+            container.register('model:' + prop, options[prop]);
+          }
+
+          container.register('store:main', DS.Store.extend({
+            adapter: adapter
+          }));
+
+          container.register('serializer:-default', DS.JSONSerializer);
+          container.register('serializer:-rest', DS.RESTSerializer);
+          container.register('adapter:-rest', DS.RESTAdapter);
+
+          container.injection('serializer', 'store', 'store:main');
+
+          env.serializer = container.lookup('serializer:-default');
+          env.restSerializer = container.lookup('serializer:-rest');
+          env.store = container.lookup('store:main');
+          env.adapter = env.store.get('defaultAdapter');
+
+          return env;
+        };
+
+        window.createStore = function(options) {
+          return setupStore(options).store;
+        };
+
+        QUnit.begin(function(){
+          Ember.RSVP.configure('onerror', function(reason) {
+            // only print error messages if they're exceptions;
+            // otherwise, let a future turn of the event loop
+            // handle the error.
+            if (reason && reason instanceof Error) {
+              Ember.Logger.log(reason, reason.stack);
+              throw reason;
+            }
+          });
+
+          var transforms = {
+            'boolean': DS.BooleanTransform.create(),
+            'date': DS.DateTransform.create(),
+            'number': DS.NumberTransform.create(),
+            'string': DS.StringTransform.create()
+          };
+
+          // Prevent all tests involving serialization to require a container
+          DS.JSONSerializer.reopen({
+            transformFor: function(attributeType) {
+              return this._super(attributeType, true) || transforms[attributeType];
+            }
+          });
+
+        });
+
+        // Generate the jQuery expando on window ahead of time
+        // to make the QUnit global check run clean
+        jQuery(window).data('testing', true);
+
+        window.warns = function(callback, regex){
+          var warnWasCalled = false;
+          var oldWarn = Ember.warn;
+          Ember.warn = function Ember_assertWarning(message, test){
+            if (!test) {
+              warnWasCalled = true;
+              if (regex) {
+                ok(regex.test(message), 'the call to Ember.warn got an unexpected message: ' + message);
+              }
+            }
+          };
+          try {
+            callback();
+            ok(warnWasCalled, 'expected Ember.warn to warn, but was not called');
+          } finally {
+            Ember.warn = oldWarn;
+          }
+        };
+
+        window.noWarns = function(callback){
+          var oldWarn = Ember.warn;
+          var warnWasCalled = false;
+          Ember.warn = function Ember_noWarn(message, test){
+            warnWasCalled = !test;
+          };
+          try {
+            callback();
+          } finally {
+            ok(!warnWasCalled, 'Ember.warn warned when it should not have warned');
+            Ember.warn = oldWarn;
+          }
+        };
+
+      })();
+    </script>
   </head>
 <body>
   <div id="qunit"></div>
diff --git a/tests/qunit_configuration.js b/tests/qunit_configuration.js
deleted file mode 100644
index 2fc9648ce36..00000000000
--- a/tests/qunit_configuration.js
+++ /dev/null
@@ -1,286 +0,0 @@
-(function() {
-  window.EmberDev = window.EmberDev || {};
-
-  EmberDev.afterEach = function() {
-      if (Ember && Ember.View) {
-        var viewIds = [], id;
-        for (id in Ember.View.views) {
-          if (Ember.View.views[id] != null) {
-            viewIds.push(id);
-          }
-        }
-
-        if (viewIds.length > 0) {
-          deepEqual(viewIds, [], "Ember.View.views should be empty");
-          Ember.View.views = [];
-        }
-      }
-
-      if (Ember && Ember.TEMPLATES) {
-        var templateNames = [], name;
-        for (name in Ember.TEMPLATES) {
-          if (Ember.TEMPLATES[name] != null) {
-            templateNames.push(name);
-          }
-        }
-
-        if (templateNames.length > 0) {
-          deepEqual(templateNames, [], "Ember.TEMPLATES should be empty");
-          Ember.TEMPLATES = {};
-        }
-      }
-    };
-
-   window.globalFailedTests  = [];
-      window.globalTestResults = null;
-      window.lastAssertionTime = new Date().getTime();
-
-      var currentTest, assertCount;
-
-      QUnit.testStart(function(data) {
-        // Reset the assertion count
-        assertCount = 0;
-
-        currentTest = {
-          name: data.name,
-          failedAssertions: [],
-          total: 0,
-          passed: 0,
-          failed: 0,
-          start: new Date(),
-          time: 0
-        };
-
-      })
-
-      QUnit.log(function(data) {
-        assertCount++;
-        lastAssertionTime = new Date().getTime();
-
-        // Ignore passing assertions
-        if (!data.result) {
-          currentTest.failedAssertions.push(data);
-        }
-      });
-
-      QUnit.testDone(function(data) {
-        currentTest.time = (new Date()).getTime() - currentTest.start.getTime();  // ms
-        currentTest.total = data.total;
-        currentTest.passed = data.passed;
-        currentTest.failed = data.failed;
-
-        if (currentTest.failed > 0)
-          window.globalFailedTests.push(currentTest)
-
-        currentTest = null;
-      });
-
-      QUnit.done(function( details ) {
-        details.failedTests = globalFailedTests;
-
-        window.globalTestResults = details;
-      });
-
-  // hack qunit to not suck for Ember objects
-  var originalTypeof = QUnit.jsDump.typeOf;
-
-  QUnit.jsDump.typeOf = function(obj) {
-    if (Ember && Ember.Object && Ember.Object.detectInstance(obj)) {
-      return "emberObject";
-    }
-
-    return originalTypeof.call(this, obj);
-  };
-
-  // raises is deprecated, but we likely want to keep it around for our es3
-  // test runs.
-  // taken from emberjs/ember-dev here: http://git.io/sQhl3A
-  QUnit.raises = QUnit['throws'];
-  window.raises = QUnit['throws'];
-
-  QUnit.jsDump.parsers.emberObject = function(obj) {
-    return obj.toString();
-  };
-
-  var originalModule = module;
-  module = function(name, origOpts) {
-    var opts = {};
-    if (origOpts && origOpts.setup) { opts.setup = origOpts.setup; }
-    opts.teardown = function() {
-      if (origOpts && origOpts.teardown) { origOpts.teardown(); }
-
-      if (Ember && Ember.run) {
-        if (Ember.run.currentRunLoop) {
-          ok(false, "Should not be in a run loop at end of test");
-          while (Ember.run.currentRunLoop) {
-            Ember.run.end();
-          }
-        }
-        if (Ember.run.hasScheduledTimers()) {
-          // Use `ok` so we get full description.
-          // Gate inside of `if` so that we don't mess up `expects` counts
-          ok(false, "Ember run should not have scheduled timers at end of test");
-          Ember.run.cancelTimers();
-        }
-      }
-
-      if (EmberDev.afterEach) {
-        EmberDev.afterEach();
-      }
-    };
-    return originalModule(name, opts);
-  };
-
-  // Tests should time out after 5 seconds
-  QUnit.config.testTimeout = 5000;
-
-  // Handle JSHint
-  QUnit.config.urlConfig.push('nojshint');
-
-  EmberDev.jsHint = !QUnit.urlParams.nojshint;
-
-  EmberDev.jsHintReporter = function (file, errors) {
-    if (!errors) { return ''; }
-
-    var len = errors.length,
-        str = '',
-        error, idx;
-
-    if (len === 0) { return ''; }
-
-    for (idx=0; idx<len; idx++) {
-      error = errors[idx];
-      str += file  + ': line ' + error.line + ', col ' +
-          error.character + ', ' + error.reason + '\n';
-    }
-
-    return str + "\n" + len + ' error' + ((len === 1) ? '' : 's');
-  };
-
-
-  EmberDev.deprecations = {
-    NONE: 99, // 99 problems and a deprecation ain't one
-    expecteds: null,
-    actuals: null,
-    stubEmber: function(){
-      if (!EmberDev.deprecations.originalEmberDeprecate && Ember.deprecate !== EmberDev.deprecations.originalEmberDeprecate) {
-        EmberDev.deprecations.originalEmberDeprecate = Ember.deprecate;
-      }
-      Ember.deprecate = function(msg, test) {
-        EmberDev.deprecations.actuals = EmberDev.deprecations.actuals || [];
-        EmberDev.deprecations.actuals.push([msg, test]);
-      };
-    },
-    restoreEmber: function(){
-      Ember.deprecate = EmberDev.deprecations.originalEmberDeprecate;
-    }
-  };
-
-  // Expects no deprecation to happen from the time of calling until
-  // the end of the test.
-  //
-  // expectNoDeprecation(/* optionalStringOrRegex */);
-  // Ember.deprecate("Old And Busted");
-  //
-  window.expectNoDeprecation = function(message) {
-    if (typeof EmberDev.deprecations.expecteds === 'array') {
-      throw("No deprecation was expected after expectDeprecation was called!");
-    }
-    EmberDev.deprecations.stubEmber();
-    EmberDev.deprecations.expecteds = EmberDev.deprecations.NONE;
-  };
-
-  // Expect a deprecation to happen within a function, or if no function
-  // is pass, from the time of calling until the end of the test. Can be called
-  // multiple times to assert deprecations with different specific messages
-  // were fired.
-  //
-  // expectDeprecation(function(){
-  //   Ember.deprecate("Old And Busted");
-  // }, /* optionalStringOrRegex */);
-  //
-  // expectDeprecation(/* optionalStringOrRegex */);
-  // Ember.deprecate("Old And Busted");
-  //
-  window.expectDeprecation = function(fn, message) {
-    if (EmberDev.deprecations.expecteds === EmberDev.deprecations.NONE) {
-      throw("A deprecation was expected after expectNoDeprecation was called!");
-    }
-    EmberDev.deprecations.stubEmber();
-    EmberDev.deprecations.expecteds = EmberDev.deprecations.expecteds || [];
-    if (fn && typeof fn !== 'function') {
-      // fn is a message
-      EmberDev.deprecations.expecteds.push(fn);
-    } else {
-      EmberDev.deprecations.expecteds.push(message || /.*/);
-      if (fn) {
-        fn();
-        window.assertDeprecation();
-      }
-    }
-  };
-
-  // Forces an assert the deprecations occurred, and resets the globals
-  // storing asserts for the next run.
-  //
-  // expectNoDeprecation(/Old/);
-  // setTimeout(function(){
-  //   Ember.deprecate("Old And Busted");
-  //   assertDeprecation();
-  // });
-  //
-  // assertDeprecation is called after each test run to catch any expectations
-  // without explicit asserts.
-  //
-  window.assertDeprecation = function() {
-    var expecteds = EmberDev.deprecations.expecteds,
-        actuals   = EmberDev.deprecations.actuals || [];
-    if (!expecteds) {
-      EmberDev.deprecations.actuals = null;
-      return;
-    }
-
-    EmberDev.deprecations.restoreEmber();
-    EmberDev.deprecations.actuals = null;
-    EmberDev.deprecations.expecteds = null;
-
-    if (expecteds === EmberDev.deprecations.NONE) {
-      var actualMessages = [];
-      for (var actual in actuals) {
-        actualMessages.push(actual[0]);
-      }
-      ok(actuals.length === 0, "Expected no deprecation call, got: "+actualMessages.join(', '));
-    } else {
-      for (var o=0;o < expecteds.length; o++) {
-        var expected = expecteds[o], match;
-        for (var i=0;i < actuals.length; i++) {
-          var actual = actuals[i];
-          if (!actual[1]) {
-            if (expected instanceof RegExp) {
-              if (expected.test(actual[0])) {
-                match = actual;
-                break;
-              }
-            } else {
-              if (expected === actual[0]) {
-                match = actual;
-                break;
-              }
-            }
-          }
-        }
-
-        if (!actual)
-          ok(false, "Recieved no deprecate calls at all, expecting: "+expected);
-        else if (match && !match[1])
-          ok(true, "Recieved failing deprecation with message: "+match[0]);
-        else if (match && match[1])
-          ok(false, "Expected failing deprecation, got succeeding with message: "+match[0]);
-        else if (actual[1])
-          ok(false, "Did not receive failing deprecation matching '"+expected+"', last was success with '"+actual[0]+"'");
-        else if (!actual[1])
-          ok(false, "Did not receive failing deprecation matching '"+expected+"', last was failure with '"+actual[0]+"'");
-      }
-    }
-  };
-})();