@jamashita/lluvia-sequence 2.6.0 → 2.9.0

package/src/__tests__/ImmutableSequence.spec.ts

@@ -3,22 +3,30 @@ import { Nullable } from '@jamashita/anden-type';
 import { ImmutableSequence } from '../ImmutableSequence';
 
 describe('ImmutableSequence', () => {
+  describe('empty', () => {
+    it('returns singleton instance', () => {
+      expect(ImmutableSequence.empty()).toBe(ImmutableSequence.empty());
+    });
+
+    it('always returns 0-size array', () => {
+      expect(ImmutableSequence.empty().isEmpty()).toBe(true);
+    });
+  });
+
   describe('of', () => {
     it('returns copied collection, does not use the same one', () => {
-      expect.assertions(4);
-
-      const sequence: ImmutableSequence<MockValueObject<number>> = ImmutableSequence.ofArray<MockValueObject<number>>([
-        new MockValueObject<number>(1),
-        new MockValueObject<number>(2)
+      const sequence: ImmutableSequence<MockValueObject<number>> = ImmutableSequence.ofArray([
+        new MockValueObject(1),
+        new MockValueObject(2)
       ]);
-      const copied: ImmutableSequence<MockValueObject<number>> = ImmutableSequence.of<MockValueObject<number>>(sequence);
+      const copied: ImmutableSequence<MockValueObject<number>> = ImmutableSequence.of(sequence);
 
       expect(sequence.size()).toBe(copied.size());
       sequence.forEach((v: MockValueObject<number>, k: number) => {
         expect(v).toBe(copied.get(k));
       });
 
-      sequence.add(new MockValueObject<number>(3));
+      sequence.add(new MockValueObject(3));
 
       expect(sequence.size()).toBe(copied.size());
     });
@@ -26,25 +34,21 @@ describe('ImmutableSequence', () => {
 
   describe('ofArray', () => {
     it('returns ImmutableSequence.empty() when the size is 0', () => {
-      expect.assertions(2);
-
-      const sequence: ImmutableSequence<MockValueObject<number>> = ImmutableSequence.ofArray<MockValueObject<number>>([]);
+      const sequence: ImmutableSequence<MockValueObject<number>> = ImmutableSequence.ofArray([]);
 
       expect(sequence.isEmpty()).toBe(true);
-      expect(sequence).toBe(ImmutableSequence.empty<MockValueObject<number>>());
+      expect(sequence).toBe(ImmutableSequence.empty());
     });
 
     it('returns instance', () => {
-      expect.assertions(2);
-
-      const sequence1: ImmutableSequence<MockValueObject<number>> = ImmutableSequence.ofArray<MockValueObject<number>>([
-        new MockValueObject<number>(1),
-        new MockValueObject<number>(3)
+      const sequence1: ImmutableSequence<MockValueObject<number>> = ImmutableSequence.ofArray([
+        new MockValueObject(1),
+        new MockValueObject(3)
       ]);
-      const sequence2: ImmutableSequence<MockValueObject<number>> = ImmutableSequence.ofArray<MockValueObject<number>>([
-        new MockValueObject<number>(2),
-        new MockValueObject<number>(4),
-        new MockValueObject<number>(5)
+      const sequence2: ImmutableSequence<MockValueObject<number>> = ImmutableSequence.ofArray([
+        new MockValueObject(2),
+        new MockValueObject(4),
+        new MockValueObject(5)
       ]);
 
       expect(sequence1.size()).toBe(2);
@@ -52,28 +56,12 @@ describe('ImmutableSequence', () => {
     });
   });
 
-  describe('empty', () => {
-    it('returns singleton instance', () => {
-      expect.assertions(1);
-
-      expect(ImmutableSequence.empty<MockValueObject<number>>()).toBe(ImmutableSequence.empty<MockValueObject<string>>());
-    });
-
-    it('always returns 0-size array', () => {
-      expect.assertions(1);
-
-      expect(ImmutableSequence.empty<MockValueObject<number>>().isEmpty()).toBe(true);
-    });
-  });
-
   describe('add', () => {
     it('can extend immutably', () => {
-      expect.assertions(13);
+      const value1: MockValueObject<number> = new MockValueObject(1);
+      const value2: MockValueObject<number> = new MockValueObject(2);
 
-      const value1: MockValueObject<number> = new MockValueObject<number>(1);
-      const value2: MockValueObject<number> = new MockValueObject<number>(2);
-
-      const sequence1: ImmutableSequence<MockValueObject<number>> = ImmutableSequence.empty<MockValueObject<number>>();
+      const sequence1: ImmutableSequence<MockValueObject<number>> = ImmutableSequence.empty();
 
       expect(sequence1.size()).toBe(0);
 
@@ -97,142 +85,133 @@ describe('ImmutableSequence', () => {
     });
   });
 
-  describe('set', () => {
-    it('can be set the value into first position', () => {
-      expect.assertions(6);
-
-      const value1: MockValueObject<number> = new MockValueObject<number>(1);
-      const value2: MockValueObject<number> = new MockValueObject<number>(2);
-      const value3: MockValueObject<number> = new MockValueObject<number>(3);
-      const value4: MockValueObject<number> = new MockValueObject<number>(4);
-
-      const sequence1: ImmutableSequence<MockValueObject<number>> = ImmutableSequence.ofArray<MockValueObject<number>>([
-        value1,
-        value2,
-        value3
-      ]);
-      const sequence2: ImmutableSequence<MockValueObject<number>> = sequence1.set(0, value4);
-
-      expect(sequence1).not.toBe(sequence2);
-      expect(sequence1.size()).toBe(3);
-      expect(sequence2.size()).toBe(3);
-      expect(sequence2.get(0)).toBe(value4);
-      expect(sequence2.get(1)).toBe(value2);
-      expect(sequence2.get(2)).toBe(value3);
+  describe('duplicate', () => {
+    it('returns ImmutableSequence.empty() when this is ImmutableSequence.empty()', () => {
+      expect(ImmutableSequence.empty().duplicate()).toBe(ImmutableSequence.empty());
     });
 
-    it('can be set the value into middle position', () => {
-      expect.assertions(6);
-
-      const value1: MockValueObject<number> = new MockValueObject<number>(1);
-      const value2: MockValueObject<number> = new MockValueObject<number>(2);
-      const value3: MockValueObject<number> = new MockValueObject<number>(3);
-      const value4: MockValueObject<number> = new MockValueObject<number>(4);
-
-      const sequence1: ImmutableSequence<MockValueObject<number>> = ImmutableSequence.ofArray<MockValueObject<number>>([
-        value1,
-        value2,
-        value3
+    it('returns shallow-copied instance', () => {
+      const sequence1: ImmutableSequence<MockValueObject<number>> = ImmutableSequence.ofArray([
+        new MockValueObject(1),
+        new MockValueObject(2),
+        new MockValueObject(3),
+        new MockValueObject(2)
       ]);
-      const sequence2: ImmutableSequence<MockValueObject<number>> = sequence1.set(1, value4);
+      const sequence2: ImmutableSequence<MockValueObject<number>> = sequence1.duplicate();
 
+      expect(sequence1.size()).toBe(sequence2.size());
       expect(sequence1).not.toBe(sequence2);
-      expect(sequence1.size()).toBe(3);
-      expect(sequence2.size()).toBe(3);
-      expect(sequence2.get(0)).toBe(value1);
-      expect(sequence2.get(1)).toBe(value4);
-      expect(sequence2.get(2)).toBe(value3);
+      sequence1.forEach((v: MockValueObject<number>, k: number) => {
+        expect(v).toBe(sequence2.get(k));
+      });
     });
+  });
 
-    it('can be set the value into last position', () => {
-      expect.assertions(6);
-
-      const value1: MockValueObject<number> = new MockValueObject<number>(1);
-      const value2: MockValueObject<number> = new MockValueObject<number>(2);
-      const value3: MockValueObject<number> = new MockValueObject<number>(3);
-      const value4: MockValueObject<number> = new MockValueObject<number>(4);
+  describe('filter', () => {
+    it('returns ImmutableSequence.EMPTY when no match', () => {
+      const value1: MockValueObject<number> = new MockValueObject(1);
+      const value2: MockValueObject<number> = new MockValueObject(2);
+      const value3: MockValueObject<number> = new MockValueObject(3);
+      const value4: MockValueObject<number> = new MockValueObject(2);
 
-      const sequence1: ImmutableSequence<MockValueObject<number>> = ImmutableSequence.ofArray<MockValueObject<number>>([
+      const sequence: ImmutableSequence<MockValueObject<number>> = ImmutableSequence.ofArray([
         value1,
         value2,
-        value3
+        value3,
+        value4
       ]);
-      const sequence2: ImmutableSequence<MockValueObject<number>> = sequence1.set(2, value4);
 
-      expect(sequence1).not.toBe(sequence2);
-      expect(sequence1.size()).toBe(3);
-      expect(sequence2.size()).toBe(3);
-      expect(sequence2.get(0)).toBe(value1);
-      expect(sequence2.get(1)).toBe(value2);
-      expect(sequence2.get(2)).toBe(value4);
-    });
+      const filtered: ImmutableSequence<MockValueObject<number>> = sequence.filter((v: MockValueObject<number>) => {
+        return v.get() > 100;
+      });
 
-    it('returns itself when given key is less than 0', () => {
-      expect.assertions(1);
+      expect(filtered.size()).toBe(0);
+      expect(filtered).toBe(ImmutableSequence.empty<number>());
+    });
 
-      const value1: MockValueObject<number> = new MockValueObject<number>(1);
-      const value2: MockValueObject<number> = new MockValueObject<number>(2);
-      const value3: MockValueObject<number> = new MockValueObject<number>(3);
-      const value4: MockValueObject<number> = new MockValueObject<number>(4);
+    it('can remove match values', () => {
+      const value1: MockValueObject<number> = new MockValueObject(1);
+      const value2: MockValueObject<number> = new MockValueObject(2);
+      const value3: MockValueObject<number> = new MockValueObject(3);
+      const value4: MockValueObject<number> = new MockValueObject(2);
+      const value5: MockValueObject<number> = new MockValueObject(5);
 
-      const sequence1: ImmutableSequence<MockValueObject<number>> = ImmutableSequence.ofArray<MockValueObject<number>>([
+      const sequence: ImmutableSequence<MockValueObject<number>> = ImmutableSequence.ofArray([
         value1,
         value2,
-        value3
+        value3,
+        value4
       ]);
-      const sequence2: ImmutableSequence<MockValueObject<number>> = sequence1.set(-1, value4);
 
-      expect(sequence1).toBe(sequence2);
-    });
-
-    it('returns itself when given key is greater than sequence length', () => {
-      expect.assertions(1);
+      const filtered1: ImmutableSequence<MockValueObject<number>> = sequence.filter((v: MockValueObject<number>) => {
+        return v.get() % 2 === 0;
+      });
+      const filtered2: ImmutableSequence<MockValueObject<number>> = sequence.filter((v: MockValueObject<number>) => {
+        return v === value4;
+      });
+      const filtered3: ImmutableSequence<MockValueObject<number>> = sequence.filter((v: MockValueObject<number>) => {
+        return v === value5;
+      });
 
-      const value1: MockValueObject<number> = new MockValueObject<number>(1);
-      const value2: MockValueObject<number> = new MockValueObject<number>(2);
-      const value3: MockValueObject<number> = new MockValueObject<number>(3);
-      const value4: MockValueObject<number> = new MockValueObject<number>(4);
+      expect(filtered1.size()).toBe(2);
+      expect(filtered1.get(0)).toBe(value2);
+      expect(filtered1.get(1)).toBe(value4);
+      expect(filtered2.size()).toBe(1);
+      expect(filtered2.get(0)).toBe(value4);
+      expect(filtered3.size()).toBe(0);
+    });
+  });
 
-      const sequence1: ImmutableSequence<MockValueObject<number>> = ImmutableSequence.ofArray<MockValueObject<number>>([
-        value1,
-        value2,
-        value3
+  describe('isEmpty', () => {
+    it('returns true if the value size is 0', () => {
+      const sequence1: ImmutableSequence<MockValueObject<number>> = ImmutableSequence.ofArray([
+        new MockValueObject(1),
+        new MockValueObject(2)
       ]);
+      const sequence2: ImmutableSequence<MockValueObject<number>> = ImmutableSequence.ofArray([]);
 
-      const sequence2: ImmutableSequence<MockValueObject<number>> = sequence1.set(sequence1.size(), value4);
-
-      expect(sequence1).toBe(sequence2);
+      expect(sequence1.isEmpty()).toBe(false);
+      expect(sequence2.isEmpty()).toBe(true);
     });
+  });
 
-    it('returns itself when given key is not integer', () => {
-      expect.assertions(1);
+  describe('map', () => {
+    it('execute the mapper function and returns mapped Address immutably', () => {
+      const sequence1: ImmutableSequence<MockValueObject<number>> = ImmutableSequence.ofArray([
+        new MockValueObject(1),
+        new MockValueObject(2),
+        new MockValueObject(3)
+      ]);
+      const sequence2: ImmutableSequence<MockValueObject<string>> = sequence1.map(
+        (value: MockValueObject<number>): MockValueObject<string> => {
+          const num: number = value.get();
 
-      const value1: MockValueObject<number> = new MockValueObject<number>(1);
-      const value2: MockValueObject<number> = new MockValueObject<number>(2);
-      const value3: MockValueObject<number> = new MockValueObject<number>(3);
-      const value4: MockValueObject<number> = new MockValueObject<number>(4);
+          return new MockValueObject<string>(`${num ** 2}`);
+        }
+      );
 
-      const sequence1: ImmutableSequence<MockValueObject<number>> = ImmutableSequence.ofArray<MockValueObject<number>>([
-        value1,
-        value2,
-        value3
-      ]);
+      expect(sequence1.size()).toBe(sequence2.size());
+      expect(sequence1).not.toBe(sequence2);
+      sequence2.forEach((v: MockValueObject<string>, k: number) => {
+        const value: Nullable<MockValueObject<number>> = sequence1.get(k);
 
-      const sequence2: ImmutableSequence<MockValueObject<number>> = sequence1.set(2.2, value4);
+        if (value === null) {
+          fail();
+          return;
+        }
 
-      expect(sequence1).toBe(sequence2);
+        expect(v.get()).toBe(`${value.get() ** 2}`);
+      });
     });
   });
 
   describe('remove', () => {
     it('can remove retaining value if it contains', () => {
-      expect.assertions(5);
+      const value1: MockValueObject<number> = new MockValueObject(1);
+      const value2: MockValueObject<number> = new MockValueObject(2);
+      const value3: MockValueObject<number> = new MockValueObject(3);
 
-      const value1: MockValueObject<number> = new MockValueObject<number>(1);
-      const value2: MockValueObject<number> = new MockValueObject<number>(2);
-      const value3: MockValueObject<number> = new MockValueObject<number>(3);
-
-      const sequence1: ImmutableSequence<MockValueObject<number>> = ImmutableSequence.ofArray<MockValueObject<number>>([
+      const sequence1: ImmutableSequence<MockValueObject<number>> = ImmutableSequence.ofArray([
         value1,
         value2,
         value3
@@ -248,13 +227,11 @@ describe('ImmutableSequence', () => {
     });
 
     it('removes middle value', () => {
-      expect.assertions(5);
-
-      const value1: MockValueObject<number> = new MockValueObject<number>(1);
-      const value2: MockValueObject<number> = new MockValueObject<number>(2);
-      const value3: MockValueObject<number> = new MockValueObject<number>(3);
+      const value1: MockValueObject<number> = new MockValueObject(1);
+      const value2: MockValueObject<number> = new MockValueObject(2);
+      const value3: MockValueObject<number> = new MockValueObject(3);
 
-      const sequence1: ImmutableSequence<MockValueObject<number>> = ImmutableSequence.ofArray<MockValueObject<number>>([
+      const sequence1: ImmutableSequence<MockValueObject<number>> = ImmutableSequence.ofArray([
         value1,
         value2,
         value3
@@ -269,13 +246,11 @@ describe('ImmutableSequence', () => {
     });
 
     it('removes last value', () => {
-      expect.assertions(5);
+      const value1: MockValueObject<number> = new MockValueObject(1);
+      const value2: MockValueObject<number> = new MockValueObject(2);
+      const value3: MockValueObject<number> = new MockValueObject(3);
 
-      const value1: MockValueObject<number> = new MockValueObject<number>(1);
-      const value2: MockValueObject<number> = new MockValueObject<number>(2);
-      const value3: MockValueObject<number> = new MockValueObject<number>(3);
-
-      const sequence1: ImmutableSequence<MockValueObject<number>> = ImmutableSequence.ofArray<MockValueObject<number>>([
+      const sequence1: ImmutableSequence<MockValueObject<number>> = ImmutableSequence.ofArray([
         value1,
         value2,
         value3
@@ -290,13 +265,11 @@ describe('ImmutableSequence', () => {
     });
 
     it('returns itself when given key is greater than sequence length', () => {
-      expect.assertions(1);
-
-      const value1: MockValueObject<number> = new MockValueObject<number>(1);
-      const value2: MockValueObject<number> = new MockValueObject<number>(2);
-      const value3: MockValueObject<number> = new MockValueObject<number>(3);
+      const value1: MockValueObject<number> = new MockValueObject(1);
+      const value2: MockValueObject<number> = new MockValueObject(2);
+      const value3: MockValueObject<number> = new MockValueObject(3);
 
-      const sequence1: ImmutableSequence<MockValueObject<number>> = ImmutableSequence.ofArray<MockValueObject<number>>([
+      const sequence1: ImmutableSequence<MockValueObject<number>> = ImmutableSequence.ofArray([
         value1,
         value2,
         value3
@@ -307,13 +280,11 @@ describe('ImmutableSequence', () => {
     });
 
     it('returns itself when given key is less than 0', () => {
-      expect.assertions(1);
+      const value1: MockValueObject<number> = new MockValueObject(1);
+      const value2: MockValueObject<number> = new MockValueObject(2);
+      const value3: MockValueObject<number> = new MockValueObject(3);
 
-      const value1: MockValueObject<number> = new MockValueObject<number>(1);
-      const value2: MockValueObject<number> = new MockValueObject<number>(2);
-      const value3: MockValueObject<number> = new MockValueObject<number>(3);
-
-      const sequence1: ImmutableSequence<MockValueObject<number>> = ImmutableSequence.ofArray<MockValueObject<number>>([
+      const sequence1: ImmutableSequence<MockValueObject<number>> = ImmutableSequence.ofArray([
         value1,
         value2,
         value3
@@ -324,13 +295,11 @@ describe('ImmutableSequence', () => {
     });
 
     it('returns itself when given key is not integer', () => {
-      expect.assertions(1);
-
-      const value1: MockValueObject<number> = new MockValueObject<number>(1);
-      const value2: MockValueObject<number> = new MockValueObject<number>(2);
-      const value3: MockValueObject<number> = new MockValueObject<number>(3);
+      const value1: MockValueObject<number> = new MockValueObject(1);
+      const value2: MockValueObject<number> = new MockValueObject(2);
+      const value3: MockValueObject<number> = new MockValueObject(3);
 
-      const sequence1: ImmutableSequence<MockValueObject<number>> = ImmutableSequence.ofArray<MockValueObject<number>>([
+      const sequence1: ImmutableSequence<MockValueObject<number>> = ImmutableSequence.ofArray([
         value1,
         value2,
         value3
@@ -341,117 +310,124 @@ describe('ImmutableSequence', () => {
     });
   });
 
-  describe('isEmpty', () => {
-    it('returns true if the value size is 0', () => {
-      expect.assertions(2);
+  describe('set', () => {
+    it('can be set the value into first position', () => {
+      const value1: MockValueObject<number> = new MockValueObject(1);
+      const value2: MockValueObject<number> = new MockValueObject(2);
+      const value3: MockValueObject<number> = new MockValueObject(3);
+      const value4: MockValueObject<number> = new MockValueObject(4);
 
-      const sequence1: ImmutableSequence<MockValueObject<number>> = ImmutableSequence.ofArray<MockValueObject<number>>([
-        new MockValueObject<number>(1),
-        new MockValueObject<number>(2)
+      const sequence1: ImmutableSequence<MockValueObject<number>> = ImmutableSequence.ofArray([
+        value1,
+        value2,
+        value3
       ]);
-      const sequence2: ImmutableSequence<MockValueObject<number>> = ImmutableSequence.ofArray<MockValueObject<number>>([]);
+      const sequence2: ImmutableSequence<MockValueObject<number>> = sequence1.set(0, value4);
 
-      expect(sequence1.isEmpty()).toBe(false);
-      expect(sequence2.isEmpty()).toBe(true);
+      expect(sequence1).not.toBe(sequence2);
+      expect(sequence1.size()).toBe(3);
+      expect(sequence2.size()).toBe(3);
+      expect(sequence2.get(0)).toBe(value4);
+      expect(sequence2.get(1)).toBe(value2);
+      expect(sequence2.get(2)).toBe(value3);
     });
-  });
 
-  describe('map', () => {
-    it('execute the mapper function and returns mapped Address immutably', () => {
-      expect.assertions(5);
+    it('can be set the value into middle position', () => {
+      const value1: MockValueObject<number> = new MockValueObject(1);
+      const value2: MockValueObject<number> = new MockValueObject(2);
+      const value3: MockValueObject<number> = new MockValueObject(3);
+      const value4: MockValueObject<number> = new MockValueObject(4);
 
-      const sequence1: ImmutableSequence<MockValueObject<number>> = ImmutableSequence.ofArray<MockValueObject<number>>([
-        new MockValueObject<number>(1),
-        new MockValueObject<number>(2),
-        new MockValueObject<number>(3)
+      const sequence1: ImmutableSequence<MockValueObject<number>> = ImmutableSequence.ofArray([
+        value1,
+        value2,
+        value3
       ]);
-      const sequence2: ImmutableSequence<MockValueObject<string>> = sequence1.map<MockValueObject<string>>(
-        (value: MockValueObject<number>) => {
-          const num: number = value.get();
-
-          return new MockValueObject<string>(`${num ** 2}`);
-        }
-      );
+      const sequence2: ImmutableSequence<MockValueObject<number>> = sequence1.set(1, value4);
 
-      expect(sequence1.size()).toBe(sequence2.size());
       expect(sequence1).not.toBe(sequence2);
-      sequence2.forEach((v: MockValueObject<string>, k: number) => {
-        const value: Nullable<MockValueObject<number>> = sequence1.get(k);
+      expect(sequence1.size()).toBe(3);
+      expect(sequence2.size()).toBe(3);
+      expect(sequence2.get(0)).toBe(value1);
+      expect(sequence2.get(1)).toBe(value4);
+      expect(sequence2.get(2)).toBe(value3);
+    });
 
-        if (value === null) {
-          fail();
-          return;
-        }
+    it('can be set the value into last position', () => {
+      const value1: MockValueObject<number> = new MockValueObject(1);
+      const value2: MockValueObject<number> = new MockValueObject(2);
+      const value3: MockValueObject<number> = new MockValueObject(3);
+      const value4: MockValueObject<number> = new MockValueObject(4);
 
-        expect(v.get()).toBe(`${value.get() ** 2}`);
-      });
+      const sequence1: ImmutableSequence<MockValueObject<number>> = ImmutableSequence.ofArray([
+        value1,
+        value2,
+        value3
+      ]);
+      const sequence2: ImmutableSequence<MockValueObject<number>> = sequence1.set(2, value4);
+
+      expect(sequence1).not.toBe(sequence2);
+      expect(sequence1.size()).toBe(3);
+      expect(sequence2.size()).toBe(3);
+      expect(sequence2.get(0)).toBe(value1);
+      expect(sequence2.get(1)).toBe(value2);
+      expect(sequence2.get(2)).toBe(value4);
     });
-  });
 
-  describe('filter', () => {
-    it('returns ImmutableSequence.EMPTY when no match', () => {
-      expect.assertions(2);
+    it('returns itself when given key is less than 0', () => {
+      const value1: MockValueObject<number> = new MockValueObject(1);
+      const value2: MockValueObject<number> = new MockValueObject(2);
+      const value3: MockValueObject<number> = new MockValueObject(3);
+      const value4: MockValueObject<number> = new MockValueObject(4);
 
-      const value1: MockValueObject<number> = new MockValueObject<number>(1);
-      const value2: MockValueObject<number> = new MockValueObject<number>(2);
-      const value3: MockValueObject<number> = new MockValueObject<number>(3);
-      const value4: MockValueObject<number> = new MockValueObject<number>(2);
+      const sequence1: ImmutableSequence<MockValueObject<number>> = ImmutableSequence.ofArray([
+        value1,
+        value2,
+        value3
+      ]);
+      const sequence2: ImmutableSequence<MockValueObject<number>> = sequence1.set(-1, value4);
 
-      const sequence: ImmutableSequence<MockValueObject<number>> = ImmutableSequence.ofArray<MockValueObject<number>>([
+      expect(sequence1).toBe(sequence2);
+    });
+
+    it('returns itself when given key is greater than sequence length', () => {
+      const value1: MockValueObject<number> = new MockValueObject(1);
+      const value2: MockValueObject<number> = new MockValueObject(2);
+      const value3: MockValueObject<number> = new MockValueObject(3);
+      const value4: MockValueObject<number> = new MockValueObject(4);
+
+      const sequence1: ImmutableSequence<MockValueObject<number>> = ImmutableSequence.ofArray([
         value1,
         value2,
-        value3,
-        value4
+        value3
       ]);
 
-      const filtered: ImmutableSequence<MockValueObject<number>> = sequence.filter((v: MockValueObject<number>) => {
-        return v.get() > 100;
-      });
+      const sequence2: ImmutableSequence<MockValueObject<number>> = sequence1.set(sequence1.size(), value4);
 
-      expect(filtered.size()).toBe(0);
-      expect(filtered).toBe(ImmutableSequence.empty<number>());
+      expect(sequence1).toBe(sequence2);
     });
 
-    it('can remove match values', () => {
-      expect.assertions(6);
-
-      const value1: MockValueObject<number> = new MockValueObject<number>(1);
-      const value2: MockValueObject<number> = new MockValueObject<number>(2);
-      const value3: MockValueObject<number> = new MockValueObject<number>(3);
-      const value4: MockValueObject<number> = new MockValueObject<number>(2);
-      const value5: MockValueObject<number> = new MockValueObject<number>(5);
+    it('returns itself when given key is not integer', () => {
+      const value1: MockValueObject<number> = new MockValueObject(1);
+      const value2: MockValueObject<number> = new MockValueObject(2);
+      const value3: MockValueObject<number> = new MockValueObject(3);
+      const value4: MockValueObject<number> = new MockValueObject(4);
 
-      const sequence: ImmutableSequence<MockValueObject<number>> = ImmutableSequence.ofArray<MockValueObject<number>>([
+      const sequence1: ImmutableSequence<MockValueObject<number>> = ImmutableSequence.ofArray([
         value1,
         value2,
-        value3,
-        value4
+        value3
       ]);
 
-      const filtered1: ImmutableSequence<MockValueObject<number>> = sequence.filter((v: MockValueObject<number>) => {
-        return v.get() % 2 === 0;
-      });
-      const filtered2: ImmutableSequence<MockValueObject<number>> = sequence.filter((v: MockValueObject<number>) => {
-        return v === value4;
-      });
-      const filtered3: ImmutableSequence<MockValueObject<number>> = sequence.filter((v: MockValueObject<number>) => {
-        return v === value5;
-      });
+      const sequence2: ImmutableSequence<MockValueObject<number>> = sequence1.set(2.2, value4);
 
-      expect(filtered1.size()).toBe(2);
-      expect(filtered1.get(0)).toBe(value2);
-      expect(filtered1.get(1)).toBe(value4);
-      expect(filtered2.size()).toBe(1);
-      expect(filtered2.get(0)).toBe(value4);
-      expect(filtered3.size()).toBe(0);
+      expect(sequence1).toBe(sequence2);
     });
   });
 
   describe('sort', () => {
     it('when the size is 0, do nothing', () => {
-      expect.assertions(2);
-
-      const sequence: ImmutableSequence<MockValueObject<number>> = ImmutableSequence.empty<MockValueObject<number>>();
+      const sequence: ImmutableSequence<MockValueObject<number>> = ImmutableSequence.empty();
       const sorted: ImmutableSequence<MockValueObject<number>> = sequence.sort(() => {
         return 1;
       });
@@ -461,12 +437,10 @@ describe('ImmutableSequence', () => {
     });
 
     it('when the size is 1, just copy a sequence shallowly', () => {
-      expect.assertions(3);
-
       const arr: Array<MockValueObject<number>> = [
-        new MockValueObject<number>(2)
+        new MockValueObject(2)
       ];
-      const sequence: ImmutableSequence<MockValueObject<number>> = ImmutableSequence.ofArray<MockValueObject<number>>(arr);
+      const sequence: ImmutableSequence<MockValueObject<number>> = ImmutableSequence.ofArray(arr);
       const sorted: ImmutableSequence<MockValueObject<number>> = sequence.sort(() => {
         return 1;
       });
@@ -477,15 +451,13 @@ describe('ImmutableSequence', () => {
     });
 
     it('returns like an array', () => {
-      expect.assertions(10);
-
       const arr: Array<MockValueObject<number>> = [
-        new MockValueObject<number>(4),
-        new MockValueObject<number>(2),
-        new MockValueObject<number>(3),
-        new MockValueObject<number>(1)
+        new MockValueObject(4),
+        new MockValueObject(2),
+        new MockValueObject(3),
+        new MockValueObject(1)
       ];
-      const sequence: ImmutableSequence<MockValueObject<number>> = ImmutableSequence.ofArray<MockValueObject<number>>(arr);
+      const sequence: ImmutableSequence<MockValueObject<number>> = ImmutableSequence.ofArray(arr);
       const sorted: ImmutableSequence<MockValueObject<number>> = sequence.sort((m1: MockValueObject<number>, m2: MockValueObject<number>) => {
         return m1.get() - m2.get();
       });
@@ -502,30 +474,4 @@ describe('ImmutableSequence', () => {
       expect(sorted.get(3)?.get()).toBe(4);
     });
   });
-
-  describe('duplicate', () => {
-    it('returns ImmutableSequence.empty() when this is ImmutableSequence.empty()', () => {
-      expect.assertions(1);
-
-      expect(ImmutableSequence.empty<MockValueObject<number>>().duplicate()).toBe(ImmutableSequence.empty<MockValueObject<number>>());
-    });
-
-    it('returns shallow-copied instance', () => {
-      expect.assertions(6);
-
-      const sequence1: ImmutableSequence<MockValueObject<number>> = ImmutableSequence.ofArray<MockValueObject<number>>([
-        new MockValueObject<number>(1),
-        new MockValueObject<number>(2),
-        new MockValueObject<number>(3),
-        new MockValueObject<number>(2)
-      ]);
-      const sequence2: ImmutableSequence<MockValueObject<number>> = sequence1.duplicate();
-
-      expect(sequence1.size()).toBe(sequence2.size());
-      expect(sequence1).not.toBe(sequence2);
-      sequence1.forEach((v: MockValueObject<number>, k: number) => {
-        expect(v).toBe(sequence2.get(k));
-      });
-    });
-  });
 });