/** * Having a parser context that imports the classes speeds MVEL by up to 60%. */ protected ParserContext getParserContext() { if (parserContext == null) { parserContext = new ParserContext(); parserContext.addImport("MVEL", MVEL.class); parserContext.addImport("MvelHelper", MvelHelper.class); } return parserContext; }
context.addImport("MVEL", MVEL.class); context.addImport("MvelHelper", MvelHelper.class); context.addImport("CollectionUtils", SelectizeCollectionUtils.class); if (MapUtils.isNotEmpty(additionalContextImports)) { for (Entry<String, Class<?>> entry : additionalContextImports.entrySet()) { context.addImport(entry.getKey(), entry.getValue());
@Override public Object compile(String expression, Map<String, Object> parameters) { logger.debug("About to compile mvel expression {}", expression); ClassLoader classLoader = (ClassLoader) parameters.get("classloader"); if (classLoader == null) { classLoader = this.getClass().getClassLoader(); } ParserConfiguration config = new ParserConfiguration(); config.setClassLoader(classLoader); ParserContext context = new ParserContext(config); if (parameters != null) { @SuppressWarnings("unchecked") Set<String> imports = (Set<String>)parameters.get("imports"); if (imports != null) { for(String clazz : imports) { try { Class<?> cl = Class.forName(clazz, true, classLoader); context.addImport(cl.getSimpleName(), cl); } catch (ClassNotFoundException e) { logger.warn("Unable to load class {} due to {}", clazz, e.getException()); }; } } } return MVEL.compileExpression(expression, context); }
public static void exerciseWorkaround() { System.setProperty("mvel2.disable.jit", "true"); String rule = "CollectionUtils.intersection(level1.level2.getMultiValueSkuAttributes()[\"TEST-VALID\"],[\"TEST-VALID\"]).size()>0"; ParserContext context = new ParserContext(); context.addImport("CollectionUtils", SelectizeCollectionUtils.class); Serializable exp = MVEL.compileExpression(rule, context); executeTestCase(exp, "TEST-INVALID"); boolean response = executeTestCase(exp, "TEST-VALID"); if (!response) { //With the workaround, we should never get here System.out.print("false"); } else { //The expression should never be corrupted now that we've removed the overloaded method (this is the workaround) System.out.print("true"); } }
public static void exerciseFailure() { System.setProperty("mvel2.disable.jit", "true"); String rule = "CollectionUtils.intersection(level1.level2.getMultiValueSkuAttributes()[\"TEST-VALID\"],[\"TEST-VALID\"]).size()>0"; ParserContext context = new ParserContext(); context.addImport("CollectionUtils", MvelTestOverloadUtils.class); Serializable exp = MVEL.compileExpression(rule, context); executeTestCase(exp, "TEST-INVALID"); boolean response = executeTestCase(exp, "TEST-VALID"); if (!response) { //We received the expected, corrupted expression state, so return true to validate the expected test results System.out.print("true"); } else { //We did not receive the expected, corrupted expression state. This can happen sometimes, since the ordering of methods //returned from the call to Class#getMethods for SelectizeCollectionUtilsTest is undetermined. Return false //since we did not validate the expected test results in this run. System.out.print("false"); } }
@Test public void testOfferAppliesToSpecificItems() { DiscreteOrderItemImpl orderItem = new DiscreteOrderItemImpl(); Sku sku = new SkuImpl(); sku.setRetailPrice(new Money("1")); sku.setId(1234L); orderItem.setSku(sku); OfferImpl offer = new OfferImpl(); offer.setType(OfferType.ORDER_ITEM); //Set up MVEL Context ParserContext context = new ParserContext(); //Import OfferType into the MVEL context since it may be used context.addImport("OfferType", OfferType.class); context.addImport("FulfillmentType", FulfillmentType.class); //Compile the MVEL Expression Serializable domainExp1 = MVEL.compileExpression("offer.type == OfferType.ORDER_ITEM and (currentItem.sku.id in [1234, 2345, 5678])", context); //Add variables to a HashMap that should be passed in to execute the expression HashMap<String, Object> domainVars = new HashMap<>(); domainVars.put("currentItem", orderItem); domainVars.put("offer", offer); //Execute the expression Boolean expressionOutcome1 = (Boolean)MVEL.executeExpression(domainExp1, domainVars); assert expressionOutcome1 != null && expressionOutcome1; }
context.addImport("OfferType", OfferType.class);
/** * Adds an import for the specified <tt>Class</tt>. * * @param cls The instance of the <tt>Class</tt> which represents the imported class. */ public void addImport(Class cls) { addImport(cls.getSimpleName(), cls); }
@Test public void testDebugSymbolCount() { String expr = "System.out.println( \"a1\" );\n" + "System.out.println( \"a2\" );\n" + "System.out.println( \"a3\" );\n" + "System.out.println( \"a4\" );\n"; ParserContext context = new ParserContext(); context.setDebugSymbols( true ); context.addImport( "System", System.class ); context.setStrictTypeEnforcement( true ); //context.setDebugSymbols( true ); context.setSourceFile( "mysource" ); ExpressionCompiler compiler = new ExpressionCompiler( expr, context ); Serializable compiledExpression = compiler.compile(); String s = DebugTools.decompile( compiledExpression ); System.out.println( "s " + s ); int fromIndex = 0; int count = 0; while ( (fromIndex = s.indexOf( "DEBUG_SYMBOL", fromIndex + 1 )) > -1 ) { count++; } assertEquals( 4, count ); }
public void testLateResolveOfClass() { ParserContext ctx = new ParserContext(); ctx.addImport(Foo.class); ExpressionCompiler compiler = new ExpressionCompiler("System.out.println(new Foo());", ctx); System.out.println(executeExpression(compiler.compile())); }
public void testNewUsingWith() { ParserContext ctx = new ParserContext(); ctx.setStrongTyping(true); ctx.addImport(Foo.class); ctx.addImport(Bar.class); Serializable s = compileExpression("[ 'foo' : (with ( new Foo() )" + " { bar = with ( new Bar() ) { name = 'ziggy' } }) ]", ctx); OptimizerFactory.setDefaultOptimizer("reflective"); assertEquals("ziggy", (((Foo) ((Map) executeExpression(s)).get("foo")).getBar().getName())); }
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 testStrictTypingCompilation4() throws NoSuchMethodException { ParserContext ctx = new ParserContext(); ctx.addImport(Foo.class); ctx.setStrictTypeEnforcement(true); ExpressionCompiler compiler = new ExpressionCompiler("x_a = new Foo()", ctx); compiler.compile(); assertEquals(Foo.class, ctx.getVariables().get("x_a")); }
public void testJIRA155() { ParserContext pctx = new ParserContext(); pctx.addImport("returnTrue", MVEL.getStaticMethod(CoreConfidenceTests.class, "returnTrue", new Class[0])); assertEquals(true, executeExpression(MVEL.compileExpression("!true || returnTrue()", pctx))); }
public void testJIRA155b() { ParserContext pctx = new ParserContext(); pctx.addImport("returnTrue", MVEL.getStaticMethod(CoreConfidenceTests.class, "returnTrue", new Class[0])); assertEquals(true, executeExpression(MVEL.compileExpression("!(!true || !returnTrue())", pctx))); }
public void testWithInsideBlock() { String str = "Foo f = new Foo(); with(f) { setBoolTest( true ) }; f.isBoolTest()"; ParserConfiguration pconf = new ParserConfiguration(); ParserContext pctx = new ParserContext(pconf); pctx.setStrongTyping(true); pctx.addInput("this", Bar.class); pctx.addImport(Foo.class); ExecutableStatement stmt = (ExecutableStatement) MVEL.compileExpression(str, pctx); Bar ctx = new Bar(); Boolean result = (Boolean) MVEL.executeExpression(stmt, ctx, new HashMap()); assertTrue(result); }
public void testStaticNestedWithImport() { String expr = "Message.GOODBYE;\n"; ParserContext context = new ParserContext(); context.setStrictTypeEnforcement(false); context.addImport("Message", Message.class); ExpressionCompiler compiler = new ExpressionCompiler(expr, context); assertEquals(1, executeExpression(compiler.compile())); }
public void testStrictStaticMethodCall() { ParserContext ctx = new ParserContext(); ctx.addImport("Bar", Bar.class); ctx.setStrictTypeEnforcement(true); ExpressionCompiler compiler = new ExpressionCompiler("Bar.staticMethod()", ctx); Serializable s = compiler.compile(); assertEquals(1, executeExpression(s)); }
public void testInlineWith4() { OptimizerFactory.setDefaultOptimizer("ASM"); ParserContext pCtx = new ParserContext(); pCtx.addImport(Foo.class); ExpressionCompiler expr = new ExpressionCompiler("new Foo().{ name = 'bar' }", pCtx); CompiledExpression c = expr.compile(); Foo f = (Foo) executeExpression(c); assertEquals("bar", f.getName()); f = (Foo) executeExpression(c); assertEquals("bar", f.getName()); }