From e410129aafcd2a031c14976bf44dc01da4b1f5e1 Mon Sep 17 00:00:00 2001 From: Andy Clement Date: Tue, 24 Nov 2015 22:37:53 +0100 Subject: [PATCH] Ensure cast correctly included for OpPlus compilation When the plus operator is used between strings in a SpEL expression and that expression is compiled, it is important to include a cast if computation of any of the operands isn't obviously leaving strings on the stack. Likewise if the stack contents are known to be strings, a cast should not be included. Issue: SPR-12426 (cherry picked from commit 58756b0) --- .../expression/spel/ast/OpPlus.java | 4 +- .../spel/SpelCompilationCoverageTests.java | 1208 +++++++++-------- 2 files changed, 626 insertions(+), 586 deletions(-) diff --git a/spring-expression/src/main/java/org/springframework/expression/spel/ast/OpPlus.java b/spring-expression/src/main/java/org/springframework/expression/spel/ast/OpPlus.java index 91fe886756..36b3e4e788 100644 --- a/spring-expression/src/main/java/org/springframework/expression/spel/ast/OpPlus.java +++ b/spring-expression/src/main/java/org/springframework/expression/spel/ast/OpPlus.java @@ -1,5 +1,5 @@ /* - * Copyright 2002-2014 the original author or authors. + * Copyright 2002-2015 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. @@ -206,7 +206,7 @@ public class OpPlus extends Operator { else { cf.enterCompilationScope(); operand.generateCode(mv,cf); - if (cf.lastDescriptor() != "Ljava/lang/String") { + if (!"Ljava/lang/String".equals(cf.lastDescriptor())) { mv.visitTypeInsn(CHECKCAST, "java/lang/String"); } cf.exitCompilationScope(); 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 022d94157c..855361f174 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 @@ -1,5 +1,5 @@ /* - * Copyright 2014 the original author or authors. + * Copyright 2002-2015 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. @@ -50,13 +50,13 @@ import static org.junit.Assert.*; * @since 4.1 */ public class SpelCompilationCoverageTests extends AbstractExpressionTests { - + private Expression expression; private SpelNodeImpl ast; - + /* * Further TODOs for compilation: - * + * * - OpMinus with a single literal operand could be treated as a negative literal. Will save a * pointless loading of 0 and then a subtract instruction in code gen. * - allow other accessors/resolvers to participate in compilation and create their own code @@ -66,10 +66,10 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { * - The opEq implementation is quite basic. It will compare numbers of the same type (allowing * them to be their boxed or unboxed variants) or compare object references. It does not * compile expressions where numbers are of different types or when objects implement - * Comparable. + * Comparable. * * Compiled nodes: - * + * * TypeReference * OperatorInstanceOf * StringLiteral @@ -103,7 +103,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { * FunctionReference * InlineList * OpModulus - * + * * Not yet compiled (some may never need to be): * Assign * BeanReference @@ -117,14 +117,14 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { * QualifiedId * Selection */ - + @Test public void typeReference() throws Exception { expression = parse("T(String)"); assertEquals(String.class,expression.getValue()); assertCanCompile(expression); assertEquals(String.class,expression.getValue()); - + expression = parse("T(java.io.IOException)"); assertEquals(IOException.class,expression.getValue()); assertCanCompile(expression); @@ -179,7 +179,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { assertEquals(Boolean.TYPE,expression.getValue()); assertCanCompile(expression); assertEquals(Boolean.TYPE,expression.getValue()); - + expression = parse("T(Missing)"); assertGetValueFail(expression); assertCantCompile(expression); @@ -209,7 +209,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { assertEquals(true,expression.getValue(arrayOfLists)); assertCanCompile(expression); assertEquals(true,expression.getValue(arrayOfLists)); - + int[] intArray = new int[]{1,2,3}; expression = parse("#root instanceof T(int[])"); assertEquals(true,expression.getValue(intArray)); @@ -237,7 +237,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { @Test public void stringLiteral() throws Exception { - expression = parser.parseExpression("'abcde'"); + expression = parser.parseExpression("'abcde'"); assertEquals("abcde",expression.getValue(new TestClass1(),String.class)); assertCanCompile(expression); String resultC = expression.getValue(new TestClass1(),String.class); @@ -249,7 +249,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { assertCanCompile(expression); assertEquals("abcde",expression.getValue(String.class)); } - + @Test public void nullLiteral() throws Exception { expression = parser.parseExpression("null"); @@ -260,7 +260,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { assertEquals(null,resultC); assertEquals(null,resultC); } - + @Test public void realLiteral() throws Exception { expression = parser.parseExpression("3.4d"); @@ -272,7 +272,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { assertEquals(3.4d,expression.getValue()); } - + @SuppressWarnings("rawtypes") @Test public void inlineList() throws Exception { @@ -282,21 +282,21 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { assertCanCompile(expression); o = expression.getValue(); assertEquals("bcde", o); - + expression = parser.parseExpression("{'abc','def'}"); List l = (List) expression.getValue(); assertEquals("[abc, def]", l.toString()); assertCanCompile(expression); l = (List) expression.getValue(); assertEquals("[abc, def]", l.toString()); - + expression = parser.parseExpression("{'abc','def'}[0]"); o = expression.getValue(); assertEquals("abc",o); assertCanCompile(expression); o = expression.getValue(); assertEquals("abc", o); - + expression = parser.parseExpression("{'abcde','ijklm'}[0].substring({1,3,4}[0])"); o = expression.getValue(); assertEquals("bcde",o); @@ -316,7 +316,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { @Test public void nestedInlineLists() throws Exception { Object o = null; - + expression = parser.parseExpression("{{1,2,3},{4,5,6},{7,8,9}}"); o = expression.getValue(); assertEquals("[[1, 2, 3], [4, 5, 6], [7, 8, 9]]",o.toString()); @@ -337,7 +337,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { assertCanCompile(expression); o = expression.getValue(); assertEquals(4,o); - + expression = parser.parseExpression("{{1,2,3},'abc',{7,8,9}}[1]"); o = expression.getValue(); assertEquals("abc",o); @@ -358,7 +358,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { assertCanCompile(expression); o = expression.getValue(); assertEquals("bcde", o); - + expression = parser.parseExpression("{'abc',{'def','ghi'}}"); List l = (List) expression.getValue(); assertEquals("[abc, [def, ghi]]", l.toString()); @@ -372,7 +372,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { assertCanCompile(expression); o = expression.getValue(); assertEquals("bcde", o); - + expression = parser.parseExpression("{'abcde',{'ijklm','nopqr'}}[1][0].substring({1,3,4}[0])"); o = expression.getValue(); assertEquals("jklm",o); @@ -401,10 +401,10 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { expression.getValue(Integer.class); assertCanCompile(expression); 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 - + // Not an int literal but an opminus with one operand: // expression = parser.parseExpression("-1"); // assertCanCompile(expression); @@ -419,7 +419,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { assertCanCompile(expression); assertEquals(7,expression.getValue()); } - + @Test public void longLiteral() throws Exception { expression = parser.parseExpression("99L"); @@ -427,9 +427,9 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { assertCanCompile(expression); long resultC = expression.getValue(new TestClass1(),Long.TYPE); assertEquals(99L,resultI); - assertEquals(99L,resultC); + assertEquals(99L,resultC); } - + @Test public void booleanLiteral() throws Exception { expression = parser.parseExpression("true"); @@ -438,7 +438,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { assertTrue(SpelCompiler.compile(expression)); boolean resultC = expression.getValue(1,Boolean.TYPE); assertEquals(true,resultC); - + expression = parser.parseExpression("false"); resultI = expression.getValue(1,Boolean.TYPE); assertEquals(false,resultI); @@ -446,7 +446,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { resultC = expression.getValue(1,Boolean.TYPE); assertEquals(false,resultC); } - + @Test public void floatLiteral() throws Exception { expression = parser.parseExpression("3.4f"); @@ -458,7 +458,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { assertEquals(3.4f,expression.getValue()); } - + @Test public void opOr() throws Exception { Expression expression = parser.parseExpression("false or false"); @@ -467,21 +467,21 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { 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); assertCanCompile(expression); resultC = expression.getValue(1,Boolean.TYPE); assertEquals(true,resultI); assertEquals(true,resultC); - + expression = parser.parseExpression("true or false"); resultI = expression.getValue(1,Boolean.TYPE); assertCanCompile(expression); resultC = expression.getValue(1,Boolean.TYPE); assertEquals(true,resultI); assertEquals(true,resultC); - + expression = parser.parseExpression("true or true"); resultI = expression.getValue(1,Boolean.TYPE); assertCanCompile(expression); @@ -501,7 +501,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { expression = parser.parseExpression("gettrue() or getfalse()"); resultI = expression.getValue(tc,Boolean.TYPE); assertCantCompile(expression); - + expression = parser.parseExpression("getA() or getB()"); tc.a = true; tc.b = true; @@ -512,7 +512,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { resultI = expression.getValue(tc,Boolean.TYPE); assertCanCompile(expression); // Now been down both assertTrue(resultI); - + boolean b = false; expression = parse("#root or #root"); Object resultI2 = expression.getValue(b); @@ -520,7 +520,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { assertFalse((Boolean)resultI2); assertFalse((Boolean)expression.getValue(b)); } - + @Test public void opAnd() throws Exception { Expression expression = parser.parseExpression("false and false"); @@ -536,7 +536,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { resultC = expression.getValue(1,Boolean.TYPE); assertEquals(false,resultI); assertEquals(false,resultC); - + expression = parser.parseExpression("true and false"); resultI = expression.getValue(1,Boolean.TYPE); SpelCompiler.compile(expression); @@ -550,14 +550,14 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { 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); assertCantCompile(expression); - + expression = parser.parseExpression("getA() and getB()"); tc.a = false; tc.b = false; @@ -572,7 +572,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { tc.b = true; resultI = expression.getValue(tc,Boolean.TYPE); assertTrue(resultI); - + boolean b = true; expression = parse("#root and #root"); Object resultI2 = expression.getValue(b); @@ -580,7 +580,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { assertTrue((Boolean)resultI2); assertTrue((Boolean)expression.getValue(b)); } - + @Test public void operatorNot() throws Exception { expression = parse("!true"); @@ -614,7 +614,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { String resultC = expression.getValue(String.class); assertEquals("a",resultI); assertEquals("a",resultC); - + expression = parser.parseExpression("false?'a':'b'"); resultI = expression.getValue(String.class); assertCanCompile(expression); @@ -636,9 +636,9 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { assertCanCompile(expression); 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'"); @@ -651,7 +651,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { assertCanCompile(expression); assertEquals("def",expression.getValue()); } - + @Test public void elvis() throws Exception { Expression expression = parser.parseExpression("'a'?:'b'"); @@ -660,14 +660,14 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { String resultC = expression.getValue(String.class); 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); - + String s = "abc"; expression = parser.parseExpression("#root?:'b'"); assertCantCompile(expression); @@ -675,7 +675,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { assertEquals("abc",resultI); assertCanCompile(expression); } - + @Test public void variableReference_root() throws Exception { String s = "hello"; @@ -684,7 +684,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { assertCanCompile(expression); String resultC = expression.getValue(s,String.class); assertEquals(s,resultI); - assertEquals(s,resultC); + assertEquals(s,resultC); expression = parser.parseExpression("#root"); int i = (Integer)expression.getValue(42); @@ -693,11 +693,11 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { i = (Integer)expression.getValue(42); assertEquals(42,i); } - + public static String concat(String a, String b) { return a+b; } - + public static String join(String...strings) { StringBuilder buf = new StringBuilder(); for (String string: strings) { @@ -705,7 +705,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { } return buf.toString(); } - + @Test public void compiledExpressionShouldWorkWhenUsingCustomFunctionWithVarargs() throws Exception { StandardEvaluationContext context = null; @@ -748,23 +748,23 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { assertCanCompile(expression); assertEquals("hey there", expression.getValue(String.class)); } - + @Test public void functionReference() throws Exception { EvaluationContext ctx = new StandardEvaluationContext(); Method m = this.getClass().getDeclaredMethod("concat",String.class,String.class); ctx.setVariable("concat",m); - + expression = parser.parseExpression("#concat('a','b')"); assertEquals("ab",expression.getValue(ctx)); assertCanCompile(expression); assertEquals("ab",expression.getValue(ctx)); - + expression = parser.parseExpression("#concat(#concat('a','b'),'c').charAt(1)"); assertEquals('b',expression.getValue(ctx)); assertCanCompile(expression); assertEquals('b',expression.getValue(ctx)); - + expression = parser.parseExpression("#concat(#a,#b)"); ctx.setVariable("a", "foo"); ctx.setVariable("b", "bar"); @@ -773,7 +773,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { assertEquals("foobar",expression.getValue(ctx)); ctx.setVariable("b", "boo"); assertEquals("fooboo",expression.getValue(ctx)); - + m = Math.class.getDeclaredMethod("pow",Double.TYPE,Double.TYPE); ctx.setVariable("kapow",m); expression = parser.parseExpression("#kapow(2.0d,2.0d)"); @@ -793,7 +793,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { expression = parser.parseExpression("#doCompare([0],#arg)"); assertEquals("-1",expression.getValue(context, Integer.class).toString()); assertCantCompile(expression); - + // type not public but method is context = new StandardEvaluationContext(new Object[] { "1" }); context.registerFunction("doCompare", SomeCompareMethod.class.getDeclaredMethod( @@ -803,7 +803,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { assertEquals("-1",expression.getValue(context, Integer.class).toString()); assertCantCompile(expression); } - + @Test public void functionReferenceNonCompilableArguments_SPR12359() throws Exception { StandardEvaluationContext context = new StandardEvaluationContext(new Object[] { "1" }); @@ -818,8 +818,8 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { // Selection isn't compilable. assertFalse(((SpelNodeImpl)((SpelExpression)expression).getAST()).isCompilable()); } - - @Test + + @Test public void functionReferenceVarargs_SPR12359() throws Exception { StandardEvaluationContext context = new StandardEvaluationContext(); context.registerFunction("append", @@ -860,20 +860,20 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { assertTrue(((SpelNodeImpl)((SpelExpression)expression).getAST()).isCompilable()); assertCanCompile(expression); assertEquals("",expression.getValue(context).toString()); - + expression = parser.parseExpression("#append(#stringArray)"); assertEquals("xyz",expression.getValue(context).toString()); assertTrue(((SpelNodeImpl)((SpelExpression)expression).getAST()).isCompilable()); assertCanCompile(expression); 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()); assertCanCompile(expression); 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()); @@ -897,7 +897,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { assertTrue(((SpelNodeImpl)((SpelExpression)expression).getAST()).isCompilable()); assertCanCompile(expression); assertEquals("",expression.getValue(context).toString()); - + expression = parser.parseExpression("#append3(#stringArray)"); assertEquals("xyz",expression.getValue(context, new SomeCompareMethod2()).toString()); assertTrue(((SpelNodeImpl)((SpelExpression)expression).getAST()).isCompilable()); @@ -910,7 +910,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { // 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()); @@ -928,13 +928,13 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { assertTrue(((SpelNodeImpl)((SpelExpression)expression).getAST()).isCompilable()); assertCanCompile(expression); assertEquals(0,expression.getValue(context)); - + expression = parser.parseExpression("#sum(#intArray)"); assertEquals(20,expression.getValue(context)); assertTrue(((SpelNodeImpl)((SpelExpression)expression).getAST()).isCompilable()); assertCanCompile(expression); 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()); @@ -952,7 +952,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { assertTrue(((SpelNodeImpl)((SpelExpression)expression).getAST()).isCompilable()); assertCanCompile(expression); assertEquals(0,expression.getValue(context)); - + expression = parser.parseExpression("#sumDouble(#doubleArray)"); assertEquals(20,expression.getValue(context)); assertTrue(((SpelNodeImpl)((SpelExpression)expression).getAST()).isCompilable()); @@ -976,21 +976,21 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { assertTrue(((SpelNodeImpl)((SpelExpression)expression).getAST()).isCompilable()); assertCanCompile(expression); assertEquals(0,expression.getValue(context)); - + expression = parser.parseExpression("#sumFloat(#floatArray)"); assertEquals(20,expression.getValue(context)); assertTrue(((SpelNodeImpl)((SpelExpression)expression).getAST()).isCompilable()); assertCanCompile(expression); 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()); assertCanCompile(expression); 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()); @@ -1008,14 +1008,14 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { assertTrue(((SpelNodeImpl)((SpelExpression)expression).getAST()).isCompilable()); assertCanCompile(expression); 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()); assertCanCompile(expression); assertEquals("a::xyz",expression.getValue(context).toString()); } - + @Test public void functionReferenceVarargs() throws Exception { EvaluationContext ctx = new StandardEvaluationContext(); @@ -1026,7 +1026,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { assertCanCompile(expression); assertEquals("abc",expression.getValue(ctx)); } - + @Test public void variableReference_userDefined() throws Exception { EvaluationContext ctx = new StandardEvaluationContext(); @@ -1034,33 +1034,35 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { expression = parser.parseExpression("#target"); 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)); fail(); - } catch (SpelEvaluationException see) { + } + catch (SpelEvaluationException see) { assertTrue(see.getCause() instanceof ClassCastException); } - + ctx.setVariable("target", "abc"); expression = parser.parseExpression("#target.charAt(0)"); 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)); fail(); - } catch (SpelEvaluationException see) { + } + catch (SpelEvaluationException see) { assertTrue(see.getCause() instanceof ClassCastException); } } - + @Test public void opLt() throws Exception { expression = parse("3.0d < 4.0d"); @@ -1076,25 +1078,25 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { expression = parse("2 < 4"); assertCanCompile(expression); assertTrue((Boolean)expression.getValue()); - + expression = parse("3.0f < 1.0f"); assertCanCompile(expression); assertFalse((Boolean)expression.getValue()); expression = parse("1.0f < 5.0f"); assertCanCompile(expression); assertTrue((Boolean)expression.getValue()); - + expression = parse("30L < 30L"); assertCanCompile(expression); assertFalse((Boolean)expression.getValue()); expression = parse("15L < 20L"); assertCanCompile(expression); 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()); assertCanCompile(expression); @@ -1110,7 +1112,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { assertCanCompile(expression); assertFalse((Boolean)expression.getValue()); } - + @Test public void opLe() throws Exception { expression = parse("3.0d <= 4.0d"); @@ -1132,7 +1134,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { expression = parse("3 <= 3"); assertCanCompile(expression); assertTrue((Boolean)expression.getValue()); - + expression = parse("3.0f <= 1.0f"); assertCanCompile(expression); assertFalse((Boolean)expression.getValue()); @@ -1142,14 +1144,14 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { expression = parse("2.0f <= 2.0f"); assertCanCompile(expression); assertTrue((Boolean)expression.getValue()); - + expression = parse("30L <= 30L"); assertCanCompile(expression); assertTrue((Boolean)expression.getValue()); expression = parse("15L <= 20L"); assertCanCompile(expression); assertTrue((Boolean)expression.getValue()); - + // Differing types of number, not yet supported expression = parse("1 <= 3.0d"); assertCantCompile(expression); @@ -1169,8 +1171,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { assertCanCompile(expression); assertFalse((Boolean)expression.getValue()); } - - + @Test public void opGt() throws Exception { expression = parse("3.0d > 4.0d"); @@ -1186,21 +1187,21 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { expression = parse("2 > 4"); assertCanCompile(expression); assertFalse((Boolean)expression.getValue()); - + expression = parse("3.0f > 1.0f"); assertCanCompile(expression); assertTrue((Boolean)expression.getValue()); expression = parse("1.0f > 5.0f"); assertCanCompile(expression); assertFalse((Boolean)expression.getValue()); - + expression = parse("30L > 30L"); assertCanCompile(expression); assertFalse((Boolean)expression.getValue()); expression = parse("15L > 20L"); assertCanCompile(expression); assertFalse((Boolean)expression.getValue()); - + // Differing types of number, not yet supported expression = parse("1 > 3.0d"); assertCantCompile(expression); @@ -1209,7 +1210,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { assertFalse((Boolean)expression.getValue()); assertCanCompile(expression); assertFalse((Boolean)expression.getValue()); - + expression = parse("T(Integer).valueOf(3) > T(Integer).valueOf(3)"); assertFalse((Boolean)expression.getValue()); assertCanCompile(expression); @@ -1220,7 +1221,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { assertCanCompile(expression); assertTrue((Boolean)expression.getValue()); } - + @Test public void opGe() throws Exception { expression = parse("3.0d >= 4.0d"); @@ -1242,7 +1243,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { expression = parse("3 >= 3"); assertCanCompile(expression); assertTrue((Boolean)expression.getValue()); - + expression = parse("3.0f >= 1.0f"); assertCanCompile(expression); assertTrue((Boolean)expression.getValue()); @@ -1252,7 +1253,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { expression = parse("3.0f >= 3.0f"); assertCanCompile(expression); assertTrue((Boolean)expression.getValue()); - + expression = parse("40L >= 30L"); assertCanCompile(expression); assertTrue((Boolean)expression.getValue()); @@ -1262,7 +1263,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { expression = parse("30L >= 30L"); assertCanCompile(expression); assertTrue((Boolean)expression.getValue()); - + // Differing types of number, not yet supported expression = parse("1 >= 3.0d"); assertCantCompile(expression); @@ -1271,7 +1272,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { assertFalse((Boolean)expression.getValue()); assertCanCompile(expression); assertFalse((Boolean)expression.getValue()); - + expression = parse("T(Integer).valueOf(3) >= T(Integer).valueOf(3)"); assertTrue((Boolean)expression.getValue()); assertCanCompile(expression); @@ -1316,8 +1317,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { assertTrue((Boolean)expression.getValue(tc7)); assertCanCompile(expression); assertTrue((Boolean)expression.getValue(tc7)); - - + expression = parse("3.0d == 4.0d"); assertCanCompile(expression); assertFalse((Boolean)expression.getValue()); @@ -1331,31 +1331,31 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { expression = parse("3 == 3"); assertCanCompile(expression); assertTrue((Boolean)expression.getValue()); - + expression = parse("3.0f == 1.0f"); assertCanCompile(expression); assertFalse((Boolean)expression.getValue()); expression = parse("2.0f == 2.0f"); assertCanCompile(expression); assertTrue((Boolean)expression.getValue()); - + expression = parse("30L == 30L"); assertCanCompile(expression); assertTrue((Boolean)expression.getValue()); expression = parse("15L == 20L"); assertCanCompile(expression); assertFalse((Boolean)expression.getValue()); - + // number types are not the same expression = parse("1 == 3.0d"); assertCantCompile(expression); - + Double d = 3.0d; expression = parse("#root==3.0d"); assertTrue((Boolean)expression.getValue(d)); assertCanCompile(expression); assertTrue((Boolean)expression.getValue(d)); - + Integer i = 3; expression = parse("#root==3"); assertTrue((Boolean)expression.getValue(i)); @@ -1367,13 +1367,13 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { assertTrue((Boolean)expression.getValue(f)); assertCanCompile(expression); assertTrue((Boolean)expression.getValue(f)); - + long l = 300l; expression = parse("#root==300l"); assertTrue((Boolean)expression.getValue(l)); assertCanCompile(expression); assertTrue((Boolean)expression.getValue(l)); - + boolean b = true; expression = parse("#root==true"); assertTrue((Boolean)expression.getValue(b)); @@ -1384,7 +1384,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { assertFalse((Boolean)expression.getValue()); assertCanCompile(expression); assertFalse((Boolean)expression.getValue()); - + expression = parse("T(Integer).valueOf(3) == T(Integer).valueOf(3)"); assertTrue((Boolean)expression.getValue()); assertCanCompile(expression); @@ -1399,7 +1399,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { assertFalse((Boolean)expression.getValue()); assertCanCompile(expression); assertFalse((Boolean)expression.getValue()); - + expression = parse("T(Float).valueOf(3.0f) == T(Float).valueOf(3.0f)"); assertTrue((Boolean)expression.getValue()); assertCanCompile(expression); @@ -1409,12 +1409,12 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { assertFalse((Boolean)expression.getValue()); assertCanCompile(expression); assertFalse((Boolean)expression.getValue()); - + expression = parse("T(Long).valueOf(3L) == 4L"); assertFalse((Boolean)expression.getValue()); assertCanCompile(expression); assertFalse((Boolean)expression.getValue()); - + expression = parse("T(Long).valueOf(3L) == T(Long).valueOf(3L)"); assertTrue((Boolean)expression.getValue()); assertCanCompile(expression); @@ -1423,13 +1423,13 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { expression = parse("5L == T(Long).valueOf(3L)"); 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()); assertCanCompile(expression); assertFalse((Boolean)expression.getValue()); - + expression = parse("T(Double).valueOf(3.0d) == T(Double).valueOf(3.0d)"); assertTrue((Boolean)expression.getValue()); assertCanCompile(expression); @@ -1444,7 +1444,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { assertFalse((Boolean)expression.getValue()); assertCanCompile(expression); assertFalse((Boolean)expression.getValue()); - + expression = parse("T(Boolean).valueOf('true') == T(Boolean).valueOf('true')"); assertTrue((Boolean)expression.getValue()); assertCanCompile(expression); @@ -1476,30 +1476,30 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { expression = parse("3 != 3"); assertCanCompile(expression); assertFalse((Boolean)expression.getValue()); - + expression = parse("3.0f != 1.0f"); assertCanCompile(expression); assertTrue((Boolean)expression.getValue()); expression = parse("2.0f != 2.0f"); assertCanCompile(expression); assertFalse((Boolean)expression.getValue()); - + expression = parse("30L != 30L"); assertCanCompile(expression); assertFalse((Boolean)expression.getValue()); expression = parse("15L != 20L"); assertCanCompile(expression); assertTrue((Boolean)expression.getValue()); - + // not compatible number types - expression = parse("1 != 3.0d"); + expression = parse("1 != 3.0d"); assertCantCompile(expression); expression = parse("T(Integer).valueOf(3) != 4"); assertTrue((Boolean)expression.getValue()); assertCanCompile(expression); assertTrue((Boolean)expression.getValue()); - + expression = parse("T(Integer).valueOf(3) != T(Integer).valueOf(3)"); assertFalse((Boolean)expression.getValue()); assertCanCompile(expression); @@ -1514,7 +1514,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { assertTrue((Boolean)expression.getValue()); assertCanCompile(expression); assertTrue((Boolean)expression.getValue()); - + expression = parse("T(Float).valueOf(3.0f) != T(Float).valueOf(3.0f)"); assertFalse((Boolean)expression.getValue()); assertCanCompile(expression); @@ -1524,12 +1524,12 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { assertTrue((Boolean)expression.getValue()); assertCanCompile(expression); assertTrue((Boolean)expression.getValue()); - + expression = parse("T(Long).valueOf(3L) != 4L"); assertTrue((Boolean)expression.getValue()); assertCanCompile(expression); assertTrue((Boolean)expression.getValue()); - + expression = parse("T(Long).valueOf(3L) != T(Long).valueOf(3L)"); assertFalse((Boolean)expression.getValue()); assertCanCompile(expression); @@ -1538,13 +1538,13 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { expression = parse("5L != T(Long).valueOf(3L)"); 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()); assertCanCompile(expression); assertFalse((Boolean)expression.getValue()); - + expression = parse("T(Double).valueOf(3.0d) == T(Double).valueOf(3.0d)"); assertTrue((Boolean)expression.getValue()); assertCanCompile(expression); @@ -1559,7 +1559,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { assertFalse((Boolean)expression.getValue()); assertCanCompile(expression); assertFalse((Boolean)expression.getValue()); - + expression = parse("T(Boolean).valueOf('true') == T(Boolean).valueOf('true')"); assertTrue((Boolean)expression.getValue()); assertCanCompile(expression); @@ -1575,14 +1575,14 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { assertCanCompile(expression); assertTrue((Boolean)expression.getValue()); } - + @Test public void opPlus() throws Exception { expression = parse("2+2"); expression.getValue(); assertCanCompile(expression); assertEquals(4,expression.getValue()); - + expression = parse("2L+2L"); expression.getValue(); assertCanCompile(expression); @@ -1597,37 +1597,37 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { expression.getValue(); assertCanCompile(expression); 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()); assertCanCompile(expression); assertEquals(8,expression.getValue()); - + expression = parse("T(Integer).valueOf(1)+T(Integer).valueOf(3)"); assertEquals(4,expression.getValue()); assertCanCompile(expression); @@ -1641,7 +1641,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { expression = parse("T(Float).valueOf(2.0f)+6"); assertEquals(8.0f,expression.getValue()); assertCantCompile(expression); - + expression = parse("T(Float).valueOf(2.0f)+T(Float).valueOf(3.0f)"); assertEquals(5.0f,expression.getValue()); assertCanCompile(expression); @@ -1655,7 +1655,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { expression = parse("T(Long).valueOf(2L)+6"); assertEquals(8L,expression.getValue()); assertCantCompile(expression); - + expression = parse("T(Long).valueOf(2L)+T(Long).valueOf(3L)"); assertEquals(5L,expression.getValue()); assertCanCompile(expression); @@ -1666,7 +1666,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { assertCanCompile(expression); assertEquals(3L,expression.getValue()); } - + @Test public void opPlusString() throws Exception { expression = parse("'hello' + 'world'"); @@ -1679,7 +1679,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { assertEquals("helloworld",expression.getValue(new Greeter())); assertCanCompile(expression); assertEquals("helloworld",expression.getValue(new Greeter())); - + // Method with string return expression = parse("getWorld() + 'hello'"); assertEquals("worldhello",expression.getValue(new Greeter())); @@ -1691,17 +1691,17 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { assertEquals("helloworld spring",expression.getValue(new Greeter())); assertCanCompile(expression); 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())); assertCantCompile(expression); - + expression = parse("object + 'a'"); assertEquals("objecta",expression.getValue(new Greeter())); assertCanCompile(expression); assertEquals("objecta",expression.getValue(new Greeter())); - + expression = parse("'a'+object"); assertEquals("aobject",expression.getValue(new Greeter())); assertCanCompile(expression); @@ -1722,16 +1722,6 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { assertCanCompile(expression); assertEquals("objectobject",expression.getValue(new Greeter())); } - - public static class Greeter { - public String getWorld() { - return "world"; - } - - public Object getObject() { - return "object"; - } - } @Test public void opMinus() throws Exception { @@ -1739,7 +1729,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { expression.getValue(); assertCanCompile(expression); assertEquals(0,expression.getValue()); - + expression = parse("4L-2L"); expression.getValue(); assertCanCompile(expression); @@ -1754,32 +1744,32 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { expression.getValue(); assertCanCompile(expression); 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()); assertCanCompile(expression); assertEquals(-4,expression.getValue()); - + expression = parse("T(Integer).valueOf(1)-T(Integer).valueOf(3)"); assertEquals(-2,expression.getValue()); assertCanCompile(expression); @@ -1793,7 +1783,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { expression = parse("T(Float).valueOf(2.0f)-6"); assertEquals(-4.0f,expression.getValue()); assertCantCompile(expression); - + expression = parse("T(Float).valueOf(8.0f)-T(Float).valueOf(3.0f)"); assertEquals(5.0f,expression.getValue()); assertCanCompile(expression); @@ -1807,7 +1797,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { expression = parse("T(Long).valueOf(9L)-6"); assertEquals(3L,expression.getValue()); assertCantCompile(expression); - + expression = parse("T(Long).valueOf(4L)-T(Long).valueOf(3L)"); assertEquals(1L,expression.getValue()); assertCanCompile(expression); @@ -1818,15 +1808,14 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { assertCanCompile(expression); assertEquals(6L,expression.getValue()); } - - + @Test public void opMultiply() throws Exception { expression = parse("2*2"); expression.getValue(); assertCanCompile(expression); assertEquals(4,expression.getValue()); - + expression = parse("2L*2L"); expression.getValue(); assertCanCompile(expression); @@ -1845,7 +1834,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { expression = parse("T(Float).valueOf(2.0f)*6"); assertEquals(12.0f,expression.getValue()); assertCantCompile(expression); - + expression = parse("T(Float).valueOf(8.0f)*T(Float).valueOf(3.0f)"); assertEquals(24.0f,expression.getValue()); assertCanCompile(expression); @@ -1859,7 +1848,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { expression = parse("T(Long).valueOf(9L)*6"); assertEquals(54L,expression.getValue()); assertCantCompile(expression); - + expression = parse("T(Long).valueOf(4L)*T(Long).valueOf(3L)"); assertEquals(12L,expression.getValue()); assertCanCompile(expression); @@ -1875,14 +1864,14 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { assertCanCompile(expression); assertEquals(-24.0f,expression.getValue()); } - + @Test public void opDivide() throws Exception { expression = parse("2/2"); expression.getValue(); assertCanCompile(expression); assertEquals(1,expression.getValue()); - + expression = parse("2L/2L"); expression.getValue(); assertCanCompile(expression); @@ -1901,7 +1890,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { expression = parse("T(Float).valueOf(6.0f)/2"); assertEquals(3.0f,expression.getValue()); assertCantCompile(expression); - + expression = parse("T(Float).valueOf(8.0f)/T(Float).valueOf(2.0f)"); assertEquals(4.0f,expression.getValue()); assertCanCompile(expression); @@ -1915,7 +1904,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { expression = parse("T(Long).valueOf(44L)/11"); assertEquals(4L,expression.getValue()); assertCantCompile(expression); - + expression = parse("T(Long).valueOf(4L)/T(Long).valueOf(2L)"); assertEquals(2L,expression.getValue()); assertCanCompile(expression); @@ -1931,7 +1920,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { assertCanCompile(expression); assertEquals(-2.0f,expression.getValue()); } - + @Test public void opModulus_12041() throws Exception { expression = parse("2%2"); @@ -1950,7 +1939,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { assertEquals(2,expression.getValue()); assertCanCompile(expression); assertEquals(2,expression.getValue()); - + expression = parse("17L%5L"); assertEquals(2L,expression.getValue()); assertCanCompile(expression); @@ -1969,7 +1958,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { expression = parse("T(Float).valueOf(6.0f)%2"); assertEquals(0.0f,expression.getValue()); assertCantCompile(expression); - + expression = parse("T(Float).valueOf(6.0f)%4"); assertEquals(2.0f,expression.getValue()); assertCantCompile(expression); @@ -1987,7 +1976,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { expression = parse("T(Long).valueOf(44L)%12"); assertEquals(8L,expression.getValue()); assertCantCompile(expression); - + expression = parse("T(Long).valueOf(9L)%T(Long).valueOf(2L)"); assertEquals(1L,expression.getValue()); assertCanCompile(expression); @@ -2006,19 +1995,19 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { @Test public void failsWhenSettingContextForExpression_SPR12326() { - SpelExpressionParser parser = new SpelExpressionParser(new SpelParserConfiguration(SpelCompilerMode.IMMEDIATE, this - .getClass().getClassLoader())); - Person3 person = new Person3("foo", 1); - SpelExpression expression = parser.parseRaw("#it?.age?.equals([0])"); - StandardEvaluationContext context = new StandardEvaluationContext(new Object[] { 1 }); - context.setVariable("it", person); - expression.setEvaluationContext(context); - assertTrue(expression.getValue(Boolean.class)); - assertTrue(expression.getValue(Boolean.class)); - assertCanCompile(expression); - assertTrue(expression.getValue(Boolean.class)); + SpelExpressionParser parser = new SpelExpressionParser( + new SpelParserConfiguration(SpelCompilerMode.IMMEDIATE, getClass().getClassLoader())); + Person3 person = new Person3("foo", 1); + SpelExpression expression = parser.parseRaw("#it?.age?.equals([0])"); + StandardEvaluationContext context = new StandardEvaluationContext(new Object[] { 1 }); + context.setVariable("it", person); + expression.setEvaluationContext(context); + assertTrue(expression.getValue(Boolean.class)); + assertTrue(expression.getValue(Boolean.class)); + assertCanCompile(expression); + assertTrue(expression.getValue(Boolean.class)); } - + @Test public void constructorReference_SPR12326() { String type = this.getClass().getName(); @@ -2028,7 +2017,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { assertEquals("test", ((Obj) expression.getValue(new Object[] { "test" })).param1); assertCanCompile(expression); assertEquals("test", ((Obj) expression.getValue(new Object[] { "test" })).param1); - + expression = parser.parseExpression(prefix+"2('foo','bar').output"); assertEquals("foobar", expression.getValue(String.class)); assertCanCompile(expression); @@ -2043,7 +2032,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { assertEquals("", expression.getValue(String.class)); assertCanCompile(expression); assertEquals("", expression.getValue(String.class)); - + expression = parser.parseExpression(prefix+"3(1,2,3).output"); assertEquals("123", expression.getValue(String.class)); assertCanCompile(expression); @@ -2058,7 +2047,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { assertEquals("", expression.getValue(String.class)); assertCanCompile(expression); assertEquals("", expression.getValue(String.class)); - + expression = parser.parseExpression(prefix+"3('abc',5.0f,1,2,3).output"); assertEquals("abc:5.0:123", expression.getValue(String.class)); assertCanCompile(expression); @@ -2073,13 +2062,13 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { 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)); assertCanCompile(expression); assertEquals("123", expression.getValue(new int[]{1,2,3},String.class)); } - + @Test public void methodReferenceMissingCastAndRootObjectAccessing_SPR12326() { // Need boxing code on the 1 so that toString() can be called @@ -2090,7 +2079,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { expression = parser.parseExpression("#it?.age.equals([0])"); Person person = new Person(1); - StandardEvaluationContext context = + StandardEvaluationContext context = new StandardEvaluationContext(new Object[] { person.getAge() }); context.setVariable("it", person); assertTrue(expression.getValue(context, Boolean.class)); @@ -2107,56 +2096,22 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { context.setVariable("it", person); assertTrue(ex.getValue(context, Boolean.class)); assertTrue(ex.getValue(context, Boolean.class)); - + PersonInOtherPackage person2 = new PersonInOtherPackage(1); ex = parser.parseRaw("#it?.age.equals([0])"); - context = + context = new StandardEvaluationContext(new Object[] { person2.getAge() }); context.setVariable("it", person2); assertTrue(ex.getValue(context, Boolean.class)); assertTrue(ex.getValue(context, Boolean.class)); - + ex = parser.parseRaw("#it?.age.equals([0])"); - context = + context = new StandardEvaluationContext(new Object[] { person2.getAge() }); context.setVariable("it", person2); assertTrue((Boolean)ex.getValue(context)); assertTrue((Boolean)ex.getValue(context)); } - - public class Person { - - private int age; - - public Person(int age) { - this.age = age; - } - - public int getAge() { - return age; - } - - public void setAge(int age) { - this.age = age; - } - } - - public class Person3 { - - private int age; - - public Person3(String name, int age) { - this.age = age; - } - - public int getAge() { - return age; - } - - public void setAge(int age) { - this.age = age; - } - } @Test public void constructorReference() throws Exception { @@ -2166,7 +2121,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { assertCanCompile(expression); assertEquals("123",expression.getValue()); - String testclass8 = "org.springframework.expression.spel.SpelCompilationCoverageTests$TestClass8"; + 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()); @@ -2178,14 +2133,14 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { 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()); 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()); @@ -2196,16 +2151,16 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { assertEquals(42,tc8.i); // private class, can't compile it - String testclass9 = "org.springframework.expression.spel.SpelCompilationCoverageTests$TestClass9"; + String testclass9 = "org.springframework.expression.spel.SpelCompilationCoverageTests$TestClass9"; expression = parser.parseExpression("new "+testclass9+"(42)"); assertEquals(testclass9,expression.getValue().getClass().getName()); assertCantCompile(expression); } - + @Test public void methodReferenceReflectiveMethodSelectionWithVarargs() throws Exception { TestClass10 tc = new TestClass10(); - + // Should call the non varargs version of concat // (which causes the '::' prefix in test output) expression = parser.parseExpression("concat('test')"); @@ -2216,7 +2171,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { tc.reset(); expression.getValue(tc); assertEquals("::test",tc.s); - tc.reset(); + tc.reset(); // This will call the varargs concat with an empty array expression = parser.parseExpression("concat()"); @@ -2227,8 +2182,8 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { tc.reset(); expression.getValue(tc); assertEquals("",tc.s); - tc.reset(); - + tc.reset(); + // Should call the non varargs version of concat // (which causes the '::' prefix in test output) expression = parser.parseExpression("concat2('test')"); @@ -2239,7 +2194,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { tc.reset(); expression.getValue(tc); assertEquals("::test",tc.s); - tc.reset(); + tc.reset(); // This will call the varargs concat with an empty array expression = parser.parseExpression("concat2()"); @@ -2250,13 +2205,13 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { tc.reset(); expression.getValue(tc); assertEquals("",tc.s); - tc.reset(); + tc.reset(); } @Test public void methodReferenceVarargs() throws Exception { TestClass5 tc = new TestClass5(); - + // varargs string expression = parser.parseExpression("eleven()"); assertCantCompile(expression); @@ -2267,7 +2222,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { expression.getValue(tc); assertEquals("",tc.s); tc.reset(); - + // varargs string expression = parser.parseExpression("eleven('aaa')"); assertCantCompile(expression); @@ -2278,7 +2233,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { expression.getValue(tc); assertEquals("aaa",tc.s); tc.reset(); - + // varargs string expression = parser.parseExpression("eleven(stringArray)"); assertCantCompile(expression); @@ -2300,7 +2255,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { expression.getValue(tc); assertEquals("aaabbbccc",tc.s); tc.reset(); - + expression = parser.parseExpression("sixteen('aaa','bbb','ccc')"); assertCantCompile(expression); expression.getValue(tc); @@ -2310,7 +2265,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { expression.getValue(tc); 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); @@ -2332,7 +2287,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { expression.getValue(tc); assertEquals(6,tc.i); tc.reset(); - + expression = parser.parseExpression("twelve(1)"); assertCantCompile(expression); expression.getValue(tc); @@ -2353,7 +2308,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { expression.getValue(tc); assertEquals("aaa::bbbccc",tc.s); tc.reset(); - + // nothing passed to varargs parameter expression = parser.parseExpression("thirteen('aaa')"); assertCantCompile(expression); @@ -2364,7 +2319,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { expression.getValue(tc); assertEquals("aaa::",tc.s); tc.reset(); - + // nested arrays expression = parser.parseExpression("fourteen('aaa',stringArray,stringArray)"); assertCantCompile(expression); @@ -2375,7 +2330,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { expression.getValue(tc); assertEquals("aaa::{aaabbbccc}{aaabbbccc}",tc.s); tc.reset(); - + // nested primitive array expression = parser.parseExpression("fifteen('aaa',intArray,intArray)"); assertCantCompile(expression); @@ -2386,7 +2341,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { expression.getValue(tc); assertEquals("aaa::{112233}{112233}",tc.s); tc.reset(); - + // varargs boolean expression = parser.parseExpression("arrayz(true,true,false)"); assertCantCompile(expression); @@ -2397,7 +2352,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { expression.getValue(tc); assertEquals("truetruefalse",tc.s); tc.reset(); - + expression = parser.parseExpression("arrayz(true)"); assertCantCompile(expression); expression.getValue(tc); @@ -2407,7 +2362,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { expression.getValue(tc); assertEquals("true",tc.s); tc.reset(); - + // varargs short expression = parser.parseExpression("arrays(s1,s2,s3)"); assertCantCompile(expression); @@ -2418,7 +2373,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { expression.getValue(tc); assertEquals("123",tc.s); tc.reset(); - + expression = parser.parseExpression("arrays(s1)"); assertCantCompile(expression); expression.getValue(tc); @@ -2428,7 +2383,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { expression.getValue(tc); assertEquals("1",tc.s); tc.reset(); - + // varargs double expression = parser.parseExpression("arrayd(1.0d,2.0d,3.0d)"); assertCantCompile(expression); @@ -2449,7 +2404,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { expression.getValue(tc); assertEquals("1.0",tc.s); tc.reset(); - + // varargs long expression = parser.parseExpression("arrayj(l1,l2,l3)"); assertCantCompile(expression); @@ -2502,7 +2457,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { expression.getValue(tc); assertEquals("656667",tc.s); tc.reset(); - + expression = parser.parseExpression("arrayb(b1)"); assertCantCompile(expression); expression.getValue(tc); @@ -2523,7 +2478,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { expression.getValue(tc); assertEquals("1.02.03.0",tc.s); tc.reset(); - + expression = parser.parseExpression("arrayf(f1)"); assertCantCompile(expression); expression.getValue(tc); @@ -2534,11 +2489,11 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { assertEquals("1.0",tc.s); tc.reset(); } - + @Test public void methodReference() throws Exception { TestClass5 tc = new TestClass5(); - + // non-static method, no args, void return expression = parser.parseExpression("one()"); assertCantCompile(expression); @@ -2548,7 +2503,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { expression.getValue(tc); assertEquals(1,tc.i); tc.reset(); - + // static method, no args, void return expression = parser.parseExpression("two()"); assertCantCompile(expression); @@ -2558,7 +2513,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { expression.getValue(tc); assertEquals(1,TestClass5._i); tc.reset(); - + // non-static method, reference type return expression = parser.parseExpression("three()"); assertCantCompile(expression); @@ -2576,7 +2531,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { tc.reset(); assertEquals(3277700L,expression.getValue(tc)); tc.reset(); - + // static method, reference type return expression = parser.parseExpression("five()"); assertCantCompile(expression); @@ -2594,7 +2549,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { tc.reset(); assertEquals(3277700L,expression.getValue(tc)); tc.reset(); - + // non-static method, one parameter of reference type expression = parser.parseExpression("seven(\"foo\")"); assertCantCompile(expression); @@ -2604,7 +2559,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { expression.getValue(tc); assertEquals("foo",tc.s); tc.reset(); - + // static method, one parameter of reference type expression = parser.parseExpression("eight(\"bar\")"); assertCantCompile(expression); @@ -2634,23 +2589,23 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { expression.getValue(tc); assertEquals(111,TestClass5._i); tc.reset(); - + // method that gets type converted parameters - + // Converting from an int to a string expression = parser.parseExpression("seven(123)"); assertCantCompile(expression); expression.getValue(tc); 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); assertCanCompile(expression); 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); @@ -2679,14 +2634,13 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { tc.reset(); assertCantCompile(expression); // method takes a string and we are passing an Integer } - - - @Test + + @Test public void errorHandling() throws Exception { TestClass5 tc = new TestClass5(); - + // changing target - + // from primitive array to reference type array int[] is = new int[]{1,2,3}; String[] strings = new String[]{"a","b","c"}; @@ -2694,19 +2648,20 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { assertEquals(2,expression.getValue(is)); assertCanCompile(expression); assertEquals(2,expression.getValue(is)); - + try { assertEquals(2,expression.getValue(strings)); fail(); - } catch (SpelEvaluationException see) { + } + catch (SpelEvaluationException see) { assertTrue(see.getCause() instanceof ClassCastException); } SpelCompiler.revertToInterpreted(expression); assertEquals("b",expression.getValue(strings)); assertCanCompile(expression); assertEquals("b",expression.getValue(strings)); - - + + tc.field = "foo"; expression = parser.parseExpression("seven(field)"); assertCantCompile(expression); @@ -2716,7 +2671,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { tc.reset(); tc.field="bar"; expression.getValue(tc); - + // method with changing parameter types (change reference type) tc.obj = "foo"; expression = parser.parseExpression("seven(obj)"); @@ -2729,11 +2684,12 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { try { expression.getValue(tc); fail(); - } catch (SpelEvaluationException see) { + } + catch (SpelEvaluationException see) { assertTrue(see.getCause() instanceof ClassCastException); } - - + + // method with changing target expression = parser.parseExpression("#root.charAt(0)"); assertEquals('a',expression.getValue("abc")); @@ -2741,12 +2697,13 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { try { expression.getValue(new Integer(42)); fail(); - } catch (SpelEvaluationException see) { + } + catch (SpelEvaluationException see) { // java.lang.Integer cannot be cast to java.lang.String assertTrue(see.getCause() instanceof ClassCastException); - } + } } - + @Test public void methodReference_staticMethod() throws Exception { Expression expression = parser.parseExpression("T(Integer).valueOf(42)"); @@ -2754,9 +2711,9 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { assertCanCompile(expression); int resultC = expression.getValue(new TestClass1(),Integer.TYPE); assertEquals(42,resultI); - assertEquals(42,resultC); + assertEquals(42,resultC); } - + @Test public void methodReference_literalArguments_int() throws Exception { Expression expression = parser.parseExpression("'abcd'.substring(1,3)"); @@ -2786,7 +2743,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { 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')"); @@ -2843,8 +2800,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { assertEquals(0.04d,expression.getValue(payload)); assertEquals("D",getAst().getExitDescriptor()); } - - + @Test public void mixingItUp_indexerOpEqTernary() throws Exception { Map m = new HashMap(); @@ -2857,25 +2813,25 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { m.remove("andy"); assertEquals(1,expression.getValue(m)); } - + @Test public void propertyReference() throws Exception { TestClass6 tc = new TestClass6(); - + // non static field expression = parser.parseExpression("orange"); assertCantCompile(expression); assertEquals("value1",expression.getValue(tc)); assertCanCompile(expression); assertEquals("value1",expression.getValue(tc)); - + // static field expression = parser.parseExpression("apple"); assertCantCompile(expression); 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); @@ -2901,7 +2857,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { assertCanCompile(expression); assertEquals("wibble",expression.getValue(ctx)); } - + @SuppressWarnings("unchecked") @Test public void indexer() throws Exception { @@ -2914,7 +2870,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { 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)); @@ -2927,7 +2883,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { assertCanCompile(expression); assertEquals(8,expression.getValue(ns)); assertEquals("Ljava/lang/Number",getAst().getExitDescriptor()); - + // Access int array expression = parser.parseExpression("[2]"); assertEquals(10,expression.getValue(is)); @@ -2976,7 +2932,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { assertCanCompile(expression); assertEquals('b',expression.getValue(cs)); assertEquals("C",getAst().getExitDescriptor()); - + // Collections List strings = new ArrayList(); strings.add("aaa"); @@ -2987,7 +2943,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { assertCanCompile(expression); assertEquals("bbb",expression.getValue(strings)); assertEquals("Ljava/lang/Object",getAst().getExitDescriptor()); - + List ints = new ArrayList(); ints.add(123); ints.add(456); @@ -2997,7 +2953,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { assertCanCompile(expression); assertEquals(789,expression.getValue(ints)); assertEquals("Ljava/lang/Object",getAst().getExitDescriptor()); - + // Maps Map map1 = new HashMap(); map1.put("aaa", 111); @@ -3008,7 +2964,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { assertCanCompile(expression); assertEquals(111,expression.getValue(map1)); assertEquals("Ljava/lang/Object",getAst().getExitDescriptor()); - + // Object TestClass6 tc = new TestClass6(); expression = parser.parseExpression("['orange']"); @@ -3016,7 +2972,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { assertCanCompile(expression); assertEquals("value1",expression.getValue(tc)); assertEquals("Ljava/lang/String",getAst().getExitDescriptor()); - + expression = parser.parseExpression("['peach']"); assertEquals(34L,expression.getValue(tc)); assertCanCompile(expression); @@ -3029,9 +2985,9 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { assertCanCompile(expression); 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"}); @@ -3040,7 +2996,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { assertCanCompile(expression); 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))); assertCanCompile(expression); @@ -3061,7 +3017,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { assertCanCompile(expression); assertEquals(2,expression.getValue(listOfIntegerArrays)); assertEquals("Ljava/lang/Integer",getAst().getExitDescriptor()); - + // array of lists List[] stringArrayOfLists = new ArrayList[2]; stringArrayOfLists[0] = new ArrayList(); @@ -3077,13 +3033,13 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { assertCanCompile(expression); 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))); assertCanCompile(expression); 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"}}; expression = parser.parseExpression("[1]"); @@ -3092,26 +3048,26 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { 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))); assertCanCompile(expression); 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}}; expression = parser.parseExpression("[1]"); assertEquals("4 5 6",stringify(expression.getValue(primitiveTypeArrayOfArrays))); assertCanCompile(expression); assertEquals("4 5 6",stringify(expression.getValue(primitiveTypeArrayOfArrays))); assertEquals("[I",getAst().getExitDescriptor()); - + expression = parser.parseExpression("[1][2]"); assertEquals("6",stringify(expression.getValue(primitiveTypeArrayOfArrays))); assertCanCompile(expression); assertEquals("6",stringify(expression.getValue(primitiveTypeArrayOfArrays))); assertEquals("I",getAst().getExitDescriptor()); - + // list of lists of reference types List> listOfListOfStrings = new ArrayList>(); List list = new ArrayList(); @@ -3124,20 +3080,20 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { list.add("e"); list.add("f"); listOfListOfStrings.add(list); - + expression = parser.parseExpression("[1]"); 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()); - + expression = parser.parseExpression("[1][2]"); assertEquals("f",stringify(expression.getValue(listOfListOfStrings))); assertCanCompile(expression); assertEquals("f",stringify(expression.getValue(listOfListOfStrings))); assertEquals("Ljava/lang/Object",getAst().getExitDescriptor()); - + // Map of lists Map> mapToLists = new HashMap>(); list = new ArrayList(); @@ -3151,13 +3107,13 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { 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))); assertCanCompile(expression); assertEquals("c",stringify(expression.getValue(mapToLists))); assertEquals("Ljava/lang/Object",getAst().getExitDescriptor()); - + // Map to array Map mapToIntArray = new HashMap(); StandardEvaluationContext ctx = new StandardEvaluationContext(); @@ -3169,12 +3125,12 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { 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)); assertCanCompile(expression); assertEquals(2,expression.getValue(mapToIntArray)); - + expression = parser.parseExpression("foo"); assertEquals("1 2 3",stringify(expression.getValue(ctx,mapToIntArray))); assertCanCompile(expression); @@ -3191,7 +3147,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { assertCanCompile(expression); assertEquals("3",stringify(expression.getValue(ctx,mapToIntArray))); assertEquals("I",getAst().getExitDescriptor()); - + // Map array Map[] mapArray = new Map[1]; mapArray[0] = new HashMap(); @@ -3202,25 +3158,40 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { 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))); assertCanCompile(expression); 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); + assertCanCompile(expression); + assertEquals("hello world",v); + + expression = parser.parseExpression("object + ' world'"); + v = expression.getValue(new FooString()); + assertEquals("hello world",v); + assertCanCompile(expression); + assertEquals("hello world",v); + } + @Test public void mixingItUp_propertyAccessIndexerOpLtTernaryRootNull() throws Exception { Payload payload = new Payload(); - + expression = parser.parseExpression("DR[0].three"); Object v = expression.getValue(payload); 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); @@ -3228,7 +3199,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { String cExprExitDescriptor = cExpr.getExitDescriptor(); assertEquals("D",cExprExitDescriptor); assertEquals("Z",oplt.getExitDescriptor()); - + assertCanCompile(expression); Object vc = expression.getValue(payload); assertEquals(payload,v); @@ -3246,7 +3217,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { expression = parser.parseExpression("payload2.var1"); Object v = expression.getValue(ctx,holder); assertEquals("abc",v); - + // // time it interpreted // long stime = System.currentTimeMillis(); // for (int i=0;i<100000;i++) { @@ -3257,7 +3228,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { assertCanCompile(expression); v = expression.getValue(ctx,holder); assertEquals("abc",v); -// +// // // time it compiled // stime = System.currentTimeMillis(); // for (int i=0;i<100000;i++) { @@ -3265,14 +3236,14 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { // } // System.out.println((System.currentTimeMillis()-stime)); } - + @Test public void compilerWithGenerics_12040() { expression = parser.parseExpression("payload!=2"); assertTrue(expression.getValue(new GenericMessageTestHelper(4),Boolean.class)); assertCanCompile(expression); assertFalse(expression.getValue(new GenericMessageTestHelper(2),Boolean.class)); - + expression = parser.parseExpression("2!=payload"); assertTrue(expression.getValue(new GenericMessageTestHelper(4),Boolean.class)); assertCanCompile(expression); @@ -3282,12 +3253,12 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { assertTrue(expression.getValue(new GenericMessageTestHelper(4L),Boolean.class)); assertCanCompile(expression); assertFalse(expression.getValue(new GenericMessageTestHelper(6L),Boolean.class)); - + expression = parser.parseExpression("payload==2"); assertFalse(expression.getValue(new GenericMessageTestHelper(4),Boolean.class)); assertCanCompile(expression); assertTrue(expression.getValue(new GenericMessageTestHelper(2),Boolean.class)); - + expression = parser.parseExpression("2==payload"); assertFalse(expression.getValue(new GenericMessageTestHelper(4),Boolean.class)); assertCanCompile(expression); @@ -3307,27 +3278,27 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { assertEquals(2,expression.getValue(new GenericMessageTestHelper(4))); assertCanCompile(expression); assertEquals(3,expression.getValue(new GenericMessageTestHelper(6))); - + expression = parser.parseExpression("100/payload"); assertEquals(25,expression.getValue(new GenericMessageTestHelper(4))); assertCanCompile(expression); assertEquals(10,expression.getValue(new GenericMessageTestHelper(10))); - + expression = parser.parseExpression("payload+2"); assertEquals(6,expression.getValue(new GenericMessageTestHelper(4))); assertCanCompile(expression); assertEquals(8,expression.getValue(new GenericMessageTestHelper(6))); - + expression = parser.parseExpression("100+payload"); assertEquals(104,expression.getValue(new GenericMessageTestHelper(4))); assertCanCompile(expression); assertEquals(110,expression.getValue(new GenericMessageTestHelper(10))); - + expression = parser.parseExpression("payload-2"); assertEquals(2,expression.getValue(new GenericMessageTestHelper(4))); assertCanCompile(expression); assertEquals(4,expression.getValue(new GenericMessageTestHelper(6))); - + expression = parser.parseExpression("100-payload"); assertEquals(96,expression.getValue(new GenericMessageTestHelper(4))); assertCanCompile(expression); @@ -3337,7 +3308,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { assertEquals(8,expression.getValue(new GenericMessageTestHelper(4))); assertCanCompile(expression); assertEquals(12,expression.getValue(new GenericMessageTestHelper(6))); - + expression = parser.parseExpression("100*payload"); assertEquals(400,expression.getValue(new GenericMessageTestHelper(4))); assertCanCompile(expression); @@ -3347,7 +3318,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { assertEquals(2L,expression.getValue(new GenericMessageTestHelper(4L))); assertCanCompile(expression); assertEquals(3L,expression.getValue(new GenericMessageTestHelper(6L))); - + expression = parser.parseExpression("100L/payload"); assertEquals(25L,expression.getValue(new GenericMessageTestHelper(4L))); assertCanCompile(expression); @@ -3357,7 +3328,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { assertEquals(2f,expression.getValue(new GenericMessageTestHelper(4f))); assertCanCompile(expression); assertEquals(3f,expression.getValue(new GenericMessageTestHelper(6f))); - + expression = parser.parseExpression("100f/payload"); assertEquals(25f,expression.getValue(new GenericMessageTestHelper(4f))); assertCanCompile(expression); @@ -3367,13 +3338,13 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { assertEquals(2d,expression.getValue(new GenericMessageTestHelper(4d))); assertCanCompile(expression); assertEquals(3d,expression.getValue(new GenericMessageTestHelper(6d))); - + expression = parser.parseExpression("100d/payload"); assertEquals(25d,expression.getValue(new GenericMessageTestHelper(4d))); assertCanCompile(expression); 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() { @@ -3391,17 +3362,17 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { assertEquals(6,expression.getValue(new GenericMessageTestHelper2(4))); assertCanCompile(expression); assertEquals(8,expression.getValue(new GenericMessageTestHelper2(6))); - + expression = parser.parseExpression("100+payload"); assertEquals(104,expression.getValue(new GenericMessageTestHelper2(4))); assertCanCompile(expression); assertEquals(110,expression.getValue(new GenericMessageTestHelper2(10))); - + expression = parser.parseExpression("payload-2"); assertEquals(2,expression.getValue(new GenericMessageTestHelper2(4))); assertCanCompile(expression); assertEquals(4,expression.getValue(new GenericMessageTestHelper2(6))); - + expression = parser.parseExpression("100-payload"); assertEquals(96,expression.getValue(new GenericMessageTestHelper2(4))); assertCanCompile(expression); @@ -3411,13 +3382,13 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { assertEquals(8,expression.getValue(new GenericMessageTestHelper2(4))); assertCanCompile(expression); assertEquals(12,expression.getValue(new GenericMessageTestHelper2(6))); - + expression = parser.parseExpression("100*payload"); assertEquals(400,expression.getValue(new GenericMessageTestHelper2(4))); assertCanCompile(expression); assertEquals(1000,expression.getValue(new GenericMessageTestHelper2(10))); } - + // The other numeric operators @Test public void compilerWithGenerics_12040_3() { @@ -3479,33 +3450,100 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { expression=sep.parseExpression("headers[getKey()]"); 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)); - + expression = sep.parseExpression("ia[getKey2()]"); assertEquals(3,expression.getValue(root)); assertEquals(3,expression.getValue(root)); } - // --- - public static interface Message { + // helper methods + + private SpelNodeImpl getAst() { + SpelExpression spelExpression = (SpelExpression)expression; + SpelNode ast = spelExpression.getAST(); + return (SpelNodeImpl)ast; + } + + private String stringify(Object object) { + StringBuilder s = new StringBuilder(); + if (object instanceof List) { + List ls = (List)object; + for (Object l: ls) { + s.append(l); + s.append(" "); + } + } + else if (object instanceof Object[]) { + Object[] os = (Object[])object; + for (Object o: os) { + s.append(o); + s.append(" "); + } + } + else if (object instanceof int[]) { + int[] is = (int[])object; + for (int i: is) { + s.append(i); + s.append(" "); + } + } + else { + s.append(object.toString()); + } + return s.toString().trim(); + } + + private void assertCanCompile(Expression expression) { + assertTrue(SpelCompiler.compile(expression)); + } + + private void assertCantCompile(Expression expression) { + assertFalse(SpelCompiler.compile(expression)); + } + + private Expression parse(String expression) { + return parser.parseExpression(expression); + } + + private void assertGetValueFail(Expression expression) { + try { + Object o = expression.getValue(); + fail("Calling getValue on the expression should have failed but returned "+o); + } + catch (Exception ex) { + // success! + } + } + + + // helper classes + + public interface Message { + MessageHeaders getHeaders(); + @SuppressWarnings("rawtypes") List getList(); + int[] getIa(); } - + public static class MyMessage implements Message { + public MessageHeaders getHeaders() { MessageHeaders mh = new MessageHeaders(); mh.put("command", "wibble"); mh.put("command2", "wobble"); return mh; } + public int[] getIa() { return new int[]{5,3}; } + @SuppressWarnings({ "rawtypes", "unchecked" }) public List getList() { List l = new ArrayList(); @@ -3513,44 +3551,47 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { l.add("wobble"); return l; } - + public String getKey() { return "command2"; } - + public int getKey2() { return 1; } } @SuppressWarnings("serial") - public static class MessageHeaders extends HashMap { } + public static class MessageHeaders extends HashMap { + } public static class GenericMessageTestHelper { + private T payload; - + GenericMessageTestHelper(T value) { this.payload = value; } - + public T getPayload() { return payload; } } - + // This test helper has a bound on the type variable public static class GenericMessageTestHelper2 { + private T payload; - + GenericMessageTestHelper2(T value) { this.payload = value; } - + public T getPayload() { return payload; } } - + static class MyAccessor implements CompilablePropertyAccessor { private Method method; @@ -3608,7 +3649,6 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { } } - static class CompilableMapAccessor implements CompilablePropertyAccessor { @Override @@ -3662,27 +3702,9 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { } mv.visitLdcInsn(propertyName); mv.visitMethodInsn(INVOKEINTERFACE, "java/util/Map", "get","(Ljava/lang/Object;)Ljava/lang/Object;",true); - -// if (method == null) { -// try { -// method = Payload2.class.getDeclaredMethod("getField", String.class); -// } catch (Exception e) {} -// } -// String descriptor = codeflow.lastDescriptor(); -// String memberDeclaringClassSlashedDescriptor = method.getDeclaringClass().getName().replace('.','/'); -// if (descriptor == null) { -// codeflow.loadTarget(mv); -// } -// if (descriptor == null || !memberDeclaringClassSlashedDescriptor.equals(descriptor.substring(1))) { -// mv.visitTypeInsn(CHECKCAST, memberDeclaringClassSlashedDescriptor); -// } -// mv.visitLdcInsn(propertyReference.getName()); -// mv.visitMethodInsn(INVOKEVIRTUAL, memberDeclaringClassSlashedDescriptor, method.getName(),CodeFlow.createDescriptor(method)); -// 6: invokeinterface #6, 2; //InterfaceMethod java/util/Map.get:(Ljava/lang/Object;)Ljava/lang/Object; } } - /** * Exception thrown from {@code read} in order to reset a cached * PropertyAccessor, allowing other accessors to have a try. @@ -3703,83 +3725,51 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { } } - - // helpers - private SpelNodeImpl getAst() { - SpelExpression spelExpression = (SpelExpression)expression; - SpelNode ast = spelExpression.getAST(); - return (SpelNodeImpl)ast; - } - - private String stringify(Object object) { - StringBuilder s = new StringBuilder(); - if (object instanceof List) { - List ls = (List)object; - for (Object l: ls) { - s.append(l); - s.append(" "); - } - } - else if (object instanceof Object[]) { - Object[] os = (Object[])object; - for (Object o: os) { - s.append(o); - s.append(" "); - } - } - else if (object instanceof int[]) { - int[] is = (int[])object; - for (int i: is) { - s.append(i); - s.append(" "); - } - } - else { - s.append(object.toString()); - } - return s.toString().trim(); - } - - private void assertCanCompile(Expression expression) { - assertTrue(SpelCompiler.compile(expression)); - } - - private void assertCantCompile(Expression expression) { - assertFalse(SpelCompiler.compile(expression)); - } - - private Expression parse(String expression) { - return parser.parseExpression(expression); - } - - private void assertGetValueFail(Expression expression) { - try { - Object o = expression.getValue(); - fail("Calling getValue on the expression should have failed but returned "+o); - } catch (Exception ex) { - // success! - } - } - // test classes - + + public static class Greeter { + + public String getWorld() { + return "world"; + } + + public Object getObject() { + return "object"; + } + } + + 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()}; + public Two holder = new Two(); - + public Two[] getDR() { return DR; } } - + public static class Payload2 { + String var1 = "abc"; String var2 = "def"; + public Object getField(String name) { if (name.equals("var1")) { return var1; - } else if (name.equals("var2")) { + } + else if (name.equals("var2")) { return var2; } return null; @@ -3787,11 +3777,48 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { } public static class Payload2Holder { + public Payload2 payload2 = new Payload2(); } - + + public class Person { + + private int age; + + public Person(int age) { + this.age = age; + } + + public int getAge() { + return age; + } + + public void setAge(int age) { + this.age = age; + } + } + + public class Person3 { + + private int age; + + public Person3(String name, int age) { + this.age = age; + } + + public int getAge() { + return age; + } + + public void setAge(int age) { + this.age = age; + } + } + public static class Two { + Three three = new Three(); + public Three getThree() { return three; } @@ -3799,40 +3826,45 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { return "instanceof Two"; } } - + public static class Three { + double four = 0.04d; + public double getFour() { return four; } } public static class TestClass1 { + public int index1 = 1; public int index2 = 3; - public String word = "abcd"; + public String word = "abcd"; } - + public static class TestClass4 { + public boolean a,b; public boolean gettrue() { return true; } public boolean getfalse() { return false; } public boolean getA() { return a; } public boolean getB() { return b; } } - + public static class TestClass10 { + public String s = null; - + public void reset() { s = null; } - + public void concat(String arg) { s = "::"+arg; } - public void concat(String... vargs) { + public void concat(String... vargs) { if (vargs==null) { s = ""; } @@ -3843,12 +3875,12 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { } } } - + public void concat2(Object arg) { s = "::"+arg; } - public void concat2(Object... vargs) { + public void concat2(Object... vargs) { if (vargs==null) { s = ""; } @@ -3860,13 +3892,14 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { } } } - + public static class TestClass5 { + public int i = 0; public String s = null; public static int _i = 0; public static String _s = null; - + public static short s1 = (short)1; public static short s2 = (short)2; public static short s3 = (short)3; @@ -3882,18 +3915,18 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { public static char c1 = 'a'; public static char c2 = 'b'; public static char c3 = 'c'; - + public static byte b1 = (byte)65; 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 Object obj = null; - + public String field = null; - + public void reset() { i = 0; _i=0; @@ -3901,28 +3934,28 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { _s = null; field = null; } - + public void one() { i = 1; } - + public static void two() { _i = 1; } - + public String three() { return "hello"; } public long four() { return 3277700L; } public static String five() { return "hello"; } public static long six() { return 3277700L; } - + public void seven(String toset) { s = toset; } // public void seven(Number n) { s = n.toString(); } - + public void takeNumber(Number n) { s = n.toString(); } public void takeString(String s) { this.s = s; } public static void eight(String toset) { _s = toset; } - + public void nine(int toset) { i = toset; } public static void ten(int toset) { _i = toset; } - - public void eleven(String... vargs) { + + public void eleven(String... vargs) { if (vargs==null) { s = ""; } @@ -3933,8 +3966,8 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { } } } - - public void twelve(int... vargs) { + + public void twelve(int... vargs) { if (vargs==null) { i = 0; } @@ -3945,8 +3978,8 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { } } } - - public void thirteen(String a, String... vargs) { + + public void thirteen(String a, String... vargs) { if (vargs==null) { s = a+"::"; } @@ -3957,7 +3990,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { } } } - + public void arrayz(boolean... bs) { s = ""; if (bs != null) { @@ -3967,7 +4000,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { } } } - + public void arrays(short... ss) { s = ""; if (ss != null) { @@ -3977,7 +4010,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { } } } - + public void arrayd(double... vargs) { s = ""; if (vargs != null) { @@ -4017,7 +4050,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { } } } - + public void arrayc(char... vargs) { s = ""; if (vargs != null) { @@ -4028,7 +4061,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { } } - public void fourteen(String a, String[]... vargs) { + public void fourteen(String a, String[]... vargs) { if (vargs==null) { s = a+"::"; } @@ -4037,14 +4070,14 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { for (String[] varg: vargs) { s+="{"; for (String v: varg) { - s+=v; + s+=v; } s+="}"; } } } - - public void fifteen(String a, int[]... vargs) { + + public void fifteen(String a, int[]... vargs) { if (vargs==null) { s = a+"::"; } @@ -4053,14 +4086,14 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { for (int[] varg: vargs) { s+="{"; for (int v: varg) { - s+=Integer.toString(v); + s+=Integer.toString(v); } s+="}"; } } } - - public void sixteen(Object... vargs) { + + public void sixteen(Object... vargs) { if (vargs==null) { s = ""; } @@ -4071,15 +4104,15 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { } } } - } - + public static class TestClass6 { + public String orange = "value1"; public static String apple = "value2"; - + public long peach = 34L; - + public String getBanana() { return "value3"; } @@ -4088,139 +4121,145 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { return "value4"; } } - + public static class TestClass7 { + public static String property; + static { String s = "UK 123"; StringTokenizer st = new StringTokenizer(s); property = st.nextToken(); } - + public static void reset() { String s = "UK 123"; StringTokenizer st = new StringTokenizer(s); property = st.nextToken(); } - + } public static class TestClass8 { + public int i; public String s; public double d; public boolean z; - + public TestClass8(int i, String s, double d, boolean z) { this.i = i; this.s = s; this.d = d; this.z = z; } - + public TestClass8() { - + } - + public TestClass8(Integer i) { this.i = i; } - + @SuppressWarnings("unused") private TestClass8(String a, String b) { this.s = a+b; } } - public static class Obj { - - private final String param1; - - public Obj(String param1){ - this.param1 = param1; - } - } + public static class Obj { - public static class Obj2 { - - public final String output; - - public Obj2(String... params){ - StringBuilder b = new StringBuilder(); - for (String param: params) { - b.append(param); - } - output = b.toString(); - } - } + private final String param1; + + public Obj(String param1){ + this.param1 = param1; + } + } + + public static class Obj2 { + + public final String output; + + public Obj2(String... params){ + StringBuilder b = new StringBuilder(); + for (String param: params) { + b.append(param); + } + output = b.toString(); + } + } + + public static class Obj3 { + + public final String output; + + public Obj3(int... params) { + StringBuilder b = new StringBuilder(); + for (int param: params) { + b.append(Integer.toString(param)); + } + output = b.toString(); + } + + public Obj3(String s, Float f, int... ints) { + StringBuilder b = new StringBuilder(); + b.append(s); + b.append(":"); + b.append(Float.toString(f)); + b.append(":"); + for (int param: ints) { + b.append(Integer.toString(param)); + } + output = b.toString(); + } + } + + public static class Obj4 { + + public final String output; + + public Obj4(int[] params) { + StringBuilder b = new StringBuilder(); + for (int param: params) { + b.append(Integer.toString(param)); + } + output = b.toString(); + } + } - public static class Obj3 { - - public final String output; - - public Obj3(int... params) { - StringBuilder b = new StringBuilder(); - for (int param: params) { - b.append(Integer.toString(param)); - } - output = b.toString(); - } - - public Obj3(String s, Float f, int... ints) { - StringBuilder b = new StringBuilder(); - b.append(s); - b.append(":"); - b.append(Float.toString(f)); - b.append(":"); - for (int param: ints) { - b.append(Integer.toString(param)); - } - output = b.toString(); - } - } - - public static class Obj4 { - - public final String output; - - public Obj4(int[] params) { - StringBuilder b = new StringBuilder(); - for (int param: params) { - b.append(Integer.toString(param)); - } - output = b.toString(); - } - } - @SuppressWarnings("unused") private static class TestClass9 { + public TestClass9(int i) {} } - + // These test classes simulate a pattern of public/private classes seen in Spring Security - - // final class HttpServlet3RequestFactory implements HttpServletRequestFactory + + // final class HttpServlet3RequestFactory implements HttpServletRequestFactory static class HttpServlet3RequestFactory { - - static Servlet3SecurityContextHolderAwareRequestWrapper getOne() { - HttpServlet3RequestFactory outer = new HttpServlet3RequestFactory(); - return outer.new Servlet3SecurityContextHolderAwareRequestWrapper(); - } - // private class Servlet3SecurityContextHolderAwareRequestWrapper extends SecurityContextHolderAwareRequestWrapper - private class Servlet3SecurityContextHolderAwareRequestWrapper extends SecurityContextHolderAwareRequestWrapper { - } + + static Servlet3SecurityContextHolderAwareRequestWrapper getOne() { + HttpServlet3RequestFactory outer = new HttpServlet3RequestFactory(); + return outer.new Servlet3SecurityContextHolderAwareRequestWrapper(); + } + + // private class Servlet3SecurityContextHolderAwareRequestWrapper extends SecurityContextHolderAwareRequestWrapper + private class Servlet3SecurityContextHolderAwareRequestWrapper extends SecurityContextHolderAwareRequestWrapper { + } } - - // public class SecurityContextHolderAwareRequestWrapper extends HttpServletRequestWrapper + + // public class SecurityContextHolderAwareRequestWrapper extends HttpServletRequestWrapper static class SecurityContextHolderAwareRequestWrapper extends HttpServletRequestWrapper { } - + public static class HttpServletRequestWrapper { + public String getServletPath() { return "wibble"; } } - + // Here the declaring class is not public static class SomeCompareMethod { @@ -4234,8 +4273,9 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { return -1; } } - + public static class SomeCompareMethod2 { + public static int negate(int i1) { return -i1; } @@ -4247,7 +4287,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { } return b.toString(); } - + public static String append2(Object... objects) { StringBuilder b = new StringBuilder(); for (Object object: objects) { @@ -4255,7 +4295,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { } return b.toString(); } - + public static String append3(String[] strings) { StringBuilder b = new StringBuilder(); for (String string: strings) { @@ -4263,7 +4303,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { } return b.toString(); } - + public static String append4(String s, String... strings) { StringBuilder b = new StringBuilder(); b.append(s).append("::"); @@ -4280,7 +4320,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { } return b.toString(); } - + public static int sum(int... ints) { int total = 0; for (int i: ints) { @@ -4304,13 +4344,13 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { } return total; } - } - + public static class DelegatingStringFormat { + public static String format(String s, Object... args) { return String.format(s, args); } } - + }