data-structure-typed 2.4.1 → 2.4.3

package/test/unit/data-structures/binary-tree/tree-multi-map.more-branches-2.coverage.test.ts.skip

@@ -1,59 +0,0 @@
-import { TreeMultiMap, TreeMultiMapNode } from '../../../../src';
-
-describe('TreeMultiMap additional branch coverage (batch 2)', () => {
-  it('set(node) takes isRealNode early-return path', () => {
-    const t = new TreeMultiMap<number, string>([], { isMapMode: false });
-
-    const n = new TreeMultiMapNode<number, string>(1, ['a']);
-    expect(t.set(n as any)).toBe(true);
-    expect(t.get(1)).toEqual(['a']);
-  });
-
-  it('set() returns false when key exists but incoming values are undefined (covers values===undefined else branch)', () => {
-    const t = new TreeMultiMap<number, string>([], { isMapMode: false });
-    t.set(1, 'a');
-
-    // value undefined and values undefined => should not append
-    expect(t.set(1, undefined as any)).toBe(false);
-    expect(t.get(1)).toEqual(['a']);
-  });
-
-  it('mapMode set(): forces evaluation of _setToValues via _setByNode false (covers _setByNode() || _setToValues() rhs)', () => {
-    const t = new TreeMultiMap<number, string>([], { isMapMode: true });
-    t.set(1, 'a');
-
-    // Patch getNode to be non-real so _setByNode uses `super.set(key, values)`.
-    const origGetNode = (t as any).getNode;
-    (t as any).getNode = () => (t as any)._NIL;
-
-    // Patch super.set to return false so _setByNode becomes falsy and OR evaluates _setToValues.
-    const rbProto = Object.getPrototypeOf(Object.getPrototypeOf(t));
-    const origSuperSet = rbProto.set;
-    rbProto.set = () => false;
-
-    try {
-      expect(t.set(1, 'b')).toBe(true);
-      expect(t.get(1)).toEqual(['a', 'b']);
-    } finally {
-      rbProto.set = origSuperSet;
-      (t as any).getNode = origGetNode;
-    }
-  });
-
-  it('_createInstance/_createLike cover snapshotOptions fallback (?? {}) and createLike default iter=[]', () => {
-    const t = new TreeMultiMap<number, string>();
-
-    const orig = (t as any)._snapshotOptions;
-    (t as any)._snapshotOptions = undefined;
-    try {
-      const inst = (t as any)._createInstance();
-      expect(inst).toBeInstanceOf(TreeMultiMap);
-
-      const like = (t as any)._createLike();
-      expect(like).toBeInstanceOf(TreeMultiMap);
-      expect(like.size).toBe(0);
-    } finally {
-      (t as any)._snapshotOptions = orig;
-    }
-  });
-});

package/test/unit/data-structures/binary-tree/tree-multi-map.rfc.test.ts

@@ -1,146 +0,0 @@
-import { TreeMultiMap } from '../../../../src';
-
-describe('TreeMultiMap (RFC additions)', () => {
-  it('get() returns a live bucket reference (mutating it mutates the container); empty bucket does not auto-delete key', () => {
-    const mm = new TreeMultiMap<number, string>();
-    mm.set(1, 'a');
-    mm.set(1, 'b');
-
-    const bucket = mm.get(1)!;
-    expect(bucket).toEqual(['a', 'b']);
-
-    bucket.push('c');
-    expect(mm.get(1)).toEqual(['a', 'b', 'c']);
-
-    // If bucket is emptied by mutation, key remains until delete(key) is called.
-    bucket.length = 0;
-    expect(mm.has(1)).toBe(true);
-    expect(mm.get(1)).toEqual([]);
-  });
-
-  it('totalSize is the sum of bucket lengths across all keys', () => {
-    const mm = new TreeMultiMap<number, string>();
-    mm.set(1, 'a');
-    mm.set(1, 'b');
-    mm.set(2, 'x');
-    expect(mm.totalSize).toBe(3);
-
-    // live bucket mutation reflected
-    mm.get(2)!.push('y', 'z');
-    expect(mm.totalSize).toBe(5);
-  });
-
-  it('hasEntry/deleteValue/deleteValues default Object.is and optional eq', () => {
-    const mm = new TreeMultiMap<number, { id: number }>();
-    const a1 = { id: 1 };
-    const a1b = { id: 1 };
-
-    mm.set(1, a1);
-    mm.set(1, a1b);
-
-    // Object.is uses reference equality for objects
-    expect(mm.hasEntry(1, { id: 1 })).toBe(false);
-    expect(mm.hasEntry(1, a1)).toBe(true);
-
-    const eq = (x: { id: number }, y: { id: number }) => x.id === y.id;
-    expect(mm.hasEntry(1, { id: 1 }, eq)).toBe(true);
-
-    // deleteValue deletes one match
-    expect(mm.deleteValue(1, { id: 1 }, eq)).toBe(true);
-    expect(mm.get(1)!.length).toBe(1);
-
-    // deleteValues deletes all matches
-    mm.set(1, { id: 1 });
-    mm.set(1, { id: 2 });
-    expect(mm.deleteValues(1, { id: 1 }, eq)).toBe(2);
-    expect(mm.get(1)).toEqual([{ id: 2 }]);
-  });
-
-  it('navigable methods return entry tuples [K, V[]]; pollFirst/pollLast delete whole buckets', () => {
-    const mm = new TreeMultiMap<number, string>();
-    mm.set(2, 'b');
-    mm.set(1, 'a');
-    mm.set(3, 'c');
-
-    expect(mm.first()).toEqual([1, ['a']]);
-    expect(mm.last()).toEqual([3, ['c']]);
-    expect(mm.ceiling(2)).toEqual([2, ['b']]);
-    expect(mm.floor(2)).toEqual([2, ['b']]);
-    expect(mm.higher(2)).toEqual([3, ['c']]);
-    expect(mm.lower(2)).toEqual([1, ['a']]);
-
-    const pf = mm.pollFirst();
-    expect(pf).toEqual([1, ['a']]);
-    expect(mm.has(1)).toBe(false);
-
-    const pl = mm.pollLast();
-    expect(pl).toEqual([3, ['c']]);
-    expect(mm.has(3)).toBe(false);
-  });
-
-  it('flatEntries()/entriesOf()/valuesOf() provide entry-flat views', () => {
-    const mm = new TreeMultiMap<number, string>();
-    mm.set(1, 'a');
-    mm.set(1, 'b');
-    mm.set(2, 'x');
-
-    expect([...mm.entriesOf(1)]).toEqual([
-      [1, 'a'],
-      [1, 'b']
-    ]);
-    expect([...mm.valuesOf(1)]).toEqual(['a', 'b']);
-
-    expect([...mm.flatEntries()]).toEqual([
-      [1, 'a'],
-      [1, 'b'],
-      [2, 'x']
-    ]);
-  });
-
-  it('toEntryFn: construct from raw objects', () => {
-    interface Player {
-      score: number;
-      items: string[];
-    }
-
-    const players: Player[] = [
-      { score: 200, items: ['sword', 'shield'] },
-      { score: 100, items: ['bow'] },
-      { score: 150, items: ['staff', 'wand', 'robe'] }
-    ];
-
-    const mm = new TreeMultiMap<number, string>(players, {
-      toEntryFn: ((p: Player) => [p.score, p.items]) as (raw: unknown) => [number, string[]]
-    });
-
-    expect(mm.size).toBe(3);
-    expect([...mm.keys()]).toEqual([100, 150, 200]); // sorted by key
-    expect(mm.get(100)).toEqual(['bow']);
-    expect(mm.get(150)).toEqual(['staff', 'wand', 'robe']);
-    expect(mm.get(200)).toEqual(['sword', 'shield']);
-    expect(mm.totalSize).toBe(6); // 1 + 3 + 2
-  });
-
-  it('toEntryFn: with single value converted to bucket', () => {
-    interface Event {
-      date: string;
-      title: string;
-    }
-
-    const events: Event[] = [
-      { date: '2024-01-01', title: 'New Year' },
-      { date: '2024-02-14', title: 'Valentine' },
-      { date: '2024-01-01', title: 'Party' } // same date
-    ];
-
-    // Note: toEntryFn returns [K, V | V[]], but TreeMultiMap normalizes to array
-    const mm = new TreeMultiMap<string, string>(events, {
-      toEntryFn: ((e: Event) => [e.date, [e.title]]) as (raw: unknown) => [string, string[]]
-    });
-
-    expect(mm.size).toBe(2); // 2 distinct dates
-    // The second entry for '2024-01-01' overwrites the first bucket
-    expect(mm.get('2024-01-01')).toEqual(['Party']);
-    expect(mm.get('2024-02-14')).toEqual(['Valentine']);
-  });
-});

package/test/unit/data-structures/binary-tree/tree-multi-map.simplified.test.ts

@@ -1,482 +0,0 @@
-import { TreeMultiMap, TreeMultiMapNode } from '../../../../src';
-
-describe('TreeMultiMap (Simplified API)', () => {
-  describe('Core methods', () => {
-    it('constructor initializes empty map', () => {
-      const mm = new TreeMultiMap<number, string>();
-      expect(mm.size).toBe(0);
-      expect(mm.totalSize).toBe(0);
-      expect(mm.isEmpty()).toBe(true);
-    });
-
-    it('constructor with entries', () => {
-      const mm = new TreeMultiMap<number, string>([
-        [1, ['a', 'b']],
-        [2, ['c']]
-      ]);
-      expect(mm.size).toBe(2);
-      expect(mm.totalSize).toBe(3);
-      expect(mm.get(1)).toEqual(['a', 'b']);
-      expect(mm.get(2)).toEqual(['c']);
-    });
-
-    it('add() appends value to bucket', () => {
-      const mm = new TreeMultiMap<number, string>();
-      mm.add(1, 'a');
-      mm.add(1, 'b');
-      mm.add(2, 'c');
-      expect(mm.get(1)).toEqual(['a', 'b']);
-      expect(mm.get(2)).toEqual(['c']);
-    });
-
-    it('set() works like add() for single values', () => {
-      const mm = new TreeMultiMap<number, string>();
-      mm.set(1, 'a');
-      mm.set(1, 'b');
-      expect(mm.get(1)).toEqual(['a', 'b']);
-    });
-
-    it('set() with entry tuple', () => {
-      const mm = new TreeMultiMap<number, string>();
-      mm.set([1, ['a', 'b']]);
-      expect(mm.get(1)).toEqual(['a', 'b']);
-    });
-
-    it('has() checks if key exists', () => {
-      const mm = new TreeMultiMap<number, string>();
-      mm.add(1, 'a');
-      expect(mm.has(1)).toBe(true);
-      expect(mm.has(2)).toBe(false);
-    });
-
-    it('count() returns bucket length', () => {
-      const mm = new TreeMultiMap<number, string>();
-      mm.add(1, 'a');
-      mm.add(1, 'b');
-      expect(mm.count(1)).toBe(2);
-      expect(mm.count(2)).toBe(0);
-    });
-
-    it('delete() removes key and bucket', () => {
-      const mm = new TreeMultiMap<number, string>();
-      mm.add(1, 'a');
-      mm.add(1, 'b');
-      expect(mm.delete(1)).toBe(true);
-      expect(mm.has(1)).toBe(false);
-      expect(mm.delete(1)).toBe(false);
-    });
-
-    it('clear() removes all entries', () => {
-      const mm = new TreeMultiMap<number, string>();
-      mm.add(1, 'a');
-      mm.add(2, 'b');
-      mm.clear();
-      expect(mm.size).toBe(0);
-      expect(mm.isEmpty()).toBe(true);
-    });
-
-    it('get() returns live bucket reference', () => {
-      const mm = new TreeMultiMap<number, string>();
-      mm.add(1, 'a');
-      const bucket = mm.get(1)!;
-      bucket.push('b');
-      expect(mm.get(1)).toEqual(['a', 'b']);
-    });
-  });
-
-  describe('Value-level operations', () => {
-    it('hasEntry() checks if value exists in bucket', () => {
-      const mm = new TreeMultiMap<number, string>();
-      mm.add(1, 'a');
-      mm.add(1, 'b');
-      expect(mm.hasEntry(1, 'a')).toBe(true);
-      expect(mm.hasEntry(1, 'c')).toBe(false);
-    });
-
-    it('deleteValue() removes first matching value', () => {
-      const mm = new TreeMultiMap<number, string>();
-      mm.add(1, 'a');
-      mm.add(1, 'b');
-      mm.add(1, 'a');
-      expect(mm.deleteValue(1, 'a')).toBe(true);
-      expect(mm.get(1)).toEqual(['b', 'a']);
-    });
-
-    it('deleteValues() removes all matching values', () => {
-      const mm = new TreeMultiMap<number, string>();
-      mm.add(1, 'a');
-      mm.add(1, 'b');
-      mm.add(1, 'a');
-      expect(mm.deleteValues(1, 'a')).toBe(2);
-      expect(mm.get(1)).toEqual(['b']);
-    });
-
-    it('deleteValue() auto-deletes key when bucket empty', () => {
-      const mm = new TreeMultiMap<number, string>();
-      mm.add(1, 'a');
-      mm.deleteValue(1, 'a');
-      expect(mm.has(1)).toBe(false);
-    });
-  });
-
-  describe('Iteration', () => {
-    it('[Symbol.iterator] yields bucket entries', () => {
-      const mm = new TreeMultiMap<number, string>();
-      mm.add(1, 'a');
-      mm.add(2, 'b');
-      expect([...mm]).toEqual([[1, ['a']], [2, ['b']]]);
-    });
-
-    it('keys() yields keys in order', () => {
-      const mm = new TreeMultiMap<number, string>();
-      mm.add(3, 'c');
-      mm.add(1, 'a');
-      mm.add(2, 'b');
-      expect([...mm.keys()]).toEqual([1, 2, 3]);
-    });
-
-    it('values() yields buckets', () => {
-      const mm = new TreeMultiMap<number, string>();
-      mm.add(1, 'a');
-      mm.add(2, 'b');
-      expect([...mm.values()]).toEqual([['a'], ['b']]);
-    });
-
-    it('flatEntries() yields flat [K, V] pairs', () => {
-      const mm = new TreeMultiMap<number, string>();
-      mm.add(1, 'a');
-      mm.add(1, 'b');
-      mm.add(2, 'c');
-      expect([...mm.flatEntries()]).toEqual([
-        [1, 'a'],
-        [1, 'b'],
-        [2, 'c']
-      ]);
-    });
-
-    it('entriesOf() yields entries for single key', () => {
-      const mm = new TreeMultiMap<number, string>();
-      mm.add(1, 'a');
-      mm.add(1, 'b');
-      mm.add(2, 'c');
-      expect([...mm.entriesOf(1)]).toEqual([
-        [1, 'a'],
-        [1, 'b']
-      ]);
-    });
-
-    it('valuesOf() yields values for single key', () => {
-      const mm = new TreeMultiMap<number, string>();
-      mm.add(1, 'a');
-      mm.add(1, 'b');
-      expect([...mm.valuesOf(1)]).toEqual(['a', 'b']);
-    });
-  });
-
-  describe('Navigable methods (return [K, V[]])', () => {
-    let mm: TreeMultiMap<number, string>;
-
-    beforeEach(() => {
-      mm = new TreeMultiMap<number, string>();
-      mm.add(10, 'a');
-      mm.add(20, 'b');
-      mm.add(30, 'c');
-    });
-
-    it('first() returns entry with smallest key', () => {
-      expect(mm.first()).toEqual([10, ['a']]);
-    });
-
-    it('first() returns undefined on empty map', () => {
-      expect(new TreeMultiMap<number, string>().first()).toBeUndefined();
-    });
-
-    it('last() returns entry with largest key', () => {
-      expect(mm.last()).toEqual([30, ['c']]);
-    });
-
-    it('last() returns undefined on empty map', () => {
-      expect(new TreeMultiMap<number, string>().last()).toBeUndefined();
-    });
-
-    it('pollFirst() removes and returns smallest entry', () => {
-      expect(mm.pollFirst()).toEqual([10, ['a']]);
-      expect(mm.has(10)).toBe(false);
-      expect(mm.size).toBe(2);
-    });
-
-    it('pollFirst() returns undefined on empty map', () => {
-      expect(new TreeMultiMap<number, string>().pollFirst()).toBeUndefined();
-    });
-
-    it('pollLast() removes and returns largest entry', () => {
-      expect(mm.pollLast()).toEqual([30, ['c']]);
-      expect(mm.has(30)).toBe(false);
-      expect(mm.size).toBe(2);
-    });
-
-    it('pollLast() returns undefined on empty map', () => {
-      expect(new TreeMultiMap<number, string>().pollLast()).toBeUndefined();
-    });
-
-    it('ceiling() returns smallest entry >= key', () => {
-      expect(mm.ceiling(15)).toEqual([20, ['b']]);
-      expect(mm.ceiling(20)).toEqual([20, ['b']]);
-      expect(mm.ceiling(10)).toEqual([10, ['a']]);
-      expect(mm.ceiling(35)).toBeUndefined();
-    });
-
-    it('floor() returns largest entry <= key', () => {
-      expect(mm.floor(25)).toEqual([20, ['b']]);
-      expect(mm.floor(20)).toEqual([20, ['b']]);
-      expect(mm.floor(30)).toEqual([30, ['c']]);
-      expect(mm.floor(5)).toBeUndefined();
-    });
-
-    it('higher() returns smallest entry > key', () => {
-      expect(mm.higher(10)).toEqual([20, ['b']]);
-      expect(mm.higher(15)).toEqual([20, ['b']]);
-      expect(mm.higher(30)).toBeUndefined();
-    });
-
-    it('lower() returns largest entry < key', () => {
-      expect(mm.lower(20)).toEqual([10, ['a']]);
-      expect(mm.lower(15)).toEqual([10, ['a']]);
-      expect(mm.lower(10)).toBeUndefined();
-    });
-  });
-
-  describe('Functional methods', () => {
-    it('forEach() iterates with bucket, key, map', () => {
-      const mm = new TreeMultiMap<number, string>();
-      mm.add(1, 'a');
-      mm.add(2, 'b');
-      const result: Array<[number, string[]]> = [];
-      mm.forEach((bucket, key) => result.push([key, bucket]));
-      expect(result).toEqual([[1, ['a']], [2, ['b']]]);
-    });
-
-    it('filter() creates filtered map', () => {
-      const mm = new TreeMultiMap<number, string>();
-      mm.add(1, 'a');
-      mm.add(2, 'b');
-      mm.add(3, 'c');
-      const filtered = mm.filter((bucket, key) => key >= 2);
-      expect(filtered.size).toBe(2);
-      expect(filtered.has(1)).toBe(false);
-      expect(filtered.has(2)).toBe(true);
-    });
-
-    it('reduce() accumulates values', () => {
-      const mm = new TreeMultiMap<number, string>();
-      mm.add(1, 'a');
-      mm.add(1, 'b');
-      mm.add(2, 'c');
-      const total = mm.reduce((acc, bucket) => acc + bucket.length, 0);
-      expect(total).toBe(3);
-    });
-
-    it('map() transforms entries', () => {
-      const mm = new TreeMultiMap<number, string>();
-      mm.add(1, 'a');
-      mm.add(2, 'b');
-      const mapped = mm.map((bucket, key) => [key * 10, bucket.map(v => v.toUpperCase())]);
-      expect(mapped.get(10)).toEqual(['A']);
-      expect(mapped.get(20)).toEqual(['B']);
-    });
-
-    it('clone() creates independent copy', () => {
-      const mm = new TreeMultiMap<number, string>();
-      mm.add(1, 'a');
-      const copy = mm.clone();
-      copy.add(2, 'b');
-      expect(mm.has(2)).toBe(false);
-      expect(copy.has(2)).toBe(true);
-    });
-  });
-
-  describe('Tree utilities', () => {
-    it('rangeSearch() returns entries in range', () => {
-      const mm = new TreeMultiMap<number, string>();
-      mm.add(10, 'a');
-      mm.add(20, 'b');
-      mm.add(30, 'c');
-      mm.add(40, 'd');
-      const result = mm.rangeSearch([15, 35], node => node.key);
-      expect(result).toEqual([20, 30]);
-    });
-
-    it('print() does not throw', () => {
-      const mm = new TreeMultiMap<number, string>();
-      mm.add(1, 'a');
-      expect(() => mm.print()).not.toThrow();
-    });
-  });
-
-  describe('Edge cases', () => {
-    it('works with string keys', () => {
-      const mm = new TreeMultiMap<string, number>();
-      mm.add('b', 2);
-      mm.add('a', 1);
-      mm.add('c', 3);
-      expect([...mm.keys()]).toEqual(['a', 'b', 'c']);
-    });
-
-    it('works with Date keys', () => {
-      const d1 = new Date('2020-01-01');
-      const d2 = new Date('2021-01-01');
-      const mm = new TreeMultiMap<Date, string>();
-      mm.add(d2, 'later');
-      mm.add(d1, 'earlier');
-      expect(mm.first()?.[0]).toEqual(d1);
-    });
-
-    it('rejects NaN keys', () => {
-      const mm = new TreeMultiMap<number, string>();
-      expect(() => mm.add(NaN, 'x')).toThrow(TypeError);
-    });
-
-    it('custom comparator', () => {
-      const mm = new TreeMultiMap<number, string>([], {
-        comparator: (a, b) => b - a  // descending
-      });
-      mm.add(1, 'a');
-      mm.add(2, 'b');
-      mm.add(3, 'c');
-      expect([...mm.keys()]).toEqual([3, 2, 1]);
-    });
-
-    it('setMany() adds multiple entries', () => {
-      const mm = new TreeMultiMap<number, string>();
-      mm.setMany([[1, ['a']], [2, ['b']]]);
-      expect(mm.size).toBe(2);
-    });
-
-    it('comparator getter', () => {
-      const cmp = (a: number, b: number) => a - b;
-      const mm = new TreeMultiMap<number, string>([], { comparator: cmp });
-      expect(mm.comparator).toBe(cmp);
-    });
-
-    it('constructor with key-only entries', () => {
-      const mm = new TreeMultiMap<number, string>([[1, undefined], [2, undefined]] as any);
-      expect(mm.has(1)).toBe(true);
-      expect(mm.has(2)).toBe(true);
-      expect(mm.get(1)).toEqual([]);
-    });
-
-    it('constructor with null/undefined entries skipped', () => {
-      const mm = new TreeMultiMap<number, string>([null, undefined, [1, ['a']]] as any);
-      expect(mm.size).toBe(1);
-      expect(mm.has(1)).toBe(true);
-    });
-
-    it('constructor with key having null key in tuple skipped', () => {
-      const mm = new TreeMultiMap<number, string>([[null, ['a']], [1, ['b']]] as any);
-      expect(mm.size).toBe(1);
-    });
-
-    it('rejects invalid Date keys', () => {
-      const mm = new TreeMultiMap<Date, string>();
-      expect(() => mm.add(new Date('invalid'), 'x')).toThrow(TypeError);
-    });
-
-    it('rejects non-primitive keys without comparator', () => {
-      const mm = new TreeMultiMap<{ id: number }, string>();
-      expect(() => mm.add({ id: 1 }, 'x')).toThrow(TypeError);
-    });
-
-    it('set() with null entry returns false', () => {
-      const mm = new TreeMultiMap<number, string>();
-      expect(mm.set(null as any)).toBe(false);
-      expect(mm.set(undefined as any)).toBe(false);
-    });
-
-    it('set() entry with null key returns false', () => {
-      const mm = new TreeMultiMap<number, string>();
-      expect(mm.set([null, ['a']] as any)).toBe(false);
-      expect(mm.set([undefined, ['a']] as any)).toBe(false);
-    });
-
-    it('set() entry with value appends to existing bucket', () => {
-      const mm = new TreeMultiMap<number, string>();
-      mm.add(1, 'a');
-      mm.set([1, ['b', 'c']]);
-      expect(mm.get(1)).toEqual(['a', 'b', 'c']);
-    });
-
-    it('set() entry tuple with undefined bucket creates empty bucket', () => {
-      const mm = new TreeMultiMap<number, string>();
-      mm.set([1, undefined] as any);
-      expect(mm.has(1)).toBe(true);
-      expect(mm.get(1)).toEqual([]);
-    });
-
-    it('set() key-only creates empty bucket', () => {
-      const mm = new TreeMultiMap<number, string>();
-      mm.set(1);
-      expect(mm.has(1)).toBe(true);
-      expect(mm.get(1)).toEqual([]);
-    });
-
-    it('entriesOf() on non-existent key yields nothing', () => {
-      const mm = new TreeMultiMap<number, string>();
-      expect([...mm.entriesOf(999)]).toEqual([]);
-    });
-
-    it('valuesOf() on non-existent key yields nothing', () => {
-      const mm = new TreeMultiMap<number, string>();
-      expect([...mm.valuesOf(999)]).toEqual([]);
-    });
-
-    it('hasEntry() returns false for non-existent key', () => {
-      const mm = new TreeMultiMap<number, string>();
-      expect(mm.hasEntry(999, 'x')).toBe(false);
-    });
-
-    it('deleteValue() returns false for non-existent key', () => {
-      const mm = new TreeMultiMap<number, string>();
-      expect(mm.deleteValue(999, 'x')).toBe(false);
-    });
-
-    it('deleteValue() returns false when value not found', () => {
-      const mm = new TreeMultiMap<number, string>();
-      mm.add(1, 'a');
-      expect(mm.deleteValue(1, 'x')).toBe(false);
-    });
-
-    it('deleteValues() returns 0 for non-existent key', () => {
-      const mm = new TreeMultiMap<number, string>();
-      expect(mm.deleteValues(999, 'x')).toBe(0);
-    });
-
-    it('filter() with custom comparator preserves it', () => {
-      const cmp = (a: number, b: number) => b - a;
-      const mm = new TreeMultiMap<number, string>([], { comparator: cmp });
-      mm.add(1, 'a');
-      mm.add(2, 'b');
-      const filtered = mm.filter(() => true);
-      expect([...filtered.keys()]).toEqual([2, 1]);  // descending
-    });
-
-    it('TreeMultiMapNode (deprecated) can be created', () => {
-      const node = new TreeMultiMapNode(1, ['a', 'b']);
-      expect(node.key).toBe(1);
-      expect(node.value).toEqual(['a', 'b']);
-    });
-
-    it('TreeMultiMapNode with default value', () => {
-      const node = new TreeMultiMapNode(1);
-      expect(node.key).toBe(1);
-      expect(node.value).toEqual([]);
-    });
-
-    it('constructor with plain key entries (not array)', () => {
-      const mm = new TreeMultiMap<number, string>([1, 2, 3] as any);
-      expect(mm.has(1)).toBe(true);
-      expect(mm.has(2)).toBe(true);
-      expect(mm.has(3)).toBe(true);
-      expect(mm.get(1)).toEqual([]);
-    });
-  });
-});