@jamashita/lluvia-sequence 2.5.0 → 2.8.0

package/src/__tests__/ASequence.spec.ts

@@ -1,80 +1,25 @@
 import { MockValueObject } from '@jamashita/anden-object';
 import { Nullable, Predicate } from '@jamashita/anden-type';
-import { MockSequence } from '../Mock/MockSequence';
+import { MockSequence } from '../mock/MockSequence';
 
 describe('ASequence', () => {
-  describe('iterator', () => {
-    it('returns [number, MockValueObject<number>]', () => {
-      expect.assertions(4);
-
-      const sequence: MockSequence<MockValueObject<number>> = new MockSequence<MockValueObject<number>>([
-        new MockValueObject<number>(1),
-        new MockValueObject<number>(2)
-      ]);
-
-      let i: number = 0;
-
-      for (const value of sequence) {
-        expect(value[0]).toBe(i);
-        expect(value[1].get()).toBe(sequence.get(i)?.get());
-        i++;
-      }
-    });
-  });
-
-  describe('get', () => {
-    it('returns value at the correct key', () => {
-      expect.assertions(4);
-
-      const values: Array<MockValueObject<number>> = [
-        new MockValueObject<number>(1),
-        new MockValueObject<number>(2),
-        new MockValueObject<number>(3)
-      ];
-
-      const sequence: MockSequence<MockValueObject<number>> = new MockSequence<MockValueObject<number>>(values);
-
-      expect(sequence.size()).toBe(values.length);
-      for (let i: number = 0; i < sequence.size(); i++) {
-        expect(sequence.get(i)).toBe(values[i]);
-      }
-    });
-
-    it('returns null at incorrect keys', () => {
-      expect.assertions(2);
-
-      const sequence: MockSequence<MockValueObject<number>> = new MockSequence<MockValueObject<number>>([
-        new MockValueObject<number>(1),
-        new MockValueObject<number>(2),
-        new MockValueObject<number>(3)
-      ]);
-
-      expect(sequence.get(-1)).toBeNull();
-      expect(sequence.get(3)).toBeNull();
-    });
-  });
-
   describe('contains', () => {
     it('returns false if the value does not exist', () => {
-      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 sequence: MockSequence<MockValueObject<number>> = new MockSequence<MockValueObject<number>>([value1, value2]);
+      const sequence: MockSequence<MockValueObject<number>> = new MockSequence([value1, value2]);
 
       expect(sequence.contains(value3)).toBe(false);
     });
 
     it('returns true if the value exists', () => {
-      expect.assertions(3);
-
-      const value1: MockValueObject<number> = new MockValueObject<number>(1);
-      const value2: MockValueObject<number> = new MockValueObject<number>(2);
-      const value3: MockValueObject<number> = new MockValueObject<number>(2);
+      const value1: MockValueObject<number> = new MockValueObject(1);
+      const value2: MockValueObject<number> = new MockValueObject(2);
+      const value3: MockValueObject<number> = new MockValueObject(2);
 
-      const sequence: MockSequence<MockValueObject<number>> = new MockSequence<MockValueObject<number>>([value1, value2]);
+      const sequence: MockSequence<MockValueObject<number>> = new MockSequence([value1, value2]);
 
       expect(sequence.contains(value1)).toBe(true);
       expect(sequence.contains(value2)).toBe(true);
@@ -82,83 +27,59 @@ describe('ASequence', () => {
     });
   });
 
-  describe('isEmpty', () => {
-    it('returns true if the values does not exist', () => {
-      expect.assertions(2);
+  describe('equals', () => {
+    it('returns true when the same instance given', () => {
+      const value: MockValueObject<number> = new MockValueObject(1);
 
-      const sequence1: MockSequence<MockValueObject<number>> = new MockSequence<MockValueObject<number>>([
-        new MockValueObject<number>(1),
-        new MockValueObject<number>(2)
-      ]);
-      const sequence2: MockSequence<MockValueObject<number>> = new MockSequence<MockValueObject<number>>([]);
+      const sequence: MockSequence<MockValueObject<number>> = new MockSequence([value]);
 
-      expect(sequence1.isEmpty()).toBe(false);
-      expect(sequence2.isEmpty()).toBe(true);
+      expect(sequence.equals(sequence)).toBe(true);
     });
-  });
 
-  describe('forEach', () => {
-    it('calls back as much as the size of set', () => {
-      expect.assertions(4);
+    it('returns false if the size is different', () => {
+      const value1: MockValueObject<number> = new MockValueObject(1);
+      const value2: MockValueObject<number> = new MockValueObject(2);
 
-      const sequence: MockSequence<MockValueObject<number>> = new MockSequence<MockValueObject<number>>([
-        new MockValueObject<number>(1),
-        new MockValueObject<number>(2),
-        new MockValueObject<number>(3)
-      ]);
+      const sequence1: MockSequence<MockValueObject<number>> = new MockSequence([value1]);
+      const sequence2: MockSequence<MockValueObject<number>> = new MockSequence([value1, value2]);
 
-      expect(sequence.size()).toBe(3);
-      sequence.forEach((value: MockValueObject<number>, index: number) => {
-        expect(sequence.get(index)).toBe(value);
-      });
+      expect(sequence1.equals(sequence2)).toBe(false);
     });
-  });
 
-  describe('find', () => {
-    it('returns the first found value', () => {
-      expect.assertions(4);
+    it('returns false when the different class instance given', () => {
+      const sequence: MockSequence<MockValueObject<number>> = new MockSequence([]);
 
-      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(sequence.equals(new MockValueObject('mock'))).toBe(false);
+    });
 
-      const sequence: MockSequence<MockValueObject<number>> = new MockSequence<MockValueObject<number>>([
-        value1,
-        value2,
-        value3,
-        value4
-      ]);
+    it('returns true even if the order is different', () => {
+      const value1: MockValueObject<number> = new MockValueObject(1);
+      const value2: MockValueObject<number> = new MockValueObject(2);
 
-      const found1: Nullable<MockValueObject<number>> = sequence.find((v: MockValueObject<number>) => {
-        return v.get() === 1;
-      });
-      const found2: Nullable<MockValueObject<number>> = sequence.find((v: MockValueObject<number>) => {
-        return v.get() === 2;
-      });
-      const found3: Nullable<MockValueObject<number>> = sequence.find((v: MockValueObject<number>) => {
-        return v.get() % 2 === 0;
-      });
-      const found4: Nullable<MockValueObject<number>> = sequence.find((v: MockValueObject<number>) => {
-        return v.get() > 1000;
-      });
+      const sequence1: MockSequence<MockValueObject<number>> = new MockSequence([value2, value1]);
+      const sequence2: MockSequence<MockValueObject<number>> = new MockSequence([value1, value2]);
 
-      expect(found1).toBe(value1);
-      expect(found2).toBe(value2);
-      expect(found3).toBe(value2);
-      expect(found4).toBeNull();
+      expect(sequence1.equals(sequence2)).toBe(false);
+    });
+
+    it('returns true if the length is the same and the sequence is the same', () => {
+      const value1: MockValueObject<number> = new MockValueObject(1);
+      const value2: MockValueObject<number> = new MockValueObject(2);
+
+      const sequence1: MockSequence<MockValueObject<number>> = new MockSequence([value1, value2]);
+      const sequence2: MockSequence<MockValueObject<number>> = new MockSequence([value1, value2]);
+
+      expect(sequence1.equals(sequence2)).toBe(true);
     });
   });
 
   describe('every', () => {
     it('returns true if all the values are the same', () => {
-      expect.assertions(1);
-
-      const sequence: MockSequence<MockValueObject<number>> = new MockSequence<MockValueObject<number>>([
-        new MockValueObject<number>(2),
-        new MockValueObject<number>(4),
-        new MockValueObject<number>(6),
-        new MockValueObject<number>(8)
+      const sequence: MockSequence<MockValueObject<number>> = new MockSequence([
+        new MockValueObject(2),
+        new MockValueObject(4),
+        new MockValueObject(6),
+        new MockValueObject(8)
       ]);
 
       const every: boolean = sequence.every((v: MockValueObject<number>) => {
@@ -169,45 +90,43 @@ describe('ASequence', () => {
     });
 
     it('returns false if at least one of the values is not false', () => {
-      expect.assertions(6);
-
-      const value1: MockValueObject<number> = new MockValueObject<number>(1);
-      const value2: MockValueObject<number> = new MockValueObject<number>(4);
-      const value3: MockValueObject<number> = new MockValueObject<number>(6);
-      const value4: MockValueObject<number> = new MockValueObject<number>(8);
-      const value5: MockValueObject<number> = new MockValueObject<number>(3);
+      const value1: MockValueObject<number> = new MockValueObject(1);
+      const value2: MockValueObject<number> = new MockValueObject(4);
+      const value3: MockValueObject<number> = new MockValueObject(6);
+      const value4: MockValueObject<number> = new MockValueObject(8);
+      const value5: MockValueObject<number> = new MockValueObject(3);
 
-      const sequence1: MockSequence<MockValueObject<number>> = new MockSequence<MockValueObject<number>>([
+      const sequence1: MockSequence<MockValueObject<number>> = new MockSequence([
         value1,
         value2,
         value3,
         value4
       ]);
-      const sequence2: MockSequence<MockValueObject<number>> = new MockSequence<MockValueObject<number>>([
+      const sequence2: MockSequence<MockValueObject<number>> = new MockSequence([
         value2,
         value1,
         value3,
         value4
       ]);
-      const sequence3: MockSequence<MockValueObject<number>> = new MockSequence<MockValueObject<number>>([
+      const sequence3: MockSequence<MockValueObject<number>> = new MockSequence([
         value2,
         value3,
         value1,
         value4
       ]);
-      const sequence4: MockSequence<MockValueObject<number>> = new MockSequence<MockValueObject<number>>([
+      const sequence4: MockSequence<MockValueObject<number>> = new MockSequence([
         value2,
         value3,
         value4,
         value1
       ]);
-      const sequence5: MockSequence<MockValueObject<number>> = new MockSequence<MockValueObject<number>>([
+      const sequence5: MockSequence<MockValueObject<number>> = new MockSequence([
         value1,
         value5,
         value3,
         value4
       ]);
-      const sequence6: MockSequence<MockValueObject<number>> = new MockSequence<MockValueObject<number>>([
+      const sequence6: MockSequence<MockValueObject<number>> = new MockSequence([
         value1,
         value2,
         value5,
@@ -234,140 +153,209 @@ describe('ASequence', () => {
     });
   });
 
-  describe('some', () => {
-    it('returns true if at least one of the values returns true', () => {
-      expect.assertions(2);
+  describe('find', () => {
+    it('returns the first found value', () => {
+      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: MockSequence<MockValueObject<number>> = new MockSequence<MockValueObject<number>>([
-        new MockValueObject<number>(2),
-        new MockValueObject<number>(4),
-        new MockValueObject<number>(6),
-        new MockValueObject<number>(8)
-      ]);
-      const sequence2: MockSequence<MockValueObject<number>> = new MockSequence<MockValueObject<number>>([
-        new MockValueObject<number>(1),
-        new MockValueObject<number>(4),
-        new MockValueObject<number>(3),
-        new MockValueObject<number>(3)
+      const sequence: MockSequence<MockValueObject<number>> = new MockSequence([
+        value1,
+        value2,
+        value3,
+        value4
       ]);
 
-      const predicate: Predicate<MockValueObject<number>> = (v: MockValueObject<number>) => {
+      const found1: Nullable<MockValueObject<number>> = sequence.find((v: MockValueObject<number>) => {
+        return v.get() === 1;
+      });
+      const found2: Nullable<MockValueObject<number>> = sequence.find((v: MockValueObject<number>) => {
+        return v.get() === 2;
+      });
+      const found3: Nullable<MockValueObject<number>> = sequence.find((v: MockValueObject<number>) => {
         return v.get() % 2 === 0;
-      };
+      });
+      const found4: Nullable<MockValueObject<number>> = sequence.find((v: MockValueObject<number>) => {
+        return v.get() > 1000;
+      });
 
-      const some1: boolean = sequence1.some(predicate);
-      const some2: boolean = sequence2.some(predicate);
+      expect(found1).toBe(value1);
+      expect(found2).toBe(value2);
+      expect(found3).toBe(value2);
+      expect(found4).toBeNull();
+    });
+  });
 
-      expect(some1).toBe(true);
-      expect(some2).toBe(true);
+  describe('forEach', () => {
+    it('calls back as much as the size of set', () => {
+      const sequence: MockSequence<MockValueObject<number>> = new MockSequence([
+        new MockValueObject(1),
+        new MockValueObject(2),
+        new MockValueObject(3)
+      ]);
+
+      expect(sequence.size()).toBe(3);
+      sequence.forEach((value: MockValueObject<number>, index: number) => {
+        expect(sequence.get(index)).toBe(value);
+      });
     });
+  });
 
-    it('returns false if none of the values are true', () => {
-      expect.assertions(1);
+  describe('get', () => {
+    it('returns value at the correct key', () => {
+      const values: Array<MockValueObject<number>> = [
+        new MockValueObject(1),
+        new MockValueObject(2),
+        new MockValueObject(3)
+      ];
 
-      const value1: MockValueObject<number> = new MockValueObject<number>(2);
-      const value2: MockValueObject<number> = new MockValueObject<number>(4);
-      const value3: MockValueObject<number> = new MockValueObject<number>(6);
-      const value4: MockValueObject<number> = new MockValueObject<number>(8);
+      const sequence: MockSequence<MockValueObject<number>> = new MockSequence(values);
 
-      const sequence: MockSequence<MockValueObject<number>> = new MockSequence<MockValueObject<number>>([
-        value1,
-        value2,
-        value3,
-        value4
+      expect(sequence.size()).toBe(values.length);
+      for (let i: number = 0; i < sequence.size(); i++) {
+        expect(sequence.get(i)).toBe(values[i]);
+      }
+    });
+
+    it('returns null at incorrect keys', () => {
+      const sequence: MockSequence<MockValueObject<number>> = new MockSequence([
+        new MockValueObject(1),
+        new MockValueObject(2),
+        new MockValueObject(3)
       ]);
 
-      const predicate: Predicate<MockValueObject<number>> = (v: MockValueObject<number>) => {
-        return v.get() % 2 === 1;
-      };
+      expect(sequence.get(-1)).toBeNull();
+      expect(sequence.get(3)).toBeNull();
+    });
+  });
 
-      const some: boolean = sequence.some(predicate);
+  describe('isEmpty', () => {
+    it('returns true if the values does not exist', () => {
+      const sequence1: MockSequence<MockValueObject<number>> = new MockSequence([
+        new MockValueObject(1),
+        new MockValueObject(2)
+      ]);
+      const sequence2: MockSequence<MockValueObject<number>> = new MockSequence([]);
 
-      expect(some).toBe(false);
+      expect(sequence1.isEmpty()).toBe(false);
+      expect(sequence2.isEmpty()).toBe(true);
     });
   });
 
-  describe('equals', () => {
-    it('returns true when the same instance given', () => {
-      expect.assertions(1);
-
-      const value: MockValueObject<number> = new MockValueObject<number>(1);
+  describe('iterator', () => {
+    it('returns [number, MockValueObject<number>]', () => {
+      const sequence: MockSequence<MockValueObject<number>> = new MockSequence([
+        new MockValueObject(1),
+        new MockValueObject(2)
+      ]);
 
-      const sequence: MockSequence<MockValueObject<number>> = new MockSequence<MockValueObject<number>>([value]);
+      let i: number = 0;
 
-      expect(sequence.equals(sequence)).toBe(true);
+      for (const value of sequence) {
+        expect(value[0]).toBe(i);
+        expect(value[1].get()).toBe(sequence.get(i)?.get());
+        i++;
+      }
     });
+  });
 
-    it('returns false if the size is different', () => {
-      expect.assertions(1);
-
-      const value1: MockValueObject<number> = new MockValueObject<number>(1);
-      const value2: MockValueObject<number> = new MockValueObject<number>(2);
-
-      const sequence1: MockSequence<MockValueObject<number>> = new MockSequence<MockValueObject<number>>([value1]);
-      const sequence2: MockSequence<MockValueObject<number>> = new MockSequence<MockValueObject<number>>([value1, value2]);
+  describe('reduce', () => {
+    it('throws TypeError when array size is 0 and initialValue is undefined', () => {
+      const sequence: MockSequence<MockValueObject<number>> = new MockSequence([]);
 
-      expect(sequence1.equals(sequence2)).toBe(false);
+      expect(() => {
+        sequence.reduce((_o1: MockValueObject<number>, o2: MockValueObject<number>) => {
+          return o2;
+        });
+      }).toThrow(TypeError);
     });
 
-    it('returns false when the different class instance given', () => {
-      expect.assertions(1);
+    it('returns initialValue itself when the array size is 0', () => {
+      const o: MockValueObject<number> = new MockValueObject(1);
+      const sequence: MockSequence<MockValueObject<number>> = new MockSequence([]);
 
-      const sequence: MockSequence<MockValueObject<number>> = new MockSequence<MockValueObject<number>>([]);
-
-      expect(sequence.equals(new MockValueObject('mock'))).toBe(false);
+      expect(sequence.reduce((_o1: MockValueObject<number>, o2: MockValueObject<number>) => {
+        return o2;
+      }, o)).toBe(o);
     });
 
-    it('returns true even if the order is different', () => {
-      expect.assertions(1);
+    it('returns first element when the array size is only 1', () => {
+      const o: MockValueObject<number> = new MockValueObject(1);
+      const sequence: MockSequence<MockValueObject<number>> = new MockSequence([o]);
 
-      const value1: MockValueObject<number> = new MockValueObject<number>(1);
-      const value2: MockValueObject<number> = new MockValueObject<number>(2);
+      expect(sequence.reduce((o1: MockValueObject<number>) => {
+        return o1;
+      })).toBe(o);
+    });
 
-      const sequence1: MockSequence<MockValueObject<number>> = new MockSequence<MockValueObject<number>>([value2, value1]);
-      const sequence2: MockSequence<MockValueObject<number>> = new MockSequence<MockValueObject<number>>([value1, value2]);
+    it('returns reduced value', () => {
+      const sequence: MockSequence<number> = new MockSequence([1, 2, 3, 4]);
 
-      expect(sequence1.equals(sequence2)).toBe(false);
+      expect(sequence.reduce((o1: number, o2: number) => {
+        return o1 + o2;
+      })).toBe(10);
     });
+  });
 
-    it('returns true if the length is the same and the sequence is the same', () => {
-      expect.assertions(1);
+  describe('some', () => {
+    it('returns true if at least one of the values returns true', () => {
+      const sequence1: MockSequence<MockValueObject<number>> = new MockSequence([
+        new MockValueObject(2),
+        new MockValueObject(4),
+        new MockValueObject(6),
+        new MockValueObject(8)
+      ]);
+      const sequence2: MockSequence<MockValueObject<number>> = new MockSequence([
+        new MockValueObject(1),
+        new MockValueObject(4),
+        new MockValueObject(3),
+        new MockValueObject(3)
+      ]);
 
-      const value1: MockValueObject<number> = new MockValueObject<number>(1);
-      const value2: MockValueObject<number> = new MockValueObject<number>(2);
+      const predicate: Predicate<MockValueObject<number>> = (v: MockValueObject<number>) => {
+        return v.get() % 2 === 0;
+      };
 
-      const sequence1: MockSequence<MockValueObject<number>> = new MockSequence<MockValueObject<number>>([value1, value2]);
-      const sequence2: MockSequence<MockValueObject<number>> = new MockSequence<MockValueObject<number>>([value1, value2]);
+      const some1: boolean = sequence1.some(predicate);
+      const some2: boolean = sequence2.some(predicate);
 
-      expect(sequence1.equals(sequence2)).toBe(true);
+      expect(some1).toBe(true);
+      expect(some2).toBe(true);
     });
-  });
 
-  describe('toString', () => {
-    it('returns concatenated string', () => {
-      expect.assertions(1);
+    it('returns false if none of the values are true', () => {
+      const value1: MockValueObject<number> = new MockValueObject(2);
+      const value2: MockValueObject<number> = new MockValueObject(4);
+      const value3: MockValueObject<number> = new MockValueObject(6);
+      const value4: MockValueObject<number> = new MockValueObject(8);
 
-      const sequence: MockSequence<MockValueObject<number>> = new MockSequence<MockValueObject<number>>([
-        new MockValueObject<number>(1),
-        new MockValueObject<number>(2),
-        new MockValueObject<number>(3)
+      const sequence: MockSequence<MockValueObject<number>> = new MockSequence([
+        value1,
+        value2,
+        value3,
+        value4
       ]);
 
-      expect(sequence.toString()).toBe('1, 2, 3');
+      const predicate: Predicate<MockValueObject<number>> = (v: MockValueObject<number>) => {
+        return v.get() % 2 === 1;
+      };
+
+      const some: boolean = sequence.some(predicate);
+
+      expect(some).toBe(false);
     });
   });
 
   describe('toArray', () => {
     it('returns its retaining shallow-copied array', () => {
-      expect.assertions(5);
-
       const values: Array<MockValueObject<number>> = [
-        new MockValueObject<number>(1),
-        new MockValueObject<number>(2),
-        new MockValueObject<number>(3)
+        new MockValueObject(1),
+        new MockValueObject(2),
+        new MockValueObject(3)
       ];
 
-      const sequence: MockSequence<MockValueObject<number>> = new MockSequence<MockValueObject<number>>(values);
+      const sequence: MockSequence<MockValueObject<number>> = new MockSequence(values);
       const array: Array<MockValueObject<number>> = sequence.toArray();
 
       expect(sequence.size()).toBe(values.length);
@@ -375,21 +363,31 @@ describe('ASequence', () => {
         expect(sequence.get(i)).toBe(array[i]);
       }
 
-      array.push(new MockValueObject<number>(4));
+      array.push(new MockValueObject(4));
 
       expect(sequence.size()).not.toBe(array.length);
     });
   });
 
+  describe('toString', () => {
+    it('returns concatenated string', () => {
+      const sequence: MockSequence<MockValueObject<number>> = new MockSequence([
+        new MockValueObject(1),
+        new MockValueObject(2),
+        new MockValueObject(3)
+      ]);
+
+      expect(sequence.toString()).toBe('1, 2, 3');
+    });
+  });
+
   describe('values', () => {
     it('returns its retaining values', () => {
-      expect.assertions(2);
-
       const values: Array<MockValueObject<number>> = [
-        new MockValueObject<number>(1),
-        new MockValueObject<number>(2)
+        new MockValueObject(1),
+        new MockValueObject(2)
       ];
-      const sequence: MockSequence<MockValueObject<number>> = new MockSequence<MockValueObject<number>>(values);
+      const sequence: MockSequence<MockValueObject<number>> = new MockSequence(values);
 
       let i: number = 0;