@jamashita/lluvia-sequence 2.4.1 → 2.7.0

package/src/__tests__/ASequence.spec.ts

@@ -1,15 +1,13 @@
 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)
+      const sequence: MockSequence<MockValueObject<number>> = new MockSequence([
+        new MockValueObject(1),
+        new MockValueObject(2)
       ]);
 
       let i: number = 0;
@@ -24,15 +22,13 @@ describe('ASequence', () => {
 
   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)
+        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);
 
       expect(sequence.size()).toBe(values.length);
       for (let i: number = 0; i < sequence.size(); i++) {
@@ -41,12 +37,10 @@ describe('ASequence', () => {
     });
 
     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)
+      const sequence: MockSequence<MockValueObject<number>> = new MockSequence([
+        new MockValueObject(1),
+        new MockValueObject(2),
+        new MockValueObject(3)
       ]);
 
       expect(sequence.get(-1)).toBeNull();
@@ -56,25 +50,21 @@ describe('ASequence', () => {
 
   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);
@@ -84,13 +74,11 @@ describe('ASequence', () => {
 
   describe('isEmpty', () => {
     it('returns true if the values does not exist', () => {
-      expect.assertions(2);
-
-      const sequence1: MockSequence<MockValueObject<number>> = new MockSequence<MockValueObject<number>>([
-        new MockValueObject<number>(1),
-        new MockValueObject<number>(2)
+      const sequence1: MockSequence<MockValueObject<number>> = new MockSequence([
+        new MockValueObject(1),
+        new MockValueObject(2)
       ]);
-      const sequence2: MockSequence<MockValueObject<number>> = new MockSequence<MockValueObject<number>>([]);
+      const sequence2: MockSequence<MockValueObject<number>> = new MockSequence([]);
 
       expect(sequence1.isEmpty()).toBe(false);
       expect(sequence2.isEmpty()).toBe(true);
@@ -99,12 +87,10 @@ describe('ASequence', () => {
 
   describe('forEach', () => {
     it('calls back as much as the size of set', () => {
-      expect.assertions(4);
-
-      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([
+        new MockValueObject(1),
+        new MockValueObject(2),
+        new MockValueObject(3)
       ]);
 
       expect(sequence.size()).toBe(3);
@@ -116,14 +102,12 @@ describe('ASequence', () => {
 
   describe('find', () => {
     it('returns the first found value', () => {
-      expect.assertions(4);
+      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>(4);
-
-      const sequence: MockSequence<MockValueObject<number>> = new MockSequence<MockValueObject<number>>([
+      const sequence: MockSequence<MockValueObject<number>> = new MockSequence([
         value1,
         value2,
         value3,
@@ -152,13 +136,11 @@ describe('ASequence', () => {
 
   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 +151,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(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 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 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,21 +214,57 @@ describe('ASequence', () => {
     });
   });
 
+  describe('reduce', () => {
+    it('throws TypeError when array size is 0 and initialValue is undefined', () => {
+      const sequence: MockSequence<MockValueObject<number>> = new MockSequence([]);
+
+      expect(() => {
+        sequence.reduce((_o1: MockValueObject<number>, o2: MockValueObject<number>) => {
+          return o2;
+        });
+      }).toThrow(TypeError);
+    });
+
+    it('returns initialValue itself when the array size is 0', () => {
+      const o: MockValueObject<number> = new MockValueObject(1);
+      const sequence: MockSequence<MockValueObject<number>> = new MockSequence([]);
+
+      expect(sequence.reduce((_o1: MockValueObject<number>, o2: MockValueObject<number>) => {
+        return o2;
+      }, o)).toBe(o);
+    });
+
+    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]);
+
+      expect(sequence.reduce((o1: MockValueObject<number>) => {
+        return o1;
+      })).toBe(o);
+    });
+
+    it('returns reduced value', () => {
+      const sequence: MockSequence<number> = new MockSequence([1, 2, 3, 4]);
+
+      expect(sequence.reduce((o1: number, o2: number) => {
+        return o1 + o2;
+      })).toBe(10);
+    });
+  });
+
   describe('some', () => {
     it('returns true if at least one of the values returns true', () => {
-      expect.assertions(2);
-
-      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 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<MockValueObject<number>>([
-        new MockValueObject<number>(1),
-        new MockValueObject<number>(4),
-        new MockValueObject<number>(3),
-        new MockValueObject<number>(3)
+      const sequence2: MockSequence<MockValueObject<number>> = new MockSequence([
+        new MockValueObject(1),
+        new MockValueObject(4),
+        new MockValueObject(3),
+        new MockValueObject(3)
       ]);
 
       const predicate: Predicate<MockValueObject<number>> = (v: MockValueObject<number>) => {
@@ -263,14 +279,12 @@ describe('ASequence', () => {
     });
 
     it('returns false if none of the values are true', () => {
-      expect.assertions(1);
-
-      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 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>>([
+      const sequence: MockSequence<MockValueObject<number>> = new MockSequence([
         value1,
         value2,
         value3,
@@ -289,55 +303,45 @@ describe('ASequence', () => {
 
   describe('equals', () => {
     it('returns true when the same instance given', () => {
-      expect.assertions(1);
+      const value: MockValueObject<number> = new MockValueObject(1);
 
-      const value: MockValueObject<number> = new MockValueObject<number>(1);
-
-      const sequence: MockSequence<MockValueObject<number>> = new MockSequence<MockValueObject<number>>([value]);
+      const sequence: MockSequence<MockValueObject<number>> = new MockSequence([value]);
 
       expect(sequence.equals(sequence)).toBe(true);
     });
 
     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 value1: MockValueObject<number> = new MockValueObject(1);
+      const value2: MockValueObject<number> = new MockValueObject(2);
 
-      const sequence1: MockSequence<MockValueObject<number>> = new MockSequence<MockValueObject<number>>([value1]);
-      const sequence2: MockSequence<MockValueObject<number>> = new MockSequence<MockValueObject<number>>([value1, value2]);
+      const sequence1: MockSequence<MockValueObject<number>> = new MockSequence([value1]);
+      const sequence2: MockSequence<MockValueObject<number>> = new MockSequence([value1, value2]);
 
       expect(sequence1.equals(sequence2)).toBe(false);
     });
 
     it('returns false when the different class instance given', () => {
-      expect.assertions(1);
-
-      const sequence: MockSequence<MockValueObject<number>> = new MockSequence<MockValueObject<number>>([]);
+      const sequence: MockSequence<MockValueObject<number>> = new MockSequence([]);
 
       expect(sequence.equals(new MockValueObject('mock'))).toBe(false);
     });
 
     it('returns true even if the order is different', () => {
-      expect.assertions(1);
-
-      const value1: MockValueObject<number> = new MockValueObject<number>(1);
-      const value2: MockValueObject<number> = new MockValueObject<number>(2);
+      const value1: MockValueObject<number> = new MockValueObject(1);
+      const value2: MockValueObject<number> = new MockValueObject(2);
 
-      const sequence1: MockSequence<MockValueObject<number>> = new MockSequence<MockValueObject<number>>([value2, value1]);
-      const sequence2: MockSequence<MockValueObject<number>> = new MockSequence<MockValueObject<number>>([value1, value2]);
+      const sequence1: MockSequence<MockValueObject<number>> = new MockSequence([value2, value1]);
+      const sequence2: MockSequence<MockValueObject<number>> = new MockSequence([value1, value2]);
 
       expect(sequence1.equals(sequence2)).toBe(false);
     });
 
     it('returns true if the length is the same and the sequence is the same', () => {
-      expect.assertions(1);
+      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: MockSequence<MockValueObject<number>> = new MockSequence<MockValueObject<number>>([value1, value2]);
-      const sequence2: MockSequence<MockValueObject<number>> = new MockSequence<MockValueObject<number>>([value1, value2]);
+      const sequence1: MockSequence<MockValueObject<number>> = new MockSequence([value1, value2]);
+      const sequence2: MockSequence<MockValueObject<number>> = new MockSequence([value1, value2]);
 
       expect(sequence1.equals(sequence2)).toBe(true);
     });
@@ -345,12 +349,10 @@ describe('ASequence', () => {
 
   describe('toString', () => {
     it('returns concatenated string', () => {
-      expect.assertions(1);
-
-      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([
+        new MockValueObject(1),
+        new MockValueObject(2),
+        new MockValueObject(3)
       ]);
 
       expect(sequence.toString()).toBe('1, 2, 3');
@@ -359,15 +361,13 @@ describe('ASequence', () => {
 
   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,7 +375,7 @@ 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);
     });
@@ -383,13 +383,11 @@ describe('ASequence', () => {
 
   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;