| (function (global, factory) { |
| typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('rxjs')) : |
| typeof define === 'function' && define.amd ? define('@angular/cdk/testing', ['exports', 'rxjs'], factory) : |
| (global = global || self, factory((global.ng = global.ng || {}, global.ng.cdk = global.ng.cdk || {}, global.ng.cdk.testing = {}), global.rxjs)); |
| }(this, (function (exports, rxjs) { 'use strict'; |
| |
| /*! ***************************************************************************** |
| Copyright (c) Microsoft Corporation. |
| |
| Permission to use, copy, modify, and/or distribute this software for any |
| purpose with or without fee is hereby granted. |
| |
| THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH |
| REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY |
| AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, |
| INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM |
| LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR |
| OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR |
| PERFORMANCE OF THIS SOFTWARE. |
| ***************************************************************************** */ |
| /* global Reflect, Promise */ |
| var extendStatics = function (d, b) { |
| extendStatics = Object.setPrototypeOf || |
| ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || |
| function (d, b) { for (var p in b) |
| if (Object.prototype.hasOwnProperty.call(b, p)) |
| d[p] = b[p]; }; |
| return extendStatics(d, b); |
| }; |
| function __extends(d, b) { |
| if (typeof b !== "function" && b !== null) |
| throw new TypeError("Class extends value " + String(b) + " is not a constructor or null"); |
| extendStatics(d, b); |
| function __() { this.constructor = d; } |
| d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); |
| } |
| var __assign = function () { |
| __assign = Object.assign || function __assign(t) { |
| for (var s, i = 1, n = arguments.length; i < n; i++) { |
| s = arguments[i]; |
| for (var p in s) |
| if (Object.prototype.hasOwnProperty.call(s, p)) |
| t[p] = s[p]; |
| } |
| return t; |
| }; |
| return __assign.apply(this, arguments); |
| }; |
| function __rest(s, e) { |
| var t = {}; |
| for (var p in s) |
| if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) |
| t[p] = s[p]; |
| if (s != null && typeof Object.getOwnPropertySymbols === "function") |
| for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) { |
| if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) |
| t[p[i]] = s[p[i]]; |
| } |
| return t; |
| } |
| function __decorate(decorators, target, key, desc) { |
| var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d; |
| if (typeof Reflect === "object" && typeof Reflect.decorate === "function") |
| r = Reflect.decorate(decorators, target, key, desc); |
| 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; |
| return c > 3 && r && Object.defineProperty(target, key, r), r; |
| } |
| function __param(paramIndex, decorator) { |
| return function (target, key) { decorator(target, key, paramIndex); }; |
| } |
| function __metadata(metadataKey, metadataValue) { |
| if (typeof Reflect === "object" && typeof Reflect.metadata === "function") |
| return Reflect.metadata(metadataKey, metadataValue); |
| } |
| function __awaiter(thisArg, _arguments, P, generator) { |
| function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } |
| return new (P || (P = Promise))(function (resolve, reject) { |
| function fulfilled(value) { try { |
| step(generator.next(value)); |
| } |
| catch (e) { |
| reject(e); |
| } } |
| function rejected(value) { try { |
| step(generator["throw"](value)); |
| } |
| catch (e) { |
| reject(e); |
| } } |
| function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } |
| step((generator = generator.apply(thisArg, _arguments || [])).next()); |
| }); |
| } |
| function __generator(thisArg, body) { |
| var _ = { label: 0, sent: function () { if (t[0] & 1) |
| throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g; |
| return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function () { return this; }), g; |
| function verb(n) { return function (v) { return step([n, v]); }; } |
| function step(op) { |
| if (f) |
| throw new TypeError("Generator is already executing."); |
| while (_) |
| try { |
| 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; |
| if (y = 0, t) |
| op = [op[0] & 2, t.value]; |
| switch (op[0]) { |
| case 0: |
| case 1: |
| t = op; |
| break; |
| case 4: |
| _.label++; |
| return { value: op[1], done: false }; |
| case 5: |
| _.label++; |
| y = op[1]; |
| op = [0]; |
| continue; |
| case 7: |
| op = _.ops.pop(); |
| _.trys.pop(); |
| continue; |
| default: |
| if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { |
| _ = 0; |
| continue; |
| } |
| if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { |
| _.label = op[1]; |
| break; |
| } |
| if (op[0] === 6 && _.label < t[1]) { |
| _.label = t[1]; |
| t = op; |
| break; |
| } |
| if (t && _.label < t[2]) { |
| _.label = t[2]; |
| _.ops.push(op); |
| break; |
| } |
| if (t[2]) |
| _.ops.pop(); |
| _.trys.pop(); |
| continue; |
| } |
| op = body.call(thisArg, _); |
| } |
| catch (e) { |
| op = [6, e]; |
| y = 0; |
| } |
| finally { |
| f = t = 0; |
| } |
| if (op[0] & 5) |
| throw op[1]; |
| return { value: op[0] ? op[1] : void 0, done: true }; |
| } |
| } |
| var __createBinding = Object.create ? (function (o, m, k, k2) { |
| if (k2 === undefined) |
| k2 = k; |
| Object.defineProperty(o, k2, { enumerable: true, get: function () { return m[k]; } }); |
| }) : (function (o, m, k, k2) { |
| if (k2 === undefined) |
| k2 = k; |
| o[k2] = m[k]; |
| }); |
| function __exportStar(m, o) { |
| for (var p in m) |
| if (p !== "default" && !Object.prototype.hasOwnProperty.call(o, p)) |
| __createBinding(o, m, p); |
| } |
| function __values(o) { |
| var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0; |
| if (m) |
| return m.call(o); |
| if (o && typeof o.length === "number") |
| return { |
| next: function () { |
| if (o && i >= o.length) |
| o = void 0; |
| return { value: o && o[i++], done: !o }; |
| } |
| }; |
| throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined."); |
| } |
| function __read(o, n) { |
| var m = typeof Symbol === "function" && o[Symbol.iterator]; |
| if (!m) |
| return o; |
| var i = m.call(o), r, ar = [], e; |
| try { |
| while ((n === void 0 || n-- > 0) && !(r = i.next()).done) |
| ar.push(r.value); |
| } |
| catch (error) { |
| e = { error: error }; |
| } |
| finally { |
| try { |
| if (r && !r.done && (m = i["return"])) |
| m.call(i); |
| } |
| finally { |
| if (e) |
| throw e.error; |
| } |
| } |
| return ar; |
| } |
| /** @deprecated */ |
| function __spread() { |
| for (var ar = [], i = 0; i < arguments.length; i++) |
| ar = ar.concat(__read(arguments[i])); |
| return ar; |
| } |
| /** @deprecated */ |
| function __spreadArrays() { |
| for (var s = 0, i = 0, il = arguments.length; i < il; i++) |
| s += arguments[i].length; |
| for (var r = Array(s), k = 0, i = 0; i < il; i++) |
| for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++) |
| r[k] = a[j]; |
| return r; |
| } |
| function __spreadArray(to, from) { |
| for (var i = 0, il = from.length, j = to.length; i < il; i++, j++) |
| to[j] = from[i]; |
| return to; |
| } |
| function __await(v) { |
| return this instanceof __await ? (this.v = v, this) : new __await(v); |
| } |
| function __asyncGenerator(thisArg, _arguments, generator) { |
| if (!Symbol.asyncIterator) |
| throw new TypeError("Symbol.asyncIterator is not defined."); |
| var g = generator.apply(thisArg, _arguments || []), i, q = []; |
| return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i; |
| function verb(n) { if (g[n]) |
| i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; } |
| function resume(n, v) { try { |
| step(g[n](v)); |
| } |
| catch (e) { |
| settle(q[0][3], e); |
| } } |
| function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); } |
| function fulfill(value) { resume("next", value); } |
| function reject(value) { resume("throw", value); } |
| function settle(f, v) { if (f(v), q.shift(), q.length) |
| resume(q[0][0], q[0][1]); } |
| } |
| function __asyncDelegator(o) { |
| var i, p; |
| return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i; |
| function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === "return" } : f ? f(v) : v; } : f; } |
| } |
| function __asyncValues(o) { |
| if (!Symbol.asyncIterator) |
| throw new TypeError("Symbol.asyncIterator is not defined."); |
| var m = o[Symbol.asyncIterator], i; |
| return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i); |
| function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; } |
| function settle(resolve, reject, d, v) { Promise.resolve(v).then(function (v) { resolve({ value: v, done: d }); }, reject); } |
| } |
| function __makeTemplateObject(cooked, raw) { |
| if (Object.defineProperty) { |
| Object.defineProperty(cooked, "raw", { value: raw }); |
| } |
| else { |
| cooked.raw = raw; |
| } |
| return cooked; |
| } |
| ; |
| var __setModuleDefault = Object.create ? (function (o, v) { |
| Object.defineProperty(o, "default", { enumerable: true, value: v }); |
| }) : function (o, v) { |
| o["default"] = v; |
| }; |
| function __importStar(mod) { |
| if (mod && mod.__esModule) |
| return mod; |
| var result = {}; |
| if (mod != null) |
| for (var k in mod) |
| if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) |
| __createBinding(result, mod, k); |
| __setModuleDefault(result, mod); |
| return result; |
| } |
| function __importDefault(mod) { |
| return (mod && mod.__esModule) ? mod : { default: mod }; |
| } |
| function __classPrivateFieldGet(receiver, privateMap) { |
| if (!privateMap.has(receiver)) { |
| throw new TypeError("attempted to get private field on non-instance"); |
| } |
| return privateMap.get(receiver); |
| } |
| function __classPrivateFieldSet(receiver, privateMap, value) { |
| if (!privateMap.has(receiver)) { |
| throw new TypeError("attempted to set private field on non-instance"); |
| } |
| privateMap.set(receiver, value); |
| return value; |
| } |
| |
| /** Subject used to dispatch and listen for changes to the auto change detection status . */ |
| var autoChangeDetectionSubject = new rxjs.BehaviorSubject({ |
| isDisabled: false |
| }); |
| /** The current subscription to `autoChangeDetectionSubject`. */ |
| var autoChangeDetectionSubscription; |
| /** |
| * The default handler for auto change detection status changes. This handler will be used if the |
| * specific environment does not install its own. |
| * @param status The new auto change detection status. |
| */ |
| function defaultAutoChangeDetectionHandler(status) { |
| var _a; |
| (_a = status.onDetectChangesNow) === null || _a === void 0 ? void 0 : _a.call(status); |
| } |
| /** |
| * Allows a test `HarnessEnvironment` to install its own handler for auto change detection status |
| * changes. |
| * @param handler The handler for the auto change detection status. |
| */ |
| function handleAutoChangeDetectionStatus(handler) { |
| stopHandlingAutoChangeDetectionStatus(); |
| autoChangeDetectionSubscription = autoChangeDetectionSubject.subscribe(handler); |
| } |
| /** Allows a `HarnessEnvironment` to stop handling auto change detection status changes. */ |
| function stopHandlingAutoChangeDetectionStatus() { |
| autoChangeDetectionSubscription === null || autoChangeDetectionSubscription === void 0 ? void 0 : autoChangeDetectionSubscription.unsubscribe(); |
| autoChangeDetectionSubscription = null; |
| } |
| /** |
| * Batches together triggering of change detection over the duration of the given function. |
| * @param fn The function to call with batched change detection. |
| * @param triggerBeforeAndAfter Optionally trigger change detection once before and after the batch |
| * operation. If false, change detection will not be triggered. |
| * @return The result of the given function. |
| */ |
| function batchChangeDetection(fn, triggerBeforeAndAfter) { |
| return __awaiter(this, void 0, void 0, function () { |
| return __generator(this, function (_b) { |
| switch (_b.label) { |
| case 0: |
| if (!autoChangeDetectionSubject.getValue().isDisabled) return [3 /*break*/, 2]; |
| return [4 /*yield*/, fn()]; |
| case 1: return [2 /*return*/, _b.sent()]; |
| case 2: |
| // If nothing is handling change detection batching, install the default handler. |
| if (!autoChangeDetectionSubscription) { |
| handleAutoChangeDetectionStatus(defaultAutoChangeDetectionHandler); |
| } |
| if (!triggerBeforeAndAfter) return [3 /*break*/, 9]; |
| return [4 /*yield*/, new Promise(function (resolve) { return autoChangeDetectionSubject.next({ |
| isDisabled: true, |
| onDetectChangesNow: resolve, |
| }); })]; |
| case 3: |
| _b.sent(); |
| _b.label = 4; |
| case 4: |
| _b.trys.push([4, , 6, 8]); |
| return [4 /*yield*/, fn()]; |
| case 5: return [2 /*return*/, _b.sent()]; |
| case 6: return [4 /*yield*/, new Promise(function (resolve) { return autoChangeDetectionSubject.next({ |
| isDisabled: false, |
| onDetectChangesNow: resolve, |
| }); })]; |
| case 7: |
| _b.sent(); |
| return [7 /*endfinally*/]; |
| case 8: return [3 /*break*/, 13]; |
| case 9: |
| autoChangeDetectionSubject.next({ isDisabled: true }); |
| _b.label = 10; |
| case 10: |
| _b.trys.push([10, , 12, 13]); |
| return [4 /*yield*/, fn()]; |
| case 11: return [2 /*return*/, _b.sent()]; |
| case 12: |
| autoChangeDetectionSubject.next({ isDisabled: false }); |
| return [7 /*endfinally*/]; |
| case 13: return [2 /*return*/]; |
| } |
| }); |
| }); |
| } |
| /** |
| * Disables the harness system's auto change detection for the duration of the given function. |
| * @param fn The function to disable auto change detection for. |
| * @return The result of the given function. |
| */ |
| function manualChangeDetection(fn) { |
| return __awaiter(this, void 0, void 0, function () { |
| return __generator(this, function (_b) { |
| return [2 /*return*/, batchChangeDetection(fn, false)]; |
| }); |
| }); |
| } |
| function parallel(values) { |
| return __awaiter(this, void 0, void 0, function () { |
| return __generator(this, function (_b) { |
| return [2 /*return*/, batchChangeDetection(function () { return Promise.all(values()); }, true)]; |
| }); |
| }); |
| } |
| |
| /** |
| * Base class for component harnesses that all component harness authors should extend. This base |
| * component harness provides the basic ability to locate element and sub-component harness. It |
| * should be inherited when defining user's own harness. |
| */ |
| var ComponentHarness = /** @class */ (function () { |
| function ComponentHarness(locatorFactory) { |
| this.locatorFactory = locatorFactory; |
| } |
| /** Gets a `Promise` for the `TestElement` representing the host element of the component. */ |
| ComponentHarness.prototype.host = function () { |
| return __awaiter(this, void 0, void 0, function () { |
| return __generator(this, function (_b) { |
| return [2 /*return*/, this.locatorFactory.rootElement]; |
| }); |
| }); |
| }; |
| /** |
| * Gets a `LocatorFactory` for the document root element. This factory can be used to create |
| * locators for elements that a component creates outside of its own root element. (e.g. by |
| * appending to document.body). |
| */ |
| ComponentHarness.prototype.documentRootLocatorFactory = function () { |
| return this.locatorFactory.documentRootLocatorFactory(); |
| }; |
| /** |
| * Creates an asynchronous locator function that can be used to find a `ComponentHarness` instance |
| * or element under the host element of this `ComponentHarness`. |
| * @param queries A list of queries specifying which harnesses and elements to search for: |
| * - A `string` searches for elements matching the CSS selector specified by the string. |
| * - A `ComponentHarness` constructor searches for `ComponentHarness` instances matching the |
| * given class. |
| * - A `HarnessPredicate` searches for `ComponentHarness` instances matching the given |
| * predicate. |
| * @return An asynchronous locator function that searches for and returns a `Promise` for the |
| * first element or harness matching the given search criteria. Matches are ordered first by |
| * order in the DOM, and second by order in the queries list. If no matches are found, the |
| * `Promise` rejects. The type that the `Promise` resolves to is a union of all result types for |
| * each query. |
| * |
| * e.g. Given the following DOM: `<div id="d1" /><div id="d2" />`, and assuming |
| * `DivHarness.hostSelector === 'div'`: |
| * - `await ch.locatorFor(DivHarness, 'div')()` gets a `DivHarness` instance for `#d1` |
| * - `await ch.locatorFor('div', DivHarness)()` gets a `TestElement` instance for `#d1` |
| * - `await ch.locatorFor('span')()` throws because the `Promise` rejects. |
| */ |
| ComponentHarness.prototype.locatorFor = function () { |
| var _b; |
| var queries = []; |
| for (var _i = 0; _i < arguments.length; _i++) { |
| queries[_i] = arguments[_i]; |
| } |
| return (_b = this.locatorFactory).locatorFor.apply(_b, __spread(queries)); |
| }; |
| /** |
| * Creates an asynchronous locator function that can be used to find a `ComponentHarness` instance |
| * or element under the host element of this `ComponentHarness`. |
| * @param queries A list of queries specifying which harnesses and elements to search for: |
| * - A `string` searches for elements matching the CSS selector specified by the string. |
| * - A `ComponentHarness` constructor searches for `ComponentHarness` instances matching the |
| * given class. |
| * - A `HarnessPredicate` searches for `ComponentHarness` instances matching the given |
| * predicate. |
| * @return An asynchronous locator function that searches for and returns a `Promise` for the |
| * first element or harness matching the given search criteria. Matches are ordered first by |
| * order in the DOM, and second by order in the queries list. If no matches are found, the |
| * `Promise` is resolved with `null`. The type that the `Promise` resolves to is a union of all |
| * result types for each query or null. |
| * |
| * e.g. Given the following DOM: `<div id="d1" /><div id="d2" />`, and assuming |
| * `DivHarness.hostSelector === 'div'`: |
| * - `await ch.locatorForOptional(DivHarness, 'div')()` gets a `DivHarness` instance for `#d1` |
| * - `await ch.locatorForOptional('div', DivHarness)()` gets a `TestElement` instance for `#d1` |
| * - `await ch.locatorForOptional('span')()` gets `null`. |
| */ |
| ComponentHarness.prototype.locatorForOptional = function () { |
| var _b; |
| var queries = []; |
| for (var _i = 0; _i < arguments.length; _i++) { |
| queries[_i] = arguments[_i]; |
| } |
| return (_b = this.locatorFactory).locatorForOptional.apply(_b, __spread(queries)); |
| }; |
| /** |
| * Creates an asynchronous locator function that can be used to find `ComponentHarness` instances |
| * or elements under the host element of this `ComponentHarness`. |
| * @param queries A list of queries specifying which harnesses and elements to search for: |
| * - A `string` searches for elements matching the CSS selector specified by the string. |
| * - A `ComponentHarness` constructor searches for `ComponentHarness` instances matching the |
| * given class. |
| * - A `HarnessPredicate` searches for `ComponentHarness` instances matching the given |
| * predicate. |
| * @return An asynchronous locator function that searches for and returns a `Promise` for all |
| * elements and harnesses matching the given search criteria. Matches are ordered first by |
| * order in the DOM, and second by order in the queries list. If an element matches more than |
| * one `ComponentHarness` class, the locator gets an instance of each for the same element. If |
| * an element matches multiple `string` selectors, only one `TestElement` instance is returned |
| * for that element. The type that the `Promise` resolves to is an array where each element is |
| * the union of all result types for each query. |
| * |
| * e.g. Given the following DOM: `<div id="d1" /><div id="d2" />`, and assuming |
| * `DivHarness.hostSelector === 'div'` and `IdIsD1Harness.hostSelector === '#d1'`: |
| * - `await ch.locatorForAll(DivHarness, 'div')()` gets `[ |
| * DivHarness, // for #d1 |
| * TestElement, // for #d1 |
| * DivHarness, // for #d2 |
| * TestElement // for #d2 |
| * ]` |
| * - `await ch.locatorForAll('div', '#d1')()` gets `[ |
| * TestElement, // for #d1 |
| * TestElement // for #d2 |
| * ]` |
| * - `await ch.locatorForAll(DivHarness, IdIsD1Harness)()` gets `[ |
| * DivHarness, // for #d1 |
| * IdIsD1Harness, // for #d1 |
| * DivHarness // for #d2 |
| * ]` |
| * - `await ch.locatorForAll('span')()` gets `[]`. |
| */ |
| ComponentHarness.prototype.locatorForAll = function () { |
| var _b; |
| var queries = []; |
| for (var _i = 0; _i < arguments.length; _i++) { |
| queries[_i] = arguments[_i]; |
| } |
| return (_b = this.locatorFactory).locatorForAll.apply(_b, __spread(queries)); |
| }; |
| /** |
| * Flushes change detection and async tasks in the Angular zone. |
| * In most cases it should not be necessary to call this manually. However, there may be some edge |
| * cases where it is needed to fully flush animation events. |
| */ |
| ComponentHarness.prototype.forceStabilize = function () { |
| return __awaiter(this, void 0, void 0, function () { |
| return __generator(this, function (_b) { |
| return [2 /*return*/, this.locatorFactory.forceStabilize()]; |
| }); |
| }); |
| }; |
| /** |
| * Waits for all scheduled or running async tasks to complete. This allows harness |
| * authors to wait for async tasks outside of the Angular zone. |
| */ |
| ComponentHarness.prototype.waitForTasksOutsideAngular = function () { |
| return __awaiter(this, void 0, void 0, function () { |
| return __generator(this, function (_b) { |
| return [2 /*return*/, this.locatorFactory.waitForTasksOutsideAngular()]; |
| }); |
| }); |
| }; |
| return ComponentHarness; |
| }()); |
| /** |
| * Base class for component harnesses that authors should extend if they anticipate that consumers |
| * of the harness may want to access other harnesses within the `<ng-content>` of the component. |
| */ |
| var ContentContainerComponentHarness = /** @class */ (function (_super) { |
| __extends(ContentContainerComponentHarness, _super); |
| function ContentContainerComponentHarness() { |
| return _super !== null && _super.apply(this, arguments) || this; |
| } |
| ContentContainerComponentHarness.prototype.getChildLoader = function (selector) { |
| return __awaiter(this, void 0, void 0, function () { |
| return __generator(this, function (_b) { |
| switch (_b.label) { |
| case 0: return [4 /*yield*/, this.getRootHarnessLoader()]; |
| case 1: return [2 /*return*/, (_b.sent()).getChildLoader(selector)]; |
| } |
| }); |
| }); |
| }; |
| ContentContainerComponentHarness.prototype.getAllChildLoaders = function (selector) { |
| return __awaiter(this, void 0, void 0, function () { |
| return __generator(this, function (_b) { |
| switch (_b.label) { |
| case 0: return [4 /*yield*/, this.getRootHarnessLoader()]; |
| case 1: return [2 /*return*/, (_b.sent()).getAllChildLoaders(selector)]; |
| } |
| }); |
| }); |
| }; |
| ContentContainerComponentHarness.prototype.getHarness = function (query) { |
| return __awaiter(this, void 0, void 0, function () { |
| return __generator(this, function (_b) { |
| switch (_b.label) { |
| case 0: return [4 /*yield*/, this.getRootHarnessLoader()]; |
| case 1: return [2 /*return*/, (_b.sent()).getHarness(query)]; |
| } |
| }); |
| }); |
| }; |
| ContentContainerComponentHarness.prototype.getAllHarnesses = function (query) { |
| return __awaiter(this, void 0, void 0, function () { |
| return __generator(this, function (_b) { |
| switch (_b.label) { |
| case 0: return [4 /*yield*/, this.getRootHarnessLoader()]; |
| case 1: return [2 /*return*/, (_b.sent()).getAllHarnesses(query)]; |
| } |
| }); |
| }); |
| }; |
| /** |
| * Gets the root harness loader from which to start |
| * searching for content contained by this harness. |
| */ |
| ContentContainerComponentHarness.prototype.getRootHarnessLoader = function () { |
| return __awaiter(this, void 0, void 0, function () { |
| return __generator(this, function (_b) { |
| return [2 /*return*/, this.locatorFactory.rootHarnessLoader()]; |
| }); |
| }); |
| }; |
| return ContentContainerComponentHarness; |
| }(ComponentHarness)); |
| /** |
| * A class used to associate a ComponentHarness class with predicates functions that can be used to |
| * filter instances of the class. |
| */ |
| var HarnessPredicate = /** @class */ (function () { |
| function HarnessPredicate(harnessType, options) { |
| this.harnessType = harnessType; |
| this._predicates = []; |
| this._descriptions = []; |
| this._addBaseOptions(options); |
| } |
| /** |
| * Checks if the specified nullable string value matches the given pattern. |
| * @param value The nullable string value to check, or a Promise resolving to the |
| * nullable string value. |
| * @param pattern The pattern the value is expected to match. If `pattern` is a string, |
| * `value` is expected to match exactly. If `pattern` is a regex, a partial match is |
| * allowed. If `pattern` is `null`, the value is expected to be `null`. |
| * @return Whether the value matches the pattern. |
| */ |
| HarnessPredicate.stringMatches = function (value, pattern) { |
| return __awaiter(this, void 0, void 0, function () { |
| return __generator(this, function (_b) { |
| switch (_b.label) { |
| case 0: return [4 /*yield*/, value]; |
| case 1: |
| value = _b.sent(); |
| if (pattern === null) { |
| return [2 /*return*/, value === null]; |
| } |
| else if (value === null) { |
| return [2 /*return*/, false]; |
| } |
| return [2 /*return*/, typeof pattern === 'string' ? value === pattern : pattern.test(value)]; |
| } |
| }); |
| }); |
| }; |
| /** |
| * Adds a predicate function to be run against candidate harnesses. |
| * @param description A description of this predicate that may be used in error messages. |
| * @param predicate An async predicate function. |
| * @return this (for method chaining). |
| */ |
| HarnessPredicate.prototype.add = function (description, predicate) { |
| this._descriptions.push(description); |
| this._predicates.push(predicate); |
| return this; |
| }; |
| /** |
| * Adds a predicate function that depends on an option value to be run against candidate |
| * harnesses. If the option value is undefined, the predicate will be ignored. |
| * @param name The name of the option (may be used in error messages). |
| * @param option The option value. |
| * @param predicate The predicate function to run if the option value is not undefined. |
| * @return this (for method chaining). |
| */ |
| HarnessPredicate.prototype.addOption = function (name, option, predicate) { |
| if (option !== undefined) { |
| this.add(name + " = " + _valueAsString(option), function (item) { return predicate(item, option); }); |
| } |
| return this; |
| }; |
| /** |
| * Filters a list of harnesses on this predicate. |
| * @param harnesses The list of harnesses to filter. |
| * @return A list of harnesses that satisfy this predicate. |
| */ |
| HarnessPredicate.prototype.filter = function (harnesses) { |
| return __awaiter(this, void 0, void 0, function () { |
| var results; |
| var _this = this; |
| return __generator(this, function (_b) { |
| switch (_b.label) { |
| case 0: |
| if (harnesses.length === 0) { |
| return [2 /*return*/, []]; |
| } |
| return [4 /*yield*/, parallel(function () { return harnesses.map(function (h) { return _this.evaluate(h); }); })]; |
| case 1: |
| results = _b.sent(); |
| return [2 /*return*/, harnesses.filter(function (_, i) { return results[i]; })]; |
| } |
| }); |
| }); |
| }; |
| /** |
| * Evaluates whether the given harness satisfies this predicate. |
| * @param harness The harness to check |
| * @return A promise that resolves to true if the harness satisfies this predicate, |
| * and resolves to false otherwise. |
| */ |
| HarnessPredicate.prototype.evaluate = function (harness) { |
| return __awaiter(this, void 0, void 0, function () { |
| var results; |
| var _this = this; |
| return __generator(this, function (_b) { |
| switch (_b.label) { |
| case 0: return [4 /*yield*/, parallel(function () { return _this._predicates.map(function (p) { return p(harness); }); })]; |
| case 1: |
| results = _b.sent(); |
| return [2 /*return*/, results.reduce(function (combined, current) { return combined && current; }, true)]; |
| } |
| }); |
| }); |
| }; |
| /** Gets a description of this predicate for use in error messages. */ |
| HarnessPredicate.prototype.getDescription = function () { |
| return this._descriptions.join(', '); |
| }; |
| /** Gets the selector used to find candidate elements. */ |
| HarnessPredicate.prototype.getSelector = function () { |
| // We don't have to go through the extra trouble if there are no ancestors. |
| if (!this._ancestor) { |
| return (this.harnessType.hostSelector || '').trim(); |
| } |
| var _b = __read(_splitAndEscapeSelector(this._ancestor), 2), ancestors = _b[0], ancestorPlaceholders = _b[1]; |
| var _c = __read(_splitAndEscapeSelector(this.harnessType.hostSelector || ''), 2), selectors = _c[0], selectorPlaceholders = _c[1]; |
| var result = []; |
| // We have to add the ancestor to each part of the host compound selector, otherwise we can get |
| // incorrect results. E.g. `.ancestor .a, .ancestor .b` vs `.ancestor .a, .b`. |
| ancestors.forEach(function (escapedAncestor) { |
| var ancestor = _restoreSelector(escapedAncestor, ancestorPlaceholders); |
| return selectors.forEach(function (escapedSelector) { return result.push(ancestor + " " + _restoreSelector(escapedSelector, selectorPlaceholders)); }); |
| }); |
| return result.join(', '); |
| }; |
| /** Adds base options common to all harness types. */ |
| HarnessPredicate.prototype._addBaseOptions = function (options) { |
| var _this = this; |
| this._ancestor = options.ancestor || ''; |
| if (this._ancestor) { |
| this._descriptions.push("has ancestor matching selector \"" + this._ancestor + "\""); |
| } |
| var selector = options.selector; |
| if (selector !== undefined) { |
| this.add("host matches selector \"" + selector + "\"", function (item) { return __awaiter(_this, void 0, void 0, function () { |
| return __generator(this, function (_b) { |
| switch (_b.label) { |
| case 0: return [4 /*yield*/, item.host()]; |
| case 1: return [2 /*return*/, (_b.sent()).matchesSelector(selector)]; |
| } |
| }); |
| }); }); |
| } |
| }; |
| return HarnessPredicate; |
| }()); |
| /** Represent a value as a string for the purpose of logging. */ |
| function _valueAsString(value) { |
| if (value === undefined) { |
| return 'undefined'; |
| } |
| // `JSON.stringify` doesn't handle RegExp properly, so we need a custom replacer. |
| try { |
| return JSON.stringify(value, function (_, v) { |
| if (v instanceof RegExp) { |
| return "/" + v.toString() + "/"; |
| } |
| return typeof v === 'string' ? v.replace('/\//g', '\\/') : v; |
| }).replace(/"\/\//g, '\\/').replace(/\/\/"/g, '\\/').replace(/\\\//g, '/'); |
| } |
| catch (_a) { |
| // `JSON.stringify` will throw if the object is cyclical, |
| // in this case the best we can do is report the value as `{...}`. |
| return '{...}'; |
| } |
| } |
| /** |
| * Splits up a compound selector into its parts and escapes any quoted content. The quoted content |
| * has to be escaped, because it can contain commas which will throw throw us off when trying to |
| * split it. |
| * @param selector Selector to be split. |
| * @returns The escaped string where any quoted content is replaced with a placeholder. E.g. |
| * `[foo="bar"]` turns into `[foo=__cdkPlaceholder-0__]`. Use `_restoreSelector` to restore |
| * the placeholders. |
| */ |
| function _splitAndEscapeSelector(selector) { |
| var placeholders = []; |
| // Note that the regex doesn't account for nested quotes so something like `"ab'cd'e"` will be |
| // considered as two blocks. It's a bit of an edge case, but if we find that it's a problem, |
| // we can make it a bit smarter using a loop. Use this for now since it's more readable and |
| // compact. More complete implementation: |
| // https://github.com/angular/angular/blob/bd34bc9e89f18a/packages/compiler/src/shadow_css.ts#L655 |
| var result = selector.replace(/(["'][^["']*["'])/g, function (_, keep) { |
| var replaceBy = "__cdkPlaceholder-" + placeholders.length + "__"; |
| placeholders.push(keep); |
| return replaceBy; |
| }); |
| return [result.split(',').map(function (part) { return part.trim(); }), placeholders]; |
| } |
| /** Restores a selector whose content was escaped in `_splitAndEscapeSelector`. */ |
| function _restoreSelector(selector, placeholders) { |
| return selector.replace(/__cdkPlaceholder-(\d+)__/g, function (_, index) { return placeholders[+index]; }); |
| } |
| |
| /** |
| * Base harness environment class that can be extended to allow `ComponentHarness`es to be used in |
| * different test environments (e.g. testbed, protractor, etc.). This class implements the |
| * functionality of both a `HarnessLoader` and `LocatorFactory`. This class is generic on the raw |
| * element type, `E`, used by the particular test environment. |
| */ |
| var HarnessEnvironment = /** @class */ (function () { |
| function HarnessEnvironment(rawRootElement) { |
| this.rawRootElement = rawRootElement; |
| this.rootElement = this.createTestElement(rawRootElement); |
| } |
| // Implemented as part of the `LocatorFactory` interface. |
| HarnessEnvironment.prototype.documentRootLocatorFactory = function () { |
| return this.createEnvironment(this.getDocumentRoot()); |
| }; |
| // Implemented as part of the `LocatorFactory` interface. |
| HarnessEnvironment.prototype.locatorFor = function () { |
| var _this = this; |
| var queries = []; |
| for (var _i = 0; _i < arguments.length; _i++) { |
| queries[_i] = arguments[_i]; |
| } |
| return function () { return _assertResultFound(_this._getAllHarnessesAndTestElements(queries), _getDescriptionForLocatorForQueries(queries)); }; |
| }; |
| // Implemented as part of the `LocatorFactory` interface. |
| HarnessEnvironment.prototype.locatorForOptional = function () { |
| var _this = this; |
| var queries = []; |
| for (var _i = 0; _i < arguments.length; _i++) { |
| queries[_i] = arguments[_i]; |
| } |
| return function () { return __awaiter(_this, void 0, void 0, function () { return __generator(this, function (_a) { |
| switch (_a.label) { |
| case 0: return [4 /*yield*/, this._getAllHarnessesAndTestElements(queries)]; |
| case 1: return [2 /*return*/, (_a.sent())[0] || null]; |
| } |
| }); }); }; |
| }; |
| // Implemented as part of the `LocatorFactory` interface. |
| HarnessEnvironment.prototype.locatorForAll = function () { |
| var _this = this; |
| var queries = []; |
| for (var _i = 0; _i < arguments.length; _i++) { |
| queries[_i] = arguments[_i]; |
| } |
| return function () { return _this._getAllHarnessesAndTestElements(queries); }; |
| }; |
| // Implemented as part of the `LocatorFactory` interface. |
| HarnessEnvironment.prototype.rootHarnessLoader = function () { |
| return __awaiter(this, void 0, void 0, function () { |
| return __generator(this, function (_a) { |
| return [2 /*return*/, this]; |
| }); |
| }); |
| }; |
| // Implemented as part of the `LocatorFactory` interface. |
| HarnessEnvironment.prototype.harnessLoaderFor = function (selector) { |
| return __awaiter(this, void 0, void 0, function () { |
| var _a; |
| return __generator(this, function (_b) { |
| switch (_b.label) { |
| case 0: |
| _a = this.createEnvironment; |
| return [4 /*yield*/, _assertResultFound(this.getAllRawElements(selector), [_getDescriptionForHarnessLoaderQuery(selector)])]; |
| case 1: return [2 /*return*/, _a.apply(this, [_b.sent()])]; |
| } |
| }); |
| }); |
| }; |
| // Implemented as part of the `LocatorFactory` interface. |
| HarnessEnvironment.prototype.harnessLoaderForOptional = function (selector) { |
| return __awaiter(this, void 0, void 0, function () { |
| var elements; |
| return __generator(this, function (_a) { |
| switch (_a.label) { |
| case 0: return [4 /*yield*/, this.getAllRawElements(selector)]; |
| case 1: |
| elements = _a.sent(); |
| return [2 /*return*/, elements[0] ? this.createEnvironment(elements[0]) : null]; |
| } |
| }); |
| }); |
| }; |
| // Implemented as part of the `LocatorFactory` interface. |
| HarnessEnvironment.prototype.harnessLoaderForAll = function (selector) { |
| return __awaiter(this, void 0, void 0, function () { |
| var elements; |
| var _this = this; |
| return __generator(this, function (_a) { |
| switch (_a.label) { |
| case 0: return [4 /*yield*/, this.getAllRawElements(selector)]; |
| case 1: |
| elements = _a.sent(); |
| return [2 /*return*/, elements.map(function (element) { return _this.createEnvironment(element); })]; |
| } |
| }); |
| }); |
| }; |
| // Implemented as part of the `HarnessLoader` interface. |
| HarnessEnvironment.prototype.getHarness = function (query) { |
| return this.locatorFor(query)(); |
| }; |
| // Implemented as part of the `HarnessLoader` interface. |
| HarnessEnvironment.prototype.getAllHarnesses = function (query) { |
| return this.locatorForAll(query)(); |
| }; |
| // Implemented as part of the `HarnessLoader` interface. |
| HarnessEnvironment.prototype.getChildLoader = function (selector) { |
| return __awaiter(this, void 0, void 0, function () { |
| var _a; |
| return __generator(this, function (_b) { |
| switch (_b.label) { |
| case 0: |
| _a = this.createEnvironment; |
| return [4 /*yield*/, _assertResultFound(this.getAllRawElements(selector), [_getDescriptionForHarnessLoaderQuery(selector)])]; |
| case 1: return [2 /*return*/, _a.apply(this, [_b.sent()])]; |
| } |
| }); |
| }); |
| }; |
| // Implemented as part of the `HarnessLoader` interface. |
| HarnessEnvironment.prototype.getAllChildLoaders = function (selector) { |
| return __awaiter(this, void 0, void 0, function () { |
| var _this = this; |
| return __generator(this, function (_a) { |
| switch (_a.label) { |
| case 0: return [4 /*yield*/, this.getAllRawElements(selector)]; |
| case 1: return [2 /*return*/, (_a.sent()).map(function (e) { return _this.createEnvironment(e); })]; |
| } |
| }); |
| }); |
| }; |
| /** Creates a `ComponentHarness` for the given harness type with the given raw host element. */ |
| HarnessEnvironment.prototype.createComponentHarness = function (harnessType, element) { |
| return new harnessType(this.createEnvironment(element)); |
| }; |
| /** |
| * Matches the given raw elements with the given list of element and harness queries to produce a |
| * list of matched harnesses and test elements. |
| */ |
| HarnessEnvironment.prototype._getAllHarnessesAndTestElements = function (queries) { |
| return __awaiter(this, void 0, void 0, function () { |
| var _a, allQueries, harnessQueries, elementQueries, harnessTypes, rawElements, skipSelectorCheck, perElementMatches; |
| var _this = this; |
| return __generator(this, function (_b) { |
| switch (_b.label) { |
| case 0: |
| _a = _parseQueries(queries), allQueries = _a.allQueries, harnessQueries = _a.harnessQueries, elementQueries = _a.elementQueries, harnessTypes = _a.harnessTypes; |
| return [4 /*yield*/, this.getAllRawElements(__spread(elementQueries, harnessQueries.map(function (predicate) { return predicate.getSelector(); })).join(','))]; |
| case 1: |
| rawElements = _b.sent(); |
| skipSelectorCheck = (elementQueries.length === 0 && harnessTypes.size === 1) || |
| harnessQueries.length === 0; |
| return [4 /*yield*/, parallel(function () { return rawElements.map(function (rawElement) { return __awaiter(_this, void 0, void 0, function () { |
| var testElement, allResultsForElement; |
| var _this = this; |
| return __generator(this, function (_a) { |
| switch (_a.label) { |
| case 0: |
| testElement = this.createTestElement(rawElement); |
| return [4 /*yield*/, parallel( |
| // For each query, get `null` if it doesn't match, or a `TestElement` or |
| // `ComponentHarness` as appropriate if it does match. This gives us everything that |
| // matches the current raw element, but it may contain duplicate entries (e.g. |
| // multiple `TestElement` or multiple `ComponentHarness` of the same type). |
| function () { return allQueries.map(function (query) { return _this._getQueryResultForElement(query, rawElement, testElement, skipSelectorCheck); }); })]; |
| case 1: |
| allResultsForElement = _a.sent(); |
| return [2 /*return*/, _removeDuplicateQueryResults(allResultsForElement)]; |
| } |
| }); |
| }); }); })]; |
| case 2: |
| perElementMatches = _b.sent(); |
| return [2 /*return*/, [].concat.apply([], __spread(perElementMatches))]; |
| } |
| }); |
| }); |
| }; |
| /** |
| * Check whether the given query matches the given element, if it does return the matched |
| * `TestElement` or `ComponentHarness`, if it does not, return null. In cases where the caller |
| * knows for sure that the query matches the element's selector, `skipSelectorCheck` can be used |
| * to skip verification and optimize performance. |
| */ |
| HarnessEnvironment.prototype._getQueryResultForElement = function (query, rawElement, testElement, skipSelectorCheck) { |
| if (skipSelectorCheck === void 0) { skipSelectorCheck = false; } |
| return __awaiter(this, void 0, void 0, function () { |
| var _a, _b, harness; |
| return __generator(this, function (_c) { |
| switch (_c.label) { |
| case 0: |
| if (!(typeof query === 'string')) return [3 /*break*/, 3]; |
| _a = skipSelectorCheck; |
| if (_a) return [3 /*break*/, 2]; |
| return [4 /*yield*/, testElement.matchesSelector(query)]; |
| case 1: |
| _a = (_c.sent()); |
| _c.label = 2; |
| case 2: return [2 /*return*/, ((_a) ? testElement : null)]; |
| case 3: |
| _b = skipSelectorCheck; |
| if (_b) return [3 /*break*/, 5]; |
| return [4 /*yield*/, testElement.matchesSelector(query.getSelector())]; |
| case 4: |
| _b = (_c.sent()); |
| _c.label = 5; |
| case 5: |
| if (!_b) return [3 /*break*/, 7]; |
| harness = this.createComponentHarness(query.harnessType, rawElement); |
| return [4 /*yield*/, query.evaluate(harness)]; |
| case 6: return [2 /*return*/, (_c.sent()) ? harness : null]; |
| case 7: return [2 /*return*/, null]; |
| } |
| }); |
| }); |
| }; |
| return HarnessEnvironment; |
| }()); |
| /** |
| * Parses a list of queries in the format accepted by the `locatorFor*` methods into an easier to |
| * work with format. |
| */ |
| function _parseQueries(queries) { |
| var e_1, _a; |
| var allQueries = []; |
| var harnessQueries = []; |
| var elementQueries = []; |
| var harnessTypes = new Set(); |
| try { |
| for (var queries_1 = __values(queries), queries_1_1 = queries_1.next(); !queries_1_1.done; queries_1_1 = queries_1.next()) { |
| var query = queries_1_1.value; |
| if (typeof query === 'string') { |
| allQueries.push(query); |
| elementQueries.push(query); |
| } |
| else { |
| var predicate = query instanceof HarnessPredicate ? query : new HarnessPredicate(query, {}); |
| allQueries.push(predicate); |
| harnessQueries.push(predicate); |
| harnessTypes.add(predicate.harnessType); |
| } |
| } |
| } |
| catch (e_1_1) { e_1 = { error: e_1_1 }; } |
| finally { |
| try { |
| if (queries_1_1 && !queries_1_1.done && (_a = queries_1.return)) _a.call(queries_1); |
| } |
| finally { if (e_1) throw e_1.error; } |
| } |
| return { allQueries: allQueries, harnessQueries: harnessQueries, elementQueries: elementQueries, harnessTypes: harnessTypes }; |
| } |
| /** |
| * Removes duplicate query results for a particular element. (e.g. multiple `TestElement` |
| * instances or multiple instances of the same `ComponentHarness` class. |
| */ |
| function _removeDuplicateQueryResults(results) { |
| return __awaiter(this, void 0, void 0, function () { |
| var testElementMatched, matchedHarnessTypes, dedupedMatches, results_1, results_1_1, result; |
| var e_2, _a; |
| return __generator(this, function (_b) { |
| testElementMatched = false; |
| matchedHarnessTypes = new Set(); |
| dedupedMatches = []; |
| try { |
| for (results_1 = __values(results), results_1_1 = results_1.next(); !results_1_1.done; results_1_1 = results_1.next()) { |
| result = results_1_1.value; |
| if (!result) { |
| continue; |
| } |
| if (result instanceof ComponentHarness) { |
| if (!matchedHarnessTypes.has(result.constructor)) { |
| matchedHarnessTypes.add(result.constructor); |
| dedupedMatches.push(result); |
| } |
| } |
| else if (!testElementMatched) { |
| testElementMatched = true; |
| dedupedMatches.push(result); |
| } |
| } |
| } |
| catch (e_2_1) { e_2 = { error: e_2_1 }; } |
| finally { |
| try { |
| if (results_1_1 && !results_1_1.done && (_a = results_1.return)) _a.call(results_1); |
| } |
| finally { if (e_2) throw e_2.error; } |
| } |
| return [2 /*return*/, dedupedMatches]; |
| }); |
| }); |
| } |
| /** Verifies that there is at least one result in an array. */ |
| function _assertResultFound(results, queryDescriptions) { |
| return __awaiter(this, void 0, void 0, function () { |
| var result; |
| return __generator(this, function (_a) { |
| switch (_a.label) { |
| case 0: return [4 /*yield*/, results]; |
| case 1: |
| result = (_a.sent())[0]; |
| if (result == undefined) { |
| throw Error("Failed to find element matching one of the following queries:\n" + |
| queryDescriptions.map(function (desc) { return "(" + desc + ")"; }).join(',\n')); |
| } |
| return [2 /*return*/, result]; |
| } |
| }); |
| }); |
| } |
| /** Gets a list of description strings from a list of queries. */ |
| function _getDescriptionForLocatorForQueries(queries) { |
| return queries.map(function (query) { return typeof query === 'string' ? |
| _getDescriptionForTestElementQuery(query) : _getDescriptionForComponentHarnessQuery(query); }); |
| } |
| /** Gets a description string for a `ComponentHarness` query. */ |
| function _getDescriptionForComponentHarnessQuery(query) { |
| var harnessPredicate = query instanceof HarnessPredicate ? query : new HarnessPredicate(query, {}); |
| var _a = harnessPredicate.harnessType, name = _a.name, hostSelector = _a.hostSelector; |
| var description = name + " with host element matching selector: \"" + hostSelector + "\""; |
| var constraints = harnessPredicate.getDescription(); |
| return description + (constraints ? |
| " satisfying the constraints: " + harnessPredicate.getDescription() : ''); |
| } |
| /** Gets a description string for a `TestElement` query. */ |
| function _getDescriptionForTestElementQuery(selector) { |
| return "TestElement for element matching selector: \"" + selector + "\""; |
| } |
| /** Gets a description string for a `HarnessLoader` query. */ |
| function _getDescriptionForHarnessLoaderQuery(selector) { |
| return "HarnessLoader for element matching selector: \"" + selector + "\""; |
| } |
| |
| /** |
| * @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 |
| */ |
| (function (TestKey) { |
| TestKey[TestKey["BACKSPACE"] = 0] = "BACKSPACE"; |
| TestKey[TestKey["TAB"] = 1] = "TAB"; |
| TestKey[TestKey["ENTER"] = 2] = "ENTER"; |
| TestKey[TestKey["SHIFT"] = 3] = "SHIFT"; |
| TestKey[TestKey["CONTROL"] = 4] = "CONTROL"; |
| TestKey[TestKey["ALT"] = 5] = "ALT"; |
| TestKey[TestKey["ESCAPE"] = 6] = "ESCAPE"; |
| TestKey[TestKey["PAGE_UP"] = 7] = "PAGE_UP"; |
| TestKey[TestKey["PAGE_DOWN"] = 8] = "PAGE_DOWN"; |
| TestKey[TestKey["END"] = 9] = "END"; |
| TestKey[TestKey["HOME"] = 10] = "HOME"; |
| TestKey[TestKey["LEFT_ARROW"] = 11] = "LEFT_ARROW"; |
| TestKey[TestKey["UP_ARROW"] = 12] = "UP_ARROW"; |
| TestKey[TestKey["RIGHT_ARROW"] = 13] = "RIGHT_ARROW"; |
| TestKey[TestKey["DOWN_ARROW"] = 14] = "DOWN_ARROW"; |
| TestKey[TestKey["INSERT"] = 15] = "INSERT"; |
| TestKey[TestKey["DELETE"] = 16] = "DELETE"; |
| TestKey[TestKey["F1"] = 17] = "F1"; |
| TestKey[TestKey["F2"] = 18] = "F2"; |
| TestKey[TestKey["F3"] = 19] = "F3"; |
| TestKey[TestKey["F4"] = 20] = "F4"; |
| TestKey[TestKey["F5"] = 21] = "F5"; |
| TestKey[TestKey["F6"] = 22] = "F6"; |
| TestKey[TestKey["F7"] = 23] = "F7"; |
| TestKey[TestKey["F8"] = 24] = "F8"; |
| TestKey[TestKey["F9"] = 25] = "F9"; |
| TestKey[TestKey["F10"] = 26] = "F10"; |
| TestKey[TestKey["F11"] = 27] = "F11"; |
| TestKey[TestKey["F12"] = 28] = "F12"; |
| TestKey[TestKey["META"] = 29] = "META"; |
| })(exports.TestKey || (exports.TestKey = {})); |
| |
| /** |
| * @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 |
| */ |
| /** |
| * Gets text of element excluding certain selectors within the element. |
| * @param element Element to get text from, |
| * @param excludeSelector Selector identifying which elements to exclude, |
| */ |
| function _getTextWithExcludedElements(element, excludeSelector) { |
| var _a; |
| var clone = element.cloneNode(true); |
| var exclusions = clone.querySelectorAll(excludeSelector); |
| for (var i = 0; i < exclusions.length; i++) { |
| var child = exclusions[i]; |
| (_a = child.parentNode) === null || _a === void 0 ? void 0 : _a.removeChild(child); |
| } |
| return (clone.textContent || '').trim(); |
| } |
| |
| /** |
| * @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 |
| */ |
| |
| /** |
| * @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 |
| */ |
| |
| exports.ComponentHarness = ComponentHarness; |
| exports.ContentContainerComponentHarness = ContentContainerComponentHarness; |
| exports.HarnessEnvironment = HarnessEnvironment; |
| exports.HarnessPredicate = HarnessPredicate; |
| exports._getTextWithExcludedElements = _getTextWithExcludedElements; |
| exports.handleAutoChangeDetectionStatus = handleAutoChangeDetectionStatus; |
| exports.manualChangeDetection = manualChangeDetection; |
| exports.parallel = parallel; |
| exports.stopHandlingAutoChangeDetectionStatus = stopHandlingAutoChangeDetectionStatus; |
| |
| Object.defineProperty(exports, '__esModule', { value: true }); |
| |
| }))); |
| //# sourceMappingURL=cdk-testing.umd.js.map |
