From 231ed695075b494d892c16e8c98765955b9d8868 Mon Sep 17 00:00:00 2001
From: mgiambalvo <heathkit@gmail.com>
Date: Mon, 15 Aug 2016 13:52:57 -0700
Subject: [PATCH] refactor(common): Remove uses of deprecated
 TestComponentBuilder. (#10754)

* ng_class_spec

* Working through ng_for_spec.

* Finishing up ng_for_spec.

* Finish the rest of the specs.

* Convert pipes tests.
---
 .../common/test/directives/ng_class_spec.ts   | 714 ++++++----------
 .../common/test/directives/ng_for_spec.ts     | 799 +++++++-----------
 .../common/test/directives/ng_if_spec.ts      | 328 +++----
 .../common/test/directives/ng_plural_spec.ts  | 217 ++---
 .../common/test/directives/ng_style_spec.ts   | 257 +++---
 .../common/test/directives/ng_switch_spec.ts  | 245 +++---
 .../directives/ng_template_outlet_spec.ts     | 265 +++---
 .../test/directives/non_bindable_spec.ts      |  79 +-
 .../common/test/pipes/json_pipe_spec.ts       |  36 +-
 .../common/test/pipes/slice_pipe_spec.ts      |  34 +-
 10 files changed, 1186 insertions(+), 1788 deletions(-)

diff --git a/modules/@angular/common/test/directives/ng_class_spec.ts b/modules/@angular/common/test/directives/ng_class_spec.ts
index 4d4d7237c0..4861d3de5b 100644
--- a/modules/@angular/common/test/directives/ng_class_spec.ts
+++ b/modules/@angular/common/test/directives/ng_class_spec.ts
@@ -8,8 +8,9 @@
 
 import {NgClass, NgFor} from '@angular/common';
 import {Component} from '@angular/core';
-import {ComponentFixture, TestComponentBuilder} from '@angular/core/testing';
-import {AsyncTestCompleter, beforeEach, beforeEachProviders, ddescribe, describe, expect, iit, inject, it, xdescribe, xit} from '@angular/core/testing/testing_internal';
+import {ComponentFixture, TestBed, async} from '@angular/core/testing';
+import {beforeEach, ddescribe, describe, expect, iit, inject, it, xdescribe, xit} from '@angular/core/testing/testing_internal';
+
 import {ListWrapper, StringMapWrapper} from '../../src/facade/collection';
 
 function detectChangesAndCheck(fixture: ComponentFixture<any>, classes: string) {
@@ -19,567 +20,360 @@ function detectChangesAndCheck(fixture: ComponentFixture<any>, classes: string)
 
 export function main() {
   describe('binding to CSS class list', () => {
+    beforeEach(() => {
+      TestBed.configureTestingModule({
+        declarations: [TestComponent],
+      });
+    });
 
-    it('should clean up when the directive is destroyed',
-       inject(
-           [TestComponentBuilder, AsyncTestCompleter],
-           (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
-             var template = '<div *ngFor="let item of items" [ngClass]="item"></div>';
-             tcb.overrideTemplate(TestComponent, template)
-                 .createAsync(TestComponent)
-                 .then((fixture: ComponentFixture<TestComponent>) => {
-                   fixture.debugElement.componentInstance.items = [['0']];
-                   fixture.detectChanges();
-                   fixture.debugElement.componentInstance.items = [['1']];
+    it('should clean up when the directive is destroyed', async(() => {
+         let template = '<div *ngFor="let item of items" [ngClass]="item"></div>';
+         TestBed.overrideComponent(TestComponent, {set: {template: template}});
+         let fixture = TestBed.createComponent(TestComponent);
 
-                   detectChangesAndCheck(fixture, '1');
-
-                   async.done();
-                 });
-           }));
+         fixture.debugElement.componentInstance.items = [['0']];
+         fixture.detectChanges();
+         fixture.debugElement.componentInstance.items = [['1']];
 
+         detectChangesAndCheck(fixture, '1');
+       }));
 
     describe('expressions evaluating to objects', () => {
 
-      it('should add classes specified in an object literal',
-         inject(
-             [TestComponentBuilder, AsyncTestCompleter],
-             (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
-               var template = '<div [ngClass]="{foo: true, bar: false}"></div>';
+      it('should add classes specified in an object literal', async(() => {
+           let template = '<div [ngClass]="{foo: true, bar: false}"></div>';
+           TestBed.overrideComponent(TestComponent, {set: {template: template}});
+           let fixture = TestBed.createComponent(TestComponent);
 
-               tcb.overrideTemplate(TestComponent, template)
-                   .createAsync(TestComponent)
-                   .then((fixture) => {
-                     detectChangesAndCheck(fixture, 'foo');
-                     async.done();
-                   });
-             }));
+           detectChangesAndCheck(fixture, 'foo');
+         }));
 
 
       it('should add classes specified in an object literal without change in class names',
-         inject(
-             [TestComponentBuilder, AsyncTestCompleter],
-             (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
-               var template = `<div [ngClass]="{'foo-bar': true, 'fooBar': true}"></div>`;
+         async(() => {
+           let template = `<div [ngClass]="{'foo-bar': true, 'fooBar': true}"></div>`;
+           TestBed.overrideComponent(TestComponent, {set: {template: template}});
+           let fixture = TestBed.createComponent(TestComponent);
 
-               tcb.overrideTemplate(TestComponent, template)
-                   .createAsync(TestComponent)
-                   .then((fixture) => {
-                     detectChangesAndCheck(fixture, 'foo-bar fooBar');
-                     async.done();
-                   });
-             }));
+           detectChangesAndCheck(fixture, 'foo-bar fooBar');
+         }));
 
-      it('should add and remove classes based on changes in object literal values',
-         inject(
-             [TestComponentBuilder, AsyncTestCompleter],
-             (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
-               var template = '<div [ngClass]="{foo: condition, bar: !condition}"></div>';
+      it('should add and remove classes based on changes in object literal values', async(() => {
+           let template = '<div [ngClass]="{foo: condition, bar: !condition}"></div>';
+           TestBed.overrideComponent(TestComponent, {set: {template: template}});
+           let fixture = TestBed.createComponent(TestComponent);
 
-               tcb.overrideTemplate(TestComponent, template)
-                   .createAsync(TestComponent)
-                   .then((fixture) => {
-                     detectChangesAndCheck(fixture, 'foo');
+           detectChangesAndCheck(fixture, 'foo');
 
-                     fixture.debugElement.componentInstance.condition = false;
-                     detectChangesAndCheck(fixture, 'bar');
+           fixture.debugElement.componentInstance.condition = false;
+           detectChangesAndCheck(fixture, 'bar');
+         }));
 
-                     async.done();
-                   });
-             }));
+      it('should add and remove classes based on changes to the expression object', async(() => {
+           let template = '<div [ngClass]="objExpr"></div>';
+           TestBed.overrideComponent(TestComponent, {set: {template: template}});
+           let fixture = TestBed.createComponent(TestComponent);
 
-      it('should add and remove classes based on changes to the expression object',
-         inject(
-             [TestComponentBuilder, AsyncTestCompleter],
-             (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
-               var template = '<div [ngClass]="objExpr"></div>';
+           detectChangesAndCheck(fixture, 'foo');
 
-               tcb.overrideTemplate(TestComponent, template)
-                   .createAsync(TestComponent)
-                   .then((fixture) => {
-                     detectChangesAndCheck(fixture, 'foo');
+           StringMapWrapper.set(fixture.debugElement.componentInstance.objExpr, 'bar', true);
+           detectChangesAndCheck(fixture, 'foo bar');
 
-                     StringMapWrapper.set(
-                         fixture.debugElement.componentInstance.objExpr, 'bar', true);
-                     detectChangesAndCheck(fixture, 'foo bar');
+           StringMapWrapper.set(fixture.debugElement.componentInstance.objExpr, 'baz', true);
+           detectChangesAndCheck(fixture, 'foo bar baz');
 
-                     StringMapWrapper.set(
-                         fixture.debugElement.componentInstance.objExpr, 'baz', true);
-                     detectChangesAndCheck(fixture, 'foo bar baz');
-
-                     StringMapWrapper.delete(fixture.debugElement.componentInstance.objExpr, 'bar');
-                     detectChangesAndCheck(fixture, 'foo baz');
-
-                     async.done();
-                   });
-             }));
+           StringMapWrapper.delete(fixture.debugElement.componentInstance.objExpr, 'bar');
+           detectChangesAndCheck(fixture, 'foo baz');
+         }));
 
       it('should add and remove classes based on reference changes to the expression object',
-         inject(
-             [TestComponentBuilder, AsyncTestCompleter],
-             (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
-               var template = '<div [ngClass]="objExpr"></div>';
+         async(() => {
+           let template = '<div [ngClass]="objExpr"></div>';
+           TestBed.overrideComponent(TestComponent, {set: {template: template}});
+           let fixture = TestBed.createComponent(TestComponent);
 
-               tcb.overrideTemplate(TestComponent, template)
-                   .createAsync(TestComponent)
-                   .then((fixture) => {
-                     detectChangesAndCheck(fixture, 'foo');
+           detectChangesAndCheck(fixture, 'foo');
 
-                     fixture.debugElement.componentInstance.objExpr = {foo: true, bar: true};
-                     detectChangesAndCheck(fixture, 'foo bar');
+           fixture.debugElement.componentInstance.objExpr = {foo: true, bar: true};
+           detectChangesAndCheck(fixture, 'foo bar');
 
-                     fixture.debugElement.componentInstance.objExpr = {baz: true};
-                     detectChangesAndCheck(fixture, 'baz');
+           fixture.debugElement.componentInstance.objExpr = {baz: true};
+           detectChangesAndCheck(fixture, 'baz');
+         }));
 
-                     async.done();
-                   });
-             }));
+      it('should remove active classes when expression evaluates to null', async(() => {
+           let template = '<div [ngClass]="objExpr"></div>';
+           TestBed.overrideComponent(TestComponent, {set: {template: template}});
+           let fixture = TestBed.createComponent(TestComponent);
 
-      it('should remove active classes when expression evaluates to null',
-         inject(
-             [TestComponentBuilder, AsyncTestCompleter],
-             (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
-               var template = '<div [ngClass]="objExpr"></div>';
+           detectChangesAndCheck(fixture, 'foo');
 
-               tcb.overrideTemplate(TestComponent, template)
-                   .createAsync(TestComponent)
-                   .then((fixture) => {
-                     detectChangesAndCheck(fixture, 'foo');
+           fixture.debugElement.componentInstance.objExpr = null;
+           detectChangesAndCheck(fixture, '');
 
-                     fixture.debugElement.componentInstance.objExpr = null;
-                     detectChangesAndCheck(fixture, '');
-
-                     fixture.debugElement.componentInstance.objExpr = {'foo': false, 'bar': true};
-                     detectChangesAndCheck(fixture, 'bar');
-
-                     async.done();
-                   });
-             }));
+           fixture.debugElement.componentInstance.objExpr = {'foo': false, 'bar': true};
+           detectChangesAndCheck(fixture, 'bar');
+         }));
 
 
-      it('should allow multiple classes per expression',
-         inject(
-             [TestComponentBuilder, AsyncTestCompleter],
-             (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
-               var template = '<div [ngClass]="objExpr"></div>';
+      it('should allow multiple classes per expression', async(() => {
+           let template = '<div [ngClass]="objExpr"></div>';
+           TestBed.overrideComponent(TestComponent, {set: {template: template}});
+           let fixture = TestBed.createComponent(TestComponent);
 
-               tcb.overrideTemplate(TestComponent, template)
-                   .createAsync(TestComponent)
-                   .then((fixture) => {
+           fixture.debugElement.componentInstance.objExpr = {'bar baz': true, 'bar1 baz1': true};
+           detectChangesAndCheck(fixture, 'bar baz bar1 baz1');
 
-                     fixture.debugElement.componentInstance.objExpr = {
-                       'bar baz': true,
-                       'bar1 baz1': true
-                     };
-                     detectChangesAndCheck(fixture, 'bar baz bar1 baz1');
+           fixture.debugElement.componentInstance.objExpr = {'bar baz': false, 'bar1 baz1': true};
+           detectChangesAndCheck(fixture, 'bar1 baz1');
+         }));
 
-                     fixture.debugElement.componentInstance.objExpr = {
-                       'bar baz': false,
-                       'bar1 baz1': true
-                     };
-                     detectChangesAndCheck(fixture, 'bar1 baz1');
+      it('should split by one or more spaces between classes', async(() => {
+           let template = '<div [ngClass]="objExpr"></div>';
+           TestBed.overrideComponent(TestComponent, {set: {template: template}});
+           let fixture = TestBed.createComponent(TestComponent);
 
-
-                     async.done();
-                   });
-             }));
-
-      it('should split by one or more spaces between classes',
-         inject(
-             [TestComponentBuilder, AsyncTestCompleter],
-             (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
-               var template = '<div [ngClass]="objExpr"></div>';
-
-               tcb.overrideTemplate(TestComponent, template)
-                   .createAsync(TestComponent)
-                   .then((fixture) => {
-
-                     fixture.debugElement.componentInstance.objExpr = {'foo bar     baz': true};
-                     detectChangesAndCheck(fixture, 'foo bar baz');
-
-                     async.done();
-                   });
-             }));
+           fixture.debugElement.componentInstance.objExpr = {'foo bar     baz': true};
+           detectChangesAndCheck(fixture, 'foo bar baz');
+         }));
 
     });
 
     describe('expressions evaluating to lists', () => {
 
-      it('should add classes specified in a list literal',
-         inject(
-             [TestComponentBuilder, AsyncTestCompleter],
-             (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
-               var template = `<div [ngClass]="['foo', 'bar', 'foo-bar', 'fooBar']"></div>`;
+      it('should add classes specified in a list literal', async(() => {
+           let template = `<div [ngClass]="['foo', 'bar', 'foo-bar', 'fooBar']"></div>`;
+           TestBed.overrideComponent(TestComponent, {set: {template: template}});
+           let fixture = TestBed.createComponent(TestComponent);
 
-               tcb.overrideTemplate(TestComponent, template)
-                   .createAsync(TestComponent)
-                   .then((fixture) => {
-                     detectChangesAndCheck(fixture, 'foo bar foo-bar fooBar');
-                     async.done();
-                   });
-             }));
+           detectChangesAndCheck(fixture, 'foo bar foo-bar fooBar');
+         }));
 
-      it('should add and remove classes based on changes to the expression',
-         inject(
-             [TestComponentBuilder, AsyncTestCompleter],
-             (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
-               var template = '<div [ngClass]="arrExpr"></div>';
+      it('should add and remove classes based on changes to the expression', async(() => {
+           let template = '<div [ngClass]="arrExpr"></div>';
+           TestBed.overrideComponent(TestComponent, {set: {template: template}});
+           let fixture = TestBed.createComponent(TestComponent);
+           var arrExpr: string[] = fixture.debugElement.componentInstance.arrExpr;
+           detectChangesAndCheck(fixture, 'foo');
 
-               tcb.overrideTemplate(TestComponent, template)
-                   .createAsync(TestComponent)
-                   .then((fixture) => {
-                     var arrExpr: string[] = fixture.debugElement.componentInstance.arrExpr;
-                     detectChangesAndCheck(fixture, 'foo');
+           arrExpr.push('bar');
+           detectChangesAndCheck(fixture, 'foo bar');
 
-                     arrExpr.push('bar');
-                     detectChangesAndCheck(fixture, 'foo bar');
+           arrExpr[1] = 'baz';
+           detectChangesAndCheck(fixture, 'foo baz');
 
-                     arrExpr[1] = 'baz';
-                     detectChangesAndCheck(fixture, 'foo baz');
+           ListWrapper.remove(fixture.debugElement.componentInstance.arrExpr, 'baz');
+           detectChangesAndCheck(fixture, 'foo');
+         }));
 
-                     ListWrapper.remove(fixture.debugElement.componentInstance.arrExpr, 'baz');
-                     detectChangesAndCheck(fixture, 'foo');
+      it('should add and remove classes when a reference changes', async(() => {
+           let template = '<div [ngClass]="arrExpr"></div>';
+           TestBed.overrideComponent(TestComponent, {set: {template: template}});
+           let fixture = TestBed.createComponent(TestComponent);
+           detectChangesAndCheck(fixture, 'foo');
 
-                     async.done();
-                   });
-             }));
+           fixture.debugElement.componentInstance.arrExpr = ['bar'];
+           detectChangesAndCheck(fixture, 'bar');
+         }));
 
-      it('should add and remove classes when a reference changes',
-         inject(
-             [TestComponentBuilder, AsyncTestCompleter],
-             (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
-               var template = '<div [ngClass]="arrExpr"></div>';
+      it('should take initial classes into account when a reference changes', async(() => {
+           let template = '<div class="foo" [ngClass]="arrExpr"></div>';
+           TestBed.overrideComponent(TestComponent, {set: {template: template}});
+           let fixture = TestBed.createComponent(TestComponent);
+           detectChangesAndCheck(fixture, 'foo');
 
-               tcb.overrideTemplate(TestComponent, template)
-                   .createAsync(TestComponent)
-                   .then((fixture) => {
-                     detectChangesAndCheck(fixture, 'foo');
+           fixture.debugElement.componentInstance.arrExpr = ['bar'];
+           detectChangesAndCheck(fixture, 'foo bar');
+         }));
 
-                     fixture.debugElement.componentInstance.arrExpr = ['bar'];
-                     detectChangesAndCheck(fixture, 'bar');
+      it('should ignore empty or blank class names', async(() => {
+           let template = '<div class="foo" [ngClass]="arrExpr"></div>';
+           TestBed.overrideComponent(TestComponent, {set: {template: template}});
+           let fixture = TestBed.createComponent(TestComponent);
+           fixture.debugElement.componentInstance.arrExpr = ['', '  '];
+           detectChangesAndCheck(fixture, 'foo');
+         }));
 
-                     async.done();
-                   });
-             }));
+      it('should trim blanks from class names', async(() => {
+           var template = '<div class="foo" [ngClass]="arrExpr"></div>';
+           TestBed.overrideComponent(TestComponent, {set: {template: template}});
+           let fixture = TestBed.createComponent(TestComponent);
 
-      it('should take initial classes into account when a reference changes',
-         inject(
-             [TestComponentBuilder, AsyncTestCompleter],
-             (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
-               var template = '<div class="foo" [ngClass]="arrExpr"></div>';
-
-               tcb.overrideTemplate(TestComponent, template)
-                   .createAsync(TestComponent)
-                   .then((fixture) => {
-                     detectChangesAndCheck(fixture, 'foo');
-
-                     fixture.debugElement.componentInstance.arrExpr = ['bar'];
-                     detectChangesAndCheck(fixture, 'foo bar');
-
-                     async.done();
-                   });
-             }));
-
-      it('should ignore empty or blank class names',
-         inject(
-             [TestComponentBuilder, AsyncTestCompleter],
-             (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
-               var template = '<div class="foo" [ngClass]="arrExpr"></div>';
-
-               tcb.overrideTemplate(TestComponent, template)
-                   .createAsync(TestComponent)
-                   .then((fixture) => {
-
-                     fixture.debugElement.componentInstance.arrExpr = ['', '  '];
-                     detectChangesAndCheck(fixture, 'foo');
-
-                     async.done();
-                   });
-             }));
-
-      it('should trim blanks from class names',
-         inject(
-             [TestComponentBuilder, AsyncTestCompleter],
-             (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
-               var template = '<div class="foo" [ngClass]="arrExpr"></div>';
-
-               tcb.overrideTemplate(TestComponent, template)
-                   .createAsync(TestComponent)
-                   .then((fixture) => {
-
-                     fixture.debugElement.componentInstance.arrExpr = [' bar  '];
-                     detectChangesAndCheck(fixture, 'foo bar');
-
-                     async.done();
-                   });
-             }));
+           fixture.debugElement.componentInstance.arrExpr = [' bar  '];
+           detectChangesAndCheck(fixture, 'foo bar');
+         }));
 
 
-      it('should allow multiple classes per item in arrays',
-         inject(
-             [TestComponentBuilder, AsyncTestCompleter],
-             (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
-               var template = '<div [ngClass]="arrExpr"></div>';
+      it('should allow multiple classes per item in arrays', async(() => {
+           var template = '<div [ngClass]="arrExpr"></div>';
+           TestBed.overrideComponent(TestComponent, {set: {template: template}});
+           let fixture = TestBed.createComponent(TestComponent);
 
-               tcb.overrideTemplate(TestComponent, template)
-                   .createAsync(TestComponent)
-                   .then((fixture) => {
+           fixture.debugElement.componentInstance.arrExpr = ['foo bar baz', 'foo1 bar1   baz1'];
+           detectChangesAndCheck(fixture, 'foo bar baz foo1 bar1 baz1');
 
-                     fixture.debugElement.componentInstance.arrExpr =
-                         ['foo bar baz', 'foo1 bar1   baz1'];
-                     detectChangesAndCheck(fixture, 'foo bar baz foo1 bar1 baz1');
-
-                     fixture.debugElement.componentInstance.arrExpr = ['foo bar   baz foobar'];
-                     detectChangesAndCheck(fixture, 'foo bar baz foobar');
-
-                     async.done();
-                   });
-             }));
+           fixture.debugElement.componentInstance.arrExpr = ['foo bar   baz foobar'];
+           detectChangesAndCheck(fixture, 'foo bar baz foobar');
+         }));
     });
 
     describe('expressions evaluating to sets', () => {
 
-      it('should add and remove classes if the set instance changed',
-         inject(
-             [TestComponentBuilder, AsyncTestCompleter],
-             (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
-               var template = '<div [ngClass]="setExpr"></div>';
+      it('should add and remove classes if the set instance changed', async(() => {
+           var template = '<div [ngClass]="setExpr"></div>';
+           TestBed.overrideComponent(TestComponent, {set: {template: template}});
+           let fixture = TestBed.createComponent(TestComponent);
+           var setExpr = new Set<string>();
+           setExpr.add('bar');
+           fixture.debugElement.componentInstance.setExpr = setExpr;
+           detectChangesAndCheck(fixture, 'bar');
 
-               tcb.overrideTemplate(TestComponent, template)
-                   .createAsync(TestComponent)
-                   .then((fixture) => {
-                     var setExpr = new Set<string>();
-                     setExpr.add('bar');
-                     fixture.debugElement.componentInstance.setExpr = setExpr;
-                     detectChangesAndCheck(fixture, 'bar');
-
-                     setExpr = new Set<string>();
-                     setExpr.add('baz');
-                     fixture.debugElement.componentInstance.setExpr = setExpr;
-                     detectChangesAndCheck(fixture, 'baz');
-
-                     async.done();
-                   });
-             }));
+           setExpr = new Set<string>();
+           setExpr.add('baz');
+           fixture.debugElement.componentInstance.setExpr = setExpr;
+           detectChangesAndCheck(fixture, 'baz');
+         }));
     });
+
     describe('expressions evaluating to string', () => {
 
-      it('should add classes specified in a string literal',
-         inject(
-             [TestComponentBuilder, AsyncTestCompleter],
-             (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
-               var template = `<div [ngClass]="'foo bar foo-bar fooBar'"></div>`;
+      it('should add classes specified in a string literal', async(() => {
+           var template = `<div [ngClass]="'foo bar foo-bar fooBar'"></div>`;
+           TestBed.overrideComponent(TestComponent, {set: {template: template}});
+           let fixture = TestBed.createComponent(TestComponent);
+           detectChangesAndCheck(fixture, 'foo bar foo-bar fooBar');
+         }));
 
-               tcb.overrideTemplate(TestComponent, template)
-                   .createAsync(TestComponent)
-                   .then((fixture) => {
-                     detectChangesAndCheck(fixture, 'foo bar foo-bar fooBar');
-                     async.done();
-                   });
-             }));
+      it('should add and remove classes based on changes to the expression', async(() => {
+           var template = '<div [ngClass]="strExpr"></div>';
+           TestBed.overrideComponent(TestComponent, {set: {template: template}});
+           let fixture = TestBed.createComponent(TestComponent);
+           detectChangesAndCheck(fixture, 'foo');
 
-      it('should add and remove classes based on changes to the expression',
-         inject(
-             [TestComponentBuilder, AsyncTestCompleter],
-             (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
-               var template = '<div [ngClass]="strExpr"></div>';
-
-               tcb.overrideTemplate(TestComponent, template)
-                   .createAsync(TestComponent)
-                   .then((fixture) => {
-                     detectChangesAndCheck(fixture, 'foo');
-
-                     fixture.debugElement.componentInstance.strExpr = 'foo bar';
-                     detectChangesAndCheck(fixture, 'foo bar');
+           fixture.debugElement.componentInstance.strExpr = 'foo bar';
+           detectChangesAndCheck(fixture, 'foo bar');
 
 
-                     fixture.debugElement.componentInstance.strExpr = 'baz';
-                     detectChangesAndCheck(fixture, 'baz');
+           fixture.debugElement.componentInstance.strExpr = 'baz';
+           detectChangesAndCheck(fixture, 'baz');
 
-                     async.done();
-                   });
-             }));
+         }));
 
-      it('should remove active classes when switching from string to null',
-         inject(
-             [TestComponentBuilder, AsyncTestCompleter],
-             (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
-               var template = `<div [ngClass]="strExpr"></div>`;
+      it('should remove active classes when switching from string to null', async(() => {
+           var template = `<div [ngClass]="strExpr"></div>`;
+           TestBed.overrideComponent(TestComponent, {set: {template: template}});
+           let fixture = TestBed.createComponent(TestComponent);
+           detectChangesAndCheck(fixture, 'foo');
 
-               tcb.overrideTemplate(TestComponent, template)
-                   .createAsync(TestComponent)
-                   .then((fixture) => {
-                     detectChangesAndCheck(fixture, 'foo');
+           fixture.debugElement.componentInstance.strExpr = null;
+           detectChangesAndCheck(fixture, '');
 
-                     fixture.debugElement.componentInstance.strExpr = null;
-                     detectChangesAndCheck(fixture, '');
-
-                     async.done();
-                   });
-             }));
+         }));
 
       it('should take initial classes into account when switching from string to null',
-         inject(
-             [TestComponentBuilder, AsyncTestCompleter],
-             (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
-               var template = `<div class="foo" [ngClass]="strExpr"></div>`;
+         async(() => {
+           var template = `<div class="foo" [ngClass]="strExpr"></div>`;
+           TestBed.overrideComponent(TestComponent, {set: {template: template}});
+           let fixture = TestBed.createComponent(TestComponent);
+           detectChangesAndCheck(fixture, 'foo');
 
-               tcb.overrideTemplate(TestComponent, template)
-                   .createAsync(TestComponent)
-                   .then((fixture) => {
-                     detectChangesAndCheck(fixture, 'foo');
+           fixture.debugElement.componentInstance.strExpr = null;
+           detectChangesAndCheck(fixture, 'foo');
 
-                     fixture.debugElement.componentInstance.strExpr = null;
-                     detectChangesAndCheck(fixture, 'foo');
+         }));
 
-                     async.done();
-                   });
-             }));
+      it('should ignore empty and blank strings', async(() => {
+           var template = `<div class="foo" [ngClass]="strExpr"></div>`;
+           TestBed.overrideComponent(TestComponent, {set: {template: template}});
+           let fixture = TestBed.createComponent(TestComponent);
+           fixture.debugElement.componentInstance.strExpr = '';
+           detectChangesAndCheck(fixture, 'foo');
 
-      it('should ignore empty and blank strings',
-         inject(
-             [TestComponentBuilder, AsyncTestCompleter],
-             (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
-               var template = `<div class="foo" [ngClass]="strExpr"></div>`;
-
-               tcb.overrideTemplate(TestComponent, template)
-                   .createAsync(TestComponent)
-                   .then((fixture) => {
-                     fixture.debugElement.componentInstance.strExpr = '';
-                     detectChangesAndCheck(fixture, 'foo');
-
-                     async.done();
-                   });
-             }));
+         }));
 
     });
 
     describe('cooperation with other class-changing constructs', () => {
 
-      it('should co-operate with the class attribute',
-         inject(
-             [TestComponentBuilder, AsyncTestCompleter],
-             (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
-               var template = '<div [ngClass]="objExpr" class="init foo"></div>';
+      it('should co-operate with the class attribute', async(() => {
+           var template = '<div [ngClass]="objExpr" class="init foo"></div>';
+           TestBed.overrideComponent(TestComponent, {set: {template: template}});
+           let fixture = TestBed.createComponent(TestComponent);
+           StringMapWrapper.set(fixture.debugElement.componentInstance.objExpr, 'bar', true);
+           detectChangesAndCheck(fixture, 'init foo bar');
 
-               tcb.overrideTemplate(TestComponent, template)
-                   .createAsync(TestComponent)
-                   .then((fixture) => {
-                     StringMapWrapper.set(
-                         fixture.debugElement.componentInstance.objExpr, 'bar', true);
-                     detectChangesAndCheck(fixture, 'init foo bar');
+           StringMapWrapper.set(fixture.debugElement.componentInstance.objExpr, 'foo', false);
+           detectChangesAndCheck(fixture, 'init bar');
 
-                     StringMapWrapper.set(
-                         fixture.debugElement.componentInstance.objExpr, 'foo', false);
-                     detectChangesAndCheck(fixture, 'init bar');
+           fixture.debugElement.componentInstance.objExpr = null;
+           detectChangesAndCheck(fixture, 'init foo');
 
-                     fixture.debugElement.componentInstance.objExpr = null;
-                     detectChangesAndCheck(fixture, 'init foo');
+         }));
 
-                     async.done();
-                   });
-             }));
+      it('should co-operate with the interpolated class attribute', async(() => {
+           var template = `<div [ngClass]="objExpr" class="{{'init foo'}}"></div>`;
+           TestBed.overrideComponent(TestComponent, {set: {template: template}});
+           let fixture = TestBed.createComponent(TestComponent);
+           StringMapWrapper.set(fixture.debugElement.componentInstance.objExpr, 'bar', true);
+           detectChangesAndCheck(fixture, `init foo bar`);
 
-      it('should co-operate with the interpolated class attribute',
-         inject(
-             [TestComponentBuilder, AsyncTestCompleter],
-             (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
-               var template = `<div [ngClass]="objExpr" class="{{'init foo'}}"></div>`;
+           StringMapWrapper.set(fixture.debugElement.componentInstance.objExpr, 'foo', false);
+           detectChangesAndCheck(fixture, `init bar`);
 
-               tcb.overrideTemplate(TestComponent, template)
-                   .createAsync(TestComponent)
-                   .then((fixture) => {
-                     StringMapWrapper.set(
-                         fixture.debugElement.componentInstance.objExpr, 'bar', true);
-                     detectChangesAndCheck(fixture, `init foo bar`);
+           fixture.debugElement.componentInstance.objExpr = null;
+           detectChangesAndCheck(fixture, `init foo`);
 
-                     StringMapWrapper.set(
-                         fixture.debugElement.componentInstance.objExpr, 'foo', false);
-                     detectChangesAndCheck(fixture, `init bar`);
+         }));
 
-                     fixture.debugElement.componentInstance.objExpr = null;
-                     detectChangesAndCheck(fixture, `init foo`);
+      it('should co-operate with the class attribute and binding to it', async(() => {
+           var template = `<div [ngClass]="objExpr" class="init" [class]="'foo'"></div>`;
+           TestBed.overrideComponent(TestComponent, {set: {template: template}});
+           let fixture = TestBed.createComponent(TestComponent);
+           StringMapWrapper.set(fixture.debugElement.componentInstance.objExpr, 'bar', true);
+           detectChangesAndCheck(fixture, `init foo bar`);
 
-                     async.done();
-                   });
-             }));
+           StringMapWrapper.set(fixture.debugElement.componentInstance.objExpr, 'foo', false);
+           detectChangesAndCheck(fixture, `init bar`);
 
-      it('should co-operate with the class attribute and binding to it',
-         inject(
-             [TestComponentBuilder, AsyncTestCompleter],
-             (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
-               var template = `<div [ngClass]="objExpr" class="init" [class]="'foo'"></div>`;
+           fixture.debugElement.componentInstance.objExpr = null;
+           detectChangesAndCheck(fixture, `init foo`);
 
-               tcb.overrideTemplate(TestComponent, template)
-                   .createAsync(TestComponent)
-                   .then((fixture) => {
-                     StringMapWrapper.set(
-                         fixture.debugElement.componentInstance.objExpr, 'bar', true);
-                     detectChangesAndCheck(fixture, `init foo bar`);
+         }));
 
-                     StringMapWrapper.set(
-                         fixture.debugElement.componentInstance.objExpr, 'foo', false);
-                     detectChangesAndCheck(fixture, `init bar`);
+      it('should co-operate with the class attribute and class.name binding', async(() => {
+           var template =
+               '<div class="init foo" [ngClass]="objExpr" [class.baz]="condition"></div>';
+           TestBed.overrideComponent(TestComponent, {set: {template: template}});
+           let fixture = TestBed.createComponent(TestComponent);
+           detectChangesAndCheck(fixture, 'init foo baz');
 
-                     fixture.debugElement.componentInstance.objExpr = null;
-                     detectChangesAndCheck(fixture, `init foo`);
+           StringMapWrapper.set(fixture.debugElement.componentInstance.objExpr, 'bar', true);
+           detectChangesAndCheck(fixture, 'init foo baz bar');
 
-                     async.done();
-                   });
-             }));
+           StringMapWrapper.set(fixture.debugElement.componentInstance.objExpr, 'foo', false);
+           detectChangesAndCheck(fixture, 'init baz bar');
 
-      it('should co-operate with the class attribute and class.name binding',
-         inject(
-             [TestComponentBuilder, AsyncTestCompleter],
-             (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
-               var template =
-                   '<div class="init foo" [ngClass]="objExpr" [class.baz]="condition"></div>';
+           fixture.debugElement.componentInstance.condition = false;
+           detectChangesAndCheck(fixture, 'init bar');
 
-               tcb.overrideTemplate(TestComponent, template)
-                   .createAsync(TestComponent)
-                   .then((fixture) => {
-                     detectChangesAndCheck(fixture, 'init foo baz');
-
-                     StringMapWrapper.set(
-                         fixture.debugElement.componentInstance.objExpr, 'bar', true);
-                     detectChangesAndCheck(fixture, 'init foo baz bar');
-
-                     StringMapWrapper.set(
-                         fixture.debugElement.componentInstance.objExpr, 'foo', false);
-                     detectChangesAndCheck(fixture, 'init baz bar');
-
-                     fixture.debugElement.componentInstance.condition = false;
-                     detectChangesAndCheck(fixture, 'init bar');
-
-                     async.done();
-                   });
-             }));
+         }));
 
       it('should co-operate with initial class and class attribute binding when binding changes',
-         inject(
-             [TestComponentBuilder, AsyncTestCompleter],
-             (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
-               var template = '<div class="init" [ngClass]="objExpr" [class]="strExpr"></div>';
+         async(() => {
+           var template = '<div class="init" [ngClass]="objExpr" [class]="strExpr"></div>';
+           TestBed.overrideComponent(TestComponent, {set: {template: template}});
+           let fixture = TestBed.createComponent(TestComponent);
+           detectChangesAndCheck(fixture, 'init foo');
 
-               tcb.overrideTemplate(TestComponent, template)
-                   .createAsync(TestComponent)
-                   .then((fixture) => {
-                     detectChangesAndCheck(fixture, 'init foo');
+           StringMapWrapper.set(fixture.debugElement.componentInstance.objExpr, 'bar', true);
+           detectChangesAndCheck(fixture, 'init foo bar');
 
-                     StringMapWrapper.set(
-                         fixture.debugElement.componentInstance.objExpr, 'bar', true);
-                     detectChangesAndCheck(fixture, 'init foo bar');
-
-                     fixture.debugElement.componentInstance.strExpr = 'baz';
-                     detectChangesAndCheck(fixture, 'init bar baz foo');
-
-                     fixture.debugElement.componentInstance.objExpr = null;
-                     detectChangesAndCheck(fixture, 'init baz');
-
-                     async.done();
-                   });
-             }));
+           fixture.debugElement.componentInstance.strExpr = 'baz';
+           detectChangesAndCheck(fixture, 'init bar baz foo');
 
+           fixture.debugElement.componentInstance.objExpr = null;
+           detectChangesAndCheck(fixture, 'init baz');
+         }));
     });
   });
 }
diff --git a/modules/@angular/common/test/directives/ng_for_spec.ts b/modules/@angular/common/test/directives/ng_for_spec.ts
index 283979ecf9..7035ea19fb 100644
--- a/modules/@angular/common/test/directives/ng_for_spec.ts
+++ b/modules/@angular/common/test/directives/ng_for_spec.ts
@@ -8,8 +8,8 @@
 
 import {NgFor, NgIf} from '@angular/common';
 import {Component, ContentChild, TemplateRef} from '@angular/core';
-import {TestComponentBuilder} from '@angular/core/testing';
-import {AsyncTestCompleter, beforeEach, beforeEachProviders, ddescribe, describe, iit, inject, it, xit} from '@angular/core/testing/testing_internal';
+import {TestBed, async} from '@angular/core/testing';
+import {ddescribe, describe, iit, inject, it, xit} from '@angular/core/testing/testing_internal';
 import {By} from '@angular/platform-browser/src/dom/debug/by';
 import {expect} from '@angular/platform-browser/testing/matchers';
 
@@ -22,545 +22,396 @@ export function main() {
     const TEMPLATE =
         '<div><copy-me template="ngFor let item of items">{{item.toString()}};</copy-me></div>';
 
-    it('should reflect initial elements',
-       inject(
-           [TestComponentBuilder, AsyncTestCompleter],
-           (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
-             tcb.overrideTemplate(TestComponent, TEMPLATE)
-                 .createAsync(TestComponent)
-                 .then((fixture) => {
-                   fixture.detectChanges();
-                   expect(fixture.debugElement.nativeElement).toHaveText('1;2;');
-                   async.done();
-                 });
-           }));
+    beforeEach(() => {
+      TestBed.configureTestingModule({
+        declarations: [TestComponent, ComponentUsingTestComponent],
+      });
+    });
 
-    it('should reflect added elements',
-       inject(
-           [TestComponentBuilder, AsyncTestCompleter],
-           (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
-             tcb.overrideTemplate(TestComponent, TEMPLATE)
-                 .createAsync(TestComponent)
-                 .then((fixture) => {
-                   fixture.detectChanges();
+    it('should reflect initial elements', async(() => {
+         TestBed.overrideComponent(TestComponent, {set: {template: TEMPLATE}});
+         let fixture = TestBed.createComponent(TestComponent);
+         fixture.detectChanges();
+         expect(fixture.debugElement.nativeElement).toHaveText('1;2;');
+       }));
 
-                   (<number[]>fixture.debugElement.componentInstance.items).push(3);
-                   fixture.detectChanges();
+    it('should reflect added elements', async(() => {
+         TestBed.overrideComponent(TestComponent, {set: {template: TEMPLATE}});
+         let fixture = TestBed.createComponent(TestComponent);
+         fixture.detectChanges();
 
-                   expect(fixture.debugElement.nativeElement).toHaveText('1;2;3;');
-                   async.done();
-                 });
-           }));
+         (<number[]>fixture.debugElement.componentInstance.items).push(3);
+         fixture.detectChanges();
 
-    it('should reflect removed elements',
-       inject(
-           [TestComponentBuilder, AsyncTestCompleter],
-           (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
-             tcb.overrideTemplate(TestComponent, TEMPLATE)
-                 .createAsync(TestComponent)
-                 .then((fixture) => {
-                   fixture.detectChanges();
+         expect(fixture.debugElement.nativeElement).toHaveText('1;2;3;');
+       }));
 
-                   ListWrapper.removeAt(fixture.debugElement.componentInstance.items, 1);
-                   fixture.detectChanges();
+    it('should reflect removed elements', async(() => {
+         TestBed.overrideComponent(TestComponent, {set: {template: TEMPLATE}});
+         let fixture = TestBed.createComponent(TestComponent);
+         fixture.detectChanges();
 
-                   expect(fixture.debugElement.nativeElement).toHaveText('1;');
-                   async.done();
-                 });
-           }));
+         ListWrapper.removeAt(fixture.debugElement.componentInstance.items, 1);
+         fixture.detectChanges();
 
-    it('should reflect moved elements',
-       inject(
-           [TestComponentBuilder, AsyncTestCompleter],
-           (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
-             tcb.overrideTemplate(TestComponent, TEMPLATE)
-                 .createAsync(TestComponent)
-                 .then((fixture) => {
-                   fixture.detectChanges();
+         expect(fixture.debugElement.nativeElement).toHaveText('1;');
+       }));
 
-                   ListWrapper.removeAt(fixture.debugElement.componentInstance.items, 0);
-                   (<number[]>fixture.debugElement.componentInstance.items).push(1);
-                   fixture.detectChanges();
+    it('should reflect moved elements', async(() => {
+         TestBed.overrideComponent(TestComponent, {set: {template: TEMPLATE}});
+         let fixture = TestBed.createComponent(TestComponent);
+         fixture.detectChanges();
 
-                   expect(fixture.debugElement.nativeElement).toHaveText('2;1;');
-                   async.done();
-                 });
-           }));
+         ListWrapper.removeAt(fixture.debugElement.componentInstance.items, 0);
+         (<number[]>fixture.debugElement.componentInstance.items).push(1);
+         fixture.detectChanges();
 
-    it('should reflect a mix of all changes (additions/removals/moves)',
-       inject(
-           [TestComponentBuilder, AsyncTestCompleter],
-           (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
-             tcb.overrideTemplate(TestComponent, TEMPLATE)
-                 .createAsync(TestComponent)
-                 .then((fixture) => {
-                   fixture.debugElement.componentInstance.items = [0, 1, 2, 3, 4, 5];
-                   fixture.detectChanges();
+         expect(fixture.debugElement.nativeElement).toHaveText('2;1;');
+       }));
 
-                   fixture.debugElement.componentInstance.items = [6, 2, 7, 0, 4, 8];
-                   fixture.detectChanges();
+    it('should reflect a mix of all changes (additions/removals/moves)', async(() => {
+         TestBed.overrideComponent(TestComponent, {set: {template: TEMPLATE}});
+         let fixture = TestBed.createComponent(TestComponent);
+         fixture.debugElement.componentInstance.items = [0, 1, 2, 3, 4, 5];
+         fixture.detectChanges();
 
-                   expect(fixture.debugElement.nativeElement).toHaveText('6;2;7;0;4;8;');
-                   async.done();
-                 });
-           }));
+         fixture.debugElement.componentInstance.items = [6, 2, 7, 0, 4, 8];
+         fixture.detectChanges();
 
-    it('should iterate over an array of objects',
-       inject(
-           [TestComponentBuilder, AsyncTestCompleter],
-           (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
-             const template =
-                 '<ul><li template="ngFor let item of items">{{item["name"]}};</li></ul>';
+         expect(fixture.debugElement.nativeElement).toHaveText('6;2;7;0;4;8;');
+       }));
 
-             tcb.overrideTemplate(TestComponent, template)
-                 .createAsync(TestComponent)
-                 .then((fixture) => {
+    it('should iterate over an array of objects', async(() => {
+         const template = '<ul><li template="ngFor let item of items">{{item["name"]}};</li></ul>';
+         TestBed.overrideComponent(TestComponent, {set: {template: template}});
+         let fixture = TestBed.createComponent(TestComponent);
 
-                   // INIT
-                   fixture.debugElement.componentInstance.items =
-                       [{'name': 'misko'}, {'name': 'shyam'}];
-                   fixture.detectChanges();
-                   expect(fixture.debugElement.nativeElement).toHaveText('misko;shyam;');
+         // INIT
+         fixture.debugElement.componentInstance.items = [{'name': 'misko'}, {'name': 'shyam'}];
+         fixture.detectChanges();
+         expect(fixture.debugElement.nativeElement).toHaveText('misko;shyam;');
 
-                   // GROW
-                   (<any[]>fixture.debugElement.componentInstance.items).push({'name': 'adam'});
-                   fixture.detectChanges();
+         // GROW
+         (<any[]>fixture.debugElement.componentInstance.items).push({'name': 'adam'});
+         fixture.detectChanges();
 
-                   expect(fixture.debugElement.nativeElement).toHaveText('misko;shyam;adam;');
+         expect(fixture.debugElement.nativeElement).toHaveText('misko;shyam;adam;');
 
-                   // SHRINK
-                   ListWrapper.removeAt(fixture.debugElement.componentInstance.items, 2);
-                   ListWrapper.removeAt(fixture.debugElement.componentInstance.items, 0);
-                   fixture.detectChanges();
+         // SHRINK
+         ListWrapper.removeAt(fixture.debugElement.componentInstance.items, 2);
+         ListWrapper.removeAt(fixture.debugElement.componentInstance.items, 0);
+         fixture.detectChanges();
 
-                   expect(fixture.debugElement.nativeElement).toHaveText('shyam;');
-                   async.done();
-                 });
-           }));
+         expect(fixture.debugElement.nativeElement).toHaveText('shyam;');
+       }));
 
-    it('should gracefully handle nulls',
-       inject(
-           [TestComponentBuilder, AsyncTestCompleter],
-           (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
-             const template = '<ul><li template="ngFor let item of null">{{item}};</li></ul>';
-             tcb.overrideTemplate(TestComponent, template)
-                 .createAsync(TestComponent)
-                 .then((fixture) => {
-                   fixture.detectChanges();
-                   expect(fixture.debugElement.nativeElement).toHaveText('');
-                   async.done();
-                 });
-           }));
+    it('should gracefully handle nulls', async(() => {
+         const template = '<ul><li template="ngFor let item of null">{{item}};</li></ul>';
+         TestBed.overrideComponent(TestComponent, {set: {template: template}});
+         let fixture = TestBed.createComponent(TestComponent);
+         fixture.detectChanges();
+         expect(fixture.debugElement.nativeElement).toHaveText('');
+       }));
 
-    it('should gracefully handle ref changing to null and back',
-       inject(
-           [TestComponentBuilder, AsyncTestCompleter],
-           (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
-             tcb.overrideTemplate(TestComponent, TEMPLATE)
-                 .createAsync(TestComponent)
-                 .then((fixture) => {
-                   fixture.detectChanges();
-                   expect(fixture.debugElement.nativeElement).toHaveText('1;2;');
+    it('should gracefully handle ref changing to null and back', async(() => {
+         TestBed.overrideComponent(TestComponent, {set: {template: TEMPLATE}});
+         let fixture = TestBed.createComponent(TestComponent);
+         fixture.detectChanges();
+         expect(fixture.debugElement.nativeElement).toHaveText('1;2;');
 
-                   fixture.debugElement.componentInstance.items = null;
-                   fixture.detectChanges();
-                   expect(fixture.debugElement.nativeElement).toHaveText('');
+         fixture.debugElement.componentInstance.items = null;
+         fixture.detectChanges();
+         expect(fixture.debugElement.nativeElement).toHaveText('');
 
-                   fixture.debugElement.componentInstance.items = [1, 2, 3];
-                   fixture.detectChanges();
-                   expect(fixture.debugElement.nativeElement).toHaveText('1;2;3;');
-                   async.done();
-                 });
-           }));
+         fixture.debugElement.componentInstance.items = [1, 2, 3];
+         fixture.detectChanges();
+         expect(fixture.debugElement.nativeElement).toHaveText('1;2;3;');
+       }));
 
-    it('should throw on non-iterable ref and suggest using an array',
-       inject(
-           [TestComponentBuilder, AsyncTestCompleter],
-           (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
-             tcb.overrideTemplate(TestComponent, TEMPLATE).createAsync(TestComponent).then((fixture) => {
-               fixture.debugElement.componentInstance.items = 'whaaa';
-               expect(() => fixture.detectChanges())
-                   .toThrowError(
-                       /Cannot find a differ supporting object 'whaaa' of type 'string'. NgFor only supports binding to Iterables such as Arrays/);
-               async.done();
-             });
-           }));
+    it('should throw on non-iterable ref and suggest using an array', async(() => {
+         TestBed.overrideComponent(TestComponent, {set: {template: TEMPLATE}});
+         let fixture = TestBed.createComponent(TestComponent);
+         fixture.debugElement.componentInstance.items = 'whaaa';
+         expect(() => fixture.detectChanges())
+             .toThrowError(
+                 /Cannot find a differ supporting object 'whaaa' of type 'string'. NgFor only supports binding to Iterables such as Arrays/);
+       }));
 
-    it('should throw on ref changing to string',
-       inject(
-           [TestComponentBuilder, AsyncTestCompleter],
-           (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
-             tcb.overrideTemplate(TestComponent, TEMPLATE)
-                 .createAsync(TestComponent)
-                 .then((fixture) => {
-                   fixture.detectChanges();
-                   expect(fixture.debugElement.nativeElement).toHaveText('1;2;');
+    it('should throw on ref changing to string', async(() => {
+         TestBed.overrideComponent(TestComponent, {set: {template: TEMPLATE}});
+         let fixture = TestBed.createComponent(TestComponent);
+         fixture.detectChanges();
+         expect(fixture.debugElement.nativeElement).toHaveText('1;2;');
 
-                   fixture.debugElement.componentInstance.items = 'whaaa';
-                   expect(() => fixture.detectChanges()).toThrowError();
-                   async.done();
-                 });
-           }));
+         fixture.debugElement.componentInstance.items = 'whaaa';
+         expect(() => fixture.detectChanges()).toThrowError();
+       }));
 
-    it('should works with duplicates',
-       inject(
-           [TestComponentBuilder, AsyncTestCompleter],
-           (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
-             tcb.overrideTemplate(TestComponent, TEMPLATE)
-                 .createAsync(TestComponent)
-                 .then((fixture) => {
-                   var a = new Foo();
-                   fixture.debugElement.componentInstance.items = [a, a];
-                   fixture.detectChanges();
-                   expect(fixture.debugElement.nativeElement).toHaveText('foo;foo;');
-                   async.done();
-                 });
-           }));
+    it('should works with duplicates', async(() => {
+         TestBed.overrideComponent(TestComponent, {set: {template: TEMPLATE}});
+         let fixture = TestBed.createComponent(TestComponent);
+         var a = new Foo();
+         fixture.debugElement.componentInstance.items = [a, a];
+         fixture.detectChanges();
+         expect(fixture.debugElement.nativeElement).toHaveText('foo;foo;');
+       }));
 
-    it('should repeat over nested arrays',
-       inject(
-           [TestComponentBuilder, AsyncTestCompleter],
-           (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
-             const template = '<div>' +
-                 '<div template="ngFor let item of items">' +
-                 '<div template="ngFor let subitem of item">' +
-                 '{{subitem}}-{{item.length}};' +
-                 '</div>|' +
-                 '</div>' +
-                 '</div>';
+    it('should repeat over nested arrays', async(() => {
+         const template = '<div>' +
+             '<div template="ngFor let item of items">' +
+             '<div template="ngFor let subitem of item">' +
+             '{{subitem}}-{{item.length}};' +
+             '</div>|' +
+             '</div>' +
+             '</div>';
+         TestBed.overrideComponent(TestComponent, {set: {template: template}});
+         let fixture = TestBed.createComponent(TestComponent);
 
-             tcb.overrideTemplate(TestComponent, template)
-                 .createAsync(TestComponent)
-                 .then((fixture) => {
-                   fixture.debugElement.componentInstance.items = [['a', 'b'], ['c']];
-                   fixture.detectChanges();
-                   fixture.detectChanges();
-                   fixture.detectChanges();
-                   expect(fixture.debugElement.nativeElement).toHaveText('a-2;b-2;|c-1;|');
+         fixture.debugElement.componentInstance.items = [['a', 'b'], ['c']];
+         fixture.detectChanges();
+         fixture.detectChanges();
+         fixture.detectChanges();
+         expect(fixture.debugElement.nativeElement).toHaveText('a-2;b-2;|c-1;|');
 
-                   fixture.debugElement.componentInstance.items = [['e'], ['f', 'g']];
-                   fixture.detectChanges();
-                   expect(fixture.debugElement.nativeElement).toHaveText('e-1;|f-2;g-2;|');
+         fixture.debugElement.componentInstance.items = [['e'], ['f', 'g']];
+         fixture.detectChanges();
+         expect(fixture.debugElement.nativeElement).toHaveText('e-1;|f-2;g-2;|');
+       }));
 
-                   async.done();
-                 });
-           }));
+    it('should repeat over nested arrays with no intermediate element', async(() => {
+         const template = '<div><template ngFor let-item [ngForOf]="items">' +
+             '<div template="ngFor let subitem of item">' +
+             '{{subitem}}-{{item.length}};' +
+             '</div></template></div>';
+         TestBed.overrideComponent(TestComponent, {set: {template: template}});
+         let fixture = TestBed.createComponent(TestComponent);
 
-    it('should repeat over nested arrays with no intermediate element',
-       inject(
-           [TestComponentBuilder, AsyncTestCompleter],
-           (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
-             const template = '<div><template ngFor let-item [ngForOf]="items">' +
-                 '<div template="ngFor let subitem of item">' +
-                 '{{subitem}}-{{item.length}};' +
-                 '</div></template></div>';
+         fixture.debugElement.componentInstance.items = [['a', 'b'], ['c']];
+         fixture.detectChanges();
+         expect(fixture.debugElement.nativeElement).toHaveText('a-2;b-2;c-1;');
 
-             tcb.overrideTemplate(TestComponent, template)
-                 .createAsync(TestComponent)
-                 .then((fixture) => {
-                   fixture.debugElement.componentInstance.items = [['a', 'b'], ['c']];
-                   fixture.detectChanges();
-                   expect(fixture.debugElement.nativeElement).toHaveText('a-2;b-2;c-1;');
+         fixture.debugElement.componentInstance.items = [['e'], ['f', 'g']];
+         fixture.detectChanges();
+         expect(fixture.debugElement.nativeElement).toHaveText('e-1;f-2;g-2;');
+       }));
 
-                   fixture.debugElement.componentInstance.items = [['e'], ['f', 'g']];
-                   fixture.detectChanges();
-                   expect(fixture.debugElement.nativeElement).toHaveText('e-1;f-2;g-2;');
-                   async.done();
-                 });
-           }));
+    it('should repeat over nested ngIf that are the last node in the ngFor temlate', async(() => {
+         const template =
+             `<div><template ngFor let-item [ngForOf]="items" let-i="index"><div>{{i}}|</div>` +
+             `<div *ngIf="i % 2 == 0">even|</div></template></div>`;
 
-    it('should repeat over nested ngIf that are the last node in the ngFor temlate',
-       inject(
-           [TestComponentBuilder, AsyncTestCompleter],
-           (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
-             const template =
-                 `<div><template ngFor let-item [ngForOf]="items" let-i="index"><div>{{i}}|</div>` +
-                 `<div *ngIf="i % 2 == 0">even|</div></template></div>`;
+         TestBed.overrideComponent(TestComponent, {set: {template: template}});
+         let fixture = TestBed.createComponent(TestComponent);
 
-             tcb.overrideTemplate(TestComponent, template)
-                 .createAsync(TestComponent)
-                 .then((fixture) => {
-                   const el = fixture.debugElement.nativeElement;
-                   const items = [1];
-                   fixture.debugElement.componentInstance.items = items;
-                   fixture.detectChanges();
-                   expect(el).toHaveText('0|even|');
+         const el = fixture.debugElement.nativeElement;
+         const items = [1];
+         fixture.debugElement.componentInstance.items = items;
+         fixture.detectChanges();
+         expect(el).toHaveText('0|even|');
 
-                   items.push(1);
-                   fixture.detectChanges();
-                   expect(el).toHaveText('0|even|1|');
+         items.push(1);
+         fixture.detectChanges();
+         expect(el).toHaveText('0|even|1|');
 
-                   items.push(1);
-                   fixture.detectChanges();
-                   expect(el).toHaveText('0|even|1|2|even|');
+         items.push(1);
+         fixture.detectChanges();
+         expect(el).toHaveText('0|even|1|2|even|');
+       }));
 
-                   async.done();
-                 });
-           }));
+    it('should display indices correctly', async(() => {
+         const template =
+             '<div><copy-me template="ngFor: let item of items; let i=index">{{i.toString()}}</copy-me></div>';
+         TestBed.overrideComponent(TestComponent, {set: {template: template}});
+         let fixture = TestBed.createComponent(TestComponent);
 
-    it('should display indices correctly',
-       inject(
-           [TestComponentBuilder, AsyncTestCompleter],
-           (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
-             const template =
-                 '<div><copy-me template="ngFor: let item of items; let i=index">{{i.toString()}}</copy-me></div>';
+         fixture.debugElement.componentInstance.items = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
+         fixture.detectChanges();
+         expect(fixture.debugElement.nativeElement).toHaveText('0123456789');
 
-             tcb.overrideTemplate(TestComponent, template)
-                 .createAsync(TestComponent)
-                 .then((fixture) => {
-                   fixture.debugElement.componentInstance.items = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
-                   fixture.detectChanges();
-                   expect(fixture.debugElement.nativeElement).toHaveText('0123456789');
+         fixture.debugElement.componentInstance.items = [1, 2, 6, 7, 4, 3, 5, 8, 9, 0];
+         fixture.detectChanges();
+         expect(fixture.debugElement.nativeElement).toHaveText('0123456789');
+       }));
 
-                   fixture.debugElement.componentInstance.items = [1, 2, 6, 7, 4, 3, 5, 8, 9, 0];
-                   fixture.detectChanges();
-                   expect(fixture.debugElement.nativeElement).toHaveText('0123456789');
-                   async.done();
-                 });
-           }));
+    it('should display first item correctly', async(() => {
+         const template =
+             '<div><copy-me template="ngFor: let item of items; let isFirst=first">{{isFirst.toString()}}</copy-me></div>';
+         TestBed.overrideComponent(TestComponent, {set: {template: template}});
+         let fixture = TestBed.createComponent(TestComponent);
 
-    it('should display first item correctly',
-       inject(
-           [TestComponentBuilder, AsyncTestCompleter],
-           (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
-             const template =
-                 '<div><copy-me template="ngFor: let item of items; let isFirst=first">{{isFirst.toString()}}</copy-me></div>';
+         fixture.debugElement.componentInstance.items = [0, 1, 2];
+         fixture.detectChanges();
+         expect(fixture.debugElement.nativeElement).toHaveText('truefalsefalse');
 
-             tcb.overrideTemplate(TestComponent, template)
-                 .createAsync(TestComponent)
-                 .then((fixture) => {
-                   fixture.debugElement.componentInstance.items = [0, 1, 2];
-                   fixture.detectChanges();
-                   expect(fixture.debugElement.nativeElement).toHaveText('truefalsefalse');
+         fixture.debugElement.componentInstance.items = [2, 1];
+         fixture.detectChanges();
+         expect(fixture.debugElement.nativeElement).toHaveText('truefalse');
+       }));
 
-                   fixture.debugElement.componentInstance.items = [2, 1];
-                   fixture.detectChanges();
-                   expect(fixture.debugElement.nativeElement).toHaveText('truefalse');
-                   async.done();
-                 });
-           }));
+    it('should display last item correctly', async(() => {
+         const template =
+             '<div><copy-me template="ngFor: let item of items; let isLast=last">{{isLast.toString()}}</copy-me></div>';
+         TestBed.overrideComponent(TestComponent, {set: {template: template}});
+         let fixture = TestBed.createComponent(TestComponent);
 
-    it('should display last item correctly',
-       inject(
-           [TestComponentBuilder, AsyncTestCompleter],
-           (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
-             const template =
-                 '<div><copy-me template="ngFor: let item of items; let isLast=last">{{isLast.toString()}}</copy-me></div>';
+         fixture.debugElement.componentInstance.items = [0, 1, 2];
+         fixture.detectChanges();
+         expect(fixture.debugElement.nativeElement).toHaveText('falsefalsetrue');
 
-             tcb.overrideTemplate(TestComponent, template)
-                 .createAsync(TestComponent)
-                 .then((fixture) => {
-                   fixture.debugElement.componentInstance.items = [0, 1, 2];
-                   fixture.detectChanges();
-                   expect(fixture.debugElement.nativeElement).toHaveText('falsefalsetrue');
+         fixture.debugElement.componentInstance.items = [2, 1];
+         fixture.detectChanges();
+         expect(fixture.debugElement.nativeElement).toHaveText('falsetrue');
+       }));
 
-                   fixture.debugElement.componentInstance.items = [2, 1];
-                   fixture.detectChanges();
-                   expect(fixture.debugElement.nativeElement).toHaveText('falsetrue');
-                   async.done();
-                 });
-           }));
+    it('should display even items correctly', async(() => {
+         const template =
+             '<div><copy-me template="ngFor: let item of items; let isEven=even">{{isEven.toString()}}</copy-me></div>';
+         TestBed.overrideComponent(TestComponent, {set: {template: template}});
+         let fixture = TestBed.createComponent(TestComponent);
 
-    it('should display even items correctly',
-       inject(
-           [TestComponentBuilder, AsyncTestCompleter],
-           (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
-             const template =
-                 '<div><copy-me template="ngFor: let item of items; let isEven=even">{{isEven.toString()}}</copy-me></div>';
+         fixture.debugElement.componentInstance.items = [0, 1, 2];
+         fixture.detectChanges();
+         expect(fixture.debugElement.nativeElement).toHaveText('truefalsetrue');
 
-             tcb.overrideTemplate(TestComponent, template)
-                 .createAsync(TestComponent)
-                 .then((fixture) => {
-                   fixture.debugElement.componentInstance.items = [0, 1, 2];
-                   fixture.detectChanges();
-                   expect(fixture.debugElement.nativeElement).toHaveText('truefalsetrue');
+         fixture.debugElement.componentInstance.items = [2, 1];
+         fixture.detectChanges();
+         expect(fixture.debugElement.nativeElement).toHaveText('truefalse');
+       }));
 
-                   fixture.debugElement.componentInstance.items = [2, 1];
-                   fixture.detectChanges();
-                   expect(fixture.debugElement.nativeElement).toHaveText('truefalse');
-                   async.done();
-                 });
-           }));
+    it('should display odd items correctly', async(() => {
+         const template =
+             '<div><copy-me template="ngFor: let item of items; let isOdd=odd">{{isOdd.toString()}}</copy-me></div>';
+         TestBed.overrideComponent(TestComponent, {set: {template: template}});
+         let fixture = TestBed.createComponent(TestComponent);
 
-    it('should display odd items correctly',
-       inject(
-           [TestComponentBuilder, AsyncTestCompleter],
-           (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
-             const template =
-                 '<div><copy-me template="ngFor: let item of items; let isOdd=odd">{{isOdd.toString()}}</copy-me></div>';
+         fixture.debugElement.componentInstance.items = [0, 1, 2, 3];
+         fixture.detectChanges();
+         expect(fixture.debugElement.nativeElement).toHaveText('falsetruefalsetrue');
 
-             tcb.overrideTemplate(TestComponent, template)
-                 .createAsync(TestComponent)
-                 .then((fixture) => {
-                   fixture.debugElement.componentInstance.items = [0, 1, 2, 3];
-                   fixture.detectChanges();
-                   expect(fixture.debugElement.nativeElement).toHaveText('falsetruefalsetrue');
+         fixture.debugElement.componentInstance.items = [2, 1];
+         fixture.detectChanges();
+         expect(fixture.debugElement.nativeElement).toHaveText('falsetrue');
+       }));
 
-                   fixture.debugElement.componentInstance.items = [2, 1];
-                   fixture.detectChanges();
-                   expect(fixture.debugElement.nativeElement).toHaveText('falsetrue');
-                   async.done();
-                 });
-           }));
+    it('should allow to use a custom template', async(() => {
+         const tcTemplate =
+             '<ul><template ngFor [ngForOf]="items" [ngForTemplate]="contentTpl"></template></ul>';
+         TestBed.overrideComponent(TestComponent, {set: {template: tcTemplate}});
+         const cutTemplate =
+             '<test-cmp><li template="let item; let i=index">{{i}}: {{item}};</li></test-cmp>';
+         TestBed.overrideComponent(ComponentUsingTestComponent, {set: {template: cutTemplate}});
+         let fixture = TestBed.createComponent(ComponentUsingTestComponent);
 
-    it('should allow to use a custom template',
-       inject(
-           [TestComponentBuilder, AsyncTestCompleter],
-           (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
-             tcb.overrideTemplate(
-                    TestComponent,
-                    '<ul><template ngFor [ngForOf]="items" [ngForTemplate]="contentTpl"></template></ul>')
-                 .overrideTemplate(
-                     ComponentUsingTestComponent,
-                     '<test-cmp><li template="let item; let i=index">{{i}}: {{item}};</li></test-cmp>')
-                 .createAsync(ComponentUsingTestComponent)
-                 .then((fixture) => {
-                   const testComponent = fixture.debugElement.children[0];
-                   testComponent.componentInstance.items = ['a', 'b', 'c'];
-                   fixture.detectChanges();
-                   expect(testComponent.nativeElement).toHaveText('0: a;1: b;2: c;');
+         const testComponent = fixture.debugElement.children[0];
+         testComponent.componentInstance.items = ['a', 'b', 'c'];
+         fixture.detectChanges();
+         expect(testComponent.nativeElement).toHaveText('0: a;1: b;2: c;');
+       }));
 
-                   async.done();
-                 });
-           }));
+    it('should use a default template if a custom one is null', async(() => {
+         const testTemplate = `<ul><template ngFor let-item [ngForOf]="items" 
+            [ngForTemplate]="contentTpl" let-i="index">{{i}}: {{item}};</template></ul>`;
+         TestBed.overrideComponent(TestComponent, {set: {template: testTemplate}});
+         const cutTemplate =
+             '<test-cmp><li template="let item; let i=index">{{i}}: {{item}};</li></test-cmp>';
+         TestBed.overrideComponent(ComponentUsingTestComponent, {set: {template: cutTemplate}});
+         let fixture = TestBed.createComponent(ComponentUsingTestComponent);
 
-    it('should use a default template if a custom one is null',
-       inject(
-           [TestComponentBuilder, AsyncTestCompleter],
-           (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
-             tcb.overrideTemplate(TestComponent, `<ul><template ngFor let-item [ngForOf]="items"
-         [ngForTemplate]="contentTpl" let-i="index">{{i}}: {{item}};</template></ul>`)
-                 .overrideTemplate(ComponentUsingTestComponent, '<test-cmp></test-cmp>')
-                 .createAsync(ComponentUsingTestComponent)
-                 .then((fixture) => {
-                   const testComponent = fixture.debugElement.children[0];
-                   testComponent.componentInstance.items = ['a', 'b', 'c'];
-                   fixture.detectChanges();
-                   expect(testComponent.nativeElement).toHaveText('0: a;1: b;2: c;');
+         const testComponent = fixture.debugElement.children[0];
+         testComponent.componentInstance.items = ['a', 'b', 'c'];
+         fixture.detectChanges();
+         expect(testComponent.nativeElement).toHaveText('0: a;1: b;2: c;');
+       }));
 
-                   async.done();
-                 });
-           }));
+    it('should use a custom template when both default and a custom one are present', async(() => {
+         const testTemplate = `<ul><template ngFor let-item [ngForOf]="items"
+         [ngForTemplate]="contentTpl" let-i="index">{{i}}=> {{item}};</template></ul>`;
+         TestBed.overrideComponent(TestComponent, {set: {template: testTemplate}});
+         const cutTemplate =
+             '<test-cmp><li template="let item; let i=index">{{i}}: {{item}};</li></test-cmp>';
+         TestBed.overrideComponent(ComponentUsingTestComponent, {set: {template: cutTemplate}});
+         let fixture = TestBed.createComponent(ComponentUsingTestComponent);
 
-    it('should use a custom template when both default and a custom one are present',
-       inject(
-           [TestComponentBuilder, AsyncTestCompleter],
-           (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
-             tcb.overrideTemplate(TestComponent, `<ul><template ngFor let-item [ngForOf]="items"
-         [ngForTemplate]="contentTpl" let-i="index">{{i}}=> {{item}};</template></ul>`)
-                 .overrideTemplate(
-                     ComponentUsingTestComponent,
-                     '<test-cmp><li template="let item; let i=index">{{i}}: {{item}};</li></test-cmp>')
-                 .createAsync(ComponentUsingTestComponent)
-                 .then((fixture) => {
-                   const testComponent = fixture.debugElement.children[0];
-                   testComponent.componentInstance.items = ['a', 'b', 'c'];
-                   fixture.detectChanges();
-                   expect(testComponent.nativeElement).toHaveText('0: a;1: b;2: c;');
-
-                   async.done();
-                 });
-           }));
+         const testComponent = fixture.debugElement.children[0];
+         testComponent.componentInstance.items = ['a', 'b', 'c'];
+         fixture.detectChanges();
+         expect(testComponent.nativeElement).toHaveText('0: a;1: b;2: c;');
+       }));
 
     describe('track by', () => {
-      it('should set the context to the component instance',
-         inject(
-             [TestComponentBuilder, AsyncTestCompleter],
-             (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
-               const template =
-                   `<template ngFor let-item [ngForOf]="items" [ngForTrackBy]="trackByContext.bind(this)"></template>`;
-               tcb.overrideTemplate(TestComponent, template)
-                   .createAsync(TestComponent)
-                   .then((fixture) => {
-                     thisArg = null;
-                     fixture.detectChanges();
-                     expect(thisArg).toBe(fixture.debugElement.componentInstance);
-                     async.done();
-                   });
-             }));
+      it('should set the context to the component instance', async(() => {
+           const template =
+               `<template ngFor let-item [ngForOf]="items" [ngForTrackBy]="trackByContext.bind(this)"></template>`;
+           TestBed.overrideComponent(TestComponent, {set: {template: template}});
+           let fixture = TestBed.createComponent(TestComponent);
 
-      it('should not replace tracked items',
-         inject(
-             [TestComponentBuilder, AsyncTestCompleter],
-             (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
-               const template =
-                   `<template ngFor let-item [ngForOf]="items" [ngForTrackBy]="trackById" let-i="index">
+           thisArg = null;
+           fixture.detectChanges();
+           expect(thisArg).toBe(fixture.debugElement.componentInstance);
+         }));
+
+      it('should not replace tracked items', async(() => {
+           const template =
+               `<template ngFor let-item [ngForOf]="items" [ngForTrackBy]="trackById" let-i="index">
                <p>{{items[i]}}</p>
               </template>`;
-               tcb.overrideTemplate(TestComponent, template)
-                   .createAsync(TestComponent)
-                   .then((fixture) => {
-                     var buildItemList = () => {
-                       fixture.debugElement.componentInstance.items = [{'id': 'a'}];
-                       fixture.detectChanges();
-                       return fixture.debugElement.queryAll(By.css('p'))[0];
-                     };
+           TestBed.overrideComponent(TestComponent, {set: {template: template}});
+           let fixture = TestBed.createComponent(TestComponent);
 
-                     var firstP = buildItemList();
-                     var finalP = buildItemList();
-                     expect(finalP.nativeElement).toBe(firstP.nativeElement);
-                     async.done();
-                   });
-             }));
+           var buildItemList = () => {
+             fixture.debugElement.componentInstance.items = [{'id': 'a'}];
+             fixture.detectChanges();
+             return fixture.debugElement.queryAll(By.css('p'))[0];
+           };
 
-      it('should update implicit local variable on view',
-         inject(
-             [TestComponentBuilder, AsyncTestCompleter],
-             (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
-               const template =
-                   `<div><template ngFor let-item [ngForOf]="items" [ngForTrackBy]="trackById">{{item['color']}}</template></div>`;
-               tcb.overrideTemplate(TestComponent, template)
-                   .createAsync(TestComponent)
-                   .then((fixture) => {
-                     fixture.debugElement.componentInstance.items = [{'id': 'a', 'color': 'blue'}];
-                     fixture.detectChanges();
-                     expect(fixture.debugElement.nativeElement).toHaveText('blue');
-                     fixture.debugElement.componentInstance.items = [{'id': 'a', 'color': 'red'}];
-                     fixture.detectChanges();
-                     expect(fixture.debugElement.nativeElement).toHaveText('red');
-                     async.done();
-                   });
-             }));
-      it('should move items around and keep them updated ',
-         inject(
-             [TestComponentBuilder, AsyncTestCompleter],
-             (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
-               const template =
-                   `<div><template ngFor let-item [ngForOf]="items" [ngForTrackBy]="trackById">{{item['color']}}</template></div>`;
-               tcb.overrideTemplate(TestComponent, template)
-                   .createAsync(TestComponent)
-                   .then((fixture) => {
-                     fixture.debugElement.componentInstance.items =
-                         [{'id': 'a', 'color': 'blue'}, {'id': 'b', 'color': 'yellow'}];
-                     fixture.detectChanges();
-                     expect(fixture.debugElement.nativeElement).toHaveText('blueyellow');
-                     fixture.debugElement.componentInstance.items =
-                         [{'id': 'b', 'color': 'orange'}, {'id': 'a', 'color': 'red'}];
-                     fixture.detectChanges();
-                     expect(fixture.debugElement.nativeElement).toHaveText('orangered');
-                     async.done();
-                   });
-             }));
+           var firstP = buildItemList();
+           var finalP = buildItemList();
+           expect(finalP.nativeElement).toBe(firstP.nativeElement);
+         }));
 
-      it('should handle added and removed items properly when tracking by index',
-         inject(
-             [TestComponentBuilder, AsyncTestCompleter],
-             (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
-               const template =
-                   `<div><template ngFor let-item [ngForOf]="items" [ngForTrackBy]="trackByIndex">{{item}}</template></div>`;
-               tcb.overrideTemplate(TestComponent, template)
-                   .createAsync(TestComponent)
-                   .then((fixture) => {
-                     fixture.debugElement.componentInstance.items = ['a', 'b', 'c', 'd'];
-                     fixture.detectChanges();
-                     fixture.debugElement.componentInstance.items = ['e', 'f', 'g', 'h'];
-                     fixture.detectChanges();
-                     fixture.debugElement.componentInstance.items = ['e', 'f', 'h'];
-                     fixture.detectChanges();
-                     expect(fixture.debugElement.nativeElement).toHaveText('efh');
-                     async.done();
-                   });
-             }));
+      it('should update implicit local variable on view', async(() => {
+           const template =
+               `<div><template ngFor let-item [ngForOf]="items" [ngForTrackBy]="trackById">{{item['color']}}</template></div>`;
+           TestBed.overrideComponent(TestComponent, {set: {template: template}});
+           let fixture = TestBed.createComponent(TestComponent);
+
+           fixture.debugElement.componentInstance.items = [{'id': 'a', 'color': 'blue'}];
+           fixture.detectChanges();
+           expect(fixture.debugElement.nativeElement).toHaveText('blue');
+           fixture.debugElement.componentInstance.items = [{'id': 'a', 'color': 'red'}];
+           fixture.detectChanges();
+           expect(fixture.debugElement.nativeElement).toHaveText('red');
+         }));
+      it('should move items around and keep them updated ', async(() => {
+           const template =
+               `<div><template ngFor let-item [ngForOf]="items" [ngForTrackBy]="trackById">{{item['color']}}</template></div>`;
+           TestBed.overrideComponent(TestComponent, {set: {template: template}});
+           let fixture = TestBed.createComponent(TestComponent);
+
+           fixture.debugElement.componentInstance.items =
+               [{'id': 'a', 'color': 'blue'}, {'id': 'b', 'color': 'yellow'}];
+           fixture.detectChanges();
+           expect(fixture.debugElement.nativeElement).toHaveText('blueyellow');
+           fixture.debugElement.componentInstance.items =
+               [{'id': 'b', 'color': 'orange'}, {'id': 'a', 'color': 'red'}];
+           fixture.detectChanges();
+           expect(fixture.debugElement.nativeElement).toHaveText('orangered');
+         }));
+
+      it('should handle added and removed items properly when tracking by index', async(() => {
+           const template =
+               `<div><template ngFor let-item [ngForOf]="items" [ngForTrackBy]="trackByIndex">{{item}}</template></div>`;
+           TestBed.overrideComponent(TestComponent, {set: {template: template}});
+           let fixture = TestBed.createComponent(TestComponent);
+
+           fixture.debugElement.componentInstance.items = ['a', 'b', 'c', 'd'];
+           fixture.detectChanges();
+           fixture.debugElement.componentInstance.items = ['e', 'f', 'g', 'h'];
+           fixture.detectChanges();
+           fixture.debugElement.componentInstance.items = ['e', 'f', 'h'];
+           fixture.detectChanges();
+           expect(fixture.debugElement.nativeElement).toHaveText('efh');
+         }));
     });
   });
 }
diff --git a/modules/@angular/common/test/directives/ng_if_spec.ts b/modules/@angular/common/test/directives/ng_if_spec.ts
index 5a61a0648b..aba59c417b 100644
--- a/modules/@angular/common/test/directives/ng_if_spec.ts
+++ b/modules/@angular/common/test/directives/ng_if_spec.ts
@@ -8,236 +8,166 @@
 
 import {NgIf} from '@angular/common';
 import {Component} from '@angular/core';
-import {TestComponentBuilder} from '@angular/core/testing';
-import {AsyncTestCompleter, beforeEach, ddescribe, describe, iit, inject, it, xit} from '@angular/core/testing/testing_internal';
+import {TestBed, async} from '@angular/core/testing';
+import {beforeEach, ddescribe, describe, iit, inject, it, xit} from '@angular/core/testing/testing_internal';
 import {getDOM} from '@angular/platform-browser/src/dom/dom_adapter';
 import {expect} from '@angular/platform-browser/testing/matchers';
 
 export function main() {
   describe('ngIf directive', () => {
-    it('should work in a template attribute',
-       inject(
-           [TestComponentBuilder, AsyncTestCompleter],
-           (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
-             var html = '<div><copy-me template="ngIf booleanCondition">hello</copy-me></div>';
 
-             tcb.overrideTemplate(TestComponent, html)
-                 .createAsync(TestComponent)
-                 .then((fixture) => {
-                   fixture.detectChanges();
-                   expect(getDOM()
-                              .querySelectorAll(fixture.debugElement.nativeElement, 'copy-me')
-                              .length)
-                       .toEqual(1);
-                   expect(fixture.debugElement.nativeElement).toHaveText('hello');
-                   async.done();
-                 });
-           }));
+    beforeEach(() => {
+      TestBed.configureTestingModule({
+        declarations: [TestComponent],
+      });
+    });
 
-    it('should work in a template element',
-       inject(
-           [TestComponentBuilder, AsyncTestCompleter],
-           (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
-             var html =
-                 '<div><template [ngIf]="booleanCondition"><copy-me>hello2</copy-me></template></div>';
+    it('should work in a template attribute', async(() => {
+         const template = '<div><copy-me template="ngIf booleanCondition">hello</copy-me></div>';
 
-             tcb.overrideTemplate(TestComponent, html)
-                 .createAsync(TestComponent)
-                 .then((fixture) => {
-                   fixture.detectChanges();
-                   expect(getDOM()
-                              .querySelectorAll(fixture.debugElement.nativeElement, 'copy-me')
-                              .length)
-                       .toEqual(1);
-                   expect(fixture.debugElement.nativeElement).toHaveText('hello2');
-                   async.done();
-                 });
-           }));
+         TestBed.overrideComponent(TestComponent, {set: {template: template}});
+         let fixture = TestBed.createComponent(TestComponent);
+         fixture.detectChanges();
+         expect(getDOM().querySelectorAll(fixture.debugElement.nativeElement, 'copy-me').length)
+             .toEqual(1);
+         expect(fixture.debugElement.nativeElement).toHaveText('hello');
+       }));
 
-    it('should toggle node when condition changes',
-       inject(
-           [TestComponentBuilder, AsyncTestCompleter],
-           (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
-             var html = '<div><copy-me template="ngIf booleanCondition">hello</copy-me></div>';
+    it('should work in a template element', async(() => {
+         const template =
+             '<div><template [ngIf]="booleanCondition"><copy-me>hello2</copy-me></template></div>';
 
-             tcb.overrideTemplate(TestComponent, html)
-                 .createAsync(TestComponent)
-                 .then((fixture) => {
-                   fixture.debugElement.componentInstance.booleanCondition = false;
-                   fixture.detectChanges();
-                   expect(getDOM()
-                              .querySelectorAll(fixture.debugElement.nativeElement, 'copy-me')
-                              .length)
-                       .toEqual(0);
-                   expect(fixture.debugElement.nativeElement).toHaveText('');
+         TestBed.overrideComponent(TestComponent, {set: {template: template}});
+         let fixture = TestBed.createComponent(TestComponent);
+         fixture.detectChanges();
+         expect(getDOM().querySelectorAll(fixture.debugElement.nativeElement, 'copy-me').length)
+             .toEqual(1);
+         expect(fixture.debugElement.nativeElement).toHaveText('hello2');
+       }));
 
-                   fixture.debugElement.componentInstance.booleanCondition = true;
-                   fixture.detectChanges();
-                   expect(getDOM()
-                              .querySelectorAll(fixture.debugElement.nativeElement, 'copy-me')
-                              .length)
-                       .toEqual(1);
-                   expect(fixture.debugElement.nativeElement).toHaveText('hello');
+    it('should toggle node when condition changes', async(() => {
+         const template = '<div><copy-me template="ngIf booleanCondition">hello</copy-me></div>';
 
-                   fixture.debugElement.componentInstance.booleanCondition = false;
-                   fixture.detectChanges();
-                   expect(getDOM()
-                              .querySelectorAll(fixture.debugElement.nativeElement, 'copy-me')
-                              .length)
-                       .toEqual(0);
-                   expect(fixture.debugElement.nativeElement).toHaveText('');
+         TestBed.overrideComponent(TestComponent, {set: {template: template}});
+         let fixture = TestBed.createComponent(TestComponent);
+         fixture.debugElement.componentInstance.booleanCondition = false;
+         fixture.detectChanges();
+         expect(getDOM().querySelectorAll(fixture.debugElement.nativeElement, 'copy-me').length)
+             .toEqual(0);
+         expect(fixture.debugElement.nativeElement).toHaveText('');
 
-                   async.done();
-                 });
-           }));
+         fixture.debugElement.componentInstance.booleanCondition = true;
+         fixture.detectChanges();
+         expect(getDOM().querySelectorAll(fixture.debugElement.nativeElement, 'copy-me').length)
+             .toEqual(1);
+         expect(fixture.debugElement.nativeElement).toHaveText('hello');
 
-    it('should handle nested if correctly',
-       inject(
-           [TestComponentBuilder, AsyncTestCompleter],
-           (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
-             var html =
-                 '<div><template [ngIf]="booleanCondition"><copy-me *ngIf="nestedBooleanCondition">hello</copy-me></template></div>';
+         fixture.debugElement.componentInstance.booleanCondition = false;
+         fixture.detectChanges();
+         expect(getDOM().querySelectorAll(fixture.debugElement.nativeElement, 'copy-me').length)
+             .toEqual(0);
+         expect(fixture.debugElement.nativeElement).toHaveText('');
+       }));
 
-             tcb.overrideTemplate(TestComponent, html)
-                 .createAsync(TestComponent)
-                 .then((fixture) => {
-                   fixture.debugElement.componentInstance.booleanCondition = false;
-                   fixture.detectChanges();
-                   expect(getDOM()
-                              .querySelectorAll(fixture.debugElement.nativeElement, 'copy-me')
-                              .length)
-                       .toEqual(0);
-                   expect(fixture.debugElement.nativeElement).toHaveText('');
+    it('should handle nested if correctly', async(() => {
+         const template =
+             '<div><template [ngIf]="booleanCondition"><copy-me *ngIf="nestedBooleanCondition">hello</copy-me></template></div>';
 
-                   fixture.debugElement.componentInstance.booleanCondition = true;
-                   fixture.detectChanges();
-                   expect(getDOM()
-                              .querySelectorAll(fixture.debugElement.nativeElement, 'copy-me')
-                              .length)
-                       .toEqual(1);
-                   expect(fixture.debugElement.nativeElement).toHaveText('hello');
+         TestBed.overrideComponent(TestComponent, {set: {template: template}});
+         let fixture = TestBed.createComponent(TestComponent);
+         fixture.debugElement.componentInstance.booleanCondition = false;
+         fixture.detectChanges();
+         expect(getDOM().querySelectorAll(fixture.debugElement.nativeElement, 'copy-me').length)
+             .toEqual(0);
+         expect(fixture.debugElement.nativeElement).toHaveText('');
 
-                   fixture.debugElement.componentInstance.nestedBooleanCondition = false;
-                   fixture.detectChanges();
-                   expect(getDOM()
-                              .querySelectorAll(fixture.debugElement.nativeElement, 'copy-me')
-                              .length)
-                       .toEqual(0);
-                   expect(fixture.debugElement.nativeElement).toHaveText('');
+         fixture.debugElement.componentInstance.booleanCondition = true;
+         fixture.detectChanges();
+         expect(getDOM().querySelectorAll(fixture.debugElement.nativeElement, 'copy-me').length)
+             .toEqual(1);
+         expect(fixture.debugElement.nativeElement).toHaveText('hello');
 
-                   fixture.debugElement.componentInstance.nestedBooleanCondition = true;
-                   fixture.detectChanges();
-                   expect(getDOM()
-                              .querySelectorAll(fixture.debugElement.nativeElement, 'copy-me')
-                              .length)
-                       .toEqual(1);
-                   expect(fixture.debugElement.nativeElement).toHaveText('hello');
+         fixture.debugElement.componentInstance.nestedBooleanCondition = false;
+         fixture.detectChanges();
+         expect(getDOM().querySelectorAll(fixture.debugElement.nativeElement, 'copy-me').length)
+             .toEqual(0);
+         expect(fixture.debugElement.nativeElement).toHaveText('');
 
-                   fixture.debugElement.componentInstance.booleanCondition = false;
-                   fixture.detectChanges();
-                   expect(getDOM()
-                              .querySelectorAll(fixture.debugElement.nativeElement, 'copy-me')
-                              .length)
-                       .toEqual(0);
-                   expect(fixture.debugElement.nativeElement).toHaveText('');
+         fixture.debugElement.componentInstance.nestedBooleanCondition = true;
+         fixture.detectChanges();
+         expect(getDOM().querySelectorAll(fixture.debugElement.nativeElement, 'copy-me').length)
+             .toEqual(1);
+         expect(fixture.debugElement.nativeElement).toHaveText('hello');
 
-                   async.done();
-                 });
-           }));
+         fixture.debugElement.componentInstance.booleanCondition = false;
+         fixture.detectChanges();
+         expect(getDOM().querySelectorAll(fixture.debugElement.nativeElement, 'copy-me').length)
+             .toEqual(0);
+         expect(fixture.debugElement.nativeElement).toHaveText('');
+       }));
 
-    it('should update several nodes with if',
-       inject(
-           [TestComponentBuilder, AsyncTestCompleter],
-           (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
-             var html = '<div>' +
-                 '<copy-me template="ngIf numberCondition + 1 >= 2">helloNumber</copy-me>' +
-                 '<copy-me template="ngIf stringCondition == \'foo\'">helloString</copy-me>' +
-                 '<copy-me template="ngIf functionCondition(stringCondition, numberCondition)">helloFunction</copy-me>' +
-                 '</div>';
+    it('should update several nodes with if', async(() => {
+         const template = '<div>' +
+             '<copy-me template="ngIf numberCondition + 1 >= 2">helloNumber</copy-me>' +
+             '<copy-me template="ngIf stringCondition == \'foo\'">helloString</copy-me>' +
+             '<copy-me template="ngIf functionCondition(stringCondition, numberCondition)">helloFunction</copy-me>' +
+             '</div>';
 
-             tcb.overrideTemplate(TestComponent, html)
-                 .createAsync(TestComponent)
-                 .then((fixture) => {
-                   fixture.detectChanges();
-                   expect(getDOM()
-                              .querySelectorAll(fixture.debugElement.nativeElement, 'copy-me')
-                              .length)
-                       .toEqual(3);
-                   expect(getDOM().getText(fixture.debugElement.nativeElement))
-                       .toEqual('helloNumberhelloStringhelloFunction');
+         TestBed.overrideComponent(TestComponent, {set: {template: template}});
+         let fixture = TestBed.createComponent(TestComponent);
+         fixture.detectChanges();
+         expect(getDOM().querySelectorAll(fixture.debugElement.nativeElement, 'copy-me').length)
+             .toEqual(3);
+         expect(getDOM().getText(fixture.debugElement.nativeElement))
+             .toEqual('helloNumberhelloStringhelloFunction');
 
-                   fixture.debugElement.componentInstance.numberCondition = 0;
-                   fixture.detectChanges();
-                   expect(getDOM()
-                              .querySelectorAll(fixture.debugElement.nativeElement, 'copy-me')
-                              .length)
-                       .toEqual(1);
-                   expect(fixture.debugElement.nativeElement).toHaveText('helloString');
+         fixture.debugElement.componentInstance.numberCondition = 0;
+         fixture.detectChanges();
+         expect(getDOM().querySelectorAll(fixture.debugElement.nativeElement, 'copy-me').length)
+             .toEqual(1);
+         expect(fixture.debugElement.nativeElement).toHaveText('helloString');
 
-                   fixture.debugElement.componentInstance.numberCondition = 1;
-                   fixture.debugElement.componentInstance.stringCondition = 'bar';
-                   fixture.detectChanges();
-                   expect(getDOM()
-                              .querySelectorAll(fixture.debugElement.nativeElement, 'copy-me')
-                              .length)
-                       .toEqual(1);
-                   expect(fixture.debugElement.nativeElement).toHaveText('helloNumber');
-                   async.done();
-                 });
-           }));
+         fixture.debugElement.componentInstance.numberCondition = 1;
+         fixture.debugElement.componentInstance.stringCondition = 'bar';
+         fixture.detectChanges();
+         expect(getDOM().querySelectorAll(fixture.debugElement.nativeElement, 'copy-me').length)
+             .toEqual(1);
+         expect(fixture.debugElement.nativeElement).toHaveText('helloNumber');
+       }));
 
     it('should not add the element twice if the condition goes from true to true (JS)',
-       inject(
-           [TestComponentBuilder, AsyncTestCompleter],
-           (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
-             var html = '<div><copy-me template="ngIf numberCondition">hello</copy-me></div>';
+       async(() => {
+         const template = '<div><copy-me template="ngIf numberCondition">hello</copy-me></div>';
 
-             tcb.overrideTemplate(TestComponent, html)
-                 .createAsync(TestComponent)
-                 .then((fixture) => {
-                   fixture.detectChanges();
-                   expect(getDOM()
-                              .querySelectorAll(fixture.debugElement.nativeElement, 'copy-me')
-                              .length)
-                       .toEqual(1);
-                   expect(fixture.debugElement.nativeElement).toHaveText('hello');
+         TestBed.overrideComponent(TestComponent, {set: {template: template}});
+         let fixture = TestBed.createComponent(TestComponent);
+         fixture.detectChanges();
+         expect(getDOM().querySelectorAll(fixture.debugElement.nativeElement, 'copy-me').length)
+             .toEqual(1);
+         expect(fixture.debugElement.nativeElement).toHaveText('hello');
 
-                   fixture.debugElement.componentInstance.numberCondition = 2;
-                   fixture.detectChanges();
-                   expect(getDOM()
-                              .querySelectorAll(fixture.debugElement.nativeElement, 'copy-me')
-                              .length)
-                       .toEqual(1);
-                   expect(fixture.debugElement.nativeElement).toHaveText('hello');
+         fixture.debugElement.componentInstance.numberCondition = 2;
+         fixture.detectChanges();
+         expect(getDOM().querySelectorAll(fixture.debugElement.nativeElement, 'copy-me').length)
+             .toEqual(1);
+         expect(fixture.debugElement.nativeElement).toHaveText('hello');
+       }));
 
-                   async.done();
-                 });
-           }));
+    it('should not recreate the element if the condition goes from true to true (JS)', async(() => {
+         const template = '<div><copy-me template="ngIf numberCondition">hello</copy-me></div>';
 
-    it('should not recreate the element if the condition goes from true to true (JS)',
-       inject(
-           [TestComponentBuilder, AsyncTestCompleter],
-           (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
-             var html = '<div><copy-me template="ngIf numberCondition">hello</copy-me></div>';
+         TestBed.overrideComponent(TestComponent, {set: {template: template}});
+         let fixture = TestBed.createComponent(TestComponent);
+         fixture.detectChanges();
+         getDOM().addClass(
+             getDOM().querySelector(fixture.debugElement.nativeElement, 'copy-me'), 'foo');
 
-             tcb.overrideTemplate(TestComponent, html)
-                 .createAsync(TestComponent)
-                 .then((fixture) => {
-                   fixture.detectChanges();
-                   getDOM().addClass(
-                       getDOM().querySelector(fixture.debugElement.nativeElement, 'copy-me'),
-                       'foo');
-
-                   fixture.debugElement.componentInstance.numberCondition = 2;
-                   fixture.detectChanges();
-                   expect(getDOM().hasClass(
-                              getDOM().querySelector(fixture.debugElement.nativeElement, 'copy-me'),
-                              'foo'))
-                       .toBe(true);
-
-                   async.done();
-                 });
-           }));
+         fixture.debugElement.componentInstance.numberCondition = 2;
+         fixture.detectChanges();
+         expect(getDOM().hasClass(
+                    getDOM().querySelector(fixture.debugElement.nativeElement, 'copy-me'), 'foo'))
+             .toBe(true);
+       }));
   });
 }
 
diff --git a/modules/@angular/common/test/directives/ng_plural_spec.ts b/modules/@angular/common/test/directives/ng_plural_spec.ts
index aef41421c2..e8644ae89b 100644
--- a/modules/@angular/common/test/directives/ng_plural_spec.ts
+++ b/modules/@angular/common/test/directives/ng_plural_spec.ts
@@ -8,157 +8,120 @@
 
 import {NgLocalization, NgPlural, NgPluralCase} from '@angular/common';
 import {Component, Injectable} from '@angular/core';
-import {TestComponentBuilder} from '@angular/core/testing';
-import {AsyncTestCompleter, beforeEach, beforeEachProviders, ddescribe, describe, iit, inject, it, xit} from '@angular/core/testing/testing_internal';
+import {TestBed, async} from '@angular/core/testing';
+import {beforeEach, ddescribe, describe, iit, inject, it, xit} from '@angular/core/testing/testing_internal';
 import {expect} from '@angular/platform-browser/testing/matchers';
 
 export function main() {
   describe('switch', () => {
-    beforeEachProviders(() => [{provide: NgLocalization, useClass: TestLocalization}]);
 
-    it('should display the template according to the exact value',
-       inject(
-           [TestComponentBuilder, AsyncTestCompleter],
-           (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
-             var template = '<div>' +
-                 '<ul [ngPlural]="switchValue">' +
-                 '<template ngPluralCase="=0"><li>you have no messages.</li></template>' +
-                 '<template ngPluralCase="=1"><li>you have one message.</li></template>' +
-                 '</ul></div>';
+    beforeEach(() => {
+      TestBed.configureTestingModule({
+        declarations: [TestComponent],
+        providers: [{provide: NgLocalization, useClass: TestLocalization}]
+      });
+    });
 
-             tcb.overrideTemplate(TestComponent, template)
-                 .createAsync(TestComponent)
-                 .then((fixture) => {
-                   fixture.debugElement.componentInstance.switchValue = 0;
-                   fixture.detectChanges();
-                   expect(fixture.debugElement.nativeElement).toHaveText('you have no messages.');
+    it('should display the template according to the exact value', async(() => {
+         var template = '<div>' +
+             '<ul [ngPlural]="switchValue">' +
+             '<template ngPluralCase="=0"><li>you have no messages.</li></template>' +
+             '<template ngPluralCase="=1"><li>you have one message.</li></template>' +
+             '</ul></div>';
 
-                   fixture.debugElement.componentInstance.switchValue = 1;
-                   fixture.detectChanges();
-                   expect(fixture.debugElement.nativeElement).toHaveText('you have one message.');
+         TestBed.overrideComponent(TestComponent, {set: {template: template}});
+         let fixture = TestBed.createComponent(TestComponent);
+         fixture.debugElement.componentInstance.switchValue = 0;
+         fixture.detectChanges();
+         expect(fixture.debugElement.nativeElement).toHaveText('you have no messages.');
 
-                   async.done();
-                 });
-           }));
+         fixture.debugElement.componentInstance.switchValue = 1;
+         fixture.detectChanges();
+         expect(fixture.debugElement.nativeElement).toHaveText('you have one message.');
+       }));
 
     // https://github.com/angular/angular/issues/9868
     // https://github.com/angular/angular/issues/9882
-    it('should not throw when ngPluralCase contains expressions',
-       inject(
-           [TestComponentBuilder, AsyncTestCompleter],
-           (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
-             var template = '<div>' +
-                 '<ul [ngPlural]="switchValue">' +
-                 '<template ngPluralCase="=0"><li>{{ switchValue }}</li></template>' +
-                 '</ul></div>';
+    it('should not throw when ngPluralCase contains expressions', async(() => {
+         var template = '<div>' +
+             '<ul [ngPlural]="switchValue">' +
+             '<template ngPluralCase="=0"><li>{{ switchValue }}</li></template>' +
+             '</ul></div>';
 
-             tcb.overrideTemplate(TestComponent, template)
-                 .createAsync(TestComponent)
-                 .then((fixture) => {
-                   fixture.debugElement.componentInstance.switchValue = 0;
-                   expect(() => fixture.detectChanges()).not.toThrow();
-                   async.done();
-                 });
-           }));
+         TestBed.overrideComponent(TestComponent, {set: {template: template}});
+         let fixture = TestBed.createComponent(TestComponent);
+         fixture.debugElement.componentInstance.switchValue = 0;
+         expect(() => fixture.detectChanges()).not.toThrow();
+       }));
 
 
-    it('should be applicable to <ng-container> elements',
-       inject(
-           [TestComponentBuilder, AsyncTestCompleter],
-           (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
-             var template = '<div>' +
-                 '<ng-container [ngPlural]="switchValue">' +
-                 '<template ngPluralCase="=0">you have no messages.</template>' +
-                 '<template ngPluralCase="=1">you have one message.</template>' +
-                 '</ng-container></div>';
+    it('should be applicable to <ng-container> elements', async(() => {
+         var template = '<div>' +
+             '<ng-container [ngPlural]="switchValue">' +
+             '<template ngPluralCase="=0">you have no messages.</template>' +
+             '<template ngPluralCase="=1">you have one message.</template>' +
+             '</ng-container></div>';
 
-             tcb.overrideTemplate(TestComponent, template)
-                 .createAsync(TestComponent)
-                 .then((fixture) => {
-                   fixture.debugElement.componentInstance.switchValue = 0;
-                   fixture.detectChanges();
-                   expect(fixture.debugElement.nativeElement).toHaveText('you have no messages.');
+         TestBed.overrideComponent(TestComponent, {set: {template: template}});
+         let fixture = TestBed.createComponent(TestComponent);
+         fixture.debugElement.componentInstance.switchValue = 0;
+         fixture.detectChanges();
+         expect(fixture.debugElement.nativeElement).toHaveText('you have no messages.');
 
-                   fixture.debugElement.componentInstance.switchValue = 1;
-                   fixture.detectChanges();
-                   expect(fixture.debugElement.nativeElement).toHaveText('you have one message.');
+         fixture.debugElement.componentInstance.switchValue = 1;
+         fixture.detectChanges();
+         expect(fixture.debugElement.nativeElement).toHaveText('you have one message.');
+       }));
 
-                   async.done();
-                 });
-           }));
+    it('should display the template according to the category', async(() => {
+         var template = '<div>' +
+             '<ul [ngPlural]="switchValue">' +
+             '<template ngPluralCase="few"><li>you have a few messages.</li></template>' +
+             '<template ngPluralCase="many"><li>you have many messages.</li></template>' +
+             '</ul></div>';
 
-    it('should display the template according to the category',
-       inject(
-           [TestComponentBuilder, AsyncTestCompleter],
-           (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
-             var template = '<div>' +
-                 '<ul [ngPlural]="switchValue">' +
-                 '<template ngPluralCase="few"><li>you have a few messages.</li></template>' +
-                 '<template ngPluralCase="many"><li>you have many messages.</li></template>' +
-                 '</ul></div>';
+         TestBed.overrideComponent(TestComponent, {set: {template: template}});
+         let fixture = TestBed.createComponent(TestComponent);
+         fixture.debugElement.componentInstance.switchValue = 2;
+         fixture.detectChanges();
+         expect(fixture.debugElement.nativeElement).toHaveText('you have a few messages.');
 
-             tcb.overrideTemplate(TestComponent, template)
-                 .createAsync(TestComponent)
-                 .then((fixture) => {
-                   fixture.debugElement.componentInstance.switchValue = 2;
-                   fixture.detectChanges();
-                   expect(fixture.debugElement.nativeElement)
-                       .toHaveText('you have a few messages.');
+         fixture.debugElement.componentInstance.switchValue = 8;
+         fixture.detectChanges();
+         expect(fixture.debugElement.nativeElement).toHaveText('you have many messages.');
+       }));
 
-                   fixture.debugElement.componentInstance.switchValue = 8;
-                   fixture.detectChanges();
-                   expect(fixture.debugElement.nativeElement).toHaveText('you have many messages.');
+    it('should default to other when no matches are found', async(() => {
+         var template = '<div>' +
+             '<ul [ngPlural]="switchValue">' +
+             '<template ngPluralCase="few"><li>you have a few messages.</li></template>' +
+             '<template ngPluralCase="other"><li>default message.</li></template>' +
+             '</ul></div>';
 
-                   async.done();
-                 });
-           }));
+         TestBed.overrideComponent(TestComponent, {set: {template: template}});
+         let fixture = TestBed.createComponent(TestComponent);
+         fixture.debugElement.componentInstance.switchValue = 100;
+         fixture.detectChanges();
+         expect(fixture.debugElement.nativeElement).toHaveText('default message.');
+       }));
 
-    it('should default to other when no matches are found',
-       inject(
-           [TestComponentBuilder, AsyncTestCompleter],
-           (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
-             var template = '<div>' +
-                 '<ul [ngPlural]="switchValue">' +
-                 '<template ngPluralCase="few"><li>you have a few messages.</li></template>' +
-                 '<template ngPluralCase="other"><li>default message.</li></template>' +
-                 '</ul></div>';
+    it('should prioritize value matches over category matches', async(() => {
+         var template = '<div>' +
+             '<ul [ngPlural]="switchValue">' +
+             '<template ngPluralCase="few"><li>you have a few messages.</li></template>' +
+             '<template ngPluralCase="=2">you have two messages.</template>' +
+             '</ul></div>';
 
-             tcb.overrideTemplate(TestComponent, template)
-                 .createAsync(TestComponent)
-                 .then((fixture) => {
-                   fixture.debugElement.componentInstance.switchValue = 100;
-                   fixture.detectChanges();
-                   expect(fixture.debugElement.nativeElement).toHaveText('default message.');
+         TestBed.overrideComponent(TestComponent, {set: {template: template}});
+         let fixture = TestBed.createComponent(TestComponent);
+         fixture.debugElement.componentInstance.switchValue = 2;
+         fixture.detectChanges();
+         expect(fixture.debugElement.nativeElement).toHaveText('you have two messages.');
 
-                   async.done();
-                 });
-           }));
-
-    it('should prioritize value matches over category matches',
-       inject(
-           [TestComponentBuilder, AsyncTestCompleter],
-           (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
-             var template = '<div>' +
-                 '<ul [ngPlural]="switchValue">' +
-                 '<template ngPluralCase="few"><li>you have a few messages.</li></template>' +
-                 '<template ngPluralCase="=2">you have two messages.</template>' +
-                 '</ul></div>';
-
-             tcb.overrideTemplate(TestComponent, template)
-                 .createAsync(TestComponent)
-                 .then((fixture) => {
-                   fixture.debugElement.componentInstance.switchValue = 2;
-                   fixture.detectChanges();
-                   expect(fixture.debugElement.nativeElement).toHaveText('you have two messages.');
-
-                   fixture.debugElement.componentInstance.switchValue = 3;
-                   fixture.detectChanges();
-                   expect(fixture.debugElement.nativeElement)
-                       .toHaveText('you have a few messages.');
-
-                   async.done();
-                 });
-           }));
+         fixture.debugElement.componentInstance.switchValue = 3;
+         fixture.detectChanges();
+         expect(fixture.debugElement.nativeElement).toHaveText('you have a few messages.');
+       }));
   });
 }
 
diff --git a/modules/@angular/common/test/directives/ng_style_spec.ts b/modules/@angular/common/test/directives/ng_style_spec.ts
index 5c5384ee1e..e7b95f2089 100644
--- a/modules/@angular/common/test/directives/ng_style_spec.ts
+++ b/modules/@angular/common/test/directives/ng_style_spec.ts
@@ -6,8 +6,8 @@
  * found in the LICENSE file at https://angular.io/license
  */
 
-import {AsyncTestCompleter, beforeEach, beforeEachProviders, ddescribe, xdescribe, describe, expect, iit, inject, it, xit,} from '@angular/core/testing/testing_internal';
-import {TestComponentBuilder, ComponentFixture} from '@angular/core/testing';
+import {beforeEach, ddescribe, xdescribe, describe, expect, iit, it, xit,} from '@angular/core/testing/testing_internal';
+import {async, TestBed, ComponentFixture} from '@angular/core/testing';
 
 import {Component} from '@angular/core';
 
@@ -20,188 +20,137 @@ function expectNativeEl(fixture: ComponentFixture<any>) {
 export function main() {
   describe('binding to CSS styles', () => {
 
-    it('should add styles specified in an object literal',
-       inject(
-           [TestComponentBuilder, AsyncTestCompleter],
-           (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
-             var template = `<div [ngStyle]="{'max-width': '40px'}"></div>`;
+    beforeEach(() => {
+      TestBed.configureTestingModule({
+        declarations: [TestComponent],
+      });
+    });
 
-             tcb.overrideTemplate(TestComponent, template)
-                 .createAsync(TestComponent)
-                 .then((fixture) => {
-                   fixture.detectChanges();
-                   expectNativeEl(fixture).toHaveCssStyle({'max-width': '40px'});
+    it('should add styles specified in an object literal', async(() => {
+         var template = `<div [ngStyle]="{'max-width': '40px'}"></div>`;
 
-                   async.done();
-                 });
-           }));
+         TestBed.overrideComponent(TestComponent, {set: {template: template}});
+         let fixture = TestBed.createComponent(TestComponent);
+         fixture.detectChanges();
+         expectNativeEl(fixture).toHaveCssStyle({'max-width': '40px'});
+       }));
 
-    it('should add and change styles specified in an object expression',
-       inject(
-           [TestComponentBuilder, AsyncTestCompleter],
-           (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
-             var template = `<div [ngStyle]="expr"></div>`;
+    it('should add and change styles specified in an object expression', async(() => {
+         var template = `<div [ngStyle]="expr"></div>`;
 
-             tcb.overrideTemplate(TestComponent, template)
-                 .createAsync(TestComponent)
-                 .then((fixture) => {
-                   var expr: Map<string, any>;
+         TestBed.overrideComponent(TestComponent, {set: {template: template}});
+         let fixture = TestBed.createComponent(TestComponent);
+         var expr: Map<string, any>;
 
-                   fixture.debugElement.componentInstance.expr = {'max-width': '40px'};
-                   fixture.detectChanges();
-                   expectNativeEl(fixture).toHaveCssStyle({'max-width': '40px'});
+         fixture.debugElement.componentInstance.expr = {'max-width': '40px'};
+         fixture.detectChanges();
+         expectNativeEl(fixture).toHaveCssStyle({'max-width': '40px'});
 
-                   expr = fixture.debugElement.componentInstance.expr;
-                   (expr as any)['max-width'] = '30%';
-                   fixture.detectChanges();
-                   expectNativeEl(fixture).toHaveCssStyle({'max-width': '30%'});
+         expr = fixture.debugElement.componentInstance.expr;
+         (expr as any)['max-width'] = '30%';
+         fixture.detectChanges();
+         expectNativeEl(fixture).toHaveCssStyle({'max-width': '30%'});
+       }));
 
-                   async.done();
-                 });
-           }));
+    it('should add and remove styles specified using style.unit notation', async(() => {
+         var template = `<div [ngStyle]="{'max-width.px': expr}"></div>`;
 
-    it('should add and remove styles specified using style.unit notation',
-       inject(
-           [TestComponentBuilder, AsyncTestCompleter],
-           (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
-             var template = `<div [ngStyle]="{'max-width.px': expr}"></div>`;
+         TestBed.overrideComponent(TestComponent, {set: {template: template}});
+         let fixture = TestBed.createComponent(TestComponent);
 
-             tcb.overrideTemplate(TestComponent, template)
-                 .createAsync(TestComponent)
-                 .then((fixture) => {
+         fixture.debugElement.componentInstance.expr = '40';
+         fixture.detectChanges();
+         expectNativeEl(fixture).toHaveCssStyle({'max-width': '40px'});
 
-                   fixture.debugElement.componentInstance.expr = '40';
-                   fixture.detectChanges();
-                   expectNativeEl(fixture).toHaveCssStyle({'max-width': '40px'});
+         fixture.debugElement.componentInstance.expr = null;
+         fixture.detectChanges();
+         expectNativeEl(fixture).not.toHaveCssStyle('max-width');
+       }));
 
-                   fixture.debugElement.componentInstance.expr = null;
-                   fixture.detectChanges();
-                   expectNativeEl(fixture).not.toHaveCssStyle('max-width');
+    it('should update styles using style.unit notation when unit changes', async(() => {
+         var template = `<div [ngStyle]="expr"></div>`;
 
-                   async.done();
-                 });
-           }));
+         TestBed.overrideComponent(TestComponent, {set: {template: template}});
+         let fixture = TestBed.createComponent(TestComponent);
 
-    it('should update styles using style.unit notation when unit changes',
-       inject(
-           [TestComponentBuilder, AsyncTestCompleter],
-           (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
-             var template = `<div [ngStyle]="expr"></div>`;
+         fixture.debugElement.componentInstance.expr = {'max-width.px': '40'};
+         fixture.detectChanges();
+         expectNativeEl(fixture).toHaveCssStyle({'max-width': '40px'});
 
-             tcb.overrideTemplate(TestComponent, template)
-                 .createAsync(TestComponent)
-                 .then((fixture) => {
-
-                   fixture.debugElement.componentInstance.expr = {'max-width.px': '40'};
-                   fixture.detectChanges();
-                   expectNativeEl(fixture).toHaveCssStyle({'max-width': '40px'});
-
-                   fixture.debugElement.componentInstance.expr = {'max-width.em': '40'};
-                   fixture.detectChanges();
-                   expectNativeEl(fixture).toHaveCssStyle({'max-width': '40em'});
-
-                   async.done();
-                 });
-           }));
+         fixture.debugElement.componentInstance.expr = {'max-width.em': '40'};
+         fixture.detectChanges();
+         expectNativeEl(fixture).toHaveCssStyle({'max-width': '40em'});
+       }));
 
     // keyValueDiffer is sensitive to key order #9115
-    it('should change styles specified in an object expression',
-       inject(
-           [TestComponentBuilder, AsyncTestCompleter],
-           (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
-             const template = `<div [ngStyle]="expr"></div>`;
+    it('should change styles specified in an object expression', async(() => {
+         const template = `<div [ngStyle]="expr"></div>`;
 
-             tcb.overrideTemplate(TestComponent, template)
-                 .createAsync(TestComponent)
-                 .then((fixture) => {
-                   fixture.debugElement.componentInstance.expr = {
-                     // height, width order is important here
-                     height: '10px',
-                     width: '10px'
-                   };
+         TestBed.overrideComponent(TestComponent, {set: {template: template}});
+         let fixture = TestBed.createComponent(TestComponent);
+         fixture.debugElement.componentInstance.expr = {
+           // height, width order is important here
+           height: '10px',
+           width: '10px'
+         };
 
-                   fixture.detectChanges();
-                   expectNativeEl(fixture).toHaveCssStyle({'height': '10px', 'width': '10px'});
+         fixture.detectChanges();
+         expectNativeEl(fixture).toHaveCssStyle({'height': '10px', 'width': '10px'});
 
-                   fixture.debugElement.componentInstance.expr = {
-                     // width, height order is important here
-                     width: '5px',
-                     height: '5px',
-                   };
+         fixture.debugElement.componentInstance.expr = {
+           // width, height order is important here
+           width: '5px',
+           height: '5px',
+         };
 
-                   fixture.detectChanges();
-                   expectNativeEl(fixture).toHaveCssStyle({'height': '5px', 'width': '5px'});
+         fixture.detectChanges();
+         expectNativeEl(fixture).toHaveCssStyle({'height': '5px', 'width': '5px'});
+       }));
 
-                   async.done();
-                 });
-           }));
+    it('should remove styles when deleting a key in an object expression', async(() => {
+         var template = `<div [ngStyle]="expr"></div>`;
 
-    it('should remove styles when deleting a key in an object expression',
-       inject(
-           [TestComponentBuilder, AsyncTestCompleter],
-           (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
-             var template = `<div [ngStyle]="expr"></div>`;
+         TestBed.overrideComponent(TestComponent, {set: {template: template}});
+         let fixture = TestBed.createComponent(TestComponent);
+         fixture.debugElement.componentInstance.expr = {'max-width': '40px'};
+         fixture.detectChanges();
+         expectNativeEl(fixture).toHaveCssStyle({'max-width': '40px'});
 
-             tcb.overrideTemplate(TestComponent, template)
-                 .createAsync(TestComponent)
-                 .then((fixture) => {
-                   fixture.debugElement.componentInstance.expr = {'max-width': '40px'};
-                   fixture.detectChanges();
-                   expectNativeEl(fixture).toHaveCssStyle({'max-width': '40px'});
+         delete fixture.debugElement.componentInstance.expr['max-width'];
+         fixture.detectChanges();
+         expectNativeEl(fixture).not.toHaveCssStyle('max-width');
+       }));
 
-                   delete fixture.debugElement.componentInstance.expr['max-width'];
-                   fixture.detectChanges();
-                   expectNativeEl(fixture).not.toHaveCssStyle('max-width');
+    it('should co-operate with the style attribute', async(() => {
+         var template = `<div style="font-size: 12px" [ngStyle]="expr"></div>`;
 
-                   async.done();
-                 });
-           }));
+         TestBed.overrideComponent(TestComponent, {set: {template: template}});
+         let fixture = TestBed.createComponent(TestComponent);
+         fixture.debugElement.componentInstance.expr = {'max-width': '40px'};
+         fixture.detectChanges();
+         expectNativeEl(fixture).toHaveCssStyle({'max-width': '40px', 'font-size': '12px'});
 
-    it('should co-operate with the style attribute',
-       inject(
-           [TestComponentBuilder, AsyncTestCompleter],
-           (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
-             var template = `<div style="font-size: 12px" [ngStyle]="expr"></div>`;
-
-             tcb.overrideTemplate(TestComponent, template)
-                 .createAsync(TestComponent)
-                 .then((fixture) => {
-                   fixture.debugElement.componentInstance.expr = {'max-width': '40px'};
-                   fixture.detectChanges();
-                   expectNativeEl(fixture).toHaveCssStyle(
-                       {'max-width': '40px', 'font-size': '12px'});
-
-                   delete fixture.debugElement.componentInstance.expr['max-width'];
-                   fixture.detectChanges();
-                   expectNativeEl(fixture).not.toHaveCssStyle('max-width');
-                   expectNativeEl(fixture).toHaveCssStyle({'font-size': '12px'});
-
-                   async.done();
-                 });
-           }));
+         delete fixture.debugElement.componentInstance.expr['max-width'];
+         fixture.detectChanges();
+         expectNativeEl(fixture).not.toHaveCssStyle('max-width');
+         expectNativeEl(fixture).toHaveCssStyle({'font-size': '12px'});
+       }));
 
     it('should co-operate with the style.[styleName]="expr" special-case in the compiler',
-       inject(
-           [TestComponentBuilder, AsyncTestCompleter],
-           (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
-             var template = `<div [style.font-size.px]="12" [ngStyle]="expr"></div>`;
+       async(() => {
+         var template = `<div [style.font-size.px]="12" [ngStyle]="expr"></div>`;
 
-             tcb.overrideTemplate(TestComponent, template)
-                 .createAsync(TestComponent)
-                 .then((fixture) => {
-                   fixture.debugElement.componentInstance.expr = {'max-width': '40px'};
-                   fixture.detectChanges();
-                   expectNativeEl(fixture).toHaveCssStyle(
-                       {'max-width': '40px', 'font-size': '12px'});
+         TestBed.overrideComponent(TestComponent, {set: {template: template}});
+         let fixture = TestBed.createComponent(TestComponent);
+         fixture.debugElement.componentInstance.expr = {'max-width': '40px'};
+         fixture.detectChanges();
+         expectNativeEl(fixture).toHaveCssStyle({'max-width': '40px', 'font-size': '12px'});
 
-                   delete fixture.debugElement.componentInstance.expr['max-width'];
-                   fixture.detectChanges();
-                   expectNativeEl(fixture).not.toHaveCssStyle('max-width');
-                   expectNativeEl(fixture).toHaveCssStyle({'font-size': '12px'});
-
-                   async.done();
-                 });
-           }));
+         delete fixture.debugElement.componentInstance.expr['max-width'];
+         fixture.detectChanges();
+         expectNativeEl(fixture).not.toHaveCssStyle('max-width');
+         expectNativeEl(fixture).toHaveCssStyle({'font-size': '12px'});
+       }));
   });
 }
 
diff --git a/modules/@angular/common/test/directives/ng_switch_spec.ts b/modules/@angular/common/test/directives/ng_switch_spec.ts
index 17b82b35b4..6c62d6c130 100644
--- a/modules/@angular/common/test/directives/ng_switch_spec.ts
+++ b/modules/@angular/common/test/directives/ng_switch_spec.ts
@@ -8,172 +8,143 @@
 
 import {NgSwitch, NgSwitchCase, NgSwitchDefault} from '@angular/common';
 import {Component} from '@angular/core';
-import {TestComponentBuilder} from '@angular/core/testing';
-import {AsyncTestCompleter, beforeEach, ddescribe, describe, iit, inject, it, xit} from '@angular/core/testing/testing_internal';
+import {TestBed, async} from '@angular/core/testing';
+import {beforeEach, ddescribe, describe, iit, inject, it, xit} from '@angular/core/testing/testing_internal';
 import {expect} from '@angular/platform-browser/testing/matchers';
 
 export function main() {
   describe('switch', () => {
+
+    beforeEach(() => {
+      TestBed.configureTestingModule({
+        declarations: [TestComponent],
+      });
+    });
+
     describe('switch value changes', () => {
-      it('should switch amongst when values',
-         inject(
-             [TestComponentBuilder, AsyncTestCompleter],
-             (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
-               var template = '<div>' +
-                   '<ul [ngSwitch]="switchValue">' +
-                   '<template ngSwitchCase="a"><li>when a</li></template>' +
-                   '<template ngSwitchCase="b"><li>when b</li></template>' +
-                   '</ul></div>';
+      it('should switch amongst when values', async(() => {
+           var template = '<div>' +
+               '<ul [ngSwitch]="switchValue">' +
+               '<template ngSwitchCase="a"><li>when a</li></template>' +
+               '<template ngSwitchCase="b"><li>when b</li></template>' +
+               '</ul></div>';
 
-               tcb.overrideTemplate(TestComponent, template)
-                   .createAsync(TestComponent)
-                   .then((fixture) => {
-                     fixture.detectChanges();
-                     expect(fixture.debugElement.nativeElement).toHaveText('');
+           TestBed.overrideComponent(TestComponent, {set: {template: template}});
+           let fixture = TestBed.createComponent(TestComponent);
+           fixture.detectChanges();
+           expect(fixture.debugElement.nativeElement).toHaveText('');
 
-                     fixture.debugElement.componentInstance.switchValue = 'a';
-                     fixture.detectChanges();
-                     expect(fixture.debugElement.nativeElement).toHaveText('when a');
+           fixture.debugElement.componentInstance.switchValue = 'a';
+           fixture.detectChanges();
+           expect(fixture.debugElement.nativeElement).toHaveText('when a');
 
-                     fixture.debugElement.componentInstance.switchValue = 'b';
-                     fixture.detectChanges();
-                     expect(fixture.debugElement.nativeElement).toHaveText('when b');
-
-                     async.done();
-                   });
-             }));
+           fixture.debugElement.componentInstance.switchValue = 'b';
+           fixture.detectChanges();
+           expect(fixture.debugElement.nativeElement).toHaveText('when b');
+         }));
 
       // TODO(robwormald): deprecate and remove
-      it('should switch amongst when values using switchWhen',
-         inject(
-             [TestComponentBuilder, AsyncTestCompleter],
-             (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
-               var template = '<div>' +
-                   '<ul [ngSwitch]="switchValue">' +
-                   '<template ngSwitchWhen="a"><li>when a</li></template>' +
-                   '<template ngSwitchWhen="b"><li>when b</li></template>' +
-                   '</ul></div>';
+      it('should switch amongst when values using switchWhen', async(() => {
+           var template = '<div>' +
+               '<ul [ngSwitch]="switchValue">' +
+               '<template ngSwitchWhen="a"><li>when a</li></template>' +
+               '<template ngSwitchWhen="b"><li>when b</li></template>' +
+               '</ul></div>';
 
-               tcb.overrideTemplate(TestComponent, template)
-                   .createAsync(TestComponent)
-                   .then((fixture) => {
-                     fixture.detectChanges();
-                     expect(fixture.debugElement.nativeElement).toHaveText('');
+           TestBed.overrideComponent(TestComponent, {set: {template: template}});
+           let fixture = TestBed.createComponent(TestComponent);
+           fixture.detectChanges();
+           expect(fixture.debugElement.nativeElement).toHaveText('');
 
-                     fixture.debugElement.componentInstance.switchValue = 'a';
-                     fixture.detectChanges();
-                     expect(fixture.debugElement.nativeElement).toHaveText('when a');
+           fixture.debugElement.componentInstance.switchValue = 'a';
+           fixture.detectChanges();
+           expect(fixture.debugElement.nativeElement).toHaveText('when a');
 
-                     fixture.debugElement.componentInstance.switchValue = 'b';
-                     fixture.detectChanges();
-                     expect(fixture.debugElement.nativeElement).toHaveText('when b');
+           fixture.debugElement.componentInstance.switchValue = 'b';
+           fixture.detectChanges();
+           expect(fixture.debugElement.nativeElement).toHaveText('when b');
+         }));
 
-                     async.done();
-                   });
-             }));
+      it('should switch amongst when values with fallback to default', async(() => {
+           var template = '<div>' +
+               '<ul [ngSwitch]="switchValue">' +
+               '<li template="ngSwitchCase \'a\'">when a</li>' +
+               '<li template="ngSwitchDefault">when default</li>' +
+               '</ul></div>';
 
-      it('should switch amongst when values with fallback to default',
-         inject(
-             [TestComponentBuilder, AsyncTestCompleter],
-             (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
-               var template = '<div>' +
-                   '<ul [ngSwitch]="switchValue">' +
-                   '<li template="ngSwitchCase \'a\'">when a</li>' +
-                   '<li template="ngSwitchDefault">when default</li>' +
-                   '</ul></div>';
+           TestBed.overrideComponent(TestComponent, {set: {template: template}});
+           let fixture = TestBed.createComponent(TestComponent);
+           fixture.detectChanges();
+           expect(fixture.debugElement.nativeElement).toHaveText('when default');
 
-               tcb.overrideTemplate(TestComponent, template)
-                   .createAsync(TestComponent)
-                   .then((fixture) => {
-                     fixture.detectChanges();
-                     expect(fixture.debugElement.nativeElement).toHaveText('when default');
+           fixture.debugElement.componentInstance.switchValue = 'a';
+           fixture.detectChanges();
+           expect(fixture.debugElement.nativeElement).toHaveText('when a');
 
-                     fixture.debugElement.componentInstance.switchValue = 'a';
-                     fixture.detectChanges();
-                     expect(fixture.debugElement.nativeElement).toHaveText('when a');
+           fixture.debugElement.componentInstance.switchValue = 'b';
+           fixture.detectChanges();
+           expect(fixture.debugElement.nativeElement).toHaveText('when default');
+         }));
 
-                     fixture.debugElement.componentInstance.switchValue = 'b';
-                     fixture.detectChanges();
-                     expect(fixture.debugElement.nativeElement).toHaveText('when default');
+      it('should support multiple whens with the same value', async(() => {
+           var template = '<div>' +
+               '<ul [ngSwitch]="switchValue">' +
+               '<template ngSwitchCase="a"><li>when a1;</li></template>' +
+               '<template ngSwitchCase="b"><li>when b1;</li></template>' +
+               '<template ngSwitchCase="a"><li>when a2;</li></template>' +
+               '<template ngSwitchCase="b"><li>when b2;</li></template>' +
+               '<template ngSwitchDefault><li>when default1;</li></template>' +
+               '<template ngSwitchDefault><li>when default2;</li></template>' +
+               '</ul></div>';
 
-                     async.done();
-                   });
-             }));
+           TestBed.overrideComponent(TestComponent, {set: {template: template}});
+           let fixture = TestBed.createComponent(TestComponent);
+           fixture.detectChanges();
+           expect(fixture.debugElement.nativeElement).toHaveText('when default1;when default2;');
 
-      it('should support multiple whens with the same value',
-         inject(
-             [TestComponentBuilder, AsyncTestCompleter],
-             (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
-               var template = '<div>' +
-                   '<ul [ngSwitch]="switchValue">' +
-                   '<template ngSwitchCase="a"><li>when a1;</li></template>' +
-                   '<template ngSwitchCase="b"><li>when b1;</li></template>' +
-                   '<template ngSwitchCase="a"><li>when a2;</li></template>' +
-                   '<template ngSwitchCase="b"><li>when b2;</li></template>' +
-                   '<template ngSwitchDefault><li>when default1;</li></template>' +
-                   '<template ngSwitchDefault><li>when default2;</li></template>' +
-                   '</ul></div>';
+           fixture.debugElement.componentInstance.switchValue = 'a';
+           fixture.detectChanges();
+           expect(fixture.debugElement.nativeElement).toHaveText('when a1;when a2;');
 
-               tcb.overrideTemplate(TestComponent, template)
-                   .createAsync(TestComponent)
-                   .then((fixture) => {
-                     fixture.detectChanges();
-                     expect(fixture.debugElement.nativeElement)
-                         .toHaveText('when default1;when default2;');
-
-                     fixture.debugElement.componentInstance.switchValue = 'a';
-                     fixture.detectChanges();
-                     expect(fixture.debugElement.nativeElement).toHaveText('when a1;when a2;');
-
-                     fixture.debugElement.componentInstance.switchValue = 'b';
-                     fixture.detectChanges();
-                     expect(fixture.debugElement.nativeElement).toHaveText('when b1;when b2;');
-
-                     async.done();
-                   });
-             }));
+           fixture.debugElement.componentInstance.switchValue = 'b';
+           fixture.detectChanges();
+           expect(fixture.debugElement.nativeElement).toHaveText('when b1;when b2;');
+         }));
     });
 
     describe('when values changes', () => {
-      it('should switch amongst when values',
-         inject(
-             [TestComponentBuilder, AsyncTestCompleter],
-             (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
-               var template = '<div>' +
-                   '<ul [ngSwitch]="switchValue">' +
-                   '<template [ngSwitchCase]="when1"><li>when 1;</li></template>' +
-                   '<template [ngSwitchCase]="when2"><li>when 2;</li></template>' +
-                   '<template ngSwitchDefault><li>when default;</li></template>' +
-                   '</ul></div>';
+      it('should switch amongst when values', async(() => {
+           var template = '<div>' +
+               '<ul [ngSwitch]="switchValue">' +
+               '<template [ngSwitchCase]="when1"><li>when 1;</li></template>' +
+               '<template [ngSwitchCase]="when2"><li>when 2;</li></template>' +
+               '<template ngSwitchDefault><li>when default;</li></template>' +
+               '</ul></div>';
 
-               tcb.overrideTemplate(TestComponent, template)
-                   .createAsync(TestComponent)
-                   .then((fixture) => {
-                     fixture.debugElement.componentInstance.when1 = 'a';
-                     fixture.debugElement.componentInstance.when2 = 'b';
-                     fixture.debugElement.componentInstance.switchValue = 'a';
-                     fixture.detectChanges();
-                     expect(fixture.debugElement.nativeElement).toHaveText('when 1;');
+           TestBed.overrideComponent(TestComponent, {set: {template: template}});
+           let fixture = TestBed.createComponent(TestComponent);
+           fixture.debugElement.componentInstance.when1 = 'a';
+           fixture.debugElement.componentInstance.when2 = 'b';
+           fixture.debugElement.componentInstance.switchValue = 'a';
+           fixture.detectChanges();
+           expect(fixture.debugElement.nativeElement).toHaveText('when 1;');
 
-                     fixture.debugElement.componentInstance.switchValue = 'b';
-                     fixture.detectChanges();
-                     expect(fixture.debugElement.nativeElement).toHaveText('when 2;');
+           fixture.debugElement.componentInstance.switchValue = 'b';
+           fixture.detectChanges();
+           expect(fixture.debugElement.nativeElement).toHaveText('when 2;');
 
-                     fixture.debugElement.componentInstance.switchValue = 'c';
-                     fixture.detectChanges();
-                     expect(fixture.debugElement.nativeElement).toHaveText('when default;');
+           fixture.debugElement.componentInstance.switchValue = 'c';
+           fixture.detectChanges();
+           expect(fixture.debugElement.nativeElement).toHaveText('when default;');
 
-                     fixture.debugElement.componentInstance.when1 = 'c';
-                     fixture.detectChanges();
-                     expect(fixture.debugElement.nativeElement).toHaveText('when 1;');
+           fixture.debugElement.componentInstance.when1 = 'c';
+           fixture.detectChanges();
+           expect(fixture.debugElement.nativeElement).toHaveText('when 1;');
 
-                     fixture.debugElement.componentInstance.when1 = 'd';
-                     fixture.detectChanges();
-                     expect(fixture.debugElement.nativeElement).toHaveText('when default;');
-
-                     async.done();
-                   });
-             }));
+           fixture.debugElement.componentInstance.when1 = 'd';
+           fixture.detectChanges();
+           expect(fixture.debugElement.nativeElement).toHaveText('when default;');
+         }));
     });
   });
 }
diff --git a/modules/@angular/common/test/directives/ng_template_outlet_spec.ts b/modules/@angular/common/test/directives/ng_template_outlet_spec.ts
index 98d7c86747..ececac1f28 100644
--- a/modules/@angular/common/test/directives/ng_template_outlet_spec.ts
+++ b/modules/@angular/common/test/directives/ng_template_outlet_spec.ts
@@ -8,200 +8,149 @@
 
 import {NgTemplateOutlet} from '@angular/common';
 import {Component, ContentChildren, Directive, QueryList, TemplateRef} from '@angular/core';
-import {TestComponentBuilder} from '@angular/core/testing';
-import {AsyncTestCompleter, beforeEach, ddescribe, describe, iit, inject, it, xit} from '@angular/core/testing/testing_internal';
+import {TestBed, async} from '@angular/core/testing';
+import {beforeEach, ddescribe, describe, iit, inject, it, xit} from '@angular/core/testing/testing_internal';
 import {expect} from '@angular/platform-browser/testing/matchers';
 
 export function main() {
   describe('insert', () => {
-    it('should do nothing if templateRef is null',
-       inject(
-           [TestComponentBuilder, AsyncTestCompleter],
-           (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
-             var template = `<template [ngTemplateOutlet]="null"></template>`;
-             tcb.overrideTemplate(TestComponent, template)
-                 .createAsync(TestComponent)
-                 .then((fixture) => {
 
-                   fixture.detectChanges();
-                   expect(fixture.nativeElement).toHaveText('');
+    beforeEach(() => {
+      TestBed.configureTestingModule({
+        declarations: [TestComponent],
+      });
+    });
 
-                   async.done();
-                 });
-           }));
+    it('should do nothing if templateRef is null', async(() => {
+         var template = `<template [ngTemplateOutlet]="null"></template>`;
+         TestBed.overrideComponent(TestComponent, {set: {template: template}});
+         let fixture = TestBed.createComponent(TestComponent);
 
-    it('should insert content specified by TemplateRef',
-       inject(
-           [TestComponentBuilder, AsyncTestCompleter],
-           (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
-             var template =
-                 `<tpl-refs #refs="tplRefs"><template>foo</template></tpl-refs><template [ngTemplateOutlet]="currentTplRef"></template>`;
-             tcb.overrideTemplate(TestComponent, template)
-                 .createAsync(TestComponent)
-                 .then((fixture) => {
+         fixture.detectChanges();
+         expect(fixture.nativeElement).toHaveText('');
+       }));
 
-                   fixture.detectChanges();
-                   expect(fixture.nativeElement).toHaveText('');
+    it('should insert content specified by TemplateRef', async(() => {
+         var template =
+             `<tpl-refs #refs="tplRefs"><template>foo</template></tpl-refs><template [ngTemplateOutlet]="currentTplRef"></template>`;
+         TestBed.overrideComponent(TestComponent, {set: {template: template}});
+         let fixture = TestBed.createComponent(TestComponent);
 
-                   var refs = fixture.debugElement.children[0].references['refs'];
+         fixture.detectChanges();
+         expect(fixture.nativeElement).toHaveText('');
 
-                   fixture.componentInstance.currentTplRef = refs.tplRefs.first;
-                   fixture.detectChanges();
-                   expect(fixture.nativeElement).toHaveText('foo');
+         var refs = fixture.debugElement.children[0].references['refs'];
 
-                   async.done();
-                 });
-           }));
+         fixture.componentInstance.currentTplRef = refs.tplRefs.first;
+         fixture.detectChanges();
+         expect(fixture.nativeElement).toHaveText('foo');
+       }));
 
-    it('should clear content if TemplateRef becomes null',
-       inject(
-           [TestComponentBuilder, AsyncTestCompleter],
-           (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
-             var template =
-                 `<tpl-refs #refs="tplRefs"><template>foo</template></tpl-refs><template [ngTemplateOutlet]="currentTplRef"></template>`;
-             tcb.overrideTemplate(TestComponent, template)
-                 .createAsync(TestComponent)
-                 .then((fixture) => {
+    it('should clear content if TemplateRef becomes null', async(() => {
+         var template =
+             `<tpl-refs #refs="tplRefs"><template>foo</template></tpl-refs><template [ngTemplateOutlet]="currentTplRef"></template>`;
+         TestBed.overrideComponent(TestComponent, {set: {template: template}});
+         let fixture = TestBed.createComponent(TestComponent);
 
-                   fixture.detectChanges();
-                   var refs = fixture.debugElement.children[0].references['refs'];
+         fixture.detectChanges();
+         var refs = fixture.debugElement.children[0].references['refs'];
 
-                   fixture.componentInstance.currentTplRef = refs.tplRefs.first;
-                   fixture.detectChanges();
-                   expect(fixture.nativeElement).toHaveText('foo');
+         fixture.componentInstance.currentTplRef = refs.tplRefs.first;
+         fixture.detectChanges();
+         expect(fixture.nativeElement).toHaveText('foo');
 
-                   fixture.componentInstance.currentTplRef = null;
-                   fixture.detectChanges();
-                   expect(fixture.nativeElement).toHaveText('');
+         fixture.componentInstance.currentTplRef = null;
+         fixture.detectChanges();
+         expect(fixture.nativeElement).toHaveText('');
+       }));
 
-                   async.done();
-                 });
-           }));
+    it('should swap content if TemplateRef changes', async(() => {
+         var template =
+             `<tpl-refs #refs="tplRefs"><template>foo</template><template>bar</template></tpl-refs><template [ngTemplateOutlet]="currentTplRef"></template>`;
+         TestBed.overrideComponent(TestComponent, {set: {template: template}});
+         let fixture = TestBed.createComponent(TestComponent);
 
-    it('should swap content if TemplateRef changes',
-       inject(
-           [TestComponentBuilder, AsyncTestCompleter],
-           (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
-             var template =
-                 `<tpl-refs #refs="tplRefs"><template>foo</template><template>bar</template></tpl-refs><template [ngTemplateOutlet]="currentTplRef"></template>`;
-             tcb.overrideTemplate(TestComponent, template)
-                 .createAsync(TestComponent)
-                 .then((fixture) => {
+         fixture.detectChanges();
+         var refs = fixture.debugElement.children[0].references['refs'];
 
-                   fixture.detectChanges();
-                   var refs = fixture.debugElement.children[0].references['refs'];
+         fixture.componentInstance.currentTplRef = refs.tplRefs.first;
+         fixture.detectChanges();
+         expect(fixture.nativeElement).toHaveText('foo');
 
-                   fixture.componentInstance.currentTplRef = refs.tplRefs.first;
-                   fixture.detectChanges();
-                   expect(fixture.nativeElement).toHaveText('foo');
+         fixture.componentInstance.currentTplRef = refs.tplRefs.last;
+         fixture.detectChanges();
+         expect(fixture.nativeElement).toHaveText('bar');
+       }));
 
-                   fixture.componentInstance.currentTplRef = refs.tplRefs.last;
-                   fixture.detectChanges();
-                   expect(fixture.nativeElement).toHaveText('bar');
+    it('should display template if context is null', async(() => {
+         var template =
+             `<tpl-refs #refs="tplRefs"><template>foo</template></tpl-refs><template [ngTemplateOutlet]="currentTplRef" [ngOutletContext]="null"></template>`;
+         TestBed.overrideComponent(TestComponent, {set: {template: template}});
+         let fixture = TestBed.createComponent(TestComponent);
 
-                   async.done();
-                 });
-           }));
+         fixture.detectChanges();
+         expect(fixture.nativeElement).toHaveText('');
 
-    it('should display template if context is null',
-       inject(
-           [TestComponentBuilder, AsyncTestCompleter],
-           (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
-             var template =
-                 `<tpl-refs #refs="tplRefs"><template>foo</template></tpl-refs><template [ngTemplateOutlet]="currentTplRef" [ngOutletContext]="null"></template>`;
-             tcb.overrideTemplate(TestComponent, template)
-                 .createAsync(TestComponent)
-                 .then((fixture) => {
+         var refs = fixture.debugElement.children[0].references['refs'];
 
-                   fixture.detectChanges();
-                   expect(fixture.nativeElement).toHaveText('');
+         fixture.componentInstance.currentTplRef = refs.tplRefs.first;
+         fixture.detectChanges();
+         expect(fixture.nativeElement).toHaveText('foo');
+       }));
 
-                   var refs = fixture.debugElement.children[0].references['refs'];
+    it('should reflect initial context and changes', async(() => {
+         var template =
+             `<tpl-refs #refs="tplRefs"><template let-foo="foo"><span>{{foo}}</span></template></tpl-refs><template [ngTemplateOutlet]="currentTplRef" [ngOutletContext]="context"></template>`;
+         TestBed.overrideComponent(TestComponent, {set: {template: template}});
+         let fixture = TestBed.createComponent(TestComponent);
+         fixture.detectChanges();
 
-                   fixture.componentInstance.currentTplRef = refs.tplRefs.first;
-                   fixture.detectChanges();
-                   expect(fixture.nativeElement).toHaveText('foo');
+         var refs = fixture.debugElement.children[0].references['refs'];
+         fixture.componentInstance.currentTplRef = refs.tplRefs.first;
 
-                   async.done();
-                 });
-           }));
+         fixture.detectChanges();
+         expect(fixture.debugElement.nativeElement).toHaveText('bar');
 
-    it('should reflect initial context and changes',
-       inject(
-           [TestComponentBuilder, AsyncTestCompleter],
-           (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
-             var template =
-                 `<tpl-refs #refs="tplRefs"><template let-foo="foo"><span>{{foo}}</span></template></tpl-refs><template [ngTemplateOutlet]="currentTplRef" [ngOutletContext]="context"></template>`;
-             tcb.overrideTemplate(TestComponent, template)
-                 .createAsync(TestComponent)
-                 .then((fixture) => {
-                   fixture.detectChanges();
+         fixture.componentInstance.context.foo = 'alter-bar';
 
-                   var refs = fixture.debugElement.children[0].references['refs'];
-                   fixture.componentInstance.currentTplRef = refs.tplRefs.first;
+         fixture.detectChanges();
+         expect(fixture.debugElement.nativeElement).toHaveText('alter-bar');
+       }));
 
-                   fixture.detectChanges();
-                   expect(fixture.debugElement.nativeElement).toHaveText('bar');
+    it('should reflect user defined $implicit property in the context', async(() => {
+         var template =
+             `<tpl-refs #refs="tplRefs"><template let-ctx><span>{{ctx.foo}}</span></template></tpl-refs><template [ngTemplateOutlet]="currentTplRef" [ngOutletContext]="context"></template>`;
+         TestBed.overrideComponent(TestComponent, {set: {template: template}});
+         let fixture = TestBed.createComponent(TestComponent);
+         fixture.detectChanges();
 
-                   fixture.componentInstance.context.foo = 'alter-bar';
+         var refs = fixture.debugElement.children[0].references['refs'];
+         fixture.componentInstance.currentTplRef = refs.tplRefs.first;
 
-                   fixture.detectChanges();
-                   expect(fixture.debugElement.nativeElement).toHaveText('alter-bar');
+         fixture.componentInstance.context = {$implicit: fixture.componentInstance.context};
+         fixture.detectChanges();
+         expect(fixture.debugElement.nativeElement).toHaveText('bar');
+       }));
 
-                   async.done();
-                 });
-           }));
+    it('should reflect context re-binding', async(() => {
+         var template =
+             `<tpl-refs #refs="tplRefs"><template let-shawshank="shawshank"><span>{{shawshank}}</span></template></tpl-refs><template [ngTemplateOutlet]="currentTplRef" [ngOutletContext]="context"></template>`;
+         TestBed.overrideComponent(TestComponent, {set: {template: template}});
+         let fixture = TestBed.createComponent(TestComponent);
+         fixture.detectChanges();
 
-    it('should reflect user defined $implicit property in the context',
-       inject(
-           [TestComponentBuilder, AsyncTestCompleter],
-           (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
-             var template =
-                 `<tpl-refs #refs="tplRefs"><template let-ctx><span>{{ctx.foo}}</span></template></tpl-refs><template [ngTemplateOutlet]="currentTplRef" [ngOutletContext]="context"></template>`;
-             tcb.overrideTemplate(TestComponent, template)
-                 .createAsync(TestComponent)
-                 .then((fixture) => {
-                   fixture.detectChanges();
+         var refs = fixture.debugElement.children[0].references['refs'];
+         fixture.componentInstance.currentTplRef = refs.tplRefs.first;
+         fixture.componentInstance.context = {shawshank: 'brooks'};
 
-                   var refs = fixture.debugElement.children[0].references['refs'];
-                   fixture.componentInstance.currentTplRef = refs.tplRefs.first;
+         fixture.detectChanges();
+         expect(fixture.debugElement.nativeElement).toHaveText('brooks');
 
-                   fixture.componentInstance.context = {
-                     $implicit: fixture.componentInstance.context
-                   };
-                   fixture.detectChanges();
-                   expect(fixture.debugElement.nativeElement).toHaveText('bar');
+         fixture.componentInstance.context = {shawshank: 'was here'};
 
-                   async.done();
-                 });
-           }));
-
-    it('should reflect context re-binding',
-       inject(
-           [TestComponentBuilder, AsyncTestCompleter],
-           (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
-             var template =
-                 `<tpl-refs #refs="tplRefs"><template let-shawshank="shawshank"><span>{{shawshank}}</span></template></tpl-refs><template [ngTemplateOutlet]="currentTplRef" [ngOutletContext]="context"></template>`;
-             tcb.overrideTemplate(TestComponent, template)
-                 .createAsync(TestComponent)
-                 .then((fixture) => {
-                   fixture.detectChanges();
-
-                   var refs = fixture.debugElement.children[0].references['refs'];
-                   fixture.componentInstance.currentTplRef = refs.tplRefs.first;
-                   fixture.componentInstance.context = {shawshank: 'brooks'};
-
-                   fixture.detectChanges();
-                   expect(fixture.debugElement.nativeElement).toHaveText('brooks');
-
-                   fixture.componentInstance.context = {shawshank: 'was here'};
-
-                   fixture.detectChanges();
-                   expect(fixture.debugElement.nativeElement).toHaveText('was here');
-
-                   async.done();
-                 });
-           }));
+         fixture.detectChanges();
+         expect(fixture.debugElement.nativeElement).toHaveText('was here');
+       }));
   });
 }
 
diff --git a/modules/@angular/common/test/directives/non_bindable_spec.ts b/modules/@angular/common/test/directives/non_bindable_spec.ts
index 64f9f3af48..a70e01cf27 100644
--- a/modules/@angular/common/test/directives/non_bindable_spec.ts
+++ b/modules/@angular/common/test/directives/non_bindable_spec.ts
@@ -8,59 +8,48 @@
 
 import {Component, Directive} from '@angular/core';
 import {ElementRef} from '@angular/core/src/linker/element_ref';
-import {TestComponentBuilder} from '@angular/core/testing';
-import {AsyncTestCompleter, beforeEach, ddescribe, describe, iit, inject, it, xit} from '@angular/core/testing/testing_internal';
+import {TestBed, async} from '@angular/core/testing';
+import {beforeEach, ddescribe, describe, iit, inject, it, xit} from '@angular/core/testing/testing_internal';
 import {getDOM} from '@angular/platform-browser/src/dom/dom_adapter';
 import {expect} from '@angular/platform-browser/testing/matchers';
 
 export function main() {
   describe('non-bindable', () => {
-    it('should not interpolate children',
-       inject(
-           [TestComponentBuilder, AsyncTestCompleter],
-           (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
-             var template = '<div>{{text}}<span ngNonBindable>{{text}}</span></div>';
-             tcb.overrideTemplate(TestComponent, template)
-                 .createAsync(TestComponent)
-                 .then((fixture) => {
-                   fixture.detectChanges();
-                   expect(fixture.debugElement.nativeElement).toHaveText('foo{{text}}');
-                   async.done();
-                 });
-           }));
 
-    it('should ignore directives on child nodes',
-       inject(
-           [TestComponentBuilder, AsyncTestCompleter],
-           (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
-             var template = '<div ngNonBindable><span id=child test-dec>{{text}}</span></div>';
-             tcb.overrideTemplate(TestComponent, template)
-                 .createAsync(TestComponent)
-                 .then((fixture) => {
-                   fixture.detectChanges();
+    beforeEach(() => {
+      TestBed.configureTestingModule({
+        declarations: [TestComponent],
+      });
+    });
 
-                   // We must use getDOM().querySelector instead of fixture.query here
-                   // since the elements inside are not compiled.
-                   var span = getDOM().querySelector(fixture.debugElement.nativeElement, '#child');
-                   expect(getDOM().hasClass(span, 'compiled')).toBeFalsy();
-                   async.done();
-                 });
-           }));
+    it('should not interpolate children', async(() => {
+         var template = '<div>{{text}}<span ngNonBindable>{{text}}</span></div>';
+         TestBed.overrideComponent(TestComponent, {set: {template: template}});
+         let fixture = TestBed.createComponent(TestComponent);
+         fixture.detectChanges();
+         expect(fixture.debugElement.nativeElement).toHaveText('foo{{text}}');
+       }));
 
-    it('should trigger directives on the same node',
-       inject(
-           [TestComponentBuilder, AsyncTestCompleter],
-           (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
-             var template = '<div><span id=child ngNonBindable test-dec>{{text}}</span></div>';
-             tcb.overrideTemplate(TestComponent, template)
-                 .createAsync(TestComponent)
-                 .then((fixture) => {
-                   fixture.detectChanges();
-                   var span = getDOM().querySelector(fixture.debugElement.nativeElement, '#child');
-                   expect(getDOM().hasClass(span, 'compiled')).toBeTruthy();
-                   async.done();
-                 });
-           }));
+    it('should ignore directives on child nodes', async(() => {
+         var template = '<div ngNonBindable><span id=child test-dec>{{text}}</span></div>';
+         TestBed.overrideComponent(TestComponent, {set: {template: template}});
+         let fixture = TestBed.createComponent(TestComponent);
+         fixture.detectChanges();
+
+         // We must use getDOM().querySelector instead of fixture.query here
+         // since the elements inside are not compiled.
+         var span = getDOM().querySelector(fixture.debugElement.nativeElement, '#child');
+         expect(getDOM().hasClass(span, 'compiled')).toBeFalsy();
+       }));
+
+    it('should trigger directives on the same node', async(() => {
+         var template = '<div><span id=child ngNonBindable test-dec>{{text}}</span></div>';
+         TestBed.overrideComponent(TestComponent, {set: {template: template}});
+         let fixture = TestBed.createComponent(TestComponent);
+         fixture.detectChanges();
+         var span = getDOM().querySelector(fixture.debugElement.nativeElement, '#child');
+         expect(getDOM().hasClass(span, 'compiled')).toBeTruthy();
+       }));
   });
 }
 
diff --git a/modules/@angular/common/test/pipes/json_pipe_spec.ts b/modules/@angular/common/test/pipes/json_pipe_spec.ts
index 83c5a16ac2..ac782f5480 100644
--- a/modules/@angular/common/test/pipes/json_pipe_spec.ts
+++ b/modules/@angular/common/test/pipes/json_pipe_spec.ts
@@ -8,8 +8,8 @@
 
 import {JsonPipe} from '@angular/common';
 import {Component} from '@angular/core';
-import {TestComponentBuilder} from '@angular/core/testing';
-import {AsyncTestCompleter, afterEach, beforeEach, ddescribe, describe, iit, inject, it, xit} from '@angular/core/testing/testing_internal';
+import {TestBed, async} from '@angular/core/testing';
+import {afterEach, beforeEach, ddescribe, describe, iit, inject, it, xit} from '@angular/core/testing/testing_internal';
 import {expect} from '@angular/platform-browser/testing/matchers';
 
 import {Json, StringWrapper} from '../../src/facade/lang';
@@ -55,23 +55,25 @@ export function main() {
     });
 
     describe('integration', () => {
-      it('should work with mutable objects',
-         inject(
-             [TestComponentBuilder, AsyncTestCompleter],
-             (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
-               tcb.createAsync(TestComp).then((fixture) => {
-                 let mutable: number[] = [1];
-                 fixture.debugElement.componentInstance.data = mutable;
-                 fixture.detectChanges();
-                 expect(fixture.debugElement.nativeElement).toHaveText('[\n  1\n]');
 
-                 mutable.push(2);
-                 fixture.detectChanges();
-                 expect(fixture.debugElement.nativeElement).toHaveText('[\n  1,\n  2\n]');
+      beforeEach(() => {
+        TestBed.configureTestingModule({
+          declarations: [TestComp],
+        });
+      });
 
-                 async.done();
-               });
-             }));
+      it('should work with mutable objects', async(() => {
+           let fixture = TestBed.createComponent(TestComp);
+           let mutable: number[] = [1];
+           fixture.debugElement.componentInstance.data = mutable;
+           fixture.detectChanges();
+           expect(fixture.debugElement.nativeElement).toHaveText('[\n  1\n]');
+
+           mutable.push(2);
+           fixture.detectChanges();
+           expect(fixture.debugElement.nativeElement).toHaveText('[\n  1,\n  2\n]');
+
+         }));
     });
   });
 }
diff --git a/modules/@angular/common/test/pipes/slice_pipe_spec.ts b/modules/@angular/common/test/pipes/slice_pipe_spec.ts
index 8e5e406cc9..9a9c72a742 100644
--- a/modules/@angular/common/test/pipes/slice_pipe_spec.ts
+++ b/modules/@angular/common/test/pipes/slice_pipe_spec.ts
@@ -8,8 +8,8 @@
 
 import {SlicePipe} from '@angular/common';
 import {Component} from '@angular/core';
-import {TestComponentBuilder} from '@angular/core/testing';
-import {AsyncTestCompleter, afterEach, beforeEach, ddescribe, describe, iit, inject, it, xit} from '@angular/core/testing/testing_internal';
+import {TestBed, async} from '@angular/core/testing';
+import {afterEach, beforeEach, ddescribe, describe, iit, inject, it, xit} from '@angular/core/testing/testing_internal';
 import {browserDetection} from '@angular/platform-browser/testing/browser_util';
 import {expect} from '@angular/platform-browser/testing/matchers';
 
@@ -88,23 +88,23 @@ export function main() {
     });
 
     describe('integration', () => {
-      it('should work with mutable arrays',
-         inject(
-             [TestComponentBuilder, AsyncTestCompleter],
-             (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
-               tcb.createAsync(TestComp).then((fixture) => {
-                 let mutable: number[] = [1, 2];
-                 fixture.debugElement.componentInstance.data = mutable;
-                 fixture.detectChanges();
-                 expect(fixture.debugElement.nativeElement).toHaveText('2');
+      beforeEach(() => {
+        TestBed.configureTestingModule({
+          declarations: [TestComp],
+        });
+      });
 
-                 mutable.push(3);
-                 fixture.detectChanges();
-                 expect(fixture.debugElement.nativeElement).toHaveText('2,3');
+      it('should work with mutable arrays', async(() => {
+           let fixture = TestBed.createComponent(TestComp);
+           let mutable: number[] = [1, 2];
+           fixture.debugElement.componentInstance.data = mutable;
+           fixture.detectChanges();
+           expect(fixture.debugElement.nativeElement).toHaveText('2');
 
-                 async.done();
-               });
-             }));
+           mutable.push(3);
+           fixture.detectChanges();
+           expect(fixture.debugElement.nativeElement).toHaveText('2,3');
+         }));
     });
   });
 }