new function invocation tests for normal and error behaviour

org.springframework.expression/src/test/java/org/springframework/expression/spel/AllTests.java

@@ -32,6 +32,7 @@ public class AllTests {
 		suite.addTestSuite(BooleanExpressionTests.class);
 		suite.addTestSuite(LiteralTests.class);
 		suite.addTestSuite(ParsingTests.class);
+		suite.addTestSuite(VariableAndFunctionTests.class);
 		suite.addTestSuite(ParserErrorMessagesTests.class);
 		suite.addTestSuite(EvaluationTests.class);
 		suite.addTestSuite(OperatorTests.class);

org.springframework.expression/src/test/java/org/springframework/expression/spel/ExpressionTestCase.java

@@ -34,6 +34,9 @@ public abstract class ExpressionTestCase extends TestCase {
 
 	private final static boolean DEBUG = false;
 
+	protected final static boolean SHOULD_BE_WRITABLE = true;
+	protected final static boolean SHOULD_NOT_BE_WRITABLE = false;
+	
 	protected static SpelExpressionParser parser = new SpelExpressionParser();
 	protected static StandardEvaluationContext eContext = TestScenarioCreator.getTestEvaluationContext();
 
@@ -159,8 +162,14 @@ public abstract class ExpressionTestCase extends TestCase {
 						null);
 			}
 			Class<? extends Object> resultType = value.getClass();
-			assertEquals("Did not get expected value for expression '" + expression + "'.", expectedValue,
-					ExpressionTestCase.stringValueOf(value));
+			if (expectedValue instanceof String) {
+				assertEquals("Did not get expected value for expression '" + expression + "'.", expectedValue,
+						ExpressionTestCase.stringValueOf(value));
+			} else {
+				assertEquals("Did not get expected value for expression '" + expression + "'.", expectedValue, value);
+			}
+//			assertEquals("Did not get expected value for expression '" + expression + "'.", expectedValue,
+//					ExpressionTestCase.stringValueOf(value));
 			assertEquals("Type of the result was not as expected.  Expected '" + expectedClassOfResult
 					+ "' but result was of type '" + resultType + "'", expectedClassOfResult
 					.equals/* isAssignableFrom */(resultType), true);

org.springframework.expression/src/test/java/org/springframework/expression/spel/TestScenarioCreator.java

@@ -61,6 +61,10 @@ public class TestScenarioCreator {
 					new Class[] { Integer.TYPE, Integer.TYPE, Integer.TYPE }));
 			testContext.registerFunction("reverseString", TestScenarioCreator.class.getDeclaredMethod("reverseString",
 					new Class[] { String.class }));
+			testContext.registerFunction("varargsFunctionReverseStringsAndMerge", TestScenarioCreator.class.getDeclaredMethod("varargsFunctionReverseStringsAndMerge",
+					new Class[] { String[].class }));
+			testContext.registerFunction("varargsFunctionReverseStringsAndMerge2", TestScenarioCreator.class.getDeclaredMethod("varargsFunctionReverseStringsAndMerge2",
+					new Class[] { Integer.TYPE,String[].class }));
 		} catch (SecurityException e) {
 			e.printStackTrace();
 		} catch (NoSuchMethodException e) {
@@ -200,4 +204,25 @@ public class TestScenarioCreator {
 		}
 		return backwards.toString();
 	}
+
+	public static String varargsFunctionReverseStringsAndMerge(String...strings) {
+		StringBuilder sb = new StringBuilder();
+		if (strings!=null) {
+			for (int i=strings.length-1;i>=0;i--) {
+				sb.append(strings[i]);
+			}
+		}
+		return sb.toString();
+	}
+	
+	public static String varargsFunctionReverseStringsAndMerge2(int j, String...strings) {
+		StringBuilder sb = new StringBuilder();
+		sb.append(j);
+		if (strings!=null) {
+			for (int i=strings.length-1;i>=0;i--) {
+				sb.append(strings[i]);
+			}
+		}
+		return sb.toString();
+	}
 }

org.springframework.expression/src/test/java/org/springframework/expression/spel/VariableAndFunctionTests.java

@@ -0,0 +1,78 @@
+/*
+ * Copyright 2004-2008 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.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.expression.spel;
+
+import org.springframework.expression.spel.standard.StandardEvaluationContext;
+
+/**
+ * Tests the evaluation of expressions that access variables and functions (lambda/java).
+ * 
+ * @author Andy Clement
+ */
+public class VariableAndFunctionTests extends ExpressionTestCase {
+
+	public void testVariableAccess() {
+		evaluate("#answer", "42", Integer.class, SHOULD_BE_WRITABLE);
+		evaluate("(#i=5;#i)", 5, Integer.class, SHOULD_BE_WRITABLE);
+		evaluate("#answer / 2", 21, Integer.class, SHOULD_NOT_BE_WRITABLE);
+	}
+
+	public void testFunctionAccess01() {
+		evaluate("#reverseInt(1,2,3)", "int[3]{3,2,1}", int[].class);
+		evaluate("#reverseInt('1',2,3)", "int[3]{3,2,1}", int[].class); // requires type conversion of '1' to 1
+	}
+
+	public void testFunctionAccess02() {
+		evaluate("#reverseString('hello')", "olleh", String.class);
+		evaluate("#reverseString(37)", "73", String.class); // requires type conversion of 37 to '37'
+	}
+	
+	public void testCallVarargsFunction() {
+		evaluate("#varargsFunctionReverseStringsAndMerge('a','b','c')","cba",String.class);
+		evaluate("#varargsFunctionReverseStringsAndMerge('a')","a",String.class);
+		evaluate("#varargsFunctionReverseStringsAndMerge()","",String.class);
+		evaluate("#varargsFunctionReverseStringsAndMerge('b',25)","25b",String.class);
+		evaluate("#varargsFunctionReverseStringsAndMerge(25)","25",String.class);
+		evaluate("#varargsFunctionReverseStringsAndMerge2(1,'a','b','c')","1cba",String.class);
+		evaluate("#varargsFunctionReverseStringsAndMerge2(2,'a')","2a",String.class);
+		evaluate("#varargsFunctionReverseStringsAndMerge2(3)","3",String.class);
+		evaluate("#varargsFunctionReverseStringsAndMerge2(4,'b',25)","425b",String.class);
+		evaluate("#varargsFunctionReverseStringsAndMerge2(5,25)","525",String.class);
+	}
+	
+	public void testCallingFunctionsIncorrectly() {
+		evaluateAndCheckError("#varargsFunctionReverseStringsAndMerge(new StringBuilder())",SpelMessages.TYPE_CONVERSION_ERROR);
+	}
+	
+	public void testCallingIllegalFunctions() throws Exception {
+		SpelExpressionParser parser = new SpelExpressionParser();
+		StandardEvaluationContext ctx = new StandardEvaluationContext();
+		ctx.setVariable("notStatic",this.getClass().getMethod("nonStatic"));
+		try {
+			@SuppressWarnings("unused")
+			Object v = parser.parseExpression("#notStatic()").getValue(ctx);
+			fail("Should have failed with exception - cannot call non static method that way");
+		} catch (SpelException se) {
+			if (se.getMessageUnformatted()!=SpelMessages.FUNCTION_MUST_BE_STATIC) {
+				se.printStackTrace();
+				fail("Should have failed a message about the function needing to be static, not: "+se.getMessageUnformatted()); 
+			}
+		}
+	}
+	
+	public void nonStatic() {}
+	
+}