Updated testing tools
This commit is contained in:
parent
d64e330da1
commit
59ca64e7b2
|
@ -1,6 +1,6 @@
|
||||||
root = true
|
root = true
|
||||||
|
|
||||||
[*.ts]
|
[*.{ts,json}]
|
||||||
charset = utf-8
|
charset = utf-8
|
||||||
end_of_line = lf
|
end_of_line = lf
|
||||||
insert_final_newline = true
|
insert_final_newline = true
|
||||||
|
|
|
@ -1,58 +1,58 @@
|
||||||
import { assertEquals } from "https://deno.land/std/testing/asserts.ts";
|
import { expect, test } from "./deps.test.ts";
|
||||||
import { bool, cmp, is } from "./comparison.ts";
|
import { bool, cmp, is } from "./comparison.ts";
|
||||||
|
|
||||||
Deno.test("cmp", () => {
|
test("cmp", () => {
|
||||||
assertEquals([8, 3, 5].sort(cmp()), [3, 5, 8]);
|
expect([8, 3, 5].sort(cmp())).toEqual([3, 5, 8]);
|
||||||
assertEquals([8, 3, 5, 8].sort(cmp({ reverse: true })), [8, 8, 5, 3]);
|
expect([8, 3, 5, 8].sort(cmp({ reverse: true }))).toEqual([8, 8, 5, 3]);
|
||||||
assertEquals([-2, 8, -7].sort(cmp({ key: Math.abs })), [-2, -7, 8]);
|
expect([-2, 8, -7].sort(cmp({ key: Math.abs }))).toEqual([-2, -7, 8]);
|
||||||
assertEquals(["c", "a", "b"].sort(cmp()), ["a", "b", "c"]);
|
expect(["c", "a", "b"].sort(cmp())).toEqual(["a", "b", "c"]);
|
||||||
});
|
});
|
||||||
|
|
||||||
Deno.test("is", () => {
|
test("is", () => {
|
||||||
const f1 = is(5);
|
const f1 = is(5);
|
||||||
assertEquals(f1(5), true);
|
expect(f1(5)).toBe(true);
|
||||||
assertEquals(f1(4), false);
|
expect(f1(4)).toBe(false);
|
||||||
assertEquals(f1("a" as any), false);
|
expect(f1("a" as any)).toBe(false);
|
||||||
assertEquals(f1(null as any), false);
|
expect(f1(null as any)).toBe(false);
|
||||||
assertEquals(f1(undefined as any), false);
|
expect(f1(undefined as any)).toBe(false);
|
||||||
|
|
||||||
const obj: { x: number } = { x: 1 };
|
const obj: { x: number } = { x: 1 };
|
||||||
let f2 = is(obj);
|
let f2 = is(obj);
|
||||||
assertEquals(f2(obj), true);
|
expect(f2(obj)).toBe(true);
|
||||||
assertEquals(f2({ x: 1 }), false);
|
expect(f2({ x: 1 })).toBe(false);
|
||||||
assertEquals(f2({ y: 1 } as any), false);
|
expect(f2({ y: 1 } as any)).toBe(false);
|
||||||
});
|
});
|
||||||
|
|
||||||
Deno.test("bool", () => {
|
test("bool", () => {
|
||||||
assertEquals(bool(null), false);
|
expect(bool(null)).toBe(false);
|
||||||
assertEquals(bool(undefined), false);
|
expect(bool(undefined)).toBe(false);
|
||||||
|
|
||||||
assertEquals(bool(false), false);
|
expect(bool(false)).toBe(false);
|
||||||
assertEquals(bool(true), true);
|
expect(bool(true)).toBe(true);
|
||||||
|
|
||||||
assertEquals(bool(-1), true);
|
expect(bool(-1)).toBe(true);
|
||||||
assertEquals(bool(0), false);
|
expect(bool(0)).toBe(false);
|
||||||
assertEquals(bool(1), true);
|
expect(bool(1)).toBe(true);
|
||||||
|
|
||||||
assertEquals(bool(""), false);
|
expect(bool("")).toBe(false);
|
||||||
assertEquals(bool(" "), true);
|
expect(bool(" ")).toBe(true);
|
||||||
assertEquals(bool("abc"), true);
|
expect(bool("abc")).toBe(true);
|
||||||
|
|
||||||
assertEquals(bool([]), false);
|
expect(bool([])).toBe(false);
|
||||||
assertEquals(bool([0]), true);
|
expect(bool([0])).toBe(true);
|
||||||
assertEquals(bool([1, 2, 3]), true);
|
expect(bool([1, 2, 3])).toBe(true);
|
||||||
|
|
||||||
assertEquals(bool(new Set()), false);
|
expect(bool(new Set())).toBe(false);
|
||||||
assertEquals(bool(new Set([0])), true);
|
expect(bool(new Set([0]))).toBe(true);
|
||||||
assertEquals(bool(new Set([1, 2, 3])), true);
|
expect(bool(new Set([1, 2, 3]))).toBe(true);
|
||||||
|
|
||||||
assertEquals(bool({}), false);
|
expect(bool({})).toBe(false);
|
||||||
assertEquals(bool({ a: 5 }), true);
|
expect(bool({ a: 5 })).toBe(true);
|
||||||
|
|
||||||
class Obj1 {}
|
class Obj1 {}
|
||||||
class Obj2 {
|
class Obj2 {
|
||||||
private x = 0;
|
private x = 0;
|
||||||
}
|
}
|
||||||
assertEquals(bool(new Obj1()), false);
|
expect(bool(new Obj1())).toBe(false);
|
||||||
assertEquals(bool(new Obj2()), true);
|
expect(bool(new Obj2())).toBe(true);
|
||||||
});
|
});
|
||||||
|
|
|
@ -1,30 +1,30 @@
|
||||||
import { assertEquals } from "https://deno.land/std/testing/asserts.ts";
|
import { expect, test } from "./deps.test.ts";
|
||||||
import { identity, nop, partial, pipe } from "./composition.ts";
|
import { identity, nop, partial, pipe } from "./composition.ts";
|
||||||
|
|
||||||
Deno.test("nop", () => {
|
test("nop", () => {
|
||||||
assertEquals(nop(), undefined);
|
expect(nop()).toBeUndefined();
|
||||||
});
|
});
|
||||||
|
|
||||||
Deno.test("identity", () => {
|
test("identity", () => {
|
||||||
assertEquals(identity(5), 5);
|
expect(identity(5)).toBe(5);
|
||||||
assertEquals(identity(null), null);
|
expect(identity(null)).toBe(null);
|
||||||
});
|
});
|
||||||
|
|
||||||
Deno.test("partial", () => {
|
test("partial", () => {
|
||||||
const func1 = (conf: { a: number; b: string; c: number }) =>
|
const func1 = (conf: { a: number; b: string; c: number }) =>
|
||||||
`${conf.a}${conf.b}${conf.c}`;
|
`${conf.a}${conf.b}${conf.c}`;
|
||||||
const pfunc1 = partial({ b: "test" }, func1);
|
const pfunc1 = partial({ b: "test" }, func1);
|
||||||
assertEquals(pfunc1({ a: 5, c: 8 }), "5test8");
|
expect(pfunc1({ a: 5, c: 8 })).toEqual("5test8");
|
||||||
|
|
||||||
const func2 = (conf: { a: number; b: string }, c: number) =>
|
const func2 = (conf: { a: number; b: string }, c: number) =>
|
||||||
`${conf.a}${conf.b}${c}`;
|
`${conf.a}${conf.b}${c}`;
|
||||||
const pfunc2 = partial({ b: "test" }, func2);
|
const pfunc2 = partial({ b: "test" }, func2);
|
||||||
assertEquals(pfunc2({ a: 2 }, 3), "2test3");
|
expect(pfunc2({ a: 2 }, 3)).toEqual("2test3");
|
||||||
});
|
});
|
||||||
|
|
||||||
Deno.test("pipe", () => {
|
test("pipe", () => {
|
||||||
const f = pipe((x: number) => x * 2, (x: number) => x + 1);
|
const f = pipe((x: number) => x * 2, (x: number) => x + 1);
|
||||||
assertEquals(f(1), 3);
|
expect(f(1)).toBe(3);
|
||||||
assertEquals(f(2), 5);
|
expect(f(2)).toBe(5);
|
||||||
assertEquals(f(3), 7);
|
expect(f(3)).toBe(7);
|
||||||
});
|
});
|
||||||
|
|
|
@ -0,0 +1 @@
|
||||||
|
export * from "https://code.thunderk.net/typescript/deno_tools/raw/1.0.0/testing.ts";
|
|
@ -1,47 +1,46 @@
|
||||||
import { assertEquals } from "https://deno.land/std/testing/asserts.ts";
|
import { expect, test } from "./deps.test.ts";
|
||||||
import { at, first, fmap, last, second, third } from "./iterables.ts";
|
import { at, first, fmap, last, second, third } from "./iterables.ts";
|
||||||
|
|
||||||
Deno.test("at", () => {
|
test("at", () => {
|
||||||
const second = at(1);
|
const second = at(1);
|
||||||
assertEquals(second([1, 4, 8]), 4);
|
expect(second([1, 4, 8])).toBe(4);
|
||||||
assertEquals(second([1]), undefined);
|
expect(second([1])).toBeUndefined();
|
||||||
|
|
||||||
const second_from_end = at(-2);
|
const second_from_end = at(-2);
|
||||||
assertEquals(second_from_end([1, 4, 6, 8]), 6);
|
expect(second_from_end([1, 4, 6, 8])).toBe(6);
|
||||||
assertEquals(second_from_end([1]), undefined);
|
expect(second_from_end([1])).toBeUndefined();
|
||||||
});
|
});
|
||||||
|
|
||||||
Deno.test("first", () => {
|
test("first", () => {
|
||||||
assertEquals(first([1, 4, 8]), 1);
|
expect(first([1, 4, 8])).toBe(1);
|
||||||
assertEquals(first([1]), 1);
|
expect(first([1])).toBe(1);
|
||||||
assertEquals(first([]), undefined);
|
expect(first([])).toBeUndefined();
|
||||||
});
|
});
|
||||||
|
|
||||||
Deno.test("second", () => {
|
test("second", () => {
|
||||||
assertEquals(second([1, 4, 8]), 4);
|
expect(second([1, 4, 8])).toBe(4);
|
||||||
assertEquals(second([1]), undefined);
|
expect(second([1])).toBeUndefined();
|
||||||
assertEquals(second([]), undefined);
|
expect(second([])).toBeUndefined();
|
||||||
});
|
});
|
||||||
|
|
||||||
Deno.test("third", () => {
|
test("third", () => {
|
||||||
assertEquals(third([1, 4, 8]), 8);
|
expect(third([1, 4, 8])).toBe(8);
|
||||||
assertEquals(third([1, 4]), undefined);
|
expect(third([1, 4])).toBeUndefined();
|
||||||
assertEquals(third([]), undefined);
|
expect(third([])).toBeUndefined();
|
||||||
});
|
});
|
||||||
|
|
||||||
Deno.test("last", () => {
|
test("last", () => {
|
||||||
assertEquals(last([1, 4, 8]), 8);
|
expect(last([1, 4, 8])).toBe(8);
|
||||||
assertEquals(last([1]), 1);
|
expect(last([1])).toBe(1);
|
||||||
assertEquals(last([]), undefined);
|
expect(last([])).toBeUndefined();
|
||||||
});
|
});
|
||||||
|
|
||||||
Deno.test("fmap", () => {
|
test("fmap", () => {
|
||||||
assertEquals(fmap()([1, 2, 3]), [1, 2, 3]);
|
expect(fmap()([1, 2, 3])).toEqual([1, 2, 3]);
|
||||||
assertEquals(fmap((x: number) => x * 2)([1, 2, 3]), [2, 4, 6]);
|
expect(fmap((x: number) => x * 2)([1, 2, 3])).toEqual([2, 4, 6]);
|
||||||
assertEquals(fmap(undefined, (x: number) => x % 2 == 0)([1, 2, 3]), [2]);
|
expect(fmap(undefined, (x: number) => x % 2 == 0)([1, 2, 3])).toEqual([2]);
|
||||||
assertEquals(fmap((x: number) => x * 2)([1, 2, 3]), [2, 4, 6]);
|
expect(fmap((x: number) => x * 2)([1, 2, 3])).toEqual([2, 4, 6]);
|
||||||
assertEquals(
|
expect(fmap((x: number) => x * 2, (x: number) => x < 5)([1, 2, 3])).toEqual(
|
||||||
fmap((x: number) => x * 2, (x: number) => x < 5)([1, 2, 3]),
|
|
||||||
[2, 4],
|
[2, 4],
|
||||||
);
|
);
|
||||||
});
|
});
|
||||||
|
|
|
@ -1,8 +1,8 @@
|
||||||
import { assertEquals } from "https://deno.land/std/testing/asserts.ts";
|
import { expect, test } from "./deps.test.ts";
|
||||||
import { attr } from "./objects.ts";
|
import { attr } from "./objects.ts";
|
||||||
|
|
||||||
Deno.test("attr", () => {
|
test("attr", () => {
|
||||||
const getx = attr("x");
|
const getx = attr("x");
|
||||||
assertEquals(getx({ x: 4, y: 5 }), 4);
|
expect(getx({ x: 4, y: 5 })).toBe(4);
|
||||||
assertEquals(getx({ x: undefined, y: 5 }), undefined);
|
expect(getx({ x: undefined, y: 5 })).toBeUndefined();
|
||||||
});
|
});
|
||||||
|
|
|
@ -1,43 +1,43 @@
|
||||||
import { assertEquals } from "https://deno.land/std/testing/asserts.ts";
|
import { expect, test } from "./deps.test.ts";
|
||||||
import { always, and, never, not, or } from "./predicates.ts";
|
import { always, and, never, not, or } from "./predicates.ts";
|
||||||
|
|
||||||
Deno.test("always", () => {
|
test("always", () => {
|
||||||
assertEquals(always(), true);
|
expect(always()).toBe(true);
|
||||||
assertEquals(always(true), true);
|
expect(always(true)).toBe(true);
|
||||||
assertEquals(always(false), true);
|
expect(always(false)).toBe(true);
|
||||||
});
|
});
|
||||||
|
|
||||||
Deno.test("never", () => {
|
test("never", () => {
|
||||||
assertEquals(never(), false);
|
expect(never()).toBe(false);
|
||||||
assertEquals(never(true), false);
|
expect(never(true)).toBe(false);
|
||||||
assertEquals(never(false), false);
|
expect(never(false)).toBe(false);
|
||||||
});
|
});
|
||||||
|
|
||||||
Deno.test("not", () => {
|
test("not", () => {
|
||||||
const iseven = (x: number) => x % 2 == 0;
|
const iseven = (x: number) => x % 2 == 0;
|
||||||
const isodd = not(iseven);
|
const isodd = not(iseven);
|
||||||
assertEquals(iseven(0), true);
|
expect(iseven(0)).toBe(true);
|
||||||
assertEquals(isodd(0), false);
|
expect(isodd(0)).toBe(false);
|
||||||
assertEquals(iseven(1), false);
|
expect(iseven(1)).toBe(false);
|
||||||
assertEquals(isodd(1), true);
|
expect(isodd(1)).toBe(true);
|
||||||
assertEquals(iseven(2), true);
|
expect(iseven(2)).toBe(true);
|
||||||
assertEquals(isodd(2), false);
|
expect(isodd(2)).toBe(false);
|
||||||
});
|
});
|
||||||
|
|
||||||
Deno.test("and", () => {
|
test("and", () => {
|
||||||
const f = and((x: number) => x % 2 == 0, (x: number) => x > 5);
|
const f = and((x: number) => x % 2 == 0, (x: number) => x > 5);
|
||||||
assertEquals(f(0), false);
|
expect(f(0)).toBe(false);
|
||||||
assertEquals(f(2), false);
|
expect(f(2)).toBe(false);
|
||||||
assertEquals(f(8), true);
|
expect(f(8)).toBe(true);
|
||||||
assertEquals(f(9), false);
|
expect(f(9)).toBe(false);
|
||||||
assertEquals(f(10), true);
|
expect(f(10)).toBe(true);
|
||||||
});
|
});
|
||||||
|
|
||||||
Deno.test("or", () => {
|
test("or", () => {
|
||||||
const f = or((x: number) => x % 2 == 0, (x: number) => x > 5);
|
const f = or((x: number) => x % 2 == 0, (x: number) => x > 5);
|
||||||
assertEquals(f(0), true);
|
expect(f(0)).toBe(true);
|
||||||
assertEquals(f(1), false);
|
expect(f(1)).toBe(false);
|
||||||
assertEquals(f(2), true);
|
expect(f(2)).toBe(true);
|
||||||
assertEquals(f(8), true);
|
expect(f(8)).toBe(true);
|
||||||
assertEquals(f(9), true);
|
expect(f(9)).toBe(true);
|
||||||
});
|
});
|
||||||
|
|
|
@ -1,10 +1,7 @@
|
||||||
import {
|
import { expect, test } from "./deps.test.ts";
|
||||||
assertEquals,
|
|
||||||
assertThrows,
|
|
||||||
} from "https://deno.land/std/testing/asserts.ts";
|
|
||||||
import { isinstance, nn, nnu, nu } from "./typing.ts";
|
import { isinstance, nn, nnu, nu } from "./typing.ts";
|
||||||
|
|
||||||
Deno.test("isinstance", () => {
|
test("isinstance", () => {
|
||||||
class A {}
|
class A {}
|
||||||
class A1 extends A {}
|
class A1 extends A {}
|
||||||
class A2 extends A {}
|
class A2 extends A {}
|
||||||
|
@ -12,29 +9,29 @@ Deno.test("isinstance", () => {
|
||||||
|
|
||||||
const f: any[] = [5, null, undefined, new A(), new A1(), new B(), new A2()];
|
const f: any[] = [5, null, undefined, new A(), new A1(), new B(), new A2()];
|
||||||
const result = f.filter(isinstance(A));
|
const result = f.filter(isinstance(A));
|
||||||
assertEquals(result, [f[3], f[4], f[6]]);
|
expect(result).toEqual([f[3], f[4], f[6]]);
|
||||||
});
|
});
|
||||||
|
|
||||||
Deno.test("nn", () => {
|
test("nn", () => {
|
||||||
assertEquals(nn(undefined), undefined);
|
expect(nn(undefined)).toBeUndefined();
|
||||||
assertEquals(nn(0), 0);
|
expect(nn(0)).toBe(0);
|
||||||
assertEquals(nn(""), "");
|
expect(nn("")).toBe("");
|
||||||
assertEquals(nn([]), []);
|
expect(nn([])).toEqual([]);
|
||||||
assertThrows(() => nn(null), Error, "null value");
|
expect(() => nn(null)).toThrow("null value");
|
||||||
});
|
});
|
||||||
|
|
||||||
Deno.test("nu", () => {
|
test("nu", () => {
|
||||||
assertEquals(nu(null), null);
|
expect(nu(null)).toBe(null);
|
||||||
assertEquals(nu(0), 0);
|
expect(nu(0)).toBe(0);
|
||||||
assertEquals(nu(""), "");
|
expect(nu("")).toBe("");
|
||||||
assertEquals(nu([]), []);
|
expect(nu([])).toEqual([]);
|
||||||
assertThrows(() => nu(undefined), Error, "undefined value");
|
expect(() => nu(undefined)).toThrow("undefined value");
|
||||||
});
|
});
|
||||||
|
|
||||||
Deno.test("nnu", () => {
|
test("nnu", () => {
|
||||||
assertEquals(nnu(0), 0);
|
expect(nnu(0)).toBe(0);
|
||||||
assertEquals(nnu(""), "");
|
expect(nnu("")).toBe("");
|
||||||
assertEquals(nnu([]), []);
|
expect(nnu([])).toEqual([]);
|
||||||
assertThrows(() => nnu(undefined), Error, "undefined value");
|
expect(() => nnu(undefined)).toThrow("undefined value");
|
||||||
assertThrows(() => nnu(null), Error, "null value");
|
expect(() => nnu(null)).toThrow("null value");
|
||||||
});
|
});
|
||||||
|
|
Loading…
Reference in New Issue