Skip to content

Commit 4181514

Browse files
fluxw42fluxw42
committed
Add proper tests for fluent-interface pattern and fixed a little bug
1 parent df69a8f commit 4181514

5 files changed

Lines changed: 222 additions & 1 deletion

File tree

‎fluentinterface/pom.xml‎

Lines changed: 5 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -16,5 +16,10 @@
1616
<artifactId>junit</artifactId>
1717
<scope>test</scope>
1818
</dependency>
19+
<dependency>
20+
<groupId>org.mockito</groupId>
21+
<artifactId>mockito-core</artifactId>
22+
<scope>test</scope>
23+
</dependency>
1924
</dependencies>
2025
</project>

‎fluentinterface/src/main/java/com/iluwatar/fluentinterface/fluentiterable/lazy/LazyFluentIterable.java‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -215,7 +215,7 @@ public Iterator<TYPE> iterator() {
215215
return new DecoratingIterator<TYPE>(iterable.iterator()) {
216216
@Override
217217
public TYPE computeNext() {
218-
return fromIterator.next();
218+
return fromIterator.hasNext() ? fromIterator.next() : null;
219219
}
220220
};
221221
}

‎fluentinterface/src/test/java/com/iluwatar/fluentinterface/fluentiterable/FluentIterableTest.java‎

Lines changed: 180 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,180 @@
1+
package com.iluwatar.fluentinterface.fluentiterable;
2+
3+
import org.junit.Test;
4+
5+
import java.util.Arrays;
6+
import java.util.Collections;
7+
import java.util.List;
8+
import java.util.Optional;
9+
import java.util.Spliterator;
10+
import java.util.function.Consumer;
11+
12+
import static org.junit.Assert.assertEquals;
13+
import static org.junit.Assert.assertFalse;
14+
import static org.junit.Assert.assertNotNull;
15+
import static org.junit.Assert.assertTrue;
16+
import static org.mockito.Mockito.mock;
17+
import static org.mockito.Mockito.times;
18+
import static org.mockito.Mockito.verify;
19+
import static org.mockito.Mockito.verifyNoMoreInteractions;
20+
21+
/**
22+
* Date: 12/12/15 - 7:00 PM
23+
*
24+
* @author Jeroen Meulemeester
25+
*/
26+
public abstract class FluentIterableTest {
27+
28+
/**
29+
* Create a new {@link FluentIterable<Integer>} from the given integers
30+
*
31+
* @param integers The integers
32+
* @return The new iterable, use for testing
33+
*/
34+
protected abstract FluentIterable<Integer> createFluentIterable(final Iterable<Integer> integers);
35+
36+
@Test
37+
public void testFirst() throws Exception {
38+
final List<Integer> integers = Arrays.asList(1, 2, 3, 10, 9, 8);
39+
final Optional<Integer> first = createFluentIterable(integers).first();
40+
assertNotNull(first);
41+
assertTrue(first.isPresent());
42+
assertEquals(integers.get(0), first.get());
43+
}
44+
45+
@Test
46+
public void testFirstEmptyCollection() throws Exception {
47+
final List<Integer> integers = Collections.<Integer>emptyList();
48+
final Optional<Integer> first = createFluentIterable(integers).first();
49+
assertNotNull(first);
50+
assertFalse(first.isPresent());
51+
}
52+
53+
@Test
54+
public void testFirstCount() throws Exception {
55+
final List<Integer> integers = Arrays.asList(1, 2, 3, 10, 9, 8);
56+
final List<Integer> first4 = createFluentIterable(integers)
57+
.first(4)
58+
.asList();
59+
60+
assertNotNull(first4);
61+
assertEquals(4, first4.size());
62+
63+
assertEquals(integers.get(0), first4.get(0));
64+
assertEquals(integers.get(1), first4.get(1));
65+
assertEquals(integers.get(2), first4.get(2));
66+
assertEquals(integers.get(3), first4.get(3));
67+
}
68+
69+
@Test
70+
public void testFirstCountLessItems() throws Exception {
71+
final List<Integer> integers = Arrays.asList(1, 2, 3);
72+
final List<Integer> first4 = createFluentIterable(integers)
73+
.first(4)
74+
.asList();
75+
76+
assertNotNull(first4);
77+
assertEquals(3, first4.size());
78+
79+
assertEquals(integers.get(0), first4.get(0));
80+
assertEquals(integers.get(1), first4.get(1));
81+
assertEquals(integers.get(2), first4.get(2));
82+
}
83+
84+
@Test
85+
public void testLast() throws Exception {
86+
final List<Integer> integers = Arrays.asList(1, 2, 3, 10, 9, 8);
87+
final Optional<Integer> last = createFluentIterable(integers).last();
88+
assertNotNull(last);
89+
assertTrue(last.isPresent());
90+
assertEquals(integers.get(integers.size() - 1), last.get());
91+
}
92+
93+
@Test
94+
public void testLastEmptyCollection() throws Exception {
95+
final List<Integer> integers = Collections.<Integer>emptyList();
96+
final Optional<Integer> last = createFluentIterable(integers).last();
97+
assertNotNull(last);
98+
assertFalse(last.isPresent());
99+
}
100+
101+
@Test
102+
public void testLastCount() throws Exception {
103+
final List<Integer> integers = Arrays.asList(1, 2, 3, 10, 9, 8);
104+
final List<Integer> last4 = createFluentIterable(integers)
105+
.last(4)
106+
.asList();
107+
108+
assertNotNull(last4);
109+
assertEquals(4, last4.size());
110+
assertEquals(Integer.valueOf(3), last4.get(0));
111+
assertEquals(Integer.valueOf(10), last4.get(1));
112+
assertEquals(Integer.valueOf(9), last4.get(2));
113+
assertEquals(Integer.valueOf(8), last4.get(3));
114+
}
115+
116+
@Test
117+
public void testLastCountLessItems() throws Exception {
118+
final List<Integer> integers = Arrays.asList(1, 2, 3);
119+
final List<Integer> last4 = createFluentIterable(integers)
120+
.last(4)
121+
.asList();
122+
123+
assertNotNull(last4);
124+
assertEquals(3, last4.size());
125+
126+
assertEquals(Integer.valueOf(1), last4.get(0));
127+
assertEquals(Integer.valueOf(2), last4.get(1));
128+
assertEquals(Integer.valueOf(3), last4.get(2));
129+
}
130+
131+
@Test
132+
public void testFilter() throws Exception {
133+
final List<Integer> integers = Arrays.asList(1, 2, 3, 10, 9, 8);
134+
final List<Integer> evenItems = createFluentIterable(integers)
135+
.filter(i -> i % 2 == 0)
136+
.asList();
137+
138+
assertNotNull(evenItems);
139+
assertEquals(3, evenItems.size());
140+
assertEquals(Integer.valueOf(2), evenItems.get(0));
141+
assertEquals(Integer.valueOf(10), evenItems.get(1));
142+
assertEquals(Integer.valueOf(8), evenItems.get(2));
143+
}
144+
145+
@Test
146+
public void testMap() throws Exception {
147+
final List<Integer> integers = Arrays.asList(1, 2, 3);
148+
final List<Long> longs = createFluentIterable(integers)
149+
.map(Integer::longValue)
150+
.asList();
151+
152+
assertNotNull(longs);
153+
assertEquals(integers.size(), longs.size());
154+
assertEquals(Long.valueOf(1), longs.get(0));
155+
assertEquals(Long.valueOf(2), longs.get(1));
156+
assertEquals(Long.valueOf(3), longs.get(2));
157+
}
158+
159+
@Test
160+
public void testForEach() throws Exception {
161+
final List<Integer> integers = Arrays.asList(1, 2, 3);
162+
163+
final Consumer<Integer> consumer = mock(Consumer.class);
164+
createFluentIterable(integers).forEach(consumer);
165+
166+
verify(consumer, times(1)).accept(Integer.valueOf(1));
167+
verify(consumer, times(1)).accept(Integer.valueOf(2));
168+
verify(consumer, times(1)).accept(Integer.valueOf(3));
169+
verifyNoMoreInteractions(consumer);
170+
171+
}
172+
173+
@Test
174+
public void testSpliterator() throws Exception {
175+
final List<Integer> integers = Arrays.asList(1, 2, 3);
176+
final Spliterator<Integer> split = createFluentIterable(integers).spliterator();
177+
assertNotNull(split);
178+
}
179+
180+
}

‎fluentinterface/src/test/java/com/iluwatar/fluentinterface/fluentiterable/lazy/LazyFluentIterableTest.java‎

Lines changed: 18 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,18 @@
1+
package com.iluwatar.fluentinterface.fluentiterable.lazy;
2+
3+
import com.iluwatar.fluentinterface.fluentiterable.FluentIterable;
4+
import com.iluwatar.fluentinterface.fluentiterable.FluentIterableTest;
5+
6+
/**
7+
* Date: 12/12/15 - 7:56 PM
8+
*
9+
* @author Jeroen Meulemeester
10+
*/
11+
public class LazyFluentIterableTest extends FluentIterableTest {
12+
13+
@Override
14+
protected FluentIterable<Integer> createFluentIterable(Iterable<Integer> integers) {
15+
return LazyFluentIterable.from(integers);
16+
}
17+
18+
}

‎fluentinterface/src/test/java/com/iluwatar/fluentinterface/fluentiterable/simple/SimpleFluentIterableTest.java‎

Lines changed: 18 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,18 @@
1+
package com.iluwatar.fluentinterface.fluentiterable.simple;
2+
3+
import com.iluwatar.fluentinterface.fluentiterable.FluentIterable;
4+
import com.iluwatar.fluentinterface.fluentiterable.FluentIterableTest;
5+
6+
/**
7+
* Date: 12/12/15 - 7:56 PM
8+
*
9+
* @author Jeroen Meulemeester
10+
*/
11+
public class SimpleFluentIterableTest extends FluentIterableTest {
12+
13+
@Override
14+
protected FluentIterable<Integer> createFluentIterable(Iterable<Integer> integers) {
15+
return SimpleFluentIterable.fromCopyOf(integers);
16+
}
17+
18+
}

0 commit comments

Comments
 (0)