mirror of
https://github.com/gosticks/DefinitelyTyped.git
synced 2025-10-16 12:05:41 +00:00
425 lines
13 KiB
TypeScript
425 lines
13 KiB
TypeScript
// adapted from `cat wu.js/test/* |sed '/= require/d'> wu-tests.ts`
|
|
|
|
declare const describe: any;
|
|
declare const it: any;
|
|
declare const mocha: any;
|
|
declare const assert: {
|
|
iterable: any;
|
|
eqSet<T>(expected: Set<T>, actual: Iterable<T>): any;
|
|
ok: any;
|
|
equal<T>(x: T, y: T): any;
|
|
eqArray<T>(x: T[], y: Iterable<T>): any;
|
|
deepEqual<T>(x: T, y: T): any;
|
|
};
|
|
|
|
// Helper for asserting that the given thing is iterable.
|
|
assert.iterable = (thing: any) => {
|
|
assert.ok(wu(thing));
|
|
};
|
|
|
|
// Helper for asserting that all the elements yielded from the |actual|
|
|
// iterator are in the |expected| set.
|
|
assert.eqSet = (expected: any, actual: any) => {
|
|
assert.iterable(actual);
|
|
for (const x of actual) {
|
|
assert.ok(expected.has(x));
|
|
expected.delete(x);
|
|
}
|
|
};
|
|
|
|
// Helper for asserting that all the elements yielded from the |actual|
|
|
// iterator are equal to and in the same order as the elements of the
|
|
// |expected| array.
|
|
assert.eqArray = (expected: any, actual: any) => {
|
|
assert.iterable(actual);
|
|
assert.deepEqual(expected, [...actual]);
|
|
};
|
|
|
|
mocha.setup('bdd');
|
|
describe("wu.asyncEach", () => {
|
|
it("should iterate over each item", () => {
|
|
const arr = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
|
|
let n = 0;
|
|
|
|
return wu(arr)
|
|
.asyncEach(x => {
|
|
n++;
|
|
const start = Date.now();
|
|
while (Date.now() - start <= 3) {
|
|
// Kill time.
|
|
}
|
|
}, 3)
|
|
.then(() => {
|
|
assert.equal(n, arr.length);
|
|
});
|
|
});
|
|
});
|
|
describe("wu.chain", () => {
|
|
it("should concatenate iterables", () => {
|
|
assert.eqArray([1, 2, 3, 4, 5, 6],
|
|
wu.chain([1, 2], [3, 4], [5, 6]));
|
|
});
|
|
});
|
|
describe("wu.chunk", () => {
|
|
it("should chunk items into tuples", () => {
|
|
assert.eqArray([[1, 2, 3], [4, 5, 6]],
|
|
wu.chunk(3, [1, 2, 3, 4, 5, 6]));
|
|
});
|
|
});
|
|
describe("wu.concatMap", () => {
|
|
it("should map the function over the iterable and concatenate results", () => {
|
|
assert.eqArray([1, 1, 2, 4, 3, 9],
|
|
wu.concatMap(x => [x, x * x], [1, 2, 3]));
|
|
});
|
|
});
|
|
describe("wu.count", () => {
|
|
it("should keep incrementing", () => {
|
|
const count = wu.count();
|
|
assert.equal(count.next().value, 0);
|
|
assert.equal(count.next().value, 1);
|
|
assert.equal(count.next().value, 2);
|
|
assert.equal(count.next().value, 3);
|
|
assert.equal(count.next().value, 4);
|
|
assert.equal(count.next().value, 5);
|
|
});
|
|
|
|
it("should start at the provided number", () => {
|
|
const count = wu.count(5);
|
|
assert.equal(count.next().value, 5);
|
|
assert.equal(count.next().value, 6);
|
|
assert.equal(count.next().value, 7);
|
|
});
|
|
|
|
it("should increment by the provided step", () => {
|
|
const count = wu.count(0, 2);
|
|
assert.equal(count.next().value, 0);
|
|
assert.equal(count.next().value, 2);
|
|
assert.equal(count.next().value, 4);
|
|
});
|
|
});
|
|
describe("wu.curryable", () => {
|
|
it("should wait until its given enough arguments", () => {
|
|
const f = wu.curryable((a, b) => a + b);
|
|
|
|
const f0 = f()()()()();
|
|
assert.equal(typeof f0, "function");
|
|
|
|
const f1 = f(1);
|
|
assert.equal(typeof f1, "function");
|
|
assert.equal(f1(2), 3);
|
|
});
|
|
|
|
it("should just call the function when given enough arguments", () => {
|
|
const f = wu.curryable((a, b) => a + b);
|
|
assert.equal(f(1, 2), 3);
|
|
});
|
|
|
|
it("should expect the number of arguments we tell it to", () => {
|
|
const f = wu.curryable((...args) => 5, 5);
|
|
assert.equal(typeof f(1, 2, 3, 4), "function");
|
|
assert.equal(f(1, 2, 3, 4, 5), 5);
|
|
});
|
|
});
|
|
describe("wu.cycle", () => {
|
|
it("should keep yielding items from the original iterable", () => {
|
|
let i = 0;
|
|
const arr = [1, 2, 3];
|
|
for (const x of wu.cycle(arr)) {
|
|
assert.equal(x, arr[i % 3]);
|
|
if (i++ > 9) {
|
|
break;
|
|
}
|
|
}
|
|
});
|
|
});
|
|
describe("wu.drop", () => {
|
|
it("should drop the number of items specified", () => {
|
|
const count = wu.count().drop(5);
|
|
assert.equal(count.next().value, 5);
|
|
});
|
|
});
|
|
describe("wu.dropWhile", () => {
|
|
it("should drop items while the predicate is true", () => {
|
|
const count = wu.dropWhile(x => x < 5, wu.count());
|
|
assert.equal(count.next().value, 5);
|
|
});
|
|
});
|
|
describe("wu.entries", () => {
|
|
it("should iterate over entries", () => {
|
|
const expected = new Map([["foo", 1], ["bar", 2], ["baz", 3]]);
|
|
for (const [k, v] of wu.entries({ foo: 1, bar: 2, baz: 3 })) {
|
|
assert.equal(expected.get(k), v);
|
|
}
|
|
});
|
|
});
|
|
describe("wu.enumerate", () => {
|
|
it("should yield items with their index", () => {
|
|
assert.eqArray([["a", 0], ["b", 1], ["c", 2]],
|
|
wu.enumerate("abc"));
|
|
});
|
|
});
|
|
describe("wu.every", () => {
|
|
it("should return true when the predicate succeeds for all items", () => {
|
|
assert.equal(true, wu.every(x => typeof x === "number", [1, 2, 3]));
|
|
});
|
|
|
|
it("should return false when the predicate fails for any item", () => {
|
|
assert.equal(false, wu.every(x => typeof x === "number", [1, 2, "3"]));
|
|
});
|
|
});
|
|
describe("wu.filter", () => {
|
|
it("should filter based on the predicate", () => {
|
|
assert.eqArray(["a", "b", "c"],
|
|
wu.filter(x => typeof x === "string",
|
|
[1, "a", true, "b", {}, "c"]));
|
|
});
|
|
});
|
|
describe("wu.find", () => {
|
|
it("should return the first item that matches the predicate", () => {
|
|
assert.deepEqual({ name: "rza" },
|
|
wu.find(x => !!x.name.match(/.za$/),
|
|
[{ name: "odb" },
|
|
{ name: "method man" },
|
|
{ name: "rza" },
|
|
{ name: "gza" }]));
|
|
});
|
|
|
|
it("should return undefined if no items match the predicate", () => {
|
|
assert.equal(undefined,
|
|
wu.find(x => (<any> x) === "raekwon",
|
|
[{ name: "odb" },
|
|
{ name: "method man" },
|
|
{ name: "rza" },
|
|
{ name: "gza" }]));
|
|
});
|
|
});
|
|
describe("wu.flatten", () => {
|
|
it("should flatten iterables", () => {
|
|
assert.eqArray(["I", "like", "LISP"],
|
|
wu(["I", ["like", ["LISP"]]]).flatten());
|
|
});
|
|
|
|
it("should shallowly flatten iterables", () => {
|
|
assert.eqArray([1, 2, 3, [[4]]],
|
|
wu.flatten(true, [1, [2], [3, [[4]]]]));
|
|
});
|
|
});
|
|
describe("wu.forEach", () => {
|
|
it("should iterate over every item", () => {
|
|
const items: any[] = [];
|
|
wu.forEach(x => items.push(x), [1, 2, 3]);
|
|
assert.eqArray([1, 2, 3], items);
|
|
});
|
|
});
|
|
describe("wu.has", () => {
|
|
it("should return true if the item is in the iterable", () => {
|
|
assert.ok(wu.has(3, [1, 2, 3]));
|
|
});
|
|
|
|
it("should return false if the item is not in the iterable", () => {
|
|
assert.ok(!wu.has(<any> "36 chambers", [1, 2, 3]));
|
|
});
|
|
});
|
|
describe("wu.invoke", () => {
|
|
it("should yield the method invokation on each item", () => {
|
|
class Greeter {
|
|
constructor(readonly name: string) {}
|
|
greet(tail: string) { return `hello ${this.name}${tail}`; }
|
|
}
|
|
assert.eqArray(["hello world!", "hello test!"],
|
|
wu.invoke("greet", "!",
|
|
[new Greeter("world"), new Greeter("test")]));
|
|
});
|
|
});
|
|
describe("wu.keys", () => {
|
|
it("should iterate over keys", () => {
|
|
assert.eqSet(new Set(["foo", "bar", "baz"]),
|
|
wu.keys({ foo: 1, bar: 2, baz: 3 }));
|
|
});
|
|
});
|
|
describe("wu.map", () => {
|
|
it("should map the function over the iterable", () => {
|
|
assert.eqArray([1, 4, 9],
|
|
wu.map(x => x * x, [1, 2, 3]));
|
|
});
|
|
});
|
|
describe("wu.pluck", () => {
|
|
it("should access the named property of each item in the iterable", () => {
|
|
assert.eqArray([1, 2, 3],
|
|
wu.pluck("i", [{ i: 1 }, { i: 2 }, { i: 3 }]));
|
|
});
|
|
});
|
|
describe("wu.reduce", () => {
|
|
it("should reduce the iterable with the function", () => {
|
|
assert.equal(6, wu([1, 2, 3]).reduce((x, y) => x + y));
|
|
});
|
|
|
|
it("should accept an initial state for the reducer function", () => {
|
|
assert.equal(16, wu.reduce((x, y) => x + y, 10, [1, 2, 3]));
|
|
});
|
|
});
|
|
describe("wu.reductions", () => {
|
|
it("should yield the intermediate reductions of the iterable", () => {
|
|
assert.eqArray([1, 3, 6],
|
|
wu.reductions((x, y) => x + y, undefined, [1, 2, 3]));
|
|
});
|
|
});
|
|
describe("wu.reject", () => {
|
|
it("should yield items for which the predicate is false", () => {
|
|
assert.eqArray([1, true, {}],
|
|
wu.reject(x => typeof x === "string",
|
|
[1, "a", true, "b", {}, "c"]));
|
|
});
|
|
});
|
|
describe("wu.repeat", () => {
|
|
it("should keep yielding its item", () => {
|
|
const repeat = wu.repeat(3);
|
|
assert.equal(repeat.next().value, 3);
|
|
assert.equal(repeat.next().value, 3);
|
|
assert.equal(repeat.next().value, 3);
|
|
assert.equal(repeat.next().value, 3);
|
|
assert.equal(repeat.next().value, 3);
|
|
assert.equal(repeat.next().value, 3);
|
|
assert.equal(repeat.next().value, 3);
|
|
});
|
|
|
|
it("should repeat n times", () => {
|
|
const repeat = wu.repeat(3, 2);
|
|
assert.equal(repeat.next().value, 3);
|
|
assert.equal(repeat.next().value, 3);
|
|
assert.equal(repeat.next().value, undefined);
|
|
assert.equal(repeat.next().done, true);
|
|
});
|
|
});
|
|
describe("wu.slice", () => {
|
|
it("should slice the front of iterables", () => {
|
|
assert.eqArray([3, 4, 5],
|
|
wu.slice(3, undefined, [0, 1, 2, 3, 4, 5]));
|
|
});
|
|
|
|
it("should slice the end of iterables", () => {
|
|
assert.eqArray([0, 1, 2],
|
|
wu.slice(undefined,
|
|
3,
|
|
[0, 1, 2, 3, 4, 5]));
|
|
});
|
|
});
|
|
describe("wu.some", () => {
|
|
it("should return true if any item matches the predicate", () => {
|
|
assert.ok(wu.some(x => x % 2 === 0, [1, 2, 3]));
|
|
});
|
|
|
|
it("should return false if no items match the predicate", () => {
|
|
assert.ok(!wu.some(x => x % 5 === 0, [1, 2, 3]));
|
|
});
|
|
});
|
|
describe("wu.spreadMap", () => {
|
|
it("should map the function over the iterable with spread arguments", () => {
|
|
assert.eqArray([32, 9, 1000],
|
|
wu.spreadMap(Math.pow, [[2, 5], [3, 2], [10, 3]]));
|
|
});
|
|
});
|
|
describe("wu.take", () => {
|
|
it("should yield as many items as requested", () => {
|
|
assert.eqArray([0, 1, 2, 3, 4],
|
|
wu.take(5, wu.count()));
|
|
});
|
|
});
|
|
describe("wu.takeWhile", () => {
|
|
it("should keep yielding items from the iterable until the predicate is false", () => {
|
|
assert.eqArray([0, 1, 2, 3, 4],
|
|
wu.takeWhile(x => x < 5, wu.count()));
|
|
});
|
|
});
|
|
describe("wu.tap", () => {
|
|
it("should perform side effects and yield the original item", () => {
|
|
let i = 0;
|
|
assert.eqArray([1, 2, 3],
|
|
wu.tap(x => i++, [1, 2, 3]));
|
|
assert.equal(i, 3);
|
|
});
|
|
});
|
|
describe("wu.tee", () => {
|
|
it("should clone iterables", () => {
|
|
const factorials = wu(wu.count(1)).reductions((a, b) => a * b);
|
|
const [i1, i2] = wu(factorials).tee();
|
|
|
|
assert.equal(i1.next().value, 1);
|
|
assert.equal(i1.next().value, 2);
|
|
assert.equal(i1.next().value, 6);
|
|
assert.equal(i1.next().value, 24);
|
|
|
|
assert.equal(i2.next().value, 1);
|
|
assert.equal(i2.next().value, 2);
|
|
assert.equal(i2.next().value, 6);
|
|
assert.equal(i2.next().value, 24);
|
|
});
|
|
});
|
|
describe("wu.toArray", () => {
|
|
it("should return array from the iterable", () => {
|
|
assert.eqArray(
|
|
wu.count(0).take(3).toArray(),
|
|
[0, 1, 2],
|
|
);
|
|
assert.eqArray(
|
|
wu([0, 1, 2]).toArray(),
|
|
[0, 1, 2]
|
|
);
|
|
});
|
|
});
|
|
describe("wu.unique", () => {
|
|
it("should yield only the unique items from the iterable", () => {
|
|
assert.eqArray([1, 2, 3],
|
|
wu.unique([1, 1, 2, 2, 1, 1, 3, 3]));
|
|
});
|
|
});
|
|
describe("wu.unzip", () => {
|
|
it("should create iterables from zipped items", () => {
|
|
const pairs = [
|
|
["one", 1],
|
|
["two", 2],
|
|
["three", 3]
|
|
];
|
|
const [i1, i2] = wu(pairs).unzip();
|
|
assert.eqArray(["one", "two", "three"], [...i1]);
|
|
assert.eqArray([1, 2, 3], [...i2]);
|
|
});
|
|
});
|
|
describe("wu.values", () => {
|
|
it("should iterate over values", () => {
|
|
assert.eqSet(new Set([1, 2, 3]),
|
|
wu.values({ foo: 1, bar: 2, baz: 3 }));
|
|
});
|
|
});
|
|
describe("wu.zip", () => {
|
|
it("should zip two iterables together", () => {
|
|
assert.eqArray([["a", 1], ["b", 2], ["c", 3]],
|
|
wu.zip("abc", [1, 2, 3]));
|
|
});
|
|
|
|
it("should stop with the shorter iterable", () => {
|
|
assert.eqArray([["a", 1], ["b", 2], ["c", 3]],
|
|
wu.zip("abc", wu.count(1)));
|
|
});
|
|
});
|
|
describe("wu.zipLongest", () => {
|
|
it("should stop with the longer iterable", () => {
|
|
const arr1: any[] = [];
|
|
arr1[1] = 2;
|
|
const arr2: any[] = [];
|
|
arr2[1] = 3;
|
|
assert.eqArray([["a", 1], arr1, arr2],
|
|
wu.zipLongest("a", [1, 2, 3]));
|
|
});
|
|
});
|
|
describe("wu.zipWith", () => {
|
|
it("should spread map over the zipped iterables", () => {
|
|
const add3 = (a: any, b: any, c: any) => a + b + c;
|
|
assert.eqArray([12, 15, 18],
|
|
wu.zipWith(add3,
|
|
[1, 2, 3],
|
|
[4, 5, 6],
|
|
[7, 8, 9]));
|
|
});
|
|
});
|