@angular/core 19.2.0-rc.0 → 20.0.0-next.0

package/fesm2022/testing.mjs

@@ -1,5 +1,5 @@
 /**
- * @license Angular v19.2.0-rc.0
+ * @license Angular v20.0.0-next.0
  * (c) 2010-2024 Google LLC. https://angular.io/
  * License: MIT
  */
@@ -175,10 +175,10 @@ class TestBedApplicationErrorHandler {
             throw e;
         }
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.0-rc.0", ngImport: i0, type: TestBedApplicationErrorHandler, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.0-rc.0", ngImport: i0, type: TestBedApplicationErrorHandler });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.0-next.0", ngImport: i0, type: TestBedApplicationErrorHandler, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.0.0-next.0", ngImport: i0, type: TestBedApplicationErrorHandler });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.0-rc.0", ngImport: i0, type: TestBedApplicationErrorHandler, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.0.0-next.0", ngImport: i0, type: TestBedApplicationErrorHandler, decorators: [{
             type: Injectable
         }] });
 
@@ -257,6 +257,17 @@ class ComponentFixture {
         this._ngZone.runOutsideAngular(() => {
             this.subscriptions.add(this._ngZone.onError.subscribe({
                 next: (error) => {
+                    // The rethrow here is to ensure that errors don't go unreported. Since `NgZone.onHandleError` returns `false`,
+                    // ZoneJS will not throw the error coming out of a task. Instead, the handling is defined by
+                    // the chain of parent delegates and whether they indicate the error is handled in some way (by returning `false`).
+                    // Unfortunately, 'onError' does not forward the information about whether the error was handled by a parent zone
+                    // so cannot know here whether throwing is appropriate. As a half-solution, we can check to see if we're inside
+                    // a fakeAsync context, which we know has its own error handling.
+                    // https://github.com/angular/angular/blob/db2f2d99c82aae52d8a0ae46616c6411d070b35e/packages/zone.js/lib/zone-spec/fake-async-test.ts#L783-L784
+                    // https://github.com/angular/angular/blob/db2f2d99c82aae52d8a0ae46616c6411d070b35e/packages/zone.js/lib/zone-spec/fake-async-test.ts#L473-L478
+                    if (typeof Zone === 'undefined' || Zone.current.get('FakeAsyncTestZoneSpec')) {
+                        return;
+                    }
                     throw error;
                 },
             }));
@@ -2308,6 +2319,697 @@ const __core_private_testing_placeholder__ = '';
  * Entry point for all public APIs of the core/testing package.
  */
 
+/**
+ * Fake implementation of user agent history and navigation behavior. This is a
+ * high-fidelity implementation of browser behavior that attempts to emulate
+ * things like traversal delay.
+ */
+class FakeNavigation {
+    window;
+    /**
+     * The fake implementation of an entries array. Only same-document entries
+     * allowed.
+     */
+    entriesArr = [];
+    /**
+     * The current active entry index into `entriesArr`.
+     */
+    currentEntryIndex = 0;
+    /**
+     * The current navigate event.
+     */
+    navigateEvent = undefined;
+    /**
+     * A Map of pending traversals, so that traversals to the same entry can be
+     * re-used.
+     */
+    traversalQueue = new Map();
+    /**
+     * A Promise that resolves when the previous traversals have finished. Used to
+     * simulate the cross-process communication necessary for traversals.
+     */
+    nextTraversal = Promise.resolve();
+    /**
+     * A prospective current active entry index, which includes unresolved
+     * traversals. Used by `go` to determine where navigations are intended to go.
+     */
+    prospectiveEntryIndex = 0;
+    /**
+     * A test-only option to make traversals synchronous, rather than emulate
+     * cross-process communication.
+     */
+    synchronousTraversals = false;
+    /** Whether to allow a call to setInitialEntryForTesting. */
+    canSetInitialEntry = true;
+    /** `EventTarget` to dispatch events. */
+    eventTarget;
+    /** The next unique id for created entries. Replace recreates this id. */
+    nextId = 0;
+    /** The next unique key for created entries. Replace inherits this id. */
+    nextKey = 0;
+    /** Whether this fake is disposed. */
+    disposed = false;
+    /** Equivalent to `navigation.currentEntry`. */
+    get currentEntry() {
+        return this.entriesArr[this.currentEntryIndex];
+    }
+    get canGoBack() {
+        return this.currentEntryIndex > 0;
+    }
+    get canGoForward() {
+        return this.currentEntryIndex < this.entriesArr.length - 1;
+    }
+    constructor(window, startURL) {
+        this.window = window;
+        this.eventTarget = this.window.document.createElement('div');
+        // First entry.
+        this.setInitialEntryForTesting(startURL);
+    }
+    /**
+     * Sets the initial entry.
+     */
+    setInitialEntryForTesting(url, options = { historyState: null }) {
+        if (!this.canSetInitialEntry) {
+            throw new Error('setInitialEntryForTesting can only be called before any ' + 'navigation has occurred');
+        }
+        const currentInitialEntry = this.entriesArr[0];
+        this.entriesArr[0] = new FakeNavigationHistoryEntry(new URL(url).toString(), {
+            index: 0,
+            key: currentInitialEntry?.key ?? String(this.nextKey++),
+            id: currentInitialEntry?.id ?? String(this.nextId++),
+            sameDocument: true,
+            historyState: options?.historyState,
+            state: options.state,
+        });
+    }
+    /** Returns whether the initial entry is still eligible to be set. */
+    canSetInitialEntryForTesting() {
+        return this.canSetInitialEntry;
+    }
+    /**
+     * Sets whether to emulate traversals as synchronous rather than
+     * asynchronous.
+     */
+    setSynchronousTraversalsForTesting(synchronousTraversals) {
+        this.synchronousTraversals = synchronousTraversals;
+    }
+    /** Equivalent to `navigation.entries()`. */
+    entries() {
+        return this.entriesArr.slice();
+    }
+    /** Equivalent to `navigation.navigate()`. */
+    navigate(url, options) {
+        const fromUrl = new URL(this.currentEntry.url);
+        const toUrl = new URL(url, this.currentEntry.url);
+        let navigationType;
+        if (!options?.history || options.history === 'auto') {
+            // Auto defaults to push, but if the URLs are the same, is a replace.
+            if (fromUrl.toString() === toUrl.toString()) {
+                navigationType = 'replace';
+            }
+            else {
+                navigationType = 'push';
+            }
+        }
+        else {
+            navigationType = options.history;
+        }
+        const hashChange = isHashChange(fromUrl, toUrl);
+        const destination = new FakeNavigationDestination({
+            url: toUrl.toString(),
+            state: options?.state,
+            sameDocument: hashChange,
+            historyState: null,
+        });
+        const result = new InternalNavigationResult();
+        this.userAgentNavigate(destination, result, {
+            navigationType,
+            cancelable: true,
+            canIntercept: true,
+            // Always false for navigate().
+            userInitiated: false,
+            hashChange,
+            info: options?.info,
+        });
+        return {
+            committed: result.committed,
+            finished: result.finished,
+        };
+    }
+    /** Equivalent to `history.pushState()`. */
+    pushState(data, title, url) {
+        this.pushOrReplaceState('push', data, title, url);
+    }
+    /** Equivalent to `history.replaceState()`. */
+    replaceState(data, title, url) {
+        this.pushOrReplaceState('replace', data, title, url);
+    }
+    pushOrReplaceState(navigationType, data, _title, url) {
+        const fromUrl = new URL(this.currentEntry.url);
+        const toUrl = url ? new URL(url, this.currentEntry.url) : fromUrl;
+        const hashChange = isHashChange(fromUrl, toUrl);
+        const destination = new FakeNavigationDestination({
+            url: toUrl.toString(),
+            sameDocument: true,
+            historyState: data,
+        });
+        const result = new InternalNavigationResult();
+        this.userAgentNavigate(destination, result, {
+            navigationType,
+            cancelable: true,
+            canIntercept: true,
+            // Always false for pushState() or replaceState().
+            userInitiated: false,
+            hashChange,
+            skipPopState: true,
+        });
+    }
+    /** Equivalent to `navigation.traverseTo()`. */
+    traverseTo(key, options) {
+        const fromUrl = new URL(this.currentEntry.url);
+        const entry = this.findEntry(key);
+        if (!entry) {
+            const domException = new DOMException('Invalid key', 'InvalidStateError');
+            const committed = Promise.reject(domException);
+            const finished = Promise.reject(domException);
+            committed.catch(() => { });
+            finished.catch(() => { });
+            return {
+                committed,
+                finished,
+            };
+        }
+        if (entry === this.currentEntry) {
+            return {
+                committed: Promise.resolve(this.currentEntry),
+                finished: Promise.resolve(this.currentEntry),
+            };
+        }
+        if (this.traversalQueue.has(entry.key)) {
+            const existingResult = this.traversalQueue.get(entry.key);
+            return {
+                committed: existingResult.committed,
+                finished: existingResult.finished,
+            };
+        }
+        const hashChange = isHashChange(fromUrl, new URL(entry.url, this.currentEntry.url));
+        const destination = new FakeNavigationDestination({
+            url: entry.url,
+            state: entry.getState(),
+            historyState: entry.getHistoryState(),
+            key: entry.key,
+            id: entry.id,
+            index: entry.index,
+            sameDocument: entry.sameDocument,
+        });
+        this.prospectiveEntryIndex = entry.index;
+        const result = new InternalNavigationResult();
+        this.traversalQueue.set(entry.key, result);
+        this.runTraversal(() => {
+            this.traversalQueue.delete(entry.key);
+            this.userAgentNavigate(destination, result, {
+                navigationType: 'traverse',
+                cancelable: true,
+                canIntercept: true,
+                // Always false for traverseTo().
+                userInitiated: false,
+                hashChange,
+                info: options?.info,
+            });
+        });
+        return {
+            committed: result.committed,
+            finished: result.finished,
+        };
+    }
+    /** Equivalent to `navigation.back()`. */
+    back(options) {
+        if (this.currentEntryIndex === 0) {
+            const domException = new DOMException('Cannot go back', 'InvalidStateError');
+            const committed = Promise.reject(domException);
+            const finished = Promise.reject(domException);
+            committed.catch(() => { });
+            finished.catch(() => { });
+            return {
+                committed,
+                finished,
+            };
+        }
+        const entry = this.entriesArr[this.currentEntryIndex - 1];
+        return this.traverseTo(entry.key, options);
+    }
+    /** Equivalent to `navigation.forward()`. */
+    forward(options) {
+        if (this.currentEntryIndex === this.entriesArr.length - 1) {
+            const domException = new DOMException('Cannot go forward', 'InvalidStateError');
+            const committed = Promise.reject(domException);
+            const finished = Promise.reject(domException);
+            committed.catch(() => { });
+            finished.catch(() => { });
+            return {
+                committed,
+                finished,
+            };
+        }
+        const entry = this.entriesArr[this.currentEntryIndex + 1];
+        return this.traverseTo(entry.key, options);
+    }
+    /**
+     * Equivalent to `history.go()`.
+     * Note that this method does not actually work precisely to how Chrome
+     * does, instead choosing a simpler model with less unexpected behavior.
+     * Chrome has a few edge case optimizations, for instance with repeated
+     * `back(); forward()` chains it collapses certain traversals.
+     */
+    go(direction) {
+        const targetIndex = this.prospectiveEntryIndex + direction;
+        if (targetIndex >= this.entriesArr.length || targetIndex < 0) {
+            return;
+        }
+        this.prospectiveEntryIndex = targetIndex;
+        this.runTraversal(() => {
+            // Check again that destination is in the entries array.
+            if (targetIndex >= this.entriesArr.length || targetIndex < 0) {
+                return;
+            }
+            const fromUrl = new URL(this.currentEntry.url);
+            const entry = this.entriesArr[targetIndex];
+            const hashChange = isHashChange(fromUrl, new URL(entry.url, this.currentEntry.url));
+            const destination = new FakeNavigationDestination({
+                url: entry.url,
+                state: entry.getState(),
+                historyState: entry.getHistoryState(),
+                key: entry.key,
+                id: entry.id,
+                index: entry.index,
+                sameDocument: entry.sameDocument,
+            });
+            const result = new InternalNavigationResult();
+            this.userAgentNavigate(destination, result, {
+                navigationType: 'traverse',
+                cancelable: true,
+                canIntercept: true,
+                // Always false for go().
+                userInitiated: false,
+                hashChange,
+            });
+        });
+    }
+    /** Runs a traversal synchronously or asynchronously */
+    runTraversal(traversal) {
+        if (this.synchronousTraversals) {
+            traversal();
+            return;
+        }
+        // Each traversal occupies a single timeout resolution.
+        // This means that Promises added to commit and finish should resolve
+        // before the next traversal.
+        this.nextTraversal = this.nextTraversal.then(() => {
+            return new Promise((resolve) => {
+                setTimeout(() => {
+                    resolve();
+                    traversal();
+                });
+            });
+        });
+    }
+    /** Equivalent to `navigation.addEventListener()`. */
+    addEventListener(type, callback, options) {
+        this.eventTarget.addEventListener(type, callback, options);
+    }
+    /** Equivalent to `navigation.removeEventListener()`. */
+    removeEventListener(type, callback, options) {
+        this.eventTarget.removeEventListener(type, callback, options);
+    }
+    /** Equivalent to `navigation.dispatchEvent()` */
+    dispatchEvent(event) {
+        return this.eventTarget.dispatchEvent(event);
+    }
+    /** Cleans up resources. */
+    dispose() {
+        // Recreate eventTarget to release current listeners.
+        // `document.createElement` because NodeJS `EventTarget` is incompatible with Domino's `Event`.
+        this.eventTarget = this.window.document.createElement('div');
+        this.disposed = true;
+    }
+    /** Returns whether this fake is disposed. */
+    isDisposed() {
+        return this.disposed;
+    }
+    /** Implementation for all navigations and traversals. */
+    userAgentNavigate(destination, result, options) {
+        // The first navigation should disallow any future calls to set the initial
+        // entry.
+        this.canSetInitialEntry = false;
+        if (this.navigateEvent) {
+            this.navigateEvent.cancel(new DOMException('Navigation was aborted', 'AbortError'));
+            this.navigateEvent = undefined;
+        }
+        const navigateEvent = createFakeNavigateEvent({
+            navigationType: options.navigationType,
+            cancelable: options.cancelable,
+            canIntercept: options.canIntercept,
+            userInitiated: options.userInitiated,
+            hashChange: options.hashChange,
+            signal: result.signal,
+            destination,
+            info: options.info,
+            sameDocument: destination.sameDocument,
+            skipPopState: options.skipPopState,
+            result,
+            userAgentCommit: () => {
+                this.userAgentCommit();
+            },
+        });
+        this.navigateEvent = navigateEvent;
+        this.eventTarget.dispatchEvent(navigateEvent);
+        navigateEvent.dispatchedNavigateEvent();
+        if (navigateEvent.commitOption === 'immediate') {
+            navigateEvent.commit(/* internal= */ true);
+        }
+    }
+    /** Implementation to commit a navigation. */
+    userAgentCommit() {
+        if (!this.navigateEvent) {
+            return;
+        }
+        const from = this.currentEntry;
+        if (!this.navigateEvent.sameDocument) {
+            const error = new Error('Cannot navigate to a non-same-document URL.');
+            this.navigateEvent.cancel(error);
+            throw error;
+        }
+        if (this.navigateEvent.navigationType === 'push' ||
+            this.navigateEvent.navigationType === 'replace') {
+            this.userAgentPushOrReplace(this.navigateEvent.destination, {
+                navigationType: this.navigateEvent.navigationType,
+            });
+        }
+        else if (this.navigateEvent.navigationType === 'traverse') {
+            this.userAgentTraverse(this.navigateEvent.destination);
+        }
+        this.navigateEvent.userAgentNavigated(this.currentEntry);
+        const currentEntryChangeEvent = createFakeNavigationCurrentEntryChangeEvent({
+            from,
+            navigationType: this.navigateEvent.navigationType,
+        });
+        this.eventTarget.dispatchEvent(currentEntryChangeEvent);
+        if (!this.navigateEvent.skipPopState) {
+            const popStateEvent = createPopStateEvent({
+                state: this.navigateEvent.destination.getHistoryState(),
+            });
+            this.window.dispatchEvent(popStateEvent);
+        }
+    }
+    /** Implementation for a push or replace navigation. */
+    userAgentPushOrReplace(destination, { navigationType }) {
+        if (navigationType === 'push') {
+            this.currentEntryIndex++;
+            this.prospectiveEntryIndex = this.currentEntryIndex;
+        }
+        const index = this.currentEntryIndex;
+        const key = navigationType === 'push' ? String(this.nextKey++) : this.currentEntry.key;
+        const entry = new FakeNavigationHistoryEntry(destination.url, {
+            id: String(this.nextId++),
+            key,
+            index,
+            sameDocument: true,
+            state: destination.getState(),
+            historyState: destination.getHistoryState(),
+        });
+        if (navigationType === 'push') {
+            this.entriesArr.splice(index, Infinity, entry);
+        }
+        else {
+            this.entriesArr[index] = entry;
+        }
+    }
+    /** Implementation for a traverse navigation. */
+    userAgentTraverse(destination) {
+        this.currentEntryIndex = destination.index;
+    }
+    /** Utility method for finding entries with the given `key`. */
+    findEntry(key) {
+        for (const entry of this.entriesArr) {
+            if (entry.key === key)
+                return entry;
+        }
+        return undefined;
+    }
+    set onnavigate(
+    // tslint:disable-next-line:no-any
+    _handler) {
+        throw new Error('unimplemented');
+    }
+    // tslint:disable-next-line:no-any
+    get onnavigate() {
+        throw new Error('unimplemented');
+    }
+    set oncurrententrychange(_handler) {
+        throw new Error('unimplemented');
+    }
+    get oncurrententrychange() {
+        throw new Error('unimplemented');
+    }
+    set onnavigatesuccess(
+    // tslint:disable-next-line:no-any
+    _handler) {
+        throw new Error('unimplemented');
+    }
+    // tslint:disable-next-line:no-any
+    get onnavigatesuccess() {
+        throw new Error('unimplemented');
+    }
+    set onnavigateerror(
+    // tslint:disable-next-line:no-any
+    _handler) {
+        throw new Error('unimplemented');
+    }
+    // tslint:disable-next-line:no-any
+    get onnavigateerror() {
+        throw new Error('unimplemented');
+    }
+    get transition() {
+        throw new Error('unimplemented');
+    }
+    updateCurrentEntry(_options) {
+        throw new Error('unimplemented');
+    }
+    reload(_options) {
+        throw new Error('unimplemented');
+    }
+}
+/**
+ * Fake equivalent of `NavigationHistoryEntry`.
+ */
+class FakeNavigationHistoryEntry {
+    url;
+    sameDocument;
+    id;
+    key;
+    index;
+    state;
+    historyState;
+    // tslint:disable-next-line:no-any
+    ondispose = null;
+    constructor(url, { id, key, index, sameDocument, state, historyState, }) {
+        this.url = url;
+        this.id = id;
+        this.key = key;
+        this.index = index;
+        this.sameDocument = sameDocument;
+        this.state = state;
+        this.historyState = historyState;
+    }
+    getState() {
+        // Budget copy.
+        return this.state ? JSON.parse(JSON.stringify(this.state)) : this.state;
+    }
+    getHistoryState() {
+        // Budget copy.
+        return this.historyState
+            ? JSON.parse(JSON.stringify(this.historyState))
+            : this.historyState;
+    }
+    addEventListener(type, callback, options) {
+        throw new Error('unimplemented');
+    }
+    removeEventListener(type, callback, options) {
+        throw new Error('unimplemented');
+    }
+    dispatchEvent(event) {
+        throw new Error('unimplemented');
+    }
+}
+/**
+ * Create a fake equivalent of `NavigateEvent`. This is not a class because ES5
+ * transpiled JavaScript cannot extend native Event.
+ */
+function createFakeNavigateEvent({ cancelable, canIntercept, userInitiated, hashChange, navigationType, signal, destination, info, sameDocument, skipPopState, result, userAgentCommit, }) {
+    const event = new Event('navigate', { bubbles: false, cancelable });
+    event.canIntercept = canIntercept;
+    event.userInitiated = userInitiated;
+    event.hashChange = hashChange;
+    event.navigationType = navigationType;
+    event.signal = signal;
+    event.destination = destination;
+    event.info = info;
+    event.downloadRequest = null;
+    event.formData = null;
+    event.sameDocument = sameDocument;
+    event.skipPopState = skipPopState;
+    event.commitOption = 'immediate';
+    let handlerFinished = undefined;
+    let interceptCalled = false;
+    let dispatchedNavigateEvent = false;
+    let commitCalled = false;
+    event.intercept = function (options) {
+        interceptCalled = true;
+        event.sameDocument = true;
+        const handler = options?.handler;
+        if (handler) {
+            handlerFinished = handler();
+        }
+        if (options?.commit) {
+            event.commitOption = options.commit;
+        }
+        // TODO: handle focus reset and scroll?
+    };
+    event.scroll = function () {
+        // TODO: handle scroll?
+    };
+    event.commit = function (internal = false) {
+        if (!internal && !interceptCalled) {
+            throw new DOMException(`Failed to execute 'commit' on 'NavigateEvent': intercept() must be ` +
+                `called before commit().`, 'InvalidStateError');
+        }
+        if (!dispatchedNavigateEvent) {
+            throw new DOMException(`Failed to execute 'commit' on 'NavigateEvent': commit() may not be ` +
+                `called during event dispatch.`, 'InvalidStateError');
+        }
+        if (commitCalled) {
+            throw new DOMException(`Failed to execute 'commit' on 'NavigateEvent': commit() already ` + `called.`, 'InvalidStateError');
+        }
+        commitCalled = true;
+        userAgentCommit();
+    };
+    // Internal only.
+    event.cancel = function (reason) {
+        result.committedReject(reason);
+        result.finishedReject(reason);
+    };
+    // Internal only.
+    event.dispatchedNavigateEvent = function () {
+        dispatchedNavigateEvent = true;
+        if (event.commitOption === 'after-transition') {
+            // If handler finishes before commit, call commit.
+            handlerFinished?.then(() => {
+                if (!commitCalled) {
+                    event.commit(/* internal */ true);
+                }
+            }, () => { });
+        }
+        Promise.all([result.committed, handlerFinished]).then(([entry]) => {
+            result.finishedResolve(entry);
+        }, (reason) => {
+            result.finishedReject(reason);
+        });
+    };
+    // Internal only.
+    event.userAgentNavigated = function (entry) {
+        result.committedResolve(entry);
+    };
+    return event;
+}
+/**
+ * Create a fake equivalent of `NavigationCurrentEntryChange`. This does not use
+ * a class because ES5 transpiled JavaScript cannot extend native Event.
+ */
+function createFakeNavigationCurrentEntryChangeEvent({ from, navigationType, }) {
+    const event = new Event('currententrychange', {
+        bubbles: false,
+        cancelable: false,
+    });
+    event.from = from;
+    event.navigationType = navigationType;
+    return event;
+}
+/**
+ * Create a fake equivalent of `PopStateEvent`. This does not use a class
+ * because ES5 transpiled JavaScript cannot extend native Event.
+ */
+function createPopStateEvent({ state }) {
+    const event = new Event('popstate', {
+        bubbles: false,
+        cancelable: false,
+    });
+    event.state = state;
+    return event;
+}
+/**
+ * Fake equivalent of `NavigationDestination`.
+ */
+class FakeNavigationDestination {
+    url;
+    sameDocument;
+    key;
+    id;
+    index;
+    state;
+    historyState;
+    constructor({ url, sameDocument, historyState, state, key = null, id = null, index = -1, }) {
+        this.url = url;
+        this.sameDocument = sameDocument;
+        this.state = state;
+        this.historyState = historyState;
+        this.key = key;
+        this.id = id;
+        this.index = index;
+    }
+    getState() {
+        return this.state;
+    }
+    getHistoryState() {
+        return this.historyState;
+    }
+}
+/** Utility function to determine whether two UrlLike have the same hash. */
+function isHashChange(from, to) {
+    return (to.hash !== from.hash &&
+        to.hostname === from.hostname &&
+        to.pathname === from.pathname &&
+        to.search === from.search);
+}
+/** Internal utility class for representing the result of a navigation.  */
+class InternalNavigationResult {
+    committedResolve;
+    committedReject;
+    finishedResolve;
+    finishedReject;
+    committed;
+    finished;
+    get signal() {
+        return this.abortController.signal;
+    }
+    abortController = new AbortController();
+    constructor() {
+        this.committed = new Promise((resolve, reject) => {
+            this.committedResolve = resolve;
+            this.committedReject = reject;
+        });
+        this.finished = new Promise(async (resolve, reject) => {
+            this.finishedResolve = resolve;
+            this.finishedReject = (reason) => {
+                reject(reason);
+                this.abortController.abort(reason);
+            };
+        });
+        // All rejections are handled.
+        this.committed.catch(() => { });
+        this.finished.catch(() => { });
+    }
+}
+
 /// <reference types="jasmine" />
 // This file only reexports content of the `src` folder. Keep it that way.
 
@@ -2317,5 +3019,5 @@ const __core_private_testing_placeholder__ = '';
  * Generated bundle index. Do not edit.
  */
 
-export { ComponentFixture, ComponentFixtureAutoDetect, ComponentFixtureNoNgZone, DeferBlockFixture, InjectSetupWrapper, TestBed, TestComponentRenderer, __core_private_testing_placeholder__, discardPeriodicTasks, fakeAsync, flush, flushMicrotasks, getTestBed, inject, resetFakeAsyncZone, tick, waitForAsync, withModule, MetadataOverrider as ɵMetadataOverrider };
+export { ComponentFixture, ComponentFixtureAutoDetect, ComponentFixtureNoNgZone, DeferBlockFixture, InjectSetupWrapper, TestBed, TestComponentRenderer, __core_private_testing_placeholder__, discardPeriodicTasks, fakeAsync, flush, flushMicrotasks, getTestBed, inject, resetFakeAsyncZone, tick, waitForAsync, withModule, FakeNavigation as ɵFakeNavigation, MetadataOverrider as ɵMetadataOverrider };
 //# sourceMappingURL=testing.mjs.map