/** * @license * Copyright Google LLC 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, ɵgetUnknownElementStrictMode as getUnknownElementStrictMode, ɵgetUnknownPropertyStrictMode as getUnknownPropertyStrictMode, ɵRender3ComponentFactory as ComponentFactory, ɵresetCompiledComponents as resetCompiledComponents, ɵsetAllowDuplicateNgModuleIdsForTest as setAllowDuplicateNgModuleIdsForTest, ɵsetUnknownElementStrictMode as setUnknownElementStrictMode, ɵsetUnknownPropertyStrictMode as setUnknownPropertyStrictMode, ɵstringify as stringify } from '@angular/core'; /* clang-format on */ import { ComponentFixture } from './component_fixture'; import { ComponentFixtureAutoDetect, ComponentFixtureNoNgZone, TEARDOWN_TESTING_MODULE_ON_DESTROY_DEFAULT, TestComponentRenderer, THROW_ON_UNKNOWN_ELEMENTS_DEFAULT, THROW_ON_UNKNOWN_PROPERTIES_DEFAULT } from './test_bed_common'; import { TestBedCompiler } from './test_bed_compiler'; let _nextRootElementId = 0; /** * Returns a singleton of the `TestBed` class. * * @publicApi */ export function getTestBed() { return TestBedImpl.INSTANCE; } /** * @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. */ export class TestBedImpl { constructor() { // Properties this.platform = null; this.ngModule = null; this._compiler = null; this._testModuleRef = null; this._activeFixtures = []; /** * Internal-only flag to indicate whether a module * scoping queue has been checked and flushed already. * @nodoc */ this.globalCompilationChecked = false; } static get INSTANCE() { return TestBedImpl._INSTANCE = TestBedImpl._INSTANCE || new TestBedImpl(); } /** * 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//testing'. * * @publicApi */ static initTestEnvironment(ngModule, platform, options) { const testBed = TestBedImpl.INSTANCE; testBed.initTestEnvironment(ngModule, platform, options); return testBed; } /** * Reset the providers for the test injector. * * @publicApi */ static resetTestEnvironment() { TestBedImpl.INSTANCE.resetTestEnvironment(); } static configureCompiler(config) { return TestBedImpl.INSTANCE.configureCompiler(config); } /** * Allows overriding default providers, directives, pipes, modules of the test injector, * which are defined in test_injector.js */ static configureTestingModule(moduleDef) { return TestBedImpl.INSTANCE.configureTestingModule(moduleDef); } /** * Compile components with a `templateUrl` for the test's NgModule. * It is necessary to call this function * as fetching urls is asynchronous. */ static compileComponents() { return TestBedImpl.INSTANCE.compileComponents(); } static overrideModule(ngModule, override) { return TestBedImpl.INSTANCE.overrideModule(ngModule, override); } static overrideComponent(component, override) { return TestBedImpl.INSTANCE.overrideComponent(component, override); } static overrideDirective(directive, override) { return TestBedImpl.INSTANCE.overrideDirective(directive, override); } static overridePipe(pipe, override) { return TestBedImpl.INSTANCE.overridePipe(pipe, override); } static overrideTemplate(component, template) { return TestBedImpl.INSTANCE.overrideTemplate(component, template); } /** * 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. */ static overrideTemplateUsingTestingModule(component, template) { return TestBedImpl.INSTANCE.overrideTemplateUsingTestingModule(component, template); } static overrideProvider(token, provider) { return TestBedImpl.INSTANCE.overrideProvider(token, provider); } static inject(token, notFoundValue, flags) { return TestBedImpl.INSTANCE.inject(token, notFoundValue, flags); } /** @deprecated from v9.0.0 use TestBed.inject */ static get(token, notFoundValue = Injector.THROW_IF_NOT_FOUND, flags = InjectFlags.Default) { return TestBedImpl.INSTANCE.inject(token, notFoundValue, flags); } static createComponent(component) { return TestBedImpl.INSTANCE.createComponent(component); } static resetTestingModule() { return TestBedImpl.INSTANCE.resetTestingModule(); } static execute(tokens, fn, context) { return TestBedImpl.INSTANCE.execute(tokens, fn, context); } static get platform() { return TestBedImpl.INSTANCE.platform; } static get ngModule() { return TestBedImpl.INSTANCE.ngModule; } /** * 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//testing'. * * @publicApi */ initTestEnvironment(ngModule, platform, options) { if (this.platform || this.ngModule) { throw new Error('Cannot set base providers because it has already been called'); } TestBedImpl._environmentTeardownOptions = options?.teardown; TestBedImpl._environmentErrorOnUnknownElementsOption = options?.errorOnUnknownElements; TestBedImpl._environmentErrorOnUnknownPropertiesOption = options?.errorOnUnknownProperties; this.platform = platform; this.ngModule = ngModule; this._compiler = new TestBedCompiler(this.platform, this.ngModule); // TestBed does not have an API which can reliably detect the start of a test, and thus could be // used to track the state of the NgModule registry and reset it correctly. Instead, when we // know we're in a testing scenario, we disable the check for duplicate NgModule registration // completely. setAllowDuplicateNgModuleIdsForTest(true); } /** * Reset the providers for the test injector. * * @publicApi */ resetTestEnvironment() { this.resetTestingModule(); this._compiler = null; this.platform = null; this.ngModule = null; TestBedImpl._environmentTeardownOptions = undefined; setAllowDuplicateNgModuleIdsForTest(false); } resetTestingModule() { this.checkGlobalCompilationFinished(); resetCompiledComponents(); if (this._compiler !== null) { this.compiler.restoreOriginalState(); } this._compiler = new TestBedCompiler(this.platform, this.ngModule); // Restore the previous value of the "error on unknown elements" option setUnknownElementStrictMode(this._previousErrorOnUnknownElementsOption ?? THROW_ON_UNKNOWN_ELEMENTS_DEFAULT); // Restore the previous value of the "error on unknown properties" option setUnknownPropertyStrictMode(this._previousErrorOnUnknownPropertiesOption ?? THROW_ON_UNKNOWN_PROPERTIES_DEFAULT); // We have to chain a couple of try/finally blocks, because each step can // throw errors and we don't want it to interrupt the next step and we also // want an error to be thrown at the end. try { this.destroyActiveFixtures(); } finally { try { if (this.shouldTearDownTestingModule()) { this.tearDownTestingModule(); } } finally { this._testModuleRef = null; this._instanceTeardownOptions = undefined; this._instanceErrorOnUnknownElementsOption = undefined; this._instanceErrorOnUnknownPropertiesOption = undefined; } } return this; } 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); } return this; } configureTestingModule(moduleDef) { this.assertNotInstantiated('R3TestBed.configureTestingModule', 'configure the test module'); // Trigger module scoping queue flush before executing other TestBed operations in a test. // This is needed for the first test invocation to ensure that globally declared modules have // their components scoped properly. See the `checkGlobalCompilationFinished` function // description for additional info. this.checkGlobalCompilationFinished(); // Always re-assign the options, even if they're undefined. // This ensures that we don't carry them between tests. this._instanceTeardownOptions = moduleDef.teardown; this._instanceErrorOnUnknownElementsOption = moduleDef.errorOnUnknownElements; this._instanceErrorOnUnknownPropertiesOption = moduleDef.errorOnUnknownProperties; // Store the current value of the strict mode option, // so we can restore it later this._previousErrorOnUnknownElementsOption = getUnknownElementStrictMode(); setUnknownElementStrictMode(this.shouldThrowErrorOnUnknownElements()); this._previousErrorOnUnknownPropertiesOption = getUnknownPropertyStrictMode(); setUnknownPropertyStrictMode(this.shouldThrowErrorOnUnknownProperties()); this.compiler.configureTestingModule(moduleDef); return this; } compileComponents() { return this.compiler.compileComponents(); } inject(token, notFoundValue, flags) { if (token === TestBed) { return this; } const UNDEFINED = {}; const result = this.testModuleRef.injector.get(token, UNDEFINED, flags); return result === UNDEFINED ? this.compiler.injector.get(token, notFoundValue, flags) : result; } /** @deprecated from v9.0.0 use TestBed.inject */ get(token, notFoundValue = Injector.THROW_IF_NOT_FOUND, flags = InjectFlags.Default) { return this.inject(token, notFoundValue, flags); } execute(tokens, fn, context) { const params = tokens.map(t => this.inject(t)); return fn.apply(context, params); } overrideModule(ngModule, override) { this.assertNotInstantiated('overrideModule', 'override module metadata'); this.compiler.overrideModule(ngModule, override); return this; } overrideComponent(component, override) { this.assertNotInstantiated('overrideComponent', 'override component metadata'); this.compiler.overrideComponent(component, override); return this; } overrideTemplateUsingTestingModule(component, template) { this.assertNotInstantiated('R3TestBed.overrideTemplateUsingTestingModule', 'Cannot override template when the test module has already been instantiated'); this.compiler.overrideTemplateUsingTestingModule(component, template); return this; } overrideDirective(directive, override) { this.assertNotInstantiated('overrideDirective', 'override directive metadata'); this.compiler.overrideDirective(directive, override); return this; } overridePipe(pipe, override) { this.assertNotInstantiated('overridePipe', 'override pipe metadata'); this.compiler.overridePipe(pipe, override); return this; } /** * Overwrites all providers for the given token with the given provider definition. */ overrideProvider(token, provider) { this.assertNotInstantiated('overrideProvider', 'override provider'); this.compiler.overrideProvider(token, provider); return this; } overrideTemplate(component, template) { return this.overrideComponent(component, { set: { template, templateUrl: null } }); } createComponent(type) { const testComponentRenderer = this.inject(TestComponentRenderer); const rootElId = `root${_nextRootElementId++}`; testComponentRenderer.insertRootElement(rootElId); const componentDef = type.ɵcmp; if (!componentDef) { throw new Error(`It looks like '${stringify(type)}' has not been compiled.`); } // TODO: Don't cast as `InjectionToken`, proper type is boolean[] const noNgZone = this.inject(ComponentFixtureNoNgZone, false); // TODO: Don't cast as `InjectionToken`, proper type is boolean[] const autoDetect = this.inject(ComponentFixtureAutoDetect, false); const ngZone = noNgZone ? null : this.inject(NgZone, null); const componentFactory = new ComponentFactory(componentDef); const initComponent = () => { const componentRef = componentFactory.create(Injector.NULL, [], `#${rootElId}`, this.testModuleRef); return new ComponentFixture(componentRef, ngZone, autoDetect); }; 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 */ 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 */ get testModuleRef() { if (this._testModuleRef === null) { this._testModuleRef = this.compiler.finalize(); } return this._testModuleRef; } 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. */ 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; } destroyActiveFixtures() { let errorCount = 0; this._activeFixtures.forEach((fixture) => { try { fixture.destroy(); } catch (e) { errorCount++; console.error('Error during cleanup of component', { component: fixture.componentInstance, stacktrace: e, }); } }); this._activeFixtures = []; if (errorCount > 0 && this.shouldRethrowTeardownErrors()) { throw Error(`${errorCount} ${(errorCount === 1 ? 'component' : 'components')} ` + `threw errors during cleanup`); } } shouldRethrowTeardownErrors() { const instanceOptions = this._instanceTeardownOptions; const environmentOptions = TestBedImpl._environmentTeardownOptions; // If the new teardown behavior hasn't been configured, preserve the old behavior. if (!instanceOptions && !environmentOptions) { return TEARDOWN_TESTING_MODULE_ON_DESTROY_DEFAULT; } // Otherwise use the configured behavior or default to rethrowing. return instanceOptions?.rethrowErrors ?? environmentOptions?.rethrowErrors ?? this.shouldTearDownTestingModule(); } shouldThrowErrorOnUnknownElements() { // Check if a configuration has been provided to throw when an unknown element is found return this._instanceErrorOnUnknownElementsOption ?? TestBedImpl._environmentErrorOnUnknownElementsOption ?? THROW_ON_UNKNOWN_ELEMENTS_DEFAULT; } shouldThrowErrorOnUnknownProperties() { // Check if a configuration has been provided to throw when an unknown property is found return this._instanceErrorOnUnknownPropertiesOption ?? TestBedImpl._environmentErrorOnUnknownPropertiesOption ?? THROW_ON_UNKNOWN_PROPERTIES_DEFAULT; } shouldTearDownTestingModule() { return this._instanceTeardownOptions?.destroyAfterEach ?? TestBedImpl._environmentTeardownOptions?.destroyAfterEach ?? TEARDOWN_TESTING_MODULE_ON_DESTROY_DEFAULT; } tearDownTestingModule() { // If the module ref has already been destroyed, we won't be able to get a test renderer. if (this._testModuleRef === null) { return; } // Resolve the renderer ahead of time, because we want to remove the root elements as the very // last step, but the injector will be destroyed as a part of the module ref destruction. const testRenderer = this.inject(TestComponentRenderer); try { this._testModuleRef.destroy(); } catch (e) { if (this.shouldRethrowTeardownErrors()) { throw e; } else { console.error('Error during cleanup of a testing module', { component: this._testModuleRef.instance, stacktrace: e, }); } } finally { testRenderer.removeAllRootElements?.(); } } } TestBedImpl._INSTANCE = null; /** * @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. * * @publicApi */ export const TestBed = TestBedImpl; /** * Allows injecting dependencies in `beforeEach()` and `it()`. Note: this function * (imported from the `@angular/core/testing` package) can **only** be used to inject dependencies * in tests. To inject dependencies in your application code, use the [`inject`](api/core/inject) * function from the `@angular/core` package instead. * * Example: * * ``` * beforeEach(inject([Dependency, AClass], (dep, object) => { * // some code that uses `dep` and `object` * // ... * })); * * it('...', inject([AClass], (object) => { * object.doSomething(); * expect(...); * }) * ``` * * @publicApi */ export function inject(tokens, fn) { const testBed = TestBedImpl.INSTANCE; // Not using an arrow function to preserve context passed from call site return function () { return testBed.execute(tokens, fn, this); }; } /** * @publicApi */ export class InjectSetupWrapper { constructor(_moduleDef) { this._moduleDef = _moduleDef; } _addModule() { const moduleDef = this._moduleDef(); if (moduleDef) { TestBedImpl.configureTestingModule(moduleDef); } } inject(tokens, fn) { const self = this; // Not using an arrow function to preserve context passed from call site return function () { self._addModule(); return inject(tokens, fn).call(this); }; } } export function withModule(moduleDef, fn) { if (fn) { // Not using an arrow function to preserve context passed from call site return function () { const testBed = TestBedImpl.INSTANCE; if (moduleDef) { testBed.configureTestingModule(moduleDef); } return fn.apply(this); }; } return new InjectSetupWrapper(() => moduleDef); } //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"test_bed.js","sourceRoot":"","sources":["../../../../../../../packages/core/testing/src/test_bed.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC 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  Component,\n  Directive,\n  InjectFlags,\n  InjectionToken,\n  Injector,\n  NgModule,\n  NgZone,\n  Pipe,\n  PlatformRef,\n  ProviderToken,\n  Type,\n  ɵflushModuleScopingQueueAsMuchAsPossible as flushModuleScopingQueueAsMuchAsPossible,\n  ɵgetUnknownElementStrictMode as getUnknownElementStrictMode,\n  ɵgetUnknownPropertyStrictMode as getUnknownPropertyStrictMode,\n  ɵRender3ComponentFactory as ComponentFactory,\n  ɵRender3NgModuleRef as NgModuleRef,\n  ɵresetCompiledComponents as resetCompiledComponents,\n  ɵsetAllowDuplicateNgModuleIdsForTest as setAllowDuplicateNgModuleIdsForTest,\n  ɵsetUnknownElementStrictMode as setUnknownElementStrictMode,\n  ɵsetUnknownPropertyStrictMode as setUnknownPropertyStrictMode,\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 {ComponentFixtureAutoDetect, ComponentFixtureNoNgZone, ModuleTeardownOptions, TEARDOWN_TESTING_MODULE_ON_DESTROY_DEFAULT, TestComponentRenderer, TestEnvironmentOptions, TestModuleMetadata, THROW_ON_UNKNOWN_ELEMENTS_DEFAULT, THROW_ON_UNKNOWN_PROPERTIES_DEFAULT} from './test_bed_common';\nimport {TestBedCompiler} from './test_bed_compiler';\n\n/**\n * Static methods implemented by the `TestBed`.\n *\n * @publicApi\n */\nexport interface TestBedStatic extends TestBed {\n  new(...args: any[]): TestBed;\n}\n\n/**\n * @publicApi\n */\nexport interface TestBed {\n  get platform(): PlatformRef;\n\n  get ngModule(): Type<any>|Type<any>[];\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  initTestEnvironment(\n      ngModule: Type<any>|Type<any>[], platform: PlatformRef,\n      options?: TestEnvironmentOptions): void;\n\n  /**\n   * Reset the providers for the test injector.\n   */\n  resetTestEnvironment(): void;\n\n  resetTestingModule(): TestBed;\n\n  configureCompiler(config: {providers?: any[], useJit?: boolean}): void;\n\n  configureTestingModule(moduleDef: TestModuleMetadata): TestBed;\n\n  compileComponents(): Promise<any>;\n\n  inject<T>(token: ProviderToken<T>, notFoundValue?: T, flags?: InjectFlags): T;\n  inject<T>(token: ProviderToken<T>, notFoundValue: null, flags?: InjectFlags): T|null;\n\n  /** @deprecated from v9.0.0 use TestBed.inject */\n  get<T>(token: ProviderToken<T>, notFoundValue?: T, flags?: InjectFlags): any;\n  /** @deprecated from v9.0.0 use TestBed.inject */\n  get(token: any, notFoundValue?: any): any;\n\n  execute(tokens: any[], fn: Function, context?: any): any;\n\n  overrideModule(ngModule: Type<any>, override: MetadataOverride<NgModule>): TestBed;\n\n  overrideComponent(component: Type<any>, override: MetadataOverride<Component>): TestBed;\n\n  overrideDirective(directive: Type<any>, override: MetadataOverride<Directive>): TestBed;\n\n  overridePipe(pipe: Type<any>, override: MetadataOverride<Pipe>): TestBed;\n\n  overrideTemplate(component: Type<any>, template: string): TestBed;\n\n  /**\n   * Overwrites all providers for the given token with the given provider definition.\n   */\n  overrideProvider(token: any, provider: {\n    useFactory: Function,\n    deps: any[],\n  }): TestBed;\n  overrideProvider(token: any, provider: {useValue: any;}): TestBed;\n  overrideProvider(token: any, provider: {useFactory?: Function, useValue?: any, deps?: any[]}):\n      TestBed;\n\n  overrideTemplateUsingTestingModule(component: Type<any>, template: string): TestBed;\n\n  createComponent<T>(component: Type<T>): ComponentFixture<T>;\n}\n\nlet _nextRootElementId = 0;\n\n/**\n * Returns a singleton of the `TestBed` class.\n *\n * @publicApi\n */\nexport function getTestBed(): TestBed {\n  return TestBedImpl.INSTANCE;\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 */\nexport class TestBedImpl implements TestBed {\n  private static _INSTANCE: TestBedImpl|null = null;\n\n  static get INSTANCE(): TestBedImpl {\n    return TestBedImpl._INSTANCE = TestBedImpl._INSTANCE || new TestBedImpl();\n  }\n\n  /**\n   * Teardown options that have been configured at the environment level.\n   * Used as a fallback if no instance-level options have been provided.\n   */\n  private static _environmentTeardownOptions: ModuleTeardownOptions|undefined;\n\n  /**\n   * \"Error on unknown elements\" option that has been configured at the environment level.\n   * Used as a fallback if no instance-level option has been provided.\n   */\n  private static _environmentErrorOnUnknownElementsOption: boolean|undefined;\n\n  /**\n   * \"Error on unknown properties\" option that has been configured at the environment level.\n   * Used as a fallback if no instance-level option has been provided.\n   */\n  private static _environmentErrorOnUnknownPropertiesOption: boolean|undefined;\n\n  /**\n   * Teardown options that have been configured at the `TestBed` instance level.\n   * These options take precedence over the environment-level ones.\n   */\n  private _instanceTeardownOptions: ModuleTeardownOptions|undefined;\n\n  /**\n   * \"Error on unknown elements\" option that has been configured at the `TestBed` instance level.\n   * This option takes precedence over the environment-level one.\n   */\n  private _instanceErrorOnUnknownElementsOption: boolean|undefined;\n\n  /**\n   * \"Error on unknown properties\" option that has been configured at the `TestBed` instance level.\n   * This option takes precedence over the environment-level one.\n   */\n  private _instanceErrorOnUnknownPropertiesOption: boolean|undefined;\n\n  /**\n   * Stores the previous \"Error on unknown elements\" option value,\n   * allowing to restore it in the reset testing module logic.\n   */\n  private _previousErrorOnUnknownElementsOption: boolean|undefined;\n\n  /**\n   * Stores the previous \"Error on unknown properties\" option value,\n   * allowing to restore it in the reset testing module logic.\n   */\n  private _previousErrorOnUnknownPropertiesOption: boolean|undefined;\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  static initTestEnvironment(\n      ngModule: Type<any>|Type<any>[], platform: PlatformRef,\n      options?: TestEnvironmentOptions): TestBed {\n    const testBed = TestBedImpl.INSTANCE;\n    testBed.initTestEnvironment(ngModule, platform, options);\n    return testBed;\n  }\n\n  /**\n   * Reset the providers for the test injector.\n   *\n   * @publicApi\n   */\n  static resetTestEnvironment(): void {\n    TestBedImpl.INSTANCE.resetTestEnvironment();\n  }\n\n  static configureCompiler(config: {providers?: any[]; useJit?: boolean;}): TestBed {\n    return TestBedImpl.INSTANCE.configureCompiler(config);\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): TestBed {\n    return TestBedImpl.INSTANCE.configureTestingModule(moduleDef);\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 TestBedImpl.INSTANCE.compileComponents();\n  }\n\n  static overrideModule(ngModule: Type<any>, override: MetadataOverride<NgModule>): TestBed {\n    return TestBedImpl.INSTANCE.overrideModule(ngModule, override);\n  }\n\n  static overrideComponent(component: Type<any>, override: MetadataOverride<Component>): TestBed {\n    return TestBedImpl.INSTANCE.overrideComponent(component, override);\n  }\n\n  static overrideDirective(directive: Type<any>, override: MetadataOverride<Directive>): TestBed {\n    return TestBedImpl.INSTANCE.overrideDirective(directive, override);\n  }\n\n  static overridePipe(pipe: Type<any>, override: MetadataOverride<Pipe>): TestBed {\n    return TestBedImpl.INSTANCE.overridePipe(pipe, override);\n  }\n\n  static overrideTemplate(component: Type<any>, template: string): TestBed {\n    return TestBedImpl.INSTANCE.overrideTemplate(component, template);\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): TestBed {\n    return TestBedImpl.INSTANCE.overrideTemplateUsingTestingModule(component, template);\n  }\n\n  static overrideProvider(token: any, provider: {\n    useFactory: Function,\n    deps: any[],\n  }): TestBed;\n  static overrideProvider(token: any, provider: {useValue: any;}): TestBed;\n  static overrideProvider(token: any, provider: {\n    useFactory?: Function,\n    useValue?: any,\n    deps?: any[],\n  }): TestBed {\n    return TestBedImpl.INSTANCE.overrideProvider(token, provider);\n  }\n\n  static inject<T>(token: ProviderToken<T>, notFoundValue?: T, flags?: InjectFlags): T;\n  static inject<T>(token: ProviderToken<T>, notFoundValue: null, flags?: InjectFlags): T|null;\n  static inject<T>(token: ProviderToken<T>, notFoundValue?: T|null, flags?: InjectFlags): T|null {\n    return TestBedImpl.INSTANCE.inject(token, notFoundValue, flags);\n  }\n\n  /** @deprecated from v9.0.0 use TestBed.inject */\n  static get<T>(token: ProviderToken<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 TestBedImpl.INSTANCE.inject(token, notFoundValue, flags);\n  }\n\n  static createComponent<T>(component: Type<T>): ComponentFixture<T> {\n    return TestBedImpl.INSTANCE.createComponent(component);\n  }\n\n  static resetTestingModule(): TestBed {\n    return TestBedImpl.INSTANCE.resetTestingModule();\n  }\n\n  static execute(tokens: any[], fn: Function, context?: any): any {\n    return TestBedImpl.INSTANCE.execute(tokens, fn, context);\n  }\n\n  static get platform(): PlatformRef {\n    return TestBedImpl.INSTANCE.platform;\n  }\n\n  static get ngModule(): Type<any>|Type<any>[] {\n    return TestBedImpl.INSTANCE.ngModule;\n  }\n\n  // Properties\n\n  platform: PlatformRef = null!;\n  ngModule: Type<any>|Type<any>[] = null!;\n\n  private _compiler: TestBedCompiler|null = null;\n  private _testModuleRef: NgModuleRef<any>|null = null;\n\n  private _activeFixtures: ComponentFixture<any>[] = [];\n\n  /**\n   * Internal-only flag to indicate whether a module\n   * scoping queue has been checked and flushed already.\n   * @nodoc\n   */\n  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,\n      options?: TestEnvironmentOptions): void {\n    if (this.platform || this.ngModule) {\n      throw new Error('Cannot set base providers because it has already been called');\n    }\n\n    TestBedImpl._environmentTeardownOptions = options?.teardown;\n\n    TestBedImpl._environmentErrorOnUnknownElementsOption = options?.errorOnUnknownElements;\n\n    TestBedImpl._environmentErrorOnUnknownPropertiesOption = options?.errorOnUnknownProperties;\n\n    this.platform = platform;\n    this.ngModule = ngModule;\n    this._compiler = new TestBedCompiler(this.platform, this.ngModule);\n\n    // TestBed does not have an API which can reliably detect the start of a test, and thus could be\n    // used to track the state of the NgModule registry and reset it correctly. Instead, when we\n    // know we're in a testing scenario, we disable the check for duplicate NgModule registration\n    // completely.\n    setAllowDuplicateNgModuleIdsForTest(true);\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    TestBedImpl._environmentTeardownOptions = undefined;\n    setAllowDuplicateNgModuleIdsForTest(false);\n  }\n\n  resetTestingModule(): this {\n    this.checkGlobalCompilationFinished();\n    resetCompiledComponents();\n    if (this._compiler !== null) {\n      this.compiler.restoreOriginalState();\n    }\n    this._compiler = new TestBedCompiler(this.platform, this.ngModule);\n    // Restore the previous value of the \"error on unknown elements\" option\n    setUnknownElementStrictMode(\n        this._previousErrorOnUnknownElementsOption ?? THROW_ON_UNKNOWN_ELEMENTS_DEFAULT);\n    // Restore the previous value of the \"error on unknown properties\" option\n    setUnknownPropertyStrictMode(\n        this._previousErrorOnUnknownPropertiesOption ?? THROW_ON_UNKNOWN_PROPERTIES_DEFAULT);\n\n    // We have to chain a couple of try/finally blocks, because each step can\n    // throw errors and we don't want it to interrupt the next step and we also\n    // want an error to be thrown at the end.\n    try {\n      this.destroyActiveFixtures();\n    } finally {\n      try {\n        if (this.shouldTearDownTestingModule()) {\n          this.tearDownTestingModule();\n        }\n      } finally {\n        this._testModuleRef = null;\n        this._instanceTeardownOptions = undefined;\n        this._instanceErrorOnUnknownElementsOption = undefined;\n        this._instanceErrorOnUnknownPropertiesOption = undefined;\n      }\n    }\n    return this;\n  }\n\n  configureCompiler(config: {providers?: any[]; useJit?: boolean;}): this {\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    return this;\n  }\n\n  configureTestingModule(moduleDef: TestModuleMetadata): this {\n    this.assertNotInstantiated('R3TestBed.configureTestingModule', 'configure the test module');\n\n    // Trigger module scoping queue flush before executing other TestBed operations in a test.\n    // This is needed for the first test invocation to ensure that globally declared modules have\n    // their components scoped properly. See the `checkGlobalCompilationFinished` function\n    // description for additional info.\n    this.checkGlobalCompilationFinished();\n\n    // Always re-assign the options, even if they're undefined.\n    // This ensures that we don't carry them between tests.\n    this._instanceTeardownOptions = moduleDef.teardown;\n    this._instanceErrorOnUnknownElementsOption = moduleDef.errorOnUnknownElements;\n    this._instanceErrorOnUnknownPropertiesOption = moduleDef.errorOnUnknownProperties;\n    // Store the current value of the strict mode option,\n    // so we can restore it later\n    this._previousErrorOnUnknownElementsOption = getUnknownElementStrictMode();\n    setUnknownElementStrictMode(this.shouldThrowErrorOnUnknownElements());\n    this._previousErrorOnUnknownPropertiesOption = getUnknownPropertyStrictMode();\n    setUnknownPropertyStrictMode(this.shouldThrowErrorOnUnknownProperties());\n    this.compiler.configureTestingModule(moduleDef);\n    return this;\n  }\n\n  compileComponents(): Promise<any> {\n    return this.compiler.compileComponents();\n  }\n\n  inject<T>(token: ProviderToken<T>, notFoundValue?: T, flags?: InjectFlags): T;\n  inject<T>(token: ProviderToken<T>, notFoundValue: null, flags?: InjectFlags): T|null;\n  inject<T>(token: ProviderToken<T>, notFoundValue?: T|null, flags?: InjectFlags): T|null {\n    if (token as unknown === TestBed) {\n      return this as any;\n    }\n    const UNDEFINED = {} as unknown as T;\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: ProviderToken<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>): this {\n    this.assertNotInstantiated('overrideModule', 'override module metadata');\n    this.compiler.overrideModule(ngModule, override);\n    return this;\n  }\n\n  overrideComponent(component: Type<any>, override: MetadataOverride<Component>): this {\n    this.assertNotInstantiated('overrideComponent', 'override component metadata');\n    this.compiler.overrideComponent(component, override);\n    return this;\n  }\n\n  overrideTemplateUsingTestingModule(component: Type<any>, template: string): this {\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    return this;\n  }\n\n  overrideDirective(directive: Type<any>, override: MetadataOverride<Directive>): this {\n    this.assertNotInstantiated('overrideDirective', 'override directive metadata');\n    this.compiler.overrideDirective(directive, override);\n    return this;\n  }\n\n  overridePipe(pipe: Type<any>, override: MetadataOverride<Pipe>): this {\n    this.assertNotInstantiated('overridePipe', 'override pipe metadata');\n    this.compiler.overridePipe(pipe, override);\n    return this;\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      this {\n    this.assertNotInstantiated('overrideProvider', 'override provider');\n    this.compiler.overrideProvider(token, provider);\n    return this;\n  }\n\n  overrideTemplate(component: Type<any>, template: string): TestBed {\n    return this.overrideComponent(component, {set: {template, templateUrl: null!}});\n  }\n\n  createComponent<T>(type: Type<T>): ComponentFixture<T> {\n    const testComponentRenderer = this.inject(TestComponentRenderer);\n    const rootElId = `root${_nextRootElementId++}`;\n    testComponentRenderer.insertRootElement(rootElId);\n\n    const componentDef = (type as any).ɵcmp;\n\n    if (!componentDef) {\n      throw new Error(`It looks like '${stringify(type)}' has not been compiled.`);\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(): TestBedCompiler {\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 checkGlobalCompilationFinished(): void {\n    // Checking _testNgModuleRef is null should not be necessary, but is left in as an additional\n    // guard that compilations queued in tests (after instantiation) are never flushed accidentally.\n    if (!this.globalCompilationChecked && this._testModuleRef === null) {\n      flushModuleScopingQueueAsMuchAsPossible();\n    }\n    this.globalCompilationChecked = true;\n  }\n\n  private destroyActiveFixtures(): void {\n    let errorCount = 0;\n    this._activeFixtures.forEach((fixture) => {\n      try {\n        fixture.destroy();\n      } catch (e) {\n        errorCount++;\n        console.error('Error during cleanup of component', {\n          component: fixture.componentInstance,\n          stacktrace: e,\n        });\n      }\n    });\n    this._activeFixtures = [];\n\n    if (errorCount > 0 && this.shouldRethrowTeardownErrors()) {\n      throw Error(\n          `${errorCount} ${(errorCount === 1 ? 'component' : 'components')} ` +\n          `threw errors during cleanup`);\n    }\n  }\n\n  shouldRethrowTeardownErrors(): boolean {\n    const instanceOptions = this._instanceTeardownOptions;\n    const environmentOptions = TestBedImpl._environmentTeardownOptions;\n\n    // If the new teardown behavior hasn't been configured, preserve the old behavior.\n    if (!instanceOptions && !environmentOptions) {\n      return TEARDOWN_TESTING_MODULE_ON_DESTROY_DEFAULT;\n    }\n\n    // Otherwise use the configured behavior or default to rethrowing.\n    return instanceOptions?.rethrowErrors ?? environmentOptions?.rethrowErrors ??\n        this.shouldTearDownTestingModule();\n  }\n\n  shouldThrowErrorOnUnknownElements(): boolean {\n    // Check if a configuration has been provided to throw when an unknown element is found\n    return this._instanceErrorOnUnknownElementsOption ??\n        TestBedImpl._environmentErrorOnUnknownElementsOption ?? THROW_ON_UNKNOWN_ELEMENTS_DEFAULT;\n  }\n\n  shouldThrowErrorOnUnknownProperties(): boolean {\n    // Check if a configuration has been provided to throw when an unknown property is found\n    return this._instanceErrorOnUnknownPropertiesOption ??\n        TestBedImpl._environmentErrorOnUnknownPropertiesOption ??\n        THROW_ON_UNKNOWN_PROPERTIES_DEFAULT;\n  }\n\n  shouldTearDownTestingModule(): boolean {\n    return this._instanceTeardownOptions?.destroyAfterEach ??\n        TestBedImpl._environmentTeardownOptions?.destroyAfterEach ??\n        TEARDOWN_TESTING_MODULE_ON_DESTROY_DEFAULT;\n  }\n\n  tearDownTestingModule() {\n    // If the module ref has already been destroyed, we won't be able to get a test renderer.\n    if (this._testModuleRef === null) {\n      return;\n    }\n    // Resolve the renderer ahead of time, because we want to remove the root elements as the very\n    // last step, but the injector will be destroyed as a part of the module ref destruction.\n    const testRenderer = this.inject(TestComponentRenderer);\n    try {\n      this._testModuleRef.destroy();\n    } catch (e) {\n      if (this.shouldRethrowTeardownErrors()) {\n        throw e;\n      } else {\n        console.error('Error during cleanup of a testing module', {\n          component: this._testModuleRef.instance,\n          stacktrace: e,\n        });\n      }\n    } finally {\n      testRenderer.removeAllRootElements?.();\n    }\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 * @publicApi\n */\nexport const TestBed: TestBedStatic = TestBedImpl;\n\n/**\n * Allows injecting dependencies in `beforeEach()` and `it()`. Note: this function\n * (imported from the `@angular/core/testing` package) can **only** be used to inject dependencies\n * in tests. To inject dependencies in your application code, use the [`inject`](api/core/inject)\n * function from the `@angular/core` package instead.\n *\n * Example:\n *\n * ```\n * beforeEach(inject([Dependency, AClass], (dep, object) => {\n *   // some code that uses `dep` and `object`\n *   // ...\n * }));\n *\n * it('...', inject([AClass], (object) => {\n *   object.doSomething();\n *   expect(...);\n * })\n * ```\n *\n * @publicApi\n */\nexport function inject(tokens: any[], fn: Function): () => any {\n  const testBed = TestBedImpl.INSTANCE;\n  // Not using an arrow function to preserve context passed from call site\n  return function(this: unknown) {\n    return testBed.execute(tokens, fn, this);\n  };\n}\n\n/**\n * @publicApi\n */\nexport class InjectSetupWrapper {\n  constructor(private _moduleDef: () => TestModuleMetadata) {}\n\n  private _addModule() {\n    const moduleDef = this._moduleDef();\n    if (moduleDef) {\n      TestBedImpl.configureTestingModule(moduleDef);\n    }\n  }\n\n  inject(tokens: any[], fn: Function): () => any {\n    const self = this;\n    // Not using an arrow function to preserve context passed from call site\n    return function(this: unknown) {\n      self._addModule();\n      return inject(tokens, fn).call(this);\n    };\n  }\n}\n\n/**\n * @publicApi\n */\nexport function withModule(moduleDef: TestModuleMetadata): InjectSetupWrapper;\nexport function withModule(moduleDef: TestModuleMetadata, fn: Function): () => any;\nexport function withModule(moduleDef: TestModuleMetadata, fn?: Function|null): (() => any)|\n    InjectSetupWrapper {\n  if (fn) {\n    // Not using an arrow function to preserve context passed from call site\n    return function(this: unknown) {\n      const testBed = TestBedImpl.INSTANCE;\n      if (moduleDef) {\n        testBed.configureTestingModule(moduleDef);\n      }\n      return fn.apply(this);\n    };\n  }\n  return new InjectSetupWrapper(() => moduleDef);\n}\n"]}