Add JUEL tests and improve implementation

Copy tests for the Odysseus JUEL implementation from https://github.com/beckchr/juel
Copy Tomcat EL implementation tests from https://github.com/apache/tomcat/tree/97f157af6d750a644a3d1c26e2d6af0d59d7b553/test/org/apache/el

Implement some improvements for JUEL:

* Support BigInteger literal - prior to this if a number larger than a long was used it would throw an exception during expression parsing
* Support BigDecimal literal - prior to this if a number larger than a double would be used we would have an an infinite double, now it will use BigDecimal
* Support using other quote escaping in string literal according to: https://jakarta.ee/specifications/expression-language/6.0/jakarta-expression-language-spec-6.0#literals.
  * `\` must be escaped as `\\`
  * `"` must be escaped as `\"` when the string is enclosed with `"`
  * `"` may be escaped as `\"` when the string is enclosed with `'`
  * `'` must be escaped as `\'` when the string is enclosed with `'`
  * `'` may be escaped as `\'` when the string is enclosed with `"`
* Adjust Odysseus TypeConverter to coerce null to non primitive types according to the JUEL spec (https://jakarta.ee/specifications/expression-language/6.0/jakarta-expression-language-spec-6.0#type-conversion).
  This leads to the changes in `AstBinary`, `AstChoice` and `AstUnary` to use a primitive boolean class to do the binding.
  It is safe to do since the other place where we coerce values is the BeanELResolver, in which we only call the coercion with a null value for primitives

Author: filiphr

modules/flowable-engine-common/pom.xml

@@ -120,7 +120,7 @@
 
         <dependency>
             <groupId>org.junit.jupiter</groupId>
-            <artifactId>junit-jupiter-engine</artifactId>
+            <artifactId>junit-jupiter</artifactId>
             <scope>test</scope>
         </dependency>
         <dependency>

modules/flowable-engine-common/src/main/java/org/flowable/common/engine/impl/de/odysseus/el/misc/TypeConverterImpl.java

@@ -305,9 +305,16 @@ protected Object coerceStringToType(String value, Class<?> type) {
 
 	@SuppressWarnings("unchecked")
 	protected Object coerceToType(Object value, Class<?> type) {
+		if (type == null || Object.class.equals(type)) {
+			return value;
+		}
+
 		if (type == String.class) {
 			return coerceToString(value);
 		}
+		if (value == null && !type.isPrimitive()) {
+			return null;
+		}
 		if (type == Long.class || type == long.class) {
 			return coerceToLong(value);
 		}

modules/flowable-engine-common/src/main/java/org/flowable/common/engine/impl/de/odysseus/el/tree/impl/Parser.java

@@ -39,6 +39,8 @@
 import static org.flowable.common.engine.impl.de.odysseus.el.tree.impl.Scanner.Symbol.TEXT;
 import static org.flowable.common.engine.impl.de.odysseus.el.tree.impl.Scanner.Symbol.TRUE;
 
+import java.math.BigDecimal;
+import java.math.BigInteger;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.HashMap;
@@ -191,8 +193,16 @@ protected ExtensionHandler getExtensionHandler(Token token) {
 	 */
 	protected Number parseInteger(String string) throws ParseException {
 		try {
-			return Long.valueOf(string);
-		} catch (NumberFormatException e) {
+			try {
+				return Long.valueOf(string);
+			} catch (NumberFormatException e) {
+				// Too large for Long. Try BigInteger.
+				return new BigInteger(string);
+			}
+		} catch (ArithmeticException | NumberFormatException exception) {
+			// Too big for BigInteger.
+			// Catch NumberFormatException as well here just in case the
+			// parser provides invalid input.
 			fail(INTEGER);
 			return null;
 		}
@@ -205,7 +215,11 @@ protected Number parseInteger(String string) throws ParseException {
 	 */
 	protected Number parseFloat(String string) throws ParseException {
 		try {
-			return Double.valueOf(string);
+			Double value = Double.valueOf(string);
+			if (value.isInfinite() || value.isNaN()) {
+				return new BigDecimal(string);
+			}
+			return value;
 		} catch (NumberFormatException e) {
 			fail(FLOAT);
 			return null;

modules/flowable-engine-common/src/main/java/org/flowable/common/engine/impl/de/odysseus/el/tree/impl/Scanner.java

@@ -309,10 +309,10 @@ protected Token nextString() throws ScanException {
 					throw new ScanException(position, "unterminated string", quote + " or \\");
 				} else {
 					c = input.charAt(i++);
-					if (c == '\\' || c == quote) {
+					if (c == '\\' || c == '\'' || c == '\"') {
 						builder.append(c);
 					} else {
-						throw new ScanException(position, "invalid escape sequence \\" + c, "\\" + quote + " or \\\\");
+						throw new ScanException(position, "invalid escape sequence \\" + c, "\\', \\\" or \\\\");
 					}
 				}
 			} else if (c == quote) {

modules/flowable-engine-common/src/main/java/org/flowable/common/engine/impl/de/odysseus/el/tree/impl/ast/AstBinary.java

@@ -40,8 +40,8 @@ public Object eval(Bindings bindings, ELContext context, AstNode left, AstNode r
 	public static final Operator AND = new Operator() {
         @Override
 		public Object eval(Bindings bindings, ELContext context, AstNode left, AstNode right) {
-			Boolean l = bindings.convert(left.eval(bindings, context), Boolean.class);
-			return Boolean.TRUE.equals(l) ? bindings.convert(right.eval(bindings, context), Boolean.class) : Boolean.FALSE;
+			Boolean l = bindings.convert(left.eval(bindings, context), boolean.class);
+			return Boolean.TRUE.equals(l) ? bindings.convert(right.eval(bindings, context), boolean.class) : Boolean.FALSE;
 		}
 		@Override public String toString() { return "&&"; }
 	};
@@ -84,8 +84,8 @@ public Object eval(Bindings bindings, ELContext context, AstNode left, AstNode r
 	public static final Operator OR = new Operator() {
         @Override
 		public Object eval(Bindings bindings, ELContext context, AstNode left, AstNode right) {
-			Boolean l = bindings.convert(left.eval(bindings, context), Boolean.class);
-			return Boolean.TRUE.equals(l) ? Boolean.TRUE : bindings.convert(right.eval(bindings, context), Boolean.class);
+			Boolean l = bindings.convert(left.eval(bindings, context), boolean.class);
+			return Boolean.TRUE.equals(l) ? Boolean.TRUE : bindings.convert(right.eval(bindings, context), boolean.class);
 		}
 		@Override public String toString() { return "||"; }
 	};

modules/flowable-engine-common/src/main/java/org/flowable/common/engine/impl/de/odysseus/el/tree/impl/ast/AstChoice.java

@@ -30,8 +30,8 @@ public AstChoice(AstNode question, AstNode yes, AstNode no) {
 
 	@Override 
 	public Object eval(Bindings bindings, ELContext context) throws ELException {
-		Boolean value = bindings.convert(question.eval(bindings, context), Boolean.class);
-		return value.booleanValue() ? yes.eval(bindings, context) : no.eval(bindings, context);
+		boolean value = bindings.convert(question.eval(bindings, context), boolean.class);
+		return value ? yes.eval(bindings, context) : no.eval(bindings, context);
 	}
 
 	@Override

modules/flowable-engine-common/src/main/java/org/flowable/common/engine/impl/de/odysseus/el/tree/impl/ast/AstUnary.java

@@ -43,7 +43,7 @@ public Object eval(Bindings bindings, ELContext context, AstNode node) {
 		@Override public String toString() { return "-"; }
 	};
 	public static final Operator NOT = new SimpleOperator() {
-		@Override public Object apply(TypeConverter converter, Object o) { return !converter.convert(o, Boolean.class); }
+		@Override public Object apply(TypeConverter converter, Object o) { return !converter.convert(o, boolean.class); }
 		@Override public String toString() { return "!"; }
 	};
 

modules/flowable-engine-common/src/test/java/org/flowable/common/engine/impl/de/odysseus/el/ExpressionFactoryImplTest.java

@@ -0,0 +1,55 @@
+/*
+ * Copyright 2006-2009 Odysseus Software GmbH
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.flowable.common.engine.impl.de.odysseus.el;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import org.flowable.common.engine.impl.de.odysseus.el.util.SimpleContext;
+import org.flowable.common.engine.impl.de.odysseus.el.util.SimpleResolver;
+import org.junit.jupiter.api.Test;
+
+class ExpressionFactoryImplTest {
+
+    public static long bar() {
+        return 1;
+    }
+
+    private ExpressionFactoryImpl factory = new ExpressionFactoryImpl();
+
+    @Test
+    void testCoerceToType() {
+        assertThat(factory.coerceToType(1l, String.class)).isEqualTo("1");
+    }
+
+    @Test
+    void testCreateTreeValueExpression() {
+        SimpleContext context = new SimpleContext(new SimpleResolver());
+        assertThat(factory.createValueExpression(context, "${1}", Object.class).getValue(context)).isEqualTo(1l);
+    }
+
+    @Test
+    void testCreateObjectValueExpression() {
+        SimpleContext context = new SimpleContext(new SimpleResolver());
+        assertThat(factory.createValueExpression("1", Object.class).getValue(context)).isEqualTo("1");
+    }
+
+    @Test
+    void testCreateMethodExpression() throws NoSuchMethodException {
+        SimpleContext context = new SimpleContext(new SimpleResolver());
+        context.getELResolver().setValue(context, null, "foo", this);
+        assertThat(factory.createMethodExpression(context, "${foo.bar}", null, new Class[0]).invoke(context, null)).isEqualTo(bar());
+    }
+}

modules/flowable-engine-common/src/test/java/org/flowable/common/engine/impl/de/odysseus/el/ObjectValueExpressionTest.java

@@ -0,0 +1,78 @@
+/*
+ * Copyright 2006-2009 Odysseus Software GmbH
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.flowable.common.engine.impl.de.odysseus.el;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+import org.flowable.common.engine.impl.de.odysseus.el.misc.TypeConverter;
+import org.flowable.common.engine.impl.javax.el.ELException;
+import org.junit.jupiter.api.Test;
+
+class ObjectValueExpressionTest extends TestCase {
+
+    private TypeConverter converter = TypeConverter.DEFAULT;
+
+    @Test
+    void testHashCode() {
+        assertThat(new ObjectValueExpression(converter, "foo", Object.class).hashCode()).isEqualTo("foo".hashCode());
+    }
+
+    @Test
+    void testEqualsObject() {
+        assertThat(new ObjectValueExpression(converter, "foo", Object.class).equals(new ObjectValueExpression(converter, "foo", Object.class))).isTrue();
+        assertThat(new ObjectValueExpression(converter, new String("foo"), Object.class).equals(
+                new ObjectValueExpression(converter, "foo", Object.class))).isTrue();
+        assertThat(new ObjectValueExpression(converter, "foo", Object.class).equals(new ObjectValueExpression(converter, "bar", Object.class))).isFalse();
+    }
+
+    @Test
+    void testGetValue() {
+        assertThat(new ObjectValueExpression(converter, "foo", Object.class).getValue(null)).isEqualTo("foo");
+    }
+
+    @Test
+    void testGetExpressionString() {
+        assertThat(new ObjectValueExpression(converter, "foo", Object.class).getExpressionString()).isNull();
+    }
+
+    @Test
+    void testIsLiteralText() {
+        assertThat(new ObjectValueExpression(converter, "foo", Object.class).isLiteralText()).isFalse();
+    }
+
+    @Test
+    void testGetType() {
+        assertThat(new ObjectValueExpression(converter, "foo", Object.class).getType(null)).isNull();
+    }
+
+    @Test
+    void testIsReadOnly() {
+        assertThat(new ObjectValueExpression(converter, "foo", Object.class).isReadOnly(null)).isTrue();
+    }
+
+    @Test
+    void testSetValue() {
+        assertThatThrownBy(() -> new ObjectValueExpression(converter, "foo", Object.class).setValue(null, "bar"))
+                .isInstanceOf(ELException.class);
+    }
+
+    @Test
+    void testSerialize() throws Exception {
+        ObjectValueExpression expression = new ObjectValueExpression(converter, "foo", Object.class);
+        assertThat(deserialize(serialize(expression))).isEqualTo(expression);
+    }
+}

modules/flowable-engine-common/src/test/java/org/flowable/common/engine/impl/de/odysseus/el/TestCase.java

@@ -0,0 +1,86 @@
+/*
+ * Copyright 2006-2009 Odysseus Software GmbH
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.flowable.common.engine.impl.de.odysseus.el;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.ObjectInput;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutput;
+import java.io.ObjectOutputStream;
+
+import org.flowable.common.engine.impl.de.odysseus.el.tree.Tree;
+import org.flowable.common.engine.impl.de.odysseus.el.tree.TreeStore;
+import org.flowable.common.engine.impl.de.odysseus.el.tree.impl.Builder;
+import org.flowable.common.engine.impl.de.odysseus.el.util.SimpleContext;
+import org.flowable.common.engine.impl.javax.el.ELContext;
+import org.flowable.common.engine.impl.javax.el.ExpressionFactory;
+import org.flowable.common.engine.impl.javax.el.ValueExpression;
+
+public abstract class TestCase {
+
+    protected static final Builder BUILDER = new Builder(Builder.Feature.METHOD_INVOCATIONS);
+
+    protected ExpressionFactory expressionFactory;
+
+    protected static Tree parse(String expression) {
+        return BUILDER.build(expression);
+    }
+
+    protected Object eval(String expression) {
+        return eval(expression, Object.class);
+    }
+    protected Object eval(String expression, ELContext context) {
+        return eval(expression, context, Object.class);
+    }
+
+    protected <T> T eval(String expression, Class<T> expectedType) {
+        return eval(expression, null, expectedType);
+    }
+    protected <T> T eval(String expression, ELContext context, Class<T> expectedType) {
+        if (context == null) {
+            context = new SimpleContext();
+        }
+        ValueExpression valueExpression = getExpressionFactory().createValueExpression(context, expression, expectedType);
+        return (T) valueExpression.getValue(context);
+    }
+
+    protected ExpressionFactory getExpressionFactory() {
+        if (expressionFactory == null) {
+            expressionFactory = createExpressionFactory();
+        }
+        return expressionFactory;
+    }
+
+    protected ExpressionFactory createExpressionFactory() {
+        TreeStore store = new TreeStore(BUILDER, null);
+        return new ExpressionFactoryImpl(store);
+    }
+
+    protected static byte[] serialize(Object value) throws Exception {
+        ByteArrayOutputStream bout = new ByteArrayOutputStream();
+        ObjectOutput out = new ObjectOutputStream(bout);
+        out.writeObject(value);
+        out.close();
+        return bout.toByteArray();
+    }
+
+    protected static Object deserialize(byte[] bytes) throws Exception {
+        ByteArrayInputStream bin = new ByteArrayInputStream(bytes);
+        ObjectInput in = new ObjectInputStream(bin);
+        return in.readObject();
+    }
+}