public void testTypeVarDeclr() { String ex = "String a;"; ParserContext ctx = new ParserContext(); ExpressionCompiler compiler = new ExpressionCompiler(ex); compiler.compile(ctx); assertNotNull(ctx.getVariables()); assertEquals(1, ctx.getVariables().entrySet().size()); for (Map.Entry<String, Class> entry : ctx.getVariables().entrySet()) { assertEquals(String.class, entry.getValue()); } }
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 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 testMultiTypeVarDeclr3() { String ex = "int a = 52 * 3, b = 8, c = 16;"; ParserContext ctx = new ParserContext(); ExpressionCompiler compiler = new ExpressionCompiler(ex); Serializable s = compiler.compile(ctx); assertNotNull(ctx.getVariables()); assertEquals(3, ctx.getVariables().entrySet().size()); for (Map.Entry<String, Class> entry : ctx.getVariables().entrySet()) { assertEquals(int.class, entry.getValue()); } Map vars = new HashMap(); executeExpression(s, vars); assertEquals(52 * 3, vars.get("a")); assertEquals(8, vars.get("b")); assertEquals(16, vars.get("c")); }
public void testVarDeclr() { String ex = "var a"; ParserContext ctx = new ParserContext(); ExpressionCompiler compiler = new ExpressionCompiler(ex); compiler.setVerifyOnly(true); compiler.compile(ctx); assertEquals(1, ctx.getVariables().size()); }
public void testAnalysisCompile() { ParserContext pCtx = new ParserContext(); ExpressionCompiler e = new ExpressionCompiler("foo.aValue = 'bar'"); e.setVerifyOnly(true); e.compile(pCtx); assertTrue(pCtx.getInputs().keySet().contains("foo")); assertEquals(1, pCtx.getInputs().size()); assertEquals(0, pCtx.getVariables().size()); }
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 testStrictTypingCompilation4() throws NoSuchMethodException { ParserContext ctx = new ParserContext(); ctx.addImport(Foo.class); ctx.setStrictTypeEnforcement(true); ExpressionCompiler compiler = new ExpressionCompiler("x_a = new Foo()"); compiler.compile(ctx); assertEquals(Foo.class, ctx.getVariables().get("x_a")); }
/** * Analyze an expression. * * @param expr The expression to analyze. * @param availDecls Total set of declarations available. * @return The <code>Set</code> of declarations used by the expression. * @throws RecognitionException If an error occurs in the parser. */ public MVELAnalysisResult analyzeExpression( final PackageBuildContext context, final String expr, final BoundIdentifiers availableIdentifiers, final Map<String, Class<?>> localTypes) { MVELAnalysisResult result = null; if (expr.trim().length() > 0) { MVEL.COMPILER_OPT_ALLOW_NAKED_METH_CALL = true; MVELDialect dialect = (MVELDialect) context.getDialect("mvel"); // creating a reusable parser configuration ParserConfiguration conf = new ParserConfiguration(); conf.setImports(dialect.getImports()); conf.setPackageImports((HashSet) dialect.getPackgeImports()); conf.setClassLoader(context.getPackageBuilder().getRootClassLoader()); // first compilation is for verification only // @todo proper source file name final ParserContext parserContext1 = new ParserContext(conf); if (localTypes != null) { for (Entry entry : localTypes.entrySet()) { parserContext1.addInput((String) entry.getKey(), (Class) entry.getValue()); } } if (availableIdentifiers.getThisClass() != null) { parserContext1.addInput("this", availableIdentifiers.getThisClass()); } parserContext1.setStrictTypeEnforcement(false); parserContext1.setStrongTyping(false); parserContext1.setInterceptors(dialect.getInterceptors()); Class returnType = null; try { returnType = MVEL.analyze(expr, parserContext1); } catch (Exception e) { context .getErrors() .add( new DescrBuildError( context.getParentDescr(), null, null, "Unable to Analyse Expression " + expr + ":\n" + e.getMessage())); return null; } Set<String> requiredInputs = new HashSet(); requiredInputs.addAll(parserContext1.getInputs().keySet()); HashMap<String, Class<?>> variables = (HashMap<String, Class<?>>) ((Map) parserContext1.getVariables()); // MVEL includes direct fields of context object in non-strict mode. so we need to strip those if (availableIdentifiers.getThisClass() != null) { for (Iterator<String> it = requiredInputs.iterator(); it.hasNext(); ) { if (PropertyTools.getFieldOrAccessor(availableIdentifiers.getThisClass(), it.next()) != null) { it.remove(); } } } // now, set the required input types and compile again final ParserContext parserContext2 = new ParserContext(conf); parserContext2.setStrictTypeEnforcement(true); parserContext2.setStrongTyping(true); parserContext2.setInterceptors(dialect.getInterceptors()); if (context.isTypesafe()) { if (localTypes != null) { for (Entry<String, Class<?>> entry : localTypes.entrySet()) { parserContext2.addInput(entry.getKey(), entry.getValue()); } } for (String str : requiredInputs) { Class cls = availableIdentifiers.getDeclarations().get(str); if (cls != null) { parserContext2.addInput(str, cls); continue; } if (cls == null) { cls = availableIdentifiers.getGlobals().get(str); if (cls != null) { parserContext2.addInput(str, cls); continue; } } if (cls == null) { if (str.equals("drools")) { parserContext2.addInput("drools", KnowledgeHelper.class); } else if (str.equals("kcontext")) { parserContext2.addInput("kcontext", RuleContext.class); } if (str.equals("rule")) { parserContext2.addInput("rule", Rule.class); } } } if (availableIdentifiers.getThisClass() != null) { parserContext2.addInput("this", availableIdentifiers.getThisClass()); } try { returnType = MVEL.analyze(expr, parserContext2); } catch (Exception e) { context .getErrors() .add( new DescrBuildError( context.getParentDescr(), null, null, "Unable to Analyse Expression " + expr + ":\n" + e.getMessage())); return null; } requiredInputs = new HashSet(); requiredInputs.addAll(parserContext2.getInputs().keySet()); requiredInputs.addAll(variables.keySet()); variables = (HashMap<String, Class<?>>) ((Map) parserContext2.getVariables()); } result = analyze(requiredInputs, availableIdentifiers); result.setReturnType(returnType); result.setMvelVariables(variables); } else { result = analyze((Set<String>) Collections.EMPTY_SET, availableIdentifiers); result.setMvelVariables(new HashMap<String, Class<?>>()); } return result; }