Added basic EL symbols and validation support for arrays and lists. Unit test coverage included.

17 files changed, 728 insertions, 49 deletions

diff --git a/jsf/tests/org.eclipse.jst.jsf.context.symbol.tests/src/org/eclipse/jst/jsf/context/symbol/tests/TestIJavaTypeDescriptor2.java b/jsf/tests/org.eclipse.jst.jsf.context.symbol.tests/src/org/eclipse/jst/jsf/context/symbol/tests/TestIJavaTypeDescriptor2.java
index bdd81db..64132dd 100644
--- a/jsf/tests/org.eclipse.jst.jsf.context.symbol.tests/src/org/eclipse/jst/jsf/context/symbol/tests/TestIJavaTypeDescriptor2.java
+++ b/jsf/tests/org.eclipse.jst.jsf.context.symbol.tests/src/org/eclipse/jst/jsf/context/symbol/tests/TestIJavaTypeDescriptor2.java
@@ -20,12 +20,16 @@ import java.util.Map;
 import org.eclipse.jdt.core.IType;
 import org.eclipse.jdt.core.JavaModelException;
 import org.eclipse.jdt.core.Signature;
+import org.eclipse.jst.jsf.common.internal.types.TypeConstants;
 import org.eclipse.jst.jsf.context.symbol.SymbolFactory;
 import org.eclipse.jst.jsf.context.symbol.SymbolPackage;
 import org.eclipse.jst.jsf.context.symbol.internal.provisional.IBeanInstanceSymbol;
 import org.eclipse.jst.jsf.context.symbol.internal.provisional.IBeanMethodSymbol;
 import org.eclipse.jst.jsf.context.symbol.internal.provisional.IBeanPropertySymbol;
 import org.eclipse.jst.jsf.context.symbol.internal.provisional.IJavaTypeDescriptor2;
+import org.eclipse.jst.jsf.context.symbol.internal.provisional.IObjectSymbol;
+import org.eclipse.jst.jsf.context.symbol.internal.provisional.IPropertySymbol;
+import org.eclipse.jst.jsf.context.symbol.internal.provisional.ITypeDescriptor;
 import org.eclipse.jst.jsf.core.tests.TestsPlugin;
 
 /**
@@ -67,11 +71,15 @@ public class TestIJavaTypeDescriptor2 extends ModelBaseTestCase
         
         _beanProperties = new HashMap();
         _testBean1Symbol =
-            setupBeanProperty(TestsPlugin.getDefault().getBundle(), "/testfiles/TestBean1.java.data", packageName1, testBeanName1, _beanProperties);
+            setupBeanProperty(TestsPlugin.getDefault().getBundle(), 
+                              "/testfiles/TestBean1.java.data", packageName1, 
+                              testBeanName1, _beanProperties);
         
         _beanSubclassProperties = new HashMap();
         _testBean1SubclassSymbol =
-            setupBeanProperty(TestsPlugin.getDefault().getBundle(), "/testfiles/TestBean1Subclass.java.data", packageName1, testBeanSubclass1, _beanSubclassProperties);
+            setupBeanProperty(TestsPlugin.getDefault().getBundle(), 
+                              "/testfiles/TestBean1Subclass.java.data", packageName1, 
+                              testBeanSubclass1, _beanSubclassProperties);
 
         _beanMethods = new HashMap();
         _testBean2Symbol = 
@@ -118,8 +126,9 @@ public class TestIJavaTypeDescriptor2 extends ModelBaseTestCase
      */
     public void testMapSanity()
     {
-        assertEquals("Check extra or missing properties",_beanProperties.size(), 12);
-        assertEquals("Check extra or missing properties",_beanSubclassProperties.size(), 13);
+        final int NUM_PROPS_IN_BEAN = 14;
+        assertEquals("Check extra or missing properties",_beanProperties.size(), NUM_PROPS_IN_BEAN);
+        assertEquals("Check extra or missing properties",_beanSubclassProperties.size(), NUM_PROPS_IN_BEAN+1);
         assertEquals("Check extra or missing methods",_beanMethods.size(), 5);
         assertEquals("Check extra or missing methods",_beanMethodsSubclass.size(), 6);
     }
@@ -289,15 +298,6 @@ public class TestIJavaTypeDescriptor2 extends ModelBaseTestCase
     }
     
     /**
-     * test inhertied
-     */
-    public void testReadonlyStringPropertySubClass()
-    {
-        testReadonlyStringProperty(_beanSubclassProperties);
-    }
-    
-    
-    /**
      * 
      */
     private void testReadonlyStringProperty(Map properties)
@@ -329,6 +329,14 @@ public class TestIJavaTypeDescriptor2 extends ModelBaseTestCase
     }
     
     /**
+     * test inhertied
+     */
+    public void testReadonlyStringPropertySubClass()
+    {
+        testReadonlyStringProperty(_beanSubclassProperties);
+    }
+
+    /**
      * 
      */
     private void testReadonlyBooleanProperty(Map properties)
@@ -370,8 +378,74 @@ public class TestIJavaTypeDescriptor2 extends ModelBaseTestCase
         
         assertTrue(property.isReadable());
         assertTrue(property.isWritable());
+        
+        ITypeDescriptor typeDesc = property.getTypeDescriptor();
         assertEquals("Signature must be for a String[]", 
-                "[Ljava.lang.String;", property.getTypeDescriptor().getTypeSignature());
+                Signature.createArraySignature(TypeConstants.TYPE_STRING, 1), typeDesc.getTypeSignature());
+        assertEquals(true, typeDesc.isArray());
+        assertEquals(1, ((IJavaTypeDescriptor2)typeDesc).getArrayCount());
+    }
+    
+    /**
+     * 
+     */
+    public void testIntArrayProperty()
+    {
+        testIntArrayProperty(_beanProperties);
+    }
+    
+    /**
+     * test inherited
+     */
+    public void testIntArrayPropertySubClass()
+    {
+        testIntArrayProperty(_beanSubclassProperties);
+    }
+    
+    private void testIntArrayProperty(Map properties)
+    {
+        IBeanPropertySymbol  property = 
+            (IBeanPropertySymbol) properties.get("intArrayProperty");
+        assertNotNull(property);
+        
+        assertTrue(property.isReadable());
+        
+        ITypeDescriptor typeDesc = property.getTypeDescriptor();
+        assertEquals("Signature must be for a int[]", 
+                Signature.createArraySignature(Signature.SIG_INT, 1), typeDesc.getTypeSignature());
+        assertEquals(true, typeDesc.isArray());
+        assertEquals(1, ((IJavaTypeDescriptor2)typeDesc).getArrayCount());
+    }
+
+    /**
+     * 
+     */
+    public void testArrayOfArrayOfStringProperty()
+    {
+        testArrayOfArrayOfStringProperty(_beanProperties);
+    }
+    
+    /**
+     * test inherited
+     */
+    public void testArrayOfArrayOfStringPropertySubClass()
+    {
+        testArrayOfArrayOfStringProperty(_beanSubclassProperties);
+    }
+
+    private void testArrayOfArrayOfStringProperty(Map properties)
+    {
+        IBeanPropertySymbol  property = 
+            (IBeanPropertySymbol) properties.get("arrayOfArrayOfStringProperty");
+        assertNotNull(property);
+        
+        assertTrue(property.isReadable());
+        
+        ITypeDescriptor typeDesc = property.getTypeDescriptor();
+        assertEquals("Signature must be for a String[][]",
+                Signature.createArraySignature(TypeConstants.TYPE_STRING, 2), typeDesc.getTypeSignature());
+        assertEquals(true, typeDesc.isArray());
+        assertEquals(2, ((IJavaTypeDescriptor2)typeDesc).getArrayCount());
     }
 
     /**
@@ -559,6 +633,70 @@ public class TestIJavaTypeDescriptor2 extends ModelBaseTestCase
                 "Ljava.lang.String;", property.getTypeDescriptor().getTypeSignature());
     }
     
+    /**
+     * Acquire an element of an array
+     */
+    public void testArrayPropertyElement()
+    {
+    	final IPropertySymbol propSymbol = 
+    		(IPropertySymbol) _beanProperties.get("stringArrayProperty");
+    	assertNotNull(propSymbol);
+    	
+    	ITypeDescriptor typeDesc = propSymbol.getTypeDescriptor();
+    	assertNotNull(typeDesc);
+        assertEquals(TypeConstants.TYPE_STRING, typeDesc.getArrayElement().getTypeDescriptor().getTypeSignature());
+
+    	final IObjectSymbol symbol = typeDesc.getArrayElement();
+    	assertNotNull(symbol);
+    	assertEquals(TypeConstants.TYPE_STRING, symbol.getTypeDescriptor().getTypeSignature());
+    }
+    
+    /**
+     * Acquire an element of an int array
+     */
+    public void testIntArrayPropertyElement()
+    {
+        final IPropertySymbol propSymbol = 
+            (IPropertySymbol) _beanProperties.get("intArrayProperty");
+        assertNotNull(propSymbol);
+        
+        ITypeDescriptor typeDesc = propSymbol.getTypeDescriptor();
+        assertNotNull(typeDesc);
+        assertEquals(Signature.SIG_INT, typeDesc.getArrayElement().getTypeDescriptor().getTypeSignature());
+
+        final IObjectSymbol symbol = typeDesc.getArrayElement();
+        assertNotNull(symbol);
+        assertEquals(Signature.SIG_INT, symbol.getTypeDescriptor().getTypeSignature());
+    }
+    
+    /**
+     * Acquire an element of an array of array of string and
+     * get the element of that element
+     */
+    public void testArrayOfArrayOfStringPropertyElement()
+    {
+        final IPropertySymbol propSymbol = 
+            (IPropertySymbol) _beanProperties.get("arrayOfArrayOfStringProperty");
+        assertNotNull(propSymbol);
+        
+        ITypeDescriptor typeDesc = propSymbol.getTypeDescriptor();
+        assertNotNull(typeDesc);
+        assertEquals(Signature.createArraySignature(TypeConstants.TYPE_STRING, 1), 
+                      typeDesc.getArrayElement().getTypeDescriptor().getTypeSignature()
+                    );
+
+        final IObjectSymbol symbol = typeDesc.getArrayElement();
+        assertNotNull(symbol);
+        assertEquals(Signature.createArraySignature(TypeConstants.TYPE_STRING, 1), 
+                typeDesc.getArrayElement().getTypeDescriptor().getTypeSignature());
+        
+        assertTrue(symbol.getTypeDescriptor().isArray());
+        final IObjectSymbol nestedSymbol = symbol.getTypeDescriptor().getArrayElement();
+        assertNotNull(nestedSymbol);
+        assertEquals(TypeConstants.TYPE_STRING, 
+                nestedSymbol.getTypeDescriptor().getTypeSignature());
+    }
+    
 /* ------ Method signature testing -----------------------*/
     
     /**
diff --git a/jsf/tests/org.eclipse.jst.jsf.context.symbol.tests/src/org/eclipse/jst/jsf/context/symbol/tests/TestTypeCoercion.java b/jsf/tests/org.eclipse.jst.jsf.context.symbol.tests/src/org/eclipse/jst/jsf/context/symbol/tests/TestTypeCoercion.java
index 37afa75..c71e2a2 100644
--- a/jsf/tests/org.eclipse.jst.jsf.context.symbol.tests/src/org/eclipse/jst/jsf/context/symbol/tests/TestTypeCoercion.java
+++ b/jsf/tests/org.eclipse.jst.jsf.context.symbol.tests/src/org/eclipse/jst/jsf/context/symbol/tests/TestTypeCoercion.java
@@ -4,6 +4,7 @@ import java.util.HashMap;
 
 import org.eclipse.jst.jsf.common.internal.types.TypeConstants;
 import org.eclipse.jst.jsf.context.symbol.internal.provisional.IBeanInstanceSymbol;
+import org.eclipse.jst.jsf.context.symbol.internal.provisional.IBoundedListTypeDescriptor;
 import org.eclipse.jst.jsf.context.symbol.internal.provisional.IBoundedMapTypeDescriptor;
 import org.eclipse.jst.jsf.context.symbol.internal.provisional.ISymbol;
 import org.eclipse.jst.jsf.context.symbol.internal.provisional.ITypeDescriptor;
@@ -17,6 +18,7 @@ public class TestTypeCoercion extends ModelBaseTestCase
 {
     private final static String     packageName = "com.test";
     private IBeanInstanceSymbol     _testMapBeanSymbol;
+    private IBeanInstanceSymbol     _testListBeanSymbol;
     
     protected void setUp() throws Exception 
     {
@@ -26,6 +28,11 @@ public class TestTypeCoercion extends ModelBaseTestCase
             setupBeanProperty(ContextSymbolTestPlugin.getDefault().getBundle(),
                     "/testdata/TestBeanMap.java.data", packageName, 
                     "TestBeanMap", new HashMap());
+        
+        _testListBeanSymbol =
+            setupBeanProperty(ContextSymbolTestPlugin.getDefault().getBundle(),
+                    "/testdata/MyListBean.java.data", packageName, 
+                    "MyListBean", new HashMap());
     }
 
     /**
@@ -34,6 +41,7 @@ public class TestTypeCoercion extends ModelBaseTestCase
     public void testSanity()
     {
         assertNotNull(_testMapBeanSymbol);
+        assertNotNull(_testListBeanSymbol);
     }
     
     /**
@@ -56,4 +64,26 @@ public class TestTypeCoercion extends ModelBaseTestCase
         
         assertEquals(testSymbolName, symbol.getName());
     }
+    
+    /**
+     * Test basic bean coercion to a list
+     */
+    public void testBasicListBean()
+    {
+        assertTrue(_testListBeanSymbol.getTypeDescriptor().instanceOf(TypeConstants.TYPE_LIST));
+        assertTrue(_testListBeanSymbol.supportsCoercion(TypeConstants.TYPE_LIST));
+        final ITypeDescriptor typeDesc = 
+            _testListBeanSymbol.coerce(TypeConstants.TYPE_LIST);
+        assertNotNull(typeDesc);
+        assertTrue(typeDesc.instanceOf(TypeConstants.TYPE_LIST));
+        assertTrue(typeDesc instanceof IBoundedListTypeDescriptor);
+        assertTrue(((IBoundedListTypeDescriptor)typeDesc).isUnboundedForType(TypeConstants.TYPE_LIST));
+        final String testSymbolName = "chelsea";
+        ISymbol symbol = 
+            ((IBoundedListTypeDescriptor)typeDesc).
+                getUnboundedProperty(testSymbolName, TypeConstants.TYPE_LIST);
+        
+        assertEquals(testSymbolName, symbol.getName());
+
+    }
 }
diff --git a/jsf/tests/org.eclipse.jst.jsf.context.symbol.tests/testdata/MyListBean.java.data b/jsf/tests/org.eclipse.jst.jsf.context.symbol.tests/testdata/MyListBean.java.data
new file mode 100644
index 0000000..95da5d5
--- /dev/null
+++ b/jsf/tests/org.eclipse.jst.jsf.context.symbol.tests/testdata/MyListBean.java.data
@@ -0,0 +1,29 @@
+package com.test;
+
+import java.util.AbstractList;
+
+/**
+ * A bean class that implements java.util.List
+ * 
+ * @author cbateman
+ *
+ */
+public class MyListBean extends AbstractList 
+{
+    public Object get(int index) {
+        return null;
+    }
+
+    public int size() {
+        return 0;
+    }
+
+    /**
+     * Simulate a 
+     * @return
+     */
+    public String getStringProperty()
+    {
+        return "";
+    }
+}
\ No newline at end of file
diff --git a/jsf/tests/org.eclipse.jst.jsf.core.tests/src/org/eclipse/jst/jsf/core/tests/util/TestJDTBeanIntrospector.java b/jsf/tests/org.eclipse.jst.jsf.core.tests/src/org/eclipse/jst/jsf/core/tests/util/TestJDTBeanIntrospector.java
index c40e679..9d9c44c 100644
--- a/jsf/tests/org.eclipse.jst.jsf.core.tests/src/org/eclipse/jst/jsf/core/tests/util/TestJDTBeanIntrospector.java
+++ b/jsf/tests/org.eclipse.jst.jsf.core.tests/src/org/eclipse/jst/jsf/core/tests/util/TestJDTBeanIntrospector.java
@@ -99,15 +99,17 @@ public class TestJDTBeanIntrospector extends TestCase
      */
     public void testMapSanity()
     {
-        checkMapSanity(_properties, 12);
+        final int NUM_PROPS = 14;
+        
+        checkMapSanity(_properties, NUM_PROPS);
         // sub class an locally defined property in addition to what
         // is inherited
-        checkMapSanity(_subClassProperties, 13);
+        checkMapSanity(_subClassProperties, NUM_PROPS+1);
     }
 
     private void checkMapSanity(Map properties, int numProps)
     {
-        assertEquals("Check extra or missing properties",properties.size(), numProps);
+        assertEquals("Check extra or missing properties",numProps,properties.size());
         assertNull("Empty string is invalid property name", properties.get(""));
         assertNull("Null is not a valid property name", properties.get(null));
         
@@ -392,7 +394,8 @@ public class TestJDTBeanIntrospector extends TestCase
         assertTrue(property.isWritable());
         assertEquals("Signature must be for a String[]", 
                 "[Ljava.lang.String;", property.getTypeSignature());
-        assertNull("No IType for arrays", property.getType());
+        assertNotNull("Should resolve the base type", property.getType());
+        assertEquals(1, property.getArrayCount());
     }
 
     /**
diff --git a/jsf/tests/org.eclipse.jst.jsf.core.tests/src/org/eclipse/jst/jsf/core/tests/util/TestJDTBeanPropertyWorkingCopy.java b/jsf/tests/org.eclipse.jst.jsf.core.tests/src/org/eclipse/jst/jsf/core/tests/util/TestJDTBeanPropertyWorkingCopy.java
index 9197477..62fc87c 100644
--- a/jsf/tests/org.eclipse.jst.jsf.core.tests/src/org/eclipse/jst/jsf/core/tests/util/TestJDTBeanPropertyWorkingCopy.java
+++ b/jsf/tests/org.eclipse.jst.jsf.core.tests/src/org/eclipse/jst/jsf/core/tests/util/TestJDTBeanPropertyWorkingCopy.java
@@ -370,8 +370,8 @@ public class TestJDTBeanPropertyWorkingCopy extends TestCase {
         // the type should resolve to a String[]
         assertTrue("[Ljava.lang.String;".equals(beanProperty.getTypeSignature()));
         
-        // no IType for arrays
-        assertNull(beanProperty.getType());
+        // Should resolve to base type (String)
+        assertNotNull(beanProperty.getType());
     }
     
     /**
diff --git a/jsf/tests/org.eclipse.jst.jsf.core.tests/testfiles/TestBean1.java.data b/jsf/tests/org.eclipse.jst.jsf.core.tests/testfiles/TestBean1.java.data
index 97659ad..e3a5304 100644
--- a/jsf/tests/org.eclipse.jst.jsf.core.tests/testfiles/TestBean1.java.data
+++ b/jsf/tests/org.eclipse.jst.jsf.core.tests/testfiles/TestBean1.java.data
@@ -128,4 +128,14 @@ public class TestBean1
     public void setAnotherBean(AnotherBean anotherBean)
     {
     }
+// Int array property
+	public int[] getIntArrayProperty()
+	{
+		return new int[] {0,1,2};
+	}
+// array of array of string
+	public String[][] getArrayOfArrayOfStringProperty()
+	{
+		return new String[3][];
+	}
 }
\ No newline at end of file
diff --git a/jsf/tests/org.eclipse.jst.jsf.designtime.tests/src/org/eclipse/jst/jsf/designtime/tests/TestDefaultPropertyResolver.java b/jsf/tests/org.eclipse.jst.jsf.designtime.tests/src/org/eclipse/jst/jsf/designtime/tests/TestDefaultPropertyResolver.java
index 1c51c2f..23d70cf 100644
--- a/jsf/tests/org.eclipse.jst.jsf.designtime.tests/src/org/eclipse/jst/jsf/designtime/tests/TestDefaultPropertyResolver.java
+++ b/jsf/tests/org.eclipse.jst.jsf.designtime.tests/src/org/eclipse/jst/jsf/designtime/tests/TestDefaultPropertyResolver.java
@@ -30,14 +30,17 @@ import org.eclipse.jst.jsf.test.util.WebProjectTestEnvironment;
  */
 public class TestDefaultPropertyResolver extends TestCase 
 {
+    private static final int NUM_PROPERTIES_TEST_BEAN_1 = 5;
     private JDTTestEnvironment              _jdtTestEnvironment;
     private JSFFacetedTestEnvironment       _jsfFactedTestEnvironment;
 
     private IType                           _testBean1Type;
-    private IType _testMapBean1Type;
-    private IType _testBean2Type;
-    private IType _testBean3Type;
-    private IType _testBeanWithMapProp;
+    private IType                           _testMapBean1Type;
+    private IType                           _testBean2Type;
+    private IType                           _testBean3Type;
+    private IType                           _testBeanWithMapProp;
+    private IType                           _testListBeanType;
+    private IType                           _testBeanWithListPropType;
     
     private final static String     SRC_FOLDER_NAME = "src";
     private final static String     PACKAGE_NAME = "com.test";
@@ -46,7 +49,8 @@ public class TestDefaultPropertyResolver extends TestCase
     private final static String     TESTBEAN3_NAME = "TestBean3";
     private final static String     MAPBEAN_NAME = "MapBean";
     private final static String     BEANWITHMAPPROP_NAME = "BeanWithMapProp";  
-    
+    private final static String     LISTBEAN_NAME = "ListBean";
+    private final static String     BEANWITHLISTPROP_NAME = "BeanWithListProp";
     
     protected void setUp() throws Exception 
     {
@@ -102,6 +106,19 @@ public class TestDefaultPropertyResolver extends TestCase
             _jdtTestEnvironment.getJavaProject().findType(PACKAGE_NAME+"."+BEANWITHMAPPROP_NAME);
         assertNotNull(_testBeanWithMapProp);
 
+        JSFTestUtil.loadSourceClass(
+                DesignTimeTestsPlugin.getDefault().getBundle(), 
+                    "/testdata/ListBean.java.data", LISTBEAN_NAME, SRC_FOLDER_NAME, PACKAGE_NAME, _jdtTestEnvironment);
+        _testListBeanType =
+            _jdtTestEnvironment.getJavaProject().findType(PACKAGE_NAME+"."+LISTBEAN_NAME);
+        assertNotNull(_testListBeanType);
+        
+        JSFTestUtil.loadSourceClass(
+                DesignTimeTestsPlugin.getDefault().getBundle(), 
+                    "/testdata/BeanWithListProp.java.data", BEANWITHLISTPROP_NAME, SRC_FOLDER_NAME, PACKAGE_NAME, _jdtTestEnvironment);
+        _testBeanWithListPropType =
+            _jdtTestEnvironment.getJavaProject().findType(PACKAGE_NAME+"."+BEANWITHLISTPROP_NAME);
+        assertNotNull(_testBeanWithListPropType);
     }
     
     /**
@@ -111,7 +128,7 @@ public class TestDefaultPropertyResolver extends TestCase
     {
         JDTBeanIntrospector  beanIntrospector = new JDTBeanIntrospector(_testBean1Type);
         Map props = beanIntrospector.getProperties();
-        assertEquals(2, props.size());
+        assertEquals(NUM_PROPERTIES_TEST_BEAN_1, props.size());
         assertTrue(props.containsKey("stringProp1"));
         assertTrue(props.containsKey("booleanIsProp1"));
         
@@ -134,6 +151,15 @@ public class TestDefaultPropertyResolver extends TestCase
         props = beanIntrospector.getProperties();
         // one props: one of type Map
         assertEquals(1, props.size());
+        
+        beanIntrospector = new JDTBeanIntrospector(_testListBeanType);
+        props = beanIntrospector.getProperties();
+        // includes isEmpty
+        assertEquals(2, props.size());
+        
+        beanIntrospector = new JDTBeanIntrospector(_testBeanWithListPropType);
+        props = beanIntrospector.getProperties();
+        assertEquals(1, props.size());
     }
     
     /**
@@ -149,7 +175,7 @@ public class TestDefaultPropertyResolver extends TestCase
         
         DefaultDTPropertyResolver propResolver = new DefaultDTPropertyResolver();
         ISymbol[]  properties = propResolver.getAllProperties(symbol);
-        assertEquals(2, properties.length);
+        assertEquals(NUM_PROPERTIES_TEST_BEAN_1, properties.length);
         Map  checkProps = new HashMap();
         for (int i = 0; i < properties.length; i++)
         {
@@ -361,4 +387,166 @@ public class TestDefaultPropertyResolver extends TestCase
         IPropertySymbol unboundedProp = (IPropertySymbol) propResolver.getProperty(mapProp, "foo");
         assertEquals(TypeConstants.TYPE_JAVAOBJECT, unboundedProp.getTypeDescriptor().getTypeSignature());
     }
+    
+    /**
+     * Verify that bean properties of type array are resolved properly
+     * using the getProperty(base, offset) method.
+     */
+    public void testBeanWithArrayProperty()
+    {
+        final IBeanInstanceSymbol symbol = SymbolFactory.eINSTANCE.createIBeanInstanceSymbol();
+        symbol.setName("BeanWithArrayProp");
+        final IJavaTypeDescriptor2 typeDesc = SymbolFactory.eINSTANCE.createIJavaTypeDescriptor2();
+        typeDesc.setType(_testBean1Type);
+        symbol.setTypeDescriptor(typeDesc);
+        
+        DefaultDTPropertyResolver propResolver = new DefaultDTPropertyResolver();
+
+        // test array of strings property
+        {
+            final ISymbol arrayOfStringsProperty = 
+                propResolver.getProperty(symbol, "stringArrayProperty");
+            
+            assertTrue(arrayOfStringsProperty instanceof IPropertySymbol);
+            final IPropertySymbol arrayOfStringsPropertySymbol = 
+                (IPropertySymbol) arrayOfStringsProperty;
+            assertEquals(Signature.createArraySignature(TypeConstants.TYPE_STRING, 1), arrayOfStringsPropertySymbol.getTypeDescriptor().getTypeSignature());
+            assertTrue(arrayOfStringsPropertySymbol.getTypeDescriptor().isArray());
+            assertEquals(TypeConstants.TYPE_STRING, arrayOfStringsPropertySymbol.getTypeDescriptor().getArrayElement().getTypeDescriptor().getTypeSignature());
+    
+            // now the real property resolver test
+            // get an array element
+            final ISymbol  arrayElement = propResolver.getProperty(arrayOfStringsPropertySymbol, 0);
+            assertTrue(arrayElement instanceof IObjectSymbol);
+            final IObjectSymbol arrayElementSymbol = (IObjectSymbol) arrayElement;
+            assertNotNull(((IJavaTypeDescriptor2)arrayElementSymbol.getTypeDescriptor()).getType());
+            assertEquals(TypeConstants.TYPE_STRING, arrayElementSymbol.getTypeDescriptor().getTypeSignature());
+        }
+        
+        // test array of int property
+        {
+            final ISymbol arrayOfIntProperty = 
+                propResolver.getProperty(symbol, "intArrayProperty");
+            
+            assertTrue(arrayOfIntProperty instanceof IPropertySymbol);
+            final IPropertySymbol arrayOfIntPropertySymbol = 
+                (IPropertySymbol) arrayOfIntProperty;
+            assertEquals(Signature.createArraySignature(Signature.SIG_INT, 1), arrayOfIntPropertySymbol.getTypeDescriptor().getTypeSignature());
+            assertTrue(arrayOfIntPropertySymbol.getTypeDescriptor().isArray());
+            assertEquals(Signature.SIG_INT, arrayOfIntPropertySymbol.getTypeDescriptor().getArrayElement().getTypeDescriptor().getTypeSignature());
+    
+            // now the real property resolver test
+            // get an array element
+            final ISymbol  arrayElement = propResolver.getProperty(arrayOfIntPropertySymbol, 0);
+            assertTrue(arrayElement instanceof IObjectSymbol);
+            final IObjectSymbol arrayElementSymbol = (IObjectSymbol) arrayElement;
+            // type will be null since int has no corresponding IType (not an object)
+            assertNull(((IJavaTypeDescriptor2)arrayElementSymbol.getTypeDescriptor()).getType());
+            assertEquals(Signature.SIG_INT, arrayElementSymbol.getTypeDescriptor().getTypeSignature());
+        }
+        
+        // test array of array of strings
+        {
+            final ISymbol arrayOfIntProperty = 
+                propResolver.getProperty(symbol, "arrayOfArrayOfStringProperty");
+            
+            assertTrue(arrayOfIntProperty instanceof IPropertySymbol);
+            final IPropertySymbol arrayOfIntPropertySymbol = 
+                (IPropertySymbol) arrayOfIntProperty;
+            assertEquals(Signature.createArraySignature(TypeConstants.TYPE_STRING, 2),
+                         arrayOfIntPropertySymbol.getTypeDescriptor().getTypeSignature());
+            assertTrue(arrayOfIntPropertySymbol.getTypeDescriptor().isArray());
+            assertEquals(
+                         Signature.createArraySignature(TypeConstants.TYPE_STRING,1), 
+                         arrayOfIntPropertySymbol.getTypeDescriptor().getArrayElement().getTypeDescriptor().getTypeSignature()
+                        );
+    
+            // now the real property resolver test
+            // get an array element
+            final ISymbol  arrayElement = propResolver.getProperty(arrayOfIntPropertySymbol, 0);
+            assertTrue(arrayElement instanceof IObjectSymbol);
+            final IObjectSymbol arrayElementSymbol = (IObjectSymbol) arrayElement;
+            assertNotNull(((IJavaTypeDescriptor2)arrayElementSymbol.getTypeDescriptor()).getType());
+            assertEquals(
+                            Signature.createArraySignature(TypeConstants.TYPE_STRING,1), 
+                            arrayElementSymbol.getTypeDescriptor().getTypeSignature()
+                        );
+            
+            // the elements of the array are arrays themselves
+            assertTrue(arrayElementSymbol.getTypeDescriptor().isArray());
+            final ISymbol arrayElementElement =
+                propResolver.getProperty(arrayElementSymbol, 0);
+            assertTrue(arrayElementElement instanceof IObjectSymbol);
+            final IObjectSymbol arrayElementElementSymbol = 
+                (IObjectSymbol) arrayElementElement;
+            assertNotNull(((IJavaTypeDescriptor2)arrayElementElementSymbol.getTypeDescriptor()).getType());
+            assertEquals(TypeConstants.TYPE_STRING, arrayElementElementSymbol.getTypeDescriptor().getTypeSignature());
+        }
+    }
+    
+    /**
+     * Test an unconstrained Map bean
+     */
+    public void testListBeanInstanceSymbol()
+    {
+        IBeanInstanceSymbol symbol = 
+            SymbolFactory.eINSTANCE.createIBeanInstanceSymbol();
+        symbol.setName("myListBean");
+        IJavaTypeDescriptor2 typeDesc = 
+            SymbolFactory.eINSTANCE.createIJavaTypeDescriptor2();
+        typeDesc.setType(_testListBeanType);
+        symbol.setTypeDescriptor(typeDesc);
+        
+        DefaultDTPropertyResolver propResolver = 
+            new DefaultDTPropertyResolver();
+        ISymbol[]  properties = propResolver.getAllProperties(symbol);
+
+        // should have no properties since a list won't be treated like
+        // anything but a list
+        assertEquals(0, properties.length);
+
+        // but being that it's an unbounded List, it may have  any number
+        // of arbitrary "unconstrained" properties a different indices
+        for (int i = 0; i < 25; i++)
+        {
+            ISymbol someProperty1 = propResolver.getProperty(symbol, i);
+            assertNotNull(someProperty1);
+            assertTrue(someProperty1 instanceof IPropertySymbol);
+            // completely unconstrained properties should come back as java object
+            assertEquals(TypeConstants.TYPE_JAVAOBJECT, 
+                    ((IPropertySymbol)someProperty1).getTypeDescriptor().getTypeSignature());
+        }
+    }
+    
+    /**
+     * Test a property on a bean that is a list
+     */
+    public void testBeanWithListProperty()
+    {
+        final IBeanInstanceSymbol symbol = SymbolFactory.eINSTANCE.createIBeanInstanceSymbol();
+        symbol.setName("beanWithListProp");
+        final IJavaTypeDescriptor2 typeDesc = SymbolFactory.eINSTANCE.createIJavaTypeDescriptor2();
+        typeDesc.setType(_testBeanWithListPropType);
+        symbol.setTypeDescriptor(typeDesc);
+        
+        DefaultDTPropertyResolver propResolver = new DefaultDTPropertyResolver();
+        ISymbol[]  properties = propResolver.getAllProperties(symbol);
+
+        // should be just one property
+        assertEquals(1, properties.length);
+        assertEquals(properties[0].getName(), "listProp");
+        assertEquals(properties[0].getName(),
+                     propResolver.getProperty(symbol, "listProp").getName());
+        
+        IPropertySymbol  listProp = (IPropertySymbol) propResolver.getProperty(symbol, "listProp");
+        assertEquals("Lcom.test.ListBean;", listProp.getTypeDescriptor().getTypeSignature());
+        
+        properties = propResolver.getAllProperties(listProp);
+        
+        // has isEmpty and one bean props
+        assertEquals(0, properties.length);
+        
+        IPropertySymbol unboundedProp = (IPropertySymbol) propResolver.getProperty(listProp, 0);
+        assertEquals(TypeConstants.TYPE_JAVAOBJECT, unboundedProp.getTypeDescriptor().getTypeSignature());
+    }
 }
diff --git a/jsf/tests/org.eclipse.jst.jsf.designtime.tests/testdata/BeanWithListProp.java.data b/jsf/tests/org.eclipse.jst.jsf.designtime.tests/testdata/BeanWithListProp.java.data
new file mode 100644
index 0000000..e7425e3
--- /dev/null
+++ b/jsf/tests/org.eclipse.jst.jsf.designtime.tests/testdata/BeanWithListProp.java.data
@@ -0,0 +1,12 @@
+package com.test;
+
+public class BeanWithListProp
+{
+	private ListBean		_myBean1;
+	
+	// test a property of type Map
+	public ListBean getListProp()
+	{
+		return _myBean1;
+	}
+}
\ No newline at end of file
diff --git a/jsf/tests/org.eclipse.jst.jsf.designtime.tests/testdata/ListBean.java.data b/jsf/tests/org.eclipse.jst.jsf.designtime.tests/testdata/ListBean.java.data
new file mode 100644
index 0000000..4abadc7
--- /dev/null
+++ b/jsf/tests/org.eclipse.jst.jsf.designtime.tests/testdata/ListBean.java.data
@@ -0,0 +1,29 @@
+package com.test;
+
+import java.util.AbstractList;
+
+/**
+ * A bean class that implements java.util.List
+ * 
+ * @author cbateman
+ *
+ */
+public class ListBean extends AbstractList 
+{
+    public Object get(int index) {
+        return null;
+    }
+
+    public int size() {
+        return 0;
+    }
+
+    /**
+     * Simulate a 
+     * @return
+     */
+    public String getStringProperty()
+    {
+        return "";
+    }
+}
\ No newline at end of file
diff --git a/jsf/tests/org.eclipse.jst.jsf.designtime.tests/testdata/TestBean1.java.data b/jsf/tests/org.eclipse.jst.jsf.designtime.tests/testdata/TestBean1.java.data
index ecd7d08..47606fc 100644
--- a/jsf/tests/org.eclipse.jst.jsf.designtime.tests/testdata/TestBean1.java.data
+++ b/jsf/tests/org.eclipse.jst.jsf.designtime.tests/testdata/TestBean1.java.data
@@ -23,4 +23,19 @@ public class TestBean1
 	public void setBooleanIsProp1(boolean property)
 	{
 	}
+// array of string property
+	public String[] getStringArrayProperty()
+	{
+	    return new String[] {"a", "b", "c"};
+	}
+// array of integer property
+	public int[] getIntArrayProperty()
+	{
+		return new int[] {0,1,2};
+	}
+// array of array of string
+	public String[][] getArrayOfArrayOfStringProperty()
+	{
+		return new String[3][];
+	}
 }
\ No newline at end of file
diff --git a/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/src/org/eclipse/jst/jsf/validation/el/tests/base/BaseTestCase.java b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/src/org/eclipse/jst/jsf/validation/el/tests/base/BaseTestCase.java
index dc185bc..edb0755 100644
--- a/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/src/org/eclipse/jst/jsf/validation/el/tests/base/BaseTestCase.java
+++ b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/src/org/eclipse/jst/jsf/validation/el/tests/base/BaseTestCase.java
@@ -99,6 +99,16 @@ public class BaseTestCase extends TestCase
         resource.load(ELValidationTestPlugin.getDefault().getBundle(), 
                       "/testdata/classes/BeanWithMapProperties.java.data");
         _jdtTestEnv.addSourceFile("src", "beans", "BeanWithMapProperties", resource.toString());
+
+        resource = new TestFileResource();
+        resource.load(ELValidationTestPlugin.getDefault().getBundle(), 
+                      "/testdata/classes/BeanWithListProperties.java.data");
+        _jdtTestEnv.addSourceFile("src", "beans", "BeanWithListProperties", resource.toString());
+        
+        resource = new TestFileResource();
+        resource.load(ELValidationTestPlugin.getDefault().getBundle(), 
+                      "/testdata/classes/ListBean.java.data");
+        _jdtTestEnv.addSourceFile("src", "beans", "ListBean", resource.toString());
         
         resource = new TestFileResource();
         resource.load(ELValidationTestPlugin.getDefault().getBundle(), 
@@ -137,7 +147,13 @@ public class BaseTestCase extends TestCase
             
             type = javaProject.findType("beans.BeanWithMapProperties");
             assertNotNull(type);
-            
+
+            type = javaProject.findType("beans.BeanWithListProperties");
+            assertNotNull(type);
+
+            type = javaProject.findType("beans.ListBean");
+            assertNotNull(type);
+
             IPackageFragmentRoot srcRoot = _jdtTestEnv.getPackageFragmentRoot("src");
             assertTrue(srcRoot.exists());
             IPackageFragment frag = srcRoot.getPackageFragment("beans");
@@ -164,6 +180,8 @@ public class BaseTestCase extends TestCase
             assertTrue(nameTest.containsKey("myBeanSettable"));
             assertTrue(nameTest.containsKey("myBeanSubClass"));
             assertTrue(nameTest.containsKey("beanWithMapProperties"));
+            assertTrue(nameTest.containsKey("beanWithListProperties"));
+            assertTrue(nameTest.containsKey("listBean"));
         }
         catch(JavaModelException jme)
         {
diff --git a/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/src/org/eclipse/jst/jsf/validation/el/tests/jsp/BracketOperatorTestCase.java b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/src/org/eclipse/jst/jsf/validation/el/tests/jsp/BracketOperatorTestCase.java
index 4260895..6beac0b 100644
--- a/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/src/org/eclipse/jst/jsf/validation/el/tests/jsp/BracketOperatorTestCase.java
+++ b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/src/org/eclipse/jst/jsf/validation/el/tests/jsp/BracketOperatorTestCase.java
@@ -37,18 +37,48 @@ public class BracketOperatorTestCase extends SingleJSPTestCase
         assertEquals("mapBean['foo.x']", getELText(_structuredDocument,1428));
         assertEquals("mapBean['getIgnoredIntProperty']", getELText(_structuredDocument,1478));
         assertEquals("beanWithMapProperties['actionProperty']", getELText(_structuredDocument,1548));
+        assertEquals("myBean.stringArrayProperty[0]", getELText(_structuredDocument,1620));
+        assertEquals("myBean.stringArrayProperty[myBean.integerProperty]", getELText(_structuredDocument,1680));
+        assertEquals("myBean.stringArrayProperty['0']", getELText(_structuredDocument,1761));
+        assertEquals("myBean.intArrayProperty[1]", getELText(_structuredDocument,1823));
+        assertEquals("myBean.intArrayProperty[1] > 0", getELText(_structuredDocument,1880));
+        assertEquals("empty myBean.arrayOfArrayOfStringProperty", getELText(_structuredDocument,1941));
+        assertEquals("empty myBean.arrayOfArrayOfStringProperty[1]", getELText(_structuredDocument,2013));
+        assertEquals("myBean.arrayOfArrayOfStringProperty[0][1]", getELText(_structuredDocument,2088));
+        assertEquals("myBean.arrayOfArrayOfStringProperty[myBean.intArrayProperty[0]][myBean.intArrayProperty[1]]", getELText(_structuredDocument,2160));
         
-        
-        assertEquals("bundle['y']", getELText(_structuredDocument,1645));
-        assertEquals("bundle['x.z']", getELText(_structuredDocument,1690));
-        assertEquals("beanWithMapProperties['actionProperty.foo']", getELText(_structuredDocument,1737));
-        assertEquals("beanWithMapProperties['treeMap.foo']", getELText(_structuredDocument,1814));
-        assertEquals("beanWithMapProperties['mapProperty.foo']", getELText(_structuredDocument,1884));
-        assertEquals("beanWithMapProperties['mapProperty.foo.x']", getELText(_structuredDocument,1958));
-        assertEquals("beanWithMapProperties['treeMap.foo.x']", getELText(_structuredDocument,2034));    
-    }
-    
+        assertEquals("beanWithListProperties.listProperty[0]", getELText(_structuredDocument,2284));
+        assertEquals("beanWithListProperties.listProperty[myBean.integerProperty]", getELText(_structuredDocument,2353));
+        assertEquals("beanWithListProperties.listProperty['0']", getELText(_structuredDocument,2443));
+        assertEquals("beanWithListProperties.listProperty['0'].someValue", getELText(_structuredDocument,2514));
+        assertEquals("beanWithListProperties.arrayListProperty[0]", getELText(_structuredDocument,2595));
+        assertEquals("beanWithListProperties.arrayListProperty[myBean.integerProperty]", getELText(_structuredDocument,2669));
+        assertEquals("beanWithListProperties.arrayListProperty['0']", getELText(_structuredDocument,2764));
+        assertEquals("beanWithListProperties.arrayListProperty['0'].someValue", getELText(_structuredDocument,2840));
+        assertEquals("listBean[0]", getELText(_structuredDocument,2930));
+        assertEquals("listBean[myBean.integerProperty]", getELText(_structuredDocument,2972));
+        assertEquals("listBean['0']", getELText(_structuredDocument,3035));
+        assertEquals("listBean['0'].someValue", getELText(_structuredDocument,3079));
 
+        assertEquals("bundle['y']", getELText(_structuredDocument,3160));
+        assertEquals("bundle['x.z']", getELText(_structuredDocument,3205));
+        assertEquals("beanWithMapProperties['actionProperty.foo']", getELText(_structuredDocument,3252));
+        assertEquals("beanWithMapProperties['treeMap.foo']", getELText(_structuredDocument,3329));
+        assertEquals("beanWithMapProperties['mapProperty.foo']", getELText(_structuredDocument,3399));
+        assertEquals("beanWithMapProperties['mapProperty.foo.x']", getELText(_structuredDocument,3473));
+        assertEquals("beanWithMapProperties['treeMap.foo.x']", getELText(_structuredDocument,3549));
+        assertEquals("myBean.stringArrayProperty[myBean.stringProperty]", getELText(_structuredDocument,3621));
+        assertEquals("myBean.stringArrayProperty[-1]", getELText(_structuredDocument,3703));
+        assertEquals("beanWithListProperties.listProperty.someProperty", getELText(_structuredDocument,3766));
+        assertEquals("beanWithListProperties.arrayListProperty.someProperty", getELText(_structuredDocument,3845));
+        assertEquals("beanWithListProperties.arrayListProperty[-1]", getELText(_structuredDocument,3929));
+        assertEquals("listBean[-1]", getELText(_structuredDocument,4004));
+        assertEquals("myBean.stringArrayProperty['a']", getELText(_structuredDocument,4249));
+        assertEquals("beanWithListProperties.arrayListProperty['a']", getELText(_structuredDocument,4311));
+        assertEquals("beanWithListProperties.arrayListProperty[true]", getELText(_structuredDocument,4387));
+        assertEquals("listBean['a']", getELText(_structuredDocument,4464));
+        assertEquals("listBean[true]", getELText(_structuredDocument,4508));    }
+    
     public void testNoErrorExprs() 
     {
         assertNoError(841, TypeConstants.TYPE_STRING);
@@ -63,35 +93,92 @@ public class BracketOperatorTestCase extends SingleJSPTestCase
         assertNoError(1428, TypeConstants.TYPE_JAVAOBJECT);
         assertNoError(1478, TypeConstants.TYPE_JAVAOBJECT);
         assertNoError(1548, Signature.createMethodSignature(new String[0], TypeConstants.TYPE_STRING));
+        
+        assertNoError(1620, TypeConstants.TYPE_STRING);
+        assertNoError(1680, TypeConstants.TYPE_STRING);
+        assertNoError(1761, TypeConstants.TYPE_STRING);
+        
+        assertNoError(1823, Signature.SIG_INT);
+        assertNoError(1880, Signature.SIG_BOOLEAN);
+        assertNoError(1941, Signature.SIG_BOOLEAN);
+        assertNoError(2013, Signature.SIG_BOOLEAN);
+
+        assertNoError(2088, TypeConstants.TYPE_STRING);
+        assertNoError(2160, TypeConstants.TYPE_STRING);
+
+
+        assertNoError(2284, TypeConstants.TYPE_JAVAOBJECT);
+        assertNoError(2353, TypeConstants.TYPE_JAVAOBJECT);
+        assertNoError(2443, TypeConstants.TYPE_JAVAOBJECT);
+        assertNoError(2514, TypeConstants.TYPE_JAVAOBJECT);
+        assertNoError(2595, TypeConstants.TYPE_JAVAOBJECT);
+        assertNoError(2669, TypeConstants.TYPE_JAVAOBJECT);
+        assertNoError(2764, TypeConstants.TYPE_JAVAOBJECT);
+        assertNoError(2840, TypeConstants.TYPE_JAVAOBJECT);
+        assertNoError(2930, TypeConstants.TYPE_JAVAOBJECT);
+        assertNoError(2972, TypeConstants.TYPE_JAVAOBJECT);
+        assertNoError(3035, TypeConstants.TYPE_JAVAOBJECT);
+        assertNoError(3079, TypeConstants.TYPE_JAVAOBJECT);
     }
 
     public void testWarningExprs() 
     {
-        List list = assertSemanticWarning(1645, null, 1);
+
+        List list = assertSemanticWarning(3160, null, 1);
         assertContainsProblem(list, DiagnosticFactory.MEMBER_NOT_FOUND_ID);
         
-        list = assertSemanticWarning(1690, null, 1);
+        list = assertSemanticWarning(3205, null, 1);
         assertContainsProblem(list, DiagnosticFactory.MEMBER_NOT_FOUND_ID);
         
-        list = assertSemanticWarning(1737, null, 1);
+        list = assertSemanticWarning(3252, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.MEMBER_NOT_FOUND_ID);
+
+        list = assertSemanticWarning(3329, null, 1);
         assertContainsProblem(list, DiagnosticFactory.MEMBER_NOT_FOUND_ID);
 
-        list = assertSemanticWarning(1814, null, 1);
+        list = assertSemanticWarning(3399, null, 1);
         assertContainsProblem(list, DiagnosticFactory.MEMBER_NOT_FOUND_ID);
 
-        list = assertSemanticWarning(1884, null, 1);
+        list = assertSemanticWarning(3473, null, 1);
         assertContainsProblem(list, DiagnosticFactory.MEMBER_NOT_FOUND_ID);
 
-        list = assertSemanticWarning(1958, null, 1);
+        list = assertSemanticWarning(3549, null, 1);
         assertContainsProblem(list, DiagnosticFactory.MEMBER_NOT_FOUND_ID);
 
-        list = assertSemanticWarning(2034, null, 1);
+        list = assertSemanticWarning(3621, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.UNARY_OP_STRING_CONVERSION_NOT_GUARANTEED_ID);
+
+        list = assertSemanticWarning(3703, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.POSSIBLE_ARRAY_INDEX_OUT_OF_BOUNDS_ID);
+
+        list = assertSemanticWarning(3766, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.MEMBER_NOT_FOUND_ID);
+
+        list = assertSemanticWarning(3845, null, 1);
         assertContainsProblem(list, DiagnosticFactory.MEMBER_NOT_FOUND_ID);
+
+        list = assertSemanticWarning(3929, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.POSSIBLE_ARRAY_INDEX_OUT_OF_BOUNDS_ID);
+
+        list = assertSemanticWarning(4004, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.POSSIBLE_ARRAY_INDEX_OUT_OF_BOUNDS_ID);
     }
     
     public void testErrorExprs() 
-    {
-        // no error expressions
-    }
+    {        
+        List list = assertSemanticError(4249, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_COULD_NOT_MAKE_NUMERIC_COERCION_ID);
+        
+        list = assertSemanticError(4311, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_COULD_NOT_MAKE_NUMERIC_COERCION_ID);
 
+        list = assertSemanticError(4387, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_COULD_NOT_MAKE_NUMERIC_COERCION_ID);
+        
+        list = assertSemanticError(4464, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_COULD_NOT_MAKE_NUMERIC_COERCION_ID);
+
+        list = assertSemanticError(4508, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_COULD_NOT_MAKE_NUMERIC_COERCION_ID);
+    }
 }
diff --git a/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/classes/BeanWithListProperties.java.data b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/classes/BeanWithListProperties.java.data
new file mode 100644
index 0000000..859a202
--- /dev/null
+++ b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/classes/BeanWithListProperties.java.data
@@ -0,0 +1,25 @@
+package beans;
+
+
+public class BeanWithListProperties 
+{
+	public java.util.List getListProperty()
+	{
+		return new HashMap();
+	}
+	
+	public int getIntegerProperty()
+	{
+		return -1;
+	}
+	
+	public java.util.ArrayList getArrayListProperty()
+	{
+		return new java.util.ArrayList();
+	}
+	
+	public String actionProperty()
+	{
+		return "go";
+	}
+}
diff --git a/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/classes/ListBean.java.data b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/classes/ListBean.java.data
new file mode 100644
index 0000000..bbb246b
--- /dev/null
+++ b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/classes/ListBean.java.data
@@ -0,0 +1,29 @@
+package beans;
+
+import java.util.AbstractList;
+
+/**
+ * A bean class that implements java.util.List
+ * 
+ * @author cbateman
+ *
+ */
+public class ListBean extends AbstractList 
+{
+    public Object get(int index) {
+        return null;
+    }
+
+    public int size() {
+        return 0;
+    }
+
+    /**
+     * Simulate a 
+     * @return
+     */
+    public String getStringProperty()
+    {
+        return "";
+    }
+}
\ No newline at end of file
diff --git a/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/classes/MyBean.java.data b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/classes/MyBean.java.data
index e57a67a..6b9c342 100644
--- a/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/classes/MyBean.java.data
+++ b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/classes/MyBean.java.data
@@ -108,4 +108,14 @@ public class MyBean
 	{
 		return false;
 	}
+	
+	public int[] getIntArrayProperty()
+	{
+		return new int[] {0, 1, 2};
+	}
+	
+	public String[][] getArrayOfArrayOfStringProperty()
+	{
+		return new String[3][];
+	}	
 }
diff --git a/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/jsps/bracketOperator.jsp.data b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/jsps/bracketOperator.jsp.data
index 16a4576..312ea06 100644
--- a/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/jsps/bracketOperator.jsp.data
+++ b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/jsps/bracketOperator.jsp.data
@@ -40,6 +40,30 @@ on Libraries node in Projects view can be used to add the JSTL 1.1 library.
 	   	<h:outputText value="#{mapBean['getIgnoredIntProperty']}"/>
 	   	<h:commandButton action="#{beanWithMapProperties['actionProperty']}"/>
 
+		<h:outputText value="#{myBean.stringArrayProperty[0]}"/>
+		<h:outputText value="#{myBean.stringArrayProperty[myBean.integerProperty]}"/>
+		<h:outputText value="#{myBean.stringArrayProperty['0']}"/>
+		<h:outputText value="#{myBean.intArrayProperty[1]}"/>
+		<h:outputText value="#{myBean.intArrayProperty[1] > 0}"/>
+		<h:outputText value="#{empty myBean.arrayOfArrayOfStringProperty}"/>
+		<h:outputText value="#{empty myBean.arrayOfArrayOfStringProperty[1]}"/>
+		<h:outputText value="#{myBean.arrayOfArrayOfStringProperty[0][1]}"/>
+		<h:outputText value="#{myBean.arrayOfArrayOfStringProperty[myBean.intArrayProperty[0]][myBean.intArrayProperty[1]]}"/>
+
+		<h:outputText value="#{beanWithListProperties.listProperty[0]}"/>
+		<h:outputText value="#{beanWithListProperties.listProperty[myBean.integerProperty]}"/>
+		<h:outputText value="#{beanWithListProperties.listProperty['0']}"/>
+		<h:outputText value="#{beanWithListProperties.listProperty['0'].someValue}"/>
+		<h:outputText value="#{beanWithListProperties.arrayListProperty[0]}"/>
+		<h:outputText value="#{beanWithListProperties.arrayListProperty[myBean.integerProperty]}"/>
+		<h:outputText value="#{beanWithListProperties.arrayListProperty['0']}"/>
+		<h:outputText value="#{beanWithListProperties.arrayListProperty['0'].someValue}"/>
+		
+		<h:outputText value="#{listBean[0]}"/>
+		<h:outputText value="#{listBean[myBean.integerProperty]}"/>
+		<h:outputText value="#{listBean['0']}"/>
+		<h:outputText value="#{listBean['0'].someValue}"/>
+
 		<!--  warnings -->
 	   	<h:outputText value="#{bundle['y']}"/>
 	   	<h:outputText value="#{bundle['x.z']}"/>
@@ -48,7 +72,23 @@ on Libraries node in Projects view can be used to add the JSTL 1.1 library.
     	<h:outputText value="#{beanWithMapProperties['mapProperty.foo']}"/>
     	<h:outputText value="#{beanWithMapProperties['mapProperty.foo.x']}"/>
 	   	<h:outputText value="#{beanWithMapProperties['treeMap.foo.x']}"/>
-	   	
+	   	<h:outputText value="#{myBean.stringArrayProperty[myBean.stringProperty]"/>
+	   	<h:outputText value="#{myBean.stringArrayProperty[-1]}"/>
+
+		<h:outputText value="#{beanWithListProperties.listProperty.someProperty}"/>
+		<h:outputText value="#{beanWithListProperties.arrayListProperty.someProperty"}/>
+		<h:outputText value="#{beanWithListProperties.arrayListProperty[-1]}"/>
+		<h:outputText value="#{listBean[-1]}"/>
+		<!-- because it is a list the bean properties are invisible
+		<h:outputText value="#{listBean.stringProperty}"}/>
+		<h:outputText value="#{listBean['stringProperty']}"}/>
+		
+	   	<!-- errors -->
+		<h:outputText value="#{myBean.stringArrayProperty['a']}"/>
+		<h:outputText value="#{beanWithListProperties.arrayListProperty['a']}"/>
+		<h:outputText value="#{beanWithListProperties.arrayListProperty[true]}"/>
+		<h:outputText value="#{listBean['a']}"/>
+		<h:outputText value="#{listBean[true]}"/>
   </f:view>
     </body>
 </html>
\ No newline at end of file
diff --git a/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/web/faces-config.xml.data b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/web/faces-config.xml.data
index 1282640..fd25069 100644
--- a/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/web/faces-config.xml.data
+++ b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/web/faces-config.xml.data
@@ -85,4 +85,20 @@
 		<managed-bean-scope>
 		request</managed-bean-scope>
 	</managed-bean>
+	<managed-bean>
+		<managed-bean-name>
+		beanWithListProperties</managed-bean-name>
+		<managed-bean-class>
+		beans.BeanWithListProperties</managed-bean-class>
+		<managed-bean-scope>
+		request</managed-bean-scope>
+	</managed-bean>
+	<managed-bean>
+		<managed-bean-name>
+		listBean</managed-bean-name>
+		<managed-bean-class>
+		beans.ListBean</managed-bean-class>
+		<managed-bean-scope>
+		request</managed-bean-scope>
+	</managed-bean>
 </faces-config>