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

Commit 0d3c0e0

Browse files
alexengrigalexengrig
authored
Merge pull request #10 from alexengrig/fix/7
Fixes #7
2 parents 1a303d0 + 6aacefe commit 0d3c0e0

File tree

2 files changed

+250
-0
lines changed

2 files changed

+250
-0
lines changed

‎src/main/java/alexengrig/lambdax/collection/SetX.java

+85
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,85 @@
1+
package alexengrig.lambdax.collection;
2+
3+
import java.util.Collection;
4+
import java.util.Set;
5+
import java.util.function.Consumer;
6+
import java.util.function.Function;
7+
import java.util.function.IntFunction;
8+
import java.util.function.Predicate;
9+
10+
/**
11+
* This utility class contains useful lambdas for {@link Set}
12+
*
13+
* @author Grig Alex
14+
* @see Set
15+
* @see Collection
16+
* @see Consumer
17+
* @see Function
18+
* @see IntFunction
19+
* @see Predicate
20+
* @since 0.1.0
21+
*/
22+
public final class SetX {
23+
private SetX() {
24+
}
25+
26+
public static <E> Predicate<Set<? extends E>> contains(E item) {
27+
return s -> s.contains(item);
28+
}
29+
30+
public static <E> Predicate<Set<? extends E>> containsAll(Collection<? extends E> all) {
31+
return s -> s.containsAll(all);
32+
}
33+
34+
public static <E> Predicate<Set<? super E>> add(E item) {
35+
return s -> s.add(item);
36+
}
37+
38+
public static <E> Predicate<Set<? super E>> addAll(Collection<? extends E> all) {
39+
return s -> s.addAll(all);
40+
}
41+
42+
public static <E> Consumer<Set<? super E>> onlyAdd(E item) {
43+
return s -> s.add(item);
44+
}
45+
46+
public static <E> Consumer<Set<? super E>> onlyAddAll(Collection<? extends E> all) {
47+
return s -> s.addAll(all);
48+
}
49+
50+
public static <E> Predicate<Set<? super E>> remove(E item) {
51+
return s -> s.remove(item);
52+
}
53+
54+
public static <E> Predicate<Set<? super E>> removeAll(Collection<? extends E> all) {
55+
return s -> s.removeAll(all);
56+
}
57+
58+
public static <E> Consumer<Set<? super E>> onlyRemove(E item) {
59+
return s -> s.remove(item);
60+
}
61+
62+
public static <E> Consumer<Set<? super E>> onlyRemoveAll(Collection<? extends E> all) {
63+
return s -> s.removeAll(all);
64+
}
65+
66+
public static <E> Predicate<Set<? super E>> retainAll(Collection<? extends E> all) {
67+
return s -> s.retainAll(all);
68+
}
69+
70+
public static <E> Consumer<Set<? super E>> onlyRetainAll(Collection<? extends E> all) {
71+
return s -> s.retainAll(all);
72+
}
73+
74+
public static <E> Function<Set<? extends E>, E[]> toArray(E[] array) {
75+
return c -> c.toArray(array);
76+
}
77+
78+
public static <E> Function<Set<? extends E>, E[]> toArray(IntFunction<? extends E[]> generator) {
79+
return c -> c.toArray(generator.apply(0));
80+
}
81+
82+
public static <E> Predicate<Set<? extends E>> equalsTo(Object other) {
83+
return c -> c.equals(other);
84+
}
85+
}

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

+165
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,165 @@
1+
package alexengrig.lambdax.collection;
2+
3+
import org.junit.Test;
4+
5+
import java.util.HashSet;
6+
import java.util.Set;
7+
import java.util.function.Consumer;
8+
import java.util.function.Function;
9+
import java.util.function.Predicate;
10+
11+
import static org.junit.Assert.*;
12+
13+
public class SetXTest {
14+
@Test
15+
public void checkContains() {
16+
int value = 1;
17+
Set<Number> numbers = new HashSet<>();
18+
numbers.add(value);
19+
Predicate<Set<? extends Number>> containsValue = SetX.contains(value);
20+
assertTrue(containsValue.test(numbers));
21+
}
22+
23+
@Test
24+
public void checkContainsAll() {
25+
int value = 2;
26+
Set<Number> numbers = new HashSet<>();
27+
numbers.add(value);
28+
Set<Integer> values = new HashSet<>();
29+
values.add(value);
30+
Predicate<Set<? extends Number>> containsAllValues = SetX.containsAll(values);
31+
assertTrue(containsAllValues.test(numbers));
32+
}
33+
34+
@Test
35+
public void checkAdd() {
36+
int value = 3;
37+
Set<Number> numbers = new HashSet<>();
38+
Predicate<Set<? super Number>> addValue = SetX.add(value);
39+
assertTrue(addValue.test(numbers));
40+
}
41+
42+
@Test
43+
public void checkAddAll() {
44+
int value = 4;
45+
Set<Number> numbers = new HashSet<>();
46+
Set<Integer> values = new HashSet<>();
47+
values.add(value);
48+
Predicate<Set<? super Number>> addAllValues = SetX.addAll(values);
49+
assertTrue(addAllValues.test(numbers));
50+
}
51+
52+
@Test
53+
public void checkOnlyAdd() {
54+
int value = 5;
55+
Set<Number> numbers = new HashSet<>();
56+
Consumer<Set<? super Number>> onlyAddValue = SetX.onlyAdd(value);
57+
onlyAddValue.accept(numbers);
58+
assertTrue(numbers.contains(value));
59+
}
60+
61+
@Test
62+
public void checkOnlyAddAll() {
63+
int value = 6;
64+
Set<Number> numbers = new HashSet<>();
65+
Set<Integer> values = new HashSet<>();
66+
values.add(value);
67+
Consumer<Set<? super Number>> onlyAddAllValues = SetX.onlyAddAll(values);
68+
onlyAddAllValues.accept(numbers);
69+
assertTrue(numbers.containsAll(values));
70+
}
71+
72+
@Test
73+
public void checkRemove() {
74+
int value = 7;
75+
Set<Number> numbers = new HashSet<>();
76+
numbers.add(value);
77+
Predicate<Set<? super Number>> removeValue = SetX.remove(value);
78+
assertTrue(removeValue.test(numbers));
79+
}
80+
81+
@Test
82+
public void checkRemoveAll() {
83+
int value = 8;
84+
Set<Number> numbers = new HashSet<>();
85+
numbers.add(value);
86+
Set<Integer> values = new HashSet<>();
87+
values.add(value);
88+
Predicate<Set<? super Number>> removeAllValues = SetX.removeAll(values);
89+
assertTrue(removeAllValues.test(numbers));
90+
}
91+
92+
@Test
93+
public void checkOnlyRemove() {
94+
int value = 9;
95+
Set<Number> numbers = new HashSet<>();
96+
numbers.add(value);
97+
Consumer<Set<? super Number>> onlyRemoveValue = SetX.onlyRemove(value);
98+
onlyRemoveValue.accept(numbers);
99+
assertFalse(numbers.contains(value));
100+
}
101+
102+
@Test
103+
public void checkOnlyRemoveAll() {
104+
int value = 10;
105+
Set<Number> numbers = new HashSet<>();
106+
numbers.add(value);
107+
Set<Integer> values = new HashSet<>();
108+
values.add(value);
109+
Consumer<Set<? super Number>> removeAllValues = SetX.onlyRemoveAll(values);
110+
removeAllValues.accept(numbers);
111+
assertFalse(numbers.containsAll(values));
112+
}
113+
114+
@Test
115+
public void checkRetainAll() {
116+
int value = 11;
117+
Set<Number> numbers = new HashSet<>();
118+
numbers.add(value);
119+
Set<Integer> values = new HashSet<>();
120+
values.add(value);
121+
Predicate<Set<? super Number>> retainAllValues = SetX.retainAll(values);
122+
assertFalse(retainAllValues.test(numbers));
123+
}
124+
125+
@Test
126+
public void checkOnlyRetainAll() {
127+
int value = 12;
128+
Set<Number> numbers = new HashSet<>();
129+
numbers.add(value);
130+
Set<Integer> values = new HashSet<>();
131+
values.add(value);
132+
Consumer<Set<? super Number>> onlyRetainAllValues = SetX.onlyRetainAll(values);
133+
onlyRetainAllValues.accept(numbers);
134+
assertTrue(numbers.containsAll(values));
135+
}
136+
137+
@Test
138+
public void checkToArray() {
139+
int value = 13;
140+
Set<Number> numbers = new HashSet<>();
141+
numbers.add(value);
142+
Function<Set<? extends Number>, ? extends Number[]> toIntegerArray = SetX.toArray(new Integer[0]);
143+
assertArrayEquals(new Integer[]{value}, toIntegerArray.apply(numbers));
144+
}
145+
146+
@Test
147+
public void checkToArrayWithGenerator() {
148+
int value = 14;
149+
Set<Number> numbers = new HashSet<>();
150+
numbers.add(value);
151+
Function<Set<? extends Number>, ? extends Number[]> toIntegerArray = SetX.toArray(Integer[]::new);
152+
assertArrayEquals(new Integer[]{value}, toIntegerArray.apply(numbers));
153+
}
154+
155+
@Test
156+
public void checkEquals() {
157+
int value = 15;
158+
Set<Number> numbers = new HashSet<>();
159+
numbers.add(value);
160+
Set<Integer> values = new HashSet<>();
161+
values.add(value);
162+
Predicate<Set<? extends Number>> equalsToValues = SetX.equalsTo(values);
163+
assertTrue(equalsToValues.test(numbers));
164+
}
165+
}

0 commit comments

Comments
 (0)