From 38cd1ecff49c879577cc6f2ceba074173f9fafe0 Mon Sep 17 00:00:00 2001 From: Andy Clement Date: Tue, 1 Nov 2016 21:42:23 +0100 Subject: [PATCH] Rework compilation of OpNE/OpEQ SpEL operators For SPR-14863 we need to adjust the code generation for OpNE to use !x.equals(y) rather than x!=y. There are also further cases in the equalityCheck() code in Operator that were not being handled in the compilation case (when comparators are used for example). This latter issue also affects OpEQ. Rather than add yet more bytecode generation, both OpNE and OpEQ generateCode() methods have been simplified. The generated code now delegates to equalityCheck() in Operator which is exactly what the interpreted case does. This ensures that the compiled code continues to behave just like the interpreted case. It ensures changes to the interpreted case are automatically picked up for the compiled case. It makes the bytecode generation simpler. The benefit of compilation of SpEL expressions is to avoid slow reflective calls - that doesn't apply for a basic (in)equality test so there is no need to go crazy in bytecode gen. Issue: SPR-14863 (cherry picked from commit 9000acd) --- .../expression/spel/CodeFlow.java | 71 +- .../expression/spel/ast/OpEQ.java | 103 +- .../expression/spel/ast/OpNE.java | 80 +- .../expression/spel/ast/Operator.java | 18 +- .../spel/SpelCompilationCoverageTests.java | 2465 +++++++++-------- 5 files changed, 1425 insertions(+), 1312 deletions(-) diff --git a/spring-expression/src/main/java/org/springframework/expression/spel/CodeFlow.java b/spring-expression/src/main/java/org/springframework/expression/spel/CodeFlow.java index decb2f1cb4..083a7d0455 100644 --- a/spring-expression/src/main/java/org/springframework/expression/spel/CodeFlow.java +++ b/spring-expression/src/main/java/org/springframework/expression/spel/CodeFlow.java @@ -28,15 +28,28 @@ import org.springframework.asm.Opcodes; import org.springframework.util.Assert; /** - * Manages the class being generated by the compilation process. It records - * intermediate compilation state as the bytecode is generated. It also includes - * various bytecode generation helper functions. + * Manages the class being generated by the compilation process. + * + *

Records intermediate compilation state as the bytecode is generated. + * Also includes various bytecode generation helper functions. * * @author Andy Clement + * @author Juergen Hoeller * @since 4.1 */ public class CodeFlow implements Opcodes { + /** + * Name of the class being generated. Typically used when generating code + * that accesses freshly generated fields on the generated type. + */ + private final String className; + + /** + * The current class being generated. + */ + private final ClassWriter classWriter; + /** * Record the type of what is on top of the bytecode stack (i.e. the type of the * output from the previous expression component). New scopes are used to evaluate @@ -45,17 +58,12 @@ public class CodeFlow implements Opcodes { */ private final Stack> compilationScopes; - /** - * The current class being generated - */ - private ClassWriter cw; - /** * As SpEL ast nodes are called to generate code for the main evaluation method * they can register to add a field to this class. Any registered FieldAdders * will be called after the main evaluation function has finished being generated. */ - private List fieldAdders = null; + private List fieldAdders; /** * As SpEL ast nodes are called to generate code for the main evaluation method @@ -63,13 +71,7 @@ public class CodeFlow implements Opcodes { * registered ClinitAdders will be called after the main evaluation function * has finished being generated. */ - private List clinitAdders = null; - - /** - * Name of the class being generated. Typically used when generating code - * that accesses freshly generated fields on the generated type. - */ - private String clazzName; + private List clinitAdders; /** * When code generation requires holding a value in a class level field, this @@ -83,13 +85,20 @@ public class CodeFlow implements Opcodes { */ private int nextFreeVariableId = 1; - public CodeFlow(String clazzName, ClassWriter cw) { + + /** + * Construct a new {@code CodeFlow} for the given class. + * @param className the name of the class + * @param classWriter the corresponding ASM {@code ClassWriter} + */ + public CodeFlow(String className, ClassWriter classWriter) { + this.className = className; + this.classWriter = classWriter; this.compilationScopes = new Stack>(); this.compilationScopes.add(new ArrayList()); - this.cw = cw; - this.clazzName = clazzName; } + /** * Push the byte code to load the target (i.e. what was passed as the first argument * to CompiledExpression.getValue(target, context)) @@ -99,6 +108,16 @@ public class CodeFlow implements Opcodes { mv.visitVarInsn(ALOAD, 1); } + /** + * Push the bytecode to load the EvaluationContext (the second parameter passed to + * the compiled expression method). + * @param mv the visitor into which the load instruction should be inserted + * @since 4.3.4 + */ + public void loadEvaluationContext(MethodVisitor mv) { + mv.visitVarInsn(ALOAD, 2); + } + /** * Record the descriptor for the most recently evaluated expression element. * @param descriptor type descriptor for most recently evaluated element @@ -155,18 +174,18 @@ public class CodeFlow implements Opcodes { public void finish() { if (this.fieldAdders != null) { for (FieldAdder fieldAdder : this.fieldAdders) { - fieldAdder.generateField(cw,this); + fieldAdder.generateField(this.classWriter, this); } } if (this.clinitAdders != null) { - MethodVisitor mv = cw.visitMethod(ACC_PUBLIC | ACC_STATIC, "", "()V", null, null); + MethodVisitor mv = this.classWriter.visitMethod(ACC_PUBLIC | ACC_STATIC, "", "()V", null, null); mv.visitCode(); - this.nextFreeVariableId = 0; // To 0 because there is no 'this' in a clinit + this.nextFreeVariableId = 0; // to 0 because there is no 'this' in a clinit for (ClinitAdder clinitAdder : this.clinitAdders) { clinitAdder.generateCode(mv, this); } mv.visitInsn(RETURN); - mv.visitMaxs(0,0); // not supplied due to COMPUTE_MAXS + mv.visitMaxs(0,0); // not supplied due to COMPUTE_MAXS mv.visitEnd(); } } @@ -204,18 +223,18 @@ public class CodeFlow implements Opcodes { } public String getClassName() { - return this.clazzName; + return this.className; } @Deprecated public String getClassname() { - return this.clazzName; + return this.className; } /** * Insert any necessary cast and value call to convert from a boxed type to a - * primitive value + * primitive value. * @param mv the method visitor into which instructions should be inserted * @param ch the primitive type desired as output * @param stackDescriptor the descriptor of the type on top of the stack diff --git a/spring-expression/src/main/java/org/springframework/expression/spel/ast/OpEQ.java b/spring-expression/src/main/java/org/springframework/expression/spel/ast/OpEQ.java index f40bbf3014..4bca782289 100644 --- a/spring-expression/src/main/java/org/springframework/expression/spel/ast/OpEQ.java +++ b/spring-expression/src/main/java/org/springframework/expression/spel/ast/OpEQ.java @@ -1,5 +1,5 @@ /* - * Copyright 2002-2014 the original author or authors. + * Copyright 2002-2016 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -16,8 +16,8 @@ package org.springframework.expression.spel.ast; -import org.springframework.asm.Label; import org.springframework.asm.MethodVisitor; +import org.springframework.expression.EvaluationContext; import org.springframework.expression.EvaluationException; import org.springframework.expression.spel.CodeFlow; import org.springframework.expression.spel.ExpressionState; @@ -43,105 +43,52 @@ public class OpEQ extends Operator { Object right = getRightOperand().getValueInternal(state).getValue(); this.leftActualDescriptor = CodeFlow.toDescriptorFromObject(left); this.rightActualDescriptor = CodeFlow.toDescriptorFromObject(right); - return BooleanTypedValue.forValue(equalityCheck(state, left, right)); + return BooleanTypedValue.forValue( + equalityCheck(state.getEvaluationContext(), left, right)); } - + // This check is different to the one in the other numeric operators (OpLt/etc) // because it allows for simple object comparison @Override public boolean isCompilable() { SpelNodeImpl left = getLeftOperand(); - SpelNodeImpl right= getRightOperand(); + SpelNodeImpl right = getRightOperand(); if (!left.isCompilable() || !right.isCompilable()) { return false; } String leftDesc = left.exitTypeDescriptor; String rightDesc = right.exitTypeDescriptor; - DescriptorComparison dc = DescriptorComparison.checkNumericCompatibility( - leftDesc, rightDesc, this.leftActualDescriptor, this.rightActualDescriptor); + DescriptorComparison dc = DescriptorComparison.checkNumericCompatibility(leftDesc, + rightDesc, this.leftActualDescriptor, this.rightActualDescriptor); return (!dc.areNumbers || dc.areCompatible); } - - + @Override public void generateCode(MethodVisitor mv, CodeFlow cf) { + cf.loadEvaluationContext(mv); String leftDesc = getLeftOperand().exitTypeDescriptor; String rightDesc = getRightOperand().exitTypeDescriptor; - Label elseTarget = new Label(); - Label endOfIf = new Label(); boolean leftPrim = CodeFlow.isPrimitive(leftDesc); boolean rightPrim = CodeFlow.isPrimitive(rightDesc); - DescriptorComparison dc = DescriptorComparison.checkNumericCompatibility( - leftDesc, rightDesc, this.leftActualDescriptor, this.rightActualDescriptor); - - if (dc.areNumbers && dc.areCompatible) { - char targetType = dc.compatibleType; - getLeftOperand().generateCode(mv, cf); - if (!leftPrim) { - CodeFlow.insertUnboxInsns(mv, targetType, leftDesc); - } - cf.enterCompilationScope(); - getRightOperand().generateCode(mv, cf); - cf.exitCompilationScope(); - if (!rightPrim) { - CodeFlow.insertUnboxInsns(mv, targetType, rightDesc); - } - // assert: SpelCompiler.boxingCompatible(leftDesc, rightDesc) - if (targetType == 'D') { - mv.visitInsn(DCMPL); - mv.visitJumpInsn(IFNE, elseTarget); - } - else if (targetType == 'F') { - mv.visitInsn(FCMPL); - mv.visitJumpInsn(IFNE, elseTarget); - } - else if (targetType == 'J') { - mv.visitInsn(LCMP); - mv.visitJumpInsn(IFNE, elseTarget); - } - else if (targetType == 'I' || targetType == 'Z') { - mv.visitJumpInsn(IF_ICMPNE, elseTarget); - } - else { - throw new IllegalStateException("Unexpected descriptor " + leftDesc); - } + cf.enterCompilationScope(); + getLeftOperand().generateCode(mv, cf); + cf.exitCompilationScope(); + if (leftPrim) { + CodeFlow.insertBoxIfNecessary(mv, leftDesc.charAt(0)); } - else { - getLeftOperand().generateCode(mv, cf); - if (leftPrim) { - CodeFlow.insertBoxIfNecessary(mv, leftDesc.charAt(0)); - } - getRightOperand().generateCode(mv, cf); - if (rightPrim) { - CodeFlow.insertBoxIfNecessary(mv, rightDesc.charAt(0)); - } - Label leftNotNull = new Label(); - mv.visitInsn(DUP_X1); // dup right on the top of the stack - mv.visitJumpInsn(IFNONNULL, leftNotNull); - // Right is null! - mv.visitInsn(SWAP); - mv.visitInsn(POP); // remove it - Label rightNotNull = new Label(); - mv.visitJumpInsn(IFNONNULL, rightNotNull); - // Left is null too - mv.visitInsn(ICONST_1); - mv.visitJumpInsn(GOTO, endOfIf); - mv.visitLabel(rightNotNull); - mv.visitInsn(ICONST_0); - mv.visitJumpInsn(GOTO, endOfIf); - mv.visitLabel(leftNotNull); - mv.visitMethodInsn(INVOKEVIRTUAL, "java/lang/Object", "equals", "(Ljava/lang/Object;)Z", false); - mv.visitLabel(endOfIf); - cf.pushDescriptor("Z"); - return; + cf.enterCompilationScope(); + getRightOperand().generateCode(mv, cf); + cf.exitCompilationScope(); + if (rightPrim) { + CodeFlow.insertBoxIfNecessary(mv, rightDesc.charAt(0)); } - mv.visitInsn(ICONST_1); - mv.visitJumpInsn(GOTO, endOfIf); - mv.visitLabel(elseTarget); - mv.visitInsn(ICONST_0); - mv.visitLabel(endOfIf); + + String operatorClassName = Operator.class.getName().replace('.', '/'); + String evaluationContextClassName = EvaluationContext.class.getName().replace('.', '/'); + mv.visitMethodInsn(INVOKESTATIC, operatorClassName, "equalityCheck", + "(L" + evaluationContextClassName + ";Ljava/lang/Object;Ljava/lang/Object;)Z", false); cf.pushDescriptor("Z"); } diff --git a/spring-expression/src/main/java/org/springframework/expression/spel/ast/OpNE.java b/spring-expression/src/main/java/org/springframework/expression/spel/ast/OpNE.java index 4f96b3bbdd..b2b3c2b3fa 100644 --- a/spring-expression/src/main/java/org/springframework/expression/spel/ast/OpNE.java +++ b/spring-expression/src/main/java/org/springframework/expression/spel/ast/OpNE.java @@ -18,6 +18,7 @@ package org.springframework.expression.spel.ast; import org.springframework.asm.Label; import org.springframework.asm.MethodVisitor; +import org.springframework.expression.EvaluationContext; import org.springframework.expression.EvaluationException; import org.springframework.expression.spel.CodeFlow; import org.springframework.expression.spel.ExpressionState; @@ -43,7 +44,8 @@ public class OpNE extends Operator { Object right = getRightOperand().getValueInternal(state).getValue(); this.leftActualDescriptor = CodeFlow.toDescriptorFromObject(left); this.rightActualDescriptor = CodeFlow.toDescriptorFromObject(right); - return BooleanTypedValue.forValue(!equalityCheck(state, left, right)); + return BooleanTypedValue.forValue( + !equalityCheck(state.getEvaluationContext(), left, right)); } // This check is different to the one in the other numeric operators (OpLt/etc) @@ -51,72 +53,54 @@ public class OpNE extends Operator { @Override public boolean isCompilable() { SpelNodeImpl left = getLeftOperand(); - SpelNodeImpl right= getRightOperand(); + SpelNodeImpl right = getRightOperand(); if (!left.isCompilable() || !right.isCompilable()) { return false; } String leftDesc = left.exitTypeDescriptor; String rightDesc = right.exitTypeDescriptor; - DescriptorComparison dc = DescriptorComparison.checkNumericCompatibility( - leftDesc, rightDesc, this.leftActualDescriptor, this.rightActualDescriptor); + DescriptorComparison dc = DescriptorComparison.checkNumericCompatibility(leftDesc, + rightDesc, this.leftActualDescriptor, this.rightActualDescriptor); return (!dc.areNumbers || dc.areCompatible); } - + @Override public void generateCode(MethodVisitor mv, CodeFlow cf) { + cf.loadEvaluationContext(mv); String leftDesc = getLeftOperand().exitTypeDescriptor; String rightDesc = getRightOperand().exitTypeDescriptor; - Label elseTarget = new Label(); - Label endOfIf = new Label(); boolean leftPrim = CodeFlow.isPrimitive(leftDesc); boolean rightPrim = CodeFlow.isPrimitive(rightDesc); - DescriptorComparison dc = DescriptorComparison.checkNumericCompatibility( - leftDesc, rightDesc, this.leftActualDescriptor, this.rightActualDescriptor); - - if (dc.areNumbers && dc.areCompatible) { - char targetType = dc.compatibleType; - getLeftOperand().generateCode(mv, cf); - if (!leftPrim) { - CodeFlow.insertUnboxInsns(mv, targetType, leftDesc); - } - cf.enterCompilationScope(); - getRightOperand().generateCode(mv, cf); - cf.exitCompilationScope(); - if (!rightPrim) { - CodeFlow.insertUnboxInsns(mv, targetType, rightDesc); - } - // assert: SpelCompiler.boxingCompatible(leftDesc, rightDesc) - if (targetType == 'D') { - mv.visitInsn(DCMPL); - mv.visitJumpInsn(IFEQ, elseTarget); - } - else if (targetType == 'F') { - mv.visitInsn(FCMPL); - mv.visitJumpInsn(IFEQ, elseTarget); - } - else if (targetType == 'J') { - mv.visitInsn(LCMP); - mv.visitJumpInsn(IFEQ, elseTarget); - } - else if (targetType == 'I' || targetType == 'Z') { - mv.visitJumpInsn(IF_ICMPEQ, elseTarget); - } - else { - throw new IllegalStateException("Unexpected descriptor " + leftDesc); - } + cf.enterCompilationScope(); + getLeftOperand().generateCode(mv, cf); + cf.exitCompilationScope(); + if (leftPrim) { + CodeFlow.insertBoxIfNecessary(mv, leftDesc.charAt(0)); } - else { - getLeftOperand().generateCode(mv, cf); - getRightOperand().generateCode(mv, cf); - mv.visitJumpInsn(IF_ACMPEQ, elseTarget); + cf.enterCompilationScope(); + getRightOperand().generateCode(mv, cf); + cf.exitCompilationScope(); + if (rightPrim) { + CodeFlow.insertBoxIfNecessary(mv, rightDesc.charAt(0)); } + + String operatorClassName = Operator.class.getName().replace('.', '/'); + String evaluationContextClassName = EvaluationContext.class.getName().replace('.', '/'); + mv.visitMethodInsn(INVOKESTATIC, operatorClassName, "equalityCheck", + "(L" + evaluationContextClassName + ";Ljava/lang/Object;Ljava/lang/Object;)Z", false); + + // Invert the boolean + Label notZero = new Label(); + Label end = new Label(); + mv.visitJumpInsn(IFNE, notZero); mv.visitInsn(ICONST_1); - mv.visitJumpInsn(GOTO,endOfIf); - mv.visitLabel(elseTarget); + mv.visitJumpInsn(GOTO, end); + mv.visitLabel(notZero); mv.visitInsn(ICONST_0); - mv.visitLabel(endOfIf); + mv.visitLabel(end); + cf.pushDescriptor("Z"); } diff --git a/spring-expression/src/main/java/org/springframework/expression/spel/ast/Operator.java b/spring-expression/src/main/java/org/springframework/expression/spel/ast/Operator.java index 73ed4a75c7..a47b9a103c 100644 --- a/spring-expression/src/main/java/org/springframework/expression/spel/ast/Operator.java +++ b/spring-expression/src/main/java/org/springframework/expression/spel/ast/Operator.java @@ -21,8 +21,8 @@ import java.math.BigInteger; import org.springframework.asm.Label; import org.springframework.asm.MethodVisitor; +import org.springframework.expression.EvaluationContext; import org.springframework.expression.spel.CodeFlow; -import org.springframework.expression.spel.ExpressionState; import org.springframework.util.ClassUtils; import org.springframework.util.NumberUtils; import org.springframework.util.ObjectUtils; @@ -114,7 +114,9 @@ public abstract class Operator extends SpelNodeImpl { leftDesc, rightDesc, this.leftActualDescriptor, this.rightActualDescriptor); char targetType = dc.compatibleType; // CodeFlow.toPrimitiveTargetDesc(leftDesc); + cf.enterCompilationScope(); getLeftOperand().generateCode(mv, cf); + cf.exitCompilationScope(); if (unboxLeft) { CodeFlow.insertUnboxInsns(mv, targetType, leftDesc); } @@ -157,7 +159,17 @@ public abstract class Operator extends SpelNodeImpl { cf.pushDescriptor("Z"); } - protected boolean equalityCheck(ExpressionState state, Object left, Object right) { + + /** + * Perform an equality check for the given operand values. + *

This method is not just used for reflective comparisons in subclasses + * but also from compiled expression code, which is why it needs to be + * declared as {@code public static} here. + * @param context the current evaluation context + * @param left the left-hand operand value + * @param right the right-hand operand value + */ + public static boolean equalityCheck(EvaluationContext context, Object left, Object right) { if (left instanceof Number && right instanceof Number) { Number leftNumber = (Number) left; Number rightNumber = (Number) right; @@ -207,7 +219,7 @@ public abstract class Operator extends SpelNodeImpl { if (left instanceof Comparable && right instanceof Comparable) { Class ancestor = ClassUtils.determineCommonAncestor(left.getClass(), right.getClass()); if (ancestor != null && Comparable.class.isAssignableFrom(ancestor)) { - return (state.getTypeComparator().compare(left, right) == 0); + return (context.getTypeComparator().compare(left, right) == 0); } } diff --git a/spring-expression/src/test/java/org/springframework/expression/spel/SpelCompilationCoverageTests.java b/spring-expression/src/test/java/org/springframework/expression/spel/SpelCompilationCoverageTests.java index cfde694a64..9aef460db0 100644 --- a/spring-expression/src/test/java/org/springframework/expression/spel/SpelCompilationCoverageTests.java +++ b/spring-expression/src/test/java/org/springframework/expression/spel/SpelCompilationCoverageTests.java @@ -44,16 +44,14 @@ import org.springframework.expression.spel.testdata.PersonInOtherPackage; import static org.junit.Assert.*; /** - * Checks the behaviour of the SpelCompiler. This should cover compilation all compiled node types. + * Checks the behaviour of the SpelCompiler. + * This should cover compilation all compiled node types. * * @author Andy Clement * @since 4.1 */ public class SpelCompilationCoverageTests extends AbstractExpressionTests { - private Expression expression; - private SpelNodeImpl ast; - /* * Further TODOs for compilation: * @@ -118,67 +116,73 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { * Selection */ + + private Expression expression; + + private SpelNodeImpl ast; + + @Test public void typeReference() throws Exception { expression = parse("T(String)"); - assertEquals(String.class,expression.getValue()); + assertEquals(String.class, expression.getValue()); assertCanCompile(expression); - assertEquals(String.class,expression.getValue()); + assertEquals(String.class, expression.getValue()); expression = parse("T(java.io.IOException)"); - assertEquals(IOException.class,expression.getValue()); + assertEquals(IOException.class, expression.getValue()); assertCanCompile(expression); - assertEquals(IOException.class,expression.getValue()); + assertEquals(IOException.class, expression.getValue()); expression = parse("T(java.io.IOException[])"); - assertEquals(IOException[].class,expression.getValue()); + assertEquals(IOException[].class, expression.getValue()); assertCanCompile(expression); - assertEquals(IOException[].class,expression.getValue()); + assertEquals(IOException[].class, expression.getValue()); expression = parse("T(int[][])"); - assertEquals(int[][].class,expression.getValue()); + assertEquals(int[][].class, expression.getValue()); assertCanCompile(expression); - assertEquals(int[][].class,expression.getValue()); + assertEquals(int[][].class, expression.getValue()); expression = parse("T(int)"); - assertEquals(Integer.TYPE,expression.getValue()); + assertEquals(Integer.TYPE, expression.getValue()); assertCanCompile(expression); - assertEquals(Integer.TYPE,expression.getValue()); + assertEquals(Integer.TYPE, expression.getValue()); expression = parse("T(byte)"); - assertEquals(Byte.TYPE,expression.getValue()); + assertEquals(Byte.TYPE, expression.getValue()); assertCanCompile(expression); - assertEquals(Byte.TYPE,expression.getValue()); + assertEquals(Byte.TYPE, expression.getValue()); expression = parse("T(char)"); - assertEquals(Character.TYPE,expression.getValue()); + assertEquals(Character.TYPE, expression.getValue()); assertCanCompile(expression); - assertEquals(Character.TYPE,expression.getValue()); + assertEquals(Character.TYPE, expression.getValue()); expression = parse("T(short)"); - assertEquals(Short.TYPE,expression.getValue()); + assertEquals(Short.TYPE, expression.getValue()); assertCanCompile(expression); - assertEquals(Short.TYPE,expression.getValue()); + assertEquals(Short.TYPE, expression.getValue()); expression = parse("T(long)"); - assertEquals(Long.TYPE,expression.getValue()); + assertEquals(Long.TYPE, expression.getValue()); assertCanCompile(expression); - assertEquals(Long.TYPE,expression.getValue()); + assertEquals(Long.TYPE, expression.getValue()); expression = parse("T(float)"); - assertEquals(Float.TYPE,expression.getValue()); + assertEquals(Float.TYPE, expression.getValue()); assertCanCompile(expression); - assertEquals(Float.TYPE,expression.getValue()); + assertEquals(Float.TYPE, expression.getValue()); expression = parse("T(double)"); - assertEquals(Double.TYPE,expression.getValue()); + assertEquals(Double.TYPE, expression.getValue()); assertCanCompile(expression); - assertEquals(Double.TYPE,expression.getValue()); + assertEquals(Double.TYPE, expression.getValue()); expression = parse("T(boolean)"); - assertEquals(Boolean.TYPE,expression.getValue()); + assertEquals(Boolean.TYPE, expression.getValue()); assertCanCompile(expression); - assertEquals(Boolean.TYPE,expression.getValue()); + assertEquals(Boolean.TYPE, expression.getValue()); expression = parse("T(Missing)"); assertGetValueFail(expression); @@ -189,135 +193,135 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { @Test public void operatorInstanceOf() throws Exception { expression = parse("'xyz' instanceof T(String)"); - assertEquals(true,expression.getValue()); + assertEquals(true, expression.getValue()); assertCanCompile(expression); - assertEquals(true,expression.getValue()); + assertEquals(true, expression.getValue()); expression = parse("'xyz' instanceof T(Integer)"); - assertEquals(false,expression.getValue()); + assertEquals(false, expression.getValue()); assertCanCompile(expression); - assertEquals(false,expression.getValue()); + assertEquals(false, expression.getValue()); - List list = new ArrayList(); + List list = new ArrayList<>(); expression = parse("#root instanceof T(java.util.List)"); - assertEquals(true,expression.getValue(list)); + assertEquals(true, expression.getValue(list)); assertCanCompile(expression); - assertEquals(true,expression.getValue(list)); + assertEquals(true, expression.getValue(list)); - List[] arrayOfLists = new List[]{new ArrayList()}; + List[] arrayOfLists = new List[] {new ArrayList()}; expression = parse("#root instanceof T(java.util.List[])"); - assertEquals(true,expression.getValue(arrayOfLists)); + assertEquals(true, expression.getValue(arrayOfLists)); assertCanCompile(expression); - assertEquals(true,expression.getValue(arrayOfLists)); + assertEquals(true, expression.getValue(arrayOfLists)); - int[] intArray = new int[]{1,2,3}; + int[] intArray = new int[] {1,2,3}; expression = parse("#root instanceof T(int[])"); - assertEquals(true,expression.getValue(intArray)); + assertEquals(true, expression.getValue(intArray)); assertCanCompile(expression); - assertEquals(true,expression.getValue(intArray)); + assertEquals(true, expression.getValue(intArray)); String root = null; expression = parse("#root instanceof T(Integer)"); - assertEquals(false,expression.getValue(root)); + assertEquals(false, expression.getValue(root)); assertCanCompile(expression); - assertEquals(false,expression.getValue(root)); + assertEquals(false, expression.getValue(root)); // root still null expression = parse("#root instanceof T(java.lang.Object)"); - assertEquals(false,expression.getValue(root)); + assertEquals(false, expression.getValue(root)); assertCanCompile(expression); - assertEquals(false,expression.getValue(root)); + assertEquals(false, expression.getValue(root)); root = "howdy!"; expression = parse("#root instanceof T(java.lang.Object)"); - assertEquals(true,expression.getValue(root)); + assertEquals(true, expression.getValue(root)); assertCanCompile(expression); - assertEquals(true,expression.getValue(root)); + assertEquals(true, expression.getValue(root)); } @Test public void operatorInstanceOf_SPR14250() throws Exception { // primitive left operand - should get boxed, return true expression = parse("3 instanceof T(Integer)"); - assertEquals(true,expression.getValue()); + assertEquals(true, expression.getValue()); assertCanCompile(expression); - assertEquals(true,expression.getValue()); + assertEquals(true, expression.getValue()); // primitive left operand - should get boxed, return false expression = parse("3 instanceof T(String)"); - assertEquals(false,expression.getValue()); + assertEquals(false, expression.getValue()); assertCanCompile(expression); - assertEquals(false,expression.getValue()); - + assertEquals(false, expression.getValue()); + // double slot left operand - should get boxed, return false expression = parse("3.0d instanceof T(Integer)"); - assertEquals(false,expression.getValue()); + assertEquals(false, expression.getValue()); assertCanCompile(expression); - assertEquals(false,expression.getValue()); + assertEquals(false, expression.getValue()); // double slot left operand - should get boxed, return true expression = parse("3.0d instanceof T(Double)"); - assertEquals(true,expression.getValue()); + assertEquals(true, expression.getValue()); assertCanCompile(expression); - assertEquals(true,expression.getValue()); - + assertEquals(true, expression.getValue()); + // Only when the right hand operand is a direct type reference // will it be compilable. StandardEvaluationContext ctx = new StandardEvaluationContext(); ctx.setVariable("foo", String.class); expression = parse("3 instanceof #foo"); - assertEquals(false,expression.getValue(ctx)); + assertEquals(false, expression.getValue(ctx)); assertCantCompile(expression); // use of primitive as type for instanceof check - compilable // but always false expression = parse("3 instanceof T(int)"); - assertEquals(false,expression.getValue()); + assertEquals(false, expression.getValue()); assertCanCompile(expression); - assertEquals(false,expression.getValue()); - + assertEquals(false, expression.getValue()); + expression = parse("3 instanceof T(long)"); - assertEquals(false,expression.getValue()); + assertEquals(false, expression.getValue()); assertCanCompile(expression); - assertEquals(false,expression.getValue()); + assertEquals(false, expression.getValue()); } - + @Test public void stringLiteral() throws Exception { expression = parser.parseExpression("'abcde'"); - assertEquals("abcde",expression.getValue(new TestClass1(),String.class)); + assertEquals("abcde", expression.getValue(new TestClass1(), String.class)); assertCanCompile(expression); - String resultC = expression.getValue(new TestClass1(),String.class); - assertEquals("abcde",resultC); - assertEquals("abcde",expression.getValue(String.class)); - assertEquals("abcde",expression.getValue()); - assertEquals("abcde",expression.getValue(new StandardEvaluationContext())); + String resultC = expression.getValue(new TestClass1(), String.class); + assertEquals("abcde", resultC); + assertEquals("abcde", expression.getValue(String.class)); + assertEquals("abcde", expression.getValue()); + assertEquals("abcde", expression.getValue(new StandardEvaluationContext())); expression = parser.parseExpression("\"abcde\""); assertCanCompile(expression); - assertEquals("abcde",expression.getValue(String.class)); + assertEquals("abcde", expression.getValue(String.class)); } @Test public void nullLiteral() throws Exception { expression = parser.parseExpression("null"); - Object resultI = expression.getValue(new TestClass1(),Object.class); + Object resultI = expression.getValue(new TestClass1(), Object.class); assertCanCompile(expression); - Object resultC = expression.getValue(new TestClass1(),Object.class); - assertEquals(null,resultI); - assertEquals(null,resultC); - assertEquals(null,resultC); + Object resultC = expression.getValue(new TestClass1(), Object.class); + assertEquals(null, resultI); + assertEquals(null, resultC); + assertEquals(null, resultC); } @Test public void realLiteral() throws Exception { expression = parser.parseExpression("3.4d"); - double resultI = expression.getValue(new TestClass1(),Double.TYPE); + double resultI = expression.getValue(new TestClass1(), Double.TYPE); assertCanCompile(expression); - double resultC = expression.getValue(new TestClass1(),Double.TYPE); - assertEquals(3.4d,resultI,0.1d); - assertEquals(3.4d,resultC,0.1d); + double resultC = expression.getValue(new TestClass1(), Double.TYPE); + assertEquals(3.4d, resultI,0.1d); + assertEquals(3.4d, resultC,0.1d); - assertEquals(3.4d,expression.getValue()); + assertEquals(3.4d, expression.getValue()); } @SuppressWarnings("rawtypes") @@ -438,16 +442,16 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { @Test public void intLiteral() throws Exception { expression = parser.parseExpression("42"); - int resultI = expression.getValue(new TestClass1(),Integer.TYPE); + int resultI = expression.getValue(new TestClass1(), Integer.TYPE); assertCanCompile(expression); - int resultC = expression.getValue(new TestClass1(),Integer.TYPE); - assertEquals(42,resultI); - assertEquals(42,resultC); + int resultC = expression.getValue(new TestClass1(), Integer.TYPE); + assertEquals(42, resultI); + assertEquals(42, resultC); expression = parser.parseExpression("T(Integer).valueOf(42)"); expression.getValue(Integer.class); assertCanCompile(expression); - assertEquals(new Integer(42),expression.getValue(null,Integer.class)); + assertEquals(new Integer(42), expression.getValue(null, Integer.class)); // Code gen is different for -1 .. 6 because there are bytecode instructions specifically for those // values @@ -455,108 +459,108 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { // Not an int literal but an opminus with one operand: // expression = parser.parseExpression("-1"); // assertCanCompile(expression); -// assertEquals(-1,expression.getValue()); +// assertEquals(-1, expression.getValue()); expression = parser.parseExpression("0"); assertCanCompile(expression); - assertEquals(0,expression.getValue()); + assertEquals(0, expression.getValue()); expression = parser.parseExpression("2"); assertCanCompile(expression); - assertEquals(2,expression.getValue()); + assertEquals(2, expression.getValue()); expression = parser.parseExpression("7"); assertCanCompile(expression); - assertEquals(7,expression.getValue()); + assertEquals(7, expression.getValue()); } @Test public void longLiteral() throws Exception { expression = parser.parseExpression("99L"); - long resultI = expression.getValue(new TestClass1(),Long.TYPE); + long resultI = expression.getValue(new TestClass1(), Long.TYPE); assertCanCompile(expression); - long resultC = expression.getValue(new TestClass1(),Long.TYPE); - assertEquals(99L,resultI); - assertEquals(99L,resultC); + long resultC = expression.getValue(new TestClass1(), Long.TYPE); + assertEquals(99L, resultI); + assertEquals(99L, resultC); } @Test public void booleanLiteral() throws Exception { expression = parser.parseExpression("true"); - boolean resultI = expression.getValue(1,Boolean.TYPE); - assertEquals(true,resultI); + boolean resultI = expression.getValue(1, Boolean.TYPE); + assertEquals(true, resultI); assertTrue(SpelCompiler.compile(expression)); - boolean resultC = expression.getValue(1,Boolean.TYPE); - assertEquals(true,resultC); + boolean resultC = expression.getValue(1, Boolean.TYPE); + assertEquals(true, resultC); expression = parser.parseExpression("false"); - resultI = expression.getValue(1,Boolean.TYPE); - assertEquals(false,resultI); + resultI = expression.getValue(1, Boolean.TYPE); + assertEquals(false, resultI); assertTrue(SpelCompiler.compile(expression)); - resultC = expression.getValue(1,Boolean.TYPE); - assertEquals(false,resultC); + resultC = expression.getValue(1, Boolean.TYPE); + assertEquals(false, resultC); } @Test public void floatLiteral() throws Exception { expression = parser.parseExpression("3.4f"); - float resultI = expression.getValue(new TestClass1(),Float.TYPE); + float resultI = expression.getValue(new TestClass1(), Float.TYPE); assertCanCompile(expression); - float resultC = expression.getValue(new TestClass1(),Float.TYPE); - assertEquals(3.4f,resultI,0.1f); - assertEquals(3.4f,resultC,0.1f); + float resultC = expression.getValue(new TestClass1(), Float.TYPE); + assertEquals(3.4f, resultI,0.1f); + assertEquals(3.4f, resultC,0.1f); - assertEquals(3.4f,expression.getValue()); + assertEquals(3.4f, expression.getValue()); } @Test public void opOr() throws Exception { Expression expression = parser.parseExpression("false or false"); - boolean resultI = expression.getValue(1,Boolean.TYPE); + boolean resultI = expression.getValue(1, Boolean.TYPE); SpelCompiler.compile(expression); - boolean resultC = expression.getValue(1,Boolean.TYPE); - assertEquals(false,resultI); - assertEquals(false,resultC); + boolean resultC = expression.getValue(1, Boolean.TYPE); + assertEquals(false, resultI); + assertEquals(false, resultC); expression = parser.parseExpression("false or true"); - resultI = expression.getValue(1,Boolean.TYPE); + resultI = expression.getValue(1, Boolean.TYPE); assertCanCompile(expression); - resultC = expression.getValue(1,Boolean.TYPE); - assertEquals(true,resultI); - assertEquals(true,resultC); + resultC = expression.getValue(1, Boolean.TYPE); + assertEquals(true, resultI); + assertEquals(true, resultC); expression = parser.parseExpression("true or false"); - resultI = expression.getValue(1,Boolean.TYPE); + resultI = expression.getValue(1, Boolean.TYPE); assertCanCompile(expression); - resultC = expression.getValue(1,Boolean.TYPE); - assertEquals(true,resultI); - assertEquals(true,resultC); + resultC = expression.getValue(1, Boolean.TYPE); + assertEquals(true, resultI); + assertEquals(true, resultC); expression = parser.parseExpression("true or true"); - resultI = expression.getValue(1,Boolean.TYPE); + resultI = expression.getValue(1, Boolean.TYPE); assertCanCompile(expression); - resultC = expression.getValue(1,Boolean.TYPE); - assertEquals(true,resultI); - assertEquals(true,resultC); + resultC = expression.getValue(1, Boolean.TYPE); + assertEquals(true, resultI); + assertEquals(true, resultC); TestClass4 tc = new TestClass4(); expression = parser.parseExpression("getfalse() or gettrue()"); - resultI = expression.getValue(tc,Boolean.TYPE); + resultI = expression.getValue(tc, Boolean.TYPE); assertCanCompile(expression); - resultC = expression.getValue(tc,Boolean.TYPE); - assertEquals(true,resultI); - assertEquals(true,resultC); + resultC = expression.getValue(tc, Boolean.TYPE); + assertEquals(true, resultI); + assertEquals(true, resultC); // Can't compile this as we aren't going down the getfalse() branch in our evaluation expression = parser.parseExpression("gettrue() or getfalse()"); - resultI = expression.getValue(tc,Boolean.TYPE); + resultI = expression.getValue(tc, Boolean.TYPE); assertCantCompile(expression); expression = parser.parseExpression("getA() or getB()"); tc.a = true; tc.b = true; - resultI = expression.getValue(tc,Boolean.TYPE); + resultI = expression.getValue(tc, Boolean.TYPE); assertCantCompile(expression); // Haven't yet been into second branch tc.a = false; tc.b = true; - resultI = expression.getValue(tc,Boolean.TYPE); + resultI = expression.getValue(tc, Boolean.TYPE); assertCanCompile(expression); // Now been down both assertTrue(resultI); @@ -564,93 +568,93 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { expression = parse("#root or #root"); Object resultI2 = expression.getValue(b); assertCanCompile(expression); - assertFalse((Boolean)resultI2); - assertFalse((Boolean)expression.getValue(b)); + assertFalse((Boolean) resultI2); + assertFalse((Boolean) expression.getValue(b)); } @Test public void opAnd() throws Exception { Expression expression = parser.parseExpression("false and false"); - boolean resultI = expression.getValue(1,Boolean.TYPE); + boolean resultI = expression.getValue(1, Boolean.TYPE); SpelCompiler.compile(expression); - boolean resultC = expression.getValue(1,Boolean.TYPE); - assertEquals(false,resultI); - assertEquals(false,resultC); + boolean resultC = expression.getValue(1, Boolean.TYPE); + assertEquals(false, resultI); + assertEquals(false, resultC); expression = parser.parseExpression("false and true"); - resultI = expression.getValue(1,Boolean.TYPE); + resultI = expression.getValue(1, Boolean.TYPE); SpelCompiler.compile(expression); - resultC = expression.getValue(1,Boolean.TYPE); - assertEquals(false,resultI); - assertEquals(false,resultC); + resultC = expression.getValue(1, Boolean.TYPE); + assertEquals(false, resultI); + assertEquals(false, resultC); expression = parser.parseExpression("true and false"); - resultI = expression.getValue(1,Boolean.TYPE); + resultI = expression.getValue(1, Boolean.TYPE); SpelCompiler.compile(expression); - resultC = expression.getValue(1,Boolean.TYPE); - assertEquals(false,resultI); - assertEquals(false,resultC); + resultC = expression.getValue(1, Boolean.TYPE); + assertEquals(false, resultI); + assertEquals(false, resultC); expression = parser.parseExpression("true and true"); - resultI = expression.getValue(1,Boolean.TYPE); + resultI = expression.getValue(1, Boolean.TYPE); SpelCompiler.compile(expression); - resultC = expression.getValue(1,Boolean.TYPE); - assertEquals(true,resultI); - assertEquals(true,resultC); + resultC = expression.getValue(1, Boolean.TYPE); + assertEquals(true, resultI); + assertEquals(true, resultC); TestClass4 tc = new TestClass4(); // Can't compile this as we aren't going down the gettrue() branch in our evaluation expression = parser.parseExpression("getfalse() and gettrue()"); - resultI = expression.getValue(tc,Boolean.TYPE); + resultI = expression.getValue(tc, Boolean.TYPE); assertCantCompile(expression); expression = parser.parseExpression("getA() and getB()"); tc.a = false; tc.b = false; - resultI = expression.getValue(tc,Boolean.TYPE); + resultI = expression.getValue(tc, Boolean.TYPE); assertCantCompile(expression); // Haven't yet been into second branch tc.a = true; tc.b = false; - resultI = expression.getValue(tc,Boolean.TYPE); + resultI = expression.getValue(tc, Boolean.TYPE); assertCanCompile(expression); // Now been down both assertFalse(resultI); tc.a = true; tc.b = true; - resultI = expression.getValue(tc,Boolean.TYPE); + resultI = expression.getValue(tc, Boolean.TYPE); assertTrue(resultI); boolean b = true; expression = parse("#root and #root"); Object resultI2 = expression.getValue(b); assertCanCompile(expression); - assertTrue((Boolean)resultI2); - assertTrue((Boolean)expression.getValue(b)); + assertTrue((Boolean) resultI2); + assertTrue((Boolean) expression.getValue(b)); } @Test public void operatorNot() throws Exception { expression = parse("!true"); - assertEquals(false,expression.getValue()); + assertEquals(false, expression.getValue()); assertCanCompile(expression); - assertEquals(false,expression.getValue()); + assertEquals(false, expression.getValue()); expression = parse("!false"); - assertEquals(true,expression.getValue()); + assertEquals(true, expression.getValue()); assertCanCompile(expression); - assertEquals(true,expression.getValue()); + assertEquals(true, expression.getValue()); boolean b = true; expression = parse("!#root"); - assertEquals(false,expression.getValue(b)); + assertEquals(false, expression.getValue(b)); assertCanCompile(expression); - assertEquals(false,expression.getValue(b)); + assertEquals(false, expression.getValue(b)); b = false; expression = parse("!#root"); - assertEquals(true,expression.getValue(b)); + assertEquals(true, expression.getValue(b)); assertCanCompile(expression); - assertEquals(true,expression.getValue(b)); + assertEquals(true, expression.getValue(b)); } @Test @@ -659,44 +663,44 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { String resultI = expression.getValue(String.class); assertCanCompile(expression); String resultC = expression.getValue(String.class); - assertEquals("a",resultI); - assertEquals("a",resultC); + assertEquals("a", resultI); + assertEquals("a", resultC); expression = parser.parseExpression("false?'a':'b'"); resultI = expression.getValue(String.class); assertCanCompile(expression); resultC = expression.getValue(String.class); - assertEquals("b",resultI); - assertEquals("b",resultC); + assertEquals("b", resultI); + assertEquals("b", resultC); expression = parser.parseExpression("false?1:'b'"); // All literals so we can do this straight away assertCanCompile(expression); - assertEquals("b",expression.getValue()); + assertEquals("b", expression.getValue()); boolean root = true; expression = parser.parseExpression("(#root and true)?T(Integer).valueOf(1):T(Long).valueOf(3L)"); - assertEquals(1,expression.getValue(root)); + assertEquals(1, expression.getValue(root)); assertCantCompile(expression); // Have not gone down false branch root = false; - assertEquals(3L,expression.getValue(root)); + assertEquals(3L, expression.getValue(root)); assertCanCompile(expression); - assertEquals(3L,expression.getValue(root)); + assertEquals(3L, expression.getValue(root)); root = true; - assertEquals(1,expression.getValue(root)); + assertEquals(1, expression.getValue(root)); } @Test public void ternaryWithBooleanReturn() { // SPR-12271 expression = parser.parseExpression("T(Boolean).TRUE?'abc':'def'"); - assertEquals("abc",expression.getValue()); + assertEquals("abc", expression.getValue()); assertCanCompile(expression); - assertEquals("abc",expression.getValue()); + assertEquals("abc", expression.getValue()); expression = parser.parseExpression("T(Boolean).FALSE?'abc':'def'"); - assertEquals("def",expression.getValue()); + assertEquals("def", expression.getValue()); assertCanCompile(expression); - assertEquals("def",expression.getValue()); + assertEquals("def", expression.getValue()); } @Test @@ -705,21 +709,21 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { String resultI = expression.getValue(String.class); assertCanCompile(expression); String resultC = expression.getValue(String.class); - assertEquals("a",resultI); - assertEquals("a",resultC); + assertEquals("a", resultI); + assertEquals("a", resultC); expression = parser.parseExpression("null?:'a'"); resultI = expression.getValue(String.class); assertCanCompile(expression); resultC = expression.getValue(String.class); - assertEquals("a",resultI); - assertEquals("a",resultC); + assertEquals("a", resultI); + assertEquals("a", resultC); String s = "abc"; expression = parser.parseExpression("#root?:'b'"); assertCantCompile(expression); - resultI = expression.getValue(s,String.class); - assertEquals("abc",resultI); + resultI = expression.getValue(s, String.class); + assertEquals("abc", resultI); assertCanCompile(expression); } @@ -727,17 +731,17 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { public void variableReference_root() throws Exception { String s = "hello"; Expression expression = parser.parseExpression("#root"); - String resultI = expression.getValue(s,String.class); + String resultI = expression.getValue(s, String.class); assertCanCompile(expression); - String resultC = expression.getValue(s,String.class); - assertEquals(s,resultI); - assertEquals(s,resultC); + String resultC = expression.getValue(s, String.class); + assertEquals(s, resultI); + assertEquals(s, resultC); expression = parser.parseExpression("#root"); - int i = (Integer)expression.getValue(42); + int i = (Integer) expression.getValue(42); assertEquals(42,i); assertCanCompile(expression); - i = (Integer)expression.getValue(42); + i = (Integer) expression.getValue(42); assertEquals(42,i); } @@ -761,8 +765,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { expression = parser.parseExpression("#doFormat('hey %s', 'there')"); context = new StandardEvaluationContext(); context.registerFunction("doFormat", - DelegatingStringFormat.class.getDeclaredMethod("format", String.class, - Object[].class)); + DelegatingStringFormat.class.getDeclaredMethod("format", String.class, Object[].class)); ((SpelExpression) expression).setEvaluationContext(context); assertEquals("hey there", expression.getValue(String.class)); @@ -771,10 +774,9 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { assertEquals("hey there", expression.getValue(String.class)); expression = parser.parseExpression("#doFormat([0], 'there')"); - context = new StandardEvaluationContext(new Object[] { "hey %s" }); + context = new StandardEvaluationContext(new Object[] {"hey %s"}); context.registerFunction("doFormat", - DelegatingStringFormat.class.getDeclaredMethod("format", String.class, - Object[].class)); + DelegatingStringFormat.class.getDeclaredMethod("format", String.class, Object[].class)); ((SpelExpression) expression).setEvaluationContext(context); assertEquals("hey there", expression.getValue(String.class)); @@ -783,10 +785,9 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { assertEquals("hey there", expression.getValue(String.class)); expression = parser.parseExpression("#doFormat([0], #arg)"); - context = new StandardEvaluationContext(new Object[] { "hey %s" }); + context = new StandardEvaluationContext(new Object[] {"hey %s"}); context.registerFunction("doFormat", - DelegatingStringFormat.class.getDeclaredMethod("format", String.class, - Object[].class)); + DelegatingStringFormat.class.getDeclaredMethod("format", String.class, Object[].class)); context.setVariable("arg", "there"); ((SpelExpression) expression).setEvaluationContext(context); @@ -799,71 +800,71 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { @Test public void functionReference() throws Exception { EvaluationContext ctx = new StandardEvaluationContext(); - Method m = this.getClass().getDeclaredMethod("concat",String.class,String.class); + Method m = getClass().getDeclaredMethod("concat", String.class, String.class); ctx.setVariable("concat",m); expression = parser.parseExpression("#concat('a','b')"); - assertEquals("ab",expression.getValue(ctx)); + assertEquals("ab", expression.getValue(ctx)); assertCanCompile(expression); - assertEquals("ab",expression.getValue(ctx)); + assertEquals("ab", expression.getValue(ctx)); expression = parser.parseExpression("#concat(#concat('a','b'),'c').charAt(1)"); - assertEquals('b',expression.getValue(ctx)); + assertEquals('b', expression.getValue(ctx)); assertCanCompile(expression); - assertEquals('b',expression.getValue(ctx)); + assertEquals('b', expression.getValue(ctx)); expression = parser.parseExpression("#concat(#a,#b)"); ctx.setVariable("a", "foo"); ctx.setVariable("b", "bar"); - assertEquals("foobar",expression.getValue(ctx)); + assertEquals("foobar", expression.getValue(ctx)); assertCanCompile(expression); - assertEquals("foobar",expression.getValue(ctx)); + assertEquals("foobar", expression.getValue(ctx)); ctx.setVariable("b", "boo"); - assertEquals("fooboo",expression.getValue(ctx)); + assertEquals("fooboo", expression.getValue(ctx)); - m = Math.class.getDeclaredMethod("pow",Double.TYPE,Double.TYPE); + m = Math.class.getDeclaredMethod("pow", Double.TYPE, Double.TYPE); ctx.setVariable("kapow",m); expression = parser.parseExpression("#kapow(2.0d,2.0d)"); - assertEquals("4.0",expression.getValue(ctx).toString()); + assertEquals("4.0", expression.getValue(ctx).toString()); assertCanCompile(expression); - assertEquals("4.0",expression.getValue(ctx).toString()); + assertEquals("4.0", expression.getValue(ctx).toString()); } // Confirms visibility of what is being called. @Test public void functionReferenceVisibility_SPR12359() throws Exception { - StandardEvaluationContext context = new StandardEvaluationContext(new Object[] { "1" }); + StandardEvaluationContext context = new StandardEvaluationContext(new Object[] {"1"}); context.registerFunction("doCompare", SomeCompareMethod.class.getDeclaredMethod( "compare", Object.class, Object.class)); context.setVariable("arg", "2"); // type nor method are public expression = parser.parseExpression("#doCompare([0],#arg)"); - assertEquals("-1",expression.getValue(context, Integer.class).toString()); + assertEquals("-1", expression.getValue(context, Integer.class).toString()); assertCantCompile(expression); // type not public but method is - context = new StandardEvaluationContext(new Object[] { "1" }); + context = new StandardEvaluationContext(new Object[] {"1"}); context.registerFunction("doCompare", SomeCompareMethod.class.getDeclaredMethod( "compare2", Object.class, Object.class)); context.setVariable("arg", "2"); expression = parser.parseExpression("#doCompare([0],#arg)"); - assertEquals("-1",expression.getValue(context, Integer.class).toString()); + assertEquals("-1", expression.getValue(context, Integer.class).toString()); assertCantCompile(expression); } @Test public void functionReferenceNonCompilableArguments_SPR12359() throws Exception { - StandardEvaluationContext context = new StandardEvaluationContext(new Object[] { "1" }); + StandardEvaluationContext context = new StandardEvaluationContext(new Object[] {"1"}); context.registerFunction("negate", SomeCompareMethod2.class.getDeclaredMethod( "negate", Integer.TYPE)); context.setVariable("arg", "2"); - int[] ints = new int[]{1,2,3}; + int[] ints = new int[] {1,2,3}; context.setVariable("ints",ints); expression = parser.parseExpression("#negate(#ints.?[#this<2][0])"); - assertEquals("-1",expression.getValue(context, Integer.class).toString()); + assertEquals("-1", expression.getValue(context, Integer.class).toString()); // Selection isn't compilable. - assertFalse(((SpelNodeImpl)((SpelExpression)expression).getAST()).isCompilable()); + assertFalse(((SpelNodeImpl)((SpelExpression) expression).getAST()).isCompilable()); } @Test @@ -885,193 +886,193 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { SomeCompareMethod2.class.getDeclaredMethod("sumDouble", double[].class)); context.registerFunction("sumFloat", SomeCompareMethod2.class.getDeclaredMethod("sumFloat", float[].class)); - context.setVariable("stringArray", new String[]{"x","y","z"}); - context.setVariable("intArray", new int[]{5,6,9}); - context.setVariable("doubleArray", new double[]{5.0d,6.0d,9.0d}); - context.setVariable("floatArray", new float[]{5.0f,6.0f,9.0f}); + context.setVariable("stringArray", new String[] {"x","y","z"}); + context.setVariable("intArray", new int[] {5,6,9}); + context.setVariable("doubleArray", new double[] {5.0d,6.0d,9.0d}); + context.setVariable("floatArray", new float[] {5.0f,6.0f,9.0f}); expression = parser.parseExpression("#append('a','b','c')"); - assertEquals("abc",expression.getValue(context).toString()); - assertTrue(((SpelNodeImpl)((SpelExpression)expression).getAST()).isCompilable()); + assertEquals("abc", expression.getValue(context).toString()); + assertTrue(((SpelNodeImpl)((SpelExpression) expression).getAST()).isCompilable()); assertCanCompile(expression); - assertEquals("abc",expression.getValue(context).toString()); + assertEquals("abc", expression.getValue(context).toString()); expression = parser.parseExpression("#append('a')"); - assertEquals("a",expression.getValue(context).toString()); - assertTrue(((SpelNodeImpl)((SpelExpression)expression).getAST()).isCompilable()); + assertEquals("a", expression.getValue(context).toString()); + assertTrue(((SpelNodeImpl)((SpelExpression) expression).getAST()).isCompilable()); assertCanCompile(expression); - assertEquals("a",expression.getValue(context).toString()); + assertEquals("a", expression.getValue(context).toString()); expression = parser.parseExpression("#append()"); - assertEquals("",expression.getValue(context).toString()); - assertTrue(((SpelNodeImpl)((SpelExpression)expression).getAST()).isCompilable()); + assertEquals("", expression.getValue(context).toString()); + assertTrue(((SpelNodeImpl)((SpelExpression) expression).getAST()).isCompilable()); assertCanCompile(expression); - assertEquals("",expression.getValue(context).toString()); + assertEquals("", expression.getValue(context).toString()); expression = parser.parseExpression("#append(#stringArray)"); - assertEquals("xyz",expression.getValue(context).toString()); - assertTrue(((SpelNodeImpl)((SpelExpression)expression).getAST()).isCompilable()); + assertEquals("xyz", expression.getValue(context).toString()); + assertTrue(((SpelNodeImpl)((SpelExpression) expression).getAST()).isCompilable()); assertCanCompile(expression); - assertEquals("xyz",expression.getValue(context).toString()); + assertEquals("xyz", expression.getValue(context).toString()); // This is a methodreference invocation, to compare with functionreference expression = parser.parseExpression("append(#stringArray)"); - assertEquals("xyz",expression.getValue(context,new SomeCompareMethod2()).toString()); - assertTrue(((SpelNodeImpl)((SpelExpression)expression).getAST()).isCompilable()); + assertEquals("xyz", expression.getValue(context,new SomeCompareMethod2()).toString()); + assertTrue(((SpelNodeImpl)((SpelExpression) expression).getAST()).isCompilable()); assertCanCompile(expression); - assertEquals("xyz",expression.getValue(context,new SomeCompareMethod2()).toString()); + assertEquals("xyz", expression.getValue(context,new SomeCompareMethod2()).toString()); expression = parser.parseExpression("#append2('a','b','c')"); - assertEquals("abc",expression.getValue(context).toString()); - assertTrue(((SpelNodeImpl)((SpelExpression)expression).getAST()).isCompilable()); + assertEquals("abc", expression.getValue(context).toString()); + assertTrue(((SpelNodeImpl)((SpelExpression) expression).getAST()).isCompilable()); assertCanCompile(expression); - assertEquals("abc",expression.getValue(context).toString()); + assertEquals("abc", expression.getValue(context).toString()); expression = parser.parseExpression("append2('a','b')"); - assertEquals("ab",expression.getValue(context, new SomeCompareMethod2()).toString()); - assertTrue(((SpelNodeImpl)((SpelExpression)expression).getAST()).isCompilable()); + assertEquals("ab", expression.getValue(context, new SomeCompareMethod2()).toString()); + assertTrue(((SpelNodeImpl)((SpelExpression) expression).getAST()).isCompilable()); assertCanCompile(expression); - assertEquals("ab",expression.getValue(context, new SomeCompareMethod2()).toString()); + assertEquals("ab", expression.getValue(context, new SomeCompareMethod2()).toString()); expression = parser.parseExpression("#append2('a','b')"); - assertEquals("ab",expression.getValue(context).toString()); - assertTrue(((SpelNodeImpl)((SpelExpression)expression).getAST()).isCompilable()); + assertEquals("ab", expression.getValue(context).toString()); + assertTrue(((SpelNodeImpl)((SpelExpression) expression).getAST()).isCompilable()); assertCanCompile(expression); - assertEquals("ab",expression.getValue(context).toString()); + assertEquals("ab", expression.getValue(context).toString()); expression = parser.parseExpression("#append2()"); - assertEquals("",expression.getValue(context).toString()); - assertTrue(((SpelNodeImpl)((SpelExpression)expression).getAST()).isCompilable()); + assertEquals("", expression.getValue(context).toString()); + assertTrue(((SpelNodeImpl)((SpelExpression) expression).getAST()).isCompilable()); assertCanCompile(expression); - assertEquals("",expression.getValue(context).toString()); + assertEquals("", expression.getValue(context).toString()); expression = parser.parseExpression("#append3(#stringArray)"); - assertEquals("xyz",expression.getValue(context, new SomeCompareMethod2()).toString()); - assertTrue(((SpelNodeImpl)((SpelExpression)expression).getAST()).isCompilable()); + assertEquals("xyz", expression.getValue(context, new SomeCompareMethod2()).toString()); + assertTrue(((SpelNodeImpl)((SpelExpression) expression).getAST()).isCompilable()); assertCanCompile(expression); - assertEquals("xyz",expression.getValue(context, new SomeCompareMethod2()).toString()); + assertEquals("xyz", expression.getValue(context, new SomeCompareMethod2()).toString()); // TODO fails due to conversionservice handling of String[] to Object... -// expression = parser.parseExpression("#append2(#stringArray)"); -// assertEquals("xyz",expression.getValue(context).toString()); -// assertTrue(((SpelNodeImpl)((SpelExpression)expression).getAST()).isCompilable()); -// assertCanCompile(expression); -// assertEquals("xyz",expression.getValue(context).toString()); + // expression = parser.parseExpression("#append2(#stringArray)"); + // assertEquals("xyz", expression.getValue(context).toString()); + // assertTrue(((SpelNodeImpl)((SpelExpression) expression).getAST()).isCompilable()); + // assertCanCompile(expression); + // assertEquals("xyz", expression.getValue(context).toString()); expression = parser.parseExpression("#sum(1,2,3)"); - assertEquals(6,expression.getValue(context)); - assertTrue(((SpelNodeImpl)((SpelExpression)expression).getAST()).isCompilable()); + assertEquals(6, expression.getValue(context)); + assertTrue(((SpelNodeImpl)((SpelExpression) expression).getAST()).isCompilable()); assertCanCompile(expression); - assertEquals(6,expression.getValue(context)); + assertEquals(6, expression.getValue(context)); expression = parser.parseExpression("#sum(2)"); - assertEquals(2,expression.getValue(context)); - assertTrue(((SpelNodeImpl)((SpelExpression)expression).getAST()).isCompilable()); + assertEquals(2, expression.getValue(context)); + assertTrue(((SpelNodeImpl)((SpelExpression) expression).getAST()).isCompilable()); assertCanCompile(expression); - assertEquals(2,expression.getValue(context)); + assertEquals(2, expression.getValue(context)); expression = parser.parseExpression("#sum()"); - assertEquals(0,expression.getValue(context)); - assertTrue(((SpelNodeImpl)((SpelExpression)expression).getAST()).isCompilable()); + assertEquals(0, expression.getValue(context)); + assertTrue(((SpelNodeImpl)((SpelExpression) expression).getAST()).isCompilable()); assertCanCompile(expression); - assertEquals(0,expression.getValue(context)); + assertEquals(0, expression.getValue(context)); expression = parser.parseExpression("#sum(#intArray)"); - assertEquals(20,expression.getValue(context)); - assertTrue(((SpelNodeImpl)((SpelExpression)expression).getAST()).isCompilable()); + assertEquals(20, expression.getValue(context)); + assertTrue(((SpelNodeImpl)((SpelExpression) expression).getAST()).isCompilable()); assertCanCompile(expression); - assertEquals(20,expression.getValue(context)); + assertEquals(20, expression.getValue(context)); expression = parser.parseExpression("#sumDouble(1.0d,2.0d,3.0d)"); - assertEquals(6,expression.getValue(context)); - assertTrue(((SpelNodeImpl)((SpelExpression)expression).getAST()).isCompilable()); + assertEquals(6, expression.getValue(context)); + assertTrue(((SpelNodeImpl)((SpelExpression) expression).getAST()).isCompilable()); assertCanCompile(expression); - assertEquals(6,expression.getValue(context)); + assertEquals(6, expression.getValue(context)); expression = parser.parseExpression("#sumDouble(2.0d)"); - assertEquals(2,expression.getValue(context)); - assertTrue(((SpelNodeImpl)((SpelExpression)expression).getAST()).isCompilable()); + assertEquals(2, expression.getValue(context)); + assertTrue(((SpelNodeImpl)((SpelExpression) expression).getAST()).isCompilable()); assertCanCompile(expression); - assertEquals(2,expression.getValue(context)); + assertEquals(2, expression.getValue(context)); expression = parser.parseExpression("#sumDouble()"); - assertEquals(0,expression.getValue(context)); - assertTrue(((SpelNodeImpl)((SpelExpression)expression).getAST()).isCompilable()); + assertEquals(0, expression.getValue(context)); + assertTrue(((SpelNodeImpl)((SpelExpression) expression).getAST()).isCompilable()); assertCanCompile(expression); - assertEquals(0,expression.getValue(context)); + assertEquals(0, expression.getValue(context)); expression = parser.parseExpression("#sumDouble(#doubleArray)"); - assertEquals(20,expression.getValue(context)); - assertTrue(((SpelNodeImpl)((SpelExpression)expression).getAST()).isCompilable()); + assertEquals(20, expression.getValue(context)); + assertTrue(((SpelNodeImpl)((SpelExpression) expression).getAST()).isCompilable()); assertCanCompile(expression); - assertEquals(20,expression.getValue(context)); + assertEquals(20, expression.getValue(context)); expression = parser.parseExpression("#sumFloat(1.0f,2.0f,3.0f)"); - assertEquals(6,expression.getValue(context)); - assertTrue(((SpelNodeImpl)((SpelExpression)expression).getAST()).isCompilable()); + assertEquals(6, expression.getValue(context)); + assertTrue(((SpelNodeImpl)((SpelExpression) expression).getAST()).isCompilable()); assertCanCompile(expression); - assertEquals(6,expression.getValue(context)); + assertEquals(6, expression.getValue(context)); expression = parser.parseExpression("#sumFloat(2.0f)"); - assertEquals(2,expression.getValue(context)); - assertTrue(((SpelNodeImpl)((SpelExpression)expression).getAST()).isCompilable()); + assertEquals(2, expression.getValue(context)); + assertTrue(((SpelNodeImpl)((SpelExpression) expression).getAST()).isCompilable()); assertCanCompile(expression); - assertEquals(2,expression.getValue(context)); + assertEquals(2, expression.getValue(context)); expression = parser.parseExpression("#sumFloat()"); - assertEquals(0,expression.getValue(context)); - assertTrue(((SpelNodeImpl)((SpelExpression)expression).getAST()).isCompilable()); + assertEquals(0, expression.getValue(context)); + assertTrue(((SpelNodeImpl)((SpelExpression) expression).getAST()).isCompilable()); assertCanCompile(expression); - assertEquals(0,expression.getValue(context)); + assertEquals(0, expression.getValue(context)); expression = parser.parseExpression("#sumFloat(#floatArray)"); - assertEquals(20,expression.getValue(context)); - assertTrue(((SpelNodeImpl)((SpelExpression)expression).getAST()).isCompilable()); + assertEquals(20, expression.getValue(context)); + assertTrue(((SpelNodeImpl)((SpelExpression) expression).getAST()).isCompilable()); assertCanCompile(expression); - assertEquals(20,expression.getValue(context)); + assertEquals(20, expression.getValue(context)); expression = parser.parseExpression("#appendChar('abc'.charAt(0),'abc'.charAt(1))"); - assertEquals("ab",expression.getValue(context)); - assertTrue(((SpelNodeImpl)((SpelExpression)expression).getAST()).isCompilable()); + assertEquals("ab", expression.getValue(context)); + assertTrue(((SpelNodeImpl)((SpelExpression) expression).getAST()).isCompilable()); assertCanCompile(expression); - assertEquals("ab",expression.getValue(context)); + assertEquals("ab", expression.getValue(context)); expression = parser.parseExpression("#append4('a','b','c')"); - assertEquals("a::bc",expression.getValue(context).toString()); - assertTrue(((SpelNodeImpl)((SpelExpression)expression).getAST()).isCompilable()); + assertEquals("a::bc", expression.getValue(context).toString()); + assertTrue(((SpelNodeImpl)((SpelExpression) expression).getAST()).isCompilable()); assertCanCompile(expression); - assertEquals("a::bc",expression.getValue(context).toString()); + assertEquals("a::bc", expression.getValue(context).toString()); expression = parser.parseExpression("#append4('a','b')"); - assertEquals("a::b",expression.getValue(context).toString()); - assertTrue(((SpelNodeImpl)((SpelExpression)expression).getAST()).isCompilable()); + assertEquals("a::b", expression.getValue(context).toString()); + assertTrue(((SpelNodeImpl)((SpelExpression) expression).getAST()).isCompilable()); assertCanCompile(expression); - assertEquals("a::b",expression.getValue(context).toString()); + assertEquals("a::b", expression.getValue(context).toString()); expression = parser.parseExpression("#append4('a')"); - assertEquals("a::",expression.getValue(context).toString()); - assertTrue(((SpelNodeImpl)((SpelExpression)expression).getAST()).isCompilable()); + assertEquals("a::", expression.getValue(context).toString()); + assertTrue(((SpelNodeImpl)((SpelExpression) expression).getAST()).isCompilable()); assertCanCompile(expression); - assertEquals("a::",expression.getValue(context).toString()); + assertEquals("a::", expression.getValue(context).toString()); expression = parser.parseExpression("#append4('a',#stringArray)"); - assertEquals("a::xyz",expression.getValue(context).toString()); - assertTrue(((SpelNodeImpl)((SpelExpression)expression).getAST()).isCompilable()); + assertEquals("a::xyz", expression.getValue(context).toString()); + assertTrue(((SpelNodeImpl)((SpelExpression) expression).getAST()).isCompilable()); assertCanCompile(expression); - assertEquals("a::xyz",expression.getValue(context).toString()); + assertEquals("a::xyz", expression.getValue(context).toString()); } @Test public void functionReferenceVarargs() throws Exception { EvaluationContext ctx = new StandardEvaluationContext(); - Method m = this.getClass().getDeclaredMethod("join", String[].class); + Method m = getClass().getDeclaredMethod("join", String[].class); ctx.setVariable("join", m); expression = parser.parseExpression("#join('a','b','c')"); - assertEquals("abc",expression.getValue(ctx)); + assertEquals("abc", expression.getValue(ctx)); assertCanCompile(expression); - assertEquals("abc",expression.getValue(ctx)); + assertEquals("abc", expression.getValue(ctx)); } @Test @@ -1079,14 +1080,14 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { EvaluationContext ctx = new StandardEvaluationContext(); ctx.setVariable("target", "abc"); expression = parser.parseExpression("#target"); - assertEquals("abc",expression.getValue(ctx)); + assertEquals("abc", expression.getValue(ctx)); assertCanCompile(expression); - assertEquals("abc",expression.getValue(ctx)); + assertEquals("abc", expression.getValue(ctx)); ctx.setVariable("target", "123"); - assertEquals("123",expression.getValue(ctx)); + assertEquals("123", expression.getValue(ctx)); ctx.setVariable("target", 42); try { - assertEquals(42,expression.getValue(ctx)); + assertEquals(42, expression.getValue(ctx)); fail(); } catch (SpelEvaluationException see) { @@ -1095,14 +1096,14 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { ctx.setVariable("target", "abc"); expression = parser.parseExpression("#target.charAt(0)"); - assertEquals('a',expression.getValue(ctx)); + assertEquals('a', expression.getValue(ctx)); assertCanCompile(expression); - assertEquals('a',expression.getValue(ctx)); + assertEquals('a', expression.getValue(ctx)); ctx.setVariable("target", "1"); - assertEquals('1',expression.getValue(ctx)); + assertEquals('1', expression.getValue(ctx)); ctx.setVariable("target", 42); try { - assertEquals('4',expression.getValue(ctx)); + assertEquals('4', expression.getValue(ctx)); fail(); } catch (SpelEvaluationException see) { @@ -1114,284 +1115,282 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { public void opLt() throws Exception { expression = parse("3.0d < 4.0d"); assertCanCompile(expression); - assertTrue((Boolean)expression.getValue()); + assertTrue((Boolean) expression.getValue()); expression = parse("3446.0d < 1123.0d"); assertCanCompile(expression); - assertFalse((Boolean)expression.getValue()); + assertFalse((Boolean) expression.getValue()); expression = parse("3 < 1"); assertCanCompile(expression); - assertFalse((Boolean)expression.getValue()); + assertFalse((Boolean) expression.getValue()); expression = parse("2 < 4"); assertCanCompile(expression); - assertTrue((Boolean)expression.getValue()); + assertTrue((Boolean) expression.getValue()); expression = parse("3.0f < 1.0f"); assertCanCompile(expression); - assertFalse((Boolean)expression.getValue()); + assertFalse((Boolean) expression.getValue()); expression = parse("1.0f < 5.0f"); assertCanCompile(expression); - assertTrue((Boolean)expression.getValue()); + assertTrue((Boolean) expression.getValue()); expression = parse("30L < 30L"); assertCanCompile(expression); - assertFalse((Boolean)expression.getValue()); + assertFalse((Boolean) expression.getValue()); expression = parse("15L < 20L"); assertCanCompile(expression); - assertTrue((Boolean)expression.getValue()); + assertTrue((Boolean) expression.getValue()); // Differing types of number, not yet supported expression = parse("1 < 3.0d"); assertCantCompile(expression); expression = parse("T(Integer).valueOf(3) < 4"); - assertTrue((Boolean)expression.getValue()); + assertTrue((Boolean) expression.getValue()); assertCanCompile(expression); - assertTrue((Boolean)expression.getValue()); + assertTrue((Boolean) expression.getValue()); expression = parse("T(Integer).valueOf(3) < T(Integer).valueOf(3)"); - assertFalse((Boolean)expression.getValue()); + assertFalse((Boolean) expression.getValue()); assertCanCompile(expression); - assertFalse((Boolean)expression.getValue()); + assertFalse((Boolean) expression.getValue()); expression = parse("5 < T(Integer).valueOf(3)"); - assertFalse((Boolean)expression.getValue()); + assertFalse((Boolean) expression.getValue()); assertCanCompile(expression); - assertFalse((Boolean)expression.getValue()); + assertFalse((Boolean) expression.getValue()); } @Test public void opLe() throws Exception { expression = parse("3.0d <= 4.0d"); assertCanCompile(expression); - assertTrue((Boolean)expression.getValue()); + assertTrue((Boolean) expression.getValue()); expression = parse("3446.0d <= 1123.0d"); assertCanCompile(expression); - assertFalse((Boolean)expression.getValue()); + assertFalse((Boolean) expression.getValue()); expression = parse("3446.0d <= 3446.0d"); assertCanCompile(expression); - assertTrue((Boolean)expression.getValue()); + assertTrue((Boolean) expression.getValue()); expression = parse("3 <= 1"); assertCanCompile(expression); - assertFalse((Boolean)expression.getValue()); + assertFalse((Boolean) expression.getValue()); expression = parse("2 <= 4"); assertCanCompile(expression); - assertTrue((Boolean)expression.getValue()); + assertTrue((Boolean) expression.getValue()); expression = parse("3 <= 3"); assertCanCompile(expression); - assertTrue((Boolean)expression.getValue()); + assertTrue((Boolean) expression.getValue()); expression = parse("3.0f <= 1.0f"); assertCanCompile(expression); - assertFalse((Boolean)expression.getValue()); + assertFalse((Boolean) expression.getValue()); expression = parse("1.0f <= 5.0f"); assertCanCompile(expression); - assertTrue((Boolean)expression.getValue()); + assertTrue((Boolean) expression.getValue()); expression = parse("2.0f <= 2.0f"); assertCanCompile(expression); - assertTrue((Boolean)expression.getValue()); + assertTrue((Boolean) expression.getValue()); expression = parse("30L <= 30L"); assertCanCompile(expression); - assertTrue((Boolean)expression.getValue()); + assertTrue((Boolean) expression.getValue()); expression = parse("15L <= 20L"); assertCanCompile(expression); - assertTrue((Boolean)expression.getValue()); + assertTrue((Boolean) expression.getValue()); // Differing types of number, not yet supported expression = parse("1 <= 3.0d"); assertCantCompile(expression); expression = parse("T(Integer).valueOf(3) <= 4"); - assertTrue((Boolean)expression.getValue()); + assertTrue((Boolean) expression.getValue()); assertCanCompile(expression); - assertTrue((Boolean)expression.getValue()); + assertTrue((Boolean) expression.getValue()); expression = parse("T(Integer).valueOf(3) <= T(Integer).valueOf(3)"); - assertTrue((Boolean)expression.getValue()); + assertTrue((Boolean) expression.getValue()); assertCanCompile(expression); - assertTrue((Boolean)expression.getValue()); + assertTrue((Boolean) expression.getValue()); expression = parse("5 <= T(Integer).valueOf(3)"); - assertFalse((Boolean)expression.getValue()); + assertFalse((Boolean) expression.getValue()); assertCanCompile(expression); - assertFalse((Boolean)expression.getValue()); + assertFalse((Boolean) expression.getValue()); } @Test public void opGt() throws Exception { expression = parse("3.0d > 4.0d"); assertCanCompile(expression); - assertFalse((Boolean)expression.getValue()); + assertFalse((Boolean) expression.getValue()); expression = parse("3446.0d > 1123.0d"); assertCanCompile(expression); - assertTrue((Boolean)expression.getValue()); + assertTrue((Boolean) expression.getValue()); expression = parse("3 > 1"); assertCanCompile(expression); - assertTrue((Boolean)expression.getValue()); + assertTrue((Boolean) expression.getValue()); expression = parse("2 > 4"); assertCanCompile(expression); - assertFalse((Boolean)expression.getValue()); + assertFalse((Boolean) expression.getValue()); expression = parse("3.0f > 1.0f"); assertCanCompile(expression); - assertTrue((Boolean)expression.getValue()); + assertTrue((Boolean) expression.getValue()); expression = parse("1.0f > 5.0f"); assertCanCompile(expression); - assertFalse((Boolean)expression.getValue()); + assertFalse((Boolean) expression.getValue()); expression = parse("30L > 30L"); assertCanCompile(expression); - assertFalse((Boolean)expression.getValue()); + assertFalse((Boolean) expression.getValue()); expression = parse("15L > 20L"); assertCanCompile(expression); - assertFalse((Boolean)expression.getValue()); + assertFalse((Boolean) expression.getValue()); // Differing types of number, not yet supported expression = parse("1 > 3.0d"); assertCantCompile(expression); expression = parse("T(Integer).valueOf(3) > 4"); - assertFalse((Boolean)expression.getValue()); + assertFalse((Boolean) expression.getValue()); assertCanCompile(expression); - assertFalse((Boolean)expression.getValue()); + assertFalse((Boolean) expression.getValue()); expression = parse("T(Integer).valueOf(3) > T(Integer).valueOf(3)"); - assertFalse((Boolean)expression.getValue()); + assertFalse((Boolean) expression.getValue()); assertCanCompile(expression); - assertFalse((Boolean)expression.getValue()); + assertFalse((Boolean) expression.getValue()); expression = parse("5 > T(Integer).valueOf(3)"); - assertTrue((Boolean)expression.getValue()); + assertTrue((Boolean) expression.getValue()); assertCanCompile(expression); - assertTrue((Boolean)expression.getValue()); + assertTrue((Boolean) expression.getValue()); } @Test public void opGe() throws Exception { expression = parse("3.0d >= 4.0d"); assertCanCompile(expression); - assertFalse((Boolean)expression.getValue()); + assertFalse((Boolean) expression.getValue()); expression = parse("3446.0d >= 1123.0d"); assertCanCompile(expression); - assertTrue((Boolean)expression.getValue()); + assertTrue((Boolean) expression.getValue()); expression = parse("3446.0d >= 3446.0d"); assertCanCompile(expression); - assertTrue((Boolean)expression.getValue()); + assertTrue((Boolean) expression.getValue()); expression = parse("3 >= 1"); assertCanCompile(expression); - assertTrue((Boolean)expression.getValue()); + assertTrue((Boolean) expression.getValue()); expression = parse("2 >= 4"); assertCanCompile(expression); - assertFalse((Boolean)expression.getValue()); + assertFalse((Boolean) expression.getValue()); expression = parse("3 >= 3"); assertCanCompile(expression); - assertTrue((Boolean)expression.getValue()); + assertTrue((Boolean) expression.getValue()); expression = parse("3.0f >= 1.0f"); assertCanCompile(expression); - assertTrue((Boolean)expression.getValue()); + assertTrue((Boolean) expression.getValue()); expression = parse("1.0f >= 5.0f"); assertCanCompile(expression); - assertFalse((Boolean)expression.getValue()); + assertFalse((Boolean) expression.getValue()); expression = parse("3.0f >= 3.0f"); assertCanCompile(expression); - assertTrue((Boolean)expression.getValue()); + assertTrue((Boolean) expression.getValue()); expression = parse("40L >= 30L"); assertCanCompile(expression); - assertTrue((Boolean)expression.getValue()); + assertTrue((Boolean) expression.getValue()); expression = parse("15L >= 20L"); assertCanCompile(expression); - assertFalse((Boolean)expression.getValue()); + assertFalse((Boolean) expression.getValue()); expression = parse("30L >= 30L"); assertCanCompile(expression); - assertTrue((Boolean)expression.getValue()); + assertTrue((Boolean) expression.getValue()); // Differing types of number, not yet supported expression = parse("1 >= 3.0d"); assertCantCompile(expression); expression = parse("T(Integer).valueOf(3) >= 4"); - assertFalse((Boolean)expression.getValue()); + assertFalse((Boolean) expression.getValue()); assertCanCompile(expression); - assertFalse((Boolean)expression.getValue()); + assertFalse((Boolean) expression.getValue()); expression = parse("T(Integer).valueOf(3) >= T(Integer).valueOf(3)"); - assertTrue((Boolean)expression.getValue()); + assertTrue((Boolean) expression.getValue()); assertCanCompile(expression); - assertTrue((Boolean)expression.getValue()); + assertTrue((Boolean) expression.getValue()); expression = parse("5 >= T(Integer).valueOf(3)"); - assertTrue((Boolean)expression.getValue()); + assertTrue((Boolean) expression.getValue()); assertCanCompile(expression); - assertTrue((Boolean)expression.getValue()); + assertTrue((Boolean) expression.getValue()); } @Test public void opEq() throws Exception { String tvar = "35"; expression = parse("#root == 35"); - Boolean bb = (Boolean)expression.getValue(tvar); - System.out.println(bb); - assertFalse((Boolean)expression.getValue(tvar)); + assertFalse((Boolean) expression.getValue(tvar)); assertCanCompile(expression); - assertFalse((Boolean)expression.getValue(tvar)); + assertFalse((Boolean) expression.getValue(tvar)); expression = parse("35 == #root"); expression.getValue(tvar); - assertFalse((Boolean)expression.getValue(tvar)); + assertFalse((Boolean) expression.getValue(tvar)); assertCanCompile(expression); - assertFalse((Boolean)expression.getValue(tvar)); + assertFalse((Boolean) expression.getValue(tvar)); TestClass7 tc7 = new TestClass7(); expression = parse("property == 'UK'"); - assertTrue((Boolean)expression.getValue(tc7)); + assertTrue((Boolean) expression.getValue(tc7)); TestClass7.property = null; - assertFalse((Boolean)expression.getValue(tc7)); + assertFalse((Boolean) expression.getValue(tc7)); assertCanCompile(expression); TestClass7.reset(); - assertTrue((Boolean)expression.getValue(tc7)); + assertTrue((Boolean) expression.getValue(tc7)); TestClass7.property = "UK"; - assertTrue((Boolean)expression.getValue(tc7)); + assertTrue((Boolean) expression.getValue(tc7)); TestClass7.reset(); TestClass7.property = null; - assertFalse((Boolean)expression.getValue(tc7)); + assertFalse((Boolean) expression.getValue(tc7)); expression = parse("property == null"); - assertTrue((Boolean)expression.getValue(tc7)); + assertTrue((Boolean) expression.getValue(tc7)); assertCanCompile(expression); - assertTrue((Boolean)expression.getValue(tc7)); + assertTrue((Boolean) expression.getValue(tc7)); expression = parse("3.0d == 4.0d"); assertCanCompile(expression); - assertFalse((Boolean)expression.getValue()); + assertFalse((Boolean) expression.getValue()); expression = parse("3446.0d == 3446.0d"); assertCanCompile(expression); - assertTrue((Boolean)expression.getValue()); + assertTrue((Boolean) expression.getValue()); expression = parse("3 == 1"); assertCanCompile(expression); - assertFalse((Boolean)expression.getValue()); + assertFalse((Boolean) expression.getValue()); expression = parse("3 == 3"); assertCanCompile(expression); - assertTrue((Boolean)expression.getValue()); + assertTrue((Boolean) expression.getValue()); expression = parse("3.0f == 1.0f"); assertCanCompile(expression); - assertFalse((Boolean)expression.getValue()); + assertFalse((Boolean) expression.getValue()); expression = parse("2.0f == 2.0f"); assertCanCompile(expression); - assertTrue((Boolean)expression.getValue()); + assertTrue((Boolean) expression.getValue()); expression = parse("30L == 30L"); assertCanCompile(expression); - assertTrue((Boolean)expression.getValue()); + assertTrue((Boolean) expression.getValue()); expression = parse("15L == 20L"); assertCanCompile(expression); - assertFalse((Boolean)expression.getValue()); + assertFalse((Boolean) expression.getValue()); // number types are not the same expression = parse("1 == 3.0d"); @@ -1399,228 +1398,304 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { Double d = 3.0d; expression = parse("#root==3.0d"); - assertTrue((Boolean)expression.getValue(d)); + assertTrue((Boolean) expression.getValue(d)); assertCanCompile(expression); - assertTrue((Boolean)expression.getValue(d)); + assertTrue((Boolean) expression.getValue(d)); Integer i = 3; expression = parse("#root==3"); - assertTrue((Boolean)expression.getValue(i)); + assertTrue((Boolean) expression.getValue(i)); assertCanCompile(expression); - assertTrue((Boolean)expression.getValue(i)); + assertTrue((Boolean) expression.getValue(i)); Float f = 3.0f; expression = parse("#root==3.0f"); - assertTrue((Boolean)expression.getValue(f)); + assertTrue((Boolean) expression.getValue(f)); assertCanCompile(expression); - assertTrue((Boolean)expression.getValue(f)); + assertTrue((Boolean) expression.getValue(f)); long l = 300l; expression = parse("#root==300l"); - assertTrue((Boolean)expression.getValue(l)); + assertTrue((Boolean) expression.getValue(l)); assertCanCompile(expression); - assertTrue((Boolean)expression.getValue(l)); + assertTrue((Boolean) expression.getValue(l)); boolean b = true; expression = parse("#root==true"); - assertTrue((Boolean)expression.getValue(b)); + assertTrue((Boolean) expression.getValue(b)); assertCanCompile(expression); - assertTrue((Boolean)expression.getValue(b)); + assertTrue((Boolean) expression.getValue(b)); expression = parse("T(Integer).valueOf(3) == 4"); - assertFalse((Boolean)expression.getValue()); + assertFalse((Boolean) expression.getValue()); assertCanCompile(expression); - assertFalse((Boolean)expression.getValue()); + assertFalse((Boolean) expression.getValue()); expression = parse("T(Integer).valueOf(3) == T(Integer).valueOf(3)"); - assertTrue((Boolean)expression.getValue()); + assertTrue((Boolean) expression.getValue()); assertCanCompile(expression); - assertTrue((Boolean)expression.getValue()); + assertTrue((Boolean) expression.getValue()); expression = parse("5 == T(Integer).valueOf(3)"); - assertFalse((Boolean)expression.getValue()); + assertFalse((Boolean) expression.getValue()); assertCanCompile(expression); - assertFalse((Boolean)expression.getValue()); + assertFalse((Boolean) expression.getValue()); expression = parse("T(Float).valueOf(3.0f) == 4.0f"); - assertFalse((Boolean)expression.getValue()); + assertFalse((Boolean) expression.getValue()); assertCanCompile(expression); - assertFalse((Boolean)expression.getValue()); + assertFalse((Boolean) expression.getValue()); expression = parse("T(Float).valueOf(3.0f) == T(Float).valueOf(3.0f)"); - assertTrue((Boolean)expression.getValue()); + assertTrue((Boolean) expression.getValue()); assertCanCompile(expression); - assertTrue((Boolean)expression.getValue()); + assertTrue((Boolean) expression.getValue()); expression = parse("5.0f == T(Float).valueOf(3.0f)"); - assertFalse((Boolean)expression.getValue()); + assertFalse((Boolean) expression.getValue()); assertCanCompile(expression); - assertFalse((Boolean)expression.getValue()); + assertFalse((Boolean) expression.getValue()); expression = parse("T(Long).valueOf(3L) == 4L"); - assertFalse((Boolean)expression.getValue()); + assertFalse((Boolean) expression.getValue()); assertCanCompile(expression); - assertFalse((Boolean)expression.getValue()); + assertFalse((Boolean) expression.getValue()); expression = parse("T(Long).valueOf(3L) == T(Long).valueOf(3L)"); - assertTrue((Boolean)expression.getValue()); + assertTrue((Boolean) expression.getValue()); assertCanCompile(expression); - assertTrue((Boolean)expression.getValue()); + assertTrue((Boolean) expression.getValue()); expression = parse("5L == T(Long).valueOf(3L)"); - assertFalse((Boolean)expression.getValue()); + assertFalse((Boolean) expression.getValue()); assertCanCompile(expression); - assertFalse((Boolean)expression.getValue()); + assertFalse((Boolean) expression.getValue()); expression = parse("T(Double).valueOf(3.0d) == 4.0d"); - assertFalse((Boolean)expression.getValue()); + assertFalse((Boolean) expression.getValue()); assertCanCompile(expression); - assertFalse((Boolean)expression.getValue()); + assertFalse((Boolean) expression.getValue()); expression = parse("T(Double).valueOf(3.0d) == T(Double).valueOf(3.0d)"); - assertTrue((Boolean)expression.getValue()); + assertTrue((Boolean) expression.getValue()); assertCanCompile(expression); - assertTrue((Boolean)expression.getValue()); + assertTrue((Boolean) expression.getValue()); expression = parse("5.0d == T(Double).valueOf(3.0d)"); - assertFalse((Boolean)expression.getValue()); + assertFalse((Boolean) expression.getValue()); assertCanCompile(expression); - assertFalse((Boolean)expression.getValue()); + assertFalse((Boolean) expression.getValue()); expression = parse("false == true"); - assertFalse((Boolean)expression.getValue()); + assertFalse((Boolean) expression.getValue()); assertCanCompile(expression); - assertFalse((Boolean)expression.getValue()); + assertFalse((Boolean) expression.getValue()); expression = parse("T(Boolean).valueOf('true') == T(Boolean).valueOf('true')"); - assertTrue((Boolean)expression.getValue()); + assertTrue((Boolean) expression.getValue()); assertCanCompile(expression); - assertTrue((Boolean)expression.getValue()); + assertTrue((Boolean) expression.getValue()); expression = parse("T(Boolean).valueOf('true') == true"); - assertTrue((Boolean)expression.getValue()); + assertTrue((Boolean) expression.getValue()); assertCanCompile(expression); - assertTrue((Boolean)expression.getValue()); + assertTrue((Boolean) expression.getValue()); expression = parse("false == T(Boolean).valueOf('false')"); - assertTrue((Boolean)expression.getValue()); + assertTrue((Boolean) expression.getValue()); assertCanCompile(expression); - assertTrue((Boolean)expression.getValue()); + assertTrue((Boolean) expression.getValue()); } @Test public void opNe() throws Exception { expression = parse("3.0d != 4.0d"); assertCanCompile(expression); - assertTrue((Boolean)expression.getValue()); + assertTrue((Boolean) expression.getValue()); expression = parse("3446.0d != 3446.0d"); assertCanCompile(expression); - assertFalse((Boolean)expression.getValue()); + assertFalse((Boolean) expression.getValue()); expression = parse("3 != 1"); assertCanCompile(expression); - assertTrue((Boolean)expression.getValue()); + assertTrue((Boolean) expression.getValue()); expression = parse("3 != 3"); assertCanCompile(expression); - assertFalse((Boolean)expression.getValue()); + assertFalse((Boolean) expression.getValue()); expression = parse("3.0f != 1.0f"); assertCanCompile(expression); - assertTrue((Boolean)expression.getValue()); + assertTrue((Boolean) expression.getValue()); expression = parse("2.0f != 2.0f"); assertCanCompile(expression); - assertFalse((Boolean)expression.getValue()); + assertFalse((Boolean) expression.getValue()); expression = parse("30L != 30L"); assertCanCompile(expression); - assertFalse((Boolean)expression.getValue()); + assertFalse((Boolean) expression.getValue()); expression = parse("15L != 20L"); assertCanCompile(expression); - assertTrue((Boolean)expression.getValue()); + assertTrue((Boolean) expression.getValue()); // not compatible number types expression = parse("1 != 3.0d"); assertCantCompile(expression); expression = parse("T(Integer).valueOf(3) != 4"); - assertTrue((Boolean)expression.getValue()); + assertTrue((Boolean) expression.getValue()); assertCanCompile(expression); - assertTrue((Boolean)expression.getValue()); + assertTrue((Boolean) expression.getValue()); expression = parse("T(Integer).valueOf(3) != T(Integer).valueOf(3)"); - assertFalse((Boolean)expression.getValue()); + assertFalse((Boolean) expression.getValue()); assertCanCompile(expression); - assertFalse((Boolean)expression.getValue()); + assertFalse((Boolean) expression.getValue()); expression = parse("5 != T(Integer).valueOf(3)"); - assertTrue((Boolean)expression.getValue()); + assertTrue((Boolean) expression.getValue()); assertCanCompile(expression); - assertTrue((Boolean)expression.getValue()); + assertTrue((Boolean) expression.getValue()); expression = parse("T(Float).valueOf(3.0f) != 4.0f"); - assertTrue((Boolean)expression.getValue()); + assertTrue((Boolean) expression.getValue()); assertCanCompile(expression); - assertTrue((Boolean)expression.getValue()); + assertTrue((Boolean) expression.getValue()); expression = parse("T(Float).valueOf(3.0f) != T(Float).valueOf(3.0f)"); - assertFalse((Boolean)expression.getValue()); + assertFalse((Boolean) expression.getValue()); assertCanCompile(expression); - assertFalse((Boolean)expression.getValue()); + assertFalse((Boolean) expression.getValue()); expression = parse("5.0f != T(Float).valueOf(3.0f)"); - assertTrue((Boolean)expression.getValue()); + assertTrue((Boolean) expression.getValue()); assertCanCompile(expression); - assertTrue((Boolean)expression.getValue()); + assertTrue((Boolean) expression.getValue()); expression = parse("T(Long).valueOf(3L) != 4L"); - assertTrue((Boolean)expression.getValue()); + assertTrue((Boolean) expression.getValue()); assertCanCompile(expression); - assertTrue((Boolean)expression.getValue()); + assertTrue((Boolean) expression.getValue()); expression = parse("T(Long).valueOf(3L) != T(Long).valueOf(3L)"); - assertFalse((Boolean)expression.getValue()); + assertFalse((Boolean) expression.getValue()); assertCanCompile(expression); - assertFalse((Boolean)expression.getValue()); + assertFalse((Boolean) expression.getValue()); expression = parse("5L != T(Long).valueOf(3L)"); - assertTrue((Boolean)expression.getValue()); + assertTrue((Boolean) expression.getValue()); assertCanCompile(expression); - assertTrue((Boolean)expression.getValue()); + assertTrue((Boolean) expression.getValue()); expression = parse("T(Double).valueOf(3.0d) == 4.0d"); - assertFalse((Boolean)expression.getValue()); + assertFalse((Boolean) expression.getValue()); assertCanCompile(expression); - assertFalse((Boolean)expression.getValue()); + assertFalse((Boolean) expression.getValue()); expression = parse("T(Double).valueOf(3.0d) == T(Double).valueOf(3.0d)"); - assertTrue((Boolean)expression.getValue()); + assertTrue((Boolean) expression.getValue()); assertCanCompile(expression); - assertTrue((Boolean)expression.getValue()); + assertTrue((Boolean) expression.getValue()); expression = parse("5.0d == T(Double).valueOf(3.0d)"); - assertFalse((Boolean)expression.getValue()); + assertFalse((Boolean) expression.getValue()); assertCanCompile(expression); - assertFalse((Boolean)expression.getValue()); + assertFalse((Boolean) expression.getValue()); expression = parse("false == true"); - assertFalse((Boolean)expression.getValue()); + assertFalse((Boolean) expression.getValue()); assertCanCompile(expression); - assertFalse((Boolean)expression.getValue()); + assertFalse((Boolean) expression.getValue()); expression = parse("T(Boolean).valueOf('true') == T(Boolean).valueOf('true')"); - assertTrue((Boolean)expression.getValue()); + assertTrue((Boolean) expression.getValue()); assertCanCompile(expression); - assertTrue((Boolean)expression.getValue()); + assertTrue((Boolean) expression.getValue()); expression = parse("T(Boolean).valueOf('true') == true"); - assertTrue((Boolean)expression.getValue()); + assertTrue((Boolean) expression.getValue()); assertCanCompile(expression); - assertTrue((Boolean)expression.getValue()); + assertTrue((Boolean) expression.getValue()); expression = parse("false == T(Boolean).valueOf('false')"); - assertTrue((Boolean)expression.getValue()); + assertTrue((Boolean) expression.getValue()); assertCanCompile(expression); - assertTrue((Boolean)expression.getValue()); + assertTrue((Boolean) expression.getValue()); + } + + @Test + public void opNe_SPR14863() throws Exception { + SpelParserConfiguration configuration = + new SpelParserConfiguration(SpelCompilerMode.MIXED, ClassLoader.getSystemClassLoader()); + SpelExpressionParser parser = new SpelExpressionParser(configuration); + Expression expression = parser.parseExpression("data['my-key'] != 'my-value'"); + + Map data = new HashMap<>(); + data.put("my-key", new String("my-value")); + StandardEvaluationContext context = new StandardEvaluationContext(new MyContext(data)); + assertFalse(expression.getValue(context, Boolean.class)); + assertCanCompile(expression); + ((SpelExpression) expression).compileExpression(); + assertFalse(expression.getValue(context, Boolean.class)); + + List ls = new ArrayList(); + ls.add(new String("foo")); + context = new StandardEvaluationContext(ls); + expression = parse("get(0) != 'foo'"); + assertFalse(expression.getValue(context, Boolean.class)); + assertCanCompile(expression); + assertFalse(expression.getValue(context, Boolean.class)); + + ls.remove(0); + ls.add("goo"); + assertTrue(expression.getValue(context, Boolean.class)); + } + + @Test + public void opEq_SPR14863() throws Exception { + // Exercise the comparator invocation code that runs in + // equalityCheck() (called from interpreted and compiled code) + expression = parser.parseExpression("#aa==#bb"); + StandardEvaluationContext sec = new StandardEvaluationContext(); + Apple aa = new Apple(1); + Apple bb = new Apple(2); + sec.setVariable("aa",aa); + sec.setVariable("bb",bb); + boolean b = expression.getValue(sec, Boolean.class); + // Verify what the expression caused aa to be compared to + assertEquals(bb,aa.gotComparedTo); + assertFalse(b); + bb.setValue(1); + b = expression.getValue(sec, Boolean.class); + assertEquals(bb,aa.gotComparedTo); + assertTrue(b); + + assertCanCompile(expression); + + // Similar test with compiled expression + aa = new Apple(99); + bb = new Apple(100); + sec.setVariable("aa",aa); + sec.setVariable("bb",bb); + b = expression.getValue(sec, Boolean.class); + assertFalse(b); + assertEquals(bb,aa.gotComparedTo); + bb.setValue(99); + b = expression.getValue(sec, Boolean.class); + assertTrue(b); + assertEquals(bb,aa.gotComparedTo); + + + List ls = new ArrayList(); + ls.add(new String("foo")); + StandardEvaluationContext context = new StandardEvaluationContext(ls); + expression = parse("get(0) == 'foo'"); + assertTrue(expression.getValue(context, Boolean.class)); + assertCanCompile(expression); + assertTrue(expression.getValue(context, Boolean.class)); + + ls.remove(0); + ls.add("goo"); + assertFalse(expression.getValue(context, Boolean.class)); } @Test @@ -1628,92 +1703,92 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { expression = parse("2+2"); expression.getValue(); assertCanCompile(expression); - assertEquals(4,expression.getValue()); + assertEquals(4, expression.getValue()); expression = parse("2L+2L"); expression.getValue(); assertCanCompile(expression); - assertEquals(4L,expression.getValue()); + assertEquals(4L, expression.getValue()); expression = parse("2.0f+2.0f"); expression.getValue(); assertCanCompile(expression); - assertEquals(4.0f,expression.getValue()); + assertEquals(4.0f, expression.getValue()); expression = parse("3.0d+4.0d"); expression.getValue(); assertCanCompile(expression); - assertEquals(7.0d,expression.getValue()); + assertEquals(7.0d, expression.getValue()); expression = parse("+1"); expression.getValue(); assertCanCompile(expression); - assertEquals(1,expression.getValue()); + assertEquals(1, expression.getValue()); expression = parse("+1L"); expression.getValue(); assertCanCompile(expression); - assertEquals(1L,expression.getValue()); + assertEquals(1L, expression.getValue()); expression = parse("+1.5f"); expression.getValue(); assertCanCompile(expression); - assertEquals(1.5f,expression.getValue()); + assertEquals(1.5f, expression.getValue()); expression = parse("+2.5d"); expression.getValue(); assertCanCompile(expression); - assertEquals(2.5d,expression.getValue()); + assertEquals(2.5d, expression.getValue()); expression = parse("+T(Double).valueOf(2.5d)"); expression.getValue(); assertCanCompile(expression); - assertEquals(2.5d,expression.getValue()); + assertEquals(2.5d, expression.getValue()); expression = parse("T(Integer).valueOf(2)+6"); - assertEquals(8,expression.getValue()); + assertEquals(8, expression.getValue()); assertCanCompile(expression); - assertEquals(8,expression.getValue()); + assertEquals(8, expression.getValue()); expression = parse("T(Integer).valueOf(1)+T(Integer).valueOf(3)"); - assertEquals(4,expression.getValue()); + assertEquals(4, expression.getValue()); assertCanCompile(expression); - assertEquals(4,expression.getValue()); + assertEquals(4, expression.getValue()); expression = parse("1+T(Integer).valueOf(3)"); - assertEquals(4,expression.getValue()); + assertEquals(4, expression.getValue()); assertCanCompile(expression); - assertEquals(4,expression.getValue()); + assertEquals(4, expression.getValue()); expression = parse("T(Float).valueOf(2.0f)+6"); - assertEquals(8.0f,expression.getValue()); + assertEquals(8.0f, expression.getValue()); assertCanCompile(expression); - assertEquals(8.0f,expression.getValue()); + assertEquals(8.0f, expression.getValue()); expression = parse("T(Float).valueOf(2.0f)+T(Float).valueOf(3.0f)"); - assertEquals(5.0f,expression.getValue()); + assertEquals(5.0f, expression.getValue()); assertCanCompile(expression); - assertEquals(5.0f,expression.getValue()); + assertEquals(5.0f, expression.getValue()); expression = parse("3L+T(Long).valueOf(4L)"); - assertEquals(7L,expression.getValue()); + assertEquals(7L, expression.getValue()); assertCanCompile(expression); - assertEquals(7L,expression.getValue()); + assertEquals(7L, expression.getValue()); expression = parse("T(Long).valueOf(2L)+6"); - assertEquals(8L,expression.getValue()); + assertEquals(8L, expression.getValue()); assertCanCompile(expression); - assertEquals(8L,expression.getValue()); + assertEquals(8L, expression.getValue()); expression = parse("T(Long).valueOf(2L)+T(Long).valueOf(3L)"); - assertEquals(5L,expression.getValue()); + assertEquals(5L, expression.getValue()); assertCanCompile(expression); - assertEquals(5L,expression.getValue()); + assertEquals(5L, expression.getValue()); expression = parse("1L+T(Long).valueOf(2L)"); - assertEquals(3L,expression.getValue()); + assertEquals(3L, expression.getValue()); assertCanCompile(expression); - assertEquals(3L,expression.getValue()); + assertEquals(3L, expression.getValue()); } @Test @@ -2082,86 +2157,86 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { private void checkCalc(PayloadX p, String expression, int expectedResult) { Expression expr = parse(expression); - assertEquals(expectedResult,expr.getValue(p)); + assertEquals(expectedResult, expr.getValue(p)); assertCanCompile(expr); - assertEquals(expectedResult,expr.getValue(p)); + assertEquals(expectedResult, expr.getValue(p)); } private void checkCalc(PayloadX p, String expression, float expectedResult) { Expression expr = parse(expression); - assertEquals(expectedResult,expr.getValue(p)); + assertEquals(expectedResult, expr.getValue(p)); assertCanCompile(expr); - assertEquals(expectedResult,expr.getValue(p)); + assertEquals(expectedResult, expr.getValue(p)); } private void checkCalc(PayloadX p, String expression, long expectedResult) { Expression expr = parse(expression); - assertEquals(expectedResult,expr.getValue(p)); + assertEquals(expectedResult, expr.getValue(p)); assertCanCompile(expr); - assertEquals(expectedResult,expr.getValue(p)); + assertEquals(expectedResult, expr.getValue(p)); } private void checkCalc(PayloadX p, String expression, double expectedResult) { Expression expr = parse(expression); - assertEquals(expectedResult,expr.getValue(p)); + assertEquals(expectedResult, expr.getValue(p)); assertCanCompile(expr); - assertEquals(expectedResult,expr.getValue(p)); + assertEquals(expectedResult, expr.getValue(p)); } @Test public void opPlusString() throws Exception { expression = parse("'hello' + 'world'"); - assertEquals("helloworld",expression.getValue()); + assertEquals("helloworld", expression.getValue()); assertCanCompile(expression); - assertEquals("helloworld",expression.getValue()); + assertEquals("helloworld", expression.getValue()); // Method with string return expression = parse("'hello' + getWorld()"); - assertEquals("helloworld",expression.getValue(new Greeter())); + assertEquals("helloworld", expression.getValue(new Greeter())); assertCanCompile(expression); - assertEquals("helloworld",expression.getValue(new Greeter())); + assertEquals("helloworld", expression.getValue(new Greeter())); // Method with string return expression = parse("getWorld() + 'hello'"); - assertEquals("worldhello",expression.getValue(new Greeter())); + assertEquals("worldhello", expression.getValue(new Greeter())); assertCanCompile(expression); - assertEquals("worldhello",expression.getValue(new Greeter())); + assertEquals("worldhello", expression.getValue(new Greeter())); // Three strings, optimal bytecode would only use one StringBuilder expression = parse("'hello' + getWorld() + ' spring'"); - assertEquals("helloworld spring",expression.getValue(new Greeter())); + assertEquals("helloworld spring", expression.getValue(new Greeter())); assertCanCompile(expression); - assertEquals("helloworld spring",expression.getValue(new Greeter())); + assertEquals("helloworld spring", expression.getValue(new Greeter())); // Three strings, optimal bytecode would only use one StringBuilder expression = parse("'hello' + 3 + ' spring'"); - assertEquals("hello3 spring",expression.getValue(new Greeter())); + assertEquals("hello3 spring", expression.getValue(new Greeter())); assertCantCompile(expression); expression = parse("object + 'a'"); - assertEquals("objecta",expression.getValue(new Greeter())); + assertEquals("objecta", expression.getValue(new Greeter())); assertCanCompile(expression); - assertEquals("objecta",expression.getValue(new Greeter())); + assertEquals("objecta", expression.getValue(new Greeter())); expression = parse("'a'+object"); - assertEquals("aobject",expression.getValue(new Greeter())); + assertEquals("aobject", expression.getValue(new Greeter())); assertCanCompile(expression); - assertEquals("aobject",expression.getValue(new Greeter())); + assertEquals("aobject", expression.getValue(new Greeter())); expression = parse("'a'+object+'a'"); - assertEquals("aobjecta",expression.getValue(new Greeter())); + assertEquals("aobjecta", expression.getValue(new Greeter())); assertCanCompile(expression); - assertEquals("aobjecta",expression.getValue(new Greeter())); + assertEquals("aobjecta", expression.getValue(new Greeter())); expression = parse("object+'a'+object"); - assertEquals("objectaobject",expression.getValue(new Greeter())); + assertEquals("objectaobject", expression.getValue(new Greeter())); assertCanCompile(expression); - assertEquals("objectaobject",expression.getValue(new Greeter())); + assertEquals("objectaobject", expression.getValue(new Greeter())); expression = parse("object+object"); - assertEquals("objectobject",expression.getValue(new Greeter())); + assertEquals("objectobject", expression.getValue(new Greeter())); assertCanCompile(expression); - assertEquals("objectobject",expression.getValue(new Greeter())); + assertEquals("objectobject", expression.getValue(new Greeter())); } @Test @@ -2169,87 +2244,87 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { expression = parse("2-2"); expression.getValue(); assertCanCompile(expression); - assertEquals(0,expression.getValue()); + assertEquals(0, expression.getValue()); expression = parse("4L-2L"); expression.getValue(); assertCanCompile(expression); - assertEquals(2L,expression.getValue()); + assertEquals(2L, expression.getValue()); expression = parse("4.0f-2.0f"); expression.getValue(); assertCanCompile(expression); - assertEquals(2.0f,expression.getValue()); + assertEquals(2.0f, expression.getValue()); expression = parse("3.0d-4.0d"); expression.getValue(); assertCanCompile(expression); - assertEquals(-1.0d,expression.getValue()); + assertEquals(-1.0d, expression.getValue()); expression = parse("-1"); expression.getValue(); assertCanCompile(expression); - assertEquals(-1,expression.getValue()); + assertEquals(-1, expression.getValue()); expression = parse("-1L"); expression.getValue(); assertCanCompile(expression); - assertEquals(-1L,expression.getValue()); + assertEquals(-1L, expression.getValue()); expression = parse("-1.5f"); expression.getValue(); assertCanCompile(expression); - assertEquals(-1.5f,expression.getValue()); + assertEquals(-1.5f, expression.getValue()); expression = parse("-2.5d"); expression.getValue(); assertCanCompile(expression); - assertEquals(-2.5d,expression.getValue()); + assertEquals(-2.5d, expression.getValue()); expression = parse("T(Integer).valueOf(2)-6"); - assertEquals(-4,expression.getValue()); + assertEquals(-4, expression.getValue()); assertCanCompile(expression); - assertEquals(-4,expression.getValue()); + assertEquals(-4, expression.getValue()); expression = parse("T(Integer).valueOf(1)-T(Integer).valueOf(3)"); - assertEquals(-2,expression.getValue()); + assertEquals(-2, expression.getValue()); assertCanCompile(expression); - assertEquals(-2,expression.getValue()); + assertEquals(-2, expression.getValue()); expression = parse("4-T(Integer).valueOf(3)"); - assertEquals(1,expression.getValue()); + assertEquals(1, expression.getValue()); assertCanCompile(expression); - assertEquals(1,expression.getValue()); + assertEquals(1, expression.getValue()); expression = parse("T(Float).valueOf(2.0f)-6"); - assertEquals(-4.0f,expression.getValue()); + assertEquals(-4.0f, expression.getValue()); assertCanCompile(expression); - assertEquals(-4.0f,expression.getValue()); + assertEquals(-4.0f, expression.getValue()); expression = parse("T(Float).valueOf(8.0f)-T(Float).valueOf(3.0f)"); - assertEquals(5.0f,expression.getValue()); + assertEquals(5.0f, expression.getValue()); assertCanCompile(expression); - assertEquals(5.0f,expression.getValue()); + assertEquals(5.0f, expression.getValue()); expression = parse("11L-T(Long).valueOf(4L)"); - assertEquals(7L,expression.getValue()); + assertEquals(7L, expression.getValue()); assertCanCompile(expression); - assertEquals(7L,expression.getValue()); + assertEquals(7L, expression.getValue()); expression = parse("T(Long).valueOf(9L)-6"); - assertEquals(3L,expression.getValue()); + assertEquals(3L, expression.getValue()); assertCanCompile(expression); - assertEquals(3L,expression.getValue()); + assertEquals(3L, expression.getValue()); expression = parse("T(Long).valueOf(4L)-T(Long).valueOf(3L)"); - assertEquals(1L,expression.getValue()); + assertEquals(1L, expression.getValue()); assertCanCompile(expression); - assertEquals(1L,expression.getValue()); + assertEquals(1L, expression.getValue()); expression = parse("8L-T(Long).valueOf(2L)"); - assertEquals(6L,expression.getValue()); + assertEquals(6L, expression.getValue()); assertCanCompile(expression); - assertEquals(6L,expression.getValue()); + assertEquals(6L, expression.getValue()); } @Test @@ -2616,7 +2691,6 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { checkCalc(p,"payload.valueI*payload.valueBB20",2400); } - @Test public void opModulus_mixedNumberTypes() throws Exception { PayloadX p = new PayloadX(); @@ -2804,57 +2878,57 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { expression = parse("2*2"); expression.getValue(); assertCanCompile(expression); - assertEquals(4,expression.getValue()); + assertEquals(4, expression.getValue()); expression = parse("2L*2L"); expression.getValue(); assertCanCompile(expression); - assertEquals(4L,expression.getValue()); + assertEquals(4L, expression.getValue()); expression = parse("2.0f*2.0f"); expression.getValue(); assertCanCompile(expression); - assertEquals(4.0f,expression.getValue()); + assertEquals(4.0f, expression.getValue()); expression = parse("3.0d*4.0d"); expression.getValue(); assertCanCompile(expression); - assertEquals(12.0d,expression.getValue()); + assertEquals(12.0d, expression.getValue()); expression = parse("T(Float).valueOf(2.0f)*6"); - assertEquals(12.0f,expression.getValue()); + assertEquals(12.0f, expression.getValue()); assertCanCompile(expression); - assertEquals(12.0f,expression.getValue()); + assertEquals(12.0f, expression.getValue()); expression = parse("T(Float).valueOf(8.0f)*T(Float).valueOf(3.0f)"); - assertEquals(24.0f,expression.getValue()); + assertEquals(24.0f, expression.getValue()); assertCanCompile(expression); - assertEquals(24.0f,expression.getValue()); + assertEquals(24.0f, expression.getValue()); expression = parse("11L*T(Long).valueOf(4L)"); - assertEquals(44L,expression.getValue()); + assertEquals(44L, expression.getValue()); assertCanCompile(expression); - assertEquals(44L,expression.getValue()); + assertEquals(44L, expression.getValue()); expression = parse("T(Long).valueOf(9L)*6"); - assertEquals(54L,expression.getValue()); + assertEquals(54L, expression.getValue()); assertCanCompile(expression); - assertEquals(54L,expression.getValue()); + assertEquals(54L, expression.getValue()); expression = parse("T(Long).valueOf(4L)*T(Long).valueOf(3L)"); - assertEquals(12L,expression.getValue()); + assertEquals(12L, expression.getValue()); assertCanCompile(expression); - assertEquals(12L,expression.getValue()); + assertEquals(12L, expression.getValue()); expression = parse("8L*T(Long).valueOf(2L)"); - assertEquals(16L,expression.getValue()); + assertEquals(16L, expression.getValue()); assertCanCompile(expression); - assertEquals(16L,expression.getValue()); + assertEquals(16L, expression.getValue()); expression = parse("T(Float).valueOf(8.0f)*-T(Float).valueOf(3.0f)"); - assertEquals(-24.0f,expression.getValue()); + assertEquals(-24.0f, expression.getValue()); assertCanCompile(expression); - assertEquals(-24.0f,expression.getValue()); + assertEquals(-24.0f, expression.getValue()); } @Test @@ -2862,132 +2936,132 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { expression = parse("2/2"); expression.getValue(); assertCanCompile(expression); - assertEquals(1,expression.getValue()); + assertEquals(1, expression.getValue()); expression = parse("2L/2L"); expression.getValue(); assertCanCompile(expression); - assertEquals(1L,expression.getValue()); + assertEquals(1L, expression.getValue()); expression = parse("2.0f/2.0f"); expression.getValue(); assertCanCompile(expression); - assertEquals(1.0f,expression.getValue()); + assertEquals(1.0f, expression.getValue()); expression = parse("3.0d/4.0d"); expression.getValue(); assertCanCompile(expression); - assertEquals(0.75d,expression.getValue()); + assertEquals(0.75d, expression.getValue()); expression = parse("T(Float).valueOf(6.0f)/2"); - assertEquals(3.0f,expression.getValue()); + assertEquals(3.0f, expression.getValue()); assertCanCompile(expression); - assertEquals(3.0f,expression.getValue()); + assertEquals(3.0f, expression.getValue()); expression = parse("T(Float).valueOf(8.0f)/T(Float).valueOf(2.0f)"); - assertEquals(4.0f,expression.getValue()); + assertEquals(4.0f, expression.getValue()); assertCanCompile(expression); - assertEquals(4.0f,expression.getValue()); + assertEquals(4.0f, expression.getValue()); expression = parse("12L/T(Long).valueOf(4L)"); - assertEquals(3L,expression.getValue()); + assertEquals(3L, expression.getValue()); assertCanCompile(expression); - assertEquals(3L,expression.getValue()); + assertEquals(3L, expression.getValue()); expression = parse("T(Long).valueOf(44L)/11"); - assertEquals(4L,expression.getValue()); + assertEquals(4L, expression.getValue()); assertCanCompile(expression); - assertEquals(4L,expression.getValue()); + assertEquals(4L, expression.getValue()); expression = parse("T(Long).valueOf(4L)/T(Long).valueOf(2L)"); - assertEquals(2L,expression.getValue()); + assertEquals(2L, expression.getValue()); assertCanCompile(expression); - assertEquals(2L,expression.getValue()); + assertEquals(2L, expression.getValue()); expression = parse("8L/T(Long).valueOf(2L)"); - assertEquals(4L,expression.getValue()); + assertEquals(4L, expression.getValue()); assertCanCompile(expression); - assertEquals(4L,expression.getValue()); + assertEquals(4L, expression.getValue()); expression = parse("T(Float).valueOf(8.0f)/-T(Float).valueOf(4.0f)"); - assertEquals(-2.0f,expression.getValue()); + assertEquals(-2.0f, expression.getValue()); assertCanCompile(expression); - assertEquals(-2.0f,expression.getValue()); + assertEquals(-2.0f, expression.getValue()); } @Test public void opModulus_12041() throws Exception { expression = parse("2%2"); - assertEquals(0,expression.getValue()); + assertEquals(0, expression.getValue()); assertCanCompile(expression); - assertEquals(0,expression.getValue()); + assertEquals(0, expression.getValue()); expression = parse("payload%2==0"); - assertTrue(expression.getValue(new GenericMessageTestHelper(4),Boolean.TYPE)); - assertFalse(expression.getValue(new GenericMessageTestHelper(5),Boolean.TYPE)); + assertTrue(expression.getValue(new GenericMessageTestHelper<>(4), Boolean.TYPE)); + assertFalse(expression.getValue(new GenericMessageTestHelper<>(5), Boolean.TYPE)); assertCanCompile(expression); - assertTrue(expression.getValue(new GenericMessageTestHelper(4),Boolean.TYPE)); - assertFalse(expression.getValue(new GenericMessageTestHelper(5),Boolean.TYPE)); + assertTrue(expression.getValue(new GenericMessageTestHelper<>(4), Boolean.TYPE)); + assertFalse(expression.getValue(new GenericMessageTestHelper<>(5), Boolean.TYPE)); expression = parse("8%3"); - assertEquals(2,expression.getValue()); + assertEquals(2, expression.getValue()); assertCanCompile(expression); - assertEquals(2,expression.getValue()); + assertEquals(2, expression.getValue()); expression = parse("17L%5L"); - assertEquals(2L,expression.getValue()); + assertEquals(2L, expression.getValue()); assertCanCompile(expression); - assertEquals(2L,expression.getValue()); + assertEquals(2L, expression.getValue()); expression = parse("3.0f%2.0f"); - assertEquals(1.0f,expression.getValue()); + assertEquals(1.0f, expression.getValue()); assertCanCompile(expression); - assertEquals(1.0f,expression.getValue()); + assertEquals(1.0f, expression.getValue()); expression = parse("3.0d%4.0d"); - assertEquals(3.0d,expression.getValue()); + assertEquals(3.0d, expression.getValue()); assertCanCompile(expression); - assertEquals(3.0d,expression.getValue()); + assertEquals(3.0d, expression.getValue()); expression = parse("T(Float).valueOf(6.0f)%2"); - assertEquals(0.0f,expression.getValue()); + assertEquals(0.0f, expression.getValue()); assertCanCompile(expression); - assertEquals(0.0f,expression.getValue()); + assertEquals(0.0f, expression.getValue()); expression = parse("T(Float).valueOf(6.0f)%4"); - assertEquals(2.0f,expression.getValue()); + assertEquals(2.0f, expression.getValue()); assertCanCompile(expression); - assertEquals(2.0f,expression.getValue()); + assertEquals(2.0f, expression.getValue()); expression = parse("T(Float).valueOf(8.0f)%T(Float).valueOf(3.0f)"); - assertEquals(2.0f,expression.getValue()); + assertEquals(2.0f, expression.getValue()); assertCanCompile(expression); - assertEquals(2.0f,expression.getValue()); + assertEquals(2.0f, expression.getValue()); expression = parse("13L%T(Long).valueOf(4L)"); - assertEquals(1L,expression.getValue()); + assertEquals(1L, expression.getValue()); assertCanCompile(expression); - assertEquals(1L,expression.getValue()); + assertEquals(1L, expression.getValue()); expression = parse("T(Long).valueOf(44L)%12"); - assertEquals(8L,expression.getValue()); + assertEquals(8L, expression.getValue()); assertCanCompile(expression); - assertEquals(8L,expression.getValue()); + assertEquals(8L, expression.getValue()); expression = parse("T(Long).valueOf(9L)%T(Long).valueOf(2L)"); - assertEquals(1L,expression.getValue()); + assertEquals(1L, expression.getValue()); assertCanCompile(expression); - assertEquals(1L,expression.getValue()); + assertEquals(1L, expression.getValue()); expression = parse("7L%T(Long).valueOf(2L)"); - assertEquals(1L,expression.getValue()); + assertEquals(1L, expression.getValue()); assertCanCompile(expression); - assertEquals(1L,expression.getValue()); + assertEquals(1L, expression.getValue()); expression = parse("T(Float).valueOf(9.0f)%-T(Float).valueOf(4.0f)"); - assertEquals(1.0f,expression.getValue()); + assertEquals(1.0f, expression.getValue()); assertCanCompile(expression); - assertEquals(1.0f,expression.getValue()); + assertEquals(1.0f, expression.getValue()); } @Test @@ -3013,9 +3087,9 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { public void constructorReference_SPR13781() { // Static field access on a T() referenced type expression = parser.parseExpression("T(java.util.Locale).ENGLISH"); - assertEquals("en",expression.getValue().toString()); + assertEquals("en", expression.getValue().toString()); assertCanCompile(expression); - assertEquals("en",expression.getValue().toString()); + assertEquals("en", expression.getValue().toString()); // The actual expression from the bug report. It fails if the ENGLISH reference fails // to pop the type reference for Locale off the stack (if it isn't popped then @@ -3026,28 +3100,28 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { StandardEvaluationContext context = new StandardEvaluationContext(); context.setVariable("userId", "RoDnEy"); - assertEquals("rodney",expression.getValue(context)); + assertEquals("rodney", expression.getValue(context)); assertCanCompile(expression); - assertEquals("rodney",expression.getValue(context)); + assertEquals("rodney", expression.getValue(context)); // Property access on a class object expression = parser.parseExpression("T(String).name"); - assertEquals("java.lang.String",expression.getValue()); + assertEquals("java.lang.String", expression.getValue()); assertCanCompile(expression); - assertEquals("java.lang.String",expression.getValue()); + assertEquals("java.lang.String", expression.getValue()); // Now the type reference isn't on the stack, and needs loading context = new StandardEvaluationContext(String.class); expression = parser.parseExpression("name"); - assertEquals("java.lang.String",expression.getValue(context)); + assertEquals("java.lang.String", expression.getValue(context)); assertCanCompile(expression); - assertEquals("java.lang.String",expression.getValue(context)); + assertEquals("java.lang.String", expression.getValue(context)); expression = parser.parseExpression("T(String).getName()"); - assertEquals("java.lang.String",expression.getValue()); + assertEquals("java.lang.String", expression.getValue()); assertCanCompile(expression); - assertEquals("java.lang.String",expression.getValue()); - + assertEquals("java.lang.String", expression.getValue()); + // These tests below verify that the chain of static accesses (either method/property or field) // leave the right thing on top of the stack for processing by any outer consuming code. // Here the consuming code is the String.valueOf() function. If the wrong thing were on @@ -3057,110 +3131,110 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { String shclass = StaticsHelper.class.getName(); // Basic chain: property access then method access expression = parser.parseExpression("T(String).valueOf(T(String).name.valueOf(1))"); - assertEquals("1",expression.getValue()); + assertEquals("1", expression.getValue()); assertCanCompile(expression); - assertEquals("1",expression.getValue()); + assertEquals("1", expression.getValue()); // chain of statics ending with static method - expression = parser.parseExpression("T(String).valueOf(T("+shclass+").methoda().methoda().methodb())"); - assertEquals("mb",expression.getValue()); + expression = parser.parseExpression("T(String).valueOf(T(" + shclass + ").methoda().methoda().methodb())"); + assertEquals("mb", expression.getValue()); assertCanCompile(expression); - assertEquals("mb",expression.getValue()); + assertEquals("mb", expression.getValue()); // chain of statics ending with static field - expression = parser.parseExpression("T(String).valueOf(T("+shclass+").fielda.fielda.fieldb)"); - assertEquals("fb",expression.getValue()); + expression = parser.parseExpression("T(String).valueOf(T(" + shclass + ").fielda.fielda.fieldb)"); + assertEquals("fb", expression.getValue()); assertCanCompile(expression); - assertEquals("fb",expression.getValue()); + assertEquals("fb", expression.getValue()); // chain of statics ending with static property access - expression = parser.parseExpression("T(String).valueOf(T("+shclass+").propertya.propertya.propertyb)"); - assertEquals("pb",expression.getValue()); + expression = parser.parseExpression("T(String).valueOf(T(" + shclass + ").propertya.propertya.propertyb)"); + assertEquals("pb", expression.getValue()); assertCanCompile(expression); - assertEquals("pb",expression.getValue()); + assertEquals("pb", expression.getValue()); // variety chain - expression = parser.parseExpression("T(String).valueOf(T("+shclass+").fielda.methoda().propertya.fieldb)"); - assertEquals("fb",expression.getValue()); + expression = parser.parseExpression("T(String).valueOf(T(" + shclass + ").fielda.methoda().propertya.fieldb)"); + assertEquals("fb", expression.getValue()); assertCanCompile(expression); - assertEquals("fb",expression.getValue()); + assertEquals("fb", expression.getValue()); expression = parser.parseExpression("T(String).valueOf(fielda.fieldb)"); - assertEquals("fb",expression.getValue(StaticsHelper.sh)); + assertEquals("fb", expression.getValue(StaticsHelper.sh)); assertCanCompile(expression); - assertEquals("fb",expression.getValue(StaticsHelper.sh)); - + assertEquals("fb", expression.getValue(StaticsHelper.sh)); + expression = parser.parseExpression("T(String).valueOf(propertya.propertyb)"); - assertEquals("pb",expression.getValue(StaticsHelper.sh)); + assertEquals("pb", expression.getValue(StaticsHelper.sh)); assertCanCompile(expression); - assertEquals("pb",expression.getValue(StaticsHelper.sh)); + assertEquals("pb", expression.getValue(StaticsHelper.sh)); expression = parser.parseExpression("T(String).valueOf(methoda().methodb())"); - assertEquals("mb",expression.getValue(StaticsHelper.sh)); + assertEquals("mb", expression.getValue(StaticsHelper.sh)); assertCanCompile(expression); - assertEquals("mb",expression.getValue(StaticsHelper.sh)); - + assertEquals("mb", expression.getValue(StaticsHelper.sh)); + } @Test public void constructorReference_SPR12326() { - String type = this.getClass().getName(); - String prefix = "new "+type+".Obj"; + String type = getClass().getName(); + String prefix = "new " + type + ".Obj"; - expression = parser.parseExpression(prefix+"([0])"); - assertEquals("test", ((Obj) expression.getValue(new Object[] { "test" })).param1); + expression = parser.parseExpression(prefix + "([0])"); + assertEquals("test", ((Obj) expression.getValue(new Object[] {"test"})).param1); assertCanCompile(expression); - assertEquals("test", ((Obj) expression.getValue(new Object[] { "test" })).param1); + assertEquals("test", ((Obj) expression.getValue(new Object[] {"test"})).param1); - expression = parser.parseExpression(prefix+"2('foo','bar').output"); + expression = parser.parseExpression(prefix + "2('foo','bar').output"); assertEquals("foobar", expression.getValue(String.class)); assertCanCompile(expression); assertEquals("foobar", expression.getValue(String.class)); - expression = parser.parseExpression(prefix+"2('foo').output"); + expression = parser.parseExpression(prefix + "2('foo').output"); assertEquals("foo", expression.getValue(String.class)); assertCanCompile(expression); assertEquals("foo", expression.getValue(String.class)); - expression = parser.parseExpression(prefix+"2().output"); + expression = parser.parseExpression(prefix + "2().output"); assertEquals("", expression.getValue(String.class)); assertCanCompile(expression); assertEquals("", expression.getValue(String.class)); - expression = parser.parseExpression(prefix+"3(1,2,3).output"); + expression = parser.parseExpression(prefix + "3(1,2,3).output"); assertEquals("123", expression.getValue(String.class)); assertCanCompile(expression); assertEquals("123", expression.getValue(String.class)); - expression = parser.parseExpression(prefix+"3(1).output"); + expression = parser.parseExpression(prefix + "3(1).output"); assertEquals("1", expression.getValue(String.class)); assertCanCompile(expression); assertEquals("1", expression.getValue(String.class)); - expression = parser.parseExpression(prefix+"3().output"); + expression = parser.parseExpression(prefix + "3().output"); assertEquals("", expression.getValue(String.class)); assertCanCompile(expression); assertEquals("", expression.getValue(String.class)); - expression = parser.parseExpression(prefix+"3('abc',5.0f,1,2,3).output"); + expression = parser.parseExpression(prefix + "3('abc',5.0f,1,2,3).output"); assertEquals("abc:5.0:123", expression.getValue(String.class)); assertCanCompile(expression); assertEquals("abc:5.0:123", expression.getValue(String.class)); - expression = parser.parseExpression(prefix+"3('abc',5.0f,1).output"); + expression = parser.parseExpression(prefix + "3('abc',5.0f,1).output"); assertEquals("abc:5.0:1", expression.getValue(String.class)); assertCanCompile(expression); assertEquals("abc:5.0:1", expression.getValue(String.class)); - expression = parser.parseExpression(prefix+"3('abc',5.0f).output"); + expression = parser.parseExpression(prefix + "3('abc',5.0f).output"); assertEquals("abc:5.0:", expression.getValue(String.class)); assertCanCompile(expression); assertEquals("abc:5.0:", expression.getValue(String.class)); - expression = parser.parseExpression(prefix+"4(#root).output"); - assertEquals("123", expression.getValue(new int[]{1,2,3},String.class)); + expression = parser.parseExpression(prefix + "4(#root).output"); + assertEquals("123", expression.getValue(new int[] {1,2,3}, String.class)); assertCanCompile(expression); - assertEquals("123", expression.getValue(new int[]{1,2,3},String.class)); + assertEquals("123", expression.getValue(new int[] {1,2,3}, String.class)); } @Test @@ -3183,7 +3257,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { // Variant of above more like what was in the bug report: SpelExpressionParser parser = new SpelExpressionParser( new SpelParserConfiguration(SpelCompilerMode.IMMEDIATE, - this.getClass().getClassLoader())); + getClass().getClassLoader())); SpelExpression ex = parser.parseRaw("#it?.age.equals([0])"); context = new StandardEvaluationContext(new Object[] { person.getAge() }); @@ -3211,43 +3285,43 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { public void constructorReference() throws Exception { // simple ctor expression = parser.parseExpression("new String('123')"); - assertEquals("123",expression.getValue()); + assertEquals("123", expression.getValue()); assertCanCompile(expression); - assertEquals("123",expression.getValue()); + assertEquals("123", expression.getValue()); String testclass8 = "org.springframework.expression.spel.SpelCompilationCoverageTests$TestClass8"; // multi arg ctor that includes primitives - expression = parser.parseExpression("new "+testclass8+"(42,'123',4.0d,true)"); - assertEquals(testclass8,expression.getValue().getClass().getName()); + expression = parser.parseExpression("new " + testclass8 + "(42,'123',4.0d,true)"); + assertEquals(testclass8, expression.getValue().getClass().getName()); assertCanCompile(expression); Object o = expression.getValue(); assertEquals(testclass8,o.getClass().getName()); TestClass8 tc8 = (TestClass8)o; - assertEquals(42,tc8.i); - assertEquals("123",tc8.s); - assertEquals(4.0d,tc8.d,0.5d); - assertEquals(true,tc8.z); + assertEquals(42, tc8.i); + assertEquals("123", tc8.s); + assertEquals(4.0d, tc8.d,0.5d); + assertEquals(true, tc8.z); // no-arg ctor - expression = parser.parseExpression("new "+testclass8+"()"); - assertEquals(testclass8,expression.getValue().getClass().getName()); + expression = parser.parseExpression("new " + testclass8 + "()"); + assertEquals(testclass8, expression.getValue().getClass().getName()); assertCanCompile(expression); o = expression.getValue(); assertEquals(testclass8,o.getClass().getName()); // pass primitive to reference type ctor - expression = parser.parseExpression("new "+testclass8+"(42)"); - assertEquals(testclass8,expression.getValue().getClass().getName()); + expression = parser.parseExpression("new " + testclass8 + "(42)"); + assertEquals(testclass8, expression.getValue().getClass().getName()); assertCanCompile(expression); o = expression.getValue(); assertEquals(testclass8,o.getClass().getName()); - tc8 = (TestClass8)o; - assertEquals(42,tc8.i); + tc8 = (TestClass8) o; + assertEquals(42, tc8.i); // private class, can't compile it String testclass9 = "org.springframework.expression.spel.SpelCompilationCoverageTests$TestClass9"; - expression = parser.parseExpression("new "+testclass9+"(42)"); - assertEquals(testclass9,expression.getValue().getClass().getName()); + expression = parser.parseExpression("new " + testclass9 + "(42)"); + assertEquals(testclass9, expression.getValue().getClass().getName()); assertCantCompile(expression); } @@ -3260,22 +3334,22 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { expression = parser.parseExpression("concat('test')"); assertCantCompile(expression); expression.getValue(tc); - assertEquals("::test",tc.s); + assertEquals("::test", tc.s); assertCanCompile(expression); tc.reset(); expression.getValue(tc); - assertEquals("::test",tc.s); + assertEquals("::test", tc.s); tc.reset(); // This will call the varargs concat with an empty array expression = parser.parseExpression("concat()"); assertCantCompile(expression); expression.getValue(tc); - assertEquals("",tc.s); + assertEquals("", tc.s); assertCanCompile(expression); tc.reset(); expression.getValue(tc); - assertEquals("",tc.s); + assertEquals("", tc.s); tc.reset(); // Should call the non varargs version of concat @@ -3283,22 +3357,22 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { expression = parser.parseExpression("concat2('test')"); assertCantCompile(expression); expression.getValue(tc); - assertEquals("::test",tc.s); + assertEquals("::test", tc.s); assertCanCompile(expression); tc.reset(); expression.getValue(tc); - assertEquals("::test",tc.s); + assertEquals("::test", tc.s); tc.reset(); // This will call the varargs concat with an empty array expression = parser.parseExpression("concat2()"); assertCantCompile(expression); expression.getValue(tc); - assertEquals("",tc.s); + assertEquals("", tc.s); assertCanCompile(expression); tc.reset(); expression.getValue(tc); - assertEquals("",tc.s); + assertEquals("", tc.s); tc.reset(); } @@ -3310,277 +3384,277 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { expression = parser.parseExpression("eleven()"); assertCantCompile(expression); expression.getValue(tc); - assertEquals("",tc.s); + assertEquals("", tc.s); assertCanCompile(expression); tc.reset(); expression.getValue(tc); - assertEquals("",tc.s); + assertEquals("", tc.s); tc.reset(); // varargs string expression = parser.parseExpression("eleven('aaa')"); assertCantCompile(expression); expression.getValue(tc); - assertEquals("aaa",tc.s); + assertEquals("aaa", tc.s); assertCanCompile(expression); tc.reset(); expression.getValue(tc); - assertEquals("aaa",tc.s); + assertEquals("aaa", tc.s); tc.reset(); // varargs string expression = parser.parseExpression("eleven(stringArray)"); assertCantCompile(expression); expression.getValue(tc); - assertEquals("aaabbbccc",tc.s); + assertEquals("aaabbbccc", tc.s); assertCanCompile(expression); tc.reset(); expression.getValue(tc); - assertEquals("aaabbbccc",tc.s); + assertEquals("aaabbbccc", tc.s); tc.reset(); // varargs string expression = parser.parseExpression("eleven('aaa','bbb','ccc')"); assertCantCompile(expression); expression.getValue(tc); - assertEquals("aaabbbccc",tc.s); + assertEquals("aaabbbccc", tc.s); assertCanCompile(expression); tc.reset(); expression.getValue(tc); - assertEquals("aaabbbccc",tc.s); + assertEquals("aaabbbccc", tc.s); tc.reset(); expression = parser.parseExpression("sixteen('aaa','bbb','ccc')"); assertCantCompile(expression); expression.getValue(tc); - assertEquals("aaabbbccc",tc.s); + assertEquals("aaabbbccc", tc.s); assertCanCompile(expression); tc.reset(); expression.getValue(tc); - assertEquals("aaabbbccc",tc.s); + assertEquals("aaabbbccc", tc.s); tc.reset(); // TODO Fails related to conversion service converting a String[] to satisfy Object... // expression = parser.parseExpression("sixteen(stringArray)"); // assertCantCompile(expression); // expression.getValue(tc); -// assertEquals("aaabbbccc",tc.s); +// assertEquals("aaabbbccc", tc.s); // assertCanCompile(expression); // tc.reset(); // expression.getValue(tc); -// assertEquals("aaabbbccc",tc.s); +// assertEquals("aaabbbccc", tc.s); // tc.reset(); // varargs int expression = parser.parseExpression("twelve(1,2,3)"); assertCantCompile(expression); expression.getValue(tc); - assertEquals(6,tc.i); + assertEquals(6, tc.i); assertCanCompile(expression); tc.reset(); expression.getValue(tc); - assertEquals(6,tc.i); + assertEquals(6, tc.i); tc.reset(); expression = parser.parseExpression("twelve(1)"); assertCantCompile(expression); expression.getValue(tc); - assertEquals(1,tc.i); + assertEquals(1, tc.i); assertCanCompile(expression); tc.reset(); expression.getValue(tc); - assertEquals(1,tc.i); + assertEquals(1, tc.i); tc.reset(); // one string then varargs string expression = parser.parseExpression("thirteen('aaa','bbb','ccc')"); assertCantCompile(expression); expression.getValue(tc); - assertEquals("aaa::bbbccc",tc.s); + assertEquals("aaa::bbbccc", tc.s); assertCanCompile(expression); tc.reset(); expression.getValue(tc); - assertEquals("aaa::bbbccc",tc.s); + assertEquals("aaa::bbbccc", tc.s); tc.reset(); // nothing passed to varargs parameter expression = parser.parseExpression("thirteen('aaa')"); assertCantCompile(expression); expression.getValue(tc); - assertEquals("aaa::",tc.s); + assertEquals("aaa::", tc.s); assertCanCompile(expression); tc.reset(); expression.getValue(tc); - assertEquals("aaa::",tc.s); + assertEquals("aaa::", tc.s); tc.reset(); // nested arrays expression = parser.parseExpression("fourteen('aaa',stringArray,stringArray)"); assertCantCompile(expression); expression.getValue(tc); - assertEquals("aaa::{aaabbbccc}{aaabbbccc}",tc.s); + assertEquals("aaa::{aaabbbccc}{aaabbbccc}", tc.s); assertCanCompile(expression); tc.reset(); expression.getValue(tc); - assertEquals("aaa::{aaabbbccc}{aaabbbccc}",tc.s); + assertEquals("aaa::{aaabbbccc}{aaabbbccc}", tc.s); tc.reset(); // nested primitive array expression = parser.parseExpression("fifteen('aaa',intArray,intArray)"); assertCantCompile(expression); expression.getValue(tc); - assertEquals("aaa::{112233}{112233}",tc.s); + assertEquals("aaa::{112233}{112233}", tc.s); assertCanCompile(expression); tc.reset(); expression.getValue(tc); - assertEquals("aaa::{112233}{112233}",tc.s); + assertEquals("aaa::{112233}{112233}", tc.s); tc.reset(); // varargs boolean expression = parser.parseExpression("arrayz(true,true,false)"); assertCantCompile(expression); expression.getValue(tc); - assertEquals("truetruefalse",tc.s); + assertEquals("truetruefalse", tc.s); assertCanCompile(expression); tc.reset(); expression.getValue(tc); - assertEquals("truetruefalse",tc.s); + assertEquals("truetruefalse", tc.s); tc.reset(); expression = parser.parseExpression("arrayz(true)"); assertCantCompile(expression); expression.getValue(tc); - assertEquals("true",tc.s); + assertEquals("true", tc.s); assertCanCompile(expression); tc.reset(); expression.getValue(tc); - assertEquals("true",tc.s); + assertEquals("true", tc.s); tc.reset(); // varargs short expression = parser.parseExpression("arrays(s1,s2,s3)"); assertCantCompile(expression); expression.getValue(tc); - assertEquals("123",tc.s); + assertEquals("123", tc.s); assertCanCompile(expression); tc.reset(); expression.getValue(tc); - assertEquals("123",tc.s); + assertEquals("123", tc.s); tc.reset(); expression = parser.parseExpression("arrays(s1)"); assertCantCompile(expression); expression.getValue(tc); - assertEquals("1",tc.s); + assertEquals("1", tc.s); assertCanCompile(expression); tc.reset(); expression.getValue(tc); - assertEquals("1",tc.s); + assertEquals("1", tc.s); tc.reset(); // varargs double expression = parser.parseExpression("arrayd(1.0d,2.0d,3.0d)"); assertCantCompile(expression); expression.getValue(tc); - assertEquals("1.02.03.0",tc.s); + assertEquals("1.02.03.0", tc.s); assertCanCompile(expression); tc.reset(); expression.getValue(tc); - assertEquals("1.02.03.0",tc.s); + assertEquals("1.02.03.0", tc.s); tc.reset(); expression = parser.parseExpression("arrayd(1.0d)"); assertCantCompile(expression); expression.getValue(tc); - assertEquals("1.0",tc.s); + assertEquals("1.0", tc.s); assertCanCompile(expression); tc.reset(); expression.getValue(tc); - assertEquals("1.0",tc.s); + assertEquals("1.0", tc.s); tc.reset(); // varargs long expression = parser.parseExpression("arrayj(l1,l2,l3)"); assertCantCompile(expression); expression.getValue(tc); - assertEquals("123",tc.s); + assertEquals("123", tc.s); assertCanCompile(expression); tc.reset(); expression.getValue(tc); - assertEquals("123",tc.s); + assertEquals("123", tc.s); tc.reset(); expression = parser.parseExpression("arrayj(l1)"); assertCantCompile(expression); expression.getValue(tc); - assertEquals("1",tc.s); + assertEquals("1", tc.s); assertCanCompile(expression); tc.reset(); expression.getValue(tc); - assertEquals("1",tc.s); + assertEquals("1", tc.s); tc.reset(); // varargs char expression = parser.parseExpression("arrayc(c1,c2,c3)"); assertCantCompile(expression); expression.getValue(tc); - assertEquals("abc",tc.s); + assertEquals("abc", tc.s); assertCanCompile(expression); tc.reset(); expression.getValue(tc); - assertEquals("abc",tc.s); + assertEquals("abc", tc.s); tc.reset(); expression = parser.parseExpression("arrayc(c1)"); assertCantCompile(expression); expression.getValue(tc); - assertEquals("a",tc.s); + assertEquals("a", tc.s); assertCanCompile(expression); tc.reset(); expression.getValue(tc); - assertEquals("a",tc.s); + assertEquals("a", tc.s); tc.reset(); // varargs byte expression = parser.parseExpression("arrayb(b1,b2,b3)"); assertCantCompile(expression); expression.getValue(tc); - assertEquals("656667",tc.s); + assertEquals("656667", tc.s); assertCanCompile(expression); tc.reset(); expression.getValue(tc); - assertEquals("656667",tc.s); + assertEquals("656667", tc.s); tc.reset(); expression = parser.parseExpression("arrayb(b1)"); assertCantCompile(expression); expression.getValue(tc); - assertEquals("65",tc.s); + assertEquals("65", tc.s); assertCanCompile(expression); tc.reset(); expression.getValue(tc); - assertEquals("65",tc.s); + assertEquals("65", tc.s); tc.reset(); // varargs float expression = parser.parseExpression("arrayf(f1,f2,f3)"); assertCantCompile(expression); expression.getValue(tc); - assertEquals("1.02.03.0",tc.s); + assertEquals("1.02.03.0", tc.s); assertCanCompile(expression); tc.reset(); expression.getValue(tc); - assertEquals("1.02.03.0",tc.s); + assertEquals("1.02.03.0", tc.s); tc.reset(); expression = parser.parseExpression("arrayf(f1)"); assertCantCompile(expression); expression.getValue(tc); - assertEquals("1.0",tc.s); + assertEquals("1.0", tc.s); assertCanCompile(expression); tc.reset(); expression.getValue(tc); - assertEquals("1.0",tc.s); + assertEquals("1.0", tc.s); tc.reset(); } @@ -3595,7 +3669,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { assertCanCompile(expression); tc.reset(); expression.getValue(tc); - assertEquals(1,tc.i); + assertEquals(1, tc.i); tc.reset(); // static method, no args, void return @@ -3605,7 +3679,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { assertCanCompile(expression); tc.reset(); expression.getValue(tc); - assertEquals(1,TestClass5._i); + assertEquals(1, TestClass5._i); tc.reset(); // non-static method, reference type return @@ -3614,7 +3688,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { expression.getValue(tc); assertCanCompile(expression); tc.reset(); - assertEquals("hello",expression.getValue(tc)); + assertEquals("hello", expression.getValue(tc)); tc.reset(); // non-static method, primitive type return @@ -3623,7 +3697,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { expression.getValue(tc); assertCanCompile(expression); tc.reset(); - assertEquals(3277700L,expression.getValue(tc)); + assertEquals(3277700L, expression.getValue(tc)); tc.reset(); // static method, reference type return @@ -3632,7 +3706,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { expression.getValue(tc); assertCanCompile(expression); tc.reset(); - assertEquals("hello",expression.getValue(tc)); + assertEquals("hello", expression.getValue(tc)); tc.reset(); // static method, primitive type return @@ -3641,7 +3715,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { expression.getValue(tc); assertCanCompile(expression); tc.reset(); - assertEquals(3277700L,expression.getValue(tc)); + assertEquals(3277700L, expression.getValue(tc)); tc.reset(); // non-static method, one parameter of reference type @@ -3651,7 +3725,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { assertCanCompile(expression); tc.reset(); expression.getValue(tc); - assertEquals("foo",tc.s); + assertEquals("foo", tc.s); tc.reset(); // static method, one parameter of reference type @@ -3661,7 +3735,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { assertCanCompile(expression); tc.reset(); expression.getValue(tc); - assertEquals("bar",TestClass5._s); + assertEquals("bar", TestClass5._s); tc.reset(); // non-static method, one parameter of primitive type @@ -3671,7 +3745,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { assertCanCompile(expression); tc.reset(); expression.getValue(tc); - assertEquals(231,tc.i); + assertEquals(231, tc.i); tc.reset(); // static method, one parameter of primitive type @@ -3681,7 +3755,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { assertCanCompile(expression); tc.reset(); expression.getValue(tc); - assertEquals(111,TestClass5._i); + assertEquals(111, TestClass5._i); tc.reset(); // method that gets type converted parameters @@ -3690,41 +3764,41 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { expression = parser.parseExpression("seven(123)"); assertCantCompile(expression); expression.getValue(tc); - assertEquals("123",tc.s); + assertEquals("123", tc.s); assertCantCompile(expression); // Uncompilable as argument conversion is occurring Expression expression = parser.parseExpression("'abcd'.substring(index1,index2)"); - String resultI = expression.getValue(new TestClass1(),String.class); + String resultI = expression.getValue(new TestClass1(), String.class); assertCanCompile(expression); - String resultC = expression.getValue(new TestClass1(),String.class); - assertEquals("bc",resultI); - assertEquals("bc",resultC); + String resultC = expression.getValue(new TestClass1(), String.class); + assertEquals("bc", resultI); + assertEquals("bc", resultC); // Converting from an int to a Number expression = parser.parseExpression("takeNumber(123)"); assertCantCompile(expression); expression.getValue(tc); - assertEquals("123",tc.s); + assertEquals("123", tc.s); tc.reset(); assertCanCompile(expression); // The generated code should include boxing of the int to a Number expression.getValue(tc); - assertEquals("123",tc.s); + assertEquals("123", tc.s); // Passing a subtype expression = parser.parseExpression("takeNumber(T(Integer).valueOf(42))"); assertCantCompile(expression); expression.getValue(tc); - assertEquals("42",tc.s); + assertEquals("42", tc.s); tc.reset(); assertCanCompile(expression); // The generated code should include boxing of the int to a Number expression.getValue(tc); - assertEquals("42",tc.s); + assertEquals("42", tc.s); // Passing a subtype expression = parser.parseExpression("takeString(T(Integer).valueOf(42))"); assertCantCompile(expression); expression.getValue(tc); - assertEquals("42",tc.s); + assertEquals("42", tc.s); tc.reset(); assertCantCompile(expression); // method takes a string and we are passing an Integer } @@ -3736,31 +3810,31 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { // changing target // from primitive array to reference type array - int[] is = new int[]{1,2,3}; - String[] strings = new String[]{"a","b","c"}; + int[] is = new int[] {1,2,3}; + String[] strings = new String[] {"a","b","c"}; expression = parser.parseExpression("[1]"); - assertEquals(2,expression.getValue(is)); + assertEquals(2, expression.getValue(is)); assertCanCompile(expression); - assertEquals(2,expression.getValue(is)); + assertEquals(2, expression.getValue(is)); try { - assertEquals(2,expression.getValue(strings)); + assertEquals(2, expression.getValue(strings)); fail(); } catch (SpelEvaluationException see) { assertTrue(see.getCause() instanceof ClassCastException); } SpelCompiler.revertToInterpreted(expression); - assertEquals("b",expression.getValue(strings)); + assertEquals("b", expression.getValue(strings)); assertCanCompile(expression); - assertEquals("b",expression.getValue(strings)); + assertEquals("b", expression.getValue(strings)); tc.field = "foo"; expression = parser.parseExpression("seven(field)"); assertCantCompile(expression); expression.getValue(tc); - assertEquals("foo",tc.s); + assertEquals("foo", tc.s); assertCanCompile(expression); tc.reset(); tc.field="bar"; @@ -3771,7 +3845,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { expression = parser.parseExpression("seven(obj)"); assertCantCompile(expression); expression.getValue(tc); - assertEquals("foo",tc.s); + assertEquals("foo", tc.s); assertCanCompile(expression); tc.reset(); tc.obj=new Integer(42); @@ -3783,10 +3857,9 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { assertTrue(see.getCause() instanceof ClassCastException); } - // method with changing target expression = parser.parseExpression("#root.charAt(0)"); - assertEquals('a',expression.getValue("abc")); + assertEquals('a', expression.getValue("abc")); assertCanCompile(expression); try { expression.getValue(new Integer(42)); @@ -3801,111 +3874,111 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { @Test public void methodReference_staticMethod() throws Exception { Expression expression = parser.parseExpression("T(Integer).valueOf(42)"); - int resultI = expression.getValue(new TestClass1(),Integer.TYPE); + int resultI = expression.getValue(new TestClass1(), Integer.TYPE); assertCanCompile(expression); - int resultC = expression.getValue(new TestClass1(),Integer.TYPE); - assertEquals(42,resultI); - assertEquals(42,resultC); + int resultC = expression.getValue(new TestClass1(), Integer.TYPE); + assertEquals(42, resultI); + assertEquals(42, resultC); } @Test public void methodReference_literalArguments_int() throws Exception { Expression expression = parser.parseExpression("'abcd'.substring(1,3)"); - String resultI = expression.getValue(new TestClass1(),String.class); + String resultI = expression.getValue(new TestClass1(), String.class); assertCanCompile(expression); - String resultC = expression.getValue(new TestClass1(),String.class); - assertEquals("bc",resultI); - assertEquals("bc",resultC); + String resultC = expression.getValue(new TestClass1(), String.class); + assertEquals("bc", resultI); + assertEquals("bc", resultC); } @Test public void methodReference_simpleInstanceMethodNoArg() throws Exception { Expression expression = parser.parseExpression("toString()"); - String resultI = expression.getValue(42,String.class); + String resultI = expression.getValue(42, String.class); assertCanCompile(expression); - String resultC = expression.getValue(42,String.class); - assertEquals("42",resultI); - assertEquals("42",resultC); + String resultC = expression.getValue(42, String.class); + assertEquals("42", resultI); + assertEquals("42", resultC); } @Test public void methodReference_simpleInstanceMethodNoArgReturnPrimitive() throws Exception { expression = parser.parseExpression("intValue()"); - int resultI = expression.getValue(new Integer(42),Integer.TYPE); - assertEquals(42,resultI); + int resultI = expression.getValue(new Integer(42), Integer.TYPE); + assertEquals(42, resultI); assertCanCompile(expression); - int resultC = expression.getValue(new Integer(42),Integer.TYPE); - assertEquals(42,resultC); + int resultC = expression.getValue(new Integer(42), Integer.TYPE); + assertEquals(42, resultC); } @Test public void methodReference_simpleInstanceMethodOneArgReturnPrimitive1() throws Exception { Expression expression = parser.parseExpression("indexOf('b')"); - int resultI = expression.getValue("abc",Integer.TYPE); + int resultI = expression.getValue("abc", Integer.TYPE); assertCanCompile(expression); - int resultC = expression.getValue("abc",Integer.TYPE); - assertEquals(1,resultI); - assertEquals(1,resultC); + int resultC = expression.getValue("abc", Integer.TYPE); + assertEquals(1, resultI); + assertEquals(1, resultC); } @Test public void methodReference_simpleInstanceMethodOneArgReturnPrimitive2() throws Exception { expression = parser.parseExpression("charAt(2)"); - char resultI = expression.getValue("abc",Character.TYPE); - assertEquals('c',resultI); + char resultI = expression.getValue("abc", Character.TYPE); + assertEquals('c', resultI); assertCanCompile(expression); - char resultC = expression.getValue("abc",Character.TYPE); - assertEquals('c',resultC); + char resultC = expression.getValue("abc", Character.TYPE); + assertEquals('c', resultC); } @Test public void compoundExpression() throws Exception { Payload payload = new Payload(); expression = parser.parseExpression("DR[0]"); - assertEquals("instanceof Two",expression.getValue(payload).toString()); + assertEquals("instanceof Two", expression.getValue(payload).toString()); assertCanCompile(expression); - assertEquals("instanceof Two",expression.getValue(payload).toString()); + assertEquals("instanceof Two", expression.getValue(payload).toString()); ast = getAst(); - assertEquals("Lorg/springframework/expression/spel/SpelCompilationCoverageTests$Two",ast.getExitDescriptor()); + assertEquals("Lorg/springframework/expression/spel/SpelCompilationCoverageTests$Two", ast.getExitDescriptor()); expression = parser.parseExpression("holder.three"); - assertEquals("org.springframework.expression.spel.SpelCompilationCoverageTests$Three",expression.getValue(payload).getClass().getName()); + assertEquals("org.springframework.expression.spel.SpelCompilationCoverageTests$Three", expression.getValue(payload).getClass().getName()); assertCanCompile(expression); - assertEquals("org.springframework.expression.spel.SpelCompilationCoverageTests$Three",expression.getValue(payload).getClass().getName()); + assertEquals("org.springframework.expression.spel.SpelCompilationCoverageTests$Three", expression.getValue(payload).getClass().getName()); ast = getAst(); - assertEquals("Lorg/springframework/expression/spel/SpelCompilationCoverageTests$Three",ast.getExitDescriptor()); + assertEquals("Lorg/springframework/expression/spel/SpelCompilationCoverageTests$Three", ast.getExitDescriptor()); expression = parser.parseExpression("DR[0]"); - assertEquals("org.springframework.expression.spel.SpelCompilationCoverageTests$Two",expression.getValue(payload).getClass().getName()); + assertEquals("org.springframework.expression.spel.SpelCompilationCoverageTests$Two", expression.getValue(payload).getClass().getName()); assertCanCompile(expression); - assertEquals("org.springframework.expression.spel.SpelCompilationCoverageTests$Two",expression.getValue(payload).getClass().getName()); - assertEquals("Lorg/springframework/expression/spel/SpelCompilationCoverageTests$Two",getAst().getExitDescriptor()); + assertEquals("org.springframework.expression.spel.SpelCompilationCoverageTests$Two", expression.getValue(payload).getClass().getName()); + assertEquals("Lorg/springframework/expression/spel/SpelCompilationCoverageTests$Two", getAst().getExitDescriptor()); expression = parser.parseExpression("DR[0].three"); - assertEquals("org.springframework.expression.spel.SpelCompilationCoverageTests$Three",expression.getValue(payload).getClass().getName()); + assertEquals("org.springframework.expression.spel.SpelCompilationCoverageTests$Three", expression.getValue(payload).getClass().getName()); assertCanCompile(expression); - assertEquals("org.springframework.expression.spel.SpelCompilationCoverageTests$Three",expression.getValue(payload).getClass().getName()); + assertEquals("org.springframework.expression.spel.SpelCompilationCoverageTests$Three", expression.getValue(payload).getClass().getName()); ast = getAst(); - assertEquals("Lorg/springframework/expression/spel/SpelCompilationCoverageTests$Three",ast.getExitDescriptor()); + assertEquals("Lorg/springframework/expression/spel/SpelCompilationCoverageTests$Three", ast.getExitDescriptor()); expression = parser.parseExpression("DR[0].three.four"); - assertEquals(0.04d,expression.getValue(payload)); + assertEquals(0.04d, expression.getValue(payload)); assertCanCompile(expression); - assertEquals(0.04d,expression.getValue(payload)); - assertEquals("D",getAst().getExitDescriptor()); + assertEquals(0.04d, expression.getValue(payload)); + assertEquals("D", getAst().getExitDescriptor()); } @Test public void mixingItUp_indexerOpEqTernary() throws Exception { - Map m = new HashMap(); + Map m = new HashMap<>(); m.put("andy","778"); expression = parse("['andy']==null?1:2"); - System.out.println(expression.getValue(m)); + assertEquals(2, expression.getValue(m)); assertCanCompile(expression); - assertEquals(2,expression.getValue(m)); + assertEquals(2, expression.getValue(m)); m.remove("andy"); - assertEquals(1,expression.getValue(m)); + assertEquals(1, expression.getValue(m)); } @Test @@ -3915,30 +3988,30 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { // non static field expression = parser.parseExpression("orange"); assertCantCompile(expression); - assertEquals("value1",expression.getValue(tc)); + assertEquals("value1", expression.getValue(tc)); assertCanCompile(expression); - assertEquals("value1",expression.getValue(tc)); + assertEquals("value1", expression.getValue(tc)); // static field expression = parser.parseExpression("apple"); assertCantCompile(expression); - assertEquals("value2",expression.getValue(tc)); + assertEquals("value2", expression.getValue(tc)); assertCanCompile(expression); - assertEquals("value2",expression.getValue(tc)); + assertEquals("value2", expression.getValue(tc)); // non static getter expression = parser.parseExpression("banana"); assertCantCompile(expression); - assertEquals("value3",expression.getValue(tc)); + assertEquals("value3", expression.getValue(tc)); assertCanCompile(expression); - assertEquals("value3",expression.getValue(tc)); + assertEquals("value3", expression.getValue(tc)); // static getter expression = parser.parseExpression("plum"); assertCantCompile(expression); - assertEquals("value4",expression.getValue(tc)); + assertEquals("value4", expression.getValue(tc)); assertCanCompile(expression); - assertEquals("value4",expression.getValue(tc)); + assertEquals("value4", expression.getValue(tc)); } @Test @@ -3947,332 +4020,332 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { ctx.setVariable("httpServletRequest", HttpServlet3RequestFactory.getOne()); // Without a fix compilation was inserting a checkcast to a private type expression = parser.parseExpression("#httpServletRequest.servletPath"); - assertEquals("wibble",expression.getValue(ctx)); + assertEquals("wibble", expression.getValue(ctx)); assertCanCompile(expression); - assertEquals("wibble",expression.getValue(ctx)); + assertEquals("wibble", expression.getValue(ctx)); } @SuppressWarnings("unchecked") @Test public void indexer() throws Exception { - String[] sss = new String[]{"a","b","c"}; - Number[] ns = new Number[]{2,8,9}; - int[] is = new int[]{8,9,10}; - double[] ds = new double[]{3.0d,4.0d,5.0d}; - long[] ls = new long[]{2L,3L,4L}; - short[] ss = new short[]{(short)33,(short)44,(short)55}; - float[] fs = new float[]{6.0f,7.0f,8.0f}; - byte[] bs = new byte[]{(byte)2,(byte)3,(byte)4}; - char[] cs = new char[]{'a','b','c'}; + String[] sss = new String[] {"a","b","c"}; + Number[] ns = new Number[] {2,8,9}; + int[] is = new int[] {8,9,10}; + double[] ds = new double[] {3.0d,4.0d,5.0d}; + long[] ls = new long[] {2L,3L,4L}; + short[] ss = new short[] {(short)33,(short)44,(short)55}; + float[] fs = new float[] {6.0f,7.0f,8.0f}; + byte[] bs = new byte[] {(byte)2,(byte)3,(byte)4}; + char[] cs = new char[] {'a','b','c'}; // Access String (reference type) array expression = parser.parseExpression("[0]"); - assertEquals("a",expression.getValue(sss)); + assertEquals("a", expression.getValue(sss)); assertCanCompile(expression); - assertEquals("a",expression.getValue(sss)); - assertEquals("Ljava/lang/String",getAst().getExitDescriptor()); + assertEquals("a", expression.getValue(sss)); + assertEquals("Ljava/lang/String", getAst().getExitDescriptor()); expression = parser.parseExpression("[1]"); - assertEquals(8,expression.getValue(ns)); + assertEquals(8, expression.getValue(ns)); assertCanCompile(expression); - assertEquals(8,expression.getValue(ns)); - assertEquals("Ljava/lang/Number",getAst().getExitDescriptor()); + assertEquals(8, expression.getValue(ns)); + assertEquals("Ljava/lang/Number", getAst().getExitDescriptor()); // Access int array expression = parser.parseExpression("[2]"); - assertEquals(10,expression.getValue(is)); + assertEquals(10, expression.getValue(is)); assertCanCompile(expression); - assertEquals(10,expression.getValue(is)); - assertEquals("I",getAst().getExitDescriptor()); + assertEquals(10, expression.getValue(is)); + assertEquals("I", getAst().getExitDescriptor()); // Access double array expression = parser.parseExpression("[1]"); - assertEquals(4.0d,expression.getValue(ds)); + assertEquals(4.0d, expression.getValue(ds)); assertCanCompile(expression); - assertEquals(4.0d,expression.getValue(ds)); - assertEquals("D",getAst().getExitDescriptor()); + assertEquals(4.0d, expression.getValue(ds)); + assertEquals("D", getAst().getExitDescriptor()); // Access long array expression = parser.parseExpression("[0]"); - assertEquals(2L,expression.getValue(ls)); + assertEquals(2L, expression.getValue(ls)); assertCanCompile(expression); - assertEquals(2L,expression.getValue(ls)); - assertEquals("J",getAst().getExitDescriptor()); + assertEquals(2L, expression.getValue(ls)); + assertEquals("J", getAst().getExitDescriptor()); // Access short array expression = parser.parseExpression("[2]"); - assertEquals((short)55,expression.getValue(ss)); + assertEquals((short)55, expression.getValue(ss)); assertCanCompile(expression); - assertEquals((short)55,expression.getValue(ss)); - assertEquals("S",getAst().getExitDescriptor()); + assertEquals((short)55, expression.getValue(ss)); + assertEquals("S", getAst().getExitDescriptor()); // Access float array expression = parser.parseExpression("[0]"); - assertEquals(6.0f,expression.getValue(fs)); + assertEquals(6.0f, expression.getValue(fs)); assertCanCompile(expression); - assertEquals(6.0f,expression.getValue(fs)); - assertEquals("F",getAst().getExitDescriptor()); + assertEquals(6.0f, expression.getValue(fs)); + assertEquals("F", getAst().getExitDescriptor()); // Access byte array expression = parser.parseExpression("[2]"); - assertEquals((byte)4,expression.getValue(bs)); + assertEquals((byte)4, expression.getValue(bs)); assertCanCompile(expression); - assertEquals((byte)4,expression.getValue(bs)); - assertEquals("B",getAst().getExitDescriptor()); + assertEquals((byte)4, expression.getValue(bs)); + assertEquals("B", getAst().getExitDescriptor()); // Access char array expression = parser.parseExpression("[1]"); - assertEquals('b',expression.getValue(cs)); + assertEquals('b', expression.getValue(cs)); assertCanCompile(expression); - assertEquals('b',expression.getValue(cs)); - assertEquals("C",getAst().getExitDescriptor()); + assertEquals('b', expression.getValue(cs)); + assertEquals("C", getAst().getExitDescriptor()); // Collections - List strings = new ArrayList(); + List strings = new ArrayList<>(); strings.add("aaa"); strings.add("bbb"); strings.add("ccc"); expression = parser.parseExpression("[1]"); - assertEquals("bbb",expression.getValue(strings)); + assertEquals("bbb", expression.getValue(strings)); assertCanCompile(expression); - assertEquals("bbb",expression.getValue(strings)); - assertEquals("Ljava/lang/Object",getAst().getExitDescriptor()); + assertEquals("bbb", expression.getValue(strings)); + assertEquals("Ljava/lang/Object", getAst().getExitDescriptor()); - List ints = new ArrayList(); + List ints = new ArrayList<>(); ints.add(123); ints.add(456); ints.add(789); expression = parser.parseExpression("[2]"); - assertEquals(789,expression.getValue(ints)); + assertEquals(789, expression.getValue(ints)); assertCanCompile(expression); - assertEquals(789,expression.getValue(ints)); - assertEquals("Ljava/lang/Object",getAst().getExitDescriptor()); + assertEquals(789, expression.getValue(ints)); + assertEquals("Ljava/lang/Object", getAst().getExitDescriptor()); // Maps - Map map1 = new HashMap(); + Map map1 = new HashMap<>(); map1.put("aaa", 111); map1.put("bbb", 222); map1.put("ccc", 333); expression = parser.parseExpression("['aaa']"); - assertEquals(111,expression.getValue(map1)); + assertEquals(111, expression.getValue(map1)); assertCanCompile(expression); - assertEquals(111,expression.getValue(map1)); - assertEquals("Ljava/lang/Object",getAst().getExitDescriptor()); + assertEquals(111, expression.getValue(map1)); + assertEquals("Ljava/lang/Object", getAst().getExitDescriptor()); // Object TestClass6 tc = new TestClass6(); expression = parser.parseExpression("['orange']"); - assertEquals("value1",expression.getValue(tc)); + assertEquals("value1", expression.getValue(tc)); assertCanCompile(expression); - assertEquals("value1",expression.getValue(tc)); - assertEquals("Ljava/lang/String",getAst().getExitDescriptor()); + assertEquals("value1", expression.getValue(tc)); + assertEquals("Ljava/lang/String", getAst().getExitDescriptor()); expression = parser.parseExpression("['peach']"); - assertEquals(34L,expression.getValue(tc)); + assertEquals(34L, expression.getValue(tc)); assertCanCompile(expression); - assertEquals(34L,expression.getValue(tc)); - assertEquals("J",getAst().getExitDescriptor()); + assertEquals(34L, expression.getValue(tc)); + assertEquals("J", getAst().getExitDescriptor()); // getter expression = parser.parseExpression("['banana']"); - assertEquals("value3",expression.getValue(tc)); + assertEquals("value3", expression.getValue(tc)); assertCanCompile(expression); - assertEquals("value3",expression.getValue(tc)); - assertEquals("Ljava/lang/String",getAst().getExitDescriptor()); + assertEquals("value3", expression.getValue(tc)); + assertEquals("Ljava/lang/String", getAst().getExitDescriptor()); // list of arrays - List listOfStringArrays = new ArrayList(); - listOfStringArrays.add(new String[]{"a","b","c"}); - listOfStringArrays.add(new String[]{"d","e","f"}); + List listOfStringArrays = new ArrayList<>(); + listOfStringArrays.add(new String[] {"a","b","c"}); + listOfStringArrays.add(new String[] {"d","e","f"}); expression = parser.parseExpression("[1]"); - assertEquals("d e f",stringify(expression.getValue(listOfStringArrays))); + assertEquals("d e f", stringify(expression.getValue(listOfStringArrays))); assertCanCompile(expression); - assertEquals("d e f",stringify(expression.getValue(listOfStringArrays))); - assertEquals("Ljava/lang/Object",getAst().getExitDescriptor()); + assertEquals("d e f", stringify(expression.getValue(listOfStringArrays))); + assertEquals("Ljava/lang/Object", getAst().getExitDescriptor()); expression = parser.parseExpression("[1][0]"); - assertEquals("d",stringify(expression.getValue(listOfStringArrays))); + assertEquals("d", stringify(expression.getValue(listOfStringArrays))); assertCanCompile(expression); - assertEquals("d",stringify(expression.getValue(listOfStringArrays))); - assertEquals("Ljava/lang/String",getAst().getExitDescriptor()); + assertEquals("d", stringify(expression.getValue(listOfStringArrays))); + assertEquals("Ljava/lang/String", getAst().getExitDescriptor()); - List listOfIntegerArrays = new ArrayList(); - listOfIntegerArrays.add(new Integer[]{1,2,3}); - listOfIntegerArrays.add(new Integer[]{4,5,6}); + List listOfIntegerArrays = new ArrayList<>(); + listOfIntegerArrays.add(new Integer[] {1,2,3}); + listOfIntegerArrays.add(new Integer[] {4,5,6}); expression = parser.parseExpression("[0]"); - assertEquals("1 2 3",stringify(expression.getValue(listOfIntegerArrays))); + assertEquals("1 2 3", stringify(expression.getValue(listOfIntegerArrays))); assertCanCompile(expression); - assertEquals("1 2 3",stringify(expression.getValue(listOfIntegerArrays))); - assertEquals("Ljava/lang/Object",getAst().getExitDescriptor()); + assertEquals("1 2 3", stringify(expression.getValue(listOfIntegerArrays))); + assertEquals("Ljava/lang/Object", getAst().getExitDescriptor()); expression = parser.parseExpression("[0][1]"); - assertEquals(2,expression.getValue(listOfIntegerArrays)); + assertEquals(2, expression.getValue(listOfIntegerArrays)); assertCanCompile(expression); - assertEquals(2,expression.getValue(listOfIntegerArrays)); - assertEquals("Ljava/lang/Integer",getAst().getExitDescriptor()); + assertEquals(2, expression.getValue(listOfIntegerArrays)); + assertEquals("Ljava/lang/Integer", getAst().getExitDescriptor()); // array of lists List[] stringArrayOfLists = new ArrayList[2]; - stringArrayOfLists[0] = new ArrayList(); + stringArrayOfLists[0] = new ArrayList<>(); stringArrayOfLists[0].add("a"); stringArrayOfLists[0].add("b"); stringArrayOfLists[0].add("c"); - stringArrayOfLists[1] = new ArrayList(); + stringArrayOfLists[1] = new ArrayList<>(); stringArrayOfLists[1].add("d"); stringArrayOfLists[1].add("e"); stringArrayOfLists[1].add("f"); expression = parser.parseExpression("[1]"); - assertEquals("d e f",stringify(expression.getValue(stringArrayOfLists))); + assertEquals("d e f", stringify(expression.getValue(stringArrayOfLists))); assertCanCompile(expression); - assertEquals("d e f",stringify(expression.getValue(stringArrayOfLists))); - assertEquals("Ljava/util/ArrayList",getAst().getExitDescriptor()); + assertEquals("d e f", stringify(expression.getValue(stringArrayOfLists))); + assertEquals("Ljava/util/ArrayList", getAst().getExitDescriptor()); expression = parser.parseExpression("[1][2]"); - assertEquals("f",stringify(expression.getValue(stringArrayOfLists))); + assertEquals("f", stringify(expression.getValue(stringArrayOfLists))); assertCanCompile(expression); - assertEquals("f",stringify(expression.getValue(stringArrayOfLists))); - assertEquals("Ljava/lang/Object",getAst().getExitDescriptor()); + assertEquals("f", stringify(expression.getValue(stringArrayOfLists))); + assertEquals("Ljava/lang/Object", getAst().getExitDescriptor()); // array of arrays - String[][] referenceTypeArrayOfArrays = new String[][]{new String[]{"a","b","c"},new String[]{"d","e","f"}}; + String[][] referenceTypeArrayOfArrays = new String[][] {new String[] {"a","b","c"},new String[] {"d","e","f"}}; expression = parser.parseExpression("[1]"); - assertEquals("d e f",stringify(expression.getValue(referenceTypeArrayOfArrays))); + assertEquals("d e f", stringify(expression.getValue(referenceTypeArrayOfArrays))); assertCanCompile(expression); - assertEquals("[Ljava/lang/String",getAst().getExitDescriptor()); - assertEquals("d e f",stringify(expression.getValue(referenceTypeArrayOfArrays))); - assertEquals("[Ljava/lang/String",getAst().getExitDescriptor()); + assertEquals("[Ljava/lang/String", getAst().getExitDescriptor()); + assertEquals("d e f", stringify(expression.getValue(referenceTypeArrayOfArrays))); + assertEquals("[Ljava/lang/String", getAst().getExitDescriptor()); expression = parser.parseExpression("[1][2]"); - assertEquals("f",stringify(expression.getValue(referenceTypeArrayOfArrays))); + assertEquals("f", stringify(expression.getValue(referenceTypeArrayOfArrays))); assertCanCompile(expression); - assertEquals("f",stringify(expression.getValue(referenceTypeArrayOfArrays))); - assertEquals("Ljava/lang/String",getAst().getExitDescriptor()); + assertEquals("f", stringify(expression.getValue(referenceTypeArrayOfArrays))); + assertEquals("Ljava/lang/String", getAst().getExitDescriptor()); - int[][] primitiveTypeArrayOfArrays = new int[][]{new int[]{1,2,3},new int[]{4,5,6}}; + int[][] primitiveTypeArrayOfArrays = new int[][] {new int[] {1,2,3},new int[] {4,5,6}}; expression = parser.parseExpression("[1]"); - assertEquals("4 5 6",stringify(expression.getValue(primitiveTypeArrayOfArrays))); + assertEquals("4 5 6", stringify(expression.getValue(primitiveTypeArrayOfArrays))); assertCanCompile(expression); - assertEquals("4 5 6",stringify(expression.getValue(primitiveTypeArrayOfArrays))); - assertEquals("[I",getAst().getExitDescriptor()); + assertEquals("4 5 6", stringify(expression.getValue(primitiveTypeArrayOfArrays))); + assertEquals("[I", getAst().getExitDescriptor()); expression = parser.parseExpression("[1][2]"); - assertEquals("6",stringify(expression.getValue(primitiveTypeArrayOfArrays))); + assertEquals("6", stringify(expression.getValue(primitiveTypeArrayOfArrays))); assertCanCompile(expression); - assertEquals("6",stringify(expression.getValue(primitiveTypeArrayOfArrays))); - assertEquals("I",getAst().getExitDescriptor()); + assertEquals("6", stringify(expression.getValue(primitiveTypeArrayOfArrays))); + assertEquals("I", getAst().getExitDescriptor()); // list of lists of reference types - List> listOfListOfStrings = new ArrayList>(); - List list = new ArrayList(); + List> listOfListOfStrings = new ArrayList<>(); + List list = new ArrayList<>(); list.add("a"); list.add("b"); list.add("c"); listOfListOfStrings.add(list); - list = new ArrayList(); + list = new ArrayList<>(); list.add("d"); list.add("e"); list.add("f"); listOfListOfStrings.add(list); expression = parser.parseExpression("[1]"); - assertEquals("d e f",stringify(expression.getValue(listOfListOfStrings))); + assertEquals("d e f", stringify(expression.getValue(listOfListOfStrings))); assertCanCompile(expression); - assertEquals("Ljava/lang/Object",getAst().getExitDescriptor()); - assertEquals("d e f",stringify(expression.getValue(listOfListOfStrings))); - assertEquals("Ljava/lang/Object",getAst().getExitDescriptor()); + assertEquals("Ljava/lang/Object", getAst().getExitDescriptor()); + assertEquals("d e f", stringify(expression.getValue(listOfListOfStrings))); + assertEquals("Ljava/lang/Object", getAst().getExitDescriptor()); expression = parser.parseExpression("[1][2]"); - assertEquals("f",stringify(expression.getValue(listOfListOfStrings))); + assertEquals("f", stringify(expression.getValue(listOfListOfStrings))); assertCanCompile(expression); - assertEquals("f",stringify(expression.getValue(listOfListOfStrings))); - assertEquals("Ljava/lang/Object",getAst().getExitDescriptor()); + assertEquals("f", stringify(expression.getValue(listOfListOfStrings))); + assertEquals("Ljava/lang/Object", getAst().getExitDescriptor()); // Map of lists - Map> mapToLists = new HashMap>(); - list = new ArrayList(); + Map> mapToLists = new HashMap<>(); + list = new ArrayList<>(); list.add("a"); list.add("b"); list.add("c"); mapToLists.put("foo", list); expression = parser.parseExpression("['foo']"); - assertEquals("a b c",stringify(expression.getValue(mapToLists))); + assertEquals("a b c", stringify(expression.getValue(mapToLists))); assertCanCompile(expression); - assertEquals("Ljava/lang/Object",getAst().getExitDescriptor()); - assertEquals("a b c",stringify(expression.getValue(mapToLists))); - assertEquals("Ljava/lang/Object",getAst().getExitDescriptor()); + assertEquals("Ljava/lang/Object", getAst().getExitDescriptor()); + assertEquals("a b c", stringify(expression.getValue(mapToLists))); + assertEquals("Ljava/lang/Object", getAst().getExitDescriptor()); expression = parser.parseExpression("['foo'][2]"); - assertEquals("c",stringify(expression.getValue(mapToLists))); + assertEquals("c", stringify(expression.getValue(mapToLists))); assertCanCompile(expression); - assertEquals("c",stringify(expression.getValue(mapToLists))); - assertEquals("Ljava/lang/Object",getAst().getExitDescriptor()); + assertEquals("c", stringify(expression.getValue(mapToLists))); + assertEquals("Ljava/lang/Object", getAst().getExitDescriptor()); // Map to array - Map mapToIntArray = new HashMap(); + Map mapToIntArray = new HashMap<>(); StandardEvaluationContext ctx = new StandardEvaluationContext(); ctx.addPropertyAccessor(new CompilableMapAccessor()); - mapToIntArray.put("foo",new int[]{1,2,3}); + mapToIntArray.put("foo",new int[] {1,2,3}); expression = parser.parseExpression("['foo']"); - assertEquals("1 2 3",stringify(expression.getValue(mapToIntArray))); + assertEquals("1 2 3", stringify(expression.getValue(mapToIntArray))); assertCanCompile(expression); - assertEquals("Ljava/lang/Object",getAst().getExitDescriptor()); - assertEquals("1 2 3",stringify(expression.getValue(mapToIntArray))); - assertEquals("Ljava/lang/Object",getAst().getExitDescriptor()); + assertEquals("Ljava/lang/Object", getAst().getExitDescriptor()); + assertEquals("1 2 3", stringify(expression.getValue(mapToIntArray))); + assertEquals("Ljava/lang/Object", getAst().getExitDescriptor()); expression = parser.parseExpression("['foo'][1]"); - assertEquals(2,expression.getValue(mapToIntArray)); + assertEquals(2, expression.getValue(mapToIntArray)); assertCanCompile(expression); - assertEquals(2,expression.getValue(mapToIntArray)); + assertEquals(2, expression.getValue(mapToIntArray)); expression = parser.parseExpression("foo"); - assertEquals("1 2 3",stringify(expression.getValue(ctx,mapToIntArray))); + assertEquals("1 2 3", stringify(expression.getValue(ctx, mapToIntArray))); assertCanCompile(expression); - assertEquals("1 2 3",stringify(expression.getValue(ctx,mapToIntArray))); - assertEquals("Ljava/lang/Object",getAst().getExitDescriptor()); + assertEquals("1 2 3", stringify(expression.getValue(ctx, mapToIntArray))); + assertEquals("Ljava/lang/Object", getAst().getExitDescriptor()); expression = parser.parseExpression("foo[1]"); - assertEquals(2,expression.getValue(ctx,mapToIntArray)); + assertEquals(2, expression.getValue(ctx, mapToIntArray)); assertCanCompile(expression); - assertEquals(2,expression.getValue(ctx,mapToIntArray)); + assertEquals(2, expression.getValue(ctx, mapToIntArray)); expression = parser.parseExpression("['foo'][2]"); - assertEquals("3",stringify(expression.getValue(ctx,mapToIntArray))); + assertEquals("3", stringify(expression.getValue(ctx, mapToIntArray))); assertCanCompile(expression); - assertEquals("3",stringify(expression.getValue(ctx,mapToIntArray))); - assertEquals("I",getAst().getExitDescriptor()); + assertEquals("3", stringify(expression.getValue(ctx, mapToIntArray))); + assertEquals("I", getAst().getExitDescriptor()); // Map array - Map[] mapArray = new Map[1]; - mapArray[0] = new HashMap(); + Map[] mapArray = new Map[1]; + mapArray[0] = new HashMap<>(); mapArray[0].put("key", "value1"); expression = parser.parseExpression("[0]"); - assertEquals("{key=value1}",stringify(expression.getValue(mapArray))); + assertEquals("{key=value1}", stringify(expression.getValue(mapArray))); assertCanCompile(expression); - assertEquals("Ljava/util/Map",getAst().getExitDescriptor()); - assertEquals("{key=value1}",stringify(expression.getValue(mapArray))); - assertEquals("Ljava/util/Map",getAst().getExitDescriptor()); + assertEquals("Ljava/util/Map", getAst().getExitDescriptor()); + assertEquals("{key=value1}", stringify(expression.getValue(mapArray))); + assertEquals("Ljava/util/Map", getAst().getExitDescriptor()); expression = parser.parseExpression("[0]['key']"); - assertEquals("value1",stringify(expression.getValue(mapArray))); + assertEquals("value1", stringify(expression.getValue(mapArray))); assertCanCompile(expression); - assertEquals("value1",stringify(expression.getValue(mapArray))); - assertEquals("Ljava/lang/Object",getAst().getExitDescriptor()); + assertEquals("value1", stringify(expression.getValue(mapArray))); + assertEquals("Ljava/lang/Object", getAst().getExitDescriptor()); } @Test public void plusNeedingCheckcast_SPR12426() { expression = parser.parseExpression("object + ' world'"); Object v = expression.getValue(new FooObject()); - assertEquals("hello world",v); + assertEquals("hello world", v); assertCanCompile(expression); - assertEquals("hello world",v); + assertEquals("hello world", v); expression = parser.parseExpression("object + ' world'"); v = expression.getValue(new FooString()); - assertEquals("hello world",v); + assertEquals("hello world", v); assertCanCompile(expression); - assertEquals("hello world",v); + assertEquals("hello world", v); } @Test @@ -4281,22 +4354,22 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { expression = parser.parseExpression("DR[0].three"); Object v = expression.getValue(payload); - assertEquals("Lorg/springframework/expression/spel/SpelCompilationCoverageTests$Three",getAst().getExitDescriptor()); + assertEquals("Lorg/springframework/expression/spel/SpelCompilationCoverageTests$Three", getAst().getExitDescriptor()); Expression expression = parser.parseExpression("DR[0].three.four lt 0.1d?#root:null"); v = expression.getValue(payload); - SpelExpression sExpr = (SpelExpression)expression; - Ternary ternary = (Ternary)sExpr.getAST(); - OpLT oplt = (OpLT)ternary.getChild(0); + SpelExpression sExpr = (SpelExpression) expression; + Ternary ternary = (Ternary) sExpr.getAST(); + OpLT oplt = (OpLT) ternary.getChild(0); CompoundExpression cExpr = (CompoundExpression)oplt.getLeftOperand(); String cExprExitDescriptor = cExpr.getExitDescriptor(); - assertEquals("D",cExprExitDescriptor); - assertEquals("Z",oplt.getExitDescriptor()); + assertEquals("D", cExprExitDescriptor); + assertEquals("Z", oplt.getExitDescriptor()); assertCanCompile(expression); Object vc = expression.getValue(payload); - assertEquals(payload,v); + assertEquals(payload, v); assertEquals(payload,vc); payload.DR[0].three.four = 0.13d; vc = expression.getValue(payload); @@ -4310,255 +4383,255 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { ctx.addPropertyAccessor(new MyAccessor()); expression = parser.parseExpression("payload2.var1"); Object v = expression.getValue(ctx,holder); - assertEquals("abc",v); + assertEquals("abc", v); + + // // time it interpreted + // long stime = System.currentTimeMillis(); + // for (int i = 0; i < 100000; i++) { + // v = expression.getValue(ctx,holder); + // } + // System.out.println((System.currentTimeMillis() - stime)); -// // time it interpreted -// long stime = System.currentTimeMillis(); -// for (int i = 0;i<100000;i++) { -// v = expression.getValue(ctx,holder); -// } -// System.out.println((System.currentTimeMillis()-stime)); -// assertCanCompile(expression); v = expression.getValue(ctx,holder); - assertEquals("abc",v); -// -// // time it compiled -// stime = System.currentTimeMillis(); -// for (int i = 0;i<100000;i++) { -// v = expression.getValue(ctx,holder); -// } -// System.out.println((System.currentTimeMillis()-stime)); + assertEquals("abc", v); + + // // time it compiled + // stime = System.currentTimeMillis(); + // for (int i = 0; i < 100000; i++) { + // v = expression.getValue(ctx,holder); + // } + // System.out.println((System.currentTimeMillis() - stime)); } @Test public void compilerWithGenerics_12040() { expression = parser.parseExpression("payload!=2"); - assertTrue(expression.getValue(new GenericMessageTestHelper(4),Boolean.class)); + assertTrue(expression.getValue(new GenericMessageTestHelper<>(4), Boolean.class)); assertCanCompile(expression); - assertFalse(expression.getValue(new GenericMessageTestHelper(2),Boolean.class)); + assertFalse(expression.getValue(new GenericMessageTestHelper<>(2), Boolean.class)); expression = parser.parseExpression("2!=payload"); - assertTrue(expression.getValue(new GenericMessageTestHelper(4),Boolean.class)); + assertTrue(expression.getValue(new GenericMessageTestHelper<>(4), Boolean.class)); assertCanCompile(expression); - assertFalse(expression.getValue(new GenericMessageTestHelper(2),Boolean.class)); + assertFalse(expression.getValue(new GenericMessageTestHelper<>(2), Boolean.class)); expression = parser.parseExpression("payload!=6L"); - assertTrue(expression.getValue(new GenericMessageTestHelper(4L),Boolean.class)); + assertTrue(expression.getValue(new GenericMessageTestHelper<>(4L), Boolean.class)); assertCanCompile(expression); - assertFalse(expression.getValue(new GenericMessageTestHelper(6L),Boolean.class)); + assertFalse(expression.getValue(new GenericMessageTestHelper<>(6L), Boolean.class)); expression = parser.parseExpression("payload==2"); - assertFalse(expression.getValue(new GenericMessageTestHelper(4),Boolean.class)); + assertFalse(expression.getValue(new GenericMessageTestHelper<>(4), Boolean.class)); assertCanCompile(expression); - assertTrue(expression.getValue(new GenericMessageTestHelper(2),Boolean.class)); + assertTrue(expression.getValue(new GenericMessageTestHelper<>(2), Boolean.class)); expression = parser.parseExpression("2==payload"); - assertFalse(expression.getValue(new GenericMessageTestHelper(4),Boolean.class)); + assertFalse(expression.getValue(new GenericMessageTestHelper<>(4), Boolean.class)); assertCanCompile(expression); - assertTrue(expression.getValue(new GenericMessageTestHelper(2),Boolean.class)); + assertTrue(expression.getValue(new GenericMessageTestHelper<>(2), Boolean.class)); expression = parser.parseExpression("payload==6L"); - assertFalse(expression.getValue(new GenericMessageTestHelper(4L),Boolean.class)); + assertFalse(expression.getValue(new GenericMessageTestHelper<>(4L), Boolean.class)); assertCanCompile(expression); - assertTrue(expression.getValue(new GenericMessageTestHelper(6L),Boolean.class)); + assertTrue(expression.getValue(new GenericMessageTestHelper<>(6L), Boolean.class)); expression = parser.parseExpression("2==payload"); - assertFalse(expression.getValue(new GenericMessageTestHelper(4),Boolean.class)); + assertFalse(expression.getValue(new GenericMessageTestHelper<>(4), Boolean.class)); assertCanCompile(expression); - assertTrue(expression.getValue(new GenericMessageTestHelper(2),Boolean.class)); + assertTrue(expression.getValue(new GenericMessageTestHelper<>(2), Boolean.class)); expression = parser.parseExpression("payload/2"); - assertEquals(2,expression.getValue(new GenericMessageTestHelper(4))); + assertEquals(2, expression.getValue(new GenericMessageTestHelper<>(4))); assertCanCompile(expression); - assertEquals(3,expression.getValue(new GenericMessageTestHelper(6))); + assertEquals(3, expression.getValue(new GenericMessageTestHelper<>(6))); expression = parser.parseExpression("100/payload"); - assertEquals(25,expression.getValue(new GenericMessageTestHelper(4))); + assertEquals(25, expression.getValue(new GenericMessageTestHelper<>(4))); assertCanCompile(expression); - assertEquals(10,expression.getValue(new GenericMessageTestHelper(10))); + assertEquals(10, expression.getValue(new GenericMessageTestHelper<>(10))); expression = parser.parseExpression("payload+2"); - assertEquals(6,expression.getValue(new GenericMessageTestHelper(4))); + assertEquals(6, expression.getValue(new GenericMessageTestHelper<>(4))); assertCanCompile(expression); - assertEquals(8,expression.getValue(new GenericMessageTestHelper(6))); + assertEquals(8, expression.getValue(new GenericMessageTestHelper<>(6))); expression = parser.parseExpression("100+payload"); - assertEquals(104,expression.getValue(new GenericMessageTestHelper(4))); + assertEquals(104, expression.getValue(new GenericMessageTestHelper<>(4))); assertCanCompile(expression); - assertEquals(110,expression.getValue(new GenericMessageTestHelper(10))); + assertEquals(110, expression.getValue(new GenericMessageTestHelper<>(10))); expression = parser.parseExpression("payload-2"); - assertEquals(2,expression.getValue(new GenericMessageTestHelper(4))); + assertEquals(2, expression.getValue(new GenericMessageTestHelper<>(4))); assertCanCompile(expression); - assertEquals(4,expression.getValue(new GenericMessageTestHelper(6))); + assertEquals(4, expression.getValue(new GenericMessageTestHelper<>(6))); expression = parser.parseExpression("100-payload"); - assertEquals(96,expression.getValue(new GenericMessageTestHelper(4))); + assertEquals(96, expression.getValue(new GenericMessageTestHelper<>(4))); assertCanCompile(expression); - assertEquals(90,expression.getValue(new GenericMessageTestHelper(10))); + assertEquals(90, expression.getValue(new GenericMessageTestHelper<>(10))); expression = parser.parseExpression("payload*2"); - assertEquals(8,expression.getValue(new GenericMessageTestHelper(4))); + assertEquals(8, expression.getValue(new GenericMessageTestHelper<>(4))); assertCanCompile(expression); - assertEquals(12,expression.getValue(new GenericMessageTestHelper(6))); + assertEquals(12, expression.getValue(new GenericMessageTestHelper<>(6))); expression = parser.parseExpression("100*payload"); - assertEquals(400,expression.getValue(new GenericMessageTestHelper(4))); + assertEquals(400, expression.getValue(new GenericMessageTestHelper<>(4))); assertCanCompile(expression); - assertEquals(1000,expression.getValue(new GenericMessageTestHelper(10))); + assertEquals(1000, expression.getValue(new GenericMessageTestHelper<>(10))); expression = parser.parseExpression("payload/2L"); - assertEquals(2L,expression.getValue(new GenericMessageTestHelper(4L))); + assertEquals(2L, expression.getValue(new GenericMessageTestHelper<>(4L))); assertCanCompile(expression); - assertEquals(3L,expression.getValue(new GenericMessageTestHelper(6L))); + assertEquals(3L, expression.getValue(new GenericMessageTestHelper<>(6L))); expression = parser.parseExpression("100L/payload"); - assertEquals(25L,expression.getValue(new GenericMessageTestHelper(4L))); + assertEquals(25L, expression.getValue(new GenericMessageTestHelper<>(4L))); assertCanCompile(expression); - assertEquals(10L,expression.getValue(new GenericMessageTestHelper(10L))); + assertEquals(10L, expression.getValue(new GenericMessageTestHelper<>(10L))); expression = parser.parseExpression("payload/2f"); - assertEquals(2f,expression.getValue(new GenericMessageTestHelper(4f))); + assertEquals(2f, expression.getValue(new GenericMessageTestHelper<>(4f))); assertCanCompile(expression); - assertEquals(3f,expression.getValue(new GenericMessageTestHelper(6f))); + assertEquals(3f, expression.getValue(new GenericMessageTestHelper<>(6f))); expression = parser.parseExpression("100f/payload"); - assertEquals(25f,expression.getValue(new GenericMessageTestHelper(4f))); + assertEquals(25f, expression.getValue(new GenericMessageTestHelper<>(4f))); assertCanCompile(expression); - assertEquals(10f,expression.getValue(new GenericMessageTestHelper(10f))); + assertEquals(10f, expression.getValue(new GenericMessageTestHelper<>(10f))); expression = parser.parseExpression("payload/2d"); - assertEquals(2d,expression.getValue(new GenericMessageTestHelper(4d))); + assertEquals(2d, expression.getValue(new GenericMessageTestHelper<>(4d))); assertCanCompile(expression); - assertEquals(3d,expression.getValue(new GenericMessageTestHelper(6d))); + assertEquals(3d, expression.getValue(new GenericMessageTestHelper<>(6d))); expression = parser.parseExpression("100d/payload"); - assertEquals(25d,expression.getValue(new GenericMessageTestHelper(4d))); + assertEquals(25d, expression.getValue(new GenericMessageTestHelper<>(4d))); assertCanCompile(expression); - assertEquals(10d,expression.getValue(new GenericMessageTestHelper(10d))); + assertEquals(10d, expression.getValue(new GenericMessageTestHelper<>(10d))); } // The new helper class here uses an upper bound on the generic @Test public void compilerWithGenerics_12040_2() { expression = parser.parseExpression("payload/2"); - assertEquals(2,expression.getValue(new GenericMessageTestHelper2(4))); + assertEquals(2, expression.getValue(new GenericMessageTestHelper2<>(4))); assertCanCompile(expression); - assertEquals(3,expression.getValue(new GenericMessageTestHelper2(6))); + assertEquals(3, expression.getValue(new GenericMessageTestHelper2<>(6))); expression = parser.parseExpression("9/payload"); - assertEquals(1,expression.getValue(new GenericMessageTestHelper2(9))); + assertEquals(1, expression.getValue(new GenericMessageTestHelper2<>(9))); assertCanCompile(expression); - assertEquals(3,expression.getValue(new GenericMessageTestHelper2(3))); + assertEquals(3, expression.getValue(new GenericMessageTestHelper2<>(3))); expression = parser.parseExpression("payload+2"); - assertEquals(6,expression.getValue(new GenericMessageTestHelper2(4))); + assertEquals(6, expression.getValue(new GenericMessageTestHelper2<>(4))); assertCanCompile(expression); - assertEquals(8,expression.getValue(new GenericMessageTestHelper2(6))); + assertEquals(8, expression.getValue(new GenericMessageTestHelper2<>(6))); expression = parser.parseExpression("100+payload"); - assertEquals(104,expression.getValue(new GenericMessageTestHelper2(4))); + assertEquals(104, expression.getValue(new GenericMessageTestHelper2<>(4))); assertCanCompile(expression); - assertEquals(110,expression.getValue(new GenericMessageTestHelper2(10))); + assertEquals(110, expression.getValue(new GenericMessageTestHelper2<>(10))); expression = parser.parseExpression("payload-2"); - assertEquals(2,expression.getValue(new GenericMessageTestHelper2(4))); + assertEquals(2, expression.getValue(new GenericMessageTestHelper2<>(4))); assertCanCompile(expression); - assertEquals(4,expression.getValue(new GenericMessageTestHelper2(6))); + assertEquals(4, expression.getValue(new GenericMessageTestHelper2<>(6))); expression = parser.parseExpression("100-payload"); - assertEquals(96,expression.getValue(new GenericMessageTestHelper2(4))); + assertEquals(96, expression.getValue(new GenericMessageTestHelper2<>(4))); assertCanCompile(expression); - assertEquals(90,expression.getValue(new GenericMessageTestHelper2(10))); + assertEquals(90, expression.getValue(new GenericMessageTestHelper2<>(10))); expression = parser.parseExpression("payload*2"); - assertEquals(8,expression.getValue(new GenericMessageTestHelper2(4))); + assertEquals(8, expression.getValue(new GenericMessageTestHelper2<>(4))); assertCanCompile(expression); - assertEquals(12,expression.getValue(new GenericMessageTestHelper2(6))); + assertEquals(12, expression.getValue(new GenericMessageTestHelper2<>(6))); expression = parser.parseExpression("100*payload"); - assertEquals(400,expression.getValue(new GenericMessageTestHelper2(4))); + assertEquals(400, expression.getValue(new GenericMessageTestHelper2<>(4))); assertCanCompile(expression); - assertEquals(1000,expression.getValue(new GenericMessageTestHelper2(10))); + assertEquals(1000, expression.getValue(new GenericMessageTestHelper2<>(10))); } // The other numeric operators @Test public void compilerWithGenerics_12040_3() { expression = parser.parseExpression("payload >= 2"); - assertTrue(expression.getValue(new GenericMessageTestHelper2(4),Boolean.TYPE)); + assertTrue(expression.getValue(new GenericMessageTestHelper2<>(4), Boolean.TYPE)); assertCanCompile(expression); - assertFalse(expression.getValue(new GenericMessageTestHelper2(1),Boolean.TYPE)); + assertFalse(expression.getValue(new GenericMessageTestHelper2<>(1), Boolean.TYPE)); expression = parser.parseExpression("2 >= payload"); - assertFalse(expression.getValue(new GenericMessageTestHelper2(5),Boolean.TYPE)); + assertFalse(expression.getValue(new GenericMessageTestHelper2<>(5), Boolean.TYPE)); assertCanCompile(expression); - assertTrue(expression.getValue(new GenericMessageTestHelper2(1),Boolean.TYPE)); + assertTrue(expression.getValue(new GenericMessageTestHelper2<>(1), Boolean.TYPE)); expression = parser.parseExpression("payload > 2"); - assertTrue(expression.getValue(new GenericMessageTestHelper2(4),Boolean.TYPE)); + assertTrue(expression.getValue(new GenericMessageTestHelper2<>(4), Boolean.TYPE)); assertCanCompile(expression); - assertFalse(expression.getValue(new GenericMessageTestHelper2(1),Boolean.TYPE)); + assertFalse(expression.getValue(new GenericMessageTestHelper2<>(1), Boolean.TYPE)); expression = parser.parseExpression("2 > payload"); - assertFalse(expression.getValue(new GenericMessageTestHelper2(5),Boolean.TYPE)); + assertFalse(expression.getValue(new GenericMessageTestHelper2<>(5), Boolean.TYPE)); assertCanCompile(expression); - assertTrue(expression.getValue(new GenericMessageTestHelper2(1),Boolean.TYPE)); + assertTrue(expression.getValue(new GenericMessageTestHelper2<>(1), Boolean.TYPE)); expression = parser.parseExpression("payload <=2"); - assertTrue(expression.getValue(new GenericMessageTestHelper2(1),Boolean.TYPE)); + assertTrue(expression.getValue(new GenericMessageTestHelper2<>(1), Boolean.TYPE)); assertCanCompile(expression); - assertFalse(expression.getValue(new GenericMessageTestHelper2(6),Boolean.TYPE)); + assertFalse(expression.getValue(new GenericMessageTestHelper2<>(6), Boolean.TYPE)); expression = parser.parseExpression("2 <= payload"); - assertFalse(expression.getValue(new GenericMessageTestHelper2(1),Boolean.TYPE)); + assertFalse(expression.getValue(new GenericMessageTestHelper2<>(1), Boolean.TYPE)); assertCanCompile(expression); - assertTrue(expression.getValue(new GenericMessageTestHelper2(6),Boolean.TYPE)); + assertTrue(expression.getValue(new GenericMessageTestHelper2<>(6), Boolean.TYPE)); expression = parser.parseExpression("payload < 2"); - assertTrue(expression.getValue(new GenericMessageTestHelper2(1),Boolean.TYPE)); + assertTrue(expression.getValue(new GenericMessageTestHelper2<>(1), Boolean.TYPE)); assertCanCompile(expression); - assertFalse(expression.getValue(new GenericMessageTestHelper2(6),Boolean.TYPE)); + assertFalse(expression.getValue(new GenericMessageTestHelper2<>(6), Boolean.TYPE)); expression = parser.parseExpression("2 < payload"); - assertFalse(expression.getValue(new GenericMessageTestHelper2(1),Boolean.TYPE)); + assertFalse(expression.getValue(new GenericMessageTestHelper2<>(1), Boolean.TYPE)); assertCanCompile(expression); - assertTrue(expression.getValue(new GenericMessageTestHelper2(6),Boolean.TYPE)); + assertTrue(expression.getValue(new GenericMessageTestHelper2<>(6), Boolean.TYPE)); } @Test public void indexerMapAccessor_12045() throws Exception { - SpelParserConfiguration spc = new SpelParserConfiguration(SpelCompilerMode.IMMEDIATE,this.getClass().getClassLoader()); + SpelParserConfiguration spc = new SpelParserConfiguration(SpelCompilerMode.IMMEDIATE,getClass().getClassLoader()); SpelExpressionParser sep = new SpelExpressionParser(spc); expression=sep.parseExpression("headers[command]"); MyMessage root = new MyMessage(); - assertEquals("wibble",expression.getValue(root)); + assertEquals("wibble", expression.getValue(root)); // This next call was failing because the isCompilable check in Indexer did not check on the key being compilable // (and also generateCode in the Indexer was missing the optimization that it didn't need necessarily need to call // generateCode for that accessor) - assertEquals("wibble",expression.getValue(root)); + assertEquals("wibble", expression.getValue(root)); assertCanCompile(expression); // What about a map key that is an expression - ensure the getKey() is evaluated in the right scope expression=sep.parseExpression("headers[getKey()]"); - assertEquals("wobble",expression.getValue(root)); - assertEquals("wobble",expression.getValue(root)); + assertEquals("wobble", expression.getValue(root)); + assertEquals("wobble", expression.getValue(root)); expression=sep.parseExpression("list[getKey2()]"); - assertEquals("wobble",expression.getValue(root)); - assertEquals("wobble",expression.getValue(root)); + assertEquals("wobble", expression.getValue(root)); + assertEquals("wobble", expression.getValue(root)); expression = sep.parseExpression("ia[getKey2()]"); - assertEquals(3,expression.getValue(root)); - assertEquals(3,expression.getValue(root)); + assertEquals(3, expression.getValue(root)); + assertEquals(3, expression.getValue(root)); } // helper methods private SpelNodeImpl getAst() { - SpelExpression spelExpression = (SpelExpression)expression; + SpelExpression spelExpression = (SpelExpression) expression; SpelNode ast = spelExpression.getAST(); return (SpelNodeImpl)ast; } @@ -4566,21 +4639,21 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { private String stringify(Object object) { StringBuilder s = new StringBuilder(); if (object instanceof List) { - List ls = (List)object; + List ls = (List) object; for (Object l: ls) { s.append(l); s.append(" "); } } else if (object instanceof Object[]) { - Object[] os = (Object[])object; + Object[] os = (Object[]) object; for (Object o: os) { s.append(o); s.append(" "); } } else if (object instanceof int[]) { - int[] is = (int[])object; + int[] is = (int[]) object; for (int i: is) { s.append(i); s.append(" "); @@ -4615,8 +4688,6 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { } - // helper classes - public interface Message { MessageHeaders getHeaders(); @@ -4627,6 +4698,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { int[] getIa(); } + public static class MyMessage implements Message { public MessageHeaders getHeaders() { @@ -4636,9 +4708,9 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { return mh; } - public int[] getIa() { return new int[]{5,3}; } + public int[] getIa() { return new int[] {5,3}; } - @SuppressWarnings({ "rawtypes", "unchecked" }) + @SuppressWarnings({"rawtypes", "unchecked"}) public List getList() { List l = new ArrayList(); l.add("wibble"); @@ -4655,10 +4727,12 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { } } + @SuppressWarnings("serial") - public static class MessageHeaders extends HashMap { + public static class MessageHeaders extends HashMap { } + public static class GenericMessageTestHelper { private T payload; @@ -4672,6 +4746,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { } } + // This test helper has a bound on the type variable public static class GenericMessageTestHelper2 { @@ -4686,12 +4761,13 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { } } + static class MyAccessor implements CompilablePropertyAccessor { private Method method; public Class[] getSpecificTargetClasses() { - return new Class[]{Payload2.class}; + return new Class[] {Payload2.class}; } public boolean canRead(EvaluationContext context, Object target, String name) throws AccessException { @@ -4743,6 +4819,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { } } + static class CompilableMapAccessor implements CompilablePropertyAccessor { @Override @@ -4769,7 +4846,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { @Override @SuppressWarnings("unchecked") public void write(EvaluationContext context, Object target, String name, Object newValue) throws AccessException { - Map map = (Map) target; + Map map = (Map) target; map.put(name, newValue); } @@ -4799,6 +4876,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { } } + /** * Exception thrown from {@code read} in order to reset a cached * PropertyAccessor, allowing other accessors to have a try. @@ -4820,8 +4898,6 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { } - // test classes - public static class Greeter { public String getWorld() { @@ -4833,19 +4909,22 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { } } + public static class FooObject { public Object getObject() { return "hello"; } } + public static class FooString { public String getObject() { return "hello"; } } + public static class Payload { - Two[] DR = new Two[]{new Two()}; + Two[] DR = new Two[] {new Two()}; public Two holder = new Two(); @@ -4854,6 +4933,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { } } + public static class Payload2 { String var1 = "abc"; @@ -4870,11 +4950,13 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { } } + public static class Payload2Holder { public Payload2 payload2 = new Payload2(); } + public class Person { private int age; @@ -4892,6 +4974,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { } } + public class Person3 { private int age; @@ -4909,6 +4992,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { } } + public static class Two { Three three = new Three(); @@ -4921,6 +5005,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { } } + public static class Three { double four = 0.04d; @@ -4930,6 +5015,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { } } + public class PayloadX { public int valueI = 120; @@ -4962,12 +5048,15 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { public Short valueSB = (short)120; public Short valueSB18 = (short)18; public Short valueSB20 = (short)20; + public PayloadX payload; + public PayloadX() { payload = this; } } + public static class TestClass1 { public int index1 = 1; @@ -4975,6 +5064,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { public String word = "abcd"; } + public static class TestClass4 { public boolean a,b; @@ -4984,6 +5074,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { public boolean getB() { return b; } } + public static class TestClass10 { public String s = null; @@ -4997,13 +5088,13 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { } public void concat(String... vargs) { - if (vargs==null) { + if (vargs == null) { s = ""; } else { s = ""; - for (String varg: vargs) { - s+=varg; + for (String varg : vargs) { + s += varg; } } } @@ -5013,18 +5104,19 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { } public void concat2(Object... vargs) { - if (vargs==null) { + if (vargs == null) { s = ""; } else { s = ""; - for (Object varg: vargs) { - s+=varg; + for (Object varg : vargs) { + s += varg; } } } } + public static class TestClass5 { public int i = 0; @@ -5052,8 +5144,8 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { public static byte b2 = (byte)66; public static byte b3 = (byte)67; - public static String[] stringArray = new String[]{"aaa","bbb","ccc"}; - public static int[] intArray = new int[]{11,22,33}; + public static String[] stringArray = new String[] {"aaa","bbb","ccc"}; + public static int[] intArray = new int[] {11,22,33}; public Object obj = null; @@ -5078,7 +5170,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { public static long six() { return 3277700L; } public void seven(String toset) { s = toset; } -// public void seven(Number n) { s = n.toString(); } + // public void seven(Number n) { s = n.toString(); } public void takeNumber(Number n) { s = n.toString(); } public void takeString(String s) { this.s = s; } @@ -5088,37 +5180,37 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { public static void ten(int toset) { _i = toset; } public void eleven(String... vargs) { - if (vargs==null) { + if (vargs == null) { s = ""; } else { s = ""; for (String varg: vargs) { - s+=varg; + s += varg; } } } public void twelve(int... vargs) { - if (vargs==null) { + if (vargs == null) { i = 0; } else { i = 0; for (int varg: vargs) { - i+=varg; + i += varg; } } } public void thirteen(String a, String... vargs) { - if (vargs==null) { - s = a+"::"; + if (vargs == null) { + s = a + "::"; } else { s = a+"::"; for (String varg: vargs) { - s+=varg; + s += varg; } } } @@ -5128,7 +5220,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { if (bs != null) { s = ""; for (boolean b: bs) { - s+=Boolean.toString(b); + s += Boolean.toString(b); } } } @@ -5138,7 +5230,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { if (ss != null) { s = ""; for (short s: ss) { - this.s+=Short.toString(s); + this.s += Short.toString(s); } } } @@ -5148,7 +5240,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { if (vargs != null) { s = ""; for (double v: vargs) { - this.s+=Double.toString(v); + this.s += Double.toString(v); } } } @@ -5158,7 +5250,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { if (vargs != null) { s = ""; for (float v: vargs) { - this.s+=Float.toString(v); + this.s += Float.toString(v); } } } @@ -5168,7 +5260,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { if (vargs != null) { s = ""; for (long v: vargs) { - this.s+=Long.toString(v); + this.s += Long.toString(v); } } } @@ -5178,7 +5270,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { if (vargs != null) { s = ""; for (Byte v: vargs) { - this.s+=Byte.toString(v); + this.s += Byte.toString(v); } } } @@ -5188,56 +5280,57 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { if (vargs != null) { s = ""; for (char v: vargs) { - this.s+=Character.toString(v); + this.s += Character.toString(v); } } } public void fourteen(String a, String[]... vargs) { - if (vargs==null) { + if (vargs == null) { s = a+"::"; } else { s = a+"::"; for (String[] varg: vargs) { - s+="{"; + s += "{"; for (String v: varg) { - s+=v; + s += v; } - s+="}"; + s += "}"; } } } public void fifteen(String a, int[]... vargs) { - if (vargs==null) { + if (vargs == null) { s = a+"::"; } else { s = a+"::"; for (int[] varg: vargs) { - s+="{"; + s += "{"; for (int v: varg) { - s+=Integer.toString(v); + s += Integer.toString(v); } - s+="}"; + s += "}"; } } } public void sixteen(Object... vargs) { - if (vargs==null) { + if (vargs == null) { s = ""; } else { s = ""; for (Object varg: vargs) { - s+=varg; + s += varg; } } } } + public static class TestClass6 { public String orange = "value1"; @@ -5254,6 +5347,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { } } + public static class TestClass7 { public static String property; @@ -5269,9 +5363,9 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { StringTokenizer st = new StringTokenizer(s); property = st.nextToken(); } - } + public static class TestClass8 { public int i; @@ -5287,7 +5381,6 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { } public TestClass8() { - } public TestClass8(Integer i) { @@ -5300,6 +5393,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { } } + public static class Obj { private final String param1; @@ -5309,6 +5403,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { } } + public static class Obj2 { public final String output; @@ -5322,6 +5417,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { } } + public static class Obj3 { public final String output; @@ -5347,6 +5443,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { } } + public static class Obj4 { public final String output; @@ -5360,12 +5457,15 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { } } + @SuppressWarnings("unused") private static class TestClass9 { - public TestClass9(int i) {} + public TestClass9(int i) { + } } + // These test classes simulate a pattern of public/private classes seen in Spring Security // final class HttpServlet3RequestFactory implements HttpServletRequestFactory @@ -5381,10 +5481,12 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { } } + // public class SecurityContextHolderAwareRequestWrapper extends HttpServletRequestWrapper static class SecurityContextHolderAwareRequestWrapper extends HttpServletRequestWrapper { } + public static class HttpServletRequestWrapper { public String getServletPath() { @@ -5392,6 +5494,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { } } + // Here the declaring class is not public static class SomeCompareMethod { @@ -5406,6 +5509,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { } } + public static class SomeCompareMethod2 { public static int negate(int i1) { @@ -5414,7 +5518,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { public static String append(String... strings) { StringBuilder b = new StringBuilder(); - for (String string: strings) { + for (String string : strings) { b.append(string); } return b.toString(); @@ -5422,7 +5526,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { public static String append2(Object... objects) { StringBuilder b = new StringBuilder(); - for (Object object: objects) { + for (Object object : objects) { b.append(object.toString()); } return b.toString(); @@ -5430,7 +5534,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { public static String append3(String[] strings) { StringBuilder b = new StringBuilder(); - for (String string: strings) { + for (String string : strings) { b.append(string); } return b.toString(); @@ -5439,7 +5543,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { public static String append4(String s, String... strings) { StringBuilder b = new StringBuilder(); b.append(s).append("::"); - for (String string: strings) { + for (String string : strings) { b.append(string); } return b.toString(); @@ -5447,7 +5551,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { public static String appendChar(char... values) { StringBuilder b = new StringBuilder(); - for (char ch: values) { + for (char ch : values) { b.append(ch); } return b.toString(); @@ -5455,29 +5559,30 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { public static int sum(int... ints) { int total = 0; - for (int i: ints) { - total+=i; + for (int i : ints) { + total += i; } return total; } public static int sumDouble(double... values) { int total = 0; - for (double i: values) { - total+=i; + for (double i : values) { + total += i; } return total; } public static int sumFloat(float... values) { int total = 0; - for (float i: values) { - total+=i; + for (float i : values) { + total += i; } return total; } } + public static class DelegatingStringFormat { public static String format(String s, Object... args) { @@ -5485,15 +5590,20 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { } } + public static class StaticsHelper { + static StaticsHelper sh = new StaticsHelper(); + public static StaticsHelper fielda = sh; + public static String fieldb = "fb"; + public static StaticsHelper methoda() { return sh; } public static String methodb() { return "mb"; } - + public static StaticsHelper getPropertya() { return sh; } @@ -5501,13 +5611,54 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { public static String getPropertyb() { return "pb"; } - - public static StaticsHelper fielda = sh; - public static String fieldb = "fb"; - public String toString() { return "sh"; } } + + + public static class Apple implements Comparable { + + public Object gotComparedTo = null; + public int i; + + public Apple(int i) { + this.i = i; + } + + public void setValue(int i) { + this.i = i; + } + + @Override + public int compareTo(Apple that) { + this.gotComparedTo = that; + if (this.i < that.i) { + return -1; + } + else if (this.i > that.i) { + return +1; + } + else { + return 0; + } + } + } + + + // For opNe_SPR14863 + public static class MyContext { + + private final Map data; + + public MyContext(Map data) { + this.data = data; + } + + public Map getData() { + return data; + } + } + }