public void testJIRA165b() {
OptimizerFactory.setDefaultOptimizer("ASM");
A b = new B();
A a = new A();
ParserContext context = new ParserContext();
Object expression = MVEL.compileExpression("a.bar(value)", context);
for (int i = 0; i < 100; i++) {
System.out.println("i: " + i);
System.out.flush();
{
Map<String, Object> variables = new HashMap<String, Object>();
variables.put("a", b);
variables.put("value", 123);
executeExpression(expression, variables);
}
{
Map<String, Object> variables = new HashMap<String, Object>();
variables.put("a", a);
variables.put("value", 123);
executeExpression(expression, variables);
}
}
}
public void testMapAsContextWithStrictTyping() {
ExpressionCompiler compiler = new ExpressionCompiler("this['KEY1'] == $msg");
ParserContext ctx = new ParserContext();
ctx.setStrictTypeEnforcement(true);
ctx.setStrongTyping(true);
ctx.addInput("$msg", String.class);
ctx.addInput("this", Map.class);
Serializable expr = compiler.compile(ctx);
Map map = new HashMap();
map.put("KEY1", "MSGONE");
Map vars = new HashMap();
vars.put("$msg", "MSGONE");
Boolean bool = (Boolean) executeExpression(expr, map, vars);
assertEquals(Boolean.TRUE, bool);
}
public void testForLoopTypeCoercion() {
ParserContext pCtx = ParserContext.create();
pCtx.setStrongTyping(true);
pCtx.addInput("$type", String.class);
pCtx.addInput("l", List.class);
Map<String, Object> vars = new HashMap<String, Object>();
vars.put("$type", "pc!!");
List list = new ArrayList();
vars.put("l", list);
ExecutableStatement stmt =
(ExecutableStatement)
MVEL.compileExpression("for (byte bt:$type.getBytes()) {l.add( bt);}", pCtx);
MVEL.executeExpression(stmt, null, vars);
byte[] exp = "pc!!".getBytes();
// byte[] res = new byte[list.size()];
for (int i = 0; i < exp.length; i++) {
assertEquals(exp[i], list.get(i));
}
}
public void testPrimitiveTypes() {
ParserContext ctx = new ParserContext();
ctx.setStrongTyping(true);
ctx.addInput("base", Base.class);
Serializable s = compileExpression("int x = 5; x = x + base.intValue; x", ctx);
Map vars = new HashMap();
vars.put("base", new Base());
Number x = (Number) executeExpression(s, vars);
assertEquals(15, x.intValue());
}
public void testMapPropertyAccess() {
ParserContext ctx = new ParserContext();
ctx.addImport(MapWrapper.class);
ctx.addInput("wrapper", MapWrapper.class);
ctx.setStrongTyping(true);
Serializable expr = MVEL.compileExpression("wrapper.map[\"key\"]", ctx);
MapWrapper wrapper = new MapWrapper();
wrapper.getMap().put("key", "value");
Map vars = new HashMap();
vars.put("wrapper", wrapper);
assertEquals("value", MVEL.executeExpression(expr, vars));
}
public void testStrictTypingCompilationWithVarInsideConstructor() {
ParserContext ctx = new ParserContext();
ctx.addInput("$likes", String.class);
ctx.addInput("results", List.class);
ctx.addImport(Cheese.class);
ctx.setStrongTyping(true);
Serializable expr = null;
try {
expr =
MVEL.compileExpression("Cheese c = new Cheese( $likes, 15 );\nresults.add( c ); ", ctx);
} catch (CompileException e) {
e.printStackTrace();
fail("This should not fail:\n" + e.getMessage());
}
List results = new ArrayList();
Map vars = new HashMap();
vars.put("$likes", "stilton");
vars.put("results", results);
executeExpression(expr, vars);
assertEquals(new Cheese("stilton", 15), results.get(0));
}
public void testTypeCast3() {
Map map = new HashMap();
map.put("foo", new Foo());
ParserContext pCtx = new ParserContext();
pCtx.setStrongTyping(true);
pCtx.addInput("foo", Foo.class);
Serializable s =
MVEL.compileExpression("((org.mvel2.tests.core.res.Bar) foo.getBar()).name != null", pCtx);
assertEquals(true, executeExpression(s, map));
assertEquals(1, pCtx.getInputs().size());
assertEquals(true, pCtx.getInputs().containsKey("foo"));
}
public void testAutoBoxing2() {
ParserContext ctx = new ParserContext();
ctx.setStrongTyping(true);
ctx.addInput("base", Base.class);
Serializable s =
compileExpression(
"java.util.List list = new java.util.ArrayList(); " + "list.add( base.intValue ); list",
ctx);
Map vars = new HashMap();
vars.put("base", new Base());
List list = (List) executeExpression(s, vars);
assertEquals(1, list.size());
}
public void testGenericMethods() {
String str = "Integer.parseInt( a.getMap().get(\"x\") )";
ParserConfiguration pconf = new ParserConfiguration();
ParserContext pctx = new ParserContext(pconf);
pctx.setStrongTyping(true);
pctx.addInput("a", AGenericTestClass.class);
ExecutableStatement stmt = (ExecutableStatement) MVEL.compileExpression(str, pctx);
AGenericTestClass a = new AGenericTestClass();
a.setMap(new HashMap<String, String>());
a.getMap().put("x", "10");
Map<String, Object> variables = new HashMap<String, Object>();
variables.put("a", a);
Number result = (Number) MVEL.executeExpression(stmt, null, variables);
assertEquals(10, result.intValue());
}
public void testTypeCoercion2() {
OptimizerFactory.setDefaultOptimizer("reflective");
ParserContext ctx = new ParserContext();
ctx.setStrongTyping(true);
ctx.addInput("base", Base.class);
Serializable s =
compileExpression(
"java.math.BigInteger x = new java.math.BigInteger( \"5\" );" + " x + base.intValue;",
ctx);
Map vars = new HashMap();
vars.put("base", new Base());
Number x = (Number) executeExpression(s, vars);
assertEquals(15, x.intValue());
}
public void testGenericInference() {
String expression = "$result = person.footributes[0].name";
ParserContext ctx;
MVEL.analysisCompile(
expression, ctx = ParserContext.create().stronglyTyped().withInput("person", Person.class));
assertEquals(String.class, ctx.getVarOrInputTypeOrNull("$result"));
Serializable s =
MVEL.compileExpression(
expression, ParserContext.create().stronglyTyped().withInput("person", Person.class));
Map<String, Object> vars = new HashMap<String, Object>();
Person p = new Person();
p.setFootributes(new ArrayList<Foo>());
p.getFootributes().add(new Foo());
vars.put("person", p);
assertEquals("dog", executeExpression(s, vars));
}