jsdk-offical
Version:
JSDK is the most comprehensive TypeScript framework, like JDK.
1,005 lines • 102 kB
JavaScript
//# sourceURL=../tests/tests.js
//JSDK 2.7.0 MIT
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
return c > 3 && r && Object.defineProperty(target, key, r), r;
};
var JS;
(function (JS) {
let test;
(function (test) {
let BiMapTest = class BiMapTest extends TestCase {
constructor() {
super(...arguments);
this.a = new BiMap();
}
setUp() {
this.a.clear();
}
test1() {
this.a.put('k1', 1);
this.a.put('k2', 2);
this.a.put('k3', 3);
let b = this.a.inverse();
Assert.equal('k1', b.get(1));
Assert.equal(3, b.size());
Assert.equal(1, this.a.get('k1'));
Assert.equal(2, this.a.get('k2'));
Assert.equal(3, this.a.size());
}
test2() {
this.a = new BiMap([
['k1', 1], ['k2', 2], ['k3', 3]
]);
Assert.equal(3, this.a.size());
Assert.equal(1, this.a.get('k1'));
Assert.true(this.a.has('k1'));
this.a.delete('k1');
Assert.equal(2, this.a.size());
Assert.equal(undefined, this.a.get('k1'));
Assert.false(this.a.has('k1'));
}
test3() {
this.a = new BiMap([
['k1', 1], ['k2', 2], ['k3', 3]
]);
Assert.false(this.a.has('k4'));
Assert.true(this.a.has('k1'));
}
};
BiMapTest = __decorate([
klass('JS.test.BiMapTest')
], BiMapTest);
test.BiMapTest = BiMapTest;
})(test = JS.test || (JS.test = {}));
})(JS || (JS = {}));
var JS;
(function (JS) {
let test;
(function (test) {
let LinkedListTest = class LinkedListTest extends TestCase {
constructor() {
super(...arguments);
this.a = new LinkedList();
}
setUp() {
this.a.clear();
}
test1() {
this.a.add(3);
this.a.add([2, 1]);
Assert.equal(3, this.a.get(0));
Assert.equal(1, this.a.get(2));
this.a.addAt(1, 0.5);
Assert.equal(0.5, this.a.get(1));
Assert.equal(4, this.a.size());
let b = new LinkedList();
b.addLast(22);
Assert.equal([22], b.toArray());
b.addFirst(11);
Assert.equal([11, 22], b.toArray());
b.addAt(0, 33);
Assert.equal([33, 11, 22], b.toArray());
b.addAt(2, 44);
Assert.equal([33, 11, 44, 22], b.toArray());
Assert.equal(4, b.size());
Assert.equal(33, b.get(0));
Assert.equal(11, b.get(1));
Assert.equal(44, b.get(2));
Assert.equal(22, b.get(3));
Assert.equal(33, b.getFirst());
Assert.equal(22, b.getLast());
this.a.addAll(b);
Assert.equal(8, this.a.size());
Assert.equal(22, this.a.get(7));
Assert.equal([3, 0.5, 2, 1, 33, 11, 44, 22], this.a.toArray());
}
test2() {
this.a.removeFirst();
Assert.equal(0, this.a.size());
this.a.removeLast();
Assert.equal(0, this.a.size());
this.a.add([3, 2, 1]);
this.a.removeFirst();
Assert.equal([2, 1], this.a.toArray());
this.a.removeLast();
Assert.equal([2], this.a.toArray());
this.a.removeFirst();
Assert.equal([], this.a.toArray());
}
test3() {
Assert.equal(null, this.a.peek());
this.a.add([3, 2, 1]);
Assert.equal(3, this.a.peek());
Assert.equal(3, this.a.size());
Assert.equal(1, this.a.peekLast());
Assert.equal(3, this.a.size());
Assert.equal(3, this.a.peekFirst());
Assert.equal(3, this.a.size());
}
test4() {
this.a.add([3, 2, 1, 1]);
Assert.equal(0, this.a.indexOf(3));
Assert.equal(2, this.a.indexOf(1));
Assert.equal(3, this.a.lastIndexOf(1));
Assert.equal(1, this.a.lastIndexOf(2));
Assert.true(this.a.contains(2));
Assert.false(this.a.contains(-1));
Assert.false(this.a.contains(null));
Assert.false(this.a.contains(undefined));
}
test5() {
this.a.add([3, 2, 1, 1]);
Assert.equal(3, this.a.get(0));
Assert.equal(3, this.a.getFirst());
Assert.equal(1, this.a.getLast());
Assert.equal(1, this.a.get(3));
}
test6() {
this.a.add([3, 2, 1, 1]);
let b = this.a.clone();
Assert.equal(this.a.toArray(), b.toArray());
}
test7() {
this.a.add([3, 2, 1]);
Assert.true(this.a.each(item => {
return item > 0;
}));
}
};
LinkedListTest = __decorate([
klass('JS.test.LinkedListTest')
], LinkedListTest);
test.LinkedListTest = LinkedListTest;
})(test = JS.test || (JS.test = {}));
})(JS || (JS = {}));
var JS;
(function (JS) {
let test;
(function (test) {
let CirArcTest = class CirArcTest extends TestCase {
constructor() {
super(...arguments);
this.s0 = new CirArc(ArcType.PIE, 0, 0, 1, 0, -0.5 * Math.PI, 0);
this.s1 = new CirArc(ArcType.OPEN, 0, 0, 1, 0, -0.5 * Math.PI, 0);
}
test1() {
Assert.true(new CirArc().equals(new CirArc()));
Assert.true(this.s0.equals(this.s0.clone()));
Assert.true(this.s0.bounds().equals(new Rect(0, -1, 1, 1)));
Assert.true(this.s1.bounds().equals(new Rect(0, -1, 1, 1)));
let s3 = new CirArc(ArcType.PIE, 0, 0, 1, 0, -0.75 * Math.PI, 0);
Assert.true(s3.bounds().equals(new Rect(-0.707, -0.707, 1.707, 0.707)));
let s4 = new CirArc(ArcType.OPEN, 0, 0, 1, 0, -0.75 * Math.PI, 1);
Assert.true(s4.bounds().equals(new Rect(-0.707, -0.707, 1.707, 0.707)));
let s5 = new CirArc(ArcType.PIE, 0, 0, 1, 0, -1.25 * Math.PI, 0);
Assert.true(s5.bounds().equals(new Rect(-0.707, 0, 1.707, 0.707)));
let s6 = new CirArc(ArcType.OPEN, 0, 0, 1, 0, -1.25 * Math.PI, 1);
Assert.true(s6.bounds().equals(new Rect(-0.707, 0, 1.707, 0.707)));
let s7 = new CirArc(ArcType.PIE, 0, 0, 1, 0, .25 * Math.PI, 1);
Assert.true(s7.bounds().equals(new Rect(0, 0, 1, 0.707)));
let s8 = new CirArc(ArcType.OPEN, 0, 0, 1, 0, .25 * Math.PI, 1);
Assert.true(s8.bounds().equals(new Rect(0, 0, 1, 0.707)));
let s9 = new CirArc(ArcType.PIE, 0, 0, 1, 0, .25 * Math.PI, 0);
Assert.true(s9.bounds().equals(new Rect(0, 0, 1, 0.707)));
let s10 = new CirArc(ArcType.OPEN, 0, 0, 1, 0, .25 * Math.PI, 0);
Assert.true(s10.bounds().equals(new Rect(0, 0, 1, 0.707)));
}
test2() {
Assert.equal(new Circle(this.s0.x, this.s0.y, this.s0.r).perimeter() / 4 + 2 * this.s0.r, this.s0.perimeter());
Assert.equal(new Circle(this.s0.x, this.s0.y, this.s0.r).perimeter() / 4, this.s1.perimeter());
Assert.equal(this.s0.arcLength(), this.s1.perimeter());
Assert.equal(new Circle(this.s0.x, this.s0.y, this.s0.r).area() / 4, this.s0.area());
Assert.equal(0, this.s1.area());
}
};
CirArcTest = __decorate([
klass('JS.test.CirArcTest')
], CirArcTest);
test.CirArcTest = CirArcTest;
})(test = JS.test || (JS.test = {}));
})(JS || (JS = {}));
var JS;
(function (JS) {
let test;
(function (test) {
let CircleTest = class CircleTest extends TestCase {
constructor() {
super(...arguments);
this.c0 = new Circle(0, 0, 1);
this.p1 = [1, 0];
this.p2 = [0, 1];
this.p3 = [-1, 0];
this.p4 = [0, -1];
}
test1() {
Assert.false(this.c0.equals(new Circle()));
Assert.true(this.c0.clone().set([0, 0], 0).equals(new Circle()));
Assert.true(this.c0.equals(this.c0.clone()));
}
test2() {
Assert.true(this.c0.onside(this.p1));
Assert.true(this.c0.onside(this.p2));
Assert.true(this.c0.onside(this.p3));
Assert.true(this.c0.onside(this.p4));
Assert.false(this.c0.onside([0, 0]));
Assert.false(this.c0.onside([1, 1]));
}
test3() {
Assert.true(this.c0.inside([0, 0]));
Assert.false(this.c0.inside([1, 1]));
Assert.false(this.c0.inside(this.p1));
}
test4() {
Assert.true(this.c0.intersects(Line.toLine(this.p1, this.p3)));
Assert.true(this.c0.intersects(Line.toLine([1, 0], [0, -1])));
Assert.false(this.c0.intersects(Line.toLine([1, 1], [1, 0])));
Assert.false(this.c0.intersects(Line.toLine([2, 0], [0, -2])));
Assert.true(this.c0.intersects(Segment.toSegment(this.p1, this.p3)));
Assert.true(this.c0.intersects(Segment.toSegment([1, 0], [0, -1])));
Assert.false(this.c0.intersects(Segment.toSegment(this.p1, [2, 0])));
Assert.false(this.c0.intersects(Segment.toSegment([1, 1], [1, 0])));
Assert.false(this.c0.intersects(Segment.toSegment([1, 1], [2, 2])));
Assert.true(this.c0.intersects(Circle.toCircle([1, 0], 1)));
Assert.false(this.c0.intersects(Circle.toCircle([2, 0], 1)));
Assert.true(this.c0.intersects(Circle.toCircle([1, 1], 1)));
Assert.true(this.c0.intersects(Circle.toCircle([0.5, 0], 0.5)));
Assert.true(this.c0.intersects(this.c0.bounds()));
Assert.true(this.c0.intersects(Rect.toRect([0, 0], 1, 1)));
Assert.true(this.c0.intersects(Rect.toRect([-.5, -.5], .5, .5)));
Assert.true(this.c0.intersects(Rect.toRect([-2, -2], 4, 4)));
Assert.false(this.c0.intersects(Rect.toRect([1, -1], 2, 2)));
}
};
CircleTest = __decorate([
klass('JS.test.CircleTest')
], CircleTest);
test.CircleTest = CircleTest;
})(test = JS.test || (JS.test = {}));
})(JS || (JS = {}));
var JS;
(function (JS) {
let test;
(function (test) {
let FloatsTest = class FloatsTest extends TestCase {
test1() {
Assert.true(Floats.equal(Number(0.0001), Number(0.0002)));
Assert.true(Floats.equal(Number(0.0001), Number(0.00012)));
Assert.false(Floats.equal(Number(0.0001), Number(0.0003)));
Assert.false(Floats.equal(Number(0.001), Number(0.002)));
}
test2() {
Floats.EQUAL_PRECISION = 0.01;
Assert.true(Floats.equal(Number(0.0001), Number(0.0002)));
Assert.false(Floats.equal(Number(0.1), Number(0.2)));
Floats.EQUAL_PRECISION = 0.00001;
Assert.false(Floats.equal(Number(0.0001), Number(0.0002)));
Assert.false(Floats.equal(Number(0.1), Number(0.2)));
}
test3() {
Assert.true(Floats.equal(Number(0.0001), Number(0.0002), 0.01));
Assert.false(Floats.equal(Number(0.1), Number(0.2), 0.01));
Assert.false(Floats.equal(Number(0.0001), Number(0.0002), 0.00001));
Assert.false(Floats.equal(Number(0.1), Number(0.2), 0.00001));
}
test4() {
Floats.EQUAL_PRECISION = 0.0001;
Assert.true(Floats.greaterEqual(Number(0.0001), Number(0.0002)));
Assert.false(Floats.greater(Number(0.0001), Number(0.0002)));
Assert.true(Floats.greater(Number(0.0003), Number(0.0001)));
}
test5() {
Assert.true(Floats.lessEqual(Number(0.0001), Number(0.0002)));
Assert.false(Floats.less(Number(0.0001), Number(0.0002)));
Assert.true(Floats.less(Number(0.0001), Number(0.0003)));
}
};
FloatsTest = __decorate([
klass('JS.test.FloatsTest')
], FloatsTest);
test.FloatsTest = FloatsTest;
})(test = JS.test || (JS.test = {}));
})(JS || (JS = {}));
var JS;
(function (JS) {
let test;
(function (test) {
let LineTest = class LineTest extends TestCase {
constructor() {
super(...arguments);
this.p1 = [1, 1];
this.p2 = [-1, 1];
this.p3 = [-1, -1];
this.p4 = [1, -1];
}
test1() {
Assert.equal(-1, Line.position(this.p1, this.p2, [0, 0], [1, 0]));
Assert.equal(-1, Line.position(this.p1, this.p4, [0, 0], [0, 1]));
Assert.equal(-1, Line.position(this.p2, this.p4, [1, 0], [0, 1]));
Assert.equal(0, Line.position(this.p1, this.p2, this.p2, [0, 1]));
Assert.equal(0, Line.position(this.p1, this.p4, this.p1, [1, 0]));
Assert.equal(0, Line.position(this.p2, this.p4, [0, 0], this.p2));
Assert.equal(1, Line.position(this.p1, this.p3, Line.Y.p1(), Line.Y.p2()));
Assert.equal(1, Line.position(this.p2, this.p4, Line.X.p1(), Line.X.p2()));
Assert.equal(2, Line.position(Line.X.p1(), Line.X.p2(), Line.Y.p1(), Line.Y.p2()));
Assert.equal(2, Line.position(Line.Y.p1(), Line.Y.p2(), Line.X.p1(), Line.X.p2()));
Assert.equal(2, Line.position(this.p1, this.p3, this.p2, this.p4));
}
test2() {
Assert.true(Point2.equal([1, 0], Line.X.crossPoint(this.p1)));
Assert.true(Point2.equal([1, 0], Line.X.crossPoint(this.p4)));
Assert.true(Point2.equal([0, 1], Line.Y.crossPoint(this.p1)));
Assert.true(Point2.equal([0, 1], Line.Y.crossPoint(this.p2)));
Assert.true(Point2.equal([0, 0], Line.toLine(this.p2, this.p4).crossPoint(this.p1)));
Assert.true(Point2.equal([1, 1], Line.toLine([2, 0], [0, 2]).crossPoint([0, 0])));
Assert.true(Point2.equal([-1, 0], Line.X.crossPoint([-1, 0])));
Assert.true(Point2.equal([0, 0], Line.X.crossPoint([0, 0])));
}
test3() {
Assert.true(Point2.equal([0, 0], Line.toLine(this.p1, this.p3).crossLine(Line.toLine(this.p2, this.p4))));
Assert.true(Point2.equal([0, 0], Line.toLine(this.p1, this.p3).crossLine(Line.toLine(this.p4, this.p2))));
Assert.true(Point2.equal([0, 0], Line.toLine(this.p3, this.p1).crossLine(Line.toLine(this.p2, this.p4))));
Assert.true(Point2.equal([0, 0], Line.toLine(this.p3, this.p1).crossLine(Line.toLine(this.p4, this.p2))));
Assert.true(Point2.equal([0, 0], Line.X.crossLine(Line.Y)));
Assert.true(Point2.equal([1, 0], Line.X.crossLine(Line.toLine(this.p1, this.p4))));
Assert.true(Point2.equal([0, 1], Line.Y.crossLine(Line.toLine(this.p1, this.p2))));
}
test4() {
Assert.true(Point2.equal([0, 0], Line.toLine(this.p1, this.p3).crossRay(this.p4, 0.75 * Math.PI)));
Assert.true(Point2.equal([0, 0], Line.toLine(this.p1, this.p3).crossRay(this.p2, 1.75 * Math.PI)));
Assert.true(Point2.equal(null, Line.toLine(this.p1, this.p3).crossRay(this.p4, 1.75 * Math.PI)));
Assert.true(Point2.equal(null, Line.toLine(this.p1, this.p3).crossRay(this.p2, 0.75 * Math.PI)));
Assert.true(Point2.equal([0, 0], Line.toLine(this.p1, this.p3).crossRay([0, 1], 1.5 * Math.PI)));
}
test5() {
let line = new Line().set(this.p2, this.p4), p = this.p1, cp = line.crossPoint(p);
Assert.true(Floats.equal(Point2.distanceSq(cp[0], cp[1], p[0], p[1]), Line.distanceSqToPoint(line.p1(), line.p2(), p)));
line = new Line().set([-2, 0], [0, 2]);
p = [0, 0];
cp = line.crossPoint(p);
Assert.true(Floats.equal(Point2.distanceSq(cp[0], cp[1], p[0], p[1]), Line.distanceSqToPoint(line.p1(), line.p2(), p)));
line = new Line().set([3.14, 1.78], [-5.82, -6.71]);
p = [1, 1];
cp = line.crossPoint(p);
Assert.true(Floats.equal(Point2.distanceSq(cp[0], cp[1], p[0], p[1]), Line.distanceSqToPoint(line.p1(), line.p2(), p)));
}
test6() {
let line = new Line().set(this.p2, this.p4);
Assert.true(line.inside(this.p2));
Assert.true(line.inside(this.p4));
Assert.true(line.inside([0, 0]));
Assert.true(line.inside([-1.5678, 1.5678]));
Assert.true(line.inside(new Segment().set([-4.5678, 4.5678], [6.5678, -6.5678])));
Assert.false(line.inside(new Segment()));
}
test7() {
let line1 = new Line().set(this.p2, this.p4), line2 = new Line().set([-1, 0], [0, 0]), line3 = new Line().set([0, 0], [1, 0]);
Assert.true(line1.intersects(Line.X));
Assert.true(line1.intersects(Line.Y));
Assert.true(line1.intersects(line2));
Assert.true(line1.intersects(line3));
Assert.true(line1.intersects(new Line().set(this.p1, this.p3)));
Assert.true(line2.intersects(Line.X));
Assert.false(line2.intersects(new Line().set(this.p2, this.p1)));
Assert.false(Line.X.intersects(new Line().set(this.p2, this.p1)));
Assert.false(line2.intersects(new Segment().set(this.p2, this.p1)));
Assert.false(Line.X.intersects(new Segment().set(this.p2, this.p1)));
Assert.false(line1.intersects(new Segment().set([0, 1], [1, 0])));
Assert.false(new Segment().intersects(new Segment().set([0, 1], [1, 0])));
Assert.true(line1.intersects(line2.toSegment()));
Assert.true(line1.intersects(line3.toSegment()));
Assert.true(line1.intersects(new Segment().set([-1, 0], [1, 0])));
Assert.false(line1.intersects(new Line()));
Assert.false(line1.intersects(new Segment()));
}
};
LineTest = __decorate([
klass('JS.test.LineTest')
], LineTest);
test.LineTest = LineTest;
})(test = JS.test || (JS.test = {}));
})(JS || (JS = {}));
var JS;
(function (JS) {
let test;
(function (test) {
let PointTest = class PointTest extends TestCase {
test1() {
let pp = Point2.xy2polar(1, 1);
Assert.true(Point2.equal([1, 1], Point2.polar2xy(pp.d, pp.a)));
}
test2() {
Assert.true(Point2.isOrigin(0.0001, -0.0001));
}
test3() {
Assert.equal(0, Point2.radian(0.0001, -0.0001));
Assert.true(Radians.equal(Radians.deg2rad(90 + 45), Point2.radian(-1, 1)));
}
test4() {
Assert.true(Floats.equal(1.4142, Point2.distance(0, 0, 1, 1)));
Assert.true(Floats.equal(2, Point2.distanceSq(0, 0, 1, 1)));
Assert.true(Floats.equal(2, Point2.distance(-1, 1, 1, 1)));
Assert.true(Floats.equal(4, Point2.distanceSq(-1, 1, 1, 1)));
Assert.true(Floats.equal(1.4142, Point2.distance(1, 0, 0, 1)));
Assert.true(Floats.equal(2, Point2.distanceSq(1, 0, 0, 1)));
}
test5() {
Assert.true(Point2.equal([3, 0], new Point2(0, 0).toward(3, Radians.EAST).toArray()));
Assert.true(Point2.equal([0, 0], new Point2(1, 1).toward(1.4142, 1.25 * Math.PI).toArray()));
Assert.true(Point2.equal([-1, -1], new Point2(0, 0).toward(1.4142, 1.25 * Math.PI).toArray()));
Assert.true(Point2.equal([-1, 1], new Point2(1, -1).toward(2.8284, .75 * Math.PI).toArray()));
}
};
PointTest = __decorate([
klass('JS.test.PointTest')
], PointTest);
test.PointTest = PointTest;
})(test = JS.test || (JS.test = {}));
})(JS || (JS = {}));
var JS;
(function (JS) {
let test;
(function (test) {
let PolygonTest = class PolygonTest extends TestCase {
constructor() {
super(...arguments);
this.p0 = new Polygon().addPoint(-1, 1).addPoint(-1, 0).addPoint(1, 0).addPoint(1, -1).addPoint(0, -1).addPoint(0, 1);
}
test1() {
Assert.false(this.p0.equals(new Polygon));
Assert.true(this.p0.equals(this.p0.clone()));
Assert.true(this.p0.bounds().equals(new Rect(-1, -1, 2, 2)));
Assert.equal(8, this.p0.perimeter());
}
test2() {
let p1 = new Polygon();
Assert.true(p1.bounds().equals(new Rect()));
p1.addPoint(-1, 1).addPoint(-1, 0).addPoint(1, 0);
Assert.true(p1.bounds().equals(new Rect(-1, 0, 2, 1)));
Assert.true(p1.addPoint(1, -1).bounds().equals(new Rect(-1, -1, 2, 2)));
Assert.true(p1.addPoint(0, -1).bounds().equals(new Rect(-1, -1, 2, 2)));
Assert.true(p1.addPoint(0, 1).bounds().equals(new Rect(-1, -1, 2, 2)));
Assert.true(p1.addPoint(1, 2).bounds().equals(new Rect(-1, -1, 2, 3)));
}
test3() {
Assert.true(this.p0.onside([0, 0]));
Assert.true(this.p0.onside([0.5, 0]));
Assert.true(this.p0.onside([-0.5, 1]));
Assert.false(this.p0.onside([-1, -1]));
Assert.false(this.p0.onside([-0.5, 0.5]));
Assert.false(this.p0.onside([1, 1]));
}
test4() {
Assert.false(this.p0.inside([0, 0]));
Assert.false(this.p0.inside([-1, 1]));
Assert.false(this.p0.inside([1, 1]));
Assert.true(this.p0.inside([-.5, .5]));
Assert.true(this.p0.inside([.5, -.5]));
let p = this.p0.clone().addPoint(1, 2).addPoint(1, 1);
Assert.true(p.onside([.5, 1.5]));
Assert.false(p.inside([.5, 1.5]));
Assert.true(p.inside([.5, 1.49]));
Assert.true(p.inside([.5, 1.25]));
}
};
PolygonTest = __decorate([
klass('JS.test.PolygonTest')
], PolygonTest);
test.PolygonTest = PolygonTest;
})(test = JS.test || (JS.test = {}));
})(JS || (JS = {}));
var JS;
(function (JS) {
let test;
(function (test) {
let RadiansTest = class RadiansTest extends TestCase {
test1() {
Assert.true(Radians.equal((3.5 * Math.PI) % (2 * Math.PI), Radians.NORTH));
Assert.true(Radians.equal(Radians.deg2rad(45), 0.25 * Math.PI));
Assert.true(Radians.equal(Radians.deg2rad(360 + 45), 0.25 * Math.PI + 2 * Math.PI));
Assert.true(Radians.equal(Radians.rad2deg(Radians.SOUTH), 90));
Assert.true(Radians.equal(Radians.reverse(Radians.EAST), Radians.WEST));
Assert.true(Radians.equal(Radians.reverse(Radians.SOUTH), Radians.NORTH));
let rad = Radians.deg2rad(75);
Assert.equal(Radians.reverse(rad) - rad, Math.PI);
}
};
RadiansTest = __decorate([
klass('JS.test.RadiansTest')
], RadiansTest);
test.RadiansTest = RadiansTest;
})(test = JS.test || (JS.test = {}));
})(JS || (JS = {}));
var JS;
(function (JS) {
let test;
(function (test) {
let RectTest = class RectTest extends TestCase {
constructor() {
super(...arguments);
this.rect1 = new Rect(-1, -1, 2, 2);
this.rect2 = new Rect(-1, -1, 1, 1);
this.rect3 = new Rect(0, 0, 1, 1);
}
test1() {
Assert.true(this.rect1.equals(this.rect1.clone()));
Assert.true(this.rect1.equals(new Rect().set(-1, -1, 2, 2)));
Assert.false(this.rect1.equals(new Rect().set(-1, -1, 1, 2)));
}
test2() {
Assert.true(this.rect1.equals(this.rect2.union(this.rect3)));
}
test3() {
Assert.true(this.rect1.inside([0, 0]));
Assert.false(this.rect1.inside([-1, -1]));
Assert.false(this.rect1.inside([1, 1]));
Assert.false(this.rect1.inside([1.1, 1.0]));
Assert.true(this.rect1.onside([-1, -1]));
Assert.true(this.rect1.onside([1, 1]));
Assert.true(this.rect1.inside(this.rect2));
Assert.true(this.rect1.inside(this.rect3));
Assert.false(this.rect1.inside(new Rect()));
Assert.false(this.rect2.inside(this.rect1));
Assert.false(this.rect2.inside(this.rect3));
Assert.true(this.rect2.inside(this.rect2));
Assert.false(this.rect3.inside(this.rect1));
Assert.false(this.rect3.inside(this.rect2));
Assert.true(this.rect3.inside(this.rect3));
Assert.true(this.rect2.onside([0, 0]));
Assert.true(this.rect3.onside([0, 0]));
}
test4() {
Assert.false(this.rect2.intersects(this.rect3));
Assert.equal(null, this.rect2.intersection(this.rect3));
Assert.true(this.rect1.intersection(this.rect2).equals(this.rect2));
Assert.true(this.rect1.intersection(this.rect3).equals(this.rect3));
Assert.false(Rect.toRect([0, -1], 1, 1).intersects(new Segment(1, 0, 0, 1)));
Assert.false(Rect.toRect([0, -1], 1, 1).intersects(new Segment(0, 0, 1, 0)));
}
};
RectTest = __decorate([
klass('JS.test.RectTest')
], RectTest);
test.RectTest = RectTest;
})(test = JS.test || (JS.test = {}));
})(JS || (JS = {}));
var JS;
(function (JS) {
let test;
(function (test) {
let SegmentTest = class SegmentTest extends TestCase {
constructor() {
super(...arguments);
this.p1 = [1, 1];
this.p2 = [-1, 1];
this.p3 = [-1, -1];
this.p4 = [1, -1];
}
test1() {
let sx = Line.X.toSegment(), sy = Line.Y.toSegment();
Assert.true(Point2.equal([0, 0], sx.crossSegment(sy)));
let s0 = new Segment().set([-1, 0], [1, 0]);
Assert.false(Point2.equal([0, 0], sx.crossSegment(s0)));
let s1 = Segment.toSegment(this.p1, this.p3), s2 = Segment.toSegment(this.p2, this.p4);
Assert.true(Point2.equal([0, 0], s1.crossSegment(s2)));
let s3 = Segment.toSegment([1, -1], [2, -2]);
Assert.false(Point2.equal([0, 0], s1.crossSegment(s3)));
}
test2() {
Assert.true(Point2.equal([0, 0], Segment.toSegment(this.p1, this.p3).crossLine(Line.toLine(this.p2, this.p4))));
Assert.true(Point2.equal([0, 0], Segment.toSegment(this.p1, this.p3).crossLine(Line.toLine(this.p4, this.p2))));
Assert.true(Point2.equal([0, 0], Segment.toSegment(this.p3, this.p1).crossLine(Line.toLine(this.p2, this.p4))));
Assert.true(Point2.equal([0, 0], Segment.toSegment(this.p3, this.p1).crossLine(Line.toLine(this.p4, this.p2))));
let s1 = Segment.toSegment([1, 0], [2, 0]), s2 = Segment.toSegment([-1, 0], [2, 0]);
Assert.false(Point2.equal([0, 0], s1.crossLine(Line.Y)));
Assert.true(Point2.equal([1, 0], s2.crossLine(Line.toLine(this.p1, this.p4))));
}
test3() {
Assert.true(Point2.equal([0, 0], Segment.toSegment(this.p1, this.p3).crossRay(this.p4, 0.75 * Math.PI)));
Assert.true(Point2.equal([0, 0], Segment.toSegment(this.p1, this.p3).crossRay(this.p2, 1.75 * Math.PI)));
Assert.true(Point2.equal(null, Segment.toSegment(this.p1, this.p3).crossRay(this.p4, 1.75 * Math.PI)));
Assert.true(Point2.equal(null, Segment.toSegment(this.p1, this.p3).crossRay(this.p2, 0.75 * Math.PI)));
Assert.true(Point2.equal([0, 0], Segment.toSegment(this.p1, this.p3).crossRay([0, 1], 1.5 * Math.PI)));
Assert.true(Point2.equal(null, Segment.toSegment(this.p1, [0.1, 0.1]).crossRay(this.p4, 0.75 * Math.PI)));
}
test4() {
let line = new Segment().set(this.p2, this.p4), p = this.p1, cp = line.crossPoint(p);
Assert.true(Floats.equal(Point2.distanceSq(cp[0], cp[1], p[0], p[1]), Segment.distanceSqToPoint(line.p1(), line.p2(), p)));
line = new Segment().set([-2, 0], [0, 2]);
p = [0, 0];
cp = line.crossPoint(p);
Assert.true(Floats.equal(Point2.distanceSq(cp[0], cp[1], p[0], p[1]), Segment.distanceSqToPoint(line.p1(), line.p2(), p)));
line = new Segment().set([3.14, 1.78], [-5.82, -6.71]);
p = [1, 1];
cp = line.crossPoint(p);
Assert.true(Floats.equal(Point2.distanceSq(cp[0], cp[1], p[0], p[1]), Segment.distanceSqToPoint(line.p1(), line.p2(), p)));
}
test5() {
let line = new Segment().set(this.p2, this.p4);
Assert.true(line.inside(this.p2));
Assert.true(line.inside(this.p4));
Assert.true(line.inside([0, 0]));
Assert.false(line.inside([-1.5678, 1.5678]));
Assert.false(line.inside(new Segment().set([-4.5678, 4.5678], [-2.5678, 2.5678])));
Assert.false(line.inside(new Segment().set([-4.5678, 4.5678], [-0.5678, 0.5678])));
Assert.true(line.inside(new Segment().set([-0.9, 0.9], [-0.5678, 0.5678])));
Assert.false(line.inside(new Segment()));
}
test6() {
let line1 = new Segment().set(this.p2, this.p4), line2 = new Segment().set([-1, 0], [0, 0]), line3 = new Segment().set([0, 0], [1, 0]);
Assert.true(line1.intersects(Line.X));
Assert.true(line1.intersects(Line.Y));
Assert.true(line1.intersects(line2));
Assert.true(line1.intersects(line3));
Assert.true(line1.intersects(new Line().set(this.p1, this.p3)));
Assert.true(line2.intersects(Line.X));
Assert.false(line2.intersects(new Line().set(this.p2, this.p1)));
Assert.false(Line.X.intersects(new Line().set(this.p2, this.p1)));
Assert.false(line2.intersects(new Segment().set(this.p2, this.p1)));
Assert.false(Line.X.intersects(new Segment().set(this.p2, this.p1)));
Assert.false(line1.intersects(new Segment().set([0, 1], [1, 0])));
Assert.false(new Segment().intersects(new Segment().set([0, 1], [1, 0])));
Assert.true(line1.intersects(line2.toSegment()));
Assert.true(line1.intersects(line3.toSegment()));
Assert.false(line1.intersects(new Segment().set([0.1, 0], [1, 0])));
Assert.false(line1.intersects(new Line()));
Assert.false(line1.intersects(new Segment()));
}
};
SegmentTest = __decorate([
klass('JS.test.SegmentTest')
], SegmentTest);
test.SegmentTest = SegmentTest;
})(test = JS.test || (JS.test = {}));
})(JS || (JS = {}));
var JS;
(function (JS) {
let test;
(function (test) {
let TriangleTest = class TriangleTest extends TestCase {
constructor() {
super(...arguments);
this.p1 = [1, 0];
this.p2 = [0, 1];
this.p3 = [-1, 0];
this.p4 = [0, -1];
}
test1() {
Assert.true(new Triangle().equals(new Triangle()));
Assert.true(Triangle.toTri(this.p1, this.p2, this.p3).equals(new Triangle().set(this.p3, this.p2, this.p1)));
Assert.true(Triangle.toTri(this.p1, this.p2, this.p3).equals(new Triangle().set(this.p1, this.p3, this.p2)));
}
test2() {
Assert.true(Triangle.toTri(this.p1, this.p2, [0, 0]).bounds().equals(Rect.toRect([0, 0], 1, 1)));
Assert.true(Triangle.toTri(this.p1, this.p2, this.p3).bounds().equals(Rect.toRect([-1, 0], 2, 1)));
}
test3() {
Assert.true(Triangle.toTri(this.p1, this.p2, [0, 0]).onside([0, 0]));
Assert.true(Triangle.toTri(this.p1, this.p2, [0, 0]).onside([0.5, 0.5]));
Assert.true(Triangle.toTri(this.p1, this.p2, [0, 0]).inside([0.49, 0.49]));
Assert.false(Triangle.toTri(this.p1, this.p2, [0, 0]).onside([0.49, 0.49]));
Assert.true(Triangle.toTri(this.p1, this.p2, this.p3).onside([0, 0]));
Assert.true(Triangle.toTri(this.p1, this.p2, this.p3).onside([-0.5, 0]));
Assert.true(Triangle.toTri(this.p1, this.p2, this.p3).inside([-0.4, 0.2]));
Assert.false(Triangle.toTri(this.p1, this.p2, this.p3).onside([-0.4, 0.2]));
}
test4() {
let tri = Triangle.toTri(this.p1, this.p2, [0, 0]);
Assert.false(tri.intersects(Rect.toRect([0, -1], 1, 1)));
Assert.false(tri.intersects(Rect.toRect([1, 0], 1, 1)));
Assert.true(tri.intersects(Rect.toRect([0.5, 0], 1, 1)));
Assert.true(tri.intersects(tri.bounds()));
Assert.true(tri.intersects(Rect.toRect([0, 0], 0.5, 0.5)));
Assert.false(tri.intersects(Line.toLine([1, 0], [0, 1])));
Assert.false(tri.intersects(Line.X));
Assert.false(tri.intersects(Line.Y));
Assert.false(tri.intersects(Line.toLine([1, 0], [2, 0])));
Assert.true(tri.intersects(Line.toLine([0.5, 0], [0, 1])));
Assert.true(tri.intersects(Line.toLine([0.5, 0], [0.5, 1])));
Assert.false(tri.intersects(Segment.toSegment([1, 0], [0, 1])));
Assert.false(tri.intersects(Segment.toSegment([1, 0], [0, 0])));
Assert.false(tri.intersects(Segment.toSegment([0, 1], [0, 0])));
Assert.false(tri.intersects(Segment.toSegment([1, 0], [2, 0])));
Assert.true(tri.intersects(Segment.toSegment([0.5, 0], [0, 1])));
Assert.true(tri.intersects(Segment.toSegment([0.5, 0], [0.5, 1])));
Assert.false(tri.intersects(Segment.toSegment([1, -1], [-1, 1])));
}
};
TriangleTest = __decorate([
klass('JS.test.TriangleTest')
], TriangleTest);
test.TriangleTest = TriangleTest;
})(test = JS.test || (JS.test = {}));
})(JS || (JS = {}));
var JS;
(function (JS) {
let test;
(function (test) {
let Vector2Test = class Vector2Test extends TestCase {
test1() {
let v1 = Vector2.toVector([1, 1], [0, 0]), v2 = Vector2.toVector([2, 2], [1, 1]);
Assert.true(v1.equals(v2));
}
test2() {
let v1 = Vector2.toVector([1, 1], [2, 2]), v2 = Vector2.toVector([2, 2], [1, 1]);
Assert.true(v1.equals(v2.negate()));
}
test3() {
let v1 = Vector2.toVector([1, 0], [2.5, 0]);
Assert.true(v1.normalize().equals(Vector2.UnitX));
let v2 = Vector2.toVector([0, 0.25], [0, 0.375]);
Assert.true(v2.normalize().equals(Vector2.UnitY));
}
test4() {
let v1 = Vector2.toVector([0, 0], [1, 1]);
Assert.true(Radians.equal(0.25 * Math.PI, v1.radian()));
Assert.true(Radians.equal(0.25 * Math.PI, v1.angle(Vector2.UnitY)));
let v2 = Vector2.toVector([0, 0], [-1, 1]);
Assert.true(Radians.equal(0.75 * Math.PI, v2.radian()));
Assert.true(Radians.equal(0.25 * Math.PI, v2.angle(Vector2.UnitY)));
}
test5() {
Assert.true(Vector2.UnitY.verticalTo(Vector2.UnitX));
Assert.true(Vector2.UnitX.verticalTo(Vector2.UnitY));
let v1 = Vector2.toVector([1.2, 1.34], [1.2, 2.75]);
Assert.true(v1.verticalTo(Vector2.UnitX));
Assert.true(v1.parallelTo(Vector2.UnitY));
Assert.true(v1.negate().parallelTo(Vector2.UnitY));
}
test6() {
Assert.true(Vector2.UnitY.clone().getNormL().normalize().equals(Vector2.UnitX));
Assert.true(Vector2.UnitX.clone().getNormR().normalize().equals(Vector2.UnitY));
let v1 = Vector2.toVector([0, 0], [1, 1]), v2 = Vector2.toVector([0, 0], [-1, 1]), v3 = Vector2.toVector([0, 0], [1, -1]);
Assert.true(v1.getNormR().normalize().equals(v2.normalize()));
Assert.true(v1.getNormL().normalize().equals(v3.normalize()));
}
test7() {
let v1 = Vector2.toVector([0, 0], [1, 1]), v2 = Vector2.toVector([0, 0], [-1, 1]), v3 = Vector2.toVector([0, 0], [1, -1]);
Assert.true(v1.getProject(Vector2.UnitY).equals(Vector2.UnitY));
Assert.true(v2.getProject(v3).equals(v2));
Assert.true(v2.getProject(Vector2.Zero).equals(Vector2.Zero));
Assert.true(v2.getProject(Vector2.UnitX).equals(Vector2.UnitX.clone().negate()));
}
test8() {
let v1 = Vector2.toVector([1, 1], [0, 0]), v2 = Vector2.toVector([0, 0], [-1, 1]), v3 = Vector2.toVector([0, 0], [1, -1]);
Assert.true(v1.getReboundR(Vector2.UnitY.clone().negate()).equals(v2));
Assert.true(v1.getReboundL(Vector2.UnitX.clone()).equals(v3));
Assert.true(v2.clone().negate().getReboundL(Vector2.UnitY).equals(v1.clone().negate()));
Assert.true(v3.clone().negate().getReboundR(Vector2.UnitX).equals(v1.clone().negate()));
}
test9() {
let p1 = [1, 1], p2 = [-1, -1];
Assert.equal(1, Vector2.whichSide(Line.X.p1(), Line.X.p2(), p1));
Assert.equal(-1, Vector2.whichSide(Line.X.p1(), Line.X.p2(), p2));
Assert.equal(-1, Vector2.whichSide(p1, p2, [-1, 1]));
Assert.equal(1, Vector2.whichSide(p1, p2, [1, -1]));
Assert.equal(0, Vector2.whichSide(p1, p2, [0, 0]));
}
};
Vector2Test = __decorate([
klass('JS.test.Vector2Test')
], Vector2Test);
test.Vector2Test = Vector2Test;
})(test = JS.test || (JS.test = {}));
})(JS || (JS = {}));
let Person = class Person extends Model {
};
Person.DEFAULT_FIELDS = [
{ name: 'code', isId: true },
{ name: 'name' },
{ name: 'age' },
{ name: 'birthday' },
{ name: 'data' }
];
Person = __decorate([
klass('Person')
], Person);
var JS;
(function (JS) {
let test;
(function (test) {
let ModelTest = class ModelTest extends TestCase {
setUp() {
this.person = new Person();
}
test1() {
Assert.true(this.person.isEmpty());
this.person.set('code', 1001);
this.person.set('name', 'Bill');
this.person.set('data', { a: 1 });
Assert.false(this.person.isEmpty());
Assert.equal(1001, this.person.get('code'));
Assert.equal('Bill', this.person.get('name'));
Assert.equal(1, this.person.get('data')['a']);
Assert.equal(1001, this.person.getId());
Assert.equal(5, Jsons.values(this.person.getFields()).length);
Assert.equal(null, this.person.get('age'));
Assert.true(this.person.hasField('age'));
Assert.false(this.person.hasField('time'));
this.person.clear();
Assert.true(this.person.isEmpty());
}
test2() {
Assert.equal(5, Jsons.values(this.person.getFields()).length);
this.person.removeField('age');
Assert.equal(4, Jsons.values(this.person.getFields()).length);
Assert.false(this.person.hasField('age'));
Assert.equal(undefined, this.person.get('age'));
this.person.addField('age');
Assert.equal(5, Jsons.values(this.person.getFields()).length);
Assert.true(this.person.hasField('age'));
Assert.equal(null, this.person.get('age'));
}
test3() {
this.person.set('code', 1001);
this.person.set('name', 'Bill');
this.person.set('data', { a: 1 });
Assert.false(this.person.isEmpty());
let cln = this.person.clone();
Assert.false(cln.isEmpty());
Assert.equal('Bill', cln.get('name'));
}
test4() {
this.person.set('code', 1001);
Assert.equal(1001, this.person.getData()['code']);
Assert.true(Check.isEmpty(this.person.iniData()));
this.person.iniData({
'code': 2001
});
Assert.equal(1001, this.person.getData()['code']);
Assert.equal(2001, this.person.iniData()['code']);
this.person.reset();
Assert.equal(2001, this.person.getData()['code']);
this.person.clear();
Assert.true(this.person.isEmpty());
Assert.false(Check.isEmpty(this.person.iniData()));
}
test5() {
Assert.true(this.person.isEmpty());
this.person.destroy();
Assert.equalError(JSError, () => {
this.person.set('code', 1002);
});
}
test6() {
this.person.updateField({
name: 'birthday',
setter: function (val) {
return new Date(val).setZeroTime().add(1, 'd').format();
}
});
this.person.set('birthday', new Date().format());
Assert.equal(new Date().setZeroTime().add(1, 'd').format(), this.person.get('birthday'));
}
test7() {
this.person.updateField({
name: 'data',
nameMapping: '_data'
});
this.person.setData({
_data: [1, 2, 3]
});
Assert.equal([1, 2, 3], this.person.get('data'));
}
};
ModelTest = __decorate([
klass('JS.test.ModelTest')
], ModelTest);
test.ModelTest = ModelTest;
})(test = JS.test || (JS.test = {}));
})(JS || (JS = {}));
let ListPerson = class ListPerson extends Model {
};
ListPerson.DEFAULT_FIELDS = [
{ name: 'id', type: 'int' },
{ name: 'name', nameMapping: 'field1', type: 'string' },
{ name: 'age', nameMapping: 'field2', type: 'float', defaultValue: 99.99 }
];
ListPerson = __decorate([
klass('ListPerson')
], ListPerson);
var JS;
(function (JS) {
let test;
(function (test) {
let ListModelTest = class ListModelTest extends TestCase {
setUp() {
this.persons = new ListModel().modelKlass(Person);
}
test1() {
this.persons.add({ code: 1001, name: 'Arthur' });
this.persons.add(new Person().setData({ code: 2001, name: 'Bill' }));
Assert.equal(2, this.persons.size());
this.persons.add([
{ code: 3001, name: 'Smith' },
{ code: 4001, name: 'David' }
]);
Assert.equal(4, this.persons.size());
Assert.equal('David', this.persons.getRowModel(3).get('name'));
}
test2() {
this.persons.insert(0, { code: 1001, name: 'Arthur' });
Assert.equal(1, this.persons.size());
this.persons.insert(0, [
{ code: 3001, name: 'Smith' },
{ code: 4001, name: 'David' }
]);
Assert.equal(3, this.persons.size());
Assert.equal('Smith', this.persons.getRow(0)['name']);
Assert.equal('David', this.persons.getRowModel(1).get('name'));
}
test3() {
this.persons.insert(1, [
{ code: 3001, name: 'Smith' },
{ code: 4001, name: 'David' },
{ code: 5001, name: 'Xman' },
{ code: 6001, name: 'Zoro' }
]);
Assert.equal(2, this.persons.indexOfId(5001));
this.persons.clear();
Assert.equal(0, this.persons.size());
Assert.true(this.persons.isEmpty());
}
test4() {
this.persons.insert(0, [
{ code: 3001, name: 'Smith' },
{ code: 4001, name: 'David' },
{ code: 5001, name: 'Xman' },
{ code: 6001, name: 'Zoro' }
]);
this.persons.removeAt(0);
Assert.equal(3, this.persons.size());
Assert.equal('David', this.persons.getRowModel(0).get('name'));
this.persons.removeAt(1);
Assert.equal(2, this.persons.size());
Assert.equal('David', this.persons.getRowModel(0).get('name'));
this.persons.insert(0, [
{ code: 3001, name: 'Smith' }
]);
Assert.equal(3, this.persons.size());
Assert.equal('Smith', this.persons.getRowModel(0).get('name'));
Assert.equal('David', this.persons.getRowModel(1).get('name'));
Assert.equal('Zoro', this.persons.getRowModel(2).get('name'));
}
test5() {
this.persons.iniData([
{ code: 3001, name: 'Smith' },
{ code: 4001, name: 'David' },
{ code: 5001, name: 'Xman' },
{ code: 6001, name: 'Zoro' }
]);
Assert.equal(4, this.persons.iniData().length);
Assert.equal(0, this.persons.size());
this.persons.setData([
{ code: 3001, name: 'Smith' },
{ code: 4001, name: 'David' }
]);
Assert.equal(2, this.persons.getData().length);
Assert.equal(2, this.persons.size());
this.persons.reset();
Assert.equal(4, this.persons.getData().length);
Assert.equal(4, this.persons.size());
this.persons.clear();
Assert.equal(null, this.persons.getData());
Assert.equal(4, this.persons.iniData().length);
}
test6() {
let persons = new ListModel().modelKlass(ListPerson);
persons.load('test-data/persons-list.json').then((result) => {
Assert.equal(3, result.count());
Assert.equal('Smith', persons.getRowModel(2).get('name'));
});
}
test7() {
let persons = new ListModel({
sorters: [{
field: 'gmtCreated'
}, {
field: 'name',
dir: 'asc'
}]
}).modelKlass(ListPerson);
persons.addSorter('name', 'desc');
persons.load('test-data/persons-li