View Javadoc
1   /*
2    * Licensed to the Apache Software Foundation (ASF) under one or more
3    * contributor license agreements.  See the NOTICE file distributed with
4    * this work for additional information regarding copyright ownership.
5    * The ASF licenses this file to You under the Apache License, Version 2.0
6    * (the "License"); you may not use this file except in compliance with
7    * the License.  You may obtain a copy of the License at
8    *
9    *      http://www.apache.org/licenses/LICENSE-2.0
10   *
11   * Unless required by applicable law or agreed to in writing, software
12   * distributed under the License is distributed on an "AS IS" BASIS,
13   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14   * See the License for the specific language governing permissions and
15   * limitations under the License.
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   * Unit tests FieldUtils
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       * Read the {@code @deprecated} notice on
74       * {@link FieldUtils#removeFinalModifier(Field, boolean)}.
75       *
76       * @param field {@link Field} to be curried into
77       *              {@link FieldUtils#removeFinalModifier(Field, boolean)}.
78       * @param forceAccess {@link Boolean} to be curried into
79       *              {@link FieldUtils#removeFinalModifier(Field, boolean)}.
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         // Field does not implement Comparable, so we use a KISS solution here.
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         // Under Jacoco,0.8.1 and Java 10, the field count is 7.
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         // Under Jacoco,0.8.1 and Java 10, the field count is 7.
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 }