Spring/spring-webflow
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

separated out the concept of a template

Browse Source 
normalized EL and OGNL to respect this concept
This commit is contained in:
Keith Donald
2008-03-06 21:52:51 +00:00
parent 82b6709a71
commit eba8741a2b
10 changed files with 195 additions and 177 deletions
Download Patch File Download Diff File Expand all files Collapse all files

46
spring-binding/src/test/java/org/springframework/binding/expression/el/ELExpressionParserTests.java
View File

@@ -14,6 +14,7 @@ import junit.framework.TestCase;
import org.jboss.el.ExpressionFactoryImpl;
import org.springframework.binding.expression.Expression;
import org.springframework.binding.expression.ExpressionVariable;
import org.springframework.binding.expression.ParserException;
import org.springframework.binding.expression.support.ParserContextImpl;
public class ELExpressionParserTests extends TestCase {
@@ -25,7 +26,7 @@ public class ELExpressionParserTests extends TestCase {
}
public void testParseSimpleEvalExpressionNoParserContext() {
String expressionString = "#{3 + 4}";
String expressionString = "3 + 4";
Expression exp = parser.parseExpression(expressionString, null);
assertEquals(new Long(7), exp.getValue(null));
}
@@ -42,71 +43,68 @@ public class ELExpressionParserTests extends TestCase {
public void testParseEmptyExpressionString() {
String expressionString = "";
Expression exp = parser.parseExpression(expressionString, null);
assertEquals("", exp.getValue(null));
try {
parser.parseExpression(expressionString, null);
fail("Should have failed");
} catch (ParserException e) {
}
}
public void testParseSimpleEvalExpressionNoEvalContextWithTypeCoersion() {
String expressionString = "#{3 + 4}";
String expressionString = "3 + 4";
Expression exp = parser.parseExpression(expressionString, new ParserContextImpl().expect(Integer.class));
assertEquals(new Integer(7), exp.getValue(null));
}
public void testParseBeanEvalExpressionNoParserContext() {
String expressionString = "#{value}";
String expressionString = "value";
Expression exp = parser.parseExpression(expressionString, null);
assertEquals("foo", exp.getValue(new TestBean()));
}
public void testParseEvalExpressionWithContextTypeCoersion() {
String expressionString = "#{maximum}";
String expressionString = "maximum";
Expression exp = parser.parseExpression(expressionString, new ParserContextImpl().expect(Long.class));
assertEquals(new Long(2), exp.getValue(new TestBean()));
}
public void testParseEvalExpressionWithContextCustomTestBeanResolver() {
String expressionString = "#{specialProperty}";
String expressionString = "specialProperty";
Expression exp = parser.parseExpression(expressionString, new ParserContextImpl().eval(TestBean.class));
assertEquals("Custom resolver resolved this special property!", exp.getValue(new TestBean()));
}
public void testParseLiteralExpression() {
String expressionString = "value";
String expressionString = "'value'";
Expression exp = parser.parseExpression(expressionString, null);
assertEquals("value", exp.getValue(null));
}
public void testParseExpressionWithVariables() {
public void testParseTemplateExpressionWithVariables() {
String expressionString = "#{value}#{max}";
Expression exp = parser.parseExpression(expressionString, new ParserContextImpl()
.variable(new ExpressionVariable("max", "#{maximum}")));
Expression exp = parser.parseExpression(expressionString, new ParserContextImpl().template().variable(
new ExpressionVariable("max", "maximum")));
TestBean target = new TestBean();
assertEquals("foo2", exp.getValue(target));
}
public void testVariablesWithCoersion() {
String expressionString = "#{max}";
Expression exp = parser.parseExpression(expressionString, new ParserContextImpl()
.variable(new ExpressionVariable("max", "#{maximum}", new ParserContextImpl().expect(Long.class))));
Expression exp = parser.parseExpression("max", new ParserContextImpl().variable(new ExpressionVariable("max",
"maximum", new ParserContextImpl().expect(Long.class))));
TestBean target = new TestBean();
assertEquals(new Long(2), exp.getValue(target));
}
public void testNestedVariables() {
public void testTemplateNestedVariables() {
String expressionString = "#{value}#{max}";
Expression exp = parser.parseExpression(expressionString, new ParserContextImpl()
.variable(new ExpressionVariable("max", "#{maximum}#{var}", new ParserContextImpl()
.variable(new ExpressionVariable("var", "bar")))));
Expression exp = parser.parseExpression(expressionString, new ParserContextImpl().template().variable(
new ExpressionVariable("max", "#{maximum}#{var}", new ParserContextImpl().template().variable(
new ExpressionVariable("var", "'bar'")))));
TestBean target = new TestBean();
assertEquals("foo2bar", exp.getValue(target));
}
public void testParseImmediateEvalExpression() {
String expressionString = "${3 + 4}";
Expression exp = parser.parseExpression(expressionString, null);
assertEquals(new Long(7), exp.getValue(null));
}
public static class TestBean {
private String value = "foo";

110
spring-binding/src/test/java/org/springframework/binding/expression/ognl/OgnlExpressionParserTests.java
View File

@@ -29,6 +29,15 @@ public class OgnlExpressionParserTests extends TestCase {
private TestBean bean = new TestBean();
public void testParseSimple() {
String exp = "flag";
Expression e = parser.parseExpression(exp, null);
assertNotNull(e);
Boolean b = (Boolean) e.getValue(bean);
assertFalse(b.booleanValue());
}
public void testParseSimpleAllowDelimited() {
parser.setAllowDelimitedEvalExpressions(true);
String exp = "${flag}";
Expression e = parser.parseExpression(exp, null);
assertNotNull(e);
@@ -36,77 +45,40 @@ public class OgnlExpressionParserTests extends TestCase {
assertFalse(b.booleanValue());
}
public void testIsTemplateExpressionAllowUndelimitedOgnlExpressions() {
String exp = "some literal text";
String exp2 = "${a delimited expression}";
String exp3 = "${a malformed delimited expression";
String exp4 = "a malformed delimited expression}";
String exp5 = "${}";
String exp6 = "a ${composite} expression";
String exp7 = "a ${composite} ${malformed expression";
assertTrue(parser.isTemplateExpression(exp));
assertTrue(parser.isTemplateExpression(exp2));
assertTrue(parser.isTemplateExpression(exp3));
assertTrue(parser.isTemplateExpression(exp4));
assertTrue(parser.isTemplateExpression(exp5));
assertTrue(parser.isTemplateExpression(exp6));
assertTrue(parser.isTemplateExpression(exp7));
public void testParseSimpleDelimitedNotAllowed() {
String exp = "${flag}";
try {
parser.parseExpression(exp, null);
fail("should have failed");
} catch (ParserException e) {
}
}
public void testIsTemplateExpressionDoNotAllowUndelimitedOgnlExpressions() {
parser.setAllowUndelimitedEvalExpressions(true);
String exp = "some literal text";
String exp2 = "${a delimited expression}";
String exp3 = "${a malformed delimited expression";
String exp4 = "a malformed delimited expression}";
String exp5 = "${}";
String exp6 = "a ${composite} expression";
String exp7 = "a ${composite} ${malformed expression";
assertFalse(parser.isTemplateExpression(exp));
assertTrue(parser.isTemplateExpression(exp2));
assertFalse(parser.isTemplateExpression(exp3));
assertFalse(parser.isTemplateExpression(exp4));
assertFalse(parser.isTemplateExpression(exp5));
assertTrue(parser.isTemplateExpression(exp6));
assertTrue(parser.isTemplateExpression(exp7));
}
public void testParseSimpleNotDelimitedAllowUndelimited() {
parser.setAllowUndelimitedEvalExpressions(true);
public void testParseTemplateSimpleLiteral() {
String exp = "flag";
Expression e = parser.parseExpression(exp, null);
assertNotNull(e);
Boolean b = (Boolean) e.getValue(bean);
assertFalse(b.booleanValue());
}
public void testParseSimpleLiteral() {
String exp = "flag";
Expression e = parser.parseExpression(exp, null);
Expression e = parser.parseExpression(exp, new ParserContextImpl().template());
assertNotNull(e);
assertEquals("flag", e.getValue(bean));
}
public void testParseEmpty() {
Expression e = parser.parseExpression("", null);
public void testParseTemplateEmpty() {
Expression e = parser.parseExpression("", new ParserContextImpl().template());
assertNotNull(e);
assertEquals("", e.getValue(bean));
}
public void testParseComposite() {
public void testParseTemplateComposite() {
String exp = "hello ${flag} ${flag} ${flag}";
assertTrue(parser.isTemplateExpression(exp));
Expression e = parser.parseExpression(exp, null);
Expression e = parser.parseExpression(exp, new ParserContextImpl().template());
assertNotNull(e);
String str = (String) e.getValue(bean);
assertEquals("hello false false false", str);
}
public void testEnclosedCompositeNotSupported() {
public void testTemplateEnclosedCompositeNotSupported() {
String exp = "${hello ${flag} ${flag} ${flag}}";
try {
parser.parseExpression(exp, null);
parser.parseExpression(exp, new ParserContextImpl().template());
fail("Should've failed - not intended use");
} catch (ParserException e) {
}
@@ -114,7 +86,7 @@ public class OgnlExpressionParserTests extends TestCase {
public void testSyntaxError1() {
try {
parser.parseExpression("${", null);
parser.parseExpression("${", new ParserContextImpl().template());
fail();
} catch (ParserException e) {
}
@@ -128,7 +100,7 @@ public class OgnlExpressionParserTests extends TestCase {
public void testSyntaxError2() {
try {
parser.parseExpression("${}", null);
parser.parseExpression("${}", new ParserContextImpl().template());
fail("Should've failed - not intended use");
} catch (ParserException e) {
}
@@ -143,41 +115,41 @@ public class OgnlExpressionParserTests extends TestCase {
public void testCollectionConstructionSyntax() {
// lists
parser.parseExpression("name in {null, \"Untitled\"}", null);
parser.parseExpression("${name in {null, \"Untitled\"}}", null);
parser.parseExpression("${name in {null, \"Untitled\"}}", new ParserContextImpl().template());
// native arrays
parser.parseExpression("new int[] {1, 2, 3}", null);
parser.parseExpression("${new int[] {1, 2, 3}}", null);
parser.parseExpression("${new int[] {1, 2, 3}}", new ParserContextImpl().template());
// maps
parser.parseExpression("#{ 'foo' : 'foo value', 'bar' : 'bar value' }", null);
parser.parseExpression("${#{ 'foo' : 'foo value', 'bar' : 'bar value' }}", null);
parser.parseExpression("${#{ 'foo' : 'foo value', 'bar' : 'bar value' }}", new ParserContextImpl().template());
parser.parseExpression("#@java.util.LinkedHashMap@{ 'foo' : 'foo value', 'bar' : 'bar value' }", null);
parser.parseExpression("${#@java.util.LinkedHashMap@{ 'foo' : 'foo value', 'bar' : 'bar value' }}", null);
parser.parseExpression("${#@java.util.LinkedHashMap@{ 'foo' : 'foo value', 'bar' : 'bar value' }}",
new ParserContextImpl().template());
// complex examples
parser.parseExpression("b,#{1:2}", null);
parser.parseExpression("${b,#{1:2}}", null);
parser.parseExpression("a${b,#{1:2},e}f${g,#{3:4},j}k", null);
parser.parseExpression("${b,#{1:2}}", new ParserContextImpl().template());
parser.parseExpression("a${b,#{1:2},e}f${g,#{3:4},j}k", new ParserContextImpl().template());
}
public void testVariables() {
Expression exp = parser.parseExpression("${#var}", new ParserContextImpl().variable(new ExpressionVariable(
"var", "${flag}")));
Expression exp = parser.parseExpression("#var", new ParserContextImpl().variable(new ExpressionVariable("var",
"flag")));
assertEquals(false, ((Boolean) exp.getValue(bean)).booleanValue());
}
public void testVariablesWithCoersion() {
Expression exp = parser.parseExpression("${#var}", new ParserContextImpl().variable(new ExpressionVariable(
"var", "${number}", new ParserContextImpl().expect(Long.class))));
Expression exp = parser.parseExpression("#var", new ParserContextImpl().variable(new ExpressionVariable("var",
"number", new ParserContextImpl().expect(Long.class))));
assertEquals(new Long(0), exp.getValue(bean));
}
public void testNestedVariables() {
Expression exp = parser
.parseExpression("${#var}", new ParserContextImpl()
.variable(new ExpressionVariable("var", "${flag}${#var}", new ParserContextImpl()
.variable(new ExpressionVariable("var", "${number}")))));
public void testNestedVariablesWithTemplates() {
Expression exp = parser.parseExpression("#var", new ParserContextImpl()
.variable(new ExpressionVariable("var", "${flag}${#var}", new ParserContextImpl().template().variable(
new ExpressionVariable("var", "number")))));
assertEquals("false0", exp.getValue(bean));
}

6
spring-binding/src/test/java/org/springframework/binding/mapping/RequiredMappingTests.java
View File

@@ -28,7 +28,7 @@ public class RequiredMappingTests extends TestCase {
public void testRequired() {
MappingBuilder builder = new MappingBuilder(new OgnlExpressionParser());
Mapping mapping = builder.source("${foo}").target("${bar}").required().value();
Mapping mapping = builder.source("foo").target("bar").required().value();
HashMap source = new HashMap();
source.put("foo", "baz");
HashMap target = new HashMap();
@@ -38,7 +38,7 @@ public class RequiredMappingTests extends TestCase {
public void testRequiredExceptionOnNull() {
MappingBuilder builder = new MappingBuilder(new OgnlExpressionParser());
Mapping mapping = builder.source("${foo}").target("${bar}").required().value();
Mapping mapping = builder.source("foo").target("bar").required().value();
HashMap source = new HashMap();
source.put("foo", null);
HashMap target = new HashMap();
@@ -50,7 +50,7 @@ public class RequiredMappingTests extends TestCase {
public void testRequiredExceptionOnNoKey() {
MappingBuilder builder = new MappingBuilder(new OgnlExpressionParser());
Mapping mapping = builder.source("${foo}").target("${bar}").required().value();
Mapping mapping = builder.source("foo").target("bar").required().value();
HashMap source = new HashMap();
HashMap target = new HashMap();
try {