diff --git a/org.springframework.expression/.classpath b/org.springframework.expression/.classpath index 548332628a..5bc40d02ea 100644 --- a/org.springframework.expression/.classpath +++ b/org.springframework.expression/.classpath @@ -7,6 +7,6 @@ - + diff --git a/org.springframework.expression/readme.txt b/org.springframework.expression/readme.txt index 6205f0d0cd..5dfdfa9e23 100644 --- a/org.springframework.expression/readme.txt +++ b/org.springframework.expression/readme.txt @@ -6,6 +6,8 @@ High Importance in a different context then the stored executor may be incorrect. It may harmless 'fail' which would cause us to retrieve a new one, but can it do anything malicious? In which case we either need to forget them when the context changes or store them elsewhere. Should caching be something that can be switched on/off by the context? (shouldCacheExecutors() on the interface?) +- Expression serialization needs supporting +- expression basic interface and common package. Should LiteralExpression be settable? should getExpressionString return quoted value? Low Importance @@ -13,6 +15,7 @@ Low Importance would have taken? At the moment ternary expressions are just considered NOT writable. - Enhance type locator interface with direct support for register/unregister imports and ability to set class loader? - Should some of the common errors (like SpelMessages.TYPE_NOT_FOUND) be promoted to top level exceptions? +- Expression comparison - is it necessary? Syntax diff --git a/org.springframework.expression/src/main/java/org/springframework/expression/common/LiteralExpression.java b/org.springframework.expression/src/main/java/org/springframework/expression/common/LiteralExpression.java index 48e20ea09b..dfb49cf35f 100644 --- a/org.springframework.expression/src/main/java/org/springframework/expression/common/LiteralExpression.java +++ b/org.springframework.expression/src/main/java/org/springframework/expression/common/LiteralExpression.java @@ -24,14 +24,15 @@ public class LiteralExpression implements Expression { } public String getExpressionString() { - return new StringBuilder().append("'").append(literalValue).append("'").toString(); + return literalValue; + // return new StringBuilder().append("'").append(literalValue).append("'").toString(); } - public Object getValue() throws EvaluationException { + public String getValue() throws EvaluationException { return literalValue; } - public Object getValue(EvaluationContext context) throws EvaluationException { + public String getValue(EvaluationContext context) throws EvaluationException { return literalValue; } diff --git a/org.springframework.expression/src/main/java/org/springframework/expression/spel/ExpressionState.java b/org.springframework.expression/src/main/java/org/springframework/expression/spel/ExpressionState.java index e742ce4a0c..74d69e9d00 100644 --- a/org.springframework.expression/src/main/java/org/springframework/expression/spel/ExpressionState.java +++ b/org.springframework.expression/src/main/java/org/springframework/expression/spel/ExpressionState.java @@ -25,6 +25,7 @@ import org.springframework.expression.Operation; import org.springframework.expression.OperatorOverloader; import org.springframework.expression.PropertyAccessor; import org.springframework.expression.TypeComparator; +import org.springframework.expression.TypeConverter; import org.springframework.expression.TypeUtils; import org.springframework.expression.spel.internal.VariableScope; @@ -42,21 +43,21 @@ public class ExpressionState { private EvaluationContext relatedContext; - private final Stack environment = new Stack(); + private final Stack variableScopes = new Stack(); private final Stack contextObjects = new Stack(); public ExpressionState(EvaluationContext context) { - this.relatedContext = context; - createEnvironment(); + relatedContext = context; + createVariableScope(); } public ExpressionState() { - createEnvironment(); + createVariableScope(); } - private void createEnvironment() { - environment.add(new VariableScope()); // create an empty top level VariableScope + private void createVariableScope() { + variableScopes.add(new VariableScope()); // create an empty top level VariableScope } /** @@ -97,37 +98,42 @@ public class ExpressionState { return getTypeUtilities().getTypeLocator().findType(type); } + // TODO all these methods that grab the type converter will fail badly if there isn't one... public boolean toBoolean(Object value) throws EvaluationException { - // TODO cache TypeConverter when it is set/changed? - return ((Boolean) getTypeUtilities().getTypeConverter().convertValue(value, Boolean.TYPE)).booleanValue(); + return ((Boolean) getTypeConverter().convertValue(value, Boolean.TYPE)).booleanValue(); } public char toCharacter(Object value) throws EvaluationException { - return ((Character) getTypeUtilities().getTypeConverter().convertValue(value, Character.TYPE)).charValue(); + return ((Character) getTypeConverter().convertValue(value, Character.TYPE)).charValue(); } public short toShort(Object value) throws EvaluationException { - return ((Short) getTypeUtilities().getTypeConverter().convertValue(value, Short.TYPE)).shortValue(); + return ((Short) getTypeConverter().convertValue(value, Short.TYPE)).shortValue(); } public int toInteger(Object value) throws EvaluationException { - return ((Integer) getTypeUtilities().getTypeConverter().convertValue(value, Integer.TYPE)).intValue(); + return ((Integer) getTypeConverter().convertValue(value, Integer.TYPE)).intValue(); } public double toDouble(Object value) throws EvaluationException { - return ((Double) getTypeUtilities().getTypeConverter().convertValue(value, Double.TYPE)).doubleValue(); + return ((Double) getTypeConverter().convertValue(value, Double.TYPE)).doubleValue(); } public float toFloat(Object value) throws EvaluationException { - return ((Float) getTypeUtilities().getTypeConverter().convertValue(value, Float.TYPE)).floatValue(); + return ((Float) getTypeConverter().convertValue(value, Float.TYPE)).floatValue(); } public long toLong(Object value) throws EvaluationException { - return ((Long) getTypeUtilities().getTypeConverter().convertValue(value, Long.TYPE)).longValue(); + return ((Long) getTypeConverter().convertValue(value, Long.TYPE)).longValue(); } public byte toByte(Object value) throws EvaluationException { - return ((Byte) getTypeUtilities().getTypeConverter().convertValue(value, Byte.TYPE)).byteValue(); + return ((Byte) getTypeConverter().convertValue(value, Byte.TYPE)).byteValue(); + } + + public TypeConverter getTypeConverter() { + // TODO cache TypeConverter when it is set/changed? + return getTypeUtilities().getTypeConverter(); } public void setVariable(String name, Object value) { @@ -142,26 +148,26 @@ public class ExpressionState { * A new scope is entered when a function is invoked */ public void enterScope(Map argMap) { - environment.push(new VariableScope(argMap)); + variableScopes.push(new VariableScope(argMap)); } public void enterScope(String name, Object value) { - environment.push(new VariableScope(name, value)); + variableScopes.push(new VariableScope(name, value)); } public void exitScope() { - environment.pop(); + variableScopes.pop(); } public void setLocalVariable(String name, Object value) { - environment.peek().setVariable(name, value); + variableScopes.peek().setVariable(name, value); } public Object lookupLocalVariable(String name) { - int scopeNumber = environment.size() - 1; + int scopeNumber = variableScopes.size() - 1; for (int i = scopeNumber; i >= 0; i--) { - if (environment.get(i).definesVariable(name)) { - return environment.get(i).lookupVariable(name); + if (variableScopes.get(i).definesVariable(name)) { + return variableScopes.get(i).lookupVariable(name); } } return null; diff --git a/org.springframework.expression/src/main/java/org/springframework/expression/spel/SpelUtilities.java b/org.springframework.expression/src/main/java/org/springframework/expression/spel/SpelUtilities.java index 209a4e6617..38fe3a2551 100644 --- a/org.springframework.expression/src/main/java/org/springframework/expression/spel/SpelUtilities.java +++ b/org.springframework.expression/src/main/java/org/springframework/expression/spel/SpelUtilities.java @@ -45,13 +45,10 @@ public class SpelUtilities { private static void printAST(PrintStream out, SpelNode t, String indent) { if (t != null) { StringBuffer sb = new StringBuffer(); - String s = null; - if (t.getType() == -1) - s = "EOF"; - else { - s = t.getClass().getSimpleName(); - } - sb.append(indent + s + (t.getChildCount() < 2 ? "" : " #" + t.getChildCount())); + String s = (t.getType() == -1 ? "EOF" : t.getClass().getSimpleName()); + sb.append(indent).append(s); + sb.append(" value=").append(t.getText()); + sb.append(t.getChildCount() < 2 ? "" : " children=#" + t.getChildCount()); out.println(sb.toString()); for (int i = 0; i < t.getChildCount(); i++) { printAST(out, t.getChild(i), indent + " "); diff --git a/org.springframework.expression/src/main/java/org/springframework/expression/spel/processors/AverageProcessor.java b/org.springframework.expression/src/main/java/org/springframework/expression/spel/processors/AverageProcessor.java index 796fac3623..176d0a5d9c 100644 --- a/org.springframework.expression/src/main/java/org/springframework/expression/spel/processors/AverageProcessor.java +++ b/org.springframework.expression/src/main/java/org/springframework/expression/spel/processors/AverageProcessor.java @@ -27,11 +27,13 @@ import org.springframework.expression.spel.SpelMessages; * The AverageProcessor operates upon an input collection and computes the average value of the elements within it. It * will currently only operate upon Numbers and its return value type is an Integer if the input values were integers, * otherwise it is a double. + * + * @author Andy Clement */ public class AverageProcessor implements DataProcessor { public Object process(Collection input, Object[] arguments, ExpressionState state) throws SpelException { - // TypeUtilities typeUtilities = state.getTypeUtilities(); + // TODO could support average of other types if delegated to OperatorOverloader for addition and division boolean allIntegerObjects = true; int total = 0; int numberOfElements = 0; diff --git a/org.springframework.expression/src/test/java/org/springframework/expression/common/CompositeStringExpressionTests.java b/org.springframework.expression/src/test/java/org/springframework/expression/common/CompositeStringExpressionTests.java new file mode 100644 index 0000000000..497c73da14 --- /dev/null +++ b/org.springframework.expression/src/test/java/org/springframework/expression/common/CompositeStringExpressionTests.java @@ -0,0 +1,69 @@ +/* + * 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.common; + +import junit.framework.TestCase; + +import org.springframework.expression.EvaluationContext; +import org.springframework.expression.Expression; +import org.springframework.expression.spel.SpelExpressionParser; +import org.springframework.expression.spel.standard.StandardEvaluationContext; + +/** + * Test LiteralExpression + * + * @author Andy Clement + */ +public class CompositeStringExpressionTests extends TestCase { + + public void testGetValue() throws Exception { + SpelExpressionParser parser = new SpelExpressionParser(); + Expression ex = parser.parseExpression("hello ${'world'}", DefaultTemplateParserContext.INSTANCE); + checkString("hello world", ex.getValue()); + checkString("hello world", ex.getValue(String.class)); + EvaluationContext ctx = new StandardEvaluationContext(); + checkString("hello world", ex.getValue(ctx)); + checkString("hello world", ex.getValue(ctx, String.class)); + assertEquals("hello ${'world'}", ex.getExpressionString()); + assertFalse(ex.isWritable(new StandardEvaluationContext())); + } + + // public void testSetValue() { + // try { + // LiteralExpression lEx = new LiteralExpression("somevalue"); + // lEx.setValue(new StandardEvaluationContext(), "flibble"); + // fail("Should have got an exception that the value cannot be set"); + // } catch (EvaluationException ee) { + // // success, not allowed - whilst here, check the expression value in the exception + // assertEquals(ee.getExpressionString(), "somevalue"); + // } + // } + // + // public void testGetValueType() throws Exception { + // LiteralExpression lEx = new LiteralExpression("somevalue"); + // assertEquals(String.class, lEx.getValueType()); + // assertEquals(String.class, lEx.getValueType(new StandardEvaluationContext())); + // } + + private void checkString(String expectedString, Object value) { + if (!(value instanceof String)) { + fail("Result was not a string, it was of type " + value.getClass() + " (value=" + value + ")"); + } + if (!((String) value).equals(expectedString)) { + fail("Did not get expected result. Should have been '" + expectedString + "' but was '" + value + "'"); + } + } +} diff --git a/org.springframework.expression/src/test/java/org/springframework/expression/common/LiteralExpressionTests.java b/org.springframework.expression/src/test/java/org/springframework/expression/common/LiteralExpressionTests.java new file mode 100644 index 0000000000..5844f03dc7 --- /dev/null +++ b/org.springframework.expression/src/test/java/org/springframework/expression/common/LiteralExpressionTests.java @@ -0,0 +1,67 @@ +/* + * 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.common; + +import junit.framework.TestCase; + +import org.springframework.expression.EvaluationContext; +import org.springframework.expression.EvaluationException; +import org.springframework.expression.spel.standard.StandardEvaluationContext; + +/** + * Test LiteralExpression + * + * @author Andy Clement + */ +public class LiteralExpressionTests extends TestCase { + + public void testGetValue() throws Exception { + LiteralExpression lEx = new LiteralExpression("somevalue"); + checkString("somevalue", lEx.getValue()); + checkString("somevalue", lEx.getValue(String.class)); + EvaluationContext ctx = new StandardEvaluationContext(); + checkString("somevalue", lEx.getValue(ctx)); + checkString("somevalue", lEx.getValue(ctx, String.class)); + assertEquals("somevalue", lEx.getExpressionString()); + assertFalse(lEx.isWritable(new StandardEvaluationContext())); + } + + public void testSetValue() { + try { + LiteralExpression lEx = new LiteralExpression("somevalue"); + lEx.setValue(new StandardEvaluationContext(), "flibble"); + fail("Should have got an exception that the value cannot be set"); + } catch (EvaluationException ee) { + // success, not allowed - whilst here, check the expression value in the exception + assertEquals(ee.getExpressionString(), "somevalue"); + } + } + + public void testGetValueType() throws Exception { + LiteralExpression lEx = new LiteralExpression("somevalue"); + assertEquals(String.class, lEx.getValueType()); + assertEquals(String.class, lEx.getValueType(new StandardEvaluationContext())); + } + + private void checkString(String expectedString, Object value) { + if (!(value instanceof String)) { + fail("Result was not a string, it was of type " + value.getClass() + " (value=" + value + ")"); + } + if (!((String) value).equals(expectedString)) { + fail("Did not get expected result. Should have been '" + expectedString + "' but was '" + value + "'"); + } + } +} diff --git a/org.springframework.expression/src/test/java/org/springframework/expression/spel/AllTests.java b/org.springframework.expression/src/test/java/org/springframework/expression/spel/AllTests.java index 0ad38c13ea..8c1837d7d3 100644 --- a/org.springframework.expression/src/test/java/org/springframework/expression/spel/AllTests.java +++ b/org.springframework.expression/src/test/java/org/springframework/expression/spel/AllTests.java @@ -18,6 +18,9 @@ package org.springframework.expression.spel; import junit.framework.Test; import junit.framework.TestSuite; +import org.springframework.expression.common.CompositeStringExpressionTests; +import org.springframework.expression.common.LiteralExpressionTests; + /** * Pulls together all the tests for Spring EL into a single suite. * @@ -42,9 +45,12 @@ public class AllTests { suite.addTestSuite(TypeReferencing.class); suite.addTestSuite(PerformanceTests.class); suite.addTestSuite(DefaultComparatorUnitTests.class); - suite.addTestSuite(TemplateExpressionParsing.class); + suite.addTestSuite(TemplateExpressionParsingTests.class); suite.addTestSuite(ExpressionLanguageScenarioTests.class); suite.addTestSuite(ScenariosForSpringSecurity.class); + suite.addTestSuite(SpelUtilitiesTests.class); + suite.addTestSuite(LiteralExpressionTests.class); + suite.addTestSuite(CompositeStringExpressionTests.class); // $JUnit-END$ return suite; } diff --git a/org.springframework.expression/src/test/java/org/springframework/expression/spel/BooleanExpressionTests.java b/org.springframework.expression/src/test/java/org/springframework/expression/spel/BooleanExpressionTests.java index 7aa6f9543c..5e5d51f91f 100644 --- a/org.springframework.expression/src/test/java/org/springframework/expression/spel/BooleanExpressionTests.java +++ b/org.springframework.expression/src/test/java/org/springframework/expression/spel/BooleanExpressionTests.java @@ -55,6 +55,12 @@ public class BooleanExpressionTests extends ExpressionTestCase { evaluate("true and false or false", Boolean.FALSE, Boolean.class); } + public void testWritability() { + evaluate("true and true", Boolean.TRUE, Boolean.class, false); + evaluate("true or true", Boolean.TRUE, Boolean.class, false); + evaluate("!false", Boolean.TRUE, Boolean.class, false); + } + public void testBooleanErrors01() { evaluateAndCheckError("1.0 or false", SpelMessages.TYPE_CONVERSION_ERROR, 0); evaluateAndCheckError("false or 39.4", SpelMessages.TYPE_CONVERSION_ERROR, 9); diff --git a/org.springframework.expression/src/test/java/org/springframework/expression/spel/ParsingTests.java b/org.springframework.expression/src/test/java/org/springframework/expression/spel/ParsingTests.java index e49587b8aa..74764f7a6b 100644 --- a/org.springframework.expression/src/test/java/org/springframework/expression/spel/ParsingTests.java +++ b/org.springframework.expression/src/test/java/org/springframework/expression/spel/ParsingTests.java @@ -47,6 +47,10 @@ public class ParsingTests extends TestCase { parseCheck("true"); } + public void testLiteralBoolean03() { + parseCheck("!true"); + } + public void testLiteralInteger01() { parseCheck("1"); } diff --git a/org.springframework.expression/src/test/java/org/springframework/expression/spel/SpelUtilitiesTests.java b/org.springframework.expression/src/test/java/org/springframework/expression/spel/SpelUtilitiesTests.java new file mode 100644 index 0000000000..aea8f9d4e5 --- /dev/null +++ b/org.springframework.expression/src/test/java/org/springframework/expression/spel/SpelUtilitiesTests.java @@ -0,0 +1,55 @@ +/* + * 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 java.io.ByteArrayOutputStream; +import java.io.PrintStream; + +import junit.framework.TestCase; + +/** + * Tests the SpelUtilities + * + * @author Andy Clement + */ +public class SpelUtilitiesTests extends TestCase { + + public void testPrintAbstractSyntaxTree01() throws Exception { + SpelExpression sEx = new SpelExpressionParser().parseExpression("1 + 2"); + ByteArrayOutputStream baos = new ByteArrayOutputStream(); + SpelUtilities.printAbstractSyntaxTree(new PrintStream(baos), sEx); + String theAst = baos.toString(); + System.out.println(theAst); + String[] expectedLines = new String[] { "===> Expression '1 + 2' - AST start", + "OperatorPlus value=+ children=#2", " CompoundExpression value=EXPRESSION", + " IntLiteral value=1", " CompoundExpression value=EXPRESSION", " IntLiteral value=2", + "===> Expression '1 + 2' - AST end" }; + checkExpected(theAst, expectedLines); + } + + private static void checkExpected(String theData, String[] expectedLines) { + String[] theDataSplit = theData.split("\n"); + if (theDataSplit.length != expectedLines.length) { + System.out.println("TheData:"); + System.out.println(theData); + System.out.println("ExpectedData:\n" + expectedLines); + fail("Data incorrect, expected " + expectedLines.length + " but got " + theDataSplit.length + " lines"); + } + for (int i = 0; i < expectedLines.length; i++) { + assertEquals("Failure in comparison at line " + i, expectedLines[i], theDataSplit[i]); + } + } +} diff --git a/org.springframework.expression/src/test/java/org/springframework/expression/spel/TemplateExpressionParsing.java b/org.springframework.expression/src/test/java/org/springframework/expression/spel/TemplateExpressionParsingTests.java similarity index 97% rename from org.springframework.expression/src/test/java/org/springframework/expression/spel/TemplateExpressionParsing.java rename to org.springframework.expression/src/test/java/org/springframework/expression/spel/TemplateExpressionParsingTests.java index 488e83fa37..79770ff1d2 100644 --- a/org.springframework.expression/src/test/java/org/springframework/expression/spel/TemplateExpressionParsing.java +++ b/org.springframework.expression/src/test/java/org/springframework/expression/spel/TemplateExpressionParsingTests.java @@ -23,7 +23,7 @@ import org.springframework.expression.common.DefaultTemplateParserContext; * * @author Andy Clement */ -public class TemplateExpressionParsing extends ExpressionTestCase { +public class TemplateExpressionParsingTests extends ExpressionTestCase { public void testParsingSimpleTemplateExpression01() throws Exception { SpelExpressionParser parser = new SpelExpressionParser(); diff --git a/org.springframework.expression/src/test/java/org/springframework/expression/spel/TestScenarioCreator.java b/org.springframework.expression/src/test/java/org/springframework/expression/spel/TestScenarioCreator.java index 506ac4f879..e4c5a7e3c2 100644 --- a/org.springframework.expression/src/test/java/org/springframework/expression/spel/TestScenarioCreator.java +++ b/org.springframework.expression/src/test/java/org/springframework/expression/spel/TestScenarioCreator.java @@ -61,10 +61,11 @@ 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 })); + 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) { @@ -86,8 +87,8 @@ public class TestScenarioCreator { */ private static void createTestClassloader(StandardEvaluationContext testContext) { try { - ClassLoader cl = new URLClassLoader(new URL[] { new File("target/test-classes/testcode.jar").toURI().toURL() }, - Thread.currentThread().getContextClassLoader()); + ClassLoader cl = new URLClassLoader(new URL[] { new File("target/test-classes/testcode.jar").toURI() + .toURL() }, Thread.currentThread().getContextClassLoader()); testContext.setClassLoader(cl); } catch (MalformedURLException mue) { mue.printStackTrace(); @@ -97,7 +98,7 @@ public class TestScenarioCreator { /** * Create the root context object, an Inventor instance. Non-qualified property and method references will be * resolved against this context object. - * + * * @param testContext the evaluation context in which to set the root object */ private static void setupRootContextObject(StandardEvaluationContext testContext) { @@ -113,11 +114,10 @@ public class TestScenarioCreator { /** * Create a context configuration that tests can reference into using the - * @() language construct. - * at(context:objectName) will index a particular object within a particular context. The 'root' context will be used - * for references where no context is specified, eg. + * @() language construct. at(context:objectName) will index a particular object within a particular context. The + * 'root' context will be used for references where no context is specified, eg. * @(orange). - * + * * @param testContext the evaluation context in which to register the new references */ private static void populateContextMap(StandardEvaluationContext testContext) { @@ -205,21 +205,21 @@ public class TestScenarioCreator { return backwards.toString(); } - public static String varargsFunctionReverseStringsAndMerge(String...strings) { + public static String varargsFunctionReverseStringsAndMerge(String... strings) { StringBuilder sb = new StringBuilder(); - if (strings!=null) { - for (int i=strings.length-1;i>=0;i--) { + 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) { + + 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--) { + if (strings != null) { + for (int i = strings.length - 1; i >= 0; i--) { sb.append(strings[i]); } }