| {"version":3,"sources":["packages/core/core-testing.umd.js"],"names":["global","factory","exports","module","require","define","amd","self","ng","core","testing","compiler","this","_global","window","runInTestZone","fn","context","finishCallback","failCallback","currentZone","Zone","current","AsyncTestZoneSpec","undefined","Error","ProxyZoneSpec","proxyZoneSpec","get","assertPresent","proxyZone","getZoneWith","previousDelegate","getDelegate","parent","run","testZoneSpec","setDelegate","error","runGuarded","ComponentFixture","componentRef","ngZone","_autoDetect","_this","_isStable","_isDestroyed","_resolve","_promise","_onUnstableSubscription","_onStableSubscription","_onMicrotaskEmptySubscription","_onErrorSubscription","changeDetectorRef","elementRef","location","debugElement","getDebugNode","nativeElement","componentInstance","instance","runOutsideAngular","onUnstable","subscribe","next","onMicrotaskEmpty","detectChanges","onStable","scheduleMicroTask","hasPendingMacrotasks","onError","prototype","_tick","checkNoChanges","autoDetectChanges","autoDetect","isStable","whenStable","Promise","resolve","res","_getRenderer","_renderer","injector","RendererFactory2","whenRenderingDone","renderer","destroy","unsubscribe","_Zone","FakeAsyncTestZoneSpec","_fakeAsyncTestZoneSpec","resetFakeAsyncZoneFallback","resetDelegate","_inFakeAsyncCall","_getFakeAsyncZoneSpec","flushMicrotasksFallback","flushMicrotasks","_Zone$1","fakeAsyncTestModule","__symbol__","resetFakeAsyncZone","extendStatics","d","b","Object","setPrototypeOf","__proto__","Array","p","hasOwnProperty","__extends","__","constructor","create","__decorate","decorators","target","key","desc","c","arguments","length","r","getOwnPropertyDescriptor","Reflect","decorate","i","defineProperty","__awaiter","thisArg","_arguments","P","generator","reject","fulfilled","value","step","e","rejected","result","done","then","apply","__generator","body","f","y","t","g","_","label","sent","trys","ops","verb","throw","return","Symbol","iterator","n","v","op","TypeError","call","pop","push","__values","o","m","__read","ar","__spread","concat","AsyncTestCompleter","rej","_reject","fail","stackTrace","enumerable","configurable","TestComponentRenderer","insertRootElement","rootElementId","ComponentFixtureAutoDetect","InjectionToken","ComponentFixtureNoNgZone","resolveComponentResources","resourceResolver","componentResolved","urlMap","Map","cachedResourceResolve","url","promise","resp","set","unwrapResponse","componentResourceResolutionQueue","forEach","component","type","promises","templateUrl","template","styleUrls","styles","styleOffset","styleUrl","index","style","splice","indexOf","fullyResolved","all","componentDefResolved","componentDefPendingResolution","delete","clearResolutionOfComponentResourcesQueue","Set","isComponentDefPendingResolution","has","old","response","text","_nextReferenceId","MetadataOverrider","_references","overrideMetadata","metadataClass","oldMetadata","override","props","_valueProps","obj","keys","prop","startsWith","proto","getPrototypeOf","protoProp","remove","add","ɵstringify","setMetadata","metadata","removeMetadata","references","removeObjects","_loop_1","removeValue","_propHashKey","_loop_2","propValue","filter","addMetadata","addValue","propName","JSON","stringify","_serializeReference","ref","id","TestingModuleOverride","reflection","ɵReflectionCapabilities","OverrideResolver","overrides","resolved","addOverride","setOverrides","clear","_a","_b","getAnnotation","annotations","annotation","Directive","Component","Pipe","NgModule","overrider_1","DirectiveResolver","_super","ComponentResolver","PipeResolver","NgModuleResolver","R3TestBedCompiler","platform","additionalModuleTypes","originalComponentResolutionQueue","declarations","imports","providers","schemas","pendingComponents","pendingDirectives","pendingPipes","seenComponents","seenDirectives","existingComponentStyles","resolvers","initResolvers","directive","pipe","componentToModuleScope","initialNgDefs","defCleanupOps","_injector","compilerProviders","providerOverrides","rootProviderOverrides","providerOverridesByToken","moduleProvidersOverridden","testModuleRef","testModuleType","DynamicTestModule","setCompilerProviders","configureTestingModule","moduleDef","_c","_d","queueTypeArray","DECLARATION","queueTypesFromModulesArray","overrideModule","ngModule","name","recompileNgModule","overrideComponent","overrideDirective","overridePipe","overrideProvider","token","provider","injectableDef","providerDef","useFactory","provide","deps","multi","useValue","ɵgetInjectableDef","providedIn","overrideTemplateUsingTestingModule","def","ɵNG_COMPONENT_DEF","overrideStyleUrls","OVERRIDE_TEMPLATE","compileComponents","resourceLoader_1","clearComponentResolutionQueue","compileTypesSync","ResourceLoader","finalize","compileTestModule","applyTransitiveScopes","applyProviderOverrides","patchComponentsWithExistingStyles","ɵRender3NgModuleRef","localeId","LOCALE_ID","ɵDEFAULT_LOCALE_ID","ɵsetLocaleId","ApplicationInitStatus","runInitializers","_compileNgModuleSync","moduleType","applyProviderOverridesToModule","_compileNgModuleAsync","_getModuleResolver","_getComponentFactories","maybeUnwrapFn","ngModuleDef","reduce","factories","declaration","componentDef","ngComponentDef","ɵRender3ComponentFactory","needsAsyncResources","maybeStoreNgDef","ɵcompileComponent","ɵNG_DIRECTIVE_DEF","ɵcompileDirective","ɵNG_PIPE_DEF","ɵcompilePipe","moduleToScope","componentType","moduleScope","realType","isTestingModuleOverride","ɵtransitiveScopesFor","getScopeOfModule","storeFieldOfDefOnType","ɵpatchComponentDefWithScope","maybeApplyOverrides","field","hasProviderOverrides","patchDefWithProviderOverrides","e_1","injectorDef","ɵNG_INJECTOR_DEF","size","getOverriddenProviders","ɵNG_MODULE_DEF","e_1_1","arr","e_2","arr_1","arr_1_1","isArray","queueType","e_2_1","ɵcompileNgModuleDefs","e_3","arr_2","arr_2_1","hasNgModuleDef","e_3_1","currentDef","defField","original","restoreComponentResolutionQueue","queue","restoreOriginalState","e_4","e_4_1","descriptor","RootScopeModule","NgZone","enableLongStackTrace","Compiler","R3TestCompiler","CompilerModule","COMPILER_OPTIONS","opts","CompilerModuleFactory","ɵNgModuleFactory","getSingleProviderOverrides","getProviderToken","getProviderOverrides","flatten","hasMultiProviderOverrides","some","isMultiProvider","overriddenProviders","final","seenMultiProviders","forEachRight","unshift","providersResolver","resolver_1","processProvidersFn_1","ngDef","maybeFn","Function","values","mapFn","out","getProviderField","idx","testBed","compileModuleSync","compileModuleAsync","compileModuleAndAllComponentsSync","ngModuleFactory","componentFactories","ModuleWithComponentFactories","compileModuleAndAllComponentsAsync","clearCache","clearCacheFor","getModuleId","meta","_nextRootElementId","UNDEFINED","TestBedRender3","_compiler","_testModuleRef","_activeFixtures","_globalCompilationChecked","initTestEnvironment","aotSummaries","_getTestBedRender3","resetTestEnvironment","configureCompiler","config","overrideTemplate","notFoundValue","flags","Injector","THROW_IF_NOT_FOUND","InjectFlags","Default","createComponent","resetTestingModule","checkGlobalCompilationFinished","ɵresetCompiledComponents","destroyActiveFixtures","useJit","assertNotInstantiated","execute","tokens","params","map","testComponentRenderer","rootElId","noNgZone","componentFactory","initComponent","NULL","fixture","methodName","methodDescription","ɵflushModuleScopingQueueAsMuchAsPossible","console","stacktrace","unimplemented","testBed$1","TestingCompiler","loadAotSummaries","summaries","getComponentFactory","getComponentFromError","Injectable","TestingCompilerFactory","UNDEFINED$1","_nextRootElementId$1","TestBedViewEngine","_instantiated","_moduleRef","_moduleFactory","_compilerOptions","_moduleOverrides","_componentOverrides","_directiveOverrides","_pipeOverrides","_providers","_declarations","_imports","_schemas","_testEnvAotSummaries","_aotSummaries","_templateOverrides","_isRoot","_rootProviderOverrides","_getTestBedViewEngine","getTestBed","ɵclearOverrides","_assertNotInstantiated","_createCompilerAndModule","moduleAndComponentFactories","_initIfNeeded","errorCompType","compFactory","templateOf","ɵoverrideComponentView","ngZoneInjector","TestBed","entry","rootScopeImports","jit","ɵAPP_ROOT","compilerFactory","createTestingCompiler","overrideProviderImpl","deprecated","dep","depToken","depFlags","Optional","SkipSelf","ɵoverrideProvider","deprecatedBehavior","OverrideComponent","selector","ɵivyEnabled","inject","completer","InjectSetupWrapper","_moduleDef","_addModule","_global$1","beforeEach","ɵangular_packages_core_testing_testing_b","ɵangular_packages_core_testing_testing_c","ɵangular_packages_core_testing_testing_a","withModule","ɵMetadataOverrider","async","asyncTest","asyncFallback","jasmine","err","fakeAsync","fakeAsyncFallback","args","_i","lastProxyZoneSpec","pendingPeriodicTimers","pendingTimers","tick","millis","tickFallback","flush","maxTurns","flushFallback","discardPeriodicTasks","discardPeriodicTasksFallback","__core_private_testing_placeholder__","ɵTestingCompiler","ɵTestingCompilerFactory"],"mappings":"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","sourcesContent":["/**\n * @license Angular v8.1.1\n * (c) 2010-2019 Google LLC. https://angular.io/\n * License: MIT\n */\n\n(function (global, factory) {\n typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@angular/core'), require('@angular/compiler')) :\n typeof define === 'function' && define.amd ? define('@angular/core/testing', ['exports', '@angular/core', '@angular/compiler'], factory) :\n (global = global || self, factory((global.ng = global.ng || {}, global.ng.core = global.ng.core || {}, global.ng.core.testing = {}), global.ng.core, global.ng.compiler));\n}(this, function (exports, core, compiler) { 'use strict';\n\n /**\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 var _global = (typeof window === 'undefined' ? global : window);\n /**\n * Wraps a test function in an asynchronous test zone. The test will automatically\n * complete when all asynchronous calls within this zone are done. Can be used\n * to wrap an {@link inject} call.\n *\n * Example:\n *\n * ```\n * it('...', async(inject([AClass], (object) => {\n * object.doSomething.then(() => {\n * expect(...);\n * })\n * });\n * ```\n *\n *\n */\n function asyncFallback(fn) {\n // If we're running using the Jasmine test framework, adapt to call the 'done'\n // function when asynchronous activity is finished.\n if (_global.jasmine) {\n // Not using an arrow function to preserve context passed from call site\n return function (done) {\n if (!done) {\n // if we run beforeEach in @angular/core/testing/testing_internal then we get no done\n // fake it here and assume sync.\n done = function () { };\n done.fail = function (e) { throw e; };\n }\n runInTestZone(fn, this, done, function (err) {\n if (typeof err === 'string') {\n return done.fail(new Error(err));\n }\n else {\n done.fail(err);\n }\n });\n };\n }\n // Otherwise, return a promise which will resolve when asynchronous activity\n // is finished. This will be correctly consumed by the Mocha framework with\n // it('...', async(myFn)); or can be used in a custom framework.\n // Not using an arrow function to preserve context passed from call site\n return function () {\n var _this = this;\n return new Promise(function (finishCallback, failCallback) {\n runInTestZone(fn, _this, finishCallback, failCallback);\n });\n };\n }\n function runInTestZone(fn, context, finishCallback, failCallback) {\n var currentZone = Zone.current;\n var AsyncTestZoneSpec = Zone['AsyncTestZoneSpec'];\n if (AsyncTestZoneSpec === undefined) {\n throw new Error('AsyncTestZoneSpec is needed for the async() test helper but could not be found. ' +\n 'Please make sure that your environment includes zone.js/dist/async-test.js');\n }\n var ProxyZoneSpec = Zone['ProxyZoneSpec'];\n if (ProxyZoneSpec === undefined) {\n throw new Error('ProxyZoneSpec is needed for the async() test helper but could not be found. ' +\n 'Please make sure that your environment includes zone.js/dist/proxy.js');\n }\n var proxyZoneSpec = ProxyZoneSpec.get();\n ProxyZoneSpec.assertPresent();\n // We need to create the AsyncTestZoneSpec outside the ProxyZone.\n // If we do it in ProxyZone then we will get to infinite recursion.\n var proxyZone = Zone.current.getZoneWith('ProxyZoneSpec');\n var previousDelegate = proxyZoneSpec.getDelegate();\n proxyZone.parent.run(function () {\n var testZoneSpec = new AsyncTestZoneSpec(function () {\n // Need to restore the original zone.\n currentZone.run(function () {\n if (proxyZoneSpec.getDelegate() == testZoneSpec) {\n // Only reset the zone spec if it's sill this one. Otherwise, assume it's OK.\n proxyZoneSpec.setDelegate(previousDelegate);\n }\n finishCallback();\n });\n }, function (error) {\n // Need to restore the original zone.\n currentZone.run(function () {\n if (proxyZoneSpec.getDelegate() == testZoneSpec) {\n // Only reset the zone spec if it's sill this one. Otherwise, assume it's OK.\n proxyZoneSpec.setDelegate(previousDelegate);\n }\n failCallback(error);\n });\n }, 'test');\n proxyZoneSpec.setDelegate(testZoneSpec);\n });\n return Zone.current.runGuarded(fn, context);\n }\n\n /**\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 * Wraps a test function in an asynchronous test zone. The test will automatically\n * complete when all asynchronous calls within this zone are done. Can be used\n * to wrap an {@link inject} call.\n *\n * Example:\n *\n * ```\n * it('...', async(inject([AClass], (object) => {\n * object.doSomething.then(() => {\n * expect(...);\n * })\n * });\n * ```\n *\n * @publicApi\n */\n function async(fn) {\n var _Zone = typeof Zone !== 'undefined' ? Zone : null;\n if (!_Zone) {\n return function () {\n return Promise.reject('Zone is needed for the async() test helper but could not be found. ' +\n 'Please make sure that your environment includes zone.js/dist/zone.js');\n };\n }\n var asyncTest = _Zone && _Zone[_Zone.__symbol__('asyncTest')];\n if (typeof asyncTest === 'function') {\n return asyncTest(fn);\n }\n // not using new version of zone.js\n // TODO @JiaLiPassion, remove this after all library updated to\n // newest version of zone.js(0.8.25)\n return asyncFallback(fn);\n }\n\n /**\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 * Fixture for debugging and testing a component.\n *\n * @publicApi\n */\n var ComponentFixture = /** @class */ (function () {\n function ComponentFixture(componentRef, ngZone, _autoDetect) {\n var _this = this;\n this.componentRef = componentRef;\n this.ngZone = ngZone;\n this._autoDetect = _autoDetect;\n this._isStable = true;\n this._isDestroyed = false;\n this._resolve = null;\n this._promise = null;\n this._onUnstableSubscription = null;\n this._onStableSubscription = null;\n this._onMicrotaskEmptySubscription = null;\n this._onErrorSubscription = null;\n this.changeDetectorRef = componentRef.changeDetectorRef;\n this.elementRef = componentRef.location;\n this.debugElement = core.getDebugNode(this.elementRef.nativeElement);\n this.componentInstance = componentRef.instance;\n this.nativeElement = this.elementRef.nativeElement;\n this.componentRef = componentRef;\n this.ngZone = ngZone;\n if (ngZone) {\n // Create subscriptions outside the NgZone so that the callbacks run oustide\n // of NgZone.\n ngZone.runOutsideAngular(function () {\n _this._onUnstableSubscription =\n ngZone.onUnstable.subscribe({ next: function () { _this._isStable = false; } });\n _this._onMicrotaskEmptySubscription = ngZone.onMicrotaskEmpty.subscribe({\n next: function () {\n if (_this._autoDetect) {\n // Do a change detection run with checkNoChanges set to true to check\n // there are no changes on the second run.\n _this.detectChanges(true);\n }\n }\n });\n _this._onStableSubscription = ngZone.onStable.subscribe({\n next: function () {\n _this._isStable = true;\n // Check whether there is a pending whenStable() completer to resolve.\n if (_this._promise !== null) {\n // If so check whether there are no pending macrotasks before resolving.\n // Do this check in the next tick so that ngZone gets a chance to update the state of\n // pending macrotasks.\n scheduleMicroTask(function () {\n if (!ngZone.hasPendingMacrotasks) {\n if (_this._promise !== null) {\n _this._resolve(true);\n _this._resolve = null;\n _this._promise = null;\n }\n }\n });\n }\n }\n });\n _this._onErrorSubscription =\n ngZone.onError.subscribe({ next: function (error) { throw error; } });\n });\n }\n }\n ComponentFixture.prototype._tick = function (checkNoChanges) {\n this.changeDetectorRef.detectChanges();\n if (checkNoChanges) {\n this.checkNoChanges();\n }\n };\n /**\n * Trigger a change detection cycle for the component.\n */\n ComponentFixture.prototype.detectChanges = function (checkNoChanges) {\n var _this = this;\n if (checkNoChanges === void 0) { checkNoChanges = true; }\n if (this.ngZone != null) {\n // Run the change detection inside the NgZone so that any async tasks as part of the change\n // detection are captured by the zone and can be waited for in isStable.\n this.ngZone.run(function () { _this._tick(checkNoChanges); });\n }\n else {\n // Running without zone. Just do the change detection.\n this._tick(checkNoChanges);\n }\n };\n /**\n * Do a change detection run to make sure there were no changes.\n */\n ComponentFixture.prototype.checkNoChanges = function () { this.changeDetectorRef.checkNoChanges(); };\n /**\n * Set whether the fixture should autodetect changes.\n *\n * Also runs detectChanges once so that any existing change is detected.\n */\n ComponentFixture.prototype.autoDetectChanges = function (autoDetect) {\n if (autoDetect === void 0) { autoDetect = true; }\n if (this.ngZone == null) {\n throw new Error('Cannot call autoDetectChanges when ComponentFixtureNoNgZone is set');\n }\n this._autoDetect = autoDetect;\n this.detectChanges();\n };\n /**\n * Return whether the fixture is currently stable or has async tasks that have not been completed\n * yet.\n */\n ComponentFixture.prototype.isStable = function () { return this._isStable && !this.ngZone.hasPendingMacrotasks; };\n /**\n * Get a promise that resolves when the fixture is stable.\n *\n * This can be used to resume testing after events have triggered asynchronous activity or\n * asynchronous change detection.\n */\n ComponentFixture.prototype.whenStable = function () {\n var _this = this;\n if (this.isStable()) {\n return Promise.resolve(false);\n }\n else if (this._promise !== null) {\n return this._promise;\n }\n else {\n this._promise = new Promise(function (res) { _this._resolve = res; });\n return this._promise;\n }\n };\n ComponentFixture.prototype._getRenderer = function () {\n if (this._renderer === undefined) {\n this._renderer = this.componentRef.injector.get(core.RendererFactory2, null);\n }\n return this._renderer;\n };\n /**\n * Get a promise that resolves when the ui state is stable following animations.\n */\n ComponentFixture.prototype.whenRenderingDone = function () {\n var renderer = this._getRenderer();\n if (renderer && renderer.whenRenderingDone) {\n return renderer.whenRenderingDone();\n }\n return this.whenStable();\n };\n /**\n * Trigger component destruction.\n */\n ComponentFixture.prototype.destroy = function () {\n if (!this._isDestroyed) {\n this.componentRef.destroy();\n if (this._onUnstableSubscription != null) {\n this._onUnstableSubscription.unsubscribe();\n this._onUnstableSubscription = null;\n }\n if (this._onStableSubscription != null) {\n this._onStableSubscription.unsubscribe();\n this._onStableSubscription = null;\n }\n if (this._onMicrotaskEmptySubscription != null) {\n this._onMicrotaskEmptySubscription.unsubscribe();\n this._onMicrotaskEmptySubscription = null;\n }\n if (this._onErrorSubscription != null) {\n this._onErrorSubscription.unsubscribe();\n this._onErrorSubscription = null;\n }\n this._isDestroyed = true;\n }\n };\n return ComponentFixture;\n }());\n function scheduleMicroTask(fn) {\n Zone.current.scheduleMicroTask('scheduleMicrotask', fn);\n }\n\n /**\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 * fakeAsync has been moved to zone.js\n * this file is for fallback in case old version of zone.js is used\n */\n var _Zone = typeof Zone !== 'undefined' ? Zone : null;\n var FakeAsyncTestZoneSpec = _Zone && _Zone['FakeAsyncTestZoneSpec'];\n var ProxyZoneSpec = _Zone && _Zone['ProxyZoneSpec'];\n var _fakeAsyncTestZoneSpec = null;\n /**\n * Clears out the shared fake async zone for a test.\n * To be called in a global `beforeEach`.\n *\n * @publicApi\n */\n function resetFakeAsyncZoneFallback() {\n _fakeAsyncTestZoneSpec = null;\n // in node.js testing we may not have ProxyZoneSpec in which case there is nothing to reset.\n ProxyZoneSpec && ProxyZoneSpec.assertPresent().resetDelegate();\n }\n var _inFakeAsyncCall = false;\n /**\n * Wraps a function to be executed in the fakeAsync zone:\n * - microtasks are manually executed by calling `flushMicrotasks()`,\n * - timers are synchronous, `tick()` simulates the asynchronous passage of time.\n *\n * If there are any pending timers at the end of the function, an exception will be thrown.\n *\n * Can be used to wrap inject() calls.\n *\n * @usageNotes\n * ### Example\n *\n * {@example core/testing/ts/fake_async.ts region='basic'}\n *\n * @param fn\n * @returns The function wrapped to be executed in the fakeAsync zone\n *\n * @publicApi\n */\n function fakeAsyncFallback(fn) {\n // Not using an arrow function to preserve context passed from call site\n return function () {\n var args = [];\n for (var _i = 0; _i < arguments.length; _i++) {\n args[_i] = arguments[_i];\n }\n var proxyZoneSpec = ProxyZoneSpec.assertPresent();\n if (_inFakeAsyncCall) {\n throw new Error('fakeAsync() calls can not be nested');\n }\n _inFakeAsyncCall = true;\n try {\n if (!_fakeAsyncTestZoneSpec) {\n if (proxyZoneSpec.getDelegate() instanceof FakeAsyncTestZoneSpec) {\n throw new Error('fakeAsync() calls can not be nested');\n }\n _fakeAsyncTestZoneSpec = new FakeAsyncTestZoneSpec();\n }\n var res = void 0;\n var lastProxyZoneSpec = proxyZoneSpec.getDelegate();\n proxyZoneSpec.setDelegate(_fakeAsyncTestZoneSpec);\n try {\n res = fn.apply(this, args);\n flushMicrotasksFallback();\n }\n finally {\n proxyZoneSpec.setDelegate(lastProxyZoneSpec);\n }\n if (_fakeAsyncTestZoneSpec.pendingPeriodicTimers.length > 0) {\n throw new Error(_fakeAsyncTestZoneSpec.pendingPeriodicTimers.length + \" \" +\n \"periodic timer(s) still in the queue.\");\n }\n if (_fakeAsyncTestZoneSpec.pendingTimers.length > 0) {\n throw new Error(_fakeAsyncTestZoneSpec.pendingTimers.length + \" timer(s) still in the queue.\");\n }\n return res;\n }\n finally {\n _inFakeAsyncCall = false;\n resetFakeAsyncZoneFallback();\n }\n };\n }\n function _getFakeAsyncZoneSpec() {\n if (_fakeAsyncTestZoneSpec == null) {\n throw new Error('The code should be running in the fakeAsync zone to call this function');\n }\n return _fakeAsyncTestZoneSpec;\n }\n /**\n * Simulates the asynchronous passage of time for the timers in the fakeAsync zone.\n *\n * The microtasks queue is drained at the very start of this function and after any timer callback\n * has been executed.\n *\n * @usageNotes\n * ### Example\n *\n * {@example core/testing/ts/fake_async.ts region='basic'}\n *\n * @publicApi\n */\n function tickFallback(millis) {\n if (millis === void 0) { millis = 0; }\n _getFakeAsyncZoneSpec().tick(millis);\n }\n /**\n * Simulates the asynchronous passage of time for the timers in the fakeAsync zone by\n * draining the macrotask queue until it is empty. The returned value is the milliseconds\n * of time that would have been elapsed.\n *\n * @param maxTurns\n * @returns The simulated time elapsed, in millis.\n *\n * @publicApi\n */\n function flushFallback(maxTurns) {\n return _getFakeAsyncZoneSpec().flush(maxTurns);\n }\n /**\n * Discard all remaining periodic tasks.\n *\n * @publicApi\n */\n function discardPeriodicTasksFallback() {\n var zoneSpec = _getFakeAsyncZoneSpec();\n zoneSpec.pendingPeriodicTimers.length = 0;\n }\n /**\n * Flush any pending microtasks.\n *\n * @publicApi\n */\n function flushMicrotasksFallback() {\n _getFakeAsyncZoneSpec().flushMicrotasks();\n }\n\n /**\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 var _Zone$1 = typeof Zone !== 'undefined' ? Zone : null;\n var fakeAsyncTestModule = _Zone$1 && _Zone$1[_Zone$1.__symbol__('fakeAsyncTest')];\n /**\n * Clears out the shared fake async zone for a test.\n * To be called in a global `beforeEach`.\n *\n * @publicApi\n */\n function resetFakeAsyncZone() {\n if (fakeAsyncTestModule) {\n return fakeAsyncTestModule.resetFakeAsyncZone();\n }\n else {\n return resetFakeAsyncZoneFallback();\n }\n }\n /**\n * Wraps a function to be executed in the fakeAsync zone:\n * - microtasks are manually executed by calling `flushMicrotasks()`,\n * - timers are synchronous, `tick()` simulates the asynchronous passage of time.\n *\n * If there are any pending timers at the end of the function, an exception will be thrown.\n *\n * Can be used to wrap inject() calls.\n *\n * @usageNotes\n * ### Example\n *\n * {@example core/testing/ts/fake_async.ts region='basic'}\n *\n * @param fn\n * @returns The function wrapped to be executed in the fakeAsync zone\n *\n * @publicApi\n */\n function fakeAsync(fn) {\n if (fakeAsyncTestModule) {\n return fakeAsyncTestModule.fakeAsync(fn);\n }\n else {\n return fakeAsyncFallback(fn);\n }\n }\n /**\n * Simulates the asynchronous passage of time for the timers in the fakeAsync zone.\n *\n * The microtasks queue is drained at the very start of this function and after any timer callback\n * has been executed.\n *\n * @usageNotes\n * ### Example\n *\n * {@example core/testing/ts/fake_async.ts region='basic'}\n *\n * @publicApi\n */\n function tick(millis) {\n if (millis === void 0) { millis = 0; }\n if (fakeAsyncTestModule) {\n return fakeAsyncTestModule.tick(millis);\n }\n else {\n return tickFallback(millis);\n }\n }\n /**\n * Simulates the asynchronous passage of time for the timers in the fakeAsync zone by\n * draining the macrotask queue until it is empty. The returned value is the milliseconds\n * of time that would have been elapsed.\n *\n * @param maxTurns\n * @returns The simulated time elapsed, in millis.\n *\n * @publicApi\n */\n function flush(maxTurns) {\n if (fakeAsyncTestModule) {\n return fakeAsyncTestModule.flush(maxTurns);\n }\n else {\n return flushFallback(maxTurns);\n }\n }\n /**\n * Discard all remaining periodic tasks.\n *\n * @publicApi\n */\n function discardPeriodicTasks() {\n if (fakeAsyncTestModule) {\n return fakeAsyncTestModule.discardPeriodicTasks();\n }\n else {\n discardPeriodicTasksFallback();\n }\n }\n /**\n * Flush any pending microtasks.\n *\n * @publicApi\n */\n function flushMicrotasks() {\n if (fakeAsyncTestModule) {\n return fakeAsyncTestModule.flushMicrotasks();\n }\n else {\n return flushMicrotasksFallback();\n }\n }\n\n /*! *****************************************************************************\r\n Copyright (c) Microsoft Corporation. All rights reserved.\r\n Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use\r\n this file except in compliance with the License. You may obtain a copy of the\r\n License at http://www.apache.org/licenses/LICENSE-2.0\r\n\r\n THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\r\n KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED\r\n WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,\r\n MERCHANTABLITY OR NON-INFRINGEMENT.\r\n\r\n See the Apache Version 2.0 License for specific language governing permissions\r\n and limitations under the License.\r\n ***************************************************************************** */\r\n /* global Reflect, Promise */\r\n\r\n var extendStatics = function(d, b) {\r\n extendStatics = Object.setPrototypeOf ||\r\n ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\r\n return extendStatics(d, b);\r\n };\r\n\r\n function __extends(d, b) {\r\n extendStatics(d, b);\r\n function __() { this.constructor = d; }\r\n d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n }\r\n\r\n function __decorate(decorators, target, key, desc) {\r\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n }\r\n\r\n function __awaiter(thisArg, _arguments, P, generator) {\r\n return new (P || (P = Promise))(function (resolve, reject) {\r\n function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }\r\n step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n });\r\n }\r\n\r\n function __generator(thisArg, body) {\r\n var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r\n return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n function verb(n) { return function (v) { return step([n, v]); }; }\r\n function step(op) {\r\n if (f) throw new TypeError(\"Generator is already executing.\");\r\n while (_) try {\r\n if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\r\n if (y = 0, t) op = [op[0] & 2, t.value];\r\n switch (op[0]) {\r\n case 0: case 1: t = op; break;\r\n case 4: _.label++; return { value: op[1], done: false };\r\n case 5: _.label++; y = op[1]; op = [0]; continue;\r\n case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n default:\r\n if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n if (t[2]) _.ops.pop();\r\n _.trys.pop(); continue;\r\n }\r\n op = body.call(thisArg, _);\r\n } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n }\r\n }\r\n\r\n function __values(o) {\r\n var m = typeof Symbol === \"function\" && o[Symbol.iterator], i = 0;\r\n if (m) return m.call(o);\r\n return {\r\n next: function () {\r\n if (o && i >= o.length) o = void 0;\r\n return { value: o && o[i++], done: !o };\r\n }\r\n };\r\n }\r\n\r\n function __read(o, n) {\r\n var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n if (!m) return o;\r\n var i = m.call(o), r, ar = [], e;\r\n try {\r\n while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n }\r\n catch (error) { e = { error: error }; }\r\n finally {\r\n try {\r\n if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n }\r\n finally { if (e) throw e.error; }\r\n }\r\n return ar;\r\n }\r\n\r\n function __spread() {\r\n for (var ar = [], i = 0; i < arguments.length; i++)\r\n ar = ar.concat(__read(arguments[i]));\r\n return ar;\r\n }\n\n /**\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 * Injectable completer that allows signaling completion of an asynchronous test. Used internally.\n */\n var AsyncTestCompleter = /** @class */ (function () {\n function AsyncTestCompleter() {\n var _this = this;\n this._promise = new Promise(function (res, rej) {\n _this._resolve = res;\n _this._reject = rej;\n });\n }\n AsyncTestCompleter.prototype.done = function (value) { this._resolve(value); };\n AsyncTestCompleter.prototype.fail = function (error, stackTrace) { this._reject(error); };\n Object.defineProperty(AsyncTestCompleter.prototype, \"promise\", {\n get: function () { return this._promise; },\n enumerable: true,\n configurable: true\n });\n return AsyncTestCompleter;\n }());\n\n /**\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 * An abstract class for inserting the root test component element in a platform independent way.\n *\n * @publicApi\n */\n var TestComponentRenderer = /** @class */ (function () {\n function TestComponentRenderer() {\n }\n TestComponentRenderer.prototype.insertRootElement = function (rootElementId) { };\n return TestComponentRenderer;\n }());\n /**\n * @publicApi\n */\n var ComponentFixtureAutoDetect = new core.InjectionToken('ComponentFixtureAutoDetect');\n /**\n * @publicApi\n */\n var ComponentFixtureNoNgZone = new core.InjectionToken('ComponentFixtureNoNgZone');\n\n /**\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 * Used to resolve resource URLs on `@Component` when used with JIT compilation.\n *\n * Example:\n * ```\n * @Component({\n * selector: 'my-comp',\n * templateUrl: 'my-comp.html', // This requires asynchronous resolution\n * })\n * class MyComponent{\n * }\n *\n * // Calling `renderComponent` will fail because `renderComponent` is a synchronous process\n * // and `MyComponent`'s `@Component.templateUrl` needs to be resolved asynchronously.\n *\n * // Calling `resolveComponentResources()` will resolve `@Component.templateUrl` into\n * // `@Component.template`, which allows `renderComponent` to proceed in a synchronous manner.\n *\n * // Use browser's `fetch()` function as the default resource resolution strategy.\n * resolveComponentResources(fetch).then(() => {\n * // After resolution all URLs have been converted into `template` strings.\n * renderComponent(MyComponent);\n * });\n *\n * ```\n *\n * NOTE: In AOT the resolution happens during compilation, and so there should be no need\n * to call this method outside JIT mode.\n *\n * @param resourceResolver a function which is responsible for returning a `Promise` to the\n * contents of the resolved URL. Browser's `fetch()` method is a good default implementation.\n */\n function resolveComponentResources(resourceResolver) {\n // Store all promises which are fetching the resources.\n var componentResolved = [];\n // Cache so that we don't fetch the same resource more than once.\n var urlMap = new Map();\n function cachedResourceResolve(url) {\n var promise = urlMap.get(url);\n if (!promise) {\n var resp = resourceResolver(url);\n urlMap.set(url, promise = resp.then(unwrapResponse));\n }\n return promise;\n }\n componentResourceResolutionQueue.forEach(function (component, type) {\n var promises = [];\n if (component.templateUrl) {\n promises.push(cachedResourceResolve(component.templateUrl).then(function (template) {\n component.template = template;\n }));\n }\n var styleUrls = component.styleUrls;\n var styles = component.styles || (component.styles = []);\n var styleOffset = component.styles.length;\n styleUrls && styleUrls.forEach(function (styleUrl, index) {\n styles.push(''); // pre-allocate array.\n promises.push(cachedResourceResolve(styleUrl).then(function (style) {\n styles[styleOffset + index] = style;\n styleUrls.splice(styleUrls.indexOf(styleUrl), 1);\n if (styleUrls.length == 0) {\n component.styleUrls = undefined;\n }\n }));\n });\n var fullyResolved = Promise.all(promises).then(function () { return componentDefResolved(type); });\n componentResolved.push(fullyResolved);\n });\n clearResolutionOfComponentResourcesQueue();\n return Promise.all(componentResolved).then(function () { return undefined; });\n }\n var componentResourceResolutionQueue = new Map();\n // Track when existing ngComponentDef for a Type is waiting on resources.\n var componentDefPendingResolution = new Set();\n function isComponentDefPendingResolution(type) {\n return componentDefPendingResolution.has(type);\n }\n function clearResolutionOfComponentResourcesQueue() {\n var old = componentResourceResolutionQueue;\n componentResourceResolutionQueue = new Map();\n return old;\n }\n function restoreComponentResolutionQueue(queue) {\n componentDefPendingResolution.clear();\n queue.forEach(function (_, type) { return componentDefPendingResolution.add(type); });\n componentResourceResolutionQueue = queue;\n }\n function unwrapResponse(response) {\n return typeof response == 'string' ? response : response.text();\n }\n function componentDefResolved(type) {\n componentDefPendingResolution.delete(type);\n }\n\n /**\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 var _nextReferenceId = 0;\n var MetadataOverrider = /** @class */ (function () {\n function MetadataOverrider() {\n this._references = new Map();\n }\n /**\n * Creates a new instance for the given metadata class\n * based on an old instance and overrides.\n */\n MetadataOverrider.prototype.overrideMetadata = function (metadataClass, oldMetadata, override) {\n var props = {};\n if (oldMetadata) {\n _valueProps(oldMetadata).forEach(function (prop) { return props[prop] = oldMetadata[prop]; });\n }\n if (override.set) {\n if (override.remove || override.add) {\n throw new Error(\"Cannot set and add/remove \" + core.ɵstringify(metadataClass) + \" at the same time!\");\n }\n setMetadata(props, override.set);\n }\n if (override.remove) {\n removeMetadata(props, override.remove, this._references);\n }\n if (override.add) {\n addMetadata(props, override.add);\n }\n return new metadataClass(props);\n };\n return MetadataOverrider;\n }());\n function removeMetadata(metadata, remove, references) {\n var removeObjects = new Set();\n var _loop_1 = function (prop) {\n var removeValue = remove[prop];\n if (removeValue instanceof Array) {\n removeValue.forEach(function (value) { removeObjects.add(_propHashKey(prop, value, references)); });\n }\n else {\n removeObjects.add(_propHashKey(prop, removeValue, references));\n }\n };\n for (var prop in remove) {\n _loop_1(prop);\n }\n var _loop_2 = function (prop) {\n var propValue = metadata[prop];\n if (propValue instanceof Array) {\n metadata[prop] = propValue.filter(function (value) { return !removeObjects.has(_propHashKey(prop, value, references)); });\n }\n else {\n if (removeObjects.has(_propHashKey(prop, propValue, references))) {\n metadata[prop] = undefined;\n }\n }\n };\n for (var prop in metadata) {\n _loop_2(prop);\n }\n }\n function addMetadata(metadata, add) {\n for (var prop in add) {\n var addValue = add[prop];\n var propValue = metadata[prop];\n if (propValue != null && propValue instanceof Array) {\n metadata[prop] = propValue.concat(addValue);\n }\n else {\n metadata[prop] = addValue;\n }\n }\n }\n function setMetadata(metadata, set) {\n for (var prop in set) {\n metadata[prop] = set[prop];\n }\n }\n function _propHashKey(propName, propValue, references) {\n var replacer = function (key, value) {\n if (typeof value === 'function') {\n value = _serializeReference(value, references);\n }\n return value;\n };\n return propName + \":\" + JSON.stringify(propValue, replacer);\n }\n function _serializeReference(ref, references) {\n var id = references.get(ref);\n if (!id) {\n id = \"\" + core.ɵstringify(ref) + _nextReferenceId++;\n references.set(ref, id);\n }\n return id;\n }\n function _valueProps(obj) {\n var props = [];\n // regular public props\n Object.keys(obj).forEach(function (prop) {\n if (!prop.startsWith('_')) {\n props.push(prop);\n }\n });\n // getters\n var proto = obj;\n while (proto = Object.getPrototypeOf(proto)) {\n Object.keys(proto).forEach(function (protoProp) {\n var desc = Object.getOwnPropertyDescriptor(proto, protoProp);\n if (!protoProp.startsWith('_') && desc && 'get' in desc) {\n props.push(protoProp);\n }\n });\n }\n return props;\n }\n\n /**\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 var reflection = new core.ɵReflectionCapabilities();\n /**\n * Allows to override ivy metadata for tests (via the `TestBed`).\n */\n var OverrideResolver = /** @class */ (function () {\n function OverrideResolver() {\n this.overrides = new Map();\n this.resolved = new Map();\n }\n OverrideResolver.prototype.addOverride = function (type, override) {\n var overrides = this.overrides.get(type) || [];\n overrides.push(override);\n this.overrides.set(type, overrides);\n this.resolved.delete(type);\n };\n OverrideResolver.prototype.setOverrides = function (overrides) {\n var _this = this;\n this.overrides.clear();\n overrides.forEach(function (_a) {\n var _b = __read(_a, 2), type = _b[0], override = _b[1];\n _this.addOverride(type, override);\n });\n };\n OverrideResolver.prototype.getAnnotation = function (type) {\n var annotations = reflection.annotations(type);\n // Try to find the nearest known Type annotation and make sure that this annotation is an\n // instance of the type we are looking for, so we can use it for resolution. Note: there might\n // be multiple known annotations found due to the fact that Components can extend Directives (so\n // both Directive and Component annotations would be present), so we always check if the known\n // annotation has the right type.\n for (var i = annotations.length - 1; i >= 0; i--) {\n var annotation = annotations[i];\n var isKnownType = annotation instanceof core.Directive || annotation instanceof core.Component ||\n annotation instanceof core.Pipe || annotation instanceof core.NgModule;\n if (isKnownType) {\n return annotation instanceof this.type ? annotation : null;\n }\n }\n return null;\n };\n OverrideResolver.prototype.resolve = function (type) {\n var _this = this;\n var resolved = this.resolved.get(type) || null;\n if (!resolved) {\n resolved = this.getAnnotation(type);\n if (resolved) {\n var overrides = this.overrides.get(type);\n if (overrides) {\n var overrider_1 = new MetadataOverrider();\n overrides.forEach(function (override) {\n resolved = overrider_1.overrideMetadata(_this.type, resolved, override);\n });\n }\n }\n this.resolved.set(type, resolved);\n }\n return resolved;\n };\n return OverrideResolver;\n }());\n var DirectiveResolver = /** @class */ (function (_super) {\n __extends(DirectiveResolver, _super);\n function DirectiveResolver() {\n return _super !== null && _super.apply(this, arguments) || this;\n }\n Object.defineProperty(DirectiveResolver.prototype, \"type\", {\n get: function () { return core.Directive; },\n enumerable: true,\n configurable: true\n });\n return DirectiveResolver;\n }(OverrideResolver));\n var ComponentResolver = /** @class */ (function (_super) {\n __extends(ComponentResolver, _super);\n function ComponentResolver() {\n return _super !== null && _super.apply(this, arguments) || this;\n }\n Object.defineProperty(ComponentResolver.prototype, \"type\", {\n get: function () { return core.Component; },\n enumerable: true,\n configurable: true\n });\n return ComponentResolver;\n }(OverrideResolver));\n var PipeResolver = /** @class */ (function (_super) {\n __extends(PipeResolver, _super);\n function PipeResolver() {\n return _super !== null && _super.apply(this, arguments) || this;\n }\n Object.defineProperty(PipeResolver.prototype, \"type\", {\n get: function () { return core.Pipe; },\n enumerable: true,\n configurable: true\n });\n return PipeResolver;\n }(OverrideResolver));\n var NgModuleResolver = /** @class */ (function (_super) {\n __extends(NgModuleResolver, _super);\n function NgModuleResolver() {\n return _super !== null && _super.apply(this, arguments) || this;\n }\n Object.defineProperty(NgModuleResolver.prototype, \"type\", {\n get: function () { return core.NgModule; },\n enumerable: true,\n configurable: true\n });\n return NgModuleResolver;\n }(OverrideResolver));\n\n /**\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 var TestingModuleOverride;\n (function (TestingModuleOverride) {\n TestingModuleOverride[TestingModuleOverride[\"DECLARATION\"] = 0] = \"DECLARATION\";\n TestingModuleOverride[TestingModuleOverride[\"OVERRIDE_TEMPLATE\"] = 1] = \"OVERRIDE_TEMPLATE\";\n })(TestingModuleOverride || (TestingModuleOverride = {}));\n function isTestingModuleOverride(value) {\n return value === TestingModuleOverride.DECLARATION ||\n value === TestingModuleOverride.OVERRIDE_TEMPLATE;\n }\n var R3TestBedCompiler = /** @class */ (function () {\n function R3TestBedCompiler(platform, additionalModuleTypes) {\n this.platform = platform;\n this.additionalModuleTypes = additionalModuleTypes;\n this.originalComponentResolutionQueue = null;\n // Testing module configuration\n this.declarations = [];\n this.imports = [];\n this.providers = [];\n this.schemas = [];\n // Queues of components/directives/pipes that should be recompiled.\n this.pendingComponents = new Set();\n this.pendingDirectives = new Set();\n this.pendingPipes = new Set();\n // Keep track of all components and directives, so we can patch Providers onto defs later.\n this.seenComponents = new Set();\n this.seenDirectives = new Set();\n // Store resolved styles for Components that have template overrides present and `styleUrls`\n // defined at the same time.\n this.existingComponentStyles = new Map();\n this.resolvers = initResolvers();\n this.componentToModuleScope = new Map();\n // Map that keeps initial version of component/directive/pipe defs in case\n // we compile a Type again, thus overriding respective static fields. This is\n // required to make sure we restore defs to their initial states between test runs\n // TODO: we should support the case with multiple defs on a type\n this.initialNgDefs = new Map();\n // Array that keeps cleanup operations for initial versions of component/directive/pipe/module\n // defs in case TestBed makes changes to the originals.\n this.defCleanupOps = [];\n this._injector = null;\n this.compilerProviders = null;\n this.providerOverrides = [];\n this.rootProviderOverrides = [];\n this.providerOverridesByToken = new Map();\n this.moduleProvidersOverridden = new Set();\n this.testModuleRef = null;\n var DynamicTestModule = /** @class */ (function () {\n function DynamicTestModule() {\n }\n return DynamicTestModule;\n }());\n this.testModuleType = DynamicTestModule;\n }\n R3TestBedCompiler.prototype.setCompilerProviders = function (providers) {\n this.compilerProviders = providers;\n this._injector = null;\n };\n R3TestBedCompiler.prototype.configureTestingModule = function (moduleDef) {\n var _a, _b, _c, _d;\n // Enqueue any compilation tasks for the directly declared component.\n if (moduleDef.declarations !== undefined) {\n this.queueTypeArray(moduleDef.declarations, TestingModuleOverride.DECLARATION);\n (_a = this.declarations).push.apply(_a, __spread(moduleDef.declarations));\n }\n // Enqueue any compilation tasks for imported modules.\n if (moduleDef.imports !== undefined) {\n this.queueTypesFromModulesArray(moduleDef.imports);\n (_b = this.imports).push.apply(_b, __spread(moduleDef.imports));\n }\n if (moduleDef.providers !== undefined) {\n (_c = this.providers).push.apply(_c, __spread(moduleDef.providers));\n }\n if (moduleDef.schemas !== undefined) {\n (_d = this.schemas).push.apply(_d, __spread(moduleDef.schemas));\n }\n };\n R3TestBedCompiler.prototype.overrideModule = function (ngModule, override) {\n // Compile the module right away.\n this.resolvers.module.addOverride(ngModule, override);\n var metadata = this.resolvers.module.resolve(ngModule);\n if (metadata === null) {\n throw new Error(ngModule.name + \" is not an @NgModule or is missing metadata\");\n }\n this.recompileNgModule(ngModule);\n // At this point, the module has a valid .ngModuleDef, but the override may have introduced\n // new declarations or imported modules. Ingest any possible new types and add them to the\n // current queue.\n this.queueTypesFromModulesArray([ngModule]);\n };\n R3TestBedCompiler.prototype.overrideComponent = function (component, override) {\n this.resolvers.component.addOverride(component, override);\n this.pendingComponents.add(component);\n };\n R3TestBedCompiler.prototype.overrideDirective = function (directive, override) {\n this.resolvers.directive.addOverride(directive, override);\n this.pendingDirectives.add(directive);\n };\n R3TestBedCompiler.prototype.overridePipe = function (pipe, override) {\n this.resolvers.pipe.addOverride(pipe, override);\n this.pendingPipes.add(pipe);\n };\n R3TestBedCompiler.prototype.overrideProvider = function (token, provider) {\n var providerDef = provider.useFactory ?\n {\n provide: token,\n useFactory: provider.useFactory,\n deps: provider.deps || [],\n multi: provider.multi,\n } :\n { provide: token, useValue: provider.useValue, multi: provider.multi };\n var injectableDef;\n var isRoot = (typeof token !== 'string' && (injectableDef = core.ɵgetInjectableDef(token)) &&\n injectableDef.providedIn === 'root');\n var overridesBucket = isRoot ? this.rootProviderOverrides : this.providerOverrides;\n overridesBucket.push(providerDef);\n // Keep overrides grouped by token as well for fast lookups using token\n this.providerOverridesByToken.set(token, providerDef);\n };\n R3TestBedCompiler.prototype.overrideTemplateUsingTestingModule = function (type, template) {\n var _this = this;\n var def = type[core.ɵNG_COMPONENT_DEF];\n var hasStyleUrls = function () {\n var metadata = _this.resolvers.component.resolve(type);\n return !!metadata.styleUrls && metadata.styleUrls.length > 0;\n };\n var overrideStyleUrls = !!def && !isComponentDefPendingResolution(type) && hasStyleUrls();\n // In Ivy, compiling a component does not require knowing the module providing the\n // component's scope, so overrideTemplateUsingTestingModule can be implemented purely via\n // overrideComponent. Important: overriding template requires full Component re-compilation,\n // which may fail in case styleUrls are also present (thus Component is considered as required\n // resolution). In order to avoid this, we preemptively set styleUrls to an empty array,\n // preserve current styles available on Component def and restore styles back once compilation\n // is complete.\n var override = overrideStyleUrls ? { template: template, styles: [], styleUrls: [] } : { template: template };\n this.overrideComponent(type, { set: override });\n if (overrideStyleUrls && def.styles && def.styles.length > 0) {\n this.existingComponentStyles.set(type, def.styles);\n }\n // Set the component's scope to be the testing module.\n this.componentToModuleScope.set(type, TestingModuleOverride.OVERRIDE_TEMPLATE);\n };\n R3TestBedCompiler.prototype.compileComponents = function () {\n return __awaiter(this, void 0, void 0, function () {\n var needsAsyncResources, resourceLoader_1, resolver;\n var _this = this;\n return __generator(this, function (_a) {\n switch (_a.label) {\n case 0:\n this.clearComponentResolutionQueue();\n needsAsyncResources = this.compileTypesSync();\n if (!needsAsyncResources) return [3 /*break*/, 2];\n resolver = function (url) {\n if (!resourceLoader_1) {\n resourceLoader_1 = _this.injector.get(compiler.ResourceLoader);\n }\n return Promise.resolve(resourceLoader_1.get(url));\n };\n return [4 /*yield*/, resolveComponentResources(resolver)];\n case 1:\n _a.sent();\n _a.label = 2;\n case 2: return [2 /*return*/];\n }\n });\n });\n };\n R3TestBedCompiler.prototype.finalize = function () {\n // One last compile\n this.compileTypesSync();\n // Create the testing module itself.\n this.compileTestModule();\n this.applyTransitiveScopes();\n this.applyProviderOverrides();\n // Patch previously stored `styles` Component values (taken from ngComponentDef), in case these\n // Components have `styleUrls` fields defined and template override was requested.\n this.patchComponentsWithExistingStyles();\n // Clear the componentToModuleScope map, so that future compilations don't reset the scope of\n // every component.\n this.componentToModuleScope.clear();\n var parentInjector = this.platform.injector;\n this.testModuleRef = new core.ɵRender3NgModuleRef(this.testModuleType, parentInjector);\n // Set the locale ID, it can be overridden for the tests\n var localeId = this.testModuleRef.injector.get(core.LOCALE_ID, core.ɵDEFAULT_LOCALE_ID);\n core.ɵsetLocaleId(localeId);\n // ApplicationInitStatus.runInitializers() is marked @internal to core.\n // Cast it to any before accessing it.\n this.testModuleRef.injector.get(core.ApplicationInitStatus).runInitializers();\n return this.testModuleRef;\n };\n /**\n * @internal\n */\n R3TestBedCompiler.prototype._compileNgModuleSync = function (moduleType) {\n this.queueTypesFromModulesArray([moduleType]);\n this.compileTypesSync();\n this.applyProviderOverrides();\n this.applyProviderOverridesToModule(moduleType);\n this.applyTransitiveScopes();\n };\n /**\n * @internal\n */\n R3TestBedCompiler.prototype._compileNgModuleAsync = function (moduleType) {\n return __awaiter(this, void 0, void 0, function () {\n return __generator(this, function (_a) {\n switch (_a.label) {\n case 0:\n this.queueTypesFromModulesArray([moduleType]);\n return [4 /*yield*/, this.compileComponents()];\n case 1:\n _a.sent();\n this.applyProviderOverrides();\n this.applyProviderOverridesToModule(moduleType);\n this.applyTransitiveScopes();\n return [2 /*return*/];\n }\n });\n });\n };\n /**\n * @internal\n */\n R3TestBedCompiler.prototype._getModuleResolver = function () { return this.resolvers.module; };\n /**\n * @internal\n */\n R3TestBedCompiler.prototype._getComponentFactories = function (moduleType) {\n var _this = this;\n return maybeUnwrapFn(moduleType.ngModuleDef.declarations).reduce(function (factories, declaration) {\n var componentDef = declaration.ngComponentDef;\n componentDef && factories.push(new core.ɵRender3ComponentFactory(componentDef, _this.testModuleRef));\n return factories;\n }, []);\n };\n R3TestBedCompiler.prototype.compileTypesSync = function () {\n var _this = this;\n // Compile all queued components, directives, pipes.\n var needsAsyncResources = false;\n this.pendingComponents.forEach(function (declaration) {\n needsAsyncResources = needsAsyncResources || isComponentDefPendingResolution(declaration);\n var metadata = _this.resolvers.component.resolve(declaration);\n _this.maybeStoreNgDef(core.ɵNG_COMPONENT_DEF, declaration);\n core.ɵcompileComponent(declaration, metadata);\n });\n this.pendingComponents.clear();\n this.pendingDirectives.forEach(function (declaration) {\n var metadata = _this.resolvers.directive.resolve(declaration);\n _this.maybeStoreNgDef(core.ɵNG_DIRECTIVE_DEF, declaration);\n core.ɵcompileDirective(declaration, metadata);\n });\n this.pendingDirectives.clear();\n this.pendingPipes.forEach(function (declaration) {\n var metadata = _this.resolvers.pipe.resolve(declaration);\n _this.maybeStoreNgDef(core.ɵNG_PIPE_DEF, declaration);\n core.ɵcompilePipe(declaration, metadata);\n });\n this.pendingPipes.clear();\n return needsAsyncResources;\n };\n R3TestBedCompiler.prototype.applyTransitiveScopes = function () {\n var _this = this;\n var moduleToScope = new Map();\n var getScopeOfModule = function (moduleType) {\n if (!moduleToScope.has(moduleType)) {\n var realType = isTestingModuleOverride(moduleType) ? _this.testModuleType : moduleType;\n moduleToScope.set(moduleType, core.ɵtransitiveScopesFor(realType));\n }\n return moduleToScope.get(moduleType);\n };\n this.componentToModuleScope.forEach(function (moduleType, componentType) {\n var moduleScope = getScopeOfModule(moduleType);\n _this.storeFieldOfDefOnType(componentType, core.ɵNG_COMPONENT_DEF, 'directiveDefs');\n _this.storeFieldOfDefOnType(componentType, core.ɵNG_COMPONENT_DEF, 'pipeDefs');\n core.ɵpatchComponentDefWithScope(componentType.ngComponentDef, moduleScope);\n });\n this.componentToModuleScope.clear();\n };\n R3TestBedCompiler.prototype.applyProviderOverrides = function () {\n var _this = this;\n var maybeApplyOverrides = function (field) { return function (type) {\n var resolver = field === core.ɵNG_COMPONENT_DEF ? _this.resolvers.component : _this.resolvers.directive;\n var metadata = resolver.resolve(type);\n if (_this.hasProviderOverrides(metadata.providers)) {\n _this.patchDefWithProviderOverrides(type, field);\n }\n }; };\n this.seenComponents.forEach(maybeApplyOverrides(core.ɵNG_COMPONENT_DEF));\n this.seenDirectives.forEach(maybeApplyOverrides(core.ɵNG_DIRECTIVE_DEF));\n this.seenComponents.clear();\n this.seenDirectives.clear();\n };\n R3TestBedCompiler.prototype.applyProviderOverridesToModule = function (moduleType) {\n var e_1, _a;\n if (this.moduleProvidersOverridden.has(moduleType)) {\n return;\n }\n this.moduleProvidersOverridden.add(moduleType);\n var injectorDef = moduleType[core.ɵNG_INJECTOR_DEF];\n if (this.providerOverridesByToken.size > 0) {\n if (this.hasProviderOverrides(injectorDef.providers)) {\n this.maybeStoreNgDef(core.ɵNG_INJECTOR_DEF, moduleType);\n this.storeFieldOfDefOnType(moduleType, core.ɵNG_INJECTOR_DEF, 'providers');\n injectorDef.providers = this.getOverriddenProviders(injectorDef.providers);\n }\n // Apply provider overrides to imported modules recursively\n var moduleDef = moduleType[core.ɵNG_MODULE_DEF];\n try {\n for (var _b = __values(moduleDef.imports), _c = _b.next(); !_c.done; _c = _b.next()) {\n var importType = _c.value;\n this.applyProviderOverridesToModule(importType);\n }\n }\n catch (e_1_1) { e_1 = { error: e_1_1 }; }\n finally {\n try {\n if (_c && !_c.done && (_a = _b.return)) _a.call(_b);\n }\n finally { if (e_1) throw e_1.error; }\n }\n }\n };\n R3TestBedCompiler.prototype.patchComponentsWithExistingStyles = function () {\n this.existingComponentStyles.forEach(function (styles, type) { return type[core.ɵNG_COMPONENT_DEF].styles = styles; });\n this.existingComponentStyles.clear();\n };\n R3TestBedCompiler.prototype.queueTypeArray = function (arr, moduleType) {\n var e_2, _a;\n try {\n for (var arr_1 = __values(arr), arr_1_1 = arr_1.next(); !arr_1_1.done; arr_1_1 = arr_1.next()) {\n var value = arr_1_1.value;\n if (Array.isArray(value)) {\n this.queueTypeArray(value, moduleType);\n }\n else {\n this.queueType(value, moduleType);\n }\n }\n }\n catch (e_2_1) { e_2 = { error: e_2_1 }; }\n finally {\n try {\n if (arr_1_1 && !arr_1_1.done && (_a = arr_1.return)) _a.call(arr_1);\n }\n finally { if (e_2) throw e_2.error; }\n }\n };\n R3TestBedCompiler.prototype.recompileNgModule = function (ngModule) {\n var metadata = this.resolvers.module.resolve(ngModule);\n if (metadata === null) {\n throw new Error(\"Unable to resolve metadata for NgModule: \" + ngModule.name);\n }\n // Cache the initial ngModuleDef as it will be overwritten.\n this.maybeStoreNgDef(core.ɵNG_MODULE_DEF, ngModule);\n this.maybeStoreNgDef(core.ɵNG_INJECTOR_DEF, ngModule);\n core.ɵcompileNgModuleDefs(ngModule, metadata);\n };\n R3TestBedCompiler.prototype.queueType = function (type, moduleType) {\n var component = this.resolvers.component.resolve(type);\n if (component) {\n // Check whether a give Type has respective NG def (ngComponentDef) and compile if def is\n // missing. That might happen in case a class without any Angular decorators extends another\n // class where Component/Directive/Pipe decorator is defined.\n if (isComponentDefPendingResolution(type) || !type.hasOwnProperty(core.ɵNG_COMPONENT_DEF)) {\n this.pendingComponents.add(type);\n }\n this.seenComponents.add(type);\n // Keep track of the module which declares this component, so later the component's scope\n // can be set correctly. If the component has already been recorded here, then one of several\n // cases is true:\n // * the module containing the component was imported multiple times (common).\n // * the component is declared in multiple modules (which is an error).\n // * the component was in 'declarations' of the testing module, and also in an imported module\n // in which case the module scope will be TestingModuleOverride.DECLARATION.\n // * overrideTemplateUsingTestingModule was called for the component in which case the module\n // scope will be TestingModuleOverride.OVERRIDE_TEMPLATE.\n //\n // If the component was previously in the testing module's 'declarations' (meaning the\n // current value is TestingModuleOverride.DECLARATION), then `moduleType` is the component's\n // real module, which was imported. This pattern is understood to mean that the component\n // should use its original scope, but that the testing module should also contain the\n // component in its scope.\n if (!this.componentToModuleScope.has(type) ||\n this.componentToModuleScope.get(type) === TestingModuleOverride.DECLARATION) {\n this.componentToModuleScope.set(type, moduleType);\n }\n return;\n }\n var directive = this.resolvers.directive.resolve(type);\n if (directive) {\n if (!type.hasOwnProperty(core.ɵNG_DIRECTIVE_DEF)) {\n this.pendingDirectives.add(type);\n }\n this.seenDirectives.add(type);\n return;\n }\n var pipe = this.resolvers.pipe.resolve(type);\n if (pipe && !type.hasOwnProperty(core.ɵNG_PIPE_DEF)) {\n this.pendingPipes.add(type);\n return;\n }\n };\n R3TestBedCompiler.prototype.queueTypesFromModulesArray = function (arr) {\n var e_3, _a;\n try {\n for (var arr_2 = __values(arr), arr_2_1 = arr_2.next(); !arr_2_1.done; arr_2_1 = arr_2.next()) {\n var value = arr_2_1.value;\n if (Array.isArray(value)) {\n this.queueTypesFromModulesArray(value);\n }\n else if (hasNgModuleDef(value)) {\n var def = value.ngModuleDef;\n // Look through declarations, imports, and exports, and queue everything found there.\n this.queueTypeArray(maybeUnwrapFn(def.declarations), value);\n this.queueTypesFromModulesArray(maybeUnwrapFn(def.imports));\n this.queueTypesFromModulesArray(maybeUnwrapFn(def.exports));\n }\n }\n }\n catch (e_3_1) { e_3 = { error: e_3_1 }; }\n finally {\n try {\n if (arr_2_1 && !arr_2_1.done && (_a = arr_2.return)) _a.call(arr_2);\n }\n finally { if (e_3) throw e_3.error; }\n }\n };\n R3TestBedCompiler.prototype.maybeStoreNgDef = function (prop, type) {\n if (!this.initialNgDefs.has(type)) {\n var currentDef = Object.getOwnPropertyDescriptor(type, prop);\n this.initialNgDefs.set(type, [prop, currentDef]);\n }\n };\n R3TestBedCompiler.prototype.storeFieldOfDefOnType = function (type, defField, field) {\n var def = type[defField];\n var original = def[field];\n this.defCleanupOps.push({ field: field, def: def, original: original });\n };\n /**\n * Clears current components resolution queue, but stores the state of the queue, so we can\n * restore it later. Clearing the queue is required before we try to compile components (via\n * `TestBed.compileComponents`), so that component defs are in sync with the resolution queue.\n */\n R3TestBedCompiler.prototype.clearComponentResolutionQueue = function () {\n var _this = this;\n if (this.originalComponentResolutionQueue === null) {\n this.originalComponentResolutionQueue = new Map();\n }\n clearResolutionOfComponentResourcesQueue().forEach(function (value, key) { return _this.originalComponentResolutionQueue.set(key, value); });\n };\n /*\n * Restores component resolution queue to the previously saved state. This operation is performed\n * as a part of restoring the state after completion of the current set of tests (that might\n * potentially mutate the state).\n */\n R3TestBedCompiler.prototype.restoreComponentResolutionQueue = function () {\n if (this.originalComponentResolutionQueue !== null) {\n restoreComponentResolutionQueue(this.originalComponentResolutionQueue);\n this.originalComponentResolutionQueue = null;\n }\n };\n R3TestBedCompiler.prototype.restoreOriginalState = function () {\n var e_4, _a;\n try {\n for (var _b = __values(this.defCleanupOps), _c = _b.next(); !_c.done; _c = _b.next()) {\n var op = _c.value;\n op.def[op.field] = op.original;\n }\n }\n catch (e_4_1) { e_4 = { error: e_4_1 }; }\n finally {\n try {\n if (_c && !_c.done && (_a = _b.return)) _a.call(_b);\n }\n finally { if (e_4) throw e_4.error; }\n }\n // Restore initial component/directive/pipe defs\n this.initialNgDefs.forEach(function (value, type) {\n var _a = __read(value, 2), prop = _a[0], descriptor = _a[1];\n if (!descriptor) {\n // Delete operations are generally undesirable since they have performance implications\n // on objects they were applied to. In this particular case, situations where this code is\n // invoked should be quite rare to cause any noticable impact, since it's applied only to\n // some test cases (for example when class with no annotations extends some @Component)\n // when we need to clear 'ngComponentDef' field on a given class to restore its original\n // state (before applying overrides and running tests).\n delete type[prop];\n }\n else {\n Object.defineProperty(type, prop, descriptor);\n }\n });\n this.initialNgDefs.clear();\n this.moduleProvidersOverridden.clear();\n this.restoreComponentResolutionQueue();\n // Restore the locale ID to the default value, this shouldn't be necessary but we never know\n core.ɵsetLocaleId(core.ɵDEFAULT_LOCALE_ID);\n };\n R3TestBedCompiler.prototype.compileTestModule = function () {\n var _this = this;\n var RootScopeModule = /** @class */ (function () {\n function RootScopeModule() {\n }\n return RootScopeModule;\n }());\n core.ɵcompileNgModuleDefs(RootScopeModule, {\n providers: __spread(this.rootProviderOverrides),\n });\n var ngZone = new core.NgZone({ enableLongStackTrace: true });\n var providers = __spread([\n { provide: core.NgZone, useValue: ngZone },\n { provide: core.Compiler, useFactory: function () { return new R3TestCompiler(_this); } }\n ], this.providers, this.providerOverrides);\n var imports = [RootScopeModule, this.additionalModuleTypes, this.imports || []];\n // clang-format off\n core.ɵcompileNgModuleDefs(this.testModuleType, {\n declarations: this.declarations,\n imports: imports,\n schemas: this.schemas,\n providers: providers,\n }, /* allowDuplicateDeclarationsInRoot */ true);\n // clang-format on\n this.applyProviderOverridesToModule(this.testModuleType);\n };\n Object.defineProperty(R3TestBedCompiler.prototype, \"injector\", {\n get: function () {\n if (this._injector !== null) {\n return this._injector;\n }\n var providers = [];\n var compilerOptions = this.platform.injector.get(core.COMPILER_OPTIONS);\n compilerOptions.forEach(function (opts) {\n if (opts.providers) {\n providers.push(opts.providers);\n }\n });\n if (this.compilerProviders !== null) {\n providers.push.apply(providers, __spread(this.compilerProviders));\n }\n // TODO(ocombe): make this work with an Injector directly instead of creating a module for it\n var CompilerModule = /** @class */ (function () {\n function CompilerModule() {\n }\n return CompilerModule;\n }());\n core.ɵcompileNgModuleDefs(CompilerModule, { providers: providers });\n var CompilerModuleFactory = new core.ɵNgModuleFactory(CompilerModule);\n this._injector = CompilerModuleFactory.create(this.platform.injector).injector;\n return this._injector;\n },\n enumerable: true,\n configurable: true\n });\n // get overrides for a specific provider (if any)\n R3TestBedCompiler.prototype.getSingleProviderOverrides = function (provider) {\n var token = getProviderToken(provider);\n return this.providerOverridesByToken.get(token) || null;\n };\n R3TestBedCompiler.prototype.getProviderOverrides = function (providers) {\n var _this = this;\n if (!providers || !providers.length || this.providerOverridesByToken.size === 0)\n return [];\n // There are two flattening operations here. The inner flatten() operates on the metadata's\n // providers and applies a mapping function which retrieves overrides for each incoming\n // provider. The outer flatten() then flattens the produced overrides array. If this is not\n // done, the array can contain other empty arrays (e.g. `[[], []]`) which leak into the\n // providers array and contaminate any error messages that might be generated.\n return flatten(flatten(providers, function (provider) { return _this.getSingleProviderOverrides(provider) || []; }));\n };\n R3TestBedCompiler.prototype.getOverriddenProviders = function (providers) {\n var _this = this;\n if (!providers || !providers.length || this.providerOverridesByToken.size === 0)\n return [];\n var overrides = this.getProviderOverrides(providers);\n var hasMultiProviderOverrides = overrides.some(isMultiProvider);\n var overriddenProviders = __spread(providers, overrides);\n // No additional processing is required in case we have no multi providers to override\n if (!hasMultiProviderOverrides) {\n return overriddenProviders;\n }\n var final = [];\n var seenMultiProviders = new Set();\n // We iterate through the list of providers in reverse order to make sure multi provider\n // overrides take precedence over the values defined in provider list. We also fiter out all\n // multi providers that have overrides, keeping overridden values only.\n forEachRight(overriddenProviders, function (provider) {\n var token = getProviderToken(provider);\n if (isMultiProvider(provider) && _this.providerOverridesByToken.has(token)) {\n if (!seenMultiProviders.has(token)) {\n seenMultiProviders.add(token);\n if (provider && provider.useValue && Array.isArray(provider.useValue)) {\n forEachRight(provider.useValue, function (value) {\n // Unwrap provider override array into individual providers in final set.\n final.unshift({ provide: token, useValue: value, multi: true });\n });\n }\n else {\n final.unshift(provider);\n }\n }\n }\n else {\n final.unshift(provider);\n }\n });\n return final;\n };\n R3TestBedCompiler.prototype.hasProviderOverrides = function (providers) {\n return this.getProviderOverrides(providers).length > 0;\n };\n R3TestBedCompiler.prototype.patchDefWithProviderOverrides = function (declaration, field) {\n var _this = this;\n var def = declaration[field];\n if (def && def.providersResolver) {\n this.maybeStoreNgDef(field, declaration);\n var resolver_1 = def.providersResolver;\n var processProvidersFn_1 = function (providers) { return _this.getOverriddenProviders(providers); };\n this.storeFieldOfDefOnType(declaration, field, 'providersResolver');\n def.providersResolver = function (ngDef) { return resolver_1(ngDef, processProvidersFn_1); };\n }\n };\n return R3TestBedCompiler;\n }());\n function initResolvers() {\n return {\n module: new NgModuleResolver(),\n component: new ComponentResolver(),\n directive: new DirectiveResolver(),\n pipe: new PipeResolver()\n };\n }\n function hasNgModuleDef(value) {\n return value.hasOwnProperty('ngModuleDef');\n }\n function maybeUnwrapFn(maybeFn) {\n return maybeFn instanceof Function ? maybeFn() : maybeFn;\n }\n function flatten(values, mapFn) {\n var out = [];\n values.forEach(function (value) {\n if (Array.isArray(value)) {\n out.push.apply(out, __spread(flatten(value, mapFn)));\n }\n else {\n out.push(mapFn ? mapFn(value) : value);\n }\n });\n return out;\n }\n function getProviderField(provider, field) {\n return provider && typeof provider === 'object' && provider[field];\n }\n function getProviderToken(provider) {\n return getProviderField(provider, 'provide') || provider;\n }\n function isMultiProvider(provider) {\n return !!getProviderField(provider, 'multi');\n }\n function forEachRight(values, fn) {\n for (var idx = values.length - 1; idx >= 0; idx--) {\n fn(values[idx], idx);\n }\n }\n var R3TestCompiler = /** @class */ (function () {\n function R3TestCompiler(testBed) {\n this.testBed = testBed;\n }\n R3TestCompiler.prototype.compileModuleSync = function (moduleType) {\n this.testBed._compileNgModuleSync(moduleType);\n return new core.ɵNgModuleFactory(moduleType);\n };\n R3TestCompiler.prototype.compileModuleAsync = function (moduleType) {\n return __awaiter(this, void 0, void 0, function () {\n return __generator(this, function (_a) {\n switch (_a.label) {\n case 0: return [4 /*yield*/, this.testBed._compileNgModuleAsync(moduleType)];\n case 1:\n _a.sent();\n return [2 /*return*/, new core.ɵNgModuleFactory(moduleType)];\n }\n });\n });\n };\n R3TestCompiler.prototype.compileModuleAndAllComponentsSync = function (moduleType) {\n var ngModuleFactory = this.compileModuleSync(moduleType);\n var componentFactories = this.testBed._getComponentFactories(moduleType);\n return new core.ModuleWithComponentFactories(ngModuleFactory, componentFactories);\n };\n R3TestCompiler.prototype.compileModuleAndAllComponentsAsync = function (moduleType) {\n return __awaiter(this, void 0, void 0, function () {\n var ngModuleFactory, componentFactories;\n return __generator(this, function (_a) {\n switch (_a.label) {\n case 0: return [4 /*yield*/, this.compileModuleAsync(moduleType)];\n case 1:\n ngModuleFactory = _a.sent();\n componentFactories = this.testBed._getComponentFactories(moduleType);\n return [2 /*return*/, new core.ModuleWithComponentFactories(ngModuleFactory, componentFactories)];\n }\n });\n });\n };\n R3TestCompiler.prototype.clearCache = function () { };\n R3TestCompiler.prototype.clearCacheFor = function (type) { };\n R3TestCompiler.prototype.getModuleId = function (moduleType) {\n var meta = this.testBed._getModuleResolver().resolve(moduleType);\n return meta && meta.id || undefined;\n };\n return R3TestCompiler;\n }());\n\n /**\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 var _nextRootElementId = 0;\n var UNDEFINED = Symbol('UNDEFINED');\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 */\n var TestBedRender3 = /** @class */ (function () {\n function TestBedRender3() {\n // Properties\n this.platform = null;\n this.ngModule = null;\n this._compiler = null;\n this._testModuleRef = null;\n this._activeFixtures = [];\n this._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 TestBedRender3.initTestEnvironment = function (ngModule, platform, aotSummaries) {\n var testBed = _getTestBedRender3();\n testBed.initTestEnvironment(ngModule, platform, aotSummaries);\n return testBed;\n };\n /**\n * Reset the providers for the test injector.\n *\n * @publicApi\n */\n TestBedRender3.resetTestEnvironment = function () { _getTestBedRender3().resetTestEnvironment(); };\n TestBedRender3.configureCompiler = function (config) {\n _getTestBedRender3().configureCompiler(config);\n return TestBedRender3;\n };\n /**\n * Allows overriding default providers, directives, pipes, modules of the test injector,\n * which are defined in test_injector.js\n */\n TestBedRender3.configureTestingModule = function (moduleDef) {\n _getTestBedRender3().configureTestingModule(moduleDef);\n return TestBedRender3;\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 TestBedRender3.compileComponents = function () { return _getTestBedRender3().compileComponents(); };\n TestBedRender3.overrideModule = function (ngModule, override) {\n _getTestBedRender3().overrideModule(ngModule, override);\n return TestBedRender3;\n };\n TestBedRender3.overrideComponent = function (component, override) {\n _getTestBedRender3().overrideComponent(component, override);\n return TestBedRender3;\n };\n TestBedRender3.overrideDirective = function (directive, override) {\n _getTestBedRender3().overrideDirective(directive, override);\n return TestBedRender3;\n };\n TestBedRender3.overridePipe = function (pipe, override) {\n _getTestBedRender3().overridePipe(pipe, override);\n return TestBedRender3;\n };\n TestBedRender3.overrideTemplate = function (component, template) {\n _getTestBedRender3().overrideComponent(component, { set: { template: template, templateUrl: null } });\n return TestBedRender3;\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 TestBedRender3.overrideTemplateUsingTestingModule = function (component, template) {\n _getTestBedRender3().overrideTemplateUsingTestingModule(component, template);\n return TestBedRender3;\n };\n TestBedRender3.overrideProvider = function (token, provider) {\n _getTestBedRender3().overrideProvider(token, provider);\n return TestBedRender3;\n };\n TestBedRender3.get = function (token, notFoundValue, flags) {\n if (notFoundValue === void 0) { notFoundValue = core.Injector.THROW_IF_NOT_FOUND; }\n if (flags === void 0) { flags = core.InjectFlags.Default; }\n return _getTestBedRender3().get(token, notFoundValue);\n };\n TestBedRender3.createComponent = function (component) {\n return _getTestBedRender3().createComponent(component);\n };\n TestBedRender3.resetTestingModule = function () {\n _getTestBedRender3().resetTestingModule();\n return TestBedRender3;\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 TestBedRender3.prototype.initTestEnvironment = function (ngModule, platform, aotSummaries) {\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 * Reset the providers for the test injector.\n *\n * @publicApi\n */\n TestBedRender3.prototype.resetTestEnvironment = function () {\n this.resetTestingModule();\n this._compiler = null;\n this.platform = null;\n this.ngModule = null;\n };\n TestBedRender3.prototype.resetTestingModule = function () {\n this.checkGlobalCompilationFinished();\n core.ɵ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 TestBedRender3.prototype.configureCompiler = function (config) {\n if (config.useJit != null) {\n throw new Error('the Render3 compiler JiT mode is not configurable !');\n }\n if (config.providers !== undefined) {\n this.compiler.setCompilerProviders(config.providers);\n }\n };\n TestBedRender3.prototype.configureTestingModule = function (moduleDef) {\n this.assertNotInstantiated('R3TestBed.configureTestingModule', 'configure the test module');\n this.compiler.configureTestingModule(moduleDef);\n };\n TestBedRender3.prototype.compileComponents = function () { return this.compiler.compileComponents(); };\n TestBedRender3.prototype.get = function (token, notFoundValue, flags) {\n if (notFoundValue === void 0) { notFoundValue = core.Injector.THROW_IF_NOT_FOUND; }\n if (flags === void 0) { flags = core.InjectFlags.Default; }\n if (token === TestBedRender3) {\n return this;\n }\n var result = this.testModuleRef.injector.get(token, UNDEFINED, flags);\n return result === UNDEFINED ? this.compiler.injector.get(token, notFoundValue, flags) : result;\n };\n TestBedRender3.prototype.execute = function (tokens, fn, context) {\n var _this = this;\n var params = tokens.map(function (t) { return _this.get(t); });\n return fn.apply(context, params);\n };\n TestBedRender3.prototype.overrideModule = function (ngModule, override) {\n this.assertNotInstantiated('overrideModule', 'override module metadata');\n this.compiler.overrideModule(ngModule, override);\n };\n TestBedRender3.prototype.overrideComponent = function (component, override) {\n this.assertNotInstantiated('overrideComponent', 'override component metadata');\n this.compiler.overrideComponent(component, override);\n };\n TestBedRender3.prototype.overrideTemplateUsingTestingModule = function (component, template) {\n this.assertNotInstantiated('R3TestBed.overrideTemplateUsingTestingModule', 'Cannot override template when the test module has already been instantiated');\n this.compiler.overrideTemplateUsingTestingModule(component, template);\n };\n TestBedRender3.prototype.overrideDirective = function (directive, override) {\n this.assertNotInstantiated('overrideDirective', 'override directive metadata');\n this.compiler.overrideDirective(directive, override);\n };\n TestBedRender3.prototype.overridePipe = function (pipe, override) {\n this.assertNotInstantiated('overridePipe', 'override pipe metadata');\n this.compiler.overridePipe(pipe, override);\n };\n /**\n * Overwrites all providers for the given token with the given provider definition.\n */\n TestBedRender3.prototype.overrideProvider = function (token, provider) {\n this.compiler.overrideProvider(token, provider);\n };\n TestBedRender3.prototype.createComponent = function (type) {\n var _this = this;\n var testComponentRenderer = this.get(TestComponentRenderer);\n var rootElId = \"root-ng-internal-isolated-\" + _nextRootElementId++;\n testComponentRenderer.insertRootElement(rootElId);\n var componentDef = type.ngComponentDef;\n if (!componentDef) {\n throw new Error(\"It looks like '\" + core.ɵstringify(type) + \"' has not been IVY compiled - it has no 'ngComponentDef' field\");\n }\n // TODO: Don't cast as `any`, proper type is boolean[]\n var noNgZone = this.get(ComponentFixtureNoNgZone, false);\n // TODO: Don't cast as `any`, proper type is boolean[]\n var autoDetect = this.get(ComponentFixtureAutoDetect, false);\n var ngZone = noNgZone ? null : this.get(core.NgZone, null);\n var componentFactory = new core.ɵRender3ComponentFactory(componentDef);\n var initComponent = function () {\n var componentRef = componentFactory.create(core.Injector.NULL, [], \"#\" + rootElId, _this.testModuleRef);\n return new ComponentFixture(componentRef, ngZone, autoDetect);\n };\n var fixture = ngZone ? ngZone.run(initComponent) : initComponent();\n this._activeFixtures.push(fixture);\n return fixture;\n };\n Object.defineProperty(TestBedRender3.prototype, \"compiler\", {\n get: function () {\n if (this._compiler === null) {\n throw new Error(\"Need to call TestBed.initTestEnvironment() first\");\n }\n return this._compiler;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(TestBedRender3.prototype, \"testModuleRef\", {\n get: function () {\n if (this._testModuleRef === null) {\n this._testModuleRef = this.compiler.finalize();\n }\n return this._testModuleRef;\n },\n enumerable: true,\n configurable: true\n });\n TestBedRender3.prototype.assertNotInstantiated = function (methodName, methodDescription) {\n if (this._testModuleRef !== null) {\n throw new Error(\"Cannot \" + methodDescription + \" when the test module has already been instantiated. \" +\n (\"Make sure you are not using `inject` before `\" + methodName + \"`.\"));\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 TestBedRender3.prototype.checkGlobalCompilationFinished = function () {\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 core.ɵflushModuleScopingQueueAsMuchAsPossible();\n }\n this._globalCompilationChecked = true;\n };\n TestBedRender3.prototype.destroyActiveFixtures = function () {\n this._activeFixtures.forEach(function (fixture) {\n try {\n fixture.destroy();\n }\n catch (e) {\n console.error('Error during cleanup of component', {\n component: fixture.componentInstance,\n stacktrace: e,\n });\n }\n });\n this._activeFixtures = [];\n };\n return TestBedRender3;\n }());\n var testBed;\n function _getTestBedRender3() {\n return testBed = testBed || new TestBedRender3();\n }\n\n /**\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 function unimplemented() {\n throw Error('unimplemented');\n }\n /**\n * Special interface to the compiler only used by testing\n *\n * @publicApi\n */\n var TestingCompiler = /** @class */ (function (_super) {\n __extends(TestingCompiler, _super);\n function TestingCompiler() {\n return _super !== null && _super.apply(this, arguments) || this;\n }\n Object.defineProperty(TestingCompiler.prototype, \"injector\", {\n get: function () { throw unimplemented(); },\n enumerable: true,\n configurable: true\n });\n TestingCompiler.prototype.overrideModule = function (module, overrides) {\n throw unimplemented();\n };\n TestingCompiler.prototype.overrideDirective = function (directive, overrides) {\n throw unimplemented();\n };\n TestingCompiler.prototype.overrideComponent = function (component, overrides) {\n throw unimplemented();\n };\n TestingCompiler.prototype.overridePipe = function (directive, overrides) {\n throw unimplemented();\n };\n /**\n * Allows to pass the compile summary from AOT compilation to the JIT compiler,\n * so that it can use the code generated by AOT.\n */\n TestingCompiler.prototype.loadAotSummaries = function (summaries) { throw unimplemented(); };\n /**\n * Gets the component factory for the given component.\n * This assumes that the component has been compiled before calling this call using\n * `compileModuleAndAllComponents*`.\n */\n TestingCompiler.prototype.getComponentFactory = function (component) { throw unimplemented(); };\n /**\n * Returns the component type that is stored in the given error.\n * This can be used for errors created by compileModule...\n */\n TestingCompiler.prototype.getComponentFromError = function (error) { throw unimplemented(); };\n TestingCompiler = __decorate([\n core.Injectable()\n ], TestingCompiler);\n return TestingCompiler;\n }(core.Compiler));\n /**\n * A factory for creating a Compiler\n *\n * @publicApi\n */\n var TestingCompilerFactory = /** @class */ (function () {\n function TestingCompilerFactory() {\n }\n return TestingCompilerFactory;\n }());\n\n /**\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 var UNDEFINED$1 = new Object();\n var _nextRootElementId$1 = 0;\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 */\n var TestBedViewEngine = /** @class */ (function () {\n function TestBedViewEngine() {\n this._instantiated = false;\n this._compiler = null;\n this._moduleRef = null;\n this._moduleFactory = null;\n this._compilerOptions = [];\n this._moduleOverrides = [];\n this._componentOverrides = [];\n this._directiveOverrides = [];\n this._pipeOverrides = [];\n this._providers = [];\n this._declarations = [];\n this._imports = [];\n this._schemas = [];\n this._activeFixtures = [];\n this._testEnvAotSummaries = function () { return []; };\n this._aotSummaries = [];\n this._templateOverrides = [];\n this._isRoot = true;\n this._rootProviderOverrides = [];\n this.platform = null;\n this.ngModule = null;\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 TestBedViewEngine.initTestEnvironment = function (ngModule, platform, aotSummaries) {\n var testBed = _getTestBedViewEngine();\n testBed.initTestEnvironment(ngModule, platform, aotSummaries);\n return testBed;\n };\n /**\n * Reset the providers for the test injector.\n */\n TestBedViewEngine.resetTestEnvironment = function () { _getTestBedViewEngine().resetTestEnvironment(); };\n TestBedViewEngine.resetTestingModule = function () {\n _getTestBedViewEngine().resetTestingModule();\n return TestBedViewEngine;\n };\n /**\n * Allows overriding default compiler providers and settings\n * which are defined in test_injector.js\n */\n TestBedViewEngine.configureCompiler = function (config) {\n _getTestBedViewEngine().configureCompiler(config);\n return TestBedViewEngine;\n };\n /**\n * Allows overriding default providers, directives, pipes, modules of the test injector,\n * which are defined in test_injector.js\n */\n TestBedViewEngine.configureTestingModule = function (moduleDef) {\n _getTestBedViewEngine().configureTestingModule(moduleDef);\n return TestBedViewEngine;\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 TestBedViewEngine.compileComponents = function () { return getTestBed().compileComponents(); };\n TestBedViewEngine.overrideModule = function (ngModule, override) {\n _getTestBedViewEngine().overrideModule(ngModule, override);\n return TestBedViewEngine;\n };\n TestBedViewEngine.overrideComponent = function (component, override) {\n _getTestBedViewEngine().overrideComponent(component, override);\n return TestBedViewEngine;\n };\n TestBedViewEngine.overrideDirective = function (directive, override) {\n _getTestBedViewEngine().overrideDirective(directive, override);\n return TestBedViewEngine;\n };\n TestBedViewEngine.overridePipe = function (pipe, override) {\n _getTestBedViewEngine().overridePipe(pipe, override);\n return TestBedViewEngine;\n };\n TestBedViewEngine.overrideTemplate = function (component, template) {\n _getTestBedViewEngine().overrideComponent(component, { set: { template: template, templateUrl: null } });\n return TestBedViewEngine;\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 TestBedViewEngine.overrideTemplateUsingTestingModule = function (component, template) {\n _getTestBedViewEngine().overrideTemplateUsingTestingModule(component, template);\n return TestBedViewEngine;\n };\n TestBedViewEngine.overrideProvider = function (token, provider) {\n _getTestBedViewEngine().overrideProvider(token, provider);\n return TestBedViewEngine;\n };\n TestBedViewEngine.get = function (token, notFoundValue, flags) {\n if (notFoundValue === void 0) { notFoundValue = core.Injector.THROW_IF_NOT_FOUND; }\n if (flags === void 0) { flags = core.InjectFlags.Default; }\n return _getTestBedViewEngine().get(token, notFoundValue, flags);\n };\n TestBedViewEngine.createComponent = function (component) {\n return _getTestBedViewEngine().createComponent(component);\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 TestBedViewEngine.prototype.initTestEnvironment = function (ngModule, platform, aotSummaries) {\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 if (aotSummaries) {\n this._testEnvAotSummaries = aotSummaries;\n }\n };\n /**\n * Reset the providers for the test injector.\n */\n TestBedViewEngine.prototype.resetTestEnvironment = function () {\n this.resetTestingModule();\n this.platform = null;\n this.ngModule = null;\n this._testEnvAotSummaries = function () { return []; };\n };\n TestBedViewEngine.prototype.resetTestingModule = function () {\n core.ɵclearOverrides();\n this._aotSummaries = [];\n this._templateOverrides = [];\n this._compiler = null;\n this._moduleOverrides = [];\n this._componentOverrides = [];\n this._directiveOverrides = [];\n this._pipeOverrides = [];\n this._isRoot = true;\n this._rootProviderOverrides = [];\n this._moduleRef = null;\n this._moduleFactory = null;\n this._compilerOptions = [];\n this._providers = [];\n this._declarations = [];\n this._imports = [];\n this._schemas = [];\n this._instantiated = false;\n this._activeFixtures.forEach(function (fixture) {\n try {\n fixture.destroy();\n }\n catch (e) {\n console.error('Error during cleanup of component', {\n component: fixture.componentInstance,\n stacktrace: e,\n });\n }\n });\n this._activeFixtures = [];\n };\n TestBedViewEngine.prototype.configureCompiler = function (config) {\n this._assertNotInstantiated('TestBed.configureCompiler', 'configure the compiler');\n this._compilerOptions.push(config);\n };\n TestBedViewEngine.prototype.configureTestingModule = function (moduleDef) {\n var _a, _b, _c, _d;\n this._assertNotInstantiated('TestBed.configureTestingModule', 'configure the test module');\n if (moduleDef.providers) {\n (_a = this._providers).push.apply(_a, __spread(moduleDef.providers));\n }\n if (moduleDef.declarations) {\n (_b = this._declarations).push.apply(_b, __spread(moduleDef.declarations));\n }\n if (moduleDef.imports) {\n (_c = this._imports).push.apply(_c, __spread(moduleDef.imports));\n }\n if (moduleDef.schemas) {\n (_d = this._schemas).push.apply(_d, __spread(moduleDef.schemas));\n }\n if (moduleDef.aotSummaries) {\n this._aotSummaries.push(moduleDef.aotSummaries);\n }\n };\n TestBedViewEngine.prototype.compileComponents = function () {\n var _this = this;\n if (this._moduleFactory || this._instantiated) {\n return Promise.resolve(null);\n }\n var moduleType = this._createCompilerAndModule();\n return this._compiler.compileModuleAndAllComponentsAsync(moduleType)\n .then(function (moduleAndComponentFactories) {\n _this._moduleFactory = moduleAndComponentFactories.ngModuleFactory;\n });\n };\n TestBedViewEngine.prototype._initIfNeeded = function () {\n var e_1, _a;\n if (this._instantiated) {\n return;\n }\n if (!this._moduleFactory) {\n try {\n var moduleType = this._createCompilerAndModule();\n this._moduleFactory =\n this._compiler.compileModuleAndAllComponentsSync(moduleType).ngModuleFactory;\n }\n catch (e) {\n var errorCompType = this._compiler.getComponentFromError(e);\n if (errorCompType) {\n throw new Error(\"This test module uses the component \" + core.ɵstringify(errorCompType) + \" which is using a \\\"templateUrl\\\" or \\\"styleUrls\\\", but they were never compiled. \" +\n \"Please call \\\"TestBed.compileComponents\\\" before your test.\");\n }\n else {\n throw e;\n }\n }\n }\n try {\n for (var _b = __values(this._templateOverrides), _c = _b.next(); !_c.done; _c = _b.next()) {\n var _d = _c.value, component = _d.component, templateOf = _d.templateOf;\n var compFactory = this._compiler.getComponentFactory(templateOf);\n core.ɵoverrideComponentView(component, compFactory);\n }\n }\n catch (e_1_1) { e_1 = { error: e_1_1 }; }\n finally {\n try {\n if (_c && !_c.done && (_a = _b.return)) _a.call(_b);\n }\n finally { if (e_1) throw e_1.error; }\n }\n var ngZone = new core.NgZone({ enableLongStackTrace: true });\n var providers = [{ provide: core.NgZone, useValue: ngZone }];\n var ngZoneInjector = core.Injector.create({\n providers: providers,\n parent: this.platform.injector,\n name: this._moduleFactory.moduleType.name\n });\n this._moduleRef = this._moduleFactory.create(ngZoneInjector);\n // ApplicationInitStatus.runInitializers() is marked @internal to core. So casting to any\n // before accessing it.\n this._moduleRef.injector.get(core.ApplicationInitStatus).runInitializers();\n this._instantiated = true;\n };\n TestBedViewEngine.prototype._createCompilerAndModule = function () {\n var _this = this;\n var e_2, _a;\n var providers = this._providers.concat([{ provide: TestBed, useValue: this }]);\n var declarations = __spread(this._declarations, this._templateOverrides.map(function (entry) { return entry.templateOf; }));\n var rootScopeImports = [];\n var rootProviderOverrides = this._rootProviderOverrides;\n if (this._isRoot) {\n var RootScopeModule = /** @class */ (function () {\n function RootScopeModule() {\n }\n RootScopeModule = __decorate([\n core.NgModule({\n providers: __spread(rootProviderOverrides),\n jit: true,\n })\n ], RootScopeModule);\n return RootScopeModule;\n }());\n rootScopeImports.push(RootScopeModule);\n }\n providers.push({ provide: core.ɵAPP_ROOT, useValue: this._isRoot });\n var imports = [rootScopeImports, this.ngModule, this._imports];\n var schemas = this._schemas;\n var DynamicTestModule = /** @class */ (function () {\n function DynamicTestModule() {\n }\n DynamicTestModule = __decorate([\n core.NgModule({ providers: providers, declarations: declarations, imports: imports, schemas: schemas, jit: true })\n ], DynamicTestModule);\n return DynamicTestModule;\n }());\n var compilerFactory = this.platform.injector.get(TestingCompilerFactory);\n this._compiler = compilerFactory.createTestingCompiler(this._compilerOptions);\n try {\n for (var _b = __values(__spread([this._testEnvAotSummaries], this._aotSummaries)), _c = _b.next(); !_c.done; _c = _b.next()) {\n var summary = _c.value;\n this._compiler.loadAotSummaries(summary);\n }\n }\n catch (e_2_1) { e_2 = { error: e_2_1 }; }\n finally {\n try {\n if (_c && !_c.done && (_a = _b.return)) _a.call(_b);\n }\n finally { if (e_2) throw e_2.error; }\n }\n this._moduleOverrides.forEach(function (entry) { return _this._compiler.overrideModule(entry[0], entry[1]); });\n this._componentOverrides.forEach(function (entry) { return _this._compiler.overrideComponent(entry[0], entry[1]); });\n this._directiveOverrides.forEach(function (entry) { return _this._compiler.overrideDirective(entry[0], entry[1]); });\n this._pipeOverrides.forEach(function (entry) { return _this._compiler.overridePipe(entry[0], entry[1]); });\n return DynamicTestModule;\n };\n TestBedViewEngine.prototype._assertNotInstantiated = function (methodName, methodDescription) {\n if (this._instantiated) {\n throw new Error(\"Cannot \" + methodDescription + \" when the test module has already been instantiated. \" +\n (\"Make sure you are not using `inject` before `\" + methodName + \"`.\"));\n }\n };\n TestBedViewEngine.prototype.get = function (token, notFoundValue, flags) {\n if (notFoundValue === void 0) { notFoundValue = core.Injector.THROW_IF_NOT_FOUND; }\n if (flags === void 0) { flags = core.InjectFlags.Default; }\n this._initIfNeeded();\n if (token === TestBed) {\n return this;\n }\n // Tests can inject things from the ng module and from the compiler,\n // but the ng module can't inject things from the compiler and vice versa.\n var result = this._moduleRef.injector.get(token, UNDEFINED$1, flags);\n return result === UNDEFINED$1 ? this._compiler.injector.get(token, notFoundValue, flags) : result;\n };\n TestBedViewEngine.prototype.execute = function (tokens, fn, context) {\n var _this = this;\n this._initIfNeeded();\n var params = tokens.map(function (t) { return _this.get(t); });\n return fn.apply(context, params);\n };\n TestBedViewEngine.prototype.overrideModule = function (ngModule, override) {\n this._assertNotInstantiated('overrideModule', 'override module metadata');\n this._moduleOverrides.push([ngModule, override]);\n };\n TestBedViewEngine.prototype.overrideComponent = function (component, override) {\n this._assertNotInstantiated('overrideComponent', 'override component metadata');\n this._componentOverrides.push([component, override]);\n };\n TestBedViewEngine.prototype.overrideDirective = function (directive, override) {\n this._assertNotInstantiated('overrideDirective', 'override directive metadata');\n this._directiveOverrides.push([directive, override]);\n };\n TestBedViewEngine.prototype.overridePipe = function (pipe, override) {\n this._assertNotInstantiated('overridePipe', 'override pipe metadata');\n this._pipeOverrides.push([pipe, override]);\n };\n TestBedViewEngine.prototype.overrideProvider = function (token, provider) {\n this.overrideProviderImpl(token, provider);\n };\n TestBedViewEngine.prototype.overrideProviderImpl = function (token, provider, deprecated) {\n if (deprecated === void 0) { deprecated = false; }\n var def = null;\n if (typeof token !== 'string' && (def = core.ɵgetInjectableDef(token)) && def.providedIn === 'root') {\n if (provider.useFactory) {\n this._rootProviderOverrides.push({ provide: token, useFactory: provider.useFactory, deps: provider.deps || [] });\n }\n else {\n this._rootProviderOverrides.push({ provide: token, useValue: provider.useValue });\n }\n }\n var flags = 0;\n var value;\n if (provider.useFactory) {\n flags |= 1024 /* TypeFactoryProvider */;\n value = provider.useFactory;\n }\n else {\n flags |= 256 /* TypeValueProvider */;\n value = provider.useValue;\n }\n var deps = (provider.deps || []).map(function (dep) {\n var depFlags = 0 /* None */;\n var depToken;\n if (Array.isArray(dep)) {\n dep.forEach(function (entry) {\n if (entry instanceof core.Optional) {\n depFlags |= 2 /* Optional */;\n }\n else if (entry instanceof core.SkipSelf) {\n depFlags |= 1 /* SkipSelf */;\n }\n else {\n depToken = entry;\n }\n });\n }\n else {\n depToken = dep;\n }\n return [depFlags, depToken];\n });\n core.ɵoverrideProvider({ token: token, flags: flags, deps: deps, value: value, deprecatedBehavior: deprecated });\n };\n TestBedViewEngine.prototype.overrideTemplateUsingTestingModule = function (component, template) {\n this._assertNotInstantiated('overrideTemplateUsingTestingModule', 'override template');\n var OverrideComponent = /** @class */ (function () {\n function OverrideComponent() {\n }\n OverrideComponent = __decorate([\n core.Component({ selector: 'empty', template: template, jit: true })\n ], OverrideComponent);\n return OverrideComponent;\n }());\n this._templateOverrides.push({ component: component, templateOf: OverrideComponent });\n };\n TestBedViewEngine.prototype.createComponent = function (component) {\n var _this = this;\n this._initIfNeeded();\n var componentFactory = this._compiler.getComponentFactory(component);\n if (!componentFactory) {\n throw new Error(\"Cannot create the component \" + core.ɵstringify(component) + \" as it was not imported into the testing module!\");\n }\n // TODO: Don't cast as `any`, proper type is boolean[]\n var noNgZone = this.get(ComponentFixtureNoNgZone, false);\n // TODO: Don't cast as `any`, proper type is boolean[]\n var autoDetect = this.get(ComponentFixtureAutoDetect, false);\n var ngZone = noNgZone ? null : this.get(core.NgZone, null);\n var testComponentRenderer = this.get(TestComponentRenderer);\n var rootElId = \"root\" + _nextRootElementId$1++;\n testComponentRenderer.insertRootElement(rootElId);\n var initComponent = function () {\n var componentRef = componentFactory.create(core.Injector.NULL, [], \"#\" + rootElId, _this._moduleRef);\n return new ComponentFixture(componentRef, ngZone, autoDetect);\n };\n var fixture = !ngZone ? initComponent() : ngZone.run(initComponent);\n this._activeFixtures.push(fixture);\n return fixture;\n };\n return TestBedViewEngine;\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 *\n * @publicApi\n */\n var TestBed = core.ɵivyEnabled ? TestBedRender3 : TestBedViewEngine;\n /**\n * Returns a singleton of the applicable `TestBed`.\n *\n * It will be either an instance of `TestBedViewEngine` or `TestBedRender3`.\n *\n * @publicApi\n */\n var getTestBed = core.ɵivyEnabled ? _getTestBedRender3 : _getTestBedViewEngine;\n var testBed$1;\n function _getTestBedViewEngine() {\n return testBed$1 = testBed$1 || new TestBedViewEngine();\n }\n /**\n * Allows injecting dependencies in `beforeEach()` and `it()`.\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 * Notes:\n * - inject is currently a function because of some Traceur limitation the syntax should\n * eventually\n * becomes `it('...', @Inject (object: AClass, async: AsyncTestCompleter) => { ... });`\n *\n * @publicApi\n */\n function inject(tokens, fn) {\n var testBed = getTestBed();\n if (tokens.indexOf(AsyncTestCompleter) >= 0) {\n // Not using an arrow function to preserve context passed from call site\n return function () {\n var _this = this;\n // Return an async test method that returns a Promise if AsyncTestCompleter is one of\n // the injected tokens.\n return testBed.compileComponents().then(function () {\n var completer = testBed.get(AsyncTestCompleter);\n testBed.execute(tokens, fn, _this);\n return completer.promise;\n });\n };\n }\n else {\n // Not using an arrow function to preserve context passed from call site\n return function () { return testBed.execute(tokens, fn, this); };\n }\n }\n /**\n * @publicApi\n */\n var InjectSetupWrapper = /** @class */ (function () {\n function InjectSetupWrapper(_moduleDef) {\n this._moduleDef = _moduleDef;\n }\n InjectSetupWrapper.prototype._addModule = function () {\n var moduleDef = this._moduleDef();\n if (moduleDef) {\n getTestBed().configureTestingModule(moduleDef);\n }\n };\n InjectSetupWrapper.prototype.inject = function (tokens, fn) {\n var self = this;\n // Not using an arrow function to preserve context passed from call site\n return function () {\n self._addModule();\n return inject(tokens, fn).call(this);\n };\n };\n return InjectSetupWrapper;\n }());\n function withModule(moduleDef, fn) {\n if (fn) {\n // Not using an arrow function to preserve context passed from call site\n return function () {\n var testBed = getTestBed();\n if (moduleDef) {\n testBed.configureTestingModule(moduleDef);\n }\n return fn.apply(this);\n };\n }\n return new InjectSetupWrapper(function () { return moduleDef; });\n }\n\n /**\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 var _global$1 = (typeof window === 'undefined' ? global : window);\n // Reset the test providers and the fake async zone before each test.\n if (_global$1.beforeEach) {\n _global$1.beforeEach(function () {\n TestBed.resetTestingModule();\n resetFakeAsyncZone();\n });\n }\n // TODO(juliemr): remove this, only used because we need to export something to have compilation\n // work.\n var __core_private_testing_placeholder__ = '';\n\n /**\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 /**\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 /**\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 // This file only reexports content of the `src` folder. Keep it that way.\n\n /**\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 /**\n * Generated bundle index. Do not edit.\n */\n\n exports.ɵangular_packages_core_testing_testing_b = TestBedRender3;\n exports.ɵangular_packages_core_testing_testing_c = _getTestBedRender3;\n exports.ɵangular_packages_core_testing_testing_a = TestBedViewEngine;\n exports.TestBed = TestBed;\n exports.getTestBed = getTestBed;\n exports.inject = inject;\n exports.InjectSetupWrapper = InjectSetupWrapper;\n exports.withModule = withModule;\n exports.ɵMetadataOverrider = MetadataOverrider;\n exports.async = async;\n exports.ComponentFixture = ComponentFixture;\n exports.resetFakeAsyncZone = resetFakeAsyncZone;\n exports.fakeAsync = fakeAsync;\n exports.tick = tick;\n exports.flush = flush;\n exports.discardPeriodicTasks = discardPeriodicTasks;\n exports.flushMicrotasks = flushMicrotasks;\n exports.TestComponentRenderer = TestComponentRenderer;\n exports.ComponentFixtureAutoDetect = ComponentFixtureAutoDetect;\n exports.ComponentFixtureNoNgZone = ComponentFixtureNoNgZone;\n exports.__core_private_testing_placeholder__ = __core_private_testing_placeholder__;\n exports.ɵTestingCompiler = TestingCompiler;\n exports.ɵTestingCompilerFactory = TestingCompilerFactory;\n\n Object.defineProperty(exports, '__esModule', { value: true });\n\n}));\n//# sourceMappingURL=core-testing.umd.js.map\n"]} |