diff --git a/spring-expression/src/main/java/org/springframework/expression/spel/ast/Indexer.java b/spring-expression/src/main/java/org/springframework/expression/spel/ast/Indexer.java index 514d7d37a2d..5205b24eb12 100644 --- a/spring-expression/src/main/java/org/springframework/expression/spel/ast/Indexer.java +++ b/spring-expression/src/main/java/org/springframework/expression/spel/ast/Indexer.java @@ -239,6 +239,7 @@ public class Indexer extends SpelNodeImpl { cf.loadTarget(mv); } + SpelNodeImpl index = this.children[0]; if (this.indexedType == IndexedType.ARRAY) { int insn = switch (this.exitTypeDescriptor) { case "D" -> { @@ -282,7 +283,6 @@ public class Indexer extends SpelNodeImpl { } }; - SpelNodeImpl index = this.children[0]; cf.enterCompilationScope(); index.generateCode(mv, cf); cf.exitCompilationScope(); @@ -292,7 +292,7 @@ public class Indexer extends SpelNodeImpl { else if (this.indexedType == IndexedType.LIST) { mv.visitTypeInsn(CHECKCAST, "java/util/List"); cf.enterCompilationScope(); - this.children[0].generateCode(mv, cf); + index.generateCode(mv, cf); cf.exitCompilationScope(); mv.visitMethodInsn(INVOKEINTERFACE, "java/util/List", "get", "(I)Ljava/lang/Object;", true); } @@ -301,13 +301,13 @@ public class Indexer extends SpelNodeImpl { mv.visitTypeInsn(CHECKCAST, "java/util/Map"); // Special case when the key is an unquoted string literal that will be parsed as // a property/field reference - if ((this.children[0] instanceof PropertyOrFieldReference reference)) { + if ((index instanceof PropertyOrFieldReference reference)) { String mapKeyName = reference.getName(); mv.visitLdcInsn(mapKeyName); } else { cf.enterCompilationScope(); - this.children[0].generateCode(mv, cf); + index.generateCode(mv, cf); cf.exitCompilationScope(); } mv.visitMethodInsn( diff --git a/spring-expression/src/main/java/org/springframework/expression/spel/support/ReflectivePropertyAccessor.java b/spring-expression/src/main/java/org/springframework/expression/spel/support/ReflectivePropertyAccessor.java index d2aff905306..322a275c62b 100644 --- a/spring-expression/src/main/java/org/springframework/expression/spel/support/ReflectivePropertyAccessor.java +++ b/spring-expression/src/main/java/org/springframework/expression/spel/support/ReflectivePropertyAccessor.java @@ -613,6 +613,9 @@ public class ReflectivePropertyAccessor implements PropertyAccessor { private final TypeDescriptor typeDescriptor; + /** + * The original method, or {@code null} if the member is not a method. + */ @Nullable private final Method originalMethod; 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 815a09abef0..16b489c2a78 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 @@ -51,6 +51,7 @@ import org.springframework.expression.spel.standard.SpelExpression; import org.springframework.expression.spel.standard.SpelExpressionParser; import org.springframework.expression.spel.support.StandardEvaluationContext; import org.springframework.expression.spel.testdata.PersonInOtherPackage; +import org.springframework.expression.spel.testresources.Person; import static java.util.stream.Collectors.joining; import static org.assertj.core.api.Assertions.assertThat; @@ -909,7 +910,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { assertThatExceptionOfType(SpelEvaluationException.class) .isThrownBy(expression::getValue) .withMessageEndingWith("Type cannot be found 'Missing'"); - assertCantCompile(expression); + assertCannotCompile(expression); } @SuppressWarnings("unchecked") @@ -994,7 +995,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { ctx.setVariable("foo", String.class); expression = parse("3 instanceof #foo"); assertThat(expression.getValue(ctx)).isEqualTo(false); - assertCantCompile(expression); + assertCannotCompile(expression); // use of primitive as type for instanceof check - compilable // but always false @@ -1279,13 +1280,13 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { // Can't compile this as we aren't going down the getfalse() branch in our evaluation expression = parser.parseExpression("gettrue() or getfalse()"); resultI = expression.getValue(tc, boolean.class); - assertCantCompile(expression); + assertCannotCompile(expression); expression = parser.parseExpression("getA() or getB()"); tc.a = true; tc.b = true; resultI = expression.getValue(tc, boolean.class); - assertCantCompile(expression); // Haven't yet been into second branch + assertCannotCompile(expression); // Haven't yet been into second branch tc.a = false; tc.b = true; resultI = expression.getValue(tc, boolean.class); @@ -1335,13 +1336,13 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { // 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.class); - assertCantCompile(expression); + assertCannotCompile(expression); expression = parser.parseExpression("getA() and getB()"); tc.a = false; tc.b = false; resultI = expression.getValue(tc, boolean.class); - assertCantCompile(expression); // Haven't yet been into second branch + assertCannotCompile(expression); // Haven't yet been into second branch tc.a = true; tc.b = false; resultI = expression.getValue(tc, boolean.class); @@ -1409,7 +1410,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { boolean root = true; expression = parser.parseExpression("(#root and true)?T(Integer).valueOf(1):T(Long).valueOf(3L)"); assertThat(expression.getValue(root)).isEqualTo(1); - assertCantCompile(expression); // Have not gone down false branch + assertCannotCompile(expression); // Have not gone down false branch root = false; assertThat(expression.getValue(root)).isEqualTo(3L); assertCanCompile(expression); @@ -1636,7 +1637,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { String s = "abc"; expression = parser.parseExpression("#root?:'b'"); - assertCantCompile(expression); + assertCannotCompile(expression); resultI = expression.getValue(s, String.class); assertThat(resultI).isEqualTo("abc"); assertCanCompile(expression); @@ -1792,7 +1793,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { // type nor method are public expression = parser.parseExpression("#doCompare([0],#arg)"); assertThat(expression.getValue(context, Integer.class).toString()).isEqualTo("-1"); - assertCantCompile(expression); + assertCannotCompile(expression); // type not public but method is context = new StandardEvaluationContext(new Object[] {"1"}); @@ -1801,7 +1802,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { context.setVariable("arg", "2"); expression = parser.parseExpression("#doCompare([0],#arg)"); assertThat(expression.getValue(context, Integer.class).toString()).isEqualTo("-1"); - assertCantCompile(expression); + assertCannotCompile(expression); } @Test @@ -2059,7 +2060,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { // Differing types of number, not yet supported expression = parse("1 < 3.0d"); - assertCantCompile(expression); + assertCannotCompile(expression); expression = parse("T(Integer).valueOf(3) < 4"); assertThat((Boolean) expression.getValue()).isTrue(); @@ -2118,7 +2119,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { // Differing types of number, not yet supported expression = parse("1 <= 3.0d"); - assertCantCompile(expression); + assertCannotCompile(expression); expression = parse("T(Integer).valueOf(3) <= 4"); assertThat((Boolean) expression.getValue()).isTrue(); @@ -2168,7 +2169,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { // Differing types of number, not yet supported expression = parse("1 > 3.0d"); - assertCantCompile(expression); + assertCannotCompile(expression); expression = parse("T(Integer).valueOf(3) > 4"); assertThat((Boolean) expression.getValue()).isFalse(); @@ -2230,7 +2231,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { // Differing types of number, not yet supported expression = parse("1 >= 3.0d"); - assertCantCompile(expression); + assertCannotCompile(expression); expression = parse("T(Integer).valueOf(3) >= 4"); assertThat((Boolean) expression.getValue()).isFalse(); @@ -2310,7 +2311,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { // number types are not the same expression = parse("1 == 3.0d"); - assertCantCompile(expression); + assertCannotCompile(expression); Double d = 3.0d; expression = parse("#root==3.0d"); @@ -2455,7 +2456,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { // not compatible number types expression = parse("1 != 3.0d"); - assertCantCompile(expression); + assertCannotCompile(expression); expression = parse("T(Integer).valueOf(3) != 4"); assertThat((Boolean) expression.getValue()).isTrue(); @@ -3127,7 +3128,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { // Three strings, optimal bytecode would only use one StringBuilder expression = parse("'hello' + 3 + ' spring'"); assertThat(expression.getValue(new Greeter())).isEqualTo("hello3 spring"); - assertCantCompile(expression); + assertCannotCompile(expression); expression = parse("object + 'a'"); assertThat(expression.getValue(new Greeter())).isEqualTo("objecta"); @@ -4262,7 +4263,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { String testclass9 = "org.springframework.expression.spel.SpelCompilationCoverageTests$TestClass9"; expression = parser.parseExpression("new " + testclass9 + "(42)"); assertThat(expression.getValue().getClass().getName()).isEqualTo(testclass9); - assertCantCompile(expression); + assertCannotCompile(expression); } @Test @@ -4272,7 +4273,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { // Should call the non varargs version of concat // (which causes the '::' prefix in test output) expression = parser.parseExpression("concat('test')"); - assertCantCompile(expression); + assertCannotCompile(expression); expression.getValue(tc); assertThat(tc.s).isEqualTo("::test"); assertCanCompile(expression); @@ -4283,7 +4284,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { // This will call the varargs concat with an empty array expression = parser.parseExpression("concat()"); - assertCantCompile(expression); + assertCannotCompile(expression); expression.getValue(tc); assertThat(tc.s).isEmpty(); assertCanCompile(expression); @@ -4295,7 +4296,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { // Should call the non varargs version of concat // (which causes the '::' prefix in test output) expression = parser.parseExpression("concat2('test')"); - assertCantCompile(expression); + assertCannotCompile(expression); expression.getValue(tc); assertThat(tc.s).isEqualTo("::test"); assertCanCompile(expression); @@ -4306,7 +4307,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { // This will call the varargs concat with an empty array expression = parser.parseExpression("concat2()"); - assertCantCompile(expression); + assertCannotCompile(expression); expression.getValue(tc); assertThat(tc.s).isEmpty(); assertCanCompile(expression); @@ -4322,7 +4323,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { // varargs string expression = parser.parseExpression("eleven()"); - assertCantCompile(expression); + assertCannotCompile(expression); expression.getValue(tc); assertThat(tc.s).isEmpty(); assertCanCompile(expression); @@ -4333,7 +4334,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { // varargs string expression = parser.parseExpression("eleven('aaa')"); - assertCantCompile(expression); + assertCannotCompile(expression); expression.getValue(tc); assertThat(tc.s).isEqualTo("aaa"); assertCanCompile(expression); @@ -4344,7 +4345,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { // varargs string expression = parser.parseExpression("eleven(stringArray)"); - assertCantCompile(expression); + assertCannotCompile(expression); expression.getValue(tc); assertThat(tc.s).isEqualTo("aaabbbccc"); assertCanCompile(expression); @@ -4355,7 +4356,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { // varargs string expression = parser.parseExpression("eleven('aaa','bbb','ccc')"); - assertCantCompile(expression); + assertCannotCompile(expression); expression.getValue(tc); assertThat(tc.s).isEqualTo("aaabbbccc"); assertCanCompile(expression); @@ -4365,7 +4366,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { tc.reset(); expression = parser.parseExpression("sixteen('aaa','bbb','ccc')"); - assertCantCompile(expression); + assertCannotCompile(expression); expression.getValue(tc); assertThat(tc.s).isEqualTo("aaabbbccc"); assertCanCompile(expression); @@ -4387,7 +4388,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { // varargs int expression = parser.parseExpression("twelve(1,2,3)"); - assertCantCompile(expression); + assertCannotCompile(expression); expression.getValue(tc); assertThat(tc.i).isEqualTo(6); assertCanCompile(expression); @@ -4397,7 +4398,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { tc.reset(); expression = parser.parseExpression("twelve(1)"); - assertCantCompile(expression); + assertCannotCompile(expression); expression.getValue(tc); assertThat(tc.i).isEqualTo(1); assertCanCompile(expression); @@ -4408,7 +4409,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { // one string then varargs string expression = parser.parseExpression("thirteen('aaa','bbb','ccc')"); - assertCantCompile(expression); + assertCannotCompile(expression); expression.getValue(tc); assertThat(tc.s).isEqualTo("aaa::bbbccc"); assertCanCompile(expression); @@ -4419,7 +4420,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { // nothing passed to varargs parameter expression = parser.parseExpression("thirteen('aaa')"); - assertCantCompile(expression); + assertCannotCompile(expression); expression.getValue(tc); assertThat(tc.s).isEqualTo("aaa::"); assertCanCompile(expression); @@ -4430,7 +4431,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { // nested arrays expression = parser.parseExpression("fourteen('aaa',stringArray,stringArray)"); - assertCantCompile(expression); + assertCannotCompile(expression); expression.getValue(tc); assertThat(tc.s).isEqualTo("aaa::{aaabbbccc}{aaabbbccc}"); assertCanCompile(expression); @@ -4441,7 +4442,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { // nested primitive array expression = parser.parseExpression("fifteen('aaa',intArray,intArray)"); - assertCantCompile(expression); + assertCannotCompile(expression); expression.getValue(tc); assertThat(tc.s).isEqualTo("aaa::{112233}{112233}"); assertCanCompile(expression); @@ -4452,7 +4453,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { // varargs boolean expression = parser.parseExpression("arrayz(true,true,false)"); - assertCantCompile(expression); + assertCannotCompile(expression); expression.getValue(tc); assertThat(tc.s).isEqualTo("truetruefalse"); assertCanCompile(expression); @@ -4462,7 +4463,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { tc.reset(); expression = parser.parseExpression("arrayz(true)"); - assertCantCompile(expression); + assertCannotCompile(expression); expression.getValue(tc); assertThat(tc.s).isEqualTo("true"); assertCanCompile(expression); @@ -4473,7 +4474,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { // varargs short expression = parser.parseExpression("arrays(s1,s2,s3)"); - assertCantCompile(expression); + assertCannotCompile(expression); expression.getValue(tc); assertThat(tc.s).isEqualTo("123"); assertCanCompile(expression); @@ -4483,7 +4484,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { tc.reset(); expression = parser.parseExpression("arrays(s1)"); - assertCantCompile(expression); + assertCannotCompile(expression); expression.getValue(tc); assertThat(tc.s).isEqualTo("1"); assertCanCompile(expression); @@ -4494,7 +4495,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { // varargs double expression = parser.parseExpression("arrayd(1.0d,2.0d,3.0d)"); - assertCantCompile(expression); + assertCannotCompile(expression); expression.getValue(tc); assertThat(tc.s).isEqualTo("1.02.03.0"); assertCanCompile(expression); @@ -4504,7 +4505,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { tc.reset(); expression = parser.parseExpression("arrayd(1.0d)"); - assertCantCompile(expression); + assertCannotCompile(expression); expression.getValue(tc); assertThat(tc.s).isEqualTo("1.0"); assertCanCompile(expression); @@ -4515,7 +4516,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { // varargs long expression = parser.parseExpression("arrayj(l1,l2,l3)"); - assertCantCompile(expression); + assertCannotCompile(expression); expression.getValue(tc); assertThat(tc.s).isEqualTo("123"); assertCanCompile(expression); @@ -4525,7 +4526,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { tc.reset(); expression = parser.parseExpression("arrayj(l1)"); - assertCantCompile(expression); + assertCannotCompile(expression); expression.getValue(tc); assertThat(tc.s).isEqualTo("1"); assertCanCompile(expression); @@ -4536,7 +4537,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { // varargs char expression = parser.parseExpression("arrayc(c1,c2,c3)"); - assertCantCompile(expression); + assertCannotCompile(expression); expression.getValue(tc); assertThat(tc.s).isEqualTo("abc"); assertCanCompile(expression); @@ -4546,7 +4547,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { tc.reset(); expression = parser.parseExpression("arrayc(c1)"); - assertCantCompile(expression); + assertCannotCompile(expression); expression.getValue(tc); assertThat(tc.s).isEqualTo("a"); assertCanCompile(expression); @@ -4557,7 +4558,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { // varargs byte expression = parser.parseExpression("arrayb(b1,b2,b3)"); - assertCantCompile(expression); + assertCannotCompile(expression); expression.getValue(tc); assertThat(tc.s).isEqualTo("656667"); assertCanCompile(expression); @@ -4567,7 +4568,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { tc.reset(); expression = parser.parseExpression("arrayb(b1)"); - assertCantCompile(expression); + assertCannotCompile(expression); expression.getValue(tc); assertThat(tc.s).isEqualTo("65"); assertCanCompile(expression); @@ -4578,7 +4579,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { // varargs float expression = parser.parseExpression("arrayf(f1,f2,f3)"); - assertCantCompile(expression); + assertCannotCompile(expression); expression.getValue(tc); assertThat(tc.s).isEqualTo("1.02.03.0"); assertCanCompile(expression); @@ -4588,7 +4589,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { tc.reset(); expression = parser.parseExpression("arrayf(f1)"); - assertCantCompile(expression); + assertCannotCompile(expression); expression.getValue(tc); assertThat(tc.s).isEqualTo("1.0"); assertCanCompile(expression); @@ -4603,7 +4604,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { // non-static method, no args, void return expression = parser.parseExpression("new %s()?.one()".formatted(TestClass5.class.getName())); - assertCantCompile(expression); + assertCannotCompile(expression); TestClass5._i = 0; assertThat(expression.getValue()).isNull(); @@ -4620,7 +4621,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { // static method, no args, void return expression = parser.parseExpression("T(%s)?.two()".formatted(TestClass5.class.getName())); - assertCantCompile(expression); + assertCannotCompile(expression); TestClass5._i = 0; assertThat(expression.getValue()).isNull(); @@ -4637,7 +4638,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { // non-static method, no args, Void return expression = parser.parseExpression("new %s()?.oneVoidWrapper()".formatted(TestClass5.class.getName())); - assertCantCompile(expression); + assertCannotCompile(expression); TestClass5._i = 0; assertThat(expression.getValue()).isNull(); @@ -4654,7 +4655,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { // static method, no args, Void return expression = parser.parseExpression("T(%s)?.twoVoidWrapper()".formatted(TestClass5.class.getName())); - assertCantCompile(expression); + assertCannotCompile(expression); TestClass5._i = 0; assertThat(expression.getValue()).isNull(); @@ -4672,7 +4673,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { // non-static method, no args, void return expression = parser.parseExpression("one()"); - assertCantCompile(expression); + assertCannotCompile(expression); expression.getValue(tc); assertCanCompile(expression); tc.reset(); @@ -4682,7 +4683,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { // static method, no args, void return expression = parser.parseExpression("two()"); - assertCantCompile(expression); + assertCannotCompile(expression); expression.getValue(tc); assertCanCompile(expression); tc.reset(); @@ -4692,7 +4693,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { // non-static method, reference type return expression = parser.parseExpression("three()"); - assertCantCompile(expression); + assertCannotCompile(expression); expression.getValue(tc); assertCanCompile(expression); tc.reset(); @@ -4701,7 +4702,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { // non-static method, primitive type return expression = parser.parseExpression("four()"); - assertCantCompile(expression); + assertCannotCompile(expression); expression.getValue(tc); assertCanCompile(expression); tc.reset(); @@ -4710,7 +4711,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { // static method, reference type return expression = parser.parseExpression("five()"); - assertCantCompile(expression); + assertCannotCompile(expression); expression.getValue(tc); assertCanCompile(expression); tc.reset(); @@ -4719,7 +4720,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { // static method, primitive type return expression = parser.parseExpression("six()"); - assertCantCompile(expression); + assertCannotCompile(expression); expression.getValue(tc); assertCanCompile(expression); tc.reset(); @@ -4728,7 +4729,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { // non-static method, one parameter of reference type expression = parser.parseExpression("seven(\"foo\")"); - assertCantCompile(expression); + assertCannotCompile(expression); expression.getValue(tc); assertCanCompile(expression); tc.reset(); @@ -4738,7 +4739,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { // static method, one parameter of reference type expression = parser.parseExpression("eight(\"bar\")"); - assertCantCompile(expression); + assertCannotCompile(expression); expression.getValue(tc); assertCanCompile(expression); tc.reset(); @@ -4748,7 +4749,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { // non-static method, one parameter of primitive type expression = parser.parseExpression("nine(231)"); - assertCantCompile(expression); + assertCannotCompile(expression); expression.getValue(tc); assertCanCompile(expression); tc.reset(); @@ -4758,7 +4759,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { // static method, one parameter of primitive type expression = parser.parseExpression("ten(111)"); - assertCantCompile(expression); + assertCannotCompile(expression); expression.getValue(tc); assertCanCompile(expression); tc.reset(); @@ -4770,10 +4771,10 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { // Converting from an int to a string expression = parser.parseExpression("seven(123)"); - assertCantCompile(expression); + assertCannotCompile(expression); expression.getValue(tc); assertThat(tc.s).isEqualTo("123"); - assertCantCompile(expression); // Uncompilable as argument conversion is occurring + assertCannotCompile(expression); // Uncompilable as argument conversion is occurring Expression expression = parser.parseExpression("'abcd'.substring(index1,index2)"); String resultI = expression.getValue(new TestClass1(), String.class); @@ -4784,7 +4785,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { // Converting from an int to a Number expression = parser.parseExpression("takeNumber(123)"); - assertCantCompile(expression); + assertCannotCompile(expression); expression.getValue(tc); assertThat(tc.s).isEqualTo("123"); tc.reset(); @@ -4794,7 +4795,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { // Passing a subtype expression = parser.parseExpression("takeNumber(T(Integer).valueOf(42))"); - assertCantCompile(expression); + assertCannotCompile(expression); expression.getValue(tc); assertThat(tc.s).isEqualTo("42"); tc.reset(); @@ -4804,11 +4805,11 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { // Passing a subtype expression = parser.parseExpression("takeString(T(Integer).valueOf(42))"); - assertCantCompile(expression); + assertCannotCompile(expression); expression.getValue(tc); assertThat(tc.s).isEqualTo("42"); tc.reset(); - assertCantCompile(expression); // method takes a string and we are passing an Integer + assertCannotCompile(expression); // method takes a string and we are passing an Integer } @Test @@ -4835,7 +4836,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { tc.field = "foo"; expression = parser.parseExpression("seven(field)"); - assertCantCompile(expression); + assertCannotCompile(expression); expression.getValue(tc); assertThat(tc.s).isEqualTo("foo"); assertCanCompile(expression); @@ -4846,7 +4847,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { // method with changing parameter types (change reference type) tc.obj = "foo"; expression = parser.parseExpression("seven(obj)"); - assertCantCompile(expression); + assertCannotCompile(expression); expression.getValue(tc); assertThat(tc.s).isEqualTo("foo"); assertCanCompile(expression); @@ -4982,35 +4983,35 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { // non-static field expression = parser.parseExpression("orange"); - assertCantCompile(expression); + assertCannotCompile(expression); assertThat(expression.getValue(tc)).isEqualTo("value1"); assertCanCompile(expression); assertThat(expression.getValue(tc)).isEqualTo("value1"); // static field expression = parser.parseExpression("apple"); - assertCantCompile(expression); + assertCannotCompile(expression); assertThat(expression.getValue(tc)).isEqualTo("value2"); assertCanCompile(expression); assertThat(expression.getValue(tc)).isEqualTo("value2"); // non static getter expression = parser.parseExpression("banana"); - assertCantCompile(expression); + assertCannotCompile(expression); assertThat(expression.getValue(tc)).isEqualTo("value3"); assertCanCompile(expression); assertThat(expression.getValue(tc)).isEqualTo("value3"); // static getter expression = parser.parseExpression("plum"); - assertCantCompile(expression); + assertCannotCompile(expression); assertThat(expression.getValue(tc)).isEqualTo("value4"); assertCanCompile(expression); assertThat(expression.getValue(tc)).isEqualTo("value4"); // record-style accessor expression = parser.parseExpression("strawberry"); - assertCantCompile(expression); + assertCannotCompile(expression); assertThat(expression.getValue(tc)).isEqualTo("value5"); assertCanCompile(expression); assertThat(expression.getValue(tc)).isEqualTo("value5"); @@ -5631,7 +5632,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { .isTrue(); } - private void assertCantCompile(Expression expression) { + private void assertCannotCompile(Expression expression) { assertThat(SpelCompiler.compile(expression)) .as(() -> "Expression <%s> should not be compilable" .formatted(((SpelExpression) expression).toStringAST())) @@ -5860,25 +5861,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { } - 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 { + public static class Person3 { private int age; diff --git a/spring-expression/src/test/java/org/springframework/expression/spel/testresources/Person.java b/spring-expression/src/test/java/org/springframework/expression/spel/testresources/Person.java index 17939f7a0f2..3a04fdadd83 100644 --- a/spring-expression/src/test/java/org/springframework/expression/spel/testresources/Person.java +++ b/spring-expression/src/test/java/org/springframework/expression/spel/testresources/Person.java @@ -20,8 +20,15 @@ public class Person { private String privateName; + private int age; + Company company; + + public Person(int age) { + this.age = age; + } + public Person(String name) { this.privateName = name; } @@ -31,6 +38,7 @@ public class Person { this.company = company; } + public String getName() { return privateName; } @@ -39,6 +47,14 @@ public class Person { this.privateName = n; } + public int getAge() { + return age; + } + + public void setAge(int age) { + this.age = age; + } + public Company getCompany() { return company; }