rc-js-util
Version:
A collection of TS and C++ utilities to help writing performant and correct applications, achieved through strict typing and (removable) invariant checking.
212 lines (182 loc) • 6.98 kB
text/typescript
import { expectValueToBeNearTo } from "../../../../test-util/test-utils.js";
import { Range1d } from "./range1d.js";
import { Mat2 } from "../../mat2/mat2.js";
import { Test_setDefaultFlags } from "../../../../test-util/test_set-default-flags.js";
describe("=> Range1d", () =>
{
beforeEach(() =>
{
Test_setDefaultFlags();
});
describe("=> isPointInRange", () =>
{
const range = Range1d.f32.factory.createOne(5, 10);
it("| returns true if the point is in the range", () =>
{
expect(range.isValueInRange1d(7)).toBe(true);
});
it("| returns false if the point is not in the range", () =>
{
expect(range.isValueInRange1d(4)).toBe(false);
expect(range.isValueInRange1d(11)).toBe(false);
});
});
describe("=> scaleRelativeTo", () =>
{
describe("=> zooming out", () =>
{
const range = Range1d.f32.factory.createOne(4, 10);
it("| retains boundaries when the point is at a boundary (min)", () =>
{
const scaledRange = range.scaleRelativeTo(0.5, 4);
expect(scaledRange.getMin()).toBe(4);
expect(scaledRange.getMax()).toBe(7);
});
it("| retains boundaries when the point is at a boundary (max)", () =>
{
const scaledRange = range.scaleRelativeTo(0.5, 10);
expect(scaledRange.getMin()).toBe(7);
expect(scaledRange.getMax()).toBe(10);
});
it("| scales proportionally where away from boundaries", () =>
{
const scaledRange = range.scaleRelativeTo(0.5, 7);
expect(scaledRange.getMin()).toBe(5.5);
expect(scaledRange.getMax()).toBe(8.5);
});
});
describe("=> zooming in", () =>
{
const range = Range1d.f32.factory.createOne(4, 10);
it("| retains boundaries when the point is at a boundary (min)", () =>
{
const scaledRange = range.scaleRelativeTo(2, 4);
expect(scaledRange.getMin()).toBe(4);
expect(scaledRange.getMax()).toBe(16);
});
it("| retains boundaries when the point is at a boundary (max)", () =>
{
const scaledRange = range.scaleRelativeTo(2, 10);
expect(scaledRange.getMin()).toBe(-2);
expect(scaledRange.getMax()).toBe(10);
});
it("| scales proportionally where away from boundaries", () =>
{
const scaledRange = range.scaleRelativeTo(2, 7);
expect(scaledRange.getMin()).toBe(1);
expect(scaledRange.getMax()).toBe(13);
});
});
});
describe("=> bound", () =>
{
it("| bounds ranges that are too large", () =>
{
const range = Range1d.f32.factory.createOne(0, 10);
range.bound1d(Range1d.f32.factory.createOne(2, 8));
expect(range.getMin()).toBe(2);
expect(range.getMax()).toBe(8);
});
it("| translates ranges that are out of bounds (neg)", () =>
{
const range = Range1d.f32.factory.createOne(0, 10);
range.bound1d(Range1d.f32.factory.createOne(-20, -5));
expect(range.getMin()).toBe(-15);
expect(range.getMax()).toBe(-5);
});
it("| translates ranges that are out of bounds (pos)", () =>
{
const range = Range1d.f32.factory.createOne(0, 10);
range.bound1d(Range1d.f32.factory.createOne(15, 30));
expect(range.getMin()).toBe(15);
expect(range.getMax()).toBe(25);
});
});
describe("=> mat2Multiply", () =>
{
it("| moves the range as expected", () =>
{
const range = Range1d.f32.factory.createOne(0, 10);
const tm = Mat2.f32.factory
.createOneEmpty()
.setTranslationMatrix(3);
range.mat2Multiply(tm, range);
expect(range.getMin()).toBe(3);
expect(range.getMax()).toBe(13);
});
});
describe("=> slice", () =>
{
it("| creates a copy", () =>
{
const a = Range1d.f32.factory.createOne(1, 2);
const b = a.slice();
expect(a).toEqual(b);
expect(a).not.toBe(b);
expect(a.bound1d).toBeDefined();
});
});
describe("=> get2dRangeTransformMatrix", () =>
{
const transform = Range1d.f32.factory
.createOne(-100, -50)
.getRangeTransform(
Range1d.f32.factory.createOne(-0.75, -0.5),
);
it("| creates the expected matrix", () =>
{
// scaling factors
expectValueToBeNearTo(transform.getValueAt(0, 0), 0.25 / 50);
// transform
expectValueToBeNearTo(transform.getValueAt(0, 1), -0.25);
});
it("maps values as expected", () =>
{
expectValueToBeNearTo(transform.getVec2MultiplyX(-75), -0.625);
expectValueToBeNearTo(transform.getVec2MultiplyX(50), 0);
});
it("inverts ranges where ranges are backwards", () =>
{
// backwards in that the min is the max and the max is the min
const backwardsTransform = Range1d.f32.factory
.createOne(0, 10)
.getRangeTransform(
Range1d.f32.factory.createOne(-10, -5),
);
expectValueToBeNearTo(backwardsTransform.getVec2MultiplyX(0), -10);
expectValueToBeNearTo(backwardsTransform.getVec2MultiplyX(10), -5);
});
});
describe("=> extendRange", () =>
{
const range = Range1d.f32.factory.createOne(5, 10);
it("| extends the range down", () =>
{
const extended = range.extendRange(4);
expect(extended.getMin()).toBe(4);
expect(extended.getMax()).toBe(10);
});
it("| extends the range up", () =>
{
const extended = range.extendRange(12);
expect(extended.getMin()).toBe(5);
expect(extended.getMax()).toBe(12);
});
});
describe("=> unionRange", () =>
{
const range = Range1d.f32.factory.createOne(5, 10);
it("| extends the range down", () =>
{
const extended = range.unionRange(Range1d.f32.factory.createOne(4, 10));
expect(extended.getMin()).toBe(4);
expect(extended.getMax()).toBe(10);
});
it("| extends the range up", () =>
{
const extended = range.unionRange(Range1d.f32.factory.createOne(5, 12));
expect(extended.getMin()).toBe(5);
expect(extended.getMax()).toBe(12);
});
});
});