Fix for PMC_approved bug: https://bugs.eclipse.org/bugs/show_bug.cgi?id=231626.
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
index 4453f0f..4b53ce7 100644
--- 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
@@ -7,7 +7,7 @@
  *
  * Contributors:
  *    Cameron Bateman/Oracle - initial API and implementation
- *    
+ * 
  ********************************************************************************/
 package org.eclipse.jst.jsf.core.tests.util;
 
@@ -16,6 +16,7 @@
 
 import junit.framework.TestCase;
 
+import org.eclipse.jdt.core.IClasspathEntry;
 import org.eclipse.jdt.core.IMethod;
 import org.eclipse.jdt.core.IType;
 import org.eclipse.jst.jsf.common.internal.types.TypeConstants;
@@ -26,158 +27,200 @@
 import org.eclipse.jst.jsf.test.util.TestFileResource;
 import org.eclipse.jst.jsf.test.util.WebProjectTestEnvironment;
 
-public class TestTypeUtil extends TestCase 
+public class TestTypeUtil extends TestCase
 {
-    private JDTTestEnvironment                      _jdtTestEnvironment;
-    private IType                                   _testBean1Type;
-    private IType                                   _testBeanSubclassType;
-    private IType                                   _testBeanGenericType;
-    private IType									_testEnum1Type;
-   
-//    private Map<String, JDTBeanProperty>            _properties;
-//    private Map<String, JDTBeanProperty>            _subClassProperties;
-//    private Map<String, JDTBeanProperty>            _genericTypeProperties;
+    private JDTTestEnvironment  _jdtTestEnvironment;
+    private IType               _testBean1Type;
+    private IType               _testBeanSubclassType;
+    private IType               _testBeanGenericType;
+    private IType               _testEnum1Type;
+    private IType               _binaryType;
 
-    private final static String srcFolderName = "src";
-    private final static String packageName1 = "com.test";
-    private final static String testBeanName1 = "TestBean1";
+    // 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";
-    private final static String testEnumName1 = "TestEnum1";
-    //private final static String testEnumName2 = "TestEnum2";
+    private final static String testAnotherBeanName   = "AnotherBean";
+    private final static String testBeanGenericName   = "TestBeanGeneric";
+    private final static String testEnumName1         = "TestEnum1";
 
-    protected void setUp() throws Exception {
+    // private final static String testEnumName2 = "TestEnum2";
+
+    protected void setUp() throws Exception
+    {
         super.setUp();
-        
+
         JSFTestUtil.setValidationEnabled(false);
-        JSFTestUtil.setInternetProxyPreferences(true, "www-proxy.us.oracle.com", "80");
-        
-        final WebProjectTestEnvironment  projectTestEnvironment = 
-            new WebProjectTestEnvironment("TestTypeUtil"+getClass().getName()+"_"+getName());
+        JSFTestUtil.setInternetProxyPreferences(true,
+                "www-proxy.us.oracle.com", "80");
+
+        final WebProjectTestEnvironment projectTestEnvironment = new WebProjectTestEnvironment(
+                "TestTypeUtil" + getClass().getName() + "_" + getName());
         projectTestEnvironment.createProject(true);
-        
+
         _jdtTestEnvironment = new JDTTestEnvironment(projectTestEnvironment);
         TestFileResource codeRes = new TestFileResource();
-        codeRes.load(TestsPlugin.getDefault().getBundle(), "/testfiles/TestBean1.java.data");
+        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);
+        _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");
+        codeRes.load(TestsPlugin.getDefault().getBundle(),
+                "/testfiles/TestBean1Subclass.java.data");
         code = codeRes.toString();
-        _jdtTestEnvironment.addSourceFile(srcFolderName, packageName1, testBeanSubclassName1, code);
+        _jdtTestEnvironment.addSourceFile(srcFolderName, packageName1,
+                testBeanSubclassName1, code);
 
-        _testBeanSubclassType = _jdtTestEnvironment.getJavaProject().findType(packageName1+"."+testBeanSubclassName1);
+        _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");
+        codeRes.load(TestsPlugin.getDefault().getBundle(),
+                "/testfiles/AnotherBean.java.data");
         code = codeRes.toString();
-        _jdtTestEnvironment.addSourceFile(srcFolderName, packageName1, testAnotherBeanName, code);
-        
-        assertNotNull(_jdtTestEnvironment.getJavaProject().findType(packageName1+"."+testAnotherBeanName));
-        
+        _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");
+        codeRes.load(TestsPlugin.getDefault().getBundle(),
+                "/testfiles/TestBeanGeneric.java.data");
         code = codeRes.toString();
-        _jdtTestEnvironment.addSourceFile(srcFolderName, packageName1, testBeanGenericName, code);
+        _jdtTestEnvironment.addSourceFile(srcFolderName, packageName1,
+                testBeanGenericName, code);
 
-        _testBeanGenericType = _jdtTestEnvironment.getJavaProject().findType(packageName1+"."+testBeanGenericName); 
+        _testBeanGenericType = _jdtTestEnvironment.getJavaProject().findType(
+                packageName1 + "." + testBeanGenericName);
         assertNotNull(_testBeanGenericType);
 
         // load TestEnum1
         codeRes = new TestFileResource();
-        codeRes.load(TestsPlugin.getDefault().getBundle(), "/testfiles/TestEnum1.java.data");
+        codeRes.load(TestsPlugin.getDefault().getBundle(),
+                "/testfiles/TestEnum1.java.data");
         code = codeRes.toString();
-        _jdtTestEnvironment.addSourceFile(srcFolderName, packageName1, testEnumName1, code);
+        _jdtTestEnvironment.addSourceFile(srcFolderName, packageName1,
+                testEnumName1, code);
 
-        _testEnum1Type = _jdtTestEnvironment.getJavaProject().findType(packageName1+"."+testEnumName1); 
+        _testEnum1Type = _jdtTestEnvironment.getJavaProject().findType(
+                packageName1 + "." + testEnumName1);
         assertNotNull(_testEnum1Type);
         assertTrue(_testEnum1Type.isEnum());
 
+        final IClasspathEntry entry = _jdtTestEnvironment.addJarClasspathEntry(
+                TestsPlugin.getDefault().getBundle(),
+                "/testfiles/signatures.jar");
+        assertNotNull(entry);
+
+        _binaryType = _jdtTestEnvironment.getJavaProject().findType(
+                packageName1 + "." + "BinaryType");
+        assertNotNull(_binaryType);
+        // 7 methods plus 1 implicit constructor
+        assertEquals(7+1, _binaryType.getMethods().length);
+
         // 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();
+        // JDTBeanIntrospector beanIntrospector =
+        // new JDTBeanIntrospector(_testBean1Type);
+        //
+        // _properties = beanIntrospector.getProperties();
+        //
+        // beanIntrospector =
+        // new JDTBeanIntrospector(_testBeanSubclassType);
+        //
+        // _subClassProperties = beanIntrospector.getProperties();
 
-//        beanIntrospector = 
-//            new JDTBeanIntrospector(_testBeanGenericType);
+        // beanIntrospector =
+        // new JDTBeanIntrospector(_testBeanGenericType);
     }
 
-    protected void tearDown() throws Exception {
+    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)
+     * 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() 
+    // 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));
+        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));
+        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
-        final String typeSigWithErasure = TypeUtil.resolveTypeSignature(_testBean1Type, "QMap<QString;QString;>;", true);        
+        // in this case, the provided signature has type erasure, so the answer
+        // will different depending on typeErasure flag
+        final String typeSigWithErasure = TypeUtil.resolveTypeSignature(
+                _testBean1Type, "QMap<QString;QString;>;", true);
         assertEquals(TypeConstants.TYPE_MAP, typeSigWithErasure);
-        final String typeSigNoErasure = TypeUtil.resolveTypeSignature(_testBean1Type, "QMap<QString;QString;>;", false);
-        assertEquals("Ljava.util.Map<Ljava.lang.String;Ljava.lang.String;>;", typeSigNoErasure);
+        final String typeSigNoErasure = TypeUtil.resolveTypeSignature(
+                _testBean1Type, "QMap<QString;QString;>;", false);
+        assertEquals("Ljava.util.Map<Ljava.lang.String;Ljava.lang.String;>;",
+                typeSigNoErasure);
 
         // test resolution of type paramaters
-        IType mapType = TypeUtil.resolveType(_jdtTestEnvironment.getJavaProject(), "Ljava.util.Map;");
+        final IType mapType = TypeUtil.resolveType(_jdtTestEnvironment
+                .getJavaProject(), "Ljava.util.Map;");
         assertNotNull(mapType);
-        assertEquals(TypeConstants.TYPE_JAVAOBJECT, TypeUtil.resolveTypeSignature(mapType, "TV;", false));
-        
+        assertEquals(TypeConstants.TYPE_JAVAOBJECT, TypeUtil
+                .resolveTypeSignature(mapType, "TV;", false));
+
         // unfound signature
-        assertEquals("QSomeNotRealClass;"
-        		, TypeUtil.resolveTypeSignature(_testBean1Type, "QSomeNotRealClass;", false));
+        assertEquals("QSomeNotRealClass;", TypeUtil.resolveTypeSignature(
+                _testBean1Type, "QSomeNotRealClass;", false));
 
         // arrays
-        assertEquals("[I"
-        		, TypeUtil.resolveTypeSignature(_testBean1Type, "[I"));
-        
-        assertEquals("[Ljava.lang.String;"
-        		, TypeUtil.resolveTypeSignature(_testBean1Type, "[QString;"));
+        assertEquals("[I", TypeUtil.resolveTypeSignature(_testBean1Type, "[I"));
 
-        assertEquals("[Ljava.util.Map;"
-        		, TypeUtil.resolveTypeSignature(_testBean1Type, "[QMap;"));
+        assertEquals("[Ljava.lang.String;", TypeUtil.resolveTypeSignature(
+                _testBean1Type, "[QString;"));
 
-        assertEquals("[Ljava.util.Collection;"
-        		, TypeUtil.resolveTypeSignature(_testBean1Type, "[QCollection;"));
+        assertEquals("[Ljava.util.Map;", TypeUtil.resolveTypeSignature(
+                _testBean1Type, "[QMap;"));
+
+        assertEquals("[Ljava.util.Collection;", TypeUtil.resolveTypeSignature(
+                _testBean1Type, "[QCollection;"));
 
         // array of arrays
-        assertEquals("[[[Ljava.lang.String;"
-        		, TypeUtil.resolveTypeSignature(_testBean1Type, "[[[QString;"));
-        
-        // cover cases where wildcards and/or capture are used.  All should be equivalent to the case for
+        assertEquals("[[[Ljava.lang.String;", TypeUtil.resolveTypeSignature(
+                _testBean1Type, "[[[QString;"));
+
+        // cover cases where wildcards and/or capture are used. All should be
+        // equivalent to the case for
         // the same signature without wildcards and capture
 
         // with type erasure
@@ -186,134 +229,216 @@
         runWildcardAndCapture(typeSigNoErasure, false);
     }
 
-    private void runWildcardAndCapture(final String expected, boolean typeErasure)
+    private void runWildcardAndCapture(final String expected,
+            final boolean typeErasure)
     {
         // extends
-        assertEquals(expected, TypeUtil.resolveTypeSignature(_testBean1Type, "QMap<+QString;+QString;>;", typeErasure));
-        assertEquals(expected, TypeUtil.resolveTypeSignature(_testBean1Type, "QMap<+QString;QString;>;", typeErasure));
-        assertEquals(expected, TypeUtil.resolveTypeSignature(_testBean1Type, "QMap<QString;+QString;>;", typeErasure));
-            //super
-        assertEquals(expected, TypeUtil.resolveTypeSignature(_testBean1Type, "QMap<-QString;-QString;>;", typeErasure));
-        assertEquals(expected, TypeUtil.resolveTypeSignature(_testBean1Type, "QMap<-QString;QString;>;", typeErasure));
-        assertEquals(expected, TypeUtil.resolveTypeSignature(_testBean1Type, "QMap<QString;-QString;>;", typeErasure));
-            // star
+        assertEquals(expected, TypeUtil.resolveTypeSignature(_testBean1Type,
+                "QMap<+QString;+QString;>;", typeErasure));
+        assertEquals(expected, TypeUtil.resolveTypeSignature(_testBean1Type,
+                "QMap<+QString;QString;>;", typeErasure));
+        assertEquals(expected, TypeUtil.resolveTypeSignature(_testBean1Type,
+                "QMap<QString;+QString;>;", typeErasure));
+        // super
+        assertEquals(expected, TypeUtil.resolveTypeSignature(_testBean1Type,
+                "QMap<-QString;-QString;>;", typeErasure));
+        assertEquals(expected, TypeUtil.resolveTypeSignature(_testBean1Type,
+                "QMap<-QString;QString;>;", typeErasure));
+        assertEquals(expected, TypeUtil.resolveTypeSignature(_testBean1Type,
+                "QMap<QString;-QString;>;", typeErasure));
+        // star
         // this one is distinct because * are converted to Object
-        final String expected1 = "Ljava.util.Map" + (typeErasure ? ";" : "<Ljava.lang.Object;Ljava.lang.Object;>;"); 
-        assertEquals(expected1, TypeUtil.resolveTypeSignature(_testBean1Type, "QMap<**>;", typeErasure));
-        final String expected2 = "Ljava.util.Map" + (typeErasure ? ";" : "<Ljava.lang.Object;Ljava.lang.String;>;");
-        assertEquals(expected2, TypeUtil.resolveTypeSignature(_testBean1Type, "QMap<*QString;>;", typeErasure));
-        final String expected3 = "Ljava.util.Map" + (typeErasure ? ";" : "<Ljava.lang.String;Ljava.lang.Object;>;"); 
-        assertEquals(expected3, TypeUtil.resolveTypeSignature(_testBean1Type, "QMap<QString;*>;", typeErasure));
-            // capture extends
-        assertEquals(expected, TypeUtil.resolveTypeSignature(_testBean1Type, "QMap<!+QString;!+QString;>;", typeErasure));
-        assertEquals(expected, TypeUtil.resolveTypeSignature(_testBean1Type, "QMap<!+QString;QString;>;", typeErasure));
-        assertEquals(expected, TypeUtil.resolveTypeSignature(_testBean1Type, "QMap<QString;!+QString;>;", typeErasure));
-        
-        assertEquals("Ljava.lang.String;", TypeUtil.resolveTypeSignature(_testBean1Type, "!+QString;", typeErasure));
-        
-        // test regression on https://bugs.eclipse.org/bugs/show_bug.cgi?id=197506
-        assertEquals("Ljava.lang.Object;", TypeUtil.resolveTypeSignature(_testBean1Type, "*", typeErasure));
+        final String expected1 = "Ljava.util.Map"
+                + (typeErasure ? ";"
+                        : "<Ljava.lang.Object;Ljava.lang.Object;>;");
+        assertEquals(expected1, TypeUtil.resolveTypeSignature(_testBean1Type,
+                "QMap<**>;", typeErasure));
+        final String expected2 = "Ljava.util.Map"
+                + (typeErasure ? ";"
+                        : "<Ljava.lang.Object;Ljava.lang.String;>;");
+        assertEquals(expected2, TypeUtil.resolveTypeSignature(_testBean1Type,
+                "QMap<*QString;>;", typeErasure));
+        final String expected3 = "Ljava.util.Map"
+                + (typeErasure ? ";"
+                        : "<Ljava.lang.String;Ljava.lang.Object;>;");
+        assertEquals(expected3, TypeUtil.resolveTypeSignature(_testBean1Type,
+                "QMap<QString;*>;", typeErasure));
+        // capture extends
+        assertEquals(expected, TypeUtil.resolveTypeSignature(_testBean1Type,
+                "QMap<!+QString;!+QString;>;", typeErasure));
+        assertEquals(expected, TypeUtil.resolveTypeSignature(_testBean1Type,
+                "QMap<!+QString;QString;>;", typeErasure));
+        assertEquals(expected, TypeUtil.resolveTypeSignature(_testBean1Type,
+                "QMap<QString;!+QString;>;", typeErasure));
+
+        assertEquals("Ljava.lang.String;", TypeUtil.resolveTypeSignature(
+                _testBean1Type, "!+QString;", typeErasure));
+
+        // test regression on
+        // https://bugs.eclipse.org/bugs/show_bug.cgi?id=197506
+        assertEquals("Ljava.lang.Object;", TypeUtil.resolveTypeSignature(
+                _testBean1Type, "*", typeErasure));
     }
 
     public void testCanNeverBeEqual()
     {
-    	// one of the arguments is the enum base
-    	assertFalse(TypeUtil.canNeverBeEqual(TypeConstants.TYPE_ENUM_BASE, "Lcom.test.SomeEnum;"));
-    	assertFalse(TypeUtil.canNeverBeEqual("Lcom.test.SomeEnum;", TypeConstants.TYPE_ENUM_BASE));
-    	
-    	assertTrue(TypeUtil.canNeverBeEqual("Lcom.test.SomeEnum1;", "Lcom.test.SomeEnum2;"));
-    	assertFalse(TypeUtil.canNeverBeEqual("Lcom.test.SomeEnum1;", "Lcom.test.SomeEnum1;"));
+        // one of the arguments is the enum base
+        assertFalse(TypeUtil.canNeverBeEqual(TypeConstants.TYPE_ENUM_BASE,
+                "Lcom.test.SomeEnum;"));
+        assertFalse(TypeUtil.canNeverBeEqual("Lcom.test.SomeEnum;",
+                TypeConstants.TYPE_ENUM_BASE));
+
+        assertTrue(TypeUtil.canNeverBeEqual("Lcom.test.SomeEnum1;",
+                "Lcom.test.SomeEnum2;"));
+        assertFalse(TypeUtil.canNeverBeEqual("Lcom.test.SomeEnum1;",
+                "Lcom.test.SomeEnum1;"));
     }
-    
+
     public void testIsEnumsCompareCompatible()
     {
-    	// one of the arguments is the enum base
-    	assertTrue(TypeUtil.isEnumsCompareCompatible(TypeConstants.TYPE_ENUM_BASE, "Lcom.test.SomeEnum;"));
-    	assertTrue(TypeUtil.isEnumsCompareCompatible("Lcom.test.SomeEnum;", TypeConstants.TYPE_ENUM_BASE));
-    	
-    	assertFalse(TypeUtil.isEnumsCompareCompatible("Lcom.test.SomeEnum1;", "Lcom.test.SomeEnum2;"));
-    	assertTrue(TypeUtil.isEnumsCompareCompatible("Lcom.test.SomeEnum1;", "Lcom.test.SomeEnum1;"));
-    }
-    
-//    public void testResolveTypeSignatureITypeStringBoolean() {
-//        fail("Not yet implemented");
-//    }
-//
-    public void testGetSignature() 
-    {
-    	assertEquals("Lcom.test.TestBean1;",TypeUtil.getSignature(_testBean1Type));
+        // one of the arguments is the enum base
+        assertTrue(TypeUtil.isEnumsCompareCompatible(
+                TypeConstants.TYPE_ENUM_BASE, "Lcom.test.SomeEnum;"));
+        assertTrue(TypeUtil.isEnumsCompareCompatible("Lcom.test.SomeEnum;",
+                TypeConstants.TYPE_ENUM_BASE));
+
+        assertFalse(TypeUtil.isEnumsCompareCompatible("Lcom.test.SomeEnum1;",
+                "Lcom.test.SomeEnum2;"));
+        assertTrue(TypeUtil.isEnumsCompareCompatible("Lcom.test.SomeEnum1;",
+                "Lcom.test.SomeEnum1;"));
     }
 
-    public void testResolveMethodSignature()  throws Exception
+    // public void testResolveTypeSignatureITypeStringBoolean() {
+    // fail("Not yet implemented");
+    // }
+    //
+    public void testGetSignature()
     {
-        assertEquals("()Ljava.lang.String;"
-        		, TypeUtil.resolveMethodSignature(_testBean1Type, "()QString;"));
-        assertEquals("(Ljava.lang.String;)V"
-        		, TypeUtil.resolveMethodSignature(_testBean1Type, "(QString;)V"));
-        assertEquals("(Ljava.lang.String;Z)V"
-        		, TypeUtil.resolveMethodSignature(_testBean1Type, "(QString;Z)V"));
-        
+        assertEquals("Lcom.test.TestBean1;", TypeUtil
+                .getSignature(_testBean1Type));
+    }
+
+    public void testResolveMethodSignature() throws Exception
+    {
+        assertEquals("()Ljava.lang.String;", TypeUtil.resolveMethodSignature(
+                _testBean1Type, "()QString;"));
+        assertEquals("(Ljava.lang.String;)V", TypeUtil.resolveMethodSignature(
+                _testBean1Type, "(QString;)V"));
+        assertEquals("(Ljava.lang.String;Z)V", TypeUtil.resolveMethodSignature(
+                _testBean1Type, "(QString;Z)V"));
+
         IMethod method = _testBean1Type.getMethod("getStringProp1", null);
-        assertEquals("()Ljava.lang.String;"
-        		, TypeUtil.resolveMethodSignature(_testBean1Type, method.getSignature()));
-        		
-        method = _testBean1Type.getMethod("setStringProperty2", new String[] {"I"});
-        assertEquals("(I)V"
-        		, TypeUtil.resolveMethodSignature(_testBean1Type, method.getSignature()));
+        assertEquals("()Ljava.lang.String;", TypeUtil.resolveMethodSignature(
+                _testBean1Type, method.getSignature()));
+
+        method = _testBean1Type.getMethod("setStringProperty2", new String[]
+        { "I" });
+        assertEquals("(I)V", TypeUtil.resolveMethodSignature(_testBean1Type,
+                method.getSignature()));
+
+        // test binary methods
+        // the framework returns method signatures using "/" instead of "."
+        // separators when the IType is BinaryType
+
+        // sanity: _binaryType must a JDT BinaryType impl for this test to
+        // be valid
+        assertTrue(_binaryType.isBinary());
+        assertEquals("()Ljava.lang.String;", TypeUtil.resolveMethodSignature(
+                _binaryType, _binaryType.getMethod("getStringProperty", null)
+                        .getSignature()));
+
+        assertEquals("(Ljava.lang.String;)V", TypeUtil.resolveMethodSignature(
+                _binaryType, _binaryType.getMethod("setStringProperty",
+                        new String[]
+                        { "Ljava.lang.String;" }).getSignature()));
+
+        assertEquals("()I", TypeUtil.resolveMethodSignature(_binaryType,
+                _binaryType.getMethod("getIntegerProperty", null)
+                        .getSignature()));
+
+        assertEquals("(I)V", TypeUtil.resolveMethodSignature(_binaryType,
+                _binaryType.getMethod("setIntegerProperty", new String[]
+                { "I" }).getSignature()));
+
+        assertEquals("()Lcom.test.BinaryPropertyAndMethodType;", TypeUtil
+                .resolveMethodSignature(_binaryType, _binaryType.getMethod(
+                        "getUserDefined", null).getSignature()));
+
+        assertEquals("(Lcom.test.BinaryPropertyAndMethodType;)V", TypeUtil
+                .resolveMethodSignature(_binaryType, _binaryType.getMethod(
+                        "setUserDefined", new String[]
+                        { "Lcom.test.BinaryPropertyAndMethodType;" })
+                        .getSignature()));
+
+        assertEquals(
+                "(Ljava.lang.String;Lcom.test.BinaryPropertyAndMethodType;I)I",
+                TypeUtil
+                        .resolveMethodSignature(
+                                _binaryType,
+                                _binaryType
+                                        .getMethod(
+                                                "methodWithMultipleArgs",
+                                                new String[]
+                                                {
+                                                        "Ljava.lang.String;",
+                                                        "Lcom.test.BinaryPropertyAndMethodType;",
+                                                        "I" }).getSignature()));
     }
 
-//    public void testGetFullyQualifiedName() {
-//        fail("Not yet implemented");
-//    }
-//
-    public void testResolveTypeIJavaProjectString() 
+    // public void testGetFullyQualifiedName() {
+    // fail("Not yet implemented");
+    // }
+    //
+    public void testResolveTypeIJavaProjectString()
     {
-        assertNotNull(TypeUtil.resolveType(_jdtTestEnvironment.getJavaProject()
-        					, "Ljava.lang.String;"));
-        assertEquals(_testBean1Type
-        			,TypeUtil.resolveType(_jdtTestEnvironment.getJavaProject()
-        									, "Lcom.test.TestBean1;"));
+        assertNotNull(TypeUtil.resolveType(
+                _jdtTestEnvironment.getJavaProject(), "Ljava.lang.String;"));
+        assertEquals(_testBean1Type, TypeUtil.resolveType(_jdtTestEnvironment
+                .getJavaProject(), "Lcom.test.TestBean1;"));
     }
 
     public void testMatchTypeParameterToArgument() throws Exception
     {
-        IType mapType = TypeUtil.resolveType(_jdtTestEnvironment.getJavaProject(), "Ljava.util.Map;");
+        final IType mapType = TypeUtil.resolveType(_jdtTestEnvironment
+                .getJavaProject(), "Ljava.util.Map;");
         assertNotNull(mapType);
-        
-        List<String> args = new ArrayList<String>();
+
+        final List<String> args = new ArrayList<String>();
         args.add("Ljava.lang.String;");
         args.add("Lcom.test.TestBean1;");
-        
+
         // TestBean1 is the "V" in Map<K,V>
-        assertEquals("Lcom.test.TestBean1;"
-        		     , TypeUtil.matchTypeParameterToArgument(mapType, "TV;", args));
-        
+        assertEquals("Lcom.test.TestBean1;", TypeUtil
+                .matchTypeParameterToArgument(mapType, "TV;", args));
+
         // there is no "Q" type arg
         assertNull(TypeUtil.matchTypeParameterToArgument(mapType, "TQ;", args));
         // there is no "garbonzo" type arg
-        assertNull(TypeUtil.matchTypeParameterToArgument(mapType, "Tgarbonzo;", args));
+        assertNull(TypeUtil.matchTypeParameterToArgument(mapType, "Tgarbonzo;",
+                args));
     }
 
     public void testIsEnumMember() throws Exception
     {
-    	assertTrue(TypeUtil.isEnumMember(_testEnum1Type, "red"));
-    	assertTrue(TypeUtil.isEnumMember(_testEnum1Type, "blue"));
-    	assertTrue(TypeUtil.isEnumMember(_testEnum1Type, "green"));
-    	assertTrue(TypeUtil.isEnumMember(_testEnum1Type, "yellow"));
-    	assertTrue(TypeUtil.isEnumMember(_testEnum1Type, "purple"));
-    	assertTrue(TypeUtil.isEnumMember(_testEnum1Type, "orange"));
-    	
-    	assertFalse(TypeUtil.isEnumMember(_testEnum1Type, "mauve"));
-    	assertFalse(TypeUtil.isEnumMember(_testEnum1Type, "pink"));
-    	
-    	// test the enum base type.. all things may be members of it
-    	IType type = _jdtTestEnvironment.getJavaProject().findType("java.lang.Enum");
-    	assertNotNull(type);
-    	//assertTrue(type.isEnum());
-    	assertTrue(TypeUtil.isEnumMember(type, "red"));
-    	assertTrue(TypeUtil.isEnumMember(type, "pink"));
-    	assertTrue(TypeUtil.isEnumMember(type, "anything"));
-    	assertTrue(TypeUtil.isEnumMember(type, "deadbeef"));
-    	
+        assertTrue(TypeUtil.isEnumMember(_testEnum1Type, "red"));
+        assertTrue(TypeUtil.isEnumMember(_testEnum1Type, "blue"));
+        assertTrue(TypeUtil.isEnumMember(_testEnum1Type, "green"));
+        assertTrue(TypeUtil.isEnumMember(_testEnum1Type, "yellow"));
+        assertTrue(TypeUtil.isEnumMember(_testEnum1Type, "purple"));
+        assertTrue(TypeUtil.isEnumMember(_testEnum1Type, "orange"));
+
+        assertFalse(TypeUtil.isEnumMember(_testEnum1Type, "mauve"));
+        assertFalse(TypeUtil.isEnumMember(_testEnum1Type, "pink"));
+
+        // test the enum base type.. all things may be members of it
+        final IType type = _jdtTestEnvironment.getJavaProject().findType(
+                "java.lang.Enum");
+        assertNotNull(type);
+        // assertTrue(type.isEnum());
+        assertTrue(TypeUtil.isEnumMember(type, "red"));
+        assertTrue(TypeUtil.isEnumMember(type, "pink"));
+        assertTrue(TypeUtil.isEnumMember(type, "anything"));
+        assertTrue(TypeUtil.isEnumMember(type, "deadbeef"));
+
     }
 }
diff --git a/jsf/tests/org.eclipse.jst.jsf.core.tests/testfiles/signatures.jar b/jsf/tests/org.eclipse.jst.jsf.core.tests/testfiles/signatures.jar
new file mode 100644
index 0000000..c3465e5
--- /dev/null
+++ b/jsf/tests/org.eclipse.jst.jsf.core.tests/testfiles/signatures.jar
Binary files differ