1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17 package org.apache.commons.collections4;
18
19 import static org.junit.jupiter.api.Assertions.assertEquals;
20 import static org.junit.jupiter.api.Assertions.assertNotNull;
21 import static org.junit.jupiter.api.Assertions.assertNull;
22 import static org.junit.jupiter.api.Assertions.assertSame;
23 import static org.junit.jupiter.api.Assertions.assertThrows;
24
25 import java.io.IOException;
26 import java.util.ArrayList;
27 import java.util.Collection;
28 import java.util.Collections;
29 import java.util.Date;
30 import java.util.HashMap;
31 import java.util.List;
32 import java.util.Map;
33
34 import org.apache.commons.collections4.functors.ConstantTransformer;
35 import org.apache.commons.collections4.functors.EqualPredicate;
36 import org.apache.commons.collections4.functors.ExceptionTransformer;
37 import org.apache.commons.collections4.functors.FalsePredicate;
38 import org.apache.commons.collections4.functors.NOPTransformer;
39 import org.apache.commons.collections4.functors.StringValueTransformer;
40 import org.apache.commons.collections4.functors.TruePredicate;
41 import org.apache.commons.lang3.StringUtils;
42 import org.junit.jupiter.api.Test;
43
44
45
46
47 public class TransformerUtilsTest {
48
49 private static final Object cObject = new Object();
50 private static final Object cString = "Hello";
51 private static final Object cInteger = Integer.valueOf(6);
52
53 @Test
54 @SuppressWarnings("unchecked")
55 public void testChainedTransformer() {
56 final Transformer<Object, Object> a = TransformerUtils.<Object, Object>constantTransformer("A");
57 final Transformer<Object, Object> b = TransformerUtils.constantTransformer((Object) "B");
58 assertEquals("A", TransformerUtils.chainedTransformer(b, a).apply(null));
59 assertEquals("B", TransformerUtils.chainedTransformer(a, b).apply(null));
60 assertEquals("A", TransformerUtils.chainedTransformer(b, a).apply(null));
61 assertEquals("A", TransformerUtils.chainedTransformer(b, a).transform(null));
62 assertEquals("B", TransformerUtils.chainedTransformer(a, b).transform(null));
63 assertEquals("A", TransformerUtils.chainedTransformer(b, a).transform(null));
64 final Collection<Transformer<Object, Object>> coll = new ArrayList<>();
65 coll.add(b);
66 coll.add(a);
67 assertEquals("A", TransformerUtils.chainedTransformer(coll).transform(null));
68 assertSame(NOPTransformer.INSTANCE, TransformerUtils.chainedTransformer());
69 assertSame(NOPTransformer.INSTANCE, TransformerUtils.chainedTransformer(Collections.<Transformer<Object, Object>>emptyList()));
70 assertThrows(NullPointerException.class, () -> TransformerUtils.chainedTransformer(null, null));
71 assertThrows(NullPointerException.class, () -> TransformerUtils.chainedTransformer((Transformer[]) null));
72 assertThrows(NullPointerException.class, () -> TransformerUtils.chainedTransformer((Collection<Transformer<Object, Object>>) null));
73 assertThrows(NullPointerException.class, () -> TransformerUtils.chainedTransformer(null, null));
74 assertThrows(NullPointerException.class, () -> {
75 final Collection<Transformer<Object, Object>> coll1 = new ArrayList<>();
76 coll1.add(null);
77 coll1.add(null);
78 TransformerUtils.chainedTransformer(coll1);
79 });
80 }
81
82 @Test
83 public void testCloneTransformer() {
84 assertNull(TransformerUtils.cloneTransformer().transform(null));
85 assertEquals(cString, TransformerUtils.cloneTransformer().transform(cString));
86 assertEquals(cInteger, TransformerUtils.cloneTransformer().transform(cInteger));
87
88 assertThrows(IllegalArgumentException.class, () -> assertEquals(cObject, TransformerUtils.cloneTransformer().transform(cObject)));
89 }
90
91 @Test
92 public void testConstantTransformer() {
93 assertEquals(cObject, TransformerUtils.constantTransformer(cObject).transform(null));
94 assertEquals(cObject, TransformerUtils.constantTransformer(cObject).transform(cObject));
95 assertEquals(cObject, TransformerUtils.constantTransformer(cObject).transform(cString));
96 assertEquals(cObject, TransformerUtils.constantTransformer(cObject).transform(cInteger));
97 assertSame(ConstantTransformer.NULL_INSTANCE, TransformerUtils.constantTransformer(null));
98 }
99
100 @Test
101 public void testExceptionTransformer() {
102 assertNotNull(TransformerUtils.exceptionTransformer());
103 assertSame(TransformerUtils.exceptionTransformer(), TransformerUtils.exceptionTransformer());
104 assertThrows(FunctorException.class, () -> TransformerUtils.exceptionTransformer().transform(null));
105 assertThrows(FunctorException.class, () -> TransformerUtils.exceptionTransformer().transform(cString));
106 }
107
108 @Test
109 public void testExecutorTransformer() {
110 assertNull(TransformerUtils.asTransformer(ClosureUtils.nopClosure()).transform(null));
111 assertEquals(cObject, TransformerUtils.asTransformer(ClosureUtils.nopClosure()).transform(cObject));
112 assertEquals(cString, TransformerUtils.asTransformer(ClosureUtils.nopClosure()).transform(cString));
113 assertEquals(cInteger, TransformerUtils.asTransformer(ClosureUtils.nopClosure()).transform(cInteger));
114
115 assertThrows(NullPointerException.class, () -> TransformerUtils.asTransformer((Closure<Object>) null));
116 }
117
118 @Test
119 public void testFactoryTransformer() {
120 assertNull(TransformerUtils.asTransformer(FactoryUtils.nullFactory()).transform(null));
121 assertNull(TransformerUtils.asTransformer(FactoryUtils.nullFactory()).transform(cObject));
122 assertNull(TransformerUtils.asTransformer(FactoryUtils.nullFactory()).transform(cString));
123 assertNull(TransformerUtils.asTransformer(FactoryUtils.nullFactory()).transform(cInteger));
124
125 assertThrows(NullPointerException.class, () -> TransformerUtils.asTransformer((Factory<Object>) null));
126 }
127
128 @Test
129 public void testIfTransformer() {
130 final Transformer<Object, String> a = TransformerUtils.constantTransformer("A");
131 final Transformer<Object, String> b = TransformerUtils.constantTransformer("B");
132 final Transformer<Object, String> c = TransformerUtils.constantTransformer("C");
133
134 assertEquals("A", TransformerUtils.ifTransformer(TruePredicate.truePredicate(), a, b).transform(null));
135 assertEquals("B", TransformerUtils.ifTransformer(FalsePredicate.falsePredicate(), a, b).transform(null));
136
137 final Predicate<Integer> lessThanFivePredicate = value -> value < 5;
138
139 assertEquals("A", TransformerUtils.ifTransformer(lessThanFivePredicate, a, b).transform(1));
140 assertEquals("B", TransformerUtils.ifTransformer(lessThanFivePredicate, a, b).transform(5));
141
142
143 final Predicate<String> equalsAPredicate = EqualPredicate.equalPredicate("A");
144 assertEquals("C", TransformerUtils.ifTransformer(equalsAPredicate, c).transform("A"));
145 assertEquals("B", TransformerUtils.ifTransformer(equalsAPredicate, c).transform("B"));
146
147 assertThrows(NullPointerException.class, () -> TransformerUtils.ifTransformer(null, null));
148 assertThrows(NullPointerException.class, () -> TransformerUtils.ifTransformer(TruePredicate.truePredicate(), null));
149 assertThrows(NullPointerException.class, () -> TransformerUtils.ifTransformer(null, ConstantTransformer.constantTransformer("A")));
150 assertThrows(NullPointerException.class, () -> TransformerUtils.ifTransformer(null, null, null));
151 }
152
153 @Test
154 public void testInstantiateTransformerNull() {
155 assertThrows(IllegalArgumentException.class, () -> TransformerUtils.instantiateTransformer(null, new Object[] { "str" }));
156 assertThrows(IllegalArgumentException.class, () -> TransformerUtils.instantiateTransformer(new Class[] {}, new Object[] { "str" }));
157 Transformer<Class<?>, Object> trans = TransformerUtils.instantiateTransformer(new Class[] { Long.class }, new Object[] { null });
158
159 final Transformer<Class<?>, Object> finalTrans = trans;
160 assertThrows(FunctorException.class, () -> finalTrans.transform(String.class));
161
162 trans = TransformerUtils.instantiateTransformer();
163 assertEquals(StringUtils.EMPTY, trans.transform(String.class));
164
165 trans = TransformerUtils.instantiateTransformer(new Class[] { Long.TYPE }, new Object[] {1000L});
166 assertEquals(new Date(1000L), trans.transform(Date.class));
167 }
168
169 @Test
170 public void testInvokerTransformer() {
171 final List<Object> list = new ArrayList<>();
172 assertEquals(0, TransformerUtils.invokerTransformer("size").transform(list));
173 list.add(new Object());
174 assertEquals(1, TransformerUtils.invokerTransformer("size").transform(list));
175 assertNull(TransformerUtils.invokerTransformer("size").transform(null));
176 assertThrows(NullPointerException.class, () -> TransformerUtils.invokerTransformer(null));
177 assertThrows(FunctorException.class, () -> TransformerUtils.invokerTransformer("noSuchMethod").transform(new Object()));
178 }
179
180 @Test
181 public void testInvokerTransformer2() {
182 final List<Object> list = new ArrayList<>();
183 assertEquals(Boolean.FALSE, TransformerUtils.invokerTransformer("contains", new Class[] { Object.class }, new Object[] { cString }).transform(list));
184 list.add(cString);
185 assertEquals(Boolean.TRUE, TransformerUtils.invokerTransformer("contains", new Class[] { Object.class }, new Object[] { cString }).transform(list));
186 assertNull(TransformerUtils.invokerTransformer("contains", new Class[] { Object.class }, new Object[] { cString }).transform(null));
187 assertThrows(NullPointerException.class, () -> TransformerUtils.invokerTransformer(null, null, null));
188 assertThrows(FunctorException.class,
189 () -> TransformerUtils.invokerTransformer("noSuchMethod", new Class[] { Object.class }, new Object[] { cString }).transform(new Object()));
190 assertThrows(IllegalArgumentException.class, () -> TransformerUtils.invokerTransformer("badArgs", null, new Object[] { cString }));
191 assertThrows(IllegalArgumentException.class, () -> TransformerUtils.invokerTransformer("badArgs", new Class[] { Object.class }, null));
192 assertThrows(IllegalArgumentException.class, () -> TransformerUtils.invokerTransformer("badArgs", new Class[] {}, new Object[] { cString }));
193 }
194
195 @Test
196 @SuppressWarnings("boxing")
197 public void testMapTransformer() {
198 final Map<Object, Integer> map = new HashMap<>();
199 map.put(null, 0);
200 map.put(cObject, 1);
201 map.put(cString, 2);
202 assertEquals(Integer.valueOf(0), TransformerUtils.mapTransformer(map).transform(null));
203 assertEquals(Integer.valueOf(1), TransformerUtils.mapTransformer(map).transform(cObject));
204 assertEquals(Integer.valueOf(2), TransformerUtils.mapTransformer(map).transform(cString));
205 assertNull(TransformerUtils.mapTransformer(map).transform(cInteger));
206 assertSame(ConstantTransformer.NULL_INSTANCE, TransformerUtils.mapTransformer(null));
207 }
208
209 @Test
210 public void testNopTransformer() {
211 assertNotNull(TransformerUtils.nullTransformer());
212 assertSame(TransformerUtils.nullTransformer(), TransformerUtils.nullTransformer());
213 assertNull(TransformerUtils.nopTransformer().transform(null));
214 assertEquals(cObject, TransformerUtils.nopTransformer().transform(cObject));
215 assertEquals(cString, TransformerUtils.nopTransformer().transform(cString));
216 assertEquals(cInteger, TransformerUtils.nopTransformer().transform(cInteger));
217 }
218
219 @Test
220 public void testNullTransformer() {
221 assertNotNull(TransformerUtils.nullTransformer());
222 assertSame(TransformerUtils.nullTransformer(), TransformerUtils.nullTransformer());
223 assertNull(TransformerUtils.nullTransformer().transform(null));
224 assertNull(TransformerUtils.nullTransformer().transform(cObject));
225 assertNull(TransformerUtils.nullTransformer().transform(cString));
226 assertNull(TransformerUtils.nullTransformer().transform(cInteger));
227 }
228
229 @Test
230 public void testPredicateTransformer() {
231 assertEquals(Boolean.TRUE, TransformerUtils.asTransformer(TruePredicate.truePredicate()).transform(null));
232 assertEquals(Boolean.TRUE, TransformerUtils.asTransformer(TruePredicate.truePredicate()).transform(cObject));
233 assertEquals(Boolean.TRUE, TransformerUtils.asTransformer(TruePredicate.truePredicate()).transform(cString));
234 assertEquals(Boolean.TRUE, TransformerUtils.asTransformer(TruePredicate.truePredicate()).transform(cInteger));
235
236 assertThrows(IllegalArgumentException.class, () -> TransformerUtils.asTransformer((Predicate<Object>) null));
237 }
238
239
240
241
242
243 @Test
244 public void testSingletonPatternInSerialization() throws ClassNotFoundException, IOException {
245 final Object[] singletons = {
246 ExceptionTransformer.INSTANCE,
247 NOPTransformer.INSTANCE,
248 StringValueTransformer.stringValueTransformer(),
249 };
250
251 for (final Object original : singletons) {
252 TestUtils.assertSameAfterSerialization("Singleton pattern broken for " + original.getClass(), original);
253 }
254 }
255
256 @Test
257 public void testStringValueTransformer() {
258 assertNotNull("StringValueTransformer should NEVER return a null value.", TransformerUtils.stringValueTransformer().transform(null));
259 assertEquals("null", TransformerUtils.stringValueTransformer().transform(null),
260 "StringValueTransformer should return \"null\" when given a null argument.");
261 assertEquals("6", TransformerUtils.stringValueTransformer().transform(6), "StringValueTransformer should return toString value");
262 }
263
264 @Test
265 public void testSwitchMapTransformer() {
266 final Transformer<String, String> a = TransformerUtils.constantTransformer("A");
267 final Transformer<String, String> b = TransformerUtils.constantTransformer("B");
268 final Transformer<String, String> c = TransformerUtils.constantTransformer("C");
269
270 Map<String, Transformer<String, String>> map = new HashMap<>();
271 map.put("HELLO", a);
272 map.put("THERE", b);
273 assertNull(TransformerUtils.switchMapTransformer(map).transform("WELL"));
274 assertEquals("A", TransformerUtils.switchMapTransformer(map).transform("HELLO"));
275 assertEquals("B", TransformerUtils.switchMapTransformer(map).transform("THERE"));
276 map.put(null, c);
277 assertEquals("C", TransformerUtils.switchMapTransformer(map).transform("WELL"));
278
279 assertSame(ConstantTransformer.NULL_INSTANCE, TransformerUtils.switchMapTransformer(new HashMap<>()));
280 map = new HashMap<>();
281 map.put(null, null);
282 assertSame(ConstantTransformer.NULL_INSTANCE, TransformerUtils.switchMapTransformer(map));
283
284 assertThrows(NullPointerException.class, () -> TransformerUtils.switchMapTransformer(null));
285 }
286
287 @Test
288 @SuppressWarnings("unchecked")
289 public void testSwitchTransformer() {
290 final Transformer<String, String> a = TransformerUtils.constantTransformer("A");
291 final Transformer<String, String> b = TransformerUtils.constantTransformer("B");
292 final Transformer<String, String> c = TransformerUtils.constantTransformer("C");
293
294 assertEquals("A", TransformerUtils.switchTransformer(TruePredicate.truePredicate(), a, b).transform(null));
295 assertEquals("B", TransformerUtils.switchTransformer(FalsePredicate.falsePredicate(), a, b).transform(null));
296
297 assertNull(TransformerUtils.<Object, String>switchTransformer(
298 new Predicate[]{EqualPredicate.equalPredicate("HELLO"), EqualPredicate.equalPredicate("THERE")},
299 new Transformer[]{a, b}).transform("WELL"));
300 assertEquals("A", TransformerUtils.switchTransformer(
301 new Predicate[] { EqualPredicate.equalPredicate("HELLO"), EqualPredicate.equalPredicate("THERE") },
302 new Transformer[] { a, b }).transform("HELLO"));
303 assertEquals("B", TransformerUtils.switchTransformer(
304 new Predicate[] { EqualPredicate.equalPredicate("HELLO"), EqualPredicate.equalPredicate("THERE") },
305 new Transformer[] { a, b }).transform("THERE"));
306
307 assertEquals("C", TransformerUtils.switchTransformer(
308 new Predicate[] { EqualPredicate.equalPredicate("HELLO"), EqualPredicate.equalPredicate("THERE") },
309 new Transformer[] { a, b }, c).transform("WELL"));
310
311 Map<Predicate<String>, Transformer<String, String>> map = new HashMap<>();
312 map.put(EqualPredicate.equalPredicate("HELLO"), a);
313 map.put(EqualPredicate.equalPredicate("THERE"), b);
314 assertNull(TransformerUtils.switchTransformer(map).transform("WELL"));
315 assertEquals("A", TransformerUtils.switchTransformer(map).transform("HELLO"));
316 assertEquals("B", TransformerUtils.switchTransformer(map).transform("THERE"));
317 map.put(null, c);
318 assertEquals("C", TransformerUtils.switchTransformer(map).transform("WELL"));
319
320 assertEquals(ConstantTransformer.NULL_INSTANCE, TransformerUtils.switchTransformer(new Predicate[0], new Transformer[0]));
321 assertEquals(ConstantTransformer.NULL_INSTANCE, TransformerUtils.switchTransformer(new HashMap<>()));
322 map = new HashMap<>();
323 map.put(null, null);
324 assertEquals(ConstantTransformer.NULL_INSTANCE, TransformerUtils.switchTransformer(map));
325
326 assertThrows(NullPointerException.class, () -> TransformerUtils.switchTransformer(null, null));
327 assertThrows(NullPointerException.class, () -> TransformerUtils.switchTransformer(null, (Transformer[]) null));
328 assertThrows(NullPointerException.class, () -> TransformerUtils.switchTransformer(null));
329 assertThrows(NullPointerException.class, () -> TransformerUtils.switchTransformer(new Predicate[2], new Transformer[2]));
330 assertThrows(IllegalArgumentException.class,
331 () -> TransformerUtils.switchTransformer(new Predicate[] { TruePredicate.truePredicate() }, new Transformer[] { a, b }));
332 }
333
334 }