Skip to content

Commit 67f38fc

Browse files
SirCotareSirCotare
committed
add tests
1 parent 2e86a41 commit 67f38fc

1 file changed

Lines changed: 371 additions & 0 deletions

File tree

‎src/test/java/it/aboutbits/springboot/toolbox/util/CollectUtilTest.java‎

Lines changed: 371 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,371 @@
1+
package it.aboutbits.springboot.toolbox.util;
2+
3+
import org.junit.jupiter.api.DisplayName;
4+
import org.junit.jupiter.api.Nested;
5+
import org.junit.jupiter.api.Test;
6+
import org.springframework.data.util.Streamable;
7+
8+
import java.util.Arrays;
9+
import java.util.Collections;
10+
import java.util.function.Function;
11+
12+
import static org.assertj.core.api.Assertions.assertThat;
13+
import static org.junit.jupiter.api.Assertions.assertEquals;
14+
import static org.junit.jupiter.api.Assertions.assertTrue;
15+
16+
class CollectUtilTest {
17+
@Nested
18+
class CollectToSet {
19+
@Test
20+
@DisplayName("Should convert Collection to Set using mapper")
21+
void shouldConvertCollectionToSetUsingMapper() {
22+
// given
23+
var numbers = Arrays.asList(1, 2, 3, 4, 5);
24+
var mapper = (Function<Integer, String>) Object::toString;
25+
26+
// when
27+
var result = CollectUtil.collectToSet(numbers, mapper);
28+
29+
// then
30+
assertThat(result).containsExactlyInAnyOrder("1", "2", "3", "4", "5");
31+
}
32+
33+
@Test
34+
@DisplayName("Should convert Collection to Set using mapper")
35+
void shouldConvertCollectionToSetUsingMapperAndFilterNullValues() {
36+
// given
37+
var numbers = Arrays.asList("a", "b", "c", "d");
38+
var mapper = (Function<String, String>) Object::toString;
39+
40+
// when
41+
var result = CollectUtil.collectToSet(numbers, mapper);
42+
43+
// then
44+
assertThat(result).containsExactlyInAnyOrder("a", "b", "c", "d");
45+
}
46+
47+
@Test
48+
@DisplayName("Should handle empty Collection when converting to Set")
49+
void shouldHandleEmptyCollectionWhenConvertingToSet() {
50+
// given
51+
var emptyList = Collections.<Integer>emptyList();
52+
var mapper = (Function<Integer, String>) Object::toString;
53+
54+
// when
55+
var result = CollectUtil.collectToSet(emptyList, mapper);
56+
57+
// then
58+
assertTrue(result.isEmpty());
59+
}
60+
61+
@Test
62+
@DisplayName("Should remove duplicates when converting Collection to Set")
63+
void shouldRemoveDuplicatesWhenConvertingCollectionToSet() {
64+
// given
65+
var numbersWithDuplicates = Arrays.asList(1, 2, 2, 3, 3, 3);
66+
var mapper = (Function<Integer, String>) Object::toString;
67+
68+
// when
69+
var result = CollectUtil.collectToSet(numbersWithDuplicates, mapper);
70+
71+
// then
72+
assertThat(result).containsExactlyInAnyOrder("1", "2", "3");
73+
assertEquals(3, result.size());
74+
}
75+
76+
@Test
77+
@DisplayName("Should convert Streamable to Set using mapper")
78+
void shouldConvertStreamableToSetUsingMapper() {
79+
// given
80+
var numbers = Streamable.of(1, 2, 3, 4, 5);
81+
var mapper = (Function<Integer, String>) Object::toString;
82+
83+
// when
84+
var result = CollectUtil.collectToSet(numbers, mapper);
85+
86+
// then
87+
assertThat(result).containsExactlyInAnyOrder("1", "2", "3", "4", "5");
88+
}
89+
90+
@Test
91+
@DisplayName("Should convert Streamable to Set using mapper")
92+
void shouldConvertStreamableToSetUsingMapperAndFilterNullValues() {
93+
// given
94+
var numbers = Streamable.of("a", "b", "c", "d");
95+
var mapper = (Function<String, String>) Object::toString;
96+
97+
// when
98+
var result = CollectUtil.collectToSet(numbers, mapper);
99+
100+
// then
101+
assertThat(result).containsExactlyInAnyOrder("a", "b", "c", "d");
102+
}
103+
104+
@Test
105+
@DisplayName("Should handle empty Streamable when converting to Set")
106+
void shouldHandleEmptyStreamableWhenConvertingToSet() {
107+
// given
108+
var emptyStreamable = Streamable.<Integer>empty();
109+
var mapper = (Function<Integer, String>) Object::toString;
110+
111+
// when
112+
var result = CollectUtil.collectToSet(emptyStreamable, mapper);
113+
114+
// then
115+
assertTrue(result.isEmpty());
116+
}
117+
118+
@Test
119+
@DisplayName("Should convert Stream to Set using mapper")
120+
void shouldConvertStreamToSetUsingMapper() {
121+
// given
122+
var numbers = java.util.stream.Stream.of(1, 2, 3, 4, 5);
123+
var mapper = (Function<Integer, String>) Object::toString;
124+
125+
// when
126+
var result = CollectUtil.collectToSet(numbers, mapper);
127+
128+
// then
129+
assertThat(result).containsExactlyInAnyOrder("1", "2", "3", "4", "5");
130+
}
131+
132+
@Test
133+
@DisplayName("Should handle empty Stream when converting to Set")
134+
void shouldHandleEmptyStreamWhenConvertingToSet() {
135+
// given
136+
var emptyStream = java.util.stream.Stream.<Integer>empty();
137+
var mapper = (Function<Integer, String>) Object::toString;
138+
139+
// when
140+
var result = CollectUtil.collectToSet(emptyStream, mapper);
141+
142+
// then
143+
assertTrue(result.isEmpty());
144+
}
145+
146+
@Test
147+
@DisplayName("Should remove duplicates when converting Stream to Set")
148+
void shouldRemoveDuplicatesWhenConvertingStreamToSet() {
149+
// given
150+
var numbersWithDuplicates = java.util.stream.Stream.of(1, 2, 2, 3, 3, 3);
151+
var mapper = (Function<Integer, String>) Object::toString;
152+
153+
// when
154+
var result = CollectUtil.collectToSet(numbersWithDuplicates, mapper);
155+
156+
// then
157+
assertThat(result).containsExactlyInAnyOrder("1", "2", "3");
158+
assertEquals(3, result.size());
159+
}
160+
}
161+
162+
@Nested
163+
class CollectToList {
164+
@Test
165+
@DisplayName("Should convert Collection to List using mapper")
166+
void shouldConvertCollectionToListUsingMapper() {
167+
// given
168+
var numbers = Arrays.asList(1, 2, 3, 4, 5);
169+
var mapper = (Function<Integer, String>) Object::toString;
170+
171+
// when
172+
var result = CollectUtil.collectToList(numbers, mapper);
173+
174+
// then
175+
assertThat(result).containsExactly("1", "2", "3", "4", "5");
176+
}
177+
178+
@Test
179+
@DisplayName("Should handle empty Collection when converting to List")
180+
void shouldHandleEmptyCollectionWhenConvertingToList() {
181+
// given
182+
var emptyList = Collections.<Integer>emptyList();
183+
var mapper = (Function<Integer, String>) Object::toString;
184+
185+
// when
186+
var result = CollectUtil.collectToList(emptyList, mapper);
187+
188+
// then
189+
assertTrue(result.isEmpty());
190+
}
191+
192+
@Test
193+
@DisplayName("Should preserve duplicates when converting Collection to List")
194+
void shouldPreserveDuplicatesWhenConvertingCollectionToList() {
195+
// given
196+
var numbersWithDuplicates = Arrays.asList(1, 2, 2, 3, 3, 3);
197+
var mapper = (Function<Integer, String>) Object::toString;
198+
199+
// when
200+
var result = CollectUtil.collectToList(numbersWithDuplicates, mapper);
201+
202+
// then
203+
assertThat(result).containsExactly("1", "2", "2", "3", "3", "3");
204+
assertEquals(6, result.size());
205+
}
206+
207+
@Test
208+
@DisplayName("Should convert Streamable to List using mapper")
209+
void shouldConvertStreamableToListUsingMapper() {
210+
// given
211+
var numbers = Streamable.of(1, 2, 3, 4, 5);
212+
var mapper = (Function<Integer, String>) Object::toString;
213+
214+
// when
215+
var result = CollectUtil.collectToList(numbers, mapper);
216+
217+
// then
218+
assertThat(result).containsExactly("1", "2", "3", "4", "5");
219+
}
220+
221+
@Test
222+
@DisplayName("Should handle empty Streamable when converting to List")
223+
void shouldHandleEmptyStreamableWhenConvertingToList() {
224+
// given
225+
var emptyStreamable = Streamable.<Integer>empty();
226+
var mapper = (Function<Integer, String>) Object::toString;
227+
228+
// when
229+
var result = CollectUtil.collectToList(emptyStreamable, mapper);
230+
231+
// then
232+
assertTrue(result.isEmpty());
233+
}
234+
235+
@Test
236+
@DisplayName("Should convert Stream to List using mapper")
237+
void shouldConvertStreamToListUsingMapper() {
238+
// given
239+
var numbers = java.util.stream.Stream.of(1, 2, 3, 4, 5);
240+
var mapper = (Function<Integer, String>) Object::toString;
241+
242+
// when
243+
var result = CollectUtil.collectToList(numbers, mapper);
244+
245+
// then
246+
assertThat(result).containsExactly("1", "2", "3", "4", "5");
247+
}
248+
249+
@Test
250+
@DisplayName("Should handle empty Stream when converting to List")
251+
void shouldHandleEmptyStreamWhenConvertingToList() {
252+
// given
253+
var emptyStream = java.util.stream.Stream.<Integer>empty();
254+
var mapper = (Function<Integer, String>) Object::toString;
255+
256+
// when
257+
var result = CollectUtil.collectToList(emptyStream, mapper);
258+
259+
// then
260+
assertTrue(result.isEmpty());
261+
}
262+
263+
@Test
264+
@DisplayName("Should preserve duplicates when converting Stream to List")
265+
void shouldPreserveDuplicatesWhenConvertingStreamToList() {
266+
// given
267+
var numbersWithDuplicates = java.util.stream.Stream.of(1, 2, 2, 3, 3, 3);
268+
var mapper = (Function<Integer, String>) Object::toString;
269+
270+
// when
271+
var result = CollectUtil.collectToList(numbersWithDuplicates, mapper);
272+
273+
// then
274+
assertThat(result).containsExactly("1", "2", "2", "3", "3", "3");
275+
assertEquals(6, result.size());
276+
}
277+
}
278+
279+
@Nested
280+
class CollectToStream {
281+
@Test
282+
@DisplayName("Should convert Collection to Stream using mapper")
283+
void shouldConvertCollectionToStreamUsingMapper() {
284+
// given
285+
var numbers = Arrays.asList(1, 2, 3, 4, 5);
286+
var mapper = (Function<Integer, String>) Object::toString;
287+
288+
// when
289+
var resultStream = CollectUtil.collectToStream(numbers, mapper);
290+
var result = resultStream.toList();
291+
292+
// then
293+
assertThat(result).containsExactly("1", "2", "3", "4", "5");
294+
}
295+
296+
@Test
297+
@DisplayName("Should handle empty Collection when converting to Stream")
298+
void shouldHandleEmptyCollectionWhenConvertingToStream() {
299+
// given
300+
var emptyList = Collections.<Integer>emptyList();
301+
var mapper = (Function<Integer, String>) Object::toString;
302+
303+
// when
304+
var resultStream = CollectUtil.collectToStream(emptyList, mapper);
305+
var result = resultStream.toList();
306+
307+
// then
308+
assertTrue(result.isEmpty());
309+
}
310+
311+
@Test
312+
@DisplayName("Should convert Streamable to Stream using mapper")
313+
void shouldConvertStreamableToStreamUsingMapper() {
314+
// given
315+
var numbers = Streamable.of(1, 2, 3, 4, 5);
316+
var mapper = (Function<Integer, String>) Object::toString;
317+
318+
// when
319+
var resultStream = CollectUtil.collectToStream(numbers, mapper);
320+
var result = resultStream.toList();
321+
322+
// then
323+
assertThat(result).containsExactly("1", "2", "3", "4", "5");
324+
}
325+
326+
@Test
327+
@DisplayName("Should handle empty Streamable when converting to Stream")
328+
void shouldHandleEmptyStreamableWhenConvertingToStream() {
329+
// given
330+
var emptyStreamable = Streamable.<Integer>empty();
331+
var mapper = (Function<Integer, String>) Object::toString;
332+
333+
// when
334+
var resultStream = CollectUtil.collectToStream(emptyStreamable, mapper);
335+
var result = resultStream.toList();
336+
337+
// then
338+
assertTrue(result.isEmpty());
339+
}
340+
341+
@Test
342+
@DisplayName("Should convert Stream to Stream using mapper")
343+
void shouldConvertStreamToStreamUsingMapper() {
344+
// given
345+
var numbers = java.util.stream.Stream.of(1, 2, 3, 4, 5);
346+
var mapper = (Function<Integer, String>) Object::toString;
347+
348+
// when
349+
var resultStream = CollectUtil.collectToStream(numbers, mapper);
350+
var result = resultStream.toList();
351+
352+
// then
353+
assertThat(result).containsExactly("1", "2", "3", "4", "5");
354+
}
355+
356+
@Test
357+
@DisplayName("Should handle empty Stream when converting to Stream")
358+
void shouldHandleEmptyStreamWhenConvertingToStream() {
359+
// given
360+
var emptyStream = java.util.stream.Stream.<Integer>empty();
361+
var mapper = (Function<Integer, String>) Object::toString;
362+
363+
// when
364+
var resultStream = CollectUtil.collectToStream(emptyStream, mapper);
365+
var result = resultStream.toList();
366+
367+
// then
368+
assertTrue(result.isEmpty());
369+
}
370+
}
371+
}

0 commit comments

Comments
 (0)