524 lines
20 KiB
TypeScript
524 lines
20 KiB
TypeScript
module TK.Specs {
|
|
testing("Tools", test => {
|
|
test.case("returns boolean equivalent", check => {
|
|
check.same(bool(null), false, "null");
|
|
check.same(bool(undefined), false, "undefined");
|
|
|
|
check.same(bool(false), false, "false");
|
|
check.same(bool(true), true, "true");
|
|
|
|
check.same(bool(0), false, "0");
|
|
check.same(bool(1), true, "1");
|
|
check.same(bool(-1), true, "-1");
|
|
|
|
check.same(bool(""), false, "\"\"");
|
|
check.same(bool(" "), true, "\" \"");
|
|
check.same(bool("abc"), true, "\"abc\"");
|
|
|
|
check.same(bool([]), false, "[]");
|
|
check.same(bool([1]), true, "[1]");
|
|
check.same(bool([null, "a"]), true, "[null, \"a\"]");
|
|
|
|
check.same(bool({}), false, "{}");
|
|
check.same(bool({ a: 5 }), true, "{a: 5}");
|
|
check.same(bool(new Timer()), true, "new Timer()");
|
|
});
|
|
|
|
test.case("coalesces to a default value", check => {
|
|
check.equals(coalesce(0, 2), 0);
|
|
check.equals(coalesce(5, 2), 5);
|
|
check.equals(coalesce(null, 2), 2);
|
|
check.equals(coalesce(undefined, 2), 2);
|
|
|
|
check.equals(coalesce("", "a"), "");
|
|
check.equals(coalesce("b", "a"), "b");
|
|
check.equals(coalesce(null, "a"), "a");
|
|
check.equals(coalesce(undefined, "a"), "a");
|
|
});
|
|
|
|
test.case("do basic function composition", check => {
|
|
check.equals(fmap((x: number) => x * 2, x => x + 1)(3), 8);
|
|
});
|
|
|
|
test.case("function composes a fallback value for null results", check => {
|
|
let f = nnf(-1, x => x > 3 ? null : x);
|
|
check.equals(f(2), 2);
|
|
check.equals(f(3), 3);
|
|
check.equals(f(4), -1);
|
|
});
|
|
|
|
test.case("checks for null value", check => {
|
|
let value: number | null | undefined = 5;
|
|
check.equals(nn(value), 5);
|
|
value = 0;
|
|
check.equals(nn(value), 0);
|
|
value = null;
|
|
check.throw(() => nn(value), "Null value");
|
|
value = undefined;
|
|
check.throw(() => nn(value), "Undefined value");
|
|
});
|
|
|
|
test.case("removes null values from arrays", check => {
|
|
let value: (number | null)[] = [];
|
|
check.equals(nna(value), []);
|
|
value = [1, 2];
|
|
check.equals(nna(value), [1, 2]);
|
|
value = [1, null, 3];
|
|
check.equals(nna(value), [1, 3]);
|
|
});
|
|
|
|
test.case("cast-checks objects", check => {
|
|
let obj = new RObject();
|
|
check.equals(as(RObject, obj), obj);
|
|
check.throw(() => as(Timer, obj), new Error("Bad cast"));
|
|
});
|
|
|
|
test.case("compare values", check => {
|
|
check.equals(cmp(8, 5), 1);
|
|
check.same(cmp(5, 8), -1);
|
|
check.equals(cmp(5, 5), 0);
|
|
|
|
check.equals(cmp("c", "b"), 1);
|
|
check.same(cmp("b", "c"), -1);
|
|
check.equals(cmp("b", "b"), 0);
|
|
|
|
check.same(cmp(8, 5, true), -1);
|
|
check.equals(cmp(5, 8, true), 1);
|
|
check.equals(cmp(5, 5, true), 0);
|
|
});
|
|
|
|
test.case("clamp values in a range", check => {
|
|
check.equals(clamp(5, 3, 8), 5);
|
|
check.equals(clamp(1, 3, 8), 3);
|
|
check.equals(clamp(10, 3, 8), 8);
|
|
});
|
|
|
|
test.case("interpolates values linearly", check => {
|
|
check.equals(lerp(0, 0, 4), 0);
|
|
check.equals(lerp(0.5, 0, 4), 2);
|
|
check.equals(lerp(1, 0, 4), 4);
|
|
check.equals(lerp(2, 0, 4), 8);
|
|
check.same(lerp(-1, 0, 4), -4);
|
|
check.equals(lerp(0.5, 3, 4), 3.5);
|
|
check.equals(lerp(0.5, 3, 3), 3);
|
|
check.equals(lerp(0.5, 3, 2), 2.5);
|
|
});
|
|
|
|
test.case("duplicates objects", check => {
|
|
check.equals(duplicate(null), null);
|
|
check.equals(duplicate(5), 5);
|
|
check.equals(duplicate("test"), "test");
|
|
check.equals(duplicate({ a: 4 }), { a: 4 });
|
|
check.equals(duplicate([1, "test"]), [1, "test"]);
|
|
check.equals(duplicate(new TestSerializerObj1(6), <any>TK.Specs), new TestSerializerObj1(6));
|
|
let original = new TestRObject(4);
|
|
check.equals(duplicate(original, <any>TK.Specs), original);
|
|
check.notsame(duplicate(original, <any>TK.Specs), original);
|
|
});
|
|
|
|
test.case("copies arrays", check => {
|
|
var array = [1, 2, "test", null, { "a": 5 }];
|
|
var copied = acopy(array);
|
|
|
|
check.equals(copied, array);
|
|
check.notsame(copied, array);
|
|
check.same(copied[4], array[4]);
|
|
|
|
check.equals(array[2], "test");
|
|
check.equals(copied[2], "test");
|
|
array[2] = "notest";
|
|
check.equals(array[2], "notest");
|
|
check.equals(copied[2], "test");
|
|
copied[2] = "ok";
|
|
check.equals(array[2], "notest");
|
|
check.equals(copied[2], "ok");
|
|
|
|
check.equals(array.length, 5);
|
|
check.equals(copied.length, 5);
|
|
remove(copied, 2);
|
|
check.equals(array.length, 5);
|
|
check.equals(copied.length, 4);
|
|
});
|
|
|
|
test.case("iterates through sorted arrays", check => {
|
|
var result: number[] = [];
|
|
itersorted([1, 2, 3], item => item, item => result.push(item));
|
|
check.equals(result, [1, 2, 3]);
|
|
|
|
result = [];
|
|
itersorted([1, 2, 3], item => -item, item => result.push(item));
|
|
check.equals(result, [3, 2, 1]);
|
|
});
|
|
|
|
test.case("checks if an array contains an item", check => {
|
|
check.equals(contains([], 5), false);
|
|
|
|
check.equals(contains([3, 5, 8], 5), true);
|
|
check.equals(contains([3, 5, 8], 4), false);
|
|
|
|
check.equals(contains([5, 5, 5], 5), true);
|
|
|
|
check.equals(contains([3, null, 8], null), true);
|
|
|
|
check.equals(contains(["a", "b"], "b"), true);
|
|
check.equals(contains(["a", "b"], "c"), false);
|
|
});
|
|
|
|
test.case("capitalizes strings", check => {
|
|
check.equals(capitalize("test"), "Test");
|
|
check.equals(capitalize("test second"), "Test second");
|
|
});
|
|
|
|
test.case("produces range of numbers", check => {
|
|
check.equals(range(-1), []);
|
|
check.equals(range(0), []);
|
|
check.equals(range(1), [0]);
|
|
check.equals(range(2), [0, 1]);
|
|
check.equals(range(5), [0, 1, 2, 3, 4]);
|
|
});
|
|
|
|
test.case("zips arrays", check => {
|
|
check.equals(zip([], []), []);
|
|
check.equals(zip([], [1]), []);
|
|
check.equals(zip([0], [1]), [[0, 1]]);
|
|
check.equals(zip([0, 2, 4], [1, 3]), [[0, 1], [2, 3]]);
|
|
check.equals(zip([0, 1], ["a", "b"]), [[0, "a"], [1, "b"]]);
|
|
});
|
|
|
|
test.case("unzips arrays", check => {
|
|
check.equals(unzip([]), [[], []]);
|
|
check.equals(unzip([[1, "a"]]), [[1], ["a"]]);
|
|
check.equals(unzip([[1, "a"], [2, "b"]]), [[1, 2], ["a", "b"]]);
|
|
});
|
|
|
|
test.case("partitions arrays by a predicate", check => {
|
|
check.equals(binpartition([], (i: number) => i % 2 == 0), [[], []]);
|
|
check.equals(binpartition([1, 2, 3, 4], i => i % 2 == 0), [[2, 4], [1, 3]]);
|
|
});
|
|
|
|
test.case("produces neighbor tuples from array", check => {
|
|
check.equals(neighbors([]), []);
|
|
check.equals(neighbors([1]), []);
|
|
check.equals(neighbors([1, 2]), [[1, 2]]);
|
|
check.equals(neighbors([1, 2, 3]), [[1, 2], [2, 3]]);
|
|
check.equals(neighbors([1, 2, 3, 4]), [[1, 2], [2, 3], [3, 4]]);
|
|
|
|
check.equals(neighbors([], true), []);
|
|
check.equals(neighbors([1], true), [[1, 1]]);
|
|
check.equals(neighbors([1, 2], true), [[1, 2], [2, 1]]);
|
|
check.equals(neighbors([1, 2, 3], true), [[1, 2], [2, 3], [3, 1]]);
|
|
check.equals(neighbors([1, 2, 3, 4], true), [[1, 2], [2, 3], [3, 4], [4, 1]]);
|
|
});
|
|
|
|
test.case("filters list with type guards", check => {
|
|
let result = tfilter(<(number | string)[]>[1, "a", 2, "b"], (x): x is number => typeof x == "number");
|
|
check.equals(result, [1, 2]);
|
|
|
|
let o1 = new RObject();
|
|
let o2 = new RObject();
|
|
let o3 = new RObjectContainer();
|
|
check.equals(cfilter([1, "a", o1, 2, o2, o3, "b"], RObject), [o1, o2]);
|
|
});
|
|
|
|
test.case("flattens lists of lists", check => {
|
|
check.equals(flatten([]), []);
|
|
check.equals(flatten([[]]), []);
|
|
check.equals(flatten([[], []]), []);
|
|
check.equals(flatten([[1], []]), [1]);
|
|
check.equals(flatten([[], [1]]), [1]);
|
|
check.equals(flatten([[1], [2]]), [1, 2]);
|
|
check.equals(flatten([[1, 2], [3, 4], [], [5]]), [1, 2, 3, 4, 5]);
|
|
});
|
|
|
|
test.case("counts items in array", check => {
|
|
check.equals(counter([]), []);
|
|
check.equals(counter(["a"]), [["a", 1]]);
|
|
check.equals(counter(["a", "b"]), [["a", 1], ["b", 1]]);
|
|
check.equals(counter(["a", "b", "a"]), [["a", 2], ["b", 1]]);
|
|
});
|
|
|
|
test.case("find the first array item to pass a predicate", check => {
|
|
check.equals(first([1, 2, 3], i => i % 2 == 0), 2);
|
|
check.equals(first([1, 2, 3], i => i % 4 == 0), null);
|
|
|
|
check.equals(any([1, 2, 3], i => i % 2 == 0), true);
|
|
check.equals(any([1, 2, 3], i => i % 4 == 0), false);
|
|
});
|
|
|
|
test.case("creates a simple iterator over an array", check => {
|
|
let i = iterator([1, 2, 3]);
|
|
check.equals(i(), 1);
|
|
check.equals(i(), 2);
|
|
check.equals(i(), 3);
|
|
check.equals(i(), null);
|
|
check.equals(i(), null);
|
|
|
|
i = iterator([]);
|
|
check.equals(i(), null);
|
|
check.equals(i(), null);
|
|
});
|
|
|
|
test.case("iterates an object keys and values", check => {
|
|
var obj = {
|
|
"a": 1,
|
|
"c": [2.5],
|
|
"b": null
|
|
};
|
|
check.equals(keys(obj), ["a", "c", "b"]);
|
|
check.equals(values(obj), [1, [2.5], null]);
|
|
var result: { [key: string]: any } = {};
|
|
iteritems(obj, (key, value) => { result[key] = value; });
|
|
check.equals(result, obj);
|
|
|
|
check.equals(dict(items(obj)), obj);
|
|
});
|
|
|
|
test.case("gets an enum values", check => {
|
|
enum Test {
|
|
ZERO,
|
|
ONE,
|
|
TWO
|
|
};
|
|
|
|
var result: any[] = [];
|
|
iterenum(Test, item => result.push(item));
|
|
check.equals(result, [0, 1, 2]);
|
|
check.equals(result, [Test.ZERO, Test.ONE, Test.TWO]);
|
|
|
|
check.equals(enumvalues(Test), [0, 1, 2]);
|
|
check.equals(enumvalues(Test), [Test.ZERO, Test.ONE, Test.TWO]);
|
|
});
|
|
|
|
test.case("create a dict from an array of couples", check => {
|
|
check.equals(dict([]), {});
|
|
check.equals(dict([["5", 3], ["4", 1], ["5", 8]]), { "5": 8, "4": 1 });
|
|
});
|
|
|
|
test.case("create an index from an array", check => {
|
|
check.equals(index([2, 3, 4], i => (i - 1).toString()), { "1": 2, "2": 3, "3": 4 });
|
|
});
|
|
|
|
test.case("add an item in an array", check => {
|
|
var result;
|
|
var array = [1];
|
|
|
|
result = add(array, 8);
|
|
check.equals(array, [1, 8]);
|
|
check.equals(result, true);
|
|
|
|
result = add(array, 2);
|
|
check.equals(array, [1, 8, 2]);
|
|
check.equals(result, true);
|
|
|
|
result = add(array, 8);
|
|
check.equals(array, [1, 8, 2]);
|
|
check.equals(result, false);
|
|
});
|
|
|
|
test.case("removes an item from an array", check => {
|
|
var array = [1, 2, 3];
|
|
var result = remove(array, 1);
|
|
check.equals(array, [2, 3]);
|
|
check.equals(result, true);
|
|
result = remove(array, 1);
|
|
check.equals(array, [2, 3]);
|
|
check.equals(result, false);
|
|
result = remove(array, 2);
|
|
check.equals(array, [3]);
|
|
check.equals(result, true);
|
|
result = remove(array, 3);
|
|
check.equals(array, []);
|
|
check.equals(result, true);
|
|
result = remove(array, 3);
|
|
check.equals(array, []);
|
|
check.equals(result, false);
|
|
});
|
|
|
|
test.case("checks objects equality", check => {
|
|
check.equals(equals({}, {}), true);
|
|
check.equals(equals({ "a": 1 }, { "a": 1 }), true);
|
|
check.equals(equals({ "a": 1 }, { "a": 2 }), false);
|
|
check.equals(equals({ "a": 1 }, { "b": 1 }), false);
|
|
check.equals(equals({ "a": 1 }, { "a": null }), false);
|
|
});
|
|
|
|
test.case("combinate filters", check => {
|
|
var filter = andfilter((item: number) => item > 5, (item: number) => item < 12);
|
|
check.equals(filter(4), false);
|
|
check.equals(filter(5), false);
|
|
check.equals(filter(6), true);
|
|
check.equals(filter(8), true);
|
|
check.equals(filter(11), true);
|
|
check.equals(filter(12), false);
|
|
check.equals(filter(13), false);
|
|
});
|
|
|
|
test.case("get a class name", check => {
|
|
class Test {
|
|
}
|
|
var a = new Test();
|
|
check.equals(classname(a), "Test");
|
|
});
|
|
|
|
test.case("find lowest item of an array", check => {
|
|
check.equals(lowest(["aaa", "b", "cc"], s => s.length), "b");
|
|
});
|
|
|
|
test.case("binds callbacks", check => {
|
|
class Test {
|
|
prop = 5;
|
|
meth() {
|
|
return this.prop + 1;
|
|
}
|
|
}
|
|
var inst = new Test();
|
|
var double = (getter: () => number): number => getter() * 2;
|
|
check.throw(() => double(inst.meth));
|
|
check.equals(double(bound(inst, "meth")), 12);
|
|
});
|
|
|
|
test.case("computes progress between two boundaries", check => {
|
|
check.equals(progress(-1.0, 0.0, 1.0), 0.0);
|
|
check.equals(progress(0.0, 0.0, 1.0), 0.0);
|
|
check.equals(progress(0.4, 0.0, 1.0), 0.4);
|
|
check.equals(progress(1.8, 0.0, 1.0), 1.0);
|
|
check.equals(progress(1.5, 0.5, 2.5), 0.5);
|
|
});
|
|
|
|
test.case("copies full javascript objects", check => {
|
|
class TestObj {
|
|
a: string;
|
|
b: any;
|
|
constructor() {
|
|
this.a = "test";
|
|
this.b = { c: 5.1, d: ["unit", "test", 5] };
|
|
}
|
|
get(): string {
|
|
return this.a;
|
|
}
|
|
}
|
|
|
|
var ini = new TestObj();
|
|
|
|
var cop = copy(ini);
|
|
|
|
check.notsame(cop, ini);
|
|
check.equals(cop, ini);
|
|
|
|
check.equals(cop.get(), "test");
|
|
});
|
|
|
|
test.case("merges objects", check => {
|
|
check.equals(merge({}, {}), {});
|
|
check.equals(merge(<any>{ a: 1 }, { b: 2 }), { a: 1, b: 2 });
|
|
check.equals(merge(<any>{ a: 1 }, { a: 3, b: 2 }), { a: 3, b: 2 });
|
|
check.equals(merge(<any>{ a: 1, b: 2 }, { a: undefined }), { a: undefined, b: 2 });
|
|
});
|
|
|
|
test.case("crawls through objects", check => {
|
|
var obj = {
|
|
"a": 1,
|
|
"b": "test",
|
|
"c": {
|
|
"a": <any[]>[2, "thing", { "a": 3, "b": {} }],
|
|
"b": null,
|
|
"c": undefined,
|
|
"d": false
|
|
}
|
|
};
|
|
/*(<any>obj).jasmineToString = () => "obj1";
|
|
(<any>obj.c).jasmineToString = () => "obj2";
|
|
(<any>obj.c.a[2]).jasmineToString = () => "obj3";
|
|
(<any>obj.c.a[2].b).jasmineToString = () => "obj4";
|
|
(<any>obj.c.a).jasmineToString = () => "array1";*/
|
|
|
|
var crawled: any[] = [];
|
|
crawl(obj, val => crawled.push(val));
|
|
check.equals(crawled, [obj, 1, "test", obj.c, obj.c.a, 2, "thing", obj.c.a[2], 3, obj.c.a[2].b, false]);
|
|
check.equals(obj.a, 1);
|
|
|
|
// replace mode
|
|
crawl(obj, val => typeof val == "number" ? 5 : val, true);
|
|
check.equals(obj, { a: 5, b: "test", c: { a: [5, "thing", { a: 5, b: {} }], b: null, c: undefined, d: false } });
|
|
});
|
|
|
|
test.case("get minimal item of an array", check => {
|
|
check.equals(min([5, 1, 8]), 1);
|
|
});
|
|
|
|
test.case("get maximal item of an array", check => {
|
|
check.equals(max([5, 12, 8]), 12);
|
|
});
|
|
|
|
test.case("get sum of an array", check => {
|
|
check.equals(sum([5, 1, 8]), 14);
|
|
});
|
|
|
|
test.case("get average of an array", check => {
|
|
check.equals(avg([4, 2, 9]), 5);
|
|
});
|
|
|
|
test.case("converts to same sign", check => {
|
|
check.equals(samesign(2, 1), 2);
|
|
check.equals(samesign(2, -1), -2);
|
|
check.equals(samesign(-2, 1), 2);
|
|
check.equals(samesign(-2, -1), -2);
|
|
});
|
|
|
|
test.case("sorts an array", check => {
|
|
let base = ["aa", "bbb", "c", "dddd"];
|
|
check.equals(sorted(base, (a, b) => cmp(a.length, b.length)), ["c", "aa", "bbb", "dddd"]);
|
|
check.equals(base, ["aa", "bbb", "c", "dddd"]);
|
|
});
|
|
|
|
test.case("sorts an array, with function applied to each element", check => {
|
|
check.equals(sortedBy([-8, 4, -2, 6], Math.abs), [-2, 4, 6, -8]);
|
|
check.equals(sortedBy([-8, 4, -2, 6], Math.abs, true), [-8, 6, 4, -2]);
|
|
});
|
|
|
|
test.case("get minimal item of an array, with function applied to each element", check => {
|
|
check.equals(minBy([-8, 4, -2, 6], Math.abs), -2);
|
|
});
|
|
|
|
test.case("get maximal item of an array, with function applied to each element", check => {
|
|
check.equals(maxBy([-8, 4, -2, 6], Math.abs), -8);
|
|
});
|
|
|
|
test.case("filter out duplicates in array", check => {
|
|
check.equals(unique([]), []);
|
|
check.equals(unique([1, 2, 3]), [1, 2, 3]);
|
|
check.equals(unique([1, 2, 3, 2, 1]), [1, 2, 3]);
|
|
});
|
|
|
|
test.case("get the union between two arrays", check => {
|
|
check.equals(union([], []), []);
|
|
check.equals(union([], [5]), [5]);
|
|
check.equals(union([4], []), [4]);
|
|
check.equals(union([4], [5]), [4, 5]);
|
|
check.equals(union([1, 2, 4, 8], [3, 2, 8, 7]), [1, 2, 4, 8, 3, 7]);
|
|
});
|
|
|
|
test.case("get the difference between two arrays", check => {
|
|
check.equals(difference([], []), []);
|
|
check.equals(difference([], [5]), []);
|
|
check.equals(difference([1, 2, 4, 8], [2, 8, 7]), [1, 4]);
|
|
});
|
|
|
|
test.case("get the intersection of two arrays", check => {
|
|
check.equals(intersection([], []), []);
|
|
check.equals(intersection([], [5]), []);
|
|
check.equals(intersection([4], []), []);
|
|
check.equals(intersection([6], [7]), []);
|
|
check.equals(intersection([1, 8, 2], [2, 8, 4]), [8, 2]);
|
|
});
|
|
|
|
test.case("get the disjunct union of two arrays", check => {
|
|
check.equals(disjunctunion([], []), []);
|
|
check.equals(disjunctunion([], [5]), [5]);
|
|
check.equals(disjunctunion([4], []), [4]);
|
|
check.equals(disjunctunion([6], [7]), [6, 7]);
|
|
check.equals(disjunctunion([1, 8, 2], [2, 8, 4]), [1, 4]);
|
|
});
|
|
});
|
|
}
|