|
Java example source code file (FieldUtilsTest.java)
This example Java source code file (FieldUtilsTest.java) is included in the alvinalexander.com
"Java Source Code
Warehouse" project. The intent of this project is to help you "Learn
Java by Example" TM.
Learn more about this Java project at its project page.
The FieldUtilsTest.java Java example source code
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.lang3.reflect;
import org.apache.commons.lang3.ArrayUtils;
import org.apache.commons.lang3.reflect.testbed.*;
import org.junit.Before;
import org.junit.Test;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import static org.junit.Assert.*;
import static org.junit.Assume.assumeNotNull;
/**
* Unit tests FieldUtils
*/
public class FieldUtilsTest {
static final Integer I0 = Integer.valueOf(0);
static final Integer I1 = Integer.valueOf(1);
static final Double D0 = Double.valueOf(0.0);
static final Double D1 = Double.valueOf(1.0);
@Annotated
private PublicChild publicChild;
private PubliclyShadowedChild publiclyShadowedChild;
@Annotated
private PrivatelyShadowedChild privatelyShadowedChild;
private final Class<? super PublicChild> parentClass = PublicChild.class.getSuperclass();
@Before
public void setUp() {
StaticContainer.reset();
publicChild = new PublicChild();
publiclyShadowedChild = new PubliclyShadowedChild();
privatelyShadowedChild = new PrivatelyShadowedChild();
}
@Test
public void testConstructor() {
assertNotNull(new FieldUtils());
final Constructor<?>[] cons = FieldUtils.class.getDeclaredConstructors();
assertEquals(1, cons.length);
assertTrue(Modifier.isPublic(cons[0].getModifiers()));
assertTrue(Modifier.isPublic(FieldUtils.class.getModifiers()));
assertFalse(Modifier.isFinal(FieldUtils.class.getModifiers()));
}
@Test
public void testGetField() {
assertEquals(Foo.class, FieldUtils.getField(PublicChild.class, "VALUE").getDeclaringClass());
assertEquals(parentClass, FieldUtils.getField(PublicChild.class, "s").getDeclaringClass());
assertNull(FieldUtils.getField(PublicChild.class, "b"));
assertNull(FieldUtils.getField(PublicChild.class, "i"));
assertNull(FieldUtils.getField(PublicChild.class, "d"));
assertEquals(Foo.class, FieldUtils.getField(PubliclyShadowedChild.class, "VALUE").getDeclaringClass());
assertEquals(PubliclyShadowedChild.class, FieldUtils.getField(PubliclyShadowedChild.class, "s").getDeclaringClass());
assertEquals(PubliclyShadowedChild.class, FieldUtils.getField(PubliclyShadowedChild.class, "b").getDeclaringClass());
assertEquals(PubliclyShadowedChild.class, FieldUtils.getField(PubliclyShadowedChild.class, "i").getDeclaringClass());
assertEquals(PubliclyShadowedChild.class, FieldUtils.getField(PubliclyShadowedChild.class, "d").getDeclaringClass());
assertEquals(Foo.class, FieldUtils.getField(PrivatelyShadowedChild.class, "VALUE").getDeclaringClass());
assertEquals(parentClass, FieldUtils.getField(PrivatelyShadowedChild.class, "s").getDeclaringClass());
assertNull(FieldUtils.getField(PrivatelyShadowedChild.class, "b"));
assertNull(FieldUtils.getField(PrivatelyShadowedChild.class, "i"));
assertNull(FieldUtils.getField(PrivatelyShadowedChild.class, "d"));
}
@Test(expected = IllegalArgumentException.class)
public void testGetFieldIllegalArgumentException1() {
FieldUtils.getField(null, "none");
}
@Test(expected = IllegalArgumentException.class)
public void testGetFieldIllegalArgumentException2() {
FieldUtils.getField(PublicChild.class, null);
}
@Test(expected = IllegalArgumentException.class)
public void testGetFieldIllegalArgumentException3() {
FieldUtils.getField(PublicChild.class, "");
}
@Test(expected = IllegalArgumentException.class)
public void testGetFieldIllegalArgumentException4() {
FieldUtils.getField(PublicChild.class, " ");
}
@Test
public void testGetFieldForceAccess() {
assertEquals(PublicChild.class, FieldUtils.getField(PublicChild.class, "VALUE", true).getDeclaringClass());
assertEquals(parentClass, FieldUtils.getField(PublicChild.class, "s", true).getDeclaringClass());
assertEquals(parentClass, FieldUtils.getField(PublicChild.class, "b", true).getDeclaringClass());
assertEquals(parentClass, FieldUtils.getField(PublicChild.class, "i", true).getDeclaringClass());
assertEquals(parentClass, FieldUtils.getField(PublicChild.class, "d", true).getDeclaringClass());
assertEquals(Foo.class, FieldUtils.getField(PubliclyShadowedChild.class, "VALUE", true).getDeclaringClass());
assertEquals(PubliclyShadowedChild.class, FieldUtils.getField(PubliclyShadowedChild.class, "s", true).getDeclaringClass());
assertEquals(PubliclyShadowedChild.class, FieldUtils.getField(PubliclyShadowedChild.class, "b", true).getDeclaringClass());
assertEquals(PubliclyShadowedChild.class, FieldUtils.getField(PubliclyShadowedChild.class, "i", true).getDeclaringClass());
assertEquals(PubliclyShadowedChild.class, FieldUtils.getField(PubliclyShadowedChild.class, "d", true).getDeclaringClass());
assertEquals(Foo.class, FieldUtils.getField(PrivatelyShadowedChild.class, "VALUE", true).getDeclaringClass());
assertEquals(PrivatelyShadowedChild.class, FieldUtils.getField(PrivatelyShadowedChild.class, "s", true).getDeclaringClass());
assertEquals(PrivatelyShadowedChild.class, FieldUtils.getField(PrivatelyShadowedChild.class, "b", true).getDeclaringClass());
assertEquals(PrivatelyShadowedChild.class, FieldUtils.getField(PrivatelyShadowedChild.class, "i", true).getDeclaringClass());
assertEquals(PrivatelyShadowedChild.class, FieldUtils.getField(PrivatelyShadowedChild.class, "d", true).getDeclaringClass());
}
@Test(expected = IllegalArgumentException.class)
public void testGetFieldForceAccessIllegalArgumentException1() {
FieldUtils.getField(null, "none", true);
}
@Test(expected = IllegalArgumentException.class)
public void testGetFieldForceAccessIllegalArgumentException2() {
FieldUtils.getField(PublicChild.class, null, true);
}
@Test(expected = IllegalArgumentException.class)
public void testGetFieldForceAccessIllegalArgumentException3() {
FieldUtils.getField(PublicChild.class, "", true);
}
@Test(expected = IllegalArgumentException.class)
public void testGetFieldForceAccessIllegalArgumentException4() {
FieldUtils.getField(PublicChild.class, " ", true);
}
@Test
public void testGetAllFields() {
assertArrayEquals(new Field[0], FieldUtils.getAllFields(Object.class));
final Field[] fieldsNumber = Number.class.getDeclaredFields();
assertArrayEquals(fieldsNumber, FieldUtils.getAllFields(Number.class));
final Field[] fieldsInteger = Integer.class.getDeclaredFields();
assertArrayEquals(ArrayUtils.addAll(fieldsInteger, fieldsNumber), FieldUtils.getAllFields(Integer.class));
assertEquals(5, FieldUtils.getAllFields(PublicChild.class).length);
}
@Test
public void testGetAllFieldsList() {
assertEquals(0, FieldUtils.getAllFieldsList(Object.class).size());
final List<Field> fieldsNumber = Arrays.asList(Number.class.getDeclaredFields());
assertEquals(fieldsNumber, FieldUtils.getAllFieldsList(Number.class));
final List<Field> fieldsInteger = Arrays.asList(Integer.class.getDeclaredFields());
final List<Field> allFieldsInteger = new ArrayList(fieldsInteger);
allFieldsInteger.addAll(fieldsNumber);
assertEquals(allFieldsInteger, FieldUtils.getAllFieldsList(Integer.class));
assertEquals(5, FieldUtils.getAllFieldsList(PublicChild.class).size());
}
@Test
public void testGetFieldsWithAnnotation() throws NoSuchFieldException {
assertArrayEquals(new Field[0], FieldUtils.getFieldsWithAnnotation(Object.class, Annotated.class));
final Field[] annotatedFields = new Field[]{
FieldUtilsTest.class.getDeclaredField("publicChild"),
FieldUtilsTest.class.getDeclaredField("privatelyShadowedChild")
};
assertArrayEquals(annotatedFields, FieldUtils.getFieldsWithAnnotation(FieldUtilsTest.class, Annotated.class));
}
@Test(expected = IllegalArgumentException.class)
public void testGetFieldsWithAnnotationIllegalArgumentException1() {
FieldUtils.getFieldsWithAnnotation(FieldUtilsTest.class, null);
}
@Test(expected = IllegalArgumentException.class)
public void testGetFieldsWithAnnotationIllegalArgumentException2() {
FieldUtils.getFieldsWithAnnotation(null, Annotated.class);
}
@Test(expected = IllegalArgumentException.class)
public void testGetFieldsWithAnnotationIllegalArgumentException3() {
FieldUtils.getFieldsWithAnnotation(null, null);
}
@Test
public void testGetFieldsListWithAnnotation() throws NoSuchFieldException {
assertEquals(0, FieldUtils.getFieldsListWithAnnotation(Object.class, Annotated.class).size());
final List<Field> annotatedFields = Arrays.asList(
FieldUtilsTest.class.getDeclaredField("publicChild"),
FieldUtilsTest.class.getDeclaredField("privatelyShadowedChild")
);
final List<Field> fieldUtilsTestAnnotatedFields = FieldUtils.getFieldsListWithAnnotation(FieldUtilsTest.class, Annotated.class);
assertEquals(annotatedFields.size(),fieldUtilsTestAnnotatedFields.size());
assertTrue(fieldUtilsTestAnnotatedFields.contains(annotatedFields.get(0)));
assertTrue(fieldUtilsTestAnnotatedFields.contains(annotatedFields.get(1)));
}
@Test(expected = IllegalArgumentException.class)
public void testGetFieldsListWithAnnotationIllegalArgumentException1() {
FieldUtils.getFieldsListWithAnnotation(FieldUtilsTest.class, null);
}
@Test(expected = IllegalArgumentException.class)
public void testGetFieldsListWithAnnotationIllegalArgumentException2() {
FieldUtils.getFieldsListWithAnnotation(null, Annotated.class);
}
@Test(expected = IllegalArgumentException.class)
public void testGetFieldsListWithAnnotationIllegalArgumentException3() {
FieldUtils.getFieldsListWithAnnotation(null, null);
}
@Test
public void testGetDeclaredField() {
assertNull(FieldUtils.getDeclaredField(PublicChild.class, "VALUE"));
assertNull(FieldUtils.getDeclaredField(PublicChild.class, "s"));
assertNull(FieldUtils.getDeclaredField(PublicChild.class, "b"));
assertNull(FieldUtils.getDeclaredField(PublicChild.class, "i"));
assertNull(FieldUtils.getDeclaredField(PublicChild.class, "d"));
assertNull(FieldUtils.getDeclaredField(PubliclyShadowedChild.class, "VALUE"));
assertEquals(PubliclyShadowedChild.class, FieldUtils.getDeclaredField(PubliclyShadowedChild.class, "s").getDeclaringClass());
assertEquals(PubliclyShadowedChild.class, FieldUtils.getDeclaredField(PubliclyShadowedChild.class, "b").getDeclaringClass());
assertEquals(PubliclyShadowedChild.class, FieldUtils.getDeclaredField(PubliclyShadowedChild.class, "i").getDeclaringClass());
assertEquals(PubliclyShadowedChild.class, FieldUtils.getDeclaredField(PubliclyShadowedChild.class, "d").getDeclaringClass());
assertNull(FieldUtils.getDeclaredField(PrivatelyShadowedChild.class, "VALUE"));
assertNull(FieldUtils.getDeclaredField(PrivatelyShadowedChild.class, "s"));
assertNull(FieldUtils.getDeclaredField(PrivatelyShadowedChild.class, "b"));
assertNull(FieldUtils.getDeclaredField(PrivatelyShadowedChild.class, "i"));
assertNull(FieldUtils.getDeclaredField(PrivatelyShadowedChild.class, "d"));
}
@Test(expected = IllegalArgumentException.class)
public void testGetDeclaredFieldAccessIllegalArgumentException1() {
FieldUtils.getDeclaredField(null, "none");
}
@Test(expected = IllegalArgumentException.class)
public void testGetDeclaredFieldAccessIllegalArgumentException2() {
FieldUtils.getDeclaredField(PublicChild.class, null);
}
@Test(expected = IllegalArgumentException.class)
public void testGetDeclaredFieldAccessIllegalArgumentException3() {
FieldUtils.getDeclaredField(PublicChild.class, "");
}
@Test(expected = IllegalArgumentException.class)
public void testGetDeclaredFieldAccessIllegalArgumentException4() {
FieldUtils.getDeclaredField(PublicChild.class, " ");
}
@Test
public void testGetDeclaredFieldForceAccess() {
assertEquals(PublicChild.class, FieldUtils.getDeclaredField(PublicChild.class, "VALUE", true).getDeclaringClass());
assertNull(FieldUtils.getDeclaredField(PublicChild.class, "s", true));
assertNull(FieldUtils.getDeclaredField(PublicChild.class, "b", true));
assertNull(FieldUtils.getDeclaredField(PublicChild.class, "i", true));
assertNull(FieldUtils.getDeclaredField(PublicChild.class, "d", true));
assertNull(FieldUtils.getDeclaredField(PubliclyShadowedChild.class, "VALUE", true));
assertEquals(PubliclyShadowedChild.class, FieldUtils.getDeclaredField(PubliclyShadowedChild.class, "s", true).getDeclaringClass());
assertEquals(PubliclyShadowedChild.class, FieldUtils.getDeclaredField(PubliclyShadowedChild.class, "b", true).getDeclaringClass());
assertEquals(PubliclyShadowedChild.class, FieldUtils.getDeclaredField(PubliclyShadowedChild.class, "i", true).getDeclaringClass());
assertEquals(PubliclyShadowedChild.class, FieldUtils.getDeclaredField(PubliclyShadowedChild.class, "d", true).getDeclaringClass());
assertNull(FieldUtils.getDeclaredField(PrivatelyShadowedChild.class, "VALUE", true));
assertEquals(PrivatelyShadowedChild.class, FieldUtils.getDeclaredField(PrivatelyShadowedChild.class, "s", true).getDeclaringClass());
assertEquals(PrivatelyShadowedChild.class, FieldUtils.getDeclaredField(PrivatelyShadowedChild.class, "b", true).getDeclaringClass());
assertEquals(PrivatelyShadowedChild.class, FieldUtils.getDeclaredField(PrivatelyShadowedChild.class, "i", true).getDeclaringClass());
assertEquals(PrivatelyShadowedChild.class, FieldUtils.getDeclaredField(PrivatelyShadowedChild.class, "d", true).getDeclaringClass());
}
@Test(expected = IllegalArgumentException.class)
public void testGetDeclaredFieldForceAccessIllegalArgumentException1() {
FieldUtils.getDeclaredField(null, "none", true);
}
@Test(expected = IllegalArgumentException.class)
public void testGetDeclaredFieldForceAccessIllegalArgumentException2() {
FieldUtils.getDeclaredField(PublicChild.class, null, true);
}
@Test(expected = IllegalArgumentException.class)
public void testGetDeclaredFieldForceAccessIllegalArgumentException3() {
FieldUtils.getDeclaredField(PublicChild.class, "", true);
}
@Test(expected = IllegalArgumentException.class)
public void testGetDeclaredFieldForceAccessIllegalArgumentException4() {
FieldUtils.getDeclaredField(PublicChild.class, " ", true);
}
@Test
public void testReadStaticField() throws Exception {
assertEquals(Foo.VALUE, FieldUtils.readStaticField(FieldUtils.getField(Foo.class, "VALUE")));
}
@Test(expected = IllegalArgumentException.class)
public void testReadStaticFieldIllegalArgumentException1() throws Exception {
FieldUtils.readStaticField(null);
}
@Test(expected = IllegalArgumentException.class)
public void testReadStaticFieldIllegalArgumentException2() throws Exception {
assertEquals(Foo.VALUE, FieldUtils.readStaticField(FieldUtils.getField(Foo.class, "VALUE")));
final Field nonStaticField = FieldUtils.getField(PublicChild.class, "s");
assumeNotNull(nonStaticField);
FieldUtils.readStaticField(nonStaticField);
}
@Test
public void testReadStaticFieldForceAccess() throws Exception {
assertEquals(Foo.VALUE, FieldUtils.readStaticField(FieldUtils.getField(Foo.class, "VALUE")));
assertEquals(Foo.VALUE, FieldUtils.readStaticField(FieldUtils.getField(PublicChild.class, "VALUE")));
}
@Test(expected = IllegalArgumentException.class)
public void testReadStaticFieldForceAccessIllegalArgumentException1() throws Exception {
FieldUtils.readStaticField(null, true);
}
@Test(expected = IllegalArgumentException.class)
public void testReadStaticFieldForceAccessIllegalArgumentException2() throws Exception {
final Field nonStaticField = FieldUtils.getField(PublicChild.class, "s", true);
assumeNotNull(nonStaticField);
FieldUtils.readStaticField(nonStaticField);
}
@Test
public void testReadNamedStaticField() throws Exception {
assertEquals(Foo.VALUE, FieldUtils.readStaticField(Foo.class, "VALUE"));
assertEquals(Foo.VALUE, FieldUtils.readStaticField(PubliclyShadowedChild.class, "VALUE"));
assertEquals(Foo.VALUE, FieldUtils.readStaticField(PrivatelyShadowedChild.class, "VALUE"));
assertEquals(Foo.VALUE, FieldUtils.readStaticField(PublicChild.class, "VALUE"));
try {
FieldUtils.readStaticField(null, "none");
fail("null class should cause an IllegalArgumentException");
} catch (final IllegalArgumentException e) {
// expected
}
try {
FieldUtils.readStaticField(Foo.class, null);
fail("null field name should cause an IllegalArgumentException");
} catch (final IllegalArgumentException e) {
// expected
}
try {
FieldUtils.readStaticField(Foo.class, "");
fail("empty field name should cause an IllegalArgumentException");
} catch (final IllegalArgumentException e) {
// expected
}
try {
FieldUtils.readStaticField(Foo.class, " ");
fail("blank field name should cause an IllegalArgumentException");
} catch (final IllegalArgumentException e) {
// expected
}
try {
FieldUtils.readStaticField(Foo.class, "does_not_exist");
fail("a field that doesn't exist should cause an IllegalArgumentException");
} catch (final IllegalArgumentException e) {
// expected
}
try {
FieldUtils.readStaticField(PublicChild.class, "s");
fail("non-static field should cause an IllegalArgumentException");
} catch (final IllegalArgumentException e) {
// expected
}
}
@Test
public void testReadNamedStaticFieldForceAccess() throws Exception {
assertEquals(Foo.VALUE, FieldUtils.readStaticField(Foo.class, "VALUE", true));
assertEquals(Foo.VALUE, FieldUtils.readStaticField(PubliclyShadowedChild.class, "VALUE", true));
assertEquals(Foo.VALUE, FieldUtils.readStaticField(PrivatelyShadowedChild.class, "VALUE", true));
assertEquals("child", FieldUtils.readStaticField(PublicChild.class, "VALUE", true));
try {
FieldUtils.readStaticField(null, "none", true);
fail("null class should cause an IllegalArgumentException");
} catch (final IllegalArgumentException e) {
// expected
}
try {
FieldUtils.readStaticField(Foo.class, null, true);
fail("null field name should cause an IllegalArgumentException");
} catch (final IllegalArgumentException e) {
// expected
}
try {
FieldUtils.readStaticField(Foo.class, "", true);
fail("empty field name should cause an IllegalArgumentException");
} catch (final IllegalArgumentException e) {
// expected
}
try {
FieldUtils.readStaticField(Foo.class, " ", true);
fail("blank field name should cause an IllegalArgumentException");
} catch (final IllegalArgumentException e) {
// expected
}
try {
FieldUtils.readStaticField(Foo.class, "does_not_exist", true);
fail("a field that doesn't exist should cause an IllegalArgumentException");
} catch (final IllegalArgumentException e) {
// expected
}
try {
FieldUtils.readStaticField(PublicChild.class, "s", false);
fail("non-static field should cause an IllegalArgumentException");
} catch (final IllegalArgumentException e) {
// expected
}
}
@Test
public void testReadDeclaredNamedStaticField() throws Exception {
assertEquals(Foo.VALUE, FieldUtils.readDeclaredStaticField(Foo.class, "VALUE"));
try {
FieldUtils.readDeclaredStaticField(PublicChild.class, "VALUE");
fail("expected IllegalArgumentException");
} catch (final IllegalArgumentException e) {
// pass
}
try {
FieldUtils.readDeclaredStaticField(PubliclyShadowedChild.class, "VALUE");
fail("expected IllegalArgumentException");
} catch (final IllegalArgumentException e) {
// pass
}
try {
FieldUtils.readDeclaredStaticField(PrivatelyShadowedChild.class, "VALUE");
fail("expected IllegalArgumentException");
} catch (final IllegalArgumentException e) {
// pass
}
}
@Test
public void testReadDeclaredNamedStaticFieldForceAccess() throws Exception {
assertEquals(Foo.VALUE, FieldUtils.readDeclaredStaticField(Foo.class, "VALUE", true));
assertEquals("child", FieldUtils.readDeclaredStaticField(PublicChild.class, "VALUE", true));
try {
FieldUtils.readDeclaredStaticField(PubliclyShadowedChild.class, "VALUE", true);
fail("expected IllegalArgumentException");
} catch (final IllegalArgumentException e) {
// pass
}
try {
FieldUtils.readDeclaredStaticField(PrivatelyShadowedChild.class, "VALUE", true);
fail("expected IllegalArgumentException");
} catch (final IllegalArgumentException e) {
// pass
}
}
@Test
public void testReadField() throws Exception {
final Field parentS = FieldUtils.getDeclaredField(parentClass, "s");
assertEquals("s", FieldUtils.readField(parentS, publicChild));
assertEquals("s", FieldUtils.readField(parentS, publiclyShadowedChild));
assertEquals("s", FieldUtils.readField(parentS, privatelyShadowedChild));
final Field parentB = FieldUtils.getDeclaredField(parentClass, "b", true);
assertEquals(Boolean.FALSE, FieldUtils.readField(parentB, publicChild));
assertEquals(Boolean.FALSE, FieldUtils.readField(parentB, publiclyShadowedChild));
assertEquals(Boolean.FALSE, FieldUtils.readField(parentB, privatelyShadowedChild));
final Field parentI = FieldUtils.getDeclaredField(parentClass, "i", true);
assertEquals(I0, FieldUtils.readField(parentI, publicChild));
assertEquals(I0, FieldUtils.readField(parentI, publiclyShadowedChild));
assertEquals(I0, FieldUtils.readField(parentI, privatelyShadowedChild));
final Field parentD = FieldUtils.getDeclaredField(parentClass, "d", true);
assertEquals(D0, FieldUtils.readField(parentD, publicChild));
assertEquals(D0, FieldUtils.readField(parentD, publiclyShadowedChild));
assertEquals(D0, FieldUtils.readField(parentD, privatelyShadowedChild));
try {
FieldUtils.readField(null, publicChild);
fail("a null field should cause an IllegalArgumentException");
} catch (final IllegalArgumentException e) {
// expected
}
}
@Test
public void testReadFieldForceAccess() throws Exception {
final Field parentS = FieldUtils.getDeclaredField(parentClass, "s");
parentS.setAccessible(false);
assertEquals("s", FieldUtils.readField(parentS, publicChild, true));
assertEquals("s", FieldUtils.readField(parentS, publiclyShadowedChild, true));
assertEquals("s", FieldUtils.readField(parentS, privatelyShadowedChild, true));
final Field parentB = FieldUtils.getDeclaredField(parentClass, "b", true);
parentB.setAccessible(false);
assertEquals(Boolean.FALSE, FieldUtils.readField(parentB, publicChild, true));
assertEquals(Boolean.FALSE, FieldUtils.readField(parentB, publiclyShadowedChild, true));
assertEquals(Boolean.FALSE, FieldUtils.readField(parentB, privatelyShadowedChild, true));
final Field parentI = FieldUtils.getDeclaredField(parentClass, "i", true);
parentI.setAccessible(false);
assertEquals(I0, FieldUtils.readField(parentI, publicChild, true));
assertEquals(I0, FieldUtils.readField(parentI, publiclyShadowedChild, true));
assertEquals(I0, FieldUtils.readField(parentI, privatelyShadowedChild, true));
final Field parentD = FieldUtils.getDeclaredField(parentClass, "d", true);
parentD.setAccessible(false);
assertEquals(D0, FieldUtils.readField(parentD, publicChild, true));
assertEquals(D0, FieldUtils.readField(parentD, publiclyShadowedChild, true));
assertEquals(D0, FieldUtils.readField(parentD, privatelyShadowedChild, true));
try {
FieldUtils.readField(null, publicChild, true);
fail("a null field should cause an IllegalArgumentException");
} catch (final IllegalArgumentException e) {
// expected
}
}
@Test
public void testReadNamedField() throws Exception {
assertEquals("s", FieldUtils.readField(publicChild, "s"));
assertEquals("ss", FieldUtils.readField(publiclyShadowedChild, "s"));
assertEquals("s", FieldUtils.readField(privatelyShadowedChild, "s"));
try {
FieldUtils.readField(publicChild, null);
fail("a null field name should cause an IllegalArgumentException");
} catch (final IllegalArgumentException e) {
// expected
}
try {
FieldUtils.readField(publicChild, "");
fail("an empty field name should cause an IllegalArgumentException");
} catch (final IllegalArgumentException e) {
// expected
}
try {
FieldUtils.readField(publicChild, " ");
fail("a blank field name should cause an IllegalArgumentException");
} catch (final IllegalArgumentException e) {
// expected
}
try {
FieldUtils.readField((Object) null, "none");
fail("a null target should cause an IllegalArgumentException");
} catch (final IllegalArgumentException e) {
// expected
}
try {
FieldUtils.readField(publicChild, "b");
fail("expected IllegalArgumentException");
} catch (final IllegalArgumentException e) {
// pass
}
assertEquals(Boolean.TRUE, FieldUtils.readField(publiclyShadowedChild, "b"));
try {
FieldUtils.readField(privatelyShadowedChild, "b");
fail("expected IllegalArgumentException");
} catch (final IllegalArgumentException e) {
// pass
}
try {
FieldUtils.readField(publicChild, "i");
fail("expected IllegalArgumentException");
} catch (final IllegalArgumentException e) {
// pass
}
assertEquals(I1, FieldUtils.readField(publiclyShadowedChild, "i"));
try {
FieldUtils.readField(privatelyShadowedChild, "i");
fail("expected IllegalArgumentException");
} catch (final IllegalArgumentException e) {
// pass
}
try {
FieldUtils.readField(publicChild, "d");
fail("expected IllegalArgumentException");
} catch (final IllegalArgumentException e) {
// pass
}
assertEquals(D1, FieldUtils.readField(publiclyShadowedChild, "d"));
try {
FieldUtils.readField(privatelyShadowedChild, "d");
fail("expected IllegalArgumentException");
} catch (final IllegalArgumentException e) {
// pass
}
}
@Test
public void testReadNamedFieldForceAccess() throws Exception {
assertEquals("s", FieldUtils.readField(publicChild, "s", true));
assertEquals("ss", FieldUtils.readField(publiclyShadowedChild, "s", true));
assertEquals("ss", FieldUtils.readField(privatelyShadowedChild, "s", true));
assertEquals(Boolean.FALSE, FieldUtils.readField(publicChild, "b", true));
assertEquals(Boolean.TRUE, FieldUtils.readField(publiclyShadowedChild, "b", true));
assertEquals(Boolean.TRUE, FieldUtils.readField(privatelyShadowedChild, "b", true));
assertEquals(I0, FieldUtils.readField(publicChild, "i", true));
assertEquals(I1, FieldUtils.readField(publiclyShadowedChild, "i", true));
assertEquals(I1, FieldUtils.readField(privatelyShadowedChild, "i", true));
assertEquals(D0, FieldUtils.readField(publicChild, "d", true));
assertEquals(D1, FieldUtils.readField(publiclyShadowedChild, "d", true));
assertEquals(D1, FieldUtils.readField(privatelyShadowedChild, "d", true));
try {
FieldUtils.readField(publicChild, null, true);
fail("a null field name should cause an IllegalArgumentException");
} catch (final IllegalArgumentException e) {
// expected
}
try {
FieldUtils.readField(publicChild, "", true);
fail("an empty field name should cause an IllegalArgumentException");
} catch (final IllegalArgumentException e) {
// expected
}
try {
FieldUtils.readField(publicChild, " ", true);
fail("a blank field name should cause an IllegalArgumentException");
} catch (final IllegalArgumentException e) {
// expected
}
try {
FieldUtils.readField((Object) null, "none", true);
fail("a null target should cause an IllegalArgumentException");
} catch (final IllegalArgumentException e) {
// expected
}
}
@Test
public void testReadDeclaredNamedField() throws Exception {
try {
FieldUtils.readDeclaredField(publicChild, null);
fail("a null field name should cause an IllegalArgumentException");
} catch (final IllegalArgumentException e) {
// expected
}
try {
FieldUtils.readDeclaredField(publicChild, "");
fail("an empty field name should cause an IllegalArgumentException");
} catch (final IllegalArgumentException e) {
// expected
}
try {
FieldUtils.readDeclaredField(publicChild, " ");
fail("a blank field name should cause an IllegalArgumentException");
} catch (final IllegalArgumentException e) {
// expected
}
try {
FieldUtils.readDeclaredField(null, "none");
fail("a null target should cause an IllegalArgumentException");
} catch (final IllegalArgumentException e) {
// expected
}
try {
FieldUtils.readDeclaredField(publicChild, "s");
fail("expected IllegalArgumentException");
} catch (final IllegalArgumentException e) {
// pass
}
assertEquals("ss", FieldUtils.readDeclaredField(publiclyShadowedChild, "s"));
try {
FieldUtils.readDeclaredField(privatelyShadowedChild, "s");
fail("expected IllegalArgumentException");
} catch (final IllegalArgumentException e) {
// pass
}
try {
FieldUtils.readDeclaredField(publicChild, "b");
fail("expected IllegalArgumentException");
} catch (final IllegalArgumentException e) {
// pass
}
assertEquals(Boolean.TRUE, FieldUtils.readDeclaredField(publiclyShadowedChild, "b"));
try {
FieldUtils.readDeclaredField(privatelyShadowedChild, "b");
fail("expected IllegalArgumentException");
} catch (final IllegalArgumentException e) {
// pass
}
try {
FieldUtils.readDeclaredField(publicChild, "i");
fail("expected IllegalArgumentException");
} catch (final IllegalArgumentException e) {
// pass
}
assertEquals(I1, FieldUtils.readDeclaredField(publiclyShadowedChild, "i"));
try {
FieldUtils.readDeclaredField(privatelyShadowedChild, "i");
fail("expected IllegalArgumentException");
} catch (final IllegalArgumentException e) {
// pass
}
try {
FieldUtils.readDeclaredField(publicChild, "d");
fail("expected IllegalArgumentException");
} catch (final IllegalArgumentException e) {
// pass
}
assertEquals(D1, FieldUtils.readDeclaredField(publiclyShadowedChild, "d"));
try {
FieldUtils.readDeclaredField(privatelyShadowedChild, "d");
fail("expected IllegalArgumentException");
} catch (final IllegalArgumentException e) {
// pass
}
}
@Test
public void testReadDeclaredNamedFieldForceAccess() throws Exception {
try {
FieldUtils.readDeclaredField(publicChild, null, true);
fail("a null field name should cause an IllegalArgumentException");
} catch (final IllegalArgumentException e) {
// expected
}
try {
FieldUtils.readDeclaredField(publicChild, "", true);
fail("an empty field name should cause an IllegalArgumentException");
} catch (final IllegalArgumentException e) {
// expected
}
try {
FieldUtils.readDeclaredField(publicChild, " ", true);
fail("a blank field name should cause an IllegalArgumentException");
} catch (final IllegalArgumentException e) {
// expected
}
try {
FieldUtils.readDeclaredField(null, "none", true);
fail("a null target should cause an IllegalArgumentException");
} catch (final IllegalArgumentException e) {
// expected
}
try {
FieldUtils.readDeclaredField(publicChild, "s", true);
fail("expected IllegalArgumentException");
} catch (final IllegalArgumentException e) {
// pass
}
assertEquals("ss", FieldUtils.readDeclaredField(publiclyShadowedChild, "s", true));
assertEquals("ss", FieldUtils.readDeclaredField(privatelyShadowedChild, "s", true));
try {
FieldUtils.readDeclaredField(publicChild, "b", true);
fail("expected IllegalArgumentException");
} catch (final IllegalArgumentException e) {
// pass
}
assertEquals(Boolean.TRUE, FieldUtils.readDeclaredField(publiclyShadowedChild, "b", true));
assertEquals(Boolean.TRUE, FieldUtils.readDeclaredField(privatelyShadowedChild, "b", true));
try {
FieldUtils.readDeclaredField(publicChild, "i", true);
fail("expected IllegalArgumentException");
} catch (final IllegalArgumentException e) {
// pass
}
assertEquals(I1, FieldUtils.readDeclaredField(publiclyShadowedChild, "i", true));
assertEquals(I1, FieldUtils.readDeclaredField(privatelyShadowedChild, "i", true));
try {
FieldUtils.readDeclaredField(publicChild, "d", true);
fail("expected IllegalArgumentException");
} catch (final IllegalArgumentException e) {
// pass
}
assertEquals(D1, FieldUtils.readDeclaredField(publiclyShadowedChild, "d", true));
assertEquals(D1, FieldUtils.readDeclaredField(privatelyShadowedChild, "d", true));
}
@Test
public void testWriteStaticField() throws Exception {
Field field = StaticContainer.class.getDeclaredField("mutablePublic");
FieldUtils.writeStaticField(field, "new");
assertEquals("new", StaticContainer.mutablePublic);
field = StaticContainer.class.getDeclaredField("mutableProtected");
try {
FieldUtils.writeStaticField(field, "new");
fail("Expected IllegalAccessException");
} catch (final IllegalAccessException e) {
// pass
}
field = StaticContainer.class.getDeclaredField("mutablePackage");
try {
FieldUtils.writeStaticField(field, "new");
fail("Expected IllegalAccessException");
} catch (final IllegalAccessException e) {
// pass
}
field = StaticContainer.class.getDeclaredField("mutablePrivate");
try {
FieldUtils.writeStaticField(field, "new");
fail("Expected IllegalAccessException");
} catch (final IllegalAccessException e) {
// pass
}
field = StaticContainer.class.getDeclaredField("IMMUTABLE_PUBLIC");
try {
FieldUtils.writeStaticField(field, "new");
fail("Expected IllegalAccessException");
} catch (final IllegalAccessException e) {
// pass
}
field = StaticContainer.class.getDeclaredField("IMMUTABLE_PROTECTED");
try {
FieldUtils.writeStaticField(field, "new");
fail("Expected IllegalAccessException");
} catch (final IllegalAccessException e) {
// pass
}
field = StaticContainer.class.getDeclaredField("IMMUTABLE_PACKAGE");
try {
FieldUtils.writeStaticField(field, "new");
fail("Expected IllegalAccessException");
} catch (final IllegalAccessException e) {
// pass
}
field = StaticContainer.class.getDeclaredField("IMMUTABLE_PRIVATE");
try {
FieldUtils.writeStaticField(field, "new");
fail("Expected IllegalAccessException");
} catch (final IllegalAccessException e) {
// pass
}
}
@Test
public void testWriteStaticFieldForceAccess() throws Exception {
Field field = StaticContainer.class.getDeclaredField("mutablePublic");
FieldUtils.writeStaticField(field, "new", true);
assertEquals("new", StaticContainer.mutablePublic);
field = StaticContainer.class.getDeclaredField("mutableProtected");
FieldUtils.writeStaticField(field, "new", true);
assertEquals("new", StaticContainer.getMutableProtected());
field = StaticContainer.class.getDeclaredField("mutablePackage");
FieldUtils.writeStaticField(field, "new", true);
assertEquals("new", StaticContainer.getMutablePackage());
field = StaticContainer.class.getDeclaredField("mutablePrivate");
FieldUtils.writeStaticField(field, "new", true);
assertEquals("new", StaticContainer.getMutablePrivate());
field = StaticContainer.class.getDeclaredField("IMMUTABLE_PUBLIC");
try {
FieldUtils.writeStaticField(field, "new", true);
fail("Expected IllegalAccessException");
} catch (final IllegalAccessException e) {
// pass
}
field = StaticContainer.class.getDeclaredField("IMMUTABLE_PROTECTED");
try {
FieldUtils.writeStaticField(field, "new", true);
fail("Expected IllegalAccessException");
} catch (final IllegalAccessException e) {
// pass
}
field = StaticContainer.class.getDeclaredField("IMMUTABLE_PACKAGE");
try {
FieldUtils.writeStaticField(field, "new", true);
fail("Expected IllegalAccessException");
} catch (final IllegalAccessException e) {
// pass
}
field = StaticContainer.class.getDeclaredField("IMMUTABLE_PRIVATE");
try {
FieldUtils.writeStaticField(field, "new", true);
fail("Expected IllegalAccessException");
} catch (final IllegalAccessException e) {
// pass
}
}
@Test
public void testWriteNamedStaticField() throws Exception {
FieldUtils.writeStaticField(StaticContainerChild.class, "mutablePublic", "new");
assertEquals("new", StaticContainer.mutablePublic);
try {
FieldUtils.writeStaticField(StaticContainerChild.class, "mutableProtected", "new");
fail("Expected IllegalArgumentException");
} catch (final IllegalArgumentException e) {
// pass
}
try {
FieldUtils.writeStaticField(StaticContainerChild.class, "mutablePackage", "new");
fail("Expected IllegalArgumentException");
} catch (final IllegalArgumentException e) {
// pass
}
try {
FieldUtils.writeStaticField(StaticContainerChild.class, "mutablePrivate", "new");
fail("Expected IllegalArgumentException");
} catch (final IllegalArgumentException e) {
// pass
}
try {
FieldUtils.writeStaticField(StaticContainerChild.class, "IMMUTABLE_PUBLIC", "new");
fail("Expected IllegalAccessException");
} catch (final IllegalAccessException e) {
// pass
}
try {
FieldUtils.writeStaticField(StaticContainerChild.class, "IMMUTABLE_PROTECTED", "new");
fail("Expected IllegalArgumentException");
} catch (final IllegalArgumentException e) {
// pass
}
try {
FieldUtils.writeStaticField(StaticContainerChild.class, "IMMUTABLE_PACKAGE", "new");
fail("Expected IllegalArgumentException");
} catch (final IllegalArgumentException e) {
// pass
}
try {
FieldUtils.writeStaticField(StaticContainerChild.class, "IMMUTABLE_PRIVATE", "new");
fail("Expected IllegalArgumentException");
} catch (final IllegalArgumentException e) {
// pass
}
}
@Test
public void testWriteNamedStaticFieldForceAccess() throws Exception {
FieldUtils.writeStaticField(StaticContainerChild.class, "mutablePublic", "new", true);
assertEquals("new", StaticContainer.mutablePublic);
FieldUtils.writeStaticField(StaticContainerChild.class, "mutableProtected", "new", true);
assertEquals("new", StaticContainer.getMutableProtected());
FieldUtils.writeStaticField(StaticContainerChild.class, "mutablePackage", "new", true);
assertEquals("new", StaticContainer.getMutablePackage());
FieldUtils.writeStaticField(StaticContainerChild.class, "mutablePrivate", "new", true);
assertEquals("new", StaticContainer.getMutablePrivate());
try {
FieldUtils.writeStaticField(StaticContainerChild.class, "IMMUTABLE_PUBLIC", "new", true);
fail("Expected IllegalAccessException");
} catch (final IllegalAccessException e) {
// pass
}
try {
FieldUtils.writeStaticField(StaticContainerChild.class, "IMMUTABLE_PROTECTED", "new", true);
fail("Expected IllegalAccessException");
} catch (final IllegalAccessException e) {
// pass
}
try {
FieldUtils.writeStaticField(StaticContainerChild.class, "IMMUTABLE_PACKAGE", "new", true);
fail("Expected IllegalAccessException");
} catch (final IllegalAccessException e) {
// pass
}
try {
FieldUtils.writeStaticField(StaticContainerChild.class, "IMMUTABLE_PRIVATE", "new", true);
fail("Expected IllegalAccessException");
} catch (final IllegalAccessException e) {
// pass
}
}
@Test
public void testWriteDeclaredNamedStaticField() throws Exception {
FieldUtils.writeStaticField(StaticContainer.class, "mutablePublic", "new");
assertEquals("new", StaticContainer.mutablePublic);
try {
FieldUtils.writeDeclaredStaticField(StaticContainer.class, "mutableProtected", "new");
fail("Expected IllegalArgumentException");
} catch (final IllegalArgumentException e) {
// pass
}
try {
FieldUtils.writeDeclaredStaticField(StaticContainer.class, "mutablePackage", "new");
fail("Expected IllegalArgumentException");
} catch (final IllegalArgumentException e) {
// pass
}
try {
FieldUtils.writeDeclaredStaticField(StaticContainer.class, "mutablePrivate", "new");
fail("Expected IllegalArgumentException");
} catch (final IllegalArgumentException e) {
// pass
}
try {
FieldUtils.writeDeclaredStaticField(StaticContainer.class, "IMMUTABLE_PUBLIC", "new");
fail("Expected IllegalAccessException");
} catch (final IllegalAccessException e) {
// pass
}
try {
FieldUtils.writeDeclaredStaticField(StaticContainer.class, "IMMUTABLE_PROTECTED", "new");
fail("Expected IllegalArgumentException");
} catch (final IllegalArgumentException e) {
// pass
}
try {
FieldUtils.writeDeclaredStaticField(StaticContainer.class, "IMMUTABLE_PACKAGE", "new");
fail("Expected IllegalArgumentException");
} catch (final IllegalArgumentException e) {
// pass
}
try {
FieldUtils.writeDeclaredStaticField(StaticContainer.class, "IMMUTABLE_PRIVATE", "new");
fail("Expected IllegalArgumentException");
} catch (final IllegalArgumentException e) {
// pass
}
}
@Test
public void testWriteDeclaredNamedStaticFieldForceAccess() throws Exception {
FieldUtils.writeDeclaredStaticField(StaticContainer.class, "mutablePublic", "new", true);
assertEquals("new", StaticContainer.mutablePublic);
FieldUtils.writeDeclaredStaticField(StaticContainer.class, "mutableProtected", "new", true);
assertEquals("new", StaticContainer.getMutableProtected());
FieldUtils.writeDeclaredStaticField(StaticContainer.class, "mutablePackage", "new", true);
assertEquals("new", StaticContainer.getMutablePackage());
FieldUtils.writeDeclaredStaticField(StaticContainer.class, "mutablePrivate", "new", true);
assertEquals("new", StaticContainer.getMutablePrivate());
try {
FieldUtils.writeDeclaredStaticField(StaticContainer.class, "IMMUTABLE_PUBLIC", "new", true);
fail("Expected IllegalAccessException");
} catch (final IllegalAccessException e) {
// pass
}
try {
FieldUtils.writeDeclaredStaticField(StaticContainer.class, "IMMUTABLE_PROTECTED", "new", true);
fail("Expected IllegalAccessException");
} catch (final IllegalAccessException e) {
// pass
}
try {
FieldUtils.writeDeclaredStaticField(StaticContainer.class, "IMMUTABLE_PACKAGE", "new", true);
fail("Expected IllegalAccessException");
} catch (final IllegalAccessException e) {
// pass
}
try {
FieldUtils.writeDeclaredStaticField(StaticContainer.class, "IMMUTABLE_PRIVATE", "new", true);
fail("Expected IllegalAccessException");
} catch (final IllegalAccessException e) {
// pass
}
}
@Test
public void testWriteField() throws Exception {
Field field = parentClass.getDeclaredField("s");
FieldUtils.writeField(field, publicChild, "S");
assertEquals("S", field.get(publicChild));
field = parentClass.getDeclaredField("b");
try {
FieldUtils.writeField(field, publicChild, Boolean.TRUE);
fail("Expected IllegalAccessException");
} catch (final IllegalAccessException e) {
// pass
}
field = parentClass.getDeclaredField("i");
try {
FieldUtils.writeField(field, publicChild, Integer.valueOf(Integer.MAX_VALUE));
fail("Expected IllegalAccessException");
} catch (final IllegalAccessException e) {
// pass
}
field = parentClass.getDeclaredField("d");
try {
FieldUtils.writeField(field, publicChild, Double.valueOf(Double.MAX_VALUE));
fail("Expected IllegalAccessException");
} catch (final IllegalAccessException e) {
// pass
}
}
@Test
public void testWriteFieldForceAccess() throws Exception {
Field field = parentClass.getDeclaredField("s");
FieldUtils.writeField(field, publicChild, "S", true);
assertEquals("S", field.get(publicChild));
field = parentClass.getDeclaredField("b");
FieldUtils.writeField(field, publicChild, Boolean.TRUE, true);
assertEquals(Boolean.TRUE, field.get(publicChild));
field = parentClass.getDeclaredField("i");
FieldUtils.writeField(field, publicChild, Integer.valueOf(Integer.MAX_VALUE), true);
assertEquals(Integer.valueOf(Integer.MAX_VALUE), field.get(publicChild));
field = parentClass.getDeclaredField("d");
FieldUtils.writeField(field, publicChild, Double.valueOf(Double.MAX_VALUE), true);
assertEquals(Double.valueOf(Double.MAX_VALUE), field.get(publicChild));
}
@Test
public void testWriteNamedField() throws Exception {
FieldUtils.writeField(publicChild, "s", "S");
assertEquals("S", FieldUtils.readField(publicChild, "s"));
try {
FieldUtils.writeField(publicChild, "b", Boolean.TRUE);
fail("Expected IllegalArgumentException");
} catch (final IllegalArgumentException e) {
// pass
}
try {
FieldUtils.writeField(publicChild, "i", Integer.valueOf(1));
fail("Expected IllegalArgumentException");
} catch (final IllegalArgumentException e) {
// pass
}
try {
FieldUtils.writeField(publicChild, "d", Double.valueOf(1.0));
fail("Expected IllegalArgumentException");
} catch (final IllegalArgumentException e) {
// pass
}
FieldUtils.writeField(publiclyShadowedChild, "s", "S");
assertEquals("S", FieldUtils.readField(publiclyShadowedChild, "s"));
FieldUtils.writeField(publiclyShadowedChild, "b", Boolean.FALSE);
assertEquals(Boolean.FALSE, FieldUtils.readField(publiclyShadowedChild, "b"));
FieldUtils.writeField(publiclyShadowedChild, "i", Integer.valueOf(0));
assertEquals(Integer.valueOf(0), FieldUtils.readField(publiclyShadowedChild, "i"));
FieldUtils.writeField(publiclyShadowedChild, "d", Double.valueOf(0.0));
assertEquals(Double.valueOf(0.0), FieldUtils.readField(publiclyShadowedChild, "d"));
FieldUtils.writeField(privatelyShadowedChild, "s", "S");
assertEquals("S", FieldUtils.readField(privatelyShadowedChild, "s"));
try {
FieldUtils.writeField(privatelyShadowedChild, "b", Boolean.TRUE);
fail("Expected IllegalArgumentException");
} catch (final IllegalArgumentException e) {
// pass
}
try {
FieldUtils.writeField(privatelyShadowedChild, "i", Integer.valueOf(1));
fail("Expected IllegalArgumentException");
} catch (final IllegalArgumentException e) {
// pass
}
try {
FieldUtils.writeField(privatelyShadowedChild, "d", Double.valueOf(1.0));
fail("Expected IllegalArgumentException");
} catch (final IllegalArgumentException e) {
// pass
}
}
@Test
public void testWriteNamedFieldForceAccess() throws Exception {
FieldUtils.writeField(publicChild, "s", "S", true);
assertEquals("S", FieldUtils.readField(publicChild, "s", true));
FieldUtils.writeField(publicChild, "b", Boolean.TRUE, true);
assertEquals(Boolean.TRUE, FieldUtils.readField(publicChild, "b", true));
FieldUtils.writeField(publicChild, "i", Integer.valueOf(1), true);
assertEquals(Integer.valueOf(1), FieldUtils.readField(publicChild, "i", true));
FieldUtils.writeField(publicChild, "d", Double.valueOf(1.0), true);
assertEquals(Double.valueOf(1.0), FieldUtils.readField(publicChild, "d", true));
FieldUtils.writeField(publiclyShadowedChild, "s", "S", true);
assertEquals("S", FieldUtils.readField(publiclyShadowedChild, "s", true));
FieldUtils.writeField(publiclyShadowedChild, "b", Boolean.FALSE, true);
assertEquals(Boolean.FALSE, FieldUtils.readField(publiclyShadowedChild, "b", true));
FieldUtils.writeField(publiclyShadowedChild, "i", Integer.valueOf(0), true);
assertEquals(Integer.valueOf(0), FieldUtils.readField(publiclyShadowedChild, "i", true));
FieldUtils.writeField(publiclyShadowedChild, "d", Double.valueOf(0.0), true);
assertEquals(Double.valueOf(0.0), FieldUtils.readField(publiclyShadowedChild, "d", true));
FieldUtils.writeField(privatelyShadowedChild, "s", "S", true);
assertEquals("S", FieldUtils.readField(privatelyShadowedChild, "s", true));
FieldUtils.writeField(privatelyShadowedChild, "b", Boolean.FALSE, true);
assertEquals(Boolean.FALSE, FieldUtils.readField(privatelyShadowedChild, "b", true));
FieldUtils.writeField(privatelyShadowedChild, "i", Integer.valueOf(0), true);
assertEquals(Integer.valueOf(0), FieldUtils.readField(privatelyShadowedChild, "i", true));
FieldUtils.writeField(privatelyShadowedChild, "d", Double.valueOf(0.0), true);
assertEquals(Double.valueOf(0.0), FieldUtils.readField(privatelyShadowedChild, "d", true));
}
@Test
public void testWriteDeclaredNamedField() throws Exception {
try {
FieldUtils.writeDeclaredField(publicChild, "s", "S");
fail("Expected IllegalArgumentException");
} catch (final IllegalArgumentException e) {
// pass
}
try {
FieldUtils.writeDeclaredField(publicChild, "b", Boolean.TRUE);
fail("Expected IllegalArgumentException");
} catch (final IllegalArgumentException e) {
// pass
}
try {
FieldUtils.writeDeclaredField(publicChild, "i", Integer.valueOf(1));
fail("Expected IllegalArgumentException");
} catch (final IllegalArgumentException e) {
// pass
}
try {
FieldUtils.writeDeclaredField(publicChild, "d", Double.valueOf(1.0));
fail("Expected IllegalArgumentException");
} catch (final IllegalArgumentException e) {
// pass
}
FieldUtils.writeDeclaredField(publiclyShadowedChild, "s", "S");
assertEquals("S", FieldUtils.readDeclaredField(publiclyShadowedChild, "s"));
FieldUtils.writeDeclaredField(publiclyShadowedChild, "b", Boolean.FALSE);
assertEquals(Boolean.FALSE, FieldUtils.readDeclaredField(publiclyShadowedChild, "b"));
FieldUtils.writeDeclaredField(publiclyShadowedChild, "i", Integer.valueOf(0));
assertEquals(Integer.valueOf(0), FieldUtils.readDeclaredField(publiclyShadowedChild, "i"));
FieldUtils.writeDeclaredField(publiclyShadowedChild, "d", Double.valueOf(0.0));
assertEquals(Double.valueOf(0.0), FieldUtils.readDeclaredField(publiclyShadowedChild, "d"));
try {
FieldUtils.writeDeclaredField(privatelyShadowedChild, "s", "S");
fail("Expected IllegalArgumentException");
} catch (final IllegalArgumentException e) {
// pass
}
try {
FieldUtils.writeDeclaredField(privatelyShadowedChild, "b", Boolean.TRUE);
fail("Expected IllegalArgumentException");
} catch (final IllegalArgumentException e) {
// pass
}
try {
FieldUtils.writeDeclaredField(privatelyShadowedChild, "i", Integer.valueOf(1));
fail("Expected IllegalArgumentException");
} catch (final IllegalArgumentException e) {
// pass
}
try {
FieldUtils.writeDeclaredField(privatelyShadowedChild, "d", Double.valueOf(1.0));
fail("Expected IllegalArgumentException");
} catch (final IllegalArgumentException e) {
// pass
}
}
@Test
public void testWriteDeclaredNamedFieldForceAccess() throws Exception {
try {
FieldUtils.writeDeclaredField(publicChild, "s", "S", true);
fail("Expected IllegalArgumentException");
} catch (final IllegalArgumentException e) {
// pass
}
try {
FieldUtils.writeDeclaredField(publicChild, "b", Boolean.TRUE, true);
fail("Expected IllegalArgumentException");
} catch (final IllegalArgumentException e) {
// pass
}
try {
FieldUtils.writeDeclaredField(publicChild, "i", Integer.valueOf(1), true);
fail("Expected IllegalArgumentException");
} catch (final IllegalArgumentException e) {
// pass
}
try {
FieldUtils.writeDeclaredField(publicChild, "d", Double.valueOf(1.0), true);
fail("Expected IllegalArgumentException");
} catch (final IllegalArgumentException e) {
// pass
}
FieldUtils.writeDeclaredField(publiclyShadowedChild, "s", "S", true);
assertEquals("S", FieldUtils.readDeclaredField(publiclyShadowedChild, "s", true));
FieldUtils.writeDeclaredField(publiclyShadowedChild, "b", Boolean.FALSE, true);
assertEquals(Boolean.FALSE, FieldUtils.readDeclaredField(publiclyShadowedChild, "b", true));
FieldUtils.writeDeclaredField(publiclyShadowedChild, "i", Integer.valueOf(0), true);
assertEquals(Integer.valueOf(0), FieldUtils.readDeclaredField(publiclyShadowedChild, "i", true));
FieldUtils.writeDeclaredField(publiclyShadowedChild, "d", Double.valueOf(0.0), true);
assertEquals(Double.valueOf(0.0), FieldUtils.readDeclaredField(publiclyShadowedChild, "d", true));
FieldUtils.writeDeclaredField(privatelyShadowedChild, "s", "S", true);
assertEquals("S", FieldUtils.readDeclaredField(privatelyShadowedChild, "s", true));
FieldUtils.writeDeclaredField(privatelyShadowedChild, "b", Boolean.FALSE, true);
assertEquals(Boolean.FALSE, FieldUtils.readDeclaredField(privatelyShadowedChild, "b", true));
FieldUtils.writeDeclaredField(privatelyShadowedChild, "i", Integer.valueOf(0), true);
assertEquals(Integer.valueOf(0), FieldUtils.readDeclaredField(privatelyShadowedChild, "i", true));
FieldUtils.writeDeclaredField(privatelyShadowedChild, "d", Double.valueOf(0.0), true);
assertEquals(Double.valueOf(0.0), FieldUtils.readDeclaredField(privatelyShadowedChild, "d", true));
}
@Test(expected = IllegalArgumentException.class)
public void testAmbig() {
FieldUtils.getField(Ambig.class, "VALUE");
}
@Test
public void testRemoveFinalModifier() throws Exception {
final Field field = StaticContainer.class.getDeclaredField("IMMUTABLE_PRIVATE_2");
assertFalse(field.isAccessible());
assertTrue(Modifier.isFinal(field.getModifiers()));
FieldUtils.removeFinalModifier(field);
// The field is no longer final
assertFalse(Modifier.isFinal(field.getModifiers()));
assertFalse(field.isAccessible());
}
@Test
public void testRemoveFinalModifierWithAccess() throws Exception {
final Field field = StaticContainer.class.getDeclaredField("IMMUTABLE_PRIVATE_2");
assertFalse(field.isAccessible());
assertTrue(Modifier.isFinal(field.getModifiers()));
FieldUtils.removeFinalModifier(field, true);
// The field is no longer final
assertFalse(Modifier.isFinal(field.getModifiers()));
assertFalse(field.isAccessible());
}
@Test
public void testRemoveFinalModifierWithoutAccess() throws Exception {
final Field field = StaticContainer.class.getDeclaredField("IMMUTABLE_PRIVATE_2");
assertFalse(field.isAccessible());
assertTrue(Modifier.isFinal(field.getModifiers()));
FieldUtils.removeFinalModifier(field, false);
// The field is STILL final because we did not force access
assertTrue(Modifier.isFinal(field.getModifiers()));
assertFalse(field.isAccessible());
}
@Test
public void testRemoveFinalModifierAccessNotNeeded() throws Exception {
final Field field = StaticContainer.class.getDeclaredField("IMMUTABLE_PACKAGE");
assertFalse(field.isAccessible());
assertTrue(Modifier.isFinal(field.getModifiers()));
FieldUtils.removeFinalModifier(field, false);
// The field is no longer final AND we did not need to force access
assertTrue(Modifier.isFinal(field.getModifiers()));
assertFalse(field.isAccessible());
}
}
Other Java examples (source code examples)
Here is a short list of links related to this Java FieldUtilsTest.java source code file:
|