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