1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17 package org.apache.commons.lang3.reflect;
18
19 import static org.junit.jupiter.api.Assertions.assertArrayEquals;
20 import static org.junit.jupiter.api.Assertions.assertEquals;
21 import static org.junit.jupiter.api.Assertions.assertFalse;
22 import static org.junit.jupiter.api.Assertions.assertNotNull;
23 import static org.junit.jupiter.api.Assertions.assertNull;
24 import static org.junit.jupiter.api.Assertions.assertThrows;
25 import static org.junit.jupiter.api.Assertions.assertTrue;
26 import static org.junit.jupiter.api.Assertions.fail;
27 import static org.junit.jupiter.api.Assumptions.assumeTrue;
28
29 import java.lang.reflect.Constructor;
30 import java.lang.reflect.Field;
31 import java.lang.reflect.Modifier;
32 import java.util.ArrayList;
33 import java.util.Arrays;
34 import java.util.HashSet;
35 import java.util.List;
36
37 import org.apache.commons.lang3.AbstractLangTest;
38 import org.apache.commons.lang3.ArraySorter;
39 import org.apache.commons.lang3.ArrayUtils;
40 import org.apache.commons.lang3.JavaVersion;
41 import org.apache.commons.lang3.SystemUtils;
42 import org.apache.commons.lang3.compare.ObjectToStringComparator;
43 import org.apache.commons.lang3.reflect.testbed.Ambig;
44 import org.apache.commons.lang3.reflect.testbed.Annotated;
45 import org.apache.commons.lang3.reflect.testbed.Foo;
46 import org.apache.commons.lang3.reflect.testbed.PrivatelyShadowedChild;
47 import org.apache.commons.lang3.reflect.testbed.PublicChild;
48 import org.apache.commons.lang3.reflect.testbed.PubliclyShadowedChild;
49 import org.apache.commons.lang3.reflect.testbed.StaticContainer;
50 import org.apache.commons.lang3.reflect.testbed.StaticContainerChild;
51 import org.junit.jupiter.api.BeforeEach;
52 import org.junit.jupiter.api.Test;
53
54
55
56
57 public class FieldUtilsTest extends AbstractLangTest {
58
59 private static final String JACOCO_DATA_FIELD_NAME = "$jacocoData";
60 static final Integer I0 = Integer.valueOf(0);
61 static final Integer I1 = Integer.valueOf(1);
62 static final Double D0 = Double.valueOf(0.0);
63 static final Double D1 = Double.valueOf(1.0);
64
65 @Annotated
66 private PublicChild publicChild;
67 private PubliclyShadowedChild publiclyShadowedChild;
68 @Annotated
69 private PrivatelyShadowedChild privatelyShadowedChild;
70 private final Class<? super PublicChild> parentClass = PublicChild.class.getSuperclass();
71
72
73
74
75
76
77
78
79
80
81 private void callRemoveFinalModifierCheckForException(final Field field, final Boolean forceAccess) {
82 try {
83 FieldUtils.removeFinalModifier(field, forceAccess);
84 } catch (final UnsupportedOperationException exception) {
85 if (SystemUtils.isJavaVersionAtLeast(JavaVersion.JAVA_12)) {
86 assertTrue(exception.getCause() instanceof NoSuchFieldException);
87 } else {
88 fail("No exception should be thrown for java prior to 12.0");
89 }
90 }
91 }
92
93 @BeforeEach
94 public void setUp() {
95 StaticContainer.reset();
96 publicChild = new PublicChild();
97 publiclyShadowedChild = new PubliclyShadowedChild();
98 privatelyShadowedChild = new PrivatelyShadowedChild();
99 }
100
101 private Field[] sort(final Field[] fields) {
102
103 return ArraySorter.sort(fields, ObjectToStringComparator.INSTANCE);
104 }
105
106 @Test
107 public void testAmbig() {
108 assertThrows(IllegalArgumentException.class, () -> FieldUtils.getField(Ambig.class, "VALUE"));
109 }
110
111 @Test
112 public void testConstructor() {
113 assertNotNull(new FieldUtils());
114 final Constructor<?>[] cons = FieldUtils.class.getDeclaredConstructors();
115 assertEquals(1, cons.length);
116 assertTrue(Modifier.isPublic(cons[0].getModifiers()));
117 assertTrue(Modifier.isPublic(FieldUtils.class.getModifiers()));
118 assertFalse(Modifier.isFinal(FieldUtils.class.getModifiers()));
119 }
120
121 @Test
122 public void testGetAllFieldListsNullPointerException() {
123 assertThrows(NullPointerException.class, () -> FieldUtils.getAllFieldsList(null));
124 }
125
126 @Test
127 public void testGetAllFields() {
128 assertArrayEquals(new Field[0], FieldUtils.getAllFields(Object.class));
129 final Field[] fieldsNumber = sort(Number.class.getDeclaredFields());
130 assertArrayEquals(fieldsNumber, sort(FieldUtils.getAllFields(Number.class)));
131 final Field[] fieldsInteger = Integer.class.getDeclaredFields();
132 assertArrayEquals(sort(ArrayUtils.addAll(fieldsInteger, fieldsNumber)), sort(FieldUtils.getAllFields(Integer.class)));
133 final Field[] allFields = FieldUtils.getAllFields(PublicChild.class);
134
135 int expected = 5;
136 for (final Field field : allFields) {
137 if (field.getName().equals(JACOCO_DATA_FIELD_NAME)) {
138 expected++;
139 }
140 }
141 assertEquals(expected, allFields.length, Arrays.toString(allFields));
142 }
143
144 @Test
145 public void testGetAllFieldsList() {
146 assertEquals(0, FieldUtils.getAllFieldsList(Object.class).size());
147 final List<Field> fieldsNumber = Arrays.asList(Number.class.getDeclaredFields());
148 assertEquals(fieldsNumber, FieldUtils.getAllFieldsList(Number.class));
149 final List<Field> fieldsInteger = Arrays.asList(Integer.class.getDeclaredFields());
150 final List<Field> allFieldsInteger = new ArrayList<>(fieldsInteger);
151 allFieldsInteger.addAll(fieldsNumber);
152 assertEquals(new HashSet<>(allFieldsInteger), new HashSet<>(FieldUtils.getAllFieldsList(Integer.class)));
153 final List<Field> allFields = FieldUtils.getAllFieldsList(PublicChild.class);
154
155 int expected = 5;
156 for (final Field field : allFields) {
157 if (field.getName().equals(JACOCO_DATA_FIELD_NAME)) {
158 expected++;
159 }
160 }
161 assertEquals(expected, allFields.size(), allFields.toString());
162
163 }
164
165 @Test
166 public void testGetAllFieldsNullPointerException() {
167 assertThrows(NullPointerException.class, () -> FieldUtils.getAllFields(null));
168 }
169
170 @Test
171 public void testGetDeclaredField() {
172 assertNull(FieldUtils.getDeclaredField(PublicChild.class, "VALUE"));
173 assertNull(FieldUtils.getDeclaredField(PublicChild.class, "s"));
174 assertNull(FieldUtils.getDeclaredField(PublicChild.class, "b"));
175 assertNull(FieldUtils.getDeclaredField(PublicChild.class, "i"));
176 assertNull(FieldUtils.getDeclaredField(PublicChild.class, "d"));
177 assertNull(FieldUtils.getDeclaredField(PubliclyShadowedChild.class, "VALUE"));
178 assertEquals(PubliclyShadowedChild.class, FieldUtils.getDeclaredField(PubliclyShadowedChild.class, "s").getDeclaringClass());
179 assertEquals(PubliclyShadowedChild.class, FieldUtils.getDeclaredField(PubliclyShadowedChild.class, "b").getDeclaringClass());
180 assertEquals(PubliclyShadowedChild.class, FieldUtils.getDeclaredField(PubliclyShadowedChild.class, "i").getDeclaringClass());
181 assertEquals(PubliclyShadowedChild.class, FieldUtils.getDeclaredField(PubliclyShadowedChild.class, "d").getDeclaringClass());
182 assertNull(FieldUtils.getDeclaredField(PrivatelyShadowedChild.class, "VALUE"));
183 assertNull(FieldUtils.getDeclaredField(PrivatelyShadowedChild.class, "s"));
184 assertNull(FieldUtils.getDeclaredField(PrivatelyShadowedChild.class, "b"));
185 assertNull(FieldUtils.getDeclaredField(PrivatelyShadowedChild.class, "i"));
186 assertNull(FieldUtils.getDeclaredField(PrivatelyShadowedChild.class, "d"));
187 }
188
189 @Test
190 public void testGetDeclaredFieldAccessIllegalArgumentException1() {
191 assertThrows(IllegalArgumentException.class, () -> FieldUtils.getDeclaredField(PublicChild.class, null));
192 }
193
194 @Test
195 public void testGetDeclaredFieldAccessIllegalArgumentException2() {
196 assertThrows(IllegalArgumentException.class, () -> FieldUtils.getDeclaredField(PublicChild.class, ""));
197 }
198
199 @Test
200 public void testGetDeclaredFieldAccessIllegalArgumentException3() {
201 assertThrows(IllegalArgumentException.class, () -> FieldUtils.getDeclaredField(PublicChild.class, " "));
202 }
203
204 @Test
205 public void testGetDeclaredFieldAccessNullPointerException() {
206 assertThrows(NullPointerException.class, () -> FieldUtils.getDeclaredField(null, "none"));
207 }
208
209 @Test
210 public void testGetDeclaredFieldForceAccess() {
211 assertEquals(PublicChild.class, FieldUtils.getDeclaredField(PublicChild.class, "VALUE", true).getDeclaringClass());
212 assertNull(FieldUtils.getDeclaredField(PublicChild.class, "s", true));
213 assertNull(FieldUtils.getDeclaredField(PublicChild.class, "b", true));
214 assertNull(FieldUtils.getDeclaredField(PublicChild.class, "i", true));
215 assertNull(FieldUtils.getDeclaredField(PublicChild.class, "d", true));
216 assertNull(FieldUtils.getDeclaredField(PubliclyShadowedChild.class, "VALUE", true));
217 assertEquals(PubliclyShadowedChild.class, FieldUtils.getDeclaredField(PubliclyShadowedChild.class, "s", true).getDeclaringClass());
218 assertEquals(PubliclyShadowedChild.class, FieldUtils.getDeclaredField(PubliclyShadowedChild.class, "b", true).getDeclaringClass());
219 assertEquals(PubliclyShadowedChild.class, FieldUtils.getDeclaredField(PubliclyShadowedChild.class, "i", true).getDeclaringClass());
220 assertEquals(PubliclyShadowedChild.class, FieldUtils.getDeclaredField(PubliclyShadowedChild.class, "d", true).getDeclaringClass());
221 assertNull(FieldUtils.getDeclaredField(PrivatelyShadowedChild.class, "VALUE", true));
222 assertEquals(PrivatelyShadowedChild.class, FieldUtils.getDeclaredField(PrivatelyShadowedChild.class, "s", true).getDeclaringClass());
223 assertEquals(PrivatelyShadowedChild.class, FieldUtils.getDeclaredField(PrivatelyShadowedChild.class, "b", true).getDeclaringClass());
224 assertEquals(PrivatelyShadowedChild.class, FieldUtils.getDeclaredField(PrivatelyShadowedChild.class, "i", true).getDeclaringClass());
225 assertEquals(PrivatelyShadowedChild.class, FieldUtils.getDeclaredField(PrivatelyShadowedChild.class, "d", true).getDeclaringClass());
226 }
227
228 @Test
229 public void testGetDeclaredFieldForceAccessIllegalArgumentException1() {
230 assertThrows(IllegalArgumentException.class, () -> FieldUtils.getDeclaredField(PublicChild.class, null, true));
231 }
232
233 @Test
234 public void testGetDeclaredFieldForceAccessIllegalArgumentException2() {
235 assertThrows(IllegalArgumentException.class, () -> FieldUtils.getDeclaredField(PublicChild.class, "", true));
236 }
237
238 @Test
239 public void testGetDeclaredFieldForceAccessIllegalArgumentException3() {
240 assertThrows(IllegalArgumentException.class, () -> FieldUtils.getDeclaredField(PublicChild.class, " ", true));
241 }
242
243 @Test
244 public void testGetDeclaredFieldForceAccessNullPointerException() {
245 assertThrows(NullPointerException.class, () -> FieldUtils.getDeclaredField(null, "none", true));
246 }
247
248 @Test
249 public void testGetField() {
250 assertEquals(Foo.class, FieldUtils.getField(PublicChild.class, "VALUE").getDeclaringClass());
251 assertEquals(parentClass, FieldUtils.getField(PublicChild.class, "s").getDeclaringClass());
252 assertNull(FieldUtils.getField(PublicChild.class, "b"));
253 assertNull(FieldUtils.getField(PublicChild.class, "i"));
254 assertNull(FieldUtils.getField(PublicChild.class, "d"));
255 assertEquals(Foo.class, FieldUtils.getField(PubliclyShadowedChild.class, "VALUE").getDeclaringClass());
256 assertEquals(PubliclyShadowedChild.class, FieldUtils.getField(PubliclyShadowedChild.class, "s").getDeclaringClass());
257 assertEquals(PubliclyShadowedChild.class, FieldUtils.getField(PubliclyShadowedChild.class, "b").getDeclaringClass());
258 assertEquals(PubliclyShadowedChild.class, FieldUtils.getField(PubliclyShadowedChild.class, "i").getDeclaringClass());
259 assertEquals(PubliclyShadowedChild.class, FieldUtils.getField(PubliclyShadowedChild.class, "d").getDeclaringClass());
260 assertEquals(Foo.class, FieldUtils.getField(PrivatelyShadowedChild.class, "VALUE").getDeclaringClass());
261 assertEquals(parentClass, FieldUtils.getField(PrivatelyShadowedChild.class, "s").getDeclaringClass());
262 assertNull(FieldUtils.getField(PrivatelyShadowedChild.class, "b"));
263 assertNull(FieldUtils.getField(PrivatelyShadowedChild.class, "i"));
264 assertNull(FieldUtils.getField(PrivatelyShadowedChild.class, "d"));
265 }
266
267 @Test
268 public void testGetFieldForceAccess() {
269 assertEquals(PublicChild.class, FieldUtils.getField(PublicChild.class, "VALUE", true).getDeclaringClass());
270 assertEquals(parentClass, FieldUtils.getField(PublicChild.class, "s", true).getDeclaringClass());
271 assertEquals(parentClass, FieldUtils.getField(PublicChild.class, "b", true).getDeclaringClass());
272 assertEquals(parentClass, FieldUtils.getField(PublicChild.class, "i", true).getDeclaringClass());
273 assertEquals(parentClass, FieldUtils.getField(PublicChild.class, "d", true).getDeclaringClass());
274 assertEquals(Foo.class, FieldUtils.getField(PubliclyShadowedChild.class, "VALUE", true).getDeclaringClass());
275 assertEquals(PubliclyShadowedChild.class, FieldUtils.getField(PubliclyShadowedChild.class, "s", true).getDeclaringClass());
276 assertEquals(PubliclyShadowedChild.class, FieldUtils.getField(PubliclyShadowedChild.class, "b", true).getDeclaringClass());
277 assertEquals(PubliclyShadowedChild.class, FieldUtils.getField(PubliclyShadowedChild.class, "i", true).getDeclaringClass());
278 assertEquals(PubliclyShadowedChild.class, FieldUtils.getField(PubliclyShadowedChild.class, "d", true).getDeclaringClass());
279 assertEquals(Foo.class, FieldUtils.getField(PrivatelyShadowedChild.class, "VALUE", true).getDeclaringClass());
280 assertEquals(PrivatelyShadowedChild.class, FieldUtils.getField(PrivatelyShadowedChild.class, "s", true).getDeclaringClass());
281 assertEquals(PrivatelyShadowedChild.class, FieldUtils.getField(PrivatelyShadowedChild.class, "b", true).getDeclaringClass());
282 assertEquals(PrivatelyShadowedChild.class, FieldUtils.getField(PrivatelyShadowedChild.class, "i", true).getDeclaringClass());
283 assertEquals(PrivatelyShadowedChild.class, FieldUtils.getField(PrivatelyShadowedChild.class, "d", true).getDeclaringClass());
284 }
285
286 @Test
287 public void testGetFieldForceAccessIllegalArgumentException1() {
288 assertThrows(IllegalArgumentException.class, () -> FieldUtils.getField(PublicChild.class, null, true));
289 }
290
291 @Test
292 public void testGetFieldForceAccessIllegalArgumentException2() {
293 assertThrows(IllegalArgumentException.class, () -> FieldUtils.getField(PublicChild.class, "", true));
294 }
295
296 @Test
297 public void testGetFieldForceAccessIllegalArgumentException3() {
298 assertThrows(IllegalArgumentException.class, () -> FieldUtils.getField(PublicChild.class, " ", true));
299 }
300
301 @Test
302 public void testGetFieldForceAccessNullPointerException() {
303 assertThrows(NullPointerException.class, () -> FieldUtils.getField(null, "none", true));
304 }
305
306 @Test
307 public void testGetFieldIllegalArgumentException1() {
308 assertThrows(IllegalArgumentException.class, () -> FieldUtils.getField(PublicChild.class, null));
309 }
310
311 @Test
312 public void testGetFieldIllegalArgumentException2() {
313 assertThrows(IllegalArgumentException.class, () -> FieldUtils.getField(PublicChild.class, ""));
314 }
315
316 @Test
317 public void testGetFieldIllegalArgumentException3() {
318 assertThrows(IllegalArgumentException.class, () -> FieldUtils.getField(PublicChild.class, " "));
319 }
320
321 @Test
322 public void testGetFieldNullPointerException() {
323 assertThrows(NullPointerException.class, () -> FieldUtils.getField(null, "none"));
324 }
325
326 @Test
327 public void testGetFieldsListWithAnnotation() throws NoSuchFieldException {
328 assertEquals(0, FieldUtils.getFieldsListWithAnnotation(Object.class, Annotated.class).size());
329 final List<Field> annotatedFields = Arrays.asList(
330 FieldUtilsTest.class.getDeclaredField("publicChild"),
331 FieldUtilsTest.class.getDeclaredField("privatelyShadowedChild")
332 );
333 final List<Field> fieldUtilsTestAnnotatedFields = FieldUtils.getFieldsListWithAnnotation(FieldUtilsTest.class, Annotated.class);
334 assertEquals(annotatedFields.size(), fieldUtilsTestAnnotatedFields.size());
335 assertTrue(fieldUtilsTestAnnotatedFields.contains(annotatedFields.get(0)));
336 assertTrue(fieldUtilsTestAnnotatedFields.contains(annotatedFields.get(1)));
337 }
338
339 @Test
340 public void testGetFieldsListWithAnnotationNullPointerException() {
341 assertThrows(NullPointerException.class, () -> FieldUtils.getFieldsListWithAnnotation(FieldUtilsTest.class, null));
342 }
343
344 @Test
345 public void testGetFieldsListWithAnnotationNullPointerException2() {
346 assertThrows(NullPointerException.class, () -> FieldUtils.getFieldsListWithAnnotation(null, Annotated.class));
347 }
348
349 @Test
350 public void testGetFieldsListWithAnnotationNullPointerException3() {
351 assertThrows(NullPointerException.class, () -> FieldUtils.getFieldsListWithAnnotation(null, null));
352 }
353
354 @Test
355 public void testGetFieldsWithAnnotation() throws NoSuchFieldException {
356 assertArrayEquals(new Field[0], FieldUtils.getFieldsWithAnnotation(Object.class, Annotated.class));
357 final Field[] annotatedFields = sort(new Field[] {
358 FieldUtilsTest.class.getDeclaredField("publicChild"),
359 FieldUtilsTest.class.getDeclaredField("privatelyShadowedChild") });
360 assertArrayEquals(annotatedFields,
361 sort(FieldUtils.getFieldsWithAnnotation(FieldUtilsTest.class, Annotated.class)));
362 }
363
364 @Test
365 public void testGetFieldsWithAnnotationNullPointerException1() {
366 assertThrows(NullPointerException.class, () -> FieldUtils.getFieldsWithAnnotation(FieldUtilsTest.class, null));
367 }
368
369 @Test
370 public void testGetFieldsWithAnnotationNullPointerException2() {
371 assertThrows(NullPointerException.class, () -> FieldUtils.getFieldsWithAnnotation(null, Annotated.class));
372 }
373
374 @Test
375 public void testGetFieldsWithAnnotationNullPointerException3() {
376 assertThrows(NullPointerException.class, () -> FieldUtils.getFieldsWithAnnotation(null, null));
377 }
378
379 @Test
380 public void testReadDeclaredNamedField() throws Exception {
381 assertThrows(
382 IllegalArgumentException.class,
383 () -> FieldUtils.readDeclaredField(publicChild, null),
384 "a null field name should cause an IllegalArgumentException");
385
386 assertThrows(
387 IllegalArgumentException.class,
388 () -> FieldUtils.readDeclaredField(publicChild, ""),
389 "an empty field name should cause an IllegalArgumentException");
390
391 assertThrows(
392 IllegalArgumentException.class,
393 () -> FieldUtils.readDeclaredField(publicChild, " "),
394 "a blank field name should cause an IllegalArgumentException");
395
396 assertThrows(
397 NullPointerException.class,
398 () -> FieldUtils.readDeclaredField(null, "none"),
399 "a null target should cause an NullPointerException");
400
401 assertThrows(IllegalArgumentException.class, () -> FieldUtils.readDeclaredField(publicChild, "s"));
402 assertEquals("ss", FieldUtils.readDeclaredField(publiclyShadowedChild, "s"));
403 assertThrows(IllegalArgumentException.class, () -> FieldUtils.readDeclaredField(privatelyShadowedChild, "s"));
404 assertThrows(IllegalArgumentException.class, () -> FieldUtils.readDeclaredField(publicChild, "b"));
405 assertEquals(Boolean.TRUE, FieldUtils.readDeclaredField(publiclyShadowedChild, "b"));
406 assertThrows(IllegalArgumentException.class, () -> FieldUtils.readDeclaredField(privatelyShadowedChild, "b"));
407 assertThrows(IllegalArgumentException.class, () -> FieldUtils.readDeclaredField(publicChild, "i"));
408 assertEquals(I1, FieldUtils.readDeclaredField(publiclyShadowedChild, "i"));
409 assertThrows(IllegalArgumentException.class, () -> FieldUtils.readDeclaredField(privatelyShadowedChild, "i"));
410 assertThrows(IllegalArgumentException.class, () -> FieldUtils.readDeclaredField(publicChild, "d"));
411 assertEquals(D1, FieldUtils.readDeclaredField(publiclyShadowedChild, "d"));
412 assertThrows(IllegalArgumentException.class, () -> FieldUtils.readDeclaredField(privatelyShadowedChild, "d"));
413 }
414
415 @Test
416 public void testReadDeclaredNamedFieldForceAccess() throws Exception {
417 assertThrows(
418 IllegalArgumentException.class,
419 () -> FieldUtils.readDeclaredField(publicChild, null, true),
420 "a null field name should cause an IllegalArgumentException");
421
422 assertThrows(
423 IllegalArgumentException.class,
424 () -> FieldUtils.readDeclaredField(publicChild, "", true),
425 "an empty field name should cause an IllegalArgumentException");
426
427 assertThrows(
428 IllegalArgumentException.class,
429 () -> FieldUtils.readDeclaredField(publicChild, " ", true),
430 "a blank field name should cause an IllegalArgumentException");
431
432 assertThrows(
433 NullPointerException.class,
434 () -> FieldUtils.readDeclaredField(null, "none", true),
435 "a null target should cause an NullPointerException");
436
437 assertThrows(IllegalArgumentException.class, () -> FieldUtils.readDeclaredField(publicChild, "s", true));
438 assertEquals("ss", FieldUtils.readDeclaredField(publiclyShadowedChild, "s", true));
439 assertEquals("ss", FieldUtils.readDeclaredField(privatelyShadowedChild, "s", true));
440 assertThrows(IllegalArgumentException.class, () -> FieldUtils.readDeclaredField(publicChild, "b", true));
441 assertEquals(Boolean.TRUE, FieldUtils.readDeclaredField(publiclyShadowedChild, "b", true));
442 assertEquals(Boolean.TRUE, FieldUtils.readDeclaredField(privatelyShadowedChild, "b", true));
443 assertThrows(IllegalArgumentException.class, () -> FieldUtils.readDeclaredField(publicChild, "i", true));
444 assertEquals(I1, FieldUtils.readDeclaredField(publiclyShadowedChild, "i", true));
445 assertEquals(I1, FieldUtils.readDeclaredField(privatelyShadowedChild, "i", true));
446 assertThrows(IllegalArgumentException.class, () -> FieldUtils.readDeclaredField(publicChild, "d", true));
447 assertEquals(D1, FieldUtils.readDeclaredField(publiclyShadowedChild, "d", true));
448 assertEquals(D1, FieldUtils.readDeclaredField(privatelyShadowedChild, "d", true));
449 }
450
451 @Test
452 public void testReadDeclaredNamedStaticField() throws Exception {
453 assertEquals(Foo.VALUE, FieldUtils.readDeclaredStaticField(Foo.class, "VALUE"));
454 assertThrows(
455 NullPointerException.class, () ->
456 FieldUtils.readDeclaredField(null, "VALUE"));
457 assertThrows(
458 NullPointerException.class, () -> FieldUtils.readDeclaredStaticField(PublicChild.class, "VALUE"));
459 assertThrows(
460 NullPointerException.class,
461 () -> FieldUtils.readDeclaredStaticField(PubliclyShadowedChild.class, "VALUE"));
462 assertThrows(
463 NullPointerException.class,
464 () -> FieldUtils.readDeclaredStaticField(PrivatelyShadowedChild.class, "VALUE"));
465 assertThrows(
466 IllegalArgumentException.class,
467 () -> FieldUtils.readDeclaredStaticField(PublicChild.class, null));
468 assertThrows(
469 IllegalArgumentException.class,
470 () -> FieldUtils.readDeclaredStaticField(PublicChild.class, ""));
471 assertThrows(
472 IllegalArgumentException.class,
473 () -> FieldUtils.readDeclaredStaticField(PublicChild.class, " "));
474 }
475
476 @Test
477 public void testReadDeclaredNamedStaticFieldForceAccess() throws Exception {
478 assertEquals(Foo.VALUE, FieldUtils.readDeclaredStaticField(Foo.class, "VALUE", true));
479 assertEquals("child", FieldUtils.readDeclaredStaticField(PublicChild.class, "VALUE", true));
480 assertThrows(
481 NullPointerException.class,
482 () -> FieldUtils.readDeclaredStaticField(PubliclyShadowedChild.class, "VALUE", true));
483 assertThrows(
484 NullPointerException.class,
485 () -> FieldUtils.readDeclaredStaticField(PrivatelyShadowedChild.class, "VALUE", true));
486 assertThrows(
487 IllegalArgumentException.class,
488 () -> FieldUtils.readDeclaredStaticField(PrivatelyShadowedChild.class, null, true));
489 assertThrows(
490 IllegalArgumentException.class,
491 () -> FieldUtils.readDeclaredStaticField(PrivatelyShadowedChild.class, "", true));
492 assertThrows(
493 IllegalArgumentException.class,
494 () -> FieldUtils.readDeclaredStaticField(PrivatelyShadowedChild.class, " ", true));
495 }
496
497 @Test
498 public void testReadField() throws Exception {
499 final Field parentS = FieldUtils.getDeclaredField(parentClass, "s");
500 assertEquals("s", FieldUtils.readField(parentS, publicChild));
501 assertEquals("s", FieldUtils.readField(parentS, publiclyShadowedChild));
502 assertEquals("s", FieldUtils.readField(parentS, privatelyShadowedChild));
503 final Field parentB = FieldUtils.getDeclaredField(parentClass, "b", true);
504 assertEquals(Boolean.FALSE, FieldUtils.readField(parentB, publicChild));
505 assertEquals(Boolean.FALSE, FieldUtils.readField(parentB, publiclyShadowedChild));
506 assertEquals(Boolean.FALSE, FieldUtils.readField(parentB, privatelyShadowedChild));
507 final Field parentI = FieldUtils.getDeclaredField(parentClass, "i", true);
508 assertEquals(I0, FieldUtils.readField(parentI, publicChild));
509 assertEquals(I0, FieldUtils.readField(parentI, publiclyShadowedChild));
510 assertEquals(I0, FieldUtils.readField(parentI, privatelyShadowedChild));
511 final Field parentD = FieldUtils.getDeclaredField(parentClass, "d", true);
512 assertEquals(D0, FieldUtils.readField(parentD, publicChild));
513 assertEquals(D0, FieldUtils.readField(parentD, publiclyShadowedChild));
514 assertEquals(D0, FieldUtils.readField(parentD, privatelyShadowedChild));
515
516 assertThrows(
517 NullPointerException.class,
518 () -> FieldUtils.readField(null, publicChild),
519 "a null field should cause an NullPointerException");
520 }
521
522 @Test
523 public void testReadFieldForceAccess() throws Exception {
524 final Field parentS = FieldUtils.getDeclaredField(parentClass, "s");
525 parentS.setAccessible(false);
526 assertEquals("s", FieldUtils.readField(parentS, publicChild, true));
527 assertEquals("s", FieldUtils.readField(parentS, publiclyShadowedChild, true));
528 assertEquals("s", FieldUtils.readField(parentS, privatelyShadowedChild, true));
529 final Field parentB = FieldUtils.getDeclaredField(parentClass, "b", true);
530 parentB.setAccessible(false);
531 assertEquals(Boolean.FALSE, FieldUtils.readField(parentB, publicChild, true));
532 assertEquals(Boolean.FALSE, FieldUtils.readField(parentB, publiclyShadowedChild, true));
533 assertEquals(Boolean.FALSE, FieldUtils.readField(parentB, privatelyShadowedChild, true));
534 final Field parentI = FieldUtils.getDeclaredField(parentClass, "i", true);
535 parentI.setAccessible(false);
536 assertEquals(I0, FieldUtils.readField(parentI, publicChild, true));
537 assertEquals(I0, FieldUtils.readField(parentI, publiclyShadowedChild, true));
538 assertEquals(I0, FieldUtils.readField(parentI, privatelyShadowedChild, true));
539 final Field parentD = FieldUtils.getDeclaredField(parentClass, "d", true);
540 parentD.setAccessible(false);
541 assertEquals(D0, FieldUtils.readField(parentD, publicChild, true));
542 assertEquals(D0, FieldUtils.readField(parentD, publiclyShadowedChild, true));
543 assertEquals(D0, FieldUtils.readField(parentD, privatelyShadowedChild, true));
544
545 assertThrows(
546 NullPointerException.class,
547 () -> FieldUtils.readField(null, publicChild, true),
548 "a null field should cause an NullPointerException");
549 }
550
551 @Test
552 public void testReadNamedField() throws Exception {
553 assertEquals("s", FieldUtils.readField(publicChild, "s"));
554 assertEquals("ss", FieldUtils.readField(publiclyShadowedChild, "s"));
555 assertEquals("s", FieldUtils.readField(privatelyShadowedChild, "s"));
556
557 assertThrows(
558 IllegalArgumentException.class,
559 () -> FieldUtils.readField(publicChild, null),
560 "a null field name should cause an IllegalArgumentException");
561
562 assertThrows(
563 IllegalArgumentException.class,
564 () -> FieldUtils.readField(publicChild, ""),
565 "an empty field name should cause an IllegalArgumentException");
566
567 assertThrows(
568 IllegalArgumentException.class,
569 () -> FieldUtils.readField(publicChild, " "),
570 "a blank field name should cause an IllegalArgumentException");
571
572 assertThrows(
573 NullPointerException.class,
574 () -> FieldUtils.readField((Object) null, "none"),
575 "a null target should cause an NullPointerException");
576
577 assertThrows(IllegalArgumentException.class, () -> FieldUtils.readField(publicChild, "b"));
578
579 assertEquals(Boolean.TRUE, FieldUtils.readField(publiclyShadowedChild, "b"));
580 assertThrows( IllegalArgumentException.class, () -> FieldUtils.readField(privatelyShadowedChild, "b"));
581 assertThrows(IllegalArgumentException.class, () -> FieldUtils.readField(publicChild, "i"));
582 assertEquals(I1, FieldUtils.readField(publiclyShadowedChild, "i"));
583 assertThrows(IllegalArgumentException.class, () -> FieldUtils.readField(privatelyShadowedChild, "i"));
584 assertThrows(IllegalArgumentException.class, () -> FieldUtils.readField(publicChild, "d"));
585 assertEquals(D1, FieldUtils.readField(publiclyShadowedChild, "d"));
586 assertThrows(IllegalArgumentException.class, () -> FieldUtils.readField(privatelyShadowedChild, "d"));
587 }
588
589 @Test
590 public void testReadNamedFieldForceAccess() throws Exception {
591 assertEquals("s", FieldUtils.readField(publicChild, "s", true));
592 assertEquals("ss", FieldUtils.readField(publiclyShadowedChild, "s", true));
593 assertEquals("ss", FieldUtils.readField(privatelyShadowedChild, "s", true));
594 assertEquals(Boolean.FALSE, FieldUtils.readField(publicChild, "b", true));
595 assertEquals(Boolean.TRUE, FieldUtils.readField(publiclyShadowedChild, "b", true));
596 assertEquals(Boolean.TRUE, FieldUtils.readField(privatelyShadowedChild, "b", true));
597 assertEquals(I0, FieldUtils.readField(publicChild, "i", true));
598 assertEquals(I1, FieldUtils.readField(publiclyShadowedChild, "i", true));
599 assertEquals(I1, FieldUtils.readField(privatelyShadowedChild, "i", true));
600 assertEquals(D0, FieldUtils.readField(publicChild, "d", true));
601 assertEquals(D1, FieldUtils.readField(publiclyShadowedChild, "d", true));
602 assertEquals(D1, FieldUtils.readField(privatelyShadowedChild, "d", true));
603
604 assertThrows(
605 IllegalArgumentException.class,
606 () -> FieldUtils.readField(publicChild, null, true),
607 "a null field name should cause an IllegalArgumentException");
608
609 assertThrows(
610 IllegalArgumentException.class,
611 () -> FieldUtils.readField(publicChild, "", true),
612 "an empty field name should cause an IllegalArgumentException");
613
614 assertThrows(
615 IllegalArgumentException.class,
616 () -> FieldUtils.readField(publicChild, " ", true),
617 "a blank field name should cause an IllegalArgumentException");
618
619 assertThrows(
620 NullPointerException.class,
621 () -> FieldUtils.readField((Object) null, "none", true),
622 "a null target should cause an NullPointerException");
623 }
624
625 @Test
626 public void testReadNamedStaticField() throws Exception {
627 assertEquals(Foo.VALUE, FieldUtils.readStaticField(Foo.class, "VALUE"));
628 assertEquals(Foo.VALUE, FieldUtils.readStaticField(PubliclyShadowedChild.class, "VALUE"));
629 assertEquals(Foo.VALUE, FieldUtils.readStaticField(PrivatelyShadowedChild.class, "VALUE"));
630 assertEquals(Foo.VALUE, FieldUtils.readStaticField(PublicChild.class, "VALUE"));
631
632 assertThrows(
633 NullPointerException.class,
634 () -> FieldUtils.readStaticField(null, "none"),
635 "null class should cause an NullPointerException");
636
637 assertThrows(
638 IllegalArgumentException.class,
639 () -> FieldUtils.readStaticField(Foo.class, null),
640 "null field name should cause an IllegalArgumentException");
641
642 assertThrows(
643 IllegalArgumentException.class,
644 () -> FieldUtils.readStaticField(Foo.class, ""),
645 "empty field name should cause an IllegalArgumentException");
646
647 assertThrows(
648 IllegalArgumentException.class,
649 () -> FieldUtils.readStaticField(Foo.class, " "),
650 "blank field name should cause an IllegalArgumentException");
651
652 assertThrows(
653 NullPointerException.class,
654 () -> FieldUtils.readStaticField(Foo.class, "does_not_exist"),
655 "a field that doesn't exist should cause an NullPointerException");
656
657 assertThrows(
658 IllegalArgumentException.class,
659 () -> FieldUtils.readStaticField(PublicChild.class, "s"),
660 "non-static field should cause an IllegalArgumentException");
661 }
662
663 @Test
664 public void testReadNamedStaticFieldForceAccess() throws Exception {
665 assertEquals(Foo.VALUE, FieldUtils.readStaticField(Foo.class, "VALUE", true));
666 assertEquals(Foo.VALUE, FieldUtils.readStaticField(PubliclyShadowedChild.class, "VALUE", true));
667 assertEquals(Foo.VALUE, FieldUtils.readStaticField(PrivatelyShadowedChild.class, "VALUE", true));
668 assertEquals("child", FieldUtils.readStaticField(PublicChild.class, "VALUE", true));
669
670 assertThrows(
671 NullPointerException.class,
672 () -> FieldUtils.readStaticField(null, "none", true),
673 "null class should cause an NullPointerException");
674
675 assertThrows(
676 IllegalArgumentException.class,
677 () -> FieldUtils.readStaticField(Foo.class, null, true),
678 "null field name should cause an IllegalArgumentException");
679
680 assertThrows(
681 IllegalArgumentException.class,
682 () -> FieldUtils.readStaticField(Foo.class, "", true),
683 "empty field name should cause an IllegalArgumentException");
684
685 assertThrows(
686 IllegalArgumentException.class,
687 () -> FieldUtils.readStaticField(Foo.class, " ", true),
688 "blank field name should cause an IllegalArgumentException");
689
690 assertThrows(
691 NullPointerException.class,
692 () -> FieldUtils.readStaticField(Foo.class, "does_not_exist", true),
693 "a field that doesn't exist should cause an NullPointerException");
694
695 assertThrows(
696 IllegalArgumentException.class,
697 () -> FieldUtils.readStaticField(PublicChild.class, "s", false),
698 "non-static field should cause an IllegalArgumentException");
699 }
700
701 @Test
702 public void testReadStaticField() throws Exception {
703 assertEquals(Foo.VALUE, FieldUtils.readStaticField(FieldUtils.getField(Foo.class, "VALUE")));
704 }
705
706 @Test
707 public void testReadStaticFieldForceAccess() throws Exception {
708 assertEquals(Foo.VALUE, FieldUtils.readStaticField(FieldUtils.getField(Foo.class, "VALUE")));
709 assertEquals(Foo.VALUE, FieldUtils.readStaticField(FieldUtils.getField(PublicChild.class, "VALUE")));
710 }
711
712 @Test
713 public void testReadStaticFieldForceAccessIllegalArgumentException() {
714 final Field nonStaticField = FieldUtils.getField(PublicChild.class, "s", true);
715 assumeTrue(nonStaticField != null);
716 assertThrows(IllegalArgumentException.class, () -> FieldUtils.readStaticField(nonStaticField, true));
717 }
718
719 @Test
720 public void testReadStaticFieldForceAccessNullPointerException() {
721 assertThrows(NullPointerException.class, () -> FieldUtils.readStaticField(null, true));
722 }
723
724 @Test
725 public void testReadStaticFieldIllegalArgumentException() throws Exception {
726 assertEquals(Foo.VALUE, FieldUtils.readStaticField(FieldUtils.getField(Foo.class, "VALUE")));
727 final Field nonStaticField = FieldUtils.getField(PublicChild.class, "s");
728 assumeTrue(nonStaticField != null);
729 assertThrows(IllegalArgumentException.class, () -> FieldUtils.readStaticField(nonStaticField));
730 }
731
732 @Test
733 public void testReadStaticFieldNullPointerException() {
734 assertThrows(NullPointerException.class, () -> FieldUtils.readStaticField(null));
735 }
736
737 @Test
738 public void testRemoveFinalModifier() throws Exception {
739 final Field field = StaticContainer.class.getDeclaredField("IMMUTABLE_PRIVATE_2");
740 assertFalse(field.isAccessible());
741 assertTrue(Modifier.isFinal(field.getModifiers()));
742 callRemoveFinalModifierCheckForException(field, true);
743 if (SystemUtils.isJavaVersionAtMost(JavaVersion.JAVA_11)) {
744 assertFalse(Modifier.isFinal(field.getModifiers()));
745 assertFalse(field.isAccessible());
746 }
747 }
748
749 @Test
750 public void testRemoveFinalModifierAccessNotNeeded() throws Exception {
751 final Field field = StaticContainer.class.getDeclaredField("IMMUTABLE_PACKAGE");
752 assertFalse(field.isAccessible());
753 assertTrue(Modifier.isFinal(field.getModifiers()));
754 callRemoveFinalModifierCheckForException(field, false);
755 if (SystemUtils.isJavaVersionAtMost(JavaVersion.JAVA_11)) {
756 assertTrue(Modifier.isFinal(field.getModifiers()));
757 assertFalse(field.isAccessible());
758 }
759 }
760
761 @Test
762 public void testRemoveFinalModifierNullPointerException() {
763 assertThrows(NullPointerException.class, () -> FieldUtils.removeFinalModifier(null));
764 }
765
766 @Test
767 public void testRemoveFinalModifierWithAccess() throws Exception {
768 final Field field = StaticContainer.class.getDeclaredField("IMMUTABLE_PRIVATE_2");
769 assertFalse(field.isAccessible());
770 assertTrue(Modifier.isFinal(field.getModifiers()));
771 callRemoveFinalModifierCheckForException(field, true);
772 if (SystemUtils.isJavaVersionAtMost(JavaVersion.JAVA_11)) {
773 assertFalse(Modifier.isFinal(field.getModifiers()));
774 assertFalse(field.isAccessible());
775 }
776 }
777
778 @Test
779 public void testRemoveFinalModifierWithAccessNullPointerException() {
780 assertThrows(NullPointerException.class, () -> FieldUtils.removeFinalModifier(null, true));
781 }
782
783 @Test
784 public void testRemoveFinalModifierWithoutAccess() throws Exception {
785 final Field field = StaticContainer.class.getDeclaredField("IMMUTABLE_PRIVATE_2");
786 assertFalse(field.isAccessible());
787 assertTrue(Modifier.isFinal(field.getModifiers()));
788 callRemoveFinalModifierCheckForException(field, false);
789 if (SystemUtils.isJavaVersionAtMost(JavaVersion.JAVA_11)) {
790 assertTrue(Modifier.isFinal(field.getModifiers()));
791 assertFalse(field.isAccessible());
792 }
793 }
794
795 @Test
796 public void testWriteDeclaredNamedField() throws Exception {
797 assertThrows(IllegalArgumentException.class, () -> FieldUtils.writeDeclaredField(publicChild, "s", "S"));
798 assertThrows(
799 IllegalArgumentException.class, () -> FieldUtils.writeDeclaredField(publicChild, "b", Boolean.TRUE));
800 assertThrows(
801 IllegalArgumentException.class,
802 () -> FieldUtils.writeDeclaredField(publicChild, "i", Integer.valueOf(1)));
803 assertThrows(
804 IllegalArgumentException.class,
805 () -> FieldUtils.writeDeclaredField(publicChild, "d", Double.valueOf(1.0)));
806
807 FieldUtils.writeDeclaredField(publiclyShadowedChild, "s", "S");
808 assertEquals("S", FieldUtils.readDeclaredField(publiclyShadowedChild, "s"));
809 FieldUtils.writeDeclaredField(publiclyShadowedChild, "b", Boolean.FALSE);
810 assertEquals(Boolean.FALSE, FieldUtils.readDeclaredField(publiclyShadowedChild, "b"));
811 FieldUtils.writeDeclaredField(publiclyShadowedChild, "i", Integer.valueOf(0));
812 assertEquals(Integer.valueOf(0), FieldUtils.readDeclaredField(publiclyShadowedChild, "i"));
813 FieldUtils.writeDeclaredField(publiclyShadowedChild, "d", Double.valueOf(0.0));
814 assertEquals(Double.valueOf(0.0), FieldUtils.readDeclaredField(publiclyShadowedChild, "d"));
815
816 assertThrows(
817 IllegalArgumentException.class, () -> FieldUtils.writeDeclaredField(privatelyShadowedChild, "s", "S"));
818 assertThrows(
819 IllegalArgumentException.class,
820 () -> FieldUtils.writeDeclaredField(privatelyShadowedChild, "b", Boolean.TRUE));
821 assertThrows(
822 IllegalArgumentException.class,
823 () -> FieldUtils.writeDeclaredField(privatelyShadowedChild, "i", Integer.valueOf(1)));
824 assertThrows(
825 IllegalArgumentException.class,
826 () -> FieldUtils.writeDeclaredField(privatelyShadowedChild, "d", Double.valueOf(1.0)));
827
828 assertThrows(
829 NullPointerException.class,
830 () -> FieldUtils.writeDeclaredField(null, "s", "S"));
831 assertThrows(
832 IllegalArgumentException.class,
833 () -> FieldUtils.writeDeclaredField(publicChild, "null", "S"));
834 assertThrows(
835 IllegalArgumentException.class,
836 () -> FieldUtils.writeDeclaredField(publicChild, "", "S"));
837 assertThrows(
838 IllegalArgumentException.class,
839 () -> FieldUtils.writeDeclaredField(publicChild, " ", "S"));
840 }
841
842 @Test
843 public void testWriteDeclaredNamedFieldForceAccess() throws Exception {
844 assertThrows(IllegalArgumentException.class, () -> FieldUtils.writeDeclaredField(publicChild, "s", "S", true));
845 assertThrows(
846 IllegalArgumentException.class,
847 () -> FieldUtils.writeDeclaredField(publicChild, "b", Boolean.TRUE, true));
848 assertThrows(
849 IllegalArgumentException.class,
850 () -> FieldUtils.writeDeclaredField(publicChild, "i", Integer.valueOf(1), true));
851 assertThrows(
852 IllegalArgumentException.class,
853 () -> FieldUtils.writeDeclaredField(publicChild, "d", Double.valueOf(1.0), true));
854
855 FieldUtils.writeDeclaredField(publiclyShadowedChild, "s", "S", true);
856 assertEquals("S", FieldUtils.readDeclaredField(publiclyShadowedChild, "s", true));
857 FieldUtils.writeDeclaredField(publiclyShadowedChild, "b", Boolean.FALSE, true);
858 assertEquals(Boolean.FALSE, FieldUtils.readDeclaredField(publiclyShadowedChild, "b", true));
859 FieldUtils.writeDeclaredField(publiclyShadowedChild, "i", Integer.valueOf(0), true);
860 assertEquals(Integer.valueOf(0), FieldUtils.readDeclaredField(publiclyShadowedChild, "i", true));
861 FieldUtils.writeDeclaredField(publiclyShadowedChild, "d", Double.valueOf(0.0), true);
862 assertEquals(Double.valueOf(0.0), FieldUtils.readDeclaredField(publiclyShadowedChild, "d", true));
863
864 FieldUtils.writeDeclaredField(privatelyShadowedChild, "s", "S", true);
865 assertEquals("S", FieldUtils.readDeclaredField(privatelyShadowedChild, "s", true));
866 FieldUtils.writeDeclaredField(privatelyShadowedChild, "b", Boolean.FALSE, true);
867 assertEquals(Boolean.FALSE, FieldUtils.readDeclaredField(privatelyShadowedChild, "b", true));
868 FieldUtils.writeDeclaredField(privatelyShadowedChild, "i", Integer.valueOf(0), true);
869 assertEquals(Integer.valueOf(0), FieldUtils.readDeclaredField(privatelyShadowedChild, "i", true));
870 FieldUtils.writeDeclaredField(privatelyShadowedChild, "d", Double.valueOf(0.0), true);
871 assertEquals(Double.valueOf(0.0), FieldUtils.readDeclaredField(privatelyShadowedChild, "d", true));
872
873 assertThrows(
874 NullPointerException.class,
875 () -> FieldUtils.writeDeclaredField(null, "s", "S", true));
876 assertThrows(
877 IllegalArgumentException.class,
878 () -> FieldUtils.writeDeclaredField(publicChild, "null", "S", true));
879 assertThrows(
880 IllegalArgumentException.class,
881 () -> FieldUtils.writeDeclaredField(publicChild, "", "S", true));
882 assertThrows(
883 IllegalArgumentException.class,
884 () -> FieldUtils.writeDeclaredField(publicChild, " ", "S", true));
885 }
886
887 @Test
888 public void testWriteDeclaredNamedStaticField() throws Exception {
889 FieldUtils.writeStaticField(StaticContainer.class, "mutablePublic", "new");
890 assertEquals("new", StaticContainer.mutablePublic);
891 assertThrows(
892 NullPointerException.class,
893 () -> FieldUtils.writeDeclaredStaticField(StaticContainer.class, "mutableProtected", "new"));
894 assertThrows(
895 NullPointerException.class,
896 () -> FieldUtils.writeDeclaredStaticField(StaticContainer.class, "mutablePackage", "new"));
897 assertThrows(
898 NullPointerException.class,
899 () -> FieldUtils.writeDeclaredStaticField(StaticContainer.class, "mutablePrivate", "new"));
900 assertThrows(
901 IllegalAccessException.class,
902 () -> FieldUtils.writeDeclaredStaticField(StaticContainer.class, "IMMUTABLE_PUBLIC", "new"));
903 assertThrows(
904 NullPointerException.class,
905 () -> FieldUtils.writeDeclaredStaticField(StaticContainer.class, "IMMUTABLE_PROTECTED", "new"));
906 assertThrows(
907 NullPointerException.class,
908 () -> FieldUtils.writeDeclaredStaticField(StaticContainer.class, "IMMUTABLE_PACKAGE", "new"));
909 assertThrows(
910 NullPointerException.class,
911 () -> FieldUtils.writeDeclaredStaticField(StaticContainer.class, "IMMUTABLE_PRIVATE", "new"));
912
913 assertThrows(
914 NullPointerException.class,
915 () -> FieldUtils.writeDeclaredStaticField(null, "mutablePublic", "new"));
916 assertThrows(
917 IllegalArgumentException.class,
918 () -> FieldUtils.writeDeclaredStaticField(StaticContainer.class, null, "new"));
919 assertThrows(
920 IllegalArgumentException.class,
921 () -> FieldUtils.writeDeclaredStaticField(StaticContainer.class, "", "new"));
922 assertThrows(
923 IllegalArgumentException.class,
924 () -> FieldUtils.writeDeclaredStaticField(StaticContainer.class, " ", "new"));
925 }
926
927 @Test
928 public void testWriteDeclaredNamedStaticFieldForceAccess() throws Exception {
929 FieldUtils.writeDeclaredStaticField(StaticContainer.class, "mutablePublic", "new", true);
930 assertEquals("new", StaticContainer.mutablePublic);
931 FieldUtils.writeDeclaredStaticField(StaticContainer.class, "mutableProtected", "new", true);
932 assertEquals("new", StaticContainer.getMutableProtected());
933 FieldUtils.writeDeclaredStaticField(StaticContainer.class, "mutablePackage", "new", true);
934 assertEquals("new", StaticContainer.getMutablePackage());
935 FieldUtils.writeDeclaredStaticField(StaticContainer.class, "mutablePrivate", "new", true);
936 assertEquals("new", StaticContainer.getMutablePrivate());
937 assertThrows(
938 IllegalAccessException.class,
939 () -> FieldUtils.writeDeclaredStaticField(StaticContainer.class, "IMMUTABLE_PUBLIC", "new", true));
940 assertThrows(
941 IllegalAccessException.class,
942 () -> FieldUtils.writeDeclaredStaticField(StaticContainer.class, "IMMUTABLE_PROTECTED", "new", true));
943 assertThrows(
944 IllegalAccessException.class,
945 () -> FieldUtils.writeDeclaredStaticField(StaticContainer.class, "IMMUTABLE_PACKAGE", "new", true));
946 assertThrows(
947 IllegalAccessException.class,
948 () -> FieldUtils.writeDeclaredStaticField(StaticContainer.class, "IMMUTABLE_PRIVATE", "new", true));
949
950 assertThrows(
951 NullPointerException.class,
952 () -> FieldUtils.writeDeclaredStaticField(null, "mutablePublic", "new", true));
953 assertThrows(
954 IllegalArgumentException.class,
955 () -> FieldUtils.writeDeclaredStaticField(StaticContainer.class, null, "new", true));
956 assertThrows(
957 IllegalArgumentException.class,
958 () -> FieldUtils.writeDeclaredStaticField(StaticContainer.class, "", "new", true));
959 assertThrows(
960 IllegalArgumentException.class,
961 () -> FieldUtils.writeDeclaredStaticField(StaticContainer.class, " ", "new", true));
962 }
963
964 @Test
965 public void testWriteField() throws Exception {
966 final Field field = parentClass.getDeclaredField("s");
967 FieldUtils.writeField(field, publicChild, "S");
968 assertEquals("S", field.get(publicChild));
969 assertThrows(
970 IllegalAccessException.class,
971 () -> FieldUtils.writeField(parentClass.getDeclaredField("b"), publicChild, Boolean.TRUE));
972 assertThrows(
973 IllegalAccessException.class,
974 () -> FieldUtils.writeField(parentClass.getDeclaredField("i"), publicChild, Integer.valueOf(Integer.MAX_VALUE)));
975 assertThrows(
976 IllegalAccessException.class,
977 () -> FieldUtils.writeField(parentClass.getDeclaredField("d"), publicChild, Double.valueOf(Double.MAX_VALUE)));
978
979 assertThrows(
980 NullPointerException.class,
981 () -> FieldUtils.writeField(null, publicChild, "S"));
982 }
983
984 @Test
985 public void testWriteFieldForceAccess() throws Exception {
986 Field field = parentClass.getDeclaredField("s");
987 FieldUtils.writeField(field, publicChild, "S", true);
988 assertEquals("S", field.get(publicChild));
989 field = parentClass.getDeclaredField("b");
990 FieldUtils.writeField(field, publicChild, Boolean.TRUE, true);
991 assertEquals(Boolean.TRUE, field.get(publicChild));
992 field = parentClass.getDeclaredField("i");
993 FieldUtils.writeField(field, publicChild, Integer.valueOf(Integer.MAX_VALUE), true);
994 assertEquals(Integer.valueOf(Integer.MAX_VALUE), field.get(publicChild));
995 field = parentClass.getDeclaredField("d");
996 FieldUtils.writeField(field, publicChild, Double.valueOf(Double.MAX_VALUE), true);
997 assertEquals(Double.valueOf(Double.MAX_VALUE), field.get(publicChild));
998
999 assertThrows(
1000 NullPointerException.class,
1001 () -> FieldUtils.writeField(null, publicChild, "S", true));
1002 }
1003
1004 @Test
1005 public void testWriteNamedField() throws Exception {
1006 FieldUtils.writeField(publicChild, "s", "S");
1007 assertEquals("S", FieldUtils.readField(publicChild, "s"));
1008 assertThrows(IllegalArgumentException.class, () -> FieldUtils.writeField(publicChild, "b", Boolean.TRUE));
1009 assertThrows(IllegalArgumentException.class, () -> FieldUtils.writeField(publicChild, "i", Integer.valueOf(1)));
1010 assertThrows(
1011 IllegalArgumentException.class, () -> FieldUtils.writeField(publicChild, "d", Double.valueOf(1.0)));
1012
1013 FieldUtils.writeField(publiclyShadowedChild, "s", "S");
1014 assertEquals("S", FieldUtils.readField(publiclyShadowedChild, "s"));
1015 FieldUtils.writeField(publiclyShadowedChild, "b", Boolean.FALSE);
1016 assertEquals(Boolean.FALSE, FieldUtils.readField(publiclyShadowedChild, "b"));
1017 FieldUtils.writeField(publiclyShadowedChild, "i", Integer.valueOf(0));
1018 assertEquals(Integer.valueOf(0), FieldUtils.readField(publiclyShadowedChild, "i"));
1019 FieldUtils.writeField(publiclyShadowedChild, "d", Double.valueOf(0.0));
1020 assertEquals(Double.valueOf(0.0), FieldUtils.readField(publiclyShadowedChild, "d"));
1021
1022 FieldUtils.writeField(privatelyShadowedChild, "s", "S");
1023 assertEquals("S", FieldUtils.readField(privatelyShadowedChild, "s"));
1024 assertThrows(
1025 IllegalArgumentException.class,
1026 () -> FieldUtils.writeField(privatelyShadowedChild, "b", Boolean.TRUE));
1027 assertThrows(
1028 IllegalArgumentException.class,
1029 () -> FieldUtils.writeField(privatelyShadowedChild, "i", Integer.valueOf(1)));
1030 assertThrows(
1031 IllegalArgumentException.class,
1032 () -> FieldUtils.writeField(privatelyShadowedChild, "d", Double.valueOf(1.0)));
1033
1034 assertThrows(
1035 NullPointerException.class,
1036 () -> FieldUtils.writeField((Object) null, "s", "s"));
1037 assertThrows(
1038 IllegalArgumentException.class,
1039 () -> FieldUtils.writeField(publicChild, null, "s"));
1040 assertThrows(
1041 IllegalArgumentException.class,
1042 () -> FieldUtils.writeField(publicChild, "", "s"));
1043 assertThrows(
1044 IllegalArgumentException.class,
1045 () -> FieldUtils.writeField(publicChild, " ", "s"));
1046 }
1047
1048 @Test
1049 public void testWriteNamedFieldForceAccess() throws Exception {
1050 FieldUtils.writeField(publicChild, "s", "S", true);
1051 assertEquals("S", FieldUtils.readField(publicChild, "s", true));
1052 FieldUtils.writeField(publicChild, "b", Boolean.TRUE, true);
1053 assertEquals(Boolean.TRUE, FieldUtils.readField(publicChild, "b", true));
1054 FieldUtils.writeField(publicChild, "i", Integer.valueOf(1), true);
1055 assertEquals(Integer.valueOf(1), FieldUtils.readField(publicChild, "i", true));
1056 FieldUtils.writeField(publicChild, "d", Double.valueOf(1.0), true);
1057 assertEquals(Double.valueOf(1.0), FieldUtils.readField(publicChild, "d", true));
1058
1059 FieldUtils.writeField(publiclyShadowedChild, "s", "S", true);
1060 assertEquals("S", FieldUtils.readField(publiclyShadowedChild, "s", true));
1061 FieldUtils.writeField(publiclyShadowedChild, "b", Boolean.FALSE, true);
1062 assertEquals(Boolean.FALSE, FieldUtils.readField(publiclyShadowedChild, "b", true));
1063 FieldUtils.writeField(publiclyShadowedChild, "i", Integer.valueOf(0), true);
1064 assertEquals(Integer.valueOf(0), FieldUtils.readField(publiclyShadowedChild, "i", true));
1065 FieldUtils.writeField(publiclyShadowedChild, "d", Double.valueOf(0.0), true);
1066 assertEquals(Double.valueOf(0.0), FieldUtils.readField(publiclyShadowedChild, "d", true));
1067
1068 FieldUtils.writeField(privatelyShadowedChild, "s", "S", true);
1069 assertEquals("S", FieldUtils.readField(privatelyShadowedChild, "s", true));
1070 FieldUtils.writeField(privatelyShadowedChild, "b", Boolean.FALSE, true);
1071 assertEquals(Boolean.FALSE, FieldUtils.readField(privatelyShadowedChild, "b", true));
1072 FieldUtils.writeField(privatelyShadowedChild, "i", Integer.valueOf(0), true);
1073 assertEquals(Integer.valueOf(0), FieldUtils.readField(privatelyShadowedChild, "i", true));
1074 FieldUtils.writeField(privatelyShadowedChild, "d", Double.valueOf(0.0), true);
1075 assertEquals(Double.valueOf(0.0), FieldUtils.readField(privatelyShadowedChild, "d", true));
1076
1077 assertThrows(
1078 NullPointerException.class,
1079 () -> FieldUtils.writeField((Object) null, "s", "s", true));
1080 assertThrows(
1081 IllegalArgumentException.class,
1082 () -> FieldUtils.writeField(publicChild, null, "s", true));
1083 assertThrows(
1084 IllegalArgumentException.class,
1085 () -> FieldUtils.writeField(publicChild, "", "s", true));
1086 assertThrows(
1087 IllegalArgumentException.class,
1088 () -> FieldUtils.writeField(publicChild, " ", "s", true));
1089 }
1090
1091 @Test
1092 public void testWriteNamedStaticField() throws Exception {
1093 FieldUtils.writeStaticField(StaticContainerChild.class, "mutablePublic", "new");
1094 assertEquals("new", StaticContainer.mutablePublic);
1095 assertThrows(
1096 NullPointerException.class,
1097 () -> FieldUtils.writeStaticField(StaticContainerChild.class, "mutableProtected", "new"));
1098 assertThrows(
1099 NullPointerException.class,
1100 () -> FieldUtils.writeStaticField(StaticContainerChild.class, "mutablePackage", "new"));
1101 assertThrows(
1102 NullPointerException.class,
1103 () -> FieldUtils.writeStaticField(StaticContainerChild.class, "mutablePrivate", "new"));
1104 assertThrows(
1105 IllegalAccessException.class,
1106 () -> FieldUtils.writeStaticField(StaticContainerChild.class, "IMMUTABLE_PUBLIC", "new"));
1107 assertThrows(
1108 NullPointerException.class,
1109 () -> FieldUtils.writeStaticField(StaticContainerChild.class, "IMMUTABLE_PROTECTED", "new"));
1110 assertThrows(
1111 NullPointerException.class,
1112 () -> FieldUtils.writeStaticField(StaticContainerChild.class, "IMMUTABLE_PACKAGE", "new"));
1113 assertThrows(
1114 NullPointerException.class,
1115 () -> FieldUtils.writeStaticField(StaticContainerChild.class, "IMMUTABLE_PRIVATE", "new"));
1116
1117 assertThrows(
1118 NullPointerException.class,
1119 () -> FieldUtils.writeStaticField(null, "IMMUTABLE_PRIVATE", "new"));
1120 assertThrows(
1121 IllegalArgumentException.class,
1122 () -> FieldUtils.writeStaticField(StaticContainerChild.class, null, "new"));
1123 assertThrows(
1124 IllegalArgumentException.class,
1125 () -> FieldUtils.writeStaticField(StaticContainerChild.class, "", "new"));
1126 assertThrows(
1127 IllegalArgumentException.class,
1128 () -> FieldUtils.writeStaticField(StaticContainerChild.class, " ", "new"));
1129 }
1130
1131 @Test
1132 public void testWriteNamedStaticFieldForceAccess() throws Exception {
1133 FieldUtils.writeStaticField(StaticContainerChild.class, "mutablePublic", "new", true);
1134 assertEquals("new", StaticContainer.mutablePublic);
1135 FieldUtils.writeStaticField(StaticContainerChild.class, "mutableProtected", "new", true);
1136 assertEquals("new", StaticContainer.getMutableProtected());
1137 FieldUtils.writeStaticField(StaticContainerChild.class, "mutablePackage", "new", true);
1138 assertEquals("new", StaticContainer.getMutablePackage());
1139 FieldUtils.writeStaticField(StaticContainerChild.class, "mutablePrivate", "new", true);
1140 assertEquals("new", StaticContainer.getMutablePrivate());
1141 assertThrows(
1142 IllegalAccessException.class,
1143 () -> FieldUtils.writeStaticField(StaticContainerChild.class, "IMMUTABLE_PUBLIC", "new", true));
1144 assertThrows(
1145 IllegalAccessException.class,
1146 () -> FieldUtils.writeStaticField(StaticContainerChild.class, "IMMUTABLE_PROTECTED", "new", true));
1147 assertThrows(
1148 IllegalAccessException.class,
1149 () -> FieldUtils.writeStaticField(StaticContainerChild.class, "IMMUTABLE_PACKAGE", "new", true));
1150 assertThrows(
1151 IllegalAccessException.class,
1152 () -> FieldUtils.writeStaticField(StaticContainerChild.class, "IMMUTABLE_PRIVATE", "new", true));
1153
1154 assertThrows(
1155 NullPointerException.class,
1156 () -> FieldUtils.writeStaticField(null, "IMMUTABLE_PRIVATE", "new", true));
1157 assertThrows(
1158 IllegalArgumentException.class,
1159 () -> FieldUtils.writeStaticField(StaticContainerChild.class, null, "new", true));
1160 assertThrows(
1161 IllegalArgumentException.class,
1162 () -> FieldUtils.writeStaticField(StaticContainerChild.class, "", "new", true));
1163 assertThrows(
1164 IllegalArgumentException.class,
1165 () -> FieldUtils.writeStaticField(StaticContainerChild.class, " ", "new", true));
1166 }
1167
1168 @Test
1169 public void testWriteStaticField() throws Exception {
1170 final Field field = StaticContainer.class.getDeclaredField("mutablePublic");
1171 FieldUtils.writeStaticField(field, "new");
1172 assertEquals("new", StaticContainer.mutablePublic);
1173 assertThrows(
1174 IllegalAccessException.class,
1175 () -> FieldUtils.writeStaticField(StaticContainer.class.getDeclaredField("mutableProtected"), "new"));
1176 assertThrows(
1177 IllegalAccessException.class,
1178 () -> FieldUtils.writeStaticField(StaticContainer.class.getDeclaredField("mutablePackage"), "new"));
1179 assertThrows(
1180 IllegalAccessException.class,
1181 () -> FieldUtils.writeStaticField(StaticContainer.class.getDeclaredField("mutablePrivate"), "new"));
1182 assertThrows(
1183 IllegalAccessException.class,
1184 () -> FieldUtils.writeStaticField(StaticContainer.class.getDeclaredField("IMMUTABLE_PUBLIC"), "new"));
1185 assertThrows(
1186 IllegalAccessException.class,
1187 () -> FieldUtils.writeStaticField(StaticContainer.class.getDeclaredField("IMMUTABLE_PROTECTED"), "new"));
1188 assertThrows(
1189 IllegalAccessException.class,
1190 () -> FieldUtils.writeStaticField(StaticContainer.class.getDeclaredField("IMMUTABLE_PACKAGE"), "new"));
1191 assertThrows(
1192 IllegalAccessException.class,
1193 () -> FieldUtils.writeStaticField(StaticContainer.class.getDeclaredField("IMMUTABLE_PRIVATE"), "new"));
1194
1195 assertThrows(
1196 NullPointerException.class,
1197 () -> FieldUtils.writeStaticField(null, "new"));
1198 }
1199
1200 @Test
1201 public void testWriteStaticFieldForceAccess() throws Exception {
1202 Field field = StaticContainer.class.getDeclaredField("mutablePublic");
1203 FieldUtils.writeStaticField(field, "new", true);
1204 assertEquals("new", StaticContainer.mutablePublic);
1205 field = StaticContainer.class.getDeclaredField("mutableProtected");
1206 FieldUtils.writeStaticField(field, "new", true);
1207 assertEquals("new", StaticContainer.getMutableProtected());
1208 field = StaticContainer.class.getDeclaredField("mutablePackage");
1209 FieldUtils.writeStaticField(field, "new", true);
1210 assertEquals("new", StaticContainer.getMutablePackage());
1211 field = StaticContainer.class.getDeclaredField("mutablePrivate");
1212 FieldUtils.writeStaticField(field, "new", true);
1213 assertEquals("new", StaticContainer.getMutablePrivate());
1214 assertThrows(
1215 IllegalAccessException.class,
1216 () -> FieldUtils.writeStaticField(StaticContainer.class.getDeclaredField("IMMUTABLE_PUBLIC"), "new", true));
1217 assertThrows(
1218 IllegalAccessException.class,
1219 () -> FieldUtils.writeStaticField(StaticContainer.class.getDeclaredField("IMMUTABLE_PROTECTED"), "new", true));
1220 assertThrows(
1221 IllegalAccessException.class,
1222 () -> FieldUtils.writeStaticField(StaticContainer.class.getDeclaredField("IMMUTABLE_PACKAGE"), "new", true));
1223 assertThrows(
1224 IllegalAccessException.class,
1225 () -> FieldUtils.writeStaticField(StaticContainer.class.getDeclaredField("IMMUTABLE_PRIVATE"), "new", true));
1226
1227 assertThrows(
1228 NullPointerException.class,
1229 () -> FieldUtils.writeStaticField(null, "new", true));
1230 }
1231
1232 }