harmony-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From ton...@apache.org
Subject svn commit: r556799 - in /harmony/enhanced/classlib/trunk/modules/beans/src: main/java/java/beans/ test/java/org/apache/harmony/beans/tests/java/beans/ test/support/java/org/apache/harmony/beans/tests/support/mock/
Date Tue, 17 Jul 2007 03:23:36 GMT
Author: tonywu
Date: Mon Jul 16 20:23:32 2007
New Revision: 556799

URL: http://svn.apache.org/viewvc?view=rev&rev=556799
Log:
Improve constructors
1, add check for empty method name, null method name and empty property name
2, add check for compatiblity between indexed read and indexed write method
3, add javadoc

Modified:
    harmony/enhanced/classlib/trunk/modules/beans/src/main/java/java/beans/IndexedPropertyDescriptor.java
    harmony/enhanced/classlib/trunk/modules/beans/src/test/java/org/apache/harmony/beans/tests/java/beans/IndexedPropertyDescriptorTest.java
    harmony/enhanced/classlib/trunk/modules/beans/src/test/support/java/org/apache/harmony/beans/tests/support/mock/MockJavaBean.java

Modified: harmony/enhanced/classlib/trunk/modules/beans/src/main/java/java/beans/IndexedPropertyDescriptor.java
URL: http://svn.apache.org/viewvc/harmony/enhanced/classlib/trunk/modules/beans/src/main/java/java/beans/IndexedPropertyDescriptor.java?view=diff&rev=556799&r1=556798&r2=556799
==============================================================================
--- harmony/enhanced/classlib/trunk/modules/beans/src/main/java/java/beans/IndexedPropertyDescriptor.java
(original)
+++ harmony/enhanced/classlib/trunk/modules/beans/src/main/java/java/beans/IndexedPropertyDescriptor.java
Mon Jul 16 20:23:32 2007
@@ -22,78 +22,131 @@
 import org.apache.harmony.beans.internal.nls.Messages;
 
 public class IndexedPropertyDescriptor extends PropertyDescriptor {
+
+    private Class indexedPropertyType;
+
     private Method indexedGetter;
 
     private Method indexedSetter;
 
+    /**
+     * Constructs a new instance of <code>IndexedPropertyDescriptor</code>.
+     * 
+     * @param propertyName
+     *            the specified indexed property's name.
+     * @param beanClass
+     *            the bean class
+     * @param getterName
+     *            the name of the array getter
+     * @param setterName
+     *            the name of the array setter
+     * @param indexedGetterName
+     *            the name of the indexed getter.
+     * @param indexedSetterName
+     *            the name of the indexed setter.
+     * @throws IntrospectionException
+     */
     public IndexedPropertyDescriptor(String propertyName, Class<?> beanClass,
             String getterName, String setterName, String indexedGetterName,
             String indexedSetterName) throws IntrospectionException {
         super(propertyName, beanClass, getterName, setterName);
+        setIndexedByName(beanClass, indexedGetterName, indexedSetterName);
+    }
+
+    private void setIndexedByName(Class beanClass, String indexedGetterName,
+            String indexedSetterName) throws IntrospectionException {
 
-        // RI behaves like this
-        if (indexedGetterName == null && indexedSetterName == null &&
-                (getterName != null || setterName != null)) {
-            throw new IntrospectionException(Messages.getString("beans.50"));
+        if (indexedGetterName == null) {
+            if (indexedSetterName != null) {
+                setIndexedWriteMethod(beanClass, indexedSetterName);
+            }
+        } else {
+            if (indexedGetterName.length() == 0) {
+                indexedGetterName = "get" + name;
+            }
+            setIndexedReadMethod(beanClass, indexedGetterName);
+            if (indexedSetterName != null) {
+                setIndexedWriteMethod(beanClass, indexedSetterName,
+                        indexedPropertyType);
+            }
+        }
+
+        if (!isCompatible()) {
+            throw new IntrospectionException(
+                    "Property type is incompatible with the indexed property type."); //$NON-NLS-1$
         }
-        setIndexedReadMethod(beanClass, indexedGetterName);
-        setIndexedWriteMethod(beanClass, indexedSetterName);
     }
 
-    public IndexedPropertyDescriptor(String propertyName, Method getter, Method setter,
-            Method indexedGetter, Method indexedSetter) throws IntrospectionException {
-        super(propertyName, getter, setter);
-        
-        // we need this in order to be compatible with RI
-        if (indexedGetter == null && indexedSetter == null &&
-                (getter != null || setter != null)) {
-            throw new IntrospectionException(Messages.getString("beans.50"));
+    private boolean isCompatible() {
+        Class propertyType = getPropertyType();
+
+        if (propertyType == null) {
+            return true;
+        }
+        Class componentTypeOfProperty = propertyType.getComponentType();
+        if (componentTypeOfProperty == null) {
+            return false;
+        }
+        if (indexedPropertyType == null) {
+            return false;
         }
-        setIndexedReadMethod(indexedGetter);
-        setIndexedWriteMethod(indexedSetter);
+
+        return componentTypeOfProperty.getName().equals(
+                indexedPropertyType.getName());
     }
 
-    public IndexedPropertyDescriptor(String propertyName, Class<?> beanClass)
+    /**
+     * Constructs a new instance of <code>IndexedPropertyDescriptor</code>.
+     * 
+     * @param propertyName
+     *            the specified indexed property's name.
+     * @param getter
+     *            the array getter
+     * @param setter
+     *            the array setter
+     * @param indexedGetter
+     *            the indexed getter
+     * @param indexedSetter
+     *            the indexed setter
+     * @throws IntrospectionException
+     */
+    public IndexedPropertyDescriptor(String propertyName, Method getter,
+            Method setter, Method indexedGetter, Method indexedSetter)
             throws IntrospectionException {
-        super(propertyName, beanClass, null, null);
-        String getterName;
-        String setterName;
-        String indexedGetterName;
-        String indexedSetterName;
-
-        // array getter
-        getterName = createDefaultMethodName(propertyName, "get"); //$NON-NLS-1$
-        if (hasMethod(beanClass, getterName)) {
-            setReadMethod(beanClass, getterName);
-        }
-        // array setter
-        setterName = createDefaultMethodName(propertyName, "set"); //$NON-NLS-1$
-        if (hasMethod(beanClass, setterName)) {
-            setWriteMethod(beanClass, setterName);
-        }
-        // indexed getter
-        indexedGetterName = createDefaultMethodName(propertyName, "get"); //$NON-NLS-1$
-        if (hasMethod(beanClass, indexedGetterName)) {
-            setIndexedReadMethod(beanClass, indexedGetterName);
-        }
-        // indexed setter
-        indexedSetterName = createDefaultMethodName(propertyName, "set"); //$NON-NLS-1$
-        if (hasMethod(beanClass, indexedSetterName)) {
-            setIndexedWriteMethod(beanClass, indexedSetterName);
+        super(propertyName, getter, setter);
+        if (indexedGetter != null) {
+            internalSetIndexedReadMethod(indexedGetter);
+            internalSetIndexedWriteMethod(indexedSetter, true);
+        } else {
+            internalSetIndexedWriteMethod(indexedSetter, true);
+            internalSetIndexedReadMethod(indexedGetter);
         }
-        // RI seems to behave a bit differently
-        if (indexedGetter == null && indexedSetter == null &&
-                getReadMethod() == null && getWriteMethod() == null) {
+
+        if (!isCompatible()) {
             throw new IntrospectionException(
-                    Messages.getString("beans.01", propertyName)); //$NON-NLS-1$
-        }
-        if (indexedGetter == null && indexedSetter == null) {
-            // not an indexed property indeed
-            throw new IntrospectionException(Messages.getString("beans.50"));
+                    "Property type is incompatible with the indexed property type."); //$NON-NLS-1$
         }
     }
 
-    public void setIndexedReadMethod(Method indexedGetter) throws IntrospectionException
{
+    /**
+     * Constructs a new instance of <code>IndexedPropertyDescriptor</code>.
+     * 
+     * @param propertyName
+     *            the specified indexed property's name.
+     * @param beanClass
+     *            the bean class.
+     * @throws IntrospectionException
+     */
+    public IndexedPropertyDescriptor(String propertyName, Class<?> beanClass)
+            throws IntrospectionException {
+        super(propertyName, beanClass);
+        setIndexedByName(beanClass, "get" //$NON-NLS-1$
+                .concat(initialUpperCase(propertyName)), "set" //$NON-NLS-1$
+                .concat(initialUpperCase(propertyName)));
+    }
+
+    public void setIndexedReadMethod(Method indexedGetter)
+            throws IntrospectionException {
         if (indexedGetter != null) {
             int modifiers = indexedGetter.getModifiers();
             Class<?>[] parameterTypes;
@@ -112,14 +165,16 @@
             }
             returnType = indexedGetter.getReturnType();
             indexedPropertyType = getIndexedPropertyType();
-            if ((indexedPropertyType != null) && !returnType.equals(indexedPropertyType))
{
+            if ((indexedPropertyType != null)
+                    && !returnType.equals(indexedPropertyType)) {
                 throw new IntrospectionException(Messages.getString("beans.24")); //$NON-NLS-1$
             }
         }
         this.indexedGetter = indexedGetter;
     }
 
-    public void setIndexedWriteMethod(Method indexedSetter) throws IntrospectionException
{
+    public void setIndexedWriteMethod(Method indexedSetter)
+            throws IntrospectionException {
         if (indexedSetter != null) {
             int modifiers = indexedSetter.getModifiers();
             Class<?>[] parameterTypes;
@@ -158,16 +213,16 @@
     @Override
     public boolean equals(Object obj) {
         boolean result = super.equals(obj);
-        
+
         if (result) {
             IndexedPropertyDescriptor pd = (IndexedPropertyDescriptor) obj;
-    
+
             if (indexedGetter != null) {
                 result = indexedGetter.equals(pd.getIndexedReadMethod());
             } else if (result && indexedGetter == null) {
                 result = pd.getIndexedReadMethod() == null;
             }
-                
+
             if (result) {
                 if (indexedSetter != null) {
                     result = indexedSetter.equals(pd.getIndexedWriteMethod());
@@ -176,7 +231,7 @@
                 }
             }
         }
-            
+
         return result;
     }
 
@@ -193,35 +248,145 @@
         return result;
     }
 
-    private void setIndexedReadMethod(Class<?> beanClass, String indexedGetterName)
{
-        Method[] getters = findMethods(beanClass, indexedGetterName);
-        boolean result = false;
-
-        for (Method element : getters) {
-            try {
-                setIndexedReadMethod(element);
-                result = true;
-            } catch (IntrospectionException ie) {}
+    private void setIndexedReadMethod(Class beanClass, String indexedGetterName)
+            throws IntrospectionException {
+        Method getter;
+        try {
+            getter = beanClass.getMethod(indexedGetterName,
+                    new Class[] { Integer.TYPE });
+        } catch (NoSuchMethodException exception) {
+            throw new IntrospectionException("No such indexed read method."); //$NON-NLS-1$
+        } catch (SecurityException exception) {
+            throw new IntrospectionException(
+                    "Security violation accessing indexed read method."); //$NON-NLS-1$
+        }
+        internalSetIndexedReadMethod(getter);
+    }
+
+    private void internalSetIndexedReadMethod(Method indexedGetter)
+            throws IntrospectionException {
+        // Clearing the indexed read method.
+        if (indexedGetter == null) {
+            if (indexedSetter == null) {
+                if (getPropertyType() != null) {
+                    throw new IntrospectionException(
+                            "Indexed method is not compatible with non indexed method");
+                }
+                indexedPropertyType = null;
+            }
+            this.indexedGetter = null;
+            return;
+        }
+        // Validate the indexed getter.
+        if ((indexedGetter.getParameterTypes().length != 1)
+                || (indexedGetter.getParameterTypes()[0] != Integer.TYPE)) {
+            throw new IntrospectionException(
+                    "Indexed read method must take a single int argument."); //$NON-NLS-1$
+        }
+        Class indexedReadType = indexedGetter.getReturnType();
+        if (indexedReadType == Void.TYPE) {
+            throw new IntrospectionException(
+                    "Indexed read method returns a void."); //$NON-NLS-1$
+        } else if (indexedSetter != null
+                && indexedGetter.getReturnType() != indexedSetter
+                        .getParameterTypes()[1]) {
+            throw new IntrospectionException(
+                    "Indexed read method is not compatible with indexed write method.");
//$NON-NLS-1$
+        }
 
-            if (result) {
-                break;
+        // Set the indexed property type if not already set, confirm validity if
+        // it is.
+        if (this.indexedGetter == null) {
+            indexedPropertyType = indexedReadType;
+        } else {
+            if (indexedPropertyType != indexedReadType) {
+                throw new IntrospectionException(
+                        "Indexed read method is incompatible with indexed write method type.");
//$NON-NLS-1$
             }
         }
+
+        // Set the indexed getter
+        this.indexedGetter = indexedGetter;
     }
 
-    private void setIndexedWriteMethod(Class<?> beanClass, String indexedSetterName)
{
-        Method[] setters = findMethods(beanClass, indexedSetterName);
-        boolean result = false;
+    private void setIndexedWriteMethod(Class beanClass, String indexedSetterName)
+            throws IntrospectionException {
+        Method setter = null;
+        try {
+            setter = beanClass.getMethod(indexedSetterName, new Class[] {
+                    Integer.TYPE, getPropertyType().getComponentType() });
+        } catch (SecurityException e) {
+            throw new IntrospectionException(
+                    "Security violation accessing indexed write method."); //$NON-NLS-1$
+        } catch (NoSuchMethodException e) {
+            throw new IntrospectionException("No such indexed write method."); //$NON-NLS-1$
+        }
+        internalSetIndexedWriteMethod(setter, true);
+    }
 
-        for (Method element : setters) {
-            try {
-                setIndexedWriteMethod(element);
-                result = true;
-            } catch (IntrospectionException ie) {}
+    private void setIndexedWriteMethod(Class beanClass,
+            String indexedSetterName, Class argType)
+            throws IntrospectionException {
+        try {
+            Method setter = beanClass.getMethod(indexedSetterName, new Class[] {
+                    Integer.TYPE, argType });
+            internalSetIndexedWriteMethod(setter, true);
+        } catch (NoSuchMethodException exception) {
+            throw new IntrospectionException("No such indexed write method."); //$NON-NLS-1$
+        } catch (SecurityException exception) {
+            throw new IntrospectionException(
+                    "Security violation accessing indexed write method."); //$NON-NLS-1$
+        }
+    }
 
-            if (result) {
-                break;
+    private void internalSetIndexedWriteMethod(Method indexedSetter,
+            boolean initialize) throws IntrospectionException {
+        // Clearing the indexed write method.
+        if (indexedSetter == null) {
+            if (indexedGetter == null) {
+                if (getPropertyType() != null) {
+                    throw new IntrospectionException(
+                            "Indexed method is not compatible with non indexed method");
+                }
+                indexedPropertyType = null;
+            }
+            this.indexedSetter = null;
+            return;
+        }
+
+        // Validate the indexed write method.
+        Class[] indexedSetterArgs = indexedSetter.getParameterTypes();
+        if (indexedSetterArgs.length != 2) {
+            throw new IntrospectionException(
+                    "Indexed write method must take a two arguments."); //$NON-NLS-1$
+        }
+        if (indexedSetterArgs[0] != Integer.TYPE) {
+            throw new IntrospectionException(
+                    "Indexed write method must take an int as its first argument."); //$NON-NLS-1$
+        }
+
+        // Set the indexed property type if not already set, confirm validity if
+        // it is.
+        Class indexedWriteType = indexedSetterArgs[1];
+        if (initialize && indexedGetter == null) {
+            indexedPropertyType = indexedWriteType;
+        } else {
+            if (indexedPropertyType != indexedWriteType) {
+                throw new IntrospectionException(
+                        "Indexed write method is incompatible with indexed read method type.");
//$NON-NLS-1$
             }
         }
+
+        // Set the indexed write method.
+        this.indexedSetter = indexedSetter;
+    }
+
+    private static String initialUpperCase(String string) {
+        if (Character.isUpperCase(string.charAt(0))) {
+            return string;
+        }
+
+        String initial = string.substring(0, 1).toUpperCase();
+        return initial.concat(string.substring(1));
     }
 }

Modified: harmony/enhanced/classlib/trunk/modules/beans/src/test/java/org/apache/harmony/beans/tests/java/beans/IndexedPropertyDescriptorTest.java
URL: http://svn.apache.org/viewvc/harmony/enhanced/classlib/trunk/modules/beans/src/test/java/org/apache/harmony/beans/tests/java/beans/IndexedPropertyDescriptorTest.java?view=diff&rev=556799&r1=556798&r2=556799
==============================================================================
--- harmony/enhanced/classlib/trunk/modules/beans/src/test/java/org/apache/harmony/beans/tests/java/beans/IndexedPropertyDescriptorTest.java
(original)
+++ harmony/enhanced/classlib/trunk/modules/beans/src/test/java/org/apache/harmony/beans/tests/java/beans/IndexedPropertyDescriptorTest.java
Mon Jul 16 20:23:32 2007
@@ -413,6 +413,22 @@
         assertEquals(String.class, ipd.getIndexedPropertyType());
     }
 
+    private class MyClass {
+        private int[] a;
+
+        public void setA(int v, int i) {
+            a[i] = v;
+        }
+
+        public void setA(int[] a) {
+            this.a = a;
+        }
+
+        public int[] getA() {
+            return a;
+        }
+    }
+    
     /*
      * Class under test for void IndexedPropertyDescriptor(String, Class,
      * String, String, String, String)
@@ -457,7 +473,59 @@
         assertFalse(ipd.isExpert());
         assertFalse(ipd.isHidden());
         assertFalse(ipd.isPreferred());
-
+        
+        //empty method name
+        new IndexedPropertyDescriptor(
+                propertyName, beanClass, "get" + propertyName, "set"
+                        + propertyName, "", "set"
+                        + propertyName);
+        
+        try {
+            new IndexedPropertyDescriptor("a", MyClass.class, "getA", "setA",
+                    "", "setA");
+            fail("Shoule throw exception");
+        } catch (IntrospectionException e) {
+        	// expected
+        }
+        
+        try {
+            new IndexedPropertyDescriptor(propertyName, beanClass, "",
+                    "set" + propertyName, "get" + propertyName, "set"
+                            + propertyName);
+            fail("Shoule throw exception");
+        } catch (IntrospectionException e) {
+        	// expected
+        }
+        try {
+            new IndexedPropertyDescriptor(propertyName, beanClass, "get"
+                    + propertyName, "", "get" + propertyName, "set"
+                    + propertyName);
+            fail("Shoule throw exception");
+        } catch (IntrospectionException e) {
+        	// expected
+        }
+        try {
+            new IndexedPropertyDescriptor(propertyName, beanClass, "get"
+                    + propertyName, "set" + propertyName, "get" + propertyName,
+                    "");
+            fail("Shoule throw exception");
+        } catch (IntrospectionException e) {
+        	// expected
+        }
+        
+        //null method name
+        new IndexedPropertyDescriptor(
+                propertyName, beanClass, "get" + propertyName, "set"
+                        + propertyName, null, "set" + propertyName);
+        new IndexedPropertyDescriptor(
+                propertyName, beanClass, null, "set" + propertyName, "get"
+                        + propertyName, "set" + propertyName);
+        new IndexedPropertyDescriptor(
+                propertyName, beanClass, "get" + propertyName, null, "get"
+                        + propertyName, "set" + propertyName);
+        new IndexedPropertyDescriptor(
+                propertyName, beanClass, "get" + propertyName, "set"
+                        + propertyName, "get" + propertyName, null);
     }
 
     public void testIndexedPropertyDescriptorStringClassStringStringStringString_propNull()
@@ -534,6 +602,16 @@
         assertNotNull(ipd.getReadMethod());
         assertNull(ipd.getWriteMethod());
         assertEquals(String.class, ipd.getIndexedPropertyType());
+        
+        new IndexedPropertyDescriptor(
+                propertyName, beanClass, "get" + propertyName, "set"+propertyName, "", "set"
+ propertyName);
+        
+        try{
+            new IndexedPropertyDescriptor(
+                propertyName, beanClass, "get" + propertyName, "set"+propertyName, "get"
+ propertyName, "");
+        fail();
+        }catch(Exception e){
+        }
     }
 
     public void testIndexedPropertyDescriptorStringClassStringStringStringString_IndexedReadMethodNull()
@@ -987,7 +1065,17 @@
         assertEquals(propertyName, ipd.getName());
         assertEquals(String[].class, ipd.getPropertyType());
         assertEquals(String.class, ipd.getIndexedPropertyType());
-
+        
+        indexedReadMethod = beanClass.getMethod("get" + anotherProp,
+                new Class[] { Integer.TYPE, Integer.TYPE });
+        try {
+            new IndexedPropertyDescriptor(
+                    propertyName, readMethod, writeMethod, indexedReadMethod,
+                    indexedWriteMethod);
+            fail("should throw IntrosecptionException");
+        } catch (IntrospectionException e) {
+        	// expected
+        }
     }
 
     public void testSetIndexedReadMethod() throws SecurityException,

Modified: harmony/enhanced/classlib/trunk/modules/beans/src/test/support/java/org/apache/harmony/beans/tests/support/mock/MockJavaBean.java
URL: http://svn.apache.org/viewvc/harmony/enhanced/classlib/trunk/modules/beans/src/test/support/java/org/apache/harmony/beans/tests/support/mock/MockJavaBean.java?view=diff&rev=556799&r1=556798&r2=556799
==============================================================================
--- harmony/enhanced/classlib/trunk/modules/beans/src/test/support/java/org/apache/harmony/beans/tests/support/mock/MockJavaBean.java
(original)
+++ harmony/enhanced/classlib/trunk/modules/beans/src/test/support/java/org/apache/harmony/beans/tests/support/mock/MockJavaBean.java
Mon Jul 16 20:23:32 2007
@@ -38,8 +38,40 @@
     private String[] propertyFive;
 
     private Integer[] propertySix;
+    
+    private String[] propertySeven;
 
     private String protectedProp;
+    
+    private String propertyWithoutSet;
+    
+    private boolean booleanProperty;
+    
+    private int propertyWithoutGet;
+    
+    private String propertyWithDifferentGetSet;
+    
+    private int propertyWithInvalidGet;
+    
+    private int propertyWithoutPublicGet;
+    
+    private int propertyWithGet1Param;
+
+    private int propertyWithIs1Param;
+    
+    private int propertyWithSet2Param;
+    
+    private int propertyWithIsGet;
+    
+    private int propertyWithVoidGet;
+
+    public Void getPropertyWithVoidGet() {
+        return null;
+    }
+
+    public void setPropertyWithVoidGet(int propertyWithVoidGet) {
+        this.propertyWithVoidGet = propertyWithVoidGet;
+    }
 
     public MockJavaBean() {
         this.beanName = getClass().getName();
@@ -48,6 +80,34 @@
     public MockJavaBean(String beanName) {
         this.beanName = beanName;
     }
+    
+    public String getXXX(){
+        return propertyThree;
+    }
+    
+    public String getPropertyWithDifferentGetSet(){
+        return propertyWithDifferentGetSet;
+    }
+    
+    public void setPropertyWithDifferentGetSet(int value){
+        this.propertyWithDifferentGetSet = String.valueOf(value);
+    }
+    
+    public String getPropertyWithoutSet(){
+        return propertyWithoutSet;
+    }
+    
+    public void setPropertyWithoutGet(int value){
+        this.propertyWithoutGet = value;
+    }
+    
+    public String getPropertyWithInvalidGet(){
+        return String.valueOf(propertyWithInvalidGet);
+    }
+    
+    public void setPropertyWithInvalidGet(String value){
+        propertyWithInvalidGet = Integer.valueOf(value);
+    }
 
     /**
      * @return Returns the beanName.
@@ -78,7 +138,7 @@
     public void setPropertyOne(String propertyOne) {
         this.propertyOne = propertyOne;
     }
-
+    
     /**
      * @return Returns the propertyTwo.
      */
@@ -137,6 +197,10 @@
     public String getPropertyFour(int i) {
         return getPropertyFour()[i];
     }
+    
+    public String getPropertyFive(int i, int j) {
+        return getPropertyFour()[i];
+    }
 
     public void getPropertyFourInvalid(int i) {
 
@@ -227,5 +291,85 @@
     public void removeMockPropertyChangeListener(
             MockPropertyChangeListener listener) {
 
+    }
+    
+    int isPropertyWithoutPublicGet() {
+        return propertyWithoutPublicGet;
+    }
+
+    int getPropertyWithoutPublicGet() {
+        return propertyWithoutPublicGet;
+    }
+
+    public void setPropertyWithoutPublicGet(int propertyWithoutPublicGet) {
+        this.propertyWithoutPublicGet = propertyWithoutPublicGet;
+    }
+    
+    public int isPropertyWithIs1Param(int i) {
+        return propertyWithIs1Param;
+    }
+    
+    public int getPropertyWithIs1Param() {
+        return propertyWithIs1Param;
+    }
+
+    public void setPropertyWithIs1Param(int value) {
+        this.propertyWithIs1Param = value;
+    }
+
+    public int getPropertyWithGet1Param(int i) {
+        return propertyWithGet1Param;
+    }
+
+    public void setPropertyWithGet1Param(int propertyWithGet1Param) {
+        this.propertyWithGet1Param = propertyWithGet1Param;
+    }
+
+    public int getPropertyWithSet2Param() {
+        return propertyWithSet2Param;
+    }
+
+    public void setPropertyWithSet2Param(int propertyWithSet2Param, int j) {
+        this.propertyWithSet2Param = propertyWithSet2Param;
+    }
+
+    public int isPropertyWithIsGet() {
+        return propertyWithIsGet;
+    }
+    
+    public int getPropertyWithIsGet() {
+        return propertyWithIsGet;
+    }
+
+    public void setPropertyWithIsGet(int propertyWithIsGet) {
+        this.propertyWithIsGet = propertyWithIsGet;
+    }
+
+    public boolean isBooleanProperty() {
+        return booleanProperty;
+    }
+    
+    public boolean getBooleanProperty() {
+        return booleanProperty;
+    }
+
+    public void setbooleanProperty(boolean booleanProperty) {
+        this.booleanProperty = booleanProperty;
+    }
+    
+    public Integer getPropertySeven(int i){
+        return Integer.valueOf(propertySeven[i]);
+    }
+    
+    public void setPropertySeven(int i, Integer I){
+        propertySeven[i] = String.valueOf(I);
+    }
+
+    public String[] getPropertySeven() {
+        return propertySeven;
+    }
+
+    public void setPropertySeven(String[] propertySeven) {
+        this.propertySeven = propertySeven;
     }
 }



Mime
View raw message