SpEL incorrectly splits string arguments by comma for `Object...` varargs method

[weiw005]

Affects

4.1.2.RELEASE or higher

Summary

In SpEL, a registered varargs function incorrectly splits string arguments by comma when varargs type is Object / Any.

Overview

This is related to previously reported #27582. The issue was likely not fully fixed yet.

I created a unit test here to demo the bug: https://github.com/weiw005/playground/blob/e6f1ae9336b8ac5e294758a90d2639c6a075df5b/spel-vararg/src/test/kotlin/SpelVarargTest.kt

It seems that when a registered function has vararg args: Any as the argument type, SpEL would have inconsistent behavior when there is single vs. multiple argument(s) of string type:

• Single argument: SpEL will split the string by comma, and take the first part only
• Multiple arguments: SpEL will take all arguments as is (expected behavior)

This bug doesn't manifest when the function signature declares vararg args: String instead (all arguments would be taken as is correctly).

I have also confirmed that version 4.1.1.RELEASE or lower did not have this bug.

Related Issues

• SpEL vararg method invocation fails if string literal contains a comma #27582
• Support varargs invocations in SpEL for varargs array subtype #32704

[weiw005]

@manoharank reported the same observation here: #27582 (comment)

[sbrannen]

Hi @weiw005,

Congratulations on submitting your first issue for the Spring Framework! 👍

Thanks for the Demo!

Though, please submit sample applications using Java (unless Kotlin is required to reproduce the issue).

I've reduced the demo to the following standalone Java test class.

import java.lang.reflect.Method;
import org.junit.jupiter.api.Test;
import org.springframework.expression.Expression;
import org.springframework.expression.spel.standard.SpelExpressionParser;
import org.springframework.expression.spel.support.StandardEvaluationContext;
import org.springframework.util.ReflectionUtils;
import static org.assertj.core.api.Assertions.assertThat;

class SpelVarargsTests {

	@Test
	void formatStringVarargs_EmptyString() {
		assertThat(evaluateExpression("#formatStringVarargs('Hello %s', '')"))
				.isEqualTo("Hello ");
	}

	@Test
	void formatObjectVarargs_EmptyString() {
		assertThat(evaluateExpression("#formatObjectVarargs('Hello %s', '')"))
				.isEqualTo("Hello ");
	}

	@Test
	void formatStringVarargs_SingleArgumentWithComma() {
		assertThat(evaluateExpression("#formatStringVarargs('Hello %s', 'a, b')"))
				.isEqualTo("Hello a, b");
	}

	@Test
	void formatObjectVarargs_SingleArgumentWithComma() {
		assertThat(evaluateExpression("#formatObjectVarargs('Hello %s', 'a, b')"))
				.isEqualTo("Hello a, b");
	}

	@Test
	void formatStringVarargs_MultiArgumentWithComma() {
		assertThat(evaluateExpression("#formatStringVarargs('Hello %s; %s', 'a, b', 'c, d')"))
				.isEqualTo("Hello a, b; c, d");
	}

	@Test
	void formatObjectVarargs_MultiArgumentWithComma() {
		assertThat(evaluateExpression("#formatObjectVarargs('Hello %s; %s', 'a, b', 'c, d')"))
				.isEqualTo("Hello a, b; c, d");
	}


	private static final Method formatObjectVarargs =
			ReflectionUtils.findMethod(SpelVarargsTests.class, "formatObjectVarargs", String.class, Object[].class);

	private static final Method formatStringVarargs =
			ReflectionUtils.findMethod(SpelVarargsTests.class, "formatStringVarargs", String.class, String[].class);

	private static Object evaluateExpression(String expression) {
		SpelExpressionParser parser = new SpelExpressionParser();
		Expression exp = parser.parseExpression(expression);
		StandardEvaluationContext context = new StandardEvaluationContext();
		context.registerFunction("formatObjectVarargs", formatObjectVarargs);
		context.registerFunction("formatStringVarargs", formatStringVarargs);
		return exp.getValue(context);
	}

	static String formatObjectVarargs(String format, Object... args) {
		return String.format(format, args);
	}

	static String formatStringVarargs(String format, String... args) {
		return String.format(format, (Object[]) args);
	}

}

When running against main, formatObjectVarargs_EmptyString() and formatObjectVarargs_SingleArgumentWithComma() fail.

We'll look into fixing this.

Cheers,

Sam

[sbrannen]

While investigating this, I noticed that (in theory) the same bug must exist for a function registered as a MethodHandle, since that code is effectively a copy of the code for Method and Constructor invocations.