@jamashita/lluvia-sequence 2.6.0 → 2.9.0

Sign up to get free protection for your applications and to get access to all the features.
Files changed (70) hide show
  1. package/dist/cjs/ASequence.d.ts +4 -3
  2. package/dist/cjs/ASequence.d.ts.map +1 -1
  3. package/dist/cjs/ASequence.js +17 -28
  4. package/dist/cjs/ASequence.js.map +1 -1
  5. package/dist/cjs/ImmutableSequence.d.ts +5 -5
  6. package/dist/cjs/ImmutableSequence.d.ts.map +1 -1
  7. package/dist/cjs/ImmutableSequence.js +2 -2
  8. package/dist/cjs/ImmutableSequence.js.map +1 -1
  9. package/dist/cjs/MutableSequence.d.ts +8 -8
  10. package/dist/cjs/MutableSequence.d.ts.map +1 -1
  11. package/dist/cjs/MutableSequence.js +2 -2
  12. package/dist/cjs/MutableSequence.js.map +1 -1
  13. package/dist/cjs/ReadonlySequence.d.ts +3 -2
  14. package/dist/cjs/ReadonlySequence.d.ts.map +1 -1
  15. package/dist/cjs/Sequence.d.ts +2 -2
  16. package/dist/cjs/Sequence.d.ts.map +1 -1
  17. package/dist/cjs/index.d.ts +1 -1
  18. package/dist/cjs/index.d.ts.map +1 -1
  19. package/dist/cjs/index.js +6 -2
  20. package/dist/cjs/index.js.map +1 -1
  21. package/dist/cjs/{Mock → mock}/MockSequence.d.ts +0 -0
  22. package/dist/{esm/Mock → cjs/mock}/MockSequence.d.ts.map +1 -1
  23. package/dist/cjs/{Mock → mock}/MockSequence.js +0 -0
  24. package/dist/cjs/{Mock → mock}/MockSequence.js.map +1 -1
  25. package/dist/cjs/mock/index.d.ts +2 -0
  26. package/dist/cjs/mock/index.d.ts.map +1 -0
  27. package/dist/cjs/mock/index.js +18 -0
  28. package/dist/cjs/mock/index.js.map +1 -0
  29. package/dist/esm/ASequence.d.ts +4 -3
  30. package/dist/esm/ASequence.d.ts.map +1 -1
  31. package/dist/esm/ASequence.js +17 -28
  32. package/dist/esm/ASequence.js.map +1 -1
  33. package/dist/esm/ImmutableSequence.d.ts +5 -5
  34. package/dist/esm/ImmutableSequence.d.ts.map +1 -1
  35. package/dist/esm/ImmutableSequence.js +2 -2
  36. package/dist/esm/ImmutableSequence.js.map +1 -1
  37. package/dist/esm/MutableSequence.d.ts +8 -8
  38. package/dist/esm/MutableSequence.d.ts.map +1 -1
  39. package/dist/esm/MutableSequence.js +2 -2
  40. package/dist/esm/MutableSequence.js.map +1 -1
  41. package/dist/esm/ReadonlySequence.d.ts +3 -2
  42. package/dist/esm/ReadonlySequence.d.ts.map +1 -1
  43. package/dist/esm/Sequence.d.ts +2 -2
  44. package/dist/esm/Sequence.d.ts.map +1 -1
  45. package/dist/esm/index.d.ts +1 -1
  46. package/dist/esm/index.d.ts.map +1 -1
  47. package/dist/esm/index.js +1 -1
  48. package/dist/esm/index.js.map +1 -1
  49. package/dist/esm/{Mock → mock}/MockSequence.d.ts +0 -0
  50. package/dist/{cjs/Mock → esm/mock}/MockSequence.d.ts.map +1 -1
  51. package/dist/esm/{Mock → mock}/MockSequence.js +0 -0
  52. package/dist/esm/{Mock → mock}/MockSequence.js.map +1 -1
  53. package/dist/esm/mock/index.d.ts +2 -0
  54. package/dist/esm/mock/index.d.ts.map +1 -0
  55. package/dist/esm/mock/index.js +2 -0
  56. package/dist/esm/mock/index.js.map +1 -0
  57. package/dist/tsconfig.cjs.tsbuildinfo +1 -1
  58. package/dist/tsconfig.esm.tsbuildinfo +1 -1
  59. package/package.json +6 -8
  60. package/src/ASequence.ts +22 -36
  61. package/src/ImmutableSequence.ts +20 -20
  62. package/src/MutableSequence.ts +17 -17
  63. package/src/ReadonlySequence.ts +4 -2
  64. package/src/Sequence.ts +2 -2
  65. package/src/__tests__/ASequence.spec.ts +227 -229
  66. package/src/__tests__/ImmutableSequence.spec.ts +231 -285
  67. package/src/__tests__/MutableSequence.spec.ts +210 -260
  68. package/src/index.ts +1 -1
  69. package/src/{Mock → mock}/MockSequence.ts +0 -0
  70. package/src/mock/index.ts +1 -0
@@ -3,22 +3,30 @@ import { Nullable } from '@jamashita/anden-type';
3
3
  import { ImmutableSequence } from '../ImmutableSequence';
4
4
 
5
5
  describe('ImmutableSequence', () => {
6
+ describe('empty', () => {
7
+ it('returns singleton instance', () => {
8
+ expect(ImmutableSequence.empty()).toBe(ImmutableSequence.empty());
9
+ });
10
+
11
+ it('always returns 0-size array', () => {
12
+ expect(ImmutableSequence.empty().isEmpty()).toBe(true);
13
+ });
14
+ });
15
+
6
16
  describe('of', () => {
7
17
  it('returns copied collection, does not use the same one', () => {
8
- expect.assertions(4);
9
-
10
- const sequence: ImmutableSequence<MockValueObject<number>> = ImmutableSequence.ofArray<MockValueObject<number>>([
11
- new MockValueObject<number>(1),
12
- new MockValueObject<number>(2)
18
+ const sequence: ImmutableSequence<MockValueObject<number>> = ImmutableSequence.ofArray([
19
+ new MockValueObject(1),
20
+ new MockValueObject(2)
13
21
  ]);
14
- const copied: ImmutableSequence<MockValueObject<number>> = ImmutableSequence.of<MockValueObject<number>>(sequence);
22
+ const copied: ImmutableSequence<MockValueObject<number>> = ImmutableSequence.of(sequence);
15
23
 
16
24
  expect(sequence.size()).toBe(copied.size());
17
25
  sequence.forEach((v: MockValueObject<number>, k: number) => {
18
26
  expect(v).toBe(copied.get(k));
19
27
  });
20
28
 
21
- sequence.add(new MockValueObject<number>(3));
29
+ sequence.add(new MockValueObject(3));
22
30
 
23
31
  expect(sequence.size()).toBe(copied.size());
24
32
  });
@@ -26,25 +34,21 @@ describe('ImmutableSequence', () => {
26
34
 
27
35
  describe('ofArray', () => {
28
36
  it('returns ImmutableSequence.empty() when the size is 0', () => {
29
- expect.assertions(2);
30
-
31
- const sequence: ImmutableSequence<MockValueObject<number>> = ImmutableSequence.ofArray<MockValueObject<number>>([]);
37
+ const sequence: ImmutableSequence<MockValueObject<number>> = ImmutableSequence.ofArray([]);
32
38
 
33
39
  expect(sequence.isEmpty()).toBe(true);
34
- expect(sequence).toBe(ImmutableSequence.empty<MockValueObject<number>>());
40
+ expect(sequence).toBe(ImmutableSequence.empty());
35
41
  });
36
42
 
37
43
  it('returns instance', () => {
38
- expect.assertions(2);
39
-
40
- const sequence1: ImmutableSequence<MockValueObject<number>> = ImmutableSequence.ofArray<MockValueObject<number>>([
41
- new MockValueObject<number>(1),
42
- new MockValueObject<number>(3)
44
+ const sequence1: ImmutableSequence<MockValueObject<number>> = ImmutableSequence.ofArray([
45
+ new MockValueObject(1),
46
+ new MockValueObject(3)
43
47
  ]);
44
- const sequence2: ImmutableSequence<MockValueObject<number>> = ImmutableSequence.ofArray<MockValueObject<number>>([
45
- new MockValueObject<number>(2),
46
- new MockValueObject<number>(4),
47
- new MockValueObject<number>(5)
48
+ const sequence2: ImmutableSequence<MockValueObject<number>> = ImmutableSequence.ofArray([
49
+ new MockValueObject(2),
50
+ new MockValueObject(4),
51
+ new MockValueObject(5)
48
52
  ]);
49
53
 
50
54
  expect(sequence1.size()).toBe(2);
@@ -52,28 +56,12 @@ describe('ImmutableSequence', () => {
52
56
  });
53
57
  });
54
58
 
55
- describe('empty', () => {
56
- it('returns singleton instance', () => {
57
- expect.assertions(1);
58
-
59
- expect(ImmutableSequence.empty<MockValueObject<number>>()).toBe(ImmutableSequence.empty<MockValueObject<string>>());
60
- });
61
-
62
- it('always returns 0-size array', () => {
63
- expect.assertions(1);
64
-
65
- expect(ImmutableSequence.empty<MockValueObject<number>>().isEmpty()).toBe(true);
66
- });
67
- });
68
-
69
59
  describe('add', () => {
70
60
  it('can extend immutably', () => {
71
- expect.assertions(13);
61
+ const value1: MockValueObject<number> = new MockValueObject(1);
62
+ const value2: MockValueObject<number> = new MockValueObject(2);
72
63
 
73
- const value1: MockValueObject<number> = new MockValueObject<number>(1);
74
- const value2: MockValueObject<number> = new MockValueObject<number>(2);
75
-
76
- const sequence1: ImmutableSequence<MockValueObject<number>> = ImmutableSequence.empty<MockValueObject<number>>();
64
+ const sequence1: ImmutableSequence<MockValueObject<number>> = ImmutableSequence.empty();
77
65
 
78
66
  expect(sequence1.size()).toBe(0);
79
67
 
@@ -97,142 +85,133 @@ describe('ImmutableSequence', () => {
97
85
  });
98
86
  });
99
87
 
100
- describe('set', () => {
101
- it('can be set the value into first position', () => {
102
- expect.assertions(6);
103
-
104
- const value1: MockValueObject<number> = new MockValueObject<number>(1);
105
- const value2: MockValueObject<number> = new MockValueObject<number>(2);
106
- const value3: MockValueObject<number> = new MockValueObject<number>(3);
107
- const value4: MockValueObject<number> = new MockValueObject<number>(4);
108
-
109
- const sequence1: ImmutableSequence<MockValueObject<number>> = ImmutableSequence.ofArray<MockValueObject<number>>([
110
- value1,
111
- value2,
112
- value3
113
- ]);
114
- const sequence2: ImmutableSequence<MockValueObject<number>> = sequence1.set(0, value4);
115
-
116
- expect(sequence1).not.toBe(sequence2);
117
- expect(sequence1.size()).toBe(3);
118
- expect(sequence2.size()).toBe(3);
119
- expect(sequence2.get(0)).toBe(value4);
120
- expect(sequence2.get(1)).toBe(value2);
121
- expect(sequence2.get(2)).toBe(value3);
88
+ describe('duplicate', () => {
89
+ it('returns ImmutableSequence.empty() when this is ImmutableSequence.empty()', () => {
90
+ expect(ImmutableSequence.empty().duplicate()).toBe(ImmutableSequence.empty());
122
91
  });
123
92
 
124
- it('can be set the value into middle position', () => {
125
- expect.assertions(6);
126
-
127
- const value1: MockValueObject<number> = new MockValueObject<number>(1);
128
- const value2: MockValueObject<number> = new MockValueObject<number>(2);
129
- const value3: MockValueObject<number> = new MockValueObject<number>(3);
130
- const value4: MockValueObject<number> = new MockValueObject<number>(4);
131
-
132
- const sequence1: ImmutableSequence<MockValueObject<number>> = ImmutableSequence.ofArray<MockValueObject<number>>([
133
- value1,
134
- value2,
135
- value3
93
+ it('returns shallow-copied instance', () => {
94
+ const sequence1: ImmutableSequence<MockValueObject<number>> = ImmutableSequence.ofArray([
95
+ new MockValueObject(1),
96
+ new MockValueObject(2),
97
+ new MockValueObject(3),
98
+ new MockValueObject(2)
136
99
  ]);
137
- const sequence2: ImmutableSequence<MockValueObject<number>> = sequence1.set(1, value4);
100
+ const sequence2: ImmutableSequence<MockValueObject<number>> = sequence1.duplicate();
138
101
 
102
+ expect(sequence1.size()).toBe(sequence2.size());
139
103
  expect(sequence1).not.toBe(sequence2);
140
- expect(sequence1.size()).toBe(3);
141
- expect(sequence2.size()).toBe(3);
142
- expect(sequence2.get(0)).toBe(value1);
143
- expect(sequence2.get(1)).toBe(value4);
144
- expect(sequence2.get(2)).toBe(value3);
104
+ sequence1.forEach((v: MockValueObject<number>, k: number) => {
105
+ expect(v).toBe(sequence2.get(k));
106
+ });
145
107
  });
108
+ });
146
109
 
147
- it('can be set the value into last position', () => {
148
- expect.assertions(6);
149
-
150
- const value1: MockValueObject<number> = new MockValueObject<number>(1);
151
- const value2: MockValueObject<number> = new MockValueObject<number>(2);
152
- const value3: MockValueObject<number> = new MockValueObject<number>(3);
153
- const value4: MockValueObject<number> = new MockValueObject<number>(4);
110
+ describe('filter', () => {
111
+ it('returns ImmutableSequence.EMPTY when no match', () => {
112
+ const value1: MockValueObject<number> = new MockValueObject(1);
113
+ const value2: MockValueObject<number> = new MockValueObject(2);
114
+ const value3: MockValueObject<number> = new MockValueObject(3);
115
+ const value4: MockValueObject<number> = new MockValueObject(2);
154
116
 
155
- const sequence1: ImmutableSequence<MockValueObject<number>> = ImmutableSequence.ofArray<MockValueObject<number>>([
117
+ const sequence: ImmutableSequence<MockValueObject<number>> = ImmutableSequence.ofArray([
156
118
  value1,
157
119
  value2,
158
- value3
120
+ value3,
121
+ value4
159
122
  ]);
160
- const sequence2: ImmutableSequence<MockValueObject<number>> = sequence1.set(2, value4);
161
123
 
162
- expect(sequence1).not.toBe(sequence2);
163
- expect(sequence1.size()).toBe(3);
164
- expect(sequence2.size()).toBe(3);
165
- expect(sequence2.get(0)).toBe(value1);
166
- expect(sequence2.get(1)).toBe(value2);
167
- expect(sequence2.get(2)).toBe(value4);
168
- });
124
+ const filtered: ImmutableSequence<MockValueObject<number>> = sequence.filter((v: MockValueObject<number>) => {
125
+ return v.get() > 100;
126
+ });
169
127
 
170
- it('returns itself when given key is less than 0', () => {
171
- expect.assertions(1);
128
+ expect(filtered.size()).toBe(0);
129
+ expect(filtered).toBe(ImmutableSequence.empty<number>());
130
+ });
172
131
 
173
- const value1: MockValueObject<number> = new MockValueObject<number>(1);
174
- const value2: MockValueObject<number> = new MockValueObject<number>(2);
175
- const value3: MockValueObject<number> = new MockValueObject<number>(3);
176
- const value4: MockValueObject<number> = new MockValueObject<number>(4);
132
+ it('can remove match values', () => {
133
+ const value1: MockValueObject<number> = new MockValueObject(1);
134
+ const value2: MockValueObject<number> = new MockValueObject(2);
135
+ const value3: MockValueObject<number> = new MockValueObject(3);
136
+ const value4: MockValueObject<number> = new MockValueObject(2);
137
+ const value5: MockValueObject<number> = new MockValueObject(5);
177
138
 
178
- const sequence1: ImmutableSequence<MockValueObject<number>> = ImmutableSequence.ofArray<MockValueObject<number>>([
139
+ const sequence: ImmutableSequence<MockValueObject<number>> = ImmutableSequence.ofArray([
179
140
  value1,
180
141
  value2,
181
- value3
142
+ value3,
143
+ value4
182
144
  ]);
183
- const sequence2: ImmutableSequence<MockValueObject<number>> = sequence1.set(-1, value4);
184
145
 
185
- expect(sequence1).toBe(sequence2);
186
- });
187
-
188
- it('returns itself when given key is greater than sequence length', () => {
189
- expect.assertions(1);
146
+ const filtered1: ImmutableSequence<MockValueObject<number>> = sequence.filter((v: MockValueObject<number>) => {
147
+ return v.get() % 2 === 0;
148
+ });
149
+ const filtered2: ImmutableSequence<MockValueObject<number>> = sequence.filter((v: MockValueObject<number>) => {
150
+ return v === value4;
151
+ });
152
+ const filtered3: ImmutableSequence<MockValueObject<number>> = sequence.filter((v: MockValueObject<number>) => {
153
+ return v === value5;
154
+ });
190
155
 
191
- const value1: MockValueObject<number> = new MockValueObject<number>(1);
192
- const value2: MockValueObject<number> = new MockValueObject<number>(2);
193
- const value3: MockValueObject<number> = new MockValueObject<number>(3);
194
- const value4: MockValueObject<number> = new MockValueObject<number>(4);
156
+ expect(filtered1.size()).toBe(2);
157
+ expect(filtered1.get(0)).toBe(value2);
158
+ expect(filtered1.get(1)).toBe(value4);
159
+ expect(filtered2.size()).toBe(1);
160
+ expect(filtered2.get(0)).toBe(value4);
161
+ expect(filtered3.size()).toBe(0);
162
+ });
163
+ });
195
164
 
196
- const sequence1: ImmutableSequence<MockValueObject<number>> = ImmutableSequence.ofArray<MockValueObject<number>>([
197
- value1,
198
- value2,
199
- value3
165
+ describe('isEmpty', () => {
166
+ it('returns true if the value size is 0', () => {
167
+ const sequence1: ImmutableSequence<MockValueObject<number>> = ImmutableSequence.ofArray([
168
+ new MockValueObject(1),
169
+ new MockValueObject(2)
200
170
  ]);
171
+ const sequence2: ImmutableSequence<MockValueObject<number>> = ImmutableSequence.ofArray([]);
201
172
 
202
- const sequence2: ImmutableSequence<MockValueObject<number>> = sequence1.set(sequence1.size(), value4);
203
-
204
- expect(sequence1).toBe(sequence2);
173
+ expect(sequence1.isEmpty()).toBe(false);
174
+ expect(sequence2.isEmpty()).toBe(true);
205
175
  });
176
+ });
206
177
 
207
- it('returns itself when given key is not integer', () => {
208
- expect.assertions(1);
178
+ describe('map', () => {
179
+ it('execute the mapper function and returns mapped Address immutably', () => {
180
+ const sequence1: ImmutableSequence<MockValueObject<number>> = ImmutableSequence.ofArray([
181
+ new MockValueObject(1),
182
+ new MockValueObject(2),
183
+ new MockValueObject(3)
184
+ ]);
185
+ const sequence2: ImmutableSequence<MockValueObject<string>> = sequence1.map(
186
+ (value: MockValueObject<number>): MockValueObject<string> => {
187
+ const num: number = value.get();
209
188
 
210
- const value1: MockValueObject<number> = new MockValueObject<number>(1);
211
- const value2: MockValueObject<number> = new MockValueObject<number>(2);
212
- const value3: MockValueObject<number> = new MockValueObject<number>(3);
213
- const value4: MockValueObject<number> = new MockValueObject<number>(4);
189
+ return new MockValueObject<string>(`${num ** 2}`);
190
+ }
191
+ );
214
192
 
215
- const sequence1: ImmutableSequence<MockValueObject<number>> = ImmutableSequence.ofArray<MockValueObject<number>>([
216
- value1,
217
- value2,
218
- value3
219
- ]);
193
+ expect(sequence1.size()).toBe(sequence2.size());
194
+ expect(sequence1).not.toBe(sequence2);
195
+ sequence2.forEach((v: MockValueObject<string>, k: number) => {
196
+ const value: Nullable<MockValueObject<number>> = sequence1.get(k);
220
197
 
221
- const sequence2: ImmutableSequence<MockValueObject<number>> = sequence1.set(2.2, value4);
198
+ if (value === null) {
199
+ fail();
200
+ return;
201
+ }
222
202
 
223
- expect(sequence1).toBe(sequence2);
203
+ expect(v.get()).toBe(`${value.get() ** 2}`);
204
+ });
224
205
  });
225
206
  });
226
207
 
227
208
  describe('remove', () => {
228
209
  it('can remove retaining value if it contains', () => {
229
- expect.assertions(5);
210
+ const value1: MockValueObject<number> = new MockValueObject(1);
211
+ const value2: MockValueObject<number> = new MockValueObject(2);
212
+ const value3: MockValueObject<number> = new MockValueObject(3);
230
213
 
231
- const value1: MockValueObject<number> = new MockValueObject<number>(1);
232
- const value2: MockValueObject<number> = new MockValueObject<number>(2);
233
- const value3: MockValueObject<number> = new MockValueObject<number>(3);
234
-
235
- const sequence1: ImmutableSequence<MockValueObject<number>> = ImmutableSequence.ofArray<MockValueObject<number>>([
214
+ const sequence1: ImmutableSequence<MockValueObject<number>> = ImmutableSequence.ofArray([
236
215
  value1,
237
216
  value2,
238
217
  value3
@@ -248,13 +227,11 @@ describe('ImmutableSequence', () => {
248
227
  });
249
228
 
250
229
  it('removes middle value', () => {
251
- expect.assertions(5);
252
-
253
- const value1: MockValueObject<number> = new MockValueObject<number>(1);
254
- const value2: MockValueObject<number> = new MockValueObject<number>(2);
255
- const value3: MockValueObject<number> = new MockValueObject<number>(3);
230
+ const value1: MockValueObject<number> = new MockValueObject(1);
231
+ const value2: MockValueObject<number> = new MockValueObject(2);
232
+ const value3: MockValueObject<number> = new MockValueObject(3);
256
233
 
257
- const sequence1: ImmutableSequence<MockValueObject<number>> = ImmutableSequence.ofArray<MockValueObject<number>>([
234
+ const sequence1: ImmutableSequence<MockValueObject<number>> = ImmutableSequence.ofArray([
258
235
  value1,
259
236
  value2,
260
237
  value3
@@ -269,13 +246,11 @@ describe('ImmutableSequence', () => {
269
246
  });
270
247
 
271
248
  it('removes last value', () => {
272
- expect.assertions(5);
249
+ const value1: MockValueObject<number> = new MockValueObject(1);
250
+ const value2: MockValueObject<number> = new MockValueObject(2);
251
+ const value3: MockValueObject<number> = new MockValueObject(3);
273
252
 
274
- const value1: MockValueObject<number> = new MockValueObject<number>(1);
275
- const value2: MockValueObject<number> = new MockValueObject<number>(2);
276
- const value3: MockValueObject<number> = new MockValueObject<number>(3);
277
-
278
- const sequence1: ImmutableSequence<MockValueObject<number>> = ImmutableSequence.ofArray<MockValueObject<number>>([
253
+ const sequence1: ImmutableSequence<MockValueObject<number>> = ImmutableSequence.ofArray([
279
254
  value1,
280
255
  value2,
281
256
  value3
@@ -290,13 +265,11 @@ describe('ImmutableSequence', () => {
290
265
  });
291
266
 
292
267
  it('returns itself when given key is greater than sequence length', () => {
293
- expect.assertions(1);
294
-
295
- const value1: MockValueObject<number> = new MockValueObject<number>(1);
296
- const value2: MockValueObject<number> = new MockValueObject<number>(2);
297
- const value3: MockValueObject<number> = new MockValueObject<number>(3);
268
+ const value1: MockValueObject<number> = new MockValueObject(1);
269
+ const value2: MockValueObject<number> = new MockValueObject(2);
270
+ const value3: MockValueObject<number> = new MockValueObject(3);
298
271
 
299
- const sequence1: ImmutableSequence<MockValueObject<number>> = ImmutableSequence.ofArray<MockValueObject<number>>([
272
+ const sequence1: ImmutableSequence<MockValueObject<number>> = ImmutableSequence.ofArray([
300
273
  value1,
301
274
  value2,
302
275
  value3
@@ -307,13 +280,11 @@ describe('ImmutableSequence', () => {
307
280
  });
308
281
 
309
282
  it('returns itself when given key is less than 0', () => {
310
- expect.assertions(1);
283
+ const value1: MockValueObject<number> = new MockValueObject(1);
284
+ const value2: MockValueObject<number> = new MockValueObject(2);
285
+ const value3: MockValueObject<number> = new MockValueObject(3);
311
286
 
312
- const value1: MockValueObject<number> = new MockValueObject<number>(1);
313
- const value2: MockValueObject<number> = new MockValueObject<number>(2);
314
- const value3: MockValueObject<number> = new MockValueObject<number>(3);
315
-
316
- const sequence1: ImmutableSequence<MockValueObject<number>> = ImmutableSequence.ofArray<MockValueObject<number>>([
287
+ const sequence1: ImmutableSequence<MockValueObject<number>> = ImmutableSequence.ofArray([
317
288
  value1,
318
289
  value2,
319
290
  value3
@@ -324,13 +295,11 @@ describe('ImmutableSequence', () => {
324
295
  });
325
296
 
326
297
  it('returns itself when given key is not integer', () => {
327
- expect.assertions(1);
328
-
329
- const value1: MockValueObject<number> = new MockValueObject<number>(1);
330
- const value2: MockValueObject<number> = new MockValueObject<number>(2);
331
- const value3: MockValueObject<number> = new MockValueObject<number>(3);
298
+ const value1: MockValueObject<number> = new MockValueObject(1);
299
+ const value2: MockValueObject<number> = new MockValueObject(2);
300
+ const value3: MockValueObject<number> = new MockValueObject(3);
332
301
 
333
- const sequence1: ImmutableSequence<MockValueObject<number>> = ImmutableSequence.ofArray<MockValueObject<number>>([
302
+ const sequence1: ImmutableSequence<MockValueObject<number>> = ImmutableSequence.ofArray([
334
303
  value1,
335
304
  value2,
336
305
  value3
@@ -341,117 +310,124 @@ describe('ImmutableSequence', () => {
341
310
  });
342
311
  });
343
312
 
344
- describe('isEmpty', () => {
345
- it('returns true if the value size is 0', () => {
346
- expect.assertions(2);
313
+ describe('set', () => {
314
+ it('can be set the value into first position', () => {
315
+ const value1: MockValueObject<number> = new MockValueObject(1);
316
+ const value2: MockValueObject<number> = new MockValueObject(2);
317
+ const value3: MockValueObject<number> = new MockValueObject(3);
318
+ const value4: MockValueObject<number> = new MockValueObject(4);
347
319
 
348
- const sequence1: ImmutableSequence<MockValueObject<number>> = ImmutableSequence.ofArray<MockValueObject<number>>([
349
- new MockValueObject<number>(1),
350
- new MockValueObject<number>(2)
320
+ const sequence1: ImmutableSequence<MockValueObject<number>> = ImmutableSequence.ofArray([
321
+ value1,
322
+ value2,
323
+ value3
351
324
  ]);
352
- const sequence2: ImmutableSequence<MockValueObject<number>> = ImmutableSequence.ofArray<MockValueObject<number>>([]);
325
+ const sequence2: ImmutableSequence<MockValueObject<number>> = sequence1.set(0, value4);
353
326
 
354
- expect(sequence1.isEmpty()).toBe(false);
355
- expect(sequence2.isEmpty()).toBe(true);
327
+ expect(sequence1).not.toBe(sequence2);
328
+ expect(sequence1.size()).toBe(3);
329
+ expect(sequence2.size()).toBe(3);
330
+ expect(sequence2.get(0)).toBe(value4);
331
+ expect(sequence2.get(1)).toBe(value2);
332
+ expect(sequence2.get(2)).toBe(value3);
356
333
  });
357
- });
358
334
 
359
- describe('map', () => {
360
- it('execute the mapper function and returns mapped Address immutably', () => {
361
- expect.assertions(5);
335
+ it('can be set the value into middle position', () => {
336
+ const value1: MockValueObject<number> = new MockValueObject(1);
337
+ const value2: MockValueObject<number> = new MockValueObject(2);
338
+ const value3: MockValueObject<number> = new MockValueObject(3);
339
+ const value4: MockValueObject<number> = new MockValueObject(4);
362
340
 
363
- const sequence1: ImmutableSequence<MockValueObject<number>> = ImmutableSequence.ofArray<MockValueObject<number>>([
364
- new MockValueObject<number>(1),
365
- new MockValueObject<number>(2),
366
- new MockValueObject<number>(3)
341
+ const sequence1: ImmutableSequence<MockValueObject<number>> = ImmutableSequence.ofArray([
342
+ value1,
343
+ value2,
344
+ value3
367
345
  ]);
368
- const sequence2: ImmutableSequence<MockValueObject<string>> = sequence1.map<MockValueObject<string>>(
369
- (value: MockValueObject<number>) => {
370
- const num: number = value.get();
371
-
372
- return new MockValueObject<string>(`${num ** 2}`);
373
- }
374
- );
346
+ const sequence2: ImmutableSequence<MockValueObject<number>> = sequence1.set(1, value4);
375
347
 
376
- expect(sequence1.size()).toBe(sequence2.size());
377
348
  expect(sequence1).not.toBe(sequence2);
378
- sequence2.forEach((v: MockValueObject<string>, k: number) => {
379
- const value: Nullable<MockValueObject<number>> = sequence1.get(k);
349
+ expect(sequence1.size()).toBe(3);
350
+ expect(sequence2.size()).toBe(3);
351
+ expect(sequence2.get(0)).toBe(value1);
352
+ expect(sequence2.get(1)).toBe(value4);
353
+ expect(sequence2.get(2)).toBe(value3);
354
+ });
380
355
 
381
- if (value === null) {
382
- fail();
383
- return;
384
- }
356
+ it('can be set the value into last position', () => {
357
+ const value1: MockValueObject<number> = new MockValueObject(1);
358
+ const value2: MockValueObject<number> = new MockValueObject(2);
359
+ const value3: MockValueObject<number> = new MockValueObject(3);
360
+ const value4: MockValueObject<number> = new MockValueObject(4);
385
361
 
386
- expect(v.get()).toBe(`${value.get() ** 2}`);
387
- });
362
+ const sequence1: ImmutableSequence<MockValueObject<number>> = ImmutableSequence.ofArray([
363
+ value1,
364
+ value2,
365
+ value3
366
+ ]);
367
+ const sequence2: ImmutableSequence<MockValueObject<number>> = sequence1.set(2, value4);
368
+
369
+ expect(sequence1).not.toBe(sequence2);
370
+ expect(sequence1.size()).toBe(3);
371
+ expect(sequence2.size()).toBe(3);
372
+ expect(sequence2.get(0)).toBe(value1);
373
+ expect(sequence2.get(1)).toBe(value2);
374
+ expect(sequence2.get(2)).toBe(value4);
388
375
  });
389
- });
390
376
 
391
- describe('filter', () => {
392
- it('returns ImmutableSequence.EMPTY when no match', () => {
393
- expect.assertions(2);
377
+ it('returns itself when given key is less than 0', () => {
378
+ const value1: MockValueObject<number> = new MockValueObject(1);
379
+ const value2: MockValueObject<number> = new MockValueObject(2);
380
+ const value3: MockValueObject<number> = new MockValueObject(3);
381
+ const value4: MockValueObject<number> = new MockValueObject(4);
394
382
 
395
- const value1: MockValueObject<number> = new MockValueObject<number>(1);
396
- const value2: MockValueObject<number> = new MockValueObject<number>(2);
397
- const value3: MockValueObject<number> = new MockValueObject<number>(3);
398
- const value4: MockValueObject<number> = new MockValueObject<number>(2);
383
+ const sequence1: ImmutableSequence<MockValueObject<number>> = ImmutableSequence.ofArray([
384
+ value1,
385
+ value2,
386
+ value3
387
+ ]);
388
+ const sequence2: ImmutableSequence<MockValueObject<number>> = sequence1.set(-1, value4);
399
389
 
400
- const sequence: ImmutableSequence<MockValueObject<number>> = ImmutableSequence.ofArray<MockValueObject<number>>([
390
+ expect(sequence1).toBe(sequence2);
391
+ });
392
+
393
+ it('returns itself when given key is greater than sequence length', () => {
394
+ const value1: MockValueObject<number> = new MockValueObject(1);
395
+ const value2: MockValueObject<number> = new MockValueObject(2);
396
+ const value3: MockValueObject<number> = new MockValueObject(3);
397
+ const value4: MockValueObject<number> = new MockValueObject(4);
398
+
399
+ const sequence1: ImmutableSequence<MockValueObject<number>> = ImmutableSequence.ofArray([
401
400
  value1,
402
401
  value2,
403
- value3,
404
- value4
402
+ value3
405
403
  ]);
406
404
 
407
- const filtered: ImmutableSequence<MockValueObject<number>> = sequence.filter((v: MockValueObject<number>) => {
408
- return v.get() > 100;
409
- });
405
+ const sequence2: ImmutableSequence<MockValueObject<number>> = sequence1.set(sequence1.size(), value4);
410
406
 
411
- expect(filtered.size()).toBe(0);
412
- expect(filtered).toBe(ImmutableSequence.empty<number>());
407
+ expect(sequence1).toBe(sequence2);
413
408
  });
414
409
 
415
- it('can remove match values', () => {
416
- expect.assertions(6);
417
-
418
- const value1: MockValueObject<number> = new MockValueObject<number>(1);
419
- const value2: MockValueObject<number> = new MockValueObject<number>(2);
420
- const value3: MockValueObject<number> = new MockValueObject<number>(3);
421
- const value4: MockValueObject<number> = new MockValueObject<number>(2);
422
- const value5: MockValueObject<number> = new MockValueObject<number>(5);
410
+ it('returns itself when given key is not integer', () => {
411
+ const value1: MockValueObject<number> = new MockValueObject(1);
412
+ const value2: MockValueObject<number> = new MockValueObject(2);
413
+ const value3: MockValueObject<number> = new MockValueObject(3);
414
+ const value4: MockValueObject<number> = new MockValueObject(4);
423
415
 
424
- const sequence: ImmutableSequence<MockValueObject<number>> = ImmutableSequence.ofArray<MockValueObject<number>>([
416
+ const sequence1: ImmutableSequence<MockValueObject<number>> = ImmutableSequence.ofArray([
425
417
  value1,
426
418
  value2,
427
- value3,
428
- value4
419
+ value3
429
420
  ]);
430
421
 
431
- const filtered1: ImmutableSequence<MockValueObject<number>> = sequence.filter((v: MockValueObject<number>) => {
432
- return v.get() % 2 === 0;
433
- });
434
- const filtered2: ImmutableSequence<MockValueObject<number>> = sequence.filter((v: MockValueObject<number>) => {
435
- return v === value4;
436
- });
437
- const filtered3: ImmutableSequence<MockValueObject<number>> = sequence.filter((v: MockValueObject<number>) => {
438
- return v === value5;
439
- });
422
+ const sequence2: ImmutableSequence<MockValueObject<number>> = sequence1.set(2.2, value4);
440
423
 
441
- expect(filtered1.size()).toBe(2);
442
- expect(filtered1.get(0)).toBe(value2);
443
- expect(filtered1.get(1)).toBe(value4);
444
- expect(filtered2.size()).toBe(1);
445
- expect(filtered2.get(0)).toBe(value4);
446
- expect(filtered3.size()).toBe(0);
424
+ expect(sequence1).toBe(sequence2);
447
425
  });
448
426
  });
449
427
 
450
428
  describe('sort', () => {
451
429
  it('when the size is 0, do nothing', () => {
452
- expect.assertions(2);
453
-
454
- const sequence: ImmutableSequence<MockValueObject<number>> = ImmutableSequence.empty<MockValueObject<number>>();
430
+ const sequence: ImmutableSequence<MockValueObject<number>> = ImmutableSequence.empty();
455
431
  const sorted: ImmutableSequence<MockValueObject<number>> = sequence.sort(() => {
456
432
  return 1;
457
433
  });
@@ -461,12 +437,10 @@ describe('ImmutableSequence', () => {
461
437
  });
462
438
 
463
439
  it('when the size is 1, just copy a sequence shallowly', () => {
464
- expect.assertions(3);
465
-
466
440
  const arr: Array<MockValueObject<number>> = [
467
- new MockValueObject<number>(2)
441
+ new MockValueObject(2)
468
442
  ];
469
- const sequence: ImmutableSequence<MockValueObject<number>> = ImmutableSequence.ofArray<MockValueObject<number>>(arr);
443
+ const sequence: ImmutableSequence<MockValueObject<number>> = ImmutableSequence.ofArray(arr);
470
444
  const sorted: ImmutableSequence<MockValueObject<number>> = sequence.sort(() => {
471
445
  return 1;
472
446
  });
@@ -477,15 +451,13 @@ describe('ImmutableSequence', () => {
477
451
  });
478
452
 
479
453
  it('returns like an array', () => {
480
- expect.assertions(10);
481
-
482
454
  const arr: Array<MockValueObject<number>> = [
483
- new MockValueObject<number>(4),
484
- new MockValueObject<number>(2),
485
- new MockValueObject<number>(3),
486
- new MockValueObject<number>(1)
455
+ new MockValueObject(4),
456
+ new MockValueObject(2),
457
+ new MockValueObject(3),
458
+ new MockValueObject(1)
487
459
  ];
488
- const sequence: ImmutableSequence<MockValueObject<number>> = ImmutableSequence.ofArray<MockValueObject<number>>(arr);
460
+ const sequence: ImmutableSequence<MockValueObject<number>> = ImmutableSequence.ofArray(arr);
489
461
  const sorted: ImmutableSequence<MockValueObject<number>> = sequence.sort((m1: MockValueObject<number>, m2: MockValueObject<number>) => {
490
462
  return m1.get() - m2.get();
491
463
  });
@@ -502,30 +474,4 @@ describe('ImmutableSequence', () => {
502
474
  expect(sorted.get(3)?.get()).toBe(4);
503
475
  });
504
476
  });
505
-
506
- describe('duplicate', () => {
507
- it('returns ImmutableSequence.empty() when this is ImmutableSequence.empty()', () => {
508
- expect.assertions(1);
509
-
510
- expect(ImmutableSequence.empty<MockValueObject<number>>().duplicate()).toBe(ImmutableSequence.empty<MockValueObject<number>>());
511
- });
512
-
513
- it('returns shallow-copied instance', () => {
514
- expect.assertions(6);
515
-
516
- const sequence1: ImmutableSequence<MockValueObject<number>> = ImmutableSequence.ofArray<MockValueObject<number>>([
517
- new MockValueObject<number>(1),
518
- new MockValueObject<number>(2),
519
- new MockValueObject<number>(3),
520
- new MockValueObject<number>(2)
521
- ]);
522
- const sequence2: ImmutableSequence<MockValueObject<number>> = sequence1.duplicate();
523
-
524
- expect(sequence1.size()).toBe(sequence2.size());
525
- expect(sequence1).not.toBe(sequence2);
526
- sequence1.forEach((v: MockValueObject<number>, k: number) => {
527
- expect(v).toBe(sequence2.get(k));
528
- });
529
- });
530
- });
531
477
  });