@angular/core
Version:
Angular - the core framework
533 lines • 51.3 kB
JavaScript
/**
* @fileoverview added by tsickle
* Generated from: packages/core/testing/src/r3_test_bed.ts
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* @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
*/
// The formatter and CI disagree on how this import statement should be formatted. Both try to keep
// it on one line, too, which has gotten very hard to read & manage. So disable the formatter for
// this statement only.
/* clang-format off */
import { InjectFlags, Injector, NgZone, ɵflushModuleScopingQueueAsMuchAsPossible as flushModuleScopingQueueAsMuchAsPossible, ɵRender3ComponentFactory as ComponentFactory, ɵresetCompiledComponents as resetCompiledComponents, ɵstringify as stringify, } from '@angular/core';
/* clang-format on */
import { ComponentFixture } from './component_fixture';
import { R3TestBedCompiler } from './r3_test_bed_compiler';
import { ComponentFixtureAutoDetect, ComponentFixtureNoNgZone, TestComponentRenderer } from './test_bed_common';
/** @type {?} */
let _nextRootElementId = 0;
/**
* \@description
* Configures and initializes environment for unit testing and provides methods for
* creating components and services in unit tests.
*
* TestBed is the primary api for writing unit tests for Angular applications and libraries.
*
* Note: Use `TestBed` in tests. It will be set to either `TestBedViewEngine` or `TestBedRender3`
* according to the compiler used.
*/
export class TestBedRender3 {
constructor() {
// Properties
this.platform = (/** @type {?} */ (null));
this.ngModule = (/** @type {?} */ (null));
this._compiler = null;
this._testModuleRef = null;
this._activeFixtures = [];
this._globalCompilationChecked = false;
}
/**
* Initialize the environment for testing with a compiler factory, a PlatformRef, and an
* angular module. These are common to every test in the suite.
*
* This may only be called once, to set up the common providers for the current test
* suite on the current platform. If you absolutely need to change the providers,
* first use `resetTestEnvironment`.
*
* Test modules and platforms for individual platforms are available from
* '\@angular/<platform_name>/testing'.
*
* \@publicApi
* @param {?} ngModule
* @param {?} platform
* @param {?=} aotSummaries
* @return {?}
*/
static initTestEnvironment(ngModule, platform, aotSummaries) {
/** @type {?} */
const testBed = _getTestBedRender3();
testBed.initTestEnvironment(ngModule, platform, aotSummaries);
return testBed;
}
/**
* Reset the providers for the test injector.
*
* \@publicApi
* @return {?}
*/
static resetTestEnvironment() {
_getTestBedRender3().resetTestEnvironment();
}
/**
* @param {?} config
* @return {?}
*/
static configureCompiler(config) {
_getTestBedRender3().configureCompiler(config);
return (/** @type {?} */ ((/** @type {?} */ (TestBedRender3))));
}
/**
* Allows overriding default providers, directives, pipes, modules of the test injector,
* which are defined in test_injector.js
* @param {?} moduleDef
* @return {?}
*/
static configureTestingModule(moduleDef) {
_getTestBedRender3().configureTestingModule(moduleDef);
return (/** @type {?} */ ((/** @type {?} */ (TestBedRender3))));
}
/**
* Compile components with a `templateUrl` for the test's NgModule.
* It is necessary to call this function
* as fetching urls is asynchronous.
* @return {?}
*/
static compileComponents() {
return _getTestBedRender3().compileComponents();
}
/**
* @param {?} ngModule
* @param {?} override
* @return {?}
*/
static overrideModule(ngModule, override) {
_getTestBedRender3().overrideModule(ngModule, override);
return (/** @type {?} */ ((/** @type {?} */ (TestBedRender3))));
}
/**
* @param {?} component
* @param {?} override
* @return {?}
*/
static overrideComponent(component, override) {
_getTestBedRender3().overrideComponent(component, override);
return (/** @type {?} */ ((/** @type {?} */ (TestBedRender3))));
}
/**
* @param {?} directive
* @param {?} override
* @return {?}
*/
static overrideDirective(directive, override) {
_getTestBedRender3().overrideDirective(directive, override);
return (/** @type {?} */ ((/** @type {?} */ (TestBedRender3))));
}
/**
* @param {?} pipe
* @param {?} override
* @return {?}
*/
static overridePipe(pipe, override) {
_getTestBedRender3().overridePipe(pipe, override);
return (/** @type {?} */ ((/** @type {?} */ (TestBedRender3))));
}
/**
* @param {?} component
* @param {?} template
* @return {?}
*/
static overrideTemplate(component, template) {
_getTestBedRender3().overrideComponent(component, { set: { template, templateUrl: (/** @type {?} */ (null)) } });
return (/** @type {?} */ ((/** @type {?} */ (TestBedRender3))));
}
/**
* Overrides the template of the given component, compiling the template
* in the context of the TestingModule.
*
* Note: This works for JIT and AOTed components as well.
* @param {?} component
* @param {?} template
* @return {?}
*/
static overrideTemplateUsingTestingModule(component, template) {
_getTestBedRender3().overrideTemplateUsingTestingModule(component, template);
return (/** @type {?} */ ((/** @type {?} */ (TestBedRender3))));
}
/**
* @param {?} token
* @param {?} provider
* @return {?}
*/
static overrideProvider(token, provider) {
_getTestBedRender3().overrideProvider(token, provider);
return (/** @type {?} */ ((/** @type {?} */ (TestBedRender3))));
}
/**
* @template T
* @param {?} token
* @param {?=} notFoundValue
* @param {?=} flags
* @return {?}
*/
static inject(token, notFoundValue, flags) {
return _getTestBedRender3().inject(token, notFoundValue, flags);
}
/**
* @deprecated from v9.0.0 use TestBed.inject
* @param {?} token
* @param {?=} notFoundValue
* @param {?=} flags
* @return {?}
*/
static get(token, notFoundValue = Injector.THROW_IF_NOT_FOUND, flags = InjectFlags.Default) {
return _getTestBedRender3().inject(token, notFoundValue, flags);
}
/**
* @template T
* @param {?} component
* @return {?}
*/
static createComponent(component) {
return _getTestBedRender3().createComponent(component);
}
/**
* @return {?}
*/
static resetTestingModule() {
_getTestBedRender3().resetTestingModule();
return (/** @type {?} */ ((/** @type {?} */ (TestBedRender3))));
}
/**
* Initialize the environment for testing with a compiler factory, a PlatformRef, and an
* angular module. These are common to every test in the suite.
*
* This may only be called once, to set up the common providers for the current test
* suite on the current platform. If you absolutely need to change the providers,
* first use `resetTestEnvironment`.
*
* Test modules and platforms for individual platforms are available from
* '\@angular/<platform_name>/testing'.
*
* \@publicApi
* @param {?} ngModule
* @param {?} platform
* @param {?=} aotSummaries
* @return {?}
*/
initTestEnvironment(ngModule, platform, aotSummaries) {
if (this.platform || this.ngModule) {
throw new Error('Cannot set base providers because it has already been called');
}
this.platform = platform;
this.ngModule = ngModule;
this._compiler = new R3TestBedCompiler(this.platform, this.ngModule);
}
/**
* Reset the providers for the test injector.
*
* \@publicApi
* @return {?}
*/
resetTestEnvironment() {
this.resetTestingModule();
this._compiler = null;
this.platform = (/** @type {?} */ (null));
this.ngModule = (/** @type {?} */ (null));
}
/**
* @return {?}
*/
resetTestingModule() {
this.checkGlobalCompilationFinished();
resetCompiledComponents();
if (this._compiler !== null) {
this.compiler.restoreOriginalState();
}
this._compiler = new R3TestBedCompiler(this.platform, this.ngModule);
this._testModuleRef = null;
this.destroyActiveFixtures();
}
/**
* @param {?} config
* @return {?}
*/
configureCompiler(config) {
if (config.useJit != null) {
throw new Error('the Render3 compiler JiT mode is not configurable !');
}
if (config.providers !== undefined) {
this.compiler.setCompilerProviders(config.providers);
}
}
/**
* @param {?} moduleDef
* @return {?}
*/
configureTestingModule(moduleDef) {
this.assertNotInstantiated('R3TestBed.configureTestingModule', 'configure the test module');
this.compiler.configureTestingModule(moduleDef);
}
/**
* @return {?}
*/
compileComponents() {
return this.compiler.compileComponents();
}
/**
* @template T
* @param {?} token
* @param {?=} notFoundValue
* @param {?=} flags
* @return {?}
*/
inject(token, notFoundValue, flags) {
if ((/** @type {?} */ (token)) === TestBedRender3) {
return (/** @type {?} */ (this));
}
/** @type {?} */
const UNDEFINED = {};
/** @type {?} */
const result = this.testModuleRef.injector.get(token, UNDEFINED, flags);
return result === UNDEFINED ? (/** @type {?} */ (this.compiler.injector.get(token, notFoundValue, flags))) :
result;
}
/**
* @deprecated from v9.0.0 use TestBed.inject
* @param {?} token
* @param {?=} notFoundValue
* @param {?=} flags
* @return {?}
*/
get(token, notFoundValue = Injector.THROW_IF_NOT_FOUND, flags = InjectFlags.Default) {
return this.inject(token, notFoundValue, flags);
}
/**
* @param {?} tokens
* @param {?} fn
* @param {?=} context
* @return {?}
*/
execute(tokens, fn, context) {
/** @type {?} */
const params = tokens.map((/**
* @param {?} t
* @return {?}
*/
t => this.inject(t)));
return fn.apply(context, params);
}
/**
* @param {?} ngModule
* @param {?} override
* @return {?}
*/
overrideModule(ngModule, override) {
this.assertNotInstantiated('overrideModule', 'override module metadata');
this.compiler.overrideModule(ngModule, override);
}
/**
* @param {?} component
* @param {?} override
* @return {?}
*/
overrideComponent(component, override) {
this.assertNotInstantiated('overrideComponent', 'override component metadata');
this.compiler.overrideComponent(component, override);
}
/**
* @param {?} component
* @param {?} template
* @return {?}
*/
overrideTemplateUsingTestingModule(component, template) {
this.assertNotInstantiated('R3TestBed.overrideTemplateUsingTestingModule', 'Cannot override template when the test module has already been instantiated');
this.compiler.overrideTemplateUsingTestingModule(component, template);
}
/**
* @param {?} directive
* @param {?} override
* @return {?}
*/
overrideDirective(directive, override) {
this.assertNotInstantiated('overrideDirective', 'override directive metadata');
this.compiler.overrideDirective(directive, override);
}
/**
* @param {?} pipe
* @param {?} override
* @return {?}
*/
overridePipe(pipe, override) {
this.assertNotInstantiated('overridePipe', 'override pipe metadata');
this.compiler.overridePipe(pipe, override);
}
/**
* Overwrites all providers for the given token with the given provider definition.
* @param {?} token
* @param {?} provider
* @return {?}
*/
overrideProvider(token, provider) {
this.compiler.overrideProvider(token, provider);
}
/**
* @template T
* @param {?} type
* @return {?}
*/
createComponent(type) {
/** @type {?} */
const testComponentRenderer = this.inject(TestComponentRenderer);
/** @type {?} */
const rootElId = `root-ng-internal-isolated-${_nextRootElementId++}`;
testComponentRenderer.insertRootElement(rootElId);
/** @type {?} */
const componentDef = ((/** @type {?} */ (type))).ɵcmp;
if (!componentDef) {
throw new Error(`It looks like '${stringify(type)}' has not been IVY compiled - it has no 'ɵcmp' field`);
}
// TODO: Don't cast as `InjectionToken<boolean>`, proper type is boolean[]
/** @type {?} */
const noNgZone = this.inject((/** @type {?} */ (ComponentFixtureNoNgZone)), false);
// TODO: Don't cast as `InjectionToken<boolean>`, proper type is boolean[]
/** @type {?} */
const autoDetect = this.inject((/** @type {?} */ (ComponentFixtureAutoDetect)), false);
/** @type {?} */
const ngZone = noNgZone ? null : this.inject(NgZone, null);
/** @type {?} */
const componentFactory = new ComponentFactory(componentDef);
/** @type {?} */
const initComponent = (/**
* @return {?}
*/
() => {
/** @type {?} */
const componentRef = componentFactory.create(Injector.NULL, [], `#${rootElId}`, this.testModuleRef);
return new ComponentFixture(componentRef, ngZone, autoDetect);
});
/** @type {?} */
const fixture = ngZone ? ngZone.run(initComponent) : initComponent();
this._activeFixtures.push(fixture);
return fixture;
}
/**
* \@internal strip this from published d.ts files due to
* https://github.com/microsoft/TypeScript/issues/36216
* @private
* @return {?}
*/
get compiler() {
if (this._compiler === null) {
throw new Error(`Need to call TestBed.initTestEnvironment() first`);
}
return this._compiler;
}
/**
* \@internal strip this from published d.ts files due to
* https://github.com/microsoft/TypeScript/issues/36216
* @private
* @return {?}
*/
get testModuleRef() {
if (this._testModuleRef === null) {
this._testModuleRef = this.compiler.finalize();
}
return this._testModuleRef;
}
/**
* @private
* @param {?} methodName
* @param {?} methodDescription
* @return {?}
*/
assertNotInstantiated(methodName, methodDescription) {
if (this._testModuleRef !== null) {
throw new Error(`Cannot ${methodDescription} when the test module has already been instantiated. ` +
`Make sure you are not using \`inject\` before \`${methodName}\`.`);
}
}
/**
* Check whether the module scoping queue should be flushed, and flush it if needed.
*
* When the TestBed is reset, it clears the JIT module compilation queue, cancelling any
* in-progress module compilation. This creates a potential hazard - the very first time the
* TestBed is initialized (or if it's reset without being initialized), there may be pending
* compilations of modules declared in global scope. These compilations should be finished.
*
* To ensure that globally declared modules have their components scoped properly, this function
* is called whenever TestBed is initialized or reset. The _first_ time that this happens, prior
* to any other operations, the scoping queue is flushed.
* @private
* @return {?}
*/
checkGlobalCompilationFinished() {
// Checking _testNgModuleRef is null should not be necessary, but is left in as an additional
// guard that compilations queued in tests (after instantiation) are never flushed accidentally.
if (!this._globalCompilationChecked && this._testModuleRef === null) {
flushModuleScopingQueueAsMuchAsPossible();
}
this._globalCompilationChecked = true;
}
/**
* @private
* @return {?}
*/
destroyActiveFixtures() {
this._activeFixtures.forEach((/**
* @param {?} fixture
* @return {?}
*/
(fixture) => {
try {
fixture.destroy();
}
catch (e) {
console.error('Error during cleanup of component', {
component: fixture.componentInstance,
stacktrace: e,
});
}
}));
this._activeFixtures = [];
}
}
if (false) {
/** @type {?} */
TestBedRender3.prototype.platform;
/** @type {?} */
TestBedRender3.prototype.ngModule;
/**
* @type {?}
* @private
*/
TestBedRender3.prototype._compiler;
/**
* @type {?}
* @private
*/
TestBedRender3.prototype._testModuleRef;
/**
* @type {?}
* @private
*/
TestBedRender3.prototype._activeFixtures;
/**
* @type {?}
* @private
*/
TestBedRender3.prototype._globalCompilationChecked;
}
/** @type {?} */
let testBed;
/**
* @return {?}
*/
export function _getTestBedRender3() {
return testBed = testBed || new TestBedRender3();
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"r3_test_bed.js","sourceRoot":"","sources":["../../../../../../../packages/core/testing/src/r3_test_bed.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\n// The formatter and CI disagree on how this import statement should be formatted. Both try to keep\n// it on one line, too, which has gotten very hard to read & manage. So disable the formatter for\n// this statement only.\n\n/* clang-format off */\nimport {\n  AbstractType,\n  Component,\n  Directive,\n  InjectFlags,\n  InjectionToken,\n  Injector,\n  NgModule,\n  NgZone,\n  Pipe,\n  PlatformRef,\n  Type,\n  ɵflushModuleScopingQueueAsMuchAsPossible as flushModuleScopingQueueAsMuchAsPossible,\n  ɵRender3ComponentFactory as ComponentFactory,\n  ɵRender3NgModuleRef as NgModuleRef,\n  ɵresetCompiledComponents as resetCompiledComponents,\n  ɵstringify as stringify,\n} from '@angular/core';\n\n/* clang-format on */\n\nimport {ComponentFixture} from './component_fixture';\nimport {MetadataOverride} from './metadata_override';\nimport {R3TestBedCompiler} from './r3_test_bed_compiler';\nimport {TestBed} from './test_bed';\nimport {ComponentFixtureAutoDetect, ComponentFixtureNoNgZone, TestBedStatic, TestComponentRenderer, TestModuleMetadata} from './test_bed_common';\n\nlet _nextRootElementId = 0;\n\n\n\n/**\n * @description\n * Configures and initializes environment for unit testing and provides methods for\n * creating components and services in unit tests.\n *\n * TestBed is the primary api for writing unit tests for Angular applications and libraries.\n *\n * Note: Use `TestBed` in tests. It will be set to either `TestBedViewEngine` or `TestBedRender3`\n * according to the compiler used.\n */\nexport class TestBedRender3 implements TestBed {\n  /**\n   * Initialize the environment for testing with a compiler factory, a PlatformRef, and an\n   * angular module. These are common to every test in the suite.\n   *\n   * This may only be called once, to set up the common providers for the current test\n   * suite on the current platform. If you absolutely need to change the providers,\n   * first use `resetTestEnvironment`.\n   *\n   * Test modules and platforms for individual platforms are available from\n   * '@angular/<platform_name>/testing'.\n   *\n   * @publicApi\n   */\n  static initTestEnvironment(\n      ngModule: Type<any>|Type<any>[], platform: PlatformRef, aotSummaries?: () => any[]): TestBed {\n    const testBed = _getTestBedRender3();\n    testBed.initTestEnvironment(ngModule, platform, aotSummaries);\n    return testBed;\n  }\n\n  /**\n   * Reset the providers for the test injector.\n   *\n   * @publicApi\n   */\n  static resetTestEnvironment(): void {\n    _getTestBedRender3().resetTestEnvironment();\n  }\n\n  static configureCompiler(config: {providers?: any[]; useJit?: boolean;}): TestBedStatic {\n    _getTestBedRender3().configureCompiler(config);\n    return TestBedRender3 as any as TestBedStatic;\n  }\n\n  /**\n   * Allows overriding default providers, directives, pipes, modules of the test injector,\n   * which are defined in test_injector.js\n   */\n  static configureTestingModule(moduleDef: TestModuleMetadata): TestBedStatic {\n    _getTestBedRender3().configureTestingModule(moduleDef);\n    return TestBedRender3 as any as TestBedStatic;\n  }\n\n  /**\n   * Compile components with a `templateUrl` for the test's NgModule.\n   * It is necessary to call this function\n   * as fetching urls is asynchronous.\n   */\n  static compileComponents(): Promise<any> {\n    return _getTestBedRender3().compileComponents();\n  }\n\n  static overrideModule(ngModule: Type<any>, override: MetadataOverride<NgModule>): TestBedStatic {\n    _getTestBedRender3().overrideModule(ngModule, override);\n    return TestBedRender3 as any as TestBedStatic;\n  }\n\n  static overrideComponent(component: Type<any>, override: MetadataOverride<Component>):\n      TestBedStatic {\n    _getTestBedRender3().overrideComponent(component, override);\n    return TestBedRender3 as any as TestBedStatic;\n  }\n\n  static overrideDirective(directive: Type<any>, override: MetadataOverride<Directive>):\n      TestBedStatic {\n    _getTestBedRender3().overrideDirective(directive, override);\n    return TestBedRender3 as any as TestBedStatic;\n  }\n\n  static overridePipe(pipe: Type<any>, override: MetadataOverride<Pipe>): TestBedStatic {\n    _getTestBedRender3().overridePipe(pipe, override);\n    return TestBedRender3 as any as TestBedStatic;\n  }\n\n  static overrideTemplate(component: Type<any>, template: string): TestBedStatic {\n    _getTestBedRender3().overrideComponent(component, {set: {template, templateUrl: null!}});\n    return TestBedRender3 as any as TestBedStatic;\n  }\n\n  /**\n   * Overrides the template of the given component, compiling the template\n   * in the context of the TestingModule.\n   *\n   * Note: This works for JIT and AOTed components as well.\n   */\n  static overrideTemplateUsingTestingModule(component: Type<any>, template: string): TestBedStatic {\n    _getTestBedRender3().overrideTemplateUsingTestingModule(component, template);\n    return TestBedRender3 as any as TestBedStatic;\n  }\n\n  static overrideProvider(token: any, provider: {\n    useFactory: Function,\n    deps: any[],\n  }): TestBedStatic;\n  static overrideProvider(token: any, provider: {useValue: any;}): TestBedStatic;\n  static overrideProvider(token: any, provider: {\n    useFactory?: Function,\n    useValue?: any,\n    deps?: any[],\n  }): TestBedStatic {\n    _getTestBedRender3().overrideProvider(token, provider);\n    return TestBedRender3 as any as TestBedStatic;\n  }\n\n  static inject<T>(\n      token: Type<T>|InjectionToken<T>|AbstractType<T>, notFoundValue?: T, flags?: InjectFlags): T;\n  static inject<T>(\n      token: Type<T>|InjectionToken<T>|AbstractType<T>, notFoundValue: null, flags?: InjectFlags): T\n      |null;\n  static inject<T>(\n      token: Type<T>|InjectionToken<T>|AbstractType<T>, notFoundValue?: T|null,\n      flags?: InjectFlags): T|null {\n    return _getTestBedRender3().inject(token, notFoundValue, flags);\n  }\n\n  /** @deprecated from v9.0.0 use TestBed.inject */\n  static get<T>(token: Type<T>|InjectionToken<T>, notFoundValue?: T, flags?: InjectFlags): any;\n  /** @deprecated from v9.0.0 use TestBed.inject */\n  static get(token: any, notFoundValue?: any): any;\n  /** @deprecated from v9.0.0 use TestBed.inject */\n  static get(\n      token: any, notFoundValue: any = Injector.THROW_IF_NOT_FOUND,\n      flags: InjectFlags = InjectFlags.Default): any {\n    return _getTestBedRender3().inject(token, notFoundValue, flags);\n  }\n\n  static createComponent<T>(component: Type<T>): ComponentFixture<T> {\n    return _getTestBedRender3().createComponent(component);\n  }\n\n  static resetTestingModule(): TestBedStatic {\n    _getTestBedRender3().resetTestingModule();\n    return TestBedRender3 as any as TestBedStatic;\n  }\n\n  // Properties\n\n  platform: PlatformRef = null!;\n  ngModule: Type<any>|Type<any>[] = null!;\n\n  private _compiler: R3TestBedCompiler|null = null;\n  private _testModuleRef: NgModuleRef<any>|null = null;\n\n  private _activeFixtures: ComponentFixture<any>[] = [];\n  private _globalCompilationChecked = false;\n\n  /**\n   * Initialize the environment for testing with a compiler factory, a PlatformRef, and an\n   * angular module. These are common to every test in the suite.\n   *\n   * This may only be called once, to set up the common providers for the current test\n   * suite on the current platform. If you absolutely need to change the providers,\n   * first use `resetTestEnvironment`.\n   *\n   * Test modules and platforms for individual platforms are available from\n   * '@angular/<platform_name>/testing'.\n   *\n   * @publicApi\n   */\n  initTestEnvironment(\n      ngModule: Type<any>|Type<any>[], platform: PlatformRef, aotSummaries?: () => any[]): void {\n    if (this.platform || this.ngModule) {\n      throw new Error('Cannot set base providers because it has already been called');\n    }\n    this.platform = platform;\n    this.ngModule = ngModule;\n    this._compiler = new R3TestBedCompiler(this.platform, this.ngModule);\n  }\n\n  /**\n   * Reset the providers for the test injector.\n   *\n   * @publicApi\n   */\n  resetTestEnvironment(): void {\n    this.resetTestingModule();\n    this._compiler = null;\n    this.platform = null!;\n    this.ngModule = null!;\n  }\n\n  resetTestingModule(): void {\n    this.checkGlobalCompilationFinished();\n    resetCompiledComponents();\n    if (this._compiler !== null) {\n      this.compiler.restoreOriginalState();\n    }\n    this._compiler = new R3TestBedCompiler(this.platform, this.ngModule);\n    this._testModuleRef = null;\n    this.destroyActiveFixtures();\n  }\n\n  configureCompiler(config: {providers?: any[]; useJit?: boolean;}): void {\n    if (config.useJit != null) {\n      throw new Error('the Render3 compiler JiT mode is not configurable !');\n    }\n\n    if (config.providers !== undefined) {\n      this.compiler.setCompilerProviders(config.providers);\n    }\n  }\n\n  configureTestingModule(moduleDef: TestModuleMetadata): void {\n    this.assertNotInstantiated('R3TestBed.configureTestingModule', 'configure the test module');\n    this.compiler.configureTestingModule(moduleDef);\n  }\n\n  compileComponents(): Promise<any> {\n    return this.compiler.compileComponents();\n  }\n\n  inject<T>(\n      token: Type<T>|InjectionToken<T>|AbstractType<T>, notFoundValue?: T, flags?: InjectFlags): T;\n  inject<T>(\n      token: Type<T>|InjectionToken<T>|AbstractType<T>, notFoundValue: null, flags?: InjectFlags): T\n      |null;\n  inject<T>(\n      token: Type<T>|InjectionToken<T>|AbstractType<T>, notFoundValue?: T|null,\n      flags?: InjectFlags): T|null {\n    if (token as unknown === TestBedRender3) {\n      return this as any;\n    }\n    const UNDEFINED = {};\n    const result = this.testModuleRef.injector.get(token, UNDEFINED, flags);\n    return result === UNDEFINED ? this.compiler.injector.get(token, notFoundValue, flags) as any :\n                                  result;\n  }\n\n  /** @deprecated from v9.0.0 use TestBed.inject */\n  get<T>(token: Type<T>|InjectionToken<T>, notFoundValue?: T, flags?: InjectFlags): any;\n  /** @deprecated from v9.0.0 use TestBed.inject */\n  get(token: any, notFoundValue?: any): any;\n  /** @deprecated from v9.0.0 use TestBed.inject */\n  get(token: any, notFoundValue: any = Injector.THROW_IF_NOT_FOUND,\n      flags: InjectFlags = InjectFlags.Default): any {\n    return this.inject(token, notFoundValue, flags);\n  }\n\n  execute(tokens: any[], fn: Function, context?: any): any {\n    const params = tokens.map(t => this.inject(t));\n    return fn.apply(context, params);\n  }\n\n  overrideModule(ngModule: Type<any>, override: MetadataOverride<NgModule>): void {\n    this.assertNotInstantiated('overrideModule', 'override module metadata');\n    this.compiler.overrideModule(ngModule, override);\n  }\n\n  overrideComponent(component: Type<any>, override: MetadataOverride<Component>): void {\n    this.assertNotInstantiated('overrideComponent', 'override component metadata');\n    this.compiler.overrideComponent(component, override);\n  }\n\n  overrideTemplateUsingTestingModule(component: Type<any>, template: string): void {\n    this.assertNotInstantiated(\n        'R3TestBed.overrideTemplateUsingTestingModule',\n        'Cannot override template when the test module has already been instantiated');\n    this.compiler.overrideTemplateUsingTestingModule(component, template);\n  }\n\n  overrideDirective(directive: Type<any>, override: MetadataOverride<Directive>): void {\n    this.assertNotInstantiated('overrideDirective', 'override directive metadata');\n    this.compiler.overrideDirective(directive, override);\n  }\n\n  overridePipe(pipe: Type<any>, override: MetadataOverride<Pipe>): void {\n    this.assertNotInstantiated('overridePipe', 'override pipe metadata');\n    this.compiler.overridePipe(pipe, override);\n  }\n\n  /**\n   * Overwrites all providers for the given token with the given provider definition.\n   */\n  overrideProvider(token: any, provider: {useFactory?: Function, useValue?: any, deps?: any[]}):\n      void {\n    this.compiler.overrideProvider(token, provider);\n  }\n\n  createComponent<T>(type: Type<T>): ComponentFixture<T> {\n    const testComponentRenderer = this.inject(TestComponentRenderer);\n    const rootElId = `root-ng-internal-isolated-${_nextRootElementId++}`;\n    testComponentRenderer.insertRootElement(rootElId);\n\n    const componentDef = (type as any).ɵcmp;\n\n    if (!componentDef) {\n      throw new Error(\n          `It looks like '${stringify(type)}' has not been IVY compiled - it has no 'ɵcmp' field`);\n    }\n\n    // TODO: Don't cast as `InjectionToken<boolean>`, proper type is boolean[]\n    const noNgZone = this.inject(ComponentFixtureNoNgZone as InjectionToken<boolean>, false);\n    // TODO: Don't cast as `InjectionToken<boolean>`, proper type is boolean[]\n    const autoDetect: boolean =\n        this.inject(ComponentFixtureAutoDetect as InjectionToken<boolean>, false);\n    const ngZone: NgZone|null = noNgZone ? null : this.inject(NgZone, null);\n    const componentFactory = new ComponentFactory(componentDef);\n    const initComponent = () => {\n      const componentRef =\n          componentFactory.create(Injector.NULL, [], `#${rootElId}`, this.testModuleRef);\n      return new ComponentFixture<any>(componentRef, ngZone, autoDetect);\n    };\n    const fixture = ngZone ? ngZone.run(initComponent) : initComponent();\n    this._activeFixtures.push(fixture);\n    return fixture;\n  }\n\n  /**\n   * @internal strip this from published d.ts files due to\n   * https://github.com/microsoft/TypeScript/issues/36216\n   */\n  private get compiler(): R3TestBedCompiler {\n    if (this._compiler === null) {\n      throw new Error(`Need to call TestBed.initTestEnvironment() first`);\n    }\n    return this._compiler;\n  }\n\n  /**\n   * @internal strip this from published d.ts files due to\n   * https://github.com/microsoft/TypeScript/issues/36216\n   */\n  private get testModuleRef(): NgModuleRef<any> {\n    if (this._testModuleRef === null) {\n      this._testModuleRef = this.compiler.finalize();\n    }\n    return this._testModuleRef;\n  }\n\n  private assertNotInstantiated(methodName: string, methodDescription: string) {\n    if (this._testModuleRef !== null) {\n      throw new Error(\n          `Cannot ${methodDescription} when the test module has already been instantiated. ` +\n          `Make sure you are not using \\`inject\\` before \\`${methodName}\\`.`);\n    }\n  }\n\n  /**\n   * Check whether the module scoping queue should be flushed, and flush it if needed.\n   *\n   * When the TestBed is reset, it clears the JIT module compilation queue, cancelling any\n   * in-progress module compilation. This creates a potential hazard - the very first time the\n   * TestBed is initialized (or if it's reset without being initialized), there may be pending\n   * compilations of modules declared in global scope. These compilations should be finished.\n   *\n   * To ensure that globally declared modules have their components scoped properly, this function\n   * is called whenever TestBed is initialized or reset. The _first_ time that this happens, prior\n   * to any other operations, the scoping queue is flushed.\n   */\n  private c