@jamashita/lluvia-sequence 2.7.0 → 2.10.0

package/src/__tests__/ASequence.spec.ts

@@ -3,51 +3,6 @@ import { Nullable, Predicate } from '@jamashita/anden-type';
 import { MockSequence } from '../mock/MockSequence';
 
 describe('ASequence', () => {
-  describe('iterator', () => {
-    it('returns [number, MockValueObject<number>]', () => {
-      const sequence: MockSequence<MockValueObject<number>> = new MockSequence([
-        new MockValueObject(1),
-        new MockValueObject(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', () => {
-      const values: Array<MockValueObject<number>> = [
-        new MockValueObject(1),
-        new MockValueObject(2),
-        new MockValueObject(3)
-      ];
-
-      const sequence: MockSequence<MockValueObject<number>> = new MockSequence(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', () => {
-      const sequence: MockSequence<MockValueObject<number>> = new MockSequence([
-        new MockValueObject(1),
-        new MockValueObject(2),
-        new MockValueObject(3)
-      ]);
-
-      expect(sequence.get(-1)).toBeNull();
-      expect(sequence.get(3)).toBeNull();
-    });
-  });
-
   describe('contains', () => {
     it('returns false if the value does not exist', () => {
       const value1: MockValueObject<number> = new MockValueObject(1);
@@ -72,65 +27,49 @@ describe('ASequence', () => {
     });
   });
 
-  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([]);
+  describe('equals', () => {
+    it('returns true when the same instance given', () => {
+      const value: MockValueObject<number> = new MockValueObject(1);
 
-      expect(sequence1.isEmpty()).toBe(false);
-      expect(sequence2.isEmpty()).toBe(true);
+      const sequence: MockSequence<MockValueObject<number>> = new MockSequence([value]);
+
+      expect(sequence.equals(sequence)).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)
-      ]);
+    it('returns false if the size is different', () => {
+      const value1: MockValueObject<number> = new MockValueObject(1);
+      const value2: MockValueObject<number> = new MockValueObject(2);
 
-      expect(sequence.size()).toBe(3);
-      sequence.forEach((value: MockValueObject<number>, index: number) => {
-        expect(sequence.get(index)).toBe(value);
-      });
+      const sequence1: MockSequence<MockValueObject<number>> = new MockSequence([value1]);
+      const sequence2: MockSequence<MockValueObject<number>> = new MockSequence([value1, value2]);
+
+      expect(sequence1.equals(sequence2)).toBe(false);
     });
-  });
 
-  describe('find', () => {
-    it('returns the first found value', () => {
+    it('returns false when the different class instance given', () => {
+      const sequence: MockSequence<MockValueObject<number>> = new MockSequence([]);
+
+      expect(sequence.equals(new MockValueObject('mock'))).toBe(false);
+    });
+
+    it('returns true even if the order is different', () => {
       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: MockSequence<MockValueObject<number>> = new MockSequence([
-        value1,
-        value2,
-        value3,
-        value4
-      ]);
+      const sequence1: MockSequence<MockValueObject<number>> = new MockSequence([value2, value1]);
+      const sequence2: MockSequence<MockValueObject<number>> = new MockSequence([value1, value2]);
 
-      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;
-      });
+      expect(sequence1.equals(sequence2)).toBe(false);
+    });
 
-      expect(found1).toBe(value1);
-      expect(found2).toBe(value2);
-      expect(found3).toBe(value2);
-      expect(found4).toBeNull();
+    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);
     });
   });
 
@@ -214,6 +153,113 @@ describe('ASequence', () => {
     });
   });
 
+  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 sequence: MockSequence<MockValueObject<number>> = new MockSequence([
+        value1,
+        value2,
+        value3,
+        value4
+      ]);
+
+      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;
+      });
+
+      expect(found1).toBe(value1);
+      expect(found2).toBe(value2);
+      expect(found3).toBe(value2);
+      expect(found4).toBeNull();
+    });
+  });
+
+  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);
+      });
+    });
+  });
+
+  describe('get', () => {
+    it('returns value at the correct key', () => {
+      const values: Array<MockValueObject<number>> = [
+        new MockValueObject(1),
+        new MockValueObject(2),
+        new MockValueObject(3)
+      ];
+
+      const sequence: MockSequence<MockValueObject<number>> = new MockSequence(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', () => {
+      const sequence: MockSequence<MockValueObject<number>> = new MockSequence([
+        new MockValueObject(1),
+        new MockValueObject(2),
+        new MockValueObject(3)
+      ]);
+
+      expect(sequence.get(-1)).toBeNull();
+      expect(sequence.get(3)).toBeNull();
+    });
+  });
+
+  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(sequence1.isEmpty()).toBe(false);
+      expect(sequence2.isEmpty()).toBe(true);
+    });
+  });
+
+  describe('iterator', () => {
+    it('returns [number, MockValueObject<number>]', () => {
+      const sequence: MockSequence<MockValueObject<number>> = new MockSequence([
+        new MockValueObject(1),
+        new MockValueObject(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('reduce', () => {
     it('throws TypeError when array size is 0 and initialValue is undefined', () => {
       const sequence: MockSequence<MockValueObject<number>> = new MockSequence([]);
@@ -301,64 +347,6 @@ describe('ASequence', () => {
     });
   });
 
-  describe('equals', () => {
-    it('returns true when the same instance given', () => {
-      const value: MockValueObject<number> = new MockValueObject(1);
-
-      const sequence: MockSequence<MockValueObject<number>> = new MockSequence([value]);
-
-      expect(sequence.equals(sequence)).toBe(true);
-    });
-
-    it('returns false if the size is different', () => {
-      const value1: MockValueObject<number> = new MockValueObject(1);
-      const value2: MockValueObject<number> = new MockValueObject(2);
-
-      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', () => {
-      const sequence: MockSequence<MockValueObject<number>> = new MockSequence([]);
-
-      expect(sequence.equals(new MockValueObject('mock'))).toBe(false);
-    });
-
-    it('returns true even if the order is different', () => {
-      const value1: MockValueObject<number> = new MockValueObject(1);
-      const value2: MockValueObject<number> = new MockValueObject(2);
-
-      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', () => {
-      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('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('toArray', () => {
     it('returns its retaining shallow-copied array', () => {
       const values: Array<MockValueObject<number>> = [
@@ -381,6 +369,18 @@ describe('ASequence', () => {
     });
   });
 
+  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', () => {
       const values: Array<MockValueObject<number>> = [