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