LazyDynaMapTest.java
/*
* 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
*
* https://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.beanutils2;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
/**
* <p>
* Test Case for the {@code LazyDynaMap} implementation class.
* </p>
*/
class LazyDynaMapTest {
protected LazyDynaMap dynaMap;
protected String testProperty = "myProperty";
protected String testPropertyA = "myProperty-A";
protected String testPropertyB = "myProperty-B";
protected String testString1 = "myStringValue-1";
protected String testString2 = "myStringValue-2";
protected Integer testInteger1 = Integer.valueOf(30);
protected Integer testInteger2 = Integer.valueOf(40);
protected String testKey = "myKey";
/**
* Sets up instance variables required by this test case.
*/
@BeforeEach
public void setUp() throws Exception {
dynaMap = new LazyDynaMap();
dynaMap.setReturnNull(true);
}
/**
* Tear down instance variables required by this test case.
*/
@AfterEach
public void tearDown() {
dynaMap = null;
}
/**
* General Tests
*/
@Test
void testGeneral() {
// LazyDynaMap bean = new LazyDynaMap("TestBean");
assertEquals("TestBean", new LazyDynaMap("TestBean").getName(), "Check DynaClass name");
}
/**
* Test Getting/Setting an DynaBean[] array
*/
@Test
void testIndexedDynaBeanArray() {
final int index = 3;
final Object objectArray = new LazyDynaBean[0];
// Check the property & value doesn't exist
assertNull(dynaMap.getDynaProperty(testProperty), "Check Indexed Property doesn't exist");
assertNull(dynaMap.get(testProperty), "Check Indexed Property is null");
// Add a DynaProperty of type String[]
dynaMap.add(testProperty, objectArray.getClass());
assertEquals(objectArray.getClass(), dynaMap.getDynaProperty(testProperty).getType(), "Check Indexed Property exists");
assertEquals(objectArray.getClass(), dynaMap.get(testProperty).getClass(), "Check Indexed Property is correct type");
// Retrieving from Array should initialize DynaBean
for (int i = index; i >= 0; i--) {
assertEquals(LazyDynaBean.class, dynaMap.get(testProperty, index).getClass(), "Check Array Components initialized");
}
dynaMap.add(testPropertyB, objectArray.getClass());
final LazyDynaBean newBean = new LazyDynaBean();
newBean.set(testPropertyB, testString2);
dynaMap.set(testPropertyA, index, newBean);
assertEquals(testString2, ((DynaBean) dynaMap.get(testPropertyA, index)).get(testPropertyB), "Check Indexed Value is correct(a)");
}
/**
* Test setting indexed property for type which is not List or Array
*/
@Test
void testIndexedInvalidType() {
final int index = 3;
dynaMap.set(testProperty, "Test String");
assertFalse(dynaMap.getDynaProperty(testProperty).isIndexed(), "Check Property is not indexed");
assertThrows(IllegalArgumentException.class, () -> dynaMap.set(testProperty, index, testString1));
}
/**
* Test Getting/Setting a List 'Indexed' Property - use alternative List (LinkedList)
*/
@Test
void testIndexedLinkedList() {
int index = 3;
// Check the property & value doesn't exist
assertNull(dynaMap.getDynaProperty(testProperty), "Check Indexed Property doesn't exist");
assertNull(dynaMap.get(testProperty), "Check Indexed Property is null");
// Add a 'LinkedList' property to the DynaClass - should instantiate a new LinkedList
dynaMap.add(testProperty, LinkedList.class);
assertTrue(dynaMap.getDynaProperty(testProperty).isIndexed(), "Check Property is indexed");
assertEquals(LinkedList.class, dynaMap.getDynaProperty(testProperty).getType(), "Check Property is correct type");
assertEquals(LinkedList.class, dynaMap.get(testProperty).getClass(), "Check Indexed Property now exists");
// Set the Indexed property, should grow the list to the correct size
dynaMap.set(testProperty, index, testString1);
assertEquals(LinkedList.class, dynaMap.get(testProperty).getClass(), "Check Property type is correct");
assertEquals(testString1, dynaMap.get(testProperty, index), "Check First Indexed Value is correct");
assertEquals(Integer.valueOf(index + 1), Integer.valueOf(((LinkedList<?>) dynaMap.get(testProperty)).size()), "Check First Array length is correct");
// Set a second indexed value, should automatically grow the LinkedList and set appropriate indexed value
index += 2;
dynaMap.set(testProperty, index, testInteger1);
assertEquals(testInteger1, dynaMap.get(testProperty, index), "Check Second Indexed Value is correct");
assertEquals(Integer.valueOf(index + 1), Integer.valueOf(((LinkedList<?>) dynaMap.get(testProperty)).size()), "Check Second Array length is correct");
}
/**
* Test Getting/Setting an Object array 'Indexed' Property - use String[]
*/
@Test
void testIndexedObjectArray() {
int index = 3;
final Object objectArray = new String[0];
// Check the property & value doesn't exist
assertNull(dynaMap.getDynaProperty(testProperty), "Check Indexed Property doesn't exist");
assertNull(dynaMap.get(testProperty), "Check Indexed Property is null");
// Add a DynaProperty of type String[]
dynaMap.add(testProperty, objectArray.getClass());
assertEquals(objectArray.getClass(), dynaMap.getDynaProperty(testProperty).getType(), "Check Indexed Property exists");
assertTrue(dynaMap.get(testProperty).getClass().isInstance(objectArray), "Check Indexed Property exists");
// Set an indexed value
dynaMap.set(testProperty, index, testString1);
assertNotNull(dynaMap.get(testProperty), "Check Indexed Property is not null");
assertEquals(objectArray.getClass(), dynaMap.get(testProperty).getClass(), "Check Indexed Property is correct type");
assertEquals(testString1, dynaMap.get(testProperty, index), "Check First Indexed Value is correct(a)");
assertEquals(testString1, ((String[]) dynaMap.get(testProperty))[index], "Check First Indexed Value is correct(b)");
assertEquals(Integer.valueOf(index + 1), Integer.valueOf(((String[]) dynaMap.get(testProperty)).length), "Check Array length is correct");
// Set a second indexed value, should automatically grow the String[] and set appropriate indexed value
index += 2;
dynaMap.set(testProperty, index, testString2);
assertEquals(testString2, dynaMap.get(testProperty, index), "Check Second Indexed Value is correct(a)");
assertEquals(testString2, ((String[]) dynaMap.get(testProperty))[index], "Check Second Indexed Value is correct(b)");
assertEquals(Integer.valueOf(index + 1), Integer.valueOf(((String[]) dynaMap.get(testProperty)).length), "Check Second Array length is correct");
}
/**
* Test Getting/Setting a primitive array 'Indexed' Property - use int[]
*/
@Test
void testIndexedPrimitiveArray() {
int index = 3;
final int[] primitiveArray = {};
// Check the property & value doesn't exist
assertNull(dynaMap.getDynaProperty(testProperty), "Check Indexed Property doesn't exist");
assertNull(dynaMap.get(testProperty), "Check Indexed Property is null");
// Add a DynaProperty of type int[]
dynaMap.add(testProperty, primitiveArray.getClass());
assertEquals(primitiveArray.getClass(), dynaMap.getDynaProperty(testProperty).getType(), "Check Indexed Property exists");
assertTrue(dynaMap.get(testProperty).getClass().isInstance(primitiveArray), "Check Indexed Property exists");
// Set an indexed value
dynaMap.set(testProperty, index, testInteger1);
assertNotNull(dynaMap.get(testProperty), "Check Indexed Property is not null");
assertEquals(primitiveArray.getClass(), dynaMap.get(testProperty).getClass(), "Check Indexed Property is correct type");
assertEquals(testInteger1, dynaMap.get(testProperty, index), "Check First Indexed Value is correct(a)");
assertEquals(testInteger1, Integer.valueOf(((int[]) dynaMap.get(testProperty))[index]), "Check First Indexed Value is correct(b)");
assertEquals(Integer.valueOf(index + 1), Integer.valueOf(((int[]) dynaMap.get(testProperty)).length), "Check Array length is correct");
// Set a second indexed value, should automatically grow the int[] and set appropriate indexed value
index += 2;
dynaMap.set(testProperty, index, testInteger2);
assertEquals(testInteger2, dynaMap.get(testProperty, index), "Check Second Indexed Value is correct(a)");
assertEquals(testInteger2, Integer.valueOf(((int[]) dynaMap.get(testProperty))[index]), "Check Second Indexed Value is correct(b)");
assertEquals(Integer.valueOf(index + 1), Integer.valueOf(((int[]) dynaMap.get(testProperty)).length), "Check Second Array length is correct");
}
/**
* Test Getting/Setting an 'Indexed' Property - default ArrayList property
*/
@Test
void testIndexedPropertyDefault() {
int index = 3;
// Check the property & value doesn't exist
assertNull(dynaMap.getDynaProperty(testProperty), "Check Indexed Property doesn't exist");
assertNull(dynaMap.get(testProperty), "Check Indexed Property is null");
assertNull(dynaMap.get(testProperty, index), "Check Indexed value is null");
// Set the property, should create new ArrayList and set appropriate indexed value
dynaMap.set(testProperty, index, testInteger1);
assertNotNull(dynaMap.get(testProperty), "Check Indexed Property is not null");
assertEquals(ArrayList.class, dynaMap.get(testProperty).getClass(), "Check Indexed Property is correct type");
assertEquals(testInteger1, dynaMap.get(testProperty, index), "Check First Indexed Value is correct");
assertEquals(Integer.valueOf(index + 1), Integer.valueOf(((ArrayList<?>) dynaMap.get(testProperty)).size()), "Check First Array length is correct");
// Set a second indexed value, should automatically grow the ArrayList and set appropriate indexed value
index += 2;
dynaMap.set(testProperty, index, testString1);
assertEquals(testString1, dynaMap.get(testProperty, index), "Check Second Indexed Value is correct");
assertEquals(Integer.valueOf(index + 1), Integer.valueOf(((ArrayList<?>) dynaMap.get(testProperty)).size()), "Check Second Array length is correct");
}
/**
* Test Setting an Indexed Property when MutableDynaClass is set to restricted
*/
@Test
void testIndexedPropertyRestricted() {
final int index = 3;
// Set the MutableDyanClass to 'restricted' (i.e. no new properties cab be added
dynaMap.setRestricted(true);
assertTrue(dynaMap.isRestricted(), "Check MutableDynaClass is restricted");
// Check the property & value doesn't exist
assertNull(dynaMap.getDynaProperty(testProperty), "Check Property doesn't exist");
assertNull(dynaMap.get(testProperty), "Check Value is null");
// Set the property - should fail because property doesn't exist and MutableDynaClass is restricted
assertThrows(IllegalArgumentException.class, () -> dynaMap.set(testProperty, index, testInteger1));
}
/**
* Test Setting an 'Indexed' Property using PropertyUtils
*/
@Test
void testIndexedPropertyUtils() throws Exception {
final int index = 3;
dynaMap.setReturnNull(false);
// Check the property & value doesn't exist
assertFalse(dynaMap.isDynaProperty(testProperty), "Check Indexed Property doesn't exist");
assertNull(dynaMap.get(testProperty), "Check Indexed Property is null");
assertNull(dynaMap.get(testProperty, index), "Check Indexed value is null");
PropertyUtils.setProperty(dynaMap, testProperty + "[" + index + "]", testString1);
// Check property value correctly set
assertEquals(testString1, dynaMap.get(testProperty, index), "Check Indexed Bean Value is correct");
}
/**
* Test setting mapped property for type which is not Map
*/
@Test
void testMappedInvalidType() {
dynaMap.set(testProperty, Integer.valueOf(1));
assertFalse(dynaMap.getDynaProperty(testProperty).isMapped(), "Check Property is not mapped");
assertThrows(IllegalArgumentException.class, () -> dynaMap.set(testProperty, testKey, testInteger1));
}
/**
* Test Getting/Setting a 'Mapped' Property - default HashMap property
*/
@Test
void testMappedPropertyDefault() {
// Check the property & value doesn't exist
assertNull(dynaMap.getDynaProperty(testProperty), "Check Mapped Property doesn't exist");
assertNull(dynaMap.get(testProperty), "Check Map is null");
assertNull(dynaMap.get(testProperty, testKey), "Check Mapped Value is null");
// Set a new mapped property - should add new HashMap property and set the mapped value
dynaMap.set(testProperty, testKey, testInteger1);
assertEquals(HashMap.class, dynaMap.get(testProperty).getClass(), "Check Mapped Property exists");
assertEquals(testInteger1, dynaMap.get(testProperty, testKey), "Check First Mapped Value is correct(a)");
assertEquals(testInteger1, ((HashMap<?, ?>) dynaMap.get(testProperty)).get(testKey), "Check First Mapped Value is correct(b)");
// Set the property again - should set the new value
dynaMap.set(testProperty, testKey, testInteger2);
assertEquals(testInteger2, dynaMap.get(testProperty, testKey), "Check Second Mapped Value is correct(a)");
assertEquals(testInteger2, ((HashMap<?, ?>) dynaMap.get(testProperty)).get(testKey), "Check Second Mapped Value is correct(b)");
}
/**
* Test Setting a Mapped Property when MutableDynaClass is set to restricted
*/
@Test
void testMappedPropertyRestricted() {
// Set the MutableDyanClass to 'restricted' (i.e. no new properties cab be added
dynaMap.setRestricted(true);
assertTrue(dynaMap.isRestricted(), "Check MutableDynaClass is restricted");
// Check the property & value doesn't exist
assertNull(dynaMap.getDynaProperty(testProperty), "Check Property doesn't exist");
assertNull(dynaMap.get(testProperty), "Check Value is null");
// Set the property - should fail because property doesn't exist and MutableDynaClass is restricted
assertThrows(IllegalArgumentException.class, () -> dynaMap.set(testProperty, testKey, testInteger1));
}
/**
* Test Getting/Setting a 'Mapped' Property - use TreeMap property
*/
@Test
void testMappedPropertyTreeMap() {
// Check the property & value doesn't exist
assertNull(dynaMap.getDynaProperty(testProperty), "Check Mapped Property doesn't exist");
assertNull(dynaMap.get(testProperty), "Check Map is null");
// Add a 'TreeMap' property to the DynaClass
dynaMap.add(testProperty, TreeMap.class);
assertTrue(dynaMap.getDynaProperty(testProperty).isMapped(), "Check Property is mapped");
assertEquals(TreeMap.class, dynaMap.getDynaProperty(testProperty).getType(), "Check Property is correct type");
assertEquals(TreeMap.class, dynaMap.get(testProperty).getClass(), "Check Mapped Property now exists");
// Set a new mapped property - should instantiate a new TreeMap property and set the mapped value
dynaMap.set(testProperty, testKey, testInteger1);
assertEquals(TreeMap.class, dynaMap.get(testProperty).getClass(), "Check Mapped Property exists");
assertEquals(testInteger1, dynaMap.get(testProperty, testKey), "Check First Mapped Value is correct(a)");
assertEquals(testInteger1, ((TreeMap<?, ?>) dynaMap.get(testProperty)).get(testKey), "Check First Mapped Value is correct(b)");
// Set the property again - should set the new value
dynaMap.set(testProperty, testKey, testInteger2);
assertEquals(testInteger2, dynaMap.get(testProperty, testKey), "Check Second Mapped Value is correct(a)");
assertEquals(testInteger2, ((TreeMap<?, ?>) dynaMap.get(testProperty)).get(testKey), "Check Second Mapped Value is correct(b)");
}
/**
* Test Setting a 'Mapped' Property using PropertyUtils
*/
@Test
void testMappedPropertyUtils() throws Exception {
dynaMap.setReturnNull(false);
// Check the property & value doesn't exist
assertFalse(dynaMap.isDynaProperty(testProperty), "Check Mapped Property doesn't exist");
assertNull(dynaMap.get(testProperty), "Check Map is null");
assertNull(dynaMap.get(testProperty, testKey), "Check Mapped Value is null");
// Set the mapped property using PropertyUtils
PropertyUtils.setProperty(dynaMap, testProperty + "(" + testKey + ")", testString1);
// Check property value correctly set
assertEquals(testString1, dynaMap.get(testProperty, testKey), "Check Mapped Bean Value is correct");
}
/**
* Test creating using DynaClass.newInstance()
*/
@Test
void testNewInstance() {
// Create LazyDynaMap using TreeMap
// containing some properties
final LazyDynaMap orig = new LazyDynaMap(new TreeMap<>());
orig.set("indexProp", 0, "indexVal0");
orig.set("indexProp", 1, "indexVal1");
assertEquals(2, ((List<?>) orig.get("indexProp")).size(), "Index prop size");
final LazyDynaMap newOne = (LazyDynaMap) orig.newInstance();
final Map<String, Object> newMap = newOne.getMap();
assertEquals(TreeMap.class, newMap.getClass(), "Check Map type");
final ArrayList<?> indexProp = (ArrayList<?>) newMap.get("indexProp");
assertNotNull(indexProp, "Indexed Prop missing");
assertEquals(0, indexProp.size(), "Index prop size");
}
/**
* Test Getting/Setting a Simple Property
*/
@Test
void testSimpleProperty() {
// Check the property & value doesn't exist
assertNull(dynaMap.getDynaProperty(testProperty), "Check Property doesn't exist");
assertNull(dynaMap.get(testProperty), "Check Value is null");
// Set a new property - should add new property and set value
dynaMap.set(testProperty, testInteger1);
assertEquals(testInteger1, dynaMap.get(testProperty), "Check First Value is correct");
assertEquals(Integer.class, dynaMap.getDynaProperty(testProperty).getType(), "Check Property type is correct");
// Set the property again - should set the new value
dynaMap.set(testProperty, testInteger2);
assertEquals(testInteger2, dynaMap.get(testProperty), "Check Second Value is correct");
// Set the property again - with a different type, should succeed
dynaMap.set(testProperty, testString1);
assertEquals(testString1, dynaMap.get(testProperty), "Check Third Value is correct");
}
/**
* Test Setting a Simple Property when MutableDynaClass is set to restricted
*/
@Test
void testSimplePropertyRestricted() {
// Set the MutableDyanClass to 'restricted' (i.e. no new properties cab be added
dynaMap.setRestricted(true);
assertTrue(dynaMap.isRestricted(), "Check MutableDynaClass is restricted");
// Check the property & value doesn't exist
assertNull(dynaMap.getDynaProperty(testProperty), "Check Property doesn't exist");
assertNull(dynaMap.get(testProperty), "Check Value is null");
// Set the property - should fail because property doesn't exist and MutableDynaClass is restricted
assertThrows(IllegalArgumentException.class, () -> dynaMap.set(testProperty, testString1));
}
}