Skip to content
This repository was archived by the owner on Nov 23, 2023. It is now read-only.

Commit fc9a361

Browse files
alexengrigalexengrig
authored
Merge pull request #40 from alexengrig/fix/33
Fixes #33
2 parents 811cdbc + 8a34da3 commit fc9a361

File tree

1 file changed

+179
-0
lines changed
  • src/test/java/io/github/alexengrig/lambdax/collection

1 file changed

+179
-0
lines changed

‎src/test/java/io/github/alexengrig/lambdax/collection/SetXTest.java

+179
Original file line numberDiff line numberDiff line change
@@ -16,9 +16,11 @@
1616

1717
package io.github.alexengrig.lambdax.collection;
1818

19+
import io.github.alexengrig.lambdax.OptionalX;
1920
import org.junit.Test;
2021

2122
import java.util.HashSet;
23+
import java.util.Optional;
2224
import java.util.Set;
2325
import java.util.function.Consumer;
2426
import java.util.function.Function;
@@ -36,6 +38,17 @@ public void checkContains() {
3638
assertTrue(containsValue.test(numbers));
3739
}
3840

41+
@Test
42+
public void checkContainsOptional() {
43+
double value = 1.1;
44+
Set<Number> numbers = new HashSet<>();
45+
numbers.add(value);
46+
Set<Number> actual = Optional.of(numbers)
47+
.filter(SetX.contains(value))
48+
.orElseThrow(IllegalStateException::new);
49+
assertTrue(actual.contains(value));
50+
}
51+
3952
@Test
4053
public void checkContainsAll() {
4154
int value = 2;
@@ -47,6 +60,19 @@ public void checkContainsAll() {
4760
assertTrue(containsAllValues.test(numbers));
4861
}
4962

63+
@Test
64+
public void checkContainsAllOptional() {
65+
double value = 2.1;
66+
Set<Number> numbers = new HashSet<>();
67+
numbers.add(value);
68+
Set<Double> values = new HashSet<>();
69+
values.add(value);
70+
Set<Number> actual = Optional.of(numbers)
71+
.filter(SetX.containsAll(values))
72+
.orElseThrow(IllegalStateException::new);
73+
assertTrue(actual.containsAll(values));
74+
}
75+
5076
@Test
5177
public void checkAdd() {
5278
int value = 3;
@@ -55,6 +81,16 @@ public void checkAdd() {
5581
assertTrue(addValue.test(numbers));
5682
}
5783

84+
@Test
85+
public void checkAddOptional() {
86+
double value = 3.1;
87+
Set<Number> numbers = new HashSet<>();
88+
Set<Number> actual = Optional.of(numbers)
89+
.filter(SetX.add(value))
90+
.orElseThrow(IllegalStateException::new);
91+
assertTrue(actual.contains(value));
92+
}
93+
5894
@Test
5995
public void checkAddAll() {
6096
int value = 4;
@@ -65,6 +101,18 @@ public void checkAddAll() {
65101
assertTrue(addAllValues.test(numbers));
66102
}
67103

104+
@Test
105+
public void checkAddAllOptional() {
106+
double value = 4.1;
107+
Set<Number> numbers = new HashSet<>();
108+
Set<Double> values = new HashSet<>();
109+
values.add(value);
110+
Set<Number> actual = Optional.of(numbers)
111+
.filter(SetX.addAll(values))
112+
.orElseThrow(IllegalStateException::new);
113+
assertTrue(actual.containsAll(values));
114+
}
115+
68116
@Test
69117
public void checkOnlyAdd() {
70118
int value = 5;
@@ -74,6 +122,16 @@ public void checkOnlyAdd() {
74122
assertTrue(numbers.contains(value));
75123
}
76124

125+
@Test
126+
public void checkOnlyAddOptional() {
127+
double value = 5.1;
128+
Set<Number> numbers = new HashSet<>();
129+
Set<Number> actual = Optional.of(numbers)
130+
.map(OptionalX.peek(SetX.onlyAdd(value)))
131+
.orElseThrow(IllegalStateException::new);
132+
assertTrue(actual.contains(value));
133+
}
134+
77135
@Test
78136
public void checkOnlyAddAll() {
79137
int value = 6;
@@ -85,6 +143,18 @@ public void checkOnlyAddAll() {
85143
assertTrue(numbers.containsAll(values));
86144
}
87145

146+
@Test
147+
public void checkOnlyAddAllOptional() {
148+
double value = 6.1;
149+
Set<Number> numbers = new HashSet<>();
150+
Set<Double> values = new HashSet<>();
151+
values.add(value);
152+
Set<Number> actual = Optional.of(numbers)
153+
.map(OptionalX.peek(SetX.onlyAddAll(values)))
154+
.orElseThrow(IllegalStateException::new);
155+
assertTrue(actual.containsAll(values));
156+
}
157+
88158
@Test
89159
public void checkRemove() {
90160
int value = 7;
@@ -94,6 +164,17 @@ public void checkRemove() {
94164
assertTrue(removeValue.test(numbers));
95165
}
96166

167+
@Test
168+
public void checkRemoveOptional() {
169+
double value = 7.1;
170+
Set<Number> numbers = new HashSet<>();
171+
numbers.add(value);
172+
Set<Number> actual = Optional.of(numbers)
173+
.filter(SetX.remove(value))
174+
.orElseThrow(IllegalStateException::new);
175+
assertFalse(actual.contains(value));
176+
}
177+
97178
@Test
98179
public void checkRemoveAll() {
99180
int value = 8;
@@ -105,6 +186,19 @@ public void checkRemoveAll() {
105186
assertTrue(removeAllValues.test(numbers));
106187
}
107188

189+
@Test
190+
public void checkRemoveAllOptional() {
191+
double value = 8.1;
192+
Set<Number> numbers = new HashSet<>();
193+
numbers.add(value);
194+
Set<Double> values = new HashSet<>();
195+
values.add(value);
196+
Set<Number> actual = Optional.of(numbers)
197+
.filter(SetX.removeAll(values))
198+
.orElseThrow(IllegalStateException::new);
199+
assertFalse(actual.containsAll(values));
200+
}
201+
108202
@Test
109203
public void checkOnlyRemove() {
110204
int value = 9;
@@ -115,6 +209,17 @@ public void checkOnlyRemove() {
115209
assertFalse(numbers.contains(value));
116210
}
117211

212+
@Test
213+
public void checkOnlyRemoveOptional() {
214+
double value = 9.1;
215+
Set<Number> numbers = new HashSet<>();
216+
numbers.add(value);
217+
Set<Number> actual = Optional.of(numbers)
218+
.map(OptionalX.peek(SetX.onlyRemove(value)))
219+
.orElseThrow(IllegalStateException::new);
220+
assertFalse(actual.contains(value));
221+
}
222+
118223
@Test
119224
public void checkOnlyRemoveAll() {
120225
int value = 10;
@@ -127,6 +232,19 @@ public void checkOnlyRemoveAll() {
127232
assertFalse(numbers.containsAll(values));
128233
}
129234

235+
@Test
236+
public void checkOnlyRemoveAllOptional() {
237+
double value = 10.1;
238+
Set<Number> numbers = new HashSet<>();
239+
numbers.add(value);
240+
Set<Double> values = new HashSet<>();
241+
values.add(value);
242+
Set<Number> actual = Optional.of(numbers)
243+
.map(OptionalX.peek(SetX.onlyRemoveAll(values)))
244+
.orElseThrow(IllegalStateException::new);
245+
assertFalse(actual.containsAll(values));
246+
}
247+
130248
@Test
131249
public void checkRetainAll() {
132250
int value = 11;
@@ -138,6 +256,19 @@ public void checkRetainAll() {
138256
assertFalse(retainAllValues.test(numbers));
139257
}
140258

259+
@Test(expected = NullPointerException.class)
260+
public void checkRetainAllOptional() {
261+
double value = 11.1;
262+
Set<Number> numbers = new HashSet<>();
263+
numbers.add(value);
264+
Set<Double> values = new HashSet<>();
265+
values.add(value);
266+
Set<Number> actual = Optional.of(numbers)
267+
.filter(SetX.retainAll(values))
268+
.orElseThrow(NullPointerException::new);
269+
assertNull(actual);
270+
}
271+
141272
@Test
142273
public void checkOnlyRetainAll() {
143274
int value = 12;
@@ -150,6 +281,19 @@ public void checkOnlyRetainAll() {
150281
assertTrue(numbers.containsAll(values));
151282
}
152283

284+
@Test
285+
public void checkOnlyRetainAllOptional() {
286+
double value = 12.1;
287+
Set<Number> numbers = new HashSet<>();
288+
numbers.add(value);
289+
Set<Double> values = new HashSet<>();
290+
values.add(value);
291+
Set<Number> actual = Optional.of(numbers)
292+
.map(OptionalX.peek(SetX.onlyRetainAll(values)))
293+
.orElseThrow(IllegalStateException::new);
294+
assertTrue(actual.containsAll(values));
295+
}
296+
153297
@Test
154298
public void checkToArray() {
155299
int value = 13;
@@ -159,6 +303,17 @@ public void checkToArray() {
159303
assertArrayEquals(new Integer[]{value}, toIntegerArray.apply(numbers));
160304
}
161305

306+
@Test
307+
public void checkToArrayOptional() {
308+
double value = 13.1;
309+
Set<Number> numbers = new HashSet<>();
310+
numbers.add(value);
311+
Number[] actual = Optional.of(numbers)
312+
.map(SetX.toArray(new Double[0]))
313+
.orElseThrow(IllegalStateException::new);
314+
assertArrayEquals(new Double[]{value}, actual);
315+
}
316+
162317
@Test
163318
public void checkToArrayWithGenerator() {
164319
int value = 14;
@@ -168,6 +323,17 @@ public void checkToArrayWithGenerator() {
168323
assertArrayEquals(new Integer[]{value}, toIntegerArray.apply(numbers));
169324
}
170325

326+
@Test
327+
public void checkToArrayWithGeneratorOptional() {
328+
double value = 14.1;
329+
Set<Number> numbers = new HashSet<>();
330+
numbers.add(value);
331+
Number[] actual = Optional.of(numbers)
332+
.map(SetX.toArray(Double[]::new))
333+
.orElseThrow(IllegalStateException::new);
334+
assertArrayEquals(new Double[]{value}, actual);
335+
}
336+
171337
@Test
172338
public void checkEquals() {
173339
int value = 15;
@@ -178,4 +344,17 @@ public void checkEquals() {
178344
Predicate<Set<? extends Number>> equalsToValues = SetX.equalsTo(values);
179345
assertTrue(equalsToValues.test(numbers));
180346
}
347+
348+
@Test
349+
public void checkEqualsOptional() {
350+
double value = 15.1;
351+
Set<Number> numbers = new HashSet<>();
352+
numbers.add(value);
353+
Set<Double> values = new HashSet<>();
354+
values.add(value);
355+
Set<Number> actual = Optional.of(numbers)
356+
.filter(SetX.equalsTo(values))
357+
.orElseThrow(IllegalStateException::new);
358+
assertEquals(values, actual);
359+
}
181360
}

0 commit comments

Comments
 (0)