ts-data-forge 4.0.0 → 5.0.0

package/src/array/impl/array-utils-transformation.test.mts

@@ -21,27 +21,29 @@ import {
 } from './array-utils-transformation.mjs';
 
 describe('Arr transformations', () => {
-  describe('map', () => {
+  describe(map, () => {
     const mapped = map([1, 2, 3], (x, i): number => x * x * i);
 
     expectType<typeof mapped, ArrayOfLength<3, number>>('=');
 
     test('case 1', () => {
-      expect(mapped).toStrictEqual([0, 4, 18]);
+      assert.deepStrictEqual(mapped, [0, 4, 18]);
     });
 
     test('should work with empty tuple', () => {
       const empty = [] as const;
       const mappedEmpty = map(empty, (x) => String(x));
       expectType<typeof mappedEmpty, readonly []>('=');
-      expect(mappedEmpty).toStrictEqual([]);
+
+      assert.deepStrictEqual(mappedEmpty, []);
     });
 
     test('should preserve tuple length with different types', () => {
       const mixed = [1, 'hello', true] as const;
       const mappedMixed = map(mixed, (x) => typeof x);
       expectType<typeof mappedMixed, readonly [string, string, string]>('<=');
-      expect(mappedMixed).toStrictEqual(['number', 'string', 'boolean']);
+
+      assert.deepStrictEqual(mappedMixed, ['number', 'string', 'boolean']);
     });
 
     test('should work with index parameter', () => {
@@ -50,24 +52,27 @@ describe('Arr transformations', () => {
       expectType<typeof mappedWithIndex, readonly [string, string, string]>(
         '<=',
       );
-      expect(mappedWithIndex).toStrictEqual(['0:a', '1:b', '2:c']);
+
+      assert.deepStrictEqual(mappedWithIndex, ['0:a', '1:b', '2:c']);
     });
   });
 
-  describe('scan', () => {
+  describe(scan, () => {
     test('should compute running sum', () => {
       const numbers = [1, 2, 3, 4];
       const runningSum = scan(numbers, (acc, curr) => acc + curr, 0);
 
       expectType<typeof runningSum, readonly [number, ...number[]]>('<=');
-      expect(runningSum).toStrictEqual([0, 1, 3, 6, 10]);
+
+      assert.deepStrictEqual(runningSum, [0, 1, 3, 6, 10]);
     });
 
     test('should include initial value as first element', () => {
       const numbers = [10, 20, 30];
       const result = scan(numbers, (acc, curr) => acc + curr, 100);
 
-      expect(result).toStrictEqual([100, 110, 130, 160]);
+      assert.deepStrictEqual(result, [100, 110, 130, 160]);
+
       expect(result).toHaveLength(4); // original length + 1
     });
 
@@ -77,8 +82,8 @@ describe('Arr transformations', () => {
       const result1 = scanSum([1, 2, 3]);
       const result2 = scanSum([5, 10]);
 
-      expect(result1).toStrictEqual([0, 1, 3, 6]);
-      expect(result2).toStrictEqual([0, 5, 15]);
+      assert.deepStrictEqual(result1, [0, 1, 3, 6]);
+      assert.deepStrictEqual(result2, [0, 5, 15]);
     });
 
     test('should provide index to reducer', () => {
@@ -94,14 +99,14 @@ describe('Arr transformations', () => {
         0,
       );
 
-      expect(mut_indices).toStrictEqual([0, 1, 2]);
+      assert.deepStrictEqual(mut_indices, [0, 1, 2]);
     });
 
     test('should work with empty array', () => {
       const empty: readonly number[] = [];
       const result = scan(empty, (acc, curr) => acc + curr, 42);
 
-      expect(result).toStrictEqual([42]);
+      assert.deepStrictEqual(result, [42]);
     });
 
     test('should work with different accumulator and element types', () => {
@@ -109,14 +114,15 @@ describe('Arr transformations', () => {
       const result = scan(strings, (acc, curr) => acc + curr.length, 0);
 
       expectType<typeof result, readonly [number, ...number[]]>('<=');
-      expect(result).toStrictEqual([0, 1, 2, 3]);
+
+      assert.deepStrictEqual(result, [0, 1, 2, 3]);
     });
 
     test('should compute running product', () => {
       const numbers = [2, 3, 4];
       const runningProduct = scan(numbers, (acc, curr) => acc * curr, 1);
 
-      expect(runningProduct).toStrictEqual([1, 2, 6, 24]);
+      assert.deepStrictEqual(runningProduct, [1, 2, 6, 24]);
     });
 
     test('should work with objects', () => {
@@ -124,7 +130,7 @@ describe('Arr transformations', () => {
 
       const result = scan(items, (acc, curr) => acc + curr.value, 0);
 
-      expect(result).toStrictEqual([0, 10, 30, 60]);
+      assert.deepStrictEqual(result, [0, 10, 30, 60]);
     });
 
     test('should preserve all intermediate values', () => {
@@ -132,11 +138,11 @@ describe('Arr transformations', () => {
       const result = scan(numbers, (acc, curr) => acc - curr, 10);
 
       // 10 -> 10-1=9 -> 9-2=7 -> 7-3=4
-      expect(result).toStrictEqual([10, 9, 7, 4]);
+      assert.deepStrictEqual(result, [10, 9, 7, 4]);
     });
   });
 
-  describe('toReversed', () => {
+  describe(toReversed, () => {
     {
       const xs = [1, 2, 3] as const;
       const _nativeResult = xs.toReversed();
@@ -148,7 +154,7 @@ describe('Arr transformations', () => {
       expectType<typeof result, readonly [3, 2, 1]>('=');
 
       test('case 1', () => {
-        expect(result).toStrictEqual([3, 2, 1]);
+        assert.deepStrictEqual(result, [3, 2, 1]);
       });
     }
 
@@ -156,25 +162,28 @@ describe('Arr transformations', () => {
       const empty = [] as const;
       const reversed = toReversed(empty);
       expectType<typeof reversed, readonly []>('=');
-      expect(reversed).toStrictEqual([]);
+
+      assert.deepStrictEqual(reversed, []);
     });
 
     test('should work with single element', () => {
       const single = [42] as const;
       const reversed = toReversed(single);
       expectType<typeof reversed, readonly [42]>('=');
-      expect(reversed).toStrictEqual([42]);
+
+      assert.deepStrictEqual(reversed, [42]);
     });
 
     test('should preserve mixed types in reverse order', () => {
       const mixed = [1, 'hello', true, null] as const;
       const reversed = toReversed(mixed);
       expectType<typeof reversed, readonly [null, true, 'hello', 1]>('=');
-      expect(reversed).toStrictEqual([null, true, 'hello', 1]);
+
+      assert.deepStrictEqual(reversed, [null, true, 'hello', 1]);
     });
   });
 
-  describe('toSorted', () => {
+  describe(toSorted, () => {
     {
       const xs = [2, 1, 3] as const;
       const result = toSorted(xs);
@@ -182,7 +191,7 @@ describe('Arr transformations', () => {
       expectType<typeof result, ArrayOfLength<3, 1 | 2 | 3>>('=');
 
       test('case 1', () => {
-        expect(result).toStrictEqual([1, 2, 3]);
+        assert.deepStrictEqual(result, [1, 2, 3]);
       });
     }
     {
@@ -192,7 +201,7 @@ describe('Arr transformations', () => {
       expectType<typeof result, ArrayOfLength<3, 1 | 2 | 3>>('=');
 
       test('case 2', () => {
-        expect(result).toStrictEqual([1, 2, 3]);
+        assert.deepStrictEqual(result, [1, 2, 3]);
       });
     }
     {
@@ -202,12 +211,12 @@ describe('Arr transformations', () => {
       expectType<typeof result, ArrayOfLength<3, 1 | 2 | 3>>('=');
 
       test('case 3', () => {
-        expect(result).toStrictEqual([3, 2, 1]);
+        assert.deepStrictEqual(result, [3, 2, 1]);
       });
     }
   });
 
-  describe('toSortedBy', () => {
+  describe(toSortedBy, () => {
     {
       const xs = [{ v: 2 }, { v: 1 }, { v: 3 }] as const;
       const sorted = toSortedBy(xs, (x) => x.v);
@@ -218,7 +227,7 @@ describe('Arr transformations', () => {
       >('=');
 
       test('case 1', () => {
-        expect(sorted).toStrictEqual([{ v: 1 }, { v: 2 }, { v: 3 }]);
+        assert.deepStrictEqual(sorted, [{ v: 1 }, { v: 2 }, { v: 3 }]);
       });
     }
     {
@@ -235,7 +244,7 @@ describe('Arr transformations', () => {
       >('=');
 
       test('case 2', () => {
-        expect(sorted).toStrictEqual([{ v: 1 }, { v: 2 }, { v: 3 }]);
+        assert.deepStrictEqual(sorted, [{ v: 1 }, { v: 2 }, { v: 3 }]);
       });
     }
 
@@ -260,33 +269,38 @@ describe('Arr transformations', () => {
         (word: string) => word,
         (a: string, b: string) => a.localeCompare(b),
       );
-      expect(result).toStrictEqual(['apple', 'banana', 'cherry']);
+
+      assert.deepStrictEqual(result, ['apple', 'banana', 'cherry']);
     });
 
     test('should work with custom key extraction', () => {
       const items = ['hello', 'hi', 'welcome', 'bye'];
       const result = toSortedBy(items, (item) => item.length);
-      expect(result).toStrictEqual(['hi', 'bye', 'hello', 'welcome']);
+
+      assert.deepStrictEqual(result, ['hi', 'bye', 'hello', 'welcome']);
     });
 
     test('should work with empty array', () => {
       const empty: readonly { value: number }[] = [];
       const result = toSortedBy(empty, (item) => item.value);
-      expect(result).toStrictEqual([]);
+
+      assert.deepStrictEqual(result, []);
     });
 
     test('toSortedBy should work with empty array', () => {
       const empty: readonly { value: number }[] = [];
       const result = toSortedBy(empty, (item) => item.value);
-      expect(result).toStrictEqual([]);
+
+      assert.deepStrictEqual(result, []);
     });
   });
 
-  describe('filter', () => {
+  describe(filter, () => {
     test('should filter array with predicate', () => {
       const numbers = [1, 2, 3, 4, 5];
       const evens = filter(numbers, (n) => n % 2 === 0);
-      expect(evens).toStrictEqual([2, 4]);
+
+      assert.deepStrictEqual(evens, [2, 4]);
     });
 
     test('should work with type guards', () => {
@@ -299,14 +313,16 @@ describe('Arr transformations', () => {
       ];
       const strings = filter(mixed, (x): x is string => typeof x === 'string');
       expectType<typeof strings, readonly string[]>('=');
-      expect(strings).toStrictEqual(['hello', 'world']);
+
+      assert.deepStrictEqual(strings, ['hello', 'world']);
     });
 
     test('should work with curried version', () => {
       const isPositive = (n: number): boolean => n > 0;
       const filterPositive = filter(isPositive);
       const result = filterPositive([-1, 2, -3, 4]);
-      expect(result).toStrictEqual([2, 4]);
+
+      assert.deepStrictEqual(result, [2, 4]);
     });
 
     test('should work with curried type guards', () => {
@@ -314,67 +330,75 @@ describe('Arr transformations', () => {
       const filterStrings = filter(isString);
       const result = filterStrings(['a', 1, 'b', 2]);
       expectType<typeof result, readonly string[]>('=');
-      expect(result).toStrictEqual(['a', 'b']);
+
+      assert.deepStrictEqual(result, ['a', 'b']);
     });
 
     test('should preserve array type with generic predicate', () => {
       const tuple = [1, 2, 3] as const;
       const filtered = filter(tuple, (x) => x > 1);
       expectType<typeof filtered, readonly (1 | 2 | 3)[]>('=');
-      expect(filtered).toStrictEqual([2, 3]);
+
+      assert.deepStrictEqual(filtered, [2, 3]);
     });
 
     test('should work with empty array', () => {
       const empty: number[] = [];
       const result = filter(empty, (n) => n > 0);
-      expect(result).toStrictEqual([]);
+
+      assert.deepStrictEqual(result, []);
     });
 
     test('should pass index to predicate', () => {
       const numbers = [10, 20, 30, 40];
       const evenIndexes = filter(numbers, (_, i) => i % 2 === 0);
-      expect(evenIndexes).toStrictEqual([10, 30]);
+
+      assert.deepStrictEqual(evenIndexes, [10, 30]);
     });
   });
 
-  describe('filterNot', () => {
+  describe(filterNot, () => {
     const xs = [1, 2, 3] as const;
     const filtered = filterNot(xs, (x) => x % 2 === 0);
 
     expectType<typeof filtered, readonly (1 | 2 | 3)[]>('=');
 
     test('case 1', () => {
-      expect(filtered).toStrictEqual([1, 3]);
+      assert.deepStrictEqual(filtered, [1, 3]);
     });
   });
 
-  describe('uniq', () => {
+  describe(uniq, () => {
     test('should remove duplicate primitives', () => {
       const array = [1, 2, 2, 3, 1, 4, 3];
       const result = uniq(array);
-      expect(result).toStrictEqual([1, 2, 3, 4]);
+
+      assert.deepStrictEqual(result, [1, 2, 3, 4]);
     });
 
     test('should work with strings', () => {
       const array = ['a', 'b', 'a', 'c', 'b'];
       const result = uniq(array);
-      expect(result).toStrictEqual(['a', 'b', 'c']);
+
+      assert.deepStrictEqual(result, ['a', 'b', 'c']);
     });
 
     test('should work with empty array', () => {
       const array: readonly number[] = [];
       const result = uniq(array);
-      expect(result).toStrictEqual([]);
+
+      assert.deepStrictEqual(result, []);
     });
 
     test('should preserve order of first occurrence', () => {
       const array = [3, 1, 2, 1, 3, 2];
       const result = uniq(array);
-      expect(result).toStrictEqual([3, 1, 2]);
+
+      assert.deepStrictEqual(result, [3, 1, 2]);
     });
   });
 
-  describe('uniqBy', () => {
+  describe(uniqBy, () => {
     test('should remove duplicates based on key function', () => {
       const array = [
         { id: 1, name: 'Alice' },
@@ -385,9 +409,10 @@ describe('Arr transformations', () => {
       const result = uniqBy(array, (item) => item.id);
 
       expect(result).toHaveLength(3);
-      expect(result[0]).toStrictEqual({ id: 1, name: 'Alice' });
-      expect(result[1]).toStrictEqual({ id: 2, name: 'Bob' });
-      expect(result[2]).toStrictEqual({ id: 3, name: 'Charlie' });
+
+      assert.deepStrictEqual(result[0], { id: 1, name: 'Alice' });
+      assert.deepStrictEqual(result[1], { id: 2, name: 'Bob' });
+      assert.deepStrictEqual(result[2], { id: 3, name: 'Charlie' });
     });
 
     test('should work with string key function', () => {
@@ -403,11 +428,12 @@ describe('Arr transformations', () => {
     test('should work with empty array', () => {
       const empty: readonly { id: number }[] = [];
       const result = uniqBy(empty, (item) => item.id);
-      expect(result).toStrictEqual([]);
+
+      assert.deepStrictEqual(result, []);
     });
   });
 
-  describe('flat', () => {
+  describe(flat, () => {
     test('should flatten nested arrays with default depth 1', () => {
       const nested = [
         [1, 2],
@@ -415,15 +441,17 @@ describe('Arr transformations', () => {
         [5, 6],
       ];
       const flattened = flat(nested);
-      expect(flattened).toStrictEqual([1, 2, 3, 4, 5, 6]);
+
+      assert.deepStrictEqual(flattened, [1, 2, 3, 4, 5, 6]);
     });
 
     test('should flatten with specified depth', () => {
       const deepNested = [1, [2, [3, 4]], 5];
       const flat1 = flat(deepNested, 1);
       const flat2 = flat(deepNested, 2);
-      expect(flat1).toStrictEqual([1, 2, [3, 4], 5]);
-      expect(flat2).toStrictEqual([1, 2, 3, 4, 5]);
+
+      assert.deepStrictEqual(flat1, [1, 2, [3, 4], 5]);
+      assert.deepStrictEqual(flat2, [1, 2, 3, 4, 5]);
     });
 
     test('should work with curried version', () => {
@@ -432,13 +460,15 @@ describe('Arr transformations', () => {
         [1, 2],
         [3, 4],
       ]);
-      expect(result).toStrictEqual([1, 2, 3, 4]);
+
+      assert.deepStrictEqual(result, [1, 2, 3, 4]);
     });
 
     test('should work with empty arrays', () => {
       const withEmpties = [[1], [], [2, 3]];
       const flattened = flat(withEmpties);
-      expect(flattened).toStrictEqual([1, 2, 3]);
+
+      assert.deepStrictEqual(flattened, [1, 2, 3]);
     });
 
     test('should work with depth 0', () => {
@@ -447,7 +477,8 @@ describe('Arr transformations', () => {
         [3, 4],
       ];
       const unflattened = flat(nested, 0);
-      expect(unflattened).toStrictEqual([
+
+      assert.deepStrictEqual(unflattened, [
         [1, 2],
         [3, 4],
       ]);
@@ -456,15 +487,17 @@ describe('Arr transformations', () => {
     test('should work with infinite depth', () => {
       const veryDeep = [1, [2, [3, [4, [5]]]]];
       const allFlat = flat(veryDeep, SafeUint.MAX_VALUE);
-      expect(allFlat).toStrictEqual([1, 2, 3, 4, 5]);
+
+      assert.deepStrictEqual(allFlat, [1, 2, 3, 4, 5]);
     });
   });
 
-  describe('flatMap', () => {
+  describe(flatMap, () => {
     test('should map and flatten results', () => {
       const words = ['hello', 'world'];
       const chars = flatMap(words, (word) => word.split(''));
-      expect(chars).toStrictEqual([
+
+      assert.deepStrictEqual(chars, [
         'h',
         'e',
         'l',
@@ -481,41 +514,47 @@ describe('Arr transformations', () => {
     test('should work with curried version', () => {
       const splitWords = flatMap((word: string) => word.split(''));
       const result = splitWords(['foo', 'bar']);
-      expect(result).toStrictEqual(['f', 'o', 'o', 'b', 'a', 'r']);
+
+      assert.deepStrictEqual(result, ['f', 'o', 'o', 'b', 'a', 'r']);
     });
 
     test('should work with numbers', () => {
       const numbers = [1, 2, 3];
       const doubled = flatMap(numbers, (n) => [n, n * 2]);
-      expect(doubled).toStrictEqual([1, 2, 2, 4, 3, 6]);
+
+      assert.deepStrictEqual(doubled, [1, 2, 2, 4, 3, 6]);
     });
 
     test('should pass index to mapping function', () => {
       const numbers = [10, 20];
       const result = flatMap(numbers, (n, i) => [n, i]);
-      expect(result).toStrictEqual([10, 0, 20, 1]);
+
+      assert.deepStrictEqual(result, [10, 0, 20, 1]);
     });
 
     test('should work with empty arrays', () => {
       const empty: string[] = [];
       const result = flatMap(empty, (s) => s.split(''));
-      expect(result).toStrictEqual([]);
+
+      assert.deepStrictEqual(result, []);
     });
 
     test('should handle mapping to empty arrays', () => {
       const numbers = [1, 2, 3];
       const result = flatMap(numbers, (n) => (n % 2 === 0 ? [n] : []));
-      expect(result).toStrictEqual([2]);
+
+      assert.deepStrictEqual(result, [2]);
     });
 
     test('should work with tuples', () => {
       const tuple = [1, 2] as const;
       const result = flatMap(tuple, (n) => [n, n]);
-      expect(result).toStrictEqual([1, 1, 2, 2]);
+
+      assert.deepStrictEqual(result, [1, 1, 2, 2]);
     });
   });
 
-  describe('partition', () => {
+  describe(partition, () => {
     const xs = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12] as const;
 
     {
@@ -540,7 +579,7 @@ describe('Arr transformations', () => {
       >('=');
 
       test('case 1', () => {
-        expect(result).toStrictEqual([
+        assert.deepStrictEqual(result, [
           [1, 2, 3, 4],
           [5, 6, 7, 8],
           [9, 10, 11, 12],
@@ -570,7 +609,7 @@ describe('Arr transformations', () => {
       >('=');
 
       test('case 2', () => {
-        expect(result).toStrictEqual([
+        assert.deepStrictEqual(result, [
           [1, 2, 3],
           [4, 5, 6],
           [7, 8, 9],
@@ -601,7 +640,7 @@ describe('Arr transformations', () => {
       >('=');
 
       test('case 3', () => {
-        expect(result).toStrictEqual([
+        assert.deepStrictEqual(result, [
           [1, 2, 3, 4, 5],
           [6, 7, 8, 9, 10],
           [11, 12],
@@ -613,7 +652,7 @@ describe('Arr transformations', () => {
       const numbers = [1, 2, 3, 4, 5, 6];
       const result = partition(numbers, 2);
 
-      expect(result).toStrictEqual([
+      assert.deepStrictEqual(result, [
         [1, 2],
         [3, 4],
         [5, 6],
@@ -624,7 +663,7 @@ describe('Arr transformations', () => {
       const numbers = [1, 2, 3, 4, 5];
       const result = partition(numbers, 2);
 
-      expect(result).toStrictEqual([[1, 2], [3, 4], [5]]);
+      assert.deepStrictEqual(result, [[1, 2], [3, 4], [5]]);
     });
 
     test('should work with chunk size < 2 (returns empty)', () => {
@@ -632,25 +671,25 @@ describe('Arr transformations', () => {
       const result = partition(numbers, 1);
 
       // According to docs, returns empty array if chunkSize < 2
-      expect(result).toStrictEqual([]);
+      assert.deepStrictEqual(result, []);
     });
 
     test('should work with chunk size larger than array', () => {
       const numbers = [1, 2];
       const result = partition(numbers, 5);
 
-      expect(result).toStrictEqual([[1, 2]]);
+      assert.deepStrictEqual(result, [[1, 2]]);
     });
 
     test('partition should work with empty array', () => {
       const empty: readonly number[] = [];
       const result = partition(empty, 2);
 
-      expect(result).toStrictEqual([]);
+      assert.deepStrictEqual(result, []);
     });
   });
 
-  describe('concat', () => {
+  describe(concat, () => {
     const xs = [1, 2, 3] as const;
     const ys = [4, 5] as const;
     const result = concat(xs, ys);
@@ -658,7 +697,7 @@ describe('Arr transformations', () => {
     expectType<typeof result, readonly [1, 2, 3, 4, 5]>('=');
 
     test('case 1', () => {
-      expect(result).toStrictEqual([1, 2, 3, 4, 5]);
+      assert.deepStrictEqual(result, [1, 2, 3, 4, 5]);
     });
 
     // testArrayEquality({
@@ -692,7 +731,7 @@ describe('Arr transformations', () => {
     // });
   });
 
-  describe('groupBy', () => {
+  describe(groupBy, () => {
     const xs = [
       { x: 1, y: 1 },
       { x: 2, y: 1 },
@@ -720,7 +759,8 @@ describe('Arr transformations', () => {
     >('=');
 
     test('case 1', () => {
-      expect(result).toStrictEqual(
+      assert.deepStrictEqual(
+        result,
         IMap.create<
           1 | 2 | 3,
           readonly (
@@ -761,6 +801,7 @@ describe('Arr transformations', () => {
       const grouped = groupBy(array, (item) => item.type);
 
       expect(grouped.size).toBe(2);
+
       const fruits = grouped.get('fruit');
       const vegetables = grouped.get('vegetable');
 
@@ -784,21 +825,23 @@ describe('Arr transformations', () => {
       const grouped = groupBy(numbers, (n) => n % 2);
 
       expect(grouped.size).toBe(2);
+
       const evens = grouped.get(0);
       const odds = grouped.get(1);
 
       if (Optional.isSome(evens)) {
-        expect(evens.value).toStrictEqual([2, 4, 6]);
+        assert.deepStrictEqual(evens.value, [2, 4, 6]);
       }
 
       if (Optional.isSome(odds)) {
-        expect(odds.value).toStrictEqual([1, 3, 5]);
+        assert.deepStrictEqual(odds.value, [1, 3, 5]);
       }
     });
 
     test('should work with empty array', () => {
       const empty: readonly number[] = [];
       const grouped = groupBy(empty, (n) => n % 2);
+
       expect(grouped.size).toBe(0);
     });
 
@@ -807,15 +850,16 @@ describe('Arr transformations', () => {
       const grouped = groupBy(array, () => 'all');
 
       expect(grouped.size).toBe(1);
+
       const all = grouped.get('all');
 
       if (Optional.isSome(all)) {
-        expect(all.value).toStrictEqual([1, 2, 3, 4]);
+        assert.deepStrictEqual(all.value, [1, 2, 3, 4]);
       }
     });
   });
 
-  describe('zip', () => {
+  describe(zip, () => {
     {
       const xs = [1, 2, 3] as const;
       const ys = [4, 5, 6] as const;
@@ -827,7 +871,7 @@ describe('Arr transformations', () => {
       >('=');
 
       test('case 1', () => {
-        expect(zipped).toStrictEqual([
+        assert.deepStrictEqual(zipped, [
           [1, 4],
           [2, 5],
           [3, 6],
@@ -842,7 +886,7 @@ describe('Arr transformations', () => {
       expectType<typeof zipped, readonly (readonly [number, number])[]>('=');
 
       test('case 2', () => {
-        expect(zipped).toStrictEqual([[1, 4]]);
+        assert.deepStrictEqual(zipped, [[1, 4]]);
       });
     }
     {
@@ -853,7 +897,7 @@ describe('Arr transformations', () => {
       expectType<typeof zipped, readonly [readonly [1, number]]>('=');
 
       test('case 3', () => {
-        expect(zipped).toStrictEqual([[1, 4]]);
+        assert.deepStrictEqual(zipped, [[1, 4]]);
       });
     }
 
@@ -901,7 +945,8 @@ describe('Arr transformations', () => {
       const arr1 = [1, 2, 3];
       const arr2 = ['a', 'b', 'c'];
       const result = zip(arr1, arr2);
-      expect(result).toStrictEqual([
+
+      assert.deepStrictEqual(result, [
         [1, 'a'],
         [2, 'b'],
         [3, 'c'],
@@ -912,7 +957,8 @@ describe('Arr transformations', () => {
       const arr1 = [1, 2, 3, 4];
       const arr2 = ['a', 'b'];
       const result = zip(arr1, arr2);
-      expect(result).toStrictEqual([
+
+      assert.deepStrictEqual(result, [
         [1, 'a'],
         [2, 'b'],
       ]);
@@ -922,14 +968,16 @@ describe('Arr transformations', () => {
       const arr1: readonly number[] = [];
       const arr2: readonly string[] = [];
       const result = zip(arr1, arr2);
-      expect(result).toStrictEqual([]);
+
+      assert.deepStrictEqual(result, []);
     });
 
     test('should handle one empty array', () => {
       const arr1 = [1, 2, 3];
       const arr2: readonly string[] = [];
       const result = zip(arr1, arr2);
-      expect(result).toStrictEqual([]);
+
+      assert.deepStrictEqual(result, []);
     });
   });
 });