353 lines
9.0 KiB
TypeScript
353 lines
9.0 KiB
TypeScript
/// <reference path="./refs/globals.ts"/>
|
|
/// <reference path="./helper/util.ts"/>
|
|
/// <reference path="../src/core/Rectangle.ts"/>
|
|
|
|
var assert = require('assert').strict;
|
|
|
|
interface ExpectedRectangle {
|
|
x1?: number,
|
|
x2?: number,
|
|
width?: number,
|
|
|
|
y1?: number,
|
|
y2?: number,
|
|
height?: number,
|
|
|
|
area?: number,
|
|
|
|
// rounded versions
|
|
|
|
rx1?: number,
|
|
rx2?: number,
|
|
rwidth?: number,
|
|
|
|
ry1?: number,
|
|
ry2?: number,
|
|
rheight?: number,
|
|
|
|
rarea?: number,
|
|
|
|
eps: number,
|
|
}
|
|
|
|
function assertRectangle(actual: cool.Rectangle, expected: ExpectedRectangle) {
|
|
|
|
// x-coordinate
|
|
|
|
if (expected.x1 !== undefined)
|
|
assertFloat(actual.getX1(), expected.x1, expected.eps, 'Wrong x1');
|
|
if (expected.x2 !== undefined)
|
|
assertFloat(actual.getX2(), expected.x2, expected.eps, 'Wrong x2');
|
|
if (expected.width !== undefined)
|
|
assertFloat(actual.getWidth(), expected.width, expected.eps, 'Wrong width');
|
|
|
|
if (expected.rx1 !== undefined)
|
|
assertFloat(actual.getPxX1(), expected.rx1, expected.eps, 'Wrong rounded x1');
|
|
if (expected.rx2 !== undefined)
|
|
assertFloat(actual.getPxX2(), expected.rx2, expected.eps, 'Wrong rounded x2');
|
|
if (expected.rwidth !== undefined)
|
|
assertFloat(actual.getPxWidth(), expected.rwidth, expected.eps, 'Wrong rounded width');
|
|
|
|
// y-coordinate
|
|
|
|
if (expected.y1 !== undefined)
|
|
assertFloat(actual.getY1(), expected.y1, expected.eps, 'Wrong y1');
|
|
if (expected.y2 !== undefined)
|
|
assertFloat(actual.getY2(), expected.y2, expected.eps, 'Wrong y2');
|
|
if (expected.height !== undefined)
|
|
assertFloat(actual.getHeight(), expected.height, expected.eps, 'Wrong height');
|
|
|
|
if (expected.ry1 !== undefined)
|
|
assertFloat(actual.getPxY1(), expected.ry1, expected.eps, 'Wrong rounded y1');
|
|
if (expected.ry2 !== undefined)
|
|
assertFloat(actual.getPxY2(), expected.ry2, expected.eps, 'Wrong rounded y2');
|
|
if (expected.rheight !== undefined)
|
|
assertFloat(actual.getPxHeight(), expected.rheight, expected.eps, 'Wrong rounded height');
|
|
|
|
// area
|
|
|
|
if (expected.area !== undefined)
|
|
assertFloat(actual.getArea(), expected.area, expected.eps, 'Wrong area');
|
|
if (expected.rarea !== undefined)
|
|
assertFloat(actual.getPxArea(), expected.rarea, expected.eps, 'Wrong rounded area');
|
|
|
|
}
|
|
|
|
const x1 = 3.4;
|
|
const y1 = 6.3;
|
|
const width = 2.3;
|
|
const height = 8.2;
|
|
|
|
const eps = 0.01;
|
|
|
|
describe('Validity of Rectangle', function () {
|
|
it('Invalid rectangle', function () {
|
|
let invalidRect = new cool.Rectangle(3, 4, -1, 10);
|
|
assert.ok(!invalidRect.isValid(), 'Rectangle should be invalid');
|
|
invalidRect = new cool.Rectangle(3, 4, 1, -10);
|
|
assert.ok(!invalidRect.isValid(), 'Rectangle should be invalid');
|
|
});
|
|
|
|
it('Valid rectangle', function () {
|
|
const validRect = new cool.Rectangle(3, 4, 1, 10);
|
|
assert.ok(validRect.isValid(), 'Rectangle should be valid');
|
|
});
|
|
});
|
|
|
|
describe('construction test', function () {
|
|
it('construct', function () {
|
|
const rect = cool.createRectangle(x1, y1, width, height);
|
|
assertRectangle(rect, {
|
|
x1: x1,
|
|
x2: x1 + width,
|
|
width: width,
|
|
|
|
y1: y1,
|
|
y2: y1 + height,
|
|
height: height,
|
|
|
|
rx1: Math.round(x1),
|
|
rx2: Math.round(x1 + width),
|
|
rwidth: Math.round(x1 + width) - Math.round(x1),
|
|
|
|
ry1: Math.round(y1),
|
|
ry2: Math.round(y1 + height),
|
|
rheight: Math.round(y1 + height) - Math.round(y1),
|
|
|
|
area: width * height,
|
|
rarea: (Math.round(x1 + width) - Math.round(x1)) * (Math.round(y1 + height) - Math.round(y1)),
|
|
eps: eps,
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('coordinate API tests', function () {
|
|
|
|
const coords = ['x', 'y'];
|
|
coords.forEach(function (coord: string) {
|
|
const isX = coord === 'x';
|
|
const isY = !isX;
|
|
|
|
describe(coord + '-coordinate API tests', function () {
|
|
|
|
it(isX ? 'setX1' : 'setY1', function () {
|
|
const rect = cool.createRectangle(x1, y1, width, height);
|
|
const newC1 = 1.3;
|
|
const newSize = (isX ? width + x1: height + y1) - newC1;
|
|
|
|
isX ? rect.setX1(newC1) : rect.setY1(newC1);
|
|
|
|
const newX1 = isX ? newC1 : x1;
|
|
const newY1 = isY ? newC1 : y1;
|
|
const newWidth = isX ? newSize : width;
|
|
const newHeight = isY ? newSize : height;
|
|
|
|
|
|
assertRectangle(rect, {
|
|
x1: newX1,
|
|
x2: x1 + width,
|
|
width: newWidth,
|
|
|
|
y1: newY1,
|
|
y2: y1 + height,
|
|
height: newHeight,
|
|
|
|
rx1: Math.round(newX1),
|
|
rx2: Math.round(x1 + width),
|
|
rwidth: Math.round(x1 + width) - Math.round(newX1),
|
|
|
|
ry1: Math.round(newY1),
|
|
ry2: Math.round(y1 + height),
|
|
rheight: Math.round(y1 + height) - Math.round(newY1),
|
|
|
|
area: newWidth * newHeight,
|
|
rarea: (Math.round(x1 + width) - Math.round(newX1))
|
|
* (Math.round(y1 + height) - Math.round(newY1)),
|
|
eps: eps,
|
|
});
|
|
});
|
|
|
|
|
|
it(isX ? 'setX2' : 'setY2', function () {
|
|
const rect = cool.createRectangle(x1, y1, width, height);
|
|
const newC2 = 10.3;
|
|
const newSize = newC2 - (isX ? x1 : y1);
|
|
|
|
isX ? rect.setX2(newC2) : rect.setY2(newC2);
|
|
|
|
const newX2 = isX ? newC2 : (x1 + width);
|
|
const newY2 = isY ? newC2 : (y1 + height);
|
|
const newWidth = isX ? newSize : width;
|
|
const newHeight = isY ? newSize : height;
|
|
|
|
assertRectangle(rect, {
|
|
x1: x1,
|
|
x2: newX2,
|
|
width: newWidth,
|
|
|
|
y1: y1,
|
|
y2: newY2,
|
|
height: newHeight,
|
|
|
|
rx1: Math.round(x1),
|
|
rx2: Math.round(newX2),
|
|
rwidth: Math.round(newX2) - Math.round(x1),
|
|
|
|
ry1: Math.round(y1),
|
|
ry2: Math.round(newY2),
|
|
rheight: Math.round(newY2) - Math.round(y1),
|
|
|
|
area: newWidth * newHeight,
|
|
rarea: (Math.round(newX2) - Math.round(x1))
|
|
* (Math.round(newY2) - Math.round(y1)),
|
|
eps: eps,
|
|
});
|
|
});
|
|
|
|
|
|
it(isX ? 'setWidth' : 'setHeight', function () {
|
|
const rect = cool.createRectangle(x1, y1, width, height);
|
|
const newSize = 1.4;
|
|
const newC2 = (isX ? x1 : y1) + newSize;
|
|
|
|
isX ? rect.setWidth(newSize) : rect.setHeight(newSize);
|
|
|
|
const newX2 = isX ? newC2 : (x1 + width);
|
|
const newY2 = isY ? newC2 : (y1 + height);
|
|
const newWidth = isX ? newSize : width;
|
|
const newHeight = isY ? newSize : height;
|
|
|
|
assertRectangle(rect, {
|
|
x1: x1,
|
|
x2: newX2,
|
|
width: newWidth,
|
|
|
|
y1: y1,
|
|
y2: newY2,
|
|
height: newHeight,
|
|
|
|
rx1: Math.round(x1),
|
|
rx2: Math.round(newX2),
|
|
rwidth: Math.round(newX2) - Math.round(x1),
|
|
|
|
ry1: Math.round(y1),
|
|
ry2: Math.round(newY2),
|
|
rheight: Math.round(newY2) - Math.round(y1),
|
|
|
|
area: newWidth * newHeight,
|
|
rarea: (Math.round(newX2) - Math.round(x1))
|
|
* (Math.round(newY2) - Math.round(y1)),
|
|
eps: eps,
|
|
});
|
|
});
|
|
|
|
|
|
it('setArea (Preserve ' + (isX ? 'height' : 'width') + ')', function () {
|
|
const rect = cool.createRectangle(x1, y1, width, height);
|
|
const newArea = 20.4;
|
|
const newWidth = isX ? (newArea / height) : width;
|
|
const newHeight = isY ? (newArea / width) : height;
|
|
const newX2 = isX ? (x1 + newWidth) : (x1 + width);
|
|
const newY2 = isY ? (y1 + newHeight) : (y1 + height);
|
|
|
|
rect.setArea(newArea, isX /* preserveHeight */);
|
|
|
|
assertRectangle(rect, {
|
|
x1: x1,
|
|
x2: newX2,
|
|
width: newWidth,
|
|
|
|
y1: y1,
|
|
y2: newY2,
|
|
height: newHeight,
|
|
|
|
rx1: Math.round(x1),
|
|
rx2: Math.round(newX2),
|
|
rwidth: Math.round(newX2) - Math.round(x1),
|
|
|
|
ry1: Math.round(y1),
|
|
ry2: Math.round(newY2),
|
|
rheight: Math.round(newY2) - Math.round(y1),
|
|
|
|
area: newWidth * newHeight,
|
|
rarea: (Math.round(newX2) - Math.round(x1)) * (Math.round(newY2) - Math.round(y1)),
|
|
eps: eps,
|
|
});
|
|
});
|
|
|
|
|
|
it('moveBy', function () {
|
|
const rect = cool.createRectangle(x1, y1, width, height);
|
|
const dc = 1.3;
|
|
const newX1 = isX ? (x1 + dc) : x1;
|
|
const newX2 = isX ? (x1 + width + dc) : (x1 + width);
|
|
const newY1 = isY ? (y1 + dc) : y1;
|
|
const newY2 = isY ? (y1 + height + dc) : (y1 + height);
|
|
isX ? rect.moveBy(dc, 0) : rect.moveBy(0, dc);
|
|
|
|
assertRectangle(rect, {
|
|
x1: newX1,
|
|
x2: newX2,
|
|
width: width,
|
|
|
|
y1: newY1,
|
|
y2: newY2,
|
|
height: height,
|
|
|
|
rx1: Math.round(newX1),
|
|
rx2: Math.round(newX2),
|
|
rwidth: Math.round(newX2) - Math.round(newX1),
|
|
|
|
ry1: Math.round(newY1),
|
|
ry2: Math.round(newY2),
|
|
rheight: Math.round(newY2) - Math.round(newY1),
|
|
|
|
area: width * height,
|
|
rarea: (Math.round(newX2) - Math.round(newX1)) * (Math.round(newY2) - Math.round(newY1)),
|
|
eps: eps,
|
|
});
|
|
});
|
|
|
|
|
|
it('moveTo', function () {
|
|
const rect = cool.createRectangle(x1, y1, width, height);
|
|
const newC1 = 50.3;
|
|
|
|
const newX1 = isX ? newC1 : x1;
|
|
const newX2 = newX1 + width;
|
|
|
|
const newY1 = isY ? newC1 : y1;
|
|
const newY2 = newY1 + height;
|
|
|
|
isX ? rect.moveTo(newC1, y1) : rect.moveTo(x1, newC1);
|
|
|
|
assertRectangle(rect, {
|
|
x1: newX1,
|
|
x2: newX2,
|
|
width: width,
|
|
|
|
y1: newY1,
|
|
y2: newY2,
|
|
height: height,
|
|
|
|
rx1: Math.round(newX1),
|
|
rx2: Math.round(newX2),
|
|
rwidth: Math.round(newX2) - Math.round(newX1),
|
|
|
|
ry1: Math.round(newY1),
|
|
ry2: Math.round(newY2),
|
|
rheight: Math.round(newY2) - Math.round(newY1),
|
|
|
|
area: width * height,
|
|
rarea: (Math.round(newX2) - Math.round(newX1)) * (Math.round(newY2) - Math.round(newY1)),
|
|
eps: eps,
|
|
});
|
|
});
|
|
|
|
|
|
|
|
}); // describe(coord + '-coordinate API tests'
|
|
|
|
}); // coords.forEach
|
|
|
|
}); // root describe
|