ts-data-forge 5.0.1 → 5.1.1

package/src/collections/iset-mapped.test.mts

@@ -1,14 +1,18 @@
 import { ISetMapped } from './iset-mapped.mjs';
 
 const toKey = (a: Readonly<{ v: number }>): number => a.v;
+
 const fromKey = (k: number): Readonly<{ v: number }> => ({ v: k });
 
 // Test types for additional functionality
 type TestElement = { id: number; type: string };
+
 const testElementToString = (el: Readonly<TestElement>): string =>
   `${el.type}_${el.id}`;
+
 const stringToTestElement = (str: string): TestElement => {
   const [type, idStr] = str.split('_');
+
   return { type: type ?? '', id: Number(idStr ?? '0') };
 };
 
@@ -47,7 +51,7 @@ describe('ISetMapped.has', () => {
       fromKey,
     );
 
-    expect(s0.has({ v: 3 })).toBe(true);
+    assert.isTrue(s0.has({ v: 3 }));
   });
 
   test('case 2', () => {
@@ -57,7 +61,7 @@ describe('ISetMapped.has', () => {
       fromKey,
     );
 
-    expect(s0.has({ v: 4 })).toBe(false);
+    assert.isFalse(s0.has({ v: 4 }));
   });
 
   test('case 3', () => {
@@ -67,7 +71,7 @@ describe('ISetMapped.has', () => {
       fromKey,
     );
 
-    expect(s0.has({ v: 3 })).toBe(false);
+    assert.isFalse(s0.has({ v: 3 }));
   });
 });
 
@@ -87,6 +91,7 @@ describe('ISetMapped.add', () => {
         fromKey,
       ),
     );
+
     assert.deepStrictEqual(
       s0,
       ISetMapped.create([{ v: 1 }, { v: 2 }, { v: 3 }], toKey, fromKey),
@@ -104,6 +109,7 @@ describe('ISetMapped.add', () => {
       s0.add({ v: 3 }),
       ISetMapped.create([{ v: 1 }, { v: 2 }, { v: 3 }], toKey, fromKey),
     );
+
     assert.deepStrictEqual(
       s0,
       ISetMapped.create([{ v: 1 }, { v: 2 }, { v: 3 }], toKey, fromKey),
@@ -117,6 +123,7 @@ describe('ISetMapped.add', () => {
       s0.add({ v: 1 }),
       ISetMapped.create([{ v: 1 }], toKey, fromKey),
     );
+
     assert.deepStrictEqual(s0, ISetMapped.create([], toKey, fromKey));
   });
 });
@@ -133,6 +140,7 @@ describe('ISetMapped.delete', () => {
       s0.delete({ v: 10 }),
       ISetMapped.create([{ v: 1 }, { v: 2 }, { v: 3 }], toKey, fromKey),
     );
+
     assert.deepStrictEqual(
       s0,
       ISetMapped.create([{ v: 1 }, { v: 2 }, { v: 3 }], toKey, fromKey),
@@ -150,6 +158,7 @@ describe('ISetMapped.delete', () => {
       s0.delete({ v: 3 }),
       ISetMapped.create([{ v: 1 }, { v: 2 }], toKey, fromKey),
     );
+
     assert.deepStrictEqual(
       s0,
       ISetMapped.create([{ v: 1 }, { v: 2 }, { v: 3 }], toKey, fromKey),
@@ -163,6 +172,7 @@ describe('ISetMapped.delete', () => {
       s0.delete({ v: 1 }),
       ISetMapped.create([], toKey, fromKey),
     );
+
     assert.deepStrictEqual(s0, ISetMapped.create([], toKey, fromKey));
   });
 });
@@ -174,6 +184,7 @@ describe('ISetMapped.forEach', () => {
       toKey,
       fromKey,
     );
+
     const elements = [{ v: 1 }, { v: 2 }, { v: 3 }];
 
     for (const el of s0) {
@@ -189,6 +200,7 @@ describe('ISetMapped.keys', () => {
       toKey,
       fromKey,
     );
+
     const elements = [{ v: 1 }, { v: 2 }, { v: 3 }];
 
     for (const k of s0.keys()) {
@@ -204,6 +216,7 @@ describe('ISetMapped.values', () => {
       toKey,
       fromKey,
     );
+
     const elements = [{ v: 1 }, { v: 2 }, { v: 3 }];
 
     for (const v of s0.values()) {
@@ -219,10 +232,12 @@ describe('ISetMapped.entries', () => {
       toKey,
       fromKey,
     );
+
     const elements = [{ v: 1 }, { v: 2 }, { v: 3 }];
 
     for (const [k, v] of s0.entries()) {
       expect(elements).toContainEqual(k);
+
       expect(elements).toContainEqual(v);
 
       assert.deepStrictEqual(k, v);
@@ -237,6 +252,7 @@ describe('ISetMapped.subtract', () => {
       toKey,
       fromKey,
     );
+
     const s1 = ISetMapped.create([{ v: 2 }, { v: 4 }], toKey, fromKey);
 
     assert.deepStrictEqual(
@@ -251,6 +267,7 @@ describe('ISetMapped.subtract', () => {
       toKey,
       fromKey,
     );
+
     const s1 = ISetMapped.create([], toKey, fromKey);
 
     assert.deepStrictEqual(
@@ -261,6 +278,7 @@ describe('ISetMapped.subtract', () => {
 
   test('case 3', () => {
     const s0 = ISetMapped.create([], toKey, fromKey);
+
     const s1 = ISetMapped.create(
       [{ v: 1 }, { v: 2 }, { v: 3 }],
       toKey,
@@ -281,6 +299,7 @@ describe('ISetMapped.diff', () => {
       toKey,
       fromKey,
     );
+
     const s1 = ISetMapped.create(
       [{ v: 2 }, { v: 3 }, { v: 4 }],
       toKey,
@@ -293,6 +312,7 @@ describe('ISetMapped.diff', () => {
       diff.deleted,
       ISetMapped.create([{ v: 1 }], toKey, fromKey),
     );
+
     assert.deepStrictEqual(
       diff.added,
       ISetMapped.create([{ v: 4 }], toKey, fromKey),
@@ -305,6 +325,7 @@ describe('ISetMapped.diff', () => {
       toKey,
       fromKey,
     );
+
     const s1 = ISetMapped.create([], toKey, fromKey);
 
     const diff = ISetMapped.diff(s0, s1);
@@ -313,11 +334,13 @@ describe('ISetMapped.diff', () => {
       diff.deleted,
       ISetMapped.create([{ v: 1 }, { v: 2 }, { v: 3 }], toKey, fromKey),
     );
+
     assert.deepStrictEqual(diff.added, ISetMapped.create([], toKey, fromKey));
   });
 
   test('case 3', () => {
     const s0 = ISetMapped.create([], toKey, fromKey);
+
     const s1 = ISetMapped.create(
       [{ v: 1 }, { v: 2 }, { v: 3 }],
       toKey,
@@ -327,6 +350,7 @@ describe('ISetMapped.diff', () => {
     const diff = ISetMapped.diff(s0, s1);
 
     assert.deepStrictEqual(diff.deleted, ISetMapped.create([], toKey, fromKey));
+
     assert.deepStrictEqual(
       diff.added,
       ISetMapped.create([{ v: 1 }, { v: 2 }, { v: 3 }], toKey, fromKey),
@@ -341,6 +365,7 @@ describe('ISetMapped.union', () => {
       toKey,
       fromKey,
     );
+
     const s1 = ISetMapped.create(
       [{ v: 3 }, { v: 4 }, { v: 5 }],
       toKey,
@@ -363,6 +388,7 @@ describe('ISetMapped.union', () => {
       toKey,
       fromKey,
     );
+
     const s1 = ISetMapped.create([], toKey, fromKey);
 
     assert.deepStrictEqual(
@@ -373,6 +399,7 @@ describe('ISetMapped.union', () => {
 
   test('case 3', () => {
     const s0 = ISetMapped.create([], toKey, fromKey);
+
     const s1 = ISetMapped.create(
       [{ v: 1 }, { v: 2 }, { v: 3 }],
       toKey,
@@ -393,6 +420,7 @@ describe('ISetMapped.intersection', () => {
       toKey,
       fromKey,
     );
+
     const s1 = ISetMapped.create(
       [{ v: 2 }, { v: 3 }, { v: 4 }],
       toKey,
@@ -411,6 +439,7 @@ describe('ISetMapped.intersection', () => {
       toKey,
       fromKey,
     );
+
     const s1 = ISetMapped.create([], toKey, fromKey);
 
     assert.deepStrictEqual(
@@ -421,6 +450,7 @@ describe('ISetMapped.intersection', () => {
 
   test('case 3', () => {
     const s0 = ISetMapped.create([], toKey, fromKey);
+
     const s1 = ISetMapped.create(
       [{ v: 1 }, { v: 2 }, { v: 3 }],
       toKey,
@@ -457,8 +487,10 @@ describe('ISetMapped additional functionality with complex types', () => {
       );
 
       expect(set.size).toBe(2);
-      expect(set.has({ id: 1, type: 'user' })).toBe(true);
-      expect(set.has({ id: 2, type: 'admin' })).toBe(true);
+
+      assert.isTrue(set.has({ id: 1, type: 'user' }));
+
+      assert.isTrue(set.has({ id: 2, type: 'admin' }));
     });
 
     test('should handle duplicate elements based on mapping', () => {
@@ -486,6 +518,7 @@ describe('ISetMapped additional functionality with complex types', () => {
         testElementToString,
         stringToTestElement,
       );
+
       const set2 = ISetMapped.create(
         [
           { id: 2, type: 'admin' },
@@ -495,7 +528,7 @@ describe('ISetMapped additional functionality with complex types', () => {
         stringToTestElement,
       );
 
-      expect(ISetMapped.equal(set1, set2)).toBe(true);
+      assert.isTrue(ISetMapped.equal(set1, set2));
     });
 
     test('should return false for sets with different elements', () => {
@@ -507,6 +540,7 @@ describe('ISetMapped additional functionality with complex types', () => {
         testElementToString,
         stringToTestElement,
       );
+
       const set2 = ISetMapped.create(
         [
           { id: 1, type: 'user' },
@@ -516,7 +550,7 @@ describe('ISetMapped additional functionality with complex types', () => {
         stringToTestElement,
       );
 
-      expect(ISetMapped.equal(set1, set2)).toBe(false);
+      assert.isFalse(ISetMapped.equal(set1, set2));
     });
 
     test('should return true for empty sets', () => {
@@ -525,13 +559,14 @@ describe('ISetMapped additional functionality with complex types', () => {
         testElementToString,
         stringToTestElement,
       );
+
       const set2 = ISetMapped.create<TestElement, string>(
         [],
         testElementToString,
         stringToTestElement,
       );
 
-      expect(ISetMapped.equal(set1, set2)).toBe(true);
+      assert.isTrue(ISetMapped.equal(set1, set2));
     });
   });
 
@@ -546,6 +581,7 @@ describe('ISetMapped additional functionality with complex types', () => {
         testElementToString,
         stringToTestElement,
       );
+
       const newSet = ISetMapped.create(
         [
           { id: 2, type: 'admin' },
@@ -559,10 +595,12 @@ describe('ISetMapped additional functionality with complex types', () => {
       const diff = ISetMapped.diff(oldSet, newSet);
 
       expect(diff.deleted.size).toBe(1);
-      expect(diff.deleted.has({ id: 1, type: 'user' })).toBe(true);
+
+      assert.isTrue(diff.deleted.has({ id: 1, type: 'user' }));
 
       expect(diff.added.size).toBe(1);
-      expect(diff.added.has({ id: 4, type: 'user' })).toBe(true);
+
+      assert.isTrue(diff.added.has({ id: 4, type: 'user' }));
     });
 
     test('should handle no changes', () => {
@@ -574,6 +612,7 @@ describe('ISetMapped additional functionality with complex types', () => {
         testElementToString,
         stringToTestElement,
       );
+
       const set2 = ISetMapped.create(
         [
           { id: 1, type: 'user' },
@@ -586,6 +625,7 @@ describe('ISetMapped additional functionality with complex types', () => {
       const diff = ISetMapped.diff(set1, set2);
 
       expect(diff.deleted.size).toBe(0);
+
       expect(diff.added.size).toBe(0);
     });
   });
@@ -601,6 +641,7 @@ describe('ISetMapped additional functionality with complex types', () => {
         testElementToString,
         stringToTestElement,
       );
+
       const set2 = ISetMapped.create(
         [
           { id: 2, type: 'admin' },
@@ -614,8 +655,10 @@ describe('ISetMapped additional functionality with complex types', () => {
       const intersection = ISetMapped.intersection(set1, set2);
 
       expect(intersection.size).toBe(2);
-      expect(intersection.has({ id: 2, type: 'admin' })).toBe(true);
-      expect(intersection.has({ id: 3, type: 'guest' })).toBe(true);
+
+      assert.isTrue(intersection.has({ id: 2, type: 'admin' }));
+
+      assert.isTrue(intersection.has({ id: 3, type: 'guest' }));
     });
 
     test('should compute union correctly', () => {
@@ -627,6 +670,7 @@ describe('ISetMapped additional functionality with complex types', () => {
         testElementToString,
         stringToTestElement,
       );
+
       const set2 = ISetMapped.create(
         [
           { id: 3, type: 'guest' },
@@ -639,10 +683,14 @@ describe('ISetMapped additional functionality with complex types', () => {
       const union = ISetMapped.union(set1, set2);
 
       expect(union.size).toBe(4);
-      expect(union.has({ id: 1, type: 'user' })).toBe(true);
-      expect(union.has({ id: 2, type: 'admin' })).toBe(true);
-      expect(union.has({ id: 3, type: 'guest' })).toBe(true);
-      expect(union.has({ id: 4, type: 'user' })).toBe(true);
+
+      assert.isTrue(union.has({ id: 1, type: 'user' }));
+
+      assert.isTrue(union.has({ id: 2, type: 'admin' }));
+
+      assert.isTrue(union.has({ id: 3, type: 'guest' }));
+
+      assert.isTrue(union.has({ id: 4, type: 'user' }));
     });
   });
 
@@ -657,7 +705,7 @@ describe('ISetMapped additional functionality with complex types', () => {
         stringToTestElement,
       );
 
-      expect(set.every((el) => el.type === 'user')).toBe(true);
+      assert.isTrue(set.every((el) => el.type === 'user'));
     });
 
     test('should return false when some elements do not satisfy predicate', () => {
@@ -670,7 +718,7 @@ describe('ISetMapped additional functionality with complex types', () => {
         stringToTestElement,
       );
 
-      expect(set.every((el) => el.type === 'user')).toBe(false);
+      assert.isFalse(set.every((el) => el.type === 'user'));
     });
   });
 
@@ -685,7 +733,7 @@ describe('ISetMapped additional functionality with complex types', () => {
         stringToTestElement,
       );
 
-      expect(set.some((el) => el.type === 'admin')).toBe(true);
+      assert.isTrue(set.some((el) => el.type === 'admin'));
     });
 
     test('should return false when no elements satisfy predicate', () => {
@@ -698,7 +746,7 @@ describe('ISetMapped additional functionality with complex types', () => {
         stringToTestElement,
       );
 
-      expect(set.some((el) => el.type === 'admin')).toBe(false);
+      assert.isFalse(set.some((el) => el.type === 'admin'));
     });
   });
 
@@ -709,11 +757,14 @@ describe('ISetMapped additional functionality with complex types', () => {
         testElementToString,
         stringToTestElement,
       );
+
       const updated = set.add({ id: 2, type: 'admin' });
 
       expect(updated.size).toBe(2);
-      expect(updated.has({ id: 1, type: 'user' })).toBe(true);
-      expect(updated.has({ id: 2, type: 'admin' })).toBe(true);
+
+      assert.isTrue(updated.has({ id: 1, type: 'user' }));
+
+      assert.isTrue(updated.has({ id: 2, type: 'admin' }));
     });
 
     test('should return same instance when adding existing element', () => {
@@ -722,6 +773,7 @@ describe('ISetMapped additional functionality with complex types', () => {
         testElementToString,
         stringToTestElement,
       );
+
       const updated = set.add({ id: 1, type: 'user' });
 
       expect(updated).toBe(set);
@@ -738,11 +790,14 @@ describe('ISetMapped additional functionality with complex types', () => {
         testElementToString,
         stringToTestElement,
       );
+
       const updated = set.delete({ id: 1, type: 'user' });
 
       expect(updated.size).toBe(1);
-      expect(updated.has({ id: 1, type: 'user' })).toBe(false);
-      expect(updated.has({ id: 2, type: 'admin' })).toBe(true);
+
+      assert.isFalse(updated.has({ id: 1, type: 'user' }));
+
+      assert.isTrue(updated.has({ id: 2, type: 'admin' }));
     });
 
     test('should return same instance when deleting non-existent element', () => {
@@ -751,6 +806,7 @@ describe('ISetMapped additional functionality with complex types', () => {
         testElementToString,
         stringToTestElement,
       );
+
       const updated = set.delete({ id: 2, type: 'admin' });
 
       expect(updated).toBe(set);
@@ -772,9 +828,12 @@ describe('ISetMapped additional functionality with complex types', () => {
       ]);
 
       expect(updated.size).toBe(2);
-      expect(updated.has({ id: 1, type: 'user' })).toBe(false);
-      expect(updated.has({ id: 2, type: 'admin' })).toBe(true);
-      expect(updated.has({ id: 3, type: 'guest' })).toBe(true);
+
+      assert.isFalse(updated.has({ id: 1, type: 'user' }));
+
+      assert.isTrue(updated.has({ id: 2, type: 'admin' }));
+
+      assert.isTrue(updated.has({ id: 3, type: 'guest' }));
     });
 
     test('should handle empty mutations array', () => {
@@ -783,10 +842,12 @@ describe('ISetMapped additional functionality with complex types', () => {
         testElementToString,
         stringToTestElement,
       );
+
       const updated = set.withMutations([]);
 
       expect(updated.size).toBe(1);
-      expect(ISetMapped.equal(set, updated)).toBe(true);
+
+      assert.isTrue(ISetMapped.equal(set, updated));
     });
   });
 
@@ -800,14 +861,17 @@ describe('ISetMapped additional functionality with complex types', () => {
         testElementToString,
         stringToTestElement,
       );
+
       const transformed = set.map((el) => ({
         ...el,
         type: el.type.toUpperCase(),
       }));
 
       expect(transformed.size).toBe(2);
-      expect(transformed.has({ id: 1, type: 'USER' })).toBe(true);
-      expect(transformed.has({ id: 2, type: 'ADMIN' })).toBe(true);
+
+      assert.isTrue(transformed.has({ id: 1, type: 'USER' }));
+
+      assert.isTrue(transformed.has({ id: 2, type: 'ADMIN' }));
     });
   });
 
@@ -822,12 +886,16 @@ describe('ISetMapped additional functionality with complex types', () => {
         testElementToString,
         stringToTestElement,
       );
+
       const filtered = set.filter((el) => el.type === 'user');
 
       expect(filtered.size).toBe(2);
-      expect(filtered.has({ id: 1, type: 'user' })).toBe(true);
-      expect(filtered.has({ id: 3, type: 'user' })).toBe(true);
-      expect(filtered.has({ id: 2, type: 'admin' })).toBe(false);
+
+      assert.isTrue(filtered.has({ id: 1, type: 'user' }));
+
+      assert.isTrue(filtered.has({ id: 3, type: 'user' }));
+
+      assert.isFalse(filtered.has({ id: 2, type: 'admin' }));
     });
   });
 
@@ -842,12 +910,16 @@ describe('ISetMapped additional functionality with complex types', () => {
         testElementToString,
         stringToTestElement,
       );
+
       const filtered = set.filterNot((el) => el.type === 'user');
 
       expect(filtered.size).toBe(1);
-      expect(filtered.has({ id: 2, type: 'admin' })).toBe(true);
-      expect(filtered.has({ id: 1, type: 'user' })).toBe(false);
-      expect(filtered.has({ id: 3, type: 'user' })).toBe(false);
+
+      assert.isTrue(filtered.has({ id: 2, type: 'admin' }));
+
+      assert.isFalse(filtered.has({ id: 1, type: 'user' }));
+
+      assert.isFalse(filtered.has({ id: 3, type: 'user' }));
     });
   });
 
@@ -861,6 +933,7 @@ describe('ISetMapped additional functionality with complex types', () => {
         testElementToString,
         stringToTestElement,
       );
+
       const mut_collected: TestElement[] = [];
 
       for (const el of set) {
@@ -868,7 +941,9 @@ describe('ISetMapped additional functionality with complex types', () => {
       }
 
       expect(mut_collected).toHaveLength(2);
+
       expect(mut_collected).toContainEqual({ id: 1, type: 'user' });
+
       expect(mut_collected).toContainEqual({ id: 2, type: 'admin' });
     });
   });
@@ -880,6 +955,7 @@ describe('ISetMapped additional functionality with complex types', () => {
         testElementToString,
         stringToTestElement,
       );
+
       const superset = ISetMapped.create(
         [
           { id: 1, type: 'user' },
@@ -889,7 +965,7 @@ describe('ISetMapped additional functionality with complex types', () => {
         stringToTestElement,
       );
 
-      expect(subset.isSubsetOf(superset)).toBe(true);
+      assert.isTrue(subset.isSubsetOf(superset));
     });
 
     test('should return false for non-subset', () => {
@@ -901,6 +977,7 @@ describe('ISetMapped additional functionality with complex types', () => {
         testElementToString,
         stringToTestElement,
       );
+
       const set2 = ISetMapped.create(
         [
           { id: 1, type: 'user' },
@@ -910,7 +987,7 @@ describe('ISetMapped additional functionality with complex types', () => {
         stringToTestElement,
       );
 
-      expect(set1.isSubsetOf(set2)).toBe(false);
+      assert.isFalse(set1.isSubsetOf(set2));
     });
   });
 
@@ -924,13 +1001,14 @@ describe('ISetMapped additional functionality with complex types', () => {
         testElementToString,
         stringToTestElement,
       );
+
       const subset = ISetMapped.create(
         [{ id: 1, type: 'user' }],
         testElementToString,
         stringToTestElement,
       );
 
-      expect(superset.isSupersetOf(subset)).toBe(true);
+      assert.isTrue(superset.isSupersetOf(subset));
     });
 
     test('should return false for non-superset', () => {
@@ -942,6 +1020,7 @@ describe('ISetMapped additional functionality with complex types', () => {
         testElementToString,
         stringToTestElement,
       );
+
       const set2 = ISetMapped.create(
         [
           { id: 1, type: 'user' },
@@ -951,7 +1030,7 @@ describe('ISetMapped additional functionality with complex types', () => {
         stringToTestElement,
       );
 
-      expect(set1.isSupersetOf(set2)).toBe(false);
+      assert.isFalse(set1.isSupersetOf(set2));
     });
   });
 
@@ -966,6 +1045,7 @@ describe('ISetMapped additional functionality with complex types', () => {
         testElementToString,
         stringToTestElement,
       );
+
       const set2 = ISetMapped.create(
         [
           { id: 2, type: 'admin' },
@@ -974,12 +1054,16 @@ describe('ISetMapped additional functionality with complex types', () => {
         testElementToString,
         stringToTestElement,
       );
+
       const result = set1.subtract(set2);
 
       expect(result.size).toBe(2);
-      expect(result.has({ id: 1, type: 'user' })).toBe(true);
-      expect(result.has({ id: 3, type: 'guest' })).toBe(true);
-      expect(result.has({ id: 2, type: 'admin' })).toBe(false);
+
+      assert.isTrue(result.has({ id: 1, type: 'user' }));
+
+      assert.isTrue(result.has({ id: 3, type: 'guest' }));
+
+      assert.isFalse(result.has({ id: 2, type: 'admin' }));
     });
   });
 
@@ -994,6 +1078,7 @@ describe('ISetMapped additional functionality with complex types', () => {
         testElementToString,
         stringToTestElement,
       );
+
       const set2 = ISetMapped.create(
         [
           { id: 2, type: 'admin' },
@@ -1003,12 +1088,16 @@ describe('ISetMapped additional functionality with complex types', () => {
         testElementToString,
         stringToTestElement,
       );
+
       const result = set1.intersect(set2);
 
       expect(result.size).toBe(2);
-      expect(result.has({ id: 2, type: 'admin' })).toBe(true);
-      expect(result.has({ id: 3, type: 'guest' })).toBe(true);
-      expect(result.has({ id: 1, type: 'user' })).toBe(false);
+
+      assert.isTrue(result.has({ id: 2, type: 'admin' }));
+
+      assert.isTrue(result.has({ id: 3, type: 'guest' }));
+
+      assert.isFalse(result.has({ id: 1, type: 'user' }));
     });
   });
 
@@ -1022,6 +1111,7 @@ describe('ISetMapped additional functionality with complex types', () => {
         testElementToString,
         stringToTestElement,
       );
+
       const set2 = ISetMapped.create(
         [
           { id: 3, type: 'guest' },
@@ -1030,13 +1120,18 @@ describe('ISetMapped additional functionality with complex types', () => {
         testElementToString,
         stringToTestElement,
       );
+
       const result = set1.union(set2);
 
       expect(result.size).toBe(4);
-      expect(result.has({ id: 1, type: 'user' })).toBe(true);
-      expect(result.has({ id: 2, type: 'admin' })).toBe(true);
-      expect(result.has({ id: 3, type: 'guest' })).toBe(true);
-      expect(result.has({ id: 4, type: 'user' })).toBe(true);
+
+      assert.isTrue(result.has({ id: 1, type: 'user' }));
+
+      assert.isTrue(result.has({ id: 2, type: 'admin' }));
+
+      assert.isTrue(result.has({ id: 3, type: 'guest' }));
+
+      assert.isTrue(result.has({ id: 4, type: 'user' }));
     });
   });
 
@@ -1050,10 +1145,13 @@ describe('ISetMapped additional functionality with complex types', () => {
         testElementToString,
         stringToTestElement,
       );
+
       const keys = Array.from(set.keys());
 
       expect(keys).toHaveLength(2);
+
       expect(keys).toContainEqual({ id: 1, type: 'user' });
+
       expect(keys).toContainEqual({ id: 2, type: 'admin' });
     });
 
@@ -1066,10 +1164,13 @@ describe('ISetMapped additional functionality with complex types', () => {
         testElementToString,
         stringToTestElement,
       );
+
       const values = Array.from(set.values());
 
       expect(values).toHaveLength(2);
+
       expect(values).toContainEqual({ id: 1, type: 'user' });
+
       expect(values).toContainEqual({ id: 2, type: 'admin' });
     });
 
@@ -1082,6 +1183,7 @@ describe('ISetMapped additional functionality with complex types', () => {
         testElementToString,
         stringToTestElement,
       );
+
       const entries = Array.from(set.entries());
 
       expect(entries).toHaveLength(2);
@@ -1100,6 +1202,7 @@ describe('ISetMapped additional functionality with complex types', () => {
         testElementToString,
         stringToTestElement,
       );
+
       const mut_collected: TestElement[] = [];
 
       for (const element of set) {
@@ -1107,7 +1210,9 @@ describe('ISetMapped additional functionality with complex types', () => {
       }
 
       expect(mut_collected).toHaveLength(2);
+
       expect(mut_collected).toContainEqual({ id: 1, type: 'user' });
+
       expect(mut_collected).toContainEqual({ id: 2, type: 'admin' });
     });
   });
@@ -1122,10 +1227,13 @@ describe('ISetMapped additional functionality with complex types', () => {
         testElementToString,
         stringToTestElement,
       );
+
       const array = set.toArray();
 
       expect(array).toHaveLength(2);
+
       expect(array).toContainEqual({ id: 1, type: 'user' });
+
       expect(array).toContainEqual({ id: 2, type: 'admin' });
     });
 
@@ -1138,11 +1246,14 @@ describe('ISetMapped additional functionality with complex types', () => {
         testElementToString,
         stringToTestElement,
       );
+
       const rawSet = set.toRawSet();
 
       expect(rawSet.size).toBe(2);
-      expect(rawSet.has('user_1')).toBe(true);
-      expect(rawSet.has('admin_2')).toBe(true);
+
+      assert.isTrue(rawSet.has('user_1'));
+
+      assert.isTrue(rawSet.has('admin_2'));
     });
   });
 });