@angular/core 12.0.0-rc.3 → 12.0.3

package/fesm2015/testing.js

@@ -1,5 +1,5 @@
 /**
- * @license Angular v12.0.0-rc.3
+ * @license Angular v12.0.3
  * (c) 2010-2021 Google LLC. https://angular.io/
  * License: MIT
  */
@@ -273,21 +273,25 @@ function resetFakeAsyncZone() {
     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
  */
@@ -298,23 +302,36 @@ function fakeAsync(fn) {
     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() {
@@ -326,10 +343,12 @@ function fakeAsync(fn) {
  *   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() {
@@ -341,9 +360,7 @@ function fakeAsync(fn) {
  *   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
@@ -357,12 +374,12 @@ function tick(millis = 0, tickOptions = {
     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
  */
@@ -395,34 +412,6 @@ function flushMicrotasks() {
     throw new Error(fakeAsyncTestModuleNotLoadedErrorMessage);
 }
 
-/**
- * @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.
- */
-class AsyncTestCompleter {
-    constructor() {
-        this._promise = new Promise((res, rej) => {
-            this._resolve = res;
-            this._reject = rej;
-        });
-    }
-    done(value) {
-        this._resolve(value);
-    }
-    fail(error, stackTrace) {
-        this._reject(error);
-    }
-    get promise() {
-        return this._promise;
-    }
-}
-
 /**
  * @license
  * Copyright Google LLC All Rights Reserved.
@@ -2342,33 +2331,14 @@ function _getTestBedViewEngine() {
  * })
  * ```
  *
- * 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) {
     const testBed = getTestBed();
-    if (tokens.indexOf(AsyncTestCompleter) >= 0) {
-        // Not using an arrow function to preserve context passed from call site
-        return function () {
-            // Return an async test method that returns a Promise if AsyncTestCompleter is one of
-            // the injected tokens.
-            return testBed.compileComponents().then(() => {
-                const 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