Merge branch '6.0.x'

spring-expression/src/main/java/org/springframework/expression/common/TemplateAwareExpressionParser.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2018 the original author or authors.
+ * Copyright 2002-2023 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.
@@ -26,6 +26,7 @@ import org.springframework.expression.ExpressionParser;
 import org.springframework.expression.ParseException;
 import org.springframework.expression.ParserContext;
 import org.springframework.lang.Nullable;
+import org.springframework.util.Assert;
 
 /**
  * An expression parser that understands templates. It can be subclassed by expression
@@ -34,6 +35,7 @@ import org.springframework.lang.Nullable;
  * @author Keith Donald
  * @author Juergen Hoeller
  * @author Andy Clement
+ * @author Sam Brannen
  * @since 3.0
  */
 public abstract class TemplateAwareExpressionParser implements ExpressionParser {
@@ -46,9 +48,11 @@ public abstract class TemplateAwareExpressionParser implements ExpressionParser
 	@Override
 	public Expression parseExpression(String expressionString, @Nullable ParserContext context) throws ParseException {
 		if (context != null && context.isTemplate()) {
+			Assert.notNull(expressionString, "'expressionString' must not be null");
 			return parseTemplate(expressionString, context);
 		}
 		else {
+			Assert.hasText(expressionString, "'expressionString' must not be null or blank");
 			return doParseExpression(expressionString, context);
 		}
 	}

spring-expression/src/main/java/org/springframework/expression/spel/standard/SpelExpressionParser.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2014 the original author or authors.
+ * Copyright 2002-2023 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.
@@ -28,6 +28,7 @@ import org.springframework.util.Assert;
  *
  * @author Andy Clement
  * @author Juergen Hoeller
+ * @author Sam Brannen
  * @since 3.0
  */
 public class SpelExpressionParser extends TemplateAwareExpressionParser {
@@ -53,6 +54,7 @@ public class SpelExpressionParser extends TemplateAwareExpressionParser {
 
 
 	public SpelExpression parseRaw(String expressionString) throws ParseException {
+		Assert.hasText(expressionString, "'expressionString' must not be null or blank");
 		return doParseExpression(expressionString, null);
 	}
 

spring-expression/src/test/java/org/springframework/expression/spel/TemplateExpressionParsingTests.java

@@ -30,6 +30,7 @@ import org.springframework.expression.spel.support.StandardEvaluationContext;
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
+import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
 
 /**
  * @author Andy Clement
@@ -40,26 +41,32 @@ class TemplateExpressionParsingTests extends AbstractExpressionTests {
 
 	static final ParserContext DOLLAR_SIGN_TEMPLATE_PARSER_CONTEXT = new TemplateParserContext("${", "}");
 
+	private final SpelExpressionParser parser = new SpelExpressionParser();
+
 
 	@Test
-	void parsingSimpleTemplateExpression01() throws Exception {
-		SpelExpressionParser parser = new SpelExpressionParser();
+	void nullTemplateExpressionIsRejected() {
+		assertThatIllegalArgumentException()
+			.isThrownBy(() -> parser.parseExpression(null, DOLLAR_SIGN_TEMPLATE_PARSER_CONTEXT))
+			.withMessage("'expressionString' must not be null");
+	}
+
+	@Test
+	void parsingSimpleTemplateExpression01() {
 		Expression expr = parser.parseExpression("hello ${'world'}", DOLLAR_SIGN_TEMPLATE_PARSER_CONTEXT);
 		Object o = expr.getValue();
 		assertThat(o.toString()).isEqualTo("hello world");
 	}
 
 	@Test
-	void parsingSimpleTemplateExpression02() throws Exception {
-		SpelExpressionParser parser = new SpelExpressionParser();
+	void parsingSimpleTemplateExpression02() {
 		Expression expr = parser.parseExpression("hello ${'to'} you", DOLLAR_SIGN_TEMPLATE_PARSER_CONTEXT);
 		Object o = expr.getValue();
 		assertThat(o.toString()).isEqualTo("hello to you");
 	}
 
 	@Test
-	void parsingSimpleTemplateExpression03() throws Exception {
-		SpelExpressionParser parser = new SpelExpressionParser();
+	void parsingSimpleTemplateExpression03() {
 		Expression expr = parser.parseExpression("The quick ${'brown'} fox jumped over the ${'lazy'} dog",
 				DOLLAR_SIGN_TEMPLATE_PARSER_CONTEXT);
 		Object o = expr.getValue();
@@ -67,8 +74,7 @@ class TemplateExpressionParsingTests extends AbstractExpressionTests {
 	}
 
 	@Test
-	void parsingSimpleTemplateExpression04() throws Exception {
-		SpelExpressionParser parser = new SpelExpressionParser();
+	void parsingSimpleTemplateExpression04() {
 		Expression expr = parser.parseExpression("${'hello'} world", DOLLAR_SIGN_TEMPLATE_PARSER_CONTEXT);
 		Object o = expr.getValue();
 		assertThat(o.toString()).isEqualTo("hello world");
@@ -87,8 +93,7 @@ class TemplateExpressionParsingTests extends AbstractExpressionTests {
 	}
 
 	@Test
-	void compositeStringExpression() throws Exception {
-		SpelExpressionParser parser = new SpelExpressionParser();
+	void compositeStringExpression() {
 		Expression ex = parser.parseExpression("hello ${'world'}", DOLLAR_SIGN_TEMPLATE_PARSER_CONTEXT);
 		assertThat(ex.getValue()).isInstanceOf(String.class).isEqualTo("hello world");
 		assertThat(ex.getValue(String.class)).isInstanceOf(String.class).isEqualTo("hello world");
@@ -127,8 +132,7 @@ class TemplateExpressionParsingTests extends AbstractExpressionTests {
 	static class Rooty {}
 
 	@Test
-	void nestedExpressions() throws Exception {
-		SpelExpressionParser parser = new SpelExpressionParser();
+	void nestedExpressions() {
 		// treat the nested ${..} as a part of the expression
 		Expression ex = parser.parseExpression("hello ${listOfNumbersUpToTen.$[#this<5]} world",DOLLAR_SIGN_TEMPLATE_PARSER_CONTEXT);
 		String s = ex.getValue(TestScenarioCreator.getTestEvaluationContext(),String.class);
@@ -158,7 +162,7 @@ class TemplateExpressionParsingTests extends AbstractExpressionTests {
 	}
 
 	@Test
-	void clashingWithSuffixes() throws Exception {
+	void clashingWithSuffixes() {
 		// Just wanting to use the prefix or suffix within the template:
 		Expression ex = parser.parseExpression("hello ${3+4} world",DOLLAR_SIGN_TEMPLATE_PARSER_CONTEXT);
 		String s = ex.getValue(TestScenarioCreator.getTestEvaluationContext(),String.class);
@@ -174,13 +178,13 @@ class TemplateExpressionParsingTests extends AbstractExpressionTests {
 	}
 
 	@Test
-	void parsingNormalExpressionThroughTemplateParser() throws Exception {
+	void parsingNormalExpressionThroughTemplateParser() {
 		Expression expr = parser.parseExpression("1+2+3");
 		assertThat(expr.getValue()).isEqualTo(6);
 	}
 
 	@Test
-	void errorCases() throws Exception {
+	void errorCases() {
 		assertThatExceptionOfType(ParseException.class).isThrownBy(() ->
 				parser.parseExpression("hello ${'world'", DOLLAR_SIGN_TEMPLATE_PARSER_CONTEXT))
 			.satisfies(pex -> {

spring-expression/src/test/java/org/springframework/expression/spel/standard/SpelParserTests.java

@@ -18,6 +18,8 @@ package org.springframework.expression.spel.standard;
 
 import java.util.function.Consumer;
 
+import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
+import org.assertj.core.api.ThrowableAssertAlternative;
 import org.junit.jupiter.api.Test;
 
 import org.springframework.expression.EvaluationContext;
@@ -31,16 +33,55 @@ import org.springframework.expression.spel.support.StandardEvaluationContext;
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
+import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
+import static org.springframework.expression.spel.SpelMessage.MISSING_CONSTRUCTOR_ARGS;
+import static org.springframework.expression.spel.SpelMessage.NON_TERMINATING_DOUBLE_QUOTED_STRING;
+import static org.springframework.expression.spel.SpelMessage.NON_TERMINATING_QUOTED_STRING;
+import static org.springframework.expression.spel.SpelMessage.NOT_AN_INTEGER;
+import static org.springframework.expression.spel.SpelMessage.NOT_A_LONG;
+import static org.springframework.expression.spel.SpelMessage.REAL_CANNOT_BE_LONG;
+import static org.springframework.expression.spel.SpelMessage.RUN_OUT_OF_ARGUMENTS;
+import static org.springframework.expression.spel.SpelMessage.UNEXPECTED_DATA_AFTER_DOT;
+import static org.springframework.expression.spel.SpelMessage.UNEXPECTED_ESCAPE_CHAR;
 
 /**
  * @author Andy Clement
  * @author Juergen Hoeller
+ * @author Sam Brannen
  */
 class SpelParserTests {
 
+	private final SpelExpressionParser parser = new SpelExpressionParser();
+
+
+	@Test
+	void nullExpressionIsRejected() {
+		assertNullOrEmptyExpressionIsRejected(() -> parser.parseExpression(null));
+		assertNullOrEmptyExpressionIsRejected(() -> parser.parseRaw(null));
+	}
+
+	@Test
+	void emptyExpressionIsRejected() {
+		assertNullOrEmptyExpressionIsRejected(() -> parser.parseExpression(""));
+		assertNullOrEmptyExpressionIsRejected(() -> parser.parseRaw(""));
+	}
+
+	@Test
+	void blankExpressionIsRejected() {
+		assertNullOrEmptyExpressionIsRejected(() -> parser.parseExpression("     "));
+		assertNullOrEmptyExpressionIsRejected(() -> parser.parseExpression("\t\n"));
+		assertNullOrEmptyExpressionIsRejected(() -> parser.parseRaw("     "));
+		assertNullOrEmptyExpressionIsRejected(() -> parser.parseRaw("\t\n"));
+	}
+
+	private static void assertNullOrEmptyExpressionIsRejected(ThrowingCallable throwingCallable) {
+		assertThatIllegalArgumentException()
+			.isThrownBy(throwingCallable)
+			.withMessage("'expressionString' must not be null or blank");
+	}
+
 	@Test
 	void theMostBasic() {
-		SpelExpressionParser parser = new SpelExpressionParser();
 		SpelExpression expr = parser.parseRaw("2");
 		assertThat(expr).isNotNull();
 		assertThat(expr.getAST()).isNotNull();
@@ -51,7 +92,6 @@ class SpelParserTests {
 
 	@Test
 	void valueType() {
-		SpelExpressionParser parser = new SpelExpressionParser();
 		EvaluationContext ctx = new StandardEvaluationContext();
 		Class<?> c = parser.parseRaw("2").getValueType();
 		assertThat(c).isEqualTo(Integer.class);
@@ -67,7 +107,6 @@ class SpelParserTests {
 
 	@Test
 	void whitespace() {
-		SpelExpressionParser parser = new SpelExpressionParser();
 		SpelExpression expr = parser.parseRaw("2      +    3");
 		assertThat(expr.getValue()).isEqualTo(5);
 		expr = parser.parseRaw("2	+	3");
@@ -80,7 +119,6 @@ class SpelParserTests {
 
 	@Test
 	void arithmeticPlus1() {
-		SpelExpressionParser parser = new SpelExpressionParser();
 		SpelExpression expr = parser.parseRaw("2+2");
 		assertThat(expr).isNotNull();
 		assertThat(expr.getAST()).isNotNull();
@@ -89,14 +127,12 @@ class SpelParserTests {
 
 	@Test
 	void arithmeticPlus2() {
-		SpelExpressionParser parser = new SpelExpressionParser();
 		SpelExpression expr = parser.parseRaw("37+41");
 		assertThat(expr.getValue()).isEqualTo(78);
 	}
 
 	@Test
 	void arithmeticMultiply1() {
-		SpelExpressionParser parser = new SpelExpressionParser();
 		SpelExpression expr = parser.parseRaw("2*3");
 		assertThat(expr).isNotNull();
 		assertThat(expr.getAST()).isNotNull();
@@ -105,162 +141,120 @@ class SpelParserTests {
 
 	@Test
 	void arithmeticPrecedence1() {
-		SpelExpressionParser parser = new SpelExpressionParser();
 		SpelExpression expr = parser.parseRaw("2*3+5");
 		assertThat(expr.getValue()).isEqualTo(11);
 	}
 
 	@Test
-	void generalExpressions() {
-		assertThatExceptionOfType(SpelParseException.class).isThrownBy(() -> {
-			SpelExpressionParser parser = new SpelExpressionParser();
-			parser.parseRaw("new String");
-		})
-		.satisfies(parseExceptionRequirements(SpelMessage.MISSING_CONSTRUCTOR_ARGS, 10));
-
-		assertThatExceptionOfType(SpelParseException.class).isThrownBy(() -> {
-			SpelExpressionParser parser = new SpelExpressionParser();
-			parser.parseRaw("new String(3,");
-		})
-		.satisfies(parseExceptionRequirements(SpelMessage.RUN_OUT_OF_ARGUMENTS, 10));
-
-		assertThatExceptionOfType(SpelParseException.class).isThrownBy(() -> {
-			SpelExpressionParser parser = new SpelExpressionParser();
-			parser.parseRaw("new String(3");
-		})
-		.satisfies(parseExceptionRequirements(SpelMessage.RUN_OUT_OF_ARGUMENTS, 10));
-
-		assertThatExceptionOfType(SpelParseException.class).isThrownBy(() -> {
-			SpelExpressionParser parser = new SpelExpressionParser();
-			parser.parseRaw("new String(");
-		})
-		.satisfies(parseExceptionRequirements(SpelMessage.RUN_OUT_OF_ARGUMENTS, 10));
-
-		assertThatExceptionOfType(SpelParseException.class).isThrownBy(() -> {
-			SpelExpressionParser parser = new SpelExpressionParser();
-			parser.parseRaw("\"abc");
-		})
-		.satisfies(parseExceptionRequirements(SpelMessage.NON_TERMINATING_DOUBLE_QUOTED_STRING, 0));
-
-		assertThatExceptionOfType(SpelParseException.class).isThrownBy(() -> {
-			SpelExpressionParser parser = new SpelExpressionParser();
-			parser.parseRaw("'abc");
-		})
-		.satisfies(parseExceptionRequirements(SpelMessage.NON_TERMINATING_QUOTED_STRING, 0));
-
-	}
-
-	private <E extends SpelParseException> Consumer<E> parseExceptionRequirements(
-			SpelMessage expectedMessage, int expectedPosition) {
-		return ex -> {
-			assertThat(ex.getMessageCode()).isEqualTo(expectedMessage);
-			assertThat(ex.getPosition()).isEqualTo(expectedPosition);
-			assertThat(ex.getMessage()).contains(ex.getExpressionString());
-		};
+	void parseExceptions() {
+		assertParseException(() -> parser.parseRaw("new String"), MISSING_CONSTRUCTOR_ARGS, 10);
+		assertParseException(() -> parser.parseRaw("new String(3,"), RUN_OUT_OF_ARGUMENTS, 10);
+		assertParseException(() -> parser.parseRaw("new String(3"), RUN_OUT_OF_ARGUMENTS, 10);
+		assertParseException(() -> parser.parseRaw("new String("), RUN_OUT_OF_ARGUMENTS, 10);
+		assertParseException(() -> parser.parseRaw("\"abc"), NON_TERMINATING_DOUBLE_QUOTED_STRING, 0);
+		assertParseException(() -> parser.parseRaw("'abc"), NON_TERMINATING_QUOTED_STRING, 0);
 	}
 
 	@Test
 	void arithmeticPrecedence2() {
-		SpelExpressionParser parser = new SpelExpressionParser();
 		SpelExpression expr = parser.parseRaw("2+3*5");
 		assertThat(expr.getValue()).isEqualTo(17);
 	}
 
 	@Test
 	void arithmeticPrecedence3() {
-		SpelExpression expr = new SpelExpressionParser().parseRaw("3+10/2");
+		SpelExpression expr = parser.parseRaw("3+10/2");
 		assertThat(expr.getValue()).isEqualTo(8);
 	}
 
 	@Test
 	void arithmeticPrecedence4() {
-		SpelExpression expr = new SpelExpressionParser().parseRaw("10/2+3");
+		SpelExpression expr = parser.parseRaw("10/2+3");
 		assertThat(expr.getValue()).isEqualTo(8);
 	}
 
 	@Test
 	void arithmeticPrecedence5() {
-		SpelExpression expr = new SpelExpressionParser().parseRaw("(4+10)/2");
+		SpelExpression expr = parser.parseRaw("(4+10)/2");
 		assertThat(expr.getValue()).isEqualTo(7);
 	}
 
 	@Test
 	void arithmeticPrecedence6() {
-		SpelExpression expr = new SpelExpressionParser().parseRaw("(3+2)*2");
+		SpelExpression expr = parser.parseRaw("(3+2)*2");
 		assertThat(expr.getValue()).isEqualTo(10);
 	}
 
 	@Test
 	void booleanOperators() {
-		SpelExpression expr = new SpelExpressionParser().parseRaw("true");
+		SpelExpression expr = parser.parseRaw("true");
 		assertThat(expr.getValue(Boolean.class)).isTrue();
-		expr = new SpelExpressionParser().parseRaw("false");
+		expr = parser.parseRaw("false");
 		assertThat(expr.getValue(Boolean.class)).isFalse();
-		expr = new SpelExpressionParser().parseRaw("false and false");
+		expr = parser.parseRaw("false and false");
 		assertThat(expr.getValue(Boolean.class)).isFalse();
-		expr = new SpelExpressionParser().parseRaw("true and (true or false)");
+		expr = parser.parseRaw("true and (true or false)");
 		assertThat(expr.getValue(Boolean.class)).isTrue();
-		expr = new SpelExpressionParser().parseRaw("true and true or false");
+		expr = parser.parseRaw("true and true or false");
 		assertThat(expr.getValue(Boolean.class)).isTrue();
-		expr = new SpelExpressionParser().parseRaw("!true");
+		expr = parser.parseRaw("!true");
 		assertThat(expr.getValue(Boolean.class)).isFalse();
-		expr = new SpelExpressionParser().parseRaw("!(false or true)");
+		expr = parser.parseRaw("!(false or true)");
 		assertThat(expr.getValue(Boolean.class)).isFalse();
 	}
 
 	@Test
 	void booleanOperators_symbolic_spr9614() {
-		SpelExpression expr = new SpelExpressionParser().parseRaw("true");
+		SpelExpression expr = parser.parseRaw("true");
 		assertThat(expr.getValue(Boolean.class)).isTrue();
-		expr = new SpelExpressionParser().parseRaw("false");
+		expr = parser.parseRaw("false");
 		assertThat(expr.getValue(Boolean.class)).isFalse();
-		expr = new SpelExpressionParser().parseRaw("false && false");
+		expr = parser.parseRaw("false && false");
 		assertThat(expr.getValue(Boolean.class)).isFalse();
-		expr = new SpelExpressionParser().parseRaw("true && (true || false)");
+		expr = parser.parseRaw("true && (true || false)");
 		assertThat(expr.getValue(Boolean.class)).isTrue();
-		expr = new SpelExpressionParser().parseRaw("true && true || false");
+		expr = parser.parseRaw("true && true || false");
 		assertThat(expr.getValue(Boolean.class)).isTrue();
-		expr = new SpelExpressionParser().parseRaw("!true");
+		expr = parser.parseRaw("!true");
 		assertThat(expr.getValue(Boolean.class)).isFalse();
-		expr = new SpelExpressionParser().parseRaw("!(false || true)");
+		expr = parser.parseRaw("!(false || true)");
 		assertThat(expr.getValue(Boolean.class)).isFalse();
 	}
 
 	@Test
 	void stringLiterals() {
-		SpelExpression expr = new SpelExpressionParser().parseRaw("'howdy'");
+		SpelExpression expr = parser.parseRaw("'howdy'");
 		assertThat(expr.getValue()).isEqualTo("howdy");
-		expr = new SpelExpressionParser().parseRaw("'hello '' world'");
+		expr = parser.parseRaw("'hello '' world'");
 		assertThat(expr.getValue()).isEqualTo("hello ' world");
 	}
 
 	@Test
 	void stringLiterals2() {
-		SpelExpression expr = new SpelExpressionParser().parseRaw("'howdy'.substring(0,2)");
+		SpelExpression expr = parser.parseRaw("'howdy'.substring(0,2)");
 		assertThat(expr.getValue()).isEqualTo("ho");
 	}
 
 	@Test
 	void testStringLiterals_DoubleQuotes_spr9620() {
-		SpelExpression expr = new SpelExpressionParser().parseRaw("\"double quote: \"\".\"");
+		SpelExpression expr = parser.parseRaw("\"double quote: \"\".\"");
 		assertThat(expr.getValue()).isEqualTo("double quote: \".");
-		expr = new SpelExpressionParser().parseRaw("\"hello \"\" world\"");
+		expr = parser.parseRaw("\"hello \"\" world\"");
 		assertThat(expr.getValue()).isEqualTo("hello \" world");
 	}
 
 	@Test
 	void testStringLiterals_DoubleQuotes_spr9620_2() {
-		assertThatExceptionOfType(SpelParseException.class).isThrownBy(() ->
-				new SpelExpressionParser().parseRaw("\"double quote: \\\"\\\".\""))
+		assertParseExceptionThrownBy(() -> parser.parseRaw("\"double quote: \\\"\\\".\""))
 			.satisfies(ex -> {
 				assertThat(ex.getPosition()).isEqualTo(17);
-				assertThat(ex.getMessageCode()).isEqualTo(SpelMessage.UNEXPECTED_ESCAPE_CHAR);
+				assertThat(ex.getMessageCode()).isEqualTo(UNEXPECTED_ESCAPE_CHAR);
 			});
 	}
 
 	@Test
 	void positionalInformation() {
-		SpelExpression expr = new SpelExpressionParser().parseRaw("true and true or false");
+		SpelExpression expr = parser.parseRaw("true and true or false");
 		SpelNode rootAst = expr.getAST();
 		OpOr operatorOr = (OpOr) rootAst;
 		OpAnd operatorAnd = (OpAnd) operatorOr.getLeftOperand();
@@ -355,10 +349,10 @@ class SpelParserTests {
 		checkNumber("0xa", 10, Integer.class);
 		checkNumber("0xAL", 10L, Long.class);
 
-		checkNumberError("0x", SpelMessage.NOT_AN_INTEGER);
-		checkNumberError("0xL", SpelMessage.NOT_A_LONG);
-		checkNumberError(".324", SpelMessage.UNEXPECTED_DATA_AFTER_DOT);
-		checkNumberError("3.4L", SpelMessage.REAL_CANNOT_BE_LONG);
+		checkNumberError("0x", NOT_AN_INTEGER);
+		checkNumberError("0xL", NOT_A_LONG);
+		checkNumberError(".324", UNEXPECTED_DATA_AFTER_DOT);
+		checkNumberError("3.4L", REAL_CANNOT_BE_LONG);
 
 		checkNumber("3.5f", 3.5f, Float.class);
 		checkNumber("1.2e3", 1.2e3d, Double.class);
@@ -371,7 +365,6 @@ class SpelParserTests {
 
 	private void checkNumber(String expression, Object value, Class<?> type) {
 		try {
-			SpelExpressionParser parser = new SpelExpressionParser();
 			SpelExpression expr = parser.parseRaw(expression);
 			Object exprVal = expr.getValue();
 			assertThat(exprVal).isEqualTo(value);
@@ -383,9 +376,26 @@ class SpelParserTests {
 	}
 
 	private void checkNumberError(String expression, SpelMessage expectedMessage) {
-		SpelExpressionParser parser = new SpelExpressionParser();
-		assertThatExceptionOfType(SpelParseException.class).isThrownBy(() -> parser.parseRaw(expression))
+		assertParseExceptionThrownBy(() -> parser.parseRaw(expression))
 			.satisfies(ex -> assertThat(ex.getMessageCode()).isEqualTo(expectedMessage));
 	}
 
+	private static ThrowableAssertAlternative<SpelParseException> assertParseExceptionThrownBy(ThrowingCallable throwingCallable) {
+		return assertThatExceptionOfType(SpelParseException.class).isThrownBy(throwingCallable);
+	}
+
+	private static void assertParseException(ThrowingCallable throwingCallable, SpelMessage expectedMessage, int expectedPosition) {
+		assertParseExceptionThrownBy(throwingCallable)
+			.satisfies(parseExceptionRequirements(expectedMessage, expectedPosition));
+	}
+
+	private static <E extends SpelParseException> Consumer<E> parseExceptionRequirements(
+			SpelMessage expectedMessage, int expectedPosition) {
+		return ex -> {
+			assertThat(ex.getMessageCode()).isEqualTo(expectedMessage);
+			assertThat(ex.getPosition()).isEqualTo(expectedPosition);
+			assertThat(ex.getMessage()).contains(ex.getExpressionString());
+		};
+	}
+
 }