GitHub-Spring
/
spring-framework
mirror of https://github.com/spring-projects/spring-framework.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

Expression javadoc alignment

pull/1477/head
Juergen Hoeller 9 years ago
parent
f5c54f90b3
commit
1ad6180019
3 changed files with 86 additions and 71 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 96
      spring-expression/src/main/java/org/springframework/expression/Expression.java
  2. 22
      spring-expression/src/main/java/org/springframework/expression/spel/standard/SpelExpression.java
  3. 19
      spring-expression/src/test/java/org/springframework/expression/spel/SpelCompilationCoverageTests.java

96
spring-expression/src/main/java/org/springframework/expression/Expression.java
Unescape View File

@ -20,18 +20,19 @@ import org.springframework.core.convert.TypeDescriptor;
import org.springframework.lang.Nullable; import org.springframework.lang.Nullable;
/** /**
* An expression capable of evaluating itself against context objects. Encapsulates the * An expression capable of evaluating itself against context objects.
* details of a previously parsed expression string. Provides a common abstraction for * Encapsulates the details of a previously parsed expression string.
* expression evaluation independent of any language like OGNL or the Unified EL. * Provides a common abstraction for expression evaluation.
* *
* @author Keith Donald * @author Keith Donald
* @author Andy Clement * @author Andy Clement
* @author Juergen Hoeller
* @since 3.0 * @since 3.0
*/ */
public interface Expression { public interface Expression {
/** /**
* Return the original string used to create this expression, unmodified. * Return the original string used to create this expression (unmodified).
* @return the original expression string * @return the original expression string
*/ */
String getExpressionString(); String getExpressionString();
@ -45,8 +46,9 @@ public interface Expression {
Object getValue() throws EvaluationException; Object getValue() throws EvaluationException;
/** /**
* Evaluate the expression in the default context. If the result of the evaluation does not match (and * Evaluate the expression in the default context. If the result
* cannot be converted to) the expected result type then an exception will be returned. * of the evaluation does not match (and cannot be converted to)
* the expected result type then an exception will be returned.
* @param desiredResultType the class the caller would like the result to be * @param desiredResultType the class the caller would like the result to be
* @return the evaluation result * @return the evaluation result
* @throws EvaluationException if there is a problem during evaluation * @throws EvaluationException if there is a problem during evaluation
@ -55,8 +57,8 @@ public interface Expression {
<T> T getValue(@Nullable Class<T> desiredResultType) throws EvaluationException; <T> T getValue(@Nullable Class<T> desiredResultType) throws EvaluationException;
/** /**
* Evaluate this expression against the specified root object * Evaluate this expression against the specified root object.
* @param rootObject the root object against which properties/etc will be resolved * @param rootObject the root object against which to evaluate the expression
* @return the evaluation result * @return the evaluation result
* @throws EvaluationException if there is a problem during evaluation * @throws EvaluationException if there is a problem during evaluation
*/ */
@ -64,10 +66,10 @@ public interface Expression {
Object getValue(Object rootObject) throws EvaluationException; Object getValue(Object rootObject) throws EvaluationException;
/** /**
* Evaluate the expression in the default context against the specified root object. If the * Evaluate the expression in the default context against the specified root
* result of the evaluation does not match (and cannot be converted to) the expected result type * object. If the result of the evaluation does not match (and cannot be
* then an exception will be returned. * converted to) the expected result type then an exception will be returned.
* @param rootObject the root object against which properties/etc will be resolved * @param rootObject the root object against which to evaluate the expression
* @param desiredResultType the class the caller would like the result to be * @param desiredResultType the class the caller would like the result to be
* @return the evaluation result * @return the evaluation result
* @throws EvaluationException if there is a problem during evaluation * @throws EvaluationException if there is a problem during evaluation
@ -76,7 +78,8 @@ public interface Expression {
<T> T getValue(Object rootObject, @Nullable Class<T> desiredResultType) throws EvaluationException; <T> T getValue(Object rootObject, @Nullable Class<T> desiredResultType) throws EvaluationException;
/** /**
* Evaluate this expression in the provided context and return the result of evaluation. * Evaluate this expression in the provided context and return the result
* of evaluation.
* @param context the context in which to evaluate the expression * @param context the context in which to evaluate the expression
* @return the evaluation result * @return the evaluation result
* @throws EvaluationException if there is a problem during evaluation * @throws EvaluationException if there is a problem during evaluation
@ -85,10 +88,11 @@ public interface Expression {
Object getValue(EvaluationContext context) throws EvaluationException; Object getValue(EvaluationContext context) throws EvaluationException;
/** /**
* Evaluate this expression in the provided context and return the result of evaluation, but use * Evaluate this expression in the provided context and return the result
* the supplied root context as an override for any default root object specified in the context. * of evaluation, but use the supplied root context as an override for any
* default root object specified in the context.
* @param context the context in which to evaluate the expression * @param context the context in which to evaluate the expression
* @param rootObject the root object against which properties/etc will be resolved * @param rootObject the root object against which to evaluate the expression
* @return the evaluation result * @return the evaluation result
* @throws EvaluationException if there is a problem during evaluation * @throws EvaluationException if there is a problem during evaluation
*/ */
@ -96,8 +100,9 @@ public interface Expression {
Object getValue(EvaluationContext context, Object rootObject) throws EvaluationException; Object getValue(EvaluationContext context, Object rootObject) throws EvaluationException;
/** /**
* Evaluate the expression in a specified context which can resolve references to properties, methods, types, etc - * Evaluate the expression in a specified context which can resolve references
* the type of the evaluation result is expected to be of a particular class and an exception will be thrown if it * to properties, methods, types, etc. The type of the evaluation result is
* expected to be of a particular class and an exception will be thrown if it
* is not and cannot be converted to that type. * is not and cannot be converted to that type.
* @param context the context in which to evaluate the expression * @param context the context in which to evaluate the expression
* @param desiredResultType the class the caller would like the result to be * @param desiredResultType the class the caller would like the result to be
@ -108,12 +113,13 @@ public interface Expression {
<T> T getValue(EvaluationContext context, @Nullable Class<T> desiredResultType) throws EvaluationException; <T> T getValue(EvaluationContext context, @Nullable Class<T> desiredResultType) throws EvaluationException;
/** /**
* Evaluate the expression in a specified context which can resolve references to properties, methods, types, etc - * Evaluate the expression in a specified context which can resolve references
* the type of the evaluation result is expected to be of a particular class and an exception will be thrown if it * to properties, methods, types, etc. The type of the evaluation result is
* is not and cannot be converted to that type. The supplied root object overrides any default specified on the * expected to be of a particular class and an exception will be thrown if it
* supplied context. * is not and cannot be converted to that type. The supplied root object
* overrides any default specified on the supplied context.
* @param context the context in which to evaluate the expression * @param context the context in which to evaluate the expression
* @param rootObject the root object against which properties/etc will be resolved * @param rootObject the root object against which to evaluate the expression
* @param desiredResultType the class the caller would like the result to be * @param desiredResultType the class the caller would like the result to be
* @return the evaluation result * @return the evaluation result
* @throws EvaluationException if there is a problem during evaluation * @throws EvaluationException if there is a problem during evaluation
@ -123,7 +129,7 @@ public interface Expression {
throws EvaluationException; throws EvaluationException;
/** /**
* Returns the most general type that can be passed to the {@link #setValue(EvaluationContext, Object)} * Return the most general type that can be passed to a {@link #setValue}
* method using the default context. * method using the default context.
* @return the most general type of value that can be set on this context * @return the most general type of value that can be set on this context
* @throws EvaluationException if there is a problem determining the type * @throws EvaluationException if there is a problem determining the type
@ -132,8 +138,8 @@ public interface Expression {
Class<?> getValueType() throws EvaluationException; Class<?> getValueType() throws EvaluationException;
/** /**
* Returns the most general type that can be passed to the {@link #setValue(EvaluationContext, Object)} * Return the most general type that can be passed to the
* method using the default context. * {@link #setValue(Object, Object)} method using the default context.
* @param rootObject the root object against which to evaluate the expression * @param rootObject the root object against which to evaluate the expression
* @return the most general type of value that can be set on this context * @return the most general type of value that can be set on this context
* @throws EvaluationException if there is a problem determining the type * @throws EvaluationException if there is a problem determining the type
@ -142,8 +148,8 @@ public interface Expression {
Class<?> getValueType(Object rootObject) throws EvaluationException; Class<?> getValueType(Object rootObject) throws EvaluationException;
/** /**
* Returns the most general type that can be passed to the {@link #setValue(EvaluationContext, Object)} * Return the most general type that can be passed to the
* method for the given context. * {@link #setValue(EvaluationContext, Object)} method for the given context.
* @param context the context in which to evaluate the expression * @param context the context in which to evaluate the expression
* @return the most general type of value that can be set on this context * @return the most general type of value that can be set on this context
* @throws EvaluationException if there is a problem determining the type * @throws EvaluationException if there is a problem determining the type
@ -152,8 +158,9 @@ public interface Expression {
Class<?> getValueType(EvaluationContext context) throws EvaluationException; Class<?> getValueType(EvaluationContext context) throws EvaluationException;
/** /**
* Returns the most general type that can be passed to the {@link #setValue(EvaluationContext, Object)} * Return the most general type that can be passed to the
* method for the given context. The supplied root object overrides any specified in the context. * {@link #setValue(EvaluationContext, Object, Object)} method for the given
* context. The supplied root object overrides any specified in the context.
* @param context the context in which to evaluate the expression * @param context the context in which to evaluate the expression
* @param rootObject the root object against which to evaluate the expression * @param rootObject the root object against which to evaluate the expression
* @return the most general type of value that can be set on this context * @return the most general type of value that can be set on this context
@ -163,40 +170,41 @@ public interface Expression {
Class<?> getValueType(EvaluationContext context, Object rootObject) throws EvaluationException; Class<?> getValueType(EvaluationContext context, Object rootObject) throws EvaluationException;
/** /**
* Returns the most general type that can be passed to the {@link #setValue(EvaluationContext, Object)} * Return the most general type that can be passed to a {@link #setValue}
* method using the default context. * method using the default context.
* @return a type descriptor for the most general type of value that can be set on this context * @return a type descriptor for values that can be set on this context
* @throws EvaluationException if there is a problem determining the type * @throws EvaluationException if there is a problem determining the type
*/ */
@Nullable @Nullable
TypeDescriptor getValueTypeDescriptor() throws EvaluationException; TypeDescriptor getValueTypeDescriptor() throws EvaluationException;
/** /**
* Returns the most general type that can be passed to the {@link #setValue(EvaluationContext, Object)} * Return the most general type that can be passed to the
* method using the default context. * {@link #setValue(Object, Object)} method using the default context.
* @param rootObject the root object against which to evaluate the expression * @param rootObject the root object against which to evaluate the expression
* @return a type descriptor for the most general type of value that can be set on this context * @return a type descriptor for values that can be set on this context
* @throws EvaluationException if there is a problem determining the type * @throws EvaluationException if there is a problem determining the type
*/ */
@Nullable @Nullable
TypeDescriptor getValueTypeDescriptor(Object rootObject) throws EvaluationException; TypeDescriptor getValueTypeDescriptor(Object rootObject) throws EvaluationException;
/** /**
* Returns the most general type that can be passed to the {@link #setValue(EvaluationContext, Object)} * Return the most general type that can be passed to the
* method for the given context. * {@link #setValue(EvaluationContext, Object)} method for the given context.
* @param context the context in which to evaluate the expression * @param context the context in which to evaluate the expression
* @return a type descriptor for the most general type of value that can be set on this context * @return a type descriptor for values that can be set on this context
* @throws EvaluationException if there is a problem determining the type * @throws EvaluationException if there is a problem determining the type
*/ */
@Nullable @Nullable
TypeDescriptor getValueTypeDescriptor(EvaluationContext context) throws EvaluationException; TypeDescriptor getValueTypeDescriptor(EvaluationContext context) throws EvaluationException;
/** /**
* Returns the most general type that can be passed to the {@link #setValue(EvaluationContext, Object)} * Return the most general type that can be passed to the
* method for the given context. The supplied root object overrides any specified in the context. * {@link #setValue(EvaluationContext, Object, Object)} method for the given
* context. The supplied root object overrides any specified in the context.
* @param context the context in which to evaluate the expression * @param context the context in which to evaluate the expression
* @param rootObject the root object against which to evaluate the expression * @param rootObject the root object against which to evaluate the expression
* @return a type descriptor for the most general type of value that can be set on this context * @return a type descriptor for values that can be set on this context
* @throws EvaluationException if there is a problem determining the type * @throws EvaluationException if there is a problem determining the type
*/ */
@Nullable @Nullable
@ -205,7 +213,7 @@ public interface Expression {
/** /**
* Determine if an expression can be written to, i.e. setValue() can be called. * Determine if an expression can be written to, i.e. setValue() can be called.
* @param rootObject the root object against which to evaluate the expression * @param rootObject the root object against which to evaluate the expression
* @return true if the expression is writable * @return {@code true} if the expression is writable; {@code false} otherwise
* @throws EvaluationException if there is a problem determining if it is writable * @throws EvaluationException if there is a problem determining if it is writable
*/ */
boolean isWritable(Object rootObject) throws EvaluationException; boolean isWritable(Object rootObject) throws EvaluationException;
@ -213,7 +221,7 @@ public interface Expression {
/** /**
* Determine if an expression can be written to, i.e. setValue() can be called. * Determine if an expression can be written to, i.e. setValue() can be called.
* @param context the context in which the expression should be checked * @param context the context in which the expression should be checked
* @return true if the expression is writable * @return {@code true} if the expression is writable; {@code false} otherwise
* @throws EvaluationException if there is a problem determining if it is writable * @throws EvaluationException if there is a problem determining if it is writable
*/ */
boolean isWritable(EvaluationContext context) throws EvaluationException; boolean isWritable(EvaluationContext context) throws EvaluationException;
@ -223,7 +231,7 @@ public interface Expression {
* The supplied root object overrides any specified in the context. * The supplied root object overrides any specified in the context.
* @param context the context in which the expression should be checked * @param context the context in which the expression should be checked
* @param rootObject the root object against which to evaluate the expression * @param rootObject the root object against which to evaluate the expression
* @return true if the expression is writable * @return {@code true} if the expression is writable; {@code false} otherwise
* @throws EvaluationException if there is a problem determining if it is writable * @throws EvaluationException if there is a problem determining if it is writable
*/ */
boolean isWritable(EvaluationContext context, Object rootObject) throws EvaluationException; boolean isWritable(EvaluationContext context, Object rootObject) throws EvaluationException;

22
spring-expression/src/main/java/org/springframework/expression/spel/standard/SpelExpression.java
Unescape View File

@ -115,7 +115,6 @@ public class SpelExpression implements Expression {
@Override @Override
public Object getValue() throws EvaluationException { public Object getValue() throws EvaluationException {
Object result;
if (this.compiledAst != null) { if (this.compiledAst != null) {
try { try {
TypedValue contextRoot = TypedValue contextRoot =
@ -135,8 +134,9 @@ public class SpelExpression implements Expression {
} }
} }
} }
ExpressionState expressionState = new ExpressionState(getEvaluationContext(), this.configuration); ExpressionState expressionState = new ExpressionState(getEvaluationContext(), this.configuration);
result = this.ast.getValue(expressionState); Object result = this.ast.getValue(expressionState);
checkCompile(expressionState); checkCompile(expressionState);
return result; return result;
} }
@ -170,6 +170,7 @@ public class SpelExpression implements Expression {
} }
} }
} }
ExpressionState expressionState = new ExpressionState(getEvaluationContext(), this.configuration); ExpressionState expressionState = new ExpressionState(getEvaluationContext(), this.configuration);
TypedValue typedResultValue = this.ast.getTypedValue(expressionState); TypedValue typedResultValue = this.ast.getTypedValue(expressionState);
checkCompile(expressionState); checkCompile(expressionState);
@ -179,7 +180,6 @@ public class SpelExpression implements Expression {
@Override @Override
public Object getValue(Object rootObject) throws EvaluationException { public Object getValue(Object rootObject) throws EvaluationException {
Object result;
if (this.compiledAst != null) { if (this.compiledAst != null) {
try { try {
return this.compiledAst.getValue(rootObject, evaluationContext); return this.compiledAst.getValue(rootObject, evaluationContext);
@ -196,9 +196,10 @@ public class SpelExpression implements Expression {
} }
} }
} }
ExpressionState expressionState = ExpressionState expressionState =
new ExpressionState(getEvaluationContext(), toTypedValue(rootObject), this.configuration); new ExpressionState(getEvaluationContext(), toTypedValue(rootObject), this.configuration);
result = this.ast.getValue(expressionState); Object result = this.ast.getValue(expressionState);
checkCompile(expressionState); checkCompile(expressionState);
return result; return result;
} }
@ -229,6 +230,7 @@ public class SpelExpression implements Expression {
} }
} }
} }
ExpressionState expressionState = ExpressionState expressionState =
new ExpressionState(getEvaluationContext(), toTypedValue(rootObject), this.configuration); new ExpressionState(getEvaluationContext(), toTypedValue(rootObject), this.configuration);
TypedValue typedResultValue = this.ast.getTypedValue(expressionState); TypedValue typedResultValue = this.ast.getTypedValue(expressionState);
@ -240,7 +242,8 @@ public class SpelExpression implements Expression {
@Override @Override
public Object getValue(EvaluationContext context) throws EvaluationException { public Object getValue(EvaluationContext context) throws EvaluationException {
Assert.notNull(context, "EvaluationContext is required"); Assert.notNull(context, "EvaluationContext is required");
if (compiledAst!= null) {
if (this.compiledAst != null) {
try { try {
TypedValue contextRoot = context.getRootObject(); TypedValue contextRoot = context.getRootObject();
return this.compiledAst.getValue(contextRoot.getValue(), context); return this.compiledAst.getValue(contextRoot.getValue(), context);
@ -257,6 +260,7 @@ public class SpelExpression implements Expression {
} }
} }
} }
ExpressionState expressionState = new ExpressionState(context, this.configuration); ExpressionState expressionState = new ExpressionState(context, this.configuration);
Object result = this.ast.getValue(expressionState); Object result = this.ast.getValue(expressionState);
checkCompile(expressionState); checkCompile(expressionState);
@ -266,6 +270,8 @@ public class SpelExpression implements Expression {
@SuppressWarnings("unchecked") @SuppressWarnings("unchecked")
@Override @Override
public <T> T getValue(EvaluationContext context, @Nullable Class<T> expectedResultType) throws EvaluationException { public <T> T getValue(EvaluationContext context, @Nullable Class<T> expectedResultType) throws EvaluationException {
Assert.notNull(context, "EvaluationContext is required");
if (this.compiledAst != null) { if (this.compiledAst != null) {
try { try {
TypedValue contextRoot = context.getRootObject(); TypedValue contextRoot = context.getRootObject();
@ -289,6 +295,7 @@ public class SpelExpression implements Expression {
} }
} }
} }
ExpressionState expressionState = new ExpressionState(context, this.configuration); ExpressionState expressionState = new ExpressionState(context, this.configuration);
TypedValue typedResultValue = this.ast.getTypedValue(expressionState); TypedValue typedResultValue = this.ast.getTypedValue(expressionState);
checkCompile(expressionState); checkCompile(expressionState);
@ -298,6 +305,7 @@ public class SpelExpression implements Expression {
@Override @Override
public Object getValue(EvaluationContext context, Object rootObject) throws EvaluationException { public Object getValue(EvaluationContext context, Object rootObject) throws EvaluationException {
Assert.notNull(context, "EvaluationContext is required"); Assert.notNull(context, "EvaluationContext is required");
if (this.compiledAst != null) { if (this.compiledAst != null) {
try { try {
return this.compiledAst.getValue(rootObject,context); return this.compiledAst.getValue(rootObject,context);
@ -314,6 +322,7 @@ public class SpelExpression implements Expression {
} }
} }
} }
ExpressionState expressionState = new ExpressionState(context, toTypedValue(rootObject), this.configuration); ExpressionState expressionState = new ExpressionState(context, toTypedValue(rootObject), this.configuration);
Object result = this.ast.getValue(expressionState); Object result = this.ast.getValue(expressionState);
checkCompile(expressionState); checkCompile(expressionState);
@ -325,6 +334,8 @@ public class SpelExpression implements Expression {
public <T> T getValue(EvaluationContext context, Object rootObject, @Nullable Class<T> expectedResultType) public <T> T getValue(EvaluationContext context, Object rootObject, @Nullable Class<T> expectedResultType)
throws EvaluationException { throws EvaluationException {
Assert.notNull(context, "EvaluationContext is required");
if (this.compiledAst != null) { if (this.compiledAst != null) {
try { try {
Object result = this.compiledAst.getValue(rootObject, context); Object result = this.compiledAst.getValue(rootObject, context);
@ -347,6 +358,7 @@ public class SpelExpression implements Expression {
} }
} }
} }
ExpressionState expressionState = new ExpressionState(context, toTypedValue(rootObject), this.configuration); ExpressionState expressionState = new ExpressionState(context, toTypedValue(rootObject), this.configuration);
TypedValue typedResultValue = this.ast.getTypedValue(expressionState); TypedValue typedResultValue = this.ast.getTypedValue(expressionState);
checkCompile(expressionState); checkCompile(expressionState);

19
spring-expression/src/test/java/org/springframework/expression/spel/SpelCompilationCoverageTests.java
Unescape View File

@ -474,7 +474,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests {
expression = parser.parseExpression("T(Integer).valueOf(42)"); expression = parser.parseExpression("T(Integer).valueOf(42)");
expression.getValue(Integer.class); expression.getValue(Integer.class);
assertCanCompile(expression); assertCanCompile(expression);
assertEquals(new Integer(42), expression.getValue(new StandardEvaluationContext(), Integer.class)); assertEquals(new Integer(42), expression.getValue(Integer.class));
// Code gen is different for -1 .. 6 because there are bytecode instructions specifically for those // Code gen is different for -1 .. 6 because there are bytecode instructions specifically for those
// values // values
@ -853,9 +853,9 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests {
assertEquals("4.0", expression.getValue(ctx).toString()); assertEquals("4.0", expression.getValue(ctx).toString());
} }
// Confirms visibility of what is being called.
@Test @Test
public void functionReferenceVisibility_SPR12359() throws Exception { public void functionReferenceVisibility_SPR12359() throws Exception {
// Confirms visibility of what is being called.
StandardEvaluationContext context = new StandardEvaluationContext(new Object[] {"1"}); StandardEvaluationContext context = new StandardEvaluationContext(new Object[] {"1"});
context.registerFunction("doCompare", SomeCompareMethod.class.getDeclaredMethod( context.registerFunction("doCompare", SomeCompareMethod.class.getDeclaredMethod(
"compare", Object.class, Object.class)); "compare", Object.class, Object.class));
@ -3120,8 +3120,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests {
// code generation for ENGLISH should notice there is something on the stack that // code generation for ENGLISH should notice there is something on the stack that
// is not required and pop it off. // is not required and pop it off.
expression = parser.parseExpression("#userId.toString().toLowerCase(T(java.util.Locale).ENGLISH)"); expression = parser.parseExpression("#userId.toString().toLowerCase(T(java.util.Locale).ENGLISH)");
StandardEvaluationContext context = StandardEvaluationContext context = new StandardEvaluationContext();
new StandardEvaluationContext();
context.setVariable("userId", "RoDnEy"); context.setVariable("userId", "RoDnEy");
assertEquals("rodney", expression.getValue(context)); assertEquals("rodney", expression.getValue(context));
assertCanCompile(expression); assertCanCompile(expression);
@ -3270,8 +3269,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests {
expression = parser.parseExpression("#it?.age.equals([0])"); expression = parser.parseExpression("#it?.age.equals([0])");
Person person = new Person(1); Person person = new Person(1);
StandardEvaluationContext context = StandardEvaluationContext context = new StandardEvaluationContext(new Object[] {person.getAge()});
new StandardEvaluationContext(new Object[] { person.getAge() });
context.setVariable("it", person); context.setVariable("it", person);
assertTrue(expression.getValue(context, Boolean.class)); assertTrue(expression.getValue(context, Boolean.class));
assertCanCompile(expression); assertCanCompile(expression);
@ -3279,8 +3277,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests {
// Variant of above more like what was in the bug report: // Variant of above more like what was in the bug report:
SpelExpressionParser parser = new SpelExpressionParser( SpelExpressionParser parser = new SpelExpressionParser(
new SpelParserConfiguration(SpelCompilerMode.IMMEDIATE, new SpelParserConfiguration(SpelCompilerMode.IMMEDIATE, getClass().getClassLoader()));
getClass().getClassLoader()));
SpelExpression ex = parser.parseRaw("#it?.age.equals([0])"); SpelExpression ex = parser.parseRaw("#it?.age.equals([0])");
context = new StandardEvaluationContext(new Object[] {person.getAge()}); context = new StandardEvaluationContext(new Object[] {person.getAge()});
@ -3290,15 +3287,13 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests {
PersonInOtherPackage person2 = new PersonInOtherPackage(1); PersonInOtherPackage person2 = new PersonInOtherPackage(1);
ex = parser.parseRaw("#it?.age.equals([0])"); ex = parser.parseRaw("#it?.age.equals([0])");
context = context = new StandardEvaluationContext(new Object[] {person2.getAge()});
new StandardEvaluationContext(new Object[] { person2.getAge() });
context.setVariable("it", person2); context.setVariable("it", person2);
assertTrue(ex.getValue(context, Boolean.class)); assertTrue(ex.getValue(context, Boolean.class));
assertTrue(ex.getValue(context, Boolean.class)); assertTrue(ex.getValue(context, Boolean.class));
ex = parser.parseRaw("#it?.age.equals([0])"); ex = parser.parseRaw("#it?.age.equals([0])");
context = context = new StandardEvaluationContext(new Object[] {person2.getAge()});
new StandardEvaluationContext(new Object[] { person2.getAge() });
context.setVariable("it", person2); context.setVariable("it", person2);
assertTrue((Boolean) ex.getValue(context)); assertTrue((Boolean) ex.getValue(context));
assertTrue((Boolean) ex.getValue(context)); assertTrue((Boolean) ex.getValue(context));

Write Preview
Loading…
Cancel
Save