init

test/org/apache/el/TestMethodExpressionImpl.java

@@ -0,0 +1,539 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.el;
+
+import javax.el.ELContext;
+import javax.el.ExpressionFactory;
+import javax.el.MethodExpression;
+import javax.el.MethodNotFoundException;
+import javax.el.ValueExpression;
+
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+import org.apache.jasper.el.ELContextImpl;
+
+public class TestMethodExpressionImpl {
+
+    private static final String BUG53792 = "TEST_PASS";
+
+    private ExpressionFactory factory;
+    private ELContext context;
+    private TesterBeanB beanB;
+
+    @Before
+    public void setUp() {
+        factory = ExpressionFactory.newInstance();
+        context = new ELContextImpl(factory);
+
+        TesterBeanA beanA = new TesterBeanA();
+        beanA.setName("A");
+        context.getVariableMapper().setVariable("beanA",
+                factory.createValueExpression(beanA, TesterBeanA.class));
+
+        TesterBeanAA beanAA = new TesterBeanAA();
+        beanAA.setName("AA");
+        context.getVariableMapper().setVariable("beanAA",
+                factory.createValueExpression(beanAA, TesterBeanAA.class));
+
+        TesterBeanAAA beanAAA = new TesterBeanAAA();
+        beanAAA.setName("AAA");
+        context.getVariableMapper().setVariable("beanAAA",
+                factory.createValueExpression(beanAAA, TesterBeanAAA.class));
+
+        beanB = new TesterBeanB();
+        beanB.setName("B");
+        context.getVariableMapper().setVariable("beanB",
+                factory.createValueExpression(beanB, TesterBeanB.class));
+
+        TesterBeanBB beanBB = new TesterBeanBB();
+        beanBB.setName("BB");
+        context.getVariableMapper().setVariable("beanBB",
+                factory.createValueExpression(beanBB, TesterBeanBB.class));
+
+        TesterBeanBBB beanBBB = new TesterBeanBBB();
+        beanBBB.setName("BBB");
+        context.getVariableMapper().setVariable("beanBBB",
+                factory.createValueExpression(beanBBB, TesterBeanBBB.class));
+
+        TesterBeanC beanC = new TesterBeanC();
+        context.getVariableMapper().setVariable("beanC",
+                factory.createValueExpression(beanC, TesterBeanC.class));
+
+        TesterBeanEnum beanEnum = new TesterBeanEnum();
+        context.getVariableMapper().setVariable("beanEnum",
+                factory.createValueExpression(beanEnum, TesterBeanEnum.class));
+    }
+
+    @Test
+    public void testIsParametersProvided() {
+        MethodExpression me1 = factory.createMethodExpression(
+                context, "${beanB.getName}", String.class, new Class<?>[] {});
+        MethodExpression me2 = factory.createMethodExpression(
+                context, "${beanB.sayHello('JUnit')}", String.class,
+                new Class<?>[] { String.class });
+
+        Assert.assertFalse(me1.isParametersProvided());
+        Assert.assertTrue(me2.isParametersProvided());
+    }
+
+    @Test
+    public void testInvoke() {
+        MethodExpression me1 = factory.createMethodExpression(
+                context, "${beanB.getName}", String.class, new Class<?>[] {});
+        MethodExpression me2 = factory.createMethodExpression(
+                context, "${beanB.sayHello('JUnit')}", String.class,
+                new Class<?>[] { String.class });
+        MethodExpression me3 = factory.createMethodExpression(
+                context, "${beanB.sayHello}", String.class,
+                new Class<?>[] { String.class });
+
+        Assert.assertEquals("B", me1.invoke(context, null));
+        Assert.assertEquals("Hello JUnit from B", me2.invoke(context, null));
+        Assert.assertEquals("Hello JUnit from B",
+                me2.invoke(context, new Object[] { "JUnit2" }));
+        Assert.assertEquals("Hello JUnit2 from B",
+                me3.invoke(context, new Object[] { "JUnit2" }));
+        Assert.assertEquals("Hello JUnit from B",
+                me2.invoke(context, new Object[] { null }));
+        Assert.assertEquals("Hello  from B",
+                me3.invoke(context, new Object[] { null }));
+    }
+
+    @Test
+    public void testInvokeWithSuper() {
+        MethodExpression me = factory.createMethodExpression(context,
+                "${beanA.setBean(beanBB)}", null ,
+                new Class<?>[] { TesterBeanB.class });
+        me.invoke(context, null);
+        ValueExpression ve = factory.createValueExpression(context,
+                "${beanA.bean.name}", String.class);
+        Object r = ve.getValue(context);
+        Assert.assertEquals("BB", r);
+    }
+
+    @Test
+    public void testInvokeWithSuperABNoReturnTypeNoParamTypes() {
+        MethodExpression me2 = factory.createMethodExpression(context,
+                "${beanC.sayHello(beanA,beanB)}", null , null);
+        Object r2 = me2.invoke(context, null);
+        Assert.assertEquals("AB: Hello A from B", r2.toString());
+    }
+
+    @Test
+    public void testInvokeWithSuperABReturnTypeNoParamTypes() {
+        MethodExpression me3 = factory.createMethodExpression(context,
+                "${beanC.sayHello(beanA,beanB)}", String.class , null);
+        Object r3 = me3.invoke(context, null);
+        Assert.assertEquals("AB: Hello A from B", r3.toString());
+    }
+
+    @Test
+    public void testInvokeWithSuperABNoReturnTypeParamTypes() {
+        MethodExpression me4 = factory.createMethodExpression(context,
+                "${beanC.sayHello(beanA,beanB)}", null ,
+                new Class<?>[] {TesterBeanA.class, TesterBeanB.class});
+        Object r4 = me4.invoke(context, null);
+        Assert.assertEquals("AB: Hello A from B", r4.toString());
+    }
+
+    @Test
+    public void testInvokeWithSuperABReturnTypeParamTypes() {
+        MethodExpression me5 = factory.createMethodExpression(context,
+                "${beanC.sayHello(beanA,beanB)}", String.class ,
+                new Class<?>[] {TesterBeanA.class, TesterBeanB.class});
+        Object r5 = me5.invoke(context, null);
+        Assert.assertEquals("AB: Hello A from B", r5.toString());
+    }
+
+    @Test
+    public void testInvokeWithSuperABB() {
+        MethodExpression me6 = factory.createMethodExpression(context,
+                "${beanC.sayHello(beanA,beanBB)}", null , null);
+        Object r6 = me6.invoke(context, null);
+        Assert.assertEquals("ABB: Hello A from BB", r6.toString());
+    }
+
+    @Test
+    public void testInvokeWithSuperABBB() {
+        MethodExpression me7 = factory.createMethodExpression(context,
+                "${beanC.sayHello(beanA,beanBBB)}", null , null);
+        Object r7 = me7.invoke(context, null);
+        Assert.assertEquals("ABB: Hello A from BBB", r7.toString());
+    }
+
+    @Test
+    public void testInvokeWithSuperAAB() {
+        MethodExpression me8 = factory.createMethodExpression(context,
+                "${beanC.sayHello(beanAA,beanB)}", null , null);
+        Object r8 = me8.invoke(context, null);
+        Assert.assertEquals("AAB: Hello AA from B", r8.toString());
+    }
+
+    @Test
+    public void testInvokeWithSuperAABB() {
+        MethodExpression me9 = factory.createMethodExpression(context,
+                "${beanC.sayHello(beanAA,beanBB)}", null , null);
+        Exception e = null;
+        try {
+            me9.invoke(context, null);
+        } catch (Exception e1) {
+            e = e1;
+        }
+        // Expected to fail
+        Assert.assertNotNull(e);
+    }
+
+    @Test
+    public void testInvokeWithSuperAABBB() {
+        // The Java compiler reports this as ambiguous. Using the parameter that
+        // matches exactly seems reasonable to limit the scope of the method
+        // search so the EL will find a match.
+        MethodExpression me10 = factory.createMethodExpression(context,
+                "${beanC.sayHello(beanAA,beanBBB)}", null , null);
+        Object r10 = me10.invoke(context, null);
+        Assert.assertEquals("AAB: Hello AA from BBB", r10.toString());
+    }
+
+    @Test
+    public void testInvokeWithSuperAAAB() {
+        MethodExpression me11 = factory.createMethodExpression(context,
+                "${beanC.sayHello(beanAAA,beanB)}", null , null);
+        Object r11 = me11.invoke(context, null);
+        Assert.assertEquals("AAB: Hello AAA from B", r11.toString());
+    }
+
+    @Test
+    public void testInvokeWithSuperAAABB() {
+        // The Java compiler reports this as ambiguous. Using the parameter that
+        // matches exactly seems reasonable to limit the scope of the method
+        // search so the EL will find a match.
+        MethodExpression me12 = factory.createMethodExpression(context,
+                "${beanC.sayHello(beanAAA,beanBB)}", null , null);
+        Object r12 = me12.invoke(context, null);
+        Assert.assertEquals("ABB: Hello AAA from BB", r12.toString());
+    }
+
+    @Test
+    public void testInvokeWithSuperAAABBB() {
+        MethodExpression me13 = factory.createMethodExpression(context,
+                "${beanC.sayHello(beanAAA,beanBBB)}", null , null);
+        Exception e = null;
+        try {
+            me13.invoke(context, null);
+        } catch (Exception e1) {
+            e = e1;
+        }
+        // Expected to fail
+        Assert.assertNotNull(e);
+    }
+
+    @Test
+    public void testInvokeWithVarArgsAB() throws Exception {
+        MethodExpression me1 = factory.createMethodExpression(context,
+                "${beanC.sayHello(beanA,beanB,beanB)}", null , null);
+        Exception e = null;
+        try {
+            me1.invoke(context, null);
+        } catch (Exception e1) {
+            e = e1;
+        }
+        // Expected to fail
+        Assert.assertNotNull(e);
+    }
+
+    @Test
+    public void testInvokeWithVarArgsABB() throws Exception {
+        MethodExpression me2 = factory.createMethodExpression(context,
+                "${beanC.sayHello(beanA,beanBB,beanBB)}", null , null);
+        Object r2 = me2.invoke(context, null);
+        Assert.assertEquals("ABB[]: Hello A from BB, BB", r2.toString());
+    }
+
+    @Test
+    public void testInvokeWithVarArgsABBB() throws Exception {
+        MethodExpression me3 = factory.createMethodExpression(context,
+                "${beanC.sayHello(beanA,beanBBB,beanBBB)}", null , null);
+        Object r3 = me3.invoke(context, null);
+        Assert.assertEquals("ABB[]: Hello A from BBB, BBB", r3.toString());
+    }
+
+    @Test
+    public void testInvokeWithVarArgsAAB() throws Exception {
+        MethodExpression me4 = factory.createMethodExpression(context,
+                "${beanC.sayHello(beanAA,beanB,beanB)}", null , null);
+        Exception e = null;
+        try {
+            me4.invoke(context, null);
+        } catch (Exception e1) {
+            e = e1;
+        }
+        // Expected to fail
+        Assert.assertNotNull(e);
+    }
+
+    @Test
+    public void testInvokeWithVarArgsAABB() throws Exception {
+        MethodExpression me5 = factory.createMethodExpression(context,
+                "${beanC.sayHello(beanAA,beanBB,beanBB)}", null , null);
+        Object r5 = me5.invoke(context, null);
+        Assert.assertEquals("ABB[]: Hello AA from BB, BB", r5.toString());
+    }
+
+    @Test
+    public void testInvokeWithVarArgsAABBB() throws Exception {
+        MethodExpression me6 = factory.createMethodExpression(context,
+                "${beanC.sayHello(beanAA,beanBBB,beanBBB)}", null , null);
+        Object r6 = me6.invoke(context, null);
+        Assert.assertEquals("ABB[]: Hello AA from BBB, BBB", r6.toString());
+    }
+
+    @Test
+    public void testInvokeWithVarArgsAAAB() throws Exception {
+        MethodExpression me7 = factory.createMethodExpression(context,
+                "${beanC.sayHello(beanAAA,beanB,beanB)}", null , null);
+        Exception e = null;
+        try {
+            me7.invoke(context, null);
+        } catch (Exception e1) {
+            e = e1;
+        }
+        // Expected to fail
+        Assert.assertNotNull(e);
+    }
+
+    @Test
+    public void testInvokeWithVarArgsAAABB() throws Exception {
+        MethodExpression me8 = factory.createMethodExpression(context,
+                "${beanC.sayHello(beanAAA,beanBB,beanBB)}", null , null);
+        Object r8 = me8.invoke(context, null);
+        Assert.assertEquals("ABB[]: Hello AAA from BB, BB", r8.toString());
+    }
+
+    @Test
+    public void testInvokeWithVarArgsAAABBB() throws Exception {
+        MethodExpression me9 = factory.createMethodExpression(context,
+                "${beanC.sayHello(beanAAA,beanBBB,beanBBB)}", null , null);
+        Object r9 = me9.invoke(context, null);
+        Assert.assertEquals("ABB[]: Hello AAA from BBB, BBB", r9.toString());
+    }
+
+    /*
+     * This is also tested implicitly in numerous places elsewhere in this
+     * class.
+     */
+    @Test
+    public void testBug49655() throws Exception {
+        // This is the call the failed
+        MethodExpression me = factory.createMethodExpression(context,
+                "#{beanA.setName('New value')}", null, null);
+        // The rest is to check it worked correctly
+        me.invoke(context, null);
+        ValueExpression ve = factory.createValueExpression(context,
+                "#{beanA.name}", java.lang.String.class);
+        Assert.assertEquals("New value", ve.getValue(context));
+    }
+
+    @Test
+    public void testBugPrimitives() throws Exception {
+        MethodExpression me = factory.createMethodExpression(context,
+                "${beanA.setValLong(5)}", null, null);
+        me.invoke(context, null);
+        ValueExpression ve = factory.createValueExpression(context,
+                "#{beanA.valLong}", java.lang.String.class);
+        Assert.assertEquals("5", ve.getValue(context));
+    }
+
+    @Test
+    public void testBug50449a() throws Exception {
+        MethodExpression me1 = factory.createMethodExpression(context,
+                "${beanB.sayHello()}", null, null);
+        String actual = (String) me1.invoke(context, null);
+        Assert.assertEquals("Hello from B", actual);
+    }
+
+    @Test
+    public void testBug50449b() throws Exception {
+        MethodExpression me1 = factory.createMethodExpression(context,
+                "${beanB.sayHello('Tomcat')}", null, null);
+        String actual = (String) me1.invoke(context, null);
+        Assert.assertEquals("Hello Tomcat from B", actual);
+    }
+
+    @Test
+    public void testBug50790a() throws Exception {
+        ValueExpression ve = factory.createValueExpression(context,
+                "#{beanAA.name.contains(beanA.name)}", java.lang.Boolean.class);
+        Boolean actual = (Boolean) ve.getValue(context);
+        Assert.assertEquals(Boolean.TRUE, actual);
+    }
+
+    @Test
+    public void testBug50790b() throws Exception {
+        ValueExpression ve = factory.createValueExpression(context,
+                "#{beanA.name.contains(beanAA.name)}", java.lang.Boolean.class);
+        Boolean actual = (Boolean) ve.getValue(context);
+        Assert.assertEquals(Boolean.FALSE, actual);
+    }
+
+    @Test
+    public void testBug52445a() {
+        MethodExpression me = factory.createMethodExpression(context,
+                "${beanA.setBean(beanBB)}", null ,
+                new Class<?>[] { TesterBeanB.class });
+        me.invoke(context, null);
+
+        MethodExpression me1 = factory.createMethodExpression(context,
+                "${beanA.bean.sayHello()}", null, null);
+        String actual = (String) me1.invoke(context, null);
+        Assert.assertEquals("Hello from BB", actual);
+    }
+
+    @Test
+    public void testBug52970() {
+        MethodExpression me = factory.createMethodExpression(context,
+                "${beanEnum.submit('APPLE')}", null ,
+                new Class<?>[] { TesterBeanEnum.class });
+        me.invoke(context, null);
+
+        ValueExpression ve = factory.createValueExpression(context,
+                "#{beanEnum.lastSubmitted}", TesterEnum.class);
+        TesterEnum actual = (TesterEnum) ve.getValue(context);
+        Assert.assertEquals(TesterEnum.APPLE, actual);
+
+    }
+
+    @Test
+    public void testBug53792a() {
+        MethodExpression me = factory.createMethodExpression(context,
+                "${beanA.setBean(beanB)}", null ,
+                new Class<?>[] { TesterBeanB.class });
+        me.invoke(context, null);
+        me = factory.createMethodExpression(context,
+                "${beanB.setName('" + BUG53792 + "')}", null ,
+                new Class<?>[] { TesterBeanB.class });
+        me.invoke(context, null);
+
+        ValueExpression ve = factory.createValueExpression(context,
+                "#{beanA.getBean().name}", java.lang.String.class);
+        String actual = (String) ve.getValue(context);
+        Assert.assertEquals(BUG53792, actual);
+    }
+
+    @Test
+    public void testBug53792b() {
+        MethodExpression me = factory.createMethodExpression(context,
+                "${beanA.setBean(beanB)}", null ,
+                new Class<?>[] { TesterBeanB.class });
+        me.invoke(context, null);
+        me = factory.createMethodExpression(context,
+                "${beanB.setName('" + BUG53792 + "')}", null ,
+                new Class<?>[] { TesterBeanB.class });
+        me.invoke(context, null);
+
+        ValueExpression ve = factory.createValueExpression(context,
+                "#{beanA.getBean().name.length()}", java.lang.Integer.class);
+        Integer actual = (Integer) ve.getValue(context);
+        Assert.assertEquals(Integer.valueOf(BUG53792.length()), actual);
+    }
+
+
+    @Test
+    public void testBug53792c() {
+        MethodExpression me = factory.createMethodExpression(context,
+                "#{beanB.sayHello().length()}", null, new Class<?>[] {});
+        Integer result = (Integer) me.invoke(context, null);
+        Assert.assertEquals(beanB.sayHello().length(), result.intValue());
+    }
+
+
+    @Test
+    public void testBug53792d() {
+        MethodExpression me = factory.createMethodExpression(context,
+                "#{beanB.sayHello().length()}", null, new Class<?>[] {});
+        Integer result = (Integer) me.invoke(context, new Object[] { "foo" });
+        Assert.assertEquals(beanB.sayHello().length(), result.intValue());
+    }
+
+
+    @Test
+    public void testBug56797a() {
+        MethodExpression me = factory.createMethodExpression(context,
+                "${beanAA.echo1('Hello World!')}", null , null);
+        Object r = me.invoke(context, null);
+        Assert.assertEquals("AA1Hello World!", r.toString());
+    }
+
+
+    @Test
+    public void testBug56797b() {
+        MethodExpression me = factory.createMethodExpression(context,
+                "${beanAA.echo2('Hello World!')}", null , null);
+        Object r = me.invoke(context, null);
+        Assert.assertEquals("AA2Hello World!", r.toString());
+    }
+
+
+    @Test(expected=MethodNotFoundException.class)
+    public void testBug57855a() {
+        MethodExpression me = factory.createMethodExpression(context,
+                "${beanAA.echo2}", null , new Class[]{String.class});
+        me.invoke(context, new Object[0]);
+    }
+
+
+    @Test(expected=IllegalArgumentException.class)
+    public void testBug57855b() {
+        MethodExpression me = factory.createMethodExpression(context,
+                "${beanAA.echo2}", null , new Class[]{String.class});
+        me.invoke(context, null);
+    }
+
+    @Test
+    public void testBug57855c() {
+        MethodExpression me = factory.createMethodExpression(context,
+                "${beanB.echo}", null , new Class[]{String.class});
+        me.invoke(context, null);
+    }
+
+
+    @Test
+    public void testBug57855d() {
+        MethodExpression me = factory.createMethodExpression(context,
+                "${beanB.echo}", null , new Class[]{String.class});
+        Object r = me.invoke(context, new String[] { "aaa" });
+        Assert.assertEquals("aaa", r.toString());
+    }
+
+    @Test(expected=MethodNotFoundException.class)
+    public void testBug57855e() {
+        MethodExpression me = factory.createMethodExpression(context,
+                "${beanB.echo}", null , new Class[]{String.class});
+        Object r = me.invoke(context, new String[] { "aaa", "bbb" });
+        Assert.assertEquals("aaa, bbb", r.toString());
+    }
+
+
+    @Test(expected=IllegalArgumentException.class)
+    public void testBug60844() {
+        MethodExpression me2 = factory.createMethodExpression(context,
+                "${beanC.sayHello}", null , new Class[]{ TesterBeanA.class, TesterBeanB.class});
+        me2.invoke(context, new Object[] { new Object() });
+    }
+}