@woosh/meep-engine 2.110.14 → 2.110.15

package/src/core/binary/BitSet.spec.js

@@ -1,468 +0,0 @@
-import { BitSet } from "./BitSet.js";
-
-test("get from empty", () => {
-    const set = new BitSet();
-
-    expect(set.get(0)).toBe(false);
-    expect(set.get(10000)).toBe(false);
-});
-
-test("set and get bit 7", () => {
-    const set = new BitSet();
-
-    set.set(7, true);
-
-    expect(set.get(7)).toBe(true);
-});
-
-test("set and get a bit", () => {
-    const set = new BitSet();
-
-    set.set(0, true);
-    expect(set.get(0)).toBe(true);
-
-    set.set(10000, true);
-    expect(set.get(10000)).toBe(true);
-    expect(set.get(0)).toBe(true);
-
-    set.set(0, false);
-    expect(set.get(0)).toBe(false);
-    expect(set.get(10000)).toBe(true);
-
-    set.set(10000, false);
-    expect(set.get(10000)).toBe(false);
-});
-
-test.skip("resizing up and down works as intended", () => {
-    const set = new BitSet();
-
-    const c0 = set.capacity();
-
-    set.setRange(c0, c0 + 1000);
-
-    const c1 = set.capacity();
-    expect(c1).toBeGreaterThan(c0);
-
-    //clear the bit
-    set.clearRange(c0, c0 + 1001);
-
-    expect(set.capacity()).toBeLessThan(c1);
-});
-
-test("resizing down should throw when requested capacity is smaller than actual length", () => {
-    const set = new BitSet();
-
-    const c0 = set.capacity();
-
-    set.set(c0 + 2, true);
-
-    expect(() => {
-        set.setCapacity(1);
-    }).toThrow();
-});
-
-test('previousSetBit with set bit 31', () => {
-    const bits = new BitSet();
-
-    bits.set(31, true);
-
-    expect(bits.previousSetBit(8)).toBe(-1);
-    expect(bits.previousSetBit(16)).toBe(-1);
-    expect(bits.previousSetBit(30)).toBe(-1);
-
-    expect(bits.previousSetBit(31)).toBe(31);
-    expect(bits.previousSetBit(32)).toBe(31);
-    expect(bits.previousSetBit(33)).toBe(31);
-});
-
-test("previousSetBit method works correctly", () => {
-    const bits = new BitSet();
-
-    bits.set(1, true);
-    bits.set(2, true);
-    bits.set(4, true);
-
-    bits.set(8, true);
-    bits.set(11, true);
-    bits.set(12, true);
-
-    expect(bits.previousSetBit(0)).toBe(-1);
-
-    expect(bits.previousSetBit(1)).toBe(1);
-
-    expect(bits.previousSetBit(2)).toBe(2);
-    expect(bits.previousSetBit(3)).toBe(2);
-
-    expect(bits.previousSetBit(4)).toBe(4);
-    expect(bits.previousSetBit(5)).toBe(4);
-    expect(bits.previousSetBit(6)).toBe(4);
-    expect(bits.previousSetBit(7)).toBe(4);
-
-    expect(bits.previousSetBit(8)).toBe(8);
-    expect(bits.previousSetBit(9)).toBe(8);
-    expect(bits.previousSetBit(9)).toBe(8);
-    expect(bits.previousSetBit(10)).toBe(8);
-
-    expect(bits.previousSetBit(11)).toBe(11);
-    expect(bits.previousSetBit(12)).toBe(12);
-
-    expect(bits.previousSetBit(100)).toBe(12);
-});
-
-test("nextClearBit method works correctly", () => {
-    const bits = new BitSet();
-
-    expect(bits.nextClearBit(0)).toBe(0);
-
-    bits.set(0, true);
-
-    expect(bits.nextClearBit(0)).toBe(1);
-
-    bits.set(2, true);
-
-    expect(bits.nextClearBit(2)).toBe(3);
-
-    bits.set(1, true);
-
-    expect(bits.nextClearBit(0)).toBe(3);
-
-    bits.set(3, true);
-
-    expect(bits.nextClearBit(0)).toBe(4);
-
-    bits.set(6, true);
-    bits.set(7, true);
-    bits.set(8, true);
-    bits.set(9, true);
-    bits.set(11, true);
-
-    expect(bits.nextClearBit(6)).toBe(10);
-    expect(bits.nextClearBit(9)).toBe(10);
-    expect(bits.nextClearBit(10)).toBe(10);
-    expect(bits.nextClearBit(11)).toBe(12);
-});
-
-test("nextClearBit stability", () => {
-
-    const bits = new BitSet();
-
-    expect(bits.nextClearBit(0)).toBe(0);
-    expect(bits.nextClearBit(1)).toBe(1);
-
-    //repeat
-    expect(bits.nextClearBit(0)).toBe(0);
-});
-
-test('nextClearBit from index 8, with 32 continuous set bits', () => {
-    const bits = new BitSet();
-
-    for (let i = 0; i < 32; i++) {
-        bits.set(i, true);
-    }
-
-    expect(bits.nextClearBit(8)).toBe(32);
-});
-
-test("combination of set and clear", () => {
-
-    const bits = new BitSet();
-
-    bits.set(0, true);
-    bits.set(1, true);
-    bits.set(2, true);
-    bits.set(3, true);
-    bits.set(4, true);
-    bits.set(5, true);
-
-    expect(bits.size()).toBe(6);
-
-    //set
-    bits.set(0, false);
-
-    expect(bits.get(0)).toBe(false);
-    expect(bits.get(1)).toBe(true);
-    expect(bits.get(2)).toBe(true);
-    expect(bits.get(3)).toBe(true);
-    expect(bits.get(4)).toBe(true);
-    expect(bits.get(5)).toBe(true);
-
-    expect(bits.size()).toBe(6);
-
-    //set
-    bits.set(2, false);
-
-    expect(bits.get(0)).toBe(false);
-    expect(bits.get(1)).toBe(true);
-    expect(bits.get(2)).toBe(false);
-    expect(bits.get(3)).toBe(true);
-    expect(bits.get(4)).toBe(true);
-    expect(bits.get(5)).toBe(true);
-
-    expect(bits.size()).toBe(6);
-
-    //set
-    bits.set(4, false);
-
-    expect(bits.get(0)).toBe(false);
-    expect(bits.get(1)).toBe(true);
-    expect(bits.get(2)).toBe(false);
-    expect(bits.get(3)).toBe(true);
-    expect(bits.get(4)).toBe(false);
-    expect(bits.get(5)).toBe(true);
-
-    expect(bits.size()).toBe(6);
-
-    //set
-    bits.set(0, true);
-
-    expect(bits.get(0)).toBe(true);
-    expect(bits.get(1)).toBe(true);
-    expect(bits.get(2)).toBe(false);
-    expect(bits.get(3)).toBe(true);
-    expect(bits.get(4)).toBe(false);
-    expect(bits.get(5)).toBe(true);
-
-    expect(bits.size()).toBe(6);
-
-    //set
-    bits.set(5, false);
-
-    expect(bits.get(0)).toBe(true);
-    expect(bits.get(1)).toBe(true);
-    expect(bits.get(2)).toBe(false);
-    expect(bits.get(3)).toBe(true);
-    expect(bits.get(4)).toBe(false);
-    expect(bits.get(5)).toBe(false);
-
-    expect(bits.size()).toBe(4);
-});
-
-test("nextSetBit with only bit 31 set", () => {
-
-    const bits = new BitSet();
-
-    bits.set(31, true);
-
-    expect(bits.nextSetBit(0)).toBe(31);
-    expect(bits.nextSetBit(1)).toBe(31);
-    expect(bits.nextSetBit(31)).toBe(31);
-
-    expect(bits.nextSetBit(32)).toBe(-1);
-});
-
-test("nextSetBit with only bit 33 set", () => {
-
-    const bits = new BitSet();
-
-    bits.set(33, true);
-
-    expect(bits.nextSetBit(0)).toBe(33);
-    expect(bits.nextSetBit(1)).toBe(33);
-
-    expect(bits.nextSetBit(33)).toBe(33);
-
-    expect(bits.nextSetBit(34)).toBe(-1);
-});
-
-test("nextSetBit method works correctly", () => {
-    const bits = new BitSet();
-
-    expect(bits.nextSetBit(0)).toBe(-1);
-
-    bits.set(0, true);
-
-    expect(bits.nextSetBit(0)).toBe(0);
-
-    expect(bits.nextSetBit(1)).toBe(-1);
-
-    bits.set(2, true);
-
-    expect(bits.nextSetBit(1)).toBe(2);
-
-    bits.set(2, false);
-
-    expect(bits.nextSetBit(1)).toBe(-1);
-
-    bits.set(7, true);
-
-    expect(bits.nextSetBit(7)).toBe(7);
-
-    bits.set(7, false);
-    bits.set(10, true);
-
-    expect(bits.nextSetBit(6)).toBe(10);
-});
-
-test("clear method works correctly", () => {
-    const bits = new BitSet();
-
-    bits.set(0, true);
-    bits.set(1, true);
-    bits.set(2, true);
-    bits.set(11, true);
-
-    bits.clear(1);
-
-    expect(bits.get(0)).toBe(true);
-
-    expect(bits.get(1)).toBe(false);
-
-    expect(bits.get(2)).toBe(true);
-
-    expect(bits.get(11)).toBe(true);
-
-    bits.clear(0);
-
-    expect(bits.get(0)).toBe(false);
-
-    expect(bits.get(1)).toBe(false);
-
-    expect(bits.get(2)).toBe(true);
-
-    expect(bits.get(11)).toBe(true);
-
-    bits.clear(11);
-
-    expect(bits.get(0)).toBe(false);
-
-    expect(bits.get(1)).toBe(false);
-
-    expect(bits.get(2)).toBe(true);
-
-    expect(bits.get(11)).toBe(false);
-
-    bits.clear(2);
-
-    expect(bits.get(0)).toBe(false);
-
-    expect(bits.get(1)).toBe(false);
-
-    expect(bits.get(2)).toBe(false);
-
-    expect(bits.get(11)).toBe(false);
-});
-
-test("reset clears out data correctly", () => {
-    const set = new BitSet();
-
-    set.set(0, true);
-
-    expect(set.get(0)).toBe(true);
-
-    set.reset();
-
-    expect(set.size()).toBe(0);
-
-    expect(set.nextClearBit(0)).toBe(0);
-
-    set.set(1, true);
-
-    // bit should have been cleared
-    expect(set.get(0)).toBe(false);
-});
-
-
-test("setRange 7 to 9", () => {
-    const set = new BitSet();
-
-    set.setRange(7, 9);
-
-    expect(set.get(6)).toBe(false);
-
-    expect(set.get(7)).toBe(true);
-    expect(set.get(8)).toBe(true);
-    expect(set.get(9)).toBe(true);
-
-    expect(set.get(10)).toBe(false);
-
-});
-test("setRange 0 to 35", () => {
-    const set = new BitSet();
-
-    set.setRange(0, 35);
-
-    expect(set.get(0)).toBe(true);
-    expect(set.get(1)).toBe(true);
-    expect(set.get(2)).toBe(true);
-    expect(set.get(3)).toBe(true);
-    expect(set.get(4)).toBe(true);
-    expect(set.get(8)).toBe(true);
-    expect(set.get(9)).toBe(true);
-    expect(set.get(10)).toBe(true);
-    expect(set.get(11)).toBe(true);
-    expect(set.get(12)).toBe(true);
-    expect(set.get(13)).toBe(true);
-    expect(set.get(14)).toBe(true);
-    expect(set.get(15)).toBe(true);
-    expect(set.get(16)).toBe(true);
-    expect(set.get(32)).toBe(true);
-    expect(set.get(33)).toBe(true);
-    expect(set.get(34)).toBe(true);
-    expect(set.get(35)).toBe(true);
-
-    expect(set.get(36)).toBe(false);
-
-    expect(set.nextSetBit(0)).toBe(0)
-    expect(set.nextClearBit(0)).toBe(36)
-});
-
-test('copy empty', () => {
-    const a = new BitSet();
-
-    const b = new BitSet();
-
-    b.copy(a);
-
-    expect(b.size()).toBe(0);
-});
-
-test('copy with only bit 33 set', () => {
-    const a = new BitSet();
-
-    a.set(33, true);
-
-    const b = new BitSet();
-
-    b.copy(a);
-
-    expect(b.get(32)).toBe(false);
-    expect(b.get(33)).toBe(true);
-    expect(b.get(34)).toBe(false);
-
-    expect(b.size()).toBe(34);
-});
-
-test('shift right by 1', () => {
-    const s = new BitSet();
-
-    s.set(0, true);
-
-    s.shift_right(1, 0, 1);
-
-    expect(s.get(0)).toBe(true);
-    expect(s.get(1)).toBe(true);
-});
-
-test.skip('performance, next set from 0', () => {
-    const s = new BitSet();
-
-    s.set(1024, true);
-
-    for (let i = 0; i < 1000000; i++) {
-        const v = s.nextSetBit(0);
-    }
-});
-
-test.skip('performance, next clear from 0', () => {
-    const s = new BitSet();
-
-    for (let i = 0; i < 1024; i++) {
-        s.set(i, true);
-    }
-
-    for (let i = 0; i < 1000000; i++) {
-        const v = s.nextClearBit(0);
-    }
-});
-
-

package/src/core/binary/EncodingBinaryBuffer.spec.js

@@ -1,16 +0,0 @@
-import { EncodingBinaryBuffer } from "./EncodingBinaryBuffer.js";
-
-test("read/write strings", () => {
-
-    const buffer = new EncodingBinaryBuffer();
-
-    buffer.writeUTF8String("hello world");
-    buffer.writeUTF8String("cat");
-    buffer.writeUTF8String("hello world");
-
-    buffer.position = 0;
-
-    expect(buffer.readUTF8String()).toEqual("hello world");
-    expect(buffer.readUTF8String()).toEqual("cat");
-    expect(buffer.readUTF8String()).toEqual("hello world");
-});

package/src/core/binary/align_32.spec.js

@@ -1,11 +0,0 @@
-import { align_32 } from "./align_32.js";
-
-test("basics", () => {
-    expect(align_32(0)).toBe(0);
-    expect(align_32(1)).toBe(32);
-    expect(align_32(31)).toBe(32);
-    expect(align_32(32)).toBe(32);
-    expect(align_32(33)).toBe(64);
-    expect(align_32(63)).toBe(64);
-    expect(align_32(64)).toBe(64);
-});

package/src/core/binary/align_4.spec.js

@@ -1,20 +0,0 @@
-import { align_4 } from "./align_4.js";
-
-test("basics", () => {
-
-    expect(align_4(0)).toBe(0);
-    expect(align_4(1)).toBe(4);
-    expect(align_4(3)).toBe(4);
-    expect(align_4(4)).toBe(4);
-
-    expect(align_4(5)).toBe(8);
-    expect(align_4(6)).toBe(8);
-    expect(align_4(7)).toBe(8);
-    expect(align_4(8)).toBe(8);
-
-    expect(align_4(9)).toBe(12);
-    expect(align_4(10)).toBe(12);
-    expect(align_4(11)).toBe(12);
-    expect(align_4(12)).toBe(12);
-
-});

package/src/core/binary/data_view/DataViewStructAccessor.spec.js

@@ -1,20 +0,0 @@
-import { BinaryDataType } from "../type/BinaryDataType.js";
-import { DataViewStructAccessor } from "./DataViewStructAccessor.js";
-
-test("2 field schema", () => {
-    const accessor = new DataViewStructAccessor({
-        alice: BinaryDataType.Float32,
-        bob: BinaryDataType.Uint8
-    });
-
-    const buffer = new ArrayBuffer(1024);
-    const dataView = new DataView(buffer);
-
-    accessor.bind(dataView, 1);
-
-    accessor.alice = -3.7;
-    accessor.bob = 7;
-
-    expect(dataView.getFloat32(1)).toBeCloseTo(-3.7);
-    expect(dataView.getUint8(5)).toBe(7);
-});

package/src/core/binary/de_interleave_2_bits.spec.js

@@ -1,21 +0,0 @@
-import { de_interleave_2_bits } from "./de_interleave_2_bits.js";
-
-test("deinterleave 0", () => {
-
-    const bits = de_interleave_2_bits(0);
-
-    expect(bits).toBe(0);
-
-});
-
-test("deinterleave 3 and 7", () => {
-
-    const interleaved_3 = 0b101;
-    const interleaved_4 = 0b10000;
-
-    const interleaved = (interleaved_3 << 1) | interleaved_4;
-
-    expect(de_interleave_2_bits(interleaved)).toBe(4);
-    expect(de_interleave_2_bits(interleaved >> 1)).toBe(3);
-
-});

package/src/core/binary/dec2hex.spec.js

@@ -1,13 +0,0 @@
-import { dec2hex } from "./dec2hex.js";
-
-test("zero padding", () => {
-    expect(dec2hex(0)).toBe("00");
-    expect(dec2hex(10)).toBe("0a");
-});
-
-test("two digits", () => {
-
-    expect(dec2hex(16)).toBe("10");
-    expect(dec2hex(255)).toBe("ff");
-
-});

package/src/core/binary/hex2dec.spec.js

@@ -1,22 +0,0 @@
-import { hex2dec } from "./hex2dec.js";
-
-test("basics", () => {
-
-    expect(hex2dec("0")).toBe(0)
-    expect(hex2dec("1")).toBe(1)
-    expect(hex2dec("2")).toBe(2)
-    expect(hex2dec("3")).toBe(3)
-    expect(hex2dec("4")).toBe(4)
-    expect(hex2dec("5")).toBe(5)
-    expect(hex2dec("6")).toBe(6)
-    expect(hex2dec("7")).toBe(7)
-    expect(hex2dec("8")).toBe(8)
-    expect(hex2dec("9")).toBe(9)
-    expect(hex2dec("A")).toBe(0xA)
-    expect(hex2dec("B")).toBe(0xB)
-    expect(hex2dec("C")).toBe(0xC)
-    expect(hex2dec("D")).toBe(0xD)
-    expect(hex2dec("E")).toBe(0xE)
-    expect(hex2dec("F")).toBe(0xF)
-
-});

package/src/core/binary/int32_to_binary_string.spec.js

@@ -1,9 +0,0 @@
-import { int32_to_binary_string } from "./int32_to_binary_string.js";
-
-test("sanity", () => {
-    expect(int32_to_binary_string(1024))
-        .toBe("00000000 00000000 00000100 00000000");
-
-    expect(int32_to_binary_string(-1))
-        .toBe("11111111 11111111 11111111 11111111");
-});

package/src/core/binary/operations/bitCount.spec.js

@@ -1,19 +0,0 @@
-import { bitCount } from "./bitCount.js";
-
-test("no set bits", () => {
-    expect(bitCount(0)).toBe(0)
-});
-
-test("1 set bit", () => {
-
-    for (let i = 0; i < 32; i++) {
-        expect(bitCount(1 << i)).toBe(1)
-    }
-});
-
-test("2 set bit together", () => {
-
-    for (let i = 0; i < 31; i++) {
-        expect(bitCount(0b11 << i)).toBe(2)
-    }
-});

package/src/core/binary/operations/ceilPowerOfTwo.spec.js

@@ -1,17 +0,0 @@
-import { ceilPowerOfTwo } from "./ceilPowerOfTwo.js";
-
-test('test', () => {
-    expect(ceilPowerOfTwo(1)).toBe(1);
-
-    expect(ceilPowerOfTwo(2)).toBe(2);
-
-    expect(ceilPowerOfTwo(3)).toBe(4);
-    expect(ceilPowerOfTwo(4)).toBe(4);
-
-    expect(ceilPowerOfTwo(5)).toBe(8);
-    expect(ceilPowerOfTwo(7)).toBe(8);
-    expect(ceilPowerOfTwo(8)).toBe(8);
-
-    expect(ceilPowerOfTwo(9)).toBe(16);
-    expect(ceilPowerOfTwo(15)).toBe(16);
-});

package/src/core/binary/reverse_bits_uint32.spec.js

@@ -1,18 +0,0 @@
-import { reverse_bits_uint32 } from "./reverse_bits_uint32.js";
-
-test("basics", () => {
-
-    expect(reverse_bits_uint32(1 << 31)).toEqual(1);
-    expect(reverse_bits_uint32(1)).toEqual(1 << 31);
-
-    expect(reverse_bits_uint32(2)).toEqual(1 << 30);
-    expect(reverse_bits_uint32(1 << 30)).toEqual(2);
-
-    expect(reverse_bits_uint32(0b1111)).toEqual(
-        (1 << 31) | (1 << 30) | (1 << 29) | (1 << 28)
-    );
-    expect(reverse_bits_uint32(
-        (1 << 31) | (1 << 30) | (1 << 29) | (1 << 28)
-    )).toEqual(0b1111);
-
-});

package/src/core/binary/split_by_2.spec.js

@@ -1,22 +0,0 @@
-import { int32_to_binary_string } from "./int32_to_binary_string.js";
-import { split_by_2 } from "./split_by_2.js";
-
-test("zero", () => {
-
-    expect(split_by_2(0)).toEqual(0);
-
-});
-
-test("max value", () => {
-
-    expect(
-        int32_to_binary_string(split_by_2(0xFFFFFFFF))
-    ).toEqual("01010101 01010101 01010101 01010101");
-
-});
-
-test("max 16bit value", () => {
-    expect(
-        int32_to_binary_string(split_by_2(0b1111111111111111))
-    ).toEqual("01010101 01010101 01010101 01010101");
-});

package/src/core/binary/split_by_3.spec.js

@@ -1,22 +0,0 @@
-import { int32_to_binary_string } from "./int32_to_binary_string.js";
-import { split_by_3 } from "./split_by_3.js";
-
-test("zero", () => {
-
-    expect(split_by_3(0)).toEqual(0);
-
-});
-
-test("max value", () => {
-
-    expect(
-        int32_to_binary_string(split_by_3(0xFFFFFFFF))
-    ).toEqual("00001001 00100100 10010010 01001001");
-
-});
-
-test("max 10bit value",()=>{
-    expect(
-        int32_to_binary_string(split_by_3(0b1111111111))
-    ).toEqual("00001001 00100100 10010010 01001001");
-});