Initial checkin for generics support in EL.
diff --git a/jsf/tests/org.eclipse.jst.jsf.contentassist.tests/src/org/eclipse/jst/jsf/contentassist/tests/Test_bug_149743.java b/jsf/tests/org.eclipse.jst.jsf.contentassist.tests/src/org/eclipse/jst/jsf/contentassist/tests/Test_bug_149743.java
index d1b7c71..bf2f571 100644
--- a/jsf/tests/org.eclipse.jst.jsf.contentassist.tests/src/org/eclipse/jst/jsf/contentassist/tests/Test_bug_149743.java
+++ b/jsf/tests/org.eclipse.jst.jsf.contentassist.tests/src/org/eclipse/jst/jsf/contentassist/tests/Test_bug_149743.java
@@ -1,3 +1,14 @@
+/*******************************************************************************
+ * Copyright (c) 2007 Oracle Corporation.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *    Cameron Bateman/Oracle - initial API and implementation
+ *    
+ ********************************************************************************/
 package org.eclipse.jst.jsf.contentassist.tests;
 
 import java.util.List;
@@ -121,7 +132,7 @@
                             - resolver.getStartOffset() + 1, elText);
 
             List proposals = strategy.getProposals(wrapper.getContext());
-            assertEquals(1, proposals.size());
+            assertEquals(2, proposals.size());
             final ICompletionProposal proposal = (ICompletionProposal) proposals.get(0);
             assertEquals("property", proposal.getDisplayString());
         }
diff --git a/jsf/tests/org.eclipse.jst.jsf.context.symbol.tests/src/org/eclipse/jst/jsf/context/symbol/tests/ModelBaseTestCase.java b/jsf/tests/org.eclipse.jst.jsf.context.symbol.tests/src/org/eclipse/jst/jsf/context/symbol/tests/ModelBaseTestCase.java
index b6f126e..638292c 100644
--- a/jsf/tests/org.eclipse.jst.jsf.context.symbol.tests/src/org/eclipse/jst/jsf/context/symbol/tests/ModelBaseTestCase.java
+++ b/jsf/tests/org.eclipse.jst.jsf.context.symbol.tests/src/org/eclipse/jst/jsf/context/symbol/tests/ModelBaseTestCase.java
@@ -1,3 +1,14 @@
+/*******************************************************************************
+ * Copyright (c) 2007 Oracle Corporation.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *    Cameron Bateman/Oracle - initial API and implementation
+ *    
+ ********************************************************************************/
 package org.eclipse.jst.jsf.context.symbol.tests;
 
 import java.util.Iterator;
@@ -10,6 +21,7 @@
 import org.eclipse.jst.jsf.context.symbol.IBeanInstanceSymbol;
 import org.eclipse.jst.jsf.context.symbol.IBeanPropertySymbol;
 import org.eclipse.jst.jsf.context.symbol.IJavaTypeDescriptor2;
+import org.eclipse.jst.jsf.context.symbol.IPropertySymbol;
 import org.eclipse.jst.jsf.context.symbol.SymbolFactory;
 import org.eclipse.jst.jsf.test.util.JDTTestEnvironment;
 import org.eclipse.jst.jsf.test.util.JSFTestUtil;
@@ -72,7 +84,7 @@
      * @return a bean instance set up for the indicated test class
      * @throws Exception
      */
-    protected IBeanInstanceSymbol setupBeanProperty(Bundle bundle, String fileName, String packageName, String beanClassName, Map properties) throws Exception
+    protected IBeanInstanceSymbol setupBeanProperty(Bundle bundle, String fileName, String packageName, String beanClassName, Map<String, IPropertySymbol> properties) throws Exception
     {
         loadSourceClass(bundle, fileName, packageName, beanClassName);
         
@@ -88,11 +100,10 @@
             SymbolFactory.eINSTANCE.createIBeanInstanceSymbol();
         bean.setTypeDescriptor(testBeanDescriptor);
         bean.setName(beanClassName);
-        List propertyList = bean.getProperties();
-        for(final Iterator it = propertyList.iterator(); it.hasNext();)
+        List<IPropertySymbol> propertyList = bean.getProperties();
+        for(final Iterator<IPropertySymbol> it = propertyList.iterator(); it.hasNext();)
         {
-            final IBeanPropertySymbol  property = 
-                (IBeanPropertySymbol) it.next();
+            final IPropertySymbol  property = it.next();
             properties.put(property.getName(), property);
         }
         
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 a0fc641..0031db1 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
@@ -44,14 +44,17 @@
     private Map                     _beanSubclassProperties;
     private Map                     _beanMethods;
     private Map                     _beanMethodsSubclass;     
+    private Map<String, IPropertySymbol> _genericProperties;
     
     private IBeanInstanceSymbol     _testBean1Symbol;
     private IBeanInstanceSymbol     _testBean1SubclassSymbol;
     private IBeanInstanceSymbol     _testBean2Symbol;
     private IBeanInstanceSymbol     _testBean2SubclassSymbol;
+    private IBeanInstanceSymbol     _testBeanWithGenericProperties;
     
     private final static String packageName1 = "com.test";
     private final static String testBeanName1 = "TestBean1";
+    private final static String testBean1Sig = "L"+packageName1+"."+testBeanName1+";";
     private final static String testBeanSubclass1 = "TestBean1Subclass";
     private final static String testBeanName2 = "TestBean2";
     private final static String testBean2Subclass = "TestBean2Subclass";
@@ -81,6 +84,13 @@
                               "/testfiles/TestBean1Subclass.java.data", packageName1, 
                               testBeanSubclass1, _beanSubclassProperties);
 
+        _genericProperties = new HashMap<String, IPropertySymbol>();
+        
+        _testBeanWithGenericProperties =
+            setupBeanProperty(ContextSymbolTestPlugin.getDefault().getBundle(),
+                    "/testdata/TestBeanWithGenericProperties.java.data", packageName1, 
+                    "TestBeanWithGenericProperties",_genericProperties);
+
         _beanMethods = new HashMap();
         _testBean2Symbol = 
             setupBeanMethods("/testdata/TestBean2.java.data", testBeanName2, _beanMethods);
@@ -126,11 +136,12 @@
      */
     public void testMapSanity()
     {
-        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);
+        final int NUM_PROPS_IN_BEAN = 15; // includes getClass on parent java.lang.Object
+        assertEquals("Check extra or missing properties",NUM_PROPS_IN_BEAN, _beanProperties.size());
+        assertEquals("Check extra or missing properties",NUM_PROPS_IN_BEAN+1, _beanSubclassProperties.size());
+        assertEquals("Check extra or missing methods",12,_beanMethods.size()); // includes java.lang.Object methods
+        assertEquals("Check extra or missing methods",13,_beanMethodsSubclass.size());
+        assertEquals("Check extra or missing methods", 5, _genericProperties.size());
     }
     
     /**
@@ -697,6 +708,62 @@
                 nestedSymbol.getTypeDescriptor().getTypeSignature());
     }
     
+/* ------ Properties with generics ------- */
+    
+    public void testGenericGetterBeans()
+    {
+        // list of strings
+        {
+            final IPropertySymbol propSymbol = _genericProperties.get("listOfStrings");
+            assertNotNull(propSymbol);
+            
+            ITypeDescriptor typeDesc = propSymbol.getTypeDescriptor();
+            assertNotNull(typeDesc);
+            assertEquals(TypeConstants.TYPE_LIST, typeDesc.getTypeSignature());
+            assertEquals(1, typeDesc.getTypeParameterSignatures().size());
+            assertEquals(TypeConstants.TYPE_STRING, typeDesc.getTypeParameterSignatures().get(0));
+        }
+        
+        // map of strings keyed on strings
+        {
+            final IPropertySymbol propSymbol = _genericProperties.get("mapOfStringsKeyedByString");
+            assertNotNull(propSymbol);
+            
+            ITypeDescriptor typeDesc = propSymbol.getTypeDescriptor();
+            assertNotNull(typeDesc);
+            assertEquals(TypeConstants.TYPE_MAP, typeDesc.getTypeSignature());
+            assertEquals(2, typeDesc.getTypeParameterSignatures().size());
+            assertEquals(TypeConstants.TYPE_STRING, typeDesc.getTypeParameterSignatures().get(0));
+            assertEquals(TypeConstants.TYPE_STRING, typeDesc.getTypeParameterSignatures().get(1));
+        }
+        
+        // map of user (source) defined type keyed  on strings
+        {
+            final IPropertySymbol propSymbol = _genericProperties.get("mapOfTestBeansByString");
+            assertNotNull(propSymbol);
+            
+            ITypeDescriptor typeDesc = propSymbol.getTypeDescriptor();
+            assertNotNull(typeDesc);
+            assertEquals(TypeConstants.TYPE_MAP, typeDesc.getTypeSignature());
+            assertEquals(2, typeDesc.getTypeParameterSignatures().size());
+            assertEquals(TypeConstants.TYPE_STRING, typeDesc.getTypeParameterSignatures().get(0));
+            assertEquals(testBean1Sig, typeDesc.getTypeParameterSignatures().get(1));
+        }
+        
+        // mutable map
+        {
+            final IPropertySymbol propSymbol = _genericProperties.get("mutableMapOfStringByString");
+            assertNotNull(propSymbol);
+            
+            ITypeDescriptor typeDesc = propSymbol.getTypeDescriptor();
+            assertNotNull(typeDesc);
+            assertEquals(TypeConstants.TYPE_MAP, typeDesc.getTypeSignature());
+            assertEquals(2, typeDesc.getTypeParameterSignatures().size());
+            assertEquals(TypeConstants.TYPE_STRING, typeDesc.getTypeParameterSignatures().get(0));
+            assertEquals(TypeConstants.TYPE_STRING, typeDesc.getTypeParameterSignatures().get(1));
+        }
+    }
+    
 /* ------ 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 d3d95cc..88fe896 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
@@ -1,11 +1,28 @@
+/*******************************************************************************
+ * Copyright (c) 2007 Oracle Corporation.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *    Cameron Bateman/Oracle - initial API and implementation
+ *    
+ ********************************************************************************/
 package org.eclipse.jst.jsf.context.symbol.tests;
 
 import java.util.HashMap;
+import java.util.Map;
 
+import org.eclipse.emf.common.util.BasicEList;
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.jdt.core.Signature;
 import org.eclipse.jst.jsf.common.internal.types.TypeConstants;
+import org.eclipse.jst.jsf.common.internal.types.ValueType;
 import org.eclipse.jst.jsf.context.symbol.IBeanInstanceSymbol;
 import org.eclipse.jst.jsf.context.symbol.IBoundedListTypeDescriptor;
 import org.eclipse.jst.jsf.context.symbol.IBoundedMapTypeDescriptor;
+import org.eclipse.jst.jsf.context.symbol.IPropertySymbol;
 import org.eclipse.jst.jsf.context.symbol.ISymbol;
 import org.eclipse.jst.jsf.context.symbol.ITypeDescriptor;
 
@@ -19,7 +36,15 @@
     private final static String     packageName = "com.test";
     private IBeanInstanceSymbol     _testMapBeanSymbol;
     private IBeanInstanceSymbol     _testListBeanSymbol;
-    
+    private IBeanInstanceSymbol      _testBeanWithGenericProperties;
+    private Map<String, IPropertySymbol>  _genericProperties;
+
+    // used as the int argument to List.get(int)
+    private final static ValueType  LIST_GETTER_ARG = new ValueType(Signature.SIG_INT, ValueType.ASSIGNMENT_TYPE_RHS);
+
+    // used as a String argument to List.get(String)
+    private final static ValueType  MAP_GETTER_ARG_STRING =   new ValueType(TypeConstants.TYPE_STRING, ValueType.ASSIGNMENT_TYPE_RHS);
+
     protected void setUp() throws Exception 
     {
         super.setUp();
@@ -33,6 +58,13 @@
             setupBeanProperty(ContextSymbolTestPlugin.getDefault().getBundle(),
                     "/testdata/MyListBean.java.data", packageName, 
                     "MyListBean", new HashMap());
+        
+        _genericProperties = new HashMap<String, IPropertySymbol>();
+        
+        _testBeanWithGenericProperties =
+            setupBeanProperty(ContextSymbolTestPlugin.getDefault().getBundle(),
+                    "/testdata/TestBeanWithGenericProperties.java.data", packageName, 
+                    "TestBeanWithGenericProperties",_genericProperties);
     }
 
     /**
@@ -42,6 +74,7 @@
     {
         assertNotNull(_testMapBeanSymbol);
         assertNotNull(_testListBeanSymbol);
+        assertNotNull(_testBeanWithGenericProperties);
     }
     
     /**
@@ -88,4 +121,73 @@
         assertEquals(symbolKey.toString(), symbol.getName());
 
     }
+    
+    public void testListGetCall()
+    {
+        assertTrue(_testListBeanSymbol.getTypeDescriptor().instanceOf(TypeConstants.TYPE_LIST));
+        assertTrue(_testListBeanSymbol.supportsCoercion(TypeConstants.TYPE_LIST));
+        
+        EList<ValueType> valueTypes = new BasicEList<ValueType>();
+        valueTypes.add(LIST_GETTER_ARG);
+        ISymbol symbol = _testListBeanSymbol.call("get", valueTypes, "listBean[0]");
+        assertNotNull(symbol);
+        assertTrue(symbol instanceof IPropertySymbol);
+        assertEquals(TypeConstants.TYPE_JAVAOBJECT, ((IPropertySymbol)symbol).getTypeDescriptor().getTypeSignature());
+    }
+    
+    public void testMapGetCall()
+    {
+        assertTrue(_testMapBeanSymbol.getTypeDescriptor().instanceOf(TypeConstants.TYPE_MAP));
+        assertTrue(_testMapBeanSymbol.supportsCoercion(TypeConstants.TYPE_MAP));
+
+        EList<ValueType> valueTypes = new BasicEList<ValueType>();
+        valueTypes.add(MAP_GETTER_ARG_STRING);
+        ISymbol symbol = _testMapBeanSymbol.call("get", valueTypes, "foo");
+        assertNotNull(symbol);
+        assertTrue(symbol instanceof IPropertySymbol);
+        assertEquals(TypeConstants.TYPE_JAVAOBJECT, ((IPropertySymbol)symbol).getTypeDescriptor().getTypeSignature());
+        
+    }
+    
+    public void testListGetCallWithSimpleTypeArguments()
+    {
+        final EList<ValueType> valueTypes = new BasicEList<ValueType>();
+        valueTypes.add(LIST_GETTER_ARG);
+
+        final IPropertySymbol propSymbol = 
+            _genericProperties.get("listOfStrings");
+        assertNotNull(propSymbol);
+        assertTrue(propSymbol.supportsCoercion(TypeConstants.TYPE_LIST));
+        assertFalse(propSymbol.supportsCoercion(TypeConstants.TYPE_MAP));
+        assertEquals(TypeConstants.TYPE_LIST, propSymbol.getTypeDescriptor().getTypeSignature());
+        assertEquals(1, propSymbol.getTypeDescriptor().getTypeParameterSignatures().size());
+        assertEquals(TypeConstants.TYPE_STRING, propSymbol.getTypeDescriptor().getTypeParameterSignatures().get(0));
+        
+        ISymbol symbol = propSymbol.call("get", valueTypes, "listBean[0]");
+        assertNotNull(symbol);
+        assertTrue(symbol instanceof IPropertySymbol);
+        assertEquals(TypeConstants.TYPE_STRING, ((IPropertySymbol)symbol).getTypeDescriptor().getTypeSignature());
+    }
+    
+    public void testMapGetCallWithSimpleTypeArguments()
+    {
+        final EList<ValueType> valueTypes = new BasicEList<ValueType>();
+        valueTypes.add(MAP_GETTER_ARG_STRING);
+
+        final IPropertySymbol propSymbol = 
+            _genericProperties.get("mapOfStringsKeyedByString");
+        assertNotNull(propSymbol);
+        assertTrue(propSymbol.supportsCoercion(TypeConstants.TYPE_MAP));
+        assertFalse(propSymbol.supportsCoercion(TypeConstants.TYPE_LIST));
+        assertEquals(TypeConstants.TYPE_MAP, propSymbol.getTypeDescriptor().getTypeSignature());
+        assertEquals(2, propSymbol.getTypeDescriptor().getTypeParameterSignatures().size());
+        assertEquals(TypeConstants.TYPE_STRING, propSymbol.getTypeDescriptor().getTypeParameterSignatures().get(0));
+        assertEquals(TypeConstants.TYPE_STRING, propSymbol.getTypeDescriptor().getTypeParameterSignatures().get(1));
+        
+        ISymbol symbol = propSymbol.call("get", valueTypes, "mapBean['someKey']");
+        assertNotNull(symbol);
+        assertTrue(symbol instanceof IPropertySymbol);
+        assertEquals(TypeConstants.TYPE_STRING, ((IPropertySymbol)symbol).getTypeDescriptor().getTypeSignature());
+
+    }
 }
diff --git a/jsf/tests/org.eclipse.jst.jsf.context.symbol.tests/testdata/TestBeanWithGenericProperties.java.data b/jsf/tests/org.eclipse.jst.jsf.context.symbol.tests/testdata/TestBeanWithGenericProperties.java.data
new file mode 100644
index 0000000..733c557
--- /dev/null
+++ b/jsf/tests/org.eclipse.jst.jsf.context.symbol.tests/testdata/TestBeanWithGenericProperties.java.data
@@ -0,0 +1,34 @@
+package com.test;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.HashMap;
+
+public class TestBeanWithGenericProperties
+{
+    public List<String> getListOfStrings()
+    {
+        return new ArrayList<String>();
+    }
+
+    public Map<String, String> getMapOfStringsKeyedByString()
+    {
+        return new HashMap<String, String>();
+    }
+
+    public Map<String, TestBean1> getMapOfTestBeansByString()
+    {
+        return new HashMap<String, TestBean2>();
+    }
+
+    public Map<String, String> getMutableMapOfStringByString()
+    {
+        return new HashMap<String, String>();
+    }
+
+    public void setMutableMapOfStringByString(Map<String,String> map)
+    {
+        // do nothing, method sig is all that's required
+    }
+}
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 9e5f5c6..7035271 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
@@ -20,6 +20,7 @@
 import org.eclipse.core.resources.IProject;
 import org.eclipse.jdt.core.IType;
 import org.eclipse.jdt.core.Signature;
+import org.eclipse.jst.jsf.common.internal.types.TypeConstants;
 import org.eclipse.jst.jsf.common.util.JDTBeanIntrospector;
 import org.eclipse.jst.jsf.common.util.JDTBeanProperty;
 import org.eclipse.jst.jsf.common.util.JDTBeanPropertyWorkingCopy;
@@ -36,12 +37,15 @@
  */
 public class TestJDTBeanIntrospector extends TestCase 
 {
+    // TODO: test the getAllMethods.  also ensure that we get coverage of the case
+    // where a type has no supers
     private JDTTestEnvironment                      _jdtTestEnvironment;
     private IType                                   _testBean1Type;
     private IType                                   _testBeanSubclassType;
     private IType                                   _testBeanGenericType;
     private Map<String, JDTBeanProperty>            _properties;
     private Map<String, JDTBeanProperty>            _subClassProperties;
+    private Map<String, JDTBeanProperty>            _genericTypeProperties;
 
     private final static String srcFolderName = "src";
     private final static String packageName1 = "com.test";
@@ -110,6 +114,11 @@
             new JDTBeanIntrospector(_testBeanSubclassType);
         
         _subClassProperties = beanIntrospector.getProperties();
+        
+        beanIntrospector = 
+            new JDTBeanIntrospector(_testBeanGenericType);
+        
+        _genericTypeProperties = beanIntrospector.getProperties();
     }
 
     
@@ -126,12 +135,14 @@
      */
     public void testMapSanity()
     {
-        final int NUM_PROPS = 14;
+        final int NUM_PROPS = 15;
         
         checkMapSanity(_properties, NUM_PROPS);
         // sub class an locally defined property in addition to what
         // is inherited
         checkMapSanity(_subClassProperties, NUM_PROPS+1);
+        
+        checkMapSanity(_genericTypeProperties, 5);
     }
 
     private void checkMapSanity(Map<String, JDTBeanProperty> properties, int numProps)
@@ -536,30 +547,42 @@
 
     }
     
-    public void testGenericProperty() throws Exception
+    public void testGenericListOfStringProperty() throws Exception
     {
-        JDTBeanIntrospector introspector = new JDTBeanIntrospector(_testBeanGenericType);
-        Map<String, JDTBeanProperty> props = introspector.getProperties();
-        JDTBeanProperty property = props.get("listOfStrings");
-        System.out.println(property.getTypeSignature());
-        System.out.println(property.getType().getFullyQualifiedName());
-        System.out.println(property.getType().getFullyQualifiedParameterizedName());
+        JDTBeanProperty property = _genericTypeProperties.get("listOfStrings");
+        assertEquals(TypeConstants.TYPE_LIST, property.getTypeSignature());
 
-//        for (ITypeParameter parameter : property.getType().getTypeParameters())
-//        {
-//            System.out.println(parameter.getElementName());
-//            System.out.println(parameter.getElementType());
-//            System.out.print("\n");
-//            
-//            for (String bound : parameter.getBounds())
-//            {
-//                System.out.println(bound);
-//            }
-//        }
-
-        for (String param : property.getTypeParameterSignatures())
-        {
-            System.out.println(param);
-        }
+        assertEquals(1, property.getTypeParameterSignatures().size());
+        assertEquals(TypeConstants.TYPE_STRING, property.getTypeParameterSignatures().get(0));
     }
+    
+    public void testGenericArrayListOfStringProperty() throws Exception
+    {
+        JDTBeanProperty property = _genericTypeProperties.get("arrayListOfStrings");
+        assertEquals("Ljava.util.ArrayList;", property.getTypeSignature());
+
+        assertEquals(1, property.getTypeParameterSignatures().size());
+        assertEquals(TypeConstants.TYPE_STRING, property.getTypeParameterSignatures().get(0));
+    }
+    public void testGenericListOfListOfStringProperty() throws Exception
+    {
+        JDTBeanProperty property = _genericTypeProperties.get("listOfListOfStrings");
+        assertEquals("Ljava.util.List;", property.getTypeSignature(true));
+        assertEquals("Ljava.util.List<Ljava.util.List<Ljava.lang.String;>;>;", property.getTypeSignature(false));
+        
+        assertEquals(1, property.getTypeParameterSignatures().size());
+        assertEquals("Ljava.util.List<Ljava.lang.String;>;", property.getTypeParameterSignatures().get(0));
+    }
+    
+    public void testGenericMapOfString_StringProperty() throws Exception
+    {
+        JDTBeanProperty property = _genericTypeProperties.get("mapOfString_String");
+        assertEquals("Ljava.util.Map;", property.getTypeSignature(true));
+        assertEquals("Ljava.util.Map<Ljava.lang.String;Ljava.lang.String;>;", property.getTypeSignature(false));
+        
+        assertEquals(2, property.getTypeParameterSignatures().size());
+        assertEquals("Ljava.lang.String;", property.getTypeParameterSignatures().get(0));
+        assertEquals("Ljava.lang.String;", property.getTypeParameterSignatures().get(1));
+    }
+
 }
diff --git a/jsf/tests/org.eclipse.jst.jsf.core.tests/src/org/eclipse/jst/jsf/core/tests/util/TestTypeUtil.java b/jsf/tests/org.eclipse.jst.jsf.core.tests/src/org/eclipse/jst/jsf/core/tests/util/TestTypeUtil.java
new file mode 100644
index 0000000..8410cab
--- /dev/null
+++ b/jsf/tests/org.eclipse.jst.jsf.core.tests/src/org/eclipse/jst/jsf/core/tests/util/TestTypeUtil.java
@@ -0,0 +1,162 @@
+/*******************************************************************************
+ * Copyright (c) 2007 Oracle Corporation.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *    Cameron Bateman/Oracle - initial API and implementation
+ *    
+ ********************************************************************************/
+package org.eclipse.jst.jsf.core.tests.util;
+
+import java.util.Map;
+
+import junit.framework.TestCase;
+
+import org.eclipse.jdt.core.IType;
+import org.eclipse.jst.jsf.common.internal.types.TypeConstants;
+import org.eclipse.jst.jsf.common.util.JDTBeanIntrospector;
+import org.eclipse.jst.jsf.common.util.JDTBeanProperty;
+import org.eclipse.jst.jsf.common.util.TypeUtil;
+import org.eclipse.jst.jsf.core.tests.TestsPlugin;
+import org.eclipse.jst.jsf.test.util.JDTTestEnvironment;
+import org.eclipse.jst.jsf.test.util.JSFTestUtil;
+import org.eclipse.jst.jsf.test.util.TestFileResource;
+import org.eclipse.jst.jsf.test.util.WebProjectTestEnvironment;
+
+public class TestTypeUtil extends TestCase 
+{
+    private JDTTestEnvironment                      _jdtTestEnvironment;
+    private IType                                   _testBean1Type;
+    private IType                                   _testBeanSubclassType;
+    private IType                                   _testBeanGenericType;
+    private Map<String, JDTBeanProperty>            _properties;
+    private Map<String, JDTBeanProperty>            _subClassProperties;
+    private Map<String, JDTBeanProperty>            _genericTypeProperties;
+
+    private final static String srcFolderName = "src";
+    private final static String packageName1 = "com.test";
+    private final static String testBeanName1 = "TestBean1";
+    private final static String testBeanSubclassName1 = "TestBean1Subclass";
+    private final static String testAnotherBeanName = "AnotherBean";
+    private final static String testBeanGenericName = "TestBeanGeneric";
+
+    protected void setUp() throws Exception {
+        super.setUp();
+        
+        JSFTestUtil.setValidationEnabled(false);
+        JSFTestUtil.setInternetProxyPreferences(true, "www-proxy.us.oracle.com", "80");
+        
+        final WebProjectTestEnvironment  projectTestEnvironment = 
+            new WebProjectTestEnvironment("TestJDTBeanIntrospectorProject");
+        projectTestEnvironment.createProject(true);
+        
+        _jdtTestEnvironment = new JDTTestEnvironment(projectTestEnvironment);
+        TestFileResource codeRes = new TestFileResource();
+        codeRes.load(TestsPlugin.getDefault().getBundle(), "/testfiles/TestBean1.java.data");
+        String code = codeRes.toString();
+        _jdtTestEnvironment.addSourceFile(srcFolderName, packageName1, testBeanName1, code);
+        
+        _testBean1Type = _jdtTestEnvironment.getJavaProject().findType(packageName1+"."+testBeanName1);
+        assertNotNull(_testBean1Type);
+        
+        // load TestBean1Subclass
+        codeRes = new TestFileResource();
+        codeRes.load(TestsPlugin.getDefault().getBundle(), "/testfiles/TestBean1Subclass.java.data");
+        code = codeRes.toString();
+        _jdtTestEnvironment.addSourceFile(srcFolderName, packageName1, testBeanSubclassName1, code);
+
+        _testBeanSubclassType = _jdtTestEnvironment.getJavaProject().findType(packageName1+"."+testBeanSubclassName1);
+        assertNotNull(_testBeanSubclassType);
+        // sanity to make sure we don't somehow accidently get the same class
+        assertNotSame(_testBean1Type, _testBeanSubclassType);
+        
+        // load anotherBean
+        codeRes = new TestFileResource();
+        codeRes.load(TestsPlugin.getDefault().getBundle(), "/testfiles/AnotherBean.java.data");
+        code = codeRes.toString();
+        _jdtTestEnvironment.addSourceFile(srcFolderName, packageName1, testAnotherBeanName, code);
+        
+        assertNotNull(_jdtTestEnvironment.getJavaProject().findType(packageName1+"."+testAnotherBeanName));
+        
+        // load TestBeanGeneric
+        codeRes = new TestFileResource();
+        codeRes.load(TestsPlugin.getDefault().getBundle(), "/testfiles/TestBeanGeneric.java.data");
+        code = codeRes.toString();
+        _jdtTestEnvironment.addSourceFile(srcFolderName, packageName1, testBeanGenericName, code);
+
+        _testBeanGenericType = _jdtTestEnvironment.getJavaProject().findType(packageName1+"."+testBeanGenericName); 
+        assertNotNull(_testBeanGenericType);
+        
+        // introspect after classes loaded to ensure all dependencies
+        // are in the project
+        JDTBeanIntrospector  beanIntrospector = 
+            new JDTBeanIntrospector(_testBean1Type);
+        
+        _properties = beanIntrospector.getProperties();
+        
+        beanIntrospector = 
+            new JDTBeanIntrospector(_testBeanSubclassType);
+        
+        _subClassProperties = beanIntrospector.getProperties();
+        
+        beanIntrospector = 
+            new JDTBeanIntrospector(_testBeanGenericType);
+    }
+
+    protected void tearDown() throws Exception {
+        super.tearDown();
+    }
+
+    /**
+     * only simple tests required, mainly to assert that the
+     * eraseTypeParameters is defaulted to true, since the method
+     * should be fully equivalent to resolveTypeSignature(type, signature, true)
+     */
+//    public void testResolveTypeITypeString() {
+//        fail("nbla");
+//    }
+
+    public void testResolveTypeSignatureITypeString() {
+        // this one should be the same regardless of type erasure
+        assertEquals(TypeConstants.TYPE_STRING, TypeUtil.resolveTypeSignature(_testBean1Type, "QString;", true));
+        assertEquals(TypeConstants.TYPE_STRING, TypeUtil.resolveTypeSignature(_testBean1Type, "QString;", false));
+
+        // no parameters are provided here, so we should see the same result
+        assertEquals(TypeConstants.TYPE_COLLECTION, TypeUtil.resolveTypeSignature(_testBean1Type, "QCollection;", true));
+        assertEquals(TypeConstants.TYPE_COLLECTION, TypeUtil.resolveTypeSignature(_testBean1Type, "QCollection;", false));
+        assertEquals(TypeConstants.TYPE_MAP, TypeUtil.resolveTypeSignature(_testBean1Type, "QMap;", true));
+        assertEquals(TypeConstants.TYPE_MAP, TypeUtil.resolveTypeSignature(_testBean1Type, "QMap;", false));
+        
+        // in this case, the provided signature has type erasure, so the answer will different depending on typeErasure flag
+        assertEquals(TypeConstants.TYPE_MAP, TypeUtil.resolveTypeSignature(_testBean1Type, "QMap<QString;QString;>;", true));
+        assertEquals("Ljava.util.Map<Ljava.lang.String;Ljava.lang.String;>;", TypeUtil.resolveTypeSignature(_testBean1Type, "QMap<QString;QString;>;", false));
+    }
+
+//    public void testResolveTypeSignatureITypeStringBoolean() {
+//        fail("Not yet implemented");
+//    }
+//
+//    public void testGetSignature() {
+//        fail("Not yet implemented");
+//    }
+//
+//    public void testResolveMethodSignature() {
+//        fail("Not yet implemented");
+//    }
+//
+//    public void testGetFullyQualifiedName() {
+//        fail("Not yet implemented");
+//    }
+//
+//    public void testResolveTypeIJavaProjectString() {
+//        fail("Not yet implemented");
+//    }
+//
+//    public void testMatchTypeParameterToArgument() {
+//        fail("Not yet implemented");
+//    }
+
+}
diff --git a/jsf/tests/org.eclipse.jst.jsf.core.tests/testfiles/TestBeanGeneric.java.data b/jsf/tests/org.eclipse.jst.jsf.core.tests/testfiles/TestBeanGeneric.java.data
index b13c5fd..8a6315c 100644
--- a/jsf/tests/org.eclipse.jst.jsf.core.tests/testfiles/TestBeanGeneric.java.data
+++ b/jsf/tests/org.eclipse.jst.jsf.core.tests/testfiles/TestBeanGeneric.java.data
@@ -2,6 +2,8 @@
 
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Map;
+import java.util.HashMap;
 
 public class TestBeanGeneric 
 {
@@ -14,4 +16,14 @@
     {
         return new ArrayList<String>();
     }
+    
+    public List<List<String>> getListOfListOfStrings()
+    {
+    	return new ArrayList<List<String>>();
+    }
+
+    public Map<String, String> getMapOfString_String()
+    {
+        return new HashMap<String, String>();
+    }
 }
diff --git a/jsf/tests/org.eclipse.jst.jsf.designtime.tests/src/org/eclipse/jst/jsf/designtime/tests/AllTests.java b/jsf/tests/org.eclipse.jst.jsf.designtime.tests/src/org/eclipse/jst/jsf/designtime/tests/AllTests.java
index 77c043f..0e6b755 100644
--- a/jsf/tests/org.eclipse.jst.jsf.designtime.tests/src/org/eclipse/jst/jsf/designtime/tests/AllTests.java
+++ b/jsf/tests/org.eclipse.jst.jsf.designtime.tests/src/org/eclipse/jst/jsf/designtime/tests/AllTests.java
@@ -1,3 +1,14 @@
+/*******************************************************************************
+ * Copyright (c) 2007 Oracle Corporation.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *    Cameron Bateman/Oracle - initial API and implementation
+ *    
+ ********************************************************************************/
 package org.eclipse.jst.jsf.designtime.tests;
 
 import junit.framework.Test;
@@ -16,11 +27,13 @@
      */
     public static Test suite() 
     {
-        TestSuite suite = new TestSuite("Test for org.eclipse.jst.jsf.validation.el.tests");
+        TestSuite suite = new TestSuite("Test for org.eclipse.jst.jsf.designtime.tests");
         //$JUnit-BEGIN$
         suite.addTestSuite(TestDefaultBeanSymbolSourceProvider.class);
         suite.addTestSuite(TestResourceBundleMapSource.class);
         suite.addTestSuite(TestDefaultPropertyResolver.class);
+        suite.addTestSuite(TestAbstractDataModelVariableFactory.class);
+        
         //$JUnit-END$
         return suite;
     }
diff --git a/jsf/tests/org.eclipse.jst.jsf.designtime.tests/src/org/eclipse/jst/jsf/designtime/tests/TestAbstractDataModelVariableFactory.java b/jsf/tests/org.eclipse.jst.jsf.designtime.tests/src/org/eclipse/jst/jsf/designtime/tests/TestAbstractDataModelVariableFactory.java
new file mode 100644
index 0000000..d45602c
--- /dev/null
+++ b/jsf/tests/org.eclipse.jst.jsf.designtime.tests/src/org/eclipse/jst/jsf/designtime/tests/TestAbstractDataModelVariableFactory.java
@@ -0,0 +1,223 @@
+/*******************************************************************************
+ * Copyright (c) 2007 Oracle Corporation.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *    Cameron Bateman/Oracle - initial API and implementation
+ *    
+ ********************************************************************************/
+package org.eclipse.jst.jsf.designtime.tests;
+
+import junit.framework.TestCase;
+
+import org.eclipse.jdt.core.Signature;
+import org.eclipse.jst.jsf.common.internal.types.TypeConstants;
+import org.eclipse.jst.jsf.common.internal.types.ValueType;
+import org.eclipse.jst.jsf.context.symbol.ERuntimeSource;
+import org.eclipse.jst.jsf.context.symbol.IBoundedMapTypeDescriptor;
+import org.eclipse.jst.jsf.context.symbol.IComponentSymbol;
+import org.eclipse.jst.jsf.context.symbol.IInstanceSymbol;
+import org.eclipse.jst.jsf.context.symbol.IJavaTypeDescriptor2;
+import org.eclipse.jst.jsf.context.symbol.ISymbol;
+import org.eclipse.jst.jsf.context.symbol.internal.util.IObjectSymbolBasedValueType;
+import org.eclipse.jst.jsf.core.IJSFCoreConstants;
+import org.eclipse.jst.jsf.core.tests.util.JSFFacetedTestEnvironment;
+import org.eclipse.jst.jsf.designtime.internal.symbols.DataModelVariableTestFacade;
+import org.eclipse.jst.jsf.test.util.JDTTestEnvironment;
+import org.eclipse.jst.jsf.test.util.JSFTestUtil;
+import org.eclipse.jst.jsf.test.util.WebProjectTestEnvironment;
+
+public class TestAbstractDataModelVariableFactory extends TestCase 
+{
+    private JSFFacetedTestEnvironment   _jsfFacetedTestEnvironment;
+    private JDTTestEnvironment          _jdtTestEnvironment;
+    
+
+    protected void setUp() throws Exception {
+        super.setUp();
+        
+        JSFTestUtil.setValidationEnabled(false);
+        JSFTestUtil.setInternetProxyPreferences(true, "www-proxy.us.oracle.com","80");
+
+        final WebProjectTestEnvironment  projectTestEnvironment = 
+            new WebProjectTestEnvironment("TestDefaultPropertyResolver"+getName());
+        projectTestEnvironment.createProject(false);
+
+        _jsfFacetedTestEnvironment = new JSFFacetedTestEnvironment(projectTestEnvironment);
+        _jsfFacetedTestEnvironment.initialize(IJSFCoreConstants.FACET_VERSION_1_1);
+        
+        _jdtTestEnvironment = new JDTTestEnvironment(projectTestEnvironment);
+
+    }
+
+    protected void tearDown() throws Exception {
+        super.tearDown();
+        
+        _jdtTestEnvironment.getJavaProject().getProject().delete(true, null);
+    }
+
+    public final void testCreateArraySymbol() 
+    {
+        // test array of int.  Should yield a scalar symbol for int
+        createAndVerifyArraySymbol("intArray", Signature.SIG_INT, 1, Signature.SIG_INT, 0);
+        // test array of String.  Should yield a string
+        createAndVerifyArraySymbol("stringArray", TypeConstants.TYPE_STRING, 1, TypeConstants.TYPE_STRING, 0);
+        // test an array of array of strings.  Should yield an array of Strings
+        createAndVerifyArraySymbol("stringArrayArray", TypeConstants.TYPE_STRING, 2, TypeConstants.TYPE_STRING, 1);
+    }
+
+    private ISymbol createAndVerifyArraySymbol(final String name, final String typeSignature, final int arrayCount, final String expectedResultSignature, final int expectedArrayCount)
+    {
+        DataModelVariableTestFacade testFacade = new DataModelVariableTestFacade();
+        
+        ISymbol symbol = testFacade.testCreateArraySymbol(name, Signature.createArraySignature(typeSignature, arrayCount), _jdtTestEnvironment.getJavaProject());
+        assertTrue(symbol instanceof IInstanceSymbol);
+        IInstanceSymbol instanceSymbol = (IInstanceSymbol) symbol;
+        assertTrue(instanceSymbol.getTypeDescriptor() instanceof IJavaTypeDescriptor2);
+        IJavaTypeDescriptor2 typeDesc = (IJavaTypeDescriptor2) instanceSymbol.getTypeDescriptor();
+        assertEquals(name, symbol.getName());
+        assertEquals(Signature.createArraySignature(expectedResultSignature,expectedArrayCount),typeDesc.getTypeSignature());
+        assertEquals(expectedArrayCount, typeDesc.getArrayCount());
+       
+        return symbol;
+    }
+    
+
+    public final void testCreateFromList() 
+    {
+        final String[]  stringArgType = new String[] {TypeConstants.TYPE_STRING};
+        final String[]  listOfStringArgType = 
+            new String[] {"Ljava.util.List<Ljava.lang.String;>;"};
+        
+        final DataModelVariableTestFacade testFacade = new DataModelVariableTestFacade();
+
+        // test non-parameterized list
+        ValueType valueType = new ValueType(TypeConstants.TYPE_LIST, new String[0], new String[0], new String[0], ValueType.ASSIGNMENT_TYPE_RHS);
+        ISymbol symbol = testFacade.testCreateFromList("rawList", valueType, _jdtTestEnvironment.getJavaProject());
+        {
+            // should create the same as passing directly to default
+            ISymbol compareSymbol = testFacade.createDefaultSymbol("rawListDefault");
+            assertTrue(symbol instanceof IComponentSymbol);
+            assertTrue(compareSymbol instanceof IComponentSymbol);
+         
+            IComponentSymbol s1 = (IComponentSymbol) symbol;
+            IComponentSymbol s2 = (IComponentSymbol) compareSymbol;
+            assertSame(s1, s2);
+        }
+        
+        // test list of strings
+        valueType = new ValueType(TypeConstants.TYPE_LIST, stringArgType, new String[0], new String[0], ValueType.ASSIGNMENT_TYPE_RHS);
+        symbol = testFacade.testCreateFromList("string", valueType, _jdtTestEnvironment.getJavaProject());
+        assertTrue(symbol instanceof IComponentSymbol);
+        assertEquals(ERuntimeSource.TAG_INSTANTIATED_SYMBOL_LITERAL, ((IComponentSymbol)symbol).getRuntimeSource());
+        assertEquals(TypeConstants.TYPE_STRING, ((IComponentSymbol)symbol).getTypeDescriptor().getTypeSignature());
+        assertEquals(0, ((IComponentSymbol)symbol).getTypeDescriptor().getTypeParameterSignatures().size());
+        
+        // test list of list of strings
+        valueType = new ValueType(TypeConstants.TYPE_LIST, listOfStringArgType, new String[0], new String[0], ValueType.ASSIGNMENT_TYPE_RHS);
+        symbol = testFacade.testCreateFromList("listOfString", valueType, _jdtTestEnvironment.getJavaProject());
+        assertTrue(symbol instanceof IComponentSymbol);
+        assertEquals(ERuntimeSource.TAG_INSTANTIATED_SYMBOL_LITERAL, ((IComponentSymbol)symbol).getRuntimeSource());
+        assertEquals(TypeConstants.TYPE_LIST, ((IComponentSymbol)symbol).getTypeDescriptor().getTypeSignature());
+        assertEquals(1, ((IComponentSymbol)symbol).getTypeDescriptor().getTypeParameterSignatures().size());
+        assertEquals("Ljava.lang.String;", ((IComponentSymbol)symbol).getTypeDescriptor().getTypeParameterSignatures().get(0));
+        // next level: get the nested string in the list
+        valueType = IObjectSymbolBasedValueType.getInstance(symbol);
+        symbol = testFacade.testCreateFromList("subListOfString", valueType, _jdtTestEnvironment.getJavaProject());
+        assertTrue(symbol instanceof IComponentSymbol);
+        assertEquals(ERuntimeSource.TAG_INSTANTIATED_SYMBOL_LITERAL, ((IComponentSymbol)symbol).getRuntimeSource());
+        assertEquals(TypeConstants.TYPE_STRING, ((IComponentSymbol)symbol).getTypeDescriptor().getTypeSignature());
+        assertEquals(0, ((IComponentSymbol)symbol).getTypeDescriptor().getTypeParameterSignatures().size());
+    }
+    
+    private void assertSame(IComponentSymbol s1, IComponentSymbol s2)
+    {
+        // ensure we don't pass the same ref twice by accident
+        assertFalse(s1 == s2);
+        assertEquals(s1.getRuntimeSource(), s2.getRuntimeSource());
+        assertEquals(s1.getDetailedDescription(), s2.getDetailedDescription());
+        assertEquals(s1.getTypeDescriptor().getTypeSignature(), s2.getTypeDescriptor().getTypeSignature());
+    }
+    
+    public final void testCreateScalarSymbol() 
+    {
+        createAndVerifyScalar("String", TypeConstants.TYPE_STRING);
+        createAndVerifyScalar("List", TypeConstants.TYPE_LIST);
+        createAndVerifyScalar("ListOfString", "Ljava.util.List<Ljava.lang.String;>;");
+        createAndVerifyScalar("ArrayOfInteger", Signature.createArraySignature(TypeConstants.TYPE_BOXED_INTEGER, 1));
+    }
+    
+    private void createAndVerifyScalar(final String name, final String signature)
+    {
+        final DataModelVariableTestFacade testFacade = new DataModelVariableTestFacade();
+        final ISymbol symbol =  testFacade.testCreateScalarSymbol("", signature, _jdtTestEnvironment.getJavaProject());
+        assertTrue(symbol instanceof IComponentSymbol);
+        final IComponentSymbol compSymbol = (IComponentSymbol) symbol;
+        assertEquals(ERuntimeSource.TAG_INSTANTIATED_SYMBOL_LITERAL, ((IComponentSymbol)symbol).getRuntimeSource());
+        assertEquals(Signature.getTypeErasure(signature), compSymbol.getTypeDescriptor().getTypeSignature());
+        
+        final String[]  typeArgs = Signature.getTypeArguments(signature);
+        for (int i = 0; i < typeArgs.length; i++)
+        {
+            assertEquals(typeArgs[i], compSymbol.getTypeDescriptor().getTypeParameterSignatures().get(i));
+        }
+    }
+
+    public final void testCreateDefaultSymbol() 
+    {
+        DataModelVariableTestFacade testFacade = new DataModelVariableTestFacade();
+        ISymbol defaultSymbol = testFacade.createDefaultSymbol("foo");
+        assertNotNull(defaultSymbol);
+        assertEquals("foo", defaultSymbol.getName());
+        assertTrue(defaultSymbol instanceof  IComponentSymbol);
+        IComponentSymbol symbol = (IComponentSymbol) defaultSymbol;
+        assert(symbol.getTypeDescriptor() instanceof IBoundedMapTypeDescriptor);
+        assertEquals(ERuntimeSource.TAG_INSTANTIATED_SYMBOL_LITERAL, symbol.getRuntimeSource());
+        assertNotNull(symbol.getDetailedDescription());
+    }
+    
+    public final void testCreateFromType()
+    {
+        final DataModelVariableTestFacade testFacade = new DataModelVariableTestFacade();
+        // test each of known branches against the construction method that's expected to be called
+        
+        // an array of something should yield the same thing as createArraySymbol
+        {
+            final String arraySig = "[Ljava.lang.String;";
+            ValueType valueType = new ValueType(arraySig, new String[0], new String[0], new String[0], ValueType.ASSIGNMENT_TYPE_RHS);
+            ISymbol array1 = testFacade.createFromType("array", valueType, _jdtTestEnvironment.getJavaProject()); 
+            ISymbol array2 = testFacade.testCreateArraySymbol("array2", arraySig, _jdtTestEnvironment.getJavaProject());
+            assertSame((IComponentSymbol)array1, (IComponentSymbol)array2);
+        }
+        
+        // if it's a list should be the same as createFromList
+        {
+            final String listSig = TypeConstants.TYPE_LIST;
+            ValueType valueType = new ValueType(listSig, new String[0], new String[0], new String[0], ValueType.ASSIGNMENT_TYPE_RHS);
+            ISymbol list1 = testFacade.createFromType("list", valueType, _jdtTestEnvironment.getJavaProject()); 
+            ISymbol list2 = testFacade.testCreateFromList("list2", valueType, _jdtTestEnvironment.getJavaProject());
+            assertSame((IComponentSymbol)list1, (IComponentSymbol)list2);
+        }
+        
+        // if it's a DataModel, should be the same as default
+        {
+            final String dataModelSig = TypeConstants.TYPE_DATA_MODEL;
+            ValueType valueType = new ValueType(dataModelSig, new String[0], new String[0], new String[0], ValueType.ASSIGNMENT_TYPE_RHS);
+            ISymbol dataModel1 = testFacade.createFromType("dataModel", valueType, _jdtTestEnvironment.getJavaProject()); 
+            ISymbol dataModel2 = testFacade.createDefaultSymbol("dataModel2");
+            assertSame((IComponentSymbol)dataModel1, (IComponentSymbol)dataModel2);
+        }
+        
+        // if it's just some non-special object, like a String, then should be same a scalar
+        {
+            final String stringSig = TypeConstants.TYPE_STRING;
+            ValueType valueType = new ValueType(stringSig, new String[0], new String[0], new String[0], ValueType.ASSIGNMENT_TYPE_RHS);
+            ISymbol scalar1 = testFacade.createFromType("scalar1", valueType, _jdtTestEnvironment.getJavaProject()); 
+            ISymbol scalar2 = testFacade.testCreateScalarSymbol("scalar2", stringSig, _jdtTestEnvironment.getJavaProject());
+            assertSame((IComponentSymbol)scalar1, (IComponentSymbol)scalar2);
+        }
+    }
+}
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 b2cb15e..beaec75 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
@@ -1,3 +1,14 @@
+/*******************************************************************************
+ * Copyright (c) 2007 Oracle Corporation.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *    Cameron Bateman/Oracle - initial API and implementation
+ *    
+ ********************************************************************************/
 package org.eclipse.jst.jsf.designtime.tests;
 
 import java.util.HashMap;
@@ -31,7 +42,7 @@
  */
 public class TestDefaultPropertyResolver extends TestCase 
 {
-    private static final int NUM_PROPERTIES_TEST_BEAN_1 = 5;
+    private static final int NUM_PROPERTIES_TEST_BEAN_1 = 6;  // includes java.lang.Object.getClass()
     private JDTTestEnvironment              _jdtTestEnvironment;
     private JSFFacetedTestEnvironment       _jsfFactedTestEnvironment;
 
@@ -42,6 +53,7 @@
     private IType                           _testBeanWithMapProp;
     private IType                           _testListBeanType;
     private IType                           _testBeanWithListPropType;
+    private IType                           _testBeanWithGenericProperties;
     
     private final static String     SRC_FOLDER_NAME = "src";
     private final static String     PACKAGE_NAME = "com.test";
@@ -52,6 +64,7 @@
     private final static String     BEANWITHMAPPROP_NAME = "BeanWithMapProp";  
     private final static String     LISTBEAN_NAME = "ListBean";
     private final static String     BEANWITHLISTPROP_NAME = "BeanWithListProp";
+    private final static String     BEANWITHGENERICPROP_NAME = "TestBeanWithGenericProperties";
     
     protected void setUp() throws Exception 
     {
@@ -120,6 +133,13 @@
         _testBeanWithListPropType =
             _jdtTestEnvironment.getJavaProject().findType(PACKAGE_NAME+"."+BEANWITHLISTPROP_NAME);
         assertNotNull(_testBeanWithListPropType);
+        
+        JSFTestUtil.loadSourceClass(
+                DesignTimeTestsPlugin.getDefault().getBundle(), 
+                    "/testdata/TestBeanWithGenericProperties.java.data", BEANWITHGENERICPROP_NAME, SRC_FOLDER_NAME, PACKAGE_NAME, _jdtTestEnvironment);
+        _testBeanWithGenericProperties = 
+            _jdtTestEnvironment.getJavaProject().findType(PACKAGE_NAME+"."+BEANWITHGENERICPROP_NAME);
+        assertNotNull(_testBeanWithGenericProperties);
     }
     
     
@@ -145,32 +165,36 @@
         
         beanIntrospector = new JDTBeanIntrospector(_testMapBean1Type);
         props = beanIntrospector.getProperties();
-        // has 1 as a bean: isEmpty -> empty property
-        assertEquals(1, props.size());
+        // has 2 as a bean: isEmpty -> empty property + class
+        assertEquals(2, props.size());
 
         beanIntrospector = new JDTBeanIntrospector(_testBean2Type);
         props = beanIntrospector.getProperties();
-        // two props: one TestBean3
-        assertEquals(1, props.size());
+        // two props: myBean3, class
+        assertEquals(2, props.size());
         
         beanIntrospector = new JDTBeanIntrospector(_testBean3Type);
         props = beanIntrospector.getProperties();
-        // one props: one of type TestBean2
-        assertEquals(1, props.size());
+        // two props: one of type TestBean2 + class
+        assertEquals(2, props.size());
         
         beanIntrospector = new JDTBeanIntrospector(_testBeanWithMapProp);
         props = beanIntrospector.getProperties();
-        // one props: one of type Map
-        assertEquals(1, props.size());
+        // two props: one of type Map + class
+        assertEquals(2, props.size());
         
         beanIntrospector = new JDTBeanIntrospector(_testListBeanType);
         props = beanIntrospector.getProperties();
-        // includes isEmpty
-        assertEquals(2, props.size());
+        // includes isEmpty and class
+        assertEquals(3, props.size());
         
         beanIntrospector = new JDTBeanIntrospector(_testBeanWithListPropType);
         props = beanIntrospector.getProperties();
-        assertEquals(1, props.size());
+        assertEquals(2, props.size());
+        
+        beanIntrospector = new JDTBeanIntrospector(_testBeanWithGenericProperties);
+        props = beanIntrospector.getProperties();
+        assertEquals(3, props.size());
     }
     
     /**
@@ -325,7 +349,7 @@
         final DefaultDTPropertyResolver propResolver = new DefaultDTPropertyResolver();
         {
             final ISymbol[]  properties = propResolver.getAllProperties(symbol);
-            assertEquals(1, properties.length);
+            assertEquals(2, properties.length);  // should have defined property plus class
             
             // check props
             final Map  gotProps  = new HashMap();
@@ -340,6 +364,7 @@
             }
             
             assertTrue(gotProps.containsKey("myBean3"));
+            assertTrue(gotProps.containsKey("class"));
         }
         // next run recursively on myBean3 10 props deep
         ISymbol curBase = symbol;
@@ -348,8 +373,8 @@
         for (int i = 0; i < 10; i++)
         {
             final ISymbol[] properties = propResolver.getAllProperties(curBase);
-            assertEquals(1, properties.length);
-            final IPropertySymbol  propSymbol = (IPropertySymbol) properties[0];
+            assertEquals(2, properties.length); // has class property as well as expected  in it
+            final IPropertySymbol  propSymbol = (IPropertySymbol) findSymbol(i % 2 == 0 ? "myBean3" : "myBean2", properties);
 
             // i is even
             if (i % 2 == 0)
@@ -383,10 +408,10 @@
         DefaultDTPropertyResolver propResolver = new DefaultDTPropertyResolver();
         ISymbol[]  properties = propResolver.getAllProperties(symbol);
 
-        // should be just one property
-        assertEquals(1, properties.length);
-        assertEquals(properties[0].getName(), "mapProp");
-        assertEquals(properties[0].getName(),
+        // should be two properties: mapProp and class
+        assertEquals(2, properties.length);
+        assertNotNull(findSymbol("mapProp",properties));
+        assertEquals(findSymbol("mapProp",properties).getName(),
                      propResolver.getProperty(symbol, "mapProp").getName());
         
         IPropertySymbol  mapProp = (IPropertySymbol) propResolver.getProperty(symbol, "mapProp");
@@ -543,11 +568,11 @@
         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());
+        // should be just one property plus Object.class
+        assertEquals(2, properties.length);
+        assertNotNull(findSymbol("listProp", properties));
+        assertEquals(findSymbol("listProp", properties).getName(),
+                propResolver.getProperty(symbol, "listProp").getName());
         
         IPropertySymbol  listProp = (IPropertySymbol) propResolver.getProperty(symbol, "listProp");
         assertEquals("Lcom.test.ListBean;", listProp.getTypeDescriptor().getTypeSignature());
@@ -560,4 +585,46 @@
         IPropertySymbol unboundedProp = (IPropertySymbol) propResolver.getProperty(listProp, 0);
         assertEquals(TypeConstants.TYPE_JAVAOBJECT, unboundedProp.getTypeDescriptor().getTypeSignature());
     }
+    
+    public void testGenericListProperty()
+    {
+        final IBeanInstanceSymbol symbol = SymbolFactory.eINSTANCE.createIBeanInstanceSymbol();
+        symbol.setName("beanWithListProp");
+        final IJavaTypeDescriptor2 typeDesc = SymbolFactory.eINSTANCE.createIJavaTypeDescriptor2();
+        typeDesc.setType(_testBeanWithGenericProperties);
+        symbol.setTypeDescriptor(typeDesc);
+        
+        DefaultDTPropertyResolver propResolver = new DefaultDTPropertyResolver();
+        ISymbol[]  properties = propResolver.getAllProperties(symbol);
+
+        // should be just one property plus Object.class
+        assertEquals(3, properties.length);
+        assertNotNull(findSymbol("listOfStrings", properties));
+        assertEquals(findSymbol("listOfStrings", properties).getName(),
+                propResolver.getProperty(symbol, "listOfStrings").getName());
+        
+        IPropertySymbol  listProp = (IPropertySymbol) propResolver.getProperty(symbol, "listOfStrings");
+        assertEquals(TypeConstants.TYPE_LIST, 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_STRING, unboundedProp.getTypeDescriptor().getTypeSignature());
+    }
+    
+    private ISymbol findSymbol(final String name, ISymbol[] symbols)
+    {
+        for (ISymbol symbol : symbols)
+        {
+            if (symbol.getName().equals(name))
+            {
+                return symbol;
+            }
+        }
+        
+        return null;
+     }
 }
diff --git a/jsf/tests/org.eclipse.jst.jsf.designtime.tests/testdata/TestBeanWithGenericProperties.java.data b/jsf/tests/org.eclipse.jst.jsf.designtime.tests/testdata/TestBeanWithGenericProperties.java.data
new file mode 100644
index 0000000..d8c4b89
--- /dev/null
+++ b/jsf/tests/org.eclipse.jst.jsf.designtime.tests/testdata/TestBeanWithGenericProperties.java.data
@@ -0,0 +1,19 @@
+package com.test;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.HashMap;
+
+public class TestBeanWithGenericProperties
+{
+    public List<String> getListOfStrings()
+    {
+        return new ArrayList<String>();
+    }
+
+    public Map<String, String> getMapOfStringsKeyedByString()
+    {
+        return new HashMap<String, String>();
+    }
+}
diff --git a/jsf/tests/org.eclipse.jst.jsf.facesconfig.tests/src/org/eclipse/jst/jsf/facesconfig/tests/read/BaseReadTestCase.java b/jsf/tests/org.eclipse.jst.jsf.facesconfig.tests/src/org/eclipse/jst/jsf/facesconfig/tests/read/BaseReadTestCase.java
index 44dba81..d651ff3 100644
--- a/jsf/tests/org.eclipse.jst.jsf.facesconfig.tests/src/org/eclipse/jst/jsf/facesconfig/tests/read/BaseReadTestCase.java
+++ b/jsf/tests/org.eclipse.jst.jsf.facesconfig.tests/src/org/eclipse/jst/jsf/facesconfig/tests/read/BaseReadTestCase.java
@@ -53,9 +53,9 @@
     {
         if (_testConfiguration != null)
         {
-            _facesConfigFile = (String) _testConfiguration.get(CONFIG_FILE_KEY);
+            _facesConfigFile = _testConfiguration.get(CONFIG_FILE_KEY);
             assertNotNull(_facesConfigFile);
-            _facesVersion = (String) _testConfiguration.get(FACES_VERSION_KEY);
+            _facesVersion = _testConfiguration.get(FACES_VERSION_KEY);
             assertNotNull(_facesVersion);
         }
         else
diff --git a/jsf/tests/org.eclipse.jst.jsf.facesconfig.tests/src/org/eclipse/jst/jsf/facesconfig/tests/write/BaseWriteTestCase.java b/jsf/tests/org.eclipse.jst.jsf.facesconfig.tests/src/org/eclipse/jst/jsf/facesconfig/tests/write/BaseWriteTestCase.java
index 3fd7758..329d6d3 100644
--- a/jsf/tests/org.eclipse.jst.jsf.facesconfig.tests/src/org/eclipse/jst/jsf/facesconfig/tests/write/BaseWriteTestCase.java
+++ b/jsf/tests/org.eclipse.jst.jsf.facesconfig.tests/src/org/eclipse/jst/jsf/facesconfig/tests/write/BaseWriteTestCase.java
@@ -54,9 +54,9 @@
     {
         if (_testConfiguration != null)
         {
-            _facesConfigFile = (String) _testConfiguration.get(CONFIG_FILE_KEY);
+            _facesConfigFile = _testConfiguration.get(CONFIG_FILE_KEY);
             assertNotNull(_facesConfigFile);
-            _facesVersion = (String) _testConfiguration.get(FACES_VERSION_KEY);
+            _facesVersion = _testConfiguration.get(FACES_VERSION_KEY);
             assertNotNull(_facesVersion);
         }
     }
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 072f026..9a5ebeb 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
@@ -1,3 +1,14 @@
+/*******************************************************************************
+ * Copyright (c) 2007 Oracle Corporation.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *    Cameron Bateman/Oracle - initial API and implementation
+ *    
+ ********************************************************************************/
 package org.eclipse.jst.jsf.validation.el.tests.base;
 
 import java.io.ByteArrayInputStream;
@@ -571,9 +582,9 @@
         
         MyConfiguration(TestConfiguration  configuration)
         {
-            _proxyHostName = (String) configuration.get(BaseTestCase.PROXY_SETTING_HOST);
-            _proxyPort = (String) configuration.get(BaseTestCase.PROXY_SETTING_PORT);
-            _jsfVersion = (String) configuration.get(BaseTestCase.JSF_FACET_VERSION);
+            _proxyHostName = configuration.get(BaseTestCase.PROXY_SETTING_HOST);
+            _proxyPort = configuration.get(BaseTestCase.PROXY_SETTING_PORT);
+            _jsfVersion = configuration.get(BaseTestCase.JSF_FACET_VERSION);
         }
         
         public boolean isProxyEnabled()
diff --git a/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/src/org/eclipse/jst/jsf/validation/el/tests/base/SingleJSPTestCase.java b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/src/org/eclipse/jst/jsf/validation/el/tests/base/SingleJSPTestCase.java
index 3bf661b..3e57dac 100644
--- a/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/src/org/eclipse/jst/jsf/validation/el/tests/base/SingleJSPTestCase.java
+++ b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/src/org/eclipse/jst/jsf/validation/el/tests/base/SingleJSPTestCase.java
@@ -1,3 +1,14 @@
+/*******************************************************************************
+ * Copyright (c) 2007 Oracle Corporation.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *    Cameron Bateman/Oracle - initial API and implementation
+ *    
+ ********************************************************************************/
 package org.eclipse.jst.jsf.validation.el.tests.base;
 
 import java.util.List;
@@ -214,8 +225,8 @@
         
         MyConfiguration(TestConfiguration testConfiguration)
         {
-            _facetVersion = (String) testConfiguration.get(BaseTestCase.JSF_FACET_VERSION);
-            _facesConfigFile = (String) testConfiguration.get(FACES_CONFIG_FILE);
+            _facetVersion = testConfiguration.get(BaseTestCase.JSF_FACET_VERSION);
+            _facesConfigFile = testConfiguration.get(FACES_CONFIG_FILE);
         }
 
         public String getFacetVersion() {