@angular/core/esm2022/testing/src/test_bed.mjs

Angular - the core framework

/**
 * @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 { EnvironmentInjector, InjectFlags, Injector, NgZone, runInInjectionContext, ɵconvertToBitFlags as convertToBitFlags, ɵDeferBlockBehavior as DeferBlockBehavior, ɵEffectScheduler as EffectScheduler, ɵflushModuleScopingQueueAsMuchAsPossible as flushModuleScopingQueueAsMuchAsPossible, ɵgetAsyncClassMetadataFn as getAsyncClassMetadataFn, ɵ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 { 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';
const DEFER_BLOCK_DEFAULT_BEHAVIOR = DeferBlockBehavior.Playthrough;
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() {
        /**
         * Defer block behavior option that specifies whether defer blocks will be triggered manually
         * or set to play through.
         */
        this._instanceDeferBlockBehavior = DEFER_BLOCK_DEFAULT_BEHAVIOR;
        // 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 { this._INSTANCE = null; }
    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/<platform_name>/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, convertToBitFlags(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);
    }
    /**
     * Runs the given function in the `EnvironmentInjector` context of `TestBed`.
     *
     * @see {@link EnvironmentInjector#runInContext}
     */
    static runInInjectionContext(fn) {
        return TestBedImpl.INSTANCE.runInInjectionContext(fn);
    }
    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;
    }
    static flushEffects() {
        return TestBedImpl.INSTANCE.flushEffects();
    }
    /**
     * 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
     */
    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;
                this._instanceDeferBlockBehavior = DEFER_BLOCK_DEFAULT_BEHAVIOR;
            }
        }
        return this;
    }
    configureCompiler(config) {
        if (config.useJit != null) {
            throw new Error('JIT compiler is not configurable via TestBed APIs.');
        }
        if (config.providers !== undefined) {
            this.compiler.setCompilerProviders(config.providers);
        }
        return this;
    }
    configureTestingModule(moduleDef) {
        this.assertNotInstantiated('TestBed.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;
        this._instanceDeferBlockBehavior = moduleDef.deferBlockBehavior ?? DEFER_BLOCK_DEFAULT_BEHAVIOR;
        // 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, convertToBitFlags(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);
    }
    runInInjectionContext(fn) {
        return runInInjectionContext(this.inject(EnvironmentInjector), fn);
    }
    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('TestBed.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);
        if (getAsyncClassMetadataFn(type)) {
            throw new Error(`Component '${type.name}' has unresolved metadata. ` +
                `Please call \`await TestBed.compileComponents()\` before running this test.`);
        }
        const componentDef = type.ɵcmp;
        if (!componentDef) {
            throw new Error(`It looks like '${stringify(type)}' has not been compiled.`);
        }
        const componentFactory = new ComponentFactory(componentDef);
        const initComponent = () => {
            const componentRef = componentFactory.create(Injector.NULL, [], `#${rootElId}`, this.testModuleRef);
            return this.runInInjectionContext(() => new ComponentFixture(componentRef));
        };
        const noNgZone = this.inject(ComponentFixtureNoNgZone, false);
        const ngZone = noNgZone ? null : this.inject(NgZone, null);
        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;
    }
    getDeferBlockBehavior() {
        return this._instanceDeferBlockBehavior;
    }
    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?.();
        }
    }
    /**
     * Execute any pending effects.
     *
     * @developerPreview
     */
    flushEffects() {
        this.inject(EffectScheduler).flush();
    }
}
/**
 * @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  EnvironmentInjector,\n  InjectFlags,\n  InjectOptions,\n  Injector,\n  NgModule,\n  NgZone,\n  Pipe,\n  PlatformRef,\n  ProviderToken,\n  runInInjectionContext,\n  Type,\n  ɵconvertToBitFlags as convertToBitFlags,\n  ɵDeferBlockBehavior as DeferBlockBehavior,\n  ɵEffectScheduler as EffectScheduler,\n  ɵflushModuleScopingQueueAsMuchAsPossible as flushModuleScopingQueueAsMuchAsPossible,\n  ɵgetAsyncClassMetadataFn as getAsyncClassMetadataFn,\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\n\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\nconst DEFER_BLOCK_DEFAULT_BEHAVIOR = DeferBlockBehavior.Playthrough;\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: undefined, options: InjectOptions&{\n    optional?: false\n  }): T;\n  inject<T>(token: ProviderToken<T>, notFoundValue: null|undefined, options: InjectOptions): T|null;\n  inject<T>(token: ProviderToken<T>, notFoundValue?: T, options?: InjectOptions): T;\n  /** @deprecated use object-based flags (`InjectOptions`) instead. */\n  inject<T>(token: ProviderToken<T>, notFoundValue?: T, flags?: InjectFlags): T;\n  /** @deprecated use object-based flags (`InjectOptions`) instead. */\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  /**\n   * Runs the given function in the `EnvironmentInjector` context of `TestBed`.\n   *\n   * @see {@link EnvironmentInjector#runInContext}\n   */\n  runInInjectionContext<T>(fn: () => T): T;\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: {useFactory: Function, deps: any[], multi?: boolean}):\n      TestBed;\n  overrideProvider(token: any, provider: {useValue: any, multi?: boolean}): TestBed;\n  overrideProvider(\n      token: any,\n      provider: {useFactory?: Function, useValue?: any, deps?: any[], multi?: boolean}): TestBed;\n\n  overrideTemplateUsingTestingModule(component: Type<any>, template: string): TestBed;\n\n  createComponent<T>(component: Type<T>): ComponentFixture<T>;\n\n\n  /**\n   * Execute any pending effects.\n   *\n   * @developerPreview\n   */\n  flushEffects(): void;\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 