wenay-common2 1.0.69 → 1.0.70

package/oracle/regression/bytestream.spec.ts

@@ -0,0 +1,152 @@
+import {ByteStreamR, ByteStreamW, NumericTypes, nullable} from '../../src/Common/data/ByteStream'
+
+type TestCase = {
+    name: string
+    run: () => void
+}
+
+const numericTypes: NumericTypes[] = [
+    'int8',
+    'uint8',
+    'int16',
+    'uint16',
+    'int24',
+    'uint24',
+    'int32',
+    'uint32',
+    'int48',
+    'uint48',
+    'int64',
+    'uint64',
+    'float',
+    'double',
+]
+
+function assert(condition: unknown, message: string): asserts condition {
+    if (!condition) throw new Error(message)
+}
+
+function assertDeepEqual(actual: unknown, expected: unknown, message: string) {
+    const actualText = JSON.stringify(actual)
+    const expectedText = JSON.stringify(expected)
+    if (actualText !== expectedText) {
+        throw new Error(`${message}: expected ${expectedText}, got ${actualText}`)
+    }
+}
+
+function assertThrows(fn: () => unknown, message: string) {
+    let threw = false
+    try {
+        fn()
+    } catch {
+        threw = true
+    }
+    assert(threw, message)
+}
+
+const tests: TestCase[] = [
+    {
+        name: 'nullable numeric null writes and reads null for every numeric type',
+        run() {
+            const stream = new ByteStreamW()
+            for (const type of numericTypes) {
+                assert(stream.pushNumber(null as any, nullable(type)) !== null, `write ${type} null`)
+            }
+
+            const reader = new ByteStreamR(stream.data)
+            for (const type of numericTypes) {
+                assert(reader.readNumber(nullable(type)) === null, `read ${type} nullable null`)
+            }
+            assert(stream.length === numericTypes.length, 'nullable null values occupy only presence bytes')
+        },
+    },
+    {
+        name: 'truncated uint8 array throws and noThrow returns null',
+        run() {
+            const data = new DataView(new ArrayBuffer(6))
+            data.setUint32(0, 3)
+            data.setUint8(4, 10)
+            data.setUint8(5, 20)
+
+            assertThrows(() => new ByteStreamR(data).readArray('uint8'), 'truncated uint8 array throws')
+            assert(new ByteStreamR(data).noThrow().readArray('uint8') === null, 'truncated uint8 noThrow returns null')
+        },
+    },
+    {
+        name: 'truncated int8 array throws and noThrow returns null',
+        run() {
+            const data = new DataView(new ArrayBuffer(5))
+            data.setUint32(0, 2)
+            data.setInt8(4, -1)
+
+            assertThrows(() => new ByteStreamR(data).readArray('int8'), 'truncated int8 array throws')
+            assert(new ByteStreamR(data).noThrow().readArray('int8') === null, 'truncated int8 noThrow returns null')
+        },
+    },
+    {
+        name: 'pushArray writes into a DataView byteOffset and data keeps that byteOffset',
+        run() {
+            const backing = new ArrayBuffer(32)
+            const offset = 7
+            const stream = new ByteStreamW(new DataView(backing, offset, 20))
+            stream.pushArray(new Uint8Array([9, 8, 7]))
+
+            const data = stream.data
+            assert(data.byteOffset === offset, `data byteOffset is preserved: ${data.byteOffset}`)
+            assert(data.byteLength === 7, `data byteLength is written length: ${data.byteLength}`)
+            assertDeepEqual(Array.from(new Uint8Array(backing, 0, offset)), [0, 0, 0, 0, 0, 0, 0], 'bytes before offset remain untouched')
+            assertDeepEqual(Array.from(new Uint8Array(data.buffer, data.byteOffset, data.byteLength)), [0, 0, 0, 3, 9, 8, 7], 'array bytes are written at offset')
+            assertDeepEqual(new ByteStreamR(data).readArray('uint8'), [9, 8, 7], 'offset data reads back')
+        },
+    },
+    {
+        name: 'numeric arrays round-trip signed, unsigned, floating and nullable values',
+        run() {
+            const stream = new ByteStreamW()
+            stream.pushArrayNumeric([-32768, -1, 0, 32767], 'int16')
+            stream.pushArrayNumeric([0, 1, 0x123456, 0xffffff], 'uint24')
+            stream.pushArrayNumeric([1.5, null as any, -2.25], nullable('double'))
+
+            const reader = new ByteStreamR(stream.data)
+            assertDeepEqual(reader.readArray('int16'), [-32768, -1, 0, 32767], 'int16 array round-trip')
+            assertDeepEqual(reader.readArray('uint24'), [0, 1, 0x123456, 0xffffff], 'uint24 array round-trip')
+            assertDeepEqual(reader.readArray(nullable('double')), [1.5, null, -2.25], 'nullable double array round-trip')
+        },
+    },
+    {
+        name: 'strings round-trip nulls and null-terminated values',
+        run() {
+            const stream = new ByteStreamW()
+            stream.pushAnsi(null)
+            stream.pushAnsi('abc')
+            stream.pushUnicode(null)
+            stream.pushUnicode('AZ')
+
+            const data = stream.data
+            const bytes = Array.from(new Uint8Array(data.buffer, data.byteOffset, data.byteLength))
+            assertDeepEqual(bytes.slice(0, 6), [0, 1, 97, 98, 99, 0], 'ansi null marker and terminator are written')
+            assertDeepEqual(bytes.slice(6), [0, 1, 0, 65, 0, 90, 0, 0], 'unicode null marker and terminator are written')
+
+            const reader = new ByteStreamR(data)
+            assert(reader.readAnsi() === null, 'ansi null reads null')
+            assert(reader.readAnsi() === 'abc', 'ansi value reads to terminator')
+            assert(reader.readUnicode() === null, 'unicode null reads null')
+            assert(reader.readUnicode() === 'AZ', 'unicode value reads to terminator')
+        },
+    },
+]
+
+let failures = 0
+for (const test of tests) {
+    try {
+        test.run()
+        console.log('ok', test.name)
+    } catch (error) {
+        failures++
+        console.error('FAIL', test.name)
+        console.error(error)
+    }
+}
+
+console.log(`\n${tests.length - failures}/${tests.length} ByteStream regression tests passed`)
+process.exit(failures === 0 ? 0 : 1)

package/oracle/regression/clientapiall-replay-types.spec.ts

@@ -0,0 +1,47 @@
+// Oracle: ClientAPIAll/ClientAPIStrict replay projection is a TYPE-level contract, and
+// tsconfig excludes *.spec.ts while oracles run ts-node --transpile-only — so the check
+// here is an explicit `tsc --noEmit` over the fixture. A negative control compiles a
+// deliberately broken snippet first: if THAT passes, the tsc invocation itself is broken
+// and a green fixture would mean nothing.
+
+import {spawnSync} from 'node:child_process'
+import {writeFileSync, rmSync, mkdtempSync} from 'node:fs'
+import {tmpdir} from 'node:os'
+import path from 'node:path'
+
+const root = path.resolve(__dirname, '..', '..')
+const tsc = path.join(root, 'node_modules', 'typescript', 'bin', 'tsc')
+const flags = ['--noEmit', '--strict', '--target', 'esnext', '--module', 'commonjs',
+    '--moduleResolution', 'node', '--esModuleInterop', '--skipLibCheck']
+
+function typecheck(file: string) {
+    const res = spawnSync(process.execPath, [tsc, ...flags, file],
+        {cwd: root, encoding: 'utf8', timeout: 240_000, maxBuffer: 16 * 1024 * 1024})
+    return {ok: res.status === 0, out: (res.stdout ?? '') + (res.stderr ?? '')}
+}
+
+let failures = 0
+function report(name: string, ok: boolean, detail = '') {
+    if (ok) console.log(`OK ${name}`)
+    else {
+        failures++
+        console.error(`FAIL ${name}`)
+        if (detail) console.error(detail.trim().split(/\r?\n/).slice(0, 20).join('\n'))
+    }
+}
+
+// negative control — a broken file MUST fail
+const dir = mkdtempSync(path.join(tmpdir(), 'wenay-types-'))
+const bad = path.join(dir, 'bad.ts')
+writeFileSync(bad, 'const x: number = "not a number"\nexport {x}\n')
+const badRes = typecheck(bad)
+report('negative control: broken snippet fails to compile', !badRes.ok)
+rmSync(dir, {recursive: true, force: true})
+
+// the fixture — replay projection with no casts must compile clean
+const fixture = path.join(root, 'oracle', 'regression', '_clientapiall-replay.fixture.ts')
+const fixRes = typecheck(fixture)
+report('ClientAPIAll/Strict replay projection compiles with no casts', fixRes.ok, fixRes.out)
+
+console.log(failures === 0 ? 'ALL GREEN (2)' : `${failures} FAILURE(S) / 2`)
+process.exit(failures === 0 ? 0 : 1)

package/oracle/regression/core-clone-equal.spec.ts

@@ -0,0 +1,124 @@
+import {
+    CancelablePromise,
+    MapExt,
+    StructMap,
+    StructSet,
+    clone,
+    deepEqual,
+} from '../../src/Common/core/common'
+
+let fails = 0
+
+function assert(cond: any, msg: string) {
+    if (cond) console.log('  ok  :', msg)
+    else { fails++; console.log('  FAIL:', msg) }
+}
+
+async function assertRejects(promise: Promise<any>, expected: any, msg: string) {
+    try {
+        await promise
+        assert(false, msg + ' (resolved)')
+    }
+    catch (e) {
+        assert(e === expected, msg)
+    }
+}
+
+async function main() {
+    // clone: cycles are preserved without reusing original objects.
+    {
+        const src: any = { name: 'root' }
+        src.self = src
+        src.child = { parent: src }
+
+        const copy = clone(src) as any
+
+        assert(copy !== src, 'clone creates a new root object')
+        assert(copy.self === copy, 'clone preserves direct object cycle')
+        assert(copy.child !== src.child, 'clone creates a new nested object')
+        assert(copy.child.parent === copy, 'clone rewires nested cycle to cloned root')
+    }
+
+    // clone: Map and Set entries are deeply cloned.
+    {
+        const key = { id: 1 }
+        const val = { nested: { n: 2 } }
+        const setItem = { tag: 'set-item' }
+        const src = {
+            map: new Map<any, any>([[key, val]]),
+            set: new Set<any>([setItem]),
+        }
+
+        const copy = clone(src)
+        const [[copyKey, copyVal]] = copy.map.entries()
+        const [copySetItem] = copy.set.values()
+
+        assert(copy.map !== src.map, 'clone creates a new Map')
+        assert(copy.set !== src.set, 'clone creates a new Set')
+        assert(copyKey !== key && copyKey.id === key.id, 'clone deep-clones Map keys')
+        assert(copyVal !== val && copyVal.nested !== val.nested && copyVal.nested.n === 2, 'clone deep-clones Map values')
+        assert(copySetItem !== setItem && copySetItem.tag === setItem.tag, 'clone deep-clones Set values')
+    }
+
+    // deepEqual: null, Date, Map, and Set equality.
+    {
+        assert(deepEqual(null, null), 'deepEqual treats null values as equal')
+        assert(!deepEqual(null, {}), 'deepEqual treats null and object as different')
+        assert(deepEqual(new Date('2024-01-02T03:04:05.000Z'), new Date('2024-01-02T03:04:05.000Z')), 'deepEqual compares Date time values')
+        assert(!deepEqual(new Date('2024-01-02T03:04:05.000Z'), new Date('2024-01-02T03:04:06.000Z')), 'deepEqual rejects different Date time values')
+        assert(deepEqual(new Map([['a', { n: 1 }]]), new Map([['a', { n: 1 }]])), 'deepEqual compares Map values structurally')
+        assert(!deepEqual(new Map([['a', { n: 1 }]]), new Map([['a', { n: 2 }]])), 'deepEqual rejects different Map values')
+        assert(deepEqual(new Set(['a', 'b']), new Set(['b', 'a'])), 'deepEqual compares Set membership')
+        assert(!deepEqual(new Set(['a', 'b']), new Set(['a', 'c'])), 'deepEqual rejects different Set membership')
+    }
+
+    // StructMap/StructSet: missing composite lookup over null/primitive leaves stays safe.
+    {
+        const map = new StructMap<readonly number[], null>()
+        map.set([1], null)
+
+        const set = new StructSet<readonly number[]>()
+        set.add([1])
+
+        assert(map.has([1]), 'StructMap.has finds a null leaf value')
+        assert(!map.has([1, 2]), 'StructMap.has returns false when a null leaf is used as a prefix')
+        assert(set.has([1]), 'StructSet.has finds an entry stored as a null value')
+        assert(!set.has([1, 2]), 'StructSet.has returns false when its null value is used as a prefix')
+    }
+
+    // MapExt: clear invalidates valuesArrayImmutable cache.
+    {
+        const map = new MapExt<string, number>([['a', 1], ['b', 2]])
+        const before = map.valuesArrayImmutable()
+        map.clear()
+        map.set('c', 3)
+        const after = map.valuesArrayImmutable()
+
+        assert(before !== after, 'MapExt.clear invalidates valuesArrayImmutable cache')
+        assert(after.length === 1 && after[0] === 3, 'MapExt valuesArrayImmutable reflects entries after clear')
+    }
+
+    // JSON.stringify patch: array replacer keeps native allow-list semantics.
+    {
+        const text = JSON.stringify({ a: 1, b: 2, nested: { a: 3, b: 4 } }, ['a', 'nested'])
+        assert(text === '{"a":1,"nested":{"a":3}}', 'JSON.stringify supports array replacer allow-list')
+    }
+
+    // CancelablePromise: nested cancel can cascade through the onCancel hook.
+    {
+        let innerCancelled = false
+        const inner = new CancelablePromise<string>(() => {}, () => { innerCancelled = true })
+        const outer = new CancelablePromise<string>((resolve) => resolve(inner), () => inner.cancel('inner-cancelled'))
+
+        const rejection = assertRejects(outer, 'inner-cancelled', 'CancelablePromise nested cancel rejects the outer promise through the inner promise')
+        outer.cancel('outer-cancelled')
+        await rejection
+        await assertRejects(inner, 'inner-cancelled', 'CancelablePromise nested cancel rejects the inner promise')
+        assert(innerCancelled, 'CancelablePromise nested cancel runs the inner onCancel hook')
+    }
+
+    console.log(`\n${fails === 0 ? 'ALL GREEN' : fails + ' FAILURE(S)'}`)
+    process.exit(fails === 0 ? 0 : 1)
+}
+
+main().catch(e => { console.error(e); process.exit(2) })

package/oracle/regression/data-structures.spec.ts

@@ -0,0 +1,135 @@
+import {CList} from "../../src/Common/data/List";
+import {CListNodeAnd} from "../../src/Common/data/ListNodeAnd";
+import {objectGet, objectSet, objectUnset} from "../../src/Common/data/objectPath";
+import {createRateWindow} from "../../src/Common/funcTimeWait";
+
+type Test = {
+    name: string;
+    fn: () => void;
+};
+
+const tests: Test[] = [];
+
+function test(name: string, fn: () => void) {
+    tests.push({name, fn});
+}
+
+function assert(condition: unknown, message: string): asserts condition {
+    if (!condition) throw new Error(message);
+}
+
+function assertEq<T>(actual: T, expected: T, message: string) {
+    if (actual !== expected) {
+        throw new Error(`${message}: expected ${String(expected)}, got ${String(actual)}`);
+    }
+}
+
+function assertArrayEq<T>(actual: readonly T[], expected: readonly T[], message: string) {
+    const same = actual.length === expected.length && actual.every((value, index) => value === expected[index]);
+    if (!same) {
+        throw new Error(`${message}: expected ${JSON.stringify(expected)}, got ${JSON.stringify(actual)}`);
+    }
+}
+
+function captureThrow(fn: () => void) {
+    try {
+        fn();
+    } catch (error) {
+        return error;
+    }
+    throw new Error("expected function to throw");
+}
+
+test("CList iteration survives deleting the next node", () => {
+    const list = new CList([1, 2, 3, 4]);
+    const node2 = list.find(2);
+    const visited: number[] = [];
+
+    assert(node2, "node to delete exists");
+
+    for (const node of list) {
+        visited.push(node.value);
+        if (node.value === 1) {
+            list.delete(node2);
+        }
+    }
+
+    assertArrayEq(visited, [1, 3, 4], "iterator skips the deleted next node and continues");
+    assertArrayEq([...list.values()], [1, 3, 4], "list contents are linked after deleting next node");
+    assertEq(list.size, 3, "list size reflects deleted next node");
+});
+
+test("CList reversed iteration walks from last to first", () => {
+    const list = new CList(["first", "second", "third"]);
+
+    assertArrayEq([...list.reversedValues()], ["third", "second", "first"], "reversedValues returns tail-to-head order");
+    assertArrayEq([...list.reversedNodes()].map(node => node.value), ["third", "second", "first"], "reversedNodes returns tail-to-head nodes");
+});
+
+test("CListNodeAnd keeps falsy values", () => {
+    const list = new CListNodeAnd<0 | false | "">();
+
+    list.AddEnd(0);
+    list.AddEnd(false);
+    list.AddEnd("");
+
+    assertArrayEq(list.GetArray(), [0, false, ""], "legacy list stores falsy values passed to AddEnd");
+    assertEq(list.dataFirst, 0, "dataFirst preserves 0");
+    assertEq(list.dataEnd, "", "dataEnd preserves empty string");
+    assertEq(list.find(node => node.data === false)?.data, false, "find can observe false data");
+});
+
+test("objectPath null traversal throws domain errors, not native TypeError", () => {
+    const getError = captureThrow(() => objectGet({a: null} as any, ["a", "b"]));
+    const setError = captureThrow(() => objectSet({a: null} as any, ["a", "b"], 1));
+    const unsetError = captureThrow(() => objectUnset({a: null} as any, ["a", "b"]));
+
+    assert(!(getError instanceof TypeError), "objectGet null traversal is not a native TypeError");
+    assert(!(setError instanceof TypeError), "objectSet null traversal is not a native TypeError");
+    assert(!(unsetError instanceof TypeError), "objectUnset null traversal is not a native TypeError");
+    assertEq(String(getError), "value is not an object: null", "objectGet reports null traversal");
+    assertEq(String(setError), "value is not an object: null", "objectSet reports null traversal");
+    assertEq(String(unsetError), "value is not an object: null", "objectUnset reports null traversal");
+});
+
+test("rate window handles out-of-order timestamps", () => {
+    const originalNow = Date.now;
+    const window = createRateWindow();
+
+    try {
+        Date.now = () => 350;
+        window.add({type: "UID", timeStamp: 300, weight: 3});
+        window.add({type: "UID", timeStamp: 100, weight: 1});
+        window.add({type: "UID", timeStamp: 200, weight: 2});
+
+        assertArrayEq(window.dStatic.UID.map(([time]) => time), [100, 200, 300], "add keeps timestamps sorted");
+        assertEq(window.sumWeight("UID", 175), 5, "sumWeight includes only entries inside the active window");
+        assertArrayEq(window.dStatic.UID.map(([time]) => time), [200, 300], "sumWeight prunes old sorted entries");
+
+        window.add({type: "UID", timeStamp: 250, weight: 4});
+        assertArrayEq(window.dStatic.UID.map(([time]) => time), [200, 250, 300], "later out-of-order add is inserted in timestamp order");
+        assertEq(window.readyAt("UID", 5), 300, "readyAt uses sorted time order when weights cross the limit");
+        assertEq(window.byWeightTimeNow("UID", 250, 5), 250, "byWeightTimeNow ignores future entries after sorting");
+    } finally {
+        Date.now = originalNow;
+    }
+});
+
+let failed = 0;
+
+for (const {name, fn} of tests) {
+    try {
+        fn();
+        console.log(`ok - ${name}`);
+    } catch (error) {
+        failed++;
+        console.error(`not ok - ${name}`);
+        console.error(error);
+    }
+}
+
+if (failed > 0) {
+    throw new Error(`${failed} data-structures regression test(s) failed`);
+}
+
+console.log(`${tests.length} data-structures regression tests passed`);

package/oracle/regression/listen-events.spec.ts

@@ -0,0 +1,206 @@
+import {listen as createListenPair} from "../../src/Common/events/Listen";
+import {CObjectEventsArr, CObjectEventsList, tListEvent} from "../../src/Common/events/event";
+
+type Test = {
+    name: string;
+    fn: () => void;
+};
+
+const tests: Test[] = [];
+
+function test(name: string, fn: () => void) {
+    tests.push({name, fn});
+}
+
+function assert(condition: unknown, message: string): asserts condition {
+    if (!condition) throw new Error(message);
+}
+
+function assertEq<T>(actual: T, expected: T, message: string) {
+    if (actual !== expected) {
+        throw new Error(`${message}: expected ${String(expected)}, got ${String(actual)}`);
+    }
+}
+
+test("duplicate same callback has independent off handles", () => {
+    const [emit, listen] = createListenPair<[number]>();
+    let sum = 0;
+    const cb = (value: number) => {
+        sum += value;
+    };
+
+    const off1 = listen.on(cb);
+    const off2 = listen.on(cb);
+
+    assertEq(listen.count(), 2, "same callback can be registered twice");
+    emit(2);
+    assertEq(sum, 4, "both duplicate subscriptions receive events");
+
+    off1();
+    assertEq(listen.count(), 1, "first off removes only one duplicate subscription");
+    emit(3);
+    assertEq(sum, 7, "second duplicate remains active after first off");
+
+    off2();
+    assertEq(listen.count(), 0, "second off removes remaining duplicate subscription");
+    emit(5);
+    assertEq(sum, 7, "no duplicate subscriptions remain active");
+});
+
+test("keyed overwrite cleans previous cbClose registration", () => {
+    const [emit, listen] = createListenPair<[string]>();
+    const calls: string[] = [];
+    let oldClosed = 0;
+    let newClosed = 0;
+
+    listen.on(value => calls.push(`old:${value}`), {
+        key: "slot",
+        cbClose: () => oldClosed++,
+    });
+    listen.on(value => calls.push(`new:${value}`), {
+        key: "slot",
+        cbClose: () => newClosed++,
+    });
+
+    assertEq(listen.count(), 1, "key overwrite keeps one subscription");
+    emit("event");
+    assertEq(calls.join(","), "new:event", "key overwrite replaces callback");
+
+    listen.close();
+
+    assertEq(oldClosed, 0, "overwritten cbClose is removed from close registry");
+    assertEq(newClosed, 1, "current keyed cbClose runs on close");
+});
+
+test("off(cb) removes all entries for the callback", () => {
+    const [emit, listen] = createListenPair<[number]>();
+    let removedCallbackCalls = 0;
+    let otherCallbackCalls = 0;
+    const cb = () => {
+        removedCallbackCalls++;
+    };
+
+    listen.on(cb);
+    listen.on(cb);
+    listen.on(() => {
+        otherCallbackCalls++;
+    });
+
+    assertEq(listen.count(), 3, "initial subscriptions are registered");
+    listen.off(cb);
+    assertEq(listen.count(), 1, "off(cb) removes every subscription for cb");
+
+    emit(1);
+    assertEq(removedCallbackCalls, 0, "removed callback is not called");
+    assertEq(otherCallbackCalls, 1, "unrelated callback remains active");
+});
+
+test("close handlers support off and close clears listeners", () => {
+    const [emit, listen] = createListenPair<[void]>();
+    let listenerCalls = 0;
+    let closeOffCalls = 0;
+    let onCloseCalls = 0;
+    let cbCloseCalls = 0;
+
+    const offListener = listen.on(() => {
+        listenerCalls++;
+    }, {
+        cbClose: () => cbCloseCalls++,
+    });
+    const offEventClose = listen.onClose(() => {
+        closeOffCalls++;
+    });
+    listen.onClose(() => {
+        onCloseCalls++;
+    });
+
+    offEventClose();
+    listen.close();
+
+    assertEq(listenerCalls, 0, "close does not emit regular listeners");
+    assertEq(cbCloseCalls, 1, "per-subscription cbClose runs on close");
+    assertEq(closeOffCalls, 0, "onClose off prevents close callback");
+    assertEq(onCloseCalls, 1, "onClose callback runs on close");
+    assertEq(listen.count(), 0, "close clears regular listeners");
+
+    offListener();
+    emit();
+    assertEq(listenerCalls, 0, "off after close remains harmless");
+});
+
+test("once unsubscribes after first event and supports early off", () => {
+    const [emit, listen] = createListenPair<[number]>();
+    let onceCalls = 0;
+    let earlyOffCalls = 0;
+
+    listen.once(value => {
+        onceCalls += value;
+    });
+    emit(2);
+    emit(3);
+
+    assertEq(onceCalls, 2, "once callback receives only the first event");
+    assertEq(listen.count(), 0, "once subscription removes itself after firing");
+
+    const off = listen.once(() => {
+        earlyOffCalls++;
+    });
+    off();
+    emit(4);
+
+    assertEq(earlyOffCalls, 0, "off returned from once removes subscription before event");
+    assertEq(listen.count(), 0, "early once off leaves no subscriptions");
+});
+
+test("CObjectEventsArr Clean calls OnDel and removes every item", () => {
+    const events = new CObjectEventsArr<object>();
+    const deleted: string[] = [];
+    const first: tListEvent = {OnDel: () => deleted.push("first")};
+    const second: tListEvent = {OnDel: () => deleted.push("second")};
+
+    events.Add(first);
+    events.Add(second);
+    events.Clean();
+
+    assertEq(events.count(), 0, "array event Clean removes every item");
+    assertEq(deleted.join(","), "second,first", "array event Clean calls OnDel during deletion");
+
+    events.Clean();
+    assertEq(deleted.join(","), "second,first", "array event Clean after empty does not call OnDel again");
+});
+
+test("CObjectEventsList Clean calls OnDel and removes every item", () => {
+    const events = new CObjectEventsList<object>(false);
+    const deleted: string[] = [];
+    const first: tListEvent<object> = {OnDel: () => deleted.push("first")};
+    const second: tListEvent<object> = {OnDel: () => deleted.push("second")};
+
+    events.Add(first);
+    events.Add(second);
+    events.Clean();
+
+    assertEq(events.count(), 0, "list event Clean removes every item");
+    assertEq(deleted.join(","), "second,first", "list event Clean calls OnDel during deletion");
+
+    events.Clean();
+    assertEq(deleted.join(","), "second,first", "list event Clean after empty does not call OnDel again");
+});
+
+let failed = 0;
+
+for (const {name, fn} of tests) {
+    try {
+        fn();
+        console.log(`ok - ${name}`);
+    } catch (error) {
+        failed++;
+        console.error(`not ok - ${name}`);
+        console.error(error);
+    }
+}
+
+if (failed > 0) {
+    throw new Error(`${failed} listen/event regression test(s) failed`);
+}
+
+console.log(`${tests.length} listen/event regression tests passed`);