refactor: move angular source to /packages rather than modules/@angular

packages/platform-browser/test/browser/bootstrap_spec.ts

@@ -0,0 +1,410 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {isPlatformBrowser} from '@angular/common';
+import {APP_INITIALIZER, CUSTOM_ELEMENTS_SCHEMA, Compiler, Component, Directive, ErrorHandler, Inject, Input, LOCALE_ID, NgModule, OnDestroy, PLATFORM_ID, PLATFORM_INITIALIZER, Pipe, Provider, VERSION, createPlatformFactory, ɵstringify as stringify} from '@angular/core';
+import {ApplicationRef, destroyPlatform} from '@angular/core/src/application_ref';
+import {Console} from '@angular/core/src/console';
+import {ComponentRef} from '@angular/core/src/linker/component_factory';
+import {Testability, TestabilityRegistry} from '@angular/core/src/testability/testability';
+import {AsyncTestCompleter, Log, afterEach, beforeEach, beforeEachProviders, ddescribe, describe, iit, inject, it} from '@angular/core/testing/testing_internal';
+import {BrowserModule} from '@angular/platform-browser';
+import {platformBrowserDynamic} from '@angular/platform-browser-dynamic';
+import {getDOM} from '@angular/platform-browser/src/dom/dom_adapter';
+import {DOCUMENT} from '@angular/platform-browser/src/dom/dom_tokens';
+import {expect} from '@angular/platform-browser/testing/matchers';
+
+@Component({selector: 'non-existent', template: ''})
+class NonExistentComp {
+}
+
+@Component({selector: 'hello-app', template: '{{greeting}} world!'})
+class HelloRootCmp {
+  greeting: string;
+  constructor() { this.greeting = 'hello'; }
+}
+
+@Component({selector: 'hello-app', template: 'before: <ng-content></ng-content> after: done'})
+class HelloRootCmpContent {
+  constructor() {}
+}
+
+@Component({selector: 'hello-app-2', template: '{{greeting}} world, again!'})
+class HelloRootCmp2 {
+  greeting: string;
+  constructor() { this.greeting = 'hello'; }
+}
+
+@Component({selector: 'hello-app', template: ''})
+class HelloRootCmp3 {
+  appBinding: any /** TODO #9100 */;
+
+  constructor(@Inject('appBinding') appBinding: any /** TODO #9100 */) {
+    this.appBinding = appBinding;
+  }
+}
+
+@Component({selector: 'hello-app', template: ''})
+class HelloRootCmp4 {
+  appRef: any /** TODO #9100 */;
+
+  constructor(@Inject(ApplicationRef) appRef: ApplicationRef) { this.appRef = appRef; }
+}
+
+@Component({selector: 'hello-app'})
+class HelloRootMissingTemplate {
+}
+
+@Directive({selector: 'hello-app'})
+class HelloRootDirectiveIsNotCmp {
+}
+
+@Component({selector: 'hello-app', template: ''})
+class HelloOnDestroyTickCmp implements OnDestroy {
+  appRef: ApplicationRef;
+  constructor(@Inject(ApplicationRef) appRef: ApplicationRef) { this.appRef = appRef; }
+
+  ngOnDestroy(): void { this.appRef.tick(); }
+}
+
+@Component({selector: 'hello-app', templateUrl: './sometemplate.html'})
+class HelloUrlCmp {
+  greeting = 'hello';
+}
+
+@Directive({selector: '[someDir]', host: {'[title]': 'someDir'}})
+class SomeDirective {
+  @Input()
+  someDir: string;
+}
+
+@Pipe({name: 'somePipe'})
+class SomePipe {
+  transform(value: string): any { return `transformed ${value}`; }
+}
+
+@Component({selector: 'hello-app', template: `<div  [someDir]="'someValue' | somePipe"></div>`})
+class HelloCmpUsingPlatformDirectiveAndPipe {
+  show: boolean = false;
+}
+
+@Component({selector: 'hello-app', template: '<some-el [someProp]="true">hello world!</some-el>'})
+class HelloCmpUsingCustomElement {
+}
+
+class MockConsole {
+  res: any[] = [];
+  error(s: any): void { this.res.push(s); }
+}
+
+
+class DummyConsole implements Console {
+  public warnings: string[] = [];
+
+  log(message: string) {}
+  warn(message: string) { this.warnings.push(message); }
+}
+
+
+class TestModule {}
+function bootstrap(
+    cmpType: any, providers: Provider[] = [], platformProviders: Provider[] = []): Promise<any> {
+  @NgModule({
+    imports: [BrowserModule],
+    declarations: [cmpType],
+    bootstrap: [cmpType],
+    providers: providers,
+    schemas: [CUSTOM_ELEMENTS_SCHEMA]
+  })
+  class TestModule {
+  }
+  return platformBrowserDynamic(platformProviders).bootstrapModule(TestModule);
+}
+
+export function main() {
+  let el: any /** TODO #9100 */, el2: any /** TODO #9100 */, testProviders: Provider[],
+      lightDom: any /** TODO #9100 */;
+
+  describe('bootstrap factory method', () => {
+    let compilerConsole: DummyConsole;
+
+    beforeEachProviders(() => { return [Log]; });
+
+    beforeEach(inject([DOCUMENT], (doc: any) => {
+      destroyPlatform();
+      compilerConsole = new DummyConsole();
+      testProviders = [{provide: Console, useValue: compilerConsole}];
+
+      const oldRoots = getDOM().querySelectorAll(doc, 'hello-app,hello-app-2,light-dom-el');
+      for (let i = 0; i < oldRoots.length; i++) {
+        getDOM().remove(oldRoots[i]);
+      }
+
+      el = getDOM().createElement('hello-app', doc);
+      el2 = getDOM().createElement('hello-app-2', doc);
+      lightDom = getDOM().createElement('light-dom-el', doc);
+      getDOM().appendChild(doc.body, el);
+      getDOM().appendChild(doc.body, el2);
+      getDOM().appendChild(el, lightDom);
+      getDOM().setText(lightDom, 'loading');
+    }));
+
+    afterEach(destroyPlatform);
+
+    it('should throw if bootstrapped Directive is not a Component',
+       inject([AsyncTestCompleter], (done: AsyncTestCompleter) => {
+         const logger = new MockConsole();
+         const errorHandler = new ErrorHandler(false);
+         errorHandler._console = logger as any;
+         expect(
+             () => bootstrap(
+                 HelloRootDirectiveIsNotCmp, [{provide: ErrorHandler, useValue: errorHandler}]))
+             .toThrowError(`HelloRootDirectiveIsNotCmp cannot be used as an entry component.`);
+         done.done();
+       }));
+
+    it('should throw if no element is found',
+       inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
+         const logger = new MockConsole();
+         const errorHandler = new ErrorHandler(false);
+         errorHandler._console = logger as any;
+         bootstrap(NonExistentComp, [
+           {provide: ErrorHandler, useValue: errorHandler}
+         ]).then(null, (reason) => {
+           expect(reason.message)
+               .toContain('The selector "non-existent" did not match any elements');
+           async.done();
+           return null;
+         });
+       }));
+
+    if (getDOM().supportsDOMEvents()) {
+      it('should forward the error to promise when bootstrap fails',
+         inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
+           const logger = new MockConsole();
+           const errorHandler = new ErrorHandler(false);
+           errorHandler._console = logger as any;
+
+           const refPromise =
+               bootstrap(NonExistentComp, [{provide: ErrorHandler, useValue: errorHandler}]);
+           refPromise.then(null, (reason: any) => {
+             expect(reason.message)
+                 .toContain('The selector "non-existent" did not match any elements');
+             async.done();
+           });
+         }));
+
+      it('should invoke the default exception handler when bootstrap fails',
+         inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
+           const logger = new MockConsole();
+           const errorHandler = new ErrorHandler(false);
+           errorHandler._console = logger as any;
+
+           const refPromise =
+               bootstrap(NonExistentComp, [{provide: ErrorHandler, useValue: errorHandler}]);
+           refPromise.then(null, (reason) => {
+             expect(logger.res.join(''))
+                 .toContain('The selector "non-existent" did not match any elements');
+             async.done();
+             return null;
+           });
+         }));
+    }
+
+    it('should create an injector promise', () => {
+      const refPromise = bootstrap(HelloRootCmp, testProviders);
+      expect(refPromise).not.toBe(null);
+    });
+
+    it('should set platform name to browser',
+       inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
+         const refPromise = bootstrap(HelloRootCmp, testProviders);
+         refPromise.then((ref) => {
+           expect(isPlatformBrowser(ref.injector.get(PLATFORM_ID))).toBe(true);
+           async.done();
+         });
+       }));
+
+    it('should display hello world', inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
+         const refPromise = bootstrap(HelloRootCmp, testProviders);
+         refPromise.then((ref) => {
+           expect(el).toHaveText('hello world!');
+           expect(el.getAttribute('ng-version')).toEqual(VERSION.full);
+           async.done();
+         });
+       }));
+
+    it('should throw a descriptive error if BrowserModule is installed again via a lazily loaded module',
+       inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
+         @NgModule({imports: [BrowserModule]})
+         class AsyncModule {
+         }
+         bootstrap(HelloRootCmp, testProviders)
+             .then((ref: ComponentRef<HelloRootCmp>) => {
+               const compiler: Compiler = ref.injector.get(Compiler);
+               return compiler.compileModuleAsync(AsyncModule).then(factory => {
+                 expect(() => factory.create(ref.injector))
+                     .toThrowError(
+                         `BrowserModule has already been loaded. If you need access to common directives such as NgIf and NgFor from a lazy loaded module, import CommonModule instead.`);
+               });
+             })
+             .then(() => async.done(), err => async.fail(err));
+       }));
+
+    it('should support multiple calls to bootstrap',
+       inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
+         const refPromise1 = bootstrap(HelloRootCmp, testProviders);
+         const refPromise2 = bootstrap(HelloRootCmp2, testProviders);
+         Promise.all([refPromise1, refPromise2]).then((refs) => {
+           expect(el).toHaveText('hello world!');
+           expect(el2).toHaveText('hello world, again!');
+           async.done();
+         });
+       }));
+
+    it('should not crash if change detection is invoked when the root component is disposed',
+       inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
+         bootstrap(HelloOnDestroyTickCmp, testProviders).then((ref) => {
+           expect(() => ref.destroy()).not.toThrow();
+           async.done();
+         });
+       }));
+
+    it('should unregister change detectors when components are disposed',
+       inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
+         bootstrap(HelloRootCmp, testProviders).then((ref) => {
+           const appRef = ref.injector.get(ApplicationRef);
+           ref.destroy();
+           expect(() => appRef.tick()).not.toThrow();
+           async.done();
+         });
+       }));
+
+    it('should make the provided bindings available to the application component',
+       inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
+         const refPromise = bootstrap(
+             HelloRootCmp3, [testProviders, {provide: 'appBinding', useValue: 'BoundValue'}]);
+
+         refPromise.then((ref) => {
+           expect(ref.injector.get('appBinding')).toEqual('BoundValue');
+           async.done();
+         });
+       }));
+
+    it('should not override locale provided during bootstrap',
+       inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
+         const refPromise =
+             bootstrap(HelloRootCmp, [testProviders], [{provide: LOCALE_ID, useValue: 'fr-FR'}]);
+
+         refPromise.then(ref => {
+           expect(ref.injector.get(LOCALE_ID)).toEqual('fr-FR');
+           async.done();
+         });
+       }));
+
+    it('should avoid cyclic dependencies when root component requires Lifecycle through DI',
+       inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
+         const refPromise = bootstrap(HelloRootCmp4, testProviders);
+
+         refPromise.then((ref) => {
+           const appRef = ref.injector.get(ApplicationRef);
+           expect(appRef).toBeDefined();
+           async.done();
+         });
+       }));
+
+    it('should run platform initializers',
+       inject([Log, AsyncTestCompleter], (log: Log, async: AsyncTestCompleter) => {
+         const p = createPlatformFactory(platformBrowserDynamic, 'someName', [
+           {provide: PLATFORM_INITIALIZER, useValue: log.fn('platform_init1'), multi: true},
+           {provide: PLATFORM_INITIALIZER, useValue: log.fn('platform_init2'), multi: true}
+         ])();
+
+         @NgModule({
+           imports: [BrowserModule],
+           providers: [
+             {provide: APP_INITIALIZER, useValue: log.fn('app_init1'), multi: true},
+             {provide: APP_INITIALIZER, useValue: log.fn('app_init2'), multi: true}
+           ]
+         })
+         class SomeModule {
+           ngDoBootstrap() {}
+         }
+
+         expect(log.result()).toEqual('platform_init1; platform_init2');
+         log.clear();
+         p.bootstrapModule(SomeModule).then(() => {
+           expect(log.result()).toEqual('app_init1; app_init2');
+           async.done();
+         });
+       }));
+
+    it('should remove styles when transitioning from a server render',
+       inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
+
+         @Component({
+           selector: 'root',
+           template: 'root',
+         })
+         class RootCmp {
+         }
+
+         @NgModule({
+           bootstrap: [RootCmp],
+           declarations: [RootCmp],
+           imports: [BrowserModule.withServerTransition({appId: 'my-app'})],
+         })
+         class TestModule {
+         }
+
+         // First, set up styles to be removed.
+         const dom = getDOM();
+         const platform = platformBrowserDynamic();
+         const document = platform.injector.get(DOCUMENT);
+         const style = dom.createElement('style', document);
+         dom.setAttribute(style, 'ng-transition', 'my-app');
+         dom.appendChild(document.head, style);
+
+         const root = dom.createElement('root', document);
+         dom.appendChild(document.body, root);
+
+         platform.bootstrapModule(TestModule).then(() => {
+           const styles: HTMLElement[] =
+               Array.prototype.slice.apply(dom.getElementsByTagName(document, 'style') || []);
+           styles.forEach(
+               style => { expect(dom.getAttribute(style, 'ng-transition')).not.toBe('my-app'); });
+           async.done();
+         });
+       }));
+
+    it('should register each application with the testability registry',
+       inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
+         const refPromise1: Promise<ComponentRef<any>> = bootstrap(HelloRootCmp, testProviders);
+         const refPromise2: Promise<ComponentRef<any>> = bootstrap(HelloRootCmp2, testProviders);
+
+         Promise.all([refPromise1, refPromise2]).then((refs: ComponentRef<any>[]) => {
+           const registry = refs[0].injector.get(TestabilityRegistry);
+           const testabilities =
+               [refs[0].injector.get(Testability), refs[1].injector.get(Testability)];
+           Promise.all(testabilities).then((testabilities: Testability[]) => {
+             expect(registry.findTestabilityInTree(el)).toEqual(testabilities[0]);
+             expect(registry.findTestabilityInTree(el2)).toEqual(testabilities[1]);
+             async.done();
+           });
+         });
+       }));
+
+    it('should allow to pass schemas', inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
+         bootstrap(HelloCmpUsingCustomElement, testProviders).then((compRef) => {
+           expect(el).toHaveText('hello world!');
+           async.done();
+         });
+       }));
+
+  });
+}

packages/platform-browser/test/browser/browser_adapter_spec.ts

@@ -0,0 +1,34 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {describe, expect, it} from '@angular/core/testing/testing_internal';
+import {getDOM} from '@angular/platform-browser/src/dom/dom_adapter';
+
+import {parseCookieValue} from '../../src/browser/browser_adapter';
+
+export function main() {
+  describe('cookies', () => {
+    it('parses cookies', () => {
+      const cookie = 'other-cookie=false; xsrf-token=token-value; is_awesome=true; ffo=true;';
+      expect(parseCookieValue(cookie, 'xsrf-token')).toBe('token-value');
+    });
+    it('handles encoded keys', () => {
+      expect(parseCookieValue('whitespace%20token=token-value', 'whitespace token'))
+          .toBe('token-value');
+    });
+    it('handles encoded values', () => {
+      expect(parseCookieValue('token=whitespace%20', 'token')).toBe('whitespace ');
+      expect(parseCookieValue('token=whitespace%0A', 'token')).toBe('whitespace\n');
+    });
+    it('sets cookie values', () => {
+      getDOM().setCookie('my test cookie', 'my test value');
+      getDOM().setCookie('my other cookie', 'my test value 2');
+      expect(getDOM().getCookie('my test cookie')).toBe('my test value');
+    });
+  });
+}

packages/platform-browser/test/browser/meta_spec.ts

@@ -0,0 +1,200 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {Injectable} from '@angular/core';
+import {TestBed} from '@angular/core/testing';
+import {BrowserModule, Meta} from '@angular/platform-browser';
+import {getDOM} from '@angular/platform-browser/src/dom/dom_adapter';
+import {expect} from '@angular/platform-browser/testing/matchers';
+
+export function main() {
+  describe('Meta service', () => {
+    const doc = getDOM().createHtmlDocument();
+    const metaService = new Meta(doc);
+    let defaultMeta: HTMLMetaElement;
+
+    beforeEach(() => {
+      defaultMeta = getDOM().createElement('meta', doc) as HTMLMetaElement;
+      getDOM().setAttribute(defaultMeta, 'property', 'fb:app_id');
+      getDOM().setAttribute(defaultMeta, 'content', '123456789');
+      getDOM().appendChild(getDOM().getElementsByTagName(doc, 'head')[0], defaultMeta);
+    });
+
+    afterEach(() => getDOM().remove(defaultMeta));
+
+    it('should return meta tag matching selector', () => {
+      const actual: HTMLMetaElement = metaService.getTag('property="fb:app_id"');
+      expect(actual).not.toBeNull();
+      expect(getDOM().getAttribute(actual, 'content')).toEqual('123456789');
+    });
+
+    it('should return all meta tags matching selector', () => {
+      const tag1 = metaService.addTag({name: 'author', content: 'page author'});
+      const tag2 = metaService.addTag({name: 'author', content: 'another page author'});
+
+      const actual: HTMLMetaElement[] = metaService.getTags('name=author');
+      expect(actual.length).toEqual(2);
+      expect(getDOM().getAttribute(actual[0], 'content')).toEqual('page author');
+      expect(getDOM().getAttribute(actual[1], 'content')).toEqual('another page author');
+
+      // clean up
+      metaService.removeTagElement(tag1);
+      metaService.removeTagElement(tag2);
+    });
+
+    it('should return null if meta tag does not exist', () => {
+      const actual: HTMLMetaElement = metaService.getTag('fake=fake');
+      expect(actual).toBeNull();
+    });
+
+    it('should remove meta tag by the given selector', () => {
+      const selector = 'name=author';
+      expect(metaService.getTag(selector)).toBeNull();
+
+      metaService.addTag({name: 'author', content: 'page author'});
+
+      expect(metaService.getTag(selector)).not.toBeNull();
+
+      metaService.removeTag(selector);
+
+      expect(metaService.getTag(selector)).toBeNull();
+    });
+
+    it('should remove meta tag by the given element', () => {
+      const selector = 'name=keywords';
+      expect(metaService.getTag(selector)).toBeNull();
+
+      metaService.addTags([{name: 'keywords', content: 'meta test'}]);
+
+      const meta = metaService.getTag(selector);
+      expect(meta).not.toBeNull();
+
+      metaService.removeTagElement(meta);
+
+      expect(metaService.getTag(selector)).toBeNull();
+    });
+
+    it('should update meta tag matching the given selector', () => {
+      const selector = 'property="fb:app_id"';
+      metaService.updateTag({content: '4321'}, selector);
+
+      const actual = metaService.getTag(selector);
+      expect(actual).not.toBeNull();
+      expect(getDOM().getAttribute(actual, 'content')).toEqual('4321');
+    });
+
+    it('should extract selector from the tag definition', () => {
+      const selector = 'property="fb:app_id"';
+      metaService.updateTag({property: 'fb:app_id', content: '666'});
+
+      const actual = metaService.getTag(selector);
+      expect(actual).not.toBeNull();
+      expect(getDOM().getAttribute(actual, 'content')).toEqual('666');
+    });
+
+    it('should create meta tag if it does not exist', () => {
+      const selector = 'name="twitter:title"';
+
+      metaService.updateTag({name: 'twitter:title', content: 'Content Title'}, selector);
+
+      const actual = metaService.getTag(selector);
+      expect(actual).not.toBeNull();
+      expect(getDOM().getAttribute(actual, 'content')).toEqual('Content Title');
+
+      // clean up
+      metaService.removeTagElement(actual);
+    });
+
+    it('should add new meta tag', () => {
+      const selector = 'name="og:title"';
+      expect(metaService.getTag(selector)).toBeNull();
+
+      metaService.addTag({name: 'og:title', content: 'Content Title'});
+
+      const actual = metaService.getTag(selector);
+      expect(actual).not.toBeNull();
+      expect(getDOM().getAttribute(actual, 'content')).toEqual('Content Title');
+
+      // clean up
+      metaService.removeTagElement(actual);
+    });
+
+    it('should add multiple new meta tags', () => {
+      const nameSelector = 'name="twitter:title"';
+      const propertySelector = 'property="og:title"';
+      expect(metaService.getTag(nameSelector)).toBeNull();
+      expect(metaService.getTag(propertySelector)).toBeNull();
+
+      metaService.addTags([
+        {name: 'twitter:title', content: 'Content Title'},
+        {property: 'og:title', content: 'Content Title'}
+      ]);
+      const twitterMeta = metaService.getTag(nameSelector);
+      const fbMeta = metaService.getTag(propertySelector);
+      expect(twitterMeta).not.toBeNull();
+      expect(fbMeta).not.toBeNull();
+
+      // clean up
+      metaService.removeTagElement(twitterMeta);
+      metaService.removeTagElement(fbMeta);
+    });
+
+    it('should not add meta tag if it is already present on the page and has the same attr', () => {
+      const selector = 'property="fb:app_id"';
+      expect(metaService.getTags(selector).length).toEqual(1);
+
+      metaService.addTag({property: 'fb:app_id', content: '123456789'});
+
+      expect(metaService.getTags(selector).length).toEqual(1);
+    });
+
+    it('should add meta tag if it is already present on the page and but has different attr',
+       () => {
+         const selector = 'property="fb:app_id"';
+         expect(metaService.getTags(selector).length).toEqual(1);
+
+         const meta = metaService.addTag({property: 'fb:app_id', content: '666'});
+
+         expect(metaService.getTags(selector).length).toEqual(2);
+
+         // clean up
+         metaService.removeTagElement(meta);
+       });
+
+    it('should add meta tag if it is already present on the page and force true', () => {
+      const selector = 'property="fb:app_id"';
+      expect(metaService.getTags(selector).length).toEqual(1);
+
+      const meta = metaService.addTag({property: 'fb:app_id', content: '123456789'}, true);
+
+      expect(metaService.getTags(selector).length).toEqual(2);
+
+      // clean up
+      metaService.removeTagElement(meta);
+    });
+
+  });
+
+  describe('integration test', () => {
+
+    @Injectable()
+    class DependsOnMeta {
+      constructor(public meta: Meta) {}
+    }
+
+    beforeEach(() => {
+      TestBed.configureTestingModule({
+        imports: [BrowserModule],
+        providers: [DependsOnMeta],
+      });
+    });
+
+    it('should inject Meta service when using BrowserModule',
+       () => expect(TestBed.get(DependsOnMeta).meta).toBeAnInstanceOf(Meta));
+  });
+}

packages/platform-browser/test/browser/rectangle_mock.ts

@@ -0,0 +1,13 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+export function createRectangle(
+    left: any /** TODO #9100 */, top: any /** TODO #9100 */, width: any /** TODO #9100 */,
+    height: any /** TODO #9100 */) {
+  return {left, top, width, height};
+}

packages/platform-browser/test/browser/static_assets/200.html

@@ -0,0 +1 @@
+<p>hey</p>

packages/platform-browser/test/browser/title_spec.ts

@@ -0,0 +1,55 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {Injectable} from '@angular/core';
+import {TestBed} from '@angular/core/testing';
+import {BrowserModule, Title} from '@angular/platform-browser';
+import {getDOM} from '@angular/platform-browser/src/dom/dom_adapter';
+import {expect} from '@angular/platform-browser/testing/matchers';
+
+export function main() {
+  describe('title service', () => {
+    const doc = getDOM().createHtmlDocument();
+    const initialTitle = getDOM().getTitle(doc);
+    const titleService = new Title(doc);
+
+    afterEach(() => { getDOM().setTitle(doc, initialTitle); });
+
+    it('should allow reading initial title',
+       () => { expect(titleService.getTitle()).toEqual(initialTitle); });
+
+    it('should set a title on the injected document', () => {
+      titleService.setTitle('test title');
+      expect(getDOM().getTitle(doc)).toEqual('test title');
+      expect(titleService.getTitle()).toEqual('test title');
+    });
+
+    it('should reset title to empty string if title not provided', () => {
+      titleService.setTitle(null);
+      expect(getDOM().getTitle(doc)).toEqual('');
+    });
+  });
+
+  describe('integration test', () => {
+
+    @Injectable()
+    class DependsOnTitle {
+      constructor(public title: Title) {}
+    }
+
+    beforeEach(() => {
+      TestBed.configureTestingModule({
+        imports: [BrowserModule],
+        providers: [DependsOnTitle],
+      });
+    });
+
+    it('should inject Title service when using BrowserModule',
+       () => { expect(TestBed.get(DependsOnTitle).title).toBeAnInstanceOf(Title); });
+  });
+}

packages/platform-browser/test/browser/tools/spies.ts

@@ -0,0 +1,28 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {ReflectiveInjector, ɵglobal as global} from '@angular/core';
+import {ApplicationRef, ApplicationRef_} from '@angular/core/src/application_ref';
+import {SpyObject} from '@angular/core/testing/testing_internal';
+
+export class SpyApplicationRef extends SpyObject {
+  constructor() { super(ApplicationRef_); }
+}
+
+export class SpyComponentRef extends SpyObject {
+  injector: any /** TODO #9100 */;
+  constructor() {
+    super();
+    this.injector = ReflectiveInjector.resolveAndCreate(
+        [{provide: ApplicationRef, useClass: SpyApplicationRef}]);
+  }
+}
+
+export function callNgProfilerTimeChangeDetection(config?: any /** TODO #9100 */): void {
+  (<any>global).ng.profiler.timeChangeDetection(config);
+}

packages/platform-browser/test/browser/tools/tools_spec.ts

@@ -0,0 +1,24 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {disableDebugTools, enableDebugTools} from '@angular/platform-browser';
+
+import {SpyComponentRef, callNgProfilerTimeChangeDetection} from './spies';
+
+export function main() {
+  describe('profiler', () => {
+    beforeEach(() => { enableDebugTools((<any>new SpyComponentRef())); });
+
+    afterEach(() => { disableDebugTools(); });
+
+    it('should time change detection', () => { callNgProfilerTimeChangeDetection(); });
+
+    it('should time change detection with recording',
+       () => { callNgProfilerTimeChangeDetection({'record': true}); });
+  });
+}