@pulumi/query
Version:
An simple, relational SDK for querying TypeScript and JavaScript data structures
925 lines • 73 kB
JavaScript
"use strict";
// Copyright 2016-2019, Pulumi Corporation.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
var __awaiter = (this && this.__awaiter) || function (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());
});
};
var __asyncValues = (this && this.__asyncValues) || function (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); }
};
var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
var __asyncGenerator = (this && this.__asyncGenerator) || function (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]); }
};
Object.defineProperty(exports, "__esModule", { value: true });
const assert = require("assert");
const __1 = require("..");
const asyncQueryable_1 = require("../asyncQueryable");
function assertRejects(done, p) {
p.then(() => {
done(new Error("Expected method to reject."));
})
.catch(err => {
assert.notDeepEqual(err, undefined);
done();
})
.catch(done);
}
describe("IterablePromise sources", () => {
describe("from", () => {
it("can be evaluated twice", () => __awaiter(void 0, void 0, void 0, function* () {
const xs = __1.from([1, 2, 3]);
const eval1 = yield xs.toArray();
assert.deepEqual(eval1, [1, 2, 3]);
const count1 = yield xs.count();
assert.deepEqual(count1, 3);
const eval2 = yield xs.toArray();
assert.deepEqual(eval2, [1, 2, 3]);
const count2 = yield xs.count();
assert.deepEqual(count2, 3);
const ms = __1.from(new Map([["foo", "foo"], ["bar", "bar"]]));
const eval3 = yield ms.toArray();
assert.deepEqual(eval3, [["foo", "foo"], ["bar", "bar"]]);
const count3 = yield ms.count();
assert.deepEqual(count3, 2);
const eval4 = yield ms.toArray();
assert.deepEqual(eval4, [["foo", "foo"], ["bar", "bar"]]);
const count4 = yield ms.count();
assert.deepEqual(count4, 2);
const groups = ms.groupBy(([k, v]) => k, ([k, v]) => v);
assert.deepEqual(yield groups.count(), 2);
assert.deepEqual(yield groups.count(), 2);
const flattened1 = ms.flatMap(vs => vs);
assert.deepEqual(yield flattened1.count(), 4);
assert.deepEqual(yield flattened1.count(), 4);
const flattened2 = ms.flatMap(vs => __1.range(0, 5));
assert.deepEqual(yield flattened2.count(), 10);
assert.deepEqual(yield flattened2.count(), 10);
}));
});
describe("range", () => {
//
// TODO: Throw error when range overlaps.
//
it("produces an empty array for overlapping ranges", () => __awaiter(void 0, void 0, void 0, function* () {
let xs = __1.range(0, 0);
assert.deepEqual(yield xs.toArray(), []);
assert.deepEqual(yield xs.count(), 0);
assert.deepEqual(yield xs.count(), 0);
xs = __1.range(0, -1);
assert.deepEqual(yield xs.toArray(), []);
assert.deepEqual(yield xs.count(), 0);
assert.deepEqual(yield xs.count(), 0);
}));
it("produces an array of one for boundary case", () => __awaiter(void 0, void 0, void 0, function* () {
const xs = __1.range(0, 1);
assert.deepEqual(yield xs.toArray(), [0]);
assert.deepEqual(yield xs.count(), 1);
assert.deepEqual(yield xs.count(), 1);
}));
it("can produce a range including negative numbers", () => __awaiter(void 0, void 0, void 0, function* () {
const xs = __1.range(-3, 2);
assert.deepEqual(yield xs.toArray(), [-3, -2, -1, 0, 1]);
assert.deepEqual(yield xs.count(), 5);
assert.deepEqual(yield xs.count(), 5);
}));
it("is lazily evaluated by take when range is infinite", () => __awaiter(void 0, void 0, void 0, function* () {
const xs = __1.range(0).take(5);
assert.deepEqual(yield xs.toArray(), [0, 1, 2, 3, 4]);
assert.deepEqual(yield xs.count(), 5);
assert.deepEqual(yield xs.count(), 5);
}));
it("is lazily transformed and filtered when range is infinite", () => __awaiter(void 0, void 0, void 0, function* () {
const xs = __1.range(0)
.map(x => x + 2)
// If filter is bigger than the take window, we enumerate all numbers and hang
// forever.
.filter(x => x <= 10)
.take(7)
.map(x => x - 2)
.filter(x => x > 3);
assert.deepEqual(yield xs.toArray(), [4, 5, 6]);
assert.deepEqual(yield xs.count(), 3);
assert.deepEqual(yield xs.count(), 3);
}));
it("is lazily flatMap'd when range is infinite", () => __awaiter(void 0, void 0, void 0, function* () {
const xs = yield __1.range(0)
// If filter is bigger than the take window, we enumerate all numbers and hang
// forever.
.flatMap(x => (x <= 10 ? [x, x] : []))
.take(5);
assert.deepEqual(yield xs.toArray(), [0, 0, 1, 1, 2]);
assert.deepEqual(yield xs.count(), 5);
assert.deepEqual(yield xs.count(), 5);
}));
});
});
describe("IterablePromise restriction operators", () => {
describe("filter", () => {
it("produces [] when all elements are filtered out", () => __awaiter(void 0, void 0, void 0, function* () {
const xs = asyncQueryable_1.AsyncQueryableImpl.from([1, 2, 3, 4]).filter(x => x < 0);
assert.deepEqual(yield xs.toArray(), []);
assert.deepEqual(yield xs.count(), 0);
assert.deepEqual(yield xs.count(), 0);
}));
it("produces an non-empty array when some elements are filtered out", () => __awaiter(void 0, void 0, void 0, function* () {
const xs = asyncQueryable_1.AsyncQueryableImpl.from([1, 2, 3, 4]).filter(x => x >= 3);
assert.deepEqual(yield xs.toArray(), [3, 4]);
assert.deepEqual(yield xs.count(), 2);
assert.deepEqual(yield xs.count(), 2);
}));
});
});
describe("IterablePromise projection operators", () => {
describe("map", () => {
it("x => x does identity transformation", () => __awaiter(void 0, void 0, void 0, function* () {
const xs = asyncQueryable_1.AsyncQueryableImpl.from([1, 2, 3, 4]).map(x => x);
assert.deepEqual(yield xs.toArray(), [1, 2, 3, 4]);
assert.deepEqual(yield xs.count(), 4);
assert.deepEqual(yield xs.count(), 4);
}));
it("x => x+1 adds one to every element", () => __awaiter(void 0, void 0, void 0, function* () {
const xs = asyncQueryable_1.AsyncQueryableImpl.from([1, 2, 3, 4]).map(x => x + 1);
assert.deepEqual(yield xs.toArray(), [2, 3, 4, 5]);
assert.deepEqual(yield xs.count(), 4);
assert.deepEqual(yield xs.count(), 4);
}));
});
describe("flatMap", () => {
it("produces [] when all elements are filtered out", () => __awaiter(void 0, void 0, void 0, function* () {
const xs = asyncQueryable_1.AsyncQueryableImpl.from([1, 2, 3, 4]).flatMap(x => []);
assert.deepEqual(yield xs.toArray(), []);
assert.deepEqual(yield xs.count(), 0);
assert.deepEqual(yield xs.count(), 0);
}));
it("can add elements to an enumerable", () => __awaiter(void 0, void 0, void 0, function* () {
const xs = asyncQueryable_1.AsyncQueryableImpl.from([1, 2, 3, 4]).flatMap(x => [x, x]);
assert.deepEqual(yield xs.toArray(), [1, 1, 2, 2, 3, 3, 4, 4]);
assert.deepEqual(yield xs.count(), 8);
assert.deepEqual(yield xs.count(), 8);
}));
});
});
describe("IterablePromise partitioning operators", () => {
describe("skip", () => {
it("produces [] when all elements are skipped", () => __awaiter(void 0, void 0, void 0, function* () {
let xs = asyncQueryable_1.AsyncQueryableImpl.from([1, 2, 3, 4]).skip(4);
assert.deepEqual(yield xs.toArray(), []);
assert.deepEqual(yield xs.count(), 0);
assert.deepEqual(yield xs.count(), 0);
xs = asyncQueryable_1.AsyncQueryableImpl.from([]).skip(4);
assert.deepEqual(yield xs.toArray(), []);
assert.deepEqual(yield xs.count(), 0);
assert.deepEqual(yield xs.count(), 0);
xs = asyncQueryable_1.AsyncQueryableImpl.from((function* () {
for (const x of []) {
yield x;
}
})()).skip(4);
assert.deepEqual(yield xs.toArray(), []);
assert.deepEqual(yield xs.count(), 0);
assert.deepEqual(yield xs.count(), 0);
xs = asyncQueryable_1.AsyncQueryableImpl.from([]).skip(0);
assert.deepEqual(yield xs.toArray(), []);
assert.deepEqual(yield xs.count(), 0);
assert.deepEqual(yield xs.count(), 0);
xs = asyncQueryable_1.AsyncQueryableImpl.from((function* () {
for (const x of []) {
yield x;
}
})()).skip(0);
assert.deepEqual(yield xs.toArray(), []);
assert.deepEqual(yield xs.count(), 0);
assert.deepEqual(yield xs.count(), 0);
}));
it("produces non-empty array when not all elements are skipped", () => __awaiter(void 0, void 0, void 0, function* () {
let xs = asyncQueryable_1.AsyncQueryableImpl.from([1, 2, 3, 4, 5]).skip(4);
assert.deepEqual(yield xs.toArray(), [5]);
assert.deepEqual(yield xs.count(), 1);
assert.deepEqual(yield xs.count(), 1);
xs = asyncQueryable_1.AsyncQueryableImpl.from([1, 2, 3, 4, 5]).skip(0);
assert.deepEqual(yield xs.toArray(), [1, 2, 3, 4, 5]);
assert.deepEqual(yield xs.count(), 5);
assert.deepEqual(yield xs.count(), 5);
}));
it("throws exception when negative number is provided for n, part 1", () => __awaiter(void 0, void 0, void 0, function* () {
try {
asyncQueryable_1.AsyncQueryableImpl.from([1, 2, 3, 4, 5])
.skip(-1)
.toArray();
}
catch (e) {
return;
}
assert.fail();
}));
it("throws exception when negative number is provided for n, part 2", () => __awaiter(void 0, void 0, void 0, function* () {
try {
asyncQueryable_1.AsyncQueryableImpl.from([])
.skip(-1)
.toArray();
}
catch (e) {
return;
}
}));
});
describe("skipWhile", () => {
it("produces [] when all elements are skipped", () => __awaiter(void 0, void 0, void 0, function* () {
let xs = asyncQueryable_1.AsyncQueryableImpl.from([1, 2, 3, 4]).skipWhile(x => true);
assert.deepEqual(yield xs.toArray(), []);
assert.deepEqual(yield xs.count(), 0);
assert.deepEqual(yield xs.count(), 0);
xs = asyncQueryable_1.AsyncQueryableImpl.from([]).skipWhile(x => false);
assert.deepEqual(yield xs.toArray(), []);
assert.deepEqual(yield xs.count(), 0);
assert.deepEqual(yield xs.count(), 0);
xs = asyncQueryable_1.AsyncQueryableImpl.from([]).skipWhile(x => true);
assert.deepEqual(yield xs.toArray(), []);
assert.deepEqual(yield xs.count(), 0);
assert.deepEqual(yield xs.count(), 0);
}));
it("produces non-empty array when not all elements are skipped", () => __awaiter(void 0, void 0, void 0, function* () {
let xs = asyncQueryable_1.AsyncQueryableImpl.from([1, 2, 3, 4]).skipWhile(x => x < 2);
assert.deepEqual(yield xs.toArray(), [2, 3, 4]);
assert.deepEqual(yield xs.count(), 3);
assert.deepEqual(yield xs.count(), 3);
xs = asyncQueryable_1.AsyncQueryableImpl.from([1, 2, 3, 4]).skipWhile((x, i) => i < 1);
assert.deepEqual(yield xs.toArray(), [2, 3, 4]);
assert.deepEqual(yield xs.count(), 3);
assert.deepEqual(yield xs.count(), 3);
}));
it("does not invoke the predicate again after it returns false one time", () => __awaiter(void 0, void 0, void 0, function* () {
const xs = asyncQueryable_1.AsyncQueryableImpl.from([1, 2, 3, 4, 5]).skipWhile(x => x < 2 || x > 3);
assert.deepEqual(yield xs.toArray(), [2, 3, 4, 5]);
assert.deepEqual(yield xs.count(), 4);
assert.deepEqual(yield xs.count(), 4);
}));
});
describe("take", () => {
it("produces [] when no elements are taken", () => __awaiter(void 0, void 0, void 0, function* () {
let xs = asyncQueryable_1.AsyncQueryableImpl.from([1, 2, 3, 4]).take(0);
assert.deepEqual(yield xs.toArray(), []);
assert.deepEqual(yield xs.count(), 0);
assert.deepEqual(yield xs.count(), 0);
xs = asyncQueryable_1.AsyncQueryableImpl.from([]).take(4);
assert.deepEqual(yield xs.toArray(), []);
assert.deepEqual(yield xs.count(), 0);
assert.deepEqual(yield xs.count(), 0);
xs = asyncQueryable_1.AsyncQueryableImpl.from([]).take(0);
assert.deepEqual(yield xs.toArray(), []);
assert.deepEqual(yield xs.count(), 0);
assert.deepEqual(yield xs.count(), 0);
}));
it("produces non-empty array when some elements are taken", () => __awaiter(void 0, void 0, void 0, function* () {
let xs = asyncQueryable_1.AsyncQueryableImpl.from([1, 2, 3, 4, 5]).take(4);
assert.deepEqual(yield xs.toArray(), [1, 2, 3, 4]);
assert.deepEqual(yield xs.count(), 4);
assert.deepEqual(yield xs.count(), 4);
xs = asyncQueryable_1.AsyncQueryableImpl.from([1, 2, 3, 4, 5]).take(8);
assert.deepEqual(yield xs.toArray(), [1, 2, 3, 4, 5]);
assert.deepEqual(yield xs.count(), 5);
assert.deepEqual(yield xs.count(), 5);
xs = yield asyncQueryable_1.AsyncQueryableImpl.from([1, 2, 3, 4, 5]).take(5);
assert.deepEqual(yield xs.toArray(), [1, 2, 3, 4, 5]);
assert.deepEqual(yield xs.count(), 5);
assert.deepEqual(yield xs.count(), 5);
}));
it("throws exception when negative number is provided for n, part 1", () => __awaiter(void 0, void 0, void 0, function* () {
try {
yield asyncQueryable_1.AsyncQueryableImpl.from([1, 2, 3, 4, 5])
.take(-1)
.toArray();
}
catch (e) {
return;
}
assert.fail();
}));
it("throws exception when negative number is provided for n, part 2", () => __awaiter(void 0, void 0, void 0, function* () {
try {
yield asyncQueryable_1.AsyncQueryableImpl.from([])
.take(-1)
.toArray();
}
catch (e) {
return;
}
assert.fail();
}));
});
describe("takeWhile", () => {
it("produces [] when no elements are taken", () => __awaiter(void 0, void 0, void 0, function* () {
let xs = asyncQueryable_1.AsyncQueryableImpl.from([1, 2, 3, 4]).takeWhile(x => false);
assert.deepEqual(yield xs.toArray(), []);
assert.deepEqual(yield xs.count(), 0);
assert.deepEqual(yield xs.count(), 0);
xs = yield asyncQueryable_1.AsyncQueryableImpl.from([]).takeWhile(x => true);
assert.deepEqual(yield xs.toArray(), []);
assert.deepEqual(yield xs.count(), 0);
assert.deepEqual(yield xs.count(), 0);
xs = yield asyncQueryable_1.AsyncQueryableImpl.from([]).takeWhile(x => false);
assert.deepEqual(yield xs.toArray(), []);
assert.deepEqual(yield xs.count(), 0);
assert.deepEqual(yield xs.count(), 0);
}));
it("produces non-empty array when some elements are taken", () => __awaiter(void 0, void 0, void 0, function* () {
let xs = asyncQueryable_1.AsyncQueryableImpl.from([1, 2, 3, 4]).takeWhile(x => x <= 2);
assert.deepEqual(yield xs.toArray(), [1, 2]);
assert.deepEqual(yield xs.count(), 2);
assert.deepEqual(yield xs.count(), 2);
xs = yield asyncQueryable_1.AsyncQueryableImpl.from([1, 2, 3, 4]).takeWhile((x, i) => i <= 1);
assert.deepEqual(yield xs.toArray(), [1, 2]);
assert.deepEqual(yield xs.count(), 2);
assert.deepEqual(yield xs.count(), 2);
}));
it("does not invoke the predicate again after it returns false one time", () => __awaiter(void 0, void 0, void 0, function* () {
const xs = asyncQueryable_1.AsyncQueryableImpl.from([1, 2, 3, 4, 5]).takeWhile(x => x <= 2 || x > 4);
assert.deepEqual(yield xs.toArray(), [1, 2]);
assert.deepEqual(yield xs.count(), 2);
assert.deepEqual(yield xs.count(), 2);
}));
});
});
describe("IterablePromise join operators", () => {
describe("join", () => {
it("produces [] when no elements are taken", () => __awaiter(void 0, void 0, void 0, function* () {
let xs = asyncQueryable_1.AsyncQueryableImpl.from([]).join([1, 2, 3], x => x, x => x, (x, y) => [x, y]);
assert.deepEqual(yield xs.toArray(), []);
assert.deepEqual(yield xs.count(), 0);
assert.deepEqual(yield xs.count(), 0);
xs = asyncQueryable_1.AsyncQueryableImpl.from([1, 2, 3]).join([], x => x, x => x, (x, y) => [x, y]);
assert.deepEqual(yield xs.toArray(), []);
assert.deepEqual(yield xs.count(), 0);
assert.deepEqual(yield xs.count(), 0);
}));
it("joins non-empty sets", () => __awaiter(void 0, void 0, void 0, function* () {
const xs = asyncQueryable_1.AsyncQueryableImpl.from([1, 2, 3, 4, 5]).join([1, 2, 3], x => x, x => x, (x, y) => [x, y]);
assert.deepEqual(yield xs.toArray(), [[1, 1], [2, 2], [3, 3]]);
assert.deepEqual(yield xs.count(), 3);
assert.deepEqual(yield xs.count(), 3);
}));
it("ignores joins when key selector produces undefined", () => __awaiter(void 0, void 0, void 0, function* () {
let xs = asyncQueryable_1.AsyncQueryableImpl.from([1, 2, 3, 4, 5]).join([1, 2, 3], x => (x === 2 ? undefined : x), x => x, (x, y) => [x, y]);
assert.deepEqual(yield xs.toArray(), [[1, 1], [3, 3]]);
assert.deepEqual(yield xs.count(), 2);
assert.deepEqual(yield xs.count(), 2);
xs = yield asyncQueryable_1.AsyncQueryableImpl.from([1, 2, 3, 4, 5]).join([1, 2, 3], x => x, x => (x === 2 ? undefined : x), (x, y) => [x, y]);
assert.deepEqual(yield xs.toArray(), [[1, 1], [3, 3]]);
assert.deepEqual(yield xs.count(), 2);
assert.deepEqual(yield xs.count(), 2);
xs = yield asyncQueryable_1.AsyncQueryableImpl.from([1, 2, 3, 4, 5]).join([1, 2, 3], x => (x === 2 ? null : x), x => x, (x, y) => [x, y]);
assert.deepEqual(yield xs.toArray(), [[1, 1], [3, 3]]);
assert.deepEqual(yield xs.count(), 2);
assert.deepEqual(yield xs.count(), 2);
xs = yield asyncQueryable_1.AsyncQueryableImpl.from([1, 2, 3, 4, 5]).join([1, 2, 3], x => x, x => (x === 2 ? null : x), (x, y) => [x, y]);
assert.deepEqual(yield xs.toArray(), [[1, 1], [3, 3]]);
assert.deepEqual(yield xs.count(), 2);
assert.deepEqual(yield xs.count(), 2);
}));
it("joins multiple inner records to one outer record", () => __awaiter(void 0, void 0, void 0, function* () {
let xs = yield asyncQueryable_1.AsyncQueryableImpl.from([1, 2, 2, 3, 4, 5]).join([1, 2], x => x, x => x, (x, y) => [x, y]);
assert.deepEqual(yield xs.toArray(), [[1, 1], [2, 2], [2, 2]]);
assert.deepEqual(yield xs.count(), 3);
assert.deepEqual(yield xs.count(), 3);
xs = yield asyncQueryable_1.AsyncQueryableImpl.from([1, 2]).join([1, 2, 2, 3, 4, 5], x => x, x => x, (x, y) => [x, y]);
assert.deepEqual(yield xs.toArray(), [[1, 1], [2, 2], [2, 2]]);
assert.deepEqual(yield xs.count(), 3);
assert.deepEqual(yield xs.count(), 3);
xs = yield asyncQueryable_1.AsyncQueryableImpl.from([1, 2, 2]).join([1, 2, 2, 3, 4, 5], x => x, x => x, (x, y) => [x, y]);
assert.deepEqual(yield xs.toArray(), [[1, 1], [2, 2], [2, 2], [2, 2], [2, 2]]);
assert.deepEqual(yield xs.count(), 5);
assert.deepEqual(yield xs.count(), 5);
}));
});
describe("groupJoin", () => {
it("groups multiple records to one joined record", () => __awaiter(void 0, void 0, void 0, function* () {
let xs = asyncQueryable_1.AsyncQueryableImpl.from([1, 2, 2, 3, 4, 5]).groupJoin([1, 2], x => x, x => x, (x, y) => __awaiter(void 0, void 0, void 0, function* () { return [x, yield y.toArray()]; }));
assert.deepEqual(yield xs.toArray(), [
[1, [1]],
[2, [2]],
[2, [2]],
[3, []],
[4, []],
[5, []],
]);
assert.deepEqual(yield xs.count(), 6);
assert.deepEqual(yield xs.count(), 6);
xs = asyncQueryable_1.AsyncQueryableImpl.from([1, 2]).groupJoin([1, 2, 2, 3, 4, 5], x => x, x => x, (x, y) => __awaiter(void 0, void 0, void 0, function* () { return [x, yield y.toArray()]; }));
assert.deepEqual(yield xs.toArray(), [[1, [1]], [2, [2, 2]]]);
assert.deepEqual(yield xs.count(), 2);
assert.deepEqual(yield xs.count(), 2);
xs = asyncQueryable_1.AsyncQueryableImpl.from([1, 2, 2]).groupJoin([1, 2, 2, 3, 4, 5], x => x, x => x, (x, y) => __awaiter(void 0, void 0, void 0, function* () { return [x, yield y.toArray()]; }));
assert.deepEqual(yield xs.toArray(), [[1, [1]], [2, [2, 2]], [2, [2, 2]]]);
assert.deepEqual(yield xs.count(), 3);
assert.deepEqual(yield xs.count(), 3);
}));
});
});
describe("IterablePromise concatenation operators", () => {
describe("concat", () => {
//
// These tests exist, in part, to make sure that type inference works for the complex types
// in the signatures of `concat` and `from`.
//
it("concats T[]", () => __awaiter(void 0, void 0, void 0, function* () {
let xs = asyncQueryable_1.AsyncQueryableImpl.from([1, 2]).concat([3, 4]);
assert.deepEqual(yield xs.toArray(), [1, 2, 3, 4]);
assert.deepEqual(yield xs.count(), 4);
assert.deepEqual(yield xs.count(), 4);
xs = asyncQueryable_1.AsyncQueryableImpl.from([]).concat([3, 4]);
assert.deepEqual(yield xs.toArray(), [3, 4]);
assert.deepEqual(yield xs.count(), 2);
assert.deepEqual(yield xs.count(), 2);
xs = asyncQueryable_1.AsyncQueryableImpl.from([1, 2]).concat([]);
assert.deepEqual(yield xs.toArray(), [1, 2]);
assert.deepEqual(yield xs.count(), 2);
assert.deepEqual(yield xs.count(), 2);
}));
it("concats sources of multiple types", () => __awaiter(void 0, void 0, void 0, function* () {
let xs = asyncQueryable_1.AsyncQueryableImpl.from([1, 2]).concat(["foo", "bar"]);
assert.deepEqual(yield xs.toArray(), [1, 2, "foo", "bar"]);
assert.deepEqual(yield xs.count(), 4);
assert.deepEqual(yield xs.count(), 4);
xs = asyncQueryable_1.AsyncQueryableImpl.from([]).concat(["foo", "bar"]);
assert.deepEqual(yield xs.toArray(), ["foo", "bar"]);
assert.deepEqual(yield xs.count(), 2);
assert.deepEqual(yield xs.count(), 2);
xs = asyncQueryable_1.AsyncQueryableImpl.from([1, 2]).concat([]);
assert.deepEqual(yield xs.toArray(), [1, 2]);
assert.deepEqual(yield xs.count(), 2);
assert.deepEqual(yield xs.count(), 2);
}));
it("concats Promise<T[]>", () => __awaiter(void 0, void 0, void 0, function* () {
let xs = asyncQueryable_1.AsyncQueryableImpl.from([1, 2]).concat([3, 4]);
assert.deepEqual(yield xs.toArray(), [1, 2, 3, 4]);
assert.deepEqual(yield xs.count(), 4);
assert.deepEqual(yield xs.count(), 4);
xs = asyncQueryable_1.AsyncQueryableImpl.from([1, 2]).concat([3, 4]);
assert.deepEqual(yield xs.toArray(), [1, 2, 3, 4]);
assert.deepEqual(yield xs.count(), 4);
assert.deepEqual(yield xs.count(), 4);
xs = asyncQueryable_1.AsyncQueryableImpl.from([]).concat([3, 4]);
assert.deepEqual(yield xs.toArray(), [3, 4]);
assert.deepEqual(yield xs.count(), 2);
assert.deepEqual(yield xs.count(), 2);
xs = asyncQueryable_1.AsyncQueryableImpl.from([]).concat([3, 4]);
assert.deepEqual(yield xs.toArray(), [3, 4]);
assert.deepEqual(yield xs.count(), 2);
assert.deepEqual(yield xs.count(), 2);
xs = asyncQueryable_1.AsyncQueryableImpl.from([1, 2]).concat([]);
assert.deepEqual(yield xs.toArray(), [1, 2]);
assert.deepEqual(yield xs.count(), 2);
assert.deepEqual(yield xs.count(), 2);
xs = asyncQueryable_1.AsyncQueryableImpl.from([1, 2]).concat([]);
assert.deepEqual(yield xs.toArray(), [1, 2]);
assert.deepEqual(yield xs.count(), 2);
assert.deepEqual(yield xs.count(), 2);
}));
it("concats iterators", () => __awaiter(void 0, void 0, void 0, function* () {
//
// TODO: Make `from` take generator functions.
//
let xs = asyncQueryable_1.AsyncQueryableImpl.from(__1.from(function* () {
for (const x of [1, 2]) {
yield x;
}
})).concat([3, 4]);
assert.deepEqual(yield xs.toArray(), [1, 2, 3, 4]);
assert.deepEqual(yield xs.toArray(), [1, 2, 3, 4]);
assert.deepEqual(yield xs.count(), 4);
assert.deepEqual(yield xs.count(), 4);
xs = asyncQueryable_1.AsyncQueryableImpl.from([1, 2]).concat(__1.from(function* () {
for (const x of [3, 4]) {
yield x;
}
}));
assert.deepEqual(yield xs.toArray(), [1, 2, 3, 4]);
assert.deepEqual(yield xs.count(), 4);
assert.deepEqual(yield xs.count(), 4);
xs = asyncQueryable_1.AsyncQueryableImpl.from(__1.from(function* () {
for (const x of []) {
yield x;
}
})).concat([3, 4]);
assert.deepEqual(yield xs.toArray(), [3, 4]);
assert.deepEqual(yield xs.count(), 2);
assert.deepEqual(yield xs.count(), 2);
xs = asyncQueryable_1.AsyncQueryableImpl.from([]).concat(__1.from(function* () {
for (const x of [3, 4]) {
yield x;
}
}));
assert.deepEqual(yield xs.toArray(), [3, 4]);
assert.deepEqual(yield xs.count(), 2);
assert.deepEqual(yield xs.count(), 2);
xs = asyncQueryable_1.AsyncQueryableImpl.from(__1.from(function* () {
for (const x of [1, 2]) {
yield x;
}
})).concat([]);
assert.deepEqual(yield xs.toArray(), [1, 2]);
assert.deepEqual(yield xs.count(), 2);
assert.deepEqual(yield xs.count(), 2);
xs = asyncQueryable_1.AsyncQueryableImpl.from([1, 2]).concat(__1.from(function* () {
for (const x of []) {
yield x;
}
}));
assert.deepEqual(yield xs.toArray(), [1, 2]);
assert.deepEqual(yield xs.count(), 2);
assert.deepEqual(yield xs.count(), 2);
}));
});
});
describe("IterablePromise ordering operators", () => {
describe("reverse", () => {
it("produces [] for empty array", () => __awaiter(void 0, void 0, void 0, function* () {
let xs = asyncQueryable_1.AsyncQueryableImpl.from([]).reverse();
assert.deepEqual(yield xs.toArray(), []);
assert.deepEqual(yield xs.count(), 0);
assert.deepEqual(yield xs.count(), 0);
xs = yield asyncQueryable_1.AsyncQueryableImpl.from((function* () {
for (const x of []) {
yield x;
}
})()).reverse();
assert.deepEqual(yield xs.toArray(), []);
assert.deepEqual(yield xs.count(), 0);
assert.deepEqual(yield xs.count(), 0);
}));
});
describe("orderBy", () => {
it("correctly sorts number keys", () => __awaiter(void 0, void 0, void 0, function* () {
let xs = asyncQueryable_1.AsyncQueryableImpl.from([]).orderBy(x => x);
assert.deepEqual(yield xs.toArray(), []);
assert.deepEqual(yield xs.count(), 0);
assert.deepEqual(yield xs.count(), 0);
xs = asyncQueryable_1.AsyncQueryableImpl.from([2, 3, 1, 14]).orderBy(x => x);
assert.deepEqual(yield xs.toArray(), [1, 2, 3, 14]);
assert.deepEqual(yield xs.count(), 4);
assert.deepEqual(yield xs.count(), 4);
}));
it("lexically sorts string keys", () => __awaiter(void 0, void 0, void 0, function* () {
const xs = asyncQueryable_1.AsyncQueryableImpl.from([2, 3, 1, 14]).orderBy(x => x.toString());
assert.deepEqual(yield xs.toArray(), [1, 14, 2, 3]);
assert.deepEqual(yield xs.count(), 4);
assert.deepEqual(yield xs.count(), 4);
}));
it("rejects if key function returns something other than number | string", done => {
assertRejects(done, asyncQueryable_1.AsyncQueryableImpl.from([2, 3, 1, 14])
.orderBy(() => [2])
.toArray());
});
it("rejects if key function does not return only keys of one type", done => {
assertRejects(done, asyncQueryable_1.AsyncQueryableImpl.from([2, 3, 1, 14])
.orderBy(x => {
if (x === 2) {
return "2";
}
return x;
})
.toArray());
});
});
});
describe("IterablePromise grouping operators", () => {
describe("groupBy", () => {
it("produces [] for empty array", () => __awaiter(void 0, void 0, void 0, function* () {
let xs = asyncQueryable_1.AsyncQueryableImpl.from([]).groupBy(x => x);
assert.deepEqual(yield xs.toArray(), []);
assert.deepEqual(yield xs.count(), 0);
assert.deepEqual(yield xs.count(), 0);
xs = asyncQueryable_1.AsyncQueryableImpl.from((function* () {
for (const x of []) {
yield x;
}
})()).groupBy(x => x);
assert.deepEqual(yield xs.toArray(), []);
assert.deepEqual(yield xs.count(), 0);
assert.deepEqual(yield xs.count(), 0);
}));
it("produces non-empty groups when array is not empty", () => __awaiter(void 0, void 0, void 0, function* () {
let xs = asyncQueryable_1.AsyncQueryableImpl.from([1])
.groupBy(x => x)
.map(g => g.toArray());
assert.deepEqual(yield xs.toArray(), [[1]]);
assert.deepEqual(yield xs.count(), 1);
assert.deepEqual(yield xs.count(), 1);
xs = asyncQueryable_1.AsyncQueryableImpl.from(__1.from(function* () {
for (const x of [1]) {
yield x;
}
}))
.groupBy(x => x)
.map(g => g.toArray());
assert.deepEqual(yield xs.toArray(), [[1]]);
assert.deepEqual(yield xs.count(), 1);
assert.deepEqual(yield xs.count(), 1);
xs = asyncQueryable_1.AsyncQueryableImpl.from([1, 2])
.groupBy(x => x)
.map(g => g.toArray());
assert.deepEqual(yield xs.toArray(), [[1], [2]]);
assert.deepEqual(yield xs.count(), 2);
assert.deepEqual(yield xs.count(), 2);
xs = asyncQueryable_1.AsyncQueryableImpl.from(__1.from(function* () {
for (const x of [1, 2]) {
yield x;
}
}))
.groupBy(x => x)
.map(g => g.toArray());
assert.deepEqual(yield xs.toArray(), [[1], [2]]);
assert.deepEqual(yield xs.count(), 2);
assert.deepEqual(yield xs.count(), 2);
xs = asyncQueryable_1.AsyncQueryableImpl.from([1, 2, 1])
.groupBy(x => x)
.map(g => g.toArray());
assert.deepEqual(yield xs.toArray(), [[1, 1], [2]]);
assert.deepEqual(yield xs.count(), 2);
assert.deepEqual(yield xs.count(), 2);
xs = asyncQueryable_1.AsyncQueryableImpl.from(__1.from(function* () {
for (const x of [1, 2, 1]) {
yield x;
}
}))
.groupBy(x => x)
.map(g => g.toArray());
assert.deepEqual(yield xs.toArray(), [[1, 1], [2]]);
assert.deepEqual(yield xs.count(), 2);
assert.deepEqual(yield xs.count(), 2);
const ys = asyncQueryable_1.AsyncQueryableImpl.from([
{ foo: "bar", bar: 1 },
{ foo: "baz" },
{ foo: undefined },
{ foo: "bar", bar: 2 },
])
.groupBy(x => x.foo)
.map(g => g.toArray());
assert.deepEqual(yield ys.toArray(), [
[{ foo: "bar", bar: 1 }, { foo: "bar", bar: 2 }],
[{ foo: "baz" }],
[{ foo: undefined }],
]);
assert.deepEqual(yield ys.count(), 3);
assert.deepEqual(yield ys.count(), 3);
}));
it("produces projected elements when result selector is used", () => __awaiter(void 0, void 0, void 0, function* () {
const ys = asyncQueryable_1.AsyncQueryableImpl.from([
{ foo: "bar", bar: 1 },
{ foo: "baz" },
{ foo: undefined },
{ foo: "bar", bar: 2 },
])
.groupBy(x => x.foo, x => x.foo)
.map(g => g.toArray());
assert.deepEqual(yield ys.toArray(), [["bar", "bar"], ["baz"], [undefined]]);
assert.deepEqual(yield ys.count(), 3);
assert.deepEqual(yield ys.count(), 3);
}));
});
});
describe("IterablePromise set operators", () => {
describe("distinct", () => {
it("produces [] for empty array", () => __awaiter(void 0, void 0, void 0, function* () {
const xs = asyncQueryable_1.AsyncQueryableImpl.from([]).distinct();
assert.deepEqual(yield xs.toArray(), []);
assert.deepEqual(yield xs.count(), 0);
assert.deepEqual(yield xs.count(), 0);
}));
it("produces non-empty set when array is not empty", () => __awaiter(void 0, void 0, void 0, function* () {
let xs = asyncQueryable_1.AsyncQueryableImpl.from([1, 2, 3]).distinct();
assert.deepEqual(yield xs.toArray(), [1, 2, 3]);
assert.deepEqual(yield xs.count(), 3);
assert.deepEqual(yield xs.count(), 3);
xs = asyncQueryable_1.AsyncQueryableImpl.from([1, 1, 1, 2, 3, 1, 1]).distinct();
assert.deepEqual(yield xs.toArray(), [1, 2, 3]);
assert.deepEqual(yield xs.count(), 3);
assert.deepEqual(yield xs.count(), 3);
}));
});
describe("union", () => {
it("produces [] for empty array", () => __awaiter(void 0, void 0, void 0, function* () {
const xs = asyncQueryable_1.AsyncQueryableImpl.from([]).union([]);
assert.deepEqual(yield xs.toArray(), []);
assert.deepEqual(yield xs.count(), 0);
assert.deepEqual(yield xs.count(), 0);
}));
it("produces non-empty set when array is not empty", () => __awaiter(void 0, void 0, void 0, function* () {
let xs = asyncQueryable_1.AsyncQueryableImpl.from([1, 2, 3]).union([]);
assert.deepEqual(yield xs.toArray(), [1, 2, 3]);
assert.deepEqual(yield xs.count(), 3);
assert.deepEqual(yield xs.count(), 3);
xs = asyncQueryable_1.AsyncQueryableImpl.from([]).union([1, 1, 1, 2, 3, 1, 1]);
assert.deepEqual(yield xs.toArray(), [1, 2, 3]);
assert.deepEqual(yield xs.count(), 3);
assert.deepEqual(yield xs.count(), 3);
xs = asyncQueryable_1.AsyncQueryableImpl.from([1, 2, 3]).union([1, 1, 1, 2, 3, 1, 1]);
assert.deepEqual(yield xs.toArray(), [1, 2, 3]);
assert.deepEqual(yield xs.count(), 3);
assert.deepEqual(yield xs.count(), 3);
xs = asyncQueryable_1.AsyncQueryableImpl.from([1, 1, 1, 2, 3, 1, 1]).union([1, 2, 3]);
assert.deepEqual(yield xs.toArray(), [1, 2, 3]);
assert.deepEqual(yield xs.count(), 3);
assert.deepEqual(yield xs.count(), 3);
xs = asyncQueryable_1.AsyncQueryableImpl.from([1, 1, 1, 2, 3, 1, 1, 4, 4, 5, 4]).union([1, 2, 3]);
assert.deepEqual(yield xs.toArray(), [1, 2, 3, 4, 5]);
assert.deepEqual(yield xs.count(), 5);
assert.deepEqual(yield xs.count(), 5);
}));
});
describe("intersect", () => {
it("produces [] when there is no set intersection", () => __awaiter(void 0, void 0, void 0, function* () {
let xs = asyncQueryable_1.AsyncQueryableImpl.from([]).intersect([]);
assert.deepEqual(yield xs.toArray(), []);
assert.deepEqual(yield xs.count(), 0);
assert.deepEqual(yield xs.count(), 0);
xs = asyncQueryable_1.AsyncQueryableImpl.from([1, 2, 3]).intersect([]);
assert.deepEqual(yield xs.toArray(), []);
assert.deepEqual(yield xs.count(), 0);
assert.deepEqual(yield xs.count(), 0);
xs = asyncQueryable_1.AsyncQueryableImpl.from([]).intersect([1, 2, 3]);
assert.deepEqual(yield xs.toArray(), []);
assert.deepEqual(yield xs.count(), 0);
assert.deepEqual(yield xs.count(), 0);
xs = asyncQueryable_1.AsyncQueryableImpl.from([1, 2, 3]).intersect([4, 5, 6]);
assert.deepEqual(yield xs.toArray(), []);
assert.deepEqual(yield xs.count(), 0);
assert.deepEqual(yield xs.count(), 0);
}));
it("produces non-empty set when intersection is not empty", () => __awaiter(void 0, void 0, void 0, function* () {
let xs = asyncQueryable_1.AsyncQueryableImpl.from([1, 2, 3]).intersect([1]);
assert.deepEqual(yield xs.toArray(), [1]);
assert.deepEqual(yield xs.count(), 1);
assert.deepEqual(yield xs.count(), 1);
xs = asyncQueryable_1.AsyncQueryableImpl.from([1, 2]).intersect([1, 1, 1, 2, 3, 1, 1]);
assert.deepEqual(yield xs.toArray(), [1, 2]);
assert.deepEqual(yield xs.count(), 2);
assert.deepEqual(yield xs.count(), 2);
xs = asyncQueryable_1.AsyncQueryableImpl.from([1, 1, 1, 2, 3, 1, 1]).intersect([1, 2]);
assert.deepEqual(yield xs.toArray(), [1, 2]);
assert.deepEqual(yield xs.count(), 2);
assert.deepEqual(yield xs.count(), 2);
xs = asyncQueryable_1.AsyncQueryableImpl.from([1, 1, 1, 2, 3, 1, 1]).intersect([1, 2, 3]);
assert.deepEqual(yield xs.toArray(), [1, 2, 3]);
assert.deepEqual(yield xs.count(), 3);
assert.deepEqual(yield xs.count(), 3);
}));
});
describe("except", () => {
it("produces [] when there is no set difference", () => __awaiter(void 0, void 0, void 0, function* () {
let xs = asyncQueryable_1.AsyncQueryableImpl.from([]).except([]);
assert.deepEqual(yield xs.toArray(), []);
assert.deepEqual(yield xs.count(), 0);
assert.deepEqual(yield xs.count(), 0);
xs = asyncQueryable_1.AsyncQueryableImpl.from([1, 2, 3]).except([1, 2, 3]);
assert.deepEqual(yield xs.toArray(), []);
assert.deepEqual(yield xs.count(), 0);
assert.deepEqual(yield xs.count(), 0);
xs = asyncQueryable_1.AsyncQueryableImpl.from([1, 2, 3]).except([1, 1, 1, 2, 3, 1, 1]);
assert.deepEqual(yield xs.toArray(), []);
assert.deepEqual(yield xs.count(), 0);
assert.deepEqual(yield xs.count(), 0);
xs = asyncQueryable_1.AsyncQueryableImpl.from([1, 1, 1, 2, 3, 1, 1]).except([1, 2, 3]);
assert.deepEqual(yield xs.toArray(), []);
assert.deepEqual(yield xs.count(), 0);
assert.deepEqual(yield xs.count(), 0);
}));
it("produces non-empty set when set difference is not empty", () => __awaiter(void 0, void 0, void 0, function* () {
let xs = asyncQueryable_1.AsyncQueryableImpl.from([1, 2, 3]).except([1]);
assert.deepEqual(yield xs.toArray(), [2, 3]);
assert.deepEqual(yield xs.count(), 2);
assert.deepEqual(yield xs.count(), 2);
xs = asyncQueryable_1.AsyncQueryableImpl.from([1, 2]).except([1, 1, 1, 2, 3, 1, 1]);
assert.deepEqual(yield xs.toArray(), [3]);
assert.deepEqual(yield xs.count(), 1);
assert.deepEqual(yield xs.count(), 1);
xs = asyncQueryable_1.AsyncQueryableImpl.from([1, 1, 1, 2, 3, 1, 1]).except([1, 2]);
assert.deepEqual(yield xs.toArray(), [3]);
assert.deepEqual(yield xs.count(), 1);
assert.deepEqual(yield xs.count(), 1);
}));
});
});
describe("IterablePromise element operators", () => {
describe("first", () => {
it("throws error if enumerable is empty", done => {
assertRejects(done, asyncQueryable_1.AsyncQueryableImpl.from([]).first());
});
it("throws error if predicate specifies non-existent element", done => {
assertRejects(done, asyncQueryable_1.AsyncQueryableImpl.from([1, 2, 3]).first(x => x === 4));
});
it("finds first element of sequence", () => __awaiter(void 0, void 0, void 0, function* () {
let xs = asyncQueryable_1.AsyncQueryableImpl.from([1, 2, 3]);
assert.deepEqual(yield xs.first(), 1);
assert.deepEqual(yield xs.first(), 1);
xs = asyncQueryable_1.AsyncQueryableImpl.from(__1.from(function* () {
for (const x of [1, 2, 3]) {
yield x;
}
}));
assert.deepEqual(yield xs.first(), 1);
assert.deepEqual(yield xs.first(), 1);
}));
});
describe("firstOrDefault", () => {
it("default value populated if enumerable is empty", () => __awaiter(void 0, void 0, void 0, function* () {
let xs = asyncQueryable_1.AsyncQueryableImpl.from([]);
assert.deepEqual(yield xs.firstOrDefault(99), 99);
assert.deepEqual(yield xs.firstOrDefault(99), 99);
xs = asyncQueryable_1.AsyncQueryableImpl.from((function* () {
for (const x of []) {
yield x;
}
})());
assert.deepEqual(yield xs.firstOrDefault(99), 99);
assert.deepEqual(yield xs.firstOrDefault(99), 99);
}));
it("default value if predicate specifies non-existent element", () => __awaiter(void 0, void 0, void 0, function* () {
let xs = asyncQueryable_1.AsyncQueryableImpl.from([1, 2, 3]);
assert.deepEqual(yield xs.firstOrDefault(99, x => x === 4), 99);
assert.deepEqual(yield xs.firstOrDefault(99, x => x === 4), 99);
xs = asyncQueryable_1.AsyncQueryableImpl.from((function* () {
for (const x of [1, 2, 3]) {
yield x;
}
})());
assert.deepEqual(yield xs.firstOrDefault(99, x => x === 4), 99);
assert.deepEqual(yield xs.firstOrDefault(99, x => x === 4), 99);
}));
it("finds first element of sequence", () => __awaiter(void 0, void 0, void 0, function* () {
let xs = asyncQueryable_1.AsyncQueryableImpl.from([1, 2, 3]);
assert.deepEqual(yield xs.firstOrDefault(99), 1);
assert.deepEqual(yield xs.firstOrDefault(99), 1);
xs = asyncQueryable_1.AsyncQueryableImpl.from(__1.from(function* () {
for (const x of [1, 2, 3]) {
yield x;
}
}));
assert.deepEqual(yield xs.firstOrDefault(99), 1);
assert.deepEqual(yield xs.firstOrDefault(99), 1);
}));
});
describe("last", () => {
it("throws error if enumerable is empty", done => {
assertRejects(done, asyncQueryable_1.AsyncQueryableImpl.from([]).last());
});
it("throws error if predicate specifies non-existent element", done => {
assertRejects(done, asyncQueryable_1.AsyncQueryableImpl.from([1, 2, 3]).last(x => x === 4));
});
it("finds last element of sequence", () => __awaiter(void 0, void 0, void 0, function* () {
let xs = asyncQueryable_1.AsyncQueryableImpl.from([1, 2, 3]);
assert.deepEqual(yield xs.last(), 3);
assert.deepEqual(yield xs.last(), 3);
xs = asyncQueryable_1.AsyncQueryableImpl.from(__1.from(function* () {
for (const x of [1, 2, 3]) {
yield x;
}
}));
assert.deepEqual(yield xs.last(), 3);
assert.deepEqual(yield xs.last(), 3);
}));
});
describe("lastOrDefault", () => {
it("default value populated if enumerable is empty", () => __awaiter(void 0, void 0, void 0, function* () {
let xs = asyncQueryable_1.AsyncQueryableImpl.from([]);
assert.deepEqual(yield xs.lastOrDefault(99), 99);
assert.deepEqual(yield xs.lastOrDefault(99), 99);
xs = asyncQueryable_1.AsyncQueryableImpl.from(__1.from(function* () {
for (const x of []) {
yield x;
}
}));
assert.deepEqual(yield xs.lastOrDefault(99), 99);
assert.deepEqual(yield xs.lastOrDefault(99), 99);
}));
it("default value if predicate specifies non-existent element", () => __awaiter(void 0, void 0, void 0, function*