mirror of
https://github.com/Kir-Antipov/mc-publish.git
synced 2024-11-27 10:51:03 -05:00
1606 lines
53 KiB
TypeScript
1606 lines
53 KiB
TypeScript
import { IGNORE_CASE_COMPARER } from "@/utils/comparison/string-comparer";
|
|
import { IGNORE_CASE_EQUALITY_COMPARER } from "@/utils/comparison/string-equality-comparer";
|
|
import * as Iterable from "@/utils/collections/iterable";
|
|
|
|
describe("isIterable", () => {
|
|
test("returns true for iterable objects", () => {
|
|
expect(Iterable.isIterable([1, 2, 3])).toBe(true);
|
|
expect(Iterable.isIterable(new Set())).toBe(true);
|
|
expect(Iterable.isIterable(new Map())).toBe(true);
|
|
expect(Iterable.isIterable("test")).toBe(true);
|
|
});
|
|
|
|
test("returns false for non-iterable objects", () => {
|
|
expect(Iterable.isIterable(123)).toBe(false);
|
|
expect(Iterable.isIterable({ key: "value" })).toBe(false);
|
|
expect(Iterable.isIterable(undefined)).toBe(false);
|
|
expect(Iterable.isIterable(null)).toBe(false);
|
|
});
|
|
});
|
|
|
|
describe("filter", () => {
|
|
test("filters out elements not matching the predicate", () => {
|
|
const iterable = [1, 2, 3, 4, 5];
|
|
|
|
const result = Array.from(Iterable.filter(iterable, x => x > 3));
|
|
|
|
expect(result).toEqual([4, 5]);
|
|
});
|
|
|
|
test("binds thisArg to the predicate", () => {
|
|
const iterable = [1, 2, 3, 4, 5];
|
|
const thisArg = { threshold: 3 };
|
|
|
|
const result = Array.from(Iterable.filter(iterable, function (x) { return x > this.threshold; }, thisArg));
|
|
|
|
expect(result).toEqual([4, 5]);
|
|
});
|
|
});
|
|
|
|
describe("distinct", () => {
|
|
test("removes duplicate elements", () => {
|
|
const iterable = [1, 2, 3, 2, 1];
|
|
|
|
const result = Array.from(Iterable.distinct(iterable));
|
|
|
|
expect(result).toEqual([1, 2, 3]);
|
|
});
|
|
|
|
test("uses provided comparer for equality check", () => {
|
|
const iterable = [{ id: 1 }, { id: 2 }, { id: 1 }, { id: 2 }];
|
|
|
|
const result = Array.from(Iterable.distinct(iterable, (a, b) => a.id === b.id));
|
|
|
|
expect(result).toEqual([{ id: 1 }, { id: 2 }]);
|
|
});
|
|
});
|
|
|
|
describe("distinctBy", () => {
|
|
test("removes elements with duplicate selected property", () => {
|
|
const iterable = [{ id: 1 }, { id: 2 }, { id: 1 }, { id: 2 }];
|
|
|
|
const result = Array.from(Iterable.distinctBy(iterable, x => x.id));
|
|
|
|
expect(result).toEqual([{ id: 1 }, { id: 2 }]);
|
|
});
|
|
|
|
test("uses provided comparer for equality check of selected property", () => {
|
|
const iterable = [{ id: "a" }, { id: "b" }, { id: "A" }, { id: "B" }];
|
|
|
|
const result = Array.from(Iterable.distinctBy(iterable, x => x.id, IGNORE_CASE_EQUALITY_COMPARER));
|
|
|
|
expect(result).toEqual([{ id: "A" }, { id: "B" }]);
|
|
});
|
|
});
|
|
|
|
describe("map", () => {
|
|
test("applies callback function to each element", () => {
|
|
const iterable = [1, 2, 3];
|
|
|
|
const result = Array.from(Iterable.map(iterable, x => x * 2));
|
|
|
|
expect(result).toEqual([2, 4, 6]);
|
|
});
|
|
|
|
test("binds thisArg to the callback function", () => {
|
|
const iterable = [1, 2, 3];
|
|
const thisArg = { factor: 2 };
|
|
|
|
const result = Array.from(Iterable.map(iterable, function (x) { return x * this.factor; }, thisArg));
|
|
|
|
expect(result).toEqual([2, 4, 6]);
|
|
});
|
|
});
|
|
|
|
describe("flatMap", () => {
|
|
test("applies callback function to each element and flattens the result", () => {
|
|
const iterable = [1, 2, 3];
|
|
|
|
const result = Array.from(Iterable.flatMap(iterable, x => [x, x * 2]));
|
|
|
|
expect(result).toEqual([1, 2, 2, 4, 3, 6]);
|
|
});
|
|
|
|
test("binds thisArg to the callback function", () => {
|
|
const iterable = [1, 2, 3];
|
|
const thisArg = { factor: 2 };
|
|
|
|
const result = Array.from(Iterable.flatMap(iterable, function (x) { return [x, x * this.factor]; }, thisArg));
|
|
|
|
expect(result).toEqual([1, 2, 2, 4, 3, 6]);
|
|
});
|
|
});
|
|
|
|
describe("reduce", () => {
|
|
test("reduces iterable to a single value", () => {
|
|
const iterable = [1, 2, 3, 4, 5];
|
|
|
|
const result = Iterable.reduce(iterable, (acc, curr) => acc + curr, 0);
|
|
|
|
expect(result).toBe(15);
|
|
});
|
|
|
|
test("uses the first value as a seed when one was not provided", () => {
|
|
const callback = jest.fn().mockImplementation((acc, cur) => acc + cur);
|
|
const iterable = [1, 2, 3, 4, 5];
|
|
|
|
const result = Iterable.reduce(iterable, callback);
|
|
|
|
expect(result).toBe(15);
|
|
expect(callback).toHaveBeenCalledTimes(4);
|
|
// 1st (ie 0th) call - 1 as accumulator, 2 as value, 1 as current index
|
|
expect(callback).toHaveBeenNthCalledWith(1, 1, 2, 1, iterable);
|
|
});
|
|
|
|
test("binds thisArg to the callback function", () => {
|
|
const iterable = [1, 2, 3, 4, 5];
|
|
const thisArg = { factor: 2 };
|
|
|
|
const result = Iterable.reduce(iterable, function (acc, curr) { return acc + curr * this.factor; }, 0, thisArg);
|
|
|
|
expect(result).toBe(30);
|
|
});
|
|
});
|
|
|
|
describe("skip", () => {
|
|
test("skips the first n elements", () => {
|
|
const iterable = [1, 2, 3, 4, 5];
|
|
|
|
const result = Array.from(Iterable.skip(iterable, 2));
|
|
|
|
expect(result).toEqual([3, 4, 5]);
|
|
});
|
|
|
|
test("does not skip elements if n <= 0", () => {
|
|
expect(Array.from(Iterable.skip([1, 2], 0))).toEqual([1, 2]);
|
|
expect(Array.from(Iterable.skip([1, 2], -1))).toEqual([1, 2]);
|
|
});
|
|
});
|
|
|
|
describe("take", () => {
|
|
test("takes the first n elements", () => {
|
|
const iterable = [1, 2, 3, 4, 5];
|
|
|
|
const result = Array.from(Iterable.take(iterable, 3));
|
|
|
|
expect(result).toEqual([1, 2, 3]);
|
|
});
|
|
|
|
test("returns an empty iterable if n <= 0", () => {
|
|
expect(Array.from(Iterable.take([1, 2], 0))).toEqual([]);
|
|
expect(Array.from(Iterable.take([1, 2], -1))).toEqual([]);
|
|
});
|
|
});
|
|
|
|
describe("takeLast", () => {
|
|
test("takes the last n elements", () => {
|
|
const iterable = [1, 2, 3, 4, 5];
|
|
|
|
const result = Array.from(Iterable.takeLast(iterable, 2));
|
|
|
|
expect(result).toEqual([4, 5]);
|
|
});
|
|
|
|
test("returns an empty iterable if n <= 0", () => {
|
|
expect(Array.from(Iterable.takeLast([1, 2], 0))).toEqual([]);
|
|
expect(Array.from(Iterable.takeLast([1, 2], -1))).toEqual([]);
|
|
});
|
|
});
|
|
|
|
describe("slice", () => {
|
|
test("slices the elements between start and end", () => {
|
|
const iterable = [1, 2, 3, 4, 5];
|
|
|
|
const result = Array.from(Iterable.slice(iterable, 1, 4));
|
|
|
|
expect(result).toEqual([2, 3, 4]);
|
|
});
|
|
|
|
test("slices the elements using relative indices", () => {
|
|
const iterable = [1, 2, 3, 4, 5];
|
|
|
|
const result = Array.from(Iterable.slice(iterable, -3, -1));
|
|
|
|
expect(result).toEqual([3, 4]);
|
|
});
|
|
});
|
|
|
|
describe("reverse", () => {
|
|
test("reverses the order of elements", () => {
|
|
const iterable = [1, 2, 3, 4, 5];
|
|
|
|
const result = Array.from(Iterable.reverse(iterable));
|
|
|
|
expect(result).toEqual([5, 4, 3, 2, 1]);
|
|
});
|
|
|
|
test("returns an empty iterable if the input is already empty", () => {
|
|
expect(Array.from(Iterable.reverse([]))).toEqual([]);
|
|
});
|
|
});
|
|
|
|
describe("sort", () => {
|
|
test("sorts elements in ascending order by default", () => {
|
|
const iterable = [5, 3, 1, 4, 2];
|
|
|
|
const result = Array.from(Iterable.sort(iterable));
|
|
|
|
expect(result).toEqual([1, 2, 3, 4, 5]);
|
|
});
|
|
|
|
test("sorts elements according to comparer function", () => {
|
|
const iterable = ["Apple", "Pear", "banana", "mango", "Cherry"];
|
|
|
|
const result = Array.from(Iterable.sort(iterable, IGNORE_CASE_COMPARER));
|
|
|
|
expect(result).toEqual(["Apple", "banana", "Cherry", "mango", "Pear"]);
|
|
});
|
|
});
|
|
|
|
describe("every", () => {
|
|
test("returns true if all elements meet the condition", () => {
|
|
const iterable = [2, 4, 6, 8];
|
|
|
|
const result = Iterable.every(iterable, (value) => value % 2 === 0);
|
|
|
|
expect(result).toBe(true);
|
|
});
|
|
|
|
test("returns false if any element does not meet the condition", () => {
|
|
const iterable = [2, 4, 5, 8];
|
|
|
|
const result = Iterable.every(iterable, (value) => value % 2 === 0);
|
|
|
|
expect(result).toBe(false);
|
|
});
|
|
|
|
test("binds thisArg to the callback function", () => {
|
|
const iterable = [2, 4, 6, 8];
|
|
const thisArg = { factor: 2 };
|
|
|
|
const result = Iterable.every(iterable, function (x) { return x % this.factor === 0; }, thisArg);
|
|
|
|
expect(result).toBe(true);
|
|
});
|
|
});
|
|
|
|
describe("some", () => {
|
|
test("returns true if any element meets the condition", () => {
|
|
const iterable = [1, 3, 4, 7];
|
|
|
|
const result = Iterable.some(iterable, (value) => value % 2 === 0);
|
|
|
|
expect(result).toBe(true);
|
|
});
|
|
|
|
test("returns false if no element meets the condition", () => {
|
|
const iterable = [1, 3, 5, 7];
|
|
|
|
const result = Iterable.some(iterable, (value) => value % 2 === 0);
|
|
|
|
expect(result).toBe(false);
|
|
});
|
|
|
|
test("binds thisArg to the callback function", () => {
|
|
const iterable = [1, 3, 4, 7];
|
|
const thisArg = { factor: 2 };
|
|
|
|
const result = Iterable.some(iterable, function (x) { return x % this.factor === 0; }, thisArg);
|
|
|
|
expect(result).toBe(true);
|
|
});
|
|
});
|
|
|
|
describe("min", () => {
|
|
test("returns the minimum value in an iterable", () => {
|
|
const iterable = [3, 1, 4, 2];
|
|
|
|
const result = Iterable.min(iterable);
|
|
|
|
expect(result).toBe(1);
|
|
});
|
|
|
|
test("returns the minimum value in an iterable with custom comparer", () => {
|
|
const iterable = ["apple", "banana", "cherry"];
|
|
|
|
const result = Iterable.min(iterable, (a, b) => a.length - b.length);
|
|
|
|
expect(result).toBe("apple");
|
|
});
|
|
|
|
test("returns undefined for an empty iterable", () => {
|
|
const iterable = [];
|
|
|
|
const result = Iterable.min(iterable);
|
|
|
|
expect(result).toBeUndefined();
|
|
});
|
|
|
|
test("binds thisArg to the callback function", () => {
|
|
const iterable = [3, 1, 4, 2];
|
|
const thisArg = { sign: -1 };
|
|
|
|
const result = Iterable.min(iterable, function (a, b) { return (a - b) * this.sign; }, thisArg);
|
|
|
|
expect(result).toBe(4);
|
|
});
|
|
});
|
|
|
|
describe("max", () => {
|
|
test("returns the maximum value in an iterable", () => {
|
|
const iterable = [3, 1, 4, 2];
|
|
const result = Iterable.max(iterable);
|
|
expect(result).toBe(4);
|
|
});
|
|
|
|
test("returns the maximum value in an iterable with custom comparer", () => {
|
|
const iterable = ["apple", "banana", "cherry"];
|
|
const result = Iterable.max(iterable, (a, b) => a.length - b.length);
|
|
expect(result).toBe("banana");
|
|
});
|
|
|
|
test("returns undefined for an empty iterable", () => {
|
|
const iterable = [];
|
|
const result = Iterable.max(iterable);
|
|
expect(result).toBeUndefined();
|
|
});
|
|
|
|
test("binds thisArg to the callback function", () => {
|
|
const iterable = [3, 1, 4, 2];
|
|
const thisArg = { sign: -1 };
|
|
|
|
const result = Iterable.max(iterable, function (a, b) { return (a - b) * this.sign; }, thisArg);
|
|
|
|
expect(result).toBe(1);
|
|
});
|
|
});
|
|
|
|
describe("count", () => {
|
|
test("returns the count of elements that meet the condition", () => {
|
|
const iterable = [1, 2, 3, 4, 5];
|
|
|
|
const result = Iterable.count(iterable, x => x > 2);
|
|
|
|
expect(result).toBe(3);
|
|
});
|
|
|
|
test("returns the length of the iterable if no predicate is provided", () => {
|
|
const iterable = [1, 2, 3, 4, 5];
|
|
|
|
const result = Iterable.count(iterable);
|
|
|
|
expect(result).toBe(5);
|
|
});
|
|
|
|
test("returns 0 for empty iterables", () => {
|
|
expect(Iterable.count([])).toBe(0);
|
|
expect(Iterable.count(new Set())).toBe(0);
|
|
expect(Iterable.count(new Map(), x => x)).toBe(0);
|
|
});
|
|
|
|
test("binds thisArg to the callback function", () => {
|
|
const iterable = [1, 2, 3, 4, 5];
|
|
const thisArg = { min: 2 };
|
|
|
|
const result = Iterable.count(iterable, function (x) { return x > this.min; }, thisArg);
|
|
|
|
expect(result).toBe(3);
|
|
});
|
|
});
|
|
|
|
describe("indexOf", () => {
|
|
test("returns the index of the first occurrence of a specified value", () => {
|
|
const iterable = [1, 2, 3, 2, 4];
|
|
|
|
const result = Iterable.indexOf(iterable, 2);
|
|
|
|
expect(result).toBe(1);
|
|
});
|
|
|
|
test("returns -1 if the iterable does not include a certain element", () => {
|
|
const iterable = [1, 2, 3, 2, 4];
|
|
|
|
const result = Iterable.indexOf(iterable, 5);
|
|
|
|
expect(result).toBe(-1);
|
|
});
|
|
|
|
test("returns the index of the first occurrence from the given index", () => {
|
|
const iterable = [1, 2, 3, 2, 4];
|
|
|
|
const result = Iterable.indexOf(iterable, 2, 2);
|
|
|
|
expect(result).toBe(3);
|
|
});
|
|
|
|
test("returns the index of the first occurrence with custom comparer", () => {
|
|
const iterable = ["a", "b", "c", "B", "A"];
|
|
|
|
const result = Iterable.indexOf(iterable, "B", IGNORE_CASE_EQUALITY_COMPARER);
|
|
|
|
expect(result).toBe(1);
|
|
});
|
|
|
|
test("returns the index of the first occurrence with custom comparer from the given index", () => {
|
|
const iterable = ["a", "b", "c", "B", "A"];
|
|
|
|
const result = Iterable.indexOf(iterable, "b", 2, IGNORE_CASE_EQUALITY_COMPARER);
|
|
|
|
expect(result).toBe(3);
|
|
});
|
|
});
|
|
|
|
describe("lastIndexOf", () => {
|
|
test("returns the index of the last occurrence of a specified value", () => {
|
|
const iterable = [1, 2, 3, 2, 4];
|
|
|
|
const result = Iterable.lastIndexOf(iterable, 2);
|
|
|
|
expect(result).toBe(3);
|
|
});
|
|
|
|
test("returns -1 if the iterable does not include a certain element", () => {
|
|
const iterable = [1, 2, 3, 2, 4];
|
|
|
|
const result = Iterable.lastIndexOf(iterable, 5);
|
|
|
|
expect(result).toBe(-1);
|
|
});
|
|
|
|
test("returns the index of the last occurrence with custom comparer", () => {
|
|
const iterable = ["a", "b", "c", "B", "A"];
|
|
|
|
const result = Iterable.lastIndexOf(iterable, "b", IGNORE_CASE_EQUALITY_COMPARER);
|
|
|
|
expect(result).toBe(3);
|
|
});
|
|
|
|
test("returns the index of the last occurrence with custom comparer from the given index", () => {
|
|
const iterable = ["a", "b", "c", "B", "A"];
|
|
|
|
const result = Iterable.lastIndexOf(iterable, "B", 2, IGNORE_CASE_EQUALITY_COMPARER);
|
|
|
|
expect(result).toBe(1);
|
|
});
|
|
});
|
|
|
|
describe("includes", () => {
|
|
test("returns true if the iterable includes a certain element", () => {
|
|
const iterable = [1, 2, 3, 4];
|
|
|
|
const result = Iterable.includes(iterable, 2);
|
|
|
|
expect(result).toBe(true);
|
|
});
|
|
|
|
test("returns false if the iterable does not include a certain element", () => {
|
|
const iterable = [1, 2, 3, 4];
|
|
|
|
const result = Iterable.includes(iterable, 5);
|
|
|
|
expect(result).toBe(false);
|
|
});
|
|
|
|
test("returns true if the iterable includes a certain element from the given index", () => {
|
|
const iterable = ["a", "b", "c", "B"];
|
|
|
|
const result = Iterable.includes(iterable, "B", 2);
|
|
|
|
expect(result).toBe(true);
|
|
});
|
|
|
|
test("returns true if the iterable includes a certain element with custom comparer", () => {
|
|
const iterable = ["a", "b", "c"];
|
|
|
|
const result = Iterable.includes(iterable, "B", IGNORE_CASE_EQUALITY_COMPARER);
|
|
|
|
expect(result).toBe(true);
|
|
});
|
|
|
|
test("returns true if the iterable includes a certain element with custom comparer from the given index", () => {
|
|
const iterable = ["a", "b", "c", "B"];
|
|
|
|
const result = Iterable.includes(iterable, "b", 2, IGNORE_CASE_EQUALITY_COMPARER);
|
|
|
|
expect(result).toBe(true);
|
|
});
|
|
});
|
|
|
|
describe("sequenceEqual", () => {
|
|
test("returns true if two iterables are equal", () => {
|
|
const first = [1, 2, 3, 4];
|
|
const second = [1, 2, 3, 4];
|
|
|
|
const result = Iterable.sequenceEqual(first, second);
|
|
|
|
expect(result).toBe(true);
|
|
});
|
|
|
|
test("returns false if two iterables are not equal", () => {
|
|
const first = [1, 2, 3, 4];
|
|
const second = [1, 2, 3, 5];
|
|
|
|
const result = Iterable.sequenceEqual(first, second);
|
|
|
|
expect(result).toBe(false);
|
|
});
|
|
|
|
test("returns true if two iterables are equal using custom comparer", () => {
|
|
const first = ["a", "b", "c"];
|
|
const second = ["A", "B", "C"];
|
|
|
|
const result = Iterable.sequenceEqual(first, second, IGNORE_CASE_EQUALITY_COMPARER);
|
|
|
|
expect(result).toBe(true);
|
|
});
|
|
|
|
test("returns false if two iterables are not equal using custom comparer", () => {
|
|
const first = ["a", "b", "c"];
|
|
const second = ["a", "b", "d"];
|
|
|
|
const result = Iterable.sequenceEqual(first, second, IGNORE_CASE_EQUALITY_COMPARER);
|
|
|
|
expect(result).toBe(false);
|
|
});
|
|
});
|
|
|
|
describe("startsWith", () => {
|
|
test("returns true if an iterable starts with the specified search elements", () => {
|
|
const iterable = [1, 2, 3, 4];
|
|
const searchElements = [1, 2];
|
|
|
|
const result = Iterable.startsWith(iterable, searchElements);
|
|
|
|
expect(result).toBe(true);
|
|
});
|
|
|
|
test("returns false if an iterable does not start with the specified search elements", () => {
|
|
const iterable = [1, 2, 3, 4];
|
|
const searchElements = [2, 3];
|
|
|
|
const result = Iterable.startsWith(iterable, searchElements);
|
|
|
|
expect(result).toBe(false);
|
|
});
|
|
|
|
test("returns true if an iterable starts with the specified search elements from a specific index", () => {
|
|
const iterable = [1, 2, 3, 4];
|
|
const searchElements = [3, 4];
|
|
|
|
const result = Iterable.startsWith(iterable, searchElements, 2);
|
|
|
|
expect(result).toBe(true);
|
|
});
|
|
|
|
test("returns true if an iterable starts with the specified search elements using custom comparer", () => {
|
|
const iterable = ["a", "b", "c", "d"];
|
|
const searchElements = ["A", "B"];
|
|
|
|
const result = Iterable.startsWith(iterable, searchElements, IGNORE_CASE_EQUALITY_COMPARER);
|
|
|
|
expect(result).toBe(true);
|
|
});
|
|
|
|
test("returns true if an iterable starts with the specified search elements using custom comparer from the given index", () => {
|
|
const iterable = ["a", "b", "c", "d"];
|
|
const searchElements = ["C", "D"];
|
|
|
|
const result = Iterable.startsWith(iterable, searchElements, 2, IGNORE_CASE_EQUALITY_COMPARER);
|
|
|
|
expect(result).toBe(true);
|
|
});
|
|
});
|
|
|
|
describe("endsWith", () => {
|
|
test("returns true if an iterable ends with the specified search elements", () => {
|
|
const iterable = [1, 2, 3, 4];
|
|
const searchElements = [3, 4];
|
|
|
|
const result = Iterable.endsWith(iterable, searchElements);
|
|
|
|
expect(result).toBe(true);
|
|
});
|
|
|
|
test("returns true if an iterable does not end with the specified search elements", () => {
|
|
const iterable = [1, 2, 3, 4];
|
|
const searchElements = [2, 3];
|
|
|
|
const result = Iterable.endsWith(iterable, searchElements);
|
|
|
|
expect(result).toBe(false);
|
|
});
|
|
|
|
|
|
test("returns true if an iterable ends with the specified search elements up to a specific index", () => {
|
|
const iterable = [1, 2, 3, 4];
|
|
const searchElements = [2, 3];
|
|
|
|
const result = Iterable.endsWith(iterable, searchElements, 3);
|
|
|
|
expect(result).toBe(true);
|
|
});
|
|
|
|
test("returns true if an iterable ends with the specified search elements using custom comparer", () => {
|
|
const iterable = ["a", "b", "c", "d"];
|
|
const searchElements = ["C", "D"];
|
|
|
|
const result = Iterable.endsWith(iterable, searchElements, IGNORE_CASE_EQUALITY_COMPARER);
|
|
|
|
expect(result).toBe(true);
|
|
});
|
|
|
|
test("returns true if an iterable ends with the specified search elements using custom comparer up to a specific index", () => {
|
|
const iterable = ["a", "b", "c", "d"];
|
|
const searchElements = ["B", "C"];
|
|
|
|
const result = Iterable.endsWith(iterable, searchElements, 3, IGNORE_CASE_EQUALITY_COMPARER);
|
|
|
|
expect(result).toBe(true);
|
|
});
|
|
});
|
|
|
|
describe("findIndex", () => {
|
|
test("returns the index of the first element that satisfies the predicate", () => {
|
|
const iterable = [1, 2, 3, 4, 5];
|
|
|
|
const result = Iterable.findIndex(iterable, value => value > 3);
|
|
|
|
expect(result).toBe(3);
|
|
});
|
|
|
|
test("returns -1 if no elements satisfy the predicate", () => {
|
|
const iterable = [1, 2, 3, 4, 5];
|
|
|
|
const result = Iterable.findIndex(iterable, value => value > 5);
|
|
|
|
expect(result).toBe(-1);
|
|
});
|
|
|
|
test("binds thisArg to the callback function", () => {
|
|
const iterable = [1, 2, 3, 4, 5];
|
|
const thisArg = { target: 3 };
|
|
|
|
const result = Iterable.findIndex(iterable, function (x) { return x === this.target; }, thisArg);
|
|
|
|
expect(result).toBe(2);
|
|
});
|
|
});
|
|
|
|
describe("first", () => {
|
|
test("returns the first element that satisfies the predicate", () => {
|
|
const iterable = [{ id: 1, value: "a" }, { id: 2, value: "b" }, { id: 3, value: "a" }, { id: 4, value: "b" }];
|
|
|
|
const result = Iterable.first(iterable, x => x.value === "b");
|
|
|
|
expect(result).toEqual({ id: 2, value: "b" });
|
|
});
|
|
|
|
test("returns undefined if no elements satisfy the predicate", () => {
|
|
const iterable = [{ id: 1, value: "a" }, { id: 2, value: "b" }, { id: 3, value: "a" }, { id: 4, value: "b" }];
|
|
|
|
const result = Iterable.first(iterable, x => x.value === "c");
|
|
|
|
expect(result).toBeUndefined();
|
|
});
|
|
|
|
test("returns the first element if no predicate is provided", () => {
|
|
const iterable = [{ id: 1, value: "a" }, { id: 2, value: "b" }, { id: 3, value: "a" }, { id: 4, value: "b" }];
|
|
|
|
const result = Iterable.first(iterable);
|
|
|
|
expect(result).toEqual({ id: 1, value: "a" });
|
|
});
|
|
|
|
test("returns undefined if iterable is empty", () => {
|
|
expect(Iterable.first([])).toBeUndefined();
|
|
});
|
|
|
|
test("binds thisArg to the callback function", () => {
|
|
const iterable = [{ id: 1, value: "a" }, { id: 2, value: "b" }, { id: 3, value: "a" }, { id: 4, value: "b" }];
|
|
const thisArg = { target: "b" };
|
|
|
|
const result = Iterable.first(iterable, function (x) { return x.value === this.target; }, thisArg);
|
|
|
|
expect(result).toEqual({ id: 2, value: "b" });
|
|
});
|
|
});
|
|
|
|
describe("last", () => {
|
|
test("returns the last element that satisfies the predicate", () => {
|
|
const iterable = [{ id: 1, value: "a" }, { id: 2, value: "b" }, { id: 3, value: "a" }, { id: 4, value: "b" }];
|
|
|
|
const result = Iterable.last(iterable, x => x.value === "a");
|
|
|
|
expect(result).toEqual({ id: 3, value: "a" });
|
|
});
|
|
|
|
test("returns undefined if no elements satisfy the predicate", () => {
|
|
const iterable = [{ id: 1, value: "a" }, { id: 2, value: "b" }, { id: 3, value: "a" }, { id: 4, value: "b" }];
|
|
|
|
const result = Iterable.last(iterable, x => x.value === "c");
|
|
|
|
expect(result).toBeUndefined();
|
|
});
|
|
|
|
test("returns the last element if no predicate is provided", () => {
|
|
const iterable = [{ id: 1, value: "a" }, { id: 2, value: "b" }, { id: 3, value: "a" }, { id: 4, value: "b" }];
|
|
|
|
const result = Iterable.last(iterable);
|
|
|
|
expect(result).toEqual({ id: 4, value: "b" });
|
|
});
|
|
|
|
test("returns undefined if iterable is empty", () => {
|
|
expect(Iterable.last([])).toBeUndefined();
|
|
});
|
|
|
|
test("binds thisArg to the callback function", () => {
|
|
const iterable = [{ id: 1, value: "a" }, { id: 2, value: "b" }, { id: 3, value: "a" }, { id: 4, value: "b" }];
|
|
const thisArg = { target: "a" };
|
|
|
|
const result = Iterable.last(iterable, function (x) { return x.value === this.target; }, thisArg);
|
|
|
|
expect(result).toEqual({ id: 3, value: "a" });
|
|
});
|
|
});
|
|
|
|
describe("at", () => {
|
|
test("returns the element at the specified index", () => {
|
|
const iterable = [1, 2, 3, 4, 5];
|
|
|
|
const result = Iterable.at(iterable, 2);
|
|
|
|
expect(result).toBe(3);
|
|
});
|
|
|
|
test("returns undefined if the index is out of range", () => {
|
|
const iterable = [1, 2, 3, 4, 5];
|
|
|
|
const result = Iterable.at(iterable, 5);
|
|
|
|
expect(result).toBeUndefined();
|
|
});
|
|
|
|
test("returns undefined if the iterable is empty", () => {
|
|
const iterable = [];
|
|
|
|
const result = Iterable.at(iterable, 1);
|
|
|
|
expect(result).toBeUndefined();
|
|
});
|
|
|
|
test("handles relative indices", () => {
|
|
const iterable = [1, 2, 3, 4, 5];
|
|
|
|
expect(Iterable.at(iterable, -1)).toBe(5);
|
|
expect(Iterable.at(iterable, -2)).toBe(4);
|
|
expect(Iterable.at(iterable, -3)).toBe(3);
|
|
expect(Iterable.at(iterable, -4)).toBe(2);
|
|
expect(Iterable.at(iterable, -5)).toBe(1);
|
|
expect(Iterable.at(iterable, -6)).toBeUndefined();
|
|
});
|
|
});
|
|
|
|
describe("join", () => {
|
|
test("joins elements with the specified separator", () => {
|
|
const iterable = [1, 2, 3];
|
|
|
|
const result = Iterable.join(iterable, "-");
|
|
|
|
expect(result).toBe("1-2-3");
|
|
});
|
|
|
|
test("joins elements with a comma if no separator is provided", () => {
|
|
const iterable = [1, 2, 3];
|
|
|
|
const result = Iterable.join(iterable);
|
|
|
|
expect(result).toBe("1,2,3");
|
|
});
|
|
});
|
|
|
|
describe("concat", () => {
|
|
test("concatenates multiple iterables", () => {
|
|
const iterable1 = [1, 2, 3];
|
|
const iterable2 = [4, 5, 6];
|
|
const iterable3 = [7, 8, 9];
|
|
|
|
const result = Array.from(Iterable.concat(iterable1, iterable2, iterable3));
|
|
|
|
expect(result).toEqual([1, 2, 3, 4, 5, 6, 7, 8, 9]);
|
|
});
|
|
});
|
|
|
|
describe("prepend", () => {
|
|
test("prepends a value to an iterable", () => {
|
|
const iterable = [1, 2, 3];
|
|
|
|
const result = Array.from(Iterable.prepend(iterable, 0));
|
|
|
|
expect(result).toEqual([0, 1, 2, 3]);
|
|
});
|
|
});
|
|
|
|
describe("append", () => {
|
|
test("appends a value to an iterable", () => {
|
|
const iterable = [1, 2, 3];
|
|
|
|
const result = Array.from(Iterable.append(iterable, 4));
|
|
|
|
expect(result).toEqual([1, 2, 3, 4]);
|
|
});
|
|
});
|
|
|
|
describe("pop", () => {
|
|
test("removes the last element from an iterable", () => {
|
|
const iterable = [1, 2, 3];
|
|
|
|
const [value, rest] = Iterable.pop(iterable);
|
|
|
|
expect(value).toBe(3);
|
|
expect(Array.from(rest)).toEqual([1, 2]);
|
|
});
|
|
|
|
test("returns undefined and empty iterable when the input iterable is empty", () => {
|
|
const iterable = [];
|
|
|
|
const [value, rest] = Iterable.pop(iterable);
|
|
|
|
expect(value).toBeUndefined();
|
|
expect(Array.from(rest)).toEqual([]);
|
|
});
|
|
});
|
|
|
|
describe("shift", () => {
|
|
test("removes the first element from an iterable", () => {
|
|
const iterable = [1, 2, 3];
|
|
|
|
const [value, rest] = Iterable.shift(iterable);
|
|
|
|
expect(value).toBe(1);
|
|
expect(Array.from(rest)).toEqual([2, 3]);
|
|
});
|
|
|
|
test("returns undefined and empty iterable when the input iterable is empty", () => {
|
|
const iterable = [];
|
|
const [value, rest] = Iterable.shift(iterable);
|
|
|
|
expect(value).toBeUndefined();
|
|
expect(Array.from(rest)).toEqual([]);
|
|
});
|
|
});
|
|
|
|
describe("forEach", () => {
|
|
test("executes a function for each element in an iterable", () => {
|
|
const iterable = [1, 2, 3];
|
|
const mockFn = jest.fn();
|
|
|
|
Iterable.forEach(iterable, mockFn);
|
|
|
|
expect(mockFn).toHaveBeenCalledTimes(3);
|
|
expect(mockFn).toHaveBeenNthCalledWith(1, 1, 0, iterable);
|
|
expect(mockFn).toHaveBeenNthCalledWith(2, 2, 1, iterable);
|
|
expect(mockFn).toHaveBeenNthCalledWith(3, 3, 2, iterable);
|
|
});
|
|
});
|
|
|
|
describe("asArray", () => {
|
|
test("converts an iterable to an array", () => {
|
|
const iterable = new Set([1, 2, 3]);
|
|
|
|
const result = Iterable.asArray(iterable);
|
|
|
|
expect(result).toEqual([1, 2, 3]);
|
|
});
|
|
|
|
test("returns the same array if the iterable is already an array", () => {
|
|
const iterable = [1, 2, 3];
|
|
|
|
const result = Iterable.asArray(iterable);
|
|
|
|
expect(result).toBe(iterable);
|
|
});
|
|
});
|
|
|
|
describe("asArrayLike", () => {
|
|
test("converts an iterable to an array-like", () => {
|
|
const iterable = new Set([1, 2, 3]);
|
|
|
|
const result = Iterable.asArrayLike(iterable);
|
|
|
|
expect(result).toBeInstanceOf(Iterable.ArrayLikeIterable);
|
|
expect(Array.from(result)).toEqual([1, 2, 3]);
|
|
});
|
|
|
|
test("returns the same array if the iterable is already an array", () => {
|
|
const iterable = [1, 2, 3];
|
|
|
|
const result = Iterable.asArrayLike(iterable);
|
|
|
|
expect(result).toBe(iterable);
|
|
});
|
|
|
|
test("returns the same array-like if the iterable is already an array-like", () => {
|
|
const iterable = Iterable.ArrayLikeIterable.from([1, 2, 3]);
|
|
|
|
const result = Iterable.asArrayLike(iterable);
|
|
|
|
expect(result).toBe(iterable);
|
|
});
|
|
});
|
|
|
|
describe("$i", () => {
|
|
test("converts an iterable to an ArrayLikeIterable", () => {
|
|
const iterable = new Set([1, 2, 3]);
|
|
|
|
const result = Iterable.$i(iterable);
|
|
|
|
expect(result).toBeInstanceOf(Iterable.ArrayLikeIterable);
|
|
expect(Array.from(result)).toEqual([1, 2, 3]);
|
|
});
|
|
|
|
test("returns the same ArrayLikeIterable if the iterable is already an ArrayLikeIterable", () => {
|
|
const iterable = Iterable.ArrayLikeIterable.from([1, 2, 3]);
|
|
|
|
const result = Iterable.$i(iterable);
|
|
|
|
expect(result).toBe(iterable);
|
|
});
|
|
});
|
|
|
|
describe("ArrayLikeIterable", () => {
|
|
describe("from", () => {
|
|
test("creates a new instance from an iterable", () => {
|
|
const array = [1, 2, 3];
|
|
const iterable = Iterable.ArrayLikeIterable.from(array);
|
|
|
|
const values = Array.from(iterable.values());
|
|
|
|
expect(values).toEqual(array);
|
|
});
|
|
});
|
|
|
|
describe("of", () => {
|
|
test("creates a new instance from an iterator", () => {
|
|
const array = [1, 2, 3];
|
|
const arrayIterator = array[Symbol.iterator]();
|
|
const iterable = Iterable.ArrayLikeIterable.of(arrayIterator);
|
|
|
|
const values = Array.from(iterable.values());
|
|
|
|
expect(values).toEqual(array);
|
|
});
|
|
});
|
|
|
|
describe("length", () => {
|
|
test("returns the number of elements in the iterable", () => {
|
|
const array = [1, 2, 3];
|
|
const iterable = Iterable.ArrayLikeIterable.from(array);
|
|
|
|
expect(iterable.length).toBe(array.length);
|
|
});
|
|
});
|
|
|
|
describe("toArray", () => {
|
|
test("returns an array containing all elements of the iterable", () => {
|
|
const array = [1, 2, 3];
|
|
const iterable = Iterable.ArrayLikeIterable.from(array);
|
|
|
|
const newArray = iterable.toArray();
|
|
|
|
expect(newArray).toEqual(array);
|
|
});
|
|
|
|
test("new array is not the same as one used to create ArrayLikeIterable", () => {
|
|
const array = [1, 2, 3];
|
|
const iterable = Iterable.ArrayLikeIterable.from(array);
|
|
|
|
const newArray = iterable.toArray();
|
|
|
|
expect(newArray).not.toBe(array);
|
|
});
|
|
});
|
|
|
|
describe("toMap", () => {
|
|
test("converts the iterable of key-value pairs into a map", () => {
|
|
const entries = [["zero", 0], ["one", 1], ["two", 2]] as const;
|
|
const iterable = Iterable.ArrayLikeIterable.from(entries);
|
|
|
|
const map = iterable.toMap();
|
|
|
|
expect(Array.from(map.entries())).toEqual(entries);
|
|
});
|
|
|
|
test("converts the iterable of key-value pairs into a map with custom comparer", () => {
|
|
const entries = [["zero", 0], ["one", 1], ["two", 2], ["ONE", -1]] as const;
|
|
const iterable = Iterable.ArrayLikeIterable.from(entries);
|
|
|
|
const map = iterable.toMap(IGNORE_CASE_EQUALITY_COMPARER);
|
|
|
|
expect(Array.from(map.entries())).toEqual([["zero", 0], ["ONE", -1], ["two", 2]]);
|
|
});
|
|
});
|
|
|
|
describe("toSet", () => {
|
|
test("converts the iterable into a set", () => {
|
|
const array = ["zero", "one", "two"];
|
|
const iterable = Iterable.ArrayLikeIterable.from(array);
|
|
|
|
const set = iterable.toSet();
|
|
|
|
expect(Array.from(set)).toEqual(array);
|
|
});
|
|
|
|
test("converts the iterable into a set with custom comparer", () => {
|
|
const array = ["zero", "one", "two", "ONE"];
|
|
const iterable = Iterable.ArrayLikeIterable.from(array);
|
|
|
|
const set = iterable.toSet(IGNORE_CASE_EQUALITY_COMPARER);
|
|
|
|
expect(Array.from(set)).toEqual(["zero", "ONE", "two"]);
|
|
});
|
|
});
|
|
|
|
describe("toRecord", () => {
|
|
test("converts the iterable of key-value pairs into a record", () => {
|
|
const entries = [["zero", 0], ["one", 1], ["two", 2]] as const;
|
|
const iterable = Iterable.ArrayLikeIterable.from(entries);
|
|
|
|
const record = iterable.toRecord();
|
|
|
|
expect(record).toEqual({ "zero": 0, "one": 1, "two": 2 });
|
|
});
|
|
});
|
|
|
|
describe("keys", () => {
|
|
test("returns an iterable of indices in the iterable", () => {
|
|
const array = ["zero", "one", "two"];
|
|
const iterable = Iterable.ArrayLikeIterable.from(array);
|
|
|
|
const keys = Array.from(iterable.keys());
|
|
|
|
expect(keys).toEqual([0, 1, 2]);
|
|
});
|
|
});
|
|
|
|
describe("values", () => {
|
|
test("returns an iterable of values in the iterable", () => {
|
|
const array = [1, 2, 3];
|
|
const iterable = Iterable.ArrayLikeIterable.from(array);
|
|
|
|
const values = Array.from(iterable.values());
|
|
|
|
expect(values).toEqual(array);
|
|
});
|
|
});
|
|
|
|
describe("entries", () => {
|
|
test("returns an iterable of index-value pairs for every entry in the iterable", () => {
|
|
const iterable = Iterable.ArrayLikeIterable.from(["zero", "one", "two"]);
|
|
|
|
const entries = Array.from(iterable.entries());
|
|
|
|
expect(entries).toEqual([[0, "zero"], [1, "one"], [2, "two"]]);
|
|
});
|
|
});
|
|
|
|
describe("[Symbol.iterator]", () => {
|
|
test("returns an iterator over the values", () => {
|
|
const array = ["zero", "one", "two"];
|
|
const iterable = Iterable.ArrayLikeIterable.from(array);
|
|
|
|
const values = [...iterable];
|
|
|
|
expect(values).toEqual(array);
|
|
});
|
|
});
|
|
|
|
describe("[Symbol.toStringTag]", () => {
|
|
test("returns 'Iterable'", () => {
|
|
const iterable = Iterable.ArrayLikeIterable.from([]);
|
|
|
|
expect(iterable[Symbol.toStringTag]).toBe("Iterable");
|
|
});
|
|
});
|
|
|
|
describe("filter", () => {
|
|
test("returns ArrayLikeIterable", () => {
|
|
const iterable = Iterable.ArrayLikeIterable.from([]);
|
|
|
|
expect(iterable.filter(x => x)).toBeInstanceOf(Iterable.ArrayLikeIterable);
|
|
});
|
|
|
|
test("redirects the call to 'filter'", () => {
|
|
expect(Iterable.ArrayLikeIterable.prototype.filter.toString()).toMatch(/\Wfilter\W/);
|
|
expect(Iterable.ArrayLikeIterable.prototype.filter.toString()).not.toMatch(/\wfilter\w/);
|
|
});
|
|
});
|
|
|
|
describe("map", () => {
|
|
test("returns ArrayLikeIterable", () => {
|
|
const iterable = Iterable.ArrayLikeIterable.from([]);
|
|
|
|
expect(iterable.map(x => x)).toBeInstanceOf(Iterable.ArrayLikeIterable);
|
|
});
|
|
|
|
test("redirects the call to 'map'", () => {
|
|
expect(Iterable.ArrayLikeIterable.prototype.map.toString()).toMatch(/\Wmap\W/);
|
|
expect(Iterable.ArrayLikeIterable.prototype.map.toString()).not.toMatch(/\wmap\w/);
|
|
});
|
|
});
|
|
|
|
describe("flatMap", () => {
|
|
test("returns ArrayLikeIterable", () => {
|
|
const iterable = Iterable.ArrayLikeIterable.from([]);
|
|
|
|
expect(iterable.flatMap(x => x)).toBeInstanceOf(Iterable.ArrayLikeIterable);
|
|
});
|
|
|
|
test("redirects the call to 'flatMap'", () => {
|
|
expect(Iterable.ArrayLikeIterable.prototype.flatMap.toString()).toMatch(/\WflatMap\W/);
|
|
expect(Iterable.ArrayLikeIterable.prototype.flatMap.toString()).not.toMatch(/\wflatMap\w/);
|
|
});
|
|
});
|
|
|
|
describe("reduce", () => {
|
|
test("returns a value", () => {
|
|
const iterable = Iterable.ArrayLikeIterable.from([]);
|
|
|
|
expect(iterable.reduce(x => x)).toBeUndefined();
|
|
});
|
|
|
|
test("redirects the call to 'reduce'", () => {
|
|
expect(Iterable.ArrayLikeIterable.prototype.reduce.toString()).toMatch(/\Wreduce\W/);
|
|
expect(Iterable.ArrayLikeIterable.prototype.reduce.toString()).not.toMatch(/\wreduce\w/);
|
|
});
|
|
});
|
|
|
|
describe("skip", () => {
|
|
test("returns ArrayLikeIterable", () => {
|
|
const iterable = Iterable.ArrayLikeIterable.from([]);
|
|
|
|
expect(iterable.skip(0)).toBeInstanceOf(Iterable.ArrayLikeIterable);
|
|
});
|
|
|
|
test("redirects the call to 'skip'", () => {
|
|
expect(Iterable.ArrayLikeIterable.prototype.skip.toString()).toMatch(/\Wskip\W/);
|
|
expect(Iterable.ArrayLikeIterable.prototype.skip.toString()).not.toMatch(/\wskip\w/);
|
|
});
|
|
});
|
|
|
|
describe("take", () => {
|
|
test("returns ArrayLikeIterable", () => {
|
|
const iterable = Iterable.ArrayLikeIterable.from([]);
|
|
|
|
expect(iterable.take(0)).toBeInstanceOf(Iterable.ArrayLikeIterable);
|
|
});
|
|
|
|
test("redirects the call to 'take'", () => {
|
|
expect(Iterable.ArrayLikeIterable.prototype.take.toString()).toMatch(/\Wtake\W/);
|
|
expect(Iterable.ArrayLikeIterable.prototype.take.toString()).not.toMatch(/\wtake\w/);
|
|
});
|
|
});
|
|
|
|
describe("takeLast", () => {
|
|
test("returns ArrayLikeIterable", () => {
|
|
const iterable = Iterable.ArrayLikeIterable.from([]);
|
|
|
|
expect(iterable.takeLast(0)).toBeInstanceOf(Iterable.ArrayLikeIterable);
|
|
});
|
|
|
|
test("redirects the call to 'takeLast'", () => {
|
|
expect(Iterable.ArrayLikeIterable.prototype.takeLast.toString()).toMatch(/\WtakeLast\W/);
|
|
expect(Iterable.ArrayLikeIterable.prototype.takeLast.toString()).not.toMatch(/\wtakeLast\w/);
|
|
});
|
|
});
|
|
|
|
describe("slice", () => {
|
|
test("returns ArrayLikeIterable", () => {
|
|
const iterable = Iterable.ArrayLikeIterable.from([]);
|
|
|
|
expect(iterable.slice(0)).toBeInstanceOf(Iterable.ArrayLikeIterable);
|
|
});
|
|
|
|
test("redirects the call to 'slice'", () => {
|
|
expect(Iterable.ArrayLikeIterable.prototype.slice.toString()).toMatch(/\Wslice\W/);
|
|
expect(Iterable.ArrayLikeIterable.prototype.slice.toString()).not.toMatch(/\wslice\w/);
|
|
});
|
|
});
|
|
|
|
describe("reverse", () => {
|
|
test("returns ArrayLikeIterable", () => {
|
|
const iterable = Iterable.ArrayLikeIterable.from([]);
|
|
|
|
expect(iterable.reverse()).toBeInstanceOf(Iterable.ArrayLikeIterable);
|
|
});
|
|
|
|
test("redirects the call to 'reverse'", () => {
|
|
expect(Iterable.ArrayLikeIterable.prototype.reverse.toString()).toMatch(/\Wreverse\W/);
|
|
expect(Iterable.ArrayLikeIterable.prototype.reverse.toString()).not.toMatch(/\wreverse\w/);
|
|
});
|
|
});
|
|
|
|
describe("sort", () => {
|
|
test("returns ArrayLikeIterable", () => {
|
|
const iterable = Iterable.ArrayLikeIterable.from([]);
|
|
|
|
expect(iterable.sort()).toBeInstanceOf(Iterable.ArrayLikeIterable);
|
|
});
|
|
|
|
test("redirects the call to 'sort'", () => {
|
|
expect(Iterable.ArrayLikeIterable.prototype.sort.toString()).toMatch(/\Wsort\W/);
|
|
expect(Iterable.ArrayLikeIterable.prototype.sort.toString()).not.toMatch(/\wsort\w/);
|
|
});
|
|
});
|
|
|
|
describe("every", () => {
|
|
test("returns boolean", () => {
|
|
const iterable = Iterable.ArrayLikeIterable.from([]);
|
|
|
|
expect(typeof iterable.every(x => x)).toBe("boolean");
|
|
});
|
|
|
|
test("redirects the call to 'every'", () => {
|
|
expect(Iterable.ArrayLikeIterable.prototype.every.toString()).toMatch(/\Wevery\W/);
|
|
expect(Iterable.ArrayLikeIterable.prototype.every.toString()).not.toMatch(/\wevery\w/);
|
|
});
|
|
});
|
|
|
|
describe("some", () => {
|
|
test("returns boolean", () => {
|
|
const iterable = Iterable.ArrayLikeIterable.from([]);
|
|
|
|
expect(typeof iterable.some(x => x)).toBe("boolean");
|
|
});
|
|
|
|
test("redirects the call to 'some'", () => {
|
|
expect(Iterable.ArrayLikeIterable.prototype.some.toString()).toMatch(/\Wsome\W/);
|
|
expect(Iterable.ArrayLikeIterable.prototype.some.toString()).not.toMatch(/\wsome\w/);
|
|
});
|
|
});
|
|
|
|
describe("min", () => {
|
|
test("returns a value", () => {
|
|
const iterable = Iterable.ArrayLikeIterable.from([]);
|
|
|
|
expect(iterable.min()).toBeUndefined();
|
|
});
|
|
|
|
test("redirects the call to 'min'", () => {
|
|
expect(Iterable.ArrayLikeIterable.prototype.min.toString()).toMatch(/\Wmin\W/);
|
|
expect(Iterable.ArrayLikeIterable.prototype.min.toString()).not.toMatch(/\wmin\w/);
|
|
});
|
|
});
|
|
|
|
describe("max", () => {
|
|
test("returns a value", () => {
|
|
const iterable = Iterable.ArrayLikeIterable.from([]);
|
|
|
|
expect(iterable.max()).toBeUndefined();
|
|
});
|
|
|
|
test("redirects the call to 'max'", () => {
|
|
expect(Iterable.ArrayLikeIterable.prototype.max.toString()).toMatch(/\Wmax\W/);
|
|
expect(Iterable.ArrayLikeIterable.prototype.max.toString()).not.toMatch(/\wmax\w/);
|
|
});
|
|
});
|
|
|
|
describe("count", () => {
|
|
test("returns number", () => {
|
|
const iterable = Iterable.ArrayLikeIterable.from([]);
|
|
|
|
expect(typeof iterable.count()).toBe("number");
|
|
});
|
|
|
|
test("redirects the call to 'count'", () => {
|
|
expect(Iterable.ArrayLikeIterable.prototype.count.toString()).toMatch(/\Wcount\W/);
|
|
expect(Iterable.ArrayLikeIterable.prototype.count.toString()).not.toMatch(/\wcount\w/);
|
|
});
|
|
});
|
|
|
|
describe("indexOf", () => {
|
|
test("returns number", () => {
|
|
const iterable = Iterable.ArrayLikeIterable.from([]);
|
|
|
|
expect(typeof iterable.indexOf({})).toBe("number");
|
|
});
|
|
|
|
test("redirects the call to 'indexOf'", () => {
|
|
expect(Iterable.ArrayLikeIterable.prototype.indexOf.toString()).toMatch(/\WindexOf\W/);
|
|
expect(Iterable.ArrayLikeIterable.prototype.indexOf.toString()).not.toMatch(/\windexOf\w/);
|
|
});
|
|
});
|
|
|
|
describe("lastIndexOf", () => {
|
|
test("returns number", () => {
|
|
const iterable = Iterable.ArrayLikeIterable.from([]);
|
|
|
|
expect(typeof iterable.lastIndexOf({})).toBe("number");
|
|
});
|
|
|
|
test("redirects the call to 'lastIndexOf'", () => {
|
|
expect(Iterable.ArrayLikeIterable.prototype.lastIndexOf.toString()).toMatch(/\WlastIndexOf\W/);
|
|
expect(Iterable.ArrayLikeIterable.prototype.lastIndexOf.toString()).not.toMatch(/\wlastIndexOf\w/);
|
|
});
|
|
});
|
|
|
|
describe("includes", () => {
|
|
test("returns boolean", () => {
|
|
const iterable = Iterable.ArrayLikeIterable.from([]);
|
|
|
|
expect(typeof iterable.includes({})).toBe("boolean");
|
|
});
|
|
|
|
test("redirects the call to 'includes'", () => {
|
|
expect(Iterable.ArrayLikeIterable.prototype.includes.toString()).toMatch(/\Wincludes\W/);
|
|
expect(Iterable.ArrayLikeIterable.prototype.includes.toString()).not.toMatch(/\wincludes\w/);
|
|
});
|
|
});
|
|
|
|
describe("sequenceEqual", () => {
|
|
test("returns boolean", () => {
|
|
const iterable = Iterable.ArrayLikeIterable.from([]);
|
|
|
|
expect(typeof iterable.sequenceEqual([])).toBe("boolean");
|
|
});
|
|
|
|
test("redirects the call to 'sequenceEqual'", () => {
|
|
expect(Iterable.ArrayLikeIterable.prototype.sequenceEqual.toString()).toMatch(/\WsequenceEqual\W/);
|
|
expect(Iterable.ArrayLikeIterable.prototype.sequenceEqual.toString()).not.toMatch(/\wsequenceEqual\w/);
|
|
});
|
|
});
|
|
|
|
describe("startsWith", () => {
|
|
test("returns boolean", () => {
|
|
const iterable = Iterable.ArrayLikeIterable.from([]);
|
|
|
|
expect(typeof iterable.startsWith([])).toBe("boolean");
|
|
});
|
|
|
|
test("redirects the call to 'startsWith'", () => {
|
|
expect(Iterable.ArrayLikeIterable.prototype.startsWith.toString()).toMatch(/\WstartsWith\W/);
|
|
expect(Iterable.ArrayLikeIterable.prototype.startsWith.toString()).not.toMatch(/\wstartsWith\w/);
|
|
});
|
|
});
|
|
|
|
describe("endsWith", () => {
|
|
test("returns boolean", () => {
|
|
const iterable = Iterable.ArrayLikeIterable.from([]);
|
|
|
|
expect(typeof iterable.endsWith([])).toBe("boolean");
|
|
});
|
|
|
|
test("redirects the call to 'endsWith'", () => {
|
|
expect(Iterable.ArrayLikeIterable.prototype.endsWith.toString()).toMatch(/\WendsWith\W/);
|
|
expect(Iterable.ArrayLikeIterable.prototype.endsWith.toString()).not.toMatch(/\wendsWith\w/);
|
|
});
|
|
});
|
|
|
|
describe("findIndex", () => {
|
|
test("returns number", () => {
|
|
const iterable = Iterable.ArrayLikeIterable.from([]);
|
|
|
|
expect(typeof iterable.findIndex(x => x)).toBe("number");
|
|
});
|
|
|
|
test("redirects the call to 'findIndex'", () => {
|
|
expect(Iterable.ArrayLikeIterable.prototype.findIndex.toString()).toMatch(/\WfindIndex\W/);
|
|
expect(Iterable.ArrayLikeIterable.prototype.findIndex.toString()).not.toMatch(/\wfindIndex\w/);
|
|
});
|
|
});
|
|
|
|
describe("find", () => {
|
|
test("returns a value", () => {
|
|
const iterable = Iterable.ArrayLikeIterable.from([]);
|
|
|
|
expect(iterable.find(x => x)).toBeUndefined();
|
|
});
|
|
|
|
test("redirects the call to 'first'", () => {
|
|
expect(Iterable.ArrayLikeIterable.prototype.find.toString()).toMatch(/\Wfirst\W/);
|
|
expect(Iterable.ArrayLikeIterable.prototype.find.toString()).not.toMatch(/\wfirst\w/);
|
|
});
|
|
});
|
|
|
|
describe("first", () => {
|
|
test("returns a value", () => {
|
|
const iterable = Iterable.ArrayLikeIterable.from([]);
|
|
|
|
expect(iterable.first(x => x)).toBeUndefined();
|
|
});
|
|
|
|
test("redirects the call to 'first'", () => {
|
|
expect(Iterable.ArrayLikeIterable.prototype.first.toString()).toMatch(/\Wfirst\W/);
|
|
expect(Iterable.ArrayLikeIterable.prototype.first.toString()).not.toMatch(/\wfirst\w/);
|
|
});
|
|
});
|
|
|
|
describe("last", () => {
|
|
test("returns a value", () => {
|
|
const iterable = Iterable.ArrayLikeIterable.from([]);
|
|
|
|
expect(iterable.last(x => x)).toBeUndefined();
|
|
});
|
|
|
|
test("redirects the call to 'last'", () => {
|
|
expect(Iterable.ArrayLikeIterable.prototype.last.toString()).toMatch(/\Wlast\W/);
|
|
expect(Iterable.ArrayLikeIterable.prototype.last.toString()).not.toMatch(/\wlast\w/);
|
|
});
|
|
});
|
|
|
|
describe("at", () => {
|
|
test("returns a value", () => {
|
|
const iterable = Iterable.ArrayLikeIterable.from([]);
|
|
|
|
expect(iterable.at(0)).toBeUndefined();
|
|
});
|
|
|
|
test("redirects the call to 'at'", () => {
|
|
expect(Iterable.ArrayLikeIterable.prototype.at.toString()).toMatch(/\Wat\W/);
|
|
expect(Iterable.ArrayLikeIterable.prototype.at.toString()).not.toMatch(/\wat\w/);
|
|
});
|
|
});
|
|
|
|
describe("join", () => {
|
|
test("returns string", () => {
|
|
const iterable = Iterable.ArrayLikeIterable.from([]);
|
|
|
|
expect(typeof iterable.join()).toBe("string");
|
|
});
|
|
|
|
test("redirects the call to 'join'", () => {
|
|
expect(Iterable.ArrayLikeIterable.prototype.join.toString()).toMatch(/\Wjoin\W/);
|
|
expect(Iterable.ArrayLikeIterable.prototype.join.toString()).not.toMatch(/\wjoin\w/);
|
|
});
|
|
});
|
|
|
|
describe("concat", () => {
|
|
test("returns ArrayLikeIterable", () => {
|
|
const iterable = Iterable.ArrayLikeIterable.from([]);
|
|
|
|
expect(iterable.concat([])).toBeInstanceOf(Iterable.ArrayLikeIterable);
|
|
});
|
|
|
|
test("redirects the call to 'concat'", () => {
|
|
expect(Iterable.ArrayLikeIterable.prototype.concat.toString()).toMatch(/\Wconcat\W/);
|
|
expect(Iterable.ArrayLikeIterable.prototype.concat.toString()).not.toMatch(/\wconcat\w/);
|
|
});
|
|
});
|
|
|
|
describe("prepend", () => {
|
|
test("returns ArrayLikeIterable", () => {
|
|
const iterable = Iterable.ArrayLikeIterable.from([]);
|
|
|
|
expect(iterable.prepend([])).toBeInstanceOf(Iterable.ArrayLikeIterable);
|
|
});
|
|
|
|
test("redirects the call to 'prepend'", () => {
|
|
expect(Iterable.ArrayLikeIterable.prototype.prepend.toString()).toMatch(/\Wprepend\W/);
|
|
expect(Iterable.ArrayLikeIterable.prototype.prepend.toString()).not.toMatch(/\wprepend\w/);
|
|
});
|
|
});
|
|
|
|
describe("append", () => {
|
|
test("returns ArrayLikeIterable", () => {
|
|
const iterable = Iterable.ArrayLikeIterable.from([]);
|
|
|
|
expect(iterable.append([])).toBeInstanceOf(Iterable.ArrayLikeIterable);
|
|
});
|
|
|
|
test("redirects the call to 'append'", () => {
|
|
expect(Iterable.ArrayLikeIterable.prototype.append.toString()).toMatch(/\Wappend\W/);
|
|
expect(Iterable.ArrayLikeIterable.prototype.append.toString()).not.toMatch(/\wappend\w/);
|
|
});
|
|
});
|
|
|
|
describe("shift", () => {
|
|
test("returns [value, ArrayLikeIterable]", () => {
|
|
const iterable = Iterable.ArrayLikeIterable.from([]);
|
|
|
|
const [value, newIterable] = iterable.shift();
|
|
|
|
expect(value).toBeUndefined();
|
|
expect(newIterable).toBeInstanceOf(Iterable.ArrayLikeIterable);
|
|
});
|
|
|
|
test("redirects the call to 'shift'", () => {
|
|
expect(Iterable.ArrayLikeIterable.prototype.shift.toString()).toMatch(/\Wshift\W/);
|
|
expect(Iterable.ArrayLikeIterable.prototype.shift.toString()).not.toMatch(/\wshift\w/);
|
|
});
|
|
});
|
|
|
|
describe("unshift", () => {
|
|
test("returns ArrayLikeIterable", () => {
|
|
const iterable = Iterable.ArrayLikeIterable.from([]);
|
|
|
|
expect(iterable.unshift({})).toBeInstanceOf(Iterable.ArrayLikeIterable);
|
|
});
|
|
|
|
test("redirects the call to 'prepend'", () => {
|
|
expect(Iterable.ArrayLikeIterable.prototype.unshift.toString()).toMatch(/\Wprepend\W/);
|
|
expect(Iterable.ArrayLikeIterable.prototype.unshift.toString()).not.toMatch(/\wprepend\w/);
|
|
});
|
|
});
|
|
|
|
describe("push", () => {
|
|
test("returns ArrayLikeIterable", () => {
|
|
const iterable = Iterable.ArrayLikeIterable.from([]);
|
|
|
|
expect(iterable.push({})).toBeInstanceOf(Iterable.ArrayLikeIterable);
|
|
});
|
|
|
|
test("redirects the call to 'append'", () => {
|
|
expect(Iterable.ArrayLikeIterable.prototype.push.toString()).toMatch(/\Wappend\W/);
|
|
expect(Iterable.ArrayLikeIterable.prototype.push.toString()).not.toMatch(/\wappend\w/);
|
|
});
|
|
});
|
|
|
|
describe("pop", () => {
|
|
test("returns ArrayLikeIterable", () => {
|
|
const iterable = Iterable.ArrayLikeIterable.from([]);
|
|
|
|
const [value, newIterable] = iterable.pop();
|
|
|
|
expect(value).toBeUndefined();
|
|
expect(newIterable).toBeInstanceOf(Iterable.ArrayLikeIterable);
|
|
});
|
|
|
|
test("redirects the call to 'pop'", () => {
|
|
expect(Iterable.ArrayLikeIterable.prototype.pop.toString()).toMatch(/\Wpop\W/);
|
|
expect(Iterable.ArrayLikeIterable.prototype.pop.toString()).not.toMatch(/\wpop\w/);
|
|
});
|
|
});
|
|
|
|
describe("forEach", () => {
|
|
test("returns nothing", () => {
|
|
const iterable = Iterable.ArrayLikeIterable.from([]);
|
|
|
|
expect(iterable.forEach(x => x)).toBeUndefined();
|
|
});
|
|
|
|
test("redirects the call to 'forEach'", () => {
|
|
expect(Iterable.ArrayLikeIterable.prototype.forEach.toString()).toMatch(/\WforEach\W/);
|
|
expect(Iterable.ArrayLikeIterable.prototype.forEach.toString()).not.toMatch(/\wforEach\w/);
|
|
});
|
|
});
|
|
|
|
describe("asArray", () => {
|
|
test("returns Array", () => {
|
|
const array = [];
|
|
const iterable = Iterable.ArrayLikeIterable.from(array);
|
|
|
|
expect(iterable.asArray()).toBe(array);
|
|
});
|
|
|
|
test("redirects the call to 'asArray'", () => {
|
|
expect(Iterable.ArrayLikeIterable.prototype.asArray.toString()).toMatch(/\WasArray\W/);
|
|
expect(Iterable.ArrayLikeIterable.prototype.asArray.toString()).not.toMatch(/\wasArray\w/);
|
|
});
|
|
});
|
|
|
|
describe("distinct", () => {
|
|
test("returns ArrayLikeIterable", () => {
|
|
const iterable = Iterable.ArrayLikeIterable.from([]);
|
|
|
|
expect(iterable.distinct()).toBeInstanceOf(Iterable.ArrayLikeIterable);
|
|
});
|
|
|
|
test("redirects the call to 'distinct'", () => {
|
|
expect(Iterable.ArrayLikeIterable.prototype.distinct.toString()).toMatch(/\Wdistinct\W/);
|
|
expect(Iterable.ArrayLikeIterable.prototype.distinct.toString()).not.toMatch(/\wdistinct\w/);
|
|
});
|
|
});
|
|
|
|
describe("distinctBy", () => {
|
|
test("returns ArrayLikeIterable", () => {
|
|
const iterable = Iterable.ArrayLikeIterable.from([]);
|
|
|
|
expect(iterable.distinctBy(x => x)).toBeInstanceOf(Iterable.ArrayLikeIterable);
|
|
});
|
|
|
|
test("redirects the call to 'distinctBy'", () => {
|
|
expect(Iterable.ArrayLikeIterable.prototype.distinctBy.toString()).toMatch(/\WdistinctBy\W/);
|
|
expect(Iterable.ArrayLikeIterable.prototype.distinctBy.toString()).not.toMatch(/\wdistinctBy\w/);
|
|
});
|
|
});
|
|
});
|