/**
 * @fileoverview added by tsickle
 * Generated from: packages/compiler/testing/src/resource_loader_mock.ts
 * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
/**
 * @license
 * Copyright Google Inc. 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
 */
import { ResourceLoader } from '@angular/compiler';
/**
 * A mock implementation of {\@link ResourceLoader} that allows outgoing requests to be mocked
 * and responded to within a single test, without going to the network.
 */
export class MockResourceLoader extends ResourceLoader {
    constructor() {
        super(...arguments);
        this._expectations = [];
        this._definitions = new Map();
        this._requests = [];
    }
    /**
     * @param {?} url
     * @return {?}
     */
    get(url) {
        /** @type {?} */
        const request = new _PendingRequest(url);
        this._requests.push(request);
        return request.getPromise();
    }
    /**
     * @return {?}
     */
    hasPendingRequests() { return !!this._requests.length; }
    /**
     * Add an expectation for the given URL. Incoming requests will be checked against
     * the next expectation (in FIFO order). The `verifyNoOutstandingExpectations` method
     * can be used to check if any expectations have not yet been met.
     *
     * The response given will be returned if the expectation matches.
     * @param {?} url
     * @param {?} response
     * @return {?}
     */
    expect(url, response) {
        /** @type {?} */
        const expectation = new _Expectation(url, response);
        this._expectations.push(expectation);
    }
    /**
     * Add a definition for the given URL to return the given response. Unlike expectations,
     * definitions have no order and will satisfy any matching request at any time. Also
     * unlike expectations, unused definitions do not cause `verifyNoOutstandingExpectations`
     * to return an error.
     * @param {?} url
     * @param {?} response
     * @return {?}
     */
    when(url, response) { this._definitions.set(url, response); }
    /**
     * Process pending requests and verify there are no outstanding expectations. Also fails
     * if no requests are pending.
     * @return {?}
     */
    flush() {
        if (this._requests.length === 0) {
            throw new Error('No pending requests to flush');
        }
        do {
            this._processRequest((/** @type {?} */ (this._requests.shift())));
        } while (this._requests.length > 0);
        this.verifyNoOutstandingExpectations();
    }
    /**
     * Throw an exception if any expectations have not been satisfied.
     * @return {?}
     */
    verifyNoOutstandingExpectations() {
        if (this._expectations.length === 0)
            return;
        /** @type {?} */
        const urls = [];
        for (let i = 0; i < this._expectations.length; i++) {
            /** @type {?} */
            const expectation = this._expectations[i];
            urls.push(expectation.url);
        }
        throw new Error(`Unsatisfied requests: ${urls.join(', ')}`);
    }
    /**
     * @private
     * @param {?} request
     * @return {?}
     */
    _processRequest(request) {
        /** @type {?} */
        const url = request.url;
        if (this._expectations.length > 0) {
            /** @type {?} */
            const expectation = this._expectations[0];
            if (expectation.url == url) {
                remove(this._expectations, expectation);
                request.complete(expectation.response);
                return;
            }
        }
        if (this._definitions.has(url)) {
            /** @type {?} */
            const response = this._definitions.get(url);
            request.complete(response == null ? null : response);
            return;
        }
        throw new Error(`Unexpected request ${url}`);
    }
}
if (false) {
    /**
     * @type {?}
     * @private
     */
    MockResourceLoader.prototype._expectations;
    /**
     * @type {?}
     * @private
     */
    MockResourceLoader.prototype._definitions;
    /**
     * @type {?}
     * @private
     */
    MockResourceLoader.prototype._requests;
}
class _PendingRequest {
    /**
     * @param {?} url
     */
    constructor(url) {
        this.url = url;
        this.promise = new Promise((/**
         * @param {?} res
         * @param {?} rej
         * @return {?}
         */
        (res, rej) => {
            this.resolve = res;
            this.reject = rej;
        }));
    }
    /**
     * @param {?} response
     * @return {?}
     */
    complete(response) {
        if (response == null) {
            this.reject(`Failed to load ${this.url}`);
        }
        else {
            this.resolve(response);
        }
    }
    /**
     * @return {?}
     */
    getPromise() { return this.promise; }
}
if (false) {
    /** @type {?} */
    _PendingRequest.prototype.resolve;
    /** @type {?} */
    _PendingRequest.prototype.reject;
    /** @type {?} */
    _PendingRequest.prototype.promise;
    /** @type {?} */
    _PendingRequest.prototype.url;
}
class _Expectation {
    /**
     * @param {?} url
     * @param {?} response
     */
    constructor(url, response) {
        this.url = url;
        this.response = response;
    }
}
if (false) {
    /** @type {?} */
    _Expectation.prototype.url;
    /** @type {?} */
    _Expectation.prototype.response;
}
/**
 * @template T
 * @param {?} list
 * @param {?} el
 * @return {?}
 */
function remove(list, el) {
    /** @type {?} */
    const index = list.indexOf(el);
    if (index > -1) {
        list.splice(index, 1);
    }
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"resource_loader_mock.js","sourceRoot":"","sources":["../../../../../../../packages/compiler/testing/src/resource_loader_mock.ts"],"names":[],"mappings":"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","sourcesContent":["/**\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\nimport {ResourceLoader} from '@angular/compiler';\n\n/**\n * A mock implementation of {@link ResourceLoader} that allows outgoing requests to be mocked\n * and responded to within a single test, without going to the network.\n */\nexport class MockResourceLoader extends ResourceLoader {\n  private _expectations: _Expectation[] = [];\n  private _definitions = new Map<string, string>();\n  private _requests: _PendingRequest[] = [];\n\n  get(url: string): Promise<string> {\n    const request = new _PendingRequest(url);\n    this._requests.push(request);\n    return request.getPromise();\n  }\n\n  hasPendingRequests() { return !!this._requests.length; }\n\n  /**\n   * Add an expectation for the given URL. Incoming requests will be checked against\n   * the next expectation (in FIFO order). The `verifyNoOutstandingExpectations` method\n   * can be used to check if any expectations have not yet been met.\n   *\n   * The response given will be returned if the expectation matches.\n   */\n  expect(url: string, response: string) {\n    const expectation = new _Expectation(url, response);\n    this._expectations.push(expectation);\n  }\n\n  /**\n   * Add a definition for the given URL to return the given response. Unlike expectations,\n   * definitions have no order and will satisfy any matching request at any time. Also\n   * unlike expectations, unused definitions do not cause `verifyNoOutstandingExpectations`\n   * to return an error.\n   */\n  when(url: string, response: string) { this._definitions.set(url, response); }\n\n  /**\n   * Process pending requests and verify there are no outstanding expectations. Also fails\n   * if no requests are pending.\n   */\n  flush() {\n    if (this._requests.length === 0) {\n      throw new Error('No pending requests to flush');\n    }\n\n    do {\n      this._processRequest(this._requests.shift() !);\n    } while (this._requests.length > 0);\n\n    this.verifyNoOutstandingExpectations();\n  }\n\n  /**\n   * Throw an exception if any expectations have not been satisfied.\n   */\n  verifyNoOutstandingExpectations() {\n    if (this._expectations.length === 0) return;\n\n    const urls: string[] = [];\n    for (let i = 0; i < this._expectations.length; i++) {\n      const expectation = this._expectations[i];\n      urls.push(expectation.url);\n    }\n\n    throw new Error(`Unsatisfied requests: ${urls.join(', ')}`);\n  }\n\n  private _processRequest(request: _PendingRequest) {\n    const url = request.url;\n\n    if (this._expectations.length > 0) {\n      const expectation = this._expectations[0];\n      if (expectation.url == url) {\n        remove(this._expectations, expectation);\n        request.complete(expectation.response);\n        return;\n      }\n    }\n\n    if (this._definitions.has(url)) {\n      const response = this._definitions.get(url);\n      request.complete(response == null ? null : response);\n      return;\n    }\n\n    throw new Error(`Unexpected request ${url}`);\n  }\n}\n\nclass _PendingRequest {\n  // TODO(issue/24571): remove '!'.\n  resolve !: (result: string) => void;\n  // TODO(issue/24571): remove '!'.\n  reject !: (error: any) => void;\n  promise: Promise<string>;\n\n  constructor(public url: string) {\n    this.promise = new Promise((res, rej) => {\n      this.resolve = res;\n      this.reject = rej;\n    });\n  }\n\n  complete(response: string|null) {\n    if (response == null) {\n      this.reject(`Failed to load ${this.url}`);\n    } else {\n      this.resolve(response);\n    }\n  }\n\n  getPromise(): Promise<string> { return this.promise; }\n}\n\nclass _Expectation {\n  url: string;\n  response: string;\n  constructor(url: string, response: string) {\n    this.url = url;\n    this.response = response;\n  }\n}\n\nfunction remove<T>(list: T[], el: T): void {\n  const index = list.indexOf(el);\n  if (index > -1) {\n    list.splice(index, 1);\n  }\n}\n"]}