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)); }