989 lines
36 KiB
Java
989 lines
36 KiB
Java
/*
|
|
* 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 javax.el;
|
|
|
|
import java.beans.FeatureDescriptor;
|
|
import java.beans.PropertyDescriptor;
|
|
import java.util.ArrayList;
|
|
import java.util.Iterator;
|
|
|
|
import org.junit.Assert;
|
|
import org.junit.Test;
|
|
|
|
import org.apache.jasper.el.ELContextImpl;
|
|
|
|
public class TestBeanELResolver {
|
|
|
|
private static final String METHOD01_NAME = "toString";
|
|
private static final String METHOD02_NAME = "<init>";
|
|
private static final String METHOD03_NAME = "nonExistingMethod";
|
|
private static final String BEAN_NAME = "test";
|
|
private static final String PROPERTY01_NAME = "valueA";
|
|
private static final String PROPERTY02_NAME = "valueB";
|
|
private static final String PROPERTY03_NAME = "name";
|
|
private static final String PROPERTY_VALUE = "test1";
|
|
|
|
@Test
|
|
public void testBug53421() {
|
|
ExpressionFactory factory = ExpressionFactory.newInstance();
|
|
ELContext context = new ELContextImpl(factory);
|
|
|
|
Bean bean = new Bean();
|
|
|
|
ValueExpression varBean =
|
|
factory.createValueExpression(bean, Bean.class);
|
|
context.getVariableMapper().setVariable("bean", varBean);
|
|
|
|
|
|
ValueExpression ve = factory.createValueExpression(
|
|
context, "${bean.valueA}", String.class);
|
|
Exception e = null;
|
|
try {
|
|
ve.getValue(context);
|
|
} catch (PropertyNotFoundException pnfe) {
|
|
e = pnfe;
|
|
}
|
|
Assert.assertTrue("Wrong exception type",
|
|
e instanceof PropertyNotFoundException);
|
|
String type = Bean.class.getName();
|
|
String msg = e.getMessage();
|
|
Assert.assertTrue("No reference to type [" + type +
|
|
"] where property cannot be found in [" + msg + "]",
|
|
msg.contains(type));
|
|
}
|
|
|
|
/**
|
|
* Tests that a null context results in an NPE as per EL Javadoc.
|
|
*/
|
|
@Test(expected = NullPointerException.class)
|
|
public void testGetType01() {
|
|
BeanELResolver resolver = new BeanELResolver();
|
|
resolver.getType(null, new Object(), new Object());
|
|
}
|
|
|
|
/**
|
|
* Tests that a valid property is not resolved if base is null.
|
|
*/
|
|
@Test
|
|
public void testGetType02() {
|
|
doNegativeTest(null, new Object(), MethodUnderTest.GET_TYPE, true);
|
|
}
|
|
|
|
/**
|
|
* Tests that a valid property is resolved.
|
|
*/
|
|
@Test
|
|
public void testGetType03() {
|
|
BeanELResolver resolver = new BeanELResolver();
|
|
ELContext context = new StandardELContext(ELManager.getExpressionFactory());
|
|
|
|
Class<?> result = resolver.getType(context, new Bean(), PROPERTY01_NAME);
|
|
|
|
Assert.assertEquals(String.class, result);
|
|
Assert.assertTrue(context.isPropertyResolved());
|
|
}
|
|
|
|
/**
|
|
* Tests that an exception will be thrown when the property does not exist.
|
|
*/
|
|
@Test(expected = PropertyNotFoundException.class)
|
|
public void testGetType04() {
|
|
BeanELResolver resolver = new BeanELResolver();
|
|
ELContext context = new StandardELContext(ELManager.getExpressionFactory());
|
|
|
|
resolver.getType(context, new Bean(), PROPERTY02_NAME);
|
|
}
|
|
|
|
/**
|
|
* Tests that an exception will be thrown when a coercion cannot be
|
|
* performed.
|
|
*/
|
|
@Test(expected = PropertyNotFoundException.class)
|
|
public void testGetType05() {
|
|
BeanELResolver resolver = new BeanELResolver();
|
|
ELContext context = new StandardELContext(ELManager.getExpressionFactory());
|
|
|
|
resolver.getType(context, new Bean(), new Object());
|
|
}
|
|
|
|
/**
|
|
* Tests that a null context results in an NPE as per EL Javadoc.
|
|
*/
|
|
@Test(expected = NullPointerException.class)
|
|
public void testGetValue01() {
|
|
BeanELResolver resolver = new BeanELResolver();
|
|
resolver.getValue(null, new Object(), new Object());
|
|
}
|
|
|
|
/**
|
|
* Tests that a valid property is not resolved if base is null.
|
|
*/
|
|
@Test
|
|
public void testGetValue02() {
|
|
doNegativeTest(null, new Object(), MethodUnderTest.GET_VALUE, true);
|
|
}
|
|
|
|
/**
|
|
* Tests that a valid property is resolved.
|
|
*/
|
|
@Test
|
|
public void testGetValue03() {
|
|
BeanELResolver resolver = new BeanELResolver();
|
|
ELContext context = new StandardELContext(ELManager.getExpressionFactory());
|
|
|
|
Object result = resolver.getValue(context, new TesterBean(BEAN_NAME), PROPERTY03_NAME);
|
|
|
|
Assert.assertEquals(BEAN_NAME, result);
|
|
Assert.assertTrue(context.isPropertyResolved());
|
|
}
|
|
|
|
/**
|
|
* Tests that an exception will be thrown when the property does not exist.
|
|
*/
|
|
@Test(expected = PropertyNotFoundException.class)
|
|
public void testGetValue04() {
|
|
BeanELResolver resolver = new BeanELResolver();
|
|
ELContext context = new StandardELContext(ELManager.getExpressionFactory());
|
|
|
|
resolver.getValue(context, new Bean(), PROPERTY02_NAME);
|
|
}
|
|
|
|
/**
|
|
* Tests that an exception will be thrown when a coercion cannot be
|
|
* performed.
|
|
*/
|
|
@Test(expected = PropertyNotFoundException.class)
|
|
public void testGetValue05() {
|
|
BeanELResolver resolver = new BeanELResolver();
|
|
ELContext context = new StandardELContext(ELManager.getExpressionFactory());
|
|
|
|
resolver.getValue(context, new Bean(), new Object());
|
|
}
|
|
|
|
/**
|
|
* Tests that an exception will be thrown when the property is not readable.
|
|
*/
|
|
@Test(expected = PropertyNotFoundException.class)
|
|
public void testGetValue06() {
|
|
BeanELResolver resolver = new BeanELResolver();
|
|
ELContext context = new StandardELContext(ELManager.getExpressionFactory());
|
|
|
|
resolver.getValue(context, new Bean(), PROPERTY01_NAME);
|
|
}
|
|
|
|
/**
|
|
* Tests that getter method throws exception which should be propagated.
|
|
*/
|
|
@Test(expected = ELException.class)
|
|
public void testGetValue07() {
|
|
BeanELResolver resolver = new BeanELResolver();
|
|
ELContext context = new StandardELContext(ELManager.getExpressionFactory());
|
|
|
|
resolver.getValue(context, new TesterBean(BEAN_NAME), PROPERTY01_NAME);
|
|
}
|
|
|
|
/**
|
|
* Tests that a null context results in an NPE as per EL Javadoc.
|
|
*/
|
|
@Test(expected = NullPointerException.class)
|
|
public void testSetValue01() {
|
|
BeanELResolver resolver = new BeanELResolver();
|
|
resolver.setValue(null, new Object(), new Object(), new Object());
|
|
}
|
|
|
|
/**
|
|
* Tests that a valid property is not resolved if base is null.
|
|
*/
|
|
@Test
|
|
public void testSetValue02() {
|
|
doNegativeTest(null, new Object(), MethodUnderTest.SET_VALUE, true);
|
|
}
|
|
|
|
/**
|
|
* Tests that an exception is thrown when readOnly is true.
|
|
*/
|
|
@Test(expected = PropertyNotWritableException.class)
|
|
public void testSetValue03() {
|
|
BeanELResolver resolver = new BeanELResolver(true);
|
|
ELContext context = new StandardELContext(ELManager.getExpressionFactory());
|
|
|
|
resolver.setValue(context, new Bean(), new Object(), new Object());
|
|
}
|
|
|
|
/**
|
|
* Tests that a valid property is resolved.
|
|
*/
|
|
@Test
|
|
public void testSetValue04() {
|
|
BeanELResolver resolver = new BeanELResolver();
|
|
ELContext context = new StandardELContext(ELManager.getExpressionFactory());
|
|
|
|
TesterBean bean = new TesterBean(BEAN_NAME);
|
|
resolver.setValue(context, bean, PROPERTY03_NAME, PROPERTY_VALUE);
|
|
|
|
Assert.assertEquals(PROPERTY_VALUE, resolver.getValue(context, bean, PROPERTY03_NAME));
|
|
Assert.assertTrue(context.isPropertyResolved());
|
|
}
|
|
|
|
/**
|
|
* Tests that an exception will be thrown when a coercion cannot be
|
|
* performed.
|
|
*/
|
|
@Test(expected = PropertyNotFoundException.class)
|
|
public void testSetValue05() {
|
|
BeanELResolver resolver = new BeanELResolver();
|
|
ELContext context = new StandardELContext(ELManager.getExpressionFactory());
|
|
|
|
resolver.setValue(context, new Bean(), new Object(), PROPERTY_VALUE);
|
|
}
|
|
|
|
/**
|
|
* Tests that an exception will be thrown when the property does not exist.
|
|
*/
|
|
@Test(expected = PropertyNotFoundException.class)
|
|
public void testSetValue06() {
|
|
BeanELResolver resolver = new BeanELResolver();
|
|
ELContext context = new StandardELContext(ELManager.getExpressionFactory());
|
|
|
|
resolver.setValue(context, new Bean(), PROPERTY02_NAME, PROPERTY_VALUE);
|
|
}
|
|
|
|
/**
|
|
* Tests that an exception will be thrown when the property does not have
|
|
* setter method.
|
|
*/
|
|
@Test(expected = PropertyNotWritableException.class)
|
|
public void testSetValue07() {
|
|
BeanELResolver resolver = new BeanELResolver();
|
|
ELContext context = new StandardELContext(ELManager.getExpressionFactory());
|
|
|
|
resolver.setValue(context, new TesterBean(BEAN_NAME), PROPERTY01_NAME, PROPERTY_VALUE);
|
|
}
|
|
|
|
/**
|
|
* Tests that a null context results in an NPE as per EL Javadoc.
|
|
*/
|
|
@Test(expected = NullPointerException.class)
|
|
public void testIsReadOnly01() {
|
|
BeanELResolver resolver = new BeanELResolver();
|
|
resolver.isReadOnly(null, new Object(), new Object());
|
|
}
|
|
|
|
/**
|
|
* Tests that the propertyResolved is false if base is null.
|
|
*/
|
|
@Test
|
|
public void testIsReadOnly02() {
|
|
BeanELResolver resolver = new BeanELResolver();
|
|
ELContext context = new StandardELContext(ELManager.getExpressionFactory());
|
|
|
|
resolver.isReadOnly(context, null, new Object());
|
|
|
|
Assert.assertFalse(context.isPropertyResolved());
|
|
|
|
resolver = new BeanELResolver(true);
|
|
|
|
resolver.isReadOnly(context, null, new Object());
|
|
|
|
Assert.assertFalse(context.isPropertyResolved());
|
|
}
|
|
|
|
/**
|
|
* Tests that if the BeanELResolver is constructed with readOnly the method
|
|
* will return always true.
|
|
*/
|
|
@Test
|
|
public void testIsReadOnly03() {
|
|
BeanELResolver resolver = new BeanELResolver();
|
|
ELContext context = new StandardELContext(ELManager.getExpressionFactory());
|
|
|
|
boolean result = resolver.isReadOnly(context, new TesterBean(BEAN_NAME), PROPERTY03_NAME);
|
|
|
|
Assert.assertFalse(result);
|
|
Assert.assertTrue(context.isPropertyResolved());
|
|
|
|
resolver = new BeanELResolver(true);
|
|
|
|
result = resolver.isReadOnly(context, new TesterBean(BEAN_NAME), PROPERTY03_NAME);
|
|
|
|
Assert.assertTrue(result);
|
|
Assert.assertTrue(context.isPropertyResolved());
|
|
}
|
|
|
|
/**
|
|
* Tests that an exception is thrown when a coercion cannot be performed.
|
|
*/
|
|
@Test(expected = PropertyNotFoundException.class)
|
|
public void testIsReadOnly04() {
|
|
BeanELResolver resolver = new BeanELResolver();
|
|
ELContext context = new StandardELContext(ELManager.getExpressionFactory());
|
|
|
|
resolver.isReadOnly(context, new TesterBean(BEAN_NAME), Integer.valueOf(0));
|
|
}
|
|
|
|
/**
|
|
* Tests that an exception will be thrown when the property does not exist.
|
|
*/
|
|
@Test(expected = PropertyNotFoundException.class)
|
|
public void testIsReadOnly05() {
|
|
BeanELResolver resolver = new BeanELResolver();
|
|
ELContext context = new StandardELContext(ELManager.getExpressionFactory());
|
|
|
|
resolver.isReadOnly(context, new Bean(), PROPERTY02_NAME);
|
|
}
|
|
|
|
/**
|
|
* Tests that true will be returned when the property does not have setter
|
|
* method.
|
|
*/
|
|
@Test
|
|
public void testIsReadOnly06() {
|
|
BeanELResolver resolver = new BeanELResolver();
|
|
ELContext context = new StandardELContext(ELManager.getExpressionFactory());
|
|
|
|
boolean result = resolver.isReadOnly(context, new TesterBean(BEAN_NAME), PROPERTY01_NAME);
|
|
|
|
Assert.assertTrue(result);
|
|
Assert.assertTrue(context.isPropertyResolved());
|
|
}
|
|
|
|
/**
|
|
* Tests that a valid FeatureDescriptors are not returned if base is not
|
|
* Map.
|
|
*/
|
|
@Test
|
|
public void testGetFeatureDescriptors01() {
|
|
BeanELResolver resolver = new BeanELResolver();
|
|
ELContext context = new StandardELContext(ELManager.getExpressionFactory());
|
|
|
|
Iterator<FeatureDescriptor> result = resolver.getFeatureDescriptors(context, null);
|
|
|
|
Assert.assertNull(result);
|
|
}
|
|
|
|
/**
|
|
* Tests that a valid FeatureDescriptors are returned.
|
|
*/
|
|
@Test
|
|
public void testGetFeatureDescriptors02() {
|
|
BeanELResolver resolver = new BeanELResolver();
|
|
ELContext context = new StandardELContext(ELManager.getExpressionFactory());
|
|
|
|
Iterator<FeatureDescriptor> result = resolver.getFeatureDescriptors(context, new Bean());
|
|
|
|
while (result.hasNext()) {
|
|
PropertyDescriptor featureDescriptor = (PropertyDescriptor) result.next();
|
|
Assert.assertEquals(featureDescriptor.getPropertyType(),
|
|
featureDescriptor.getValue(ELResolver.TYPE));
|
|
Assert.assertEquals(Boolean.TRUE,
|
|
featureDescriptor.getValue(ELResolver.RESOLVABLE_AT_DESIGN_TIME));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Tests that a null context results in an NPE as per EL Javadoc.
|
|
*/
|
|
@Test(expected = NullPointerException.class)
|
|
public void testInvoke01() {
|
|
BeanELResolver resolver = new BeanELResolver();
|
|
resolver.invoke(null, new Object(), new Object(), new Class<?>[0], new Object[0]);
|
|
}
|
|
|
|
/**
|
|
* Tests that a valid property is not resolved if base is null.
|
|
*/
|
|
@Test
|
|
public void testInvoke02() {
|
|
doNegativeTest(null, new Object(), MethodUnderTest.INVOKE, true);
|
|
}
|
|
|
|
/**
|
|
* Tests a method invocation.
|
|
*/
|
|
@Test
|
|
public void testInvoke03() {
|
|
BeanELResolver resolver = new BeanELResolver();
|
|
ELContext context = new StandardELContext(ELManager.getExpressionFactory());
|
|
|
|
Object result = resolver.invoke(context, new TesterBean(BEAN_NAME), METHOD01_NAME,
|
|
new Class<?>[] {}, new Object[] {});
|
|
|
|
Assert.assertEquals(BEAN_NAME, result);
|
|
Assert.assertTrue(context.isPropertyResolved());
|
|
}
|
|
|
|
/**
|
|
* Tests that the method name cannot be coerced to String.
|
|
*/
|
|
@Test
|
|
public void testInvoke04() {
|
|
doNegativeTest(new Bean(), null, MethodUnderTest.INVOKE, true);
|
|
}
|
|
|
|
/**
|
|
* Tests that a call to <init> as a method name will throw an exception.
|
|
*/
|
|
@Test(expected = MethodNotFoundException.class)
|
|
public void testInvoke05() {
|
|
BeanELResolver resolver = new BeanELResolver();
|
|
ELContext context = new StandardELContext(ELManager.getExpressionFactory());
|
|
|
|
resolver.invoke(context, new TesterBean(BEAN_NAME), METHOD02_NAME, new Class<?>[] {},
|
|
new Object[] {});
|
|
}
|
|
|
|
/**
|
|
* Tests that a call to a non existing method will throw an exception.
|
|
*/
|
|
@Test(expected = MethodNotFoundException.class)
|
|
public void testInvoke06() {
|
|
BeanELResolver resolver = new BeanELResolver();
|
|
ELContext context = new StandardELContext(ELManager.getExpressionFactory());
|
|
|
|
resolver.invoke(context, new TesterBean(BEAN_NAME), METHOD03_NAME, new Class<?>[] {},
|
|
new Object[] {});
|
|
}
|
|
|
|
@Test
|
|
public void testInvokeVarargsCoerce01() {
|
|
BeanELResolver resolver = new BeanELResolver();
|
|
ELContext context = new StandardELContext(ELManager.getExpressionFactory());
|
|
|
|
Object result = resolver.invoke(context, new TesterBean(BEAN_NAME), "getNameVarargs",
|
|
new Class<?>[] {}, new String[] {});
|
|
|
|
Assert.assertEquals(BEAN_NAME, result);
|
|
}
|
|
|
|
@Test
|
|
public void testInvokeVarargsCoerce02() {
|
|
BeanELResolver resolver = new BeanELResolver();
|
|
ELContext context = new StandardELContext(ELManager.getExpressionFactory());
|
|
|
|
Object result = resolver.invoke(context, new TesterBean(BEAN_NAME), "getNameVarargs",
|
|
null, null);
|
|
|
|
Assert.assertEquals(BEAN_NAME, result);
|
|
}
|
|
|
|
@Test
|
|
public void testInvokeVarargsCoerce03() {
|
|
BeanELResolver resolver = new BeanELResolver();
|
|
ELContext context = new StandardELContext(ELManager.getExpressionFactory());
|
|
|
|
Object result = resolver.invoke(context, new TesterBean(BEAN_NAME), "getNameVarargs",
|
|
null, new String[] {});
|
|
|
|
Assert.assertEquals(BEAN_NAME, result);
|
|
}
|
|
|
|
@Test
|
|
public void testInvokeVarargsCoerce04() {
|
|
BeanELResolver resolver = new BeanELResolver();
|
|
ELContext context = new StandardELContext(ELManager.getExpressionFactory());
|
|
|
|
Object result = resolver.invoke(context, new TesterBean(BEAN_NAME), "getNameVarargs",
|
|
new Class<?>[] {}, null);
|
|
|
|
Assert.assertEquals(BEAN_NAME, result);
|
|
}
|
|
|
|
@Test
|
|
public void testInvokeVarargsCoerce05() {
|
|
BeanELResolver resolver = new BeanELResolver();
|
|
ELContext context = new StandardELContext(ELManager.getExpressionFactory());
|
|
|
|
Object result = resolver.invoke(context, new TesterBean(BEAN_NAME), "getNameVarargs",
|
|
new Class<?>[] { null }, new String[] { null });
|
|
|
|
Assert.assertEquals(BEAN_NAME, result);
|
|
}
|
|
|
|
@Test
|
|
public void testInvokeVarargsCoerce06() {
|
|
BeanELResolver resolver = new BeanELResolver();
|
|
ELContext context = new StandardELContext(ELManager.getExpressionFactory());
|
|
|
|
Object result = resolver.invoke(context, new TesterBean(BEAN_NAME), "getNameVarargs",
|
|
null, new String[] { null });
|
|
|
|
Assert.assertEquals(BEAN_NAME, result);
|
|
}
|
|
|
|
@Test
|
|
public void testInvokeVarargsCoerce07() {
|
|
BeanELResolver resolver = new BeanELResolver();
|
|
ELContext context = new StandardELContext(ELManager.getExpressionFactory());
|
|
|
|
Object result = resolver.invoke(context, new TesterBean(BEAN_NAME), "getNameVarargs",
|
|
new Class<?>[] { null }, null);
|
|
|
|
Assert.assertEquals(BEAN_NAME, result);
|
|
}
|
|
|
|
@Test
|
|
public void testInvokeVarargsCoerce08() {
|
|
BeanELResolver resolver = new BeanELResolver();
|
|
ELContext context = new StandardELContext(ELManager.getExpressionFactory());
|
|
|
|
Object result = resolver.invoke(context, new TesterBean(BEAN_NAME), "getNameVarargs",
|
|
new Class<?>[] { String.class }, new String[] { "true" });
|
|
|
|
Assert.assertEquals(BEAN_NAME, result);
|
|
}
|
|
|
|
@Test
|
|
public void testInvokeVarargsCoerce09() {
|
|
BeanELResolver resolver = new BeanELResolver();
|
|
ELContext context = new StandardELContext(ELManager.getExpressionFactory());
|
|
|
|
Object result = resolver.invoke(context, new TesterBean(BEAN_NAME), "getNameVarargs",
|
|
new Class<?>[] { String.class, String.class }, new Object[] { "true", null });
|
|
|
|
Assert.assertEquals(BEAN_NAME, result);
|
|
}
|
|
|
|
@Test
|
|
public void testInvokeVarargsCoerce10() {
|
|
BeanELResolver resolver = new BeanELResolver();
|
|
ELContext context = new StandardELContext(ELManager.getExpressionFactory());
|
|
|
|
Object result = resolver.invoke(context, new TesterBean(BEAN_NAME), "getNameVarargs",
|
|
new Class<?>[] { String.class, String[].class }, new Object[] { "true", null });
|
|
|
|
Assert.assertEquals(BEAN_NAME, result);
|
|
}
|
|
|
|
@Test
|
|
public void testInvokeVarargsCoerce11() {
|
|
BeanELResolver resolver = new BeanELResolver();
|
|
ELContext context = new StandardELContext(ELManager.getExpressionFactory());
|
|
|
|
Object result = resolver.invoke(context, new TesterBean(BEAN_NAME), "getNameVarargs",
|
|
new Class<?>[] { String.class }, new Object[] { "10" });
|
|
|
|
Assert.assertEquals(BEAN_NAME, result);
|
|
}
|
|
|
|
@Test
|
|
public void testInvokeVarargsCoerce12() {
|
|
BeanELResolver resolver = new BeanELResolver();
|
|
ELContext context = new StandardELContext(ELManager.getExpressionFactory());
|
|
|
|
Object result = resolver.invoke(context, new TesterBean(BEAN_NAME), "getNameVarargs",
|
|
new Class<?>[] { String[].class }, new String[] { "10" });
|
|
|
|
Assert.assertEquals(BEAN_NAME, result);
|
|
}
|
|
|
|
// Ambiguous because the Strings coerce to both Boolean and Integer hence
|
|
// both varargs methods match.
|
|
@Test(expected=MethodNotFoundException.class)
|
|
public void testInvokeVarargsCoerce13() {
|
|
BeanELResolver resolver = new BeanELResolver();
|
|
ELContext context = new StandardELContext(ELManager.getExpressionFactory());
|
|
|
|
Object result = resolver.invoke(context, new TesterBean(BEAN_NAME), "getNameVarargs",
|
|
new Class<?>[] { String.class, String.class }, new String[] { "10", "11" });
|
|
|
|
Assert.assertEquals(BEAN_NAME, result);
|
|
}
|
|
|
|
@Test
|
|
public void testInvokeVarargsCoerce14() {
|
|
BeanELResolver resolver = new BeanELResolver();
|
|
ELContext context = new StandardELContext(ELManager.getExpressionFactory());
|
|
|
|
Object result = resolver.invoke(context, new TesterBean(BEAN_NAME), "getNameVarargs",
|
|
new Class<?>[] { String.class, String.class }, new String[] { "true", null });
|
|
|
|
Assert.assertEquals(BEAN_NAME, result);
|
|
}
|
|
|
|
@Test(expected=MethodNotFoundException.class)
|
|
public void testInvokeVarargsCoerce15() {
|
|
BeanELResolver resolver = new BeanELResolver();
|
|
ELContext context = new StandardELContext(ELManager.getExpressionFactory());
|
|
|
|
Object result = resolver.invoke(context, new TesterBean(BEAN_NAME), "getNameVarargs",
|
|
new Class<?>[] { String.class, String.class }, new Object[] { "true", new ArrayList<>() });
|
|
|
|
Assert.assertEquals(BEAN_NAME, result);
|
|
}
|
|
|
|
// Ambiguous because the Strings coerce to both Boolean and Integer hence
|
|
// both varargs methods match.
|
|
@Test(expected=MethodNotFoundException.class)
|
|
public void testInvokeVarargsCoerce16() {
|
|
BeanELResolver resolver = new BeanELResolver();
|
|
ELContext context = new StandardELContext(ELManager.getExpressionFactory());
|
|
|
|
Object result = resolver.invoke(context, new TesterBean(BEAN_NAME), "getNameVarargs",
|
|
new Class<?>[] { String.class, String.class, String.class },
|
|
new Object[] { "10", "11", "12" });
|
|
|
|
Assert.assertEquals(BEAN_NAME, result);
|
|
}
|
|
|
|
@Test(expected=MethodNotFoundException.class)
|
|
public void testInvokeVarargsCoerce17() {
|
|
BeanELResolver resolver = new BeanELResolver();
|
|
ELContext context = new StandardELContext(ELManager.getExpressionFactory());
|
|
|
|
Object result = resolver.invoke(context, new TesterBean(BEAN_NAME), "getNameVarargs",
|
|
new Class<?>[] { String.class, String.class },
|
|
new Object[] { "10", "11", "12" });
|
|
|
|
Assert.assertEquals(BEAN_NAME, result);
|
|
}
|
|
|
|
@Test(expected=MethodNotFoundException.class)
|
|
public void testInvokeVarargsCoerce18() {
|
|
BeanELResolver resolver = new BeanELResolver();
|
|
ELContext context = new StandardELContext(ELManager.getExpressionFactory());
|
|
|
|
Object result = resolver.invoke(context, new TesterBean(BEAN_NAME), "getNameVarargs",
|
|
new Class<?>[] { String.class, String.class, String.class, String.class },
|
|
new Object[] { "10", "11", "12" });
|
|
|
|
Assert.assertEquals(BEAN_NAME, result);
|
|
}
|
|
|
|
@Test
|
|
public void testInvokeVarargsCoerce19() {
|
|
BeanELResolver resolver = new BeanELResolver();
|
|
ELContext context = new StandardELContext(ELManager.getExpressionFactory());
|
|
|
|
Object result = resolver.invoke(context, new TesterBean(BEAN_NAME), "getNameVarargs",
|
|
new Class<?>[] { String.class, String.class, String.class, String.class },
|
|
new Object[] { "true", "10", "11", "12" });
|
|
|
|
Assert.assertEquals(BEAN_NAME, result);
|
|
}
|
|
|
|
@Test(expected=MethodNotFoundException.class)
|
|
public void testInvokeVarargsCoerce20() {
|
|
BeanELResolver resolver = new BeanELResolver();
|
|
ELContext context = new StandardELContext(ELManager.getExpressionFactory());
|
|
|
|
Object result = resolver.invoke(context, new TesterBean(BEAN_NAME), "getNameVarargs",
|
|
new Class<?>[] { String.class, String.class, String.class },
|
|
new Object[] { "true", "10", "11", "12" });
|
|
|
|
Assert.assertEquals(BEAN_NAME, result);
|
|
}
|
|
|
|
@Test(expected=MethodNotFoundException.class)
|
|
public void testInvokeVarargsCoerce21() {
|
|
BeanELResolver resolver = new BeanELResolver();
|
|
ELContext context = new StandardELContext(ELManager.getExpressionFactory());
|
|
|
|
Object result = resolver.invoke(context, new TesterBean(BEAN_NAME), "getNameVarargs",
|
|
new Class<?>[] { String.class, String.class, String.class, String.class, String.class },
|
|
new Object[] { "true", "10", "11", "12" });
|
|
|
|
Assert.assertEquals(BEAN_NAME, result);
|
|
}
|
|
|
|
@Test
|
|
public void testInvokeVarargs01() {
|
|
BeanELResolver resolver = new BeanELResolver();
|
|
ELContext context = new StandardELContext(ELManager.getExpressionFactory());
|
|
|
|
Object result = resolver.invoke(context, new TesterBean(BEAN_NAME), "getNameVarargs",
|
|
new Class<?>[] {}, new Object[] {});
|
|
|
|
Assert.assertEquals(BEAN_NAME, result);
|
|
}
|
|
|
|
@Test
|
|
public void testInvokeVarargs02() {
|
|
BeanELResolver resolver = new BeanELResolver();
|
|
ELContext context = new StandardELContext(ELManager.getExpressionFactory());
|
|
|
|
Object result = resolver.invoke(context, new TesterBean(BEAN_NAME), "getNameVarargs",
|
|
null, null);
|
|
|
|
Assert.assertEquals(BEAN_NAME, result);
|
|
}
|
|
|
|
@Test
|
|
public void testInvokeVarargs03() {
|
|
BeanELResolver resolver = new BeanELResolver();
|
|
ELContext context = new StandardELContext(ELManager.getExpressionFactory());
|
|
|
|
Object result = resolver.invoke(context, new TesterBean(BEAN_NAME), "getNameVarargs",
|
|
null, new Object[] {});
|
|
|
|
Assert.assertEquals(BEAN_NAME, result);
|
|
}
|
|
|
|
@Test
|
|
public void testInvokeVarargs04() {
|
|
BeanELResolver resolver = new BeanELResolver();
|
|
ELContext context = new StandardELContext(ELManager.getExpressionFactory());
|
|
|
|
Object result = resolver.invoke(context, new TesterBean(BEAN_NAME), "getNameVarargs",
|
|
new Class<?>[] {}, null);
|
|
|
|
Assert.assertEquals(BEAN_NAME, result);
|
|
}
|
|
|
|
@Test
|
|
public void testInvokeVarargs05() {
|
|
BeanELResolver resolver = new BeanELResolver();
|
|
ELContext context = new StandardELContext(ELManager.getExpressionFactory());
|
|
|
|
Object result = resolver.invoke(context, new TesterBean(BEAN_NAME), "getNameVarargs",
|
|
new Class<?>[] { null }, new Object[] { null });
|
|
|
|
Assert.assertEquals(BEAN_NAME, result);
|
|
}
|
|
|
|
@Test
|
|
public void testInvokeVarargs06() {
|
|
BeanELResolver resolver = new BeanELResolver();
|
|
ELContext context = new StandardELContext(ELManager.getExpressionFactory());
|
|
|
|
Object result = resolver.invoke(context, new TesterBean(BEAN_NAME), "getNameVarargs",
|
|
null, new Object[] { null });
|
|
|
|
Assert.assertEquals(BEAN_NAME, result);
|
|
}
|
|
|
|
@Test
|
|
public void testInvokeVarargs07() {
|
|
BeanELResolver resolver = new BeanELResolver();
|
|
ELContext context = new StandardELContext(ELManager.getExpressionFactory());
|
|
|
|
Object result = resolver.invoke(context, new TesterBean(BEAN_NAME), "getNameVarargs",
|
|
new Class<?>[] { null }, null);
|
|
|
|
Assert.assertEquals(BEAN_NAME, result);
|
|
}
|
|
|
|
@Test
|
|
public void testInvokeVarargs08() {
|
|
BeanELResolver resolver = new BeanELResolver();
|
|
ELContext context = new StandardELContext(ELManager.getExpressionFactory());
|
|
|
|
Object result = resolver.invoke(context, new TesterBean(BEAN_NAME), "getNameVarargs",
|
|
new Class<?>[] { Boolean.class }, new Object[] { Boolean.TRUE });
|
|
|
|
Assert.assertEquals(BEAN_NAME, result);
|
|
}
|
|
|
|
@Test
|
|
public void testInvokeVarargs09() {
|
|
BeanELResolver resolver = new BeanELResolver();
|
|
ELContext context = new StandardELContext(ELManager.getExpressionFactory());
|
|
|
|
Object result = resolver.invoke(context, new TesterBean(BEAN_NAME), "getNameVarargs",
|
|
new Class<?>[] { Boolean.class, Integer.class }, new Object[] { Boolean.TRUE, null });
|
|
|
|
Assert.assertEquals(BEAN_NAME, result);
|
|
}
|
|
|
|
@Test
|
|
public void testInvokeVarargs10() {
|
|
BeanELResolver resolver = new BeanELResolver();
|
|
ELContext context = new StandardELContext(ELManager.getExpressionFactory());
|
|
|
|
Object result = resolver.invoke(context, new TesterBean(BEAN_NAME), "getNameVarargs",
|
|
new Class<?>[] { Boolean.class, Integer[].class }, new Object[] { Boolean.TRUE, null });
|
|
|
|
Assert.assertEquals(BEAN_NAME, result);
|
|
}
|
|
|
|
@Test
|
|
public void testInvokeVarargs11() {
|
|
BeanELResolver resolver = new BeanELResolver();
|
|
ELContext context = new StandardELContext(ELManager.getExpressionFactory());
|
|
|
|
Object result = resolver.invoke(context, new TesterBean(BEAN_NAME), "getNameVarargs",
|
|
new Class<?>[] { Integer.class }, new Object[] { Integer.valueOf(10) });
|
|
|
|
Assert.assertEquals(BEAN_NAME, result);
|
|
}
|
|
|
|
@Test
|
|
public void testInvokeVarargs12() {
|
|
BeanELResolver resolver = new BeanELResolver();
|
|
ELContext context = new StandardELContext(ELManager.getExpressionFactory());
|
|
|
|
Object result = resolver.invoke(context, new TesterBean(BEAN_NAME), "getNameVarargs",
|
|
new Class<?>[] { Integer[].class }, new Object[] { Integer.valueOf(10) });
|
|
|
|
Assert.assertEquals(BEAN_NAME, result);
|
|
}
|
|
|
|
@Test
|
|
public void testInvokeVarargs13() {
|
|
BeanELResolver resolver = new BeanELResolver();
|
|
ELContext context = new StandardELContext(ELManager.getExpressionFactory());
|
|
|
|
Object result = resolver.invoke(context, new TesterBean(BEAN_NAME), "getNameVarargs",
|
|
new Class<?>[] { Integer.class, Integer.class }, new Object[] { Integer.valueOf(10), Integer.valueOf(11) });
|
|
|
|
Assert.assertEquals(BEAN_NAME, result);
|
|
}
|
|
|
|
// Note: The coercion rules are that a null of any type can be coerced to a
|
|
// null of *any* other type so this works.
|
|
@Test
|
|
public void testInvokeVarargs14() {
|
|
BeanELResolver resolver = new BeanELResolver();
|
|
ELContext context = new StandardELContext(ELManager.getExpressionFactory());
|
|
|
|
Object result = resolver.invoke(context, new TesterBean(BEAN_NAME), "getNameVarargs",
|
|
new Class<?>[] { Boolean.class, ArrayList.class }, new Object[] { Boolean.TRUE, null });
|
|
|
|
Assert.assertEquals(BEAN_NAME, result);
|
|
}
|
|
|
|
@Test(expected=MethodNotFoundException.class)
|
|
public void testInvokeVarargs15() {
|
|
BeanELResolver resolver = new BeanELResolver();
|
|
ELContext context = new StandardELContext(ELManager.getExpressionFactory());
|
|
|
|
Object result = resolver.invoke(context, new TesterBean(BEAN_NAME), "getNameVarargs",
|
|
new Class<?>[] { Boolean.class, ArrayList.class }, new Object[] { Boolean.TRUE, new ArrayList<>() });
|
|
|
|
Assert.assertEquals(BEAN_NAME, result);
|
|
}
|
|
|
|
@Test
|
|
public void testInvokeVarargs16() {
|
|
BeanELResolver resolver = new BeanELResolver();
|
|
ELContext context = new StandardELContext(ELManager.getExpressionFactory());
|
|
|
|
Object result = resolver.invoke(context, new TesterBean(BEAN_NAME), "getNameVarargs",
|
|
new Class<?>[] { Integer.class, Integer.class, Integer.class },
|
|
new Object[] { Integer.valueOf(10), Integer.valueOf(11), Integer.valueOf(12) });
|
|
|
|
Assert.assertEquals(BEAN_NAME, result);
|
|
}
|
|
|
|
@Test(expected=MethodNotFoundException.class)
|
|
public void testInvokeVarargs17() {
|
|
BeanELResolver resolver = new BeanELResolver();
|
|
ELContext context = new StandardELContext(ELManager.getExpressionFactory());
|
|
|
|
Object result = resolver.invoke(context, new TesterBean(BEAN_NAME), "getNameVarargs",
|
|
new Class<?>[] { Integer.class, Integer.class },
|
|
new Object[] { Integer.valueOf(10), Integer.valueOf(11), Integer.valueOf(12) });
|
|
|
|
Assert.assertEquals(BEAN_NAME, result);
|
|
}
|
|
|
|
@Test(expected=MethodNotFoundException.class)
|
|
public void testInvokeVarargs18() {
|
|
BeanELResolver resolver = new BeanELResolver();
|
|
ELContext context = new StandardELContext(ELManager.getExpressionFactory());
|
|
|
|
Object result = resolver.invoke(context, new TesterBean(BEAN_NAME), "getNameVarargs",
|
|
new Class<?>[] { Integer.class, Integer.class, Integer.class, Integer.class },
|
|
new Object[] { Integer.valueOf(10), Integer.valueOf(11), Integer.valueOf(12) });
|
|
|
|
Assert.assertEquals(BEAN_NAME, result);
|
|
}
|
|
|
|
@Test
|
|
public void testInvokeVarargs19() {
|
|
BeanELResolver resolver = new BeanELResolver();
|
|
ELContext context = new StandardELContext(ELManager.getExpressionFactory());
|
|
|
|
Object result = resolver.invoke(context, new TesterBean(BEAN_NAME), "getNameVarargs",
|
|
new Class<?>[] { Boolean.class, Integer.class, Integer.class, Integer.class },
|
|
new Object[] { Boolean.TRUE, Integer.valueOf(10), Integer.valueOf(11), Integer.valueOf(12) });
|
|
|
|
Assert.assertEquals(BEAN_NAME, result);
|
|
}
|
|
|
|
@Test(expected=MethodNotFoundException.class)
|
|
public void testInvokeVarargs20() {
|
|
BeanELResolver resolver = new BeanELResolver();
|
|
ELContext context = new StandardELContext(ELManager.getExpressionFactory());
|
|
|
|
Object result = resolver.invoke(context, new TesterBean(BEAN_NAME), "getNameVarargs",
|
|
new Class<?>[] { Boolean.class, Integer.class, Integer.class },
|
|
new Object[] { Boolean.TRUE, Integer.valueOf(10), Integer.valueOf(11), Integer.valueOf(12) });
|
|
|
|
Assert.assertEquals(BEAN_NAME, result);
|
|
}
|
|
|
|
@Test(expected=MethodNotFoundException.class)
|
|
public void testInvokeVarargs21() {
|
|
BeanELResolver resolver = new BeanELResolver();
|
|
ELContext context = new StandardELContext(ELManager.getExpressionFactory());
|
|
|
|
Object result = resolver.invoke(context, new TesterBean(BEAN_NAME), "getNameVarargs",
|
|
new Class<?>[] { Boolean.class, Integer.class, Integer.class, Integer.class, Integer.class },
|
|
new Object[] { Boolean.TRUE, Integer.valueOf(10), Integer.valueOf(11), Integer.valueOf(12) });
|
|
|
|
Assert.assertEquals(BEAN_NAME, result);
|
|
}
|
|
|
|
private static class Bean {
|
|
|
|
@SuppressWarnings("unused")
|
|
public void setValueA(String valueA) {
|
|
// NOOP
|
|
}
|
|
}
|
|
|
|
private void doNegativeTest(Object base, Object trigger, MethodUnderTest method,
|
|
boolean checkResult) {
|
|
BeanELResolver resolver = new BeanELResolver();
|
|
ELContext context = new StandardELContext(ELManager.getExpressionFactory());
|
|
|
|
Object result = null;
|
|
switch (method) {
|
|
case GET_VALUE: {
|
|
result = resolver.getValue(context, base, trigger);
|
|
break;
|
|
}
|
|
case SET_VALUE: {
|
|
resolver.setValue(context, base, trigger, new Object());
|
|
break;
|
|
}
|
|
case GET_TYPE: {
|
|
result = resolver.getType(context, base, trigger);
|
|
break;
|
|
}
|
|
case INVOKE: {
|
|
result = resolver.invoke(context, base, trigger, new Class<?>[0], new Object[0]);
|
|
break;
|
|
}
|
|
default: {
|
|
// Should never happen
|
|
Assert.fail("Missing case for method");
|
|
}
|
|
}
|
|
|
|
if (checkResult) {
|
|
Assert.assertNull(result);
|
|
}
|
|
Assert.assertFalse(context.isPropertyResolved());
|
|
}
|
|
|
|
private enum MethodUnderTest {
|
|
GET_VALUE, SET_VALUE, GET_TYPE, INVOKE
|
|
}
|
|
|
|
}
|