public void testContextMethodCallsInStrongMode() {
ParserContext context = new ParserContext();
context.setStrongTyping(true);
context.addInput("this", EchoContext.class);
ExecutableStatement stmt =
(ExecutableStatement) MVEL.compileExpression("this.echo( 'Mac')", context);
stmt = (ExecutableStatement) MVEL.compileExpression("echo( 'Mac')", context);
assertEquals("Mac", MVEL.executeExpression(stmt, new EchoContext()));
}
public void testEgressTypeCorrect2() {
ParserContext context = new ParserContext();
context.setStrongTyping(true);
context.addInput("this", SampleBean.class);
ExecutableStatement stmt =
(ExecutableStatement) MVEL.compileExpression("( map2[ 'yyy' ] )", context);
SampleBean s = new SampleBean();
s.getMap2().put("yyy", 1);
assertEquals(new Integer(1), MVEL.executeExpression(stmt, s));
}
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 testGenerics1() {
String str =
"addresses[0] == new Address(\"s1\") && addresses[0].street == new Address(\"s1\").street";
ParserConfiguration pconf = new ParserConfiguration();
ParserContext pctx = new ParserContext(pconf);
pctx.setStrongTyping(true);
pctx.addInput("this", PersonAddresses.class);
pctx.addImport(Address.class);
pctx.addImport(PersonAddresses.class);
ExecutableStatement stmt = (ExecutableStatement) MVEL.compileExpression(str, pctx);
PersonAddresses ctx = new PersonAddresses();
ctx.getAddresses().add(new Address("s1"));
Boolean result = (Boolean) MVEL.executeExpression(stmt, ctx);
assertTrue(result);
}
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 testStaticTyping2() {
String exp = "int x = 5; int y = 2; new int[] { x, y }";
int[] res = (int[]) MVEL.eval(exp, new HashMap());
assertEquals(5, res[0]);
assertEquals(2, res[1]);
}
public void testEgressTypeCorrect() {
ExecutableStatement stmt =
(ExecutableStatement)
MVEL.compileExpression(
"type", ParserContext.create().stronglyTyped().withInput("this", Cheese.class));
assertEquals(String.class, stmt.getKnownEgressType());
}
public void testMVEL232() {
ParserContext ctx = new ParserContext();
ctx.setStrongTyping(true);
ctx.setStrictTypeEnforcement(true);
String script =
"for(int i=0;i<2;i++) { " + " System.out.println(i+\"\");" + "} " + " return true;";
try {
CompiledExpression compiled = (CompiledExpression) MVEL.compileExpression(script, ctx);
HashMap<String, Object> map = new HashMap<String, Object>();
MVEL.executeExpression(compiled, map);
} catch (Exception e) {
e.printStackTrace();
fail("should now throw an exception");
}
}
public void testTypeCalculation() {
ParserContext ctx = ParserContext.create().stronglyTyped();
ctx.addInput("foo", Foo.class);
Class cls = MVEL.analyze("foo.bar.testList.get(0)", ctx);
assertTrue(Integer.class.isAssignableFrom(cls));
}
public void testGenericInference2() {
ParserContext ctx;
MVEL.analysisCompile(
"$result = person.maptributes['fooey'].name",
ctx = ParserContext.create().stronglyTyped().withInput("person", Person.class));
assertEquals(String.class, ctx.getVarOrInputTypeOrNull("$result"));
}
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 testStaticFieldAccessForInputsWithStrictStrong() {
ParserContext pCtx = ParserContext.create();
pCtx.setStrictTypeEnforcement(true);
pCtx.setStrongTyping(true);
MVEL.analysisCompile("java.math.BigDecimal.TEN", pCtx);
assertFalse(pCtx.getInputs().containsKey("java"));
assertEquals(0, pCtx.getInputs().size());
MVEL.COMPILER_OPT_ALLOW_NAKED_METH_CALL = true;
pCtx = ParserContext.create();
pCtx.setStrictTypeEnforcement(true);
pCtx.setStrongTyping(true);
MVEL.analysisCompile("java.math.BigDecimal.TEN", pCtx);
assertFalse(pCtx.getInputs().containsKey("java"));
assertEquals(0, pCtx.getInputs().size());
}
public void testAnalyzer() {
ParserContext ctx = new ParserContext();
MVEL.compileExpression("order.id == 10", ctx);
for (String input : ctx.getInputs().keySet()) {
System.out.println("input>" + input);
}
assertEquals(1, ctx.getInputs().size());
assertTrue(ctx.getInputs().containsKey("order"));
}
public void testStaticMethodsInInputsBug() {
String text = " getList( java.util.Formatter )";
ParserConfiguration pconf = new ParserConfiguration();
for (Method m : CoreConfidenceTests.StaticMethods.class.getMethods()) {
if (Modifier.isStatic(m.getModifiers())) {
pconf.addImport(m.getName(), m);
}
}
ParserContext pctx = new ParserContext(pconf);
pctx.setStrictTypeEnforcement(false);
pctx.setStrongTyping(false);
Map<String, Object> vars = new HashMap<String, Object>();
Serializable expr = MVEL.compileExpression(text, pctx);
List list = (List) MVEL.executeExpression(expr, null, vars);
assertEquals(Formatter.class, list.get(0));
assertEquals(0, pctx.getInputs().size());
}
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 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));
}
public void testGetCorrectInputs() {
String str = "total = total + $cheese.price";
ParserConfiguration pconf = new ParserConfiguration();
ParserContext pctx = new ParserContext(pconf);
pctx.setStrongTyping(true);
pctx.addInput("total", int.class);
pctx.addInput("$cheese", Cheese.class);
ExecutableStatement stmt = (ExecutableStatement) MVEL.compileExpression(str, pctx);
assertTrue("Should not contain" + pctx.getVariables(), pctx.getVariables().isEmpty());
}
public void testStaticMethodCallThrowsException() {
String text = " ( throwException( ) ) ";
ParserConfiguration pconf = new ParserConfiguration();
for (Method m : CoreConfidenceTests.StaticMethods.class.getMethods()) {
if (Modifier.isStatic(m.getModifiers())) {
pconf.addImport(m.getName(), m);
}
}
ParserContext pctx = new ParserContext(pconf);
pctx.setStrictTypeEnforcement(true);
pctx.setStrongTyping(true);
Map<String, Object> vars = new HashMap<String, Object>();
Serializable expr = MVEL.compileExpression(text, pctx);
try {
MVEL.executeExpression(expr);
fail("this should throw an exception");
} catch (Exception e) {
e.printStackTrace();
}
}
public void testStrictStrongTypingCompilationErrors2() throws Exception {
ParserContext ctx = new ParserContext();
ctx.setStrictTypeEnforcement(true);
ctx.setStrongTyping(true);
ctx.addImport(Foo.class);
ctx.addInput("$bar", Bar.class);
try {
MVEL.compileExpression("x_a = new Foo244( $ba ); x_a.equals($ba);", ctx);
fail("This should not compileShared");
} catch (Exception e) {
e.printStackTrace();
}
}
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 testVarInputs5() {
ParserContext pCtx = ParserContext.create().withInput("list", List.class);
MVEL.analysisCompile(
"String nodeName = list[0];\nSystem.out.println(nodeName);nodeName = list[1];\nSystem.out.println(nodeName);",
pCtx);
assertEquals(1, pCtx.getInputs().size());
assertTrue(pCtx.getInputs().containsKey("list"));
assertEquals(1, pCtx.getVariables().size());
assertTrue(pCtx.getVariables().containsKey("nodeName"));
assertEquals(List.class, pCtx.getVarOrInputType("list"));
assertEquals(String.class, pCtx.getVarOrInputType("nodeName"));
}
public void testMVEL236() {
StringBuffer buffer = new StringBuffer();
buffer.append("MyInterface2 var2 = (MyInterface2)var1;");
ParserContext ctx = new ParserContext();
ctx.setStrongTyping(true);
ctx.addInput("var1", MyInterface3.class);
ctx.addImport(MyInterface2.class);
ctx.addImport(MyInterface3.class);
try {
CompiledExpression compiled =
(CompiledExpression) MVEL.compileExpression(buffer.toString(), ctx);
} catch (Exception e) {
fail(e.getMessage());
}
}
public void testMVEL235() {
StringBuffer buffer = new StringBuffer();
buffer.append("if(var1.equals(var2)) {");
buffer.append("return true;");
buffer.append("}");
ParserContext ctx = new ParserContext();
ctx.setStrongTyping(true);
ctx.addInput("var1", MyInterface2.class);
ctx.addInput("var2", MyInterface2.class);
try {
Serializable compiled = (Serializable) MVEL.compileExpression(buffer.toString(), ctx);
System.out.println(compiled);
} catch (Exception e) {
fail(e.getMessage());
}
}
public void testMVEL228() {
ParserContext ctx = new ParserContext();
ctx.setStrongTyping(true);
ctx.setStrictTypeEnforcement(true);
HashMap<String, Class> params = new HashMap<String, Class>();
params.put("helper", ScriptHelper228.class);
params.put("person", Person228.class);
ctx.setInputs(params);
String script = "helper.methodB(2);\n" + "person.getName2();";
try {
CompiledExpression compiled = (CompiledExpression) MVEL.compileExpression(script, ctx);
} catch (Exception e) {
return;
}
fail("Should have thrown an exception");
}
public void testStaticFieldAccessForInputs() {
MVEL.COMPILER_OPT_ALLOW_NAKED_METH_CALL = true;
ParserContext pCtx = ParserContext.create();
MVEL.analysisCompile("java.math.BigDecimal.TEN", pCtx);
assertFalse(pCtx.getInputs().containsKey("java"));
assertEquals(0, pCtx.getInputs().size());
// MVEL.COMPILER_OPT_ALLOW_NAKED_METH_CALL = true;
//
// pCtx = ParserContext.create();
// MVEL.analysisCompile("java.math.BigDecimal.TEN", pCtx);
//
// assertFalse(pCtx.getInputs().containsKey("java"));
//
// assertEquals(0,
// pCtx.getInputs().size());
}
public void testMVEL234() {
StringBuffer buffer = new StringBuffer();
buffer.append("import java.text.SimpleDateFormat;");
buffer.append("if (\"test\".matches(\"[0-9]\")) {");
buffer.append(" return false;");
buffer.append("}else{");
buffer.append(" SimpleDateFormat sqf = new SimpleDateFormat(\"yyyyMMdd\");");
buffer.append("}");
ParserContext ctx = new ParserContext();
ctx.setStrongTyping(true);
try {
CompiledExpression compiled =
(CompiledExpression) MVEL.compileExpression(buffer.toString(), ctx);
} catch (Exception e) {
fail(e.getMessage());
}
}
public void testVarInputs() {
ParserContext pCtx = ParserContext.create();
MVEL.analysisCompile(
"test != foo && bo.addSomething(trouble) "
+ "&& 1 + 2 / 3 == 1; String bleh = foo; twa = bleh;",
pCtx);
assertEquals(4, pCtx.getInputs().size());
assertTrue(pCtx.getInputs().containsKey("test"));
assertTrue(pCtx.getInputs().containsKey("foo"));
assertTrue(pCtx.getInputs().containsKey("bo"));
assertTrue(pCtx.getInputs().containsKey("trouble"));
assertEquals(2, pCtx.getVariables().size());
assertTrue(pCtx.getVariables().containsKey("bleh"));
assertTrue(pCtx.getVariables().containsKey("twa"));
assertEquals(String.class, pCtx.getVarOrInputType("bleh"));
}
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 testMVEL190a() {
Serializable compiled =
MVEL.compileExpression(
"a.toString()", ParserContext.create().stronglyTyped().withInput("a", String.class));
}
