chore(format): update to latest formatter

Closes #7958

modules/angular2/test/core/linker/compiler_spec.ts

@@ -1,22 +1,9 @@
-import {
-  ddescribe,
-  describe,
-  xdescribe,
-  it,
-  iit,
-  xit,
-  expect,
-  beforeEach,
-  afterEach,
-  AsyncTestCompleter,
-  inject,
-  beforeEachProviders
-} from 'angular2/testing_internal';
+import {ddescribe, describe, xdescribe, it, iit, xit, expect, beforeEach, afterEach, AsyncTestCompleter, inject, beforeEachProviders} from 'angular2/testing_internal';
 
 import {provide} from 'angular2/core';
 import {Compiler} from 'angular2/src/core/linker/compiler';
 import {reflector, ReflectionInfo} from 'angular2/src/core/reflection/reflection';
-import {Compiler_} from "angular2/src/core/linker/compiler";
+import {Compiler_} from 'angular2/src/core/linker/compiler';
 import {HostViewFactory} from 'angular2/src/core/linker/view';
 import {HostViewFactoryRef_} from 'angular2/src/core/linker/view_ref';
 
@@ -33,12 +20,11 @@ export function main() {
 
     it('should read the template from an annotation',
        inject([AsyncTestCompleter, Compiler], (async, compiler: Compiler) => {
-         compiler.compileInHost(SomeComponent)
-             .then((hostViewFactoryRef: HostViewFactoryRef_) => {
-               expect(hostViewFactoryRef.internalHostViewFactory).toBe(someHostViewFactory);
-               async.done();
-               return null;
-             });
+         compiler.compileInHost(SomeComponent).then((hostViewFactoryRef: HostViewFactoryRef_) => {
+           expect(hostViewFactoryRef.internalHostViewFactory).toBe(someHostViewFactory);
+           async.done();
+           return null;
+         });
        }));
 
     it('should clear the cache', inject([Compiler], (compiler) => {

modules/angular2/test/core/linker/directive_lifecycle_spec.ts

@@ -1,17 +1,4 @@
-import {
-  AsyncTestCompleter,
-  beforeEach,
-  xdescribe,
-  ddescribe,
-  describe,
-  el,
-  expect,
-  iit,
-  inject,
-  it,
-  SpyObject,
-  proxy
-} from 'angular2/testing_internal';
+import {AsyncTestCompleter, beforeEach, xdescribe, ddescribe, describe, el, expect, iit, inject, it, SpyObject, proxy} from 'angular2/testing_internal';
 
 import {hasLifecycleHook} from 'angular2/src/core/linker/directive_lifecycle_reflector';
 import {LifecycleHooks} from 'angular2/src/core/linker/interfaces';
@@ -20,93 +7,93 @@ export function main() {
   describe('Create DirectiveMetadata', () => {
     describe('lifecycle', () => {
 
-      describe("ngOnChanges", () => {
-        it("should be true when the directive has the ngOnChanges method", () => {
+      describe('ngOnChanges', () => {
+        it('should be true when the directive has the ngOnChanges method', () => {
           expect(hasLifecycleHook(LifecycleHooks.OnChanges, DirectiveWithOnChangesMethod))
               .toBe(true);
         });
 
-        it("should be false otherwise", () => {
+        it('should be false otherwise', () => {
           expect(hasLifecycleHook(LifecycleHooks.OnChanges, DirectiveNoHooks)).toBe(false);
         });
       });
 
-      describe("ngOnDestroy", () => {
-        it("should be true when the directive has the ngOnDestroy method", () => {
+      describe('ngOnDestroy', () => {
+        it('should be true when the directive has the ngOnDestroy method', () => {
           expect(hasLifecycleHook(LifecycleHooks.OnDestroy, DirectiveWithOnDestroyMethod))
               .toBe(true);
         });
 
-        it("should be false otherwise", () => {
+        it('should be false otherwise', () => {
           expect(hasLifecycleHook(LifecycleHooks.OnDestroy, DirectiveNoHooks)).toBe(false);
         });
       });
 
-      describe("ngOnInit", () => {
-        it("should be true when the directive has the ngOnInit method", () => {
+      describe('ngOnInit', () => {
+        it('should be true when the directive has the ngOnInit method', () => {
           expect(hasLifecycleHook(LifecycleHooks.OnInit, DirectiveWithOnInitMethod)).toBe(true);
         });
 
-        it("should be false otherwise", () => {
+        it('should be false otherwise', () => {
           expect(hasLifecycleHook(LifecycleHooks.OnInit, DirectiveNoHooks)).toBe(false);
         });
       });
 
-      describe("ngDoCheck", () => {
-        it("should be true when the directive has the ngDoCheck method", () => {
+      describe('ngDoCheck', () => {
+        it('should be true when the directive has the ngDoCheck method', () => {
           expect(hasLifecycleHook(LifecycleHooks.DoCheck, DirectiveWithOnCheckMethod)).toBe(true);
         });
 
-        it("should be false otherwise", () => {
+        it('should be false otherwise', () => {
           expect(hasLifecycleHook(LifecycleHooks.DoCheck, DirectiveNoHooks)).toBe(false);
         });
       });
 
-      describe("ngAfterContentInit", () => {
-        it("should be true when the directive has the ngAfterContentInit method", () => {
-          expect(hasLifecycleHook(LifecycleHooks.AfterContentInit,
-                                  DirectiveWithAfterContentInitMethod))
+      describe('ngAfterContentInit', () => {
+        it('should be true when the directive has the ngAfterContentInit method', () => {
+          expect(hasLifecycleHook(
+                     LifecycleHooks.AfterContentInit, DirectiveWithAfterContentInitMethod))
               .toBe(true);
         });
 
-        it("should be false otherwise", () => {
+        it('should be false otherwise', () => {
           expect(hasLifecycleHook(LifecycleHooks.AfterContentInit, DirectiveNoHooks)).toBe(false);
         });
       });
 
-      describe("ngAfterContentChecked", () => {
-        it("should be true when the directive has the ngAfterContentChecked method", () => {
-          expect(hasLifecycleHook(LifecycleHooks.AfterContentChecked,
-                                  DirectiveWithAfterContentCheckedMethod))
+      describe('ngAfterContentChecked', () => {
+        it('should be true when the directive has the ngAfterContentChecked method', () => {
+          expect(hasLifecycleHook(
+                     LifecycleHooks.AfterContentChecked, DirectiveWithAfterContentCheckedMethod))
               .toBe(true);
         });
 
-        it("should be false otherwise", () => {
+        it('should be false otherwise', () => {
           expect(hasLifecycleHook(LifecycleHooks.AfterContentChecked, DirectiveNoHooks))
               .toBe(false);
         });
       });
 
 
-      describe("ngAfterViewInit", () => {
-        it("should be true when the directive has the ngAfterViewInit method", () => {
+      describe('ngAfterViewInit', () => {
+        it('should be true when the directive has the ngAfterViewInit method', () => {
           expect(hasLifecycleHook(LifecycleHooks.AfterViewInit, DirectiveWithAfterViewInitMethod))
               .toBe(true);
         });
 
-        it("should be false otherwise", () => {
+        it('should be false otherwise', () => {
           expect(hasLifecycleHook(LifecycleHooks.AfterViewInit, DirectiveNoHooks)).toBe(false);
         });
       });
 
-      describe("ngAfterViewChecked", () => {
-        it("should be true when the directive has the ngAfterViewChecked method", () => {
-          expect(hasLifecycleHook(LifecycleHooks.AfterViewChecked,
-                                  DirectiveWithAfterViewCheckedMethod))
+      describe('ngAfterViewChecked', () => {
+        it('should be true when the directive has the ngAfterViewChecked method', () => {
+          expect(hasLifecycleHook(
+                     LifecycleHooks.AfterViewChecked, DirectiveWithAfterViewCheckedMethod))
               .toBe(true);
         });
 
-        it("should be false otherwise", () => {
+        it('should be false otherwise', () => {
           expect(hasLifecycleHook(LifecycleHooks.AfterViewChecked, DirectiveNoHooks)).toBe(false);
         });
       });

modules/angular2/test/core/linker/directive_resolver_spec.ts

@@ -1,21 +1,6 @@
 import {ddescribe, describe, it, iit, expect, beforeEach} from 'angular2/testing_internal';
 import {DirectiveResolver} from 'angular2/src/core/linker/directive_resolver';
-import {
-  DirectiveMetadata,
-  Directive,
-  Input,
-  Output,
-  HostBinding,
-  HostListener,
-  ContentChildren,
-  ContentChildrenMetadata,
-  ViewChildren,
-  ViewChildrenMetadata,
-  ContentChild,
-  ContentChildMetadata,
-  ViewChild,
-  ViewChildMetadata
-} from 'angular2/src/core/metadata';
+import {DirectiveMetadata, Directive, Input, Output, HostBinding, HostListener, ContentChildren, ContentChildrenMetadata, ViewChildren, ViewChildrenMetadata, ContentChild, ContentChildMetadata, ViewChild, ViewChildMetadata} from 'angular2/src/core/metadata';
 
 @Directive({selector: 'someDirective'})
 class SomeDirective {
@@ -28,14 +13,14 @@ class SomeChildDirective extends SomeDirective {
 @Directive({selector: 'someDirective', inputs: ['c']})
 class SomeDirectiveWithInputs {
   @Input() a;
-  @Input("renamed") b;
+  @Input('renamed') b;
   c;
 }
 
 @Directive({selector: 'someDirective', outputs: ['c']})
 class SomeDirectiveWithOutputs {
   @Output() a;
-  @Output("renamed") b;
+  @Output('renamed') b;
   c;
 }
 
@@ -55,64 +40,59 @@ class SomeDirectiveWithEvents {
 
 @Directive({selector: 'someDirective'})
 class SomeDirectiveWithSetterProps {
-  @Input("renamed")
-  set a(value) {
-  }
+  @Input('renamed')
+  set a(value) {}
 }
 
 @Directive({selector: 'someDirective'})
 class SomeDirectiveWithGetterOutputs {
-  @Output("renamed")
-  get a() {
-    return null;
-  }
+  @Output('renamed')
+  get a() { return null; }
 }
 
 @Directive({selector: 'someDirective', host: {'[c]': 'c'}})
 class SomeDirectiveWithHostBindings {
   @HostBinding() a;
-  @HostBinding("renamed") b;
+  @HostBinding('renamed') b;
   c;
 }
 
 @Directive({selector: 'someDirective', host: {'(c)': 'onC()'}})
 class SomeDirectiveWithHostListeners {
   @HostListener('a')
-  onA() {
-  }
+  onA() {}
   @HostListener('b', ['$event.value'])
-  onB(value) {
-  }
+  onB(value) {}
 }
 
-@Directive({selector: 'someDirective', queries: {"cs": new ContentChildren("c")}})
+@Directive({selector: 'someDirective', queries: {'cs': new ContentChildren('c')}})
 class SomeDirectiveWithContentChildren {
-  @ContentChildren("a") as: any;
+  @ContentChildren('a') as: any;
   c;
 }
 
-@Directive({selector: 'someDirective', queries: {"cs": new ViewChildren("c")}})
+@Directive({selector: 'someDirective', queries: {'cs': new ViewChildren('c')}})
 class SomeDirectiveWithViewChildren {
-  @ViewChildren("a") as: any;
+  @ViewChildren('a') as: any;
   c;
 }
 
-@Directive({selector: 'someDirective', queries: {"c": new ContentChild("c")}})
+@Directive({selector: 'someDirective', queries: {'c': new ContentChild('c')}})
 class SomeDirectiveWithContentChild {
-  @ContentChild("a") a: any;
+  @ContentChild('a') a: any;
   c;
 }
 
-@Directive({selector: 'someDirective', queries: {"c": new ViewChild("c")}})
+@Directive({selector: 'someDirective', queries: {'c': new ViewChild('c')}})
 class SomeDirectiveWithViewChild {
-  @ViewChild("a") a: any;
+  @ViewChild('a') a: any;
   c;
 }
 
 class SomeDirectiveWithoutMetadata {}
 
 export function main() {
-  describe("DirectiveResolver", () => {
+  describe('DirectiveResolver', () => {
     var resolver: DirectiveResolver;
 
     beforeEach(() => { resolver = new DirectiveResolver(); });
@@ -125,8 +105,9 @@ export function main() {
     });
 
     it('should throw if not matching metadata is found', () => {
-      expect(() => { resolver.resolve(SomeDirectiveWithoutMetadata); })
-          .toThrowError('No Directive annotation found on SomeDirectiveWithoutMetadata');
+      expect(() => {
+        resolver.resolve(SomeDirectiveWithoutMetadata);
+      }).toThrowError('No Directive annotation found on SomeDirectiveWithoutMetadata');
     });
 
     it('should not read parent class Directive metadata', function() {
@@ -184,25 +165,25 @@ export function main() {
       it('should append ContentChildren', () => {
         var directiveMetadata = resolver.resolve(SomeDirectiveWithContentChildren);
         expect(directiveMetadata.queries)
-            .toEqual({"cs": new ContentChildren("c"), "as": new ContentChildren("a")});
+            .toEqual({'cs': new ContentChildren('c'), 'as': new ContentChildren('a')});
       });
 
       it('should append ViewChildren', () => {
         var directiveMetadata = resolver.resolve(SomeDirectiveWithViewChildren);
         expect(directiveMetadata.queries)
-            .toEqual({"cs": new ViewChildren("c"), "as": new ViewChildren("a")});
+            .toEqual({'cs': new ViewChildren('c'), 'as': new ViewChildren('a')});
       });
 
       it('should append ContentChild', () => {
         var directiveMetadata = resolver.resolve(SomeDirectiveWithContentChild);
         expect(directiveMetadata.queries)
-            .toEqual({"c": new ContentChild("c"), "a": new ContentChild("a")});
+            .toEqual({'c': new ContentChild('c'), 'a': new ContentChild('a')});
       });
 
       it('should append ViewChild', () => {
         var directiveMetadata = resolver.resolve(SomeDirectiveWithViewChild);
         expect(directiveMetadata.queries)
-            .toEqual({"c": new ViewChild("c"), "a": new ViewChild("a")});
+            .toEqual({'c': new ViewChild('c'), 'a': new ViewChild('a')});
       });
     });
   });

modules/angular2/test/core/linker/dynamic_component_loader_spec.ts

@@ -1,20 +1,4 @@
-import {
-  AsyncTestCompleter,
-  beforeEach,
-  ddescribe,
-  xdescribe,
-  describe,
-  el,
-  dispatchEvent,
-  expect,
-  iit,
-  inject,
-  beforeEachProviders,
-  it,
-  xit,
-  TestComponentBuilder,
-  ComponentFixture
-} from 'angular2/testing_internal';
+import {AsyncTestCompleter, beforeEach, ddescribe, xdescribe, describe, el, dispatchEvent, expect, iit, inject, beforeEachProviders, it, xit, TestComponentBuilder, ComponentFixture} from 'angular2/testing_internal';
 
 import {OnDestroy} from 'angular2/core';
 import {Injector} from 'angular2/core';
@@ -24,50 +8,48 @@ import {DynamicComponentLoader} from 'angular2/src/core/linker/dynamic_component
 import {ElementRef, ElementRef_} from 'angular2/src/core/linker/element_ref';
 import {DOCUMENT} from 'angular2/src/platform/dom/dom_tokens';
 import {DOM} from 'angular2/src/platform/dom/dom_adapter';
-import {ComponentFixture_} from "angular2/src/testing/test_component_builder";
+import {ComponentFixture_} from 'angular2/src/testing/test_component_builder';
 import {BaseException} from 'angular2/src/facade/exceptions';
 import {PromiseWrapper} from 'angular2/src/facade/promise';
 import {stringify} from 'angular2/src/facade/lang';
 
 export function main() {
   describe('DynamicComponentLoader', function() {
-    describe("loading into a location", () => {
+    describe('loading into a location', () => {
       it('should work',
-         inject([DynamicComponentLoader, TestComponentBuilder, AsyncTestCompleter],
-                (loader: DynamicComponentLoader, tcb: TestComponentBuilder, async) => {
-                  tcb.overrideView(
-                         MyComp,
-                         new ViewMetadata(
-                             {template: '<location #loc></location>', directives: [Location]}))
-                      .createAsync(MyComp)
-                      .then((tc) => {
-                        loader.loadIntoLocation(DynamicallyLoaded, tc.elementRef, 'loc')
-                            .then(ref => {
-                              expect(tc.debugElement.nativeElement)
-                                  .toHaveText("Location;DynamicallyLoaded;");
-                              async.done();
-                            });
-                      });
-                }));
+         inject(
+             [DynamicComponentLoader, TestComponentBuilder, AsyncTestCompleter],
+             (loader: DynamicComponentLoader, tcb: TestComponentBuilder, async) => {
+               tcb.overrideView(
+                      MyComp, new ViewMetadata(
+                                  {template: '<location #loc></location>', directives: [Location]}))
+                   .createAsync(MyComp)
+                   .then((tc) => {
+                     loader.loadIntoLocation(DynamicallyLoaded, tc.elementRef, 'loc').then(ref => {
+                       expect(tc.debugElement.nativeElement)
+                           .toHaveText('Location;DynamicallyLoaded;');
+                       async.done();
+                     });
+                   });
+             }));
 
       it('should return a disposable component ref',
-         inject([DynamicComponentLoader, TestComponentBuilder, AsyncTestCompleter],
-                (loader: DynamicComponentLoader, tcb: TestComponentBuilder, async) => {
-                  tcb.overrideView(
-                         MyComp,
-                         new ViewMetadata(
-                             {template: '<location #loc></location>', directives: [Location]}))
-                      .createAsync(MyComp)
-                      .then((tc) => {
+         inject(
+             [DynamicComponentLoader, TestComponentBuilder, AsyncTestCompleter],
+             (loader: DynamicComponentLoader, tcb: TestComponentBuilder, async) => {
+               tcb.overrideView(
+                      MyComp, new ViewMetadata(
+                                  {template: '<location #loc></location>', directives: [Location]}))
+                   .createAsync(MyComp)
+                   .then((tc) => {
 
-                        loader.loadIntoLocation(DynamicallyLoaded, tc.elementRef, 'loc')
-                            .then(ref => {
-                              ref.dispose();
-                              expect(tc.debugElement.nativeElement).toHaveText("Location;");
-                              async.done();
-                            });
-                      });
-                }));
+                     loader.loadIntoLocation(DynamicallyLoaded, tc.elementRef, 'loc').then(ref => {
+                       ref.dispose();
+                       expect(tc.debugElement.nativeElement).toHaveText('Location;');
+                       async.done();
+                     });
+                   });
+             }));
 
       it('should allow to dispose even if the location has been removed',
          inject(
@@ -93,14 +75,14 @@ export function main() {
                      loader.loadIntoLocation(DynamicallyLoaded, childElementRef, 'loc')
                          .then(ref => {
                            expect(tc.debugElement.nativeElement)
-                               .toHaveText("Location;DynamicallyLoaded;");
+                               .toHaveText('Location;DynamicallyLoaded;');
 
                            tc.debugElement.componentInstance.ctxBoolProp = false;
                            tc.detectChanges();
-                           expect(tc.debugElement.nativeElement).toHaveText("");
+                           expect(tc.debugElement.nativeElement).toHaveText('');
 
                            ref.dispose();
-                           expect(tc.debugElement.nativeElement).toHaveText("");
+                           expect(tc.debugElement.nativeElement).toHaveText('');
                            async.done();
                          });
                    });
@@ -117,85 +99,89 @@ export function main() {
                    .then((tc) => {
                      loader.loadIntoLocation(DynamicallyLoadedWithHostProps, tc.elementRef, 'loc')
                          .then(ref => {
-                           ref.instance.id = "new value";
+                           ref.instance.id = 'new value';
 
                            tc.detectChanges();
 
                            var newlyInsertedElement =
                                DOM.childNodes(tc.debugElement.nativeElement)[1];
-                           expect((<HTMLElement>newlyInsertedElement).id).toEqual("new value");
+                           expect((<HTMLElement>newlyInsertedElement).id).toEqual('new value');
                            async.done();
                          });
                    });
              }));
 
       it('should leave the view tree in a consistent state if hydration fails',
-         inject([DynamicComponentLoader, TestComponentBuilder, AsyncTestCompleter],
-                (loader: DynamicComponentLoader, tcb: TestComponentBuilder, async) => {
-                  tcb.overrideView(MyComp, new ViewMetadata({
-                                     template: '<div><location #loc></location></div>',
-                                     directives: [Location]
-                                   }))
-                      .createAsync(MyComp)
-                      .then((tc: ComponentFixture) => {
-                        tc.debugElement
+         inject(
+             [DynamicComponentLoader, TestComponentBuilder, AsyncTestCompleter],
+             (loader: DynamicComponentLoader, tcb: TestComponentBuilder, async) => {
+               tcb.overrideView(MyComp, new ViewMetadata({
+                                  template: '<div><location #loc></location></div>',
+                                  directives: [Location]
+                                }))
+                   .createAsync(MyComp)
+                   .then((tc: ComponentFixture) => {
+                     tc.debugElement
 
-                            PromiseWrapper.catchError(
-                                loader.loadIntoLocation(DynamicallyLoadedThrows, tc.elementRef,
-                                                        'loc'),
-                                error => {
-                                  expect(error.message).toContain("ThrownInConstructor");
-                                  expect(() => tc.detectChanges()).not.toThrow();
-                                  async.done();
-                                  return null;
-                                });
-                      });
-                }));
+                     PromiseWrapper.catchError(
+                         loader.loadIntoLocation(DynamicallyLoadedThrows, tc.elementRef, 'loc'),
+                         error => {
+                           expect(error.message).toContain('ThrownInConstructor');
+                           expect(() => tc.detectChanges()).not.toThrow();
+                           async.done();
+                           return null;
+                         });
+                   });
+             }));
 
       it('should throw if the variable does not exist',
-         inject([DynamicComponentLoader, TestComponentBuilder, AsyncTestCompleter],
-                (loader: DynamicComponentLoader, tcb: TestComponentBuilder, async) => {
-                  tcb.overrideView(
-                         MyComp,
-                         new ViewMetadata(
-                             {template: '<location #loc></location>', directives: [Location]}))
-                      .createAsync(MyComp)
-                      .then((tc) => {
-                        expect(() => loader.loadIntoLocation(DynamicallyLoadedWithHostProps,
-                                                             tc.elementRef, 'someUnknownVariable'))
-                            .toThrowError('Could not find variable someUnknownVariable');
-                        async.done();
-                      });
-                }));
+         inject(
+             [DynamicComponentLoader, TestComponentBuilder, AsyncTestCompleter],
+             (loader: DynamicComponentLoader, tcb: TestComponentBuilder, async) => {
+               tcb.overrideView(
+                      MyComp, new ViewMetadata(
+                                  {template: '<location #loc></location>', directives: [Location]}))
+                   .createAsync(MyComp)
+                   .then((tc) => {
+                     expect(
+                         () => loader.loadIntoLocation(
+                             DynamicallyLoadedWithHostProps, tc.elementRef, 'someUnknownVariable'))
+                         .toThrowError('Could not find variable someUnknownVariable');
+                     async.done();
+                   });
+             }));
 
       it('should allow to pass projectable nodes',
-         inject([DynamicComponentLoader, TestComponentBuilder, AsyncTestCompleter],
-                (loader: DynamicComponentLoader, tcb: TestComponentBuilder, async) => {
-                  tcb.overrideView(MyComp,
-                                   new ViewMetadata({template: '<div #loc></div>', directives: []}))
-                      .createAsync(MyComp)
-                      .then((tc) => {
-                        loader.loadIntoLocation(DynamicallyLoadedWithNgContent, tc.elementRef,
-                                                'loc', null, [[DOM.createTextNode('hello')]])
-                            .then(ref => {
-                              tc.detectChanges();
-                              expect(tc.nativeElement).toHaveText('dynamic(hello)');
-                              async.done();
-                            });
-                      });
-                }));
+         inject(
+             [DynamicComponentLoader, TestComponentBuilder, AsyncTestCompleter],
+             (loader: DynamicComponentLoader, tcb: TestComponentBuilder, async) => {
+               tcb.overrideView(
+                      MyComp, new ViewMetadata({template: '<div #loc></div>', directives: []}))
+                   .createAsync(MyComp)
+                   .then((tc) => {
+                     loader
+                         .loadIntoLocation(
+                             DynamicallyLoadedWithNgContent, tc.elementRef, 'loc', null,
+                             [[DOM.createTextNode('hello')]])
+                         .then(ref => {
+                           tc.detectChanges();
+                           expect(tc.nativeElement).toHaveText('dynamic(hello)');
+                           async.done();
+                         });
+                   });
+             }));
 
       it('should throw if not enough projectable nodes are passed in',
          inject(
              [DynamicComponentLoader, TestComponentBuilder, AsyncTestCompleter],
              (loader: DynamicComponentLoader, tcb: TestComponentBuilder, async) => {
-               tcb.overrideView(MyComp,
-                                new ViewMetadata({template: '<div #loc></div>', directives: []}))
+               tcb.overrideView(
+                      MyComp, new ViewMetadata({template: '<div #loc></div>', directives: []}))
                    .createAsync(MyComp)
                    .then((tc) => {
                      PromiseWrapper.catchError(
-                         loader.loadIntoLocation(DynamicallyLoadedWithNgContent, tc.elementRef,
-                                                 'loc', null, []),
+                         loader.loadIntoLocation(
+                             DynamicallyLoadedWithNgContent, tc.elementRef, 'loc', null, []),
                          (e) => {
                            expect(e.message).toContain(
                                `The component ${stringify(DynamicallyLoadedWithNgContent)} has 1 <ng-content> elements, but only 0 slots were provided`);
@@ -207,152 +193,157 @@ export function main() {
 
     });
 
-    describe("loading next to a location", () => {
+    describe('loading next to a location', () => {
       it('should work',
-         inject([DynamicComponentLoader, TestComponentBuilder, AsyncTestCompleter],
-                (loader: DynamicComponentLoader, tcb: TestComponentBuilder, async) => {
-                  tcb.overrideView(MyComp, new ViewMetadata({
-                                     template: '<div><location #loc></location></div>',
-                                     directives: [Location]
-                                   }))
-                      .createAsync(MyComp)
-                      .then((tc) => {
-                        loader.loadNextToLocation(DynamicallyLoaded, tc.elementRef)
-                            .then(ref => {
-                              expect(tc.debugElement.nativeElement).toHaveText("Location;");
-                              expect(DOM.nextSibling(tc.debugElement.nativeElement))
-                                  .toHaveText('DynamicallyLoaded;');
+         inject(
+             [DynamicComponentLoader, TestComponentBuilder, AsyncTestCompleter],
+             (loader: DynamicComponentLoader, tcb: TestComponentBuilder, async) => {
+               tcb.overrideView(MyComp, new ViewMetadata({
+                                  template: '<div><location #loc></location></div>',
+                                  directives: [Location]
+                                }))
+                   .createAsync(MyComp)
+                   .then((tc) => {
+                     loader.loadNextToLocation(DynamicallyLoaded, tc.elementRef).then(ref => {
+                       expect(tc.debugElement.nativeElement).toHaveText('Location;');
+                       expect(DOM.nextSibling(tc.debugElement.nativeElement))
+                           .toHaveText('DynamicallyLoaded;');
 
-                              async.done();
-                            });
-                      });
-                }));
+                       async.done();
+                     });
+                   });
+             }));
 
       it('should return a disposable component ref',
-         inject([DynamicComponentLoader, TestComponentBuilder, AsyncTestCompleter],
-                (loader: DynamicComponentLoader, tcb: TestComponentBuilder, async) => {
-                  tcb.overrideView(MyComp, new ViewMetadata({
-                                     template: '<div><location #loc></location></div>',
-                                     directives: [Location]
-                                   }))
-                      .
+         inject(
+             [DynamicComponentLoader, TestComponentBuilder, AsyncTestCompleter],
+             (loader: DynamicComponentLoader, tcb: TestComponentBuilder, async) => {
+               tcb.overrideView(MyComp, new ViewMetadata({
+                                  template: '<div><location #loc></location></div>',
+                                  directives: [Location]
+                                }))
+                   .
 
-                      createAsync(MyComp)
-                      .then((tc) => {
-                        loader.loadNextToLocation(DynamicallyLoaded, tc.elementRef)
-                            .then(ref => {
-                              loader.loadNextToLocation(DynamicallyLoaded2, tc.elementRef)
-                                  .then(ref2 => {
-                                    var firstSibling =
-                                        DOM.nextSibling(tc.debugElement.nativeElement);
-                                    var secondSibling = DOM.nextSibling(firstSibling);
-                                    expect(tc.debugElement.nativeElement).toHaveText("Location;");
-                                    expect(firstSibling).toHaveText("DynamicallyLoaded;");
-                                    expect(secondSibling).toHaveText("DynamicallyLoaded2;");
+                   createAsync(MyComp)
+                   .then((tc) => {
+                     loader.loadNextToLocation(DynamicallyLoaded, tc.elementRef).then(ref => {
+                       loader.loadNextToLocation(DynamicallyLoaded2, tc.elementRef).then(ref2 => {
+                         var firstSibling = DOM.nextSibling(tc.debugElement.nativeElement);
+                         var secondSibling = DOM.nextSibling(firstSibling);
+                         expect(tc.debugElement.nativeElement).toHaveText('Location;');
+                         expect(firstSibling).toHaveText('DynamicallyLoaded;');
+                         expect(secondSibling).toHaveText('DynamicallyLoaded2;');
 
-                                    ref2.dispose();
+                         ref2.dispose();
 
-                                    firstSibling = DOM.nextSibling(tc.debugElement.nativeElement);
-                                    secondSibling = DOM.nextSibling(firstSibling);
-                                    expect(secondSibling).toBeNull();
+                         firstSibling = DOM.nextSibling(tc.debugElement.nativeElement);
+                         secondSibling = DOM.nextSibling(firstSibling);
+                         expect(secondSibling).toBeNull();
 
-                                    async.done();
-                                  });
-                            });
-                      });
-                }));
+                         async.done();
+                       });
+                     });
+                   });
+             }));
 
       it('should update host properties',
-         inject([DynamicComponentLoader, TestComponentBuilder, AsyncTestCompleter],
-                (loader: DynamicComponentLoader, tcb: TestComponentBuilder, async) => {
-                  tcb.overrideView(MyComp, new ViewMetadata({
-                                     template: '<div><location #loc></location></div>',
-                                     directives: [Location]
-                                   }))
+         inject(
+             [DynamicComponentLoader, TestComponentBuilder, AsyncTestCompleter],
+             (loader: DynamicComponentLoader, tcb: TestComponentBuilder, async) => {
+               tcb.overrideView(MyComp, new ViewMetadata({
+                                  template: '<div><location #loc></location></div>',
+                                  directives: [Location]
+                                }))
 
-                      .createAsync(MyComp)
-                      .then((tc) => {
+                   .createAsync(MyComp)
+                   .then((tc) => {
 
-                        loader.loadNextToLocation(DynamicallyLoadedWithHostProps, tc.elementRef)
-                            .then(ref => {
-                              ref.instance.id = "new value";
+                     loader.loadNextToLocation(DynamicallyLoadedWithHostProps, tc.elementRef)
+                         .then(ref => {
+                           ref.instance.id = 'new value';
 
-                              tc.detectChanges();
+                           tc.detectChanges();
 
-                              var newlyInsertedElement =
-                                  DOM.nextSibling(tc.debugElement.nativeElement);
-                              expect((<HTMLElement>newlyInsertedElement).id).toEqual("new value");
+                           var newlyInsertedElement =
+                               DOM.nextSibling(tc.debugElement.nativeElement);
+                           expect((<HTMLElement>newlyInsertedElement).id).toEqual('new value');
 
-                              async.done();
-                            });
-                      });
-                }));
+                           async.done();
+                         });
+                   });
+             }));
 
       it('should allow to pass projectable nodes',
-         inject([DynamicComponentLoader, TestComponentBuilder, AsyncTestCompleter],
-                (loader: DynamicComponentLoader, tcb: TestComponentBuilder, async) => {
-                  tcb.overrideView(MyComp, new ViewMetadata({template: '', directives: [Location]}))
-                      .createAsync(MyComp)
-                      .then((tc) => {
-                        loader.loadNextToLocation(DynamicallyLoadedWithNgContent, tc.elementRef,
-                                                  null, [[DOM.createTextNode('hello')]])
-                            .then(ref => {
-                              tc.detectChanges();
-                              var newlyInsertedElement =
-                                  DOM.nextSibling(tc.debugElement.nativeElement);
-                              expect(newlyInsertedElement).toHaveText('dynamic(hello)');
-                              async.done();
-                            });
-                      });
-                }));
+         inject(
+             [DynamicComponentLoader, TestComponentBuilder, AsyncTestCompleter],
+             (loader: DynamicComponentLoader, tcb: TestComponentBuilder, async) => {
+               tcb.overrideView(MyComp, new ViewMetadata({template: '', directives: [Location]}))
+                   .createAsync(MyComp)
+                   .then((tc) => {
+                     loader
+                         .loadNextToLocation(
+                             DynamicallyLoadedWithNgContent, tc.elementRef, null,
+                             [[DOM.createTextNode('hello')]])
+                         .then(ref => {
+                           tc.detectChanges();
+                           var newlyInsertedElement =
+                               DOM.nextSibling(tc.debugElement.nativeElement);
+                           expect(newlyInsertedElement).toHaveText('dynamic(hello)');
+                           async.done();
+                         });
+                   });
+             }));
 
     });
 
     describe('loadAsRoot', () => {
       it('should allow to create, update and destroy components',
-         inject([AsyncTestCompleter, DynamicComponentLoader, DOCUMENT, Injector],
-                (async: AsyncTestCompleter, loader: DynamicComponentLoader, doc,
-                 injector: Injector) => {
-                  var rootEl = createRootElement(doc, 'child-cmp');
-                  DOM.appendChild(doc.body, rootEl);
-                  loader.loadAsRoot(ChildComp, null, injector)
-                      .then((componentRef) => {
-                        var el = new ComponentFixture_(componentRef);
+         inject(
+             [AsyncTestCompleter, DynamicComponentLoader, DOCUMENT, Injector],
+             (async: AsyncTestCompleter, loader: DynamicComponentLoader, doc,
+              injector: Injector) => {
+               var rootEl = createRootElement(doc, 'child-cmp');
+               DOM.appendChild(doc.body, rootEl);
+               loader.loadAsRoot(ChildComp, null, injector).then((componentRef) => {
+                 var el = new ComponentFixture_(componentRef);
 
-                        expect(rootEl.parentNode).toBe(doc.body);
+                 expect(rootEl.parentNode).toBe(doc.body);
 
-                        el.detectChanges();
+                 el.detectChanges();
 
-                        expect(rootEl).toHaveText('hello');
+                 expect(rootEl).toHaveText('hello');
 
-                        componentRef.instance.ctxProp = 'new';
+                 componentRef.instance.ctxProp = 'new';
 
-                        el.detectChanges();
+                 el.detectChanges();
 
-                        expect(rootEl).toHaveText('new');
+                 expect(rootEl).toHaveText('new');
 
-                        componentRef.dispose();
+                 componentRef.dispose();
 
-                        expect(rootEl.parentNode).toBeFalsy();
+                 expect(rootEl.parentNode).toBeFalsy();
 
-                        async.done();
-                      });
-                }));
+                 async.done();
+               });
+             }));
 
       it('should allow to pass projectable nodes',
-         inject([AsyncTestCompleter, DynamicComponentLoader, DOCUMENT, Injector],
-                (async: AsyncTestCompleter, loader: DynamicComponentLoader, doc,
-                 injector: Injector) => {
-                  var rootEl = createRootElement(doc, 'dummy');
-                  DOM.appendChild(doc.body, rootEl);
-                  loader.loadAsRoot(DynamicallyLoadedWithNgContent, null, injector, null,
-                                    [[DOM.createTextNode('hello')]])
-                      .then((_) => {
-                        expect(rootEl).toHaveText('dynamic(hello)');
+         inject(
+             [AsyncTestCompleter, DynamicComponentLoader, DOCUMENT, Injector],
+             (async: AsyncTestCompleter, loader: DynamicComponentLoader, doc,
+              injector: Injector) => {
+               var rootEl = createRootElement(doc, 'dummy');
+               DOM.appendChild(doc.body, rootEl);
+               loader
+                   .loadAsRoot(
+                       DynamicallyLoadedWithNgContent, null, injector, null,
+                       [[DOM.createTextNode('hello')]])
+                   .then((_) => {
+                     expect(rootEl).toHaveText('dynamic(hello)');
 
-                        async.done();
-                      });
-                }));
+                     async.done();
+                   });
+             }));
 
     });
 
@@ -381,7 +372,7 @@ class DynamicallyCreatedComponentService {}
 @Component({
   selector: 'hello-cmp',
   viewProviders: [DynamicallyCreatedComponentService],
-  template: "{{greeting}}"
+  template: '{{greeting}}'
 })
 class DynamicallyCreatedCmp implements OnDestroy {
   greeting: string;
@@ -389,41 +380,41 @@ class DynamicallyCreatedCmp implements OnDestroy {
   destroyed: boolean = false;
 
   constructor(a: DynamicallyCreatedComponentService) {
-    this.greeting = "hello";
+    this.greeting = 'hello';
     this.dynamicallyCreatedComponentService = a;
   }
 
   ngOnDestroy() { this.destroyed = true; }
 }
 
-@Component({selector: 'dummy', template: "DynamicallyLoaded;"})
+@Component({selector: 'dummy', template: 'DynamicallyLoaded;'})
 class DynamicallyLoaded {
 }
 
-@Component({selector: 'dummy', template: "DynamicallyLoaded;"})
+@Component({selector: 'dummy', template: 'DynamicallyLoaded;'})
 class DynamicallyLoadedThrows {
-  constructor() { throw new BaseException("ThrownInConstructor"); }
+  constructor() { throw new BaseException('ThrownInConstructor'); }
 }
 
-@Component({selector: 'dummy', template: "DynamicallyLoaded2;"})
+@Component({selector: 'dummy', template: 'DynamicallyLoaded2;'})
 class DynamicallyLoaded2 {
 }
 
-@Component({selector: 'dummy', host: {'[id]': 'id'}, template: "DynamicallyLoadedWithHostProps;"})
+@Component({selector: 'dummy', host: {'[id]': 'id'}, template: 'DynamicallyLoadedWithHostProps;'})
 class DynamicallyLoadedWithHostProps {
   id: string;
 
-  constructor() { this.id = "default"; }
+  constructor() { this.id = 'default'; }
 }
 
-@Component({selector: 'dummy', template: "dynamic(<ng-content></ng-content>)"})
+@Component({selector: 'dummy', template: 'dynamic(<ng-content></ng-content>)'})
 class DynamicallyLoadedWithNgContent {
   id: string;
 
-  constructor() { this.id = "default"; }
+  constructor() { this.id = 'default'; }
 }
 
-@Component({selector: 'location', template: "Location;"})
+@Component({selector: 'location', template: 'Location;'})
 class Location {
   elementRef: ElementRef;
 

modules/angular2/test/core/linker/element_spec.ts

@@ -48,8 +48,8 @@ import {ElementRef} from 'angular2/src/core/linker/element_ref';
 import {DynamicChangeDetector, ChangeDetectorRef, Parser, Lexer} from 'angular2/src/core/change_detection/change_detection';
 import {ChangeDetectorRef_} from 'angular2/src/core/change_detection/change_detector_ref';
 import {QueryList} from 'angular2/src/core/linker/query_list';
-import {AppView, AppProtoView} from "angular2/src/core/linker/view";
-import {ViewType} from "angular2/src/core/linker/view_type";
+import {AppView, AppProtoView} from 'angular2/src/core/linker/view';
+import {ViewType} from 'angular2/src/core/linker/view_type';
 
 @Directive({selector: ''})
 class SimpleDirective {}
@@ -101,18 +101,18 @@ class NeedsDirectiveFromHostShadowDom {
 @Directive({selector: ''})
 class NeedsService {
   service: any;
-  constructor(@Inject("service") service) { this.service = service; }
+  constructor(@Inject('service') service) { this.service = service; }
 }
 
 @Directive({selector: ''})
 class NeedsServiceFromHost {
   service: any;
-  constructor(@Host() @Inject("service") service) { this.service = service; }
+  constructor(@Host() @Inject('service') service) { this.service = service; }
 }
 
 class HasEventEmitter {
   emitter;
-  constructor() { this.emitter = "emitter"; }
+  constructor() { this.emitter = 'emitter'; }
 }
 
 @Directive({selector: ''})
@@ -149,7 +149,7 @@ class NeedsViewQuery {
 @Directive({selector: ''})
 class NeedsQueryByVarBindings {
   query: QueryList<any>;
-  constructor(@Query("one,two") query: QueryList<any>) { this.query = query; }
+  constructor(@Query('one,two') query: QueryList<any>) { this.query = query; }
 }
 
 @Directive({selector: ''})
@@ -334,11 +334,11 @@ export function main() {
     }));
   }
 
-  describe("ProtoAppElement", () => {
+  describe('ProtoAppElement', () => {
     init();
 
     describe('inline strategy', () => {
-      it("should allow for direct access using getProviderAtIndex", () => {
+      it('should allow for direct access using getProviderAtIndex', () => {
         var proto = protoAppElement(0, [SimpleDirective]);
 
         expect(proto.getProviderAtIndex(0)).toBeAnInstanceOf(DirectiveProvider);
@@ -348,7 +348,7 @@ export function main() {
     });
 
     describe('dynamic strategy', () => {
-      it("should allow for direct access using getProviderAtIndex", () => {
+      it('should allow for direct access using getProviderAtIndex', () => {
         var proto = protoAppElement(0, dynamicStrategyDirectives);
 
         expect(proto.getProviderAtIndex(0)).toBeAnInstanceOf(DirectiveProvider);
@@ -359,8 +359,8 @@ export function main() {
       });
     });
 
-    describe(".create", () => {
-      it("should collect providers from all directives", () => {
+    describe('.create', () => {
+      it('should collect providers from all directives', () => {
         mockDirectiveMeta.set(SimpleDirective, new DirectiveMetadata({providers: [provide('injectable1', {useValue: 'injectable1'})]}));
         mockDirectiveMeta.set(SomeOtherDirective, new DirectiveMetadata({
             providers: [provide('injectable2', {useValue: 'injectable2'})]
@@ -372,21 +372,21 @@ export function main() {
 
         expect(pel.getProviderAtIndex(0).key.token).toBe(SimpleDirective);
         expect(pel.getProviderAtIndex(1).key.token).toBe(SomeOtherDirective);
-        expect(pel.getProviderAtIndex(2).key.token).toEqual("injectable1");
-        expect(pel.getProviderAtIndex(3).key.token).toEqual("injectable2");
+        expect(pel.getProviderAtIndex(2).key.token).toEqual('injectable1');
+        expect(pel.getProviderAtIndex(3).key.token).toEqual('injectable2');
       });
 
-      it("should collect view providers from the component", () => {
+      it('should collect view providers from the component', () => {
         mockDirectiveMeta.set(SimpleDirective, new ComponentMetadata({
                               viewProviders: [provide('injectable1', {useValue: 'injectable1'})]
                             }));
         var pel = protoAppElement(0, [SimpleDirective]);
 
         expect(pel.getProviderAtIndex(0).key.token).toBe(SimpleDirective);
-        expect(pel.getProviderAtIndex(1).key.token).toEqual("injectable1");
+        expect(pel.getProviderAtIndex(1).key.token).toEqual('injectable1');
       });
 
-      it("should flatten nested arrays in viewProviders and providers", () => {
+      it('should flatten nested arrays in viewProviders and providers', () => {
         mockDirectiveMeta.set(SimpleDirective, new ComponentMetadata({
                 viewProviders: [[[provide('view', {useValue: 'view'})]]],
                 providers: [[[provide('host', {useValue: 'host'})]]]
@@ -394,8 +394,8 @@ export function main() {
         var pel = protoAppElement(0, [SimpleDirective]);
 
         expect(pel.getProviderAtIndex(0).key.token).toBe(SimpleDirective);
-        expect(pel.getProviderAtIndex(1).key.token).toEqual("view");
-        expect(pel.getProviderAtIndex(2).key.token).toEqual("host");
+        expect(pel.getProviderAtIndex(1).key.token).toEqual('view');
+        expect(pel.getProviderAtIndex(2).key.token).toEqual('host');
       });
 
       it('should support an arbitrary number of providers', () => {
@@ -406,7 +406,7 @@ export function main() {
     });
   });
 
-  describe("AppElement", () => {
+  describe('AppElement', () => {
     init();
 
     [{ strategy: 'inline', directives: [] }, { strategy: 'dynamic',
@@ -415,14 +415,14 @@ export function main() {
       var extraDirectives = context['directives'];
       describe(`${context['strategy']} strategy`, () => {
 
-        describe("injection", () => {
-          it("should instantiate directives that have no dependencies", () => {
+        describe('injection', () => {
+          it('should instantiate directives that have no dependencies', () => {
             var directives = ListWrapper.concat([SimpleDirective], extraDirectives);
             var el = appElement(null, directives);
             expect(el.get(SimpleDirective)).toBeAnInstanceOf(SimpleDirective);
           });
 
-          it("should instantiate directives that depend on an arbitrary number of directives", () => {
+          it('should instantiate directives that depend on an arbitrary number of directives', () => {
             var directives = ListWrapper.concat([SimpleDirective, NeedsDirective], extraDirectives);
             var el = appElement(null, directives);
 
@@ -432,7 +432,7 @@ export function main() {
             expect(d.dependency).toBeAnInstanceOf(SimpleDirective);
           });
 
-          it("should instantiate providers that have dependencies with set visibility",
+          it('should instantiate providers that have dependencies with set visibility',
              function() {
                mockDirectiveMeta.set(SimpleDirective, new ComponentMetadata({
                   providers: [provide('injectable1', {useValue: 'injectable1'})]
@@ -452,7 +452,7 @@ export function main() {
                expect(childInj.get('injectable2')).toEqual('injectable1-injectable2');
              });
 
-          it("should instantiate providers that have dependencies", () => {
+          it('should instantiate providers that have dependencies', () => {
             var providers = [
                     provide('injectable1', {useValue: 'injectable1'}),
                     provide('injectable2', {useFactory:
@@ -466,7 +466,7 @@ export function main() {
             expect(el.get('injectable2')).toEqual('injectable1-injectable2');
           });
 
-          it("should instantiate viewProviders that have dependencies", () => {
+          it('should instantiate viewProviders that have dependencies', () => {
             var viewProviders = [
                     provide('injectable1', {useValue: 'injectable1'}),
                     provide('injectable2', {useFactory:
@@ -481,7 +481,7 @@ export function main() {
             expect(el.get('injectable2')).toEqual('injectable1-injectable2');
           });
 
-          it("should instantiate components that depend on viewProviders providers", () => {
+          it('should instantiate components that depend on viewProviders providers', () => {
             mockDirectiveMeta.set(NeedsService, new ComponentMetadata({
               viewProviders: [provide('service', {useValue: 'service'})]
             }));
@@ -490,7 +490,7 @@ export function main() {
             expect(el.get(NeedsService).service).toEqual('service');
           });
 
-          it("should instantiate providers lazily", () => {
+          it('should instantiate providers lazily', () => {
             var created = false;
             mockDirectiveMeta.set(SimpleDirective, new ComponentMetadata({
               providers: [provide('service', {useFactory: () => created = true})]
@@ -506,7 +506,7 @@ export function main() {
             expect(created).toBe(true);
           });
 
-          it("should instantiate view providers lazily", () => {
+          it('should instantiate view providers lazily', () => {
             var created = false;
             mockDirectiveMeta.set(SimpleDirective, new ComponentMetadata({
                                      viewProviders: [provide('service', {useFactory: () => created = true})]
@@ -522,18 +522,18 @@ export function main() {
             expect(created).toBe(true);
           });
 
-          it("should not instantiate other directives that depend on viewProviders providers",
+          it('should not instantiate other directives that depend on viewProviders providers',
              () => {
                mockDirectiveMeta.set(SimpleDirective,
                new ComponentMetadata({
-                 viewProviders: [provide("service", {useValue: "service"})]
+                 viewProviders: [provide('service', {useValue: 'service'})]
                }));
                expect(() => { appElement(null, ListWrapper.concat([SimpleDirective, NeedsService], extraDirectives)); })
                    .toThrowError(containsRegexp(
                        `No provider for service! (${stringify(NeedsService) } -> service)`));
              });
 
-          it("should instantiate directives that depend on providers of other directives", () => {
+          it('should instantiate directives that depend on providers of other directives', () => {
             mockDirectiveMeta.set(SimpleDirective, new ComponentMetadata({
                       providers: [provide('service', {useValue: 'hostService'})]})
                     );
@@ -544,7 +544,7 @@ export function main() {
             expect(shadowInj.get(NeedsService).service).toEqual('hostService');
           });
 
-          it("should instantiate directives that depend on view providers of a component", () => {
+          it('should instantiate directives that depend on view providers of a component', () => {
             mockDirectiveMeta.set(SimpleDirective, new ComponentMetadata({
                       viewProviders: [provide('service', {useValue: 'hostService'})]})
                     );
@@ -555,7 +555,7 @@ export function main() {
             expect(shadowInj.get(NeedsService).service).toEqual('hostService');
           });
 
-          it("should instantiate directives in a root embedded view that depend on view providers of a component", () => {
+          it('should instantiate directives in a root embedded view that depend on view providers of a component', () => {
             mockDirectiveMeta.set(SimpleDirective, new ComponentMetadata({
                       viewProviders: [provide('service', {useValue: 'hostService'})]})
                     );
@@ -570,9 +570,9 @@ export function main() {
             expect(rootEmbeddedEl.get(NeedsService).service).toEqual('hostService');
           });
 
-          it("should instantiate directives that depend on imperatively created injector (bootstrap)", () => {
+          it('should instantiate directives that depend on imperatively created injector (bootstrap)', () => {
             var rootInjector = Injector.resolveAndCreate([
-              provide("service", {useValue: 'appService'})
+              provide('service', {useValue: 'appService'})
             ]);
             var view = createView(ViewType.HOST, null, null, rootInjector);
             expect(appElement(null, [NeedsService], view).get(NeedsService).service).toEqual('appService');
@@ -580,9 +580,9 @@ export function main() {
             expect(() => appElement(null, [NeedsServiceFromHost], view)).toThrowError();
           });
 
-          it("should instantiate directives that depend on imperatively created providers (root injector)", () => {
+          it('should instantiate directives that depend on imperatively created providers (root injector)', () => {
             var imperativelyCreatedProviders = Injector.resolve([
-              provide("service", {useValue: 'appService'})
+              provide('service', {useValue: 'appService'})
             ]);
             var containerAppElement = appElement(null, []);
             var view = createView(ViewType.HOST, containerAppElement, imperativelyCreatedProviders, null);
@@ -590,8 +590,8 @@ export function main() {
             expect(appElement(null, [NeedsServiceFromHost], view).get(NeedsServiceFromHost).service).toEqual('appService');
           });
 
-          it("should not instantiate a directive in a view that has a host dependency on providers"+
-            " of the component", () => {
+          it('should not instantiate a directive in a view that has a host dependency on providers'+
+            ' of the component', () => {
             mockDirectiveMeta.set(SomeOtherDirective, new DirectiveMetadata({
                     providers: [provide('service', {useValue: 'hostService'})]})
                 );
@@ -600,11 +600,11 @@ export function main() {
                 ListWrapper.concat([SomeOtherDirective], extraDirectives),
                 ListWrapper.concat([NeedsServiceFromHost], extraDirectives)
               );
-            }).toThrowError(new RegExp("No provider for service!"));
+            }).toThrowError(new RegExp('No provider for service!'));
           });
 
-          it("should not instantiate a directive in a view that has a host dependency on providers"+
-            " of a decorator directive", () => {
+          it('should not instantiate a directive in a view that has a host dependency on providers'+
+            ' of a decorator directive', () => {
             mockDirectiveMeta.set(SomeOtherDirective, new DirectiveMetadata({
                       providers: [provide('service', {useValue: 'hostService'})]}));
             expect(() => {
@@ -612,10 +612,10 @@ export function main() {
                 ListWrapper.concat([SimpleDirective, SomeOtherDirective], extraDirectives),
                 ListWrapper.concat([NeedsServiceFromHost], extraDirectives)
               );
-            }).toThrowError(new RegExp("No provider for service!"));
+            }).toThrowError(new RegExp('No provider for service!'));
           });
 
-          it("should get directives", () => {
+          it('should get directives', () => {
             var child = hostShadowElement(
                 ListWrapper.concat([SomeOtherDirective, SimpleDirective], extraDirectives),
                 [NeedsDirectiveFromHostShadowDom]);
@@ -626,7 +626,7 @@ export function main() {
             expect(d.dependency).toBeAnInstanceOf(SimpleDirective);
           });
 
-          it("should get directives from the host", () => {
+          it('should get directives from the host', () => {
             var child = parentChildElements(ListWrapper.concat([SimpleDirective], extraDirectives),
                                              [NeeedsDirectiveFromHost]);
 
@@ -636,19 +636,19 @@ export function main() {
             expect(d.dependency).toBeAnInstanceOf(SimpleDirective);
           });
 
-          it("should throw when a dependency cannot be resolved", () => {
+          it('should throw when a dependency cannot be resolved', () => {
             expect(() => appElement(null, ListWrapper.concat([NeeedsDirectiveFromHost], extraDirectives)))
                 .toThrowError(containsRegexp(
                     `No provider for ${stringify(SimpleDirective) }! (${stringify(NeeedsDirectiveFromHost) } -> ${stringify(SimpleDirective) })`));
           });
 
-          it("should inject null when an optional dependency cannot be resolved", () => {
+          it('should inject null when an optional dependency cannot be resolved', () => {
             var el = appElement(null, ListWrapper.concat([OptionallyNeedsDirective], extraDirectives));
             var d = el.get(OptionallyNeedsDirective);
             expect(d.dependency).toEqual(null);
           });
 
-          it("should allow for direct access using getDirectiveAtIndex", () => {
+          it('should allow for direct access using getDirectiveAtIndex', () => {
             var providers =
                 ListWrapper.concat([SimpleDirective], extraDirectives);
 
@@ -662,7 +662,7 @@ export function main() {
                 .toThrowError(`Index ${firsIndexOut} is out-of-bounds.`);
           });
 
-          it("should instantiate directives that depend on the containing component", () => {
+          it('should instantiate directives that depend on the containing component', () => {
             mockDirectiveMeta.set(SimpleDirective, new ComponentMetadata());
             var shadow = hostShadowElement(ListWrapper.concat([SimpleDirective], extraDirectives),
                                              [NeeedsDirectiveFromHost]);
@@ -672,7 +672,7 @@ export function main() {
             expect(d.dependency).toBeAnInstanceOf(SimpleDirective);
           });
 
-          it("should not instantiate directives that depend on other directives in the containing component's ElementInjector",
+          it('should not instantiate directives that depend on other directives in the containing component\'s ElementInjector',
              () => {
                mockDirectiveMeta.set(SomeOtherDirective, new ComponentMetadata());
                expect(() =>
@@ -708,13 +708,13 @@ export function main() {
           });
         });
 
-        describe("refs", () => {
-          it("should inject ElementRef", () => {
+        describe('refs', () => {
+          it('should inject ElementRef', () => {
             var el = appElement(null, ListWrapper.concat([NeedsElementRef], extraDirectives));
             expect(el.get(NeedsElementRef).elementRef).toBe(el.ref);
           });
 
-          it("should inject ChangeDetectorRef of the component's view into the component via a proxy", () => {
+          it('should inject ChangeDetectorRef of the component\'s view into the component via a proxy', () => {
             mockDirectiveMeta.set(ComponentNeedsChangeDetectorRef, new ComponentMetadata());
             var host = appElement(null, ListWrapper.concat([ComponentNeedsChangeDetectorRef], extraDirectives));
             var view = createView(ViewType.COMPONENT, host);
@@ -723,7 +723,7 @@ export function main() {
             expect((<any>view.changeDetector).spy('markPathToRootAsCheckOnce')).toHaveBeenCalled();
           });
 
-          it("should inject ChangeDetectorRef of the containing component into directives", () => {
+          it('should inject ChangeDetectorRef of the containing component into directives', () => {
             mockDirectiveMeta.set(DirectiveNeedsChangeDetectorRef, new DirectiveMetadata());
             var view = createView(ViewType.HOST);
             var el = appElement(null, ListWrapper.concat([DirectiveNeedsChangeDetectorRef], extraDirectives), view);
@@ -735,12 +735,12 @@ export function main() {
             expect(el.get(NeedsViewContainer).viewContainer).toBeAnInstanceOf(ViewContainerRef_);
           });
 
-          it("should inject TemplateRef", () => {
+          it('should inject TemplateRef', () => {
             var el = appElement(null, ListWrapper.concat([NeedsTemplateRef], extraDirectives), null, dummyViewFactory);
             expect(el.get(NeedsTemplateRef).templateRef.elementRef).toBe(el.ref);
           });
 
-          it("should throw if there is no TemplateRef", () => {
+          it('should throw if there is no TemplateRef', () => {
             expect(() => appElement(null, ListWrapper.concat([NeedsTemplateRef], extraDirectives)))
                 .toThrowError(
                     `No provider for TemplateRef! (${stringify(NeedsTemplateRef) } -> TemplateRef)`);
@@ -795,7 +795,7 @@ export function main() {
             var dirs:Type[] = [NeedsQueryByVarBindings];
 
             var dirVariableBindings:{[key:string]:number} = {
-              "one": null // element
+              'one': null // element
             };
 
             var el = appElement(null, dirs.concat(extraDirectives), null, null, null, dirVariableBindings);
@@ -810,8 +810,8 @@ export function main() {
             var dirs:Type[] = [NeedsQueryByVarBindings, NeedsDirective, SimpleDirective];
 
             var dirVariableBindings:{[key:string]:number} = {
-              "one": 2, // 2 is the index of SimpleDirective
-              "two": 1 // 1 is the index of NeedsDirective
+              'one': 2, // 2 is the index of SimpleDirective
+              'two': 1 // 1 is the index of NeedsDirective
             };
 
             var el = appElement(null, dirs.concat(extraDirectives), null, null, null, dirVariableBindings);

modules/angular2/test/core/linker/projection_integration_spec.ts

@@ -1,42 +1,9 @@
-import {
-  AsyncTestCompleter,
-  beforeEach,
-  ddescribe,
-  xdescribe,
-  describe,
-  el,
-  dispatchEvent,
-  expect,
-  iit,
-  inject,
-  beforeEachProviders,
-  it,
-  xit,
-  containsRegexp,
-  stringifyElement,
-  TestComponentBuilder,
-  ComponentFixture,
-  fakeAsync,
-  tick
-} from 'angular2/testing_internal';
+import {AsyncTestCompleter, beforeEach, ddescribe, xdescribe, describe, el, dispatchEvent, expect, iit, inject, beforeEachProviders, it, xit, containsRegexp, stringifyElement, TestComponentBuilder, ComponentFixture, fakeAsync, tick} from 'angular2/testing_internal';
 
 import {DOM} from 'angular2/src/platform/dom/dom_adapter';
 
-import {
-  bind,
-  provide,
-  forwardRef,
-  Component,
-  Directive,
-  ElementRef,
-  TemplateRef,
-  ViewContainerRef,
-  ViewEncapsulation,
-  ViewMetadata
-} from 'angular2/core';
-import {
-  By,
-} from 'angular2/platform/common_dom';
+import {bind, provide, forwardRef, Component, Directive, ElementRef, TemplateRef, ViewContainerRef, ViewEncapsulation, ViewMetadata} from 'angular2/core';
+import {By,} from 'angular2/platform/common_dom';
 import {getAllDebugNodes} from 'angular2/src/core/debug/debug_node';
 
 export function main() {
@@ -45,8 +12,8 @@ export function main() {
        inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
          tcb.overrideView(MainComp, new ViewMetadata({
                             template: '<simple>' +
-                                          '<div>A</div>' +
-                                          '</simple>',
+                                '<div>A</div>' +
+                                '</simple>',
                             directives: [Simple]
                           }))
              .createAsync(MainComp)
@@ -60,8 +27,8 @@ export function main() {
        inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
          tcb.overrideView(MainComp, new ViewMetadata({
                             template: '{{\'START(\'}}<simple>' +
-                                          '{{text}}' +
-                                          '</simple>{{\')END\'}}',
+                                '{{text}}' +
+                                '</simple>{{\')END\'}}',
                             directives: [Simple]
                           }))
              .createAsync(MainComp)
@@ -137,8 +104,8 @@ export function main() {
 
     it('should not show the light dom even if there is no content tag',
        inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
-         tcb.overrideView(MainComp,
-                          new ViewMetadata({template: '<empty>A</empty>', directives: [Empty]}))
+         tcb.overrideView(
+                MainComp, new ViewMetadata({template: '<empty>A</empty>', directives: [Empty]}))
              .createAsync(MainComp)
              .then((main) => {
 
@@ -151,10 +118,10 @@ export function main() {
        inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
          tcb.overrideView(MainComp, new ViewMetadata({
                             template: '<multiple-content-tags>' +
-                                          '<div>B</div>' +
-                                          '<div>C</div>' +
-                                          '<div class="left">A</div>' +
-                                          '</multiple-content-tags>',
+                                '<div>B</div>' +
+                                '<div>C</div>' +
+                                '<div class="left">A</div>' +
+                                '</multiple-content-tags>',
                             directives: [MultipleContentTagsComponent]
                           }))
              .createAsync(MainComp)
@@ -169,9 +136,9 @@ export function main() {
        inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
          tcb.overrideView(MainComp, new ViewMetadata({
                             template: '<multiple-content-tags>' +
-                                          '<div>B<div class="left">A</div></div>' +
-                                          '<div>C</div>' +
-                                          '</multiple-content-tags>',
+                                '<div>B<div class="left">A</div></div>' +
+                                '<div>C</div>' +
+                                '</multiple-content-tags>',
                             directives: [MultipleContentTagsComponent]
                           }))
              .createAsync(MainComp)
@@ -182,13 +149,13 @@ export function main() {
              });
        }));
 
-    it("should redistribute direct child viewcontainers when the light dom changes",
+    it('should redistribute direct child viewcontainers when the light dom changes',
        inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
          tcb.overrideView(MainComp, new ViewMetadata({
                             template: '<multiple-content-tags>' +
-                                          '<template manual class="left"><div>A1</div></template>' +
-                                          '<div>B</div>' +
-                                          '</multiple-content-tags>',
+                                '<template manual class="left"><div>A1</div></template>' +
+                                '<div>B</div>' +
+                                '</multiple-content-tags>',
                             directives: [MultipleContentTagsComponent, ManualViewportDirective]
                           }))
              .createAsync(MainComp)
@@ -210,13 +177,13 @@ export function main() {
              });
        }));
 
-    it("should support nested components",
+    it('should support nested components',
        inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
          tcb.overrideView(MainComp, new ViewMetadata({
                             template: '<outer-with-indirect-nested>' +
-                                          '<div>A</div>' +
-                                          '<div>B</div>' +
-                                          '</outer-with-indirect-nested>',
+                                '<div>A</div>' +
+                                '<div>B</div>' +
+                                '</outer-with-indirect-nested>',
                             directives: [OuterWithIndirectNestedComponent]
                           }))
              .createAsync(MainComp)
@@ -227,14 +194,14 @@ export function main() {
              });
        }));
 
-    it("should support nesting with content being direct child of a nested component",
+    it('should support nesting with content being direct child of a nested component',
        inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
          tcb.overrideView(MainComp, new ViewMetadata({
                             template: '<outer>' +
-                                          '<template manual class="left"><div>A</div></template>' +
-                                          '<div>B</div>' +
-                                          '<div>C</div>' +
-                                          '</outer>',
+                                '<template manual class="left"><div>A</div></template>' +
+                                '<div>B</div>' +
+                                '<div>C</div>' +
+                                '</outer>',
                             directives: [OuterComponent, ManualViewportDirective],
                           }))
              .createAsync(MainComp)
@@ -256,10 +223,10 @@ export function main() {
        inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
          tcb.overrideView(MainComp, new ViewMetadata({
                             template: '<conditional-content>' +
-                                          '<div class="left">A</div>' +
-                                          '<div>B</div>' +
-                                          '<div>C</div>' +
-                                          '</conditional-content>',
+                                '<div class="left">A</div>' +
+                                '<div>B</div>' +
+                                '<div>C</div>' +
+                                '</conditional-content>',
                             directives: [ConditionalContentComponent]
                           }))
              .createAsync(MainComp)
@@ -326,9 +293,9 @@ export function main() {
        inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
          tcb.overrideView(MainComp, new ViewMetadata({
                             template: '<empty>' +
-                                          '  <template manual><div>A</div></template>' +
-                                          '</empty>' +
-                                          'START(<div project></div>)END',
+                                '  <template manual><div>A</div></template>' +
+                                '</empty>' +
+                                'START(<div project></div>)END',
                             directives: [Empty, ProjectDirective, ManualViewportDirective],
                           }))
              .createAsync(MainComp)
@@ -359,7 +326,7 @@ export function main() {
        inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
          tcb.overrideView(MainComp, new ViewMetadata({
                             template: '<simple><template manual><div>A</div></template></simple>' +
-                                          'START(<div project></div>)END',
+                                'START(<div project></div>)END',
                             directives: [Simple, ProjectDirective, ManualViewportDirective],
                           }))
              .createAsync(MainComp)
@@ -384,10 +351,10 @@ export function main() {
          tcb.overrideView(
                 MainComp, new ViewMetadata({
                   template: '<conditional-content>' +
-                                '<div class="left">A</div>' +
-                                '<div>B</div>' +
-                                '</conditional-content>' +
-                                'START(<div project></div>)END',
+                      '<div class="left">A</div>' +
+                      '<div>B</div>' +
+                      '</conditional-content>' +
+                      'START(<div project></div>)END',
                   directives:
                       [ConditionalContentComponent, ProjectDirective, ManualViewportDirective]
                 }))
@@ -419,8 +386,8 @@ export function main() {
     // the presence of ng-content elements!
     it('should still allow to implement a recursive trees',
        inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
-         tcb.overrideView(MainComp,
-                          new ViewMetadata({template: '<tree></tree>', directives: [Tree]}))
+         tcb.overrideView(
+                MainComp, new ViewMetadata({template: '<tree></tree>', directives: [Tree]}))
              .createAsync(MainComp)
              .then((main) => {
 
@@ -441,7 +408,7 @@ export function main() {
          inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
            tcb.overrideView(MainComp, new ViewMetadata({
                               template: '<simple-native1><div>A</div></simple-native1>' +
-                                            '<simple-native2><div>B</div></simple-native2>',
+                                  '<simple-native2><div>B</div></simple-native2>',
                               directives: [SimpleNative1, SimpleNative2]
                             }))
                .createAsync(MainComp)
@@ -510,8 +477,9 @@ export function main() {
              .then((main) => {
                main.detectChanges();
                expect(DOM.getInnerHTML(main.debugElement.nativeElement))
-                   .toEqual('<cmp-a><cmp-b><cmp-d><d>cmp-d</d></cmp-d></cmp-b>' +
-                            '<cmp-c><c>cmp-c</c></cmp-c></cmp-a>');
+                   .toEqual(
+                       '<cmp-a><cmp-b><cmp-d><d>cmp-d</d></cmp-d></cmp-b>' +
+                       '<cmp-c><c>cmp-c</c></cmp-c></cmp-a>');
                async.done();
              });
        }));
@@ -526,8 +494,9 @@ export function main() {
              .then((main) => {
                main.detectChanges();
                expect(DOM.getInnerHTML(main.debugElement.nativeElement))
-                   .toEqual('<cmp-a1>a1<cmp-b11>b11</cmp-b11><cmp-b12>b12</cmp-b12></cmp-a1>' +
-                            '<cmp-a2>a2<cmp-b21>b21</cmp-b21><cmp-b22>b22</cmp-b22></cmp-a2>');
+                   .toEqual(
+                       '<cmp-a1>a1<cmp-b11>b11</cmp-b11><cmp-b12>b12</cmp-b12></cmp-a1>' +
+                       '<cmp-a2>a2<cmp-b21>b21</cmp-b21><cmp-b22>b22</cmp-b22></cmp-a2>');
                async.done();
              });
        }));
@@ -536,11 +505,11 @@ export function main() {
        inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
          tcb.overrideView(MainComp, new ViewMetadata({
                             template: '<conditional-content>' +
-                                          '<div class="left">A</div>' +
-                                          '<template manual class="left">B</template>' +
-                                          '<div class="left">C</div>' +
-                                          '<div>D</div>' +
-                                          '</conditional-content>',
+                                '<div class="left">A</div>' +
+                                '<template manual class="left">B</template>' +
+                                '<div class="left">C</div>' +
+                                '<div>D</div>' +
+                                '</conditional-content>',
                             directives: [ConditionalContentComponent, ManualViewportDirective]
                           }))
              .createAsync(MainComp)

modules/angular2/test/core/linker/query_list_spec.ts

@@ -1,15 +1,4 @@
-import {
-  describe,
-  it,
-  expect,
-  beforeEach,
-  ddescribe,
-  iit,
-  xit,
-  el,
-  fakeAsync,
-  tick
-} from 'angular2/testing_internal';
+import {describe, it, expect, beforeEach, ddescribe, iit, xit, el, fakeAsync, tick} from 'angular2/testing_internal';
 import {MapWrapper, ListWrapper, iterateListLike} from 'angular2/src/facade/collection';
 import {IS_DART, StringWrapper} from 'angular2/src/facade/lang';
 import {ObservableWrapper} from 'angular2/src/facade/async';
@@ -60,22 +49,22 @@ export function main() {
     if (!IS_DART) {
       it('should support filter', () => {
         queryList.reset(['one', 'two']);
-        expect((<_JsQueryList>queryList).filter((x) => x == "one")).toEqual(['one']);
+        expect((<_JsQueryList>queryList).filter((x) => x == 'one')).toEqual(['one']);
       });
 
       it('should support reduce', () => {
-        queryList.reset(["one", "two"]);
-        expect((<_JsQueryList>queryList).reduce((a, x) => a + x, "start:")).toEqual("start:onetwo");
+        queryList.reset(['one', 'two']);
+        expect((<_JsQueryList>queryList).reduce((a, x) => a + x, 'start:')).toEqual('start:onetwo');
       });
 
       it('should support toArray', () => {
-        queryList.reset(["one", "two"]);
-        expect((<_JsQueryList>queryList).reduce((a, x) => a + x, "start:")).toEqual("start:onetwo");
+        queryList.reset(['one', 'two']);
+        expect((<_JsQueryList>queryList).reduce((a, x) => a + x, 'start:')).toEqual('start:onetwo');
       });
 
       it('should support toArray', () => {
-        queryList.reset(["one", "two"]);
-        expect((<_JsQueryList>queryList).toArray()).toEqual(["one", "two"]);
+        queryList.reset(['one', 'two']);
+        expect((<_JsQueryList>queryList).toArray()).toEqual(['one', 'two']);
       });
     }
 
@@ -113,7 +102,7 @@ export function main() {
              var recorded;
              ObservableWrapper.subscribe(queryList.changes, (v: any) => { recorded = v; });
 
-             queryList.reset(["one"]);
+             queryList.reset(['one']);
              queryList.notifyOnChanges();
              tick();
 

modules/angular2/test/core/linker/view_resolver_spec.ts

@@ -7,29 +7,29 @@ class SomePipe {}
 
 @Component({
   selector: 'sample',
-  template: "some template",
+  template: 'some template',
   directives: [SomeDir],
   pipes: [SomePipe],
-  styles: ["some styles"]
+  styles: ['some styles']
 })
 class ComponentWithView {
 }
 
 @Component({
   selector: 'sample',
-  template: "some template",
+  template: 'some template',
   directives: [SomeDir],
   pipes: [SomePipe],
-  styles: ["some styles"]
+  styles: ['some styles']
 })
 class ComponentWithTemplate {
 }
 
-@Component({selector: 'sample', template: "some template"})
+@Component({selector: 'sample', template: 'some template'})
 class ComponentWithViewTemplate {
 }
 
-@Component({selector: 'sample', templateUrl: "some template url", template: "some template"})
+@Component({selector: 'sample', templateUrl: 'some template url', template: 'some template'})
 class ComponentWithViewTemplateUrl {
 }
 
@@ -41,31 +41,30 @@ class ComponentWithoutView {
 class SimpleClass {}
 
 export function main() {
-  describe("ViewResolver", () => {
+  describe('ViewResolver', () => {
     var resolver: ViewResolver;
 
     beforeEach(() => { resolver = new ViewResolver(); });
 
     it('should read out the View metadata from the Component metadata', () => {
       var viewMetadata = resolver.resolve(ComponentWithTemplate);
-      expect(viewMetadata)
-          .toEqual(new ViewMetadata({
-            template: "some template",
-            directives: [SomeDir],
-            pipes: [SomePipe],
-            styles: ["some styles"]
-          }));
+      expect(viewMetadata).toEqual(new ViewMetadata({
+        template: 'some template',
+        directives: [SomeDir],
+        pipes: [SomePipe],
+        styles: ['some styles']
+      }));
     });
 
     it('should throw when Component has no View decorator and no template is set', () => {
       expect(() => resolver.resolve(ComponentWithoutView))
           .toThrowErrorWith(
-              "Component 'ComponentWithoutView' must have either 'template' or 'templateUrl' set");
+              'Component \'ComponentWithoutView\' must have either \'template\' or \'templateUrl\' set');
     });
 
     it('should throw when simple class has no View decorator and no template is set', () => {
       expect(() => resolver.resolve(SimpleClass))
-          .toThrowErrorWith("Could not compile 'SimpleClass' because it is not a component.");
+          .toThrowErrorWith('Could not compile \'SimpleClass\' because it is not a component.');
     });
   });
 }