Examples of org.springframework.expression.Expression

org.springframework.expression.Expression
An expression capable of evaluating itself against context objects. Encapsulates the details of a previously parsed expression string. Provides a common abstraction for expression evaluation independent of any language like OGNL or the Unified EL. @author Keith Donald @author Andy Clement @since 3.0

  }


  @Test
  public void testParsingSimpleTemplateExpression04() throws Exception {
    SpelExpressionParser parser = new SpelExpressionParser();
    Expression expr = parser.parseExpression("${'hello'} world", DEFAULT_TEMPLATE_PARSER_CONTEXT);
    Object o = expr.getValue();
    assertEquals("hello world", o.toString());


    expr = parser.parseExpression("", DEFAULT_TEMPLATE_PARSER_CONTEXT);
    o = expr.getValue();
    assertEquals("", o.toString());


    expr = parser.parseExpression("abc", DEFAULT_TEMPLATE_PARSER_CONTEXT);
    o = expr.getValue();
    assertEquals("abc", o.toString());


    expr = parser.parseExpression("abc", DEFAULT_TEMPLATE_PARSER_CONTEXT);
    o = expr.getValue((Object)null);
    assertEquals("abc", o.toString());
  }

View Full Code Here

  }


  @Test
  public void testCompositeStringExpression() throws Exception {
    SpelExpressionParser parser = new SpelExpressionParser();
    Expression ex = parser.parseExpression("hello ${'world'}", DEFAULT_TEMPLATE_PARSER_CONTEXT);
    checkString("hello world", ex.getValue());
    checkString("hello world", ex.getValue(String.class));
    checkString("hello world", ex.getValue((Object)null, String.class));
    checkString("hello world", ex.getValue(new Rooty()));
    checkString("hello world", ex.getValue(new Rooty(), String.class));


    EvaluationContext ctx = new StandardEvaluationContext();
    checkString("hello world", ex.getValue(ctx));
    checkString("hello world", ex.getValue(ctx, String.class));
    checkString("hello world", ex.getValue(ctx, null, String.class));
    checkString("hello world", ex.getValue(ctx, new Rooty()));
    checkString("hello world", ex.getValue(ctx, new Rooty(), String.class));
    checkString("hello world", ex.getValue(ctx, new Rooty(), String.class));
    assertEquals("hello ${'world'}", ex.getExpressionString());
    assertFalse(ex.isWritable(new StandardEvaluationContext()));
    assertFalse(ex.isWritable(new Rooty()));
    assertFalse(ex.isWritable(new StandardEvaluationContext(), new Rooty()));


    assertEquals(String.class,ex.getValueType());
    assertEquals(String.class,ex.getValueType(ctx));
    assertEquals(String.class,ex.getValueTypeDescriptor().getType());
    assertEquals(String.class,ex.getValueTypeDescriptor(ctx).getType());
    assertEquals(String.class,ex.getValueType(new Rooty()));
    assertEquals(String.class,ex.getValueType(ctx, new Rooty()));
    assertEquals(String.class,ex.getValueTypeDescriptor(new Rooty()).getType());
    assertEquals(String.class,ex.getValueTypeDescriptor(ctx, new Rooty()).getType());


    try {
      ex.setValue(ctx, null);
      fail();
    }
    catch (EvaluationException ee) {
      // success
    }
    try {
      ex.setValue((Object)null, null);
      fail();
    }
    catch (EvaluationException ee) {
      // success
    }
    try {
      ex.setValue(ctx, null, null);
      fail();
    }
    catch (EvaluationException ee) {
      // success
    }

View Full Code Here


  @Test
  public void testNestedExpressions() throws Exception {
    SpelExpressionParser parser = new SpelExpressionParser();
    // treat the nested ${..} as a part of the expression
    Expression ex = parser.parseExpression("hello ${listOfNumbersUpToTen.$[#this<5]} world",DEFAULT_TEMPLATE_PARSER_CONTEXT);
    String s = ex.getValue(TestScenarioCreator.getTestEvaluationContext(),String.class);
    assertEquals("hello 4 world",s);


    // not a useful expression but tests nested expression syntax that clashes with template prefix/suffix
    ex = parser.parseExpression("hello ${listOfNumbersUpToTen.$[#root.listOfNumbersUpToTen.$[#this%2==1]==3]} world",DEFAULT_TEMPLATE_PARSER_CONTEXT);
    assertEquals(CompositeStringExpression.class,ex.getClass());
    CompositeStringExpression cse = (CompositeStringExpression)ex;
    Expression[] exprs = cse.getExpressions();
    assertEquals(3,exprs.length);
    assertEquals("listOfNumbersUpToTen.$[#root.listOfNumbersUpToTen.$[#this%2==1]==3]",exprs[1].getExpressionString());
    s = ex.getValue(TestScenarioCreator.getTestEvaluationContext(),String.class);
    assertEquals("hello  world",s);


    ex = parser.parseExpression("hello ${listOfNumbersUpToTen.$[#this<5]} ${listOfNumbersUpToTen.$[#this>5]} world",DEFAULT_TEMPLATE_PARSER_CONTEXT);
    s = ex.getValue(TestScenarioCreator.getTestEvaluationContext(),String.class);
    assertEquals("hello 4 10 world",s);


    try {
      ex = parser.parseExpression("hello ${listOfNumbersUpToTen.$[#this<5]} ${listOfNumbersUpToTen.$[#this>5] world",DEFAULT_TEMPLATE_PARSER_CONTEXT);
      fail("Should have failed");

View Full Code Here


  @Test


  public void testClashingWithSuffixes() throws Exception {
    // Just wanting to use the prefix or suffix within the template:
    Expression ex = parser.parseExpression("hello ${3+4} world",DEFAULT_TEMPLATE_PARSER_CONTEXT);
    String s = ex.getValue(TestScenarioCreator.getTestEvaluationContext(),String.class);
    assertEquals("hello 7 world",s);


    ex = parser.parseExpression("hello ${3+4} wo${'${'}rld",DEFAULT_TEMPLATE_PARSER_CONTEXT);
    s = ex.getValue(TestScenarioCreator.getTestEvaluationContext(),String.class);
    assertEquals("hello 7 wo${rld",s);


    ex = parser.parseExpression("hello ${3+4} wo}rld",DEFAULT_TEMPLATE_PARSER_CONTEXT);
    s = ex.getValue(TestScenarioCreator.getTestEvaluationContext(),String.class);
    assertEquals("hello 7 wo}rld",s);
  }

View Full Code Here

    assertEquals("hello 7 wo}rld",s);
  }


  @Test
  public void testParsingNormalExpressionThroughTemplateParser() throws Exception {
    Expression expr = parser.parseExpression("1+2+3");
    assertEquals(6,expr.getValue());
    expr = parser.parseExpression("1+2+3",null);
    assertEquals(6,expr.getValue());
  }

View Full Code Here

    assertFalse((Boolean)expression.getValue(b));
  }
  
  @Test
  public void opAnd() throws Exception {
    Expression expression = parser.parseExpression("false and false");
    boolean resultI = expression.getValue(1,Boolean.TYPE);
    SpelCompiler.compile(expression);
    boolean resultC = expression.getValue(1,Boolean.TYPE);
    assertEquals(false,resultI);
    assertEquals(false,resultC);


    expression = parser.parseExpression("false and true");
    resultI = expression.getValue(1,Boolean.TYPE);
    SpelCompiler.compile(expression);
    resultC = expression.getValue(1,Boolean.TYPE);
    assertEquals(false,resultI);
    assertEquals(false,resultC);
    
    expression = parser.parseExpression("true and false");
    resultI = expression.getValue(1,Boolean.TYPE);
    SpelCompiler.compile(expression);
    resultC = expression.getValue(1,Boolean.TYPE);
    assertEquals(false,resultI);
    assertEquals(false,resultC);


    expression = parser.parseExpression("true and true");
    resultI = expression.getValue(1,Boolean.TYPE);
    SpelCompiler.compile(expression);
    resultC = expression.getValue(1,Boolean.TYPE);
    assertEquals(true,resultI);
    assertEquals(true,resultC);
    
    TestClass4 tc = new TestClass4();


    // Can't compile this as we aren't going down the gettrue() branch in our evaluation
    expression = parser.parseExpression("getfalse() and gettrue()");
    resultI = expression.getValue(tc,Boolean.TYPE);
    assertCantCompile(expression);
    
    expression = parser.parseExpression("getA() and getB()");
    tc.a = false;
    tc.b = false;
    resultI = expression.getValue(tc,Boolean.TYPE);
    assertCantCompile(expression); // Haven't yet been into second branch
    tc.a = true;
    tc.b = false;
    resultI = expression.getValue(tc,Boolean.TYPE);
    assertCanCompile(expression); // Now been down both
    assertFalse(resultI);
    tc.a = true;
    tc.b = true;
    resultI = expression.getValue(tc,Boolean.TYPE);
    assertTrue(resultI);
    
    boolean b = true;
    expression = parse("#root and #root");
    Object resultI2 = expression.getValue(b);
    assertCanCompile(expression);
    assertTrue((Boolean)resultI2);
    assertTrue((Boolean)expression.getValue(b));
  }

View Full Code Here

    assertEquals(true,expression.getValue(b));
  }


  @Test
  public void ternary() throws Exception {
    Expression expression = parser.parseExpression("true?'a':'b'");
    String resultI = expression.getValue(String.class);
    assertCanCompile(expression);
    String resultC = expression.getValue(String.class);
    assertEquals("a",resultI);
    assertEquals("a",resultC);
    
    expression = parser.parseExpression("false?'a':'b'");
    resultI = expression.getValue(String.class);
    assertCanCompile(expression);
    resultC = expression.getValue(String.class);
    assertEquals("b",resultI);
    assertEquals("b",resultC);


    expression = parser.parseExpression("false?1:'b'");
    // All literals so we can do this straight away
    assertCanCompile(expression);
    assertEquals("b",expression.getValue());


    boolean root = true;
    expression = parser.parseExpression("(#root and true)?T(Integer).valueOf(1):T(Long).valueOf(3L)");
    assertEquals(1,expression.getValue(root));
    assertCantCompile(expression); // Have not gone down false branch
    root = false;
    assertEquals(3L,expression.getValue(root));
    assertCanCompile(expression);
    assertEquals(3L,expression.getValue(root));
    root = true;
    assertEquals(1,expression.getValue(root));    
  }

View Full Code Here

    assertEquals("def",expression.getValue());
  }
  
  @Test
  public void elvis() throws Exception {
    Expression expression = parser.parseExpression("'a'?:'b'");
    String resultI = expression.getValue(String.class);
    assertCanCompile(expression);
    String resultC = expression.getValue(String.class);
    assertEquals("a",resultI);
    assertEquals("a",resultC);
    
    expression = parser.parseExpression("null?:'a'");
    resultI = expression.getValue(String.class);
    assertCanCompile(expression);
    resultC = expression.getValue(String.class);
    assertEquals("a",resultI);
    assertEquals("a",resultC);
    
    String s = "abc";
    expression = parser.parseExpression("#root?:'b'");
    assertCantCompile(expression);
    resultI = expression.getValue(s,String.class);
    assertEquals("abc",resultI);
    assertCanCompile(expression);
  }

View Full Code Here

  }
  
  @Test
  public void variableReference_root() throws Exception {
    String s = "hello";
    Expression expression = parser.parseExpression("#root");
    String resultI = expression.getValue(s,String.class);
    assertCanCompile(expression);
    String resultC = expression.getValue(s,String.class);
    assertEquals(s,resultI);
    assertEquals(s,resultC);    


    expression = parser.parseExpression("#root");
    int i = (Integer)expression.getValue(42);
    assertEquals(42,i);
    assertCanCompile(expression);
    i = (Integer)expression.getValue(42);
    assertEquals(42,i);
  }

View Full Code Here

    assertCantCompile(expression);
    expression.getValue(tc);
    assertEquals("123",tc.s);
    assertCantCompile(expression); // Uncompilable as argument conversion is occurring
    
    Expression expression = parser.parseExpression("'abcd'.substring(index1,index2)");
    String resultI = expression.getValue(new TestClass1(),String.class);
    assertCanCompile(expression);
    String resultC = expression.getValue(new TestClass1(),String.class);
    assertEquals("bc",resultI);
    assertEquals("bc",resultC);
    
    // Converting from an int to a Number
    expression = parser.parseExpression("takeNumber(123)");
    assertCantCompile(expression);
    expression.getValue(tc);
    assertEquals("123",tc.s);
    tc.reset();
    assertCanCompile(expression); // The generated code should include boxing of the int to a Number
    expression.getValue(tc);
    assertEquals("123",tc.s);


    // Passing a subtype
    expression = parser.parseExpression("takeNumber(T(Integer).valueOf(42))");
    assertCantCompile(expression);
    expression.getValue(tc);
    assertEquals("42",tc.s);
    tc.reset();
    assertCanCompile(expression); // The generated code should include boxing of the int to a Number
    expression.getValue(tc);
    assertEquals("42",tc.s);


    // Passing a subtype
    expression = parser.parseExpression("takeString(T(Integer).valueOf(42))");
    assertCantCompile(expression);
    expression.getValue(tc);
    assertEquals("42",tc.s);
    tc.reset();
    assertCantCompile(expression); // method takes a string and we are passing an Integer
  }

View Full Code Here

0 1 2 3 4 5 6 7 8 9

TOP

Related Classes of org.springframework.expression.Expression

com.apress.pss.webflow.security.StateExpressionVoter

com.foreach.cuke.core.util.MapChecker

com.github.overengineer.scope.conversation.expression.eval.Spel

com.narirelays.ems.applogic.PrivilegeManagement

com.narirelays.ems.applogic.SpreadsheetManagement

com.narirelays.ems.struts2.actions.security.AccountManagement

com.ontology2.haruhi.flows.AssignmentStep

com.ontology2.haruhi.flows.SpringStep

grails.plugin.cache.web.filter.ExpressionEvaluator

net.gprussell.spel.ArgumentConversionTest

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.