craigmcc 01/08/21 16:05:08 Modified: beanutils/src/java/org/apache/commons/beanutils PropertyUtils.java beanutils/src/test/org/apache/commons/beanutils PropertyUtilsTestCase.java Log: Add unit tests for indexed properties. Along the way, fix a bug where ArrayIndexOutOfBoundsException was being reported inconsistently depending on whether the underlying property was really an array or just had indexed getter and setter methods. Revision Changes Path 1.8 +32 -6 jakarta-commons/beanutils/src/java/org/apache/commons/beanutils/PropertyUtils.java Index: PropertyUtils.java =================================================================== RCS file: /home/cvs/jakarta-commons/beanutils/src/java/org/apache/commons/beanutils/PropertyUtils.java,v retrieving revision 1.7 retrieving revision 1.8 diff -u -r1.7 -r1.8 --- PropertyUtils.java 2001/08/21 21:59:02 1.7 +++ PropertyUtils.java 2001/08/21 23:05:08 1.8 @@ -1,7 +1,7 @@ /* - * $Header: /home/cvs/jakarta-commons/beanutils/src/java/org/apache/commons/beanutils/PropertyUtils.java,v 1.7 2001/08/21 21:59:02 craigmcc Exp $ - * $Revision: 1.7 $ - * $Date: 2001/08/21 21:59:02 $ + * $Header: /home/cvs/jakarta-commons/beanutils/src/java/org/apache/commons/beanutils/PropertyUtils.java,v 1.8 2001/08/21 23:05:08 craigmcc Exp $ + * $Revision: 1.8 $ + * $Date: 2001/08/21 23:05:08 $ * * ==================================================================== * @@ -126,7 +126,7 @@ * @author Chris Audley * @author Rey François * @author Gregor Raıman - * @version $Revision: 1.7 $ $Date: 2001/08/21 21:59:02 $ + * @version $Revision: 1.8 $ $Date: 2001/08/21 23:05:08 $ */ public class PropertyUtils { @@ -295,6 +295,8 @@ * @param name <code>propertyname[index]</code> of the property value * to be extracted * + * @exception ArrayIndexOutOfBoundsException if the specified index + * is outside the valid range for the underlying array * @exception IllegalAccessException if the caller does not have * access to the property accessor method * @exception IllegalArgumentException if <code>bean</code> or @@ -343,6 +345,8 @@ * @param name Simple property name of the property value to be extracted * @param index Index of the property value to be extracted * + * @exception ArrayIndexOutOfBoundsException if the specified index + * is outside the valid range for the underlying array * @exception IllegalAccessException if the caller does not have * access to the property accessor method * @exception IllegalArgumentException if <code>bean</code> or @@ -376,7 +380,16 @@ if (readMethod != null) { Object subscript[] = new Object[1]; subscript[0] = new Integer(index); - return (readMethod.invoke(bean, subscript)); + try { + return (readMethod.invoke(bean, subscript)); + } catch (InvocationTargetException e) { + if (e.getTargetException() instanceof + ArrayIndexOutOfBoundsException) + throw (ArrayIndexOutOfBoundsException) + e.getTargetException(); + else + throw e; + } } } @@ -968,6 +981,8 @@ * @param value Value to which the specified property element * should be set * + * @exception ArrayIndexOutOfBoundsException if the specified index + * is outside the valid range for the underlying array * @exception IllegalAccessException if the caller does not have * access to the property accessor method * @exception IllegalArgumentException if <code>bean</code> or @@ -1018,6 +1033,8 @@ * @param index Index of the property value to be set * @param value Value to which the indexed property element is to be set * + * @exception ArrayIndexOutOfBoundsException if the specified index + * is outside the valid range for the underlying array * @exception IllegalAccessException if the caller does not have * access to the property accessor method * @exception IllegalArgumentException if <code>bean</code> or @@ -1052,7 +1069,16 @@ Object subscript[] = new Object[2]; subscript[0] = new Integer(index); subscript[1] = value; - writeMethod.invoke(bean, subscript); + try { + writeMethod.invoke(bean, subscript); + } catch (InvocationTargetException e) { + if (e.getTargetException() instanceof + ArrayIndexOutOfBoundsException) + throw (ArrayIndexOutOfBoundsException) + e.getTargetException(); + else + throw e; + } return; } } 1.9 +680 -4 jakarta-commons/beanutils/src/test/org/apache/commons/beanutils/PropertyUtilsTestCase.java Index: PropertyUtilsTestCase.java =================================================================== RCS file: /home/cvs/jakarta-commons/beanutils/src/test/org/apache/commons/beanutils/PropertyUtilsTestCase.java,v retrieving revision 1.8 retrieving revision 1.9 diff -u -r1.8 -r1.9 --- PropertyUtilsTestCase.java 2001/08/21 21:59:02 1.8 +++ PropertyUtilsTestCase.java 2001/08/21 23:05:08 1.9 @@ -1,7 +1,7 @@ /* - * $Header: /home/cvs/jakarta-commons/beanutils/src/test/org/apache/commons/beanutils/PropertyUtilsTestCase.java,v 1.8 2001/08/21 21:59:02 craigmcc Exp $ - * $Revision: 1.8 $ - * $Date: 2001/08/21 21:59:02 $ + * $Header: /home/cvs/jakarta-commons/beanutils/src/test/org/apache/commons/beanutils/PropertyUtilsTestCase.java,v 1.9 2001/08/21 23:05:08 craigmcc Exp $ + * $Revision: 1.9 $ + * $Date: 2001/08/21 23:05:08 $ * * ==================================================================== * @@ -82,18 +82,24 @@ * <p>So far, this test case has tests for the following methods of the * <code>PropertyUtils</code> class:</p> * <ul> + * <li>getIndexedProperty(Object,String)</li> + * <li>getIndexedProperty(Object,String,int)</li> * <li>getMappedProperty(Object,String)</li> + * <li>getMappedProperty(Object,String,String</li> * <li>getNestedProperty(Object,String)</li> * <li>getPropertyDescriptor(Object,String)</li> * <li>getPropertyDescriptors(Object)</li> * <li>getSimpleProperty(Object,String)</li> + * <li>setIndexedProperty(Object,String,Object)</li> + * <li>setIndexedProperty(Object,String,String,Object)</li> * <li>setMappedProperty(Object,String,Object)</li> + * <li>setMappedProperty(Object,String,String,Object)</li> * <li>setNestedProperty(Object,String,Object)</li> * <li>setSimpleProperty(Object,String,Object)</li> * </ul> * * @author Craig R. McClanahan - * @version $Revision: 1.8 $ $Date: 2001/08/21 21:59:02 $ + * @version $Revision: 1.9 $ $Date: 2001/08/21 23:05:08 $ */ public class PropertyUtilsTestCase extends TestCase { @@ -433,6 +439,326 @@ /** + * Corner cases on getIndexedProperty invalid arguments. + */ + public void testGetIndexedArguments() { + + // Use explicit index argument + + try { + PropertyUtils.getIndexedProperty(null, "intArray", 0); + fail("Should throw IllegalArgumentException 1"); + } catch (IllegalArgumentException e) { + ; // Expected response + } catch (Throwable t) { + fail("Threw " + t + " instead of IllegalArgumentException 1"); + } + + try { + PropertyUtils.getIndexedProperty(bean, null, 0); + fail("Should throw IllegalArgumentException 2"); + } catch (IllegalArgumentException e) { + ; // Expected response + } catch (Throwable t) { + fail("Threw " + t + " instead of IllegalArgumentException 2"); + } + + // Use index expression + + try { + PropertyUtils.getIndexedProperty(null, + "intArray[0]"); + fail("Should throw IllegalArgumentException 3"); + } catch (IllegalArgumentException e) { + ; // Expected response + } catch (Throwable t) { + fail("Threw " + t + " instead of IllegalArgumentException 3"); + } + + try { + PropertyUtils.getIndexedProperty(bean, "[0]"); + fail("Should throw NoSuchMethodException 4"); + } catch (NoSuchMethodException e) { + ; // Expected response + } catch (Throwable t) { + fail("Threw " + t + " instead of NoSuchMethodException 4"); + } + + try { + PropertyUtils.getIndexedProperty(bean, "intArray"); + fail("Should throw IllegalArgumentException 5"); + } catch (IllegalArgumentException e) { + ; // Expected response + } catch (Throwable t) { + fail("Threw " + t + " instead of IllegalArgumentException 5"); + } + + // Use explicit index argument + + try { + PropertyUtils.getIndexedProperty(null, "intIndexed", 0); + fail("Should throw IllegalArgumentException 1"); + } catch (IllegalArgumentException e) { + ; // Expected response + } catch (Throwable t) { + fail("Threw " + t + " instead of IllegalArgumentException 1"); + } + + try { + PropertyUtils.getIndexedProperty(bean, null, 0); + fail("Should throw IllegalArgumentException 2"); + } catch (IllegalArgumentException e) { + ; // Expected response + } catch (Throwable t) { + fail("Threw " + t + " instead of IllegalArgumentException 2"); + } + + // Use index expression + + try { + PropertyUtils.getIndexedProperty(null, + "intIndexed[0]"); + fail("Should throw IllegalArgumentException 3"); + } catch (IllegalArgumentException e) { + ; // Expected response + } catch (Throwable t) { + fail("Threw " + t + " instead of IllegalArgumentException 3"); + } + + try { + PropertyUtils.getIndexedProperty(bean, "[0]"); + fail("Should throw NoSuchMethodException 4"); + } catch (NoSuchMethodException e) { + ; // Expected response + } catch (Throwable t) { + fail("Threw " + t + " instead of NoSuchMethodException 4"); + } + + try { + PropertyUtils.getIndexedProperty(bean, "intIndexed"); + fail("Should throw IllegalArgumentException 5"); + } catch (IllegalArgumentException e) { + ; // Expected response + } catch (Throwable t) { + fail("Threw " + t + " instead of IllegalArgumentException 5"); + } + + } + + + /** + * Positive and negative tests on getIndexedProperty valid arguments. + */ + public void testGetIndexedValues() { + + Object value = null; + + // Use explicit key argument + + for (int i = 0; i < 5; i++) { + + try { + value = + PropertyUtils.getIndexedProperty(bean, "intArray", i); + assertNotNull("intArray returned value " + i, value); + assertTrue("intArray returned Integer " + i, + value instanceof Integer); + assertEquals("intArray returned correct " + i, i * 10, + ((Integer) value).intValue()); + } catch (Throwable t) { + fail("intArray " + i + " threw " + t); + } + + try { + value = + PropertyUtils.getIndexedProperty(bean, "intIndexed", i); + assertNotNull("intIndexed returned value " + i, value); + assertTrue("intIndexed returned Integer " + i, + value instanceof Integer); + assertEquals("intIndexed returned correct " + i, i * 10, + ((Integer) value).intValue()); + } catch (Throwable t) { + fail("intIndexed " + i + " threw " + t); + } + + try { + value = + PropertyUtils.getIndexedProperty(bean, "stringArray", i); + assertNotNull("stringArray returned value " + i, value); + assertTrue("intArray returned String " + i, + value instanceof String); + assertEquals("stringArray returned correct " + i, + "String " + i, (String) value); + } catch (Throwable t) { + fail("stringArray " + i + " threw " + t); + } + + try { + value = + PropertyUtils.getIndexedProperty(bean, "stringIndexed", i); + assertNotNull("stringIndexed returned value " + i, value); + assertTrue("intArray returned String " + i, + value instanceof String); + assertEquals("stringIndexed returned correct " + i, + "String " + i, (String) value); + } catch (Throwable t) { + fail("stringIndexed " + i + " threw " + t); + } + + } + + // Use key expression + + for (int i = 0; i < 5; i++) { + + try { + value = + PropertyUtils.getIndexedProperty(bean, + "intArray[" + i + "]"); + assertNotNull("intArray returned value " + i, value); + assertTrue("intArray returned Integer " + i, + value instanceof Integer); + assertEquals("intArray returned correct " + i, i * 10, + ((Integer) value).intValue()); + } catch (Throwable t) { + fail("intArray " + i + " threw " + t); + } + + try { + value = + PropertyUtils.getIndexedProperty(bean, + "intIndexed[" + i + "]"); + assertNotNull("intIndexed returned value " + i, value); + assertTrue("intIndexed returned Integer " + i, + value instanceof Integer); + assertEquals("intIndexed returned correct " + i, i * 10, + ((Integer) value).intValue()); + } catch (Throwable t) { + fail("intIndexed " + i + " threw " + t); + } + + try { + value = + PropertyUtils.getIndexedProperty(bean, + "stringArray[" + i + "]"); + assertNotNull("stringArray returned value " + i, value); + assertTrue("intArray returned String " + i, + value instanceof String); + assertEquals("stringArray returned correct " + i, + "String " + i, (String) value); + } catch (Throwable t) { + fail("stringArray " + i + " threw " + t); + } + + try { + value = + PropertyUtils.getIndexedProperty(bean, + "stringIndexed[" + i + "]"); + assertNotNull("stringIndexed returned value " + i, value); + assertTrue("intArray returned String " + i, + value instanceof String); + assertEquals("stringIndexed returned correct " + i, + "String " + i, (String) value); + } catch (Throwable t) { + fail("stringIndexed " + i + " threw " + t); + } + + } + + // Index out of bounds tests + + try { + value = + PropertyUtils.getIndexedProperty(bean, + "intArray", -1); + fail("Should have thrown ArrayIndexOutOfBoundsException"); + } catch (ArrayIndexOutOfBoundsException t) { + ; // Expected results + } catch (Throwable t) { + fail("Threw " + t + " instead of ArrayIndexOutOfBoundsException"); + } + + try { + value = + PropertyUtils.getIndexedProperty(bean, + "intArray", 5); + fail("Should have thrown ArrayIndexOutOfBoundsException"); + } catch (ArrayIndexOutOfBoundsException t) { + ; // Expected results + } catch (Throwable t) { + fail("Threw " + t + " instead of ArrayIndexOutOfBoundsException"); + } + + try { + value = + PropertyUtils.getIndexedProperty(bean, + "intIndexed", -1); + fail("Should have thrown ArrayIndexOutOfBoundsException"); + } catch (ArrayIndexOutOfBoundsException t) { + ; // Expected results + } catch (Throwable t) { + fail("Threw " + t + " instead of ArrayIndexOutOfBoundsException"); + } + + try { + value = + PropertyUtils.getIndexedProperty(bean, + "intIndexed", 5); + fail("Should have thrown ArrayIndexOutOfBoundsException"); + } catch (ArrayIndexOutOfBoundsException t) { + ; // Expected results + } catch (Throwable t) { + fail("Threw " + t + " instead of ArrayIndexOutOfBoundsException"); + } + + try { + value = + PropertyUtils.getIndexedProperty(bean, + "stringArray", -1); + fail("Should have thrown ArrayIndexOutOfBoundsException"); + } catch (ArrayIndexOutOfBoundsException t) { + ; // Expected results + } catch (Throwable t) { + fail("Threw " + t + " instead of ArrayIndexOutOfBoundsException"); + } + + try { + value = + PropertyUtils.getIndexedProperty(bean, + "stringArray", 5); + fail("Should have thrown ArrayIndexOutOfBoundsException"); + } catch (ArrayIndexOutOfBoundsException t) { + ; // Expected results + } catch (Throwable t) { + fail("Threw " + t + " instead of ArrayIndexOutOfBoundsException"); + } + + try { + value = + PropertyUtils.getIndexedProperty(bean, + "stringIndexed", -1); + fail("Should have thrown ArrayIndexOutOfBoundsException"); + } catch (ArrayIndexOutOfBoundsException t) { + ; // Expected results + } catch (Throwable t) { + fail("Threw " + t + " instead of ArrayIndexOutOfBoundsException"); + } + + try { + value = + PropertyUtils.getIndexedProperty(bean, + "stringIndexed", 5); + fail("Should have thrown ArrayIndexOutOfBoundsException"); + } catch (ArrayIndexOutOfBoundsException t) { + ; // Expected results + } catch (Throwable t) { + fail("Threw " + t + " instead of ArrayIndexOutOfBoundsException"); + } + + } + + + /** * Corner cases on getMappedProperty invalid arguments. */ public void testGetMappedArguments() { @@ -1298,6 +1624,356 @@ public void testGetWriteMethodPublicSubclass() { testGetWriteMethod(beanPublicSubclass, properties, TEST_BEAN_CLASS); + + } + + + /** + * Corner cases on setIndexedProperty invalid arguments. + */ + public void testSetIndexedArguments() { + + // Use explicit index argument + + try { + PropertyUtils.setIndexedProperty(null, "intArray", 0, + new Integer(1)); + fail("Should throw IllegalArgumentException 1"); + } catch (IllegalArgumentException e) { + ; // Expected response + } catch (Throwable t) { + fail("Threw " + t + " instead of IllegalArgumentException 1"); + } + + try { + PropertyUtils.setIndexedProperty(bean, null, 0, + new Integer(1)); + fail("Should throw IllegalArgumentException 2"); + } catch (IllegalArgumentException e) { + ; // Expected response + } catch (Throwable t) { + fail("Threw " + t + " instead of IllegalArgumentException 2"); + } + + // Use index expression + + try { + PropertyUtils.setIndexedProperty(null, + "intArray[0]", + new Integer(1)); + fail("Should throw IllegalArgumentException 3"); + } catch (IllegalArgumentException e) { + ; // Expected response + } catch (Throwable t) { + fail("Threw " + t + " instead of IllegalArgumentException 3"); + } + + try { + PropertyUtils.setIndexedProperty(bean, "[0]", + new Integer(1)); + fail("Should throw NoSuchMethodException 4"); + } catch (NoSuchMethodException e) { + ; // Expected response + } catch (Throwable t) { + fail("Threw " + t + " instead of NoSuchMethodException 4"); + } + + try { + PropertyUtils.setIndexedProperty(bean, "intArray", + new Integer(1)); + fail("Should throw IllegalArgumentException 5"); + } catch (IllegalArgumentException e) { + ; // Expected response + } catch (Throwable t) { + fail("Threw " + t + " instead of IllegalArgumentException 5"); + } + + // Use explicit index argument + + try { + PropertyUtils.setIndexedProperty(null, "intIndexed", 0, + new Integer(1)); + fail("Should throw IllegalArgumentException 1"); + } catch (IllegalArgumentException e) { + ; // Expected response + } catch (Throwable t) { + fail("Threw " + t + " instead of IllegalArgumentException 1"); + } + + try { + PropertyUtils.setIndexedProperty(bean, null, 0, + new Integer(1)); + fail("Should throw IllegalArgumentException 2"); + } catch (IllegalArgumentException e) { + ; // Expected response + } catch (Throwable t) { + fail("Threw " + t + " instead of IllegalArgumentException 2"); + } + + // Use index expression + + try { + PropertyUtils.setIndexedProperty(null, + "intIndexed[0]", + new Integer(1)); + fail("Should throw IllegalArgumentException 3"); + } catch (IllegalArgumentException e) { + ; // Expected response + } catch (Throwable t) { + fail("Threw " + t + " instead of IllegalArgumentException 3"); + } + + try { + PropertyUtils.setIndexedProperty(bean, "[0]", + new Integer(1)); + fail("Should throw NoSuchMethodException 4"); + } catch (NoSuchMethodException e) { + ; // Expected response + } catch (Throwable t) { + fail("Threw " + t + " instead of NoSuchMethodException 4"); + } + + try { + PropertyUtils.setIndexedProperty(bean, "intIndexed", + new Integer(1)); + fail("Should throw IllegalArgumentException 5"); + } catch (IllegalArgumentException e) { + ; // Expected response + } catch (Throwable t) { + fail("Threw " + t + " instead of IllegalArgumentException 5"); + } + + } + + + /** + * Positive and negative tests on setIndexedProperty valid arguments. + */ + public void testSetIndexedValues() { + + Object value = null; + + // Use explicit index argument + + try { + PropertyUtils.setIndexedProperty(bean, + "intArray", 0, + new Integer(1)); + value = + PropertyUtils.getIndexedProperty(bean, + "intArray", 0); + assertNotNull("Returned new value 0", value); + assertTrue("Returned Integer new value 0", + value instanceof Integer); + assertEquals("Returned correct new value 0", 1, + ((Integer) value).intValue()); + } catch (Throwable t) { + fail("Threw " + t); + } + + try { + PropertyUtils.setIndexedProperty(bean, + "intIndexed", 1, + new Integer(11)); + value = + PropertyUtils.getIndexedProperty(bean, + "intIndexed", 1); + assertNotNull("Returned new value 1", value); + assertTrue("Returned Integer new value 1", + value instanceof Integer); + assertEquals("Returned correct new value 1", 11, + ((Integer) value).intValue()); + } catch (Throwable t) { + fail("Threw " + t); + } + + try { + PropertyUtils.setIndexedProperty(bean, + "stringArray", 2, + "New Value 2"); + value = + PropertyUtils.getIndexedProperty(bean, + "stringArray", 2); + assertNotNull("Returned new value 2", value); + assertTrue("Returned String new value 2", + value instanceof String); + assertEquals("Returned correct new value 2", "New Value 2", + (String) value); + } catch (Throwable t) { + fail("Threw " + t); + } + + try { + PropertyUtils.setIndexedProperty(bean, + "stringArray", 3, + "New Value 3"); + value = + PropertyUtils.getIndexedProperty(bean, + "stringArray", 3); + assertNotNull("Returned new value 3", value); + assertTrue("Returned String new value 3", + value instanceof String); + assertEquals("Returned correct new value 3", "New Value 3", + (String) value); + } catch (Throwable t) { + fail("Threw " + t); + } + + // Use index expression + + try { + PropertyUtils.setIndexedProperty(bean, + "intArray[4]", + new Integer(1)); + value = + PropertyUtils.getIndexedProperty(bean, + "intArray[4]"); + assertNotNull("Returned new value 4", value); + assertTrue("Returned Integer new value 4", + value instanceof Integer); + assertEquals("Returned correct new value 4", 1, + ((Integer) value).intValue()); + } catch (Throwable t) { + fail("Threw " + t); + } + + try { + PropertyUtils.setIndexedProperty(bean, + "intIndexed[3]", + new Integer(11)); + value = + PropertyUtils.getIndexedProperty(bean, + "intIndexed[3]"); + assertNotNull("Returned new value 5", value); + assertTrue("Returned Integer new value 5", + value instanceof Integer); + assertEquals("Returned correct new value 5", 11, + ((Integer) value).intValue()); + } catch (Throwable t) { + fail("Threw " + t); + } + + try { + PropertyUtils.setIndexedProperty(bean, + "stringArray[1]", + "New Value 2"); + value = + PropertyUtils.getIndexedProperty(bean, + "stringArray[2]"); + assertNotNull("Returned new value 6", value); + assertTrue("Returned String new value 6", + value instanceof String); + assertEquals("Returned correct new value 6", "New Value 2", + (String) value); + } catch (Throwable t) { + fail("Threw " + t); + } + + try { + PropertyUtils.setIndexedProperty(bean, + "stringArray[0]", + "New Value 3"); + value = + PropertyUtils.getIndexedProperty(bean, + "stringArray[0]"); + assertNotNull("Returned new value 7", value); + assertTrue("Returned String new value 7", + value instanceof String); + assertEquals("Returned correct new value 7", "New Value 3", + (String) value); + } catch (Throwable t) { + fail("Threw " + t); + } + + // Index out of bounds tests + + try { + PropertyUtils.setIndexedProperty(bean, + "intArray", -1, + new Integer(0)); + fail("Should have thrown ArrayIndexOutOfBoundsException"); + } catch (ArrayIndexOutOfBoundsException t) { + ; // Expected results + } catch (Throwable t) { + fail("Threw " + t + " instead of ArrayIndexOutOfBoundsException"); + } + + try { + PropertyUtils.setIndexedProperty(bean, + "intArray", 5, + new Integer(0)); + fail("Should have thrown ArrayIndexOutOfBoundsException"); + } catch (ArrayIndexOutOfBoundsException t) { + ; // Expected results + } catch (Throwable t) { + fail("Threw " + t + " instead of ArrayIndexOutOfBoundsException"); + } + + try { + PropertyUtils.setIndexedProperty(bean, + "intIndexed", -1, + new Integer(0)); + fail("Should have thrown ArrayIndexOutOfBoundsException"); + } catch (ArrayIndexOutOfBoundsException t) { + ; // Expected results + } catch (Throwable t) { + fail("Threw " + t + " instead of ArrayIndexOutOfBoundsException"); + } + + try { + PropertyUtils.setIndexedProperty(bean, + "intIndexed", 5, + new Integer(0)); + fail("Should have thrown ArrayIndexOutOfBoundsException"); + } catch (ArrayIndexOutOfBoundsException t) { + ; // Expected results + } catch (Throwable t) { + fail("Threw " + t + " instead of ArrayIndexOutOfBoundsException"); + } + + try { + PropertyUtils.setIndexedProperty(bean, + "stringArray", -1, + "New String"); + fail("Should have thrown ArrayIndexOutOfBoundsException"); + } catch (ArrayIndexOutOfBoundsException t) { + ; // Expected results + } catch (Throwable t) { + fail("Threw " + t + " instead of ArrayIndexOutOfBoundsException"); + } + + try { + PropertyUtils.setIndexedProperty(bean, + "stringArray", 5, + "New String"); + fail("Should have thrown ArrayIndexOutOfBoundsException"); + } catch (ArrayIndexOutOfBoundsException t) { + ; // Expected results + } catch (Throwable t) { + fail("Threw " + t + " instead of ArrayIndexOutOfBoundsException"); + } + + try { + PropertyUtils.setIndexedProperty(bean, + "stringIndexed", -1, + "New String"); + fail("Should have thrown ArrayIndexOutOfBoundsException"); + } catch (ArrayIndexOutOfBoundsException t) { + ; // Expected results + } catch (Throwable t) { + fail("Threw " + t + " instead of ArrayIndexOutOfBoundsException"); + } + + try { + PropertyUtils.setIndexedProperty(bean, + "stringIndexed", 5, + "New String"); + fail("Should have thrown ArrayIndexOutOfBoundsException"); + } catch (ArrayIndexOutOfBoundsException t) { + ; // Expected results + } catch (Throwable t) { + fail("Threw " + t + " instead of ArrayIndexOutOfBoundsException"); + } }