commons-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From brit...@apache.org
Subject svn commit: r1592200 [5/9] - in /commons/sandbox/beanutils2/trunk: config/ src/changes/ src/main/java/org/apache/commons/beanutils2/ src/main/java/org/apache/commons/beanutils2/transformers/ src/test/java/org/apache/commons/beanutils2/ src/test/java/or...
Date Sat, 03 May 2014 13:14:55 GMT
Modified: commons/sandbox/beanutils2/trunk/src/test/java/org/apache/commons/beanutils2/ConstructorRegistryTestCase.java
URL: http://svn.apache.org/viewvc/commons/sandbox/beanutils2/trunk/src/test/java/org/apache/commons/beanutils2/ConstructorRegistryTestCase.java?rev=1592200&r1=1592199&r2=1592200&view=diff
==============================================================================
--- commons/sandbox/beanutils2/trunk/src/test/java/org/apache/commons/beanutils2/ConstructorRegistryTestCase.java (original)
+++ commons/sandbox/beanutils2/trunk/src/test/java/org/apache/commons/beanutils2/ConstructorRegistryTestCase.java Sat May  3 13:14:53 2014
@@ -1,5 +1,3 @@
-package org.apache.commons.beanutils2;
-
 /*
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with
@@ -17,6 +15,8 @@ package org.apache.commons.beanutils2;
  * limitations under the License.
  */
 
+package org.apache.commons.beanutils2;
+
 import static java.lang.String.format;
 import static java.lang.reflect.Modifier.isPublic;
 import static org.junit.Assert.assertArrayEquals;
@@ -30,174 +30,146 @@ import java.lang.reflect.Constructor;
 import org.apache.commons.beanutils2.testbeans.TestBean;
 import org.junit.Test;
 
-public class ConstructorRegistryTestCase
-{
+public class ConstructorRegistryTestCase {
 
     private static final String WRONG_FOUND = "ConstructorRegistry resolved wrong constructor!";
 
     private static final String NON_FOUND = "ConstructorRegistry could not resolve constructor %s!";
 
     private final AccessibleObjectsRegistry<Constructor<?>> constructorRegistry =
-        AccessibleObjectsRegistry.getConstructorsRegistry();
+            AccessibleObjectsRegistry.getConstructorsRegistry();
 
     @Test
-    public void get()
-    {
+    public void get() {
         Constructor<?>[] constructors = TestBean.class.getConstructors();
-        for ( Constructor<?> constructor : constructors )
-        {
-            Constructor<?> resolved = constructorRegistry.get( false, TestBean.class, constructor.getParameterTypes() );
-            assertNotNull( format( NON_FOUND, constructor ), resolved );
-            assertEquals( WRONG_FOUND, constructor, resolved );
+        for (Constructor<?> constructor : constructors) {
+            Constructor<?> resolved = constructorRegistry.get(false, TestBean.class, constructor.getParameterTypes());
+            assertNotNull(format(NON_FOUND, constructor), resolved);
+            assertEquals(WRONG_FOUND, constructor, resolved);
         }
     }
 
     @Test
     public void getDifferentParameter()
-        throws Exception
-    {
-        Constructor<TestBean> floatConstructor = TestBean.class.getConstructor( float.class );
-        Constructor<?> resolved = constructorRegistry.get( false, TestBean.class, Float.class );
-        assertNotNull( format( NON_FOUND, floatConstructor ), resolved );
-        assertEquals( WRONG_FOUND, floatConstructor, resolved );
+            throws Exception {
+        Constructor<TestBean> floatConstructor = TestBean.class.getConstructor(float.class);
+        Constructor<?> resolved = constructorRegistry.get(false, TestBean.class, Float.class);
+        assertNotNull(format(NON_FOUND, floatConstructor), resolved);
+        assertEquals(WRONG_FOUND, floatConstructor, resolved);
     }
 
     @Test
-    public void getExact()
-    {
+    public void getExact() {
         Constructor<?>[] constructors = TestBean.class.getConstructors();
-        for ( Constructor<?> constructor : constructors )
-        {
-            Constructor<?> resolved = constructorRegistry.get( true, TestBean.class, constructor.getParameterTypes() );
-            assertNotNull( format( NON_FOUND, constructor ), resolved );
-            assertEquals( WRONG_FOUND, constructor, resolved );
+        for (Constructor<?> constructor : constructors) {
+            Constructor<?> resolved = constructorRegistry.get(true, TestBean.class, constructor.getParameterTypes());
+            assertNotNull(format(NON_FOUND, constructor), resolved);
+            assertEquals(WRONG_FOUND, constructor, resolved);
         }
     }
 
     @Test
     public void getExactDifferentParameter()
-        throws Exception
-    {
-        Constructor<?> resolved = constructorRegistry.get( true, TestBean.class, Float.class );
-        assertNull( format( "Constructor resolved constructor [%s] for parameter type Float on type TestBean although TestBean does not describe such a constructor.",
-                            resolved ), resolved );
+            throws Exception {
+        Constructor<?> resolved = constructorRegistry.get(true, TestBean.class, Float.class);
+        assertNull(format("Constructor resolved constructor [%s] for parameter type Float on type TestBean although TestBean does not describe such a constructor.",
+                resolved), resolved);
     }
 
     @Test
-    public void getWithName()
-    {
+    public void getWithName() {
         // TODO does the constructorRegistry need this method? constructors don't have names.
         Constructor<?>[] constructors = TestBean.class.getConstructors();
-        for ( Constructor<?> constructor : constructors )
-        {
-            Constructor<?> resolved = constructorRegistry.get( true, TestBean.class,
-                                                               "name is ignored by Constructors Registry",
-                                                               constructor.getParameterTypes() );
-            assertNotNull( format( NON_FOUND, constructor ), resolved );
-            assertEquals( WRONG_FOUND, constructor, resolved );
+        for (Constructor<?> constructor : constructors) {
+            Constructor<?> resolved = constructorRegistry.get(true, TestBean.class,
+                    "name is ignored by Constructors Registry",
+                    constructor.getParameterTypes());
+            assertNotNull(format(NON_FOUND, constructor), resolved);
+            assertEquals(WRONG_FOUND, constructor, resolved);
         }
     }
 
     @Test
     public void resolveDirectly()
-        throws Exception
-    {
+            throws Exception {
         Constructor<?>[] constructors = TestBean.class.getConstructors();
-        for ( Constructor<?> constructor : constructors )
-        {
+        for (Constructor<?> constructor : constructors) {
             Constructor<?> resolved =
-                constructorRegistry.resolveDirectly( TestBean.class, null, constructor.getParameterTypes() );
-            assertNotNull( format( NON_FOUND, constructor ), resolved );
-            assertEquals( WRONG_FOUND, constructor, resolved );
+                    constructorRegistry.resolveDirectly(TestBean.class, null, constructor.getParameterTypes());
+            assertNotNull(format(NON_FOUND, constructor), resolved);
+            assertEquals(WRONG_FOUND, constructor, resolved);
         }
     }
 
     @Test
-    public void getAccessibleObjectsArrayForTestBean()
-    {
-        Constructor<?>[] constructors = constructorRegistry.getAccessibleObjectsArray( TestBean.class );
-        assertNotNull( constructors );
-        assertArrayEquals( TestBean.class.getConstructors(), constructors );
+    public void getAccessibleObjectsArrayForTestBean() {
+        Constructor<?>[] constructors = constructorRegistry.getAccessibleObjectsArray(TestBean.class);
+        assertNotNull(constructors);
+        assertArrayEquals(TestBean.class.getConstructors(), constructors);
     }
 
     @Test
-    public void matchesNull()
-    {
+    public void matchesNull() {
         // this method always returns true
-        boolean matches = constructorRegistry.matches( null, null );
-        assertTrue( matches );
+        boolean matches = constructorRegistry.matches(null, null);
+        assertTrue(matches);
     }
 
     @Test
-    public void matches()
-    {
+    public void matches() {
         // this method always returns true
         Constructor<?>[] constructors = TestBean.class.getConstructors();
-        for ( Constructor<?> constructor : constructors )
-        {
-            boolean matches = constructorRegistry.matches( constructor, "this returns true" );
-            assertTrue( matches );
+        for (Constructor<?> constructor : constructors) {
+            boolean matches = constructorRegistry.matches(constructor, "this returns true");
+            assertTrue(matches);
         }
     }
 
     @Test
-    public void getParameterTypes()
-    {
+    public void getParameterTypes() {
         Constructor<?>[] constructors = TestBean.class.getDeclaredConstructors();
-        for ( Constructor<?> constructor : constructors )
-        {
-            Class<?>[] typesFromRegistry = constructorRegistry.getParameterTypes( constructor );
-            assertArrayEquals( constructor.getParameterTypes(), typesFromRegistry );
+        for (Constructor<?> constructor : constructors) {
+            Class<?>[] typesFromRegistry = constructorRegistry.getParameterTypes(constructor);
+            assertArrayEquals(constructor.getParameterTypes(), typesFromRegistry);
         }
     }
 
     @Test
-    public void resolveAccessibleNull()
-    {
-        assertNull( constructorRegistry.resolveAccessible( Object.class, null ) );
+    public void resolveAccessibleNull() {
+        assertNull(constructorRegistry.resolveAccessible(Object.class, null));
     }
 
     @Test
-    public void resolveAccessible()
-    {
+    public void resolveAccessible() {
         Constructor<?>[] constructors = TestBean.class.getDeclaredConstructors();
-        for ( Constructor<?> constructor : constructors )
-        {
-            Constructor<?> resolved = constructorRegistry.resolveAccessible( TestBean.class, constructor );
-            if ( isPublic( constructor.getModifiers() ) )
-            {
-                assertEquals( constructor, resolved );
-            }
-            else
-            {
-                assertNull( resolved );
+        for (Constructor<?> constructor : constructors) {
+            Constructor<?> resolved = constructorRegistry.resolveAccessible(TestBean.class, constructor);
+            if (isPublic(constructor.getModifiers())) {
+                assertEquals(constructor, resolved);
+            } else {
+                assertNull(resolved);
             }
         }
     }
 
     @Test
-    public void resolveAccessiblePrivateClass()
-    {
+    public void resolveAccessiblePrivateClass() {
         Constructor<?>[] constructors = PrivateTestBean.class.getDeclaredConstructors();
-        for ( Constructor<?> constructor : constructors )
-        {
-            Constructor<?> resolved = constructorRegistry.resolveAccessible( TestBean.class, constructor );
+        for (Constructor<?> constructor : constructors) {
+            Constructor<?> resolved = constructorRegistry.resolveAccessible(TestBean.class, constructor);
             // PrivateTestBean is a private class, so no constructor is accessible.
-            assertNull( resolved );
+            assertNull(resolved);
         }
     }
 
-    @SuppressWarnings( "unused" ) // class is used for tests only
-    private static class PrivateTestBean
-    {
+    @SuppressWarnings("unused") // class is used for tests only
+    private static class PrivateTestBean {
 
-        public PrivateTestBean()
-        {
+        public PrivateTestBean() {
             // empty default constructor
         }
 
-        private PrivateTestBean( int i )
-        {
+        private PrivateTestBean(int i) {
             // int constructor
         }
     }

Modified: commons/sandbox/beanutils2/trunk/src/test/java/org/apache/commons/beanutils2/ConstructorsTestCase.java
URL: http://svn.apache.org/viewvc/commons/sandbox/beanutils2/trunk/src/test/java/org/apache/commons/beanutils2/ConstructorsTestCase.java?rev=1592200&r1=1592199&r2=1592200&view=diff
==============================================================================
--- commons/sandbox/beanutils2/trunk/src/test/java/org/apache/commons/beanutils2/ConstructorsTestCase.java (original)
+++ commons/sandbox/beanutils2/trunk/src/test/java/org/apache/commons/beanutils2/ConstructorsTestCase.java Sat May  3 13:14:53 2014
@@ -1,5 +1,3 @@
-package org.apache.commons.beanutils2;
-
 /*
  * Licensed to the Apache Software Foundation (ASF) under one
  * or more contributor license agreements.  See the NOTICE file
@@ -19,6 +17,8 @@ package org.apache.commons.beanutils2;
  * under the License.
  */
 
+package org.apache.commons.beanutils2;
+
 import static org.apache.commons.beanutils2.Argument.argument;
 import static org.apache.commons.beanutils2.BeanUtils.on;
 import static org.junit.Assert.assertEquals;
@@ -36,8 +36,7 @@ import org.junit.rules.ExpectedException
  * Test case for <code>ClassAccessor</code>
  * </p>
  */
-public class ConstructorsTestCase
-{
+public class ConstructorsTestCase {
 
     @Rule
     public ExpectedException thrown = ExpectedException.none();
@@ -46,272 +45,243 @@ public class ConstructorsTestCase
 
     @Test
     public void invokeConstructor()
-        throws Exception
-    {
+            throws Exception {
         {
-            TestBean obj = on( TestBean.class ).invokeConstructor( argument( "TEST" ) ).get();
-            assertNotNull( obj );
-            assertEquals( "TEST", obj.getStringProperty() );
+            TestBean obj = on(TestBean.class).invokeConstructor(argument("TEST")).get();
+            assertNotNull(obj);
+            assertEquals("TEST", obj.getStringProperty());
         }
         {
-            TestBean obj = on( TestBean.class ).invokeConstructor( argument( new Float( 17.3f ) ) ).get();
-            assertNotNull( obj );
-            assertEquals( 17.3f, obj.getFloatProperty(), 0.0f );
+            TestBean obj = on(TestBean.class).invokeConstructor(argument(new Float(17.3f))).get();
+            assertNotNull(obj);
+            assertEquals(17.3f, obj.getFloatProperty(), 0.0f);
         }
     }
 
-    @Test( expected = NoSuchConstructorException.class )
+    @Test(expected = NoSuchConstructorException.class)
     public void invokeConstructorWithInvalidArgument()
-        throws Exception
-    {
-        on( TestBean.class ).invokeConstructor( argument( (byte) 6 ) ).get();
+            throws Exception {
+        on(TestBean.class).invokeConstructor(argument((byte) 6)).get();
     }
 
-    @Test( expected = NullPointerException.class )
+    @Test(expected = NullPointerException.class)
     public void invokeConstructorWithNull()
-        throws Exception
-    {
-        on( TestBean.class ).invokeConstructor( (Argument<?>) null );
+            throws Exception {
+        on(TestBean.class).invokeConstructor((Argument<?>) null);
     }
 
     @Test
     public void invokeConstructorWithArgArray()
-        throws Exception
-    {
-        TestBean obj = on( TestBean.class ).invokeConstructor( argument( new Float( 17.3f ) ), argument( "TEST" ) ).get();
-        assertNotNull( obj );
-        assertEquals( 17.3f, obj.getFloatProperty(), 0.0f );
-        assertEquals( "TEST", obj.getStringProperty() );
+            throws Exception {
+        TestBean obj = on(TestBean.class).invokeConstructor(argument(new Float(17.3f)), argument("TEST")).get();
+        assertNotNull(obj);
+        assertEquals(17.3f, obj.getFloatProperty(), 0.0f);
+        assertEquals("TEST", obj.getStringProperty());
     }
 
-    @Test( expected = NoSuchConstructorException.class )
+    @Test(expected = NoSuchConstructorException.class)
     public void invokeConstrucotrWithInvalidArgArray()
-        throws Exception
-    {
-        on( TestBean.class ).invokeConstructor( argument( (byte) 17 ), argument( "TEST" ) ).get();
+            throws Exception {
+        on(TestBean.class).invokeConstructor(argument((byte) 17), argument("TEST")).get();
     }
 
-    @Test( expected = NullPointerException.class )
+    @Test(expected = NullPointerException.class)
     public void invokeConstructorWithNullArray()
-        throws Exception
-    {
-        on( TestBean.class ).invokeConstructor( null, null, null );
+            throws Exception {
+        on(TestBean.class).invokeConstructor(null, null, null);
     }
 
     @Test
     public void invokeConstructorWithTypeArray()
-        throws Exception
-    {
+            throws Exception {
         {
-            TestBean obj = on( TestBean.class ).invokeConstructor( argument( Boolean.TYPE, Boolean.TRUE ),
-                                                                   argument( String.class, "TEST" ) ).get();
-            assertNotNull( obj );
-            assertEquals( true, obj.getBooleanProperty() );
-            assertEquals( "TEST", obj.getStringProperty() );
+            TestBean obj = on(TestBean.class).invokeConstructor(argument(Boolean.TYPE, Boolean.TRUE),
+                    argument(String.class, "TEST")).get();
+            assertNotNull(obj);
+            assertEquals(true, obj.getBooleanProperty());
+            assertEquals("TEST", obj.getStringProperty());
         }
         {
-            TestBean obj = on( TestBean.class ).invokeConstructor( argument( Boolean.class, Boolean.TRUE ),
-                                                                   argument( String.class, "TEST" ) ).get();
-            assertNotNull( obj );
-            assertEquals( true, obj.isBooleanSecond() );
-            assertEquals( "TEST", obj.getStringProperty() );
+            TestBean obj = on(TestBean.class).invokeConstructor(argument(Boolean.class, Boolean.TRUE),
+                    argument(String.class, "TEST")).get();
+            assertNotNull(obj);
+            assertEquals(true, obj.isBooleanSecond());
+            assertEquals("TEST", obj.getStringProperty());
         }
     }
 
-    @Test( expected = NoSuchConstructorException.class )
-    public void invokeConstructorWithInvalidTypeArray() throws Exception
-    {
-        on( TestBean.class ).invokeConstructor( argument( String.class, "TEST" ),
-                                                argument( Boolean.TYPE, Boolean.TRUE )).get();
+    @Test(expected = NoSuchConstructorException.class)
+    public void invokeConstructorWithInvalidTypeArray() throws Exception {
+        on(TestBean.class).invokeConstructor(argument(String.class, "TEST"),
+                argument(Boolean.TYPE, Boolean.TRUE)).get();
     }
 
     @Test
     public void invokeExactConstructor()
-        throws Exception
-    {
+            throws Exception {
         {
-            TestBean obj = on( TestBean.class ).invokeExactConstructor( argument( "TEST" ) ).get();
-            assertNotNull( obj );
-            assertEquals( "TEST", obj.getStringProperty() );
+            TestBean obj = on(TestBean.class).invokeExactConstructor(argument("TEST")).get();
+            assertNotNull(obj);
+            assertEquals("TEST", obj.getStringProperty());
         }
         {
-            TestBean obj = on( TestBean.class ).invokeExactConstructor( argument( Boolean.TRUE ) ).get();
-            assertNotNull( obj );
+            TestBean obj = on(TestBean.class).invokeExactConstructor(argument(Boolean.TRUE)).get();
+            assertNotNull(obj);
 
-            assertEquals( true, obj.isBooleanSecond() );
+            assertEquals(true, obj.isBooleanSecond());
         }
     }
 
-    @Test( expected = NoSuchConstructorException.class )
+    @Test(expected = NoSuchConstructorException.class)
     public void invokeExactConstructorWithInvalidArgument()
-        throws Exception
-    {
-        on( TestBean.class ).invokeExactConstructor( argument( new Float( 17.3f ) ) ).get();
+            throws Exception {
+        on(TestBean.class).invokeExactConstructor(argument(new Float(17.3f))).get();
     }
 
-    @Test( expected = NullPointerException.class )
+    @Test(expected = NullPointerException.class)
     public void invokeExactConstructorWithNull()
-        throws Exception
-    {
-        on( TestBean.class ).invokeExactConstructor( (Argument<?>) null );
+            throws Exception {
+        on(TestBean.class).invokeExactConstructor((Argument<?>) null);
     }
 
     @Test
     public void invokeExactConstructorWithArgArray()
-        throws Exception
-    {
-        TestBean obj = on( TestBean.class ).invokeExactConstructor( argument( Boolean.TRUE ),
-                                                                    argument( "TEST" ) ).get();
-        assertNotNull( obj );
-        assertEquals( true, obj.isBooleanSecond() );
-        assertEquals( "TEST", obj.getStringProperty() );
-    }
-
-    @Test( expected = NoSuchConstructorException.class )
-    public void invokeExactConstructorWithInvalidArgArray() throws Exception
-    {
-        on( TestBean.class ).invokeExactConstructor( argument( new Float( 17.3f ) ),argument( "TEST" ) ).get();
+            throws Exception {
+        TestBean obj = on(TestBean.class).invokeExactConstructor(argument(Boolean.TRUE),
+                argument("TEST")).get();
+        assertNotNull(obj);
+        assertEquals(true, obj.isBooleanSecond());
+        assertEquals("TEST", obj.getStringProperty());
     }
 
-    @Test( expected = NullPointerException.class )
+    @Test(expected = NoSuchConstructorException.class)
+    public void invokeExactConstructorWithInvalidArgArray() throws Exception {
+        on(TestBean.class).invokeExactConstructor(argument(new Float(17.3f)), argument("TEST")).get();
+    }
+
+    @Test(expected = NullPointerException.class)
     public void invokeExactConstructorWithNullArray()
-        throws Exception
-    {
-        on( TestBean.class ).invokeExactConstructor( null, null, null );
+            throws Exception {
+        on(TestBean.class).invokeExactConstructor(null, null, null);
     }
 
     @Test
     public void invokeExactConstructorWithTypeArray()
-        throws Exception
-    {
+            throws Exception {
         {
-            TestBean obj = on( TestBean.class ).invokeExactConstructor( argument( Boolean.TYPE, Boolean.TRUE ),
-                                                                        argument( String.class, "TEST" ) ).get();
-            assertNotNull( obj );
-            assertEquals( true, obj.getBooleanProperty() );
-            assertEquals( "TEST", obj.getStringProperty() );
+            TestBean obj = on(TestBean.class).invokeExactConstructor(argument(Boolean.TYPE, Boolean.TRUE),
+                    argument(String.class, "TEST")).get();
+            assertNotNull(obj);
+            assertEquals(true, obj.getBooleanProperty());
+            assertEquals("TEST", obj.getStringProperty());
         }
         {
-            TestBean obj = on( TestBean.class ).invokeExactConstructor( argument( Boolean.class, Boolean.TRUE ),
-                                                                        argument( String.class, "TEST" ) ).get();
-            assertNotNull( obj );
-            assertEquals( true, obj.isBooleanSecond() );
-            assertEquals( "TEST", obj.getStringProperty() );
+            TestBean obj = on(TestBean.class).invokeExactConstructor(argument(Boolean.class, Boolean.TRUE),
+                    argument(String.class, "TEST")).get();
+            assertNotNull(obj);
+            assertEquals(true, obj.isBooleanSecond());
+            assertEquals("TEST", obj.getStringProperty());
         }
         {
-            TestBean obj = on( TestBean.class ).invokeExactConstructor( argument( Float.TYPE, new Float( 17.3f ) ),
-                                                                        argument( String.class, "TEST" ) ).get();
-            assertNotNull( obj );
+            TestBean obj = on(TestBean.class).invokeExactConstructor(argument(Float.TYPE, new Float(17.3f)),
+                    argument(String.class, "TEST")).get();
+            assertNotNull(obj);
 
-            assertEquals( 17.3f, obj.getFloatProperty(), 0.0f );
-            assertEquals( "TEST", obj.getStringProperty() );
+            assertEquals(17.3f, obj.getFloatProperty(), 0.0f);
+            assertEquals("TEST", obj.getStringProperty());
         }
     }
 
-    @Test( expected = NoSuchConstructorException.class )
+    @Test(expected = NoSuchConstructorException.class)
     public void invokeExactConstructorWithInvalidTypeArray()
-        throws Exception
-    {
-        on( TestBean.class ).invokeExactConstructor( argument( Float.class, new Float( 17.3f ) ),
-                                                     argument( String.class, "TEST" ) ).get();
+            throws Exception {
+        on(TestBean.class).invokeExactConstructor(argument(Float.class, new Float(17.3f)),
+                argument(String.class, "TEST")).get();
     }
 
-    @Test( expected = ConstructorInvocationException.class )
+    @Test(expected = ConstructorInvocationException.class)
     public void invokeConstructorThatThrowsException()
-        throws Exception
-    {
-        on( ThrowingExceptionBean.class ).invokeConstructor( argument( RuntimeException.class,
-                                                                           new RuntimeException() ) );
+            throws Exception {
+        on(ThrowingExceptionBean.class).invokeConstructor(argument(RuntimeException.class,
+                new RuntimeException()));
     }
 
-    @Test( expected = ConstructorInvocationException.class )
+    @Test(expected = ConstructorInvocationException.class)
     public void invokeExactConstructorThatThrowsException()
-        throws Exception
-    {
-        on( ThrowingExceptionBean.class ).invokeExactConstructor( argument( RuntimeException.class,
-                                                                                new RuntimeException() ) );
+            throws Exception {
+        on(ThrowingExceptionBean.class).invokeExactConstructor(argument(RuntimeException.class,
+                new RuntimeException()));
     }
 
     // FIXME Why don't we see a ConstructorNotAccessibleException?
-    @Test( expected = NoSuchConstructorException.class )
+    @Test(expected = NoSuchConstructorException.class)
     public void invokePrivateConstructor()
-        throws Exception
-    {
-        on( ThrowingExceptionBean.class ).invokeConstructor( argument( Integer.class, Integer.valueOf( 4711 ) ) );
+            throws Exception {
+        on(ThrowingExceptionBean.class).invokeConstructor(argument(Integer.class, Integer.valueOf(4711)));
     }
 
     // FIXME Why don't we see a ConstructorNotAccessibleException?
-    @Test( expected = NoSuchConstructorException.class )
+    @Test(expected = NoSuchConstructorException.class)
     public void invokeProtectedConstructor()
-        throws Exception
-    {
-        on( ThrowingExceptionBean.class ).invokeConstructor( argument( Short.class, Short.valueOf( (short) 4711 ) ) );
+            throws Exception {
+        on(ThrowingExceptionBean.class).invokeConstructor(argument(Short.class, Short.valueOf((short) 4711)));
     }
 
     // FIXME Why don't we see a ConstructorNotAccessibleException?
-    @Test( expected = NoSuchConstructorException.class )
+    @Test(expected = NoSuchConstructorException.class)
     public void invokeDefaultConstructor()
-        throws Exception
-    {
-        on( ThrowingExceptionBean.class ).invokeConstructor( argument( Byte.class, Byte.valueOf( (byte) 4711 ) ) );
+            throws Exception {
+        on(ThrowingExceptionBean.class).invokeConstructor(argument(Byte.class, Byte.valueOf((byte) 4711)));
     }
 
     @Test
     public void invokeConstructorOnAbstract()
-        throws Exception
-    {
-        thrown.expect( BeanInstantiationException.class );
-        thrown.expectMessage( "abstract" );
-        on( AbstractTestBean.class ).invokeConstructor();
+            throws Exception {
+        thrown.expect(BeanInstantiationException.class);
+        thrown.expectMessage("abstract");
+        on(AbstractTestBean.class).invokeConstructor();
     }
 
     @Test
     public void invokeConstructorOnInterface()
-        throws Exception
-    {
-        thrown.expect( BeanInstantiationException.class );
-        thrown.expectMessage( "interface" );
-        on( ClassAccessor.class ).invokeConstructor();
+            throws Exception {
+        thrown.expect(BeanInstantiationException.class);
+        thrown.expectMessage("interface");
+        on(ClassAccessor.class).invokeConstructor();
     }
 
     @Test
     public void invokeConstructorOnArray()
-        throws Exception
-    {
-        thrown.expect( BeanInstantiationException.class );
-        thrown.expectMessage( "array" );
-        on( String[].class ).invokeConstructor();
+            throws Exception {
+        thrown.expect(BeanInstantiationException.class);
+        thrown.expectMessage("array");
+        on(String[].class).invokeConstructor();
     }
 
     @Test
     public void invokeConstructorOnPrimitive()
-        throws Exception
-    {
-        thrown.expect( BeanInstantiationException.class );
-        thrown.expectMessage( "primitive" );
-        on( int.class ).invokeConstructor();
+            throws Exception {
+        thrown.expect(BeanInstantiationException.class);
+        thrown.expectMessage("primitive");
+        on(int.class).invokeConstructor();
     }
 
     @Test
     public void invokeConstructorOnVoid()
-        throws Exception
-    {
-        thrown.expect( BeanInstantiationException.class );
-        thrown.expectMessage( "void" );
-        on( void.class ).invokeConstructor();
+            throws Exception {
+        thrown.expect(BeanInstantiationException.class);
+        thrown.expectMessage("void");
+        on(void.class).invokeConstructor();
     }
 
-    @Test( expected = NoSuchConstructorException.class )
-    public void newInstanceWithoutDefaultConstructor()
-    {
-        on( NoDefaultConstructor.class ).newInstance();
+    @Test(expected = NoSuchConstructorException.class)
+    public void newInstanceWithoutDefaultConstructor() {
+        on(NoDefaultConstructor.class).newInstance();
     }
 
-    public static class NoDefaultConstructor
-    {
+    public static class NoDefaultConstructor {
 
-        NoDefaultConstructor( int i )
-        {
+        NoDefaultConstructor(int i) {
             // do nothing here
         }
     }

Modified: commons/sandbox/beanutils2/trunk/src/test/java/org/apache/commons/beanutils2/CopyPropertiesTestCase.java
URL: http://svn.apache.org/viewvc/commons/sandbox/beanutils2/trunk/src/test/java/org/apache/commons/beanutils2/CopyPropertiesTestCase.java?rev=1592200&r1=1592199&r2=1592200&view=diff
==============================================================================
--- commons/sandbox/beanutils2/trunk/src/test/java/org/apache/commons/beanutils2/CopyPropertiesTestCase.java (original)
+++ commons/sandbox/beanutils2/trunk/src/test/java/org/apache/commons/beanutils2/CopyPropertiesTestCase.java Sat May  3 13:14:53 2014
@@ -1,5 +1,3 @@
-package org.apache.commons.beanutils2;
-
 /*
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with
@@ -17,69 +15,67 @@ package org.apache.commons.beanutils2;
  * limitations under the License.
  */
 
+package org.apache.commons.beanutils2;
+
 import static org.apache.commons.beanutils2.BeanUtils.on;
-import static org.apache.commons.beanutils2.testbeans.TestBeanUtils.*;
+import static org.apache.commons.beanutils2.testbeans.TestBeanUtils.assertReadWritePropertiesEquals;
+import static org.apache.commons.beanutils2.testbeans.TestBeanUtils.assertShallow;
+import static org.apache.commons.beanutils2.testbeans.TestBeanUtils.changeArrayProperties;
+import static org.apache.commons.beanutils2.testbeans.TestBeanUtils.changeScalarProperties;
 import static org.junit.Assert.assertEquals;
 
 import java.util.Map;
 
 import org.apache.commons.beanutils2.testbeans.TestBean;
-import org.junit.*;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
 
-public class CopyPropertiesTestCase
-{
+public class CopyPropertiesTestCase {
 
     private TestBean source;
 
     private ExtendedTestBean target;
 
     @Before
-    public void setUp()
-    {
+    public void setUp() {
         source = new TestBean();
         target = new ExtendedTestBean();
     }
 
     @After
-    public void tearDown()
-    {
+    public void tearDown() {
         source = null;
         target = null;
     }
 
-    @Test( expected = NullPointerException.class )
+    @Test(expected = NullPointerException.class)
     public void copyPropertiesToNull()
-        throws Exception
-    {
-        on( source ).copyPropertiesTo( null );
+            throws Exception {
+        on(source).copyPropertiesTo(null);
     }
 
     @Test
-    public void copyPropertiesToTargetWithChangedScalarProperties()
-        throws Exception
-    {
-        changeScalarProperties( target );
-        on( source ).copyPropertiesTo( target );
+    public void copyPropertiesToTargetWithChangedScalarProperties() {
+        changeScalarProperties(target);
+        on(source).copyPropertiesTo(target);
         // we can not simply call assertEquals because of the nested properties in TestBean
-        assertReadWritePropertiesEquals( source, target );
+        assertReadWritePropertiesEquals(source, target);
         assertExtendedPropertiesUnchanged();
     }
 
-    private void assertExtendedPropertiesUnchanged()
-    {
+    private void assertExtendedPropertiesUnchanged() {
         ExtendedTestBean expected = new ExtendedTestBean();
-        assertEquals( expected.extendedBooleanProperty, target.extendedBooleanProperty );
-        assertEquals( expected.extendedReadOnlyProperty, target.extendedReadOnlyProperty );
-        assertEquals( expected.extendedStringProperty, target.extendedStringProperty );
+        assertEquals(expected.extendedBooleanProperty, target.extendedBooleanProperty);
+        assertEquals(expected.extendedReadOnlyProperty, target.extendedReadOnlyProperty);
+        assertEquals(expected.extendedStringProperty, target.extendedStringProperty);
     }
 
     @Test
-    public void copyPropertiesToTargetWithChangedArrayProperties()
-        throws Exception
-    {
-        changeArrayProperties( target );
-        on( source ).copyPropertiesTo( target );
-        assertReadWritePropertiesEquals( source, target );
+    public void copyPropertiesToTargetWithChangedArrayProperties() {
+        changeArrayProperties(target);
+        on(source).copyPropertiesTo(target);
+        assertReadWritePropertiesEquals(source, target);
         assertExtendedPropertiesUnchanged();
     }
 
@@ -87,36 +83,32 @@ public class CopyPropertiesTestCase
      * Makes sure that copy properties has the same effect as populate, if source and target are of the same type
      */
     @Test
-    public void copyPropertiesToSameAsPopulate()
-        throws Exception
-    {
-        changeScalarProperties( source );
-        changeArrayProperties( source );
-        Map<String, Object> sourceProperties = on( source ).describe();
+    public void copyPropertiesToSameAsPopulate() {
+        changeScalarProperties(source);
+        changeArrayProperties(source);
+        Map<String, Object> sourceProperties = on(source).describe();
 
         TestBean targetForCopyProperties = new TestBean();
         TestBean targetForPopulate = new TestBean();
 
-        on( source ).copyPropertiesTo( targetForCopyProperties );
-        on( targetForPopulate ).populate( sourceProperties );
+        on(source).copyPropertiesTo(targetForCopyProperties);
+        on(targetForPopulate).populate(sourceProperties);
 
-        assertReadWritePropertiesEquals( source, targetForCopyProperties );
-        assertReadWritePropertiesEquals( source, targetForPopulate );
-        assertReadWritePropertiesEquals( targetForCopyProperties, targetForPopulate );
+        assertReadWritePropertiesEquals(source, targetForCopyProperties);
+        assertReadWritePropertiesEquals(source, targetForPopulate);
+        assertReadWritePropertiesEquals(targetForCopyProperties, targetForPopulate);
     }
 
     /**
      * Makes sure, that coping properties does not change the source
      */
     @Test
-    public void copyPropertiesToTargetNotChangingSource()
-        throws Exception
-    {
-        Map<String, Object> propertiesBefore = on( source ).describe();
-        on( source ).copyPropertiesTo( target );
-        Map<String, Object> propertiesAfter = on( source ).describe();
+    public void copyPropertiesToTargetNotChangingSource() {
+        Map<String, Object> propertiesBefore = on(source).describe();
+        on(source).copyPropertiesTo(target);
+        Map<String, Object> propertiesAfter = on(source).describe();
 
-        assertEquals( propertiesBefore, propertiesAfter );
+        assertEquals(propertiesBefore, propertiesAfter);
     }
 
     /**
@@ -124,47 +116,38 @@ public class CopyPropertiesTestCase
      * only be referenced from target and not copied.
      */
     @Test
-    public void copyPropertiesToTargetIsShallow() throws Exception {
-        on( source ).copyPropertiesTo( target );
+    public void copyPropertiesToTargetIsShallow() {
+        on(source).copyPropertiesTo(target);
 
         assertShallow(source, target);
     }
 
-    @SuppressWarnings( "unused" ) // unused methods invoked via introspection
+    @SuppressWarnings("unused") // unused methods invoked via introspection
     private static class ExtendedTestBean
-        extends TestBean
-    {
+            extends TestBean {
 
         private static final long serialVersionUID = 4854743778089894313L;
-
-        private boolean extendedBooleanProperty = true;
-
         private final String extendedReadOnlyProperty = "extended read only property";
-
+        private boolean extendedBooleanProperty = true;
         private String extendedStringProperty = "extended string property";
 
-        public boolean getExtendedBooleanProperty()
-        {
+        public boolean getExtendedBooleanProperty() {
             return extendedBooleanProperty;
         }
 
-        public void setExtendedBooleanProperty( boolean booleanProperty )
-        {
+        public void setExtendedBooleanProperty(boolean booleanProperty) {
             extendedBooleanProperty = booleanProperty;
         }
 
-        public String getExtendedReadOnlyProperty()
-        {
+        public String getExtendedReadOnlyProperty() {
             return extendedReadOnlyProperty;
         }
 
-        public String getExtendedStringProperty()
-        {
+        public String getExtendedStringProperty() {
             return extendedStringProperty;
         }
 
-        public void setExtendedStringProperty( String stringProperty )
-        {
+        public void setExtendedStringProperty(String stringProperty) {
             extendedStringProperty = stringProperty;
         }
 

Modified: commons/sandbox/beanutils2/trunk/src/test/java/org/apache/commons/beanutils2/DescribeTestCase.java
URL: http://svn.apache.org/viewvc/commons/sandbox/beanutils2/trunk/src/test/java/org/apache/commons/beanutils2/DescribeTestCase.java?rev=1592200&r1=1592199&r2=1592200&view=diff
==============================================================================
--- commons/sandbox/beanutils2/trunk/src/test/java/org/apache/commons/beanutils2/DescribeTestCase.java (original)
+++ commons/sandbox/beanutils2/trunk/src/test/java/org/apache/commons/beanutils2/DescribeTestCase.java Sat May  3 13:14:53 2014
@@ -1,5 +1,3 @@
-package org.apache.commons.beanutils2;
-
 /*
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with
@@ -17,6 +15,8 @@ package org.apache.commons.beanutils2;
  * limitations under the License.
  */
 
+package org.apache.commons.beanutils2;
+
 import static org.apache.commons.beanutils2.BeanUtils.on;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNotNull;
@@ -30,182 +30,158 @@ import org.junit.After;
 import org.junit.Before;
 import org.junit.Test;
 
-public class DescribeTestCase
-{
+public class DescribeTestCase {
 
+    /**
+     * The set of properties that should be described.
+     */
+    private final String describes[] =
+            {"booleanProperty",
+                    "booleanSecond",
+                    "byteProperty",
+                    "doubleProperty",
+                    "dupProperty",
+                    "floatProperty",
+                    "intArray",
+//            "intIndexed",
+                    "longProperty",
+                    "listIndexed",
+                    "longProperty",
+//            "mappedProperty",
+//            "mappedIntProperty",
+                    "nested",
+                    "nullProperty",
+                    "readOnlyProperty",
+                    "shortProperty",
+                    "stringArray",
+//            "stringIndexed",
+                    "stringProperty"
+            };
     private TestBean testBean;
 
     @Before
-    public void setUp()
-    {
+    public void setUp() {
         testBean = new TestBean();
     }
 
     @After
-    public void tearDown()
-    {
+    public void tearDown() {
         testBean = null;
     }
 
-    /**
-     * The set of properties that should be described.
-     */
-    private final String describes[] =
-    { "booleanProperty",
-      "booleanSecond",
-      "byteProperty",
-      "doubleProperty",
-      "dupProperty",
-      "floatProperty",
-      "intArray",
-//            "intIndexed",
-      "longProperty",
-      "listIndexed",
-      "longProperty",
-//            "mappedProperty",
-//            "mappedIntProperty",
-      "nested",
-      "nullProperty",
-      "readOnlyProperty",
-      "shortProperty",
-      "stringArray",
-//            "stringIndexed",
-      "stringProperty"
-    };
-
     @Test
     public void describe()
-        throws Exception
-    {
-        Map<String, Object> properties = on( testBean ).describe();
-        assertNotNull( properties );
+            throws Exception {
+        Map<String, Object> properties = on(testBean).describe();
+        assertNotNull(properties);
 
         // Verify existence of all the properties that should be present
-        for ( int i = 0; i < describes.length; i++ )
-        {
-            assertTrue( "Property '" + describes[i] + "' is not present", properties.containsKey( describes[i] ) );
+        for (int i = 0; i < describes.length; i++) {
+            assertTrue("Property '" + describes[i] + "' is not present", properties.containsKey(describes[i]));
         }
 
-        assertTrue( properties.containsKey( "class" ) );
+        assertTrue(properties.containsKey("class"));
 
-        assertTrue( "Property 'writeOnlyProperty' is not present", !properties.containsKey( "writeOnlyProperty" ) );
+        assertTrue("Property 'writeOnlyProperty' is not present", !properties.containsKey("writeOnlyProperty"));
 
         // Verify the values of scalar properties
-        assertEquals( "Value of 'booleanProperty'", true, properties.get( "booleanProperty" ) );
-        assertEquals( "Value of 'byteProperty'", (byte) 121, properties.get( "byteProperty" ) );
-        assertEquals( "Value of 'doubleProperty'", 321.0d, properties.get( "doubleProperty" ) );
-        assertEquals( "Value of 'floatProperty'", 123.0f, properties.get( "floatProperty" ) );
-        assertEquals( "Value of 'intProperty'", 123, properties.get( "intProperty" ) );
-        assertEquals( "Value of 'longProperty'", 321l, properties.get( "longProperty" ) );
-        assertEquals( "Value of 'shortProperty'", (short) 987, properties.get( "shortProperty" ) );
-        assertEquals( "Value of 'stringProperty'", "This is a string", properties.get( "stringProperty" ) );
+        assertEquals("Value of 'booleanProperty'", true, properties.get("booleanProperty"));
+        assertEquals("Value of 'byteProperty'", (byte) 121, properties.get("byteProperty"));
+        assertEquals("Value of 'doubleProperty'", 321.0d, properties.get("doubleProperty"));
+        assertEquals("Value of 'floatProperty'", 123.0f, properties.get("floatProperty"));
+        assertEquals("Value of 'intProperty'", 123, properties.get("intProperty"));
+        assertEquals("Value of 'longProperty'", 321l, properties.get("longProperty"));
+        assertEquals("Value of 'shortProperty'", (short) 987, properties.get("shortProperty"));
+        assertEquals("Value of 'stringProperty'", "This is a string", properties.get("stringProperty"));
     }
 
     /**
      * Test with an private class that overrides a public method of a "grand parent" public class.
-     * <p />
+     *
      * See Jira issue# BEANUTILS-157.
      */
     @Test
-    public void describeSerializable()
-        throws Exception
-    {
-        Object bean = new Serializable()
-        {
+    public void describeSerializable() {
+        Object bean = new Serializable() {
             private static final long serialVersionUID = 1L;
 
-            @SuppressWarnings( "unused" )
-            public String getX()
-            {
+            @SuppressWarnings("unused")
+            public String getX() {
                 return "x-value";
             }
 
-            @SuppressWarnings( "unused" )
-            public String getY()
-            {
+            @SuppressWarnings("unused")
+            public String getY() {
                 return "y-value";
             }
         };
-        Map<String, Object> result = on( bean ).describe();
+        Map<String, Object> result = on(bean).describe();
         // 2 properties + getClass()
-        assertEquals( "Check Size", 3, result.size() );
-        assertTrue( "Class", result.containsKey( "class" ) );
+        assertEquals("Check Size", 3, result.size());
+        assertTrue("Class", result.containsKey("class"));
     }
 
     /**
      * Test with an private class that overrides a public method of a "grand parent" public class.
-     * <p />
+     *
      * See Jira issue# BEANUTILS-157.
      */
     @Test
-    public void describeInterface()
-        throws Exception
-    {
-        Object bean = new XY()
-        {
-            public String getX()
-            {
+    public void describeInterface() {
+        Object bean = new XY() {
+            public String getX() {
                 return "x-value";
             }
 
-            public String getY()
-            {
+            public String getY() {
                 return "y-value";
             }
         };
-        Map<String, Object> result = on( bean ).describe();
-        assertEquals( "Check Size", 3, result.size() );
-        assertTrue( "Class", result.containsKey( "class" ) );
-        assertTrue( "X Key", result.containsKey( "x" ) );
-        assertTrue( "Y Key", result.containsKey( "y" ) );
-        assertEquals( "X Value", "x-value", result.get( "x" ) );
-        assertEquals( "Y Value", "y-value", result.get( "y" ) );
+        Map<String, Object> result = on(bean).describe();
+        assertEquals("Check Size", 3, result.size());
+        assertTrue("Class", result.containsKey("class"));
+        assertTrue("X Key", result.containsKey("x"));
+        assertTrue("Y Key", result.containsKey("y"));
+        assertEquals("X Value", "x-value", result.get("x"));
+        assertEquals("Y Value", "y-value", result.get("y"));
     }
 
     /**
      * Test with an private class that overrides a public method of a "grand parent" public class.
-     * <p />
+     *
      * See Jira issue# BEANUTILS-157.
      */
     @Test
-    public void describeBean()
-        throws Exception
-    {
+    public void describeBean() {
         Object bean = new FooBar();
-        Map<String, Object> result = on( bean ).describe();
-        assertEquals( "Check Size", 2, result.size() );
-        assertTrue( "Class", result.containsKey( "class" ) );
-        assertTrue( "publicFoo Key", result.containsKey( "publicFoo" ) );
-        assertEquals( "publicFoo Value", "PublicFoo Value", result.get( "publicFoo" ) );
+        Map<String, Object> result = on(bean).describe();
+        assertEquals("Check Size", 2, result.size());
+        assertTrue("Class", result.containsKey("class"));
+        assertTrue("publicFoo Key", result.containsKey("publicFoo"));
+        assertEquals("publicFoo Value", "PublicFoo Value", result.get("publicFoo"));
     }
 
-    public static interface XY
-    {
+    public static interface XY {
         String getX();
 
         String getY();
     }
 
-    public static class FooBar
-    {
-        String getPackageFoo()
-        {
+    public static class FooBar {
+        String getPackageFoo() {
             return "Package Value";
         }
 
-        @SuppressWarnings( "unused" )
-        private String getPrivateFoo()
-        {
+        @SuppressWarnings("unused")
+        private String getPrivateFoo() {
             return "PrivateFoo Value";
         }
 
-        protected String getProtectedFoo()
-        {
+        protected String getProtectedFoo() {
             return "ProtectedFoo Value";
         }
 
-        public String getPublicFoo()
-        {
+        public String getPublicFoo() {
             return "PublicFoo Value";
         }
     }

Modified: commons/sandbox/beanutils2/trunk/src/test/java/org/apache/commons/beanutils2/GetIndexedPropertyTestCase.java
URL: http://svn.apache.org/viewvc/commons/sandbox/beanutils2/trunk/src/test/java/org/apache/commons/beanutils2/GetIndexedPropertyTestCase.java?rev=1592200&r1=1592199&r2=1592200&view=diff
==============================================================================
--- commons/sandbox/beanutils2/trunk/src/test/java/org/apache/commons/beanutils2/GetIndexedPropertyTestCase.java (original)
+++ commons/sandbox/beanutils2/trunk/src/test/java/org/apache/commons/beanutils2/GetIndexedPropertyTestCase.java Sat May  3 13:14:53 2014
@@ -1,5 +1,3 @@
-package org.apache.commons.beanutils2;
-
 /*
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with
@@ -17,6 +15,8 @@ package org.apache.commons.beanutils2;
  * limitations under the License.
  */
 
+package org.apache.commons.beanutils2;
+
 import static org.apache.commons.beanutils2.BeanUtils.on;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNotNull;
@@ -27,76 +27,65 @@ import org.junit.After;
 import org.junit.Before;
 import org.junit.Test;
 
-public class GetIndexedPropertyTestCase
-{
+public class GetIndexedPropertyTestCase {
 
     private TestBean testBean;
 
     private ThrowingExceptionBean exceptionBean;
 
     @Before
-    public void setUp()
-    {
+    public void setUp() {
         testBean = new TestBean();
         exceptionBean = new ThrowingExceptionBean();
     }
 
     @After
-    public void tearDown()
-    {
+    public void tearDown() {
         testBean = null;
         exceptionBean = null;
     }
 
-    @Test( expected = NullPointerException.class )
-    public void getIndexedNull()
-    {
-        on( testBean ).getIndexed( null );
-    }
-
-    @Test( expected = NoSuchPropertyException.class )
-    public void getIndexedUnknown()
-    {
-        on( testBean ).getIndexed( "unknown" );
-    }
-
-    @Test( expected = IllegalArgumentException.class )
-    public void getIndexedNegative()
-    {
-        on( testBean ).getIndexed( "intIndexed" ).at( -1 );
+    @Test(expected = NullPointerException.class)
+    public void getIndexedNull() {
+        on(testBean).getIndexed(null);
+    }
+
+    @Test(expected = NoSuchPropertyException.class)
+    public void getIndexedUnknown() {
+        on(testBean).getIndexed("unknown");
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void getIndexedNegative() {
+        on(testBean).getIndexed("intIndexed").at(-1);
     }
 
     @Test
-    public void getIndexed()
-    {
-        int expected = testBean.getIntIndexed( 0 );
-        BeanAccessor<?> accessor = on( testBean ).getIndexed( "intIndexed" ).at( 0 );
-        assertNotNull( accessor );
-        assertEquals( expected, accessor.get() );
+    public void getIndexed() {
+        int expected = testBean.getIntIndexed(0);
+        BeanAccessor<?> accessor = on(testBean).getIndexed("intIndexed").at(0);
+        assertNotNull(accessor);
+        assertEquals(expected, accessor.get());
     }
 
-    @Test( expected = PropertyGetterInvocationException.class )
-    public void getExceptionIndexed()
-    {
-        on( exceptionBean ).getIndexed( "exceptionIndexed" ).at( 0 );
+    @Test(expected = PropertyGetterInvocationException.class)
+    public void getExceptionIndexed() {
+        on(exceptionBean).getIndexed("exceptionIndexed").at(0);
     }
 
-    @Test( expected = NoSuchPropertyException.class )
-    public void getPrivateIndexed()
-    {
-        on( exceptionBean ).getIndexed( "privateIndexed" );
+    @Test(expected = NoSuchPropertyException.class)
+    public void getPrivateIndexed() {
+        on(exceptionBean).getIndexed("privateIndexed");
     }
 
-    @Test( expected = NoSuchPropertyException.class )
-    public void getProtectedIndexed()
-    {
-        on( exceptionBean ).getIndexed( "protecedIndexed" );
+    @Test(expected = NoSuchPropertyException.class)
+    public void getProtectedIndexed() {
+        on(exceptionBean).getIndexed("protecedIndexed");
     }
 
-    @Test( expected = NoSuchPropertyException.class )
-    public void getDefaultIndexed()
-    {
-        on( exceptionBean ).getIndexed( "defaultIndexed" );
+    @Test(expected = NoSuchPropertyException.class)
+    public void getDefaultIndexed() {
+        on(exceptionBean).getIndexed("defaultIndexed");
     }
 
 }

Modified: commons/sandbox/beanutils2/trunk/src/test/java/org/apache/commons/beanutils2/GetMappedPropertyTestCase.java
URL: http://svn.apache.org/viewvc/commons/sandbox/beanutils2/trunk/src/test/java/org/apache/commons/beanutils2/GetMappedPropertyTestCase.java?rev=1592200&r1=1592199&r2=1592200&view=diff
==============================================================================
--- commons/sandbox/beanutils2/trunk/src/test/java/org/apache/commons/beanutils2/GetMappedPropertyTestCase.java (original)
+++ commons/sandbox/beanutils2/trunk/src/test/java/org/apache/commons/beanutils2/GetMappedPropertyTestCase.java Sat May  3 13:14:53 2014
@@ -1,5 +1,3 @@
-package org.apache.commons.beanutils2;
-
 /*
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with
@@ -17,6 +15,8 @@ package org.apache.commons.beanutils2;
  * limitations under the License.
  */
 
+package org.apache.commons.beanutils2;
+
 import static org.apache.commons.beanutils2.BeanUtils.on;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNull;
@@ -26,100 +26,86 @@ import org.apache.commons.beanutils2.tes
 import org.junit.Before;
 import org.junit.Test;
 
-public class GetMappedPropertyTestCase
-{
+public class GetMappedPropertyTestCase {
 
     private TestBean testBean;
     private ThrowingExceptionBean exceptionBean;
 
     @Before
-    public void setUp()
-    {
+    public void setUp() {
         testBean = new TestBean();
         exceptionBean = new ThrowingExceptionBean();
     }
 
-    @Test( expected = NullPointerException.class )
+    @Test(expected = NullPointerException.class)
     public void getMappedNull()
-        throws Exception
-    {
-        on( testBean ).getMapped( null );
+            throws Exception {
+        on(testBean).getMapped(null);
     }
 
-    @Test( expected = NoSuchPropertyException.class )
+    @Test(expected = NoSuchPropertyException.class)
     public void getMappedUnknownProperty()
-        throws Exception
-    {
-        on( testBean ).getMapped( "unknown" );
+            throws Exception {
+        on(testBean).getMapped("unknown");
     }
 
-    @Test( expected = IllegalArgumentException.class )
+    @Test(expected = IllegalArgumentException.class)
     public void getMappedNotMappedProperty()
-        throws Exception
-    {
-        on( testBean ).getMapped( "intProperty" );
+            throws Exception {
+        on(testBean).getMapped("intProperty");
     }
 
-    @Test( expected = NullPointerException.class )
+    @Test(expected = NullPointerException.class)
     public void getMappedIntNullKey()
-        throws Exception
-    {
-        on( testBean ).getMapped( "mappedIntProperty" ).of( null );
+            throws Exception {
+        on(testBean).getMapped("mappedIntProperty").of(null);
     }
 
     @Test
     public void getMappedUnknownKey()
-        throws Exception
-    {
-        BeanAccessor<?> result = on( testBean ).getMapped( "mappedProperty" ).of( "unknownKey" );
-        assertNull( result.get() );
+            throws Exception {
+        BeanAccessor<?> result = on(testBean).getMapped("mappedProperty").of("unknownKey");
+        assertNull(result.get());
     }
 
     @Test
     public void getMappedMappedProperty()
-        throws Exception
-    {
-        BeanAccessor<?> result = on( testBean ).getMapped( "mappedProperty" ).of( "First Key" );
-        assertEquals( "First Value", result.get() );
+            throws Exception {
+        BeanAccessor<?> result = on(testBean).getMapped("mappedProperty").of("First Key");
+        assertEquals("First Value", result.get());
     }
 
     @Test
     public void getMappedMappedIntProperty()
-        throws Exception
-    {
-        BeanAccessor<?> result = on( testBean ).getMapped( "mappedIntProperty" ).of( "One" );
-        assertEquals( Integer.valueOf( 1 ), result.get() );
+            throws Exception {
+        BeanAccessor<?> result = on(testBean).getMapped("mappedIntProperty").of("One");
+        assertEquals(Integer.valueOf(1), result.get());
     }
 
     @Test
     public void getMappedMappedObjects()
-        throws Exception
-    {
-        BeanAccessor<?> result = on( testBean ).getMapped( "mappedObjects" ).of( "First Key" );
-        assertEquals( "First Value", result.get() );
+            throws Exception {
+        BeanAccessor<?> result = on(testBean).getMapped("mappedObjects").of("First Key");
+        assertEquals("First Value", result.get());
     }
 
-    @Test( expected = PropertyGetterInvocationException.class )
-    public void getExceptionMapped()
-    {
-        on( exceptionBean ).getMapped( "exceptionMapped" ).of( "A Key" );
+    @Test(expected = PropertyGetterInvocationException.class)
+    public void getExceptionMapped() {
+        on(exceptionBean).getMapped("exceptionMapped").of("A Key");
     }
 
-    @Test( expected = NoSuchPropertyException.class )
-    public void getPrivateMapped()
-    {
-        on( exceptionBean ).getMapped( "privateMapped" );
+    @Test(expected = NoSuchPropertyException.class)
+    public void getPrivateMapped() {
+        on(exceptionBean).getMapped("privateMapped");
     }
 
-    @Test( expected = NoSuchPropertyException.class )
-    public void getProtectedMapped()
-    {
-        on( exceptionBean ).getMapped( "protecedMapped" );
+    @Test(expected = NoSuchPropertyException.class)
+    public void getProtectedMapped() {
+        on(exceptionBean).getMapped("protecedMapped");
     }
 
-    @Test( expected = NoSuchPropertyException.class )
-    public void getDefaultMapped()
-    {
-        on( exceptionBean ).getMapped( "defaultMapped" );
+    @Test(expected = NoSuchPropertyException.class)
+    public void getDefaultMapped() {
+        on(exceptionBean).getMapped("defaultMapped");
     }
 }

Modified: commons/sandbox/beanutils2/trunk/src/test/java/org/apache/commons/beanutils2/GetPropertyTestCase.java
URL: http://svn.apache.org/viewvc/commons/sandbox/beanutils2/trunk/src/test/java/org/apache/commons/beanutils2/GetPropertyTestCase.java?rev=1592200&r1=1592199&r2=1592200&view=diff
==============================================================================
--- commons/sandbox/beanutils2/trunk/src/test/java/org/apache/commons/beanutils2/GetPropertyTestCase.java (original)
+++ commons/sandbox/beanutils2/trunk/src/test/java/org/apache/commons/beanutils2/GetPropertyTestCase.java Sat May  3 13:14:53 2014
@@ -1,5 +1,3 @@
-package org.apache.commons.beanutils2;
-
 /*
  * Licensed to the Apache Software Foundation (ASF) under one
  * or more contributor license agreements.  See the NOTICE file
@@ -19,6 +17,8 @@ package org.apache.commons.beanutils2;
  * under the License.
  */
 
+package org.apache.commons.beanutils2;
+
 import static org.apache.commons.beanutils2.BeanUtils.on;
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertTrue;
@@ -29,23 +29,20 @@ import org.junit.After;
 import org.junit.Before;
 import org.junit.Test;
 
-public final class GetPropertyTestCase
-{
+public final class GetPropertyTestCase {
 
     private TestBean bean;
 
     private ThrowingExceptionBean exceptionBean;
 
     @Before
-    public void setUp()
-    {
+    public void setUp() {
         bean = new TestBean();
         exceptionBean = new ThrowingExceptionBean();
     }
 
     @After
-    public void tearDown()
-    {
+    public void tearDown() {
         bean = null;
         exceptionBean = null;
     }
@@ -54,58 +51,49 @@ public final class GetPropertyTestCase
      * Test getSimpleProperty on a boolean property.
      */
     @Test
-    public void getSimpleBoolean()
-        throws Exception
-    {
-        Object value = on( bean ).get( "booleanProperty" ).get();
-        assertNotNull( "Got no value", value );
-        assertTrue( "Got a value of the wrong type", ( value instanceof Boolean ) );
-        assertTrue( "Got an incorrect value", ( (Boolean) value ).booleanValue() == bean.getBooleanProperty() );
+    public void getSimpleBoolean() {
+        Object value = on(bean).get("booleanProperty").get();
+        assertNotNull("Got no value", value);
+        assertTrue("Got a value of the wrong type", (value instanceof Boolean));
+        assertTrue("Got an incorrect value", ((Boolean) value).booleanValue() == bean.getBooleanProperty());
     }
 
-    @Test( expected = PropertyNotReadableException.class )
+    @Test(expected = PropertyNotReadableException.class)
     public void getWriteOnlyProperty()
-        throws Exception
-    {
-        on( bean ).get( "writeOnlyProperty" );
+            throws Exception {
+        on(bean).get("writeOnlyProperty");
     }
 
-    @Test( expected = NoSuchPropertyException.class )
+    @Test(expected = NoSuchPropertyException.class)
     public void getUnknownProperty()
-        throws Exception
-    {
-        on( bean ).get( "unknown" );
+            throws Exception {
+        on(bean).get("unknown");
     }
 
-    @Test( expected = NullPointerException.class )
+    @Test(expected = NullPointerException.class)
     public void getNull()
-        throws Exception
-    {
-        on( bean ).get( null );
+            throws Exception {
+        on(bean).get(null);
     }
 
-    @Test( expected = NoSuchPropertyException.class )
-    public void getPrivateProperty()
-    {
-        on( exceptionBean ).get( "privateProperty" );
+    @Test(expected = NoSuchPropertyException.class)
+    public void getPrivateProperty() {
+        on(exceptionBean).get("privateProperty");
     }
 
-    @Test( expected = NoSuchPropertyException.class )
-    public void getProtectedProperty()
-    {
-        on( exceptionBean ).get( "protectedProperty" );
+    @Test(expected = NoSuchPropertyException.class)
+    public void getProtectedProperty() {
+        on(exceptionBean).get("protectedProperty");
     }
 
-    @Test( expected = NoSuchPropertyException.class )
-    public void getDefaultProperty()
-    {
-        on( exceptionBean ).get( "defaultProperty" );
+    @Test(expected = NoSuchPropertyException.class)
+    public void getDefaultProperty() {
+        on(exceptionBean).get("defaultProperty");
     }
 
-    @Test( expected = PropertyGetterInvocationException.class )
-    public void getExceptionProperty()
-    {
-        on( exceptionBean ).get( "exceptionProperty" );
+    @Test(expected = PropertyGetterInvocationException.class)
+    public void getExceptionProperty() {
+        on(exceptionBean).get("exceptionProperty");
     }
 
 }

Modified: commons/sandbox/beanutils2/trunk/src/test/java/org/apache/commons/beanutils2/HasPropertyTestCase.java
URL: http://svn.apache.org/viewvc/commons/sandbox/beanutils2/trunk/src/test/java/org/apache/commons/beanutils2/HasPropertyTestCase.java?rev=1592200&r1=1592199&r2=1592200&view=diff
==============================================================================
--- commons/sandbox/beanutils2/trunk/src/test/java/org/apache/commons/beanutils2/HasPropertyTestCase.java (original)
+++ commons/sandbox/beanutils2/trunk/src/test/java/org/apache/commons/beanutils2/HasPropertyTestCase.java Sat May  3 13:14:53 2014
@@ -1,5 +1,3 @@
-package org.apache.commons.beanutils2;
-
 /*
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with
@@ -17,6 +15,8 @@ package org.apache.commons.beanutils2;
  * limitations under the License.
  */
 
+package org.apache.commons.beanutils2;
+
 import static org.apache.commons.beanutils2.BeanUtils.on;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertTrue;
@@ -24,30 +24,26 @@ import static org.junit.Assert.assertTru
 import org.apache.commons.beanutils2.testbeans.TestBean;
 import org.junit.Test;
 
-public class HasPropertyTestCase
-{
+public class HasPropertyTestCase {
 
-    @Test( expected = NullPointerException.class )
+    @Test(expected = NullPointerException.class)
     public void hasPropertyNull()
-        throws Exception
-    {
-        on( TestBean.class ).getProperties().hasProperty( null );
+            throws Exception {
+        on(TestBean.class).getProperties().hasProperty(null);
     }
 
     @Test
     public void hasPropertyUnknown()
-        throws Exception
-    {
-        boolean shouldBeFalse = on( TestBean.class ).getProperties().hasProperty( "unknown" );
-        assertFalse( shouldBeFalse );
+            throws Exception {
+        boolean shouldBeFalse = on(TestBean.class).getProperties().hasProperty("unknown");
+        assertFalse(shouldBeFalse);
     }
 
     @Test
     public void hasPropertyExistingProperty()
-        throws Exception
-    {
-        boolean shouldBeTrue = on( TestBean.class ).getProperties().hasProperty( "stringProperty" );
-        assertTrue( shouldBeTrue );
+            throws Exception {
+        boolean shouldBeTrue = on(TestBean.class).getProperties().hasProperty("stringProperty");
+        assertTrue(shouldBeTrue);
     }
 
 }

Modified: commons/sandbox/beanutils2/trunk/src/test/java/org/apache/commons/beanutils2/IsReadableTestCase.java
URL: http://svn.apache.org/viewvc/commons/sandbox/beanutils2/trunk/src/test/java/org/apache/commons/beanutils2/IsReadableTestCase.java?rev=1592200&r1=1592199&r2=1592200&view=diff
==============================================================================
--- commons/sandbox/beanutils2/trunk/src/test/java/org/apache/commons/beanutils2/IsReadableTestCase.java (original)
+++ commons/sandbox/beanutils2/trunk/src/test/java/org/apache/commons/beanutils2/IsReadableTestCase.java Sat May  3 13:14:53 2014
@@ -1,5 +1,3 @@
-package org.apache.commons.beanutils2;
-
 /*
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with
@@ -17,6 +15,8 @@ package org.apache.commons.beanutils2;
  * limitations under the License.
  */
 
+package org.apache.commons.beanutils2;
+
 import static org.apache.commons.beanutils2.BeanUtils.on;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertTrue;
@@ -24,77 +24,67 @@ import static org.junit.Assert.assertTru
 import org.apache.commons.beanutils2.testbeans.TestBean;
 import org.junit.Test;
 
-public class IsReadableTestCase
-{
+public class IsReadableTestCase {
 
-    @Test( expected = NullPointerException.class )
+    @Test(expected = NullPointerException.class)
     public void isReadableNull()
-        throws Exception
-    {
-        on( TestBean.class ).getProperties().isReadable( null );
+            throws Exception {
+        on(TestBean.class).getProperties().isReadable(null);
     }
 
-    @Test( expected = NoSuchPropertyException.class )
+    @Test(expected = NoSuchPropertyException.class)
     public void isReadbleUnknown()
-        throws Exception
-    {
-        on( TestBean.class ).getProperties().isReadable( "unknown" );
+            throws Exception {
+        on(TestBean.class).getProperties().isReadable("unknown");
     }
 
     @Test
     public void isReadbleIntProperty()
-        throws Exception
-    {
-        assertTrue( "isReadable returned false for a read/write int property!",
-                    on( TestBean.class ).getProperties().isReadable( "intProperty" ) );
+            throws Exception {
+        assertTrue("isReadable returned false for a read/write int property!",
+                on(TestBean.class).getProperties().isReadable("intProperty"));
     }
 
     @Test
     public void isReadbleIntArray()
-        throws Exception
-    {
-        assertTrue( "isReadable returned false for a read/write array property!",
-                    on( TestBean.class ).getProperties().isReadable( "intArray" ) );
+            throws Exception {
+        assertTrue("isReadable returned false for a read/write array property!",
+                on(TestBean.class).getProperties().isReadable("intArray"));
     }
 
     @Test
     public void isReadableIntIndexed()
-        throws Exception
-    {
-        assertTrue( "isReadable returned false for a read/write indexed property!",
-                    on( TestBean.class ).getProperties().isReadable( "intIndexed" ) );
+            throws Exception {
+        assertTrue("isReadable returned false for a read/write indexed property!",
+                on(TestBean.class).getProperties().isReadable("intIndexed"));
     }
 
     @Test
     public void isReadableMappedIntProperty()
-        throws Exception
-    {
-        assertTrue( "isReadable returned false for a read/write mapped property!",
-                    on( TestBean.class ).getProperties().isReadable( "mappedIntProperty" ) );
+            throws Exception {
+        assertTrue("isReadable returned false for a read/write mapped property!",
+                on(TestBean.class).getProperties().isReadable("mappedIntProperty"));
     }
 
     @Test
     public void isReadbleMapProperty()
-        throws Exception
-    {
-        assertTrue( "isReadable returned false for a read/write map property!",
-                    on( TestBean.class ).getProperties().isReadable( "mapProperty" ) );
+            throws Exception {
+        assertTrue("isReadable returned false for a read/write map property!",
+                on(TestBean.class).getProperties().isReadable("mapProperty"));
     }
 
     @Test
     public void isReadableReadOnlyProperty()
-        throws Exception
-    {
-        assertTrue( "isReadble returned false for a read only property!",
-                    on( TestBean.class ).getProperties().isReadable( "readOnlyProperty" ) );
+            throws Exception {
+        assertTrue("isReadble returned false for a read only property!",
+                on(TestBean.class).getProperties().isReadable("readOnlyProperty"));
     }
 
     @Test
     public void isReadableWriteOnlyProperty()
-        throws Exception
-    {
-        assertFalse( "isReadable returned true for a write only property!",
-                     on( TestBean.class ).getProperties().isReadable( "writeOnlyProperty" ) );
+            throws Exception {
+        assertFalse("isReadable returned true for a write only property!",
+                on(TestBean.class).getProperties().isReadable("writeOnlyProperty"));
     }
 
 }

Modified: commons/sandbox/beanutils2/trunk/src/test/java/org/apache/commons/beanutils2/IsWritableTestCase.java
URL: http://svn.apache.org/viewvc/commons/sandbox/beanutils2/trunk/src/test/java/org/apache/commons/beanutils2/IsWritableTestCase.java?rev=1592200&r1=1592199&r2=1592200&view=diff
==============================================================================
--- commons/sandbox/beanutils2/trunk/src/test/java/org/apache/commons/beanutils2/IsWritableTestCase.java (original)
+++ commons/sandbox/beanutils2/trunk/src/test/java/org/apache/commons/beanutils2/IsWritableTestCase.java Sat May  3 13:14:53 2014
@@ -1,5 +1,3 @@
-package org.apache.commons.beanutils2;
-
 /*
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with
@@ -17,6 +15,8 @@ package org.apache.commons.beanutils2;
  * limitations under the License.
  */
 
+package org.apache.commons.beanutils2;
+
 import static org.apache.commons.beanutils2.BeanUtils.on;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertTrue;
@@ -24,77 +24,67 @@ import static org.junit.Assert.assertTru
 import org.apache.commons.beanutils2.testbeans.TestBean;
 import org.junit.Test;
 
-public class IsWritableTestCase
-{
+public class IsWritableTestCase {
 
-    @Test( expected = NullPointerException.class )
+    @Test(expected = NullPointerException.class)
     public void isWritableNull()
-        throws Exception
-    {
-        on( TestBean.class ).getProperties().isWritable( null );
+            throws Exception {
+        on(TestBean.class).getProperties().isWritable(null);
     }
 
-    @Test( expected = NoSuchPropertyException.class )
+    @Test(expected = NoSuchPropertyException.class)
     public void isWritbleUnknown()
-        throws Exception
-    {
-        on( TestBean.class ).getProperties().isWritable( "unknown" );
+            throws Exception {
+        on(TestBean.class).getProperties().isWritable("unknown");
     }
 
     @Test
     public void isWritbleIntProperty()
-        throws Exception
-    {
-        assertTrue( "isWritable returned false for a read/write int property!",
-                    on( TestBean.class ).getProperties().isWritable( "intProperty" ) );
+            throws Exception {
+        assertTrue("isWritable returned false for a read/write int property!",
+                on(TestBean.class).getProperties().isWritable("intProperty"));
     }
 
     @Test
     public void isWritbleIntArray()
-        throws Exception
-    {
-        assertTrue( "isWritable returned false for a read/write array property!",
-                    on( TestBean.class ).getProperties().isWritable( "intArray" ) );
+            throws Exception {
+        assertTrue("isWritable returned false for a read/write array property!",
+                on(TestBean.class).getProperties().isWritable("intArray"));
     }
 
     @Test
     public void isWritableIntIndexed()
-        throws Exception
-    {
-        assertTrue( "isWritable returned false for a read/write indexed property!",
-                    on( TestBean.class ).getProperties().isWritable( "intIndexed" ) );
+            throws Exception {
+        assertTrue("isWritable returned false for a read/write indexed property!",
+                on(TestBean.class).getProperties().isWritable("intIndexed"));
     }
 
     @Test
     public void isWritableMappedIntProperty()
-        throws Exception
-    {
-        assertTrue( "isWritable returned false for a read/write mapped property!",
-                    on( TestBean.class ).getProperties().isWritable( "mappedIntProperty" ) );
+            throws Exception {
+        assertTrue("isWritable returned false for a read/write mapped property!",
+                on(TestBean.class).getProperties().isWritable("mappedIntProperty"));
     }
 
     @Test
     public void isWritbleMapProperty()
-        throws Exception
-    {
-        assertTrue( "isWritable returned false for a read/write map property!",
-                    on( TestBean.class ).getProperties().isWritable( "mapProperty" ) );
+            throws Exception {
+        assertTrue("isWritable returned false for a read/write map property!",
+                on(TestBean.class).getProperties().isWritable("mapProperty"));
     }
 
     @Test
     public void isWritableReadOnlyProperty()
-        throws Exception
-    {
-        assertFalse( "isWriteable returned true for a read only property!",
-                     on( TestBean.class ).getProperties().isWritable( "readOnlyProperty" ) );
+            throws Exception {
+        assertFalse("isWriteable returned true for a read only property!",
+                on(TestBean.class).getProperties().isWritable("readOnlyProperty"));
     }
 
     @Test
     public void isWritableWriteOnlyProperty()
-        throws Exception
-    {
-        assertTrue( "isWritable returned false for a write only property!",
-                    on( TestBean.class ).getProperties().isWritable( "writeOnlyProperty" ) );
+            throws Exception {
+        assertTrue("isWritable returned false for a write only property!",
+                on(TestBean.class).getProperties().isWritable("writeOnlyProperty"));
     }
 
 }



Mime
View raw message