@woosh/meep-engine 2.110.14 → 2.110.15

package/src/core/codegen/LineBuilder.spec.js

@@ -1,41 +0,0 @@
-import LineBuilder from "./LineBuilder.js";
-
-test("Empty builder should produce empty string", () => {
-    const b = new LineBuilder();
-
-    expect(b.build()).toEqual("");
-});
-
-test("build simple indented fragment", () => {
-    const b = new LineBuilder();
-
-    b.indentSpaces = 1;
-
-    b.add('a');
-    b.indent();
-    b.add('b');
-    b.dedent();
-    b.add('c');
-
-    expect(b.build()).toEqual('a\n b\nc');
-});
-
-test("adding another line builder copies lines correctly", () => {
-    const a = new LineBuilder();
-
-    const b = new LineBuilder();
-
-    b.add('a');
-
-    a.addLines(b);
-
-    expect(a.build()).toEqual('a');
-});
-
-test("fromText parses correct number of lines", () => {
-
-    const builder = LineBuilder.fromText('a\nb');
-
-    expect(builder.count).toBe(2);
-
-});

package/src/core/collection/CuckooFilter.spec.js

@@ -1,111 +0,0 @@
-import { CuckooFilter } from "./CuckooFilter.js";
-
-test("default constructor doesn't throw", () => {
-    expect(() => new CuckooFilter()).not.toThrow();
-});
-
-test("Sanity false negatives", () => {
-    const filter = new CuckooFilter({
-                                        fpp: 0.01,
-                                        maxKeys: 130
-                                    });
-
-    for (let i = 0; i < 100; i++) {
-        expect(filter.insert(i)).toBe(true);
-    }
-
-    let false_negatives = 0;
-
-    for (let i = 0; i < 100; i++) {
-        if (!filter.mightContain(i)) {
-            false_negatives++;
-        }
-    }
-
-    expect(false_negatives).toBe(0);
-
-});
-
-test("Sanity failed removal", () => {
-    const filter = new CuckooFilter({
-                                        fpp: 0.01,
-                                        maxKeys: 130
-                                    });
-
-    for (let i = 0; i < 100; i++) {
-        filter.insert(i);
-    }
-
-    let failed_removals = 0;
-    for (let i = 0; i < 100; i++) {
-        if (!filter.remove(i)) {
-            failed_removals++;
-        }
-    }
-
-    expect(failed_removals).toBe(0);
-});
-
-test("stress fill then drain check", () => {
-    const filter = new CuckooFilter({
-                                        fpp: 0.01,
-                                        maxKeys: 100
-                                    });
-
-    let insertion_count = 0;
-
-    while (filter.insert(insertion_count)) {
-        insertion_count++;
-    }
-
-    for (let i = 0; i < insertion_count; i++) {
-        // check for everything we added
-        const mightContain = filter.mightContain(i);
-
-        expect(mightContain).toBe(true);
-    }
-    let deletions_count = 0;
-
-    // two passes
-    for (let i = 0; i < insertion_count; i++) {
-        if (filter.remove(i)) {
-            deletions_count++;
-        } else {
-            debugger;
-        }
-    }
-
-    for (let i = 0; i < insertion_count; i++) {
-        if (filter.remove(i)) {
-            deletions_count++;
-        }
-    }
-
-    // did we remove everything?
-    expect(deletions_count).toBe(insertion_count);
-
-    // expect filter to know it's empty
-    expect(filter.count).toBe(0);
-
-    // check that none of our inserted values are in the filter
-    for (let i = 0; i < insertion_count; i++) {
-        expect(filter.mightContain(i)).toBe(false);
-    }
-});
-
-test("reverse hash stability", () => {
-    const filter = new CuckooFilter({
-                                        fpp: 0.01,
-                                        maxKeys: 100
-                                    });
-
-    for (let i = 0; i < 500; i++) {
-        const tag = filter.__compute_tag_from_hash(i);
-        const h1 = filter.__compute_bucket_index_from_hash(i);
-        const h2 = filter.__compute_alt_bucket_index(h1, tag);
-
-        const h1_restored = filter.__compute_alt_bucket_index(h2, tag);
-
-        expect(h1_restored).toBe(h1);
-    }
-});

package/src/core/collection/RingBuffer.spec.js

@@ -1,59 +0,0 @@
-import { RingBuffer } from "./RingBuffer.js";
-
-test("constructor doesn't throw", () => {
-    expect(() => new RingBuffer(1)).not.toThrow();
-});
-
-test("size set from constructor", () => {
-    const sut = new RingBuffer(7);
-
-    expect(sut.size).toBe(7);
-});
-
-test("circular overwriting", () => {
-    const sut = new RingBuffer(2);
-
-    sut.push(3);
-    sut.push(7);
-    sut.push(11);
-
-    expect(sut.contains(3)).toBe(false);
-    expect(sut.contains(7)).toBe(true);
-    expect(sut.contains(11)).toBe(true);
-});
-
-test("empty buffer count must be 0", () => {
-    const sut = new RingBuffer(1);
-
-    expect(sut.count).toBe(0);
-});
-
-test("buffer count works as expected", () => {
-    const sut = new RingBuffer(2);
-
-    expect(sut.count).toBe(0);
-
-    sut.push(1);
-
-    expect(sut.count).toBe(1);
-
-    sut.push(3);
-
-    expect(sut.count).toBe(2);
-
-    sut.push(7);
-
-    expect(sut.count).toBe(2);
-});
-
-test("resizing changes capacity", () => {
-    const sut = new RingBuffer(2);
-
-    sut.resize(1);
-
-    expect(sut.size).toBe(1);
-
-    sut.resize(3);
-
-    expect(sut.size).toBe(3);
-});

package/src/core/collection/Stack.spec.js

@@ -1,63 +0,0 @@
-import { Stack } from "./Stack.js";
-
-test('pop from empty returns undefined', () => {
-    const stack = new Stack();
-
-    expect(stack.pop()).toBe(undefined);
-});
-
-test("isEmpty works correctly", () => {
-    const stack = new Stack();
-
-    expect(stack.isEmpty()).toBe(true);
-
-    stack.push(1);
-
-    expect(stack.isEmpty()).toBe(false);
-
-    stack.pop();
-
-    expect(stack.isEmpty()).toBe(true);
-});
-
-test('push followed by pop returns the same elements in reverse order', () => {
-    const stack = new Stack();
-
-    stack.push(42);
-    stack.push(3);
-    stack.push(7);
-
-    expect(stack.pop()).toBe(7);
-    expect(stack.pop()).toBe(3);
-    expect(stack.pop()).toBe(42);
-});
-
-
-test("peek returns top element", () => {
-    const stack = new Stack();
-
-    expect(stack.peek()).toBe(undefined);
-
-    stack.push(42);
-
-    expect(stack.peek()).toBe(42);
-
-    stack.push(3);
-
-    expect(stack.peek()).toBe(3);
-});
-
-
-test("remove method", () => {
-    const stack = new Stack();
-
-    expect(stack.remove(1)).toBe(false);
-
-    stack.push(1);
-
-    expect(stack.remove(2)).toBe(false);
-
-    expect(stack.remove(1)).toBe(true);
-
-    expect(stack.isEmpty()).toBe(true);
-});

package/src/core/collection/array/arrayPickBestElement.spec.js

@@ -1,7 +0,0 @@
-import { arrayPickBestElement } from "./arrayPickBestElement.js";
-
-test("arrayPickBestElement largest number", () => {
-    expect(
-        arrayPickBestElement([7, 3, 11, -5], v => v)
-    ).toEqual(11);
-});

package/src/core/collection/array/arraySetSortingDiff.spec.js

@@ -1,74 +0,0 @@
-import { arraySetSortingDiff } from "./arraySetSortingDiff.js";
-import { number_compare_ascending } from "../../primitives/numbers/number_compare_ascending.js";
-
-test('two empty inputs', () => {
-    expect(arraySetSortingDiff([], [], number_compare_ascending)).toEqual({
-        uniqueA: [],
-        uniqueB: [],
-        common: []
-    });
-});
-
-test('[] and [1] inputs', () => {
-    expect(arraySetSortingDiff([], [1], number_compare_ascending)).toEqual({
-        uniqueA: [],
-        uniqueB: [1],
-        common: []
-    });
-});
-
-test('[1] and [] inputs', () => {
-    expect(arraySetSortingDiff([1], [], number_compare_ascending)).toEqual({
-        uniqueA: [1],
-        uniqueB: [],
-        common: []
-    });
-});
-
-test('[1] and [1] inputs', () => {
-    expect(arraySetSortingDiff([1], [1], number_compare_ascending)).toEqual({
-        uniqueA: [],
-        uniqueB: [],
-        common: [1]
-    });
-});
-
-test('[1] and [1,2] inputs', () => {
-    expect(arraySetSortingDiff([1], [1, 2], number_compare_ascending)).toEqual({
-        uniqueA: [],
-        uniqueB: [2],
-        common: [1]
-    });
-});
-
-test('[1,2] and [1] inputs', () => {
-    expect(arraySetSortingDiff([1, 2], [1], number_compare_ascending)).toEqual({
-        uniqueA: [2],
-        uniqueB: [],
-        common: [1]
-    });
-});
-
-test('[5,4,3,2,1] and [1,2,3,4,5] inputs', () => {
-    expect(arraySetSortingDiff([5, 4, 3, 2, 1], [1, 2, 3, 4, 5], number_compare_ascending)).toEqual({
-        uniqueA: [],
-        uniqueB: [],
-        common: [1, 2, 3, 4, 5]
-    });
-});
-
-test('[5,1] and [1,2,3,4,5] inputs', () => {
-    expect(arraySetSortingDiff([5, 1], [1, 2, 3, 4, 5], number_compare_ascending)).toEqual({
-        uniqueA: [],
-        uniqueB: [2, 3, 4],
-        common: [1, 5]
-    });
-});
-
-test('[1,2,3,4,5] and [5,1] inputs', () => {
-    expect(arraySetSortingDiff([1, 2, 3, 4, 5], [5, 1], number_compare_ascending)).toEqual({
-        uniqueA: [2, 3, 4],
-        uniqueB: [],
-        common: [1, 5]
-    });
-});

package/src/core/collection/array/array_contains_duplicates.spec.js

@@ -1,14 +0,0 @@
-import { array_contains_duplicates } from "./array_contains_duplicates.js";
-
-test("basics", () => {
-    expect(array_contains_duplicates([])).toBe(false);
-
-    expect(array_contains_duplicates([1])).toBe(false);
-
-    expect(array_contains_duplicates([1, 2, 3])).toBe(false);
-
-    expect(array_contains_duplicates([1, 1])).toBe(true);
-    expect(array_contains_duplicates([0, 1, 1])).toBe(true);
-    expect(array_contains_duplicates([1, 0, 1])).toBe(true);
-    expect(array_contains_duplicates([1, 1, 0])).toBe(true);
-});

package/src/core/collection/array/array_copy.spec.js

@@ -1,19 +0,0 @@
-import { array_copy } from "./array_copy.js";
-
-test("empty array copy", () => {
-
-    const target = [];
-
-    array_copy([], 0, target, 0, 0);
-
-    expect(target).toEqual([]);
-});
-
-test("copy portion", () => {
-
-    const target = [7, 8, 9];
-
-    array_copy([1, 2, 3, 4], 1, target, 1, 2);
-
-    expect(target).toEqual([7, 2, 3])
-});

package/src/core/collection/array/array_deduplicate.spec.js

@@ -1,11 +0,0 @@
-import { array_deduplicate } from "./array_deduplicate.js";
-
-test("basics", () => {
-    expect(array_deduplicate([])).toEqual([]);
-    expect(array_deduplicate([1])).toEqual([1]);
-    expect(array_deduplicate([1, 2])).toEqual([1, 2]);
-    expect(array_deduplicate([1, 2, 2])).toEqual([1, 2]);
-    expect(array_deduplicate([1, 2, 1])).toEqual([1, 2]);
-    expect(array_deduplicate([1, 1, 2])).toEqual([1, 2]);
-    expect(array_deduplicate([1, 2])).toEqual([1, 2]);
-});

package/src/core/collection/array/array_get_index_in_range.spec.js

@@ -1,16 +0,0 @@
-import { array_get_index_in_range } from "./array_get_index_in_range.js";
-
-test("basics", () => {
-
-    expect(array_get_index_in_range([], 1, 0, -1)).toBe(-1);
-    expect(array_get_index_in_range([1], 1, 0, 0)).toBe(0);
-
-    expect(array_get_index_in_range([3, 1], 1, 0, 1)).toBe(1);
-    expect(array_get_index_in_range([3, 1], 1, 0, 0)).toBe(-1);
-    expect(array_get_index_in_range([3, 1], 1, 1, 1)).toBe(1);
-
-    expect(array_get_index_in_range([1, 3], 1, 0, 1)).toBe(0);
-    expect(array_get_index_in_range([1, 3], 1, 1, 1)).toBe(-1);
-    expect(array_get_index_in_range([1, 3], 1, 0, 0)).toBe(0);
-
-});

package/src/core/collection/array/array_remove_first.spec.js

@@ -1,39 +0,0 @@
-import { array_remove_first } from "./array_remove_first.js";
-
-test("basics", () => {
-
-    expect(array_remove_first([], 1)).toBe(false);
-    expect(array_remove_first([2], 1)).toBe(false);
-    expect(array_remove_first([2, 3], 1)).toBe(false);
-
-    let array = [1];
-
-    expect(array_remove_first(array, 1)).toBe(true);
-
-    expect(array).toEqual([]);
-
-    array = [1, 1];
-
-    expect(array_remove_first(array, 1)).toBe(true);
-
-    expect(array).toEqual([1]);
-
-    array = [2, 1];
-
-    expect(array_remove_first(array, 1)).toBe(true);
-
-    expect(array).toEqual([2]);
-
-    array = [1, 2];
-
-    expect(array_remove_first(array, 1)).toBe(true);
-
-    expect(array).toEqual([2]);
-
-    array = [1, 2, 1];
-
-    expect(array_remove_first(array, 1)).toBe(true);
-
-    expect(array).toEqual([2, 1]);
-
-});

package/src/core/collection/array/array_shuffle.spec.js

@@ -1,27 +0,0 @@
-import { array_shuffle } from "./array_shuffle.js";
-
-test("sanity", () => {
-
-    const random = () => 0;
-
-    const a = [];
-
-    array_shuffle(random, a);
-
-    expect(a).toEqual([]);
-
-    const b = [1];
-
-    array_shuffle(random, b);
-
-    expect(b).toEqual([1]);
-
-    const c = [1, 2, 3];
-
-    array_shuffle(random, c);
-
-    expect(c.length).toBe(3);
-    expect(c).toContain(1);
-    expect(c).toContain(2);
-    expect(c).toContain(3);
-});

package/src/core/collection/array/binarySearchHighIndex.spec.js

@@ -1,51 +0,0 @@
-import { binarySearchHighIndex } from "./binarySearchHighIndex.js";
-
-import { number_compare_ascending } from "../../primitives/numbers/number_compare_ascending.js";
-
-test('exact match single element 1', () => {
-    expect(
-        binarySearchHighIndex([1], 1, number_compare_ascending, 0, 0)
-    ).toBe(0);
-});
-
-test('exact match single element 0', () => {
-    expect(
-        binarySearchHighIndex([0], 0, number_compare_ascending, 0, 0)
-    ).toBe(0);
-});
-
-test('exact match single element -1', () => {
-    expect(
-        binarySearchHighIndex([-1], -1, number_compare_ascending, 0, 0)
-    ).toBe(0);
-});
-
-test('0 -> 0,0', () => {
-    expect(
-        binarySearchHighIndex([0, 0], 0, number_compare_ascending, 0, 1)
-    ).toBe(0);
-});
-
-test('0 -> 0,1', () => {
-    expect(
-        binarySearchHighIndex([0, 1], 0, number_compare_ascending, 0, 1)
-    ).toBe(0);
-});
-
-test('1 -> 1,1', () => {
-    expect(
-        binarySearchHighIndex([1, 1], 1, number_compare_ascending, 0, 1)
-    ).toBe(0);
-});
-
-test('0 -> 1,2', () => {
-    expect(
-        binarySearchHighIndex([1, 2], 0, number_compare_ascending, 0, 1)
-    ).toBe(0);
-});
-
-test('1.5 -> 1,2', () => {
-    expect(
-        binarySearchHighIndex([1, 2], 1.5, number_compare_ascending, 0, 1)
-    ).toBe(1);
-});

package/src/core/collection/array/isArrayEqual.spec.js

@@ -1,25 +0,0 @@
-import { isArrayEqual } from "./isArrayEqual.js";
-
-test("empty", () => {
-
-    expect(isArrayEqual([], [])).toBe(true);
-
-});
-
-test("primitives", () => {
-
-    expect(isArrayEqual([1], [1])).toBe(true);
-    expect(isArrayEqual([1], [7])).toBe(false);
-
-    expect(isArrayEqual([1, 3], [1, 3])).toBe(true);
-
-    expect(isArrayEqual([""], [""])).toBe(true);
-    expect(isArrayEqual(["a"], ["a"])).toBe(true);
-    expect(isArrayEqual(["a"], ["b"])).toBe(false);
-    expect(isArrayEqual(["a"], ["a", "b"])).toBe(false);
-
-    expect(isArrayEqual([true], [true])).toBe(true);
-    expect(isArrayEqual([true], [true, true])).toBe(false);
-    expect(isArrayEqual([true], [false])).toBe(false);
-
-});

package/src/core/collection/array/typed/is_typed_array_equals.spec.js

@@ -1,71 +0,0 @@
-import { is_typed_array_equals } from "./is_typed_array_equals.js";
-
-test("small uint32 arrays", () => {
-    expect(is_typed_array_equals(
-        new Uint32Array(0),
-        new Uint32Array(0)
-    )).toBe(true);
-
-    expect(is_typed_array_equals(
-        new Uint32Array([1, 3, 5]),
-        new Uint32Array([1, 3, 5])
-    )).toBe(true);
-
-    expect(is_typed_array_equals(
-        new Uint32Array([7, 3]),
-        new Uint32Array([1, 3])
-    )).toBe(false);
-
-    expect(is_typed_array_equals(
-        new Uint32Array([1, 3]),
-        new Uint32Array([7, 3])
-    )).toBe(false);
-
-    expect(is_typed_array_equals(
-        new Uint32Array([1, 7]),
-        new Uint32Array([1, 3])
-    )).toBe(false);
-
-    expect(is_typed_array_equals(
-        new Uint32Array([1, 3]),
-        new Uint32Array([1, 7])
-    )).toBe(false);
-
-    expect(is_typed_array_equals(
-        new Uint32Array([1, 3]),
-        new Uint32Array([1, 3, 7])
-    )).toBe(false);
-
-    expect(is_typed_array_equals(
-        new Uint32Array([1, 3, 7]),
-        new Uint32Array([1, 3])
-    )).toBe(false);
-
-});
-
-test("large uin32 array", () => {
-    expect(is_typed_array_equals(
-        new Uint32Array(1024),
-        new Uint32Array(1024),
-    )).toBe(true);
-
-    expect(is_typed_array_equals(
-        new Uint32Array(1024),
-        new Uint32Array(1023),
-    )).toBe(false);
-
-    expect(is_typed_array_equals(
-        new Uint32Array(1023),
-        new Uint32Array(1024),
-    )).toBe(false);
-
-    const a = new Uint32Array(1024);
-    const b = new Uint32Array(1024);
-
-    a[127] = 1;
-
-    expect(is_typed_array_equals(
-        a,
-        b,
-    )).toBe(false);
-});

package/src/core/collection/array/weightedRandomFromArray.spec.js

@@ -1,22 +0,0 @@
-import { passThrough } from "../../function/passThrough.js";
-import { returnOne } from "../../function/returnOne.js";
-import { returnZero } from "../../function/returnZero.js";
-import { weightedRandomFromArray } from "./weightedRandomFromArray.js";
-
-test("empty array", () => {
-    expect(weightedRandomFromArray([], returnZero, passThrough, null, 0))
-        .toBeUndefined();
-});
-
-test("single element array", () => {
-    expect(weightedRandomFromArray([1], returnZero, passThrough, null, 1))
-        .toBe(1);
-});
-
-test("two elements", () => {
-    expect(weightedRandomFromArray([1,3], returnZero, passThrough, null, 2))
-        .toBe(1);
-
-    expect(weightedRandomFromArray([1,3], returnOne, passThrough, null, 2))
-        .toBe(3);
-});