@angular/core 12.0.1 → 12.0.5

package/bundles/core-testing.umd.js

@@ -1,5 +1,5 @@
 /**
- * @license Angular v12.0.1
+ * @license Angular v12.0.5
  * (c) 2010-2021 Google LLC. https://angular.io/
  * License: MIT
  */
@@ -280,21 +280,25 @@
         throw new Error(fakeAsyncTestModuleNotLoadedErrorMessage);
     }
     /**
-     * Wraps a function to be executed in the fakeAsync zone:
-     * - microtasks are manually executed by calling `flushMicrotasks()`,
-     * - timers are synchronous, `tick()` simulates the asynchronous passage of time.
+     * Wraps a function to be executed in the `fakeAsync` zone:
+     * - Microtasks are manually executed by calling `flushMicrotasks()`.
+     * - Timers are synchronous; `tick()` simulates the asynchronous passage of time.
      *
-     * If there are any pending timers at the end of the function, an exception will be thrown.
+     * If there are any pending timers at the end of the function, an exception is thrown.
      *
-     * Can be used to wrap inject() calls.
+     * Can be used to wrap `inject()` calls.
+     *
+     * @param fn The function that you want to wrap in the `fakeAysnc` zone.
      *
      * @usageNotes
      * ### Example
      *
      * {@example core/testing/ts/fake_async.ts region='basic'}
      *
-     * @param fn
-     * @returns The function wrapped to be executed in the fakeAsync zone
+     *
+     * @returns The function wrapped to be executed in the `fakeAsync` zone.
+     * Any arguments passed when calling this returned function will be passed through to the `fn`
+     * function in the parameters when it is called.
      *
      * @publicApi
      */
@@ -305,23 +309,36 @@
         throw new Error(fakeAsyncTestModuleNotLoadedErrorMessage);
     }
     /**
-     * Simulates the asynchronous passage of time for the timers in the fakeAsync zone.
+     * Simulates the asynchronous passage of time for the timers in the `fakeAsync` zone.
      *
      * The microtasks queue is drained at the very start of this function and after any timer callback
      * has been executed.
      *
+     * @param millis The number of milliseconds to advance the virtual timer.
+     * @param tickOptions The options to pass to the `tick()` function.
+     *
      * @usageNotes
+     *
+     * The `tick()` option is a flag called `processNewMacroTasksSynchronously`,
+     * which determines whether or not to invoke new macroTasks.
+     *
+     * If you provide a `tickOptions` object, but do not specify a
+     * `processNewMacroTasksSynchronously` property (`tick(100, {})`),
+     * then `processNewMacroTasksSynchronously` defaults to true.
+     *
+     * If you omit the `tickOptions` parameter (`tick(100))`), then
+     * `tickOptions` defaults to `{processNewMacroTasksSynchronously: true}`.
+     *
      * ### Example
      *
      * {@example core/testing/ts/fake_async.ts region='basic'}
      *
-     * @param millis, the number of millisecond to advance the virtual timer
-     * @param tickOptions, the options of tick with a flag called
-     * processNewMacroTasksSynchronously, whether to invoke the new macroTasks, by default is
-     * false, means the new macroTasks will be invoked
-     *
-     * For example,
+     * The following example includes a nested timeout (new macroTask), and
+     * the `tickOptions` parameter is allowed to default. In this case,
+     * `processNewMacroTasksSynchronously` defaults to true, and the nested
+     * function is executed on each tick.
      *
+     * ```
      * it ('test with nested setTimeout', fakeAsync(() => {
      *   let nestedTimeoutInvoked = false;
      *   function funcWithNestedTimeout() {
@@ -333,10 +350,12 @@
      *   tick();
      *   expect(nestedTimeoutInvoked).toBe(true);
      * }));
+     * ```
      *
-     * in this case, we have a nested timeout (new macroTask), when we tick, both the
-     * funcWithNestedTimeout and the nested timeout both will be invoked.
+     * In the following case, `processNewMacroTasksSynchronously` is explicitly
+     * set to false, so the nested timeout function is not invoked.
      *
+     * ```
      * it ('test with nested setTimeout', fakeAsync(() => {
      *   let nestedTimeoutInvoked = false;
      *   function funcWithNestedTimeout() {
@@ -348,9 +367,7 @@
      *   tick(0, {processNewMacroTasksSynchronously: false});
      *   expect(nestedTimeoutInvoked).toBe(false);
      * }));
-     *
-     * if we pass the tickOptions with processNewMacroTasksSynchronously to be false, the nested timeout
-     * will not be invoked.
+     * ```
      *
      *
      * @publicApi
@@ -366,12 +383,12 @@
         throw new Error(fakeAsyncTestModuleNotLoadedErrorMessage);
     }
     /**
-     * Simulates the asynchronous passage of time for the timers in the fakeAsync zone by
-     * draining the macrotask queue until it is empty. The returned value is the milliseconds
-     * of time that would have been elapsed.
+     * Simulates the asynchronous passage of time for the timers in the `fakeAsync` zone by
+     * draining the macrotask queue until it is empty.
      *
-     * @param maxTurns
-     * @returns The simulated time elapsed, in millis.
+     * @param maxTurns The maximum number of times the scheduler attempts to clear its queue before
+     *     throwing an error.
+     * @returns The simulated time elapsed, in milliseconds.
      *
      * @publicApi
      */
@@ -716,40 +733,6 @@
         return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
     }
 
-    /**
-     * @license
-     * Copyright Google LLC All Rights Reserved.
-     *
-     * Use of this source code is governed by an MIT-style license that can be
-     * found in the LICENSE file at https://angular.io/license
-     */
-    /**
-     * Injectable completer that allows signaling completion of an asynchronous test. Used internally.
-     */
-    var AsyncTestCompleter = /** @class */ (function () {
-        function AsyncTestCompleter() {
-            var _this = this;
-            this._promise = new Promise(function (res, rej) {
-                _this._resolve = res;
-                _this._reject = rej;
-            });
-        }
-        AsyncTestCompleter.prototype.done = function (value) {
-            this._resolve(value);
-        };
-        AsyncTestCompleter.prototype.fail = function (error, stackTrace) {
-            this._reject(error);
-        };
-        Object.defineProperty(AsyncTestCompleter.prototype, "promise", {
-            get: function () {
-                return this._promise;
-            },
-            enumerable: false,
-            configurable: true
-        });
-        return AsyncTestCompleter;
-    }());
-
     /**
      * @license
      * Copyright Google LLC All Rights Reserved.
@@ -2863,34 +2846,14 @@
      * })
      * ```
      *
-     * Notes:
-     * - inject is currently a function because of some Traceur limitation the syntax should
-     * eventually
-     *   becomes `it('...', @Inject (object: AClass, async: AsyncTestCompleter) => { ... });`
-     *
      * @publicApi
      */
     function inject(tokens, fn) {
         var testBed = getTestBed();
-        if (tokens.indexOf(AsyncTestCompleter) >= 0) {
-            // Not using an arrow function to preserve context passed from call site
-            return function () {
-                var _this = this;
-                // Return an async test method that returns a Promise if AsyncTestCompleter is one of
-                // the injected tokens.
-                return testBed.compileComponents().then(function () {
-                    var completer = testBed.inject(AsyncTestCompleter);
-                    testBed.execute(tokens, fn, _this);
-                    return completer.promise;
-                });
-            };
-        }
-        else {
-            // Not using an arrow function to preserve context passed from call site
-            return function () {
-                return testBed.execute(tokens, fn, this);
-            };
-        }
+        // Not using an arrow function to preserve context passed from call site
+        return function () {
+            return testBed.execute(tokens, fn, this);
+        };
     }
     /**
      * @publicApi