diff --git a/packages/ember-metal/tests/meta_test.js b/packages/ember-metal/tests/meta_test.js
index 5c898613bc6..65ac0d9d877 100644
--- a/packages/ember-metal/tests/meta_test.js
+++ b/packages/ember-metal/tests/meta_test.js
@@ -1,155 +1,155 @@
-import {
-  meta
-} from '..';
+import { meta } from '..';
+import { moduleFor, AbstractTestCase } from 'internal-test-helpers';
 
-QUnit.module('Ember.meta');
+moduleFor('Ember.meta', class extends AbstractTestCase {
+  ['@test should return the same hash for an object'](assert) {
+    let obj = {};
 
-QUnit.test('should return the same hash for an object', function() {
-  let obj = {};
+    meta(obj).foo = 'bar';
 
-  meta(obj).foo = 'bar';
-
-  equal(meta(obj).foo, 'bar', 'returns same hash with multiple calls to Ember.meta()');
-});
-
-QUnit.test('meta is not enumerable', function () {
-  let proto, obj, props, prop;
-  proto = { foo: 'bar' };
-  meta(proto);
-  obj = Object.create(proto);
-  meta(obj);
-  obj.bar = 'baz';
-  props = [];
-  for (prop in obj) {
-    props.push(prop);
+    assert.equal(meta(obj).foo, 'bar', 'returns same hash with multiple calls to Ember.meta()');
   }
-  deepEqual(props.sort(), ['bar', 'foo']);
-  if (typeof JSON !== 'undefined' && 'stringify' in JSON) {
-    try {
-      JSON.stringify(obj);
-    } catch (e) {
-      ok(false, 'meta should not fail JSON.stringify');
+
+  ['@test meta is not enumerable'](assert) {
+    let proto, obj, props, prop;
+    proto = { foo: 'bar' };
+    meta(proto);
+    obj = Object.create(proto);
+    meta(obj);
+    obj.bar = 'baz';
+    props = [];
+    for (prop in obj) {
+      props.push(prop);
+    }
+    assert.deepEqual(props.sort(), ['bar', 'foo']);
+    if (typeof JSON !== 'undefined' && 'stringify' in JSON) {
+      try {
+        JSON.stringify(obj);
+      } catch (e) {
+        assert.ok(false, 'meta should not fail JSON.stringify');
+      }
     }
   }
-});
 
-QUnit.test('meta.listeners basics', function(assert) {
-  let t = {};
-  let m = meta({});
-  m.addToListeners('hello', t, 'm', 0);
-  let matching = m.matchingListeners('hello');
-  assert.equal(matching.length, 3);
-  assert.equal(matching[0], t);
-  m.removeFromListeners('hello', t, 'm');
-  matching = m.matchingListeners('hello');
-  assert.equal(matching, undefined);
-});
+  ['@test meta.listeners basics'](assert) {
+    let t = {};
+    let m = meta({});
+    m.addToListeners('hello', t, 'm', 0);
+    let matching = m.matchingListeners('hello');
+    assert.equal(matching.length, 3);
+    assert.equal(matching[0], t);
+    m.removeFromListeners('hello', t, 'm');
+    matching = m.matchingListeners('hello');
+    assert.equal(matching, undefined);
+  }
 
-QUnit.test('meta.listeners inheritance', function(assert) {
-  let target = {};
-  let parent = {};
-  let parentMeta = meta(parent);
-  parentMeta.addToListeners('hello', target, 'm', 0);
-
-  let child = Object.create(parent);
-  let m = meta(child);
-
-  let matching = m.matchingListeners('hello');
-  assert.equal(matching.length, 3);
-  assert.equal(matching[0], target);
-  assert.equal(matching[1], 'm');
-  assert.equal(matching[2], 0);
-  m.removeFromListeners('hello', target, 'm');
-  matching = m.matchingListeners('hello');
-  assert.equal(matching, undefined);
-  matching = parentMeta.matchingListeners('hello');
-  assert.equal(matching.length, 3);
-});
+  ['@test meta.listeners inheritance'](assert) {
+    let target = {};
+    let parent = {};
+    let parentMeta = meta(parent);
+    parentMeta.addToListeners('hello', target, 'm', 0);
+
+    let child = Object.create(parent);
+    let m = meta(child);
+
+    let matching = m.matchingListeners('hello');
+    assert.equal(matching.length, 3);
+    assert.equal(matching[0], target);
+    assert.equal(matching[1], 'm');
+    assert.equal(matching[2], 0);
+    m.removeFromListeners('hello', target, 'm');
+    matching = m.matchingListeners('hello');
+    assert.equal(matching, undefined);
+    matching = parentMeta.matchingListeners('hello');
+    assert.equal(matching.length, 3);
+  }
 
-QUnit.test('meta.listeners deduplication', function(assert) {
-  let t = {};
-  let m = meta({});
-  m.addToListeners('hello', t, 'm', 0);
-  m.addToListeners('hello', t, 'm', 0);
-  let matching = m.matchingListeners('hello');
-  assert.equal(matching.length, 3);
-  assert.equal(matching[0], t);
-});
+  ['@test meta.listeners deduplication'](assert) {
+    let t = {};
+    let m = meta({});
+    m.addToListeners('hello', t, 'm', 0);
+    m.addToListeners('hello', t, 'm', 0);
+    let matching = m.matchingListeners('hello');
+    assert.equal(matching.length, 3);
+    assert.equal(matching[0], t);
+  }
 
-QUnit.test('meta.writeWatching issues useful error after destroy', function() {
-  let target = {
-    toString() { return '<special-sauce:123>'; }
-  };
-  let targetMeta = meta(target);
+  ['@test meta.writeWatching issues useful error after destroy']() {
+    let target = {
+      toString() { return '<special-sauce:123>'; }
+    };
+    let targetMeta = meta(target);
 
-  targetMeta.destroy();
+    targetMeta.destroy();
 
-  expectAssertion(() => {
-    targetMeta.writeWatching('hello', 1);
-  }, 'Cannot update watchers for `hello` on `<special-sauce:123>` after it has been destroyed.');
-});
+    expectAssertion(() => {
+      targetMeta.writeWatching('hello', 1);
+    }, 'Cannot update watchers for `hello` on `<special-sauce:123>` after it has been destroyed.');
+  }
 
-QUnit.test('meta.writableTag issues useful error after destroy', function() {
-  let target = {
-    toString() { return '<special-sauce:123>'; }
-  };
-  let targetMeta = meta(target);
+  ['@test meta.writableTag issues useful error after destroy']() {
+    let target = {
+      toString() { return '<special-sauce:123>'; }
+    };
+    let targetMeta = meta(target);
 
-  targetMeta.destroy();
+    targetMeta.destroy();
 
-  expectAssertion(() => {
-    targetMeta.writableTag(() => {});
-  }, 'Cannot create a new tag for `<special-sauce:123>` after it has been destroyed.');
-});
+    expectAssertion(() => {
+      targetMeta.writableTag(() => {});
+    }, 'Cannot create a new tag for `<special-sauce:123>` after it has been destroyed.');
+  }
 
-QUnit.test('meta.writableChainWatchers issues useful error after destroy', function() {
-  let target = {
-    toString() { return '<special-sauce:123>'; }
-  };
-  let targetMeta = meta(target);
+  ['@test meta.writableChainWatchers issues useful error after destroy']() {
+    let target = {
+      toString() { return '<special-sauce:123>'; }
+    };
+    let targetMeta = meta(target);
 
-  targetMeta.destroy();
+    targetMeta.destroy();
 
-  expectAssertion(() => {
-    targetMeta.writableChainWatchers(() => {});
-  }, 'Cannot create a new chain watcher for `<special-sauce:123>` after it has been destroyed.');
-});
+    expectAssertion(() => {
+      targetMeta.writableChainWatchers(() => {});
+    }, 'Cannot create a new chain watcher for `<special-sauce:123>` after it has been destroyed.');
+  }
 
-QUnit.test('meta.writableChains issues useful error after destroy', function() {
-  let target = {
-    toString() { return '<special-sauce:123>'; }
-  };
-  let targetMeta = meta(target);
+  ['@test meta.writableChains issues useful error after destroy']() {
+    let target = {
+      toString() { return '<special-sauce:123>'; }
+    };
+    let targetMeta = meta(target);
 
-  targetMeta.destroy();
+    targetMeta.destroy();
 
-  expectAssertion(() => {
-    targetMeta.writableChains(() => {});
-  }, 'Cannot create a new chains for `<special-sauce:123>` after it has been destroyed.');
-});
+    expectAssertion(() => {
+      targetMeta.writableChains(() => {});
+    }, 'Cannot create a new chains for `<special-sauce:123>` after it has been destroyed.');
+  }
 
-QUnit.test('meta.writeValues issues useful error after destroy', function() {
-  let target = {
-    toString() { return '<special-sauce:123>'; }
-  };
-  let targetMeta = meta(target);
+  ['@test meta.writeValues issues useful error after destroy']() {
+    let target = {
+      toString() { return '<special-sauce:123>'; }
+    };
+    let targetMeta = meta(target);
 
-  targetMeta.destroy();
+    targetMeta.destroy();
 
-  expectAssertion(() => {
-    targetMeta.writeValues('derp', 'ohai');
-  }, 'Cannot set the value of `derp` on `<special-sauce:123>` after it has been destroyed.');
-});
+    expectAssertion(() => {
+      targetMeta.writeValues('derp', 'ohai');
+    }, 'Cannot set the value of `derp` on `<special-sauce:123>` after it has been destroyed.');
+  }
 
-QUnit.test('meta.writeDeps issues useful error after destroy', function() {
-  let target = {
-    toString() { return '<special-sauce:123>'; }
-  };
-  let targetMeta = meta(target);
+  ['@test meta.writeDeps issues useful error after destroy']() {
+    let target = {
+      toString() { return '<special-sauce:123>'; }
+    };
+    let targetMeta = meta(target);
 
-  targetMeta.destroy();
+    targetMeta.destroy();
 
-  expectAssertion(() => {
-    targetMeta.writeDeps('derp', 'ohai', 1);
-  }, 'Cannot modify dependent keys for `ohai` on `<special-sauce:123>` after it has been destroyed.');
+    expectAssertion(() => {
+      targetMeta.writeDeps('derp', 'ohai', 1);
+    }, 'Cannot modify dependent keys for `ohai` on `<special-sauce:123>` after it has been destroyed.');
+  }
 });
+
diff --git a/packages/ember-metal/tests/performance_test.js b/packages/ember-metal/tests/performance_test.js
index b6567b508b0..71cb2c51957 100644
--- a/packages/ember-metal/tests/performance_test.js
+++ b/packages/ember-metal/tests/performance_test.js
@@ -8,6 +8,7 @@ import {
   endPropertyChanges,
   addObserver
 } from '..';
+import { moduleFor, AbstractTestCase } from 'internal-test-helpers';
 
 /*
   This test file is designed to capture performance regressions related to
@@ -16,50 +17,51 @@ import {
   bugs that cause them to get evaluated more than necessary should be put here.
 */
 
-QUnit.module('Computed Properties - Number of times evaluated');
+moduleFor('Computed Properties - Number of times evaluated', class extends AbstractTestCase {
+  ['@test computed properties that depend on multiple properties should run only once per run loop'](assert) {
+    let obj = { a: 'a', b: 'b', c: 'c' };
+    let cpCount = 0;
+    let obsCount = 0;
 
-QUnit.test('computed properties that depend on multiple properties should run only once per run loop', function() {
-  let obj = { a: 'a', b: 'b', c: 'c' };
-  let cpCount = 0;
-  let obsCount = 0;
+    defineProperty(obj, 'abc', computed(function(key) {
+      cpCount++;
+      return 'computed ' + key;
+    }).property('a', 'b', 'c'));
 
-  defineProperty(obj, 'abc', computed(function(key) {
-    cpCount++;
-    return 'computed ' + key;
-  }).property('a', 'b', 'c'));
+    get(obj, 'abc');
 
-  get(obj, 'abc');
+    cpCount = 0;
 
-  cpCount = 0;
+    addObserver(obj, 'abc', function() {
+      obsCount++;
+    });
 
-  addObserver(obj, 'abc', function() {
-    obsCount++;
-  });
+    beginPropertyChanges();
+    set(obj, 'a', 'aa');
+    set(obj, 'b', 'bb');
+    set(obj, 'c', 'cc');
+    endPropertyChanges();
 
-  beginPropertyChanges();
-  set(obj, 'a', 'aa');
-  set(obj, 'b', 'bb');
-  set(obj, 'c', 'cc');
-  endPropertyChanges();
+    get(obj, 'abc');
 
-  get(obj, 'abc');
+    assert.equal(cpCount, 1, 'The computed property is only invoked once');
+    assert.equal(obsCount, 1, 'The observer is only invoked once');
+  }
 
-  equal(cpCount, 1, 'The computed property is only invoked once');
-  equal(obsCount, 1, 'The observer is only invoked once');
-});
-
-QUnit.test('computed properties are not executed if they are the last segment of an observer chain pain', function() {
-  let foo = { bar: { baz: { } } };
+  ['@test computed properties are not executed if they are the last segment of an observer chain pain'](assert) {
+    let foo = { bar: { baz: { } } };
 
-  let count = 0;
+    let count = 0;
 
-  defineProperty(foo.bar.baz, 'bam', computed(function() {
-    count++;
-  }));
+    defineProperty(foo.bar.baz, 'bam', computed(function() {
+      count++;
+    }));
 
-  addObserver(foo, 'bar.baz.bam', function() {});
+    addObserver(foo, 'bar.baz.bam', function() {});
 
-  propertyDidChange(get(foo, 'bar.baz'), 'bam');
+    propertyDidChange(get(foo, 'bar.baz'), 'bam');
 
-  equal(count, 0, 'should not have recomputed property');
+    assert.equal(count, 0, 'should not have recomputed property');
+  }
 });
+
diff --git a/packages/ember-metal/tests/properties_test.js b/packages/ember-metal/tests/properties_test.js
index 2ed2dfe5ba3..e5a87ce9963 100644
--- a/packages/ember-metal/tests/properties_test.js
+++ b/packages/ember-metal/tests/properties_test.js
@@ -4,98 +4,100 @@ import {
   deprecateProperty
 } from '..';
 
-QUnit.module('Ember.defineProperty');
+import { moduleFor, AbstractTestCase } from 'internal-test-helpers';
 
-QUnit.test('toString', function() {
-  let obj = {};
-  defineProperty(obj, 'toString', undefined, function() { return 'FOO'; });
-  equal(obj.toString(), 'FOO', 'should replace toString');
-});
+moduleFor('Ember.defineProperty', class extends AbstractTestCase {
+  ['@test toString'](assert) {
+    let obj = {};
+    defineProperty(obj, 'toString', undefined, function() { return 'FOO'; });
+    assert.equal(obj.toString(), 'FOO', 'should replace toString');
+  }
 
-QUnit.test('for data properties, didDefineProperty hook should be called if implemented', function() {
-  expect(2);
+  ['@test for data properties, didDefineProperty hook should be called if implemented'](assert) {
+    assert.expect(2);
 
-  let obj = {
-    didDefineProperty(obj, keyName, value) {
-      equal(keyName, 'foo', 'key name should be foo');
-      equal(value, 'bar', 'value should be bar');
-    }
-  };
+    let obj = {
+      didDefineProperty(obj, keyName, value) {
+        assert.equal(keyName, 'foo', 'key name should be foo');
+        assert.equal(value, 'bar', 'value should be bar');
+      }
+    };
 
-  defineProperty(obj, 'foo', undefined, 'bar');
-});
+    defineProperty(obj, 'foo', undefined, 'bar');
+  }
 
-QUnit.test('for computed properties, didDefineProperty hook should be called if implemented', function() {
-  expect(2);
+  ['@test for computed properties, didDefineProperty hook should be called if implemented'](assert) {
+    assert.expect(2);
 
-  let computedProperty = computed(function() { return this; });
+    let computedProperty = computed(function() { return this; });
 
-  let obj = {
-    didDefineProperty(obj, keyName, value) {
-      equal(keyName, 'foo', 'key name should be foo');
-      strictEqual(value, computedProperty, 'value should be passed as computed property');
-    }
-  };
+    let obj = {
+      didDefineProperty(obj, keyName, value) {
+        assert.equal(keyName, 'foo', 'key name should be foo');
+        assert.strictEqual(value, computedProperty, 'value should be passed as computed property');
+      }
+    };
 
-  defineProperty(obj, 'foo', computedProperty);
-});
+    defineProperty(obj, 'foo', computedProperty);
+  }
 
-QUnit.test('for descriptor properties, didDefineProperty hook should be called if implemented', function() {
-  expect(2);
+  ['@test for descriptor properties, didDefineProperty hook should be called if implemented'](assert) {
+    assert.expect(2);
 
-  let descriptor = {
-    writable: true,
-    configurable: false,
-    enumerable: true,
-    value: 42
-  };
+    let descriptor = {
+      writable: true,
+      configurable: false,
+      enumerable: true,
+      value: 42
+    };
 
-  let obj = {
-    didDefineProperty(obj, keyName, value) {
-      equal(keyName, 'answer', 'key name should be answer');
-      strictEqual(value, descriptor, 'value should be passed as descriptor');
-    }
-  };
+    let obj = {
+      didDefineProperty(obj, keyName, value) {
+        assert.equal(keyName, 'answer', 'key name should be answer');
+        assert.strictEqual(value, descriptor, 'value should be passed as descriptor');
+      }
+    };
 
-  defineProperty(obj, 'answer', descriptor);
+    defineProperty(obj, 'answer', descriptor);
+  }
 });
 
-QUnit.module('Ember.deprecateProperty');
+moduleFor('Ember.deprecateProperty', class extends AbstractTestCase {
+  ['@test enables access to deprecated property and returns the value of the new property'](assert) {
+    assert.expect(3);
+    let obj = { foo: 'bar' };
 
-QUnit.test('enables access to deprecated property and returns the value of the new property', function() {
-  expect(3);
-  let obj = { foo: 'bar' };
+    deprecateProperty(obj, 'baz', 'foo');
 
-  deprecateProperty(obj, 'baz', 'foo');
+    expectDeprecation();
+    assert.equal(obj.baz, obj.foo, 'baz and foo are equal');
 
-  expectDeprecation();
-  equal(obj.baz, obj.foo, 'baz and foo are equal');
-
-  obj.foo = 'blammo';
-  equal(obj.baz, obj.foo, 'baz and foo are equal');
-});
+    obj.foo = 'blammo';
+    assert.equal(obj.baz, obj.foo, 'baz and foo are equal');
+  }
 
-QUnit.test('deprecatedKey is not enumerable', function() {
-  expect(2);
-  let obj = { foo: 'bar', blammo: 'whammy' };
+  ['@test deprecatedKey is not enumerable'](assert) {
+    assert.expect(2);
+    let obj = { foo: 'bar', blammo: 'whammy' };
 
-  deprecateProperty(obj, 'baz', 'foo');
+    deprecateProperty(obj, 'baz', 'foo');
 
-  for (let prop in obj) {
-    if (obj.hasOwnProperty(prop)) {
-      notEqual(prop, 'baz');
+    for (let prop in obj) {
+      if (obj.hasOwnProperty(prop)) {
+        assert.notEqual(prop, 'baz');
+      }
     }
   }
-});
 
-QUnit.test('enables setter to deprecated property and updates the value of the new property', function() {
-  expect(3);
-  let obj = { foo: 'bar' };
+  ['@test enables setter to deprecated property and updates the value of the new property'](assert) {
+    assert.expect(3);
+    let obj = { foo: 'bar' };
 
-  deprecateProperty(obj, 'baz', 'foo');
+    deprecateProperty(obj, 'baz', 'foo');
 
-  expectDeprecation();
-  obj.baz = 'bloop';
-  equal(obj.foo, 'bloop', 'updating baz updates foo');
-  equal(obj.baz, obj.foo, 'baz and foo are equal');
+    expectDeprecation();
+    obj.baz = 'bloop';
+    assert.equal(obj.foo, 'bloop', 'updating baz updates foo');
+    assert.equal(obj.baz, obj.foo, 'baz and foo are equal');
+  }
 });
diff --git a/packages/ember-metal/tests/set_properties_test.js b/packages/ember-metal/tests/set_properties_test.js
index 7b886492716..d1f0d99906d 100644
--- a/packages/ember-metal/tests/set_properties_test.js
+++ b/packages/ember-metal/tests/set_properties_test.js
@@ -1,24 +1,27 @@
 import { setProperties } from '..';
+import { moduleFor, AbstractTestCase } from 'internal-test-helpers';
 
-QUnit.module('Ember.setProperties');
+moduleFor('Ember.setProperties', class extends AbstractTestCase {
+  ['@test supports setting multiple attributes at once'](assert) {
+    assert.deepEqual(setProperties(null, null), null, 'noop for null properties and null object');
+    assert.deepEqual(setProperties(undefined, undefined), undefined, 'noop for undefined properties and undefined object');
 
-QUnit.test('supports setting multiple attributes at once', function() {
-  deepEqual(setProperties(null, null), null, 'noop for null properties and null object');
-  deepEqual(setProperties(undefined, undefined), undefined, 'noop for undefined properties and undefined object');
+    assert.deepEqual(setProperties({}), undefined, 'noop for no properties');
+    assert.deepEqual(setProperties({}, undefined), undefined, 'noop for undefined');
+    assert.deepEqual(setProperties({}, null), null, 'noop for null');
+    assert.deepEqual(setProperties({}, NaN), NaN, 'noop for NaN');
+    assert.deepEqual(setProperties({}, {}), {}, 'meh');
 
-  deepEqual(setProperties({}), undefined, 'noop for no properties');
-  deepEqual(setProperties({}, undefined), undefined, 'noop for undefined');
-  deepEqual(setProperties({}, null), null, 'noop for null');
-  deepEqual(setProperties({}, NaN), NaN, 'noop for NaN');
-  deepEqual(setProperties({}, {}), {}, 'meh');
+    assert.deepEqual(setProperties({}, { foo: 1 }), { foo: 1 }, 'Set a single property');
 
-  deepEqual(setProperties({}, { foo: 1 }), { foo: 1 }, 'Set a single property');
+    assert.deepEqual(setProperties({}, { foo: 1, bar: 1 }), { foo: 1, bar: 1 }, 'Set multiple properties');
 
-  deepEqual(setProperties({}, { foo: 1, bar: 1 }), { foo: 1, bar: 1 }, 'Set multiple properties');
+    assert.deepEqual(setProperties({ foo: 2, baz: 2 }, { foo: 1 }), { foo: 1 }, 'Set one of multiple properties');
 
-  deepEqual(setProperties({ foo: 2, baz: 2 }, { foo: 1 }), { foo: 1 }, 'Set one of multiple properties');
-
-  deepEqual(setProperties({ foo: 2, baz: 2 }, { bar: 2 }), {
-    bar: 2
-  }, 'Set an additional, previously unset property');
+    assert.deepEqual(setProperties({ foo: 2, baz: 2 }, { bar: 2 }), {
+      bar: 2
+    }, 'Set an additional, previously unset property');
+  }
 });
+
+