Basic coverage testing for JSF EL 1.1 validation.
diff --git a/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/.classpath b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/.classpath
new file mode 100644
index 0000000..751c8f2
--- /dev/null
+++ b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/.classpath
@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
+	<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
+	<classpathentry kind="output" path="bin"/>
+</classpath>
diff --git a/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/.project b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/.project
new file mode 100644
index 0000000..850fbc1
--- /dev/null
+++ b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/.project
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>org.eclipse.jst.jsf.validation.el.tests</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.pde.ManifestBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.pde.SchemaBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.pde.PluginNature</nature>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+	</natures>
+</projectDescription>
diff --git a/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/META-INF/MANIFEST.MF b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/META-INF/MANIFEST.MF
new file mode 100644
index 0000000..779308c
--- /dev/null
+++ b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/META-INF/MANIFEST.MF
@@ -0,0 +1,27 @@
+Manifest-Version: 1.0
+Bundle-ManifestVersion: 2
+Bundle-Name: Tests Plug-in
+Bundle-SymbolicName: org.eclipse.jst.jsf.validation.el.tests
+Bundle-Version: 1.0.0
+Bundle-Activator: org.eclipse.jst.jsf.validation.el.tests.ELValidationTestPlugin
+Bundle-Localization: plugin
+Require-Bundle: org.eclipse.ui,
+ org.eclipse.core.runtime,
+ org.junit,
+ org.eclipse.jst.jsf.core.tests,
+ org.eclipse.jst.jsf.test.util,
+ org.eclipse.core.resources,
+ org.eclipse.jst.jsf.core,
+ org.eclipse.jst.jsf.facesconfig,
+ org.eclipse.wst.sse.core,
+ org.eclipse.jst.jsf.context,
+ org.eclipse.jst.jsf.context.resolver,
+ org.eclipse.jst.jsf.context.resolver.structureddocument,
+ org.eclipse.jst.jsf.context.structureddocument,
+ org.eclipse.wst.xml.core,
+ org.eclipse.jst.jsp.core,
+ org.eclipse.jst.jsf.validation.el,
+ org.eclipse.wst.validation,
+ org.eclipse.wst.internet.cache,
+ org.eclipse.wst.internet.proxy
+Eclipse-LazyStart: true
diff --git a/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/build.properties b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/build.properties
new file mode 100644
index 0000000..34d2e4d
--- /dev/null
+++ b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/build.properties
@@ -0,0 +1,4 @@
+source.. = src/
+output.. = bin/
+bin.includes = META-INF/,\
+               .
diff --git a/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/src/org/eclipse/jst/jsf/validation/el/tests/AllTests.java b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/src/org/eclipse/jst/jsf/validation/el/tests/AllTests.java
new file mode 100644
index 0000000..1c5c609
--- /dev/null
+++ b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/src/org/eclipse/jst/jsf/validation/el/tests/AllTests.java
@@ -0,0 +1,90 @@
+package org.eclipse.jst.jsf.validation.el.tests;
+/*******************************************************************************
+ * Copyright (c) 2005 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:
+ *    Oracle - initial API and implementation
+ *******************************************************************************/ 
+
+import org.eclipse.jst.jsf.validation.el.tests.jsp.ArithmeticAddTestCase;
+import org.eclipse.jst.jsf.validation.el.tests.jsp.ArithmeticDivideTestCase;
+import org.eclipse.jst.jsf.validation.el.tests.jsp.ArithmeticMinusTestCase;
+import org.eclipse.jst.jsf.validation.el.tests.jsp.ArithmeticModuloTestCase;
+import org.eclipse.jst.jsf.validation.el.tests.jsp.ArithmeticMultiplyTestCase;
+import org.eclipse.jst.jsf.validation.el.tests.jsp.AssignabilityTestCase;
+import org.eclipse.jst.jsf.validation.el.tests.jsp.BadSyntaxTestCase;
+import org.eclipse.jst.jsf.validation.el.tests.jsp.BeanPropertyResolutionTestCase;
+import org.eclipse.jst.jsf.validation.el.tests.jsp.BeanVariableResolutionTestCase;
+import org.eclipse.jst.jsf.validation.el.tests.jsp.BuiltInSymbolsTestCase;
+import org.eclipse.jst.jsf.validation.el.tests.jsp.GreaterThanEqTestCase;
+import org.eclipse.jst.jsf.validation.el.tests.jsp.GreaterThanTestCase;
+import org.eclipse.jst.jsf.validation.el.tests.jsp.JSPFunctionsTestCase;
+import org.eclipse.jst.jsf.validation.el.tests.jsp.LessThanEqTestCase;
+import org.eclipse.jst.jsf.validation.el.tests.jsp.LessThanTestCase;
+import org.eclipse.jst.jsf.validation.el.tests.jsp.LoadBundleResolutionTestCase;
+import org.eclipse.jst.jsf.validation.el.tests.jsp.LogicalAndTestCase;
+import org.eclipse.jst.jsf.validation.el.tests.jsp.LogicalEqualsTestCase;
+import org.eclipse.jst.jsf.validation.el.tests.jsp.LogicalNotEqualsTestCase;
+import org.eclipse.jst.jsf.validation.el.tests.jsp.LogicalNotTestCase;
+import org.eclipse.jst.jsf.validation.el.tests.jsp.LogicalOrTestCase;
+import org.eclipse.jst.jsf.validation.el.tests.jsp.MethodBindingTestCase;
+import org.eclipse.jst.jsf.validation.el.tests.jsp.UnaryEmptyTestCase;
+import org.eclipse.jst.jsf.validation.el.tests.jsp.UnaryMinusTestCase;
+
+import junit.framework.Test;
+import junit.framework.TestSuite;
+
+
+/**
+ * The full test suite for core.tests
+ * @author cbateman
+ *
+ */
+public class AllTests {
+
+    /**
+     * @return the test suite
+     */
+    public static Test suite() 
+    {
+        TestSuite suite = new TestSuite("Test for org.eclipse.jst.jsf.validation.el.tests");
+        //$JUnit-BEGIN$
+        suite.addTestSuite(BadSyntaxTestCase.class);
+        suite.addTestSuite(BeanPropertyResolutionTestCase.class);
+        suite.addTestSuite(BeanVariableResolutionTestCase.class);
+        suite.addTestSuite(LoadBundleResolutionTestCase.class);
+        suite.addTestSuite(BuiltInSymbolsTestCase.class);
+        suite.addTestSuite(AssignabilityTestCase.class);
+        suite.addTestSuite(JSPFunctionsTestCase.class);
+        suite.addTestSuite(MethodBindingTestCase.class);
+        
+        suite.addTestSuite(ArithmeticAddTestCase.class);
+        suite.addTestSuite(ArithmeticDivideTestCase.class);
+        suite.addTestSuite(ArithmeticMinusTestCase.class);
+        suite.addTestSuite(ArithmeticModuloTestCase.class);
+        suite.addTestSuite(ArithmeticMultiplyTestCase.class);
+
+        suite.addTestSuite(GreaterThanEqTestCase.class);
+        suite.addTestSuite(GreaterThanTestCase.class);
+        suite.addTestSuite(LessThanEqTestCase.class);
+        suite.addTestSuite(LessThanTestCase.class);
+
+        suite.addTestSuite(LogicalAndTestCase.class);
+        suite.addTestSuite(LogicalOrTestCase.class);
+        suite.addTestSuite(LogicalEqualsTestCase.class);
+        suite.addTestSuite(LogicalNotEqualsTestCase.class);
+        suite.addTestSuite(LogicalNotTestCase.class);
+
+        suite.addTestSuite(UnaryEmptyTestCase.class);
+        suite.addTestSuite(UnaryMinusTestCase.class);
+
+        //$JUnit-END$
+        return suite;
+    }
+    
+}
+
diff --git a/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/src/org/eclipse/jst/jsf/validation/el/tests/ELValidationTestPlugin.java b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/src/org/eclipse/jst/jsf/validation/el/tests/ELValidationTestPlugin.java
new file mode 100644
index 0000000..a1c91d3
--- /dev/null
+++ b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/src/org/eclipse/jst/jsf/validation/el/tests/ELValidationTestPlugin.java
@@ -0,0 +1,50 @@
+package org.eclipse.jst.jsf.validation.el.tests;
+
+import org.eclipse.ui.plugin.AbstractUIPlugin;
+import org.osgi.framework.BundleContext;
+
+/**
+ * The activator class controls the plug-in life cycle
+ */
+public class ELValidationTestPlugin extends AbstractUIPlugin {
+
+	// The plug-in ID
+	public static final String PLUGIN_ID = "org.eclipse.jst.jsf.validation.el.tests";
+
+	// The shared instance
+	private static ELValidationTestPlugin plugin;
+	
+	/**
+	 * The constructor
+	 */
+	public ELValidationTestPlugin() {
+		plugin = this;
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * @see org.eclipse.ui.plugin.AbstractUIPlugin#start(org.osgi.framework.BundleContext)
+	 */
+	public void start(BundleContext context) throws Exception {
+		super.start(context);
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * @see org.eclipse.ui.plugin.AbstractUIPlugin#stop(org.osgi.framework.BundleContext)
+	 */
+	public void stop(BundleContext context) throws Exception {
+		plugin = null;
+		super.stop(context);
+	}
+
+	/**
+	 * Returns the shared instance
+	 *
+	 * @return the shared instance
+	 */
+	public static ELValidationTestPlugin getDefault() {
+		return plugin;
+	}
+
+}
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
new file mode 100644
index 0000000..e2f7c81
--- /dev/null
+++ b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/src/org/eclipse/jst/jsf/validation/el/tests/base/BaseTestCase.java
@@ -0,0 +1,430 @@
+package org.eclipse.jst.jsf.validation.el.tests.base;
+
+import java.io.ByteArrayInputStream;
+import java.lang.reflect.InvocationTargetException;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import junit.framework.TestCase;
+
+import org.eclipse.core.resources.IFile;
+import org.eclipse.core.resources.IFolder;
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.jdt.core.IJavaProject;
+import org.eclipse.jdt.core.IPackageFragment;
+import org.eclipse.jdt.core.IPackageFragmentRoot;
+import org.eclipse.jdt.core.IType;
+import org.eclipse.jdt.core.JavaModelException;
+import org.eclipse.jface.preference.IPreferenceStore;
+import org.eclipse.jst.jsf.context.resolver.structureddocument.internal.ITextRegionContextResolver;
+import org.eclipse.jst.jsf.context.resolver.structureddocument.internal.provisional.IStructuredDocumentContextResolverFactory;
+import org.eclipse.jst.jsf.context.structureddocument.internal.provisional.IStructuredDocumentContext;
+import org.eclipse.jst.jsf.context.structureddocument.internal.provisional.IStructuredDocumentContextFactory;
+import org.eclipse.jst.jsf.core.internal.provisional.jsfappconfig.JSFAppConfigManager;
+import org.eclipse.jst.jsf.core.tests.util.JSFFacetedTestEnvironment;
+import org.eclipse.jst.jsf.facesconfig.emf.ManagedBeanType;
+import org.eclipse.jst.jsf.test.util.JDTTestEnvironment;
+import org.eclipse.jst.jsf.test.util.TestFileResource;
+import org.eclipse.jst.jsf.test.util.WebProjectTestEnvironment;
+import org.eclipse.jst.jsf.validation.el.tests.ELValidationTestPlugin;
+import org.eclipse.jst.jsf.validation.internal.el.ELExpressionValidator;
+import org.eclipse.jst.jsf.validation.internal.el.diagnostics.IELLocalizedMessage;
+import org.eclipse.wst.internet.cache.internal.CacheMessages;
+import org.eclipse.wst.internet.internal.proxy.InternetPlugin;
+import org.eclipse.wst.sse.core.internal.provisional.text.IStructuredDocument;
+import org.eclipse.wst.validation.internal.ConfigurationManager;
+import org.eclipse.wst.validation.internal.GlobalConfiguration;
+import org.eclipse.wst.validation.internal.provisional.core.IMessage;
+
+public class BaseTestCase extends TestCase 
+{
+	protected WebProjectTestEnvironment  _testEnv;
+	protected JDTTestEnvironment         _jdtTestEnv;
+    
+	protected void setUp() throws Exception    
+	{
+		super.setUp();
+
+        setValidationEnabled(false);
+        
+        // setup local proxy
+        System.setProperty(CacheMessages.WTP_NO_USER_INTERACTION_SYSTEM_PROP, "true");
+        InternetPlugin plugin = InternetPlugin.getInstance();
+        IPreferenceStore prefStore = plugin.getPreferenceStore();
+        prefStore.setValue( InternetPlugin.PREFERENCE_PROXYCHECKED, true);
+        prefStore.setValue( InternetPlugin.PREFERENCE_SOCKSCHECKED, false );
+        prefStore.setValue("http.proxySet", true);
+        prefStore.setValue(InternetPlugin.PREFERENCE_HOSTNAME, "www-proxy.uk.oracle.com");
+        prefStore.setValue(InternetPlugin.PREFERENCE_PORT, "80");
+        plugin.updateProxyProperties();
+        
+        _testEnv = new WebProjectTestEnvironment("ELValidationTest_"+this.getClass().getName()+"_"+getName());
+        _testEnv.createProject();
+        assertNotNull(_testEnv);       
+        assertNotNull(_testEnv.getTestProject());
+        assertTrue(_testEnv.getTestProject().isAccessible());
+
+        JSFFacetedTestEnvironment jsfFacedEnv = new JSFFacetedTestEnvironment(_testEnv);
+        jsfFacedEnv.initialize();
+
+        _testEnv.loadResourceInWebRoot(ELValidationTestPlugin.getDefault().getBundle(),
+                                      "/testdata/web/faces-config.xml.data", 
+                                      "/WEB-INF/faces-config.xml");
+
+        _jdtTestEnv = new JDTTestEnvironment(_testEnv);
+
+        TestFileResource resource = new TestFileResource();
+        resource.load(ELValidationTestPlugin.getDefault().getBundle(), 
+                      "/testdata/classes/MyBean.java.data");
+        _jdtTestEnv.addSourceFile("src", "beans", "MyBean", resource.toString());
+
+        resource = new TestFileResource();
+        resource.load(ELValidationTestPlugin.getDefault().getBundle(), 
+                      "/testdata/classes/MapBean.java.data");
+        _jdtTestEnv.addSourceFile("src", "beans", "MapBean", resource.toString());
+
+        resource = new TestFileResource();
+        resource.load(ELValidationTestPlugin.getDefault().getBundle(), 
+                      "/testdata/classes/MyBeanSettable.java.data");
+        _jdtTestEnv.addSourceFile("src", "beans", "MyBeanSettable", resource.toString());
+
+        resource = new TestFileResource();
+        resource.load(ELValidationTestPlugin.getDefault().getBundle(), 
+                      "/testdata/classes/MyBeanSubClass.java.data");
+        _jdtTestEnv.addSourceFile("src", "beans", "MyBeanSubClass", resource.toString());
+
+        resource = new TestFileResource();
+        resource.load(ELValidationTestPlugin.getDefault().getBundle(), 
+                      "/testdata/classes/Bundle.properties.data");
+        _jdtTestEnv.addResourceFile("src", new ByteArrayInputStream(resource.toBytes()), 
+                      "beans", "Bundle.properties");
+	}
+    
+    protected void tearDown() throws Exception
+    {
+        _testEnv.getTestProject().close(null);
+    }
+    
+    public void testSanity()
+    {
+        final IJavaProject javaProject = _jdtTestEnv.getJavaProject(); 
+        assertNotNull(javaProject);
+        
+        try
+        {
+            IType type = javaProject.findType("beans.MyBean");
+            assertNotNull(type);
+            
+            type = javaProject.findType("beans.MapBean");
+            assertNotNull(type);
+
+            type = javaProject.findType("beans.MyBeanSettable");
+            assertNotNull(type);
+
+            type = javaProject.findType("beans.MyBeanSubClass");
+            assertNotNull(type);
+            
+            IPackageFragmentRoot srcRoot = _jdtTestEnv.getPackageFragmentRoot("src");
+            assertTrue(srcRoot.exists());
+            IPackageFragment frag = srcRoot.getPackageFragment("beans");
+            assertTrue(frag.exists());
+            IFolder res = (IFolder) frag.getResource();
+            IFile bundleFile = res.getFile("Bundle.properties");
+            assertTrue(bundleFile.exists());
+            
+            JSFAppConfigManager  cfgManager = 
+                JSFAppConfigManager.getInstance(_jdtTestEnv.getProjectEnvironment().getTestProject());
+            assertNotNull(cfgManager);
+            
+            List mbeans = cfgManager.getManagedBeans();
+            Map  nameTest = new HashMap();
+            
+            for (final Iterator it = mbeans.iterator(); it.hasNext();)
+            {
+                ManagedBeanType  mbean = (ManagedBeanType) it.next();
+                nameTest.put(mbean.getManagedBeanName().getTextContent(), mbean);
+            }
+
+            assertTrue(nameTest.containsKey("myBean"));
+            assertTrue(nameTest.containsKey("mapBean"));
+            assertTrue(nameTest.containsKey("myBeanSettable"));
+            assertTrue(nameTest.containsKey("myBeanSubClass"));
+        }
+        catch(JavaModelException jme)
+        {
+            assertTrue("JDT error: "+jme.getLocalizedMessage(), false);
+        }
+        catch (CoreException ce)
+        {
+            assertTrue("Problem loading bundle: "+ce.getLocalizedMessage(), false);
+        }
+    }
+    
+    protected String getELText(IStructuredDocument document, int docPos)
+    {
+        final IStructuredDocumentContext context = 
+            IStructuredDocumentContextFactory.INSTANCE.getContext(document, docPos);
+        final ITextRegionContextResolver resolver =
+            IStructuredDocumentContextResolverFactory.INSTANCE.getTextRegionResolver(context);
+        return resolver.getRegionText();
+    }
+    
+    protected ELExpressionValidator createELValidator(IStructuredDocument document, int docPos, IFile file)
+    {
+        final String elText = getELText(document, docPos);
+        final IStructuredDocumentContext context = 
+            IStructuredDocumentContextFactory.INSTANCE.getContext(document, docPos);
+        return new ELExpressionValidator(context, elText, file);
+    }
+    
+    /**
+     * Uses assertSyntaxProblems with max severity of error.
+     * 
+     * @param document
+     * @param docPos
+     * @param file
+     * @param expectedProblems
+     * @return
+     */
+    protected List assertSyntaxError(IStructuredDocument document, 
+            int docPos, 
+            IFile file, 
+            int expectedProblems)
+    {
+        return assertSyntaxProblems(document, docPos, file, expectedProblems, IMessage.HIGH_SEVERITY/* "high" is Warning for some reason*/);
+    }
+
+    
+    /**
+     * Uses assertSyntaxProblems with max severity of warning.
+     * 
+     * @param document
+     * @param docPos
+     * @param file
+     * @param expectedProblems
+     * @return the list of syntax problems
+     */
+    protected List assertSyntaxWarning(IStructuredDocument document, 
+                                          int docPos, 
+                                          IFile file, 
+                                          int expectedProblems)
+    {
+        return assertSyntaxProblems(document, docPos, file, expectedProblems, IMessage.NORMAL_SEVERITY/* "normal" is Warning for some reason*/);
+    }
+    
+    /**
+     * Checks the el expression in document at docPos in file. Asserts
+     * that there exactly the number of expectedProblems expected and that
+     * the highest error severity is expectedMaxSeverity.  Returns the list
+     * of syntax errors
+     * 
+     * @param document
+     * @param docPos
+     * @param file
+     * @param expectedProblems
+     * @param expectedMaxSeverity
+     * @return the (possibly empty) list of problems
+     */
+    protected List assertSyntaxProblems(IStructuredDocument document, 
+                                          int docPos, 
+                                          IFile file, 
+                                          int expectedProblems,
+                                          int expectedMaxSeverity)
+    {
+        final ELExpressionValidator validator = 
+            createELValidator(document, docPos, file);
+        validator.validateXMLNode();
+        
+        final List problems = validator.getSyntaxProblems();
+        assertEquals(expectedProblems, problems.size());
+        int worstSeverity = 0;
+        
+        for (final Iterator it = problems.iterator(); it.hasNext();)
+        {
+            IMessage message = (IMessage) it.next();
+            
+            // for some reason, the number values are lower for higher severity
+            // constants
+            worstSeverity = maxSeverity(worstSeverity, message.getSeverity());
+        }
+    
+        
+        assertEquals(expectedMaxSeverity, worstSeverity);
+        
+        return problems;
+    }
+
+    /**
+     * Asserts that the provided expression generates no problem diagnostics 
+     * whatsever and that the resolved type is as expected
+     * 
+     * @param document
+     * @param docPos
+     * @param file
+     * @param expectedSignature
+     */
+    protected void assertNoError(IStructuredDocument document, int docPos, IFile file, String expectedSignature)
+    {
+        assertNoError(document, docPos, file, expectedSignature, -1);
+    }
+    
+    /**
+     * Asserts that the provided expression generates no problem diagnostics 
+     * whatsever and that the resolved type is as expected and checks assignability
+     * if value positive, non-zero.
+     * 
+     * @param document
+     * @param docPos
+     * @param file
+     * @param expectedSignature
+     */
+    protected void assertNoError(IStructuredDocument document, int docPos, IFile file, String expectedSignature, int assignability)
+    {
+        ELExpressionValidator validator = createELValidator(document, docPos, file);
+        validator.validateXMLNode();
+        assertEquals(0, validator.getSyntaxProblems().size());
+        assertEquals(0, validator.getSemanticValidator().getMessages().size());
+
+        if (expectedSignature != null)
+        {
+            assertNotNull(validator.getExpressionType());
+            assertEquals(expectedSignature, validator.getExpressionType().getSignatures()[0]);
+        }
+        
+        if (assignability >= 0)
+        {
+            assertEquals(assignability, validator.getExpressionType().getAssignmentTypeMask());
+        }
+    }
+    
+    /**
+     * Asserts that the provided expression generates one or more problem 
+     * diagnostics of which the most severe is of ERROR severity and that
+     * the total number expected is returned 
+     * Asserts also that no syntax errors are present.
+     * 
+     * @param document
+     * @param docPos
+     * @param file
+     * @param expectedSignature
+     * @return the list of semantic warnings
+     */
+    protected List assertSemanticError(IStructuredDocument document, int docPos, IFile file, String expectedSignature, int expectedProblems)
+    {
+        return assertSemanticProblems(document, docPos, file, expectedSignature, expectedProblems, IMessage.HIGH_SEVERITY/* "high" is Error for some reason*/);
+    }
+    
+    /**
+     * Asserts that the provided expression generates one or more problem 
+     * diagnostics of which the most severe is of WARNING severity and that
+     * the total number expected is returned 
+     * Asserts also that no syntax errors are present.
+     * 
+     * @param document
+     * @param docPos
+     * @param file
+     * @param expectedSignature
+     * @return the list of semantic warnings
+     */
+    protected List assertSemanticWarning(IStructuredDocument document, int docPos, IFile file, String expectedSignature, int expectedProblems)
+    {
+        return assertSemanticProblems(document, docPos, file, expectedSignature, expectedProblems, IMessage.NORMAL_SEVERITY/* "normal" is Warning for some reason*/);
+    }
+    
+    protected List assertSemanticProblems(IStructuredDocument document, 
+                                          int docPos, 
+                                          IFile file, 
+                                          String expectedSignature, 
+                                          int expectedProblems,
+                                          int expectedMaxSeverity)
+    {
+        final ELExpressionValidator validator = 
+                createELValidator(document, docPos, file);
+        validator.validateXMLNode();
+        
+        if (expectedSignature != null
+                && validator.getExpressionType() != null)
+        {
+            assertEquals(expectedSignature, validator.getExpressionType().getSignatures()[0]);
+        }
+        
+        assertEquals(0, validator.getSyntaxProblems().size());
+        final List problems = validator.getSemanticValidator().getMessages();
+        assertEquals(expectedProblems, problems.size());
+        int worstSeverity = 0;
+        
+        for (final Iterator it = problems.iterator(); it.hasNext();)
+        {
+            IMessage message = (IMessage) it.next();
+            
+            // for some reason, the number values are lower for higher severity
+            // constants
+            worstSeverity = maxSeverity(worstSeverity, message.getSeverity());
+        }
+
+        
+        assertEquals(expectedMaxSeverity, worstSeverity);
+        
+        return problems;
+    }
+    
+    protected void assertContainsProblem(List problems, int code)
+    {
+        assertContainsProblem(problems, code, -1);
+    }
+    
+    protected void assertContainsProblem(List problems, int code, int curPos)
+    {
+        Set  probsFound = new HashSet();
+        
+        for (final Iterator it = problems.iterator(); it.hasNext();)
+        {
+            Object probObj = it.next();
+            
+            if (probObj instanceof IELLocalizedMessage)
+            {
+                final IELLocalizedMessage localizedMsg = (IELLocalizedMessage) probObj;
+                probsFound.add(Integer.valueOf(localizedMsg.getErrorCode()));
+                if (localizedMsg.getErrorCode() == code)
+                {
+                    // found the required code, so exit without throwing
+                    // any error assertions
+                    return;
+                }
+            }
+        }
+        // if we reach this point then we have not found the asserted
+        // error code
+        assertTrue("Expected find error code matching "+code+" found "+probsFound.toString(), false);
+    }
+    
+    
+    protected void setValidationEnabled(boolean isEnabled) throws InvocationTargetException
+    {
+        final GlobalConfiguration config = new GlobalConfiguration(ConfigurationManager.getManager().getGlobalConfiguration());
+        config.setDisableAllValidation(!isEnabled);
+        config.passivate();
+        config.store();
+    }
+    
+    private static int maxSeverity(int sev1, int sev2)
+    {
+        if (sev1 == 0)
+        {
+            return sev2;
+        }
+        else if (sev2 == 0)
+        {
+            return sev1;
+        }
+        else
+        {
+            // if both are non-0, then the most sever is the lowest value
+            return Math.min(sev1, sev2);
+        }
+    }
+}
\ No newline at end of file
diff --git a/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/src/org/eclipse/jst/jsf/validation/el/tests/base/SingleJSPTestCase.java b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/src/org/eclipse/jst/jsf/validation/el/tests/base/SingleJSPTestCase.java
new file mode 100644
index 0000000..9fc9933
--- /dev/null
+++ b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/src/org/eclipse/jst/jsf/validation/el/tests/base/SingleJSPTestCase.java
@@ -0,0 +1,108 @@
+package org.eclipse.jst.jsf.validation.el.tests.base;
+
+import java.util.List;
+
+import org.eclipse.core.resources.IFile;
+import org.eclipse.jst.jsf.validation.el.tests.ELValidationTestPlugin;
+import org.eclipse.wst.sse.core.StructuredModelManager;
+import org.eclipse.wst.sse.core.internal.provisional.IStructuredModel;
+import org.eclipse.wst.sse.core.internal.provisional.text.IStructuredDocument;
+
+/**
+ * Test case for a group of tests in a single JSP file
+ * @author cbateman
+ *
+ */
+public abstract class SingleJSPTestCase extends BaseTestCase
+{
+    protected String                  _srcFileName;
+    protected String                  _destFileName;
+    
+    protected IFile                   _testJSP;
+    protected IStructuredModel        _structuredModel;
+    protected IStructuredDocument     _structuredDocument;
+
+    protected void setUp() throws Exception 
+    {
+        super.setUp();
+
+        _testJSP = (IFile) _testEnv.loadResourceInWebRoot
+                            (ELValidationTestPlugin.getDefault().getBundle(),
+                               _srcFileName, _destFileName);
+        
+        _structuredModel = StructuredModelManager.getModelManager().getModelForRead(_testJSP);
+        _structuredDocument = _structuredModel.getStructuredDocument();
+    }
+
+    protected void tearDown() throws Exception 
+    {
+        super.tearDown();
+        
+        if (_structuredModel != null)
+        {
+            _structuredModel.releaseFromRead();
+        }
+    }
+
+    /**
+     * Same as BaseTestCase.assertNoError but automatically uses _testJSP for the file
+     * and _structuredDocument.
+     * 
+     * @param document
+     * @param docPos
+     * @param expectedSignature
+     */
+    protected void assertNoError(int docPos, String expectedSignature) {
+        super.assertNoError(_structuredDocument, docPos, _testJSP, expectedSignature);
+    }
+    
+    protected void assertNoError(int docPos, String expectedSignature, int assignability)
+    {
+        super.assertNoError(_structuredDocument, docPos, _testJSP, expectedSignature, assignability);
+        
+    }
+
+    protected List assertSyntaxError(int docPos, int expectedProblems)
+    {
+        return super.assertSyntaxError(_structuredDocument, docPos, _testJSP, 
+                expectedProblems);
+    }
+
+    protected List assertSyntaxWarning(int docPos, int expectedProblems)
+    {
+        return super.assertSyntaxWarning(_structuredDocument, docPos, _testJSP, 
+                expectedProblems);
+    }
+    
+    /**
+     * Same as BaseTestCase.assertSemanticError but automatically uses _testJSP for the file
+     * 
+     * @param document
+     * @param docPos
+     * @param expectedSignature
+     * @param expectedProblems
+     * @return the list of errors found
+     */
+    protected List assertSemanticError(int docPos, String expectedSignature, int expectedProblems) {
+        return super.assertSemanticError(_structuredDocument, docPos, _testJSP, expectedSignature,
+                expectedProblems);
+    }
+
+    /**
+     * Same as BaseTestCase.assertSemanticWarning but automatically uses _testJSP for the file
+     * and _structuredDocument for the document
+     * @param document
+     * @param docPos
+     * @param expectedSignature
+     * @param expectedProblems
+     * @return the list of errors found
+     */
+    protected List assertSemanticWarning(int docPos, String expectedSignature, int expectedProblems) {
+        return super.assertSemanticWarning(_structuredDocument, docPos, _testJSP, expectedSignature,
+                expectedProblems);
+    }
+    
+    public abstract void testNoErrorExprs();
+    public abstract void testWarningExprs();
+    public abstract void testErrorExprs();
+}
diff --git a/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/src/org/eclipse/jst/jsf/validation/el/tests/jsp/ArithmeticAddTestCase.java b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/src/org/eclipse/jst/jsf/validation/el/tests/jsp/ArithmeticAddTestCase.java
new file mode 100644
index 0000000..acecbb3
--- /dev/null
+++ b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/src/org/eclipse/jst/jsf/validation/el/tests/jsp/ArithmeticAddTestCase.java
@@ -0,0 +1,106 @@
+package org.eclipse.jst.jsf.validation.el.tests.jsp;
+
+
+import java.util.List;
+
+import org.eclipse.jdt.core.Signature;
+import org.eclipse.jst.jsf.core.internal.types.TypeConstants;
+import org.eclipse.jst.jsf.validation.el.tests.base.SingleJSPTestCase;
+import org.eclipse.jst.jsf.validation.internal.el.diagnostics.DiagnosticFactory;
+
+/**
+ * Test suite for testing validation of arithmetic add
+ * 
+ * @author cbateman
+ *
+ */
+public class ArithmeticAddTestCase extends SingleJSPTestCase 
+{
+    protected void setUp() throws Exception 
+    {
+        _srcFileName = "/testdata/jsps/arithmeticAdd.jsp.data";
+        _destFileName = "/arithmeticAdd.jsp";
+
+        super.setUp();
+    }
+
+    public void testSanity()
+    {
+        super.testSanity();
+        
+        assertEquals("myBean.integerProperty  + 3", getELText(_structuredDocument,900));
+        assertEquals("myBean.stringProperty + 3", getELText(_structuredDocument,961));
+        assertEquals("myBean.integerProperty + myBean.integerProperty", getELText(_structuredDocument,1020));
+        assertEquals("myBean.bigIntegerProperty + 4", getELText(_structuredDocument,1101));
+        assertEquals("myBean.bigIntegerProperty + 5.5", getELText(_structuredDocument,1164));
+        assertEquals("myBean.bigDoubleProperty + 5.5", getELText(_structuredDocument,1229));
+        assertEquals("myBean.doubleProperty + 5", getELText(_structuredDocument,1293));
+
+        assertEquals("5 + 3", getELText(_structuredDocument,1381));
+        assertEquals("5.5 + 4", getELText(_structuredDocument,1417));
+        assertEquals("5.5 + null", getELText(_structuredDocument,1455));
+        assertEquals("'5' + '4'", getELText(_structuredDocument,1499));
+        assertEquals("null + null", getELText(_structuredDocument,1542));
+        assertEquals("5.5 + 3.5", getELText(_structuredDocument,1588));
+
+        assertEquals("5 + true", getELText(_structuredDocument,1651));
+        assertEquals("myBean.integerProperty + myBean.booleanProperty", getELText(_structuredDocument,1690));
+        assertEquals("myBean.stringArrayProperty + myBean.booleanProperty", getELText(_structuredDocument,1768));
+        assertEquals("myBean.integerProperty + true ", getELText(_structuredDocument,1853));
+        assertEquals("'a' + 'b'", getELText(_structuredDocument,1917));
+        assertEquals("myBean.bigIntegerProperty + true", getELText(_structuredDocument,1960));
+    }
+    
+    public void testNoErrorExprs()
+    {
+        assertNoError(900, Signature.SIG_LONG);
+        assertNoError(961, Signature.SIG_LONG);
+        assertNoError(1020, Signature.SIG_LONG);
+        assertNoError(1101, TypeConstants.TYPE_BIG_INTEGER);
+        assertNoError(1164, TypeConstants.TYPE_BIG_DOUBLE);
+        assertNoError(1229, TypeConstants.TYPE_BIG_DOUBLE);
+        assertNoError(1293, Signature.SIG_DOUBLE);
+    }
+
+    public void testWarningExprs()
+    {
+        List list = assertSemanticWarning(1381, Signature.SIG_LONG, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_CONSTANT_EXPRESSION_ALWAYS_EVAL_SAME_ID);
+
+        list = assertSemanticWarning(1417, Signature.SIG_DOUBLE,  1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_CONSTANT_EXPRESSION_ALWAYS_EVAL_SAME_ID);
+        
+        list = assertSemanticWarning(1455, Signature.SIG_DOUBLE, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_CONSTANT_EXPRESSION_ALWAYS_EVAL_SAME_ID);
+        
+        list = assertSemanticWarning(1499, Signature.SIG_LONG,  1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_CONSTANT_EXPRESSION_ALWAYS_EVAL_SAME_ID);
+        
+        list = assertSemanticWarning(1542, Signature.SIG_LONG,  1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_BOTH_OPERANDS_NULL_ID);
+        
+        list = assertSemanticWarning(1588, Signature.SIG_DOUBLE, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_CONSTANT_EXPRESSION_ALWAYS_EVAL_SAME_ID);
+    }
+    
+    public void testErrorExprs()
+    {
+        List list = assertSemanticError(1651, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_COULD_NOT_MAKE_NUMERIC_COERCION_ID);
+        
+        list = assertSemanticError(1690, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_COULD_NOT_MAKE_NUMERIC_COERCION_ID);
+
+        list = assertSemanticError(1768, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_COULD_NOT_MAKE_NUMERIC_COERCION_ID);
+       
+        list = assertSemanticError(1853, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_COULD_NOT_MAKE_NUMERIC_COERCION_ID);
+        
+        list = assertSemanticError(1917, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_COULD_NOT_COERCE_LITERALS_TO_NUMBERS_ID);
+
+        list = assertSemanticError(1960, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_COULD_NOT_MAKE_NUMERIC_COERCION_ID);
+    }
+}
\ No newline at end of file
diff --git a/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/src/org/eclipse/jst/jsf/validation/el/tests/jsp/ArithmeticDivideTestCase.java b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/src/org/eclipse/jst/jsf/validation/el/tests/jsp/ArithmeticDivideTestCase.java
new file mode 100644
index 0000000..b8df74b
--- /dev/null
+++ b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/src/org/eclipse/jst/jsf/validation/el/tests/jsp/ArithmeticDivideTestCase.java
@@ -0,0 +1,161 @@
+package org.eclipse.jst.jsf.validation.el.tests.jsp;
+
+import java.util.List;
+
+import org.eclipse.jdt.core.Signature;
+import org.eclipse.jst.jsf.core.internal.types.TypeConstants;
+import org.eclipse.jst.jsf.validation.el.tests.base.SingleJSPTestCase;
+import org.eclipse.jst.jsf.validation.internal.el.diagnostics.DiagnosticFactory;
+
+
+public class ArithmeticDivideTestCase extends SingleJSPTestCase 
+{
+    protected void setUp() throws Exception 
+    {
+        _srcFileName = "/testdata/jsps/arithmeticDivide.jsp.data";
+        _destFileName = "/WEB-INF/arithmeticDivide.jsp";
+        super.setUp();
+    }
+
+    public void testSanity()
+    {
+        super.testSanity();
+        
+        assertEquals("myBean.integerProperty / 3", getELText(_structuredDocument,852));
+        assertEquals("myBean.integerProperty div 3", getELText(_structuredDocument,912));
+        assertEquals("myBean.stringProperty / 3", getELText(_structuredDocument,974));
+        assertEquals("myBean.stringProperty div 3", getELText(_structuredDocument,1033));
+        assertEquals("myBean.integerProperty / myBean.integerProperty", getELText(_structuredDocument,1094));
+        assertEquals("myBean.integerProperty div myBean.integerProperty", getELText(_structuredDocument,1175));
+        assertEquals("myBean.bigIntegerProperty / 4", getELText(_structuredDocument,1258));
+        assertEquals("myBean.bigIntegerProperty / 5.5", getELText(_structuredDocument,1321));
+        assertEquals("myBean.bigDoubleProperty / 5.5", getELText(_structuredDocument,1386));
+        assertEquals("myBean.doubleProperty / 5", getELText(_structuredDocument,1450));
+
+        assertEquals("5 / 3", getELText(_structuredDocument,1542));
+        assertEquals("5 div 3", getELText(_structuredDocument,1578));
+        assertEquals("5.5 / 4", getELText(_structuredDocument,1616));
+        assertEquals("5.5 div 4", getELText(_structuredDocument,1654));
+        assertEquals("'5' / '4'", getELText(_structuredDocument,1697));
+        assertEquals("'5' div '4'", getELText(_structuredDocument,1740));
+        assertEquals("null / null", getELText(_structuredDocument,1785));
+        assertEquals("null div null", getELText(_structuredDocument,1830));
+        assertEquals("5.5 / 3.5", getELText(_structuredDocument,1877));
+
+        assertEquals("5 / true", getELText(_structuredDocument,1945));
+        assertEquals("5 div true", getELText(_structuredDocument,1984));
+        assertEquals("myBean.integerProperty / myBean.booleanProperty", getELText(_structuredDocument,2025));
+        assertEquals("myBean.integerProperty div myBean.booleanProperty", getELText(_structuredDocument,2103));
+        assertEquals("myBean.stringArrayProperty / myBean.booleanProperty", getELText(_structuredDocument,2183));
+        assertEquals("myBean.integerProperty div myBean.booleanProperty", getELText(_structuredDocument,2265));
+        assertEquals("myBean.integerProperty / true ", getELText(_structuredDocument,2348));
+        assertEquals("myBean.integerProperty div true ", getELText(_structuredDocument,2412));
+        assertEquals("'a' / 'b'", getELText(_structuredDocument,2478));
+        assertEquals("'a' div 'b'", getELText(_structuredDocument,2521));
+        assertEquals("5.5 / null", getELText(_structuredDocument,2563));
+        assertEquals("5.5 div null", getELText(_structuredDocument,2604));
+        assertEquals("5/0", getELText(_structuredDocument,2647));
+        assertEquals("5 div 0", getELText(_structuredDocument,2681));
+        assertEquals("myBean.bigIntegerProperty + true", getELText(_structuredDocument,2719));
+        assertEquals("myBean.bigDoubleProperty / null", getELText(_structuredDocument,2782));
+        assertEquals("myBean.bigDoubleProperty div true", getELText(_structuredDocument,2844));
+    }
+    
+    public void testNoErrorExprs()
+    {
+        assertNoError(852, Signature.SIG_DOUBLE);
+        assertNoError(912, Signature.SIG_DOUBLE);
+        assertNoError(974, Signature.SIG_DOUBLE);
+        assertNoError(1033, Signature.SIG_DOUBLE);
+        assertNoError(1094, Signature.SIG_DOUBLE);
+        assertNoError(1175, Signature.SIG_DOUBLE);
+        assertNoError(1258, TypeConstants.TYPE_BIG_DOUBLE);
+        assertNoError(1321, TypeConstants.TYPE_BIG_DOUBLE);
+        assertNoError(1386, TypeConstants.TYPE_BIG_DOUBLE);
+        assertNoError(1450, Signature.SIG_DOUBLE);
+    }
+    
+    public void testWarningExprs()
+    {
+        List list = assertSemanticWarning(1542, Signature.SIG_DOUBLE, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_CONSTANT_EXPRESSION_ALWAYS_EVAL_SAME_ID);
+
+        list = assertSemanticWarning(1578, Signature.SIG_DOUBLE, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_CONSTANT_EXPRESSION_ALWAYS_EVAL_SAME_ID);
+
+        list = assertSemanticWarning(1616, Signature.SIG_DOUBLE, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_CONSTANT_EXPRESSION_ALWAYS_EVAL_SAME_ID);
+
+        list = assertSemanticWarning(1654, Signature.SIG_DOUBLE, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_CONSTANT_EXPRESSION_ALWAYS_EVAL_SAME_ID);
+
+        list = assertSemanticWarning(1697, Signature.SIG_DOUBLE, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_CONSTANT_EXPRESSION_ALWAYS_EVAL_SAME_ID);
+
+        list = assertSemanticWarning(1740, Signature.SIG_DOUBLE, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_CONSTANT_EXPRESSION_ALWAYS_EVAL_SAME_ID);
+
+        list = assertSemanticWarning(1785, Signature.SIG_LONG, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_BOTH_OPERANDS_NULL_ID);
+
+        list = assertSemanticWarning(1830, Signature.SIG_LONG, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_BOTH_OPERANDS_NULL_ID);
+        
+        list = assertSemanticWarning(1877, Signature.SIG_DOUBLE, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_CONSTANT_EXPRESSION_ALWAYS_EVAL_SAME_ID);
+    }
+    
+    public void testErrorExprs()
+    {
+        List list = assertSemanticError(1945, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_COULD_NOT_MAKE_NUMERIC_COERCION_ID);
+
+        list = assertSemanticError(1984, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_COULD_NOT_MAKE_NUMERIC_COERCION_ID);
+
+        list = assertSemanticError(2025, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_COULD_NOT_MAKE_NUMERIC_COERCION_ID);
+
+        list = assertSemanticError(2103, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_COULD_NOT_MAKE_NUMERIC_COERCION_ID);
+
+        list = assertSemanticError(2183, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_COULD_NOT_MAKE_NUMERIC_COERCION_ID);
+
+        list = assertSemanticError(2265, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_COULD_NOT_MAKE_NUMERIC_COERCION_ID);
+
+        list = assertSemanticError(2348, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_COULD_NOT_MAKE_NUMERIC_COERCION_ID);
+
+        list = assertSemanticError(2412, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_COULD_NOT_MAKE_NUMERIC_COERCION_ID);
+
+        list = assertSemanticError(2478, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_COULD_NOT_MAKE_NUMERIC_COERCION_ID);
+
+        list = assertSemanticError(2521, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_COULD_NOT_MAKE_NUMERIC_COERCION_ID);
+
+        list = assertSemanticError(2563, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_POSSIBLE_DIVISION_BY_ZERO_ID);
+
+        list = assertSemanticError(2604, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_POSSIBLE_DIVISION_BY_ZERO_ID);
+
+        list = assertSemanticError(2647, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_POSSIBLE_DIVISION_BY_ZERO_ID);
+
+        list = assertSemanticError(2681, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_POSSIBLE_DIVISION_BY_ZERO_ID);
+        
+        list = assertSemanticError(2719, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_COULD_NOT_MAKE_NUMERIC_COERCION_ID);
+
+        list = assertSemanticError(2782, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_POSSIBLE_DIVISION_BY_ZERO_ID);
+
+        list = assertSemanticError(2844, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_COULD_NOT_MAKE_NUMERIC_COERCION_ID);
+    }
+}
diff --git a/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/src/org/eclipse/jst/jsf/validation/el/tests/jsp/ArithmeticMinusTestCase.java b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/src/org/eclipse/jst/jsf/validation/el/tests/jsp/ArithmeticMinusTestCase.java
new file mode 100644
index 0000000..da340e0
--- /dev/null
+++ b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/src/org/eclipse/jst/jsf/validation/el/tests/jsp/ArithmeticMinusTestCase.java
@@ -0,0 +1,98 @@
+package org.eclipse.jst.jsf.validation.el.tests.jsp;
+
+import java.util.List;
+
+import org.eclipse.jdt.core.Signature;
+import org.eclipse.jst.jsf.core.internal.types.TypeConstants;
+import org.eclipse.jst.jsf.validation.el.tests.base.SingleJSPTestCase;
+import org.eclipse.jst.jsf.validation.internal.el.diagnostics.DiagnosticFactory;
+
+public class ArithmeticMinusTestCase extends SingleJSPTestCase
+{
+    protected void setUp() throws Exception 
+    {
+        _srcFileName = "/testdata/jsps/arithmeticMinus.jsp.data";
+        _destFileName = "/WEB-INF/arithmeticMinus.jsp";
+        super.setUp();
+    }
+
+    public void testSanity()
+    {
+        super.testSanity();
+        
+        assertEquals("myBean.integerProperty - 3", getELText(_structuredDocument,852));
+        assertEquals("myBean.stringProperty - 3", getELText(_structuredDocument,912));
+        assertEquals("myBean.integerProperty - myBean.integerProperty", getELText(_structuredDocument,971));
+        assertEquals("myBean.bigIntegerProperty - 4", getELText(_structuredDocument,1052));
+        assertEquals("myBean.bigIntegerProperty - 5.5", getELText(_structuredDocument,1115));
+        assertEquals("myBean.bigDoubleProperty - 5.5", getELText(_structuredDocument,1180));
+        assertEquals("myBean.doubleProperty - 5", getELText(_structuredDocument,1244));
+
+        assertEquals("5 - 3", getELText(_structuredDocument,1336));
+        assertEquals("5.5 - 4", getELText(_structuredDocument,1372));
+        assertEquals("5.5 - null", getELText(_structuredDocument,1410));
+        assertEquals("'5' - '4'", getELText(_structuredDocument,1454));
+        assertEquals("null - null", getELText(_structuredDocument,1497));
+        assertEquals("5.5 - 3.5", getELText(_structuredDocument,1543));
+
+        assertEquals("5 - true", getELText(_structuredDocument,1606));
+        assertEquals("myBean.integerProperty - myBean.booleanProperty", getELText(_structuredDocument,1645));
+        assertEquals("myBean.stringArrayProperty - myBean.booleanProperty", getELText(_structuredDocument,1723));
+        assertEquals("myBean.integerProperty - true ", getELText(_structuredDocument,1808));
+        assertEquals("'a' - 'b'", getELText(_structuredDocument,1872));
+        assertEquals("myBean.bigIntegerProperty - true", getELText(_structuredDocument,1915));
+    }
+    
+    public void testNoErrorExprs()
+    {
+        assertNoError(852, Signature.SIG_LONG);
+        assertNoError(912, Signature.SIG_LONG);
+        assertNoError(971, Signature.SIG_LONG);
+        assertNoError(1052, TypeConstants.TYPE_BIG_INTEGER);
+        assertNoError(1115, TypeConstants.TYPE_BIG_DOUBLE);
+        assertNoError(1180, TypeConstants.TYPE_BIG_DOUBLE);
+        assertNoError(1244, Signature.SIG_DOUBLE);
+    }
+    
+    public void testWarningExprs()
+    {
+        List list = assertSemanticWarning(1336, Signature.SIG_LONG, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_CONSTANT_EXPRESSION_ALWAYS_EVAL_SAME_ID);
+
+        list = assertSemanticWarning(1372, Signature.SIG_DOUBLE, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_CONSTANT_EXPRESSION_ALWAYS_EVAL_SAME_ID);
+
+        list = assertSemanticWarning(1410, Signature.SIG_DOUBLE, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_CONSTANT_EXPRESSION_ALWAYS_EVAL_SAME_ID);
+
+        list = assertSemanticWarning(1454, Signature.SIG_LONG, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_CONSTANT_EXPRESSION_ALWAYS_EVAL_SAME_ID);
+
+        list = assertSemanticWarning(1497, Signature.SIG_LONG, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_BOTH_OPERANDS_NULL_ID);
+        
+        list = assertSemanticWarning(1543, Signature.SIG_DOUBLE, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_CONSTANT_EXPRESSION_ALWAYS_EVAL_SAME_ID);
+    }
+    
+    public void testErrorExprs()
+    {
+        List list = assertSemanticError(1606, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_COULD_NOT_MAKE_NUMERIC_COERCION_ID);
+
+        list = assertSemanticError(1645, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_COULD_NOT_MAKE_NUMERIC_COERCION_ID);
+
+        list = assertSemanticError(1723, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_COULD_NOT_MAKE_NUMERIC_COERCION_ID);
+
+        list = assertSemanticError(1808, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_COULD_NOT_MAKE_NUMERIC_COERCION_ID);
+
+        list = assertSemanticError(1872, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_COULD_NOT_COERCE_LITERALS_TO_NUMBERS_ID);
+        
+        list = assertSemanticError(1915, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_COULD_NOT_MAKE_NUMERIC_COERCION_ID);
+    }
+}
diff --git a/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/src/org/eclipse/jst/jsf/validation/el/tests/jsp/ArithmeticModuloTestCase.java b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/src/org/eclipse/jst/jsf/validation/el/tests/jsp/ArithmeticModuloTestCase.java
new file mode 100644
index 0000000..31e9317
--- /dev/null
+++ b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/src/org/eclipse/jst/jsf/validation/el/tests/jsp/ArithmeticModuloTestCase.java
@@ -0,0 +1,154 @@
+package org.eclipse.jst.jsf.validation.el.tests.jsp;
+
+import java.util.List;
+
+import org.eclipse.jdt.core.Signature;
+import org.eclipse.jst.jsf.core.internal.types.TypeConstants;
+import org.eclipse.jst.jsf.validation.el.tests.base.SingleJSPTestCase;
+import org.eclipse.jst.jsf.validation.internal.el.diagnostics.DiagnosticFactory;
+
+public class ArithmeticModuloTestCase extends SingleJSPTestCase 
+{
+    protected void setUp() throws Exception 
+    {
+        _srcFileName = "/testdata/jsps/arithmeticModulo.jsp.data";
+        _destFileName = "/WEB-INF/arithmeticModulo.jsp";
+        super.setUp();
+    }
+
+    public void testSanity()
+    {
+        super.testSanity();
+        
+        assertEquals("myBean.integerProperty % 3", getELText(_structuredDocument,852));
+        assertEquals("myBean.integerProperty mod 3", getELText(_structuredDocument,912));
+        assertEquals("myBean.stringProperty % 3", getELText(_structuredDocument,974));
+        assertEquals("myBean.stringProperty mod 3", getELText(_structuredDocument,1033));
+        assertEquals("myBean.integerProperty % myBean.integerProperty", getELText(_structuredDocument,1094));
+        assertEquals("myBean.integerProperty mod myBean.integerProperty", getELText(_structuredDocument,1175));
+        assertEquals("myBean.bigIntegerProperty mod 4", getELText(_structuredDocument,1258));
+        assertEquals("myBean.doubleProperty mod 4", getELText(_structuredDocument,1323));
+        assertEquals("myBean.doubleProperty mod 5.43", getELText(_structuredDocument,1383));
+
+        assertEquals("5 % 3", getELText(_structuredDocument,1472));
+        assertEquals("5 mod 3", getELText(_structuredDocument,1508));
+        assertEquals("5.5 % 4 ", getELText(_structuredDocument,1546));
+        assertEquals("5.5 mod 4 ", getELText(_structuredDocument,1585));
+        assertEquals("'5' % '4'", getELText(_structuredDocument,1629));
+        assertEquals("'5' mod '4'", getELText(_structuredDocument,1672));
+        assertEquals("null % null", getELText(_structuredDocument,1717));
+        assertEquals("null mod null", getELText(_structuredDocument,1762));
+
+        assertEquals("5 % true", getELText(_structuredDocument,1829));
+        assertEquals("5 mod true", getELText(_structuredDocument,1868));
+        assertEquals("myBean.stringArrayProperty % myBean.booleanProperty", getELText(_structuredDocument,1909));
+        assertEquals("myBean.stringArrayProperty mod myBean.booleanProperty", getELText(_structuredDocument,1991));
+        assertEquals("myBean.integerProperty % true ", getELText(_structuredDocument,2078));
+        assertEquals("myBean.integerProperty mod true ", getELText(_structuredDocument,2142));
+        assertEquals("'a' % 'b'", getELText(_structuredDocument,2208));
+        assertEquals("'a' mod 'b'", getELText(_structuredDocument,2251));
+        assertEquals("5.5 % null", getELText(_structuredDocument,2293));
+        assertEquals("5.5 mod null", getELText(_structuredDocument,2334));
+        assertEquals("5%0", getELText(_structuredDocument,2377));
+        assertEquals("5 mod 0", getELText(_structuredDocument,2411));
+        assertEquals("myBean.integerProperty % myBean.booleanProperty", getELText(_structuredDocument,2449));
+        assertEquals("myBean.integerProperty mod myBean.booleanProperty", getELText(_structuredDocument,2527));
+        assertEquals("myBean.bigIntegerProperty % myBean.booleanProperty", getELText(_structuredDocument,2607));
+    }
+    
+    public void testNoErrorExprs()
+    {
+        assertNoError(852,Signature.SIG_LONG);
+        assertNoError(912, Signature.SIG_LONG);
+        assertNoError(974, Signature.SIG_LONG);
+        assertNoError(1033, Signature.SIG_LONG);
+        assertNoError(1094, Signature.SIG_LONG);
+        assertNoError(1175, Signature.SIG_LONG);
+        assertNoError(1258, TypeConstants.TYPE_BIG_INTEGER);
+        assertNoError(1323, Signature.SIG_DOUBLE);
+        assertNoError(1383, Signature.SIG_DOUBLE);
+
+    }
+    
+    public void testWarningExprs()
+    {
+        List list = assertSemanticWarning(1472, Signature.SIG_LONG, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_CONSTANT_EXPRESSION_ALWAYS_EVAL_SAME_ID);
+
+        list = assertSemanticWarning(1508, Signature.SIG_LONG, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_CONSTANT_EXPRESSION_ALWAYS_EVAL_SAME_ID);
+
+        list = assertSemanticWarning(1546, Signature.SIG_DOUBLE, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_CONSTANT_EXPRESSION_ALWAYS_EVAL_SAME_ID);
+
+        list = assertSemanticWarning(1585, Signature.SIG_DOUBLE, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_CONSTANT_EXPRESSION_ALWAYS_EVAL_SAME_ID);
+
+        list = assertSemanticWarning(1629, Signature.SIG_LONG, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_CONSTANT_EXPRESSION_ALWAYS_EVAL_SAME_ID);
+        
+        list = assertSemanticWarning(1672, Signature.SIG_LONG, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_CONSTANT_EXPRESSION_ALWAYS_EVAL_SAME_ID);
+        
+        list = assertSemanticWarning(1717, Signature.SIG_LONG, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_BOTH_OPERANDS_NULL_ID);
+        
+        list = assertSemanticWarning(1762, Signature.SIG_LONG, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_BOTH_OPERANDS_NULL_ID);
+        
+    }
+
+    public void testErrorExprs()
+    {
+        List list = assertSemanticError(1829, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_COULD_NOT_MAKE_NUMERIC_COERCION_ID);
+        
+        list = assertSemanticError(1868, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_COULD_NOT_MAKE_NUMERIC_COERCION_ID);
+        
+        list = assertSemanticError(1909, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_COULD_NOT_MAKE_NUMERIC_COERCION_ID);
+
+        list = assertSemanticError(1991, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_COULD_NOT_MAKE_NUMERIC_COERCION_ID);
+
+        list = assertSemanticError(2078, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_COULD_NOT_MAKE_NUMERIC_COERCION_ID);
+
+        list = assertSemanticError(2142, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_COULD_NOT_MAKE_NUMERIC_COERCION_ID);
+
+        list = assertSemanticError(2208, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_COULD_NOT_MAKE_NUMERIC_COERCION_ID);
+
+        list = assertSemanticError(2251, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_COULD_NOT_MAKE_NUMERIC_COERCION_ID);
+
+        list = assertSemanticError(2293, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_POSSIBLE_DIVISION_BY_ZERO_ID);
+
+        list = assertSemanticError(2334, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_POSSIBLE_DIVISION_BY_ZERO_ID);
+
+        list = assertSemanticError(2377, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_POSSIBLE_DIVISION_BY_ZERO_ID);
+
+        list = assertSemanticError(2411, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_POSSIBLE_DIVISION_BY_ZERO_ID);
+        
+        list = assertSemanticError(2449, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_COULD_NOT_MAKE_NUMERIC_COERCION_ID);
+
+        list = assertSemanticError(2527, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_COULD_NOT_MAKE_NUMERIC_COERCION_ID);
+
+        list = assertSemanticError(2607, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_COULD_NOT_MAKE_NUMERIC_COERCION_ID);
+
+        list = assertSemanticError(2688, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_POSSIBLE_DIVISION_BY_ZERO_ID);
+
+        list = assertSemanticError(2752, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_COULD_NOT_MAKE_NUMERIC_COERCION_ID);
+    }
+}
diff --git a/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/src/org/eclipse/jst/jsf/validation/el/tests/jsp/ArithmeticMultiplyTestCase.java b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/src/org/eclipse/jst/jsf/validation/el/tests/jsp/ArithmeticMultiplyTestCase.java
new file mode 100644
index 0000000..33a4cc8
--- /dev/null
+++ b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/src/org/eclipse/jst/jsf/validation/el/tests/jsp/ArithmeticMultiplyTestCase.java
@@ -0,0 +1,98 @@
+package org.eclipse.jst.jsf.validation.el.tests.jsp;
+
+import java.util.List;
+
+import org.eclipse.jdt.core.Signature;
+import org.eclipse.jst.jsf.core.internal.types.TypeConstants;
+import org.eclipse.jst.jsf.validation.el.tests.base.SingleJSPTestCase;
+import org.eclipse.jst.jsf.validation.internal.el.diagnostics.DiagnosticFactory;
+
+public class ArithmeticMultiplyTestCase extends SingleJSPTestCase 
+{
+    protected void setUp() throws Exception 
+    {
+        _srcFileName = "/testdata/jsps/arithmeticMultiply.jsp.data";
+        _destFileName = "/WEB-INF/arithmeticMultiply.jsp";
+        super.setUp();
+    }
+
+    public void testSanity()
+    {
+        super.testSanity();
+        
+        assertEquals("myBean.integerProperty * 3", getELText(_structuredDocument,852));
+        assertEquals("myBean.stringProperty * 3", getELText(_structuredDocument,912));
+        assertEquals("myBean.integerProperty * myBean.integerProperty", getELText(_structuredDocument,971));
+        assertEquals("myBean.bigIntegerProperty * 4", getELText(_structuredDocument,1052));
+        assertEquals("myBean.bigIntegerProperty * 5.5", getELText(_structuredDocument,1115));
+        assertEquals("myBean.bigDoubleProperty * 5.5", getELText(_structuredDocument,1180));
+        assertEquals("myBean.doubleProperty * 5", getELText(_structuredDocument,1244));
+        
+        assertEquals("5 * 3", getELText(_structuredDocument,1336));
+        assertEquals("5.5 * 4", getELText(_structuredDocument,1372));
+        assertEquals("5.5 * null", getELText(_structuredDocument,1410));
+        assertEquals("'5' * '4'", getELText(_structuredDocument,1454));
+        assertEquals("null * null", getELText(_structuredDocument,1497));
+        assertEquals("5.5 * 3.5", getELText(_structuredDocument,1543));
+
+        assertEquals("5 * true", getELText(_structuredDocument,1609));
+        assertEquals("myBean.integerProperty * myBean.booleanProperty", getELText(_structuredDocument,1648));
+        assertEquals("myBean.stringArrayProperty * myBean.booleanProperty", getELText(_structuredDocument,1726));
+        assertEquals("myBean.integerProperty * true ", getELText(_structuredDocument,1811));
+        assertEquals("'a' * 'b'", getELText(_structuredDocument,1875));
+        assertEquals("myBean.bigIntegerProperty * true", getELText(_structuredDocument,1918));
+    }
+    
+    public void testNoErrorExprs()
+    {
+        assertNoError(852,Signature.SIG_LONG);
+        assertNoError(912,Signature.SIG_LONG);
+        assertNoError(971,Signature.SIG_LONG);
+        assertNoError(1052, TypeConstants.TYPE_BIG_INTEGER);
+        assertNoError(1115, TypeConstants.TYPE_BIG_DOUBLE);
+        assertNoError(1180, TypeConstants.TYPE_BIG_DOUBLE);
+        assertNoError(1244, Signature.SIG_DOUBLE);
+    }
+    
+    public void testWarningExprs()
+    {
+        List list = assertSemanticWarning(1336, Signature.SIG_LONG, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_CONSTANT_EXPRESSION_ALWAYS_EVAL_SAME_ID);
+        
+        list = assertSemanticWarning(1372, Signature.SIG_DOUBLE, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_CONSTANT_EXPRESSION_ALWAYS_EVAL_SAME_ID);
+
+        list = assertSemanticWarning(1410, Signature.SIG_DOUBLE, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_CONSTANT_EXPRESSION_ALWAYS_EVAL_SAME_ID);
+
+        list = assertSemanticWarning(1454, Signature.SIG_LONG, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_CONSTANT_EXPRESSION_ALWAYS_EVAL_SAME_ID);
+
+        list = assertSemanticWarning(1497, Signature.SIG_LONG, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_BOTH_OPERANDS_NULL_ID);
+        
+        list = assertSemanticWarning(1543, Signature.SIG_DOUBLE, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_CONSTANT_EXPRESSION_ALWAYS_EVAL_SAME_ID);
+    }
+    
+    public void testErrorExprs()
+    {
+        List list = assertSemanticError(1609, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_COULD_NOT_MAKE_NUMERIC_COERCION_ID);
+
+        list = assertSemanticError(1648, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_COULD_NOT_MAKE_NUMERIC_COERCION_ID);
+
+        list = assertSemanticError(1726, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_COULD_NOT_MAKE_NUMERIC_COERCION_ID);
+        
+        list = assertSemanticError(1811, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_COULD_NOT_MAKE_NUMERIC_COERCION_ID);
+
+        list = assertSemanticError(1875, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_COULD_NOT_COERCE_LITERALS_TO_NUMBERS_ID);
+        
+        list = assertSemanticError(1918, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_COULD_NOT_MAKE_NUMERIC_COERCION_ID);
+    }
+}
diff --git a/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/src/org/eclipse/jst/jsf/validation/el/tests/jsp/AssignabilityTestCase.java b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/src/org/eclipse/jst/jsf/validation/el/tests/jsp/AssignabilityTestCase.java
new file mode 100644
index 0000000..96a23b1
--- /dev/null
+++ b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/src/org/eclipse/jst/jsf/validation/el/tests/jsp/AssignabilityTestCase.java
@@ -0,0 +1,47 @@
+package org.eclipse.jst.jsf.validation.el.tests.jsp;
+
+import org.eclipse.jdt.core.Signature;
+import org.eclipse.jst.jsf.core.internal.types.IAssignable;
+import org.eclipse.jst.jsf.core.internal.types.TypeConstants;
+import org.eclipse.jst.jsf.validation.el.tests.base.SingleJSPTestCase;
+
+public class AssignabilityTestCase extends SingleJSPTestCase 
+{
+    protected void setUp() throws Exception
+    {
+        _srcFileName = "/testdata/jsps/assignability.jsp.data";
+        _destFileName = "/assignability.jsp";
+        super.setUp();
+    }
+
+    public void testSanity()
+    {
+        assertEquals("myBean.integerProperty + 3", getELText(_structuredDocument,906));
+        assertEquals("myBean.writableStringProperty", getELText(_structuredDocument,965));
+        assertEquals("myBean.stringProperty", getELText(_structuredDocument,1025));
+        assertEquals("bundle.bundleProp2", getELText(_structuredDocument,1076));
+        assertEquals("requestScope.myBeanSubClass", getELText(_structuredDocument,1127));
+    }
+    
+    public void testNoErrorExprs() 
+    {
+        assertNoError(906, Signature.SIG_LONG, IAssignable.ASSIGNMENT_TYPE_RHS);
+        assertNoError(965, TypeConstants.TYPE_STRING, IAssignable.ASSIGNMENT_TYPE_RHS|IAssignable.ASSIGNMENT_TYPE_LHS);
+        assertNoError(1025, TypeConstants.TYPE_STRING, IAssignable.ASSIGNMENT_TYPE_RHS);
+        assertNoError(1076, TypeConstants.TYPE_STRING, IAssignable.ASSIGNMENT_TYPE_RHS);
+        assertNoError(1127, "Lbeans.MyBeanSubClass;", IAssignable.ASSIGNMENT_TYPE_RHS|IAssignable.ASSIGNMENT_TYPE_LHS);
+        // TODO: this will fail when the jsf-impl/api jars are injected since then we will
+        // have fully resolved (L) signatures instead of (Q) unresolved ones.
+        assertNoError(1187, "(QFacesContext;QUIComponent;Ljava.lang.Object;)V", IAssignable.ASSIGNMENT_TYPE_NONE);
+    }
+
+    public void testWarningExprs()
+    {
+        // no warnings
+    }
+    
+    public void testErrorExprs() 
+    {
+        // no errors
+    }
+}
diff --git a/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/src/org/eclipse/jst/jsf/validation/el/tests/jsp/BadSyntaxTestCase.java b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/src/org/eclipse/jst/jsf/validation/el/tests/jsp/BadSyntaxTestCase.java
new file mode 100644
index 0000000..de3de56
--- /dev/null
+++ b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/src/org/eclipse/jst/jsf/validation/el/tests/jsp/BadSyntaxTestCase.java
@@ -0,0 +1,54 @@
+package org.eclipse.jst.jsf.validation.el.tests.jsp;
+
+import java.util.List;
+
+import org.eclipse.jst.jsf.validation.el.tests.base.SingleJSPTestCase;
+
+public class BadSyntaxTestCase extends SingleJSPTestCase 
+{
+    protected void setUp() throws Exception
+    {
+        _srcFileName = "/testdata/jsps/badSyntax.jsp.data";
+        _destFileName = "/badSyntax.jsp";
+        super.setUp();
+    }
+
+    public void testSanity()
+    {
+        assertEquals(" ", getELText(_structuredDocument,870));
+        assertEquals("myBean.integerProperty + ", getELText(_structuredDocument,902));
+        assertEquals("&& myBean.booleanProperty", getELText(_structuredDocument,958));
+        assertEquals("&!", getELText(_structuredDocument,1014));
+        assertEquals("f?x", getELText(_structuredDocument,1047));
+    }
+
+
+    public void testNoErrorExprs() {
+        // no non-error cases
+    }
+
+
+    public void testWarningExprs() 
+    {
+        List list = assertSyntaxWarning(870,1);
+        assertContainsProblem(list, 0);
+        
+        list = assertSyntaxWarning(902,1);
+        assertContainsProblem(list, 0);
+        
+        list = assertSyntaxWarning(958,1);
+        assertContainsProblem(list, 0);
+
+        list = assertSyntaxWarning(1014,1);
+        assertContainsProblem(list, 0);
+
+        list = assertSyntaxWarning(1047,1);
+        assertContainsProblem(list, 0);
+    }
+
+    public void testErrorExprs() 
+    {
+        // no error cases
+    }
+
+}
diff --git a/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/src/org/eclipse/jst/jsf/validation/el/tests/jsp/BeanPropertyResolutionTestCase.java b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/src/org/eclipse/jst/jsf/validation/el/tests/jsp/BeanPropertyResolutionTestCase.java
new file mode 100644
index 0000000..fb04efd
--- /dev/null
+++ b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/src/org/eclipse/jst/jsf/validation/el/tests/jsp/BeanPropertyResolutionTestCase.java
@@ -0,0 +1,128 @@
+package org.eclipse.jst.jsf.validation.el.tests.jsp;
+
+import java.util.List;
+
+import org.eclipse.jdt.core.Signature;
+import org.eclipse.jst.jsf.core.internal.types.TypeConstants;
+import org.eclipse.jst.jsf.validation.el.tests.base.SingleJSPTestCase;
+
+public class BeanPropertyResolutionTestCase extends SingleJSPTestCase 
+{
+    protected void setUp() throws Exception
+    {
+        _srcFileName = "/testdata/jsps/beanPropertyResolution.jsp.data";
+        _destFileName = "/beanPropertyResolution.jsp";
+        super.setUp();
+    }
+
+    public void testSanity()
+    {
+        assertEquals("myBean.stringProperty", getELText(_structuredDocument,541));
+        assertEquals("myBean.integerProperty", getELText(_structuredDocument,596));
+        assertEquals("myBean.booleanProperty", getELText(_structuredDocument,652));
+        assertEquals("myBean.doubleProperty", getELText(_structuredDocument,708));
+        assertEquals("myBean.mapProperty", getELText(_structuredDocument,763));
+        assertEquals("myBean.stringArrayProperty", getELText(_structuredDocument,815));
+        assertEquals("myBean.collectionProperty", getELText(_structuredDocument,875));
+        assertEquals("myBean.listProperty", getELText(_structuredDocument,934));
+        assertEquals("myBean.comparableProperty", getELText(_structuredDocument,987));
+        assertEquals("myBean.bigIntegerProperty", getELText(_structuredDocument,1046));
+        assertEquals("myBean.bigDoubleProperty", getELText(_structuredDocument,1105));
+        assertEquals("myBean.writableStringProperty", getELText(_structuredDocument,1163));
+        assertEquals("myBean.isStyleBooleanProperty", getELText(_structuredDocument,1226));
+        assertEquals("myBeanSubClass.stringProperty", getELText(_structuredDocument,1324));
+        assertEquals("myBeanSubClass.integerProperty", getELText(_structuredDocument,1387));
+        assertEquals("myBeanSubClass.booleanProperty", getELText(_structuredDocument,1451));
+        assertEquals("myBeanSubClass.doubleProperty", getELText(_structuredDocument,1515));
+        assertEquals("myBeanSubClass.mapProperty", getELText(_structuredDocument,1578));
+        assertEquals("myBeanSubClass.stringArrayProperty", getELText(_structuredDocument,1638));
+        assertEquals("myBeanSubClass.collectionProperty", getELText(_structuredDocument,1706));
+        assertEquals("myBeanSubClass.listProperty", getELText(_structuredDocument,1773));
+        assertEquals("myBeanSubClass.comparableProperty", getELText(_structuredDocument,1834));
+        assertEquals("myBeanSubClass.bigIntegerProperty", getELText(_structuredDocument,1901));
+        assertEquals("myBeanSubClass.bigDoubleProperty", getELText(_structuredDocument,1968));
+        assertEquals("myBeanSubClass.writableStringProperty", getELText(_structuredDocument,2034));
+        assertEquals("myBeanSubClass.isStyleBooleanProperty", getELText(_structuredDocument,2105));
+        assertEquals("myBeanSubClass.subClassStringProperty", getELText(_structuredDocument,2176));
+        assertEquals("myBeanSubClass.stringProperty", getELText(_structuredDocument,2278));
+        assertEquals("myBeanSettable.integerProperty", getELText(_structuredDocument,2341));
+        assertEquals("myBeanSettable.booleanProperty", getELText(_structuredDocument,2405));
+        assertEquals("myBeanSettable.doubleProperty", getELText(_structuredDocument,2469));
+        assertEquals("myBeanSettable.mapProperty", getELText(_structuredDocument,2532));
+        assertEquals("myBeanSettable.stringArrayProperty", getELText(_structuredDocument,2592));
+        assertEquals("myBeanSettable.collectionProperty", getELText(_structuredDocument,2660));
+        assertEquals("myBeanSettable.listProperty", getELText(_structuredDocument,2727));
+        assertEquals("myBeanSettable.comparableProperty", getELText(_structuredDocument,2788));
+        assertEquals("myBeanSettable.bigIntegerProperty", getELText(_structuredDocument,2855));
+        assertEquals("myBeanSettable.bigDoubleProperty", getELText(_structuredDocument,2922));
+        assertEquals("myBeanSettable.writableStringProperty", getELText(_structuredDocument,2988));
+        assertEquals("myBeanSettable.isStyleBooleanProperty", getELText(_structuredDocument,3059));
+
+        assertEquals("myBean.subClassStringProperty", getELText(_structuredDocument,3159));
+        assertEquals("myBeanSubClass.notAMember", getELText(_structuredDocument,3222));
+        assertEquals("myBeanSettable.alsoNotAMember", getELText(_structuredDocument,3281));
+    }
+    
+    public void testNoErrorExprs() 
+    {
+        assertNoError(541, TypeConstants.TYPE_STRING);
+        assertNoError(596, Signature.SIG_INT);
+        assertNoError(652, Signature.SIG_BOOLEAN);
+        assertNoError(708, Signature.SIG_DOUBLE);
+        assertNoError(763, TypeConstants.TYPE_MAP);
+        assertNoError(815, Signature.createArraySignature(TypeConstants.TYPE_STRING, 1));
+        assertNoError(875, TypeConstants.TYPE_COLLECTION);
+        assertNoError(934, "Ljava.util.List;");
+        assertNoError(987, TypeConstants.TYPE_COMPARABLE);
+        assertNoError(1046, TypeConstants.TYPE_BIG_INTEGER);
+        assertNoError(1105, TypeConstants.TYPE_BIG_DOUBLE);
+        assertNoError(1163, TypeConstants.TYPE_STRING);
+        assertNoError(1226, Signature.SIG_BOOLEAN);
+
+        assertNoError(1324, TypeConstants.TYPE_STRING);
+        assertNoError(1387, Signature.SIG_INT);
+        assertNoError(1451, Signature.SIG_BOOLEAN);
+        assertNoError(1515, Signature.SIG_DOUBLE);
+        assertNoError(1578, TypeConstants.TYPE_MAP);
+        assertNoError(1638, Signature.createArraySignature(TypeConstants.TYPE_STRING, 1));
+        assertNoError(1706, TypeConstants.TYPE_COLLECTION);
+        assertNoError(1773, "Ljava.util.List;");
+        assertNoError(1834, TypeConstants.TYPE_COMPARABLE);
+        assertNoError(1901, TypeConstants.TYPE_BIG_INTEGER);
+        assertNoError(1968, TypeConstants.TYPE_BIG_DOUBLE);
+        assertNoError(2034, TypeConstants.TYPE_STRING);
+        assertNoError(2105, Signature.SIG_BOOLEAN);
+        assertNoError(2176, TypeConstants.TYPE_STRING);
+        assertNoError(2278, TypeConstants.TYPE_STRING);
+
+        assertNoError(2341, Signature.SIG_INT);
+        assertNoError(2405, Signature.SIG_BOOLEAN);
+        assertNoError(2469, Signature.SIG_DOUBLE);
+        assertNoError(2532, TypeConstants.TYPE_MAP);
+        assertNoError(2592, Signature.createArraySignature(TypeConstants.TYPE_STRING, 1));
+        assertNoError(2660, TypeConstants.TYPE_COLLECTION);
+        assertNoError(2727, "Ljava.util.List;");
+        assertNoError(2788, TypeConstants.TYPE_COMPARABLE);
+        assertNoError(2855, TypeConstants.TYPE_BIG_INTEGER);
+        assertNoError(2922, TypeConstants.TYPE_BIG_DOUBLE);
+        assertNoError(2988, TypeConstants.TYPE_STRING);
+        assertNoError(3059, Signature.SIG_BOOLEAN);
+    }
+
+    public void testWarningExprs() 
+    {
+        List list = assertSemanticWarning(3159,null,1);
+        assertContainsProblem(list, 0);
+
+        list = assertSemanticWarning(3222,null,1);
+        assertContainsProblem(list, 0);
+        
+        list = assertSemanticWarning(3281,null,1);
+        assertContainsProblem(list, 0);
+    }
+
+    public void testErrorExprs() 
+    {
+        // no error cases
+    }
+}
diff --git a/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/src/org/eclipse/jst/jsf/validation/el/tests/jsp/BeanVariableResolutionTestCase.java b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/src/org/eclipse/jst/jsf/validation/el/tests/jsp/BeanVariableResolutionTestCase.java
new file mode 100644
index 0000000..c218851
--- /dev/null
+++ b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/src/org/eclipse/jst/jsf/validation/el/tests/jsp/BeanVariableResolutionTestCase.java
@@ -0,0 +1,58 @@
+package org.eclipse.jst.jsf.validation.el.tests.jsp;
+
+import java.util.List;
+
+import org.eclipse.jst.jsf.validation.el.tests.base.SingleJSPTestCase;
+
+public class BeanVariableResolutionTestCase extends SingleJSPTestCase 
+{
+    protected void setUp() throws Exception
+    {
+        _srcFileName = "/testdata/jsps/beanVariableResolution.jsp.data";
+        _destFileName = "/beanVariableResolution.jsp";
+        super.setUp();
+    }
+
+    public void testSanity()
+    {
+        assertEquals("myBean", getELText(_structuredDocument,541));
+        assertEquals("myBeanSubClass", getELText(_structuredDocument,581));
+        assertEquals("mapBean", getELText(_structuredDocument,629));
+        assertEquals("mapBean1", getELText(_structuredDocument,670));
+        assertEquals("hiddenBean", getELText(_structuredDocument,712));
+        assertEquals("myBean_none", getELText(_structuredDocument,756));
+        assertEquals("myBeanSettable", getELText(_structuredDocument,801));
+
+        assertEquals("myBean1", getELText(_structuredDocument,878));
+        assertEquals("someOtherBeanName", getELText(_structuredDocument,919));
+    }
+    
+
+    @Override
+    public void testNoErrorExprs() 
+    {
+        assertNoError(541, "Lbeans.MyBean;");
+        assertNoError(581, "Lbeans.MyBeanSubClass;");
+        assertNoError(629, "Lbeans.MapBean;");
+        assertNoError(670, "Lbeans.MapBean;");
+        assertNoError(712, "Lbeans.MyBean;");
+        assertNoError(756, "Lbeans.MyBean;");
+        assertNoError(801, "Lbeans.MyBeanSettable;");
+    }
+
+    @Override
+    public void testWarningExprs() 
+    {
+        List list = assertSemanticWarning(878, null, 1);
+        assertContainsProblem(list,0);
+        
+        list = assertSemanticWarning(919, null, 1);
+        assertContainsProblem(list,0);
+    }
+
+    public void testErrorExprs() 
+    {
+        // no error cases
+    }
+
+}
diff --git a/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/src/org/eclipse/jst/jsf/validation/el/tests/jsp/BuiltInSymbolsTestCase.java b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/src/org/eclipse/jst/jsf/validation/el/tests/jsp/BuiltInSymbolsTestCase.java
new file mode 100644
index 0000000..8c9566e
--- /dev/null
+++ b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/src/org/eclipse/jst/jsf/validation/el/tests/jsp/BuiltInSymbolsTestCase.java
@@ -0,0 +1,180 @@
+package org.eclipse.jst.jsf.validation.el.tests.jsp;
+
+import java.util.List;
+
+import org.eclipse.jdt.core.Signature;
+import org.eclipse.jst.jsf.core.internal.types.TypeConstants;
+import org.eclipse.jst.jsf.validation.el.tests.base.SingleJSPTestCase;
+import org.eclipse.jst.jsf.validation.internal.el.diagnostics.DiagnosticFactory;
+
+public class BuiltInSymbolsTestCase extends SingleJSPTestCase 
+{
+    protected void setUp() throws Exception
+    {
+        _srcFileName = "/testdata/jsps/builtinSymbols.jsp.data";
+        _destFileName = "/builtinSymbols.jsp";
+        super.setUp();
+    }
+
+    public void testSanity()
+    {
+        assertEquals("applicationScope", getELText(_structuredDocument,1003));
+        assertEquals("sessionScope", getELText(_structuredDocument,1053));
+        assertEquals("requestScope", getELText(_structuredDocument,1099));
+        assertEquals("cookie", getELText(_structuredDocument,1145));
+        assertEquals("facesContext", getELText(_structuredDocument,1185));
+        assertEquals("header", getELText(_structuredDocument,1231));
+        assertEquals("headerValues", getELText(_structuredDocument,1271));
+        assertEquals("initParam", getELText(_structuredDocument,1317));
+        assertEquals("param", getELText(_structuredDocument,1360));
+        assertEquals("paramValues", getELText(_structuredDocument,1399));
+        assertEquals("view", getELText(_structuredDocument,1444));
+        assertEquals("applicationScope.mapBean", getELText(_structuredDocument,1533));
+        assertEquals("sessionScope.myBean", getELText(_structuredDocument,1640));
+        assertEquals("sessionScope.mapBean1", getELText(_structuredDocument,1690));
+        assertEquals("sessionScope.myBeanSettable", getELText(_structuredDocument,1742));
+        assertEquals("requestScope.myBeanSubClass", getELText(_structuredDocument,1852));
+        assertEquals("requestScope.hiddenBean", getELText(_structuredDocument,1910));
+        assertEquals("requestScope.bundle", getELText(_structuredDocument,1964));
+        assertEquals("requestScope.bundle2", getELText(_structuredDocument,2014));
+        assertEquals("empty cookie", getELText(_structuredDocument,2151));
+        assertEquals("empty header", getELText(_structuredDocument,2194));
+        assertEquals("empty headerValues", getELText(_structuredDocument,2237));
+        assertEquals("empty param", getELText(_structuredDocument,2286));
+        assertEquals("empty paramValues", getELText(_structuredDocument,2328));
+        assertEquals("facesContext.application", getELText(_structuredDocument,2429));
+        assertEquals("facesContext.clientIdsWithMessages", getELText(_structuredDocument,2484));
+        assertEquals("facesContext.externalContext", getELText(_structuredDocument,2549));
+        assertEquals("facesContext.maximumSeverity", getELText(_structuredDocument,2608));
+        assertEquals("facesContext.messages", getELText(_structuredDocument,2667));
+        assertEquals("facesContext.renderKit", getELText(_structuredDocument,2719));
+        assertEquals("facesContext.renderResponse", getELText(_structuredDocument,2772));
+        assertEquals("facesContext.responseComplete", getELText(_structuredDocument,2830));
+        assertEquals("facesContext.responseStream", getELText(_structuredDocument,2890));
+        assertEquals("facesContext.responseWriter", getELText(_structuredDocument,2948));
+        assertEquals("facesContext.viewRoot", getELText(_structuredDocument,3006));
+        assertEquals("view.viewId", getELText(_structuredDocument,3105));
+        assertEquals("view.family", getELText(_structuredDocument,3147));
+        assertEquals("view.locale", getELText(_structuredDocument,3189));
+        assertEquals("view.renderKitId", getELText(_structuredDocument,3231));
+        assertEquals("view.viewId", getELText(_structuredDocument,3278));
+        assertEquals("sessionScope.myBean.integerProperty", getELText(_structuredDocument,3377));
+        assertEquals("requestScope.bundle.bundleProp2", getELText(_structuredDocument,3446));
+        assertEquals("3 + sessionScope.myBean.integerProperty", getELText(_structuredDocument,3564));
+
+        assertEquals("applicationScope.notAMember", getELText(_structuredDocument,3661));
+        assertEquals("sessionScope.notAMember", getELText(_structuredDocument,3722));
+        assertEquals("requestScope.notAMember", getELText(_structuredDocument,3779));
+        assertEquals("cookie.notAMember", getELText(_structuredDocument,3836));
+        assertEquals("facesContext.notAMember", getELText(_structuredDocument,3887));
+        assertEquals("header.notAMember", getELText(_structuredDocument,3944));
+        assertEquals("headerValues.notAMember", getELText(_structuredDocument,3995));
+        assertEquals("initParam.notAMember", getELText(_structuredDocument,4052));
+        assertEquals("param.notAMember", getELText(_structuredDocument,4106));
+        assertEquals("paramValues.notAMember", getELText(_structuredDocument,4156));
+        assertEquals("view.notAMember", getELText(_structuredDocument,4212));
+        assertEquals("applicationScope.myBean_none", getELText(_structuredDocument,4311));
+        assertEquals("sessionScope.myBean_none", getELText(_structuredDocument,4373));
+        assertEquals("requestScope.myBean_none", getELText(_structuredDocument,4431));
+
+        assertEquals("!initParam", getELText(_structuredDocument,4507));    
+    }
+
+    public void testNoErrorExprs() 
+    {
+        assertNoError(1003, TypeConstants.TYPE_MAP);
+        assertNoError(1053, TypeConstants.TYPE_MAP);
+        assertNoError(1099, TypeConstants.TYPE_MAP);
+        assertNoError(1145, TypeConstants.TYPE_MAP);
+        assertNoError(1185, "Ljavax.faces.context.FacesContext;");
+        assertNoError(1232, TypeConstants.TYPE_MAP);
+        assertNoError(1272, TypeConstants.TYPE_MAP);
+        assertNoError(1317, TypeConstants.TYPE_MAP);
+        assertNoError(1360, TypeConstants.TYPE_MAP);
+        assertNoError(1399, TypeConstants.TYPE_MAP);
+        assertNoError(1444, "Ljavax.faces.component.UIViewRoot;");
+        assertNoError(1533, "Lbeans.MapBean;");
+        assertNoError(1640, "Lbeans.MyBean;");
+        assertNoError(1690, "Lbeans.MapBean;");
+        assertNoError(1742, "Lbeans.MyBeanSettable;");
+        assertNoError(1852, "Lbeans.MyBeanSubClass;");
+        assertNoError(1910, "Lbeans.MyBean;");
+
+        assertNoError(1964, TypeConstants.TYPE_MAP);
+        assertNoError(2014, TypeConstants.TYPE_MAP);
+        
+        assertNoError(2151, Signature.SIG_BOOLEAN);
+        assertNoError(2194, Signature.SIG_BOOLEAN);
+        assertNoError(2237, Signature.SIG_BOOLEAN);
+        assertNoError(2286, Signature.SIG_BOOLEAN);
+        assertNoError(2328, Signature.SIG_BOOLEAN);
+        // TODO: can't check these until we can import the required API jars
+        // into the project
+//        assertEquals("facesContext.application", getELText(_structuredDocument,2854));
+//        assertEquals("facesContext.clientIdsWithMessages", getELText(_structuredDocument,2909));
+//        assertEquals("facesContext.externalContext", getELText(_structuredDocument,2974));
+//        assertEquals("facesContext.maximumSeverity", getELText(_structuredDocument,3033));
+//        assertEquals("facesContext.messages", getELText(_structuredDocument,3092));
+//        assertEquals("facesContext.renderKit", getELText(_structuredDocument,3144));
+//        assertEquals("facesContext.renderResponse", getELText(_structuredDocument,3197));
+//        assertEquals("facesContext.responseComplete", getELText(_structuredDocument,3255));
+//        assertEquals("facesContext.responseStream", getELText(_structuredDocument,3315));
+//        assertEquals("facesContext.responseWriter", getELText(_structuredDocument,3373));
+//        assertEquals("facesContext.viewRoot", getELText(_structuredDocument,3431));
+//        assertEquals("view.viewId", getELText(_structuredDocument,3530));
+//        assertEquals("view.family", getELText(_structuredDocument,3572));
+//        assertEquals("view.locale", getELText(_structuredDocument,3614));
+//        assertEquals("view.renderKitId", getELText(_structuredDocument,3656));
+//        assertEquals("view.viewId", getELText(_structuredDocument,3703));
+        assertNoError(3377, Signature.SIG_INT);
+        assertNoError(3446, TypeConstants.TYPE_STRING);
+        assertNoError(3564, Signature.SIG_LONG);
+    }
+    public void testWarningExprs() 
+    {
+        List list = assertSemanticWarning(3661,null,1);
+        assertContainsProblem(list, 0);
+
+        list = assertSemanticWarning(3722,null,1);
+        assertContainsProblem(list, 0);
+
+        list = assertSemanticWarning(3779,null,1);
+        assertContainsProblem(list, 0);
+
+        list = assertSemanticWarning(3836,null,1);
+        assertContainsProblem(list, 0);
+
+        list = assertSemanticWarning(3887,null,1);
+        assertContainsProblem(list, 0);
+
+        list = assertSemanticWarning(3944,null,1);
+        assertContainsProblem(list, 0);
+
+        list = assertSemanticWarning(3995,null,1);
+        assertContainsProblem(list, 0);
+
+        list = assertSemanticWarning(4052,null,1);
+        assertContainsProblem(list, 0);
+
+        list = assertSemanticWarning(4106,null,1);
+        assertContainsProblem(list, 0);
+
+        list = assertSemanticWarning(4156,null,1);
+        assertContainsProblem(list, 0);
+
+        list = assertSemanticWarning(4212,null,1);
+        assertContainsProblem(list, 0);
+        
+        list = assertSemanticWarning(4311,null,1);
+        assertContainsProblem(list, 0);
+        list = assertSemanticWarning(4373,null,1);
+        assertContainsProblem(list, 0);
+        list = assertSemanticWarning(4431,null,1);
+        assertContainsProblem(list, 0);
+    }
+    public void testErrorExprs() 
+    {
+        List list = assertSemanticError(4507,null,1);
+        assertContainsProblem(list, DiagnosticFactory.UNARY_OP_CANNOT_COERCE_ARGUMENT_TO_BOOLEAN_ID);
+    }
+}
diff --git a/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/src/org/eclipse/jst/jsf/validation/el/tests/jsp/GreaterThanEqTestCase.java b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/src/org/eclipse/jst/jsf/validation/el/tests/jsp/GreaterThanEqTestCase.java
new file mode 100644
index 0000000..25036a1
--- /dev/null
+++ b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/src/org/eclipse/jst/jsf/validation/el/tests/jsp/GreaterThanEqTestCase.java
@@ -0,0 +1,165 @@
+package org.eclipse.jst.jsf.validation.el.tests.jsp;
+
+import java.util.List;
+
+import org.eclipse.jdt.core.Signature;
+import org.eclipse.jst.jsf.validation.el.tests.base.SingleJSPTestCase;
+import org.eclipse.jst.jsf.validation.internal.el.diagnostics.DiagnosticFactory;
+
+public class GreaterThanEqTestCase extends SingleJSPTestCase {
+
+    protected void setUp() throws Exception 
+    {
+        _srcFileName = "/testdata/jsps/greaterThanEq.jsp.data";
+        _destFileName = "/greaterThanEq.jsp";
+
+        super.setUp();
+    }
+
+    public void testSanity()
+    {
+        super.testSanity();
+        
+        assertEquals("myBean.stringProperty >= '3'", getELText(_structuredDocument,852));
+        assertEquals("myBean.stringProperty ge '3'", getELText(_structuredDocument,914));
+        assertEquals("myBean.integerProperty >= 3", getELText(_structuredDocument,976));
+        assertEquals("myBean.integerProperty ge 3", getELText(_structuredDocument,1037));
+        assertEquals("myBean.integerProperty >= '4' ", getELText(_structuredDocument,1098));
+        assertEquals("myBean.integerProperty ge '4' ", getELText(_structuredDocument,1162));
+        assertEquals("myBean.comparableProperty >= myBean.collectionProperty", getELText(_structuredDocument,1227));
+        assertEquals("myBean.comparableProperty ge myBean.collectionProperty", getELText(_structuredDocument,1315));
+        assertEquals("myBean.integerProperty >= -3", getELText(_structuredDocument,1405));
+        assertEquals("myBean.doubleProperty > 5", getELText(_structuredDocument,1467));
+        assertEquals("5 gt myBean.bigIntegerProperty", getELText(_structuredDocument,1526));
+        assertEquals("myBean.bigDoubleProperty > myBean.bigIntegerProperty", getELText(_structuredDocument,1590));
+
+        assertEquals("5 >= 3", getELText(_structuredDocument,1705));
+        assertEquals("5 ge 3", getELText(_structuredDocument,1742));
+        assertEquals("'4' >= '34'", getELText(_structuredDocument,1779));
+        assertEquals("'4' ge '34'", getELText(_structuredDocument,1821));
+        assertEquals("'34' >= '34'", getELText(_structuredDocument,1863));
+        assertEquals("'34' ge '34'", getELText(_structuredDocument,1906));
+        assertEquals("-5 >= 2", getELText(_structuredDocument,1949));
+        assertEquals("-5 ge 2", getELText(_structuredDocument,1987));
+        assertEquals("2 >= -5", getELText(_structuredDocument,2025));
+        assertEquals("2 ge -5", getELText(_structuredDocument,2063));
+        assertEquals("-5 >= -5", getELText(_structuredDocument,2101));
+        assertEquals("-5 ge -5", getELText(_structuredDocument,2140));
+        assertEquals("myBean.integerProperty > null", getELText(_structuredDocument,2179));
+        assertEquals("null gt myBean.integerProperty", getELText(_structuredDocument,2239));
+
+        assertEquals("5 >= true", getELText(_structuredDocument,2323));
+        assertEquals("5 ge true", getELText(_structuredDocument,2363));
+        assertEquals("myBean.integerProperty >= myBean.booleanProperty", getELText(_structuredDocument,2403));
+        assertEquals("myBean.integerProperty ge myBean.booleanProperty", getELText(_structuredDocument,2482));
+        assertEquals("myBean.stringArrayProperty >= myBean.booleanProperty", getELText(_structuredDocument,2561));
+        assertEquals("myBean.stringArrayProperty ge myBean.booleanProperty", getELText(_structuredDocument,2644));
+        assertEquals("myBean.integerProperty >= true ", getELText(_structuredDocument,2730));
+        assertEquals("myBean.integerProperty ge true ", getELText(_structuredDocument,2795));
+        assertEquals("myBean.booleanProperty >= true", getELText(_structuredDocument,2860));
+        assertEquals("myBean.booleanProperty ge true", getELText(_structuredDocument,2924));
+        assertEquals("true >= false", getELText(_structuredDocument,2986));
+        assertEquals("true ge false", getELText(_structuredDocument,3031));    
+    }
+    
+    public void testNoErrorExprs() 
+    {
+        assertNoError(852, Signature.SIG_BOOLEAN);
+        assertNoError(914, Signature.SIG_BOOLEAN);
+        assertNoError(976, Signature.SIG_BOOLEAN);
+        assertNoError(1037, Signature.SIG_BOOLEAN);
+        assertNoError(1098, Signature.SIG_BOOLEAN);
+        assertNoError(1162, Signature.SIG_BOOLEAN);
+        assertNoError(1227, Signature.SIG_BOOLEAN);
+        assertNoError(1315, Signature.SIG_BOOLEAN);
+        assertNoError(1405, Signature.SIG_BOOLEAN);
+        assertNoError(1467, Signature.SIG_BOOLEAN);
+        assertNoError(1526, Signature.SIG_BOOLEAN);
+        assertNoError(1590, Signature.SIG_BOOLEAN);
+    }
+
+    public void testWarningExprs() 
+    {
+        List list = assertSemanticWarning(1705, Signature.SIG_BOOLEAN, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_CONSTANT_EXPRESSION_ALWAYS_EVAL_SAME_ID);
+
+        list = assertSemanticWarning(1742, Signature.SIG_BOOLEAN, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_CONSTANT_EXPRESSION_ALWAYS_EVAL_SAME_ID);
+
+        list = assertSemanticWarning(1779, Signature.SIG_BOOLEAN, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_CONSTANT_EXPRESSION_ALWAYS_EVAL_SAME_ID);
+
+        list = assertSemanticWarning(1821, Signature.SIG_BOOLEAN, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_CONSTANT_EXPRESSION_ALWAYS_EVAL_SAME_ID);
+
+        list = assertSemanticWarning(1863, Signature.SIG_BOOLEAN, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_CONSTANT_EXPRESSION_ALWAYS_EVAL_SAME_ID);
+
+        list = assertSemanticWarning(1906, Signature.SIG_BOOLEAN, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_CONSTANT_EXPRESSION_ALWAYS_EVAL_SAME_ID);
+
+        list = assertSemanticWarning(1949, Signature.SIG_BOOLEAN, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_CONSTANT_EXPRESSION_ALWAYS_EVAL_SAME_ID);
+
+        list = assertSemanticWarning(1987, Signature.SIG_BOOLEAN, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_CONSTANT_EXPRESSION_ALWAYS_EVAL_SAME_ID);
+
+        list = assertSemanticWarning(2025, Signature.SIG_BOOLEAN, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_CONSTANT_EXPRESSION_ALWAYS_EVAL_SAME_ID);
+
+        list = assertSemanticWarning(2063, Signature.SIG_BOOLEAN, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_CONSTANT_EXPRESSION_ALWAYS_EVAL_SAME_ID);
+
+        list = assertSemanticWarning(2101, Signature.SIG_BOOLEAN, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_CONSTANT_EXPRESSION_ALWAYS_EVAL_SAME_ID);
+
+        list = assertSemanticWarning(2140, Signature.SIG_BOOLEAN, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_CONSTANT_EXPRESSION_ALWAYS_EVAL_SAME_ID);
+
+        list = assertSemanticWarning(2179, Signature.SIG_BOOLEAN, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_EQUALITY_COMP_WITH_NULL_ALWAYS_EVAL_SAME_ID);
+
+        list = assertSemanticWarning(2239, Signature.SIG_BOOLEAN, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_EQUALITY_COMP_WITH_NULL_ALWAYS_EVAL_SAME_ID);
+
+    }
+
+    public void testErrorExprs() 
+    {
+        List list = assertSemanticError(2323, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_COULD_NOT_MAKE_NUMERIC_COERCION_ID);
+
+        list = assertSemanticError(2363, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_COULD_NOT_MAKE_NUMERIC_COERCION_ID);
+
+        list = assertSemanticError(2403, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_COULD_NOT_MAKE_NUMERIC_COERCION_ID);
+
+        list = assertSemanticError(2482, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_COULD_NOT_MAKE_NUMERIC_COERCION_ID);
+
+        list = assertSemanticError(2561, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_NO_AVAILABLE_TYPE_COERCION_ID);
+
+        list = assertSemanticError(2644, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_NO_AVAILABLE_TYPE_COERCION_ID);
+
+        list = assertSemanticError(2730, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_COULD_NOT_MAKE_NUMERIC_COERCION_ID);
+
+        list = assertSemanticError(2795, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_COULD_NOT_MAKE_NUMERIC_COERCION_ID);
+
+        list = assertSemanticError(2860, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_NO_AVAILABLE_TYPE_COERCION_ID);
+
+        list = assertSemanticError(2924, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_NO_AVAILABLE_TYPE_COERCION_ID);
+
+        list = assertSemanticError(2986, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_NO_AVAILABLE_TYPE_COERCION_ID);
+
+        list = assertSemanticError(3031, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_NO_AVAILABLE_TYPE_COERCION_ID);
+    }
+}
diff --git a/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/src/org/eclipse/jst/jsf/validation/el/tests/jsp/GreaterThanTestCase.java b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/src/org/eclipse/jst/jsf/validation/el/tests/jsp/GreaterThanTestCase.java
new file mode 100644
index 0000000..f567204
--- /dev/null
+++ b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/src/org/eclipse/jst/jsf/validation/el/tests/jsp/GreaterThanTestCase.java
@@ -0,0 +1,165 @@
+package org.eclipse.jst.jsf.validation.el.tests.jsp;
+
+import java.util.List;
+
+import org.eclipse.jdt.core.Signature;
+import org.eclipse.jst.jsf.validation.el.tests.base.SingleJSPTestCase;
+import org.eclipse.jst.jsf.validation.internal.el.diagnostics.DiagnosticFactory;
+
+public class GreaterThanTestCase extends SingleJSPTestCase 
+{
+    protected void setUp() throws Exception 
+    {
+        _srcFileName = "/testdata/jsps/greaterThan.jsp.data";
+        _destFileName = "/greaterThan.jsp";
+
+        super.setUp();
+    }
+
+    public void testSanity()
+    {
+        super.testSanity();
+        
+        assertEquals("myBean.stringProperty > '3'", getELText(_structuredDocument,852));
+        assertEquals("myBean.stringProperty gt '3'", getELText(_structuredDocument,913));
+        assertEquals("myBean.integerProperty > 3", getELText(_structuredDocument,975));
+        assertEquals("myBean.integerProperty gt 3", getELText(_structuredDocument,1035));
+        assertEquals("myBean.integerProperty > '4' ", getELText(_structuredDocument,1096));
+        assertEquals("myBean.integerProperty gt '4' ", getELText(_structuredDocument,1159));
+        assertEquals("myBean.comparableProperty > myBean.collectionProperty", getELText(_structuredDocument,1224));
+        assertEquals("myBean.comparableProperty gt myBean.collectionProperty", getELText(_structuredDocument,1311));
+        assertEquals("myBean.integerProperty > -3", getELText(_structuredDocument,1399));
+        assertEquals("myBean.doubleProperty > 5", getELText(_structuredDocument,1460));
+        assertEquals("5 gt myBean.bigIntegerProperty", getELText(_structuredDocument,1519));
+        assertEquals("myBean.bigDoubleProperty > myBean.bigIntegerProperty", getELText(_structuredDocument,1583));
+
+        assertEquals("5 > 3", getELText(_structuredDocument,1695));
+        assertEquals("5 gt 3", getELText(_structuredDocument,1731));
+        assertEquals("'4' > '34'", getELText(_structuredDocument,1768));
+        assertEquals("'4' gt '34'", getELText(_structuredDocument,1809));
+        assertEquals("'34' > '34'", getELText(_structuredDocument,1851));
+        assertEquals("'34' gt '34'", getELText(_structuredDocument,1893));
+        assertEquals("-5 > 2", getELText(_structuredDocument,1936));
+        assertEquals("-5 gt 2", getELText(_structuredDocument,1973));
+        assertEquals("2 > -5", getELText(_structuredDocument,2011));
+        assertEquals("2 gt -5", getELText(_structuredDocument,2048));
+        assertEquals("-5 > -5", getELText(_structuredDocument,2086));
+        assertEquals("-5 gt -5", getELText(_structuredDocument,2124));
+        assertEquals("myBean.integerProperty > null", getELText(_structuredDocument,2163));
+        assertEquals("null gt myBean.integerProperty", getELText(_structuredDocument,2223));
+
+        assertEquals("5 > true", getELText(_structuredDocument,2307));
+        assertEquals("5 gt true", getELText(_structuredDocument,2346));
+        assertEquals("myBean.integerProperty > myBean.booleanProperty", getELText(_structuredDocument,2386));
+        assertEquals("myBean.integerProperty gt myBean.booleanProperty", getELText(_structuredDocument,2464));
+        assertEquals("myBean.stringArrayProperty > myBean.booleanProperty", getELText(_structuredDocument,2543));
+        assertEquals("myBean.stringArrayProperty gt myBean.booleanProperty", getELText(_structuredDocument,2625));
+        assertEquals("myBean.integerProperty > true ", getELText(_structuredDocument,2711));
+        assertEquals("myBean.integerProperty gt true ", getELText(_structuredDocument,2775));
+        assertEquals("myBean.booleanProperty > true", getELText(_structuredDocument,2840));
+        assertEquals("myBean.booleanProperty gt true", getELText(_structuredDocument,2903));
+        assertEquals("true > false", getELText(_structuredDocument,2965));
+        assertEquals("true gt false", getELText(_structuredDocument,3009));
+    }
+    
+    public void testNoErrorExprs() 
+    {
+        assertNoError(852, Signature.SIG_BOOLEAN);
+        assertNoError(913, Signature.SIG_BOOLEAN);
+        assertNoError(975, Signature.SIG_BOOLEAN);
+        assertNoError(1035, Signature.SIG_BOOLEAN);
+        assertNoError(1096, Signature.SIG_BOOLEAN);
+        assertNoError(1159, Signature.SIG_BOOLEAN);
+        assertNoError(1224, Signature.SIG_BOOLEAN);
+        assertNoError(1311, Signature.SIG_BOOLEAN);
+        assertNoError(1399, Signature.SIG_BOOLEAN);
+        assertNoError(1460, Signature.SIG_BOOLEAN);
+        assertNoError(1519, Signature.SIG_BOOLEAN);
+        assertNoError(1583, Signature.SIG_BOOLEAN);
+    }
+
+    public void testWarningExprs() 
+    {
+        List list = assertSemanticWarning(1695, Signature.SIG_BOOLEAN, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_CONSTANT_EXPRESSION_ALWAYS_EVAL_SAME_ID);
+
+        list = assertSemanticWarning(1731, Signature.SIG_BOOLEAN, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_CONSTANT_EXPRESSION_ALWAYS_EVAL_SAME_ID);
+
+        list = assertSemanticWarning(1768, Signature.SIG_BOOLEAN, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_CONSTANT_EXPRESSION_ALWAYS_EVAL_SAME_ID);
+
+        list = assertSemanticWarning(1809, Signature.SIG_BOOLEAN, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_CONSTANT_EXPRESSION_ALWAYS_EVAL_SAME_ID);
+
+        list = assertSemanticWarning(1851, Signature.SIG_BOOLEAN, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_CONSTANT_EXPRESSION_ALWAYS_EVAL_SAME_ID);
+
+        list = assertSemanticWarning(1893, Signature.SIG_BOOLEAN, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_CONSTANT_EXPRESSION_ALWAYS_EVAL_SAME_ID);
+
+        list = assertSemanticWarning(1936, Signature.SIG_BOOLEAN, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_CONSTANT_EXPRESSION_ALWAYS_EVAL_SAME_ID);
+
+        list = assertSemanticWarning(1973, Signature.SIG_BOOLEAN, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_CONSTANT_EXPRESSION_ALWAYS_EVAL_SAME_ID);
+
+        list = assertSemanticWarning(2011, Signature.SIG_BOOLEAN, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_CONSTANT_EXPRESSION_ALWAYS_EVAL_SAME_ID);
+
+        list = assertSemanticWarning(2048, Signature.SIG_BOOLEAN, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_CONSTANT_EXPRESSION_ALWAYS_EVAL_SAME_ID);
+
+        list = assertSemanticWarning(2086, Signature.SIG_BOOLEAN, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_CONSTANT_EXPRESSION_ALWAYS_EVAL_SAME_ID);
+
+        list = assertSemanticWarning(2124, Signature.SIG_BOOLEAN, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_CONSTANT_EXPRESSION_ALWAYS_EVAL_SAME_ID);
+
+        list = assertSemanticWarning(2163, Signature.SIG_BOOLEAN, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_EQUALITY_COMP_WITH_NULL_ALWAYS_EVAL_SAME_ID);
+
+        list = assertSemanticWarning(2223, Signature.SIG_BOOLEAN, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_EQUALITY_COMP_WITH_NULL_ALWAYS_EVAL_SAME_ID);
+
+    }
+
+    public void testErrorExprs() 
+    {
+        List list = assertSemanticError(2307, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_COULD_NOT_MAKE_NUMERIC_COERCION_ID);
+
+        list = assertSemanticError(2346, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_COULD_NOT_MAKE_NUMERIC_COERCION_ID);
+
+        list = assertSemanticError(2386, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_COULD_NOT_MAKE_NUMERIC_COERCION_ID);
+
+        list = assertSemanticError(2464, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_COULD_NOT_MAKE_NUMERIC_COERCION_ID);
+
+        list = assertSemanticError(2543, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_NO_AVAILABLE_TYPE_COERCION_ID);
+
+        list = assertSemanticError(2625, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_NO_AVAILABLE_TYPE_COERCION_ID);
+
+        list = assertSemanticError(2711, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_COULD_NOT_MAKE_NUMERIC_COERCION_ID);
+
+        list = assertSemanticError(2775, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_COULD_NOT_MAKE_NUMERIC_COERCION_ID);
+
+        list = assertSemanticError(2840, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_NO_AVAILABLE_TYPE_COERCION_ID);
+
+        list = assertSemanticError(2903, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_NO_AVAILABLE_TYPE_COERCION_ID);
+
+        list = assertSemanticError(2965, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_NO_AVAILABLE_TYPE_COERCION_ID);
+
+        list = assertSemanticError(3009, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_NO_AVAILABLE_TYPE_COERCION_ID);
+    }
+}
diff --git a/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/src/org/eclipse/jst/jsf/validation/el/tests/jsp/JSPFunctionsTestCase.java b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/src/org/eclipse/jst/jsf/validation/el/tests/jsp/JSPFunctionsTestCase.java
new file mode 100644
index 0000000..35e0d7a
--- /dev/null
+++ b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/src/org/eclipse/jst/jsf/validation/el/tests/jsp/JSPFunctionsTestCase.java
@@ -0,0 +1,52 @@
+package org.eclipse.jst.jsf.validation.el.tests.jsp;
+
+import java.util.List;
+
+import org.eclipse.jst.jsf.validation.el.tests.base.SingleJSPTestCase;
+
+public class JSPFunctionsTestCase extends SingleJSPTestCase 
+{
+    protected void setUp() throws Exception
+    {
+        _srcFileName = "/testdata/jsps/jspFunctions.jsp.data";
+        _destFileName = "/jspFunctions.jsp";
+        super.setUp();
+    }
+
+    public void testSanity()
+    {
+        assertEquals("f:someFunc(6) > 8", getELText(_structuredDocument,967));
+        assertEquals("f:someFunc(6)", getELText(_structuredDocument,1018));
+        assertEquals("f:someFunc(true)", getELText(_structuredDocument,1065));
+        assertEquals("someFunc(6) > 8", getELText(_structuredDocument,1260));
+        assertEquals("someFunc(6)", getELText(_structuredDocument,1309));
+        assertEquals("someFunc(true)", getELText(_structuredDocument,1354));
+    }
+
+    public void testNoErrorExprs() 
+    {
+        assertNoError(967, null);
+        assertNoError(1018, null);
+        assertNoError(1065, null);
+    }
+
+    public void testWarningExprs() 
+    {
+        // note: this will change to non-error when functions are properly supported
+        // by the parser
+        List list = assertSyntaxWarning(1260, 1);
+        assertContainsProblem(list, 0);
+
+        list = assertSyntaxWarning(1309, 1);
+        assertContainsProblem(list, 0);
+        
+        list = assertSyntaxWarning(1354, 1);
+        assertContainsProblem(list, 0);
+    }
+    
+    public void testErrorExprs() 
+    {
+        // no error cases
+    }
+
+}
diff --git a/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/src/org/eclipse/jst/jsf/validation/el/tests/jsp/LessThanEqTestCase.java b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/src/org/eclipse/jst/jsf/validation/el/tests/jsp/LessThanEqTestCase.java
new file mode 100644
index 0000000..6aaefc4
--- /dev/null
+++ b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/src/org/eclipse/jst/jsf/validation/el/tests/jsp/LessThanEqTestCase.java
@@ -0,0 +1,164 @@
+package org.eclipse.jst.jsf.validation.el.tests.jsp;
+
+import java.util.List;
+
+import org.eclipse.jdt.core.Signature;
+import org.eclipse.jst.jsf.validation.el.tests.base.SingleJSPTestCase;
+import org.eclipse.jst.jsf.validation.internal.el.diagnostics.DiagnosticFactory;
+
+public class LessThanEqTestCase extends SingleJSPTestCase {
+    protected void setUp() throws Exception 
+    {
+        _srcFileName = "/testdata/jsps/lessThanEq.jsp.data";
+        _destFileName = "/lessThanEq.jsp";
+
+        super.setUp();
+    }
+
+    public void testSanity()
+    {
+        super.testSanity();
+        
+        assertEquals("myBean.stringProperty <= '3'", getELText(_structuredDocument,852));
+        assertEquals("myBean.stringProperty le '3'", getELText(_structuredDocument,914));
+        assertEquals("myBean.integerProperty <= 3", getELText(_structuredDocument,976));
+        assertEquals("myBean.integerProperty le 3", getELText(_structuredDocument,1037));
+        assertEquals("myBean.integerProperty <= '4' ", getELText(_structuredDocument,1098));
+        assertEquals("myBean.integerProperty le '4' ", getELText(_structuredDocument,1162));
+        assertEquals("myBean.comparableProperty <= myBean.collectionProperty", getELText(_structuredDocument,1227));
+        assertEquals("myBean.comparableProperty le myBean.collectionProperty", getELText(_structuredDocument,1315));
+        assertEquals("myBean.integerProperty <= -3", getELText(_structuredDocument,1405));
+        assertEquals("myBean.doubleProperty <= 5", getELText(_structuredDocument,1467));
+        assertEquals("5 le myBean.bigIntegerProperty", getELText(_structuredDocument,1526));
+        assertEquals("myBean.bigDoubleProperty <= myBean.bigIntegerProperty", getELText(_structuredDocument,1590));
+
+        assertEquals("5 <= 3", getELText(_structuredDocument,1705));
+        assertEquals("5 le 3", getELText(_structuredDocument,1742));
+        assertEquals("'4' <= '34'", getELText(_structuredDocument,1779));
+        assertEquals("'4' le '34'", getELText(_structuredDocument,1821));
+        assertEquals("'34' <= '34'", getELText(_structuredDocument,1863));
+        assertEquals("'34' le '34'", getELText(_structuredDocument,1906));
+        assertEquals("-5 <= 2", getELText(_structuredDocument,1949));
+        assertEquals("-5 le 2", getELText(_structuredDocument,1987));
+        assertEquals("2 <= -5", getELText(_structuredDocument,2025));
+        assertEquals("2 le -5", getELText(_structuredDocument,2063));
+        assertEquals("-5 <= -5", getELText(_structuredDocument,2101));
+        assertEquals("-5 le -5", getELText(_structuredDocument,2140));
+        assertEquals("myBean.integerProperty <= null", getELText(_structuredDocument,2179));
+        assertEquals("null le myBean.integerProperty", getELText(_structuredDocument,2239));
+
+        assertEquals("5 <= true", getELText(_structuredDocument,2323));
+        assertEquals("5 le true", getELText(_structuredDocument,2363));
+        assertEquals("myBean.integerProperty <= myBean.booleanProperty", getELText(_structuredDocument,2403));
+        assertEquals("myBean.integerProperty le myBean.booleanProperty", getELText(_structuredDocument,2482));
+        assertEquals("myBean.stringArrayProperty <= myBean.booleanProperty", getELText(_structuredDocument,2561));
+        assertEquals("myBean.stringArrayProperty le myBean.booleanProperty", getELText(_structuredDocument,2644));
+        assertEquals("myBean.integerProperty <= true ", getELText(_structuredDocument,2730));
+        assertEquals("myBean.integerProperty le true ", getELText(_structuredDocument,2795));
+        assertEquals("myBean.booleanProperty <= true", getELText(_structuredDocument,2860));
+        assertEquals("myBean.booleanProperty le true", getELText(_structuredDocument,2924));
+        assertEquals("true <= false", getELText(_structuredDocument,2986));
+        assertEquals("true le false", getELText(_structuredDocument,3031));    
+    }
+    
+    public void testNoErrorExprs() 
+    {
+        assertNoError(852, Signature.SIG_BOOLEAN);
+        assertNoError(914, Signature.SIG_BOOLEAN);
+        assertNoError(976, Signature.SIG_BOOLEAN);
+        assertNoError(1037, Signature.SIG_BOOLEAN);
+        assertNoError(1098, Signature.SIG_BOOLEAN);
+        assertNoError(1162, Signature.SIG_BOOLEAN);
+        assertNoError(1227, Signature.SIG_BOOLEAN);
+        assertNoError(1315, Signature.SIG_BOOLEAN);
+        assertNoError(1405, Signature.SIG_BOOLEAN);
+        assertNoError(1467, Signature.SIG_BOOLEAN);
+        assertNoError(1526, Signature.SIG_BOOLEAN);
+        assertNoError(1590, Signature.SIG_BOOLEAN);
+    }
+
+    public void testWarningExprs() 
+    {
+        List list = assertSemanticWarning(1705, Signature.SIG_BOOLEAN, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_CONSTANT_EXPRESSION_ALWAYS_EVAL_SAME_ID);
+
+        list = assertSemanticWarning(1742, Signature.SIG_BOOLEAN, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_CONSTANT_EXPRESSION_ALWAYS_EVAL_SAME_ID);
+
+        list = assertSemanticWarning(1779, Signature.SIG_BOOLEAN, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_CONSTANT_EXPRESSION_ALWAYS_EVAL_SAME_ID);
+
+        list = assertSemanticWarning(1821, Signature.SIG_BOOLEAN, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_CONSTANT_EXPRESSION_ALWAYS_EVAL_SAME_ID);
+
+        list = assertSemanticWarning(1863, Signature.SIG_BOOLEAN, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_CONSTANT_EXPRESSION_ALWAYS_EVAL_SAME_ID);
+
+        list = assertSemanticWarning(1906, Signature.SIG_BOOLEAN, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_CONSTANT_EXPRESSION_ALWAYS_EVAL_SAME_ID);
+
+        list = assertSemanticWarning(1949, Signature.SIG_BOOLEAN, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_CONSTANT_EXPRESSION_ALWAYS_EVAL_SAME_ID);
+
+        list = assertSemanticWarning(1987, Signature.SIG_BOOLEAN, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_CONSTANT_EXPRESSION_ALWAYS_EVAL_SAME_ID);
+
+        list = assertSemanticWarning(2025, Signature.SIG_BOOLEAN, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_CONSTANT_EXPRESSION_ALWAYS_EVAL_SAME_ID);
+
+        list = assertSemanticWarning(2063, Signature.SIG_BOOLEAN, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_CONSTANT_EXPRESSION_ALWAYS_EVAL_SAME_ID);
+
+        list = assertSemanticWarning(2101, Signature.SIG_BOOLEAN, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_CONSTANT_EXPRESSION_ALWAYS_EVAL_SAME_ID);
+
+        list = assertSemanticWarning(2140, Signature.SIG_BOOLEAN, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_CONSTANT_EXPRESSION_ALWAYS_EVAL_SAME_ID);
+
+        list = assertSemanticWarning(2179, Signature.SIG_BOOLEAN, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_EQUALITY_COMP_WITH_NULL_ALWAYS_EVAL_SAME_ID);
+
+        list = assertSemanticWarning(2239, Signature.SIG_BOOLEAN, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_EQUALITY_COMP_WITH_NULL_ALWAYS_EVAL_SAME_ID);
+
+    }
+
+    public void testErrorExprs() 
+    {
+        List list = assertSemanticError(2323, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_COULD_NOT_MAKE_NUMERIC_COERCION_ID);
+
+        list = assertSemanticError(2363, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_COULD_NOT_MAKE_NUMERIC_COERCION_ID);
+
+        list = assertSemanticError(2403, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_COULD_NOT_MAKE_NUMERIC_COERCION_ID);
+
+        list = assertSemanticError(2482, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_COULD_NOT_MAKE_NUMERIC_COERCION_ID);
+
+        list = assertSemanticError(2561, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_NO_AVAILABLE_TYPE_COERCION_ID);
+
+        list = assertSemanticError(2644, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_NO_AVAILABLE_TYPE_COERCION_ID);
+
+        list = assertSemanticError(2730, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_COULD_NOT_MAKE_NUMERIC_COERCION_ID);
+
+        list = assertSemanticError(2795, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_COULD_NOT_MAKE_NUMERIC_COERCION_ID);
+
+        list = assertSemanticError(2860, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_NO_AVAILABLE_TYPE_COERCION_ID);
+
+        list = assertSemanticError(2924, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_NO_AVAILABLE_TYPE_COERCION_ID);
+
+        list = assertSemanticError(2986, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_NO_AVAILABLE_TYPE_COERCION_ID);
+
+        list = assertSemanticError(3031, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_NO_AVAILABLE_TYPE_COERCION_ID);
+    }
+}
diff --git a/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/src/org/eclipse/jst/jsf/validation/el/tests/jsp/LessThanTestCase.java b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/src/org/eclipse/jst/jsf/validation/el/tests/jsp/LessThanTestCase.java
new file mode 100644
index 0000000..f4f6a7f
--- /dev/null
+++ b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/src/org/eclipse/jst/jsf/validation/el/tests/jsp/LessThanTestCase.java
@@ -0,0 +1,165 @@
+package org.eclipse.jst.jsf.validation.el.tests.jsp;
+
+import java.util.List;
+
+import org.eclipse.jdt.core.Signature;
+import org.eclipse.jst.jsf.validation.el.tests.base.SingleJSPTestCase;
+import org.eclipse.jst.jsf.validation.internal.el.diagnostics.DiagnosticFactory;
+
+public class LessThanTestCase extends SingleJSPTestCase 
+{
+    protected void setUp() throws Exception 
+    {
+        _srcFileName = "/testdata/jsps/lessThan.jsp.data";
+        _destFileName = "/lessThan.jsp";
+
+        super.setUp();
+    }
+
+    public void testSanity()
+    {
+        super.testSanity();
+        
+        assertEquals("myBean.stringProperty < '3'", getELText(_structuredDocument,852));
+        assertEquals("myBean.stringProperty lt '3'", getELText(_structuredDocument,913));
+        assertEquals("myBean.integerProperty < 3", getELText(_structuredDocument,975));
+        assertEquals("myBean.integerProperty lt 3", getELText(_structuredDocument,1035));
+        assertEquals("myBean.integerProperty < '4' ", getELText(_structuredDocument,1096));
+        assertEquals("myBean.integerProperty lt '4' ", getELText(_structuredDocument,1159));
+        assertEquals("myBean.comparableProperty < myBean.collectionProperty", getELText(_structuredDocument,1224));
+        assertEquals("myBean.comparableProperty lt myBean.collectionProperty", getELText(_structuredDocument,1311));
+        assertEquals("myBean.integerProperty < -3", getELText(_structuredDocument,1399));
+        assertEquals("myBean.doubleProperty < 5", getELText(_structuredDocument,1460));
+        assertEquals("5 lt myBean.bigIntegerProperty", getELText(_structuredDocument,1519));
+        assertEquals("myBean.bigDoubleProperty < myBean.bigIntegerProperty", getELText(_structuredDocument,1583));
+
+        assertEquals("5 < 3", getELText(_structuredDocument,1695));
+        assertEquals("5 lt 3", getELText(_structuredDocument,1731));
+        assertEquals("'4' < '34'", getELText(_structuredDocument,1768));
+        assertEquals("'4' lt '34'", getELText(_structuredDocument,1809));
+        assertEquals("'34' < '34'", getELText(_structuredDocument,1851));
+        assertEquals("'34' lt '34'", getELText(_structuredDocument,1893));
+        assertEquals("-5 < 2", getELText(_structuredDocument,1936));
+        assertEquals("-5 lt 2", getELText(_structuredDocument,1973));
+        assertEquals("2 < -5", getELText(_structuredDocument,2011));
+        assertEquals("2 lt -5", getELText(_structuredDocument,2048));
+        assertEquals("-5 < -5", getELText(_structuredDocument,2086));
+        assertEquals("-5 lt -5", getELText(_structuredDocument,2124));
+        assertEquals("myBean.integerProperty < null", getELText(_structuredDocument,2163));
+        assertEquals("null lt myBean.integerProperty", getELText(_structuredDocument,2223));
+
+        assertEquals("5 < true", getELText(_structuredDocument,2307));
+        assertEquals("5 lt true", getELText(_structuredDocument,2346));
+        assertEquals("myBean.integerProperty < myBean.booleanProperty", getELText(_structuredDocument,2386));
+        assertEquals("myBean.integerProperty lt myBean.booleanProperty", getELText(_structuredDocument,2464));
+        assertEquals("myBean.stringArrayProperty < myBean.booleanProperty", getELText(_structuredDocument,2543));
+        assertEquals("myBean.stringArrayProperty lt myBean.booleanProperty", getELText(_structuredDocument,2625));
+        assertEquals("myBean.integerProperty < true ", getELText(_structuredDocument,2711));
+        assertEquals("myBean.integerProperty lt true ", getELText(_structuredDocument,2775));
+        assertEquals("myBean.booleanProperty < true", getELText(_structuredDocument,2840));
+        assertEquals("myBean.booleanProperty lt true", getELText(_structuredDocument,2903));
+        assertEquals("true < false", getELText(_structuredDocument,2965));
+        assertEquals("true lt false", getELText(_structuredDocument,3009));
+    }
+    
+    public void testNoErrorExprs() 
+    {
+        assertNoError(852, Signature.SIG_BOOLEAN);
+        assertNoError(913, Signature.SIG_BOOLEAN);
+        assertNoError(975, Signature.SIG_BOOLEAN);
+        assertNoError(1035, Signature.SIG_BOOLEAN);
+        assertNoError(1096, Signature.SIG_BOOLEAN);
+        assertNoError(1159, Signature.SIG_BOOLEAN);
+        assertNoError(1224, Signature.SIG_BOOLEAN);
+        assertNoError(1311, Signature.SIG_BOOLEAN);
+        assertNoError(1399, Signature.SIG_BOOLEAN);
+        assertNoError(1460, Signature.SIG_BOOLEAN);
+        assertNoError(1519, Signature.SIG_BOOLEAN);
+        assertNoError(1583, Signature.SIG_BOOLEAN);
+    }
+
+    public void testWarningExprs() 
+    {
+        List list = assertSemanticWarning(1695, Signature.SIG_BOOLEAN, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_CONSTANT_EXPRESSION_ALWAYS_EVAL_SAME_ID);
+
+        list = assertSemanticWarning(1731, Signature.SIG_BOOLEAN, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_CONSTANT_EXPRESSION_ALWAYS_EVAL_SAME_ID);
+
+        list = assertSemanticWarning(1768, Signature.SIG_BOOLEAN, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_CONSTANT_EXPRESSION_ALWAYS_EVAL_SAME_ID);
+
+        list = assertSemanticWarning(1809, Signature.SIG_BOOLEAN, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_CONSTANT_EXPRESSION_ALWAYS_EVAL_SAME_ID);
+
+        list = assertSemanticWarning(1851, Signature.SIG_BOOLEAN, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_CONSTANT_EXPRESSION_ALWAYS_EVAL_SAME_ID);
+
+        list = assertSemanticWarning(1893, Signature.SIG_BOOLEAN, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_CONSTANT_EXPRESSION_ALWAYS_EVAL_SAME_ID);
+
+        list = assertSemanticWarning(1936, Signature.SIG_BOOLEAN, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_CONSTANT_EXPRESSION_ALWAYS_EVAL_SAME_ID);
+
+        list = assertSemanticWarning(1973, Signature.SIG_BOOLEAN, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_CONSTANT_EXPRESSION_ALWAYS_EVAL_SAME_ID);
+
+        list = assertSemanticWarning(2011, Signature.SIG_BOOLEAN, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_CONSTANT_EXPRESSION_ALWAYS_EVAL_SAME_ID);
+
+        list = assertSemanticWarning(2048, Signature.SIG_BOOLEAN, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_CONSTANT_EXPRESSION_ALWAYS_EVAL_SAME_ID);
+
+        list = assertSemanticWarning(2086, Signature.SIG_BOOLEAN, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_CONSTANT_EXPRESSION_ALWAYS_EVAL_SAME_ID);
+
+        list = assertSemanticWarning(2124, Signature.SIG_BOOLEAN, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_CONSTANT_EXPRESSION_ALWAYS_EVAL_SAME_ID);
+
+        list = assertSemanticWarning(2163, Signature.SIG_BOOLEAN, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_EQUALITY_COMP_WITH_NULL_ALWAYS_EVAL_SAME_ID);
+
+        list = assertSemanticWarning(2223, Signature.SIG_BOOLEAN, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_EQUALITY_COMP_WITH_NULL_ALWAYS_EVAL_SAME_ID);
+
+    }
+
+    public void testErrorExprs() 
+    {
+        List list = assertSemanticError(2307, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_COULD_NOT_MAKE_NUMERIC_COERCION_ID);
+
+        list = assertSemanticError(2346, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_COULD_NOT_MAKE_NUMERIC_COERCION_ID);
+
+        list = assertSemanticError(2386, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_COULD_NOT_MAKE_NUMERIC_COERCION_ID);
+
+        list = assertSemanticError(2464, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_COULD_NOT_MAKE_NUMERIC_COERCION_ID);
+
+        list = assertSemanticError(2543, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_NO_AVAILABLE_TYPE_COERCION_ID);
+
+        list = assertSemanticError(2625, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_NO_AVAILABLE_TYPE_COERCION_ID);
+
+        list = assertSemanticError(2711, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_COULD_NOT_MAKE_NUMERIC_COERCION_ID);
+
+        list = assertSemanticError(2775, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_COULD_NOT_MAKE_NUMERIC_COERCION_ID);
+
+        list = assertSemanticError(2840, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_NO_AVAILABLE_TYPE_COERCION_ID);
+
+        list = assertSemanticError(2903, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_NO_AVAILABLE_TYPE_COERCION_ID);
+
+        list = assertSemanticError(2965, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_NO_AVAILABLE_TYPE_COERCION_ID);
+
+        list = assertSemanticError(3009, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_NO_AVAILABLE_TYPE_COERCION_ID);
+    }
+}
diff --git a/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/src/org/eclipse/jst/jsf/validation/el/tests/jsp/LoadBundleResolutionTestCase.java b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/src/org/eclipse/jst/jsf/validation/el/tests/jsp/LoadBundleResolutionTestCase.java
new file mode 100644
index 0000000..7696690
--- /dev/null
+++ b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/src/org/eclipse/jst/jsf/validation/el/tests/jsp/LoadBundleResolutionTestCase.java
@@ -0,0 +1,65 @@
+package org.eclipse.jst.jsf.validation.el.tests.jsp;
+
+import java.util.List;
+
+import org.eclipse.jdt.core.Signature;
+import org.eclipse.jst.jsf.core.internal.types.TypeConstants;
+import org.eclipse.jst.jsf.validation.el.tests.base.SingleJSPTestCase;
+import org.eclipse.jst.jsf.validation.internal.el.diagnostics.DiagnosticFactory;
+
+public class LoadBundleResolutionTestCase extends SingleJSPTestCase 
+{
+    protected void setUp() throws Exception
+    {
+        _srcFileName = "/testdata/jsps/loadBundleResolution.jsp.data";
+        _destFileName = "/loadBundleResolution.jsp";
+        super.setUp();
+    }
+
+    public void testSanity()
+    {
+        assertEquals("bundle.bundleProp2", getELText(_structuredDocument,972));
+        assertEquals("bundle.bundleProp1 && myBean.stringProperty", getELText(_structuredDocument,1024));
+        assertEquals("empty bundle", getELText(_structuredDocument,1101));
+        assertEquals("empty bundle.bundleProp2", getELText(_structuredDocument,1147));
+        assertEquals("bundle.bundleProp2 + 5", getELText(_structuredDocument,1205));
+        assertEquals("bundleProp2", getELText(_structuredDocument,1258));
+        assertEquals("bundle.x.y", getELText(_structuredDocument,1300));
+
+        assertEquals("-bundle.bundleProp1", getELText(_structuredDocument,1368));
+        assertEquals("bundle.bundleProp3", getELText(_structuredDocument,1421));
+        assertEquals("msg", getELText(_structuredDocument,1473));
+        assertEquals("bundle.x", getELText(_structuredDocument,1510));
+    }
+
+    public void testNoErrorExprs() 
+    {
+        assertNoError(972, TypeConstants.TYPE_STRING);
+        assertNoError(1024, Signature.SIG_BOOLEAN);
+        assertNoError(1101, Signature.SIG_BOOLEAN);
+        assertNoError(1147, Signature.SIG_BOOLEAN);
+        assertNoError(1205, Signature.SIG_LONG);
+        //assertNoError(1258, TypeConstants.TYPE_STRING);
+        assertNoError(1300, TypeConstants.TYPE_STRING);
+    }
+
+    public void testWarningExprs() 
+    {
+        List list = assertSemanticWarning(1368, Signature.SIG_LONG, 1);
+        assertContainsProblem(list, DiagnosticFactory.UNARY_OP_STRING_CONVERSION_NOT_GUARANTEED);
+
+        list = assertSemanticWarning(1421, null, 1);
+        assertContainsProblem(list, 0);
+
+        list = assertSemanticWarning(1473, null, 1);
+        assertContainsProblem(list, 0);
+        
+        list = assertSemanticWarning(1510, null, 1);
+        assertContainsProblem(list, 0);
+    }
+    
+    public void testErrorExprs() 
+    {
+        // no error
+    }
+}
diff --git a/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/src/org/eclipse/jst/jsf/validation/el/tests/jsp/LogicalAndTestCase.java b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/src/org/eclipse/jst/jsf/validation/el/tests/jsp/LogicalAndTestCase.java
new file mode 100644
index 0000000..223b451
--- /dev/null
+++ b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/src/org/eclipse/jst/jsf/validation/el/tests/jsp/LogicalAndTestCase.java
@@ -0,0 +1,108 @@
+package org.eclipse.jst.jsf.validation.el.tests.jsp;
+
+import java.util.List;
+
+import org.eclipse.jdt.core.Signature;
+import org.eclipse.jst.jsf.validation.el.tests.base.SingleJSPTestCase;
+import org.eclipse.jst.jsf.validation.internal.el.diagnostics.DiagnosticFactory;
+
+public class LogicalAndTestCase extends SingleJSPTestCase
+{
+
+    protected void setUp() throws Exception
+    {
+        _srcFileName = "/testdata/jsps/logicalAND.jsp.data";
+        _destFileName = "/logicalAND.jsp";
+        super.setUp();
+    }
+
+    public void testSanity()
+    {
+        assertEquals("myBean.booleanProperty && myBean.booleanProperty", getELText(_structuredDocument,852));
+        assertEquals("myBean.booleanProperty and myBean.booleanProperty", getELText(_structuredDocument,934));
+        assertEquals("myBean.booleanProperty && true ", getELText(_structuredDocument,1014));
+        assertEquals("myBean.booleanProperty and true ", getELText(_structuredDocument,1076));
+        assertEquals("'true' && myBean.booleanProperty", getELText(_structuredDocument,1142));
+        assertEquals("'true' and myBean.booleanProperty", getELText(_structuredDocument,1209));
+
+        assertEquals("false && myBean.booleanProperty", getELText(_structuredDocument,1301));
+        assertEquals("false and myBean.booleanProperty", getELText(_structuredDocument,1366));
+        assertEquals("null && myBean.booleanProperty ", getELText(_structuredDocument,1432));
+        assertEquals("null and myBean.booleanProperty ", getELText(_structuredDocument,1497));
+        assertEquals("'notTrue' && myBean.booleanProperty", getELText(_structuredDocument,1563));
+        assertEquals("myBean.booleanProperty && false", getELText(_structuredDocument,1636));
+        assertEquals("myBean.booleanProperty and false", getELText(_structuredDocument,1701));
+        assertEquals("myBean.booleanProperty && null ", getELText(_structuredDocument,1767));
+        assertEquals("myBean.booleanProperty and null", getELText(_structuredDocument,1832));
+        assertEquals("myBean.booleanProperty && 'notTrue'", getELText(_structuredDocument,1897));
+        assertEquals("true && false", getELText(_structuredDocument,1965));
+        assertEquals("null && true", getELText(_structuredDocument,2009));
+        
+        assertEquals("myBean.integerProperty && true", getELText(_structuredDocument,2084));
+        assertEquals("true && myBean.integerProperty", getELText(_structuredDocument,2148));
+        assertEquals("4 && true", getELText(_structuredDocument,2212));
+    }
+    
+
+
+    public void testNoErrorExprs() 
+    {
+        assertNoError(852, Signature.SIG_BOOLEAN);
+        assertNoError(934, Signature.SIG_BOOLEAN);
+        assertNoError(1014, Signature.SIG_BOOLEAN);
+        assertNoError(1076, Signature.SIG_BOOLEAN);
+        assertNoError(1142, Signature.SIG_BOOLEAN);
+        assertNoError(1209, Signature.SIG_BOOLEAN);
+    }
+
+    public void testWarningExprs() 
+    {
+        List list = assertSemanticWarning(1301, Signature.SIG_BOOLEAN, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_FIRST_ARGUMENT_SHORT_CIRCUITS_ID);
+
+        list = assertSemanticWarning(1366, Signature.SIG_BOOLEAN, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_FIRST_ARGUMENT_SHORT_CIRCUITS_ID);
+
+        list = assertSemanticWarning(1432, Signature.SIG_BOOLEAN, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_FIRST_ARGUMENT_SHORT_CIRCUITS_ID);
+
+        list = assertSemanticWarning(1497, Signature.SIG_BOOLEAN, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_FIRST_ARGUMENT_SHORT_CIRCUITS_ID);
+
+        list = assertSemanticWarning(1563, Signature.SIG_BOOLEAN, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_FIRST_ARGUMENT_SHORT_CIRCUITS_ID);
+
+        list = assertSemanticWarning(1636, Signature.SIG_BOOLEAN, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_SECOND_ARGUMENT_ALWAYS_EVAL_SAME_ID);
+        
+        list = assertSemanticWarning(1701, Signature.SIG_BOOLEAN, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_SECOND_ARGUMENT_ALWAYS_EVAL_SAME_ID);
+
+        list = assertSemanticWarning(1767, Signature.SIG_BOOLEAN, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_SECOND_ARGUMENT_ALWAYS_EVAL_SAME_ID);
+
+        list = assertSemanticWarning(1832, Signature.SIG_BOOLEAN, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_SECOND_ARGUMENT_ALWAYS_EVAL_SAME_ID);
+
+        list = assertSemanticWarning(1897, Signature.SIG_BOOLEAN, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_SECOND_ARGUMENT_ALWAYS_EVAL_SAME_ID);
+
+        list = assertSemanticWarning(1965, Signature.SIG_BOOLEAN, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_SECOND_ARGUMENT_ALWAYS_EVAL_SAME_ID);
+
+        list = assertSemanticWarning(2009, Signature.SIG_BOOLEAN, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_FIRST_ARGUMENT_SHORT_CIRCUITS_ID);
+    }
+
+    public void testErrorExprs() 
+    {
+        List list = assertSemanticError(2084, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_CANNOT_COERCE_ARGUMENT_TO_BOOLEAN_ID);
+
+        list = assertSemanticError(2148, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_CANNOT_COERCE_ARGUMENT_TO_BOOLEAN_ID);
+
+        list = assertSemanticError(2212, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_CANNOT_COERCE_ARGUMENT_TO_BOOLEAN_ID);
+    }
+}
diff --git a/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/src/org/eclipse/jst/jsf/validation/el/tests/jsp/LogicalEqualsTestCase.java b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/src/org/eclipse/jst/jsf/validation/el/tests/jsp/LogicalEqualsTestCase.java
new file mode 100644
index 0000000..d25305b
--- /dev/null
+++ b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/src/org/eclipse/jst/jsf/validation/el/tests/jsp/LogicalEqualsTestCase.java
@@ -0,0 +1,143 @@
+package org.eclipse.jst.jsf.validation.el.tests.jsp;
+
+import java.util.List;
+
+import org.eclipse.jdt.core.Signature;
+import org.eclipse.jst.jsf.validation.el.tests.base.SingleJSPTestCase;
+import org.eclipse.jst.jsf.validation.internal.el.diagnostics.DiagnosticFactory;
+
+public class LogicalEqualsTestCase extends SingleJSPTestCase 
+{
+    protected void setUp() throws Exception
+    {
+        _srcFileName = "/testdata/jsps/logicalEquals.jsp.data";
+        _destFileName = "/logicalEquals.jsp";
+        super.setUp();
+    }
+
+    public void testSanity()
+    {
+        assertEquals("myBean.stringProperty == '3'", getELText(_structuredDocument,852));
+        assertEquals("myBean.stringProperty eq '3'", getELText(_structuredDocument,914));
+        assertEquals("myBean.integerProperty == 3", getELText(_structuredDocument,976));
+        assertEquals("myBean.integerProperty eq 3", getELText(_structuredDocument,1037));
+        assertEquals("myBean.booleanProperty == true", getELText(_structuredDocument,1098));
+        assertEquals("myBean.booleanProperty eq true", getELText(_structuredDocument,1162));
+        assertEquals("myBean.integerProperty == '4' ", getELText(_structuredDocument,1226));
+        assertEquals("myBean.integerProperty eq '4' ", getELText(_structuredDocument,1290));
+        assertEquals("myBean.bigDoubleProperty == 4.5", getELText(_structuredDocument,1354));
+        assertEquals("myBean.doubleProperty eq 67", getELText(_structuredDocument,1419));
+        assertEquals("myBean.bigIntegerProperty == 500", getELText(_structuredDocument,1480));
+        assertEquals("myBean.stringArrayProperty == '3'", getELText(_structuredDocument,1546));
+        assertEquals("myBean.stringArrayProperty eq myBean.listProperty", getELText(_structuredDocument,1613));
+
+        assertEquals("5 == 3", getELText(_structuredDocument,1717));
+        assertEquals("5 eq 3", getELText(_structuredDocument,1754));
+        assertEquals("true == false", getELText(_structuredDocument,1791));
+        assertEquals("true eq false", getELText(_structuredDocument,1835));
+        assertEquals("'4' == '34'", getELText(_structuredDocument,1879));
+        assertEquals("'4' eq '34'", getELText(_structuredDocument,1921));
+        assertEquals("'34' == '34'", getELText(_structuredDocument,1963));
+        assertEquals("'34' eq '34'", getELText(_structuredDocument,2006));
+        assertEquals("myBean.integerProperty == null", getELText(_structuredDocument,2049));
+        assertEquals("null eq myBean.integerProperty", getELText(_structuredDocument,2110));
+        assertEquals("5.4 == 4.3", getELText(_structuredDocument,2171));
+        assertEquals("true == true", getELText(_structuredDocument,2212));
+
+        assertEquals("5 == true", getELText(_structuredDocument,2276));
+        assertEquals("5 eq true", getELText(_structuredDocument,2316));
+        assertEquals("myBean.integerProperty == myBean.booleanProperty", getELText(_structuredDocument,2356));
+        assertEquals("myBean.integerProperty eq myBean.booleanProperty", getELText(_structuredDocument,2435));
+        assertEquals("myBean.stringArrayProperty == myBean.booleanProperty", getELText(_structuredDocument,2514));
+        assertEquals("myBean.booleanProperty eq myBean.stringArrayProperty", getELText(_structuredDocument,2597));
+        assertEquals("myBean.integerProperty == true ", getELText(_structuredDocument,2683));
+        assertEquals("myBean.integerProperty eq true ", getELText(_structuredDocument,2748));
+        assertEquals("false == myBean.integerProperty", getELText(_structuredDocument,2813));  
+    }
+
+    public void testNoErrorExprs() 
+    {
+        assertNoError(852, Signature.SIG_BOOLEAN);
+        assertNoError(914, Signature.SIG_BOOLEAN);
+        assertNoError(976, Signature.SIG_BOOLEAN);
+        assertNoError(1037, Signature.SIG_BOOLEAN);
+        assertNoError(1098, Signature.SIG_BOOLEAN);
+        assertNoError(1162, Signature.SIG_BOOLEAN);
+        assertNoError(1226, Signature.SIG_BOOLEAN);
+        assertNoError(1290, Signature.SIG_BOOLEAN);
+        assertNoError(1354, Signature.SIG_BOOLEAN);
+        assertNoError(1419, Signature.SIG_BOOLEAN);
+        assertNoError(1480, Signature.SIG_BOOLEAN);
+        assertNoError(1546, Signature.SIG_BOOLEAN);
+        assertNoError(1613, Signature.SIG_BOOLEAN);
+    }
+
+    public void testWarningExprs() 
+    {
+        List list = assertSemanticWarning(1717, Signature.SIG_BOOLEAN, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_CONSTANT_EXPRESSION_ALWAYS_EVAL_SAME_ID);
+        
+        list = assertSemanticWarning(1754, Signature.SIG_BOOLEAN, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_CONSTANT_EXPRESSION_ALWAYS_EVAL_SAME_ID);
+
+        list = assertSemanticWarning(1791, Signature.SIG_BOOLEAN, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_CONSTANT_EXPRESSION_ALWAYS_EVAL_SAME_ID);
+
+        list = assertSemanticWarning(1835, Signature.SIG_BOOLEAN, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_CONSTANT_EXPRESSION_ALWAYS_EVAL_SAME_ID);
+
+        list = assertSemanticWarning(1879, Signature.SIG_BOOLEAN, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_CONSTANT_EXPRESSION_ALWAYS_EVAL_SAME_ID);
+
+        list = assertSemanticWarning(1921, Signature.SIG_BOOLEAN, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_CONSTANT_EXPRESSION_ALWAYS_EVAL_SAME_ID);
+
+        list = assertSemanticWarning(1963, Signature.SIG_BOOLEAN, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_CONSTANT_EXPRESSION_ALWAYS_EVAL_SAME_ID);
+
+        list = assertSemanticWarning(2006, Signature.SIG_BOOLEAN, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_CONSTANT_EXPRESSION_ALWAYS_EVAL_SAME_ID);
+
+        list = assertSemanticWarning(2049, Signature.SIG_BOOLEAN, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_EQUALITY_COMP_WITH_NULL_ALWAYS_EVAL_SAME_ID);
+
+        list = assertSemanticWarning(2110, Signature.SIG_BOOLEAN, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_EQUALITY_COMP_WITH_NULL_ALWAYS_EVAL_SAME_ID);
+
+        list = assertSemanticWarning(2171, Signature.SIG_BOOLEAN, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_CONSTANT_EXPRESSION_ALWAYS_EVAL_SAME_ID);
+
+        list = assertSemanticWarning(2212, Signature.SIG_BOOLEAN, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_CONSTANT_EXPRESSION_ALWAYS_EVAL_SAME_ID);
+    }
+
+    public void testErrorExprs() 
+    {
+        List list = assertSemanticError(2276, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_COULD_NOT_MAKE_NUMERIC_COERCION_ID);
+
+        list = assertSemanticError(2316, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_COULD_NOT_MAKE_NUMERIC_COERCION_ID);
+
+        list = assertSemanticError(2356, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_COULD_NOT_MAKE_NUMERIC_COERCION_ID);
+
+        list = assertSemanticError(2435, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_COULD_NOT_MAKE_NUMERIC_COERCION_ID);
+
+        list = assertSemanticError(2514, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_CANNOT_COERCE_ARGUMENT_TO_BOOLEAN_ID);
+
+        list = assertSemanticError(2597, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_CANNOT_COERCE_ARGUMENT_TO_BOOLEAN_ID);
+
+        list = assertSemanticError(2683, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_COULD_NOT_MAKE_NUMERIC_COERCION_ID);
+
+        list = assertSemanticError(2748, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_COULD_NOT_MAKE_NUMERIC_COERCION_ID);
+        
+        list = assertSemanticError(2813, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_COULD_NOT_MAKE_NUMERIC_COERCION_ID);
+    }
+}
diff --git a/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/src/org/eclipse/jst/jsf/validation/el/tests/jsp/LogicalNotEqualsTestCase.java b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/src/org/eclipse/jst/jsf/validation/el/tests/jsp/LogicalNotEqualsTestCase.java
new file mode 100644
index 0000000..add1dce
--- /dev/null
+++ b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/src/org/eclipse/jst/jsf/validation/el/tests/jsp/LogicalNotEqualsTestCase.java
@@ -0,0 +1,143 @@
+package org.eclipse.jst.jsf.validation.el.tests.jsp;
+
+import java.util.List;
+
+import org.eclipse.jdt.core.Signature;
+import org.eclipse.jst.jsf.validation.el.tests.base.SingleJSPTestCase;
+import org.eclipse.jst.jsf.validation.internal.el.diagnostics.DiagnosticFactory;
+
+public class LogicalNotEqualsTestCase extends SingleJSPTestCase 
+{
+    protected void setUp() throws Exception
+    {
+        _srcFileName = "/testdata/jsps/logicalNotEquals.jsp.data";
+        _destFileName = "/logicalNotEquals.jsp";
+        super.setUp();
+    }
+
+    public void testSanity()
+    {
+        assertEquals("myBean.stringProperty != '3'", getELText(_structuredDocument,852));
+        assertEquals("myBean.stringProperty ne '3'", getELText(_structuredDocument,914));
+        assertEquals("myBean.integerProperty != 3", getELText(_structuredDocument,976));
+        assertEquals("myBean.integerProperty ne 3", getELText(_structuredDocument,1037));
+        assertEquals("myBean.booleanProperty != true", getELText(_structuredDocument,1098));
+        assertEquals("myBean.booleanProperty ne true", getELText(_structuredDocument,1162));
+        assertEquals("myBean.integerProperty != '4' ", getELText(_structuredDocument,1226));
+        assertEquals("myBean.integerProperty ne '4' ", getELText(_structuredDocument,1290));
+        assertEquals("myBean.bigDoubleProperty != 4.5", getELText(_structuredDocument,1354));
+        assertEquals("myBean.doubleProperty ne 67", getELText(_structuredDocument,1419));
+        assertEquals("myBean.bigIntegerProperty != 500", getELText(_structuredDocument,1480));
+        assertEquals("myBean.stringArrayProperty != '3'", getELText(_structuredDocument,1546));
+        assertEquals("myBean.stringArrayProperty ne myBean.listProperty", getELText(_structuredDocument,1613));
+
+        assertEquals("5 != 3", getELText(_structuredDocument,1717));
+        assertEquals("5 ne 3", getELText(_structuredDocument,1754));
+        assertEquals("true != false", getELText(_structuredDocument,1791));
+        assertEquals("true ne false", getELText(_structuredDocument,1835));
+        assertEquals("'4' != '34'", getELText(_structuredDocument,1879));
+        assertEquals("'4' ne '34'", getELText(_structuredDocument,1921));
+        assertEquals("'34' != '34'", getELText(_structuredDocument,1963));
+        assertEquals("'34' ne '34'", getELText(_structuredDocument,2006));
+        assertEquals("myBean.integerProperty != null", getELText(_structuredDocument,2049));
+        assertEquals("null ne myBean.integerProperty", getELText(_structuredDocument,2110));
+        assertEquals("5.4 != 4.3", getELText(_structuredDocument,2171));
+        assertEquals("true != true", getELText(_structuredDocument,2212));
+
+        assertEquals("5 != true", getELText(_structuredDocument,2276));
+        assertEquals("5 ne true", getELText(_structuredDocument,2316));
+        assertEquals("myBean.integerProperty != myBean.booleanProperty", getELText(_structuredDocument,2356));
+        assertEquals("myBean.integerProperty ne myBean.booleanProperty", getELText(_structuredDocument,2435));
+        assertEquals("myBean.stringArrayProperty != myBean.booleanProperty", getELText(_structuredDocument,2514));
+        assertEquals("myBean.booleanProperty ne myBean.stringArrayProperty", getELText(_structuredDocument,2597));
+        assertEquals("myBean.integerProperty != true ", getELText(_structuredDocument,2683));
+        assertEquals("myBean.integerProperty ne true ", getELText(_structuredDocument,2748));
+        assertEquals("false != myBean.integerProperty", getELText(_structuredDocument,2813));  
+    }
+
+    public void testNoErrorExprs() 
+    {
+        assertNoError(852, Signature.SIG_BOOLEAN);
+        assertNoError(914, Signature.SIG_BOOLEAN);
+        assertNoError(976, Signature.SIG_BOOLEAN);
+        assertNoError(1037, Signature.SIG_BOOLEAN);
+        assertNoError(1098, Signature.SIG_BOOLEAN);
+        assertNoError(1162, Signature.SIG_BOOLEAN);
+        assertNoError(1226, Signature.SIG_BOOLEAN);
+        assertNoError(1290, Signature.SIG_BOOLEAN);
+        assertNoError(1354, Signature.SIG_BOOLEAN);
+        assertNoError(1419, Signature.SIG_BOOLEAN);
+        assertNoError(1480, Signature.SIG_BOOLEAN);
+        assertNoError(1546, Signature.SIG_BOOLEAN);
+        assertNoError(1613, Signature.SIG_BOOLEAN);
+    }
+
+    public void testWarningExprs() 
+    {
+        List list = assertSemanticWarning(1717, Signature.SIG_BOOLEAN, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_CONSTANT_EXPRESSION_ALWAYS_EVAL_SAME_ID);
+        
+        list = assertSemanticWarning(1754, Signature.SIG_BOOLEAN, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_CONSTANT_EXPRESSION_ALWAYS_EVAL_SAME_ID);
+
+        list = assertSemanticWarning(1791, Signature.SIG_BOOLEAN, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_CONSTANT_EXPRESSION_ALWAYS_EVAL_SAME_ID);
+
+        list = assertSemanticWarning(1835, Signature.SIG_BOOLEAN, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_CONSTANT_EXPRESSION_ALWAYS_EVAL_SAME_ID);
+
+        list = assertSemanticWarning(1879, Signature.SIG_BOOLEAN, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_CONSTANT_EXPRESSION_ALWAYS_EVAL_SAME_ID);
+
+        list = assertSemanticWarning(1921, Signature.SIG_BOOLEAN, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_CONSTANT_EXPRESSION_ALWAYS_EVAL_SAME_ID);
+
+        list = assertSemanticWarning(1963, Signature.SIG_BOOLEAN, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_CONSTANT_EXPRESSION_ALWAYS_EVAL_SAME_ID);
+
+        list = assertSemanticWarning(2006, Signature.SIG_BOOLEAN, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_CONSTANT_EXPRESSION_ALWAYS_EVAL_SAME_ID);
+
+        list = assertSemanticWarning(2049, Signature.SIG_BOOLEAN, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_EQUALITY_COMP_WITH_NULL_ALWAYS_EVAL_SAME_ID);
+
+        list = assertSemanticWarning(2110, Signature.SIG_BOOLEAN, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_EQUALITY_COMP_WITH_NULL_ALWAYS_EVAL_SAME_ID);
+
+        list = assertSemanticWarning(2171, Signature.SIG_BOOLEAN, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_CONSTANT_EXPRESSION_ALWAYS_EVAL_SAME_ID);
+
+        list = assertSemanticWarning(2212, Signature.SIG_BOOLEAN, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_CONSTANT_EXPRESSION_ALWAYS_EVAL_SAME_ID);
+    }
+
+    public void testErrorExprs() 
+    {
+        List list = assertSemanticError(2276, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_COULD_NOT_MAKE_NUMERIC_COERCION_ID);
+
+        list = assertSemanticError(2316, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_COULD_NOT_MAKE_NUMERIC_COERCION_ID);
+
+        list = assertSemanticError(2356, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_COULD_NOT_MAKE_NUMERIC_COERCION_ID);
+
+        list = assertSemanticError(2435, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_COULD_NOT_MAKE_NUMERIC_COERCION_ID);
+
+        list = assertSemanticError(2514, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_CANNOT_COERCE_ARGUMENT_TO_BOOLEAN_ID);
+
+        list = assertSemanticError(2597, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_CANNOT_COERCE_ARGUMENT_TO_BOOLEAN_ID);
+
+        list = assertSemanticError(2683, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_COULD_NOT_MAKE_NUMERIC_COERCION_ID);
+
+        list = assertSemanticError(2748, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_COULD_NOT_MAKE_NUMERIC_COERCION_ID);
+        
+        list = assertSemanticError(2813, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_COULD_NOT_MAKE_NUMERIC_COERCION_ID);
+    }
+}
diff --git a/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/src/org/eclipse/jst/jsf/validation/el/tests/jsp/LogicalNotTestCase.java b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/src/org/eclipse/jst/jsf/validation/el/tests/jsp/LogicalNotTestCase.java
new file mode 100644
index 0000000..a5968ec
--- /dev/null
+++ b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/src/org/eclipse/jst/jsf/validation/el/tests/jsp/LogicalNotTestCase.java
@@ -0,0 +1,114 @@
+package org.eclipse.jst.jsf.validation.el.tests.jsp;
+
+import java.util.List;
+
+import org.eclipse.jdt.core.Signature;
+import org.eclipse.jst.jsf.validation.el.tests.base.SingleJSPTestCase;
+import org.eclipse.jst.jsf.validation.internal.el.diagnostics.DiagnosticFactory;
+
+public class LogicalNotTestCase extends SingleJSPTestCase {
+
+    protected void setUp() throws Exception
+    {
+        _srcFileName = "/testdata/jsps/logicalNOT.jsp.data";
+        _destFileName = "/logicalNOT.jsp";
+        super.setUp();
+    }
+
+    public void testSanity()
+    {
+        assertEquals("!myBean.booleanProperty", getELText(_structuredDocument,853));
+        assertEquals("not myBean.booleanProperty", getELText(_structuredDocument,910));
+        assertEquals("!myBean.stringProperty", getELText(_structuredDocument,967));
+        assertEquals("not myBean.stringProperty", getELText(_structuredDocument,1020));
+
+        assertEquals("!true", getELText(_structuredDocument,1105));
+        assertEquals("not true", getELText(_structuredDocument,1144));
+        assertEquals("!false", getELText(_structuredDocument,1186));
+        assertEquals("not false", getELText(_structuredDocument,1226));
+        assertEquals("! 'true'", getELText(_structuredDocument,1269));
+        assertEquals("not 'true'", getELText(_structuredDocument,1311));
+        assertEquals("! 'notTrue'", getELText(_structuredDocument,1355));
+        assertEquals("not 'notTrue'", getELText(_structuredDocument,1400));
+
+        assertEquals("!5", getELText(_structuredDocument,1470));
+        assertEquals("not 5", getELText(_structuredDocument,1503));
+        assertEquals("!myBean.integerProperty", getELText(_structuredDocument,1539));
+        assertEquals("not myBean.integerProperty", getELText(_structuredDocument,1593));
+        assertEquals("!myBean.collectionProperty", getELText(_structuredDocument,1650));
+        assertEquals("not myBean.collectionProperty", getELText(_structuredDocument,1707));
+        assertEquals("!myBean.stringArrayProperty", getELText(_structuredDocument,1767));
+        assertEquals("not myBean.stringArrayProperty", getELText(_structuredDocument,1825));
+        assertEquals("!myBean.mapProperty", getELText(_structuredDocument,1886));
+        assertEquals("not myBean.mapProperty", getELText(_structuredDocument,1936));
+    }
+
+    public void testNoErrorExprs() 
+    {
+        assertNoError(853, Signature.SIG_BOOLEAN);
+        assertNoError(910, Signature.SIG_BOOLEAN);
+        assertNoError(967, Signature.SIG_BOOLEAN);
+        assertNoError(1020, Signature.SIG_BOOLEAN);
+    }
+
+    public void testWarningExprs() 
+    {
+        List list = assertSemanticWarning(1105, Signature.SIG_BOOLEAN, 1);
+        assertContainsProblem(list, DiagnosticFactory.UNARY_OP_CONSTANT_EXPRESSION_EVAL_SAME_ID);
+
+        list = assertSemanticWarning(1144, Signature.SIG_BOOLEAN, 1);
+        assertContainsProblem(list, DiagnosticFactory.UNARY_OP_CONSTANT_EXPRESSION_EVAL_SAME_ID);
+
+        list = assertSemanticWarning(1186, Signature.SIG_BOOLEAN, 1);
+        assertContainsProblem(list, DiagnosticFactory.UNARY_OP_CONSTANT_EXPRESSION_EVAL_SAME_ID);
+
+        list = assertSemanticWarning(1226, Signature.SIG_BOOLEAN, 1);
+        assertContainsProblem(list, DiagnosticFactory.UNARY_OP_CONSTANT_EXPRESSION_EVAL_SAME_ID);
+
+        list = assertSemanticWarning(1269, Signature.SIG_BOOLEAN, 1);
+        assertContainsProblem(list, DiagnosticFactory.UNARY_OP_CONSTANT_EXPRESSION_EVAL_SAME_ID);
+
+        list = assertSemanticWarning(1311, Signature.SIG_BOOLEAN, 1);
+        assertContainsProblem(list, DiagnosticFactory.UNARY_OP_CONSTANT_EXPRESSION_EVAL_SAME_ID);
+
+        list = assertSemanticWarning(1355, Signature.SIG_BOOLEAN, 1);
+        assertContainsProblem(list, DiagnosticFactory.UNARY_OP_CONSTANT_EXPRESSION_EVAL_SAME_ID);
+
+        list = assertSemanticWarning(1400, Signature.SIG_BOOLEAN, 1);
+        assertContainsProblem(list, DiagnosticFactory.UNARY_OP_CONSTANT_EXPRESSION_EVAL_SAME_ID);
+    }
+
+    public void testErrorExprs() 
+    {
+        List list = assertSemanticError(1470, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.UNARY_OP_CANNOT_COERCE_ARGUMENT_TO_BOOLEAN_ID);
+        
+        list = assertSemanticError(1503, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.UNARY_OP_CANNOT_COERCE_ARGUMENT_TO_BOOLEAN_ID);
+
+        list = assertSemanticError(1539, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.UNARY_OP_CANNOT_COERCE_ARGUMENT_TO_BOOLEAN_ID);
+
+        list = assertSemanticError(1593, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.UNARY_OP_CANNOT_COERCE_ARGUMENT_TO_BOOLEAN_ID);
+
+        list = assertSemanticError(1650, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.UNARY_OP_CANNOT_COERCE_ARGUMENT_TO_BOOLEAN_ID);
+
+        list = assertSemanticError(1707, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.UNARY_OP_CANNOT_COERCE_ARGUMENT_TO_BOOLEAN_ID);
+
+        list = assertSemanticError(1767, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.UNARY_OP_CANNOT_COERCE_ARGUMENT_TO_BOOLEAN_ID);
+
+        list = assertSemanticError(1825, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.UNARY_OP_CANNOT_COERCE_ARGUMENT_TO_BOOLEAN_ID);
+
+        list = assertSemanticError(1886, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.UNARY_OP_CANNOT_COERCE_ARGUMENT_TO_BOOLEAN_ID);
+
+        list = assertSemanticError(1936, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.UNARY_OP_CANNOT_COERCE_ARGUMENT_TO_BOOLEAN_ID);
+    }
+
+}
diff --git a/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/src/org/eclipse/jst/jsf/validation/el/tests/jsp/LogicalOrTestCase.java b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/src/org/eclipse/jst/jsf/validation/el/tests/jsp/LogicalOrTestCase.java
new file mode 100644
index 0000000..3eb0456
--- /dev/null
+++ b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/src/org/eclipse/jst/jsf/validation/el/tests/jsp/LogicalOrTestCase.java
@@ -0,0 +1,99 @@
+package org.eclipse.jst.jsf.validation.el.tests.jsp;
+
+import java.util.List;
+
+import org.eclipse.jdt.core.Signature;
+import org.eclipse.jst.jsf.validation.el.tests.base.SingleJSPTestCase;
+import org.eclipse.jst.jsf.validation.internal.el.diagnostics.DiagnosticFactory;
+
+public class LogicalOrTestCase extends SingleJSPTestCase 
+{
+    protected void setUp() throws Exception
+    {
+        _srcFileName = "/testdata/jsps/logicalOR.jsp.data";
+        _destFileName = "/logicalOR.jsp";
+        super.setUp();
+    }
+
+    public void testSanity()
+    {
+        assertEquals("myBean.booleanProperty or myBean.booleanProperty", getELText(_structuredDocument,852));
+        assertEquals("myBean.booleanProperty || myBean.booleanProperty", getELText(_structuredDocument,934));
+        assertEquals("false || myBean.booleanProperty", getELText(_structuredDocument,1016));
+        assertEquals("false or myBean.booleanProperty", getELText(_structuredDocument,1081));
+        assertEquals("null || myBean.booleanProperty ", getELText(_structuredDocument,1146));
+        assertEquals("null or myBean.booleanProperty ", getELText(_structuredDocument,1211));
+        assertEquals("'notTrue' || myBean.booleanProperty", getELText(_structuredDocument,1276));
+        assertEquals("myBean.booleanProperty || false", getELText(_structuredDocument,1352));
+        assertEquals("myBean.booleanProperty or false", getELText(_structuredDocument,1417));
+        assertEquals("myBean.booleanProperty || null ", getELText(_structuredDocument,1482));
+        assertEquals("myBean.booleanProperty or null", getELText(_structuredDocument,1547));
+        assertEquals("myBean.booleanProperty || 'notTrue'", getELText(_structuredDocument,1611));
+        assertEquals("myBean.booleanProperty or 'notTrue'", getELText(_structuredDocument,1682));
+
+        assertEquals("'true' or myBean.booleanProperty", getELText(_structuredDocument,1777));
+        assertEquals("'true' || myBean.booleanProperty", getELText(_structuredDocument,1844));
+        assertEquals("myBean.booleanProperty or true ", getELText(_structuredDocument,1908));
+        assertEquals("myBean.booleanProperty || true ", getELText(_structuredDocument,1970));
+        assertEquals("myBean.booleanProperty || 'true'", getELText(_structuredDocument,2032));
+        assertEquals("false || true", getELText(_structuredDocument,2095));
+        assertEquals("null || true", getELText(_structuredDocument,2139));
+
+        assertEquals("myBean.integerProperty || false", getELText(_structuredDocument,2209));
+        assertEquals("false || myBean.integerProperty", getELText(_structuredDocument,2274));
+        assertEquals("4 || false", getELText(_structuredDocument,2339));
+    }
+
+    public void testNoErrorExprs() 
+    {
+        assertNoError(852, Signature.SIG_BOOLEAN);
+        assertNoError(934, Signature.SIG_BOOLEAN);
+        assertNoError(1016, Signature.SIG_BOOLEAN);
+        assertNoError(1081, Signature.SIG_BOOLEAN);
+        assertNoError(1146, Signature.SIG_BOOLEAN);
+        assertNoError(1211, Signature.SIG_BOOLEAN);
+        assertNoError(1276, Signature.SIG_BOOLEAN);
+        assertNoError(1352, Signature.SIG_BOOLEAN);
+        assertNoError(1417, Signature.SIG_BOOLEAN);
+        assertNoError(1482, Signature.SIG_BOOLEAN);
+        assertNoError(1547, Signature.SIG_BOOLEAN);
+        assertNoError(1611, Signature.SIG_BOOLEAN);
+        assertNoError(1682, Signature.SIG_BOOLEAN);
+    }
+
+    public void testWarningExprs() 
+    {
+        List list = assertSemanticWarning(1777, Signature.SIG_BOOLEAN, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_FIRST_ARGUMENT_SHORT_CIRCUITS_ID);
+
+        list = assertSemanticWarning(1844, Signature.SIG_BOOLEAN, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_FIRST_ARGUMENT_SHORT_CIRCUITS_ID);
+
+        list = assertSemanticWarning(1908, Signature.SIG_BOOLEAN, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_SECOND_ARGUMENT_ALWAYS_EVAL_SAME_ID);
+
+        list = assertSemanticWarning(1970, Signature.SIG_BOOLEAN, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_SECOND_ARGUMENT_ALWAYS_EVAL_SAME_ID);
+
+        list = assertSemanticWarning(2032, Signature.SIG_BOOLEAN, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_SECOND_ARGUMENT_ALWAYS_EVAL_SAME_ID);
+        
+        list = assertSemanticWarning(2095, Signature.SIG_BOOLEAN, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_SECOND_ARGUMENT_ALWAYS_EVAL_SAME_ID);
+
+        list = assertSemanticWarning(2139, Signature.SIG_BOOLEAN, 1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_SECOND_ARGUMENT_ALWAYS_EVAL_SAME_ID);
+    }
+
+    public void testErrorExprs() 
+    {
+        List list = assertSemanticError(2209, null,1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_CANNOT_COERCE_ARGUMENT_TO_BOOLEAN_ID);
+
+        assertSemanticError(2274, null,1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_CANNOT_COERCE_ARGUMENT_TO_BOOLEAN_ID);
+
+        assertSemanticError(2339, null,1);
+        assertContainsProblem(list, DiagnosticFactory.BINARY_OP_CANNOT_COERCE_ARGUMENT_TO_BOOLEAN_ID);
+    }
+}
diff --git a/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/src/org/eclipse/jst/jsf/validation/el/tests/jsp/MethodBindingTestCase.java b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/src/org/eclipse/jst/jsf/validation/el/tests/jsp/MethodBindingTestCase.java
new file mode 100644
index 0000000..d0fb559
--- /dev/null
+++ b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/src/org/eclipse/jst/jsf/validation/el/tests/jsp/MethodBindingTestCase.java
@@ -0,0 +1,118 @@
+package org.eclipse.jst.jsf.validation.el.tests.jsp;
+
+import java.util.List;
+
+import org.eclipse.jdt.core.Signature;
+import org.eclipse.jst.jsf.core.internal.types.TypeConstants;
+import org.eclipse.jst.jsf.validation.el.tests.base.SingleJSPTestCase;
+
+public class MethodBindingTestCase extends SingleJSPTestCase 
+{
+    protected void setUp() throws Exception
+    {
+        _srcFileName = "/testdata/jsps/methodBinding.jsp.data";
+        _destFileName = "/methodBinding.jsp";
+        super.setUp();
+    }
+
+    public void testSanity()
+    {
+        assertEquals("myBean.getStringProperty", getELText(_structuredDocument,849));
+        assertEquals("myBean.getIntegerProperty", getELText(_structuredDocument,910));
+        assertEquals("myBean.getBooleanProperty", getELText(_structuredDocument,972));
+        assertEquals("myBean.getDoubleProperty", getELText(_structuredDocument,1034));
+        assertEquals("myBean.getMapProperty", getELText(_structuredDocument,1095));
+        assertEquals("myBean.getStringArrayProperty", getELText(_structuredDocument,1153));
+        assertEquals("myBean.getCollectionProperty", getELText(_structuredDocument,1219));
+        assertEquals("myBean.getListProperty", getELText(_structuredDocument,1284));
+        assertEquals("myBean.getComparableProperty", getELText(_structuredDocument,1343));
+        assertEquals("myBean.getBigIntegerProperty", getELText(_structuredDocument,1408));
+        assertEquals("myBean.getBigDoubleProperty", getELText(_structuredDocument,1473));
+        assertEquals("myBean.recursiveCall", getELText(_structuredDocument,1537));
+        assertEquals("myBean.getWritableStringProperty", getELText(_structuredDocument,1594));
+        assertEquals("myBean.setWritableStringProperty", getELText(_structuredDocument,1663));
+        assertEquals("myBean.validate", getELText(_structuredDocument,1732));
+        assertEquals("myBean.validate2", getELText(_structuredDocument,1784));
+        assertEquals("myBean.getSelf", getELText(_structuredDocument,1837));
+        assertEquals("myBean.isIsStyleBooleanProperty", getELText(_structuredDocument,1888));
+        assertEquals("myBeanSubClass.getStringProperty", getELText(_structuredDocument,1958));
+        assertEquals("myBeanSubClass.getIntegerProperty", getELText(_structuredDocument,2027));
+        assertEquals("myBeanSubClass.getBooleanProperty", getELText(_structuredDocument,2097));
+        assertEquals("myBeanSubClass.getDoubleProperty", getELText(_structuredDocument,2167));
+        assertEquals("myBeanSubClass.getMapProperty", getELText(_structuredDocument,2236));
+        assertEquals("myBeanSubClass.getStringArrayProperty", getELText(_structuredDocument,2302));
+        assertEquals("myBeanSubClass.getCollectionProperty", getELText(_structuredDocument,2376));
+        assertEquals("myBeanSubClass.getListProperty", getELText(_structuredDocument,2449));
+        assertEquals("myBeanSubClass.getComparableProperty", getELText(_structuredDocument,2516));
+        assertEquals("myBeanSubClass.getBigIntegerProperty", getELText(_structuredDocument,2589));
+        assertEquals("myBeanSubClass.getBigDoubleProperty", getELText(_structuredDocument,2662));
+        assertEquals("myBeanSubClass.recursiveCall", getELText(_structuredDocument,2734));
+        assertEquals("myBeanSubClass.getWritableStringProperty", getELText(_structuredDocument,2799));
+        assertEquals("myBeanSubClass.setWritableStringProperty", getELText(_structuredDocument,2876));
+        assertEquals("myBeanSubClass.validate", getELText(_structuredDocument,2953));
+        assertEquals("myBeanSubClass.validate2", getELText(_structuredDocument,3013));
+        assertEquals("myBeanSubClass.getSelf", getELText(_structuredDocument,3074));
+        assertEquals("myBeanSubClass.isIsStyleBooleanProperty", getELText(_structuredDocument,3133));
+        assertEquals("myBeanSubClass.getSubClassStringProperty", getELText(_structuredDocument,3209));
+
+        assertEquals("-myBean.validate", getELText(_structuredDocument,3338));
+        assertEquals("myBean.getIntegerProperty + myBean.getDoubleProperty", getELText(_structuredDocument,3387));
+    }
+ 
+    public void testNoErrorExprs() {
+        final String[] noStrings = new  String[0];
+        assertNoError(849, Signature.createMethodSignature(noStrings, TypeConstants.TYPE_STRING));
+        assertNoError(910, Signature.createMethodSignature(noStrings, Signature.SIG_INT));
+        assertNoError(972, Signature.createMethodSignature(noStrings, Signature.SIG_BOOLEAN));
+        assertNoError(1034, Signature.createMethodSignature(noStrings, Signature.SIG_DOUBLE));
+        assertNoError(1095, Signature.createMethodSignature(noStrings, TypeConstants.TYPE_MAP));
+        assertNoError(1153, Signature.createMethodSignature(noStrings, Signature.createArraySignature(TypeConstants.TYPE_STRING,1)));
+        assertNoError(1219, Signature.createMethodSignature(noStrings, TypeConstants.TYPE_COLLECTION));
+        assertNoError(1284, Signature.createMethodSignature(noStrings, "Ljava.util.List;"));
+        assertNoError(1343, Signature.createMethodSignature(noStrings, TypeConstants.TYPE_COMPARABLE));
+        assertNoError(1408, Signature.createMethodSignature(noStrings, TypeConstants.TYPE_BIG_INTEGER));
+        assertNoError(1473, Signature.createMethodSignature(noStrings, TypeConstants.TYPE_BIG_DOUBLE));
+        assertNoError(1537, Signature.createMethodSignature(noStrings, "Lbeans.MyBean;"));
+        assertNoError(1594, Signature.createMethodSignature(noStrings, TypeConstants.TYPE_STRING));
+        assertNoError(1663, Signature.createMethodSignature(new String[]{TypeConstants.TYPE_STRING}, Signature.SIG_VOID));
+        assertNoError(1732, "(QFacesContext;QUIComponent;Ljava.lang.Object;)V");
+        assertNoError(1784, "(QFacesContext;QUIComponent;[Ljava.lang.Object;)V");
+        assertNoError(1837, Signature.createMethodSignature(noStrings, "Lbeans.MyBean;"));        
+        assertNoError(1888, Signature.createMethodSignature(noStrings, Signature.SIG_BOOLEAN));        
+
+        assertNoError(1958, Signature.createMethodSignature(noStrings, TypeConstants.TYPE_STRING));
+        assertNoError(2027, Signature.createMethodSignature(noStrings, Signature.SIG_INT));
+        assertNoError(2097, Signature.createMethodSignature(noStrings, Signature.SIG_BOOLEAN));
+        assertNoError(2167, Signature.createMethodSignature(noStrings, Signature.SIG_DOUBLE));
+        assertNoError(2236, Signature.createMethodSignature(noStrings, TypeConstants.TYPE_MAP));
+        assertNoError(2302, Signature.createMethodSignature(noStrings, Signature.createArraySignature(TypeConstants.TYPE_STRING,1)));
+        assertNoError(2376, Signature.createMethodSignature(noStrings, TypeConstants.TYPE_COLLECTION));
+        assertNoError(2449, Signature.createMethodSignature(noStrings, "Ljava.util.List;"));
+        assertNoError(2516, Signature.createMethodSignature(noStrings, TypeConstants.TYPE_COMPARABLE));
+        assertNoError(2589, Signature.createMethodSignature(noStrings, TypeConstants.TYPE_BIG_INTEGER));
+        assertNoError(2662, Signature.createMethodSignature(noStrings, TypeConstants.TYPE_BIG_DOUBLE));
+        assertNoError(2734, Signature.createMethodSignature(noStrings, "Lbeans.MyBean;"));
+        assertNoError(2799, Signature.createMethodSignature(noStrings, TypeConstants.TYPE_STRING));
+        assertNoError(2876, Signature.createMethodSignature(new String[]{TypeConstants.TYPE_STRING}, Signature.SIG_VOID));
+        assertNoError(2953, "(QFacesContext;QUIComponent;Ljava.lang.Object;)V");
+        assertNoError(3013, "(QFacesContext;QUIComponent;[Ljava.lang.Object;)V");
+        assertNoError(3074, Signature.createMethodSignature(noStrings, "Lbeans.MyBean;"));        
+        assertNoError(3133, Signature.createMethodSignature(noStrings, Signature.SIG_BOOLEAN));        
+        assertNoError(3209, Signature.createMethodSignature(noStrings, TypeConstants.TYPE_STRING));        
+    }
+
+    public void testWarningExprs() 
+    {
+        // no warning cases
+    }
+
+    public void testErrorExprs() 
+    {
+        List list = assertSemanticError(3338, null, 1);
+        assertContainsProblem(list, 0);
+
+        list = assertSemanticError(3387, null, 2);
+        assertContainsProblem(list, 0);
+    }
+
+}
diff --git a/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/src/org/eclipse/jst/jsf/validation/el/tests/jsp/UnaryEmptyTestCase.java b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/src/org/eclipse/jst/jsf/validation/el/tests/jsp/UnaryEmptyTestCase.java
new file mode 100644
index 0000000..7b75ffe
--- /dev/null
+++ b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/src/org/eclipse/jst/jsf/validation/el/tests/jsp/UnaryEmptyTestCase.java
@@ -0,0 +1,84 @@
+package org.eclipse.jst.jsf.validation.el.tests.jsp;
+
+import java.util.List;
+
+import org.eclipse.jdt.core.Signature;
+import org.eclipse.jst.jsf.validation.el.tests.base.SingleJSPTestCase;
+import org.eclipse.jst.jsf.validation.internal.el.diagnostics.DiagnosticFactory;
+
+public class UnaryEmptyTestCase extends SingleJSPTestCase 
+{
+    protected void setUp() throws Exception 
+    {
+        _srcFileName = "/testdata/jsps/emptyOperator.jsp.data";
+        _destFileName = "/emptyOperator.jsp";
+
+        super.setUp();
+    }
+    
+    public void testSanity()
+    {
+        super.testSanity();
+        
+        assertEquals("empty myBean.collectionProperty", getELText(_structuredDocument,852));
+        assertEquals("empty myBean.mapProperty", getELText(_structuredDocument,917));
+        assertEquals("empty myBean.stringArrayProperty", getELText(_structuredDocument,975));
+        assertEquals("empty myBean.stringProperty", getELText(_structuredDocument,1041));
+        assertEquals("myBean.stringProperty", getELText(_structuredDocument,1102));
+        assertEquals("empty myBean.listProperty", getELText(_structuredDocument,1157));
+        assertEquals("empty mapBean", getELText(_structuredDocument,1213));
+        
+        assertEquals("empty 5", getELText(_structuredDocument,1283));
+        assertEquals("empty myBean.integerProperty", getELText(_structuredDocument,1321));
+        assertEquals("empty false", getELText(_structuredDocument,1380));
+        assertEquals("empty myBean.booleanProperty", getELText(_structuredDocument,1422));
+        assertEquals("empty ''", getELText(_structuredDocument,1481));
+        assertEquals("empty 'notEmpty'", getELText(_structuredDocument,1523));
+        assertEquals("empty null", getELText(_structuredDocument,1574));
+        assertEquals("empty 456", getELText(_structuredDocument,1618));
+    }
+
+    public void testNoErrorExprs() 
+    {
+        assertNoError(852, Signature.SIG_BOOLEAN);
+        assertNoError(917, Signature.SIG_BOOLEAN);
+        assertNoError(975, Signature.SIG_BOOLEAN);
+        assertNoError(1041, Signature.SIG_BOOLEAN);
+//        assertNoError(1102, Signature.SIG_BOOLEAN);
+        assertNoError(1157, Signature.SIG_BOOLEAN);
+        assertNoError(1213, Signature.SIG_BOOLEAN);
+
+    }
+
+    public void testWarningExprs() 
+    {
+        List list = assertSemanticWarning(1283, Signature.SIG_BOOLEAN, 1);
+        assertContainsProblem(list, DiagnosticFactory.UNARY_OP_EMPTY_ALWAYS_FALSE_ON_TYPE_ID);
+
+        list = assertSemanticWarning(1321, Signature.SIG_BOOLEAN, 1);
+        assertContainsProblem(list, DiagnosticFactory.UNARY_OP_EMPTY_ALWAYS_FALSE_ON_TYPE_ID);
+
+        list = assertSemanticWarning(1380, Signature.SIG_BOOLEAN, 1);
+        assertContainsProblem(list, DiagnosticFactory.UNARY_OP_EMPTY_ALWAYS_FALSE_ON_TYPE_ID);
+
+        list = assertSemanticWarning(1422, Signature.SIG_BOOLEAN, 1);
+        assertContainsProblem(list, DiagnosticFactory.UNARY_OP_EMPTY_ALWAYS_FALSE_ON_TYPE_ID);
+
+        list = assertSemanticWarning(1481, Signature.SIG_BOOLEAN, 1);
+        assertContainsProblem(list, DiagnosticFactory.UNARY_OP_CONSTANT_EXPRESSION_EVAL_SAME_ID);
+
+        list = assertSemanticWarning(1523, Signature.SIG_BOOLEAN, 1);
+        assertContainsProblem(list, DiagnosticFactory.UNARY_OP_CONSTANT_EXPRESSION_EVAL_SAME_ID);
+
+        list = assertSemanticWarning(1574, Signature.SIG_BOOLEAN, 1);
+        assertContainsProblem(list, DiagnosticFactory.UNARY_OP_CONSTANT_EXPRESSION_EVAL_SAME_ID);
+
+        list = assertSemanticWarning(1618, Signature.SIG_BOOLEAN, 1);
+        assertContainsProblem(list, DiagnosticFactory.UNARY_OP_EMPTY_ALWAYS_FALSE_ON_TYPE_ID);
+    }
+    
+    public void testErrorExprs() 
+    {
+        // no error cases
+    }
+}
diff --git a/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/src/org/eclipse/jst/jsf/validation/el/tests/jsp/UnaryMinusTestCase.java b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/src/org/eclipse/jst/jsf/validation/el/tests/jsp/UnaryMinusTestCase.java
new file mode 100644
index 0000000..be4b03a
--- /dev/null
+++ b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/src/org/eclipse/jst/jsf/validation/el/tests/jsp/UnaryMinusTestCase.java
@@ -0,0 +1,89 @@
+package org.eclipse.jst.jsf.validation.el.tests.jsp;
+
+import java.util.List;
+
+import org.eclipse.jdt.core.Signature;
+import org.eclipse.jst.jsf.core.internal.types.TypeConstants;
+import org.eclipse.jst.jsf.validation.el.tests.base.SingleJSPTestCase;
+import org.eclipse.jst.jsf.validation.internal.el.diagnostics.DiagnosticFactory;
+
+public class UnaryMinusTestCase extends SingleJSPTestCase 
+{
+    protected void setUp() throws Exception
+    {
+        _srcFileName = "/testdata/jsps/unaryMinus.jsp.data";
+        _destFileName = "/unaryMinus.jsp";
+        super.setUp();
+    }
+
+    public void testSanity()
+    {
+        assertEquals("-myBean.integerProperty", getELText(_structuredDocument,852));
+        assertEquals("-myBean.doubleProperty", getELText(_structuredDocument,906));
+        assertEquals("-myBean.bigDoubleProperty", getELText(_structuredDocument,959));
+        assertEquals("-myBean.bigIntegerProperty", getELText(_structuredDocument,1015));
+
+        assertEquals("-myBean.stringProperty", getELText(_structuredDocument,1102));
+        assertEquals("-5", getELText(_structuredDocument,1158));
+        assertEquals("-5.5", getELText(_structuredDocument,1194));
+        assertEquals("-'5'", getELText(_structuredDocument,1232));
+        assertEquals("-'5.5'", getELText(_structuredDocument,1270));
+        assertEquals("-null", getELText(_structuredDocument,1310));
+
+        assertEquals("-false", getELText(_structuredDocument,1370));
+        assertEquals("-true", getELText(_structuredDocument,1407));
+        assertEquals("-myBean.booleanProperty", getELText(_structuredDocument,1443));
+        assertEquals("-myBean.collectionProperty", getELText(_structuredDocument,1497));
+        assertEquals("-myBean.mapProperty", getELText(_structuredDocument,1554));
+        assertEquals("-myBean.stringArrayProperty", getELText(_structuredDocument,1604));
+        assertEquals("-'notANumber'", getELText(_structuredDocument,1662));
+    }
+    
+    public void testNoErrorExprs() 
+    {
+        assertNoError(852, Signature.SIG_INT);
+        assertNoError(906, Signature.SIG_DOUBLE);
+        assertNoError(959, TypeConstants.TYPE_BIG_DOUBLE);
+        assertNoError(1015, TypeConstants.TYPE_BIG_INTEGER);
+        assertNoError(1158, Signature.SIG_LONG);
+        assertNoError(1194, Signature.SIG_DOUBLE);
+        assertNoError(1232, Signature.SIG_LONG);
+        assertNoError(1270, Signature.SIG_DOUBLE);
+
+    }
+
+    public void testWarningExprs() 
+    {
+        List list = assertSemanticWarning(1102, Signature.SIG_LONG, 1);
+        assertContainsProblem(list, DiagnosticFactory.UNARY_OP_STRING_CONVERSION_NOT_GUARANTEED);
+
+        list = assertSemanticWarning(1310, Signature.SIG_LONG, 1);
+        assertContainsProblem(list, DiagnosticFactory.UNARY_OP_MINUS_ON_NULL_ALWAYS_ZERO_ID);
+    }
+    
+    @Override
+    public void testErrorExprs() 
+    {
+        List list = assertSemanticError(1370, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.UNARY_OP_COULD_NOT_MAKE_NUMERIC_COERCION_ID);
+
+        list = assertSemanticError(1407, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.UNARY_OP_COULD_NOT_MAKE_NUMERIC_COERCION_ID);
+
+        list = assertSemanticError(1443, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.UNARY_OP_COULD_NOT_MAKE_NUMERIC_COERCION_ID);
+
+        list = assertSemanticError(1497, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.UNARY_OP_COULD_NOT_MAKE_NUMERIC_COERCION_ID);
+
+        list = assertSemanticError(1554, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.UNARY_OP_COULD_NOT_MAKE_NUMERIC_COERCION_ID);
+
+        list = assertSemanticError(1604, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.UNARY_OP_COULD_NOT_MAKE_NUMERIC_COERCION_ID);
+
+        list = assertSemanticError(1662, null, 1);
+        assertContainsProblem(list, DiagnosticFactory.UNARY_OP_COULD_NOT_MAKE_NUMERIC_COERCION_ID);
+    }
+
+}
diff --git a/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/src/org/eclipse/jst/jsf/validation/el/tests/util/CreateTestCaseForJSP.java b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/src/org/eclipse/jst/jsf/validation/el/tests/util/CreateTestCaseForJSP.java
new file mode 100644
index 0000000..661c7a9
--- /dev/null
+++ b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/src/org/eclipse/jst/jsf/validation/el/tests/util/CreateTestCaseForJSP.java
@@ -0,0 +1,127 @@
+package org.eclipse.jst.jsf.validation.el.tests.util;
+
+import java.util.Iterator;
+
+import junit.framework.TestCase;
+
+import org.eclipse.core.resources.IFile;
+import org.eclipse.jst.jsf.test.util.WebProjectTestEnvironment;
+import org.eclipse.jst.jsf.validation.el.tests.ELValidationTestPlugin;
+import org.eclipse.jst.jsp.core.internal.regions.DOMJSPRegionContexts;
+import org.eclipse.wst.sse.core.StructuredModelManager;
+import org.eclipse.wst.sse.core.internal.provisional.IStructuredModel;
+import org.eclipse.wst.sse.core.internal.provisional.text.IStructuredDocument;
+import org.eclipse.wst.sse.core.internal.provisional.text.IStructuredDocumentRegion;
+import org.eclipse.wst.sse.core.internal.provisional.text.ITextRegion;
+import org.eclipse.wst.sse.core.internal.provisional.text.ITextRegionCollection;
+import org.eclipse.wst.sse.core.internal.provisional.text.ITextRegionList;
+import org.eclipse.wst.xml.core.internal.regions.DOMRegionContext;
+
+public class CreateTestCaseForJSP extends TestCase 
+{
+    private final static String  jspFile = "methodBinding";
+    private static IFile  file;
+    private static IStructuredModel model;
+
+    private WebProjectTestEnvironment  _testEnv;
+
+    protected void setUp() throws Exception {
+        super.setUp();
+
+        _testEnv = new WebProjectTestEnvironment("ELValidationTest_"+getName());
+        _testEnv.createProject();
+        assertNotNull(_testEnv);       
+        assertNotNull(_testEnv.getTestProject());
+        assertTrue(_testEnv.getTestProject().isAccessible());
+
+        file = 
+            (IFile) 
+            _testEnv.loadResourceInWebRoot(ELValidationTestPlugin.getDefault().getBundle(),
+                "/testdata/jsps/"+jspFile+".jsp.data", 
+                "/WEB-INF/"+jspFile+".jsp");
+
+        model = StructuredModelManager.getModelManager().getModelForRead(file);
+
+    }
+
+    protected void tearDown() throws Exception 
+    {
+        super.tearDown();
+        model.releaseFromRead();
+    }
+    
+    public void testDoTestGen()
+    {
+        System.out.println("    protected void setUp() throws Exception"); 
+        System.out.println("    {");
+        System.out.println("        _srcFileName = \"/testdata/jsps/"+jspFile+".jsp.data\";");
+        System.out.println("        _destFileName = \"/"+jspFile+".jsp\";");
+        System.out.println("        super.setUp();");
+        System.out.println("    }\n");
+
+        System.out.println("    public void testSanity()");
+        System.out.println("    {");
+        ELRegionHandler  handler = new ELRegionHandler()
+        {
+            public void handleRegion(ITextRegionCollection parentRegion, ITextRegion elRegion) {
+                final int contentStart = 
+                    parentRegion.getStartOffset(elRegion);
+                
+                final String elTextStr = "\""+parentRegion.getText(elRegion)+ "\"";
+                
+                System.out.println("        assertEquals("+elTextStr+", getELText(_structuredDocument,"+contentStart+"));");
+            }
+        };
+        processJSP(model.getStructuredDocument(), handler);
+        System.out.println("    }");
+    }
+
+    public static void processJSP(IStructuredDocument document, ELRegionHandler handler)
+    {
+        IStructuredDocumentRegion curNode = document.getFirstStructuredDocumentRegion();
+        while (null != curNode)
+        {
+            if (curNode.getFirstRegion().getType() == DOMRegionContext.XML_TAG_OPEN ) 
+            {
+                Iterator regions = curNode.getRegions().iterator();
+                ITextRegion region = null;
+
+                while (regions.hasNext()) 
+                {
+                    region = (ITextRegion) regions.next();
+
+                    if (region instanceof ITextRegionCollection
+                            && region.getType() == DOMRegionContext.XML_TAG_ATTRIBUTE_VALUE)
+                    {
+                        ITextRegionCollection parentRegion = (ITextRegionCollection) region;
+                        final ITextRegionList  regionList = parentRegion.getRegions();
+                        if (regionList.size() >= 4)
+                        {
+                            ITextRegion  openQuote = regionList.get(0);
+                            ITextRegion  openVBLQuote = regionList.get(1);
+        
+                            if (    (openQuote.getType() == DOMJSPRegionContexts.XML_TAG_ATTRIBUTE_VALUE_DQUOTE
+                                        || openQuote.getType() == DOMJSPRegionContexts.XML_TAG_ATTRIBUTE_VALUE_SQUOTE)
+                                        && (openVBLQuote.getType() == DOMJSPRegionContexts.JSP_VBL_OPEN))
+                            {
+                                // we appear to be inside "#{", so next should be a VBL_CONTENT if there's anything
+                                // here to validate
+                                final ITextRegion content = regionList.get(2);
+                                if (content.getType() == DOMJSPRegionContexts.JSP_VBL_CONTENT)
+                                {
+                                    handler.handleRegion(parentRegion, content);
+                                }
+                            }
+                        }
+                    }
+                }             
+            }
+            curNode = curNode.getNext();
+        }
+    }
+    
+    public interface ELRegionHandler
+    {
+        public void handleRegion(ITextRegionCollection parentRegion, ITextRegion elRegion);
+    }
+}
diff --git a/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/src/org/eclipse/jst/jsf/validation/el/tests/util/FindELRegions.java b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/src/org/eclipse/jst/jsf/validation/el/tests/util/FindELRegions.java
new file mode 100644
index 0000000..867a694
--- /dev/null
+++ b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/src/org/eclipse/jst/jsf/validation/el/tests/util/FindELRegions.java
@@ -0,0 +1,120 @@
+package org.eclipse.jst.jsf.validation.el.tests.util;
+
+import junit.framework.TestCase;
+
+import org.eclipse.core.resources.IFile;
+import org.eclipse.jst.jsf.test.util.WebProjectTestEnvironment;
+import org.eclipse.jst.jsf.validation.el.tests.ELValidationTestPlugin;
+import org.eclipse.jst.jsf.validation.el.tests.util.CreateTestCaseForJSP.ELRegionHandler;
+import org.eclipse.wst.sse.core.StructuredModelManager;
+import org.eclipse.wst.sse.core.internal.provisional.IStructuredModel;
+import org.eclipse.wst.sse.core.internal.provisional.text.IStructuredDocument;
+import org.eclipse.wst.sse.core.internal.provisional.text.ITextRegion;
+import org.eclipse.wst.sse.core.internal.provisional.text.ITextRegionCollection;
+
+public class FindELRegions extends TestCase
+{
+    private final static String[]  jspFiles =
+    {
+        "arithmeticAdd"
+        , "arithmeticDivide"
+        , "arithmeticMinus"
+        , "arithmeticModulo"
+        , "arithmeticMultiply"
+        , "assignability"
+        , "badSyntax"
+        , "beanScoping"
+        , "beansProperties"
+        , "beanSubClass"
+        , "builtinSymbols"
+        , "complexArithmetic1"
+        , "complexComparison"
+        , "emptyOperator"
+        , "expressionTypeChecking"
+        , "greaterThan"
+        , "greaterThanEq"
+        , "htmlSyntax"
+        , "jspFunctions"
+        , "lessThan"
+        , "lessThanEq"
+        , "listBeans"
+        , "loadBundleExpressions"
+        , "logicalAND"
+        , "logicalEquals"
+        , "logicalNOT"
+        , "logicalNotEquals"
+        , "logicalOR"
+        , "methodBinding"
+        , "test"
+        , "unaryMinus"
+        , "variableNaming"
+    };
+    
+    private final static IFile[]  files = new IFile[jspFiles.length];
+    private final static IStructuredModel[]  models = new IStructuredModel[jspFiles.length];
+
+    
+    private WebProjectTestEnvironment  _testEnv;
+    
+  
+    protected void setUp() throws Exception {
+        super.setUp();
+
+        _testEnv = new WebProjectTestEnvironment("ELValidationTest_"+getName());
+        _testEnv.createProject();
+        assertNotNull(_testEnv);       
+        assertNotNull(_testEnv.getTestProject());
+        assertTrue(_testEnv.getTestProject().isAccessible());
+
+        for (int i = 0; i < jspFiles.length; i++)
+        {
+            files[i] = 
+                (IFile) 
+                _testEnv.loadResourceInWebRoot(ELValidationTestPlugin.getDefault().getBundle(),
+                    "/testdata/jsps/"+jspFiles[i]+".jsp.data", 
+                    "/WEB-INF/"+jspFiles[i]+".jsp");
+            
+            models[i] = StructuredModelManager.getModelManager().getModelForRead(files[i]);
+        }
+    }
+
+    protected void tearDown() throws Exception 
+    {
+        super.tearDown();
+        
+        for (int i = 0; i < jspFiles.length; i++)
+        {
+            models[i].releaseFromRead();
+        }
+    }
+    
+    public void testGenReport()
+    {
+        for (int i = 0; i < models.length; i++)
+        {
+            printRegionsForModel(i);
+        }
+    }
+    
+    
+    
+    private void printRegionsForModel(int i)
+    {
+        IStructuredDocument document = models[i].getStructuredDocument();
+        
+        ELRegionHandler handler = new ELRegionHandler()
+        {
+            public void handleRegion(ITextRegionCollection parentRegion, ITextRegion elRegion) {
+                final int contentStart = 
+                    parentRegion.getStartOffset(elRegion);
+                
+                final String elTextStr = "\""+parentRegion.getText(elRegion)+ "\"";
+                System.out.println("assertEquals("+elTextStr+", getELText(_structuredDocument,"+contentStart+"));");
+
+            }
+        };
+
+
+        CreateTestCaseForJSP.processJSP(document, handler);
+    }
+}
diff --git a/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/classes/Bundle.properties.data b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/classes/Bundle.properties.data
new file mode 100644
index 0000000..d09b57b
--- /dev/null
+++ b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/classes/Bundle.properties.data
@@ -0,0 +1,3 @@
+bundleProp1=blah
+bundleProp2=chicken
+x.y=blah
\ No newline at end of file
diff --git a/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/classes/MapBean.java.data b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/classes/MapBean.java.data
new file mode 100644
index 0000000..f7a5d0c
--- /dev/null
+++ b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/classes/MapBean.java.data
@@ -0,0 +1,13 @@
+package beans;
+
+
+import java.util.AbstractMap;
+import java.util.Collections;
+import java.util.Set;
+
+public class MapBean extends AbstractMap 
+{
+	public Set entrySet() {
+		return Collections.EMPTY_SET;
+	}
+}
diff --git a/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/classes/MyBean.java.data b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/classes/MyBean.java.data
new file mode 100644
index 0000000..e57a67a
--- /dev/null
+++ b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/classes/MyBean.java.data
@@ -0,0 +1,111 @@
+package beans;
+
+import java.math.BigInteger;
+import java.math.BigDecimal;
+
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+
+import javax.faces.component.UIComponent; 
+import javax.faces.context.FacesContext;
+
+public class MyBean 
+{
+	public String getStringProperty()
+	{
+		return "";
+	}
+	
+	public int getIntegerProperty()
+	{
+		return 0;
+	}
+	
+	public boolean getBooleanProperty()
+	{
+		return false;
+	}
+	
+	public double getDoubleProperty()
+	{
+		return 1.04;
+	}
+	
+	public Map getMapProperty()
+	{
+		return Collections.EMPTY_MAP;
+	}
+	
+	public String[] getStringArrayProperty()
+	{
+		return new String[0];
+	}
+	
+	public Collection getCollectionProperty()
+	{
+		return Collections.EMPTY_LIST;
+	}
+	
+	public List getListProperty()
+	{
+		return Collections.EMPTY_LIST;
+	}
+	
+	public Comparable getComparableProperty()
+	{
+		return null;
+	}
+	
+	public BigInteger getBigIntegerProperty()
+	{
+		return BigInteger.ONE;
+	}
+	
+	public BigDecimal getBigDoubleProperty()
+	{
+		return new BigDecimal(0.5);
+	}
+	
+	public MyBean recursiveCall()
+	{
+		return this;
+	}
+	
+	public String getWritableStringProperty()
+	{
+		return "";
+	}
+	
+	public void setWritableStringProperty(String newValue)
+	{
+		;
+	}
+	
+	public void validate(FacesContext facesContext, 
+					      UIComponent component,
+					      Object object
+					      )
+	{
+		
+	}
+
+	public void validate2(FacesContext facesContext, 
+		      UIComponent component,
+		      Object[] object
+		      )
+	{
+	
+	}	
+	
+	public MyBean getSelf()
+	{
+		return this;
+	}
+	
+	public boolean isIsStyleBooleanProperty()
+	{
+		return false;
+	}
+}
diff --git a/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/classes/MyBeanSettable.java.data b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/classes/MyBeanSettable.java.data
new file mode 100644
index 0000000..7edb245
--- /dev/null
+++ b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/classes/MyBeanSettable.java.data
@@ -0,0 +1,171 @@
+package beans;
+
+import java.math.BigInteger;
+import java.math.BigDecimal;
+
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+
+import javax.faces.component.UIComponent;
+import javax.faces.context.FacesContext;
+
+public class MyBeanSettable
+{
+	public String getStringProperty()
+	{
+		return "";
+	}
+	
+	public void setStringProperty(String stringProp)
+	{
+		
+	}
+
+	public double getDoubleProperty()
+	{
+		return 1.04;
+	}
+	
+	public void setDoubleProperty(double newValue)
+	{
+		// doesn't matter what happens here
+	}
+
+	public void setIntegerProperty(int integerProp)
+	{
+		
+	}
+
+	public int getIntegerProperty()
+	{
+		return 0;
+	}
+
+	public boolean getBooleanProperty()
+	{
+		return false;
+	}
+	
+	public void setBooleanProperty(boolean booleanProp)
+	{
+		
+	}
+	
+	public Map getMapProperty()
+	{
+		return Collections.EMPTY_MAP;
+	}
+	
+	public void setMapProperty(Map mapProperty)
+	{
+		
+	}
+	
+	public void setStringArrayProperty(String[] stringArrayProperty)
+	{
+		
+	}
+	
+	public String[] getStringArrayProperty()
+	{
+		return new String[0];
+	}
+	
+	public Collection getCollectionProperty()
+	{
+		return Collections.EMPTY_LIST;
+	}
+	
+	public void setCollectionProperty(Collection collectionProp)
+	{
+		
+	}
+
+	public void setListProperty(List listProp)
+	{
+		
+	}
+	
+	public List getListProperty()
+	{
+		return Collections.EMPTY_LIST;
+	}
+
+	public void setComparablePropety(Comparable comp)
+	{
+		
+	}
+	
+	public Comparable getComparableProperty()
+	{
+		return null;
+	}
+	
+	public MyBeanSettable recursiveCall()
+	{
+		return this;
+	}
+	
+	public String getWritableStringProperty()
+	{
+		return "";
+	}
+	
+	public void setWritableStringProperty(String newValue)
+	{
+		;
+	}
+	
+	public BigInteger getBigIntegerProperty()
+	{
+		return BigInteger.ONE;
+	}
+	
+	public void setBigIntegerProperty(BigInteger newValue)
+	{
+		// doesn't matter what happens here
+	}
+	
+	public BigDecimal getBigDoubleProperty()
+	{
+		return new BigDecimal(0.5);
+	}
+	
+	public void setBigDoubleProperty(BigDecimal newValue)
+	{
+		// doesn't matter what happens here
+	}
+	
+	public void validate(FacesContext facesContext, 
+					      UIComponent component,
+					      Object object
+					      )
+	{
+		
+	}
+
+	public void validate2(FacesContext facesContext, 
+		      UIComponent component,
+		      Object[] object
+		      )
+	{
+	
+	}	
+	
+	public MyBeanSettable getSelf()
+	{
+		return this;
+	}
+	
+	public boolean isIsStyleBooleanProperty()
+	{
+		return false;
+	}
+	
+	public void setIsStyleBooleanProperty(boolean styleProp)
+	{
+		
+	}
+}
diff --git a/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/classes/MyBeanSubClass.java.data b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/classes/MyBeanSubClass.java.data
new file mode 100644
index 0000000..aa0a161
--- /dev/null
+++ b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/classes/MyBeanSubClass.java.data
@@ -0,0 +1,10 @@
+package beans;
+
+
+public class MyBeanSubClass extends MyBean 
+{
+	public String getSubClassStringProperty()
+	{
+		return "chicken";
+	}
+}
diff --git a/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/jsps/arithmeticAdd.jsp.data b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/jsps/arithmeticAdd.jsp.data
new file mode 100644
index 0000000..0215c55
--- /dev/null
+++ b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/jsps/arithmeticAdd.jsp.data
@@ -0,0 +1,52 @@
+<%@page contentType="text/html"%>
+<%@page pageEncoding="UTF-8"%>
+<%--
+The taglib directive below imports the JSTL library. If you uncomment it,
+you must also add the JSTL library to the project. The Add Library... action
+on Libraries node in Projects view can be used to add the JSTL 1.1 library.
+--%>
+
+<%@taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%> 
+<%@taglib uri="http://java.sun.com/jsf/core" prefix="f"%>
+<%@taglib uri="http://java.sun.com/jsf/html" prefix="h"%>
+
+
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
+   "http://www.w3.org/TR/html4/loose.dtd">
+
+<html>
+  <head>
+  <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
+        <title>JSP Page</title>
+    </head>
+    <body>
+    <f:view>
+    <h1>JSP Page</h1>
+    	<!--  no errors -->
+    	<h:outputLabel rendered="true"></h:outputLabel>
+    	<h:outputText value="#{myBean.integerProperty  + 3}"/>
+    	<h:outputText value="#{myBean.stringProperty + 3}"/>
+    	<h:outputText value="#{myBean.integerProperty + myBean.integerProperty}"/>
+    	<h:outputText value="#{myBean.bigIntegerProperty + 4}"/>
+    	<h:outputText value="#{myBean.bigIntegerProperty + 5.5}"/>
+    	<h:outputText value="#{myBean.bigDoubleProperty + 5.5}"/>
+    	<h:outputText value="#{myBean.doubleProperty + 5}"/>
+    	
+		<!--  warnings -->
+		<h:outputText value="#{5 + 3}"/>
+		<h:outputText value="#{5.5 + 4}"/>
+		<h:outputText value="#{5.5 + null}"/>
+    	<h:outputText value="#{'5' + '4'}"/>
+    	<h:outputText value="#{null + null}"/>
+    	<h:outputtText value="#{5.5 + 3.5}"/>
+		
+		<!-- errors -->
+		<h:outputText value="#{5 + true}"/>
+		<h:outputText value="#{myBean.integerProperty + myBean.booleanProperty}"/>
+		<h:outputText value="#{myBean.stringArrayProperty + myBean.booleanProperty}"/>
+    	<h:outputText value="#{myBean.integerProperty + true }"/>
+    	<h:outputText value="#{'a' + 'b'}"/>
+    	<h:outputText value="#{myBean.bigIntegerProperty + true}"/>
+    </f:view>
+    </body>
+</html>
diff --git a/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/jsps/arithmeticDivide.jsp.data b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/jsps/arithmeticDivide.jsp.data
new file mode 100644
index 0000000..2e78126
--- /dev/null
+++ b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/jsps/arithmeticDivide.jsp.data
@@ -0,0 +1,68 @@
+<%@page contentType="text/html"%>
+<%@page pageEncoding="UTF-8"%>
+<%--
+The taglib directive below imports the JSTL library. If you uncomment it,
+you must also add the JSTL library to the project. The Add Library... action
+on Libraries node in Projects view can be used to add the JSTL 1.1 library.
+--%>
+
+<%@taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%> 
+<%@taglib uri="http://java.sun.com/jsf/core" prefix="f"%>
+<%@taglib uri="http://java.sun.com/jsf/html" prefix="h"%>
+
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
+   "http://www.w3.org/TR/html4/loose.dtd">
+
+<html>
+    <head>
+        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
+        <title>JSP Page</title>
+    </head>
+    <body>
+    <f:view>
+    <h1>JSP Page</h1>
+    	<!--  no errors -->
+    	<h:outputText value="#{myBean.integerProperty / 3}"/>
+    	<h:outputText value="#{myBean.integerProperty div 3}"/>
+    	<h:outputText value="#{myBean.stringProperty / 3}"/>
+    	<h:outputText value="#{myBean.stringProperty div 3}"/>
+    	<h:outputText value="#{myBean.integerProperty / myBean.integerProperty}"/>
+    	<h:outputText value="#{myBean.integerProperty div myBean.integerProperty}"/>
+    	<h:outputText value="#{myBean.bigIntegerProperty / 4}"/>
+    	<h:outputText value="#{myBean.bigIntegerProperty / 5.5}"/>
+    	<h:outputText value="#{myBean.bigDoubleProperty / 5.5}"/>
+    	<h:outputText value="#{myBean.doubleProperty / 5}"/>
+    	
+    	
+		<!--  warnings -->
+		<h:outputText value="#{5 / 3}"/>
+		<h:outputText value="#{5 div 3}"/>
+		<h:outputText value="#{5.5 / 4}"/>
+		<h:outputText value="#{5.5 div 4}"/>
+    	<h:outputText value="#{'5' / '4'}"/>
+    	<h:outputText value="#{'5' div '4'}"/>
+    	<h:outputText value="#{null / null}"/>
+    	<h:outputText value="#{null div null}"/>
+    	<h:outputText value="#{5.5 / 3.5}"/>
+    			
+		<!-- errors -->
+		<h:outputText value="#{5 / true}"/>
+		<h:outputText value="#{5 div true}"/>
+		<h:outputText value="#{myBean.integerProperty / myBean.booleanProperty}"/>
+		<h:outputText value="#{myBean.integerProperty div myBean.booleanProperty}"/>
+		<h:outputText value="#{myBean.stringArrayProperty / myBean.booleanProperty}"/>
+		<h:outputText value="#{myBean.integerProperty div myBean.booleanProperty}"/>
+    	<h:outputText value="#{myBean.integerProperty / true }"/>
+    	<h:outputText value="#{myBean.integerProperty div true }"/>
+    	<h:outputText value="#{'a' / 'b'}"/>
+    	<h:outputText value="#{'a' div 'b'}"/>
+		<h:outputText value="#{5.5 / null}"/>
+		<h:outputText value="#{5.5 div null}"/>
+		<h:outputText value="#{5/0}"/>
+		<h:outputText value="#{5 div 0}"/>
+		<h:outputText value="#{myBean.bigIntegerProperty + true}"/>
+		<h:outputText value="#{myBean.bigDoubleProperty / null}"/>
+		<h:outputText value="#{myBean.bigDoubleProperty div true}"/>
+    </f:view>
+    </body>
+</html>
diff --git a/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/jsps/arithmeticMinus.jsp.data b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/jsps/arithmeticMinus.jsp.data
new file mode 100644
index 0000000..1aebb7a
--- /dev/null
+++ b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/jsps/arithmeticMinus.jsp.data
@@ -0,0 +1,51 @@
+<%@page contentType="text/html"%>
+<%@page pageEncoding="UTF-8"%>
+<%--
+The taglib directive below imports the JSTL library. If you uncomment it,
+you must also add the JSTL library to the project. The Add Library... action
+on Libraries node in Projects view can be used to add the JSTL 1.1 library.
+--%>
+
+<%@taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%> 
+<%@taglib uri="http://java.sun.com/jsf/core" prefix="f"%>
+<%@taglib uri="http://java.sun.com/jsf/html" prefix="h"%>
+
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
+   "http://www.w3.org/TR/html4/loose.dtd">
+
+<html>
+    <head>
+        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
+        <title>JSP Page</title>
+    </head>
+    <body>
+    <f:view>
+    <h1>JSP Page</h1>
+    	<!--  no errors -->
+    	<h:outputText value="#{myBean.integerProperty - 3}"/>
+    	<h:outputText value="#{myBean.stringProperty - 3}"/>
+    	<h:outputText value="#{myBean.integerProperty - myBean.integerProperty}"/>
+    	<h:outputText value="#{myBean.bigIntegerProperty - 4}"/>
+    	<h:outputText value="#{myBean.bigIntegerProperty - 5.5}"/>
+    	<h:outputText value="#{myBean.bigDoubleProperty - 5.5}"/>
+    	<h:outputText value="#{myBean.doubleProperty - 5}"/>
+    	
+    	
+		<!--  warnings -->
+		<h:outputText value="#{5 - 3}"/>
+		<h:outputText value="#{5.5 - 4}"/>
+		<h:outputText value="#{5.5 - null}"/>
+    	<h:outputText value="#{'5' - '4'}"/>
+    	<h:outputText value="#{null - null}"/>
+    	<h:outputtText value="#{5.5 - 3.5}"/>
+		
+		<!-- errors -->
+		<h:outputText value="#{5 - true}"/>
+		<h:outputText value="#{myBean.integerProperty - myBean.booleanProperty}"/>
+		<h:outputText value="#{myBean.stringArrayProperty - myBean.booleanProperty}"/>
+    	<h:outputText value="#{myBean.integerProperty - true }"/>
+    	<h:outputText value="#{'a' - 'b'}"/>
+    	<h:outputText value="#{myBean.bigIntegerProperty - true}"/>
+    </f:view>
+    </body>
+</html>
diff --git a/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/jsps/arithmeticModulo.jsp.data b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/jsps/arithmeticModulo.jsp.data
new file mode 100644
index 0000000..8eb8bb7
--- /dev/null
+++ b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/jsps/arithmeticModulo.jsp.data
@@ -0,0 +1,65 @@
+<%@page contentType="text/html"%>
+<%@page pageEncoding="UTF-8"%>
+<%--
+The taglib directive below imports the JSTL library. If you uncomment it,
+you must also add the JSTL library to the project. The Add Library... action
+on Libraries node in Projects view can be used to add the JSTL 1.1 library.
+--%>
+
+<%@taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%> 
+<%@taglib uri="http://java.sun.com/jsf/core" prefix="f"%>
+<%@taglib uri="http://java.sun.com/jsf/html" prefix="h"%>
+
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
+   "http://www.w3.org/TR/html4/loose.dtd">
+
+<html>
+    <head>
+        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
+        <title>JSP Page</title>
+    </head>
+    <body>
+    <f:view>
+    <h1>JSP Page</h1>
+    	<!--  no errors -->
+    	<h:outputText value="#{myBean.integerProperty % 3}"/>
+    	<h:outputText value="#{myBean.integerProperty mod 3}"/>
+    	<h:outputText value="#{myBean.stringProperty % 3}"/>
+    	<h:outputText value="#{myBean.stringProperty mod 3}"/>
+    	<h:outputText value="#{myBean.integerProperty % myBean.integerProperty}"/>
+    	<h:outputText value="#{myBean.integerProperty mod myBean.integerProperty}"/>
+    	<h:outputText value="#{myBean.bigIntegerProperty mod 4}"/>
+    	<h:outputText value="#{myBean.doubleProperty mod 4"/>
+    	<h:outputText value="#{myBean.doubleProperty mod 5.43"/>
+    	
+		<!--  warnings -->
+		<h:outputText value="#{5 % 3}"/>
+		<h:outputText value="#{5 mod 3}"/>
+		<h:outputText value="#{5.5 % 4 }"/>
+		<h:outputText value="#{5.5 mod 4 }"/>
+    	<h:outputText value="#{'5' % '4'}"/>
+    	<h:outputText value="#{'5' mod '4'}"/>
+    	<h:outputText value="#{null % null}"/>
+    	<h:outputText value="#{null mod null}"/>
+		
+		<!-- errors -->
+		<h:outputText value="#{5 % true}"/>
+		<h:outputText value="#{5 mod true}"/>
+		<h:outputText value="#{myBean.stringArrayProperty % myBean.booleanProperty}"/>
+		<h:outputText value="#{myBean.stringArrayProperty mod myBean.booleanProperty}"/>
+    	<h:outputText value="#{myBean.integerProperty % true }"/>
+    	<h:outputText value="#{myBean.integerProperty mod true }"/>
+    	<h:outputText value="#{'a' % 'b'}"/>
+    	<h:outputText value="#{'a' mod 'b'}"/>
+		<h:outputText value="#{5.5 % null}"/>
+		<h:outputText value="#{5.5 mod null}"/>
+		<h:outputText value="#{5%0}"/>
+		<h:outputText value="#{5 mod 0}"/>
+		<h:outputText value="#{myBean.integerProperty % myBean.booleanProperty}"/>
+		<h:outputText value="#{myBean.integerProperty mod myBean.booleanProperty}"/>
+		<h:outputText value="#{myBean.bigIntegerProperty % myBean.booleanProperty}"/>
+		<h:outputText value="#{myBean.bigIntegerProperty mod null"/>
+		<h:outputText value="#{myBean.doubleProperty % true}"/>
+    </f:view>
+    </body>
+</html>
diff --git a/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/jsps/arithmeticMultiply.jsp.data b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/jsps/arithmeticMultiply.jsp.data
new file mode 100644
index 0000000..2a308d8
--- /dev/null
+++ b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/jsps/arithmeticMultiply.jsp.data
@@ -0,0 +1,51 @@
+<%@page contentType="text/html"%>
+<%@page pageEncoding="UTF-8"%>
+<%--
+The taglib directive below imports the JSTL library. If you uncomment it,
+you must also add the JSTL library to the project. The Add Library... action
+on Libraries node in Projects view can be used to add the JSTL 1.1 library.
+--%>
+
+<%@taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%> 
+<%@taglib uri="http://java.sun.com/jsf/core" prefix="f"%>
+<%@taglib uri="http://java.sun.com/jsf/html" prefix="h"%>
+
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
+   "http://www.w3.org/TR/html4/loose.dtd">
+
+<html>
+    <head>
+        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
+        <title>JSP Page</title>
+    </head>
+    <body>
+    <f:view>
+    <h1>JSP Page</h1>
+    	<!--  no errors -->
+    	<h:outputText value="#{myBean.integerProperty * 3}"/>
+    	<h:outputText value="#{myBean.stringProperty * 3}"/>
+    	<h:outputText value="#{myBean.integerProperty * myBean.integerProperty}"/>
+    	<h:outputText value="#{myBean.bigIntegerProperty * 4}"/>
+    	<h:outputText value="#{myBean.bigIntegerProperty * 5.5}"/>
+    	<h:outputText value="#{myBean.bigDoubleProperty * 5.5}"/>
+    	<h:outputText value="#{myBean.doubleProperty * 5}"/>
+    	
+    	
+		<!--  warnings -->
+		<h:outputText value="#{5 * 3}"/>
+		<h:outputText value="#{5.5 * 4}"/>
+		<h:outputText value="#{5.5 * null}"/>
+    	<h:outputText value="#{'5' * '4'}"/>
+    	<h:outputText value="#{null * null}"/>
+    	<h:outputtText value="#{5.5 * 3.5}"/>
+    	
+		<!-- errors -->
+		<h:outputText value="#{5 * true}"/>
+		<h:outputText value="#{myBean.integerProperty * myBean.booleanProperty}"/>
+		<h:outputText value="#{myBean.stringArrayProperty * myBean.booleanProperty}"/>
+    	<h:outputText value="#{myBean.integerProperty * true }"/>
+    	<h:outputText value="#{'a' * 'b'}"/>
+    	<h:outputText value="#{myBean.bigIntegerProperty * true}"/>
+    </f:view>
+    </body>
+</html>
diff --git a/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/jsps/assignability.jsp.data b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/jsps/assignability.jsp.data
new file mode 100644
index 0000000..cce9122
--- /dev/null
+++ b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/jsps/assignability.jsp.data
@@ -0,0 +1,35 @@
+<%@page contentType="text/html"%>
+<%@page pageEncoding="UTF-8"%>
+<%--
+The taglib directive below imports the JSTL library. If you uncomment it,
+you must also add the JSTL library to the project. The Add Library... action
+on Libraries node in Projects view can be used to add the JSTL 1.1 library.
+--%>
+
+<%@taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%> 
+<%@taglib uri="http://java.sun.com/jsf/core" prefix="f"%>
+<%@taglib uri="http://java.sun.com/jsf/html" prefix="h"%>
+
+
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
+   "http://www.w3.org/TR/html4/loose.dtd">
+
+<html>
+    <head>
+  <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
+        <title>JSP Page</title>
+    </head>
+    <body>
+    <f:view>
+    <f:loadBundle var="bundle" basename="beans.Bundle"/>
+    <h1>JSP Page</h1>
+    	<!--  no errors -->
+    	<h:outputText value="#{myBean.integerProperty + 3}"/>
+    	<h:inputText value="#{myBean.writableStringProperty}"/>
+ 		<h:inputText value="#{myBean.stringProperty}"/>
+		<h:inputText value="#{bundle.bundleProp2}"/>
+    	<h:inputText value="#{requestScope.myBeanSubClass}"/>
+    	<h:inputText value="#{myBean.validate}"/>
+    </f:view>
+    </body>
+</html>
diff --git a/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/jsps/badSyntax.jsp.data b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/jsps/badSyntax.jsp.data
new file mode 100644
index 0000000..8021873
--- /dev/null
+++ b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/jsps/badSyntax.jsp.data
@@ -0,0 +1,36 @@
+<%@page contentType="text/html"%>
+<%@page pageEncoding="UTF-8"%>
+<%--
+The taglib directive below imports the JSTL library. If you uncomment it,
+you must also add the JSTL library to the project. The Add Library... action
+on Libraries node in Projects view can be used to add the JSTL 1.1 library.
+--%>
+
+<%@taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%> 
+<%@taglib uri="http://java.sun.com/jsf/core" prefix="f"%>
+<%@taglib uri="http://java.sun.com/jsf/html" prefix="h"%>
+
+
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
+   "http://www.w3.org/TR/html4/loose.dtd">
+
+<html>
+  <head>
+  <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
+        <title>JSP Page</title>
+    </head>
+    <body>
+    <f:view>
+    <h1>JSP Page</h1>
+		<!--  warnings -->
+		<h:outputText value="#{}"/>
+		<h:outputText value="#{ }"/>
+		<h:outputText value="#{myBean.integerProperty + }"/>
+		<h:outputText value="#{&& myBean.booleanProperty}"/>
+		<h:outputText value="#{&!}"/>
+		<h:outputText value="#{f?x}"/>
+		
+		<!-- errors -->
+    </f:view>
+    </body>
+</html>
diff --git a/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/jsps/beanPropertyResolution.jsp.data b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/jsps/beanPropertyResolution.jsp.data
new file mode 100644
index 0000000..ad9e557
--- /dev/null
+++ b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/jsps/beanPropertyResolution.jsp.data
@@ -0,0 +1,72 @@
+<%@page contentType="text/html"%>
+<%@page pageEncoding="UTF-8"%>
+
+<%@taglib uri="http://java.sun.com/jsf/core" prefix="f"%>
+<%@taglib uri="http://java.sun.com/jsf/html" prefix="h"%>
+
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
+   "http://www.w3.org/TR/html4/loose.dtd">
+
+<html>
+    <head>
+  		<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
+        <title>JSP Page</title>
+    </head>
+    <body>
+    <f:view>
+    <h1>JSP Page</h1>
+    	<!--  no errors -->
+    	<h:outputText value="#{myBean.stringProperty}"/>
+    	<h:outputText value="#{myBean.integerProperty}"/>
+    	<h:outputText value="#{myBean.booleanProperty}"/>
+    	<h:outputText value="#{myBean.doubleProperty}"/>
+    	<h:outputText value="#{myBean.mapProperty}"/>
+    	<h:outputText value="#{myBean.stringArrayProperty}"/>
+    	<h:outputText value="#{myBean.collectionProperty}"/>
+    	<h:outputText value="#{myBean.listProperty}"/>
+    	<h:outputText value="#{myBean.comparableProperty}"/>
+    	<h:outputText value="#{myBean.bigIntegerProperty}"/>
+    	<h:outputText value="#{myBean.bigDoubleProperty}"/>
+    	<h:outputText value="#{myBean.writableStringProperty}"/>
+    	<h:outputText value="#{myBean.isStyleBooleanProperty}"/>
+
+		<!-- sub-class resolution -->
+    	<h:outputText value="#{myBeanSubClass.stringProperty}"/>
+    	<h:outputText value="#{myBeanSubClass.integerProperty}"/>
+    	<h:outputText value="#{myBeanSubClass.booleanProperty}"/>
+    	<h:outputText value="#{myBeanSubClass.doubleProperty}"/>
+    	<h:outputText value="#{myBeanSubClass.mapProperty}"/>
+    	<h:outputText value="#{myBeanSubClass.stringArrayProperty}"/>
+    	<h:outputText value="#{myBeanSubClass.collectionProperty}"/>
+    	<h:outputText value="#{myBeanSubClass.listProperty}"/>
+    	<h:outputText value="#{myBeanSubClass.comparableProperty}"/>
+    	<h:outputText value="#{myBeanSubClass.bigIntegerProperty}"/>
+    	<h:outputText value="#{myBeanSubClass.bigDoubleProperty}"/>
+    	<h:outputText value="#{myBeanSubClass.writableStringProperty}"/>
+    	<h:outputText value="#{myBeanSubClass.isStyleBooleanProperty}"/>
+    	<h:outputText value="#{myBeanSubClass.subClassStringProperty}"/>
+
+		<!-- settable properties -->
+		<h:outputText value="#{myBeanSubClass.stringProperty}"/>
+    	<h:outputText value="#{myBeanSettable.integerProperty}"/>
+    	<h:outputText value="#{myBeanSettable.booleanProperty}"/>
+    	<h:outputText value="#{myBeanSettable.doubleProperty}"/>
+    	<h:outputText value="#{myBeanSettable.mapProperty}"/>
+    	<h:outputText value="#{myBeanSettable.stringArrayProperty}"/>
+    	<h:outputText value="#{myBeanSettable.collectionProperty}"/>
+    	<h:outputText value="#{myBeanSettable.listProperty}"/>
+    	<h:outputText value="#{myBeanSettable.comparableProperty}"/>
+    	<h:outputText value="#{myBeanSettable.bigIntegerProperty}"/>
+    	<h:outputText value="#{myBeanSettable.bigDoubleProperty}"/>
+    	<h:outputText value="#{myBeanSettable.writableStringProperty}"/>
+    	<h:outputText value="#{myBeanSettable.isStyleBooleanProperty}"/>
+    	
+		<!--  warnings -->
+    	<h:outputText value="#{myBean.subClassStringProperty}"/>
+    	<h:outputText value="#{myBeanSubClass.notAMember}"/>
+    	<h:outputText value="#{myBeanSettable.alsoNotAMember}"/>
+
+		<!-- errors -->
+    </f:view>
+    </body>
+</html>
diff --git a/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/jsps/beanVariableResolution.jsp.data b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/jsps/beanVariableResolution.jsp.data
new file mode 100644
index 0000000..45ec455
--- /dev/null
+++ b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/jsps/beanVariableResolution.jsp.data
@@ -0,0 +1,35 @@
+<%@page contentType="text/html"%>
+<%@page pageEncoding="UTF-8"%>
+
+<%@taglib uri="http://java.sun.com/jsf/core" prefix="f"%>
+<%@taglib uri="http://java.sun.com/jsf/html" prefix="h"%>
+
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
+   "http://www.w3.org/TR/html4/loose.dtd">
+
+<html>
+    <head>
+  		<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
+        <title>JSP Page</title>
+    </head>
+    <body>
+    <f:view>
+    <h1>JSP Page</h1>
+    	<!--  no errors -->
+    	<h:outputText value="#{myBean}"/>
+    	<h:outputText value="#{myBeanSubClass}"/>
+    	<h:outputText value="#{mapBean}"/>
+    	<h:outputText value="#{mapBean1}"/>
+    	<h:outputText value="#{hiddenBean}"/>
+    	<h:outputText value="#{myBean_none}"/>
+    	<h:outputText value="#{myBeanSettable}"/>
+    	
+		<!--  warnings -->
+    	<h:outputText value="#{myBean1}"/>
+    	<h:outputText value="#{someOtherBeanName}"/>
+
+		<!-- errors -->
+
+    </f:view>
+    </body>
+</html>
diff --git a/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/jsps/builtinSymbols.jsp.data b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/jsps/builtinSymbols.jsp.data
new file mode 100644
index 0000000..ebc0494
--- /dev/null
+++ b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/jsps/builtinSymbols.jsp.data
@@ -0,0 +1,112 @@
+<%@page contentType="text/html"%>
+<%@page pageEncoding="UTF-8"%>
+<%--
+The taglib directive below imports the JSTL library. If you uncomment it,
+you must also add the JSTL library to the project. The Add Library... action
+on Libraries node in Projects view can be used to add the JSTL 1.1 library.
+--%>
+
+<%@taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%> 
+<%@taglib uri="http://java.sun.com/jsf/core" prefix="f"%>
+<%@taglib uri="http://java.sun.com/jsf/html" prefix="h"%>
+
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
+   "http://www.w3.org/TR/html4/loose.dtd">
+
+<html>
+    <head>
+  <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
+        <title>JSP Page</title>
+    </head>
+    <body>
+    <f:view>
+    <h1>JSP Page</h1>
+    	<f:loadBundle var="bundle" basename="beans.Bundle"/>
+    	<f:loadBundle var="bundle2" basename="beans.Bundle"/>
+	
+    	<!--  no errors -->
+    	<!-- check all built-ins -->
+    	<h:outputText value="#{applicationScope}"/>
+    	<h:outputText value="#{sessionScope}"/>
+    	<h:outputText value="#{requestScope}"/>
+    	<h:outputText value="#{cookie}"/>
+    	<h:outputText value="#{facesContext}"/>
+    	<h:outputText value="#{header}"/>
+    	<h:outputText value="#{headerValues}"/>
+    	<h:outputText value="#{initParam}"/>
+    	<h:outputText value="#{param}"/>
+    	<h:outputText value="#{paramValues}"/>
+    	<h:outputText value="#{view}"/>
+
+		<!-- check known application scope variables -->
+		<h:outputText value="#{applicationScope.mapBean}"/>
+		
+		<!-- check known session scope variables -->
+		<h:outputText value="#{sessionScope.myBean}"/>
+		<h:outputText value="#{sessionScope.mapBean1}"/>
+		<h:outputText value="#{sessionScope.myBeanSettable}"/>
+		
+		<!-- check known request scope variables -->
+		<h:outputText value="#{requestScope.myBeanSubClass}"/>
+		<h:outputText value="#{requestScope.hiddenBean}"/>
+		<h:outputText value="#{requestScope.bundle}"/>
+		<h:outputText value="#{requestScope.bundle2}"/>
+
+		<!-- these only get runtime members, so just check that they can be empty -->
+    	<h:outputText value="#{empty cookie}"/>
+		<h:outputText value="#{empty header}"/>
+		<h:outputText value="#{empty headerValues}"/>
+		<h:outputText value="#{empty param}"/>
+		<h:outputText value="#{empty paramValues}"/>		
+		
+		<!-- test known members of facesContext -->
+		<h:outputText value="#{facesContext.application}"/>
+		<h:outputText value="#{facesContext.clientIdsWithMessages}"/>
+		<h:outputText value="#{facesContext.externalContext}"/>
+		<h:outputText value="#{facesContext.maximumSeverity}"/>
+		<h:outputText value="#{facesContext.messages}"/>
+		<h:outputText value="#{facesContext.renderKit}"/>
+		<h:outputText value="#{facesContext.renderResponse}"/>
+		<h:outputText value="#{facesContext.responseComplete}"/>
+		<h:outputText value="#{facesContext.responseStream}"/>
+		<h:outputText value="#{facesContext.responseWriter}"/>
+		<h:outputText value="#{facesContext.viewRoot}"/>
+		
+		<!-- test known members of viewRoot -->
+		<h:outputText value="#{view.viewId}"/>
+		<h:outputText value="#{view.family}"/>
+		<h:outputText value="#{view.locale}"/>
+		<h:outputText value="#{view.renderKitId}"/>
+		<h:outputText value="#{view.viewId}"/>
+
+		<!- check objects accessed through scoping -->		
+    	<h:outputText value="#{sessionScope.myBean.integerProperty}"/>
+    	<h:outputText value="#{requestScope.bundle.bundleProp2}"/>
+
+		<!-- a little interaction through scope map -->
+    	<h:outputText value="#{3 + sessionScope.myBean.integerProperty}"/>
+
+		<!--  warnings -->
+    	<h:outputText value="#{applicationScope.notAMember}"/>
+    	<h:outputText value="#{sessionScope.notAMember}"/>
+    	<h:outputText value="#{requestScope.notAMember}"/>
+    	<h:outputText value="#{cookie.notAMember}"/>
+    	<h:outputText value="#{facesContext.notAMember}"/>
+    	<h:outputText value="#{header.notAMember}"/>
+    	<h:outputText value="#{headerValues.notAMember}"/>
+    	<h:outputText value="#{initParam.notAMember}"/>
+    	<h:outputText value="#{param.notAMember}"/>
+    	<h:outputText value="#{paramValues.notAMember}"/>
+    	<h:outputText value="#{view.notAMember}"/>
+    	
+    	<!-- right bean, wrong scope map -->
+    	<h:outputText value="#{applicationScope.myBean_none}"/>
+    	<h:outputText value="#{sessionScope.myBean_none}"/>
+    	<h:outputText value="#{requestScope.myBean_none}"/>
+
+		<!-- errors -->
+		<h:outputText value="#{!initParam}"/>
+
+    </f:view>
+    </body>
+</html>
diff --git a/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/jsps/complexArithmetic1.jsp.data b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/jsps/complexArithmetic1.jsp.data
new file mode 100644
index 0000000..06a073c
--- /dev/null
+++ b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/jsps/complexArithmetic1.jsp.data
@@ -0,0 +1,46 @@
+<%@page contentType="text/html"%>
+<%@page pageEncoding="UTF-8"%>
+<%--
+The taglib directive below imports the JSTL library. If you uncomment it,
+you must also add the JSTL library to the project. The Add Library... action
+on Libraries node in Projects view can be used to add the JSTL 1.1 library.
+--%>
+
+<%@taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%> 
+<%@taglib uri="http://java.sun.com/jsf/core" prefix="f"%>
+<%@taglib uri="http://java.sun.com/jsf/html" prefix="h"%>
+
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
+   "http://www.w3.org/TR/html4/loose.dtd">
+
+<html>
+    <head>
+        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
+        <title>JSP Page</title>
+    </head>
+    <body>
+    <f:view>
+    <h1>JSP Page</h1>
+    	<!--  no errors -->
+     	<h:outputText value="#{myBean.integerProperty + 3 * myBean.integerProperty}"/>
+    	<h:outputText value="#{(myBean.stringProperty + 3) / 5}"/>
+    	<h:outputText value="#{myBean.integerProperty + myBean.integerProperty * '5'}"/>
+    	
+    	
+		<!--  warnings -->
+		<h:outputText value="#{5 + 3 / 5}"/>
+		<h:outputText value="#{1+2+3+4+5+6}"/>
+		<h:outputText value="#{1-2-3}"/>
+		<h:outputText value="#{1*2*3*4*5*6}"/>
+		<h:outputText value="#{1*2*3*4*5*6}"/>
+    	<h:outputText value="#{'5' + '4'}"/>
+    	<h:outputText value="#{null + null}"/>
+		<h:outputText value="#{1+2-3+4-5+6}"/>
+		
+		<!-- errors -->
+    	<h:outputText value="#{'a' + 'b' + 'c' * 'd'}"/>
+		<h:outputText value="#{(5.5 + 4) / (5-5)}"/>
+
+    </f:view>
+    </body>
+</html>
diff --git a/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/jsps/complexComparison.jsp.data b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/jsps/complexComparison.jsp.data
new file mode 100644
index 0000000..778aa80
--- /dev/null
+++ b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/jsps/complexComparison.jsp.data
@@ -0,0 +1,36 @@
+<%@page contentType="text/html"%>
+<%@page pageEncoding="UTF-8"%>
+<%--
+The taglib directive below imports the JSTL library. If you uncomment it,
+you must also add the JSTL library to the project. The Add Library... action
+on Libraries node in Projects view can be used to add the JSTL 1.1 library.
+--%>
+
+<%@taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%> 
+<%@taglib uri="http://java.sun.com/jsf/core" prefix="f"%>
+<%@taglib uri="http://java.sun.com/jsf/html" prefix="h"%>
+
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
+   "http://www.w3.org/TR/html4/loose.dtd">
+
+<html>
+    <head>
+        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
+        <title>JSP Page</title>
+    </head>
+    <body>
+    <f:view>
+    <h1>JSP Page</h1>
+    	<!--  no errors -->
+     	<h:outputText value="#{myBean.integerProperty > -3 and myBean.integerProperty > -3}"/>
+     	<h:outputText value="#{myBean.integerProperty > -3 && myBean.integerProperty > -3}"/>
+    	
+    	
+		<!--  warnings -->
+		
+		<!-- errors -->
+
+
+    </f:view>
+    </body>
+</html>
\ No newline at end of file
diff --git a/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/jsps/emptyOperator.jsp.data b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/jsps/emptyOperator.jsp.data
new file mode 100644
index 0000000..0e1131f
--- /dev/null
+++ b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/jsps/emptyOperator.jsp.data
@@ -0,0 +1,44 @@
+<%@page contentType="text/html"%>
+<%@page pageEncoding="UTF-8"%>
+<%--
+The taglib directive below imports the JSTL library. If you uncomment it,
+you must also add the JSTL library to the project. The Add Library... action
+on Libraries node in Projects view can be used to add the JSTL 1.1 library.
+--%>
+
+<%@taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%> 
+<%@taglib uri="http://java.sun.com/jsf/core" prefix="f"%>
+<%@taglib uri="http://java.sun.com/jsf/html" prefix="h"%>
+
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
+   "http://www.w3.org/TR/html4/loose.dtd">
+
+<html>
+    <head>
+        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
+        <title>JSP Page</title>
+    </head>
+    <body>
+    <f:view>
+    <h1>JSP Page</h1>
+    	<!--  no errors -->
+    	<h:outputText value="#{empty myBean.collectionProperty}"/>
+    	<h:outputText value="#{empty myBean.mapProperty}"/>
+    	<h:outputText value="#{empty myBean.stringArrayProperty}"/>
+    	<h:outputText value="#{empty myBean.stringProperty}"/>
+    	<h:outputText value="#{myBean.stringProperty}"/>
+    	<h:outputText value="#{empty myBean.listProperty}"/>
+		<h:outputText value="#{empty mapBean}"/>
+		
+		<!--  warnings -->
+		<h:outputText value="#{empty 5}"/>
+		<h:outputText value="#{empty myBean.integerProperty}"/>
+		<h:outputText value="#{empty false}"/>
+		<h:outputText value="#{empty myBean.booleanProperty}"/>
+		<h:outputText value="#{empty ''}"/>
+    	<h:outputText value="#{empty 'notEmpty'}"/>\
+    	<h:outputText value="#{empty null}"/>
+    	<h:outputText value="#{empty 456}"/>
+    </f:view>
+    </body>
+</html>
diff --git a/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/jsps/greaterThan.jsp.data b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/jsps/greaterThan.jsp.data
new file mode 100644
index 0000000..05ff5c4
--- /dev/null
+++ b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/jsps/greaterThan.jsp.data
@@ -0,0 +1,69 @@
+<%@page contentType="text/html"%>
+<%@page pageEncoding="UTF-8"%>
+<%--
+The taglib directive below imports the JSTL library. If you uncomment it,
+you must also add the JSTL library to the project. The Add Library... action
+on Libraries node in Projects view can be used to add the JSTL 1.1 library.
+--%>
+
+<%@taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%> 
+<%@taglib uri="http://java.sun.com/jsf/core" prefix="f"%>
+<%@taglib uri="http://java.sun.com/jsf/html" prefix="h"%>
+
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
+   "http://www.w3.org/TR/html4/loose.dtd">
+
+<html>
+    <head>
+        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
+        <title>JSP Page</title>
+    </head>
+    <body>
+    <f:view>
+    <h1>JSP Page</h1>
+    	<!--  no errors -->
+    	<h:outputText value="#{myBean.stringProperty > '3'}"/>
+    	<h:outputText value="#{myBean.stringProperty gt '3'}"/>
+    	<h:outputText value="#{myBean.integerProperty > 3}"/>
+    	<h:outputText value="#{myBean.integerProperty gt 3}"/>
+    	<h:outputText value="#{myBean.integerProperty > '4' }"/>
+    	<h:outputText value="#{myBean.integerProperty gt '4' }"/>
+     	<h:outputText value="#{myBean.comparableProperty > myBean.collectionProperty}"/>
+    	<h:outputText value="#{myBean.comparableProperty gt myBean.collectionProperty}"/>
+    	<h:outputText value="#{myBean.integerProperty > -3}"/>
+    	<h:outputText value="#{myBean.doubleProperty > 5}"/>
+    	<h:outputText value="#{5 gt myBean.bigIntegerProperty}"/>
+    	<h:outputText value="#{myBean.bigDoubleProperty > myBean.bigIntegerProperty}"/>
+    	
+		<!--  warnings -->
+		<h:outputText value="#{5 > 3}"/>
+		<h:outputText value="#{5 gt 3}"/>
+		<h:outputText value="#{'4' > '34'}"/>
+		<h:outputText value="#{'4' gt '34'}"/>
+		<h:outputText value="#{'34' > '34'}"/>
+		<h:outputText value="#{'34' gt '34'}"/>
+		<h:outputText value="#{-5 > 2}"/>
+		<h:outputText value="#{-5 gt 2}"/>
+		<h:outputText value="#{2 > -5}"/>
+		<h:outputText value="#{2 gt -5}"/>
+		<h:outputText value="#{-5 > -5}"/>
+		<h:outputText value="#{-5 gt -5}"/>
+		<h:outputText value="#{myBean.integerProperty > null}"/>
+		<h:outputText value="#{null gt myBean.integerProperty}"/>
+		
+		<!-- errors -->
+		<h:outputText value="#{5 > true}"/>
+		<h:outputText value="#{5 gt true}"/>
+		<h:outputText value="#{myBean.integerProperty > myBean.booleanProperty}"/>
+		<h:outputText value="#{myBean.integerProperty gt myBean.booleanProperty}"/>
+		<h:outputText value="#{myBean.stringArrayProperty > myBean.booleanProperty}"/>
+		<h:outputText value="#{myBean.stringArrayProperty gt myBean.booleanProperty}"/>
+    	<h:outputText value="#{myBean.integerProperty > true }"/>
+    	<h:outputText value="#{myBean.integerProperty gt true }"/>
+    	<h:outputText value="#{myBean.booleanProperty > true}"/>
+    	<h:outputText value="#{myBean.booleanProperty gt true}"/>
+ 		<h:outputText value="#{true > false}"/>
+ 		<h:outputText value="#{true gt false}"/>
+    </f:view>
+    </body>
+</html>
diff --git a/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/jsps/greaterThanEq.jsp.data b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/jsps/greaterThanEq.jsp.data
new file mode 100644
index 0000000..ee71add
--- /dev/null
+++ b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/jsps/greaterThanEq.jsp.data
@@ -0,0 +1,69 @@
+<%@page contentType="text/html"%>
+<%@page pageEncoding="UTF-8"%>
+<%--
+The taglib directive below imports the JSTL library. If you uncomment it,
+you must also add the JSTL library to the project. The Add Library... action
+on Libraries node in Projects view can be used to add the JSTL 1.1 library.
+--%>
+
+<%@taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%> 
+<%@taglib uri="http://java.sun.com/jsf/core" prefix="f"%>
+<%@taglib uri="http://java.sun.com/jsf/html" prefix="h"%>
+
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
+   "http://www.w3.org/TR/html4/loose.dtd">
+
+<html>
+    <head>
+        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
+        <title>JSP Page</title>
+    </head>
+    <body>
+    <f:view>
+    <h1>JSP Page</h1>
+    	<!--  no errors -->
+    	<h:outputText value="#{myBean.stringProperty >= '3'}"/>
+    	<h:outputText value="#{myBean.stringProperty ge '3'}"/>
+    	<h:outputText value="#{myBean.integerProperty >= 3}"/>
+    	<h:outputText value="#{myBean.integerProperty ge 3}"/>
+    	<h:outputText value="#{myBean.integerProperty >= '4' }"/>
+    	<h:outputText value="#{myBean.integerProperty ge '4' }"/>
+     	<h:outputText value="#{myBean.comparableProperty >= myBean.collectionProperty}"/>
+    	<h:outputText value="#{myBean.comparableProperty ge myBean.collectionProperty}"/>
+  	    <h:outputText value="#{myBean.integerProperty >= -3}"/>
+    	<h:outputText value="#{myBean.doubleProperty > 5}"/>
+    	<h:outputText value="#{5 gt myBean.bigIntegerProperty}"/>
+    	<h:outputText value="#{myBean.bigDoubleProperty > myBean.bigIntegerProperty}"/>
+  	    	
+		<!--  warnings -->
+		<h:outputText value="#{5 >= 3}"/>
+		<h:outputText value="#{5 ge 3}"/>
+		<h:outputText value="#{'4' >= '34'}"/>
+		<h:outputText value="#{'4' ge '34'}"/>
+		<h:outputText value="#{'34' >= '34'}"/>
+		<h:outputText value="#{'34' ge '34'}"/>
+		<h:outputText value="#{-5 >= 2}"/>
+		<h:outputText value="#{-5 ge 2}"/>
+		<h:outputText value="#{2 >= -5}"/>
+		<h:outputText value="#{2 ge -5}"/>
+		<h:outputText value="#{-5 >= -5}"/>
+		<h:outputText value="#{-5 ge -5}"/>
+		<h:outputText value="#{myBean.integerProperty > null}"/>
+		<h:outputText value="#{null gt myBean.integerProperty}"/>
+		
+		<!-- errors -->
+		<h:outputText value="#{5 >= true}"/>
+		<h:outputText value="#{5 ge true}"/>
+		<h:outputText value="#{myBean.integerProperty >= myBean.booleanProperty}"/>
+		<h:outputText value="#{myBean.integerProperty ge myBean.booleanProperty}"/>
+		<h:outputText value="#{myBean.stringArrayProperty >= myBean.booleanProperty}"/>
+		<h:outputText value="#{myBean.stringArrayProperty ge myBean.booleanProperty}"/>
+    	<h:outputText value="#{myBean.integerProperty >= true }"/>
+    	<h:outputText value="#{myBean.integerProperty ge true }"/>
+    	<h:outputText value="#{myBean.booleanProperty >= true}"/>
+    	<h:outputText value="#{myBean.booleanProperty ge true}"/>
+ 		<h:outputText value="#{true >= false}"/>
+ 		<h:outputText value="#{true ge false}"/>
+    </f:view>
+    </body>
+</html>
diff --git a/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/jsps/jspFunctions.jsp.data b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/jsps/jspFunctions.jsp.data
new file mode 100644
index 0000000..d484c3f
--- /dev/null
+++ b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/jsps/jspFunctions.jsp.data
@@ -0,0 +1,42 @@
+<%@page contentType="text/html"%>
+<%@page pageEncoding="UTF-8"%>
+<%--
+The taglib directive below imports the JSTL library. If you uncomment it,
+you must also add the JSTL library to the project. The Add Library... action
+on Libraries node in Projects view can be used to add the JSTL 1.1 library.
+--%>
+
+<%@taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%> 
+<%@taglib uri="http://java.sun.com/jsf/core" prefix="f"%>
+<%@taglib uri="http://java.sun.com/jsf/html" prefix="h"%>
+
+
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
+   "http://www.w3.org/TR/html4/loose.dtd">
+
+<html>
+  <head>
+  <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
+        <title>JSP Page</title>
+    </head>
+    <body>
+    <f:view>
+    <h1>JSP Page</h1>
+    	<!--  no errors -->
+    	<!--  functions not supported by JSF 1.1 so we should always ignore
+    	      sub-expressions with functions -->
+    	<h:outputText value="#{f:someFunc(6) > 8}"/>
+    	<h:outputText value="#{f:someFunc(6)}"/>
+    	<h:outputText value="#{f:someFunc(true)}"/>
+    	
+		<!--  warnings -->
+		<!--  these warnings are parser bugs: unqualified function invocation does
+		      not get parsed correctly -->
+    	<h:outputText value="#{someFunc(6) > 8}"/>
+    	<h:outputText value="#{someFunc(6)}"/>
+    	<h:outputText value="#{someFunc(true)}"/>
+		
+		<!-- errors -->
+    </f:view>
+    </body>
+</html>
diff --git a/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/jsps/lessThan.jsp.data b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/jsps/lessThan.jsp.data
new file mode 100644
index 0000000..c8f4de1
--- /dev/null
+++ b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/jsps/lessThan.jsp.data
@@ -0,0 +1,69 @@
+<%@page contentType="text/html"%>
+<%@page pageEncoding="UTF-8"%>
+<%--
+The taglib directive below imports the JSTL library. If you uncomment it,
+you must also add the JSTL library to the project. The Add Library... action
+on Libraries node in Projects view can be used to add the JSTL 1.1 library.
+--%>
+
+<%@taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%> 
+<%@taglib uri="http://java.sun.com/jsf/core" prefix="f"%>
+<%@taglib uri="http://java.sun.com/jsf/html" prefix="h"%>
+
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
+   "http://www.w3.org/TR/html4/loose.dtd">
+
+<html>
+    <head>
+        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
+        <title>JSP Page</title>
+    </head>
+    <body>
+    <f:view>
+    <h1>JSP Page</h1>
+    	<!--  no errors -->
+    	<h:outputText value="#{myBean.stringProperty < '3'}"/>
+    	<h:outputText value="#{myBean.stringProperty lt '3'}"/>
+    	<h:outputText value="#{myBean.integerProperty < 3}"/>
+    	<h:outputText value="#{myBean.integerProperty lt 3}"/>
+    	<h:outputText value="#{myBean.integerProperty < '4' }"/>
+    	<h:outputText value="#{myBean.integerProperty lt '4' }"/>
+     	<h:outputText value="#{myBean.comparableProperty < myBean.collectionProperty}"/>
+    	<h:outputText value="#{myBean.comparableProperty lt myBean.collectionProperty}"/>
+    	<h:outputText value="#{myBean.integerProperty < -3}"/>
+    	<h:outputText value="#{myBean.doubleProperty < 5}"/>
+    	<h:outputText value="#{5 lt myBean.bigIntegerProperty}"/>
+    	<h:outputText value="#{myBean.bigDoubleProperty < myBean.bigIntegerProperty}"/>
+    	
+		<!--  warnings -->
+		<h:outputText value="#{5 < 3}"/>
+		<h:outputText value="#{5 lt 3}"/>
+		<h:outputText value="#{'4' < '34'}"/>
+		<h:outputText value="#{'4' lt '34'}"/>
+		<h:outputText value="#{'34' < '34'}"/>
+		<h:outputText value="#{'34' lt '34'}"/>
+		<h:outputText value="#{-5 < 2}"/>
+		<h:outputText value="#{-5 lt 2}"/>
+		<h:outputText value="#{2 < -5}"/>
+		<h:outputText value="#{2 lt -5}"/>
+		<h:outputText value="#{-5 < -5}"/>
+		<h:outputText value="#{-5 lt -5}"/>
+		<h:outputText value="#{myBean.integerProperty < null}"/>
+		<h:outputText value="#{null lt myBean.integerProperty}"/>
+		
+		<!-- errors -->
+		<h:outputText value="#{5 < true}"/>
+		<h:outputText value="#{5 lt true}"/>
+		<h:outputText value="#{myBean.integerProperty < myBean.booleanProperty}"/>
+		<h:outputText value="#{myBean.integerProperty lt myBean.booleanProperty}"/>
+		<h:outputText value="#{myBean.stringArrayProperty < myBean.booleanProperty}"/>
+		<h:outputText value="#{myBean.stringArrayProperty lt myBean.booleanProperty}"/>
+    	<h:outputText value="#{myBean.integerProperty < true }"/>
+    	<h:outputText value="#{myBean.integerProperty lt true }"/>
+    	<h:outputText value="#{myBean.booleanProperty < true}"/>
+    	<h:outputText value="#{myBean.booleanProperty lt true}"/>
+ 		<h:outputText value="#{true < false}"/>
+ 		<h:outputText value="#{true lt false}"/>
+    </f:view>
+    </body>
+</html>
diff --git a/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/jsps/lessThanEq.jsp.data b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/jsps/lessThanEq.jsp.data
new file mode 100644
index 0000000..cff2356
--- /dev/null
+++ b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/jsps/lessThanEq.jsp.data
@@ -0,0 +1,69 @@
+<%@page contentType="text/html"%>
+<%@page pageEncoding="UTF-8"%>
+<%--
+The taglib directive below imports the JSTL library. If you uncomment it,
+you must also add the JSTL library to the project. The Add Library... action
+on Libraries node in Projects view can be used to add the JSTL 1.1 library.
+--%>
+
+<%@taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%> 
+<%@taglib uri="http://java.sun.com/jsf/core" prefix="f"%>
+<%@taglib uri="http://java.sun.com/jsf/html" prefix="h"%>
+
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
+   "http://www.w3.org/TR/html4/loose.dtd">
+
+<html>
+    <head>
+        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
+        <title>JSP Page</title>
+    </head>
+    <body>
+    <f:view>
+    <h1>JSP Page</h1>
+    	<!--  no errors -->
+    	<h:outputText value="#{myBean.stringProperty <= '3'}"/>
+    	<h:outputText value="#{myBean.stringProperty le '3'}"/>
+    	<h:outputText value="#{myBean.integerProperty <= 3}"/>
+    	<h:outputText value="#{myBean.integerProperty le 3}"/>
+    	<h:outputText value="#{myBean.integerProperty <= '4' }"/>
+    	<h:outputText value="#{myBean.integerProperty le '4' }"/>
+     	<h:outputText value="#{myBean.comparableProperty <= myBean.collectionProperty}"/>
+    	<h:outputText value="#{myBean.comparableProperty le myBean.collectionProperty}"/>
+    	<h:outputText value="#{myBean.integerProperty <= -3}"/>
+    	<h:outputText value="#{myBean.doubleProperty <= 5}"/>
+    	<h:outputText value="#{5 le myBean.bigIntegerProperty}"/>
+    	<h:outputText value="#{myBean.bigDoubleProperty <= myBean.bigIntegerProperty}"/>
+  	    
+		<!--  warnings -->
+		<h:outputText value="#{5 <= 3}"/>
+		<h:outputText value="#{5 le 3}"/>
+		<h:outputText value="#{'4' <= '34'}"/>
+		<h:outputText value="#{'4' le '34'}"/>
+		<h:outputText value="#{'34' <= '34'}"/>
+		<h:outputText value="#{'34' le '34'}"/>
+		<h:outputText value="#{-5 <= 2}"/>
+		<h:outputText value="#{-5 le 2}"/>
+		<h:outputText value="#{2 <= -5}"/>
+		<h:outputText value="#{2 le -5}"/>
+		<h:outputText value="#{-5 <= -5}"/>
+		<h:outputText value="#{-5 le -5}"/>
+		<h:outputText value="#{myBean.integerProperty <= null}"/>
+		<h:outputText value="#{null le myBean.integerProperty}"/>
+		
+		<!-- errors -->
+		<h:outputText value="#{5 <= true}"/>
+		<h:outputText value="#{5 le true}"/>
+		<h:outputText value="#{myBean.integerProperty <= myBean.booleanProperty}"/>
+		<h:outputText value="#{myBean.integerProperty le myBean.booleanProperty}"/>
+		<h:outputText value="#{myBean.stringArrayProperty <= myBean.booleanProperty}"/>
+		<h:outputText value="#{myBean.stringArrayProperty le myBean.booleanProperty}"/>
+    	<h:outputText value="#{myBean.integerProperty <= true }"/>
+    	<h:outputText value="#{myBean.integerProperty le true }"/>
+    	<h:outputText value="#{myBean.booleanProperty <= true}"/>
+    	<h:outputText value="#{myBean.booleanProperty le true}"/>
+ 		<h:outputText value="#{true <= false}"/>
+ 		<h:outputText value="#{true le false}"/>
+    </f:view>
+    </body>
+</html>
diff --git a/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/jsps/listBeans.jsp.data b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/jsps/listBeans.jsp.data
new file mode 100644
index 0000000..cf69f76
--- /dev/null
+++ b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/jsps/listBeans.jsp.data
@@ -0,0 +1,34 @@
+<%@page contentType="text/html"%>
+<%@page pageEncoding="UTF-8"%>
+<%--
+The taglib directive below imports the JSTL library. If you uncomment it,
+you must also add the JSTL library to the project. The Add Library... action
+on Libraries node in Projects view can be used to add the JSTL 1.1 library.
+--%>
+
+<%@taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%> 
+<%@taglib uri="http://java.sun.com/jsf/core" prefix="f"%>
+<%@taglib uri="http://java.sun.com/jsf/html" prefix="h"%>
+
+
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
+   "http://www.w3.org/TR/html4/loose.dtd">
+
+<html>
+    <head>
+  <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
+        <title>JSP Page</title>
+    </head>
+    <body>
+    <f:view>
+    <h1>JSP Page</h1>
+    	<!--  no errors -->
+    	<h:outputText value="#{myBean['abc']}"/>
+    	
+		<!--  warnings -->
+		
+		<!-- errors -->
+
+    </f:view>
+    </body>
+</html>
diff --git a/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/jsps/loadBundleResolution.jsp.data b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/jsps/loadBundleResolution.jsp.data
new file mode 100644
index 0000000..16683f5
--- /dev/null
+++ b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/jsps/loadBundleResolution.jsp.data
@@ -0,0 +1,46 @@
+<%@page contentType="text/html"%>
+<%@page pageEncoding="UTF-8"%>
+<%--
+The taglib directive below imports the JSTL library. If you uncomment it,
+you must also add the JSTL library to the project. The Add Library... action
+on Libraries node in Projects view can be used to add the JSTL 1.1 library.
+--%>
+
+<%@taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%> 
+<%@taglib uri="http://java.sun.com/jsf/core" prefix="f"%>
+<%@taglib uri="http://java.sun.com/jsf/html" prefix="h"%>
+
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
+   "http://www.w3.org/TR/html4/loose.dtd">
+
+<html>
+    <head>
+        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
+        <title>JSP Page</title>
+    </head>
+    <body>
+    <f:view>
+    <f:loadBundle var="bundle" basename="beans.Bundle"/>
+    <f:loadBundle var="msg" basename="TestMessages"/>
+   
+    <h1>JSP Page</h1>
+    	<!--  no errors -->
+    	<h:outputText value="#{bundle.bundleProp2}"/>
+    	<h:outputText value="#{bundle.bundleProp1 && myBean.stringProperty}"/>
+    	<h:outputText value="#{empty bundle}"/>
+    	<h:outputText value="#{empty bundle.bundleProp2}"/>
+    	<h:outputText value="#{bundle.bundleProp2 + 5}"/>
+		<h:outputText value="#{bundleProp2}"/>
+		<h:outputText value="#{bundle.x.y}"/>
+
+		<!--  warnings -->
+    	<h:outputText value="#{-bundle.bundleProp1}"/>
+    	<h:outputText value="#{bundle.bundleProp3}"/>
+	   	<h:outputText value="#{msg}"/>
+	   	<h:outputText value="#{bundle.x}"/>
+
+		<!-- errors -->
+
+    </f:view>
+    </body>
+</html>
diff --git a/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/jsps/logicalAND.jsp.data b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/jsps/logicalAND.jsp.data
new file mode 100644
index 0000000..bcafa50
--- /dev/null
+++ b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/jsps/logicalAND.jsp.data
@@ -0,0 +1,53 @@
+<%@page contentType="text/html"%>
+<%@page pageEncoding="UTF-8"%>
+<%--
+The taglib directive below imports the JSTL library. If you uncomment it,
+you must also add the JSTL library to the project. The Add Library... action
+on Libraries node in Projects view can be used to add the JSTL 1.1 library.
+--%>
+
+<%@taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%> 
+<%@taglib uri="http://java.sun.com/jsf/core" prefix="f"%>
+<%@taglib uri="http://java.sun.com/jsf/html" prefix="h"%>
+
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
+   "http://www.w3.org/TR/html4/loose.dtd">
+
+<html>
+    <head>
+        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
+        <title>JSP Page</title>
+    </head>
+    <body>
+    <f:view>
+    <h1>JSP Page</h1>
+    	<!--  no errors -->
+	    <h:outputText value="#{myBean.booleanProperty && myBean.booleanProperty}"/>
+	    <h:outputText value="#{myBean.booleanProperty and myBean.booleanProperty}"/>
+		<h:outputText value="#{myBean.booleanProperty && true }"/>
+		<h:outputText value="#{myBean.booleanProperty and true }"/>
+	    <h:outputText value="#{'true' && myBean.booleanProperty}"}/>
+	    <h:outputText value="#{'true' and myBean.booleanProperty}"}/>
+
+		<!--  warnings -->
+	    <h:outputText value="#{false && myBean.booleanProperty}"/>
+	    <h:outputText value="#{false and myBean.booleanProperty}"/>
+	    <h:outputText value="#{null && myBean.booleanProperty }"/>
+	    <h:outputText value="#{null and myBean.booleanProperty }"/>
+	    <h:outputText value="#{'notTrue' && myBean.booleanProperty}" }/>
+
+	    <h:outputText value="#{myBean.booleanProperty && false}"/>
+	    <h:outputText value="#{myBean.booleanProperty and false}"/>
+	    <h:outputText value="#{myBean.booleanProperty && null }"/>
+	    <h:outputText value="#{myBean.booleanProperty and null}"/>
+	    <h:outputText value="#{myBean.booleanProperty && 'notTrue'}" }/>
+		<h:outputText value="#{true && false}"/>
+		<h:outputText value="#{null && true}"/>
+	    
+	    <!-- errors -->
+	    <h:outputText value="#{myBean.integerProperty && true}"/>
+	    <h:outputText value="#{true && myBean.integerProperty}"/>
+	    <h:outputText value="#{4 && true}/>
+    </f:view>
+    </body>
+</html>
diff --git a/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/jsps/logicalEquals.jsp.data b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/jsps/logicalEquals.jsp.data
new file mode 100644
index 0000000..a354d22
--- /dev/null
+++ b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/jsps/logicalEquals.jsp.data
@@ -0,0 +1,65 @@
+<%@page contentType="text/html"%>
+<%@page pageEncoding="UTF-8"%>
+<%--
+The taglib directive below imports the JSTL library. If you uncomment it,
+you must also add the JSTL library to the project. The Add Library... action
+on Libraries node in Projects view can be used to add the JSTL 1.1 library.
+--%>
+
+<%@taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%> 
+<%@taglib uri="http://java.sun.com/jsf/core" prefix="f"%>
+<%@taglib uri="http://java.sun.com/jsf/html" prefix="h"%>
+
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
+   "http://www.w3.org/TR/html4/loose.dtd">
+
+<html>
+    <head>
+        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
+        <title>JSP Page</title>
+    </head>
+    <body>
+    <f:view>
+    <h1>JSP Page</h1>
+    	<!--  no errors -->
+    	<h:outputText value="#{myBean.stringProperty == '3'}"/>
+    	<h:outputText value="#{myBean.stringProperty eq '3'}"/>
+    	<h:outputText value="#{myBean.integerProperty == 3}"/>
+    	<h:outputText value="#{myBean.integerProperty eq 3}"/>
+    	<h:outputText value="#{myBean.booleanProperty == true}"/>
+    	<h:outputText value="#{myBean.booleanProperty eq true}"/>
+    	<h:outputText value="#{myBean.integerProperty == '4' }"/>
+    	<h:outputText value="#{myBean.integerProperty eq '4' }"/>
+    	<h:outputText value="#{myBean.bigDoubleProperty == 4.5}"/>
+    	<h:outputText value="#{myBean.doubleProperty eq 67}"/>
+    	<h:outputText value="#{myBean.bigIntegerProperty == 500}"/>
+    	<h:outputText value="#{myBean.stringArrayProperty == '3'}"/>
+    	<h:outputText value="#{myBean.stringArrayProperty eq myBean.listProperty}"/>
+
+		<!--  warnings -->
+		<h:outputText value="#{5 == 3}"/>
+		<h:outputText value="#{5 eq 3}"/>
+		<h:outputText value="#{true == false}"/>
+		<h:outputText value="#{true eq false}"/>
+		<h:outputText value="#{'4' == '34'}"/>
+		<h:outputText value="#{'4' eq '34'}"/>
+		<h:outputText value="#{'34' == '34'}"/>
+		<h:outputText value="#{'34' eq '34'}"/>
+		<h:outputText value="#{myBean.integerProperty == null}"/>
+		<h:outputText value="#{null eq myBean.integerProperty}"/>
+		<h:outputText value="#{5.4 == 4.3}"/>
+		<h:outputText value="#{true == true}"/>
+
+		<!-- errors -->
+		<h:outputText value="#{5 == true}"/>
+		<h:outputText value="#{5 eq true}"/>
+		<h:outputText value="#{myBean.integerProperty == myBean.booleanProperty}"/>
+		<h:outputText value="#{myBean.integerProperty eq myBean.booleanProperty}"/>
+		<h:outputText value="#{myBean.stringArrayProperty == myBean.booleanProperty}"/>
+		<h:outputText value="#{myBean.booleanProperty eq myBean.stringArrayProperty}"/>
+    	<h:outputText value="#{myBean.integerProperty == true }"/>
+    	<h:outputText value="#{myBean.integerProperty eq true }"/>
+    	<h:outputText value="#{false == myBean.integerProperty}"/>
+    </f:view>
+    </body>
+</html>
diff --git a/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/jsps/logicalNOT.jsp.data b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/jsps/logicalNOT.jsp.data
new file mode 100644
index 0000000..6944ceb
--- /dev/null
+++ b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/jsps/logicalNOT.jsp.data
@@ -0,0 +1,53 @@
+<%@page contentType="text/html"%>
+<%@page pageEncoding="UTF-8"%>
+<%--
+The taglib directive below imports the JSTL library. If you uncomment it,
+you must also add the JSTL library to the project. The Add Library... action
+on Libraries node in Projects view can be used to add the JSTL 1.1 library.
+--%>
+
+<%@taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%> 
+<%@taglib uri="http://java.sun.com/jsf/core" prefix="f"%>
+<%@taglib uri="http://java.sun.com/jsf/html" prefix="h"%>
+
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
+   "http://www.w3.org/TR/html4/loose.dtd">
+
+<html>
+    <head>
+        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
+        <title>JSP Page</title>
+    </head>
+    <body>
+    <f:view>
+    <h1>JSP Page</h1>
+    	<!--  no errors -->
+ 	    <h:outputText value="#{!myBean.booleanProperty}"/>
+	    <h:outputText value="#{not myBean.booleanProperty}"/>
+		<h:outputText value="#{!myBean.stringProperty}"/>
+		<h:outputText value="#{not myBean.stringProperty}"/>
+		
+		<!--  warnings -->
+	   	<h:outputText value="#{!true}"/>
+    	<h:outputText value="#{not true}"/>
+    	<h:outputText value="#{!false}"/>
+    	<h:outputText value="#{not false}"/>
+    	<h:outputText value="#{! 'true'}"/>
+    	<h:outputText value="#{not 'true'}"/>
+    	<h:outputText value="#{! 'notTrue'}"/>
+    	<h:outputText value="#{not 'notTrue'}"/>
+
+		<!-- error cases -->
+		<h:outputText value="#{!5}"/>
+		<h:outputText value="#{not 5}"/>
+		<h:outputText value="#{!myBean.integerProperty}"/>
+		<h:outputText value="#{not myBean.integerProperty}"/>
+		<h:outputText value="#{!myBean.collectionProperty}"/>
+		<h:outputText value="#{not myBean.collectionProperty}"/>
+		<h:outputText value="#{!myBean.stringArrayProperty}"/>
+		<h:outputText value="#{not myBean.stringArrayProperty}"/>
+		<h:outputText value="#{!myBean.mapProperty}"/>
+		<h:outputText value="#{not myBean.mapProperty}"/>
+    </f:view>
+    </body>
+</html>
diff --git a/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/jsps/logicalNotEquals.jsp.data b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/jsps/logicalNotEquals.jsp.data
new file mode 100644
index 0000000..a054c75
--- /dev/null
+++ b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/jsps/logicalNotEquals.jsp.data
@@ -0,0 +1,65 @@
+<%@page contentType="text/html"%>
+<%@page pageEncoding="UTF-8"%>
+<%--
+The taglib directive below imports the JSTL library. If you uncomment it,
+you must also add the JSTL library to the project. The Add Library... action
+on Libraries node in Projects view can be used to add the JSTL 1.1 library.
+--%>
+
+<%@taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%> 
+<%@taglib uri="http://java.sun.com/jsf/core" prefix="f"%>
+<%@taglib uri="http://java.sun.com/jsf/html" prefix="h"%>
+
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
+   "http://www.w3.org/TR/html4/loose.dtd">
+
+<html>
+    <head>
+        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
+        <title>JSP Page</title>
+    </head>
+    <body>
+    <f:view>
+    <h1>JSP Page</h1>
+    	<!--  no errors -->
+    	<h:outputText value="#{myBean.stringProperty != '3'}"/>
+    	<h:outputText value="#{myBean.stringProperty ne '3'}"/>
+    	<h:outputText value="#{myBean.integerProperty != 3}"/>
+    	<h:outputText value="#{myBean.integerProperty ne 3}"/>
+    	<h:outputText value="#{myBean.booleanProperty != true}"/>
+    	<h:outputText value="#{myBean.booleanProperty ne true}"/>
+    	<h:outputText value="#{myBean.integerProperty != '4' }"/>
+    	<h:outputText value="#{myBean.integerProperty ne '4' }"/>
+    	<h:outputText value="#{myBean.bigDoubleProperty != 4.5}"/>
+    	<h:outputText value="#{myBean.doubleProperty ne 67}"/>
+    	<h:outputText value="#{myBean.bigIntegerProperty != 500}"/>
+    	<h:outputText value="#{myBean.stringArrayProperty != '3'}"/>
+    	<h:outputText value="#{myBean.stringArrayProperty ne myBean.listProperty}"/>
+
+		<!--  warnings -->
+		<h:outputText value="#{5 != 3}"/>
+		<h:outputText value="#{5 ne 3}"/>
+		<h:outputText value="#{true != false}"/>
+		<h:outputText value="#{true ne false}"/>
+		<h:outputText value="#{'4' != '34'}"/>
+		<h:outputText value="#{'4' ne '34'}"/>
+		<h:outputText value="#{'34' != '34'}"/>
+		<h:outputText value="#{'34' ne '34'}"/>
+		<h:outputText value="#{myBean.integerProperty != null}"/>
+		<h:outputText value="#{null ne myBean.integerProperty}"/>
+		<h:outputText value="#{5.4 != 4.3}"/>
+		<h:outputText value="#{true != true}"/>
+
+		<!-- errors -->
+		<h:outputText value="#{5 != true}"/>
+		<h:outputText value="#{5 ne true}"/>
+		<h:outputText value="#{myBean.integerProperty != myBean.booleanProperty}"/>
+		<h:outputText value="#{myBean.integerProperty ne myBean.booleanProperty}"/>
+		<h:outputText value="#{myBean.stringArrayProperty != myBean.booleanProperty}"/>
+		<h:outputText value="#{myBean.booleanProperty ne myBean.stringArrayProperty}"/>
+    	<h:outputText value="#{myBean.integerProperty != true }"/>
+    	<h:outputText value="#{myBean.integerProperty ne true }"/>
+    	<h:outputText value="#{false != myBean.integerProperty}"/>
+    </f:view>
+    </body>
+</html>
diff --git a/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/jsps/logicalOR.jsp.data b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/jsps/logicalOR.jsp.data
new file mode 100644
index 0000000..4fccfcf
--- /dev/null
+++ b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/jsps/logicalOR.jsp.data
@@ -0,0 +1,54 @@
+<%@page contentType="text/html"%>
+<%@page pageEncoding="UTF-8"%>
+<%--
+The taglib directive below imports the JSTL library. If you uncomment it,
+you must also add the JSTL library to the project. The Add Library... action
+on Libraries node in Projects view can be used to add the JSTL 1.1 library.
+--%>
+
+<%@taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%> 
+<%@taglib uri="http://java.sun.com/jsf/core" prefix="f"%>
+<%@taglib uri="http://java.sun.com/jsf/html" prefix="h"%>
+
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
+   "http://www.w3.org/TR/html4/loose.dtd">
+
+<html>
+    <head>
+        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
+        <title>JSP Page</title>
+    </head>
+    <body>
+    <f:view>
+    <h1>JSP Page</h1>
+    	<!--  no errors -->
+	    <h:outputText value="#{myBean.booleanProperty or myBean.booleanProperty}"/>
+	    <h:outputText value="#{myBean.booleanProperty || myBean.booleanProperty}"/>
+	    <h:outputText value="#{false || myBean.booleanProperty}"/>
+	    <h:outputText value="#{false or myBean.booleanProperty}"/>
+	    <h:outputText value="#{null || myBean.booleanProperty }"/>
+	    <h:outputText value="#{null or myBean.booleanProperty }"/>
+	    <h:outputText value="#{'notTrue' || myBean.booleanProperty}" }/>	    
+	    <h:outputText value="#{myBean.booleanProperty || false}"/>
+	    <h:outputText value="#{myBean.booleanProperty or false}"/>
+	    <h:outputText value="#{myBean.booleanProperty || null }"/>
+	    <h:outputText value="#{myBean.booleanProperty or null}"/>
+	    <h:outputText value="#{myBean.booleanProperty || 'notTrue'}" }/>
+	    <h:outputText value="#{myBean.booleanProperty or 'notTrue'}" }/>
+
+		<!--  warnings -->
+	    <h:outputText value="#{'true' or myBean.booleanProperty}"}/>
+	    <h:outputText value="#{'true' || myBean.booleanProperty}"}/>
+		<h:outputText value="#{myBean.booleanProperty or true }"/>
+		<h:outputText value="#{myBean.booleanProperty || true }"/>
+		<h:outputText value="#{myBean.booleanProperty || 'true'}"/>
+		<h:outputText value="#{false || true}"/>
+		<h:outputText value="#{null || true}"/>
+
+	    <!-- errors -->
+	    <h:outputText value="#{myBean.integerProperty || false}"/>
+	    <h:outputText value="#{false || myBean.integerProperty}"/>
+	    <h:outputText value="#{4 || false}/>
+    </f:view>
+    </body>
+</html>
diff --git a/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/jsps/methodBinding.jsp.data b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/jsps/methodBinding.jsp.data
new file mode 100644
index 0000000..e189ceb
--- /dev/null
+++ b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/jsps/methodBinding.jsp.data
@@ -0,0 +1,71 @@
+<%@page contentType="text/html"%>
+<%@page pageEncoding="UTF-8"%>
+<%--
+The taglib directive below imports the JSTL library. If you uncomment it,
+you must also add the JSTL library to the project. The Add Library... action
+on Libraries node in Projects view can be used to add the JSTL 1.1 library.
+--%>
+
+<%@taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%> 
+<%@taglib uri="http://java.sun.com/jsf/core" prefix="f"%>
+<%@taglib uri="http://java.sun.com/jsf/html" prefix="h"%>
+
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
+   "http://www.w3.org/TR/html4/loose.dtd">
+
+<html>
+    <head>
+  <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
+        <title>JSP Page</title>
+    </head>
+    <body>
+    <f:view>
+    <h1>JSP Page</h1>
+    	<!--  no errors -->
+    	<h:inputText validator="#{myBean.getStringProperty}"/>
+    	<h:inputText validator="#{myBean.getIntegerProperty}"/>
+    	<h:inputText validator="#{myBean.getBooleanProperty}"/>
+    	<h:inputText validator="#{myBean.getDoubleProperty}"/>
+    	<h:inputText validator="#{myBean.getMapProperty}"/>
+    	<h:inputText validator="#{myBean.getStringArrayProperty}"/>
+    	<h:inputText validator="#{myBean.getCollectionProperty}"/>
+    	<h:inputText validator="#{myBean.getListProperty}"/>
+    	<h:inputText validator="#{myBean.getComparableProperty}"/>
+    	<h:inputText validator="#{myBean.getBigIntegerProperty}"/>
+    	<h:inputText validator="#{myBean.getBigDoubleProperty}"/>
+    	<h:inputText validator="#{myBean.recursiveCall}"/>
+    	<h:inputText validator="#{myBean.getWritableStringProperty}"/>
+    	<h:inputText validator="#{myBean.setWritableStringProperty}"/>
+    	<h:inputText validator="#{myBean.validate}"/>
+    	<h:inputText validator="#{myBean.validate2}"/>
+    	<h:inputText validator="#{myBean.getSelf}"/>
+    	<h:inputText validator="#{myBean.isIsStyleBooleanProperty}"/>
+
+    	<h:inputText validator="#{myBeanSubClass.getStringProperty}"/>
+    	<h:inputText validator="#{myBeanSubClass.getIntegerProperty}"/>
+    	<h:inputText validator="#{myBeanSubClass.getBooleanProperty}"/>
+    	<h:inputText validator="#{myBeanSubClass.getDoubleProperty}"/>
+    	<h:inputText validator="#{myBeanSubClass.getMapProperty}"/>
+    	<h:inputText validator="#{myBeanSubClass.getStringArrayProperty}"/>
+    	<h:inputText validator="#{myBeanSubClass.getCollectionProperty}"/>
+    	<h:inputText validator="#{myBeanSubClass.getListProperty}"/>
+    	<h:inputText validator="#{myBeanSubClass.getComparableProperty}"/>
+    	<h:inputText validator="#{myBeanSubClass.getBigIntegerProperty}"/>
+    	<h:inputText validator="#{myBeanSubClass.getBigDoubleProperty}"/>
+    	<h:inputText validator="#{myBeanSubClass.recursiveCall}"/>
+    	<h:inputText validator="#{myBeanSubClass.getWritableStringProperty}"/>
+    	<h:inputText validator="#{myBeanSubClass.setWritableStringProperty}"/>
+    	<h:inputText validator="#{myBeanSubClass.validate}"/>
+    	<h:inputText validator="#{myBeanSubClass.validate2}"/>
+    	<h:inputText validator="#{myBeanSubClass.getSelf}"/>
+    	<h:inputText validator="#{myBeanSubClass.isIsStyleBooleanProperty}"/>
+    	<h:inputText validator="#{myBeanSubClass.getSubClassStringProperty}"/>
+    	
+		<!--  warnings -->
+		
+		<!-- errors -->
+    	<h:inputText validator="#{-myBean.validate}"/>
+    	<h:inputText value="#{myBean.getIntegerProperty + myBean.getDoubleProperty}"/>
+    </f:view>
+    </body>
+</html>
diff --git a/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/jsps/test.jsp.data b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/jsps/test.jsp.data
new file mode 100644
index 0000000..363e088
--- /dev/null
+++ b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/jsps/test.jsp.data
@@ -0,0 +1,35 @@
+<%@page contentType="text/html"%>
+<%@page pageEncoding="UTF-8"%>
+<%--
+The taglib directive below imports the JSTL library. If you uncomment it,
+you must also add the JSTL library to the project. The Add Library... action
+on Libraries node in Projects view can be used to add the JSTL 1.1 library.
+--%>
+
+<%@taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%> 
+<%@taglib uri="http://java.sun.com/jsf/core" prefix="f"%>
+<%@taglib uri="http://java.sun.com/jsf/html" prefix="h"%>
+
+
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
+   "http://www.w3.org/TR/html4/loose.dtd">
+
+<html>
+  <head>
+  <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
+        <title>JSP Page</title>
+    </head>
+    <body>
+    <f:view>
+    <h1>JSP Page</h1>
+    	<!--  no errors -->
+    	<h:outputText value="#{myBean.stringArrayProperty}"/>
+    	
+    	
+		<!--  warnings -->
+		
+		<!-- errors -->
+
+    </f:view>
+    </body>
+</html>
diff --git a/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/jsps/unaryMinus.jsp.data b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/jsps/unaryMinus.jsp.data
new file mode 100644
index 0000000..6ec68f5
--- /dev/null
+++ b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/jsps/unaryMinus.jsp.data
@@ -0,0 +1,48 @@
+<%@page contentType="text/html"%>
+<%@page pageEncoding="UTF-8"%>
+<%--
+The taglib directive below imports the JSTL library. If you uncomment it,
+you must also add the JSTL library to the project. The Add Library... action
+on Libraries node in Projects view can be used to add the JSTL 1.1 library.
+--%>
+
+<%@taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%> 
+<%@taglib uri="http://java.sun.com/jsf/core" prefix="f"%>
+<%@taglib uri="http://java.sun.com/jsf/html" prefix="h"%>
+
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
+   "http://www.w3.org/TR/html4/loose.dtd">
+
+<html>
+    <head>
+        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
+        <title>JSP Page</title>
+    </head>
+    <body>
+    <f:view>
+    <h1>JSP Page</h1>
+    	<!--  no errors -->
+    	<h:outputText value="#{-myBean.integerProperty}"/>
+		<h:outputText value="#{-myBean.doubleProperty}"/>
+		<h:outputText value="#{-myBean.bigDoubleProperty}"/>
+		<h:outputText value="#{-myBean.bigIntegerProperty}"/>
+			
+		<!--  warnings -->
+    	<h:outputText value="#{-myBean.stringProperty}"/>
+    	<h:outputText value="#{-5}"/>
+    	<h:outputText value="#{-5.5}"/>
+    	<h:outputText value="#{-'5'}"/>
+    	<h:outputText value="#{-'5.5'}"/>
+    	<h:outputText value="#{-null}"/>
+		
+		<!--  errors -->
+		<h:outputText value="#{-false}"/>
+		<h:outputText value="#{-true}"/>
+		<h:outputText value="#{-myBean.booleanProperty}"/>
+		<h:outputText value="#{-myBean.collectionProperty}"/>
+		<h:outputText value="#{-myBean.mapProperty}"/>
+		<h:outputText value="#{-myBean.stringArrayProperty}"/>
+		<h:outputText value="#{-'notANumber'}"/>
+    </f:view>
+    </body>
+</html>
diff --git a/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/jsps/variableNaming.jsp.data b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/jsps/variableNaming.jsp.data
new file mode 100644
index 0000000..caabe3f
--- /dev/null
+++ b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/jsps/variableNaming.jsp.data
@@ -0,0 +1,30 @@
+<%@page contentType="text/html"%>
+<%@page pageEncoding="UTF-8"%>
+
+<%@taglib uri="http://java.sun.com/jsf/core" prefix="f"%>
+<%@taglib uri="http://java.sun.com/jsf/html" prefix="h"%>
+
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
+   "http://www.w3.org/TR/html4/loose.dtd">
+
+<html>
+    <head>
+  		<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
+        <title>JSP Page</title>
+    </head>
+    <body>
+    <f:view>
+    <h1>JSP Page</h1>
+    	<f:loadBundle var="hiddenBean" basename="mybeans.Bundle"/>
+    	
+    	<!--  no errors -->
+    	<h:outputText value="#{hiddenBean.bundleProp2}"/>
+
+		<!--  warnings -->
+    	<h:outputText value="#{hiddenBean.collectionProperty}"/>
+
+		<!-- errors -->
+
+    </f:view>
+    </body>
+</html>
diff --git a/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/web/faces-config.xml.data b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/web/faces-config.xml.data
new file mode 100644
index 0000000..f76c971
--- /dev/null
+++ b/jsf/tests/org.eclipse.jst.jsf.validation.el.tests/testdata/web/faces-config.xml.data
@@ -0,0 +1,81 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<!DOCTYPE faces-config PUBLIC
+    "-//Sun Microsystems, Inc.//DTD JavaServer Faces Config 1.1//EN"
+    "http://java.sun.com/dtd/web-facesconfig_1_1.dtd">
+
+<faces-config>
+	<managed-bean>
+		<managed-bean-name>
+		myBean</managed-bean-name>
+		<managed-bean-class>
+		beans.MyBean</managed-bean-class>
+		<managed-bean-scope>
+		session</managed-bean-scope>
+		<managed-property>
+			<property-name>
+			booleanProperty</property-name>
+			<property-class>
+			boolean</property-class>
+			<value>
+			</value>
+		</managed-property>
+	</managed-bean>
+	<managed-bean>
+		<managed-bean-name>
+		myBeanSubClass</managed-bean-name>
+		<managed-bean-class>
+		beans.MyBeanSubClass</managed-bean-class>
+		<managed-bean-scope>
+		request</managed-bean-scope>
+	</managed-bean>
+	<managed-bean>
+		<managed-bean-name> 
+		mapBean</managed-bean-name>
+		<managed-bean-class>
+		beans.MapBean</managed-bean-class>
+		<managed-bean-scope>
+		application</managed-bean-scope>
+	</managed-bean>
+	<managed-bean>
+		<managed-bean-name>
+		mapBean1</managed-bean-name>
+		<managed-bean-class>
+		beans.MapBean</managed-bean-class>
+		<managed-bean-scope>
+		session</managed-bean-scope>
+	</managed-bean>
+	<managed-bean>
+		<managed-bean-name>
+		hiddenBean</managed-bean-name>
+		<managed-bean-class>
+		beans.MyBean</managed-bean-class>
+		<managed-bean-scope>
+		request</managed-bean-scope>
+	</managed-bean>
+	<managed-bean>
+		<managed-bean-name>
+		myBean_none</managed-bean-name>
+		<managed-bean-class>
+		beans.MyBean</managed-bean-class>
+		<managed-bean-scope>
+		none</managed-bean-scope>
+		<managed-property>
+			<property-name>
+			booleanProperty</property-name>
+			<property-class>
+			boolean</property-class>
+			<value>
+			false</value>
+		</managed-property>
+	</managed-bean>
+	<managed-bean>
+		<managed-bean-name>
+		myBeanSettable</managed-bean-name>
+		<managed-bean-class>
+		beans.MyBeanSettable</managed-bean-class>
+		<managed-bean-scope>
+		session</managed-bean-scope>
+	</managed-bean>
+
+</faces-config>