You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@commons.apache.org by gg...@apache.org on 2023/11/03 15:11:41 UTC
(commons-jexl) 02/02: Sort test members
This is an automated email from the ASF dual-hosted git repository.
ggregory pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/commons-jexl.git
commit ac1cbf15fdaf7c424c45663555310ef43dba38e8
Author: Gary Gregory <ga...@gmail.com>
AuthorDate: Fri Nov 3 11:11:32 2023 -0400
Sort test members
---
.../org/apache/commons/jexl3/AnnotationTest.java | 354 +--
.../org/apache/commons/jexl3/AntishCallTest.java | 138 +-
.../org/apache/commons/jexl3/Arithmetic360.java | 136 +-
.../commons/jexl3/ArithmeticOperatorTest.java | 760 ++---
.../org/apache/commons/jexl3/ArithmeticTest.java | 3244 ++++++++++----------
.../org/apache/commons/jexl3/ArrayAccessTest.java | 254 +-
.../org/apache/commons/jexl3/ArrayLiteralTest.java | 110 +-
.../java/org/apache/commons/jexl3/AssignTest.java | 146 +-
.../apache/commons/jexl3/BitwiseOperatorTest.java | 88 +-
.../java/org/apache/commons/jexl3/BlockTest.java | 32 +-
.../java/org/apache/commons/jexl3/BuilderTest.java | 16 +-
.../java/org/apache/commons/jexl3/CacheTest.java | 712 ++---
.../java/org/apache/commons/jexl3/CaptureLog.java | 22 +-
.../org/apache/commons/jexl3/ClassCreator.java | 140 +-
.../org/apache/commons/jexl3/ClassCreatorTest.java | 296 +-
.../commons/jexl3/CollectionLiteralTest.java | 58 +-
.../commons/jexl3/ComposePermissionsTest.java | 38 +-
.../apache/commons/jexl3/ContextNamespaceTest.java | 372 +--
.../java/org/apache/commons/jexl3/DoWhileTest.java | 140 +-
.../org/apache/commons/jexl3/ExceptionTest.java | 276 +-
.../org/apache/commons/jexl3/FeaturesTest.java | 452 +--
src/test/java/org/apache/commons/jexl3/Foo.java | 74 +-
.../java/org/apache/commons/jexl3/ForEachTest.java | 190 +-
src/test/java/org/apache/commons/jexl3/IfTest.java | 256 +-
.../org/apache/commons/jexl3/Issues100Test.java | 464 +--
.../org/apache/commons/jexl3/Issues200Test.java | 488 +--
.../org/apache/commons/jexl3/Issues300Test.java | 754 ++---
.../org/apache/commons/jexl3/Issues400Test.java | 82 +-
.../java/org/apache/commons/jexl3/IssuesTest.java | 248 +-
.../java/org/apache/commons/jexl3/JXLTTest.java | 1678 +++++-----
src/test/java/org/apache/commons/jexl3/Jexl.java | 4 +-
.../org/apache/commons/jexl3/JexlEvalContext.java | 38 +-
.../java/org/apache/commons/jexl3/JexlTest.java | 1020 +++---
.../org/apache/commons/jexl3/JexlTestCase.java | 190 +-
.../java/org/apache/commons/jexl3/LambdaTest.java | 660 ++--
.../java/org/apache/commons/jexl3/LexicalTest.java | 1214 ++++----
.../org/apache/commons/jexl3/MapLiteralTest.java | 88 +-
.../java/org/apache/commons/jexl3/MethodTest.java | 926 +++---
.../java/org/apache/commons/jexl3/PragmaTest.java | 394 +--
.../apache/commons/jexl3/PropertyAccessTest.java | 674 ++--
.../org/apache/commons/jexl3/PublicFieldsTest.java | 106 +-
.../java/org/apache/commons/jexl3/RangeTest.java | 90 +-
.../org/apache/commons/jexl3/ReadonlyContext.java | 18 +-
.../apache/commons/jexl3/ScriptCallableTest.java | 568 ++--
.../java/org/apache/commons/jexl3/ScriptTest.java | 270 +-
.../org/apache/commons/jexl3/SetLiteralTest.java | 132 +-
.../apache/commons/jexl3/ShiftOperatorsTest.java | 160 +-
.../org/apache/commons/jexl3/SideEffectTest.java | 1162 +++----
.../org/apache/commons/jexl3/StrategyTest.java | 86 +-
.../commons/jexl3/SynchronizedArithmetic.java | 198 +-
.../apache/commons/jexl3/SynchronizedContext.java | 14 +-
.../commons/jexl3/SynchronizedOverloadsTest.java | 14 +-
.../java/org/apache/commons/jexl3/VarTest.java | 764 ++---
.../commons/jexl3/examples/AbstractOutput.java | 32 +-
.../apache/commons/jexl3/examples/ArrayTest.java | 18 +-
.../commons/jexl3/examples/MethodPropertyTest.java | 74 +-
.../apache/commons/jexl3/examples/StreamTest.java | 48 +-
.../org/apache/commons/jexl3/internal/Dumper.java | 20 +-
.../apache/commons/jexl3/internal/RangeTest.java | 38 +-
.../org/apache/commons/jexl3/internal/Util.java | 68 +-
.../internal/introspection/DiscoveryTest.java | 144 +-
.../internal/introspection/MethodKeyTest.java | 90 +-
.../introspection/MiscIntrospectionTest.java | 20 +-
.../jexl3/internal/introspection/NoJexlTest.java | 22 +-
.../internal/introspection/PermissionsTest.java | 264 +-
.../commons/jexl3/introspection/SandboxTest.java | 668 ++--
.../commons/jexl3/jexl342/OptionalArithmetic.java | 240 +-
.../commons/jexl3/jexl342/OptionalNullGetter.java | 14 +-
.../commons/jexl3/jexl342/OptionalNullMethod.java | 24 +-
.../commons/jexl3/jexl342/OptionalNullSetter.java | 14 +-
.../apache/commons/jexl3/jexl342/OptionalTest.java | 102 +-
.../jexl3/jexl342/ReferenceGetExecutor.java | 10 +-
.../jexl3/jexl342/ReferenceMethodExecutor.java | 30 +-
.../jexl3/jexl342/ReferenceSetExecutor.java | 10 +-
.../commons/jexl3/jexl342/ReferenceUberspect.java | 320 +-
.../org/apache/commons/jexl3/junit/Asserter.java | 82 +-
.../jexl3/parser/FeatureControllerTest.java | 124 +-
.../apache/commons/jexl3/parser/ParserTest.java | 82 +-
.../scripting/JexlScriptEngineOptionalTest.java | 28 +-
.../jexl3/scripting/JexlScriptEngineTest.java | 302 +-
src/test/java/org/example/SomeTest.java | 48 +-
81 files changed, 11872 insertions(+), 11872 deletions(-)
diff --git a/src/test/java/org/apache/commons/jexl3/AnnotationTest.java b/src/test/java/org/apache/commons/jexl3/AnnotationTest.java
index d2939c2d..a77f03db 100644
--- a/src/test/java/org/apache/commons/jexl3/AnnotationTest.java
+++ b/src/test/java/org/apache/commons/jexl3/AnnotationTest.java
@@ -35,25 +35,18 @@ import org.junit.Test;
public class AnnotationTest extends JexlTestCase {
- public final static int NUM_THREADS = 10;
- public final static int NUM_ITERATIONS = 1000;
-
- public AnnotationTest() {
- super("AnnotationTest");
- }
-
- @Test
- public void test197a() throws Exception {
- final JexlContext jc = new MapContext();
- final JexlScript e = JEXL.createScript("@synchronized { return 42; }");
- final Object r = e.execute(jc);
- Assert.assertEquals(42, r);
- }
-
public static class AnnotationContext extends MapContext implements JexlContext.AnnotationProcessor {
private int count;
private final Set<String> names = new TreeSet<>();
+ public int getCount() {
+ return count;
+ }
+
+ public Set<String> getNames() {
+ return names;
+ }
+
@Override
public Object processAnnotation(final String name, final Object[] args, final Callable<Object> statement) throws Exception {
count += 1;
@@ -86,13 +79,24 @@ public class AnnotationTest extends JexlTestCase {
}
return statement.call();
}
+ }
+ /**
+ * A counter whose inc method will misbehave if not mutex-ed.
+ */
+ public static class Counter {
+ private int value;
- public int getCount() {
- return count;
+ public int getValue() {
+ return value;
}
- public Set<String> getNames() {
- return names;
+ public void inc() {
+ final int v = value;
+ // introduce some concurency
+ for (int i = (int) System.currentTimeMillis() % 5; i >= 0; --i) {
+ Thread.yield();
+ }
+ value = v + 1;
}
}
@@ -138,65 +142,78 @@ public class AnnotationTest extends JexlTestCase {
}
}
- @Test
- public void testVarStmt() throws Exception {
- final OptAnnotationContext jc = new OptAnnotationContext();
- final JexlOptions options = jc.getEngineOptions();
- jc.getEngineOptions().set(JEXL);
- options.setSharedInstance(true);
- JexlScript e;
- Object r;
- e = JEXL.createScript("(s, v)->{ @strict(s) @silent(v) var x = y ; 42; }");
+ /**
+ * Runs a counter test with n-thread in //.
+ */
+ public static class TestRunner {
+ public final Counter syncCounter = new Counter();
+ public final Counter concCounter = new Counter();
- // wont make an error
- try {
- r = e.execute(jc, false, true);
- Assert.assertEquals(42, r);
- } catch (final JexlException.Variable xjexl) {
- Assert.fail("should not have thrown");
+ public void run(final Runnable runnable) throws InterruptedException {
+ final ExecutorService executor = Executors.newFixedThreadPool(NUM_THREADS);
+ for (int i = 0; i < NUM_THREADS; i++) {
+ executor.submit(runnable);
+ }
+ executor.shutdown();
+ executor.awaitTermination(5, TimeUnit.SECONDS);
+ // this may succeed concurrently if there is only one 'real' thread
+ // during execution; we can only prove the 'synchronized' if the unsync-ed
+ // version fails...
+ if (NUM_THREADS * NUM_ITERATIONS != concCounter.getValue()) {
+ Assert.assertEquals(NUM_THREADS * NUM_ITERATIONS, syncCounter.getValue());
+ }
}
+ }
- r = null;
- // will make an error and throw
- options.setSafe(false);
- try {
- r = e.execute(jc, true, false);
- Assert.fail("should have thrown");
- } catch (final JexlException.Variable xjexl) {
- Assert.assertNull(r);
- }
+ public final static int NUM_THREADS = 10;
- r = null;
- // will make an error and will not throw but result is null
- try {
- r = e.execute(jc, true, true);
- Assert.assertNull(r);
- } catch (final JexlException.Variable xjexl) {
- Assert.fail("should not have thrown");
- }
- options.setSafe(true);
+ public final static int NUM_ITERATIONS = 1000;
- r = null;
- // will not make an error and will not throw
+ public AnnotationTest() {
+ super("AnnotationTest");
+ }
+
+ @Test
+ public void test197a() throws Exception {
+ final JexlContext jc = new MapContext();
+ final JexlScript e = JEXL.createScript("@synchronized { return 42; }");
+ final Object r = e.execute(jc);
+ Assert.assertEquals(42, r);
+ }
+
+ @Test
+ public void testError() throws Exception {
+ testError(true);
+ testError(false);
+ }
+
+ private void testError(final boolean silent) throws Exception {
+ final CaptureLog log = new CaptureLog();
+ final AnnotationContext jc = new AnnotationContext();
+ final JexlEngine jexl = new JexlBuilder().logger(log).strict(true).silent(silent).create();
+ final JexlScript e = jexl.createScript("@error('42') { return 42; }");
try {
- r = e.execute(jc, false, false);
- Assert.assertEquals(42, r);
- } catch (final JexlException.Variable xjexl) {
- Assert.fail("should not have thrown");
+ final Object r = e.execute(jc);
+ if (!silent) {
+ Assert.fail("should have failed");
+ } else {
+ Assert.assertEquals(1, log.count("warn"));
+ }
+ } catch (final JexlException.Annotation xjexl) {
+ Assert.assertEquals("error", xjexl.getAnnotation());
+ }
+ Assert.assertEquals(1, jc.getCount());
+ Assert.assertTrue(jc.getNames().contains("error"));
+ Assert.assertTrue(jc.getNames().contains("42"));
+ if (!silent) {
+ Assert.assertEquals(0, log.count("warn"));
}
- //Assert.assertEquals(42, r);
- Assert.assertTrue(options.isStrict());
- e = JEXL.createScript("@scale(5) 42;");
- r = e.execute(jc);
- Assert.assertEquals(42, r);
- Assert.assertTrue(options.isStrict());
- Assert.assertEquals(5, options.getMathScale());
}
@Test
- public void testNoArg() throws Exception {
+ public void testHoistingStatement() throws Exception {
final AnnotationContext jc = new AnnotationContext();
- final JexlScript e = JEXL.createScript("@synchronized { return 42; }");
+ final JexlScript e = JEXL.createScript("var t = 1; @synchronized for(var x : [2,3,7]) t *= x; t");
final Object r = e.execute(jc);
Assert.assertEquals(42, r);
Assert.assertEquals(1, jc.getCount());
@@ -204,19 +221,39 @@ public class AnnotationTest extends JexlTestCase {
}
@Test
- public void testNoArgExpression() throws Exception {
+ public void testJexlSynchronized0() throws InterruptedException {
+ final TestRunner tr = new TestRunner();
+ final AnnotationContext ctxt = new AnnotationContext();
+ final JexlScript script = JEXL.createScript(
+ "for(var i : 1..NUM_ITERATIONS) {"
+ + "@synchronized { syncCounter.inc(); }"
+ + "concCounter.inc();"
+ + "}",
+ "NUM_ITERATIONS",
+ "syncCounter",
+ "concCounter");
+ // will sync on syncCounter
+ tr.run(() -> {
+ script.execute(ctxt, NUM_ITERATIONS, tr.syncCounter, tr.concCounter);
+ });
+ }
+
+ @Test
+ public void testMultiple() throws Exception {
final AnnotationContext jc = new AnnotationContext();
- final JexlScript e = JEXL.createScript("@synchronized 42");
+ final JexlScript e = JEXL.createScript("@one(1) @synchronized { return 42; }");
final Object r = e.execute(jc);
Assert.assertEquals(42, r);
- Assert.assertEquals(1, jc.getCount());
+ Assert.assertEquals(2, jc.getCount());
Assert.assertTrue(jc.getNames().contains("synchronized"));
+ Assert.assertTrue(jc.getNames().contains("one"));
+ Assert.assertTrue(jc.getNames().contains("1"));
}
@Test
- public void testNoArgStatement() throws Exception {
+ public void testNoArg() throws Exception {
final AnnotationContext jc = new AnnotationContext();
- final JexlScript e = JEXL.createScript("@synchronized if (true) 2 * 3 * 7; else -42;");
+ final JexlScript e = JEXL.createScript("@synchronized { return 42; }");
final Object r = e.execute(jc);
Assert.assertEquals(42, r);
Assert.assertEquals(1, jc.getCount());
@@ -224,9 +261,9 @@ public class AnnotationTest extends JexlTestCase {
}
@Test
- public void testHoistingStatement() throws Exception {
+ public void testNoArgExpression() throws Exception {
final AnnotationContext jc = new AnnotationContext();
- final JexlScript e = JEXL.createScript("var t = 1; @synchronized for(var x : [2,3,7]) t *= x; t");
+ final JexlScript e = JEXL.createScript("@synchronized 42");
final Object r = e.execute(jc);
Assert.assertEquals(42, r);
Assert.assertEquals(1, jc.getCount());
@@ -234,55 +271,42 @@ public class AnnotationTest extends JexlTestCase {
}
@Test
- public void testOneArg() throws Exception {
+ public void testNoArgStatement() throws Exception {
final AnnotationContext jc = new AnnotationContext();
- final JexlScript e = JEXL.createScript("@one(1) { return 42; }");
+ final JexlScript e = JEXL.createScript("@synchronized if (true) 2 * 3 * 7; else -42;");
final Object r = e.execute(jc);
Assert.assertEquals(42, r);
Assert.assertEquals(1, jc.getCount());
- Assert.assertTrue(jc.getNames().contains("one"));
- Assert.assertTrue(jc.getNames().contains("1"));
+ Assert.assertTrue(jc.getNames().contains("synchronized"));
}
@Test
- public void testMultiple() throws Exception {
+ public void testOneArg() throws Exception {
final AnnotationContext jc = new AnnotationContext();
- final JexlScript e = JEXL.createScript("@one(1) @synchronized { return 42; }");
+ final JexlScript e = JEXL.createScript("@one(1) { return 42; }");
final Object r = e.execute(jc);
Assert.assertEquals(42, r);
- Assert.assertEquals(2, jc.getCount());
- Assert.assertTrue(jc.getNames().contains("synchronized"));
+ Assert.assertEquals(1, jc.getCount());
Assert.assertTrue(jc.getNames().contains("one"));
Assert.assertTrue(jc.getNames().contains("1"));
}
@Test
- public void testError() throws Exception {
- testError(true);
- testError(false);
- }
-
- private void testError(final boolean silent) throws Exception {
- final CaptureLog log = new CaptureLog();
- final AnnotationContext jc = new AnnotationContext();
- final JexlEngine jexl = new JexlBuilder().logger(log).strict(true).silent(silent).create();
- final JexlScript e = jexl.createScript("@error('42') { return 42; }");
- try {
- final Object r = e.execute(jc);
- if (!silent) {
- Assert.fail("should have failed");
- } else {
- Assert.assertEquals(1, log.count("warn"));
+ /**
+ * A base test to ensure synchronized makes a difference.
+ */
+ public void testSynchronized() throws InterruptedException {
+ final TestRunner tr = new TestRunner();
+ final Counter syncCounter = tr.syncCounter;
+ final Counter concCounter = tr.concCounter;
+ tr.run(() -> {
+ for (int i = 0; i < NUM_ITERATIONS; i++) {
+ synchronized (syncCounter) {
+ syncCounter.inc();
+ }
+ concCounter.inc();
}
- } catch (final JexlException.Annotation xjexl) {
- Assert.assertEquals("error", xjexl.getAnnotation());
- }
- Assert.assertEquals(1, jc.getCount());
- Assert.assertTrue(jc.getNames().contains("error"));
- Assert.assertTrue(jc.getNames().contains("42"));
- if (!silent) {
- Assert.assertEquals(0, log.count("warn"));
- }
+ });
}
@Test
@@ -314,82 +338,58 @@ public class AnnotationTest extends JexlTestCase {
}
}
- /**
- * A counter whose inc method will misbehave if not mutex-ed.
- */
- public static class Counter {
- private int value;
+ @Test
+ public void testVarStmt() throws Exception {
+ final OptAnnotationContext jc = new OptAnnotationContext();
+ final JexlOptions options = jc.getEngineOptions();
+ jc.getEngineOptions().set(JEXL);
+ options.setSharedInstance(true);
+ JexlScript e;
+ Object r;
+ e = JEXL.createScript("(s, v)->{ @strict(s) @silent(v) var x = y ; 42; }");
- public void inc() {
- final int v = value;
- // introduce some concurency
- for (int i = (int) System.currentTimeMillis() % 5; i >= 0; --i) {
- Thread.yield();
- }
- value = v + 1;
+ // wont make an error
+ try {
+ r = e.execute(jc, false, true);
+ Assert.assertEquals(42, r);
+ } catch (final JexlException.Variable xjexl) {
+ Assert.fail("should not have thrown");
}
- public int getValue() {
- return value;
+ r = null;
+ // will make an error and throw
+ options.setSafe(false);
+ try {
+ r = e.execute(jc, true, false);
+ Assert.fail("should have thrown");
+ } catch (final JexlException.Variable xjexl) {
+ Assert.assertNull(r);
}
- }
-
- /**
- * Runs a counter test with n-thread in //.
- */
- public static class TestRunner {
- public final Counter syncCounter = new Counter();
- public final Counter concCounter = new Counter();
- public void run(final Runnable runnable) throws InterruptedException {
- final ExecutorService executor = Executors.newFixedThreadPool(NUM_THREADS);
- for (int i = 0; i < NUM_THREADS; i++) {
- executor.submit(runnable);
- }
- executor.shutdown();
- executor.awaitTermination(5, TimeUnit.SECONDS);
- // this may succeed concurrently if there is only one 'real' thread
- // during execution; we can only prove the 'synchronized' if the unsync-ed
- // version fails...
- if (NUM_THREADS * NUM_ITERATIONS != concCounter.getValue()) {
- Assert.assertEquals(NUM_THREADS * NUM_ITERATIONS, syncCounter.getValue());
- }
+ r = null;
+ // will make an error and will not throw but result is null
+ try {
+ r = e.execute(jc, true, true);
+ Assert.assertNull(r);
+ } catch (final JexlException.Variable xjexl) {
+ Assert.fail("should not have thrown");
}
- }
-
- @Test
- /**
- * A base test to ensure synchronized makes a difference.
- */
- public void testSynchronized() throws InterruptedException {
- final TestRunner tr = new TestRunner();
- final Counter syncCounter = tr.syncCounter;
- final Counter concCounter = tr.concCounter;
- tr.run(() -> {
- for (int i = 0; i < NUM_ITERATIONS; i++) {
- synchronized (syncCounter) {
- syncCounter.inc();
- }
- concCounter.inc();
- }
- });
- }
+ options.setSafe(true);
- @Test
- public void testJexlSynchronized0() throws InterruptedException {
- final TestRunner tr = new TestRunner();
- final AnnotationContext ctxt = new AnnotationContext();
- final JexlScript script = JEXL.createScript(
- "for(var i : 1..NUM_ITERATIONS) {"
- + "@synchronized { syncCounter.inc(); }"
- + "concCounter.inc();"
- + "}",
- "NUM_ITERATIONS",
- "syncCounter",
- "concCounter");
- // will sync on syncCounter
- tr.run(() -> {
- script.execute(ctxt, NUM_ITERATIONS, tr.syncCounter, tr.concCounter);
- });
+ r = null;
+ // will not make an error and will not throw
+ try {
+ r = e.execute(jc, false, false);
+ Assert.assertEquals(42, r);
+ } catch (final JexlException.Variable xjexl) {
+ Assert.fail("should not have thrown");
+ }
+ //Assert.assertEquals(42, r);
+ Assert.assertTrue(options.isStrict());
+ e = JEXL.createScript("@scale(5) 42;");
+ r = e.execute(jc);
+ Assert.assertEquals(42, r);
+ Assert.assertTrue(options.isStrict());
+ Assert.assertEquals(5, options.getMathScale());
}
}
diff --git a/src/test/java/org/apache/commons/jexl3/AntishCallTest.java b/src/test/java/org/apache/commons/jexl3/AntishCallTest.java
index fd9e5e4a..794f08b4 100644
--- a/src/test/java/org/apache/commons/jexl3/AntishCallTest.java
+++ b/src/test/java/org/apache/commons/jexl3/AntishCallTest.java
@@ -30,45 +30,6 @@ import org.junit.Test;
@SuppressWarnings({"UnnecessaryBoxing", "AssertEqualsBetweenInconvertibleTypes"})
public class AntishCallTest extends JexlTestCase {
- public AntishCallTest() {
- super("AntishCallTest");
- }
-
- /**
- * Wraps a class.
- */
- public static class ClassReference {
- final Class<?> clazz;
- ClassReference(final Class<?> c) {
- this.clazz = c;
- }
- }
-
- /**
- * Considers any call using a class reference as functor as a call to its constructor.
- * <p>Note that before 3.2, a class was not considered a functor.
- * @param ref the ClassReference of the class we seek to instantiate
- * @param args the constructor arguments
- * @return an instance if that was possible
- */
- public static Object callConstructor(final JexlEngine engine, final ClassReference ref, final Object... args) {
- return callConstructor(engine, ref.clazz, args);
- }
- public static Object callConstructor(final JexlEngine engine, final Class<?> clazz, final Object... args) {
- if (clazz == null || clazz.isPrimitive() || clazz.isInterface()
- || clazz.isMemberClass() || clazz.isAnnotation() || clazz.isArray()) {
- throw new ArithmeticException("not a constructible object");
- }
- JexlEngine jexl = engine;
- if (jexl == null) {
- jexl = JexlEngine.getThreadEngine();
- if (jexl == null) {
- throw new ArithmeticException("no engine to solve constructor");
- }
- }
- return jexl.newInstance(clazz, args);
- }
-
/**
* An arithmetic that considers class objects as callable.
*/
@@ -77,11 +38,11 @@ public class AntishCallTest extends JexlTestCase {
super(strict);
}
- public Object call(final ClassReference clazz, final Object... args) {
+ public Object call(final Class<?> clazz, final Object... args) {
return callConstructor(null, clazz, args);
}
- public Object call(final Class<?> clazz, final Object... args) {
+ public Object call(final ClassReference clazz, final Object... args) {
return callConstructor(null, clazz, args);
}
}
@@ -90,10 +51,23 @@ public class AntishCallTest extends JexlTestCase {
* A context that considers class references as callable.
*/
public static class CallSupportContext extends MapContext {
+ private JexlEngine engine;
CallSupportContext(final Map<String, Object> map) {
super(map);
}
- private JexlEngine engine;
+
+ public Object call(final Class<?> clazz, final Object... args) {
+ return callConstructor(engine, clazz, args);
+ }
+
+ public Object call(final ClassReference clazz, final Object... args) {
+ return callConstructor(engine, clazz, args);
+ }
+
+ CallSupportContext engine(final JexlEngine j) {
+ engine = j;
+ return this;
+ }
@Override public Object get(final String str) {
if (!super.has(str)) {
@@ -116,30 +90,56 @@ public class AntishCallTest extends JexlTestCase {
}
return true;
}
+ }
- CallSupportContext engine(final JexlEngine j) {
- engine = j;
- return this;
+ /**
+ * Wraps a class.
+ */
+ public static class ClassReference {
+ final Class<?> clazz;
+ ClassReference(final Class<?> c) {
+ this.clazz = c;
}
-
- public Object call(final ClassReference clazz, final Object... args) {
- return callConstructor(engine, clazz, args);
+ }
+ public static Object callConstructor(final JexlEngine engine, final Class<?> clazz, final Object... args) {
+ if (clazz == null || clazz.isPrimitive() || clazz.isInterface()
+ || clazz.isMemberClass() || clazz.isAnnotation() || clazz.isArray()) {
+ throw new ArithmeticException("not a constructible object");
}
-
- public Object call(final Class<?> clazz, final Object... args) {
- return callConstructor(engine, clazz, args);
+ JexlEngine jexl = engine;
+ if (jexl == null) {
+ jexl = JexlEngine.getThreadEngine();
+ if (jexl == null) {
+ throw new ArithmeticException("no engine to solve constructor");
+ }
}
+ return jexl.newInstance(clazz, args);
}
- @Test
- public void testAntishContextVar() throws Exception {
- final Map<String,Object> lmap = new TreeMap<>();
- final JexlContext jc = new CallSupportContext(lmap).engine(JEXL);
- runTestCall(JEXL, jc);
- lmap.put("java.math.BigInteger", new ClassReference(BigInteger.class));
- runTestCall(JEXL, jc);
- lmap.remove("java.math.BigInteger");
- runTestCall(JEXL, jc);
+ /**
+ * Considers any call using a class reference as functor as a call to its constructor.
+ * <p>Note that before 3.2, a class was not considered a functor.
+ * @param ref the ClassReference of the class we seek to instantiate
+ * @param args the constructor arguments
+ * @return an instance if that was possible
+ */
+ public static Object callConstructor(final JexlEngine engine, final ClassReference ref, final Object... args) {
+ return callConstructor(engine, ref.clazz, args);
+ }
+
+ public AntishCallTest() {
+ super("AntishCallTest");
+ }
+
+ void runTestCall(final JexlEngine jexl, final JexlContext jc) throws Exception {
+ final JexlScript check1 = jexl.createScript("var x = java.math.BigInteger; x('1234')");
+ final JexlScript check2 = jexl.createScript("java.math.BigInteger('4321')");
+
+ final Object o1 = check1.execute(jc);
+ Assert.assertEquals("Result is not 1234", new java.math.BigInteger("1234"), o1);
+
+ final Object o2 = check2.execute(jc);
+ Assert.assertEquals("Result is not 4321", new java.math.BigInteger("4321"), o2);
}
@Test
@@ -161,15 +161,15 @@ public class AntishCallTest extends JexlTestCase {
}
}
- void runTestCall(final JexlEngine jexl, final JexlContext jc) throws Exception {
- final JexlScript check1 = jexl.createScript("var x = java.math.BigInteger; x('1234')");
- final JexlScript check2 = jexl.createScript("java.math.BigInteger('4321')");
-
- final Object o1 = check1.execute(jc);
- Assert.assertEquals("Result is not 1234", new java.math.BigInteger("1234"), o1);
-
- final Object o2 = check2.execute(jc);
- Assert.assertEquals("Result is not 4321", new java.math.BigInteger("4321"), o2);
+ @Test
+ public void testAntishContextVar() throws Exception {
+ final Map<String,Object> lmap = new TreeMap<>();
+ final JexlContext jc = new CallSupportContext(lmap).engine(JEXL);
+ runTestCall(JEXL, jc);
+ lmap.put("java.math.BigInteger", new ClassReference(BigInteger.class));
+ runTestCall(JEXL, jc);
+ lmap.remove("java.math.BigInteger");
+ runTestCall(JEXL, jc);
}
// JEXL-300
diff --git a/src/test/java/org/apache/commons/jexl3/Arithmetic360.java b/src/test/java/org/apache/commons/jexl3/Arithmetic360.java
index 6db71b53..397739b1 100644
--- a/src/test/java/org/apache/commons/jexl3/Arithmetic360.java
+++ b/src/test/java/org/apache/commons/jexl3/Arithmetic360.java
@@ -33,40 +33,22 @@ public class Arithmetic360 extends JexlArithmetic {
}
/**
- * Given a long, attempt to narrow it to an int.
- * <p>Narrowing will only occur if no operand is a Long.
- * @param lhs the left-hand side operand that lead to the long result
- * @param rhs the right-hand side operand that lead to the long result
- * @param result the long to narrow
- * @return an Integer if narrowing is possible, the original Long otherwise
+ * Performs a bitwise and.
+ *
+ * @param left the left operand
+ * @param right the right operator
+ * @return left & right
*/
@Override
- protected Number narrowLong(final Object lhs, final Object rhs, final long result) {
- if (!(lhs instanceof Long || rhs instanceof Long)) {
- final int ir = (int) result;
- if (result == ir) {
- return ir;
- }
+ public Object and(final Object left, final Object right) {
+ final Number l = asLongNumber(left);
+ final Number r = asLongNumber(right);
+ if (l != null && r != null) {
+ return narrowLong(left, right, l.longValue() & r.longValue());
}
- return result;
+ return toBigInteger(left).and(toBigInteger(right));
}
- /**
- * Given a long, attempt to narrow it to an int.
- * <p>Narrowing will only occur if the initial operand is not a Long.
- * @param operand the operand that lead to the long result
- * @param result the long result to narrow
- * @return an Integer if narrowing is possible, the original Long otherwise
- */
- protected Number narrowLong(final Object operand, final long result) {
- if (!(operand instanceof Long)) {
- final int ir = (int) result;
- if (result == ir) {
- return ir;
- }
- }
- return result;
- }
/**
* Checks if value class is a number that can be represented exactly in a long.
*
@@ -80,7 +62,6 @@ public class Arithmetic360 extends JexlArithmetic {
? (Number) value
: null;
}
-
/**
* Casts to Long if possible.
* @param value the Long or else
@@ -91,66 +72,68 @@ public class Arithmetic360 extends JexlArithmetic {
}
/**
- * Performs a bitwise and.
+ * Performs a bitwise complement.
*
- * @param left the left operand
- * @param right the right operator
- * @return left & right
+ * @param val the operand
+ * @return ~val
*/
@Override
- public Object and(final Object left, final Object right) {
- final Number l = asLongNumber(left);
- final Number r = asLongNumber(right);
- if (l != null && r != null) {
- return narrowLong(left, right, l.longValue() & r.longValue());
+ public Object complement(final Object val) {
+ final long l = toLong(val);
+ return narrowLong(val, ~l);
+ }
+
+ /**
+ * Given a long, attempt to narrow it to an int.
+ * <p>Narrowing will only occur if the initial operand is not a Long.
+ * @param operand the operand that lead to the long result
+ * @param result the long result to narrow
+ * @return an Integer if narrowing is possible, the original Long otherwise
+ */
+ protected Number narrowLong(final Object operand, final long result) {
+ if (!(operand instanceof Long)) {
+ final int ir = (int) result;
+ if (result == ir) {
+ return ir;
+ }
}
- return toBigInteger(left).and(toBigInteger(right));
+ return result;
}
/**
- * Performs a bitwise or.
- *
- * @param left the left operand
- * @param right the right operator
- * @return left | right
+ * Given a long, attempt to narrow it to an int.
+ * <p>Narrowing will only occur if no operand is a Long.
+ * @param lhs the left-hand side operand that lead to the long result
+ * @param rhs the right-hand side operand that lead to the long result
+ * @param result the long to narrow
+ * @return an Integer if narrowing is possible, the original Long otherwise
*/
@Override
- public Object or(final Object left, final Object right) {
- final Number l = asLongNumber(left);
- final Number r = asLongNumber(right);
- if (l != null && r != null) {
- return narrowLong(left, right, l.longValue() | r.longValue());
+ protected Number narrowLong(final Object lhs, final Object rhs, final long result) {
+ if (!(lhs instanceof Long || rhs instanceof Long)) {
+ final int ir = (int) result;
+ if (result == ir) {
+ return ir;
+ }
}
- return toBigInteger(left).or(toBigInteger(right));
+ return result;
}
/**
- * Performs a bitwise xor.
+ * Performs a bitwise or.
*
* @param left the left operand
* @param right the right operator
- * @return left ^ right
+ * @return left | right
*/
@Override
- public Object xor(final Object left, final Object right) {
+ public Object or(final Object left, final Object right) {
final Number l = asLongNumber(left);
final Number r = asLongNumber(right);
if (l != null && r != null) {
- return narrowLong(left, right, l.longValue() ^ r.longValue());
+ return narrowLong(left, right, l.longValue() | r.longValue());
}
- return toBigInteger(left).xor(toBigInteger(right));
- }
-
- /**
- * Performs a bitwise complement.
- *
- * @param val the operand
- * @return ~val
- */
- @Override
- public Object complement(final Object val) {
- final long l = toLong(val);
- return narrowLong(val, ~l);
+ return toBigInteger(left).or(toBigInteger(right));
}
/**
@@ -226,4 +209,21 @@ public class Arithmetic360 extends JexlArithmetic {
return bl.signum() < 0? bl.negate().shiftRight(r) : bl.shiftRight(r);
}
+ /**
+ * Performs a bitwise xor.
+ *
+ * @param left the left operand
+ * @param right the right operator
+ * @return left ^ right
+ */
+ @Override
+ public Object xor(final Object left, final Object right) {
+ final Number l = asLongNumber(left);
+ final Number r = asLongNumber(right);
+ if (l != null && r != null) {
+ return narrowLong(left, right, l.longValue() ^ r.longValue());
+ }
+ return toBigInteger(left).xor(toBigInteger(right));
+ }
+
}
diff --git a/src/test/java/org/apache/commons/jexl3/ArithmeticOperatorTest.java b/src/test/java/org/apache/commons/jexl3/ArithmeticOperatorTest.java
index 2fb01976..36426e7b 100644
--- a/src/test/java/org/apache/commons/jexl3/ArithmeticOperatorTest.java
+++ b/src/test/java/org/apache/commons/jexl3/ArithmeticOperatorTest.java
@@ -45,164 +45,97 @@ import org.junit.Test;
*/
@SuppressWarnings({"UnnecessaryBoxing", "AssertEqualsBetweenInconvertibleTypes"})
public class ArithmeticOperatorTest extends JexlTestCase {
- private static final TimeZone UTC = TimeZone.getTimeZone("UTC");
- private Asserter asserter;
-
- @Before
- @Override
- public void setUp() {
- asserter = new Asserter(JEXL);
- asserter.setStrict(false);
- }
-
- /**
- * Create the named test.
- */
- public ArithmeticOperatorTest() {
- super("ArithmeticOperatorTest");
+ public static class Aggregate {
+ public static int sum(final Iterable<Integer> ii) {
+ int sum = 0;
+ for(final Integer i : ii) {
+ sum += i;
+ }
+ return sum;
+ }
+ private Aggregate() {}
}
+ public static class DateArithmetic extends JexlArithmetic {
+ DateArithmetic(final boolean flag) {
+ super(flag);
+ }
- @Test
- public void testRegexp() throws Exception {
- asserter.setVariable("str", "abc456");
- asserter.assertExpression("str =~ '.*456'", Boolean.TRUE);
- asserter.assertExpression("str !~ 'ABC.*'", Boolean.TRUE);
- asserter.setVariable("match", "abc.*");
- asserter.setVariable("nomatch", ".*123");
- asserter.assertExpression("str =~ match", Boolean.TRUE);
- asserter.assertExpression("str !~ match", Boolean.FALSE);
- asserter.assertExpression("str !~ nomatch", Boolean.TRUE);
- asserter.assertExpression("str =~ nomatch", Boolean.FALSE);
- asserter.setVariable("match", new StringBuilder("abc.*"));
- asserter.setVariable("nomatch", new StringBuilder(".*123"));
- asserter.assertExpression("str =~ match", Boolean.TRUE);
- asserter.assertExpression("str !~ match", Boolean.FALSE);
- asserter.assertExpression("str !~ nomatch", Boolean.TRUE);
- asserter.assertExpression("str =~ nomatch", Boolean.FALSE);
- asserter.setVariable("match", java.util.regex.Pattern.compile("abc.*"));
- asserter.setVariable("nomatch", java.util.regex.Pattern.compile(".*123"));
- asserter.assertExpression("str =~ match", Boolean.TRUE);
- asserter.assertExpression("str !~ match", Boolean.FALSE);
- asserter.assertExpression("str !~ nomatch", Boolean.TRUE);
- asserter.assertExpression("str =~ nomatch", Boolean.FALSE);
- // check the in/not-in variant
- asserter.assertExpression("'a' =~ ['a','b','c','d','e','f']", Boolean.TRUE);
- asserter.assertExpression("'a' !~ ['a','b','c','d','e','f']", Boolean.FALSE);
- asserter.assertExpression("'z' =~ ['a','b','c','d','e','f']", Boolean.FALSE);
- asserter.assertExpression("'z' !~ ['a','b','c','d','e','f']", Boolean.TRUE);
- }
+ public Object arrayGet(final Date date, final String identifier) {
+ return getDateValue(date, identifier);
+ }
- @Test
- public void test391() throws Exception {
- // with literals
- for(final String src : Arrays.asList(
- "2 =~ [1, 2, 3, 4]",
- "[2, 3] =~ [1, 2, 3, 4]",
- "[2, 3,...] =~ [1, 2, 3, 4]",
- "3 =~ [1, 2, 3, 4,...]",
- "[2, 3] =~ [1, 2, 3, 4,...]",
- "[2, 3,...] =~ [1, 2, 3, 4,...]")) {
- asserter.assertExpression(src, Boolean.TRUE);
+ public Object arraySet(final Date date, final String identifier, final Object value) throws Exception {
+ return setDateValue(date, identifier, value);
}
- // with variables
- final int[] ic = {1, 2, 3, 4};
- final List<Integer> iic = new ArrayList<>();
- for(final int v : ic) { iic.add(v); }
- final int[] iv = {2, 3};
- final List<Integer> iiv = new ArrayList<>();
- for(final int v : iv) { iiv.add(v); }
- final String src = "(x,y) -> x =~ y ";
- for(final Object v : Arrays.asList(iv, iiv, 2)) {
- for(final Object c : Arrays.asList(ic, iic)) {
- asserter.assertExpression(src, Boolean.TRUE, v, c);
+
+ protected Object getDateValue(final Date date, final String key) {
+ try {
+ final Calendar cal = Calendar.getInstance(UTC);
+ cal.setTime(date);
+ if ("yyyy".equals(key)) {
+ return cal.get(Calendar.YEAR);
+ }
+ if ("MM".equals(key)) {
+ return cal.get(Calendar.MONTH) + 1;
+ }
+ if ("dd".equals(key)) {
+ return cal.get(Calendar.DAY_OF_MONTH);
+ }
+ // Otherwise treat as format mask
+ final SimpleDateFormat df = new SimpleDateFormat(key);//, dfs);
+ return df.format(date);
+
+ } catch (final Exception ex) {
+ return null;
}
}
- }
-
- @Test
- public void testRegexp2() throws Exception {
- asserter.setVariable("str", "abc456");
- asserter.assertExpression("str =~ ~/.*456/", Boolean.TRUE);
- asserter.assertExpression("str !~ ~/ABC.*/", Boolean.TRUE);
- asserter.assertExpression("str =~ ~/abc\\d{3}/", Boolean.TRUE);
- // legacy, deprecated
- asserter.assertExpression("matches(str, ~/.*456/)", Boolean.TRUE);
- asserter.setVariable("str", "4/6");
- asserter.assertExpression("str =~ ~/\\d\\/\\d/", Boolean.TRUE);
- }
- @Test
- public void testStartsEndsWithString() throws Exception {
- asserter.setVariable("x", "foobar");
- asserter.assertExpression("x =^ 'foo'", Boolean.TRUE);
- asserter.assertExpression("x =$ 'foo'", Boolean.FALSE);
- asserter.setVariable("x", "barfoo");
- asserter.assertExpression("x =^ 'foo'", Boolean.FALSE);
- asserter.assertExpression("x =$ 'foo'", Boolean.TRUE);
- }
+ public Date multiply(final Date d0, final Date d1) {
+ throw new ArithmeticException("unsupported");
+ }
- @Test
- public void testStartsEndsWithStringDot() throws Exception {
- asserter.setVariable("x.y", "foobar");
- asserter.assertExpression("x.y =^ 'foo'", Boolean.TRUE);
- asserter.assertExpression("x.y =$ 'foo'", Boolean.FALSE);
- asserter.setVariable("x.y", "barfoo");
- asserter.assertExpression("x.y =^ 'foo'", Boolean.FALSE);
- asserter.assertExpression("x.y =$ 'foo'", Boolean.TRUE);
- }
+ public Date now() {
+ return new Date(System.currentTimeMillis());
+ }
- @Test
- public void testNotStartsEndsWithString() throws Exception {
- asserter.setVariable("x", "foobar");
- asserter.assertExpression("x !^ 'foo'", Boolean.FALSE);
- asserter.assertExpression("x !$ 'foo'", Boolean.TRUE);
- asserter.setVariable("x", "barfoo");
- asserter.assertExpression("x !^ 'foo'", Boolean.TRUE);
- asserter.assertExpression("x !$ 'foo'", Boolean.FALSE);
- }
+ public Object propertyGet(final Date date, final String identifier) {
+ return getDateValue(date, identifier);
+ }
- @Test
- public void testNotStartsEndsWithStringDot() throws Exception {
- asserter.setVariable("x.y", "foobar");
- asserter.assertExpression("x.y !^ 'foo'", Boolean.FALSE);
- asserter.assertExpression("x.y !$ 'foo'", Boolean.TRUE);
- asserter.setVariable("x.y", "barfoo");
- asserter.assertExpression("x.y !^ 'foo'", Boolean.TRUE);
- asserter.assertExpression("x.y !$ 'foo'", Boolean.FALSE);
- }
+ public Object propertySet(final Date date, final String identifier, final Object value) throws Exception {
+ return setDateValue(date, identifier, value);
+ }
- @Test
- public void testStartsEndsWithStringBuilder() throws Exception {
- asserter.setVariable("x", new StringBuilder("foobar"));
- asserter.assertExpression("x =^ 'foo'", Boolean.TRUE);
- asserter.assertExpression("x =$ 'foo'", Boolean.FALSE);
- asserter.setVariable("x", new StringBuilder("barfoo"));
- asserter.assertExpression("x =^ 'foo'", Boolean.FALSE);
- asserter.assertExpression("x =$ 'foo'", Boolean.TRUE);
+ protected Object setDateValue(final Date date, final String key, final Object value) throws Exception {
+ final Calendar cal = Calendar.getInstance(UTC);
+ cal.setTime(date);
+ if ("yyyy".equals(key)) {
+ cal.set(Calendar.YEAR, toInteger(value));
+ } else if ("MM".equals(key)) {
+ cal.set(Calendar.MONTH, toInteger(value) - 1);
+ } else if ("dd".equals(key)) {
+ cal.set(Calendar.DAY_OF_MONTH, toInteger(value));
+ }
+ date.setTime(cal.getTimeInMillis());
+ return date;
+ }
}
- @Test
- public void testNotStartsEndsWithStringBuilder() throws Exception {
- asserter.setVariable("x", new StringBuilder("foobar"));
- asserter.assertExpression("x !^ 'foo'", Boolean.FALSE);
- asserter.assertExpression("x !$ 'foo'", Boolean.TRUE);
- asserter.setVariable("x", new StringBuilder("barfoo"));
- asserter.assertExpression("x !^ 'foo'", Boolean.TRUE);
- asserter.assertExpression("x !$ 'foo'", Boolean.FALSE);
- }
+ public static class DateContext extends MapContext {
+ private Locale locale = Locale.US;
- public static class MatchingContainer {
- private final Set<Integer> values;
+ public String format(final Date date, final String fmt) {
+ final SimpleDateFormat sdf = new SimpleDateFormat(fmt, locale);
+ sdf.setTimeZone(UTC);
+ return sdf.format(date);
+ }
- public MatchingContainer(final int[] is) {
- values = new HashSet<>();
- for (final int value : is) {
- values.add(value);
- }
+ public String format(final Number number, final String fmt) {
+ return new DecimalFormat(fmt).format(number);
}
- public boolean contains(final int value) {
- return values.contains(value);
+ void setLocale(final Locale l10n) {
+ this.locale = l10n;
}
}
@@ -216,11 +149,6 @@ public class ArithmeticOperatorTest extends JexlTestCase {
}
}
- @Override
- public Iterator<Integer> iterator() {
- return values.iterator();
- }
-
public boolean contains(final int i) {
return values.contains(i);
}
@@ -234,16 +162,12 @@ public class ArithmeticOperatorTest extends JexlTestCase {
return true;
}
- public boolean startsWith(final int i) {
- return values.first().equals(i);
- }
-
public boolean endsWith(final int i) {
return values.last().equals(i);
}
- public boolean startsWith(final int[] i) {
- final SortedSet<Integer> sw = values.headSet(i.length);
+ public boolean endsWith(final int[] i) {
+ final SortedSet<Integer> sw = values.tailSet(values.size() - i.length);
int n = 0;
for (final Integer value : sw) {
if (!value.equals(i[n++])) {
@@ -252,8 +176,17 @@ public class ArithmeticOperatorTest extends JexlTestCase {
}
return true;
}
- public boolean endsWith(final int[] i) {
- final SortedSet<Integer> sw = values.tailSet(values.size() - i.length);
+
+ @Override
+ public Iterator<Integer> iterator() {
+ return values.iterator();
+ }
+
+ public boolean startsWith(final int i) {
+ return values.first().equals(i);
+ }
+ public boolean startsWith(final int[] i) {
+ final SortedSet<Integer> sw = values.headSet(i.length);
int n = 0;
for (final Integer value : sw) {
if (!value.equals(i[n++])) {
@@ -264,234 +197,79 @@ public class ArithmeticOperatorTest extends JexlTestCase {
}
}
- @Test
- public void testMatch() throws Exception {
- // check in/not-in on array, list, map, set and duck-type collection
- final int[] ai = {2, 4, 42, 54};
- final List<Integer> al = new ArrayList<>();
- for (final int i : ai) {
- al.add(i);
+ public static class MatchingContainer {
+ private final Set<Integer> values;
+
+ public MatchingContainer(final int[] is) {
+ values = new HashSet<>();
+ for (final int value : is) {
+ values.add(value);
+ }
}
- final Map<Integer, String> am = new HashMap<>();
- am.put(2, "two");
- am.put(4, "four");
- am.put(42, "forty-two");
- am.put(54, "fifty-four");
- final MatchingContainer ad = new MatchingContainer(ai);
- final IterableContainer ic = new IterableContainer(ai);
- final Set<Integer> as = ad.values;
- final Object[] vars = {ai, al, am, ad, as, ic};
- for (final Object var : vars) {
- asserter.setVariable("container", var);
- for (final int x : ai) {
- asserter.setVariable("x", x);
- asserter.assertExpression("x =~ container", Boolean.TRUE);
- }
- asserter.setVariable("x", 169);
- asserter.assertExpression("x !~ container", Boolean.TRUE);
+ public boolean contains(final int value) {
+ return values.contains(value);
}
}
- @Test
- public void testStartsEndsWith() throws Exception {
- asserter.setVariable("x", "foobar");
- asserter.assertExpression("x =^ 'foo'", Boolean.TRUE);
- asserter.assertExpression("x =$ 'foo'", Boolean.FALSE);
- asserter.setVariable("x", "barfoo");
- asserter.assertExpression("x =^ 'foo'", Boolean.FALSE);
- asserter.assertExpression("x =$ 'foo'", Boolean.TRUE);
-
- final int[] ai = {2, 4, 42, 54};
- final IterableContainer ic = new IterableContainer(ai);
- asserter.setVariable("x", ic);
- asserter.assertExpression("x =^ 2", Boolean.TRUE);
- asserter.assertExpression("x =$ 54", Boolean.TRUE);
- asserter.assertExpression("x =^ 4", Boolean.FALSE);
- asserter.assertExpression("x =$ 42", Boolean.FALSE);
- asserter.assertExpression("x =^ [2, 4]", Boolean.TRUE);
- asserter.assertExpression("x =^ [42, 54]", Boolean.TRUE);
- }
+ private static final TimeZone UTC = TimeZone.getTimeZone("UTC");
- @Test
- public void testNotStartsEndsWith() throws Exception {
- asserter.setVariable("x", "foobar");
- asserter.assertExpression("x !^ 'foo'", Boolean.FALSE);
- asserter.assertExpression("x !$ 'foo'", Boolean.TRUE);
- asserter.setVariable("x", "barfoo");
- asserter.assertExpression("x !^ 'foo'", Boolean.TRUE);
- asserter.assertExpression("x !$ 'foo'", Boolean.FALSE);
+ private Asserter asserter;
- final int[] ai = {2, 4, 42, 54};
- final IterableContainer ic = new IterableContainer(ai);
- asserter.setVariable("x", ic);
- asserter.assertExpression("x !^ 2", Boolean.FALSE);
- asserter.assertExpression("x !$ 54", Boolean.FALSE);
- asserter.assertExpression("x !^ 4", Boolean.TRUE);
- asserter.assertExpression("x !$ 42", Boolean.TRUE);
- asserter.assertExpression("x !^ [2, 4]", Boolean.FALSE);
- asserter.assertExpression("x !^ [42, 54]", Boolean.FALSE);
+ /**
+ * Create the named test.
+ */
+ public ArithmeticOperatorTest() {
+ super("ArithmeticOperatorTest");
}
- public static class Aggregate {
- private Aggregate() {}
- public static int sum(final Iterable<Integer> ii) {
- int sum = 0;
- for(final Integer i : ii) {
- sum += i;
- }
- return sum;
- }
+ @Before
+ @Override
+ public void setUp() {
+ asserter = new Asserter(JEXL);
+ asserter.setStrict(false);
}
- @Test
- @SuppressWarnings("unchecked")
- public void testInterval() throws Exception {
- final Map<String, Object> ns = new HashMap<>();
- ns.put("calc", Aggregate.class);
- final JexlEngine jexl = new JexlBuilder().namespaces(ns).create();
- JexlScript script;
- Object result;
-
- script = jexl.createScript("1 .. 3");
- result = script.execute(null);
- Assert.assertTrue(result instanceof Iterable<?>);
- Iterator<Integer> ii = ((Iterable<Integer>) result).iterator();
- Assert.assertEquals(Integer.valueOf(1), ii.next());
- Assert.assertEquals(Integer.valueOf(2), ii.next());
- Assert.assertEquals(Integer.valueOf(3), ii.next());
-
- script = jexl.createScript("(4 - 3) .. (9 / 3)");
- result = script.execute(null);
- Assert.assertTrue(result instanceof Iterable<?>);
- ii = ((Iterable<Integer>) result).iterator();
- Assert.assertEquals(Integer.valueOf(1), ii.next());
- Assert.assertEquals(Integer.valueOf(2), ii.next());
- Assert.assertEquals(Integer.valueOf(3), ii.next());
-
- // sum of 1, 2, 3
- script = jexl.createScript("var x = 0; for(var y : ((5 - 4) .. (12 / 4))) { x = x + y }; x");
- result = script.execute(null);
- Assert.assertEquals(Integer.valueOf(6), result);
-
- script = jexl.createScript("calc:sum(1 .. 3)");
- result = script.execute(null);
- Assert.assertEquals(Integer.valueOf(6), result);
-
- script = jexl.createScript("calc:sum(-3 .. 3)");
- result = script.execute(null);
- Assert.assertEquals(Integer.valueOf(0), result);
+ @Test public void test373a() {
+ testSelfAssignOperators("y.add(x++)", 42, 42, 43);
}
- public static class DateArithmetic extends JexlArithmetic {
- DateArithmetic(final boolean flag) {
- super(flag);
- }
-
- protected Object getDateValue(final Date date, final String key) {
- try {
- final Calendar cal = Calendar.getInstance(UTC);
- cal.setTime(date);
- if ("yyyy".equals(key)) {
- return cal.get(Calendar.YEAR);
- }
- if ("MM".equals(key)) {
- return cal.get(Calendar.MONTH) + 1;
- }
- if ("dd".equals(key)) {
- return cal.get(Calendar.DAY_OF_MONTH);
- }
- // Otherwise treat as format mask
- final SimpleDateFormat df = new SimpleDateFormat(key);//, dfs);
- return df.format(date);
-
- } catch (final Exception ex) {
- return null;
- }
- }
-
- protected Object setDateValue(final Date date, final String key, final Object value) throws Exception {
- final Calendar cal = Calendar.getInstance(UTC);
- cal.setTime(date);
- if ("yyyy".equals(key)) {
- cal.set(Calendar.YEAR, toInteger(value));
- } else if ("MM".equals(key)) {
- cal.set(Calendar.MONTH, toInteger(value) - 1);
- } else if ("dd".equals(key)) {
- cal.set(Calendar.DAY_OF_MONTH, toInteger(value));
- }
- date.setTime(cal.getTimeInMillis());
- return date;
- }
-
- public Object propertyGet(final Date date, final String identifier) {
- return getDateValue(date, identifier);
- }
-
- public Object propertySet(final Date date, final String identifier, final Object value) throws Exception {
- return setDateValue(date, identifier, value);
- }
-
- public Object arrayGet(final Date date, final String identifier) {
- return getDateValue(date, identifier);
- }
-
- public Object arraySet(final Date date, final String identifier, final Object value) throws Exception {
- return setDateValue(date, identifier, value);
- }
-
- public Date now() {
- return new Date(System.currentTimeMillis());
- }
-
- public Date multiply(final Date d0, final Date d1) {
- throw new ArithmeticException("unsupported");
- }
+ @Test public void test373b() {
+ testSelfAssignOperators("y.add(++x)", 42, 43, 43);
}
- public static class DateContext extends MapContext {
- private Locale locale = Locale.US;
-
- void setLocale(final Locale l10n) {
- this.locale = l10n;
- }
-
- public String format(final Date date, final String fmt) {
- final SimpleDateFormat sdf = new SimpleDateFormat(fmt, locale);
- sdf.setTimeZone(UTC);
- return sdf.format(date);
- }
-
- public String format(final Number number, final String fmt) {
- return new DecimalFormat(fmt).format(number);
- }
+ @Test public void test373c() {
+ testSelfAssignOperators("y.add(x--)", 42, 42, 41);
}
- @Test
- public void testOperatorError() throws Exception {
- testOperatorError(true);
- testOperatorError(false);
+ @Test public void test373d() {
+ testSelfAssignOperators("y.add(--x)", 42, 41, 41);
}
- private void testOperatorError(final boolean silent) throws Exception {
- final CaptureLog log = new CaptureLog();
- final DateContext jc = new DateContext();
- final Date d = new Date();
- final JexlEngine jexl = new JexlBuilder().logger(log).strict(true).silent(silent).cache(32)
- .arithmetic(new DateArithmetic(true)).create();
- final JexlScript expr0 = jexl.createScript("date * date", "date");
- try {
- final Object value0 = expr0.execute(jc, d);
- if (!silent) {
- Assert.fail("should have failed");
- } else {
- Assert.assertEquals(1, log.count("warn"));
- }
- } catch (final JexlException.Operator xop) {
- Assert.assertEquals("*", xop.getSymbol());
+ @Test
+ public void test391() throws Exception {
+ // with literals
+ for(final String src : Arrays.asList(
+ "2 =~ [1, 2, 3, 4]",
+ "[2, 3] =~ [1, 2, 3, 4]",
+ "[2, 3,...] =~ [1, 2, 3, 4]",
+ "3 =~ [1, 2, 3, 4,...]",
+ "[2, 3] =~ [1, 2, 3, 4,...]",
+ "[2, 3,...] =~ [1, 2, 3, 4,...]")) {
+ asserter.assertExpression(src, Boolean.TRUE);
}
- if (!silent) {
- Assert.assertEquals(0, log.count("warn"));
+ // with variables
+ final int[] ic = {1, 2, 3, 4};
+ final List<Integer> iic = new ArrayList<>();
+ for(final int v : ic) { iic.add(v); }
+ final int[] iv = {2, 3};
+ final List<Integer> iiv = new ArrayList<>();
+ for(final int v : iv) { iiv.add(v); }
+ final String src = "(x,y) -> x =~ y ";
+ for(final Object v : Arrays.asList(iv, iiv, 2)) {
+ for(final Object c : Arrays.asList(ic, iic)) {
+ asserter.assertExpression(src, Boolean.TRUE, v, c);
+ }
}
}
@@ -591,19 +369,206 @@ public class ArithmeticOperatorTest extends JexlTestCase {
Assert.assertNotNull(strws);
}
- @Test public void test373a() {
- testSelfAssignOperators("y.add(x++)", 42, 42, 43);
+ @Test
+ public void testIncrementOperatorOnNull() throws Exception {
+ final JexlEngine jexl = new JexlBuilder().strict(false).create();
+ JexlScript script;
+ Object result;
+ script = jexl.createScript("var i = null; ++i");
+ result = script.execute(null);
+ Assert.assertEquals(1, result);
+ script = jexl.createScript("var i = null; --i");
+ result = script.execute(null);
+ Assert.assertEquals(-1, result);
}
- @Test public void test373b() {
- testSelfAssignOperators("y.add(++x)", 42, 43, 43);
+
+ @Test
+ @SuppressWarnings("unchecked")
+ public void testInterval() throws Exception {
+ final Map<String, Object> ns = new HashMap<>();
+ ns.put("calc", Aggregate.class);
+ final JexlEngine jexl = new JexlBuilder().namespaces(ns).create();
+ JexlScript script;
+ Object result;
+
+ script = jexl.createScript("1 .. 3");
+ result = script.execute(null);
+ Assert.assertTrue(result instanceof Iterable<?>);
+ Iterator<Integer> ii = ((Iterable<Integer>) result).iterator();
+ Assert.assertEquals(Integer.valueOf(1), ii.next());
+ Assert.assertEquals(Integer.valueOf(2), ii.next());
+ Assert.assertEquals(Integer.valueOf(3), ii.next());
+
+ script = jexl.createScript("(4 - 3) .. (9 / 3)");
+ result = script.execute(null);
+ Assert.assertTrue(result instanceof Iterable<?>);
+ ii = ((Iterable<Integer>) result).iterator();
+ Assert.assertEquals(Integer.valueOf(1), ii.next());
+ Assert.assertEquals(Integer.valueOf(2), ii.next());
+ Assert.assertEquals(Integer.valueOf(3), ii.next());
+
+ // sum of 1, 2, 3
+ script = jexl.createScript("var x = 0; for(var y : ((5 - 4) .. (12 / 4))) { x = x + y }; x");
+ result = script.execute(null);
+ Assert.assertEquals(Integer.valueOf(6), result);
+
+ script = jexl.createScript("calc:sum(1 .. 3)");
+ result = script.execute(null);
+ Assert.assertEquals(Integer.valueOf(6), result);
+
+ script = jexl.createScript("calc:sum(-3 .. 3)");
+ result = script.execute(null);
+ Assert.assertEquals(Integer.valueOf(0), result);
}
- @Test public void test373c() {
- testSelfAssignOperators("y.add(x--)", 42, 42, 41);
+
+ @Test
+ public void testMatch() throws Exception {
+ // check in/not-in on array, list, map, set and duck-type collection
+ final int[] ai = {2, 4, 42, 54};
+ final List<Integer> al = new ArrayList<>();
+ for (final int i : ai) {
+ al.add(i);
+ }
+ final Map<Integer, String> am = new HashMap<>();
+ am.put(2, "two");
+ am.put(4, "four");
+ am.put(42, "forty-two");
+ am.put(54, "fifty-four");
+ final MatchingContainer ad = new MatchingContainer(ai);
+ final IterableContainer ic = new IterableContainer(ai);
+ final Set<Integer> as = ad.values;
+ final Object[] vars = {ai, al, am, ad, as, ic};
+
+ for (final Object var : vars) {
+ asserter.setVariable("container", var);
+ for (final int x : ai) {
+ asserter.setVariable("x", x);
+ asserter.assertExpression("x =~ container", Boolean.TRUE);
+ }
+ asserter.setVariable("x", 169);
+ asserter.assertExpression("x !~ container", Boolean.TRUE);
+ }
}
- @Test public void test373d() {
- testSelfAssignOperators("y.add(--x)", 42, 41, 41);
+
+ @Test
+ public void testNotStartsEndsWith() throws Exception {
+ asserter.setVariable("x", "foobar");
+ asserter.assertExpression("x !^ 'foo'", Boolean.FALSE);
+ asserter.assertExpression("x !$ 'foo'", Boolean.TRUE);
+ asserter.setVariable("x", "barfoo");
+ asserter.assertExpression("x !^ 'foo'", Boolean.TRUE);
+ asserter.assertExpression("x !$ 'foo'", Boolean.FALSE);
+
+ final int[] ai = {2, 4, 42, 54};
+ final IterableContainer ic = new IterableContainer(ai);
+ asserter.setVariable("x", ic);
+ asserter.assertExpression("x !^ 2", Boolean.FALSE);
+ asserter.assertExpression("x !$ 54", Boolean.FALSE);
+ asserter.assertExpression("x !^ 4", Boolean.TRUE);
+ asserter.assertExpression("x !$ 42", Boolean.TRUE);
+ asserter.assertExpression("x !^ [2, 4]", Boolean.FALSE);
+ asserter.assertExpression("x !^ [42, 54]", Boolean.FALSE);
+ }
+
+ @Test
+ public void testNotStartsEndsWithString() throws Exception {
+ asserter.setVariable("x", "foobar");
+ asserter.assertExpression("x !^ 'foo'", Boolean.FALSE);
+ asserter.assertExpression("x !$ 'foo'", Boolean.TRUE);
+ asserter.setVariable("x", "barfoo");
+ asserter.assertExpression("x !^ 'foo'", Boolean.TRUE);
+ asserter.assertExpression("x !$ 'foo'", Boolean.FALSE);
+ }
+
+ @Test
+ public void testNotStartsEndsWithStringBuilder() throws Exception {
+ asserter.setVariable("x", new StringBuilder("foobar"));
+ asserter.assertExpression("x !^ 'foo'", Boolean.FALSE);
+ asserter.assertExpression("x !$ 'foo'", Boolean.TRUE);
+ asserter.setVariable("x", new StringBuilder("barfoo"));
+ asserter.assertExpression("x !^ 'foo'", Boolean.TRUE);
+ asserter.assertExpression("x !$ 'foo'", Boolean.FALSE);
+ }
+
+ @Test
+ public void testNotStartsEndsWithStringDot() throws Exception {
+ asserter.setVariable("x.y", "foobar");
+ asserter.assertExpression("x.y !^ 'foo'", Boolean.FALSE);
+ asserter.assertExpression("x.y !$ 'foo'", Boolean.TRUE);
+ asserter.setVariable("x.y", "barfoo");
+ asserter.assertExpression("x.y !^ 'foo'", Boolean.TRUE);
+ asserter.assertExpression("x.y !$ 'foo'", Boolean.FALSE);
+ }
+
+ @Test
+ public void testOperatorError() throws Exception {
+ testOperatorError(true);
+ testOperatorError(false);
+ }
+
+ private void testOperatorError(final boolean silent) throws Exception {
+ final CaptureLog log = new CaptureLog();
+ final DateContext jc = new DateContext();
+ final Date d = new Date();
+ final JexlEngine jexl = new JexlBuilder().logger(log).strict(true).silent(silent).cache(32)
+ .arithmetic(new DateArithmetic(true)).create();
+ final JexlScript expr0 = jexl.createScript("date * date", "date");
+ try {
+ final Object value0 = expr0.execute(jc, d);
+ if (!silent) {
+ Assert.fail("should have failed");
+ } else {
+ Assert.assertEquals(1, log.count("warn"));
+ }
+ } catch (final JexlException.Operator xop) {
+ Assert.assertEquals("*", xop.getSymbol());
+ }
+ if (!silent) {
+ Assert.assertEquals(0, log.count("warn"));
+ }
}
+ @Test
+ public void testRegexp() throws Exception {
+ asserter.setVariable("str", "abc456");
+ asserter.assertExpression("str =~ '.*456'", Boolean.TRUE);
+ asserter.assertExpression("str !~ 'ABC.*'", Boolean.TRUE);
+ asserter.setVariable("match", "abc.*");
+ asserter.setVariable("nomatch", ".*123");
+ asserter.assertExpression("str =~ match", Boolean.TRUE);
+ asserter.assertExpression("str !~ match", Boolean.FALSE);
+ asserter.assertExpression("str !~ nomatch", Boolean.TRUE);
+ asserter.assertExpression("str =~ nomatch", Boolean.FALSE);
+ asserter.setVariable("match", new StringBuilder("abc.*"));
+ asserter.setVariable("nomatch", new StringBuilder(".*123"));
+ asserter.assertExpression("str =~ match", Boolean.TRUE);
+ asserter.assertExpression("str !~ match", Boolean.FALSE);
+ asserter.assertExpression("str !~ nomatch", Boolean.TRUE);
+ asserter.assertExpression("str =~ nomatch", Boolean.FALSE);
+ asserter.setVariable("match", java.util.regex.Pattern.compile("abc.*"));
+ asserter.setVariable("nomatch", java.util.regex.Pattern.compile(".*123"));
+ asserter.assertExpression("str =~ match", Boolean.TRUE);
+ asserter.assertExpression("str !~ match", Boolean.FALSE);
+ asserter.assertExpression("str !~ nomatch", Boolean.TRUE);
+ asserter.assertExpression("str =~ nomatch", Boolean.FALSE);
+ // check the in/not-in variant
+ asserter.assertExpression("'a' =~ ['a','b','c','d','e','f']", Boolean.TRUE);
+ asserter.assertExpression("'a' !~ ['a','b','c','d','e','f']", Boolean.FALSE);
+ asserter.assertExpression("'z' =~ ['a','b','c','d','e','f']", Boolean.FALSE);
+ asserter.assertExpression("'z' !~ ['a','b','c','d','e','f']", Boolean.TRUE);
+ }
+
+ @Test
+ public void testRegexp2() throws Exception {
+ asserter.setVariable("str", "abc456");
+ asserter.assertExpression("str =~ ~/.*456/", Boolean.TRUE);
+ asserter.assertExpression("str !~ ~/ABC.*/", Boolean.TRUE);
+ asserter.assertExpression("str =~ ~/abc\\d{3}/", Boolean.TRUE);
+ // legacy, deprecated
+ asserter.assertExpression("matches(str, ~/.*456/)", Boolean.TRUE);
+ asserter.setVariable("str", "4/6");
+ asserter.assertExpression("str =~ ~/\\d\\/\\d/", Boolean.TRUE);
+ }
void testSelfAssignOperators(final String text, final int x, final int y0, final int x0) {
//String text = "y.add(x++)";
final JexlEngine jexl = new JexlBuilder().safe(true).create();
@@ -616,18 +581,53 @@ public class ArithmeticOperatorTest extends JexlTestCase {
Assert.assertEquals("x0", x0, context.get("x"));
Assert.assertEquals("y0", y0, y.get(0));
}
+ @Test
+ public void testStartsEndsWith() throws Exception {
+ asserter.setVariable("x", "foobar");
+ asserter.assertExpression("x =^ 'foo'", Boolean.TRUE);
+ asserter.assertExpression("x =$ 'foo'", Boolean.FALSE);
+ asserter.setVariable("x", "barfoo");
+ asserter.assertExpression("x =^ 'foo'", Boolean.FALSE);
+ asserter.assertExpression("x =$ 'foo'", Boolean.TRUE);
+ final int[] ai = {2, 4, 42, 54};
+ final IterableContainer ic = new IterableContainer(ai);
+ asserter.setVariable("x", ic);
+ asserter.assertExpression("x =^ 2", Boolean.TRUE);
+ asserter.assertExpression("x =$ 54", Boolean.TRUE);
+ asserter.assertExpression("x =^ 4", Boolean.FALSE);
+ asserter.assertExpression("x =$ 42", Boolean.FALSE);
+ asserter.assertExpression("x =^ [2, 4]", Boolean.TRUE);
+ asserter.assertExpression("x =^ [42, 54]", Boolean.TRUE);
+ }
@Test
- public void testIncrementOperatorOnNull() throws Exception {
- final JexlEngine jexl = new JexlBuilder().strict(false).create();
- JexlScript script;
- Object result;
- script = jexl.createScript("var i = null; ++i");
- result = script.execute(null);
- Assert.assertEquals(1, result);
- script = jexl.createScript("var i = null; --i");
- result = script.execute(null);
- Assert.assertEquals(-1, result);
+ public void testStartsEndsWithString() throws Exception {
+ asserter.setVariable("x", "foobar");
+ asserter.assertExpression("x =^ 'foo'", Boolean.TRUE);
+ asserter.assertExpression("x =$ 'foo'", Boolean.FALSE);
+ asserter.setVariable("x", "barfoo");
+ asserter.assertExpression("x =^ 'foo'", Boolean.FALSE);
+ asserter.assertExpression("x =$ 'foo'", Boolean.TRUE);
+ }
+
+ @Test
+ public void testStartsEndsWithStringBuilder() throws Exception {
+ asserter.setVariable("x", new StringBuilder("foobar"));
+ asserter.assertExpression("x =^ 'foo'", Boolean.TRUE);
+ asserter.assertExpression("x =$ 'foo'", Boolean.FALSE);
+ asserter.setVariable("x", new StringBuilder("barfoo"));
+ asserter.assertExpression("x =^ 'foo'", Boolean.FALSE);
+ asserter.assertExpression("x =$ 'foo'", Boolean.TRUE);
+ }
+
+ @Test
+ public void testStartsEndsWithStringDot() throws Exception {
+ asserter.setVariable("x.y", "foobar");
+ asserter.assertExpression("x.y =^ 'foo'", Boolean.TRUE);
+ asserter.assertExpression("x.y =$ 'foo'", Boolean.FALSE);
+ asserter.setVariable("x.y", "barfoo");
+ asserter.assertExpression("x.y =^ 'foo'", Boolean.FALSE);
+ asserter.assertExpression("x.y =$ 'foo'", Boolean.TRUE);
}
}
diff --git a/src/test/java/org/apache/commons/jexl3/ArithmeticTest.java b/src/test/java/org/apache/commons/jexl3/ArithmeticTest.java
index 149809ea..7f92e95c 100644
--- a/src/test/java/org/apache/commons/jexl3/ArithmeticTest.java
+++ b/src/test/java/org/apache/commons/jexl3/ArithmeticTest.java
@@ -43,648 +43,568 @@ import org.w3c.dom.Node;
@SuppressWarnings({"UnnecessaryBoxing", "AssertEqualsBetweenInconvertibleTypes"})
public class ArithmeticTest extends JexlTestCase {
- /** A small delta to compare doubles. */
- private static final double EPSILON = 1.e-6;
- private final Asserter asserter;
- private final JexlArithmetic jexla;
- private final JexlArithmetic jexlb;
- private final Date date = new Date();
-
- public ArithmeticTest() {
- super("ArithmeticTest");
- asserter = new Asserter(JEXL);
- jexla = JEXL.getArithmetic();
- final JexlOptions options = new JexlOptions();
- options.setStrictArithmetic(false);
- jexlb = jexla.options(options);
- }
+ public static class Arithmetic132 extends JexlArithmetic {
+ public Arithmetic132() {
+ super(false);
+ }
- @Before
- @Override
- public void setUp() {
- }
+ @Override
+ public Object divide(final Object left, final Object right) {
+ if (left == null && right == null) {
+ return controlNullNullOperands(JexlOperator.DIVIDE);
+ }
+ // if either are bigdecimal use that type
+ if (left instanceof BigDecimal || right instanceof BigDecimal) {
+ final BigDecimal l = toBigDecimal(left);
+ final BigDecimal r = toBigDecimal(right);
+ if (BigDecimal.ZERO.equals(r)) {
+ return divideZero(l);
+ }
+ final BigDecimal result = l.divide(r, getMathContext());
+ return narrowBigDecimal(left, right, result);
+ }
+ // if either are floating point (double or float) use double
+ if (isFloatingPointNumber(left) || isFloatingPointNumber(right)) {
+ final double l = toDouble(left);
+ final double r = toDouble(right);
+ return Double.valueOf(l / r);
+ }
+ // otherwise treat as integers
+ final BigInteger l = toBigInteger(left);
+ final BigInteger r = toBigInteger(right);
+ if (BigInteger.ZERO.equals(r)) {
+ return divideZero(l);
+ }
+ final BigInteger result = l.divide(r);
+ return narrowBigInteger(left, right, result);
+ }
- static private void assertNullOperand(final java.util.function.Supplier<Object> fun) {
- try {
- Assert.assertNull(fun.get());
- } catch (final JexlArithmetic.NullOperand xany) {
- Assert.assertNotNull(xany);
+ protected double divideZero(final BigDecimal x) {
+ final int ls = x.signum();
+ if (ls < 0) {
+ return Double.NEGATIVE_INFINITY;
+ }
+ if (ls > 0) {
+ return Double.POSITIVE_INFINITY;
+ }
+ return Double.NaN;
}
- }
- static private void assertArithmeticException(final java.util.function.Supplier<Object> fun) {
- try {
- Assert.assertNull(fun.get());
- } catch (final ArithmeticException xany) {
- Assert.assertNotNull(xany);
+ protected double divideZero(final BigInteger x) {
+ final int ls = x.signum();
+ if (ls < 0) {
+ return Double.NEGATIVE_INFINITY;
+ }
+ if (ls > 0) {
+ return Double.POSITIVE_INFINITY;
+ }
+ return Double.NaN;
}
- }
- @Test
- public void testModEdge() {
- assertNullOperand(() -> jexla.mod(null, null));
- Assert.assertEquals(0, jexlb.mod(null, null));
- assertArithmeticException(() -> jexla.mod(1, 0));
- assertArithmeticException(() -> jexla.mod(1L, 0L));
- assertArithmeticException(() -> jexla.mod(1f, 0f));
- assertArithmeticException(() -> jexla.mod(1d, 0d));
- assertArithmeticException(() -> jexla.mod(BigInteger.ONE, BigInteger.ZERO));
- assertArithmeticException(() -> jexla.mod(BigInteger.ONE, BigDecimal.ZERO));
- assertNullOperand(() -> jexla.divide(null, null));
+ @Override
+ public Object mod(final Object left, final Object right) {
+ if (left == null && right == null) {
+ return controlNullNullOperands(JexlOperator.MOD);
+ }
+ // if either are bigdecimal use that type
+ if (left instanceof BigDecimal || right instanceof BigDecimal) {
+ final BigDecimal l = toBigDecimal(left);
+ final BigDecimal r = toBigDecimal(right);
+ if (BigDecimal.ZERO.equals(r)) {
+ return divideZero(l);
+ }
+ final BigDecimal remainder = l.remainder(r, getMathContext());
+ return narrowBigDecimal(left, right, remainder);
+ }
+ // if either are floating point (double or float) use double
+ if (isFloatingPointNumber(left) || isFloatingPointNumber(right)) {
+ final double l = toDouble(left);
+ final double r = toDouble(right);
+ return Double.valueOf(l % r);
+ }
+ // otherwise treat as integers
+ final BigInteger l = toBigInteger(left);
+ final BigInteger r = toBigInteger(right);
+ final BigInteger result = l.mod(r);
+ if (BigInteger.ZERO.equals(r)) {
+ return divideZero(l);
+ }
+ return narrowBigInteger(left, right, result);
+ }
}
+ // an arithmetic that knows how to deal with vars
+ public static class ArithmeticPlus extends JexlArithmetic {
+ public ArithmeticPlus(final boolean strict) {
+ super(strict);
+ }
- @Test
- public void testUnaryopsEdges() {
- assertArithmeticException(() -> jexla.positivize(date));
- assertNullOperand(() -> jexla.positivize(null));
- Assert.assertNull(jexlb.positivize(null));
- Assert.assertEquals(42, jexla.positivize((char) 42));
- Assert.assertEquals(Boolean.TRUE, jexla.positivize(Boolean.TRUE));
- Assert.assertEquals(Boolean.FALSE, jexla.positivize(Boolean.FALSE));
- Assert.assertEquals(Boolean.TRUE, jexla.positivize(new AtomicBoolean(true)));
- Assert.assertEquals(Boolean.FALSE, jexla.positivize(new AtomicBoolean(false)));
+ public Var add(final Var lhs, final Var rhs) {
+ return new Var(lhs.value + rhs.value);
+ }
- assertNullOperand(() -> jexla.negate(null));
- Assert.assertNull(jexlb.negate(null));
- assertArithmeticException(() -> jexla.negate(date));
- Assert.assertEquals(Boolean.FALSE, jexla.negate(Boolean.TRUE));
- Assert.assertEquals(Boolean.TRUE, jexla.negate(Boolean.FALSE));
- }
+ public Var and(final Var lhs, final Var rhs) {
+ return new Var(lhs.value & rhs.value);
+ }
- @Test
- public void testDivideEdges() {
- assertNullOperand(() -> jexla.divide(null, null));
- Assert.assertEquals(0, jexlb.divide(null, null));
- assertNullOperand(() -> jexla.divide(null, null));
- Assert.assertEquals(0, jexlb.mod(null, null));
- assertArithmeticException(() -> jexla.divide(1, 0));
- assertArithmeticException(() -> jexla.divide(1L, 0L));
- assertArithmeticException(() -> jexla.divide(1f, 0f));
- assertArithmeticException(() -> jexla.divide(1d, 0d));
- assertArithmeticException(() -> jexla.divide(BigInteger.ONE, BigInteger.ZERO));
- assertArithmeticException(() -> jexla.divide(BigInteger.ONE, BigDecimal.ZERO));
- }
+ public Var complement(final Var arg) {
+ return new Var(~arg.value);
+ }
+ public Boolean contains(final Var lhs, final Var rhs) {
+ return lhs.toString().contains(rhs.toString());
+ }
- @Test
- public void testOperatorsEdges() {
- assertNullOperand(() -> jexla.multiply(null, null));
- Assert.assertEquals(0, jexlb.multiply(null, null));
- assertNullOperand(() -> jexla.add(null, null));
- Assert.assertEquals(0, jexlb.add(null, null));
- assertNullOperand(() -> jexla.subtract(null, null));
- Assert.assertEquals(0, jexlb.subtract(null, null));
+ public Var divide(final Var lhs, final Var rhs) {
+ return new Var(lhs.value / rhs.value);
+ }
- Assert.assertTrue(jexla.contains(null, null));
- Assert.assertFalse(jexla.contains(true, null));
- Assert.assertFalse(jexla.contains(null, true));
- Assert.assertTrue(jexla.endsWith(null, null));
- Assert.assertFalse(jexla.endsWith(true, null));
- Assert.assertFalse(jexla.endsWith(null, true));
- Assert.assertTrue(jexla.startsWith(null, null));
- Assert.assertFalse(jexla.startsWith(true, null));
- Assert.assertFalse(jexla.startsWith(null, true));
- Assert.assertTrue(jexla.isEmpty(null));
- }
+ public Boolean endsWith(final Var lhs, final Var rhs) {
+ return lhs.toString().endsWith(rhs.toString());
+ }
- @Test
- public void testIntegerCoercionEdges() {
- assertNullOperand(() -> jexla.toBoolean(null));
- Assert.assertTrue(jexla.toBoolean(date));
- // int coercions
- assertNullOperand(() -> jexla.toInteger(null));
- Assert.assertEquals(0, jexlb.toInteger(null));
- assertArithmeticException(() -> jexla.toInteger(date));
- Assert.assertEquals(0, jexla.toInteger(Double.NaN));
- Assert.assertEquals(0, jexla.toInteger(""));
- Assert.assertEquals('b', jexla.toInteger('b'));
- Assert.assertEquals(1, jexla.toInteger(new AtomicBoolean(true)));
- Assert.assertEquals(0, jexla.toInteger(new AtomicBoolean(false)));
+ public boolean equals(final Var lhs, final Var rhs) {
+ return lhs.value == rhs.value;
+ }
- // long coercions
- assertNullOperand(() -> jexla.toLong(null));
- Assert.assertEquals(0L, jexlb.toLong(null));
- assertArithmeticException(() -> jexla.toLong(date));
- Assert.assertEquals(0L, jexla.toLong(Double.NaN));
- Assert.assertEquals(0L, jexla.toLong(""));
- Assert.assertEquals('b', jexla.toLong('b'));
- Assert.assertEquals(1L, jexla.toLong(new AtomicBoolean(true)));
- Assert.assertEquals(0L, jexla.toLong(new AtomicBoolean(false)));
- }
+ public boolean greaterThan(final Var lhs, final Var rhs) {
+ return lhs.value > rhs.value;
+ }
- @Test
- public void testRealCoercionEdges() {
- assertNullOperand(() -> jexla.toDouble(null));
- Assert.assertEquals(0.0d, jexlb.toDouble(null), EPSILON);
- Assert.assertEquals(32.0d, jexlb.toDouble((char) 32), EPSILON);
- assertArithmeticException(() -> jexla.toDouble(date));
- Assert.assertTrue(Double.isNaN(jexla.toDouble("")));
- Assert.assertEquals("", jexla.toString(Double.NaN));
+ public boolean greaterThanOrEqual(final Var lhs, final Var rhs) {
+ return lhs.value >= rhs.value;
+ }
- assertNullOperand(() -> jexla.toBigInteger(null));
- assertArithmeticException(() -> jexla.toBigInteger(date));
- Assert.assertEquals(BigInteger.ZERO, jexla.toBigInteger(Double.NaN));
- Assert.assertEquals(BigInteger.ZERO, jexla.toBigInteger(""));
- Assert.assertEquals(BigInteger.ZERO, jexla.toBigInteger((char) 0));
+ public boolean lessThan(final Var lhs, final Var rhs) {
+ return lhs.value < rhs.value;
+ }
- assertNullOperand(() -> jexla.toBigDecimal(null));
- assertArithmeticException(() -> jexla.toBigDecimal(date));
+ public boolean lessThanOrEqual(final Var lhs, final Var rhs) {
+ return lhs.value <= rhs.value;
+ }
- Assert.assertEquals(BigDecimal.ZERO, jexla.toBigDecimal(Double.NaN));
- Assert.assertEquals(BigDecimal.ZERO, jexla.toBigDecimal(""));
- Assert.assertEquals(BigDecimal.ZERO, jexla.toBigDecimal((char) 0));
- }
+ public Var mod(final Var lhs, final Var rhs) {
+ return new Var(lhs.value / rhs.value);
+ }
- @Test
- public void testUndefinedVar() throws Exception {
- asserter.failExpression("objects[1].status", ".*variable 'objects' is undefined.*");
- }
+ public Var multiply(final Var lhs, final Var rhs) {
+ return new Var(lhs.value * rhs.value);
+ }
- @Test
- public void testLeftNullOperand() throws Exception {
- asserter.setVariable("left", null);
- asserter.setVariable("right", Integer.valueOf(8));
- asserter.setStrict(true);
- asserter.failExpression("left + right", ".*null.*");
- asserter.failExpression("left - right", ".*null.*");
- asserter.failExpression("left * right", ".*null.*");
- asserter.failExpression("left / right", ".*null.*");
- asserter.failExpression("left % right", ".*null.*");
- asserter.failExpression("left & right", ".*null.*");
- asserter.failExpression("left | right", ".*null.*");
- asserter.failExpression("left ^ right", ".*null.*");
- asserter.failExpression("left < right", ".*null.*");
- asserter.failExpression("left <= right", ".*null.*");
- asserter.failExpression("left > right", ".*null.*");
- asserter.failExpression("left >= right", ".*null.*");
- }
+ public Object negate(final String str) {
+ final int length = str.length();
+ final StringBuilder strb = new StringBuilder(str.length());
+ for (int c = length - 1; c >= 0; --c) {
+ strb.append(str.charAt(c));
+ }
+ return strb.toString();
+ }
- @Test
- public void testLeftNullOperand2() throws Exception {
- asserter.setVariable("x.left", null);
- asserter.setVariable("right", Integer.valueOf(8));
- asserter.setStrict(true);
- asserter.failExpression("x.left + right", ".*null.*");
- asserter.failExpression("x.left - right", ".*null.*");
- asserter.failExpression("x.left * right", ".*null.*");
- asserter.failExpression("x.left / right", ".*null.*");
- asserter.failExpression("x.left % right", ".*null.*");
- asserter.failExpression("x.left & right", ".*null.*");
- asserter.failExpression("x.left | right", ".*null.*");
- asserter.failExpression("x.left ^ right", ".*null.*");
- asserter.failExpression("x.left < right", ".*null.*");
- asserter.failExpression("x.left <= right", ".*null.*");
- asserter.failExpression("x.left > right", ".*null.*");
- asserter.failExpression("x.left >= right", ".*null.*");
- }
+ public Var negate(final Var arg) {
+ return new Var(-arg.value);
+ }
- @Test
- public void testRightNullOperand() throws Exception {
- asserter.setVariable("left", Integer.valueOf(9));
- asserter.setVariable("right", null);
- asserter.failExpression("left + right", ".*null.*");
- asserter.failExpression("left - right", ".*null.*");
- asserter.failExpression("left * right", ".*null.*");
- asserter.failExpression("left / right", ".*null.*");
- asserter.failExpression("left % right", ".*null.*");
- asserter.failExpression("left & right", ".*null.*");
- asserter.failExpression("left | right", ".*null.*");
- asserter.failExpression("left ^ right", ".*null.*");
- asserter.failExpression("left < right", ".*null.*");
- asserter.failExpression("left <= right", ".*null.*");
- asserter.failExpression("left > right", ".*null.*");
- asserter.failExpression("left >= right", ".*null.*");
- }
+ public Object not(final Var x) {
+ throw new NullPointerException("make it fail");
+ }
- @Test
- public void testRightNullOperand2() throws Exception {
- asserter.setVariable("left", Integer.valueOf(9));
- asserter.setVariable("y.right", null);
- asserter.failExpression("left + y.right", ".*null.*");
- asserter.failExpression("left - y.right", ".*null.*");
- asserter.failExpression("left * y.right", ".*null.*");
- asserter.failExpression("left / y.right", ".*null.*");
- asserter.failExpression("left % y.right", ".*null.*");
- asserter.failExpression("left & y.right", ".*null.*");
- asserter.failExpression("left | y.right", ".*null.*");
- asserter.failExpression("left ^ y.right", ".*null.*");
- asserter.failExpression("left < y.right", ".*null.*");
- asserter.failExpression("left <= y.right", ".*null.*");
- asserter.failExpression("left > y.right", ".*null.*");
- asserter.failExpression("left >= y.right", ".*null.*");
- }
+ public Var or(final Var lhs, final Var rhs) {
+ return new Var(lhs.value | rhs.value);
+ }
- @Test
- public void testNullOperands() throws Exception {
- asserter.setVariable("left", null);
- asserter.setVariable("right", null);
- asserter.failExpression("left + right", ".*null.*");
- asserter.failExpression("left - right", ".*null.*");
- asserter.failExpression("left * right", ".*null.*");
- asserter.failExpression("left / right", ".*null.*");
- asserter.failExpression("left % right", ".*null.*");
- asserter.failExpression("left & right", ".*null.*");
- asserter.failExpression("left | right", ".*null.*");
- asserter.failExpression("left ^ right", ".*null.*");
- }
+ public Var shiftLeft(final Var lhs, final Var rhs) {
+ return new Var(lhs.value << rhs.value);
+ }
- @Test
- public void testNullOperand() throws Exception {
- asserter.setVariable("right", null);
- asserter.failExpression("~right", ".*null.*");
- }
+ public Var shiftRight(final Var lhs, final Var rhs) {
+ return new Var(lhs.value >> rhs.value);
+ }
- @Test
- public void testBigDecimal() throws Exception {
- asserter.setVariable("left", new BigDecimal(2));
- asserter.setVariable("right", new BigDecimal(6));
- asserter.assertExpression("left + right", new BigDecimal(8));
- asserter.assertExpression("right - left", new BigDecimal(4));
- asserter.assertExpression("right * left", new BigDecimal(12));
- asserter.assertExpression("right / left", new BigDecimal(3));
- asserter.assertExpression("right % left", new BigDecimal(0));
- }
+ public Var shiftRightUnsigned(final Var lhs, final Var rhs) {
+ return new Var(lhs.value >>> rhs.value);
+ }
- @Test
- public void testBigInteger() throws Exception {
- asserter.setVariable("left", new BigInteger("2"));
- asserter.setVariable("right", new BigInteger("6"));
- asserter.assertExpression("left + right", new BigInteger("8"));
- asserter.assertExpression("right - left", new BigInteger("4"));
- asserter.assertExpression("right * left", new BigInteger("12"));
- asserter.assertExpression("right / left", new BigInteger("3"));
- asserter.assertExpression("right % left", new BigInteger("0"));
- }
+ public Boolean startsWith(final Var lhs, final Var rhs) {
+ return lhs.toString().startsWith(rhs.toString());
+ }
- @Test
- public void testOverflows() throws Exception {
- asserter.assertExpression("1 + 2147483647", Long.valueOf("2147483648"));
- asserter.assertExpression("3 + " + (Long.MAX_VALUE - 2), BigInteger.valueOf(Long.MAX_VALUE).add(BigInteger.ONE));
- asserter.assertExpression("-2147483648 - 1", Long.valueOf("-2147483649"));
- asserter.assertExpression("-3 + " + (Long.MIN_VALUE + 2), BigInteger.valueOf(Long.MIN_VALUE).subtract(BigInteger.ONE));
- asserter.assertExpression("1 + 9223372036854775807", new BigInteger("9223372036854775808"));
- asserter.assertExpression("-1 + (-9223372036854775808)", new BigInteger("-9223372036854775809"));
- asserter.assertExpression("-9223372036854775808 - 1", new BigInteger("-9223372036854775809"));
- final BigInteger maxl = BigInteger.valueOf(Long.MAX_VALUE);
- asserter.assertExpression(maxl + " * " + maxl , maxl.multiply(maxl));
- }
+ public Object subtract(final String x, final String y) {
+ final int ix = x.indexOf(y);
+ if (ix < 0) {
+ return x;
+ }
+ final StringBuilder strb = new StringBuilder(x.substring(0, ix));
+ strb.append(x.substring(ix + y.length()));
+ return strb.toString();
+ }
- /**
- * test some simple mathematical calculations
- */
- @Test
- public void testUnaryMinus() throws Exception {
- asserter.setVariable("aByte", Byte.valueOf((byte) 1));
- asserter.setVariable("aShort", Short.valueOf((short) 2));
- asserter.setVariable("anInteger", Integer.valueOf(3));
- asserter.setVariable("aLong", Long.valueOf(4));
- asserter.setVariable("aFloat", Float.valueOf((float) 5.5));
- asserter.setVariable("aDouble", Double.valueOf(6.6));
- asserter.setVariable("aBigInteger", new BigInteger("7"));
- asserter.setVariable("aBigDecimal", new BigDecimal("8.8"));
+ public Var subtract(final Var lhs, final Var rhs) {
+ return new Var(lhs.value - rhs.value);
+ }
- // loop to allow checking caching of constant numerals (debug)
- for(int i = 0 ; i < 2; ++i) {
- asserter.assertExpression("-3", Integer.valueOf("-3"));
- asserter.assertExpression("-3.0", Double.valueOf("-3.0"));
- asserter.assertExpression("-aByte", Byte.valueOf((byte) -1));
- asserter.assertExpression("-aShort", Short.valueOf((short) -2));
- asserter.assertExpression("-anInteger", Integer.valueOf(-3));
- asserter.assertExpression("-aLong", Long.valueOf(-4));
- asserter.assertExpression("-aFloat", Float.valueOf((float) -5.5));
- asserter.assertExpression("-aDouble", Double.valueOf(-6.6));
- asserter.assertExpression("-aBigInteger", new BigInteger("-7"));
- asserter.assertExpression("-aBigDecimal", new BigDecimal("-8.8"));
+ public Var xor(final Var lhs, final Var rhs) {
+ return new Var(lhs.value ^ rhs.value);
+ }
+ }
+ public static class Callable173 {
+ public Object call(final Integer... arg) {
+ return arg[0] * arg[1];
+ }
+ public Object call(final String... arg) {
+ return 42;
}
}
+ public static class EmptyTestContext extends MapContext implements JexlContext.NamespaceResolver {
+ public static int log(final Object fmt, final int... arr) {
+ //System.out.println(String.format(fmt.toString(), arr));
+ return arr == null ? 0 : arr.length;
+ }
- /**
- * test some simple mathematical calculations
- */
- @Test
- public void testUnaryPlus() throws Exception {
- asserter.setVariable("aByte", Byte.valueOf((byte) 1));
- asserter.setVariable("aShort", Short.valueOf((short) 2));
- asserter.setVariable("anInteger", Integer.valueOf(3));
- asserter.setVariable("aLong", Long.valueOf(4));
- asserter.setVariable("aFloat", Float.valueOf((float) 5.5));
- asserter.setVariable("aDouble", Double.valueOf(6.6));
- asserter.setVariable("aBigInteger", new BigInteger("7"));
- asserter.setVariable("aBigDecimal", new BigDecimal("8.8"));
+ public static int log(final Object fmt, final Object... arr) {
+ //System.out.println(String.format(fmt.toString(), arr));
+ return arr == null ? 0 : arr.length;
+ }
- // loop to allow checking caching of constant numerals (debug)
- for(int i = 0 ; i < 2; ++i) {
- asserter.assertExpression("+3", Integer.valueOf("3"));
- asserter.assertExpression("+3.0", Double.valueOf("3.0"));
- asserter.assertExpression("+aByte", Integer.valueOf(1));
- asserter.assertExpression("+aShort", Integer.valueOf(2));
- asserter.assertExpression("+anInteger", Integer.valueOf(3));
- asserter.assertExpression("+aLong", Long.valueOf(4));
- asserter.assertExpression("+aFloat", Float.valueOf((float) 5.5));
- asserter.assertExpression("+aDouble", Double.valueOf(6.6));
- asserter.assertExpression("+aBigInteger", new BigInteger("7"));
- asserter.assertExpression("+aBigDecimal", new BigDecimal("8.8"));
+ @Override
+ public Object resolveNamespace(final String name) {
+ return this;
}
}
+ public static class Var {
+ int value;
- @Test
- public void testMinusMinusPrefix() throws Exception {
- asserter.setVariable("aByte", Byte.valueOf((byte) 2));
- asserter.setVariable("aShort", Short.valueOf((short) 3));
- asserter.setVariable("anInteger", Integer.valueOf(4));
- asserter.setVariable("aLong", Long.valueOf(5));
- asserter.setVariable("aFloat", Float.valueOf((float) 6.6));
- asserter.setVariable("aDouble", Double.valueOf(7.7));
- asserter.setVariable("aBigInteger", new BigInteger("8"));
- asserter.setVariable("aBigDecimal", new BigDecimal("9.9"));
- asserter.setVariable("aString", "forty-two");
+ Var(final int v) {
+ value = v;
+ }
- asserter.assertExpression("--aByte", Byte.valueOf((byte) 1));
- asserter.assertExpression("--aShort", Short.valueOf((short) 2));
- asserter.assertExpression("--anInteger", Integer.valueOf(3));
- asserter.assertExpression("--aLong", Long.valueOf(4));
- asserter.assertExpression("--aFloat", Float.valueOf((float) 5.6));
- asserter.assertExpression("--aDouble", Double.valueOf(6.7));
- asserter.assertExpression("--aBigInteger", new BigInteger("7"));
- asserter.assertExpression("--aBigDecimal", new BigDecimal("8.9"));
-
- asserter.failExpression("aString--", "--", String::contains);
+ @Override
+ public String toString() {
+ return Integer.toString(value);
+ }
}
- @Test
- public void testMinusMinusPostfix() throws Exception {
- asserter.setVariable("aByte", Byte.valueOf((byte) 2));
- asserter.setVariable("aShort", Short.valueOf((short) 3));
- asserter.setVariable("anInteger", Integer.valueOf(4));
- asserter.setVariable("aLong", Long.valueOf(5));
- asserter.setVariable("aFloat", Float.valueOf((float) 6.6));
- asserter.setVariable("aDouble", Double.valueOf(7.7));
- asserter.setVariable("aBigInteger", new BigInteger("8"));
- asserter.setVariable("aBigDecimal", new BigDecimal("9.9"));
- asserter.setVariable("aString", "forty-two");
-
- asserter.assertExpression("aByte--",Byte.valueOf((byte) 2));
- asserter.assertExpression("aShort--", Short.valueOf((short) 3));
- asserter.assertExpression("anInteger--", Integer.valueOf(4));
- asserter.assertExpression("aLong--", Long.valueOf(5));
- asserter.assertExpression("aFloat--", Float.valueOf((float) 6.6));
- asserter.assertExpression("aDouble--", Double.valueOf(7.7));
- asserter.assertExpression("aBigInteger--", new BigInteger("8"));
- asserter.assertExpression("aBigDecimal--", new BigDecimal("9.9"));
-
- asserter.assertExpression("aByte", Byte.valueOf((byte) 1));
- asserter.assertExpression("aShort", Short.valueOf((short) 2));
- asserter.assertExpression("anInteger", Integer.valueOf(3));
- asserter.assertExpression("aLong", Long.valueOf(4));
- asserter.assertExpression("aFloat", Float.valueOf((float) 5.6));
- asserter.assertExpression("aDouble", Double.valueOf(6.7));
- asserter.assertExpression("aBigInteger", new BigInteger("7"));
- asserter.assertExpression("aBigDecimal", new BigDecimal("8.9"));
-
- asserter.failExpression("aString--", "--", String::contains);
- }
+ public static class XmlArithmetic extends JexlArithmetic {
+ public XmlArithmetic(final boolean astrict) {
+ super(astrict);
+ }
- @Test
- public void testPlusPlusPrefix() throws Exception {
- asserter.setVariable("aByte", Byte.valueOf((byte) 0));
- asserter.setVariable("aShort", Short.valueOf((short) 1));
- asserter.setVariable("anInteger", Integer.valueOf(2));
- asserter.setVariable("aLong", Long.valueOf(3));
- asserter.setVariable("aFloat", Float.valueOf((float) 4.4));
- asserter.setVariable("aDouble", Double.valueOf(5.5));
- asserter.setVariable("aBigInteger", new BigInteger("6"));
- asserter.setVariable("aBigDecimal", new BigDecimal("7.7"));
- asserter.setVariable("aString", "forty-two");
+ public XmlArithmetic(final boolean astrict, final MathContext bigdContext, final int bigdScale) {
+ super(astrict, bigdContext, bigdScale);
+ }
- asserter.assertExpression("++aByte", Byte.valueOf((byte) 1));
- asserter.assertExpression("++aShort", Short.valueOf((short) 2));
- asserter.assertExpression("++anInteger", Integer.valueOf(3));
- asserter.assertExpression("++aLong", Long.valueOf(4));
- asserter.assertExpression("++aFloat", Float.valueOf((float) 5.4));
- asserter.assertExpression("++aDouble", Double.valueOf(6.5));
- asserter.assertExpression("++aBigInteger", new BigInteger("7"));
- asserter.assertExpression("++aBigDecimal", new BigDecimal("8.7"));
+ public boolean empty(final org.w3c.dom.Element elt) {
+ return !elt.hasAttributes() && !elt.hasChildNodes();
+ }
- asserter.failExpression("++aString", "++", String::contains);
+ public int size(final org.w3c.dom.Element elt) {
+ return elt.getChildNodes().getLength();
+ }
}
- @Test
- public void testPlusPlusPostfix() throws Exception {
- asserter.setVariable("aByte", Byte.valueOf((byte) 0));
- asserter.setVariable("aShort", Short.valueOf((short) 1));
- asserter.setVariable("anInteger", Integer.valueOf(2));
- asserter.setVariable("aLong", Long.valueOf(3));
- asserter.setVariable("aFloat", Float.valueOf((float) 4.4));
- asserter.setVariable("aDouble", Double.valueOf(5.5));
- asserter.setVariable("aBigInteger", new BigInteger("6"));
- asserter.setVariable("aBigDecimal", new BigDecimal("7.7"));
- asserter.setVariable("aString", "forty-two");
-
- asserter.assertExpression("aByte++", Byte.valueOf((byte) 0));
- asserter.assertExpression("aShort++", Short.valueOf((short) 1));
- asserter.assertExpression("anInteger++", Integer.valueOf(2));
- asserter.assertExpression("aLong++", Long.valueOf(3));
- asserter.assertExpression("aFloat++", Float.valueOf((float) 4.4));
- asserter.assertExpression("aDouble++", Double.valueOf(5.5));
- asserter.assertExpression("aBigInteger++", new BigInteger("6"));
- asserter.assertExpression("aBigDecimal++", new BigDecimal("7.7"));
-
- asserter.assertExpression("aByte", Byte.valueOf((byte) 1));
- asserter.assertExpression("aShort", Short.valueOf((short) 2));
- asserter.assertExpression("anInteger", Integer.valueOf(3));
- asserter.assertExpression("aLong", Long.valueOf(4));
- asserter.assertExpression("aFloat", Float.valueOf((float) 5.4));
- asserter.assertExpression("aDouble", Double.valueOf(6.5));
- asserter.assertExpression("aBigInteger", new BigInteger("7"));
- asserter.assertExpression("aBigDecimal", new BigDecimal("8.7"));
+ /** A small delta to compare doubles. */
+ private static final double EPSILON = 1.e-6;
- asserter.failExpression("aString++", "++", String::contains);
+ static private void assertArithmeticException(final java.util.function.Supplier<Object> fun) {
+ try {
+ Assert.assertNull(fun.get());
+ } catch (final ArithmeticException xany) {
+ Assert.assertNotNull(xany);
+ }
}
- @Test
- public void testNarrowBig() throws Exception {
- final List<String> ls = Arrays.asList("zero", "one", "two");
- asserter.setVariable("list",ls);
- asserter.setVariable("aBigDecimal", new BigDecimal("1"));
- asserter.setVariable("aBigInteger", new BigDecimal("1"));
- asserter.assertExpression("list.get(aBigDecimal)", "one");
- asserter.assertExpression("list.get(aBigInteger)", "one");
+ static private void assertNullOperand(final java.util.function.Supplier<Object> fun) {
+ try {
+ Assert.assertNull(fun.get());
+ } catch (final JexlArithmetic.NullOperand xany) {
+ Assert.assertNotNull(xany);
+ }
}
- @Test
- public void testNarrowBigDecimal() throws Exception {
- asserter.setVariable("bi420", BigInteger.valueOf(420));
- asserter.setVariable("bi10", BigInteger.valueOf(10));
- asserter.setVariable("bd420", new BigDecimal("420"));
- asserter.setVariable("bd10", new BigDecimal("10"));
- asserter.assertExpression("420 / bi10", 42);
- asserter.assertExpression("420l / bi10", 42L);
- asserter.assertExpression("bi420 / 420", 1);
- asserter.assertExpression("bi420 / 420l", 1L);
- asserter.assertExpression("bd420 / 10", new BigDecimal("42"));
+ private static Document getDocument(final String xml) throws Exception {
+ final DocumentBuilder xmlBuilder = DocumentBuilderFactory.newInstance().newDocumentBuilder();
+ final InputStream stringInputStream = new ByteArrayInputStream(xml.getBytes(StandardCharsets.UTF_8));
+ return xmlBuilder.parse(stringInputStream);
}
/**
- * test some simple mathematical calculations
+ * Returns the Java version as an int value.
+ * @return the Java version as an int value (8, 9, etc.)
*/
- @Test
- public void testCalculations() throws Exception {
- asserter.setStrict(true, false);
- /*
- * test new null coersion
- */
- asserter.setVariable("imanull", null);
- asserter.assertExpression("imanull + 2", Integer.valueOf(2));
- asserter.assertExpression("imanull + imanull", Integer.valueOf(0));
- asserter.setVariable("foo", Integer.valueOf(2));
+ private static int getJavaVersion() {
+ String version = System.getProperty("java.version");
+ if (version.startsWith("1.")) {
+ version = version.substring(2);
+ }
+ int sep = version.indexOf(".");
+ if (sep < 0) {
+ sep = version.indexOf("-");
+ }
+ if (sep > 0) {
+ version = version.substring(0, sep);
+ }
+ return Integer.parseInt(version);
+ }
- asserter.assertExpression("foo + 2", Integer.valueOf(4));
- asserter.assertExpression("3 + 3", Integer.valueOf(6));
- asserter.assertExpression("3 + 3 + foo", Integer.valueOf(8));
- asserter.assertExpression("3 * 3", Integer.valueOf(9));
- asserter.assertExpression("3 * 3 + foo", Integer.valueOf(11));
- asserter.assertExpression("3 * 3 - foo", Integer.valueOf(7));
+ private final Asserter asserter;
- /*
- * test parenthesized exprs
- */
- asserter.assertExpression("(4 + 3) * 6", Integer.valueOf(42));
- asserter.assertExpression("(8 - 2) * 7", Integer.valueOf(42));
- /*
- * test some floaty stuff
- */
- asserter.assertExpression("3 * \"3.0\"", Double.valueOf(9));
- asserter.assertExpression("3 * 3.0", Double.valueOf(9));
+ private final JexlArithmetic jexla;
- /*
- * test / and %
- */
- asserter.setStrict(false, false);
- asserter.assertExpression("6 / 3", Integer.valueOf(6 / 3));
- asserter.assertExpression("6.4 / 3", Double.valueOf(6.4 / 3));
- asserter.assertExpression("0 / 3", Integer.valueOf(0 / 3));
- asserter.assertExpression("3 / 0", Double.valueOf(0));
- asserter.assertExpression("4 % 3", Integer.valueOf(1));
- asserter.assertExpression("4.8 % 3", Double.valueOf(4.8 % 3));
+ private final JexlArithmetic jexlb;
- }
+ private final Date date = new Date();
- @Test
- public void testCoercions() throws Exception {
- asserter.assertExpression("1", Integer.valueOf(1)); // numerics default to Integer
- asserter.assertExpression("5L", Long.valueOf(5));
+ public ArithmeticTest() {
+ super("ArithmeticTest");
+ asserter = new Asserter(JEXL);
+ jexla = JEXL.getArithmetic();
+ final JexlOptions options = new JexlOptions();
+ options.setStrictArithmetic(false);
+ jexlb = jexla.options(options);
+ }
- asserter.setVariable("I2", Integer.valueOf(2));
- asserter.setVariable("L2", Long.valueOf(2));
- asserter.setVariable("L3", Long.valueOf(3));
- asserter.setVariable("B10", BigInteger.TEN);
+ void checkEmpty(final Object x, final boolean expect) {
+ final JexlScript s0 = JEXL.createScript("empty(x)", "x");
+ boolean empty = (Boolean) s0.execute(null, x);
+ Assert.assertEquals(expect, empty);
+ final JexlScript s1 = JEXL.createScript("empty x", "x");
+ empty = (Boolean) s1.execute(null, x);
+ Assert.assertEquals(expect, empty);
+ final JexlScript s2 = JEXL.createScript("x.empty()", "x");
+ empty = (Boolean) s2.execute(null, x);
+ Assert.assertEquals(expect, empty);
+ }
- // Integer & Integer => Integer
- asserter.assertExpression("I2 + 2", Integer.valueOf(4));
- asserter.assertExpression("I2 * 2", Integer.valueOf(4));
- asserter.assertExpression("I2 - 2", Integer.valueOf(0));
- asserter.assertExpression("I2 / 2", Integer.valueOf(1));
+ protected void runOverload(final JexlEngine jexl, final JexlContext jc) {
+ JexlScript script;
+ Object result;
- // Integer & Long => Long
- asserter.assertExpression("I2 * L2", Long.valueOf(4));
- asserter.assertExpression("I2 / L2", Long.valueOf(1));
+ script = jexl.createScript("(x, y)->{ x < y }");
+ result = script.execute(jc, 42, 43);
+ Assert.assertEquals(true, result);
+ result = script.execute(jc, new Var(42), new Var(43));
+ Assert.assertEquals(true, result);
+ result = script.execute(jc, new Var(42), new Var(43));
+ Assert.assertEquals(true, result);
+ result = script.execute(jc, 43, 42);
+ Assert.assertEquals(false, result);
+ result = script.execute(jc, new Var(43), new Var(42));
+ Assert.assertEquals(false, result);
- // Long & Long => Long
- asserter.assertExpression("L2 + 3", Long.valueOf(5));
- asserter.assertExpression("L2 + L3", Long.valueOf(5));
- asserter.assertExpression("L2 / L2", Long.valueOf(1));
- asserter.assertExpression("L2 / 2", Long.valueOf(1));
+ script = jexl.createScript("(x, y)->{ x <= y }");
+ result = script.execute(jc, 42, 43);
+ Assert.assertEquals(true, result);
+ result = script.execute(jc, new Var(42), new Var(43));
+ Assert.assertEquals(true, result);
+ result = script.execute(jc, new Var(41), new Var(44));
+ Assert.assertEquals(true, result);
+ result = script.execute(jc, 43, 42);
+ Assert.assertEquals(false, result);
+ result = script.execute(jc, new Var(45), new Var(40));
+ Assert.assertEquals(false, result);
- // BigInteger
- asserter.assertExpression("B10 / 10", BigInteger.ONE);
- asserter.assertExpression("B10 / I2", new BigInteger("5"));
- asserter.assertExpression("B10 / L2", new BigInteger("5"));
- }
+ script = jexl.createScript("(x, y)->{ x > y }");
+ result = script.execute(jc, 42, 43);
+ Assert.assertEquals(false, result);
+ result = script.execute(jc, new Var(42), new Var(43));
+ Assert.assertEquals(false, result);
+ result = script.execute(jc, new Var(42), new Var(43));
+ Assert.assertEquals(false, result);
+ result = script.execute(jc, 43, 42);
+ Assert.assertEquals(true, result);
+ result = script.execute(jc, new Var(43), new Var(42));
+ Assert.assertEquals(true, result);
- // JEXL-24: long integers (and doubles)
- @Test
- public void testLongLiterals() {
- final JexlEvalContext ctxt = new JexlEvalContext();
- final JexlOptions options = ctxt.getEngineOptions();
- options.setStrictArithmetic(true);
- final String stmt = "{a = 10L; b = 10l; c = 42.0D; d = 42.0d; e=56.3F; f=56.3f; g=63.5; h=0x10; i=010; j=0x10L; k=010l}";
- final JexlScript expr = JEXL.createScript(stmt);
- /* Object value = */ expr.execute(ctxt);
- Assert.assertEquals(10L, ctxt.get("a"));
- Assert.assertEquals(10L, ctxt.get("b"));
- Assert.assertEquals(42.0D, ctxt.get("c"));
- Assert.assertEquals(42.0d, ctxt.get("d"));
- Assert.assertEquals(56.3f, ctxt.get("e"));
- Assert.assertEquals(56.3f, ctxt.get("f"));
- Assert.assertEquals(63.5d, ctxt.get("g"));
- Assert.assertEquals(0x10, ctxt.get("h"));
- Assert.assertEquals(010, ctxt.get("i")); // octal 010
- Assert.assertEquals(0x10L, ctxt.get("j")); // octal 010L
- Assert.assertEquals(010L, ctxt.get("k"));
- }
+ script = jexl.createScript("(x, y)->{ x >= y }");
+ result = script.execute(jc, 42, 43);
+ Assert.assertEquals(false, result);
+ result = script.execute(jc, new Var(42), new Var(43));
+ Assert.assertEquals(false, result);
+ result = script.execute(jc, new Var(41), new Var(44));
+ Assert.assertEquals(false, result);
+ result = script.execute(jc, 43, 42);
+ Assert.assertEquals(true, result);
+ result = script.execute(jc, new Var(45), new Var(40));
+ Assert.assertEquals(true, result);
- @Test
- public void testBigLiteralValue() {
- final JexlEvalContext ctxt = new JexlEvalContext();
- final JexlOptions options = ctxt.getEngineOptions();
- options.setStrictArithmetic(true);
- final JexlExpression e = JEXL.createExpression("9223372036854775806.5B");
- final String res = String.valueOf(e.evaluate(ctxt));
- Assert.assertEquals("9223372036854775806.5", res);
- }
+ script = jexl.createScript("(x, y)->{ x == y }");
+ result = script.execute(jc, 42, 43);
+ Assert.assertEquals(false, result);
+ result = script.execute(jc, new Var(42), new Var(43));
+ Assert.assertEquals(false, result);
+ result = script.execute(jc, new Var(41), new Var(44));
+ Assert.assertEquals(false, result);
+ result = script.execute(jc, 43, 42);
+ Assert.assertEquals(false, result);
+ result = script.execute(jc, new Var(45), new Var(40));
+ Assert.assertEquals(false, result);
- @Test
- public void testBigdOp() {
- final BigDecimal sevendot475 = new BigDecimal("7.475");
- final BigDecimal SO = new BigDecimal("325");
- final JexlContext jc = new MapContext();
- jc.set("SO", SO);
+ script = jexl.createScript("(x, y)->{ x != y }");
+ result = script.execute(jc, 42, 43);
+ Assert.assertEquals(true, result);
+ result = script.execute(jc, new Var(42), new Var(43));
+ Assert.assertEquals(true, result);
+ result = script.execute(jc, new Var(44), new Var(44));
+ Assert.assertEquals(false, result);
+ result = script.execute(jc, 44, 44);
+ Assert.assertEquals(false, result);
+ result = script.execute(jc, new Var(45), new Var(40));
+ Assert.assertEquals(true, result);
- final String expr = "2.3*SO/100";
+ script = jexl.createScript("(x, y)->{ x % y }");
+ result = script.execute(jc, 4242, 100);
+ Assert.assertEquals(42, result);
+ result = script.execute(jc, new Var(4242), new Var(100));
+ Assert.assertEquals(42, ((Var) result).value);
- final Object evaluate = JEXL.createExpression(expr).evaluate(jc);
- Assert.assertEquals(sevendot475, evaluate);
+ script = jexl.createScript("(x, y)->{ x * y }");
+ result = script.execute(jc, 6, 7);
+ Assert.assertEquals(42, result);
+ result = script.execute(jc, new Var(6), new Var(7));
+ Assert.assertEquals(42, ((Var) result).value);
+
+ script = jexl.createScript("(x, y)->{ x + y }");
+ result = script.execute(jc, 35, 7);
+ Assert.assertEquals(42, result);
+ result = script.execute(jc, new Var(35), new Var(7));
+ Assert.assertEquals(42, ((Var) result).value);
+
+ script = jexl.createScript("(x, y)->{ x - y }");
+ result = script.execute(jc, 49, 7);
+ Assert.assertEquals(42, result);
+ result = script.execute(jc, "foobarquux", "bar");
+ Assert.assertEquals("fooquux", result);
+ result = script.execute(jc, 50, 8);
+ Assert.assertEquals(42, result);
+ result = script.execute(jc, new Var(50), new Var(8));
+ Assert.assertEquals(42, ((Var) result).value);
+
+ script = jexl.createScript("(x)->{ -x }");
+ result = script.execute(jc, -42);
+ Assert.assertEquals(42, result);
+ result = script.execute(jc, new Var(-42));
+ Assert.assertEquals(42, ((Var) result).value);
+ result = script.execute(jc, "pizza");
+ Assert.assertEquals("azzip", result);
+ result = script.execute(jc, -142);
+ Assert.assertEquals(142, result);
+
+ script = jexl.createScript("(x)->{ ~x }");
+ result = script.execute(jc, -1);
+ Assert.assertEquals(0L, result);
+ result = script.execute(jc, new Var(-1));
+ Assert.assertEquals(0L, ((Var) result).value);
+ result = script.execute(jc, new Var(-42));
+ Assert.assertEquals(41, ((Var) result).value);
+
+ script = jexl.createScript("(x, y)->{ x ^ y }");
+ result = script.execute(jc, 35, 7);
+ Assert.assertEquals(36L, result);
+ result = script.execute(jc, new Var(35), new Var(7));
+ Assert.assertEquals(36L, ((Var) result).value);
+ // legacy
+ script = jexl.createScript("(x, y)->bitwiseXor(x,y)");
+ result = script.execute(jc, 35, 7);
+ Assert.assertEquals(36L, result);
+
+ script = jexl.createScript("(x, y)->{ x | y }");
+ result = script.execute(jc, 35, 7);
+ Assert.assertEquals(39L, result);
+ result = script.execute(jc, new Var(35), new Var(7));
+ Assert.assertEquals(39L, ((Var) result).value);
+ // legacy
+ script = jexl.createScript("(x, y)->bitwiseOr(x,y)");
+ result = script.execute(jc, 35, 7);
+ Assert.assertEquals(39L, result);
+
+ script = jexl.createScript("(x, y)->{ x << y }");
+ result = script.execute(jc, 35, 1);
+ Assert.assertEquals(70L, result);
+ result = script.execute(jc, new Var(35), new Var(1));
+ Assert.assertEquals(70L, ((Var) result).value);
+
+ script = jexl.createScript("(x, y)->{ x >> y }");
+ result = script.execute(jc, 42, 1);
+ Assert.assertEquals(21L, result);
+ result = script.execute(jc, new Var(42), new Var(1));
+ Assert.assertEquals(21, ((Var) result).value);
+
+ script = jexl.createScript("(x, y)->{ x >>> y }");
+ result = script.execute(jc, 84, 2);
+ Assert.assertEquals(21L, result);
+ result = script.execute(jc, new Var(84), new Var(2));
+ Assert.assertEquals(21, ((Var) result).value);
+
+ script = jexl.createScript("(x, y)->{ x & y }");
+ result = script.execute(jc, 35, 7);
+ Assert.assertEquals(3L, result);
+ result = script.execute(jc, new Var(35), new Var(7));
+ Assert.assertEquals(3L, ((Var) result).value);
+ // legacy
+ script = jexl.createScript("(x, y)->bitwiseAnd(x,y)");
+ result = script.execute(jc, 35, 7);
+ Assert.assertEquals(3L, result);
+
+ script = jexl.createScript("(x, y)->{ x =^ y }");
+ result = script.execute(jc, 3115, 31);
+ Assert.assertFalse((Boolean) result);
+ result = script.execute(jc, new Var(3115), new Var(31));
+ Assert.assertTrue((Boolean) result);
+
+ script = jexl.createScript("(x, y)->{ x !^ y }");
+ result = script.execute(jc, 3115, 31);
+ Assert.assertTrue((Boolean) result);
+ result = script.execute(jc, new Var(3115), new Var(31));
+ Assert.assertFalse((Boolean) result);
+
+ script = jexl.createScript("(x, y)->{ x =$ y }");
+ result = script.execute(jc, 3115, 15);
+ Assert.assertFalse((Boolean) result);
+ result = script.execute(jc, new Var(3115), new Var(15));
+ Assert.assertTrue((Boolean) result);
+
+ script = jexl.createScript("(x, y)->{ x !$ y }");
+ result = script.execute(jc, 3115, 15);
+ Assert.assertTrue((Boolean) result);
+ result = script.execute(jc, new Var(3115), new Var(15));
+ Assert.assertFalse((Boolean) result);
+
+ script = jexl.createScript("(x, y)->{ x =~ y }");
+ result = script.execute(jc, 3155, 15);
+ Assert.assertFalse((Boolean) result);
+ result = script.execute(jc, new Var(3155), new Var(15));
+ Assert.assertFalse((Boolean) result);
+ result = script.execute(jc, new Var(15), new Var(3155));
+ Assert.assertTrue((Boolean) result);
+
+ script = jexl.createScript("(x, y)->{ x !~ y }");
+ result = script.execute(jc, 3115, 15);
+ Assert.assertTrue((Boolean) result);
+ result = script.execute(jc, new Var(3155), new Var(15));
+ Assert.assertTrue((Boolean) result);
+ result = script.execute(jc, new Var(15), new Var(3155));
+ Assert.assertFalse((Boolean) result);
+
+ script = jexl.createScript("(x)->{ !x }");
+ try {
+ result = script.execute(jc, new Var(-42));
+ Assert.fail("should fail");
+ } catch (final JexlException xany) {
+ Assert.assertTrue(xany instanceof JexlException.Operator);
+ }
}
- // JEXL-24: big integers and big decimals
+ @Before
+ @Override
+ public void setUp() {
+ }
+
+ // JEXL-24: doubles with exponent
@Test
- public void testBigLiterals() {
+ public void test2DoubleLiterals() {
final JexlEvalContext ctxt = new JexlEvalContext();
final JexlOptions options = ctxt.getEngineOptions();
options.setStrictArithmetic(true);
- final String stmt = "{a = 10H; b = 10h; c = 42.0B; d = 42.0b;}";
- final JexlScript expr = JEXL.createScript(stmt);
- /* Object value = */ expr.execute(ctxt);
- Assert.assertEquals(new BigInteger("10"), ctxt.get("a"));
- Assert.assertEquals(new BigInteger("10"), ctxt.get("b"));
- Assert.assertEquals(new BigDecimal("42.0"), ctxt.get("c"));
- Assert.assertEquals(new BigDecimal("42.0"), ctxt.get("d"));
- }
-
- // JEXL-24: big decimals with exponent
- @Test
- public void testBigExponentLiterals() {
- final JexlEvalContext ctxt = new JexlEvalContext();
- final JexlOptions options = ctxt.getEngineOptions();
- options.setStrictArithmetic(true);
- final String stmt = "{a = 42.0e1B; b = 42.0E+2B; c = 42.0e-1B; d = 42.0E-2b; e=4242.4242e1b}";
- final JexlScript expr = JEXL.createScript(stmt);
- /* Object value = */ expr.execute(ctxt);
- Assert.assertEquals(new BigDecimal("42.0e+1"), ctxt.get("a"));
- Assert.assertEquals(new BigDecimal("42.0e+2"), ctxt.get("b"));
- Assert.assertEquals(new BigDecimal("42.0e-1"), ctxt.get("c"));
- Assert.assertEquals(new BigDecimal("42.0e-2"), ctxt.get("d"));
- Assert.assertEquals(new BigDecimal("4242.4242e1"), ctxt.get("e"));
- }
-
- // JEXL-24: doubles with exponent
- @Test
- public void test2DoubleLiterals() {
- final JexlEvalContext ctxt = new JexlEvalContext();
- final JexlOptions options = ctxt.getEngineOptions();
- options.setStrictArithmetic(true);
- final String stmt = "{a = 42.0e1D; b = 42.0E+2D; c = 42.0e-1d; d = 42.0E-2d; e=10e10; f= +1.e1; g=1e1; }";
+ final String stmt = "{a = 42.0e1D; b = 42.0E+2D; c = 42.0e-1d; d = 42.0E-2d; e=10e10; f= +1.e1; g=1e1; }";
final JexlScript expr = JEXL.createScript(stmt);
/* Object value = */ expr.execute(ctxt);
Assert.assertEquals(Double.valueOf("42.0e+1"), ctxt.get("a"));
@@ -696,154 +616,6 @@ public class ArithmeticTest extends JexlTestCase {
Assert.assertEquals(Double.valueOf("10"), ctxt.get("g"));
}
- /**
- *
- * if silent, all arith exception return 0.0
- * if not silent, all arith exception throw
- */
- @Test
- public void testDivideByZero() throws Exception {
- final Map<String, Object> vars = new HashMap<>();
- final JexlEvalContext context = new JexlEvalContext(vars);
- final JexlOptions options = context.getEngineOptions();
- options.setStrictArithmetic(true);
- vars.put("aByte", Byte.valueOf((byte) 1));
- vars.put("aShort", Short.valueOf((short) 2));
- vars.put("aInteger", Integer.valueOf(3));
- vars.put("aLong", Long.valueOf(4));
- vars.put("aFloat", Float.valueOf((float) 5.5));
- vars.put("aDouble", Double.valueOf(6.6));
- vars.put("aBigInteger", new BigInteger("7"));
- vars.put("aBigDecimal", new BigDecimal("8.8"));
-
- vars.put("zByte", Byte.valueOf((byte) 0));
- vars.put("zShort", Short.valueOf((short) 0));
- vars.put("zInteger", Integer.valueOf(0));
- vars.put("zLong", Long.valueOf(0));
- vars.put("zFloat", Float.valueOf(0));
- vars.put("zDouble", Double.valueOf(0));
- vars.put("zBigInteger", new BigInteger("0"));
- vars.put("zBigDecimal", new BigDecimal("0"));
-
- final String[] tnames = {
- "Byte", "Short", "Integer", "Long",
- "Float", "Double",
- "BigInteger", "BigDecimal"
- };
- // number of permutations this will generate
- final int PERMS = tnames.length * tnames.length;
-
- final JexlEngine jexl = JEXL;
- // for non-silent, silent...
- for (int s = 0; s < 2; ++s) {
- final boolean strict = s != 0;
- options.setStrict(true);
- options.setStrictArithmetic(strict);
- int zthrow = 0;
- int zeval = 0;
- // for vars of all types...
- for (final String vname : tnames) {
- // for zeros of all types...
- for (final String zname : tnames) {
- // divide var by zero
- final String expr = "a" + vname + " / " + "z" + zname;
- try {
- final JexlExpression zexpr = jexl.createExpression(expr);
- final Object nan = zexpr.evaluate(context);
- // check we have a zero & incremement zero count
- if (nan instanceof Number) {
- final double zero = ((Number) nan).doubleValue();
- if (zero == 0.0) {
- zeval += 1;
- }
- }
- } catch (final Exception any) {
- // increment the exception count
- zthrow += 1;
- }
- }
- }
- if (strict) {
- Assert.assertEquals("All expressions should have thrown " + zthrow + "/" + PERMS, zthrow, PERMS);
- } else {
- Assert.assertEquals("All expressions should have zeroed " + zeval + "/" + PERMS, zeval, PERMS);
- }
- }
- debuggerCheck(jexl);
- }
-
- @Test
- public void testNaN() {
- final Map<String, Object> ns = new HashMap<>();
- ns.put("double", Double.class);
- final JexlEngine jexl = new JexlBuilder().namespaces(ns).create();
- JexlScript script;
- Object result;
- script = jexl.createScript("#NaN");
- result = script.execute(null);
- Assert.assertTrue(Double.isNaN((Double) result));
- script = jexl.createScript("NaN");
- result = script.execute(null);
- Assert.assertTrue(Double.isNaN((Double) result));
- script = jexl.createScript("double:isNaN(#NaN)");
- result = script.execute(null);
- Assert.assertTrue((Boolean) result);
- script = jexl.createScript("double:isNaN(NaN)");
- result = script.execute(null);
- Assert.assertTrue((Boolean) result);
- }
-
- /**
- * JEXL-156.
- */
- @Test
- public void testMultClass(){
- final JexlEngine jexl = new JexlBuilder().create();
- final JexlContext jc = new MapContext();
- final Object ra = jexl.createExpression("463.0d * 0.1").evaluate(jc);
- Assert.assertEquals(Double.class, ra.getClass());
- final Object r0 = jexl.createExpression("463.0B * 0.1").evaluate(jc);
- Assert.assertEquals(java.math.BigDecimal.class, r0.getClass());
- final Object r1 = jexl.createExpression("463.0B * 0.1B").evaluate(jc);
- Assert.assertEquals(java.math.BigDecimal.class, r1.getClass());
- }
-
- @Test
- public void testDivClass() {
- final JexlEngine jexl = new JexlBuilder().create();
- final JexlContext jc = new MapContext();
- final Object ra = jexl.createExpression("463.0d / 0.1").evaluate(jc);
- Assert.assertEquals(Double.class, ra.getClass());
- final Object r0 = jexl.createExpression("463.0B / 0.1").evaluate(jc);
- Assert.assertEquals(java.math.BigDecimal.class, r0.getClass());
- final Object r1 = jexl.createExpression("463.0B / 0.1B").evaluate(jc);
- Assert.assertEquals(java.math.BigDecimal.class, r1.getClass());
- }
-
- @Test
- public void testPlusClass() {
- final JexlEngine jexl = new JexlBuilder().create();
- final JexlContext jc = new MapContext();
- final Object ra = jexl.createExpression("463.0d + 0.1").evaluate(jc);
- Assert.assertEquals(Double.class, ra.getClass());
- final Object r0 = jexl.createExpression("463.0B + 0.1").evaluate(jc);
- Assert.assertEquals(java.math.BigDecimal.class, r0.getClass());
- final Object r1 = jexl.createExpression("463.0B + 0.1B").evaluate(jc);
- Assert.assertEquals(java.math.BigDecimal.class, r1.getClass());
- }
-
- @Test
- public void testMinusClass() {
- final JexlEngine jexl = new JexlBuilder().create();
- final JexlContext jc = new MapContext();
- final Object ra = jexl.createExpression("463.0d - 0.1").evaluate(jc);
- Assert.assertEquals(Double.class, ra.getClass());
- final Object r0 = jexl.createExpression("463.0B - 0.1").evaluate(jc);
- Assert.assertEquals(java.math.BigDecimal.class, r0.getClass());
- final Object r1 = jexl.createExpression("463.0B - 0.1B").evaluate(jc);
- Assert.assertEquals(java.math.BigDecimal.class, r1.getClass());
- }
-
@Test
public void testAddWithStringsLenient() {
final JexlEngine jexl = new JexlBuilder().arithmetic(new JexlArithmetic(false)).create();
@@ -922,498 +694,682 @@ public class ArithmeticTest extends JexlTestCase {
}
@Test
- public void testNullArgs() {
- final JexlEngine jexl = new JexlBuilder().arithmetic(new JexlArithmetic(true) {
- @Override public boolean isStrict(final JexlOperator op) {
- return JexlOperator.ADD == op? false: super.isStrict(op);
- }
- }).create();
- final JexlScript script = jexl.createScript("'1.2' + x ", "x");
- final Object result = script.execute(null);
- Assert.assertEquals("1.2", result);
+ public void testArithmeticPlus() throws Exception {
+ final JexlEngine jexl = new JexlBuilder().cache(64).arithmetic(new ArithmeticPlus(false)).create();
+ final JexlContext jc = new EmptyTestContext();
+ runOverload(jexl, jc);
+ runOverload(jexl, jc);
}
@Test
- public void testOption() {
- final Map<String, Object> vars = new HashMap<>();
- final JexlEvalContext context = new JexlEvalContext(vars);
- final JexlOptions options = context.getEngineOptions();
- options.setStrictArithmetic(true);
- final JexlScript script = JEXL.createScript("0 + '1.2' ");
- Object result;
-
- options.setStrictArithmetic(true);
- result = script.execute(context);
- Assert.assertEquals("01.2", result);
-
- options.setStrictArithmetic(false);
- result = script.execute(context);
- Assert.assertEquals(1.2d, (Double) result, EPSILON);
+ public void testArithmeticPlusNoCache() {
+ final JexlEngine jexl = new JexlBuilder().cache(0).arithmetic(new ArithmeticPlus(false)).create();
+ final JexlContext jc = new EmptyTestContext();
+ runOverload(jexl, jc);
}
@Test
- public void testIsFloatingPointPattern() {
- final JexlArithmetic ja = new JexlArithmetic(true);
+ public void testAtomicBoolean() {
+ // in a condition
+ JexlScript e = JEXL.createScript("if (x) 1 else 2;", "x");
+ final JexlContext jc = new MapContext();
+ final AtomicBoolean ab = new AtomicBoolean(false);
+ Object o;
+ o = e.execute(jc, ab);
+ Assert.assertEquals("Result is not 2", Integer.valueOf(2), o);
+ ab.set(true);
+ o = e.execute(jc, ab);
+ Assert.assertEquals("Result is not 1", Integer.valueOf(1), o);
+ // in a binary logical op
+ e = JEXL.createScript("x && y", "x", "y");
+ ab.set(true);
+ o = e.execute(jc, ab, Boolean.FALSE);
+ Assert.assertFalse((Boolean) o);
+ ab.set(true);
+ o = e.execute(jc, ab, Boolean.TRUE);
+ Assert.assertTrue((Boolean) o);
+ ab.set(false);
+ o = e.execute(jc, ab, Boolean.FALSE);
+ Assert.assertFalse((Boolean) o);
+ ab.set(false);
+ o = e.execute(jc, ab, Boolean.FALSE);
+ Assert.assertFalse((Boolean) o);
+ // in arithmetic op
+ e = JEXL.createScript("x + y", "x", "y");
+ ab.set(true);
+ o = e.execute(jc, ab, 10);
+ Assert.assertEquals(11, o);
+ o = e.execute(jc, 10, ab);
+ Assert.assertEquals(11, o);
+ o = e.execute(jc, ab, 10.d);
+ Assert.assertEquals(11.d, (Double) o, EPSILON);
+ o = e.execute(jc, 10.d, ab);
+ Assert.assertEquals(11.d, (Double) o, EPSILON);
- Assert.assertFalse(ja.isFloatingPointNumber("floating point"));
- Assert.assertFalse(ja.isFloatingPointNumber("a1."));
- Assert.assertFalse(ja.isFloatingPointNumber("b1.2"));
- Assert.assertFalse(ja.isFloatingPointNumber("-10.2a-34"));
- Assert.assertFalse(ja.isFloatingPointNumber("+10.2a+34"));
- Assert.assertFalse(ja.isFloatingPointNumber("0"));
- Assert.assertFalse(ja.isFloatingPointNumber("1"));
- Assert.assertFalse(ja.isFloatingPointNumber("12A"));
- Assert.assertFalse(ja.isFloatingPointNumber("2F3"));
- Assert.assertFalse(ja.isFloatingPointNumber("23"));
- Assert.assertFalse(ja.isFloatingPointNumber("+3"));
- Assert.assertFalse(ja.isFloatingPointNumber("+34"));
- Assert.assertFalse(ja.isFloatingPointNumber("+3-4"));
- Assert.assertFalse(ja.isFloatingPointNumber("+3.-4"));
- Assert.assertFalse(ja.isFloatingPointNumber("3ee4"));
-
- Assert.assertTrue(ja.isFloatingPointNumber("0."));
- Assert.assertTrue(ja.isFloatingPointNumber("1."));
- Assert.assertTrue(ja.isFloatingPointNumber("1.2"));
- Assert.assertTrue(ja.isFloatingPointNumber("1.2e3"));
- Assert.assertTrue(ja.isFloatingPointNumber("2e3"));
- Assert.assertTrue(ja.isFloatingPointNumber("+2e-3"));
- Assert.assertTrue(ja.isFloatingPointNumber("+23E-34"));
- Assert.assertTrue(ja.isFloatingPointNumber("+23.E-34"));
- Assert.assertTrue(ja.isFloatingPointNumber("-23.4E+45"));
- Assert.assertTrue(ja.isFloatingPointNumber("1.2e34"));
- Assert.assertTrue(ja.isFloatingPointNumber("10.2e34"));
- Assert.assertTrue(ja.isFloatingPointNumber("+10.2e34"));
- Assert.assertTrue(ja.isFloatingPointNumber("-10.2e34"));
- Assert.assertTrue(ja.isFloatingPointNumber("10.2e-34"));
- Assert.assertTrue(ja.isFloatingPointNumber("10.2e+34"));
- Assert.assertTrue(ja.isFloatingPointNumber("-10.2e-34"));
- Assert.assertTrue(ja.isFloatingPointNumber("+10.2e+34"));
- Assert.assertTrue(ja.isFloatingPointNumber("-10.2E-34"));
- Assert.assertTrue(ja.isFloatingPointNumber("+10.2E+34"));
- }
+ final BigInteger bi10 = BigInteger.TEN;
+ ab.set(false);
+ o = e.execute(jc, ab, bi10);
+ Assert.assertEquals(bi10, o);
+ o = e.execute(jc, bi10, ab);
+ Assert.assertEquals(bi10, o);
- public static class EmptyTestContext extends MapContext implements JexlContext.NamespaceResolver {
- public static int log(final Object fmt, final Object... arr) {
- //System.out.println(String.format(fmt.toString(), arr));
- return arr == null ? 0 : arr.length;
- }
+ final BigDecimal bd10 = BigDecimal.TEN;
+ ab.set(false);
+ o = e.execute(jc, ab, bd10);
+ Assert.assertEquals(bd10, o);
+ o = e.execute(jc, bd10, ab);
+ Assert.assertEquals(bd10, o);
- public static int log(final Object fmt, final int... arr) {
- //System.out.println(String.format(fmt.toString(), arr));
- return arr == null ? 0 : arr.length;
- }
+ // in a (the) monadic op
+ e = JEXL.createScript("!x", "x");
+ ab.set(true);
+ o = e.execute(jc, ab);
+ Assert.assertFalse((Boolean) o);
+ ab.set(false);
+ o = e.execute(jc, ab);
+ Assert.assertTrue((Boolean) o);
- @Override
- public Object resolveNamespace(final String name) {
- return this;
- }
+ // in a (the) monadic op
+ e = JEXL.createScript("-x", "x");
+ ab.set(true);
+ o = e.execute(jc, ab);
+ Assert.assertFalse((Boolean) o);
+ ab.set(false);
+ o = e.execute(jc, ab);
+ Assert.assertTrue((Boolean) o);
}
@Test
- public void testEmpty() throws Exception {
- final Object[] SCRIPTS = {
- "var x = null; log('x = %s', x);", 0,
- "var x = 'abc'; log('x = %s', x);", 1,
- "var x = 333; log('x = %s', x);", 1,
- "var x = [1, 2]; log('x = %s', x);", 2,
- "var x = ['a', 'b']; log('x = %s', x);", 2,
- "var x = {1:'A', 2:'B'}; log('x = %s', x);", 1,
- "var x = null; return empty(x);", true,
- "var x = ''; return empty(x);", true,
- "var x = 'abc'; return empty(x);", false,
- "var x = 0; return empty(x);", true,
- "var x = 333; return empty(x);", false,
- "var x = []; return empty(x);", true,
- "var x = [1, 2]; return empty(x);", false,
- "var x = ['a', 'b']; return empty(x);", false,
- "var x = [...]; return empty(x);", true,
- "var x = [1, 2,...]; return empty(x);", false,
- "var x = {:}; return empty(x);", true,
- "var x = {1:'A', 2:'B'}; return empty(x);", false,
- "var x = {}; return empty(x);", true,
- "var x = {'A','B'}; return empty(x);", false
- };
- final JexlEngine jexl = new JexlBuilder().create();
- final JexlContext jc = new EmptyTestContext();
- JexlScript script;
-
- for (int e = 0; e < SCRIPTS.length; e += 2) {
- final String stext = (String) SCRIPTS[e];
- final Object expected = SCRIPTS[e + 1];
- script = jexl.createScript(stext);
- final Object result = script.execute(jc);
- Assert.assertEquals("failed on " + stext, expected, result);
- }
+ public void testBigDecimal() throws Exception {
+ asserter.setVariable("left", new BigDecimal(2));
+ asserter.setVariable("right", new BigDecimal(6));
+ asserter.assertExpression("left + right", new BigDecimal(8));
+ asserter.assertExpression("right - left", new BigDecimal(4));
+ asserter.assertExpression("right * left", new BigDecimal(12));
+ asserter.assertExpression("right / left", new BigDecimal(3));
+ asserter.assertExpression("right % left", new BigDecimal(0));
}
- public static class Var {
- int value;
+ @Test
+ public void testBigdOp() {
+ final BigDecimal sevendot475 = new BigDecimal("7.475");
+ final BigDecimal SO = new BigDecimal("325");
+ final JexlContext jc = new MapContext();
+ jc.set("SO", SO);
- Var(final int v) {
- value = v;
- }
+ final String expr = "2.3*SO/100";
- @Override
- public String toString() {
- return Integer.toString(value);
- }
+ final Object evaluate = JEXL.createExpression(expr).evaluate(jc);
+ Assert.assertEquals(sevendot475, evaluate);
}
- // an arithmetic that knows how to deal with vars
- public static class ArithmeticPlus extends JexlArithmetic {
- public ArithmeticPlus(final boolean strict) {
- super(strict);
- }
-
- public boolean equals(final Var lhs, final Var rhs) {
- return lhs.value == rhs.value;
- }
-
- public boolean lessThan(final Var lhs, final Var rhs) {
- return lhs.value < rhs.value;
- }
+ // JEXL-24: big decimals with exponent
+ @Test
+ public void testBigExponentLiterals() {
+ final JexlEvalContext ctxt = new JexlEvalContext();
+ final JexlOptions options = ctxt.getEngineOptions();
+ options.setStrictArithmetic(true);
+ final String stmt = "{a = 42.0e1B; b = 42.0E+2B; c = 42.0e-1B; d = 42.0E-2b; e=4242.4242e1b}";
+ final JexlScript expr = JEXL.createScript(stmt);
+ /* Object value = */ expr.execute(ctxt);
+ Assert.assertEquals(new BigDecimal("42.0e+1"), ctxt.get("a"));
+ Assert.assertEquals(new BigDecimal("42.0e+2"), ctxt.get("b"));
+ Assert.assertEquals(new BigDecimal("42.0e-1"), ctxt.get("c"));
+ Assert.assertEquals(new BigDecimal("42.0e-2"), ctxt.get("d"));
+ Assert.assertEquals(new BigDecimal("4242.4242e1"), ctxt.get("e"));
+ }
- public boolean lessThanOrEqual(final Var lhs, final Var rhs) {
- return lhs.value <= rhs.value;
- }
+ @Test
+ public void testBigInteger() throws Exception {
+ asserter.setVariable("left", new BigInteger("2"));
+ asserter.setVariable("right", new BigInteger("6"));
+ asserter.assertExpression("left + right", new BigInteger("8"));
+ asserter.assertExpression("right - left", new BigInteger("4"));
+ asserter.assertExpression("right * left", new BigInteger("12"));
+ asserter.assertExpression("right / left", new BigInteger("3"));
+ asserter.assertExpression("right % left", new BigInteger("0"));
+ }
- public boolean greaterThan(final Var lhs, final Var rhs) {
- return lhs.value > rhs.value;
- }
+ // JEXL-24: big integers and big decimals
+ @Test
+ public void testBigLiterals() {
+ final JexlEvalContext ctxt = new JexlEvalContext();
+ final JexlOptions options = ctxt.getEngineOptions();
+ options.setStrictArithmetic(true);
+ final String stmt = "{a = 10H; b = 10h; c = 42.0B; d = 42.0b;}";
+ final JexlScript expr = JEXL.createScript(stmt);
+ /* Object value = */ expr.execute(ctxt);
+ Assert.assertEquals(new BigInteger("10"), ctxt.get("a"));
+ Assert.assertEquals(new BigInteger("10"), ctxt.get("b"));
+ Assert.assertEquals(new BigDecimal("42.0"), ctxt.get("c"));
+ Assert.assertEquals(new BigDecimal("42.0"), ctxt.get("d"));
+ }
- public boolean greaterThanOrEqual(final Var lhs, final Var rhs) {
- return lhs.value >= rhs.value;
- }
+ @Test
+ public void testBigLiteralValue() {
+ final JexlEvalContext ctxt = new JexlEvalContext();
+ final JexlOptions options = ctxt.getEngineOptions();
+ options.setStrictArithmetic(true);
+ final JexlExpression e = JEXL.createExpression("9223372036854775806.5B");
+ final String res = String.valueOf(e.evaluate(ctxt));
+ Assert.assertEquals("9223372036854775806.5", res);
+ }
- public Var add(final Var lhs, final Var rhs) {
- return new Var(lhs.value + rhs.value);
- }
+ /**
+ * test some simple mathematical calculations
+ */
+ @Test
+ public void testCalculations() throws Exception {
+ asserter.setStrict(true, false);
+ /*
+ * test new null coersion
+ */
+ asserter.setVariable("imanull", null);
+ asserter.assertExpression("imanull + 2", Integer.valueOf(2));
+ asserter.assertExpression("imanull + imanull", Integer.valueOf(0));
+ asserter.setVariable("foo", Integer.valueOf(2));
- public Var subtract(final Var lhs, final Var rhs) {
- return new Var(lhs.value - rhs.value);
- }
+ asserter.assertExpression("foo + 2", Integer.valueOf(4));
+ asserter.assertExpression("3 + 3", Integer.valueOf(6));
+ asserter.assertExpression("3 + 3 + foo", Integer.valueOf(8));
+ asserter.assertExpression("3 * 3", Integer.valueOf(9));
+ asserter.assertExpression("3 * 3 + foo", Integer.valueOf(11));
+ asserter.assertExpression("3 * 3 - foo", Integer.valueOf(7));
- public Var divide(final Var lhs, final Var rhs) {
- return new Var(lhs.value / rhs.value);
- }
+ /*
+ * test parenthesized exprs
+ */
+ asserter.assertExpression("(4 + 3) * 6", Integer.valueOf(42));
+ asserter.assertExpression("(8 - 2) * 7", Integer.valueOf(42));
- public Var multiply(final Var lhs, final Var rhs) {
- return new Var(lhs.value * rhs.value);
- }
+ /*
+ * test some floaty stuff
+ */
+ asserter.assertExpression("3 * \"3.0\"", Double.valueOf(9));
+ asserter.assertExpression("3 * 3.0", Double.valueOf(9));
- public Var mod(final Var lhs, final Var rhs) {
- return new Var(lhs.value / rhs.value);
- }
+ /*
+ * test / and %
+ */
+ asserter.setStrict(false, false);
+ asserter.assertExpression("6 / 3", Integer.valueOf(6 / 3));
+ asserter.assertExpression("6.4 / 3", Double.valueOf(6.4 / 3));
+ asserter.assertExpression("0 / 3", Integer.valueOf(0 / 3));
+ asserter.assertExpression("3 / 0", Double.valueOf(0));
+ asserter.assertExpression("4 % 3", Integer.valueOf(1));
+ asserter.assertExpression("4.8 % 3", Double.valueOf(4.8 % 3));
- public Var negate(final Var arg) {
- return new Var(-arg.value);
- }
+ }
- public Var and(final Var lhs, final Var rhs) {
- return new Var(lhs.value & rhs.value);
- }
-
- public Var or(final Var lhs, final Var rhs) {
- return new Var(lhs.value | rhs.value);
- }
-
- public Var xor(final Var lhs, final Var rhs) {
- return new Var(lhs.value ^ rhs.value);
- }
+ @Test
+ public void testCoerceBigDecimal() {
+ final JexlArithmetic ja = JEXL.getArithmetic();
+ final JexlEvalContext ctxt = new JexlEvalContext();
+ final JexlOptions options = ctxt.getEngineOptions();
+ options.setStrictArithmetic(true);
+ final String stmt = "{a = 34L; b = 45.0D; c=56.0F; d=67B; e=78H; }";
+ final JexlScript expr = JEXL.createScript(stmt);
+ /* Object value = */ expr.execute(ctxt);
+ Assert.assertEquals(BigDecimal.valueOf(34), ja.toBigDecimal(ctxt.get("a")));
+ Assert.assertEquals(BigDecimal.valueOf(45.), ja.toBigDecimal(ctxt.get("b")));
+ Assert.assertEquals(BigDecimal.valueOf(56.), ja.toBigDecimal(ctxt.get("c")));
+ Assert.assertEquals(BigDecimal.valueOf(67), ja.toBigDecimal(ctxt.get("d")));
+ Assert.assertEquals(BigDecimal.valueOf(78), ja.toBigDecimal(ctxt.get("e")));
+ Assert.assertEquals(BigDecimal.valueOf(10), ja.toBigDecimal("10"));
+ Assert.assertEquals(BigDecimal.valueOf(1.), ja.toBigDecimal(true));
+ Assert.assertEquals(BigDecimal.valueOf(0.), ja.toBigDecimal(false));
+ }
- public Var shiftRight(final Var lhs, final Var rhs) {
- return new Var(lhs.value >> rhs.value);
- }
+ @Test
+ public void testCoerceBigInteger() {
+ final JexlArithmetic ja = JEXL.getArithmetic();
+ final JexlEvalContext ctxt = new JexlEvalContext();
+ final JexlOptions options = ctxt.getEngineOptions();
+ options.setStrictArithmetic(true);
+ final String stmt = "{a = 34L; b = 45.0D; c=56.0F; d=67B; e=78H; }";
+ final JexlScript expr = JEXL.createScript(stmt);
+ /* Object value = */ expr.execute(ctxt);
+ Assert.assertEquals(BigInteger.valueOf(34), ja.toBigInteger(ctxt.get("a")));
+ Assert.assertEquals(BigInteger.valueOf(45), ja.toBigInteger(ctxt.get("b")));
+ Assert.assertEquals(BigInteger.valueOf(56), ja.toBigInteger(ctxt.get("c")));
+ Assert.assertEquals(BigInteger.valueOf(67), ja.toBigInteger(ctxt.get("d")));
+ Assert.assertEquals(BigInteger.valueOf(78), ja.toBigInteger(ctxt.get("e")));
+ Assert.assertEquals(BigInteger.valueOf(10), ja.toBigInteger("10"));
+ Assert.assertEquals(BigInteger.valueOf(1), ja.toBigInteger(true));
+ Assert.assertEquals(BigInteger.valueOf(0), ja.toBigInteger(false));
+ }
- public Var shiftRightUnsigned(final Var lhs, final Var rhs) {
- return new Var(lhs.value >>> rhs.value);
- }
+ @Test
+ public void testCoerceDouble() {
+ final JexlArithmetic ja = JEXL.getArithmetic();
+ final JexlEvalContext ctxt = new JexlEvalContext();
+ final JexlOptions options = ctxt.getEngineOptions();
+ options.setStrictArithmetic(true);
+ final String stmt = "{a = 34L; b = 45.0D; c=56.0F; d=67B; e=78H; }";
+ final JexlScript expr = JEXL.createScript(stmt);
+ /* Object value = */ expr.execute(ctxt);
+ Assert.assertEquals(34, ja.toDouble(ctxt.get("a")), EPSILON);
+ Assert.assertEquals(45, ja.toDouble(ctxt.get("b")), EPSILON);
+ Assert.assertEquals(56, ja.toDouble(ctxt.get("c")), EPSILON);
+ Assert.assertEquals(67, ja.toDouble(ctxt.get("d")), EPSILON);
+ Assert.assertEquals(78, ja.toDouble(ctxt.get("e")), EPSILON);
+ Assert.assertEquals(10d, ja.toDouble("10"), EPSILON);
+ Assert.assertEquals(1.D, ja.toDouble(true), EPSILON);
+ Assert.assertEquals(0.D, ja.toDouble(false), EPSILON);
+ }
- public Var shiftLeft(final Var lhs, final Var rhs) {
- return new Var(lhs.value << rhs.value);
- }
+ @Test
+ public void testCoerceInteger() {
+ final JexlArithmetic ja = JEXL.getArithmetic();
+ final JexlEvalContext ctxt = new JexlEvalContext();
+ final JexlOptions options = ctxt.getEngineOptions();
+ options.setStrictArithmetic(true);
+ final String stmt = "a = 34L; b = 45.0D; c=56.0F; d=67B; e=78H;";
+ final JexlScript expr = JEXL.createScript(stmt);
+ /* Object value = */ expr.execute(ctxt);
+ Assert.assertEquals(34, ja.toInteger(ctxt.get("a")));
+ Assert.assertEquals(45, ja.toInteger(ctxt.get("b")));
+ Assert.assertEquals(56, ja.toInteger(ctxt.get("c")));
+ Assert.assertEquals(67, ja.toInteger(ctxt.get("d")));
+ Assert.assertEquals(78, ja.toInteger(ctxt.get("e")));
+ Assert.assertEquals(10, ja.toInteger("10"));
+ Assert.assertEquals(1, ja.toInteger(true));
+ Assert.assertEquals(0, ja.toInteger(false));
+ }
- public Boolean contains(final Var lhs, final Var rhs) {
- return lhs.toString().contains(rhs.toString());
- }
+ @Test
+ public void testCoerceLong() {
+ final JexlArithmetic ja = JEXL.getArithmetic();
+ final JexlEvalContext ctxt = new JexlEvalContext();
+ final JexlOptions options = ctxt.getEngineOptions();
+ options.setStrictArithmetic(true);
+ final String stmt = "a = 34L; b = 45.0D; c=56.0F; d=67B; e=78H;";
+ final JexlScript expr = JEXL.createScript(stmt);
+ /* Object value = */ expr.execute(ctxt);
+ Assert.assertEquals(34L, ja.toLong(ctxt.get("a")));
+ Assert.assertEquals(45L, ja.toLong(ctxt.get("b")));
+ Assert.assertEquals(56L, ja.toLong(ctxt.get("c")));
+ Assert.assertEquals(67L, ja.toLong(ctxt.get("d")));
+ Assert.assertEquals(78L, ja.toLong(ctxt.get("e")));
+ Assert.assertEquals(10L, ja.toLong("10"));
+ Assert.assertEquals(1L, ja.toLong(true));
+ Assert.assertEquals(0L, ja.toLong(false));
+ }
- public Boolean startsWith(final Var lhs, final Var rhs) {
- return lhs.toString().startsWith(rhs.toString());
- }
+ @Test
+ public void testCoercions() throws Exception {
+ asserter.assertExpression("1", Integer.valueOf(1)); // numerics default to Integer
+ asserter.assertExpression("5L", Long.valueOf(5));
- public Boolean endsWith(final Var lhs, final Var rhs) {
- return lhs.toString().endsWith(rhs.toString());
- }
+ asserter.setVariable("I2", Integer.valueOf(2));
+ asserter.setVariable("L2", Long.valueOf(2));
+ asserter.setVariable("L3", Long.valueOf(3));
+ asserter.setVariable("B10", BigInteger.TEN);
- public Var complement(final Var arg) {
- return new Var(~arg.value);
- }
+ // Integer & Integer => Integer
+ asserter.assertExpression("I2 + 2", Integer.valueOf(4));
+ asserter.assertExpression("I2 * 2", Integer.valueOf(4));
+ asserter.assertExpression("I2 - 2", Integer.valueOf(0));
+ asserter.assertExpression("I2 / 2", Integer.valueOf(1));
- public Object subtract(final String x, final String y) {
- final int ix = x.indexOf(y);
- if (ix < 0) {
- return x;
- }
- final StringBuilder strb = new StringBuilder(x.substring(0, ix));
- strb.append(x.substring(ix + y.length()));
- return strb.toString();
- }
+ // Integer & Long => Long
+ asserter.assertExpression("I2 * L2", Long.valueOf(4));
+ asserter.assertExpression("I2 / L2", Long.valueOf(1));
- public Object negate(final String str) {
- final int length = str.length();
- final StringBuilder strb = new StringBuilder(str.length());
- for (int c = length - 1; c >= 0; --c) {
- strb.append(str.charAt(c));
- }
- return strb.toString();
- }
+ // Long & Long => Long
+ asserter.assertExpression("L2 + 3", Long.valueOf(5));
+ asserter.assertExpression("L2 + L3", Long.valueOf(5));
+ asserter.assertExpression("L2 / L2", Long.valueOf(1));
+ asserter.assertExpression("L2 / 2", Long.valueOf(1));
- public Object not(final Var x) {
- throw new NullPointerException("make it fail");
- }
+ // BigInteger
+ asserter.assertExpression("B10 / 10", BigInteger.ONE);
+ asserter.assertExpression("B10 / I2", new BigInteger("5"));
+ asserter.assertExpression("B10 / L2", new BigInteger("5"));
}
@Test
- public void testArithmeticPlus() throws Exception {
- final JexlEngine jexl = new JexlBuilder().cache(64).arithmetic(new ArithmeticPlus(false)).create();
+ public void testCompare() {
+ // JEXL doesn't support more than one operator in the same expression, for example: 1 == 1 == 1
+ final Object[] EXPRESSIONS = {
+ // Basic compare
+ "1 == 1", true,
+ "1 != 1", false,
+ "1 != 2", true,
+ "1 > 2", false,
+ "1 >= 2", false,
+ "1 < 2", true,
+ "1 <= 2", true,
+ // Int <-> Float Coercion
+ "1.0 == 1", true,
+ "1 == 1.0", true,
+ "1.1 != 1", true,
+ "1.1 < 2", true,
+ // Big Decimal <-> Big Integer Coercion
+ "1.0b == 1h", true,
+ "1h == 1.0b", true,
+ "1.1b != 1h", true,
+ "1.1b < 2h", true,
+ // Mix all type of numbers
+ "1l == 1.0", true, // long and int
+ "1.0d == 1.0f", true, // double and float
+ "1l == 1.0b", true,
+ "1l == 1h", true,
+ "1.0d == 1.0b", true,
+ "1.0f == 1.0b", true,
+ "1.0d == 1h", true,
+ "1.0f == 1h", true,
+ // numbers and strings
+ "'1' == 1", true,
+ "'1' == 1l", true,
+ "'1' == 1h", true,
+ "'' == 0", true, // empty string is coerced to zero (ECMA compliance)
+ "'1.0' == 1", true,
+ "'1.0' == 1.0f", true,
+ "'1.0' == 1.0d", true,
+ "'1.0' == 1.0b", true,
+ "'1.01' == 1.01", true,
+ "'1.01' == 1", false,
+ "'1.01' == 1b", false,
+ "'1.01' == 1h", false,
+ "'1.00001' == 1b", false,
+ "'1.00001' == 1h", false,
+ "'1.00000001' == 1", false,
+ "'1.00000001' == 1b", false,
+ "'1.00000001' == 1h", false,
+ "1.0 >= '1'", true,
+ "1.0 > '1'", false,
+ };
+ final JexlEngine jexl = new JexlBuilder().create();
final JexlContext jc = new EmptyTestContext();
- runOverload(jexl, jc);
- runOverload(jexl, jc);
+ JexlExpression expression;
+
+ for (int e = 0; e < EXPRESSIONS.length; e += 2) {
+ final String stext = (String) EXPRESSIONS[e];
+ final Object expected = EXPRESSIONS[e + 1];
+ expression = jexl.createExpression(stext);
+ final Object result = expression.evaluate(jc);
+ Assert.assertEquals("failed on " + stext, expected, result);
+ }
}
@Test
- public void testArithmeticPlusNoCache() {
- final JexlEngine jexl = new JexlBuilder().cache(0).arithmetic(new ArithmeticPlus(false)).create();
- final JexlContext jc = new EmptyTestContext();
- runOverload(jexl, jc);
+ public void testDivClass() {
+ final JexlEngine jexl = new JexlBuilder().create();
+ final JexlContext jc = new MapContext();
+ final Object ra = jexl.createExpression("463.0d / 0.1").evaluate(jc);
+ Assert.assertEquals(Double.class, ra.getClass());
+ final Object r0 = jexl.createExpression("463.0B / 0.1").evaluate(jc);
+ Assert.assertEquals(java.math.BigDecimal.class, r0.getClass());
+ final Object r1 = jexl.createExpression("463.0B / 0.1B").evaluate(jc);
+ Assert.assertEquals(java.math.BigDecimal.class, r1.getClass());
}
- protected void runOverload(final JexlEngine jexl, final JexlContext jc) {
- JexlScript script;
- Object result;
-
- script = jexl.createScript("(x, y)->{ x < y }");
- result = script.execute(jc, 42, 43);
- Assert.assertEquals(true, result);
- result = script.execute(jc, new Var(42), new Var(43));
- Assert.assertEquals(true, result);
- result = script.execute(jc, new Var(42), new Var(43));
- Assert.assertEquals(true, result);
- result = script.execute(jc, 43, 42);
- Assert.assertEquals(false, result);
- result = script.execute(jc, new Var(43), new Var(42));
- Assert.assertEquals(false, result);
-
- script = jexl.createScript("(x, y)->{ x <= y }");
- result = script.execute(jc, 42, 43);
- Assert.assertEquals(true, result);
- result = script.execute(jc, new Var(42), new Var(43));
- Assert.assertEquals(true, result);
- result = script.execute(jc, new Var(41), new Var(44));
- Assert.assertEquals(true, result);
- result = script.execute(jc, 43, 42);
- Assert.assertEquals(false, result);
- result = script.execute(jc, new Var(45), new Var(40));
- Assert.assertEquals(false, result);
-
- script = jexl.createScript("(x, y)->{ x > y }");
- result = script.execute(jc, 42, 43);
- Assert.assertEquals(false, result);
- result = script.execute(jc, new Var(42), new Var(43));
- Assert.assertEquals(false, result);
- result = script.execute(jc, new Var(42), new Var(43));
- Assert.assertEquals(false, result);
- result = script.execute(jc, 43, 42);
- Assert.assertEquals(true, result);
- result = script.execute(jc, new Var(43), new Var(42));
- Assert.assertEquals(true, result);
-
- script = jexl.createScript("(x, y)->{ x >= y }");
- result = script.execute(jc, 42, 43);
- Assert.assertEquals(false, result);
- result = script.execute(jc, new Var(42), new Var(43));
- Assert.assertEquals(false, result);
- result = script.execute(jc, new Var(41), new Var(44));
- Assert.assertEquals(false, result);
- result = script.execute(jc, 43, 42);
- Assert.assertEquals(true, result);
- result = script.execute(jc, new Var(45), new Var(40));
- Assert.assertEquals(true, result);
-
- script = jexl.createScript("(x, y)->{ x == y }");
- result = script.execute(jc, 42, 43);
- Assert.assertEquals(false, result);
- result = script.execute(jc, new Var(42), new Var(43));
- Assert.assertEquals(false, result);
- result = script.execute(jc, new Var(41), new Var(44));
- Assert.assertEquals(false, result);
- result = script.execute(jc, 43, 42);
- Assert.assertEquals(false, result);
- result = script.execute(jc, new Var(45), new Var(40));
- Assert.assertEquals(false, result);
+ /**
+ *
+ * if silent, all arith exception return 0.0
+ * if not silent, all arith exception throw
+ */
+ @Test
+ public void testDivideByZero() throws Exception {
+ final Map<String, Object> vars = new HashMap<>();
+ final JexlEvalContext context = new JexlEvalContext(vars);
+ final JexlOptions options = context.getEngineOptions();
+ options.setStrictArithmetic(true);
+ vars.put("aByte", Byte.valueOf((byte) 1));
+ vars.put("aShort", Short.valueOf((short) 2));
+ vars.put("aInteger", Integer.valueOf(3));
+ vars.put("aLong", Long.valueOf(4));
+ vars.put("aFloat", Float.valueOf((float) 5.5));
+ vars.put("aDouble", Double.valueOf(6.6));
+ vars.put("aBigInteger", new BigInteger("7"));
+ vars.put("aBigDecimal", new BigDecimal("8.8"));
- script = jexl.createScript("(x, y)->{ x != y }");
- result = script.execute(jc, 42, 43);
- Assert.assertEquals(true, result);
- result = script.execute(jc, new Var(42), new Var(43));
- Assert.assertEquals(true, result);
- result = script.execute(jc, new Var(44), new Var(44));
- Assert.assertEquals(false, result);
- result = script.execute(jc, 44, 44);
- Assert.assertEquals(false, result);
- result = script.execute(jc, new Var(45), new Var(40));
- Assert.assertEquals(true, result);
+ vars.put("zByte", Byte.valueOf((byte) 0));
+ vars.put("zShort", Short.valueOf((short) 0));
+ vars.put("zInteger", Integer.valueOf(0));
+ vars.put("zLong", Long.valueOf(0));
+ vars.put("zFloat", Float.valueOf(0));
+ vars.put("zDouble", Double.valueOf(0));
+ vars.put("zBigInteger", new BigInteger("0"));
+ vars.put("zBigDecimal", new BigDecimal("0"));
- script = jexl.createScript("(x, y)->{ x % y }");
- result = script.execute(jc, 4242, 100);
- Assert.assertEquals(42, result);
- result = script.execute(jc, new Var(4242), new Var(100));
- Assert.assertEquals(42, ((Var) result).value);
+ final String[] tnames = {
+ "Byte", "Short", "Integer", "Long",
+ "Float", "Double",
+ "BigInteger", "BigDecimal"
+ };
+ // number of permutations this will generate
+ final int PERMS = tnames.length * tnames.length;
- script = jexl.createScript("(x, y)->{ x * y }");
- result = script.execute(jc, 6, 7);
- Assert.assertEquals(42, result);
- result = script.execute(jc, new Var(6), new Var(7));
- Assert.assertEquals(42, ((Var) result).value);
+ final JexlEngine jexl = JEXL;
+ // for non-silent, silent...
+ for (int s = 0; s < 2; ++s) {
+ final boolean strict = s != 0;
+ options.setStrict(true);
+ options.setStrictArithmetic(strict);
+ int zthrow = 0;
+ int zeval = 0;
+ // for vars of all types...
+ for (final String vname : tnames) {
+ // for zeros of all types...
+ for (final String zname : tnames) {
+ // divide var by zero
+ final String expr = "a" + vname + " / " + "z" + zname;
+ try {
+ final JexlExpression zexpr = jexl.createExpression(expr);
+ final Object nan = zexpr.evaluate(context);
+ // check we have a zero & incremement zero count
+ if (nan instanceof Number) {
+ final double zero = ((Number) nan).doubleValue();
+ if (zero == 0.0) {
+ zeval += 1;
+ }
+ }
+ } catch (final Exception any) {
+ // increment the exception count
+ zthrow += 1;
+ }
+ }
+ }
+ if (strict) {
+ Assert.assertEquals("All expressions should have thrown " + zthrow + "/" + PERMS, zthrow, PERMS);
+ } else {
+ Assert.assertEquals("All expressions should have zeroed " + zeval + "/" + PERMS, zeval, PERMS);
+ }
+ }
+ debuggerCheck(jexl);
+ }
- script = jexl.createScript("(x, y)->{ x + y }");
- result = script.execute(jc, 35, 7);
- Assert.assertEquals(42, result);
- result = script.execute(jc, new Var(35), new Var(7));
- Assert.assertEquals(42, ((Var) result).value);
+ @Test
+ public void testDivideEdges() {
+ assertNullOperand(() -> jexla.divide(null, null));
+ Assert.assertEquals(0, jexlb.divide(null, null));
+ assertNullOperand(() -> jexla.divide(null, null));
+ Assert.assertEquals(0, jexlb.mod(null, null));
+ assertArithmeticException(() -> jexla.divide(1, 0));
+ assertArithmeticException(() -> jexla.divide(1L, 0L));
+ assertArithmeticException(() -> jexla.divide(1f, 0f));
+ assertArithmeticException(() -> jexla.divide(1d, 0d));
+ assertArithmeticException(() -> jexla.divide(BigInteger.ONE, BigInteger.ZERO));
+ assertArithmeticException(() -> jexla.divide(BigInteger.ONE, BigDecimal.ZERO));
+ }
- script = jexl.createScript("(x, y)->{ x - y }");
- result = script.execute(jc, 49, 7);
- Assert.assertEquals(42, result);
- result = script.execute(jc, "foobarquux", "bar");
- Assert.assertEquals("fooquux", result);
- result = script.execute(jc, 50, 8);
- Assert.assertEquals(42, result);
- result = script.execute(jc, new Var(50), new Var(8));
- Assert.assertEquals(42, ((Var) result).value);
+ @Test
+ public void testEmpty() throws Exception {
+ final Object[] SCRIPTS = {
+ "var x = null; log('x = %s', x);", 0,
+ "var x = 'abc'; log('x = %s', x);", 1,
+ "var x = 333; log('x = %s', x);", 1,
+ "var x = [1, 2]; log('x = %s', x);", 2,
+ "var x = ['a', 'b']; log('x = %s', x);", 2,
+ "var x = {1:'A', 2:'B'}; log('x = %s', x);", 1,
+ "var x = null; return empty(x);", true,
+ "var x = ''; return empty(x);", true,
+ "var x = 'abc'; return empty(x);", false,
+ "var x = 0; return empty(x);", true,
+ "var x = 333; return empty(x);", false,
+ "var x = []; return empty(x);", true,
+ "var x = [1, 2]; return empty(x);", false,
+ "var x = ['a', 'b']; return empty(x);", false,
+ "var x = [...]; return empty(x);", true,
+ "var x = [1, 2,...]; return empty(x);", false,
+ "var x = {:}; return empty(x);", true,
+ "var x = {1:'A', 2:'B'}; return empty(x);", false,
+ "var x = {}; return empty(x);", true,
+ "var x = {'A','B'}; return empty(x);", false
+ };
+ final JexlEngine jexl = new JexlBuilder().create();
+ final JexlContext jc = new EmptyTestContext();
+ JexlScript script;
- script = jexl.createScript("(x)->{ -x }");
- result = script.execute(jc, -42);
- Assert.assertEquals(42, result);
- result = script.execute(jc, new Var(-42));
- Assert.assertEquals(42, ((Var) result).value);
- result = script.execute(jc, "pizza");
- Assert.assertEquals("azzip", result);
- result = script.execute(jc, -142);
- Assert.assertEquals(142, result);
+ for (int e = 0; e < SCRIPTS.length; e += 2) {
+ final String stext = (String) SCRIPTS[e];
+ final Object expected = SCRIPTS[e + 1];
+ script = jexl.createScript(stext);
+ final Object result = script.execute(jc);
+ Assert.assertEquals("failed on " + stext, expected, result);
+ }
+ }
- script = jexl.createScript("(x)->{ ~x }");
- result = script.execute(jc, -1);
- Assert.assertEquals(0L, result);
- result = script.execute(jc, new Var(-1));
- Assert.assertEquals(0L, ((Var) result).value);
- result = script.execute(jc, new Var(-42));
- Assert.assertEquals(41, ((Var) result).value);
+ @Test
+ public void testEmptyDouble() {
+ Object x;
+ x = JEXL.createScript("4294967296.d").execute(null);
+ Assert.assertEquals(4294967296.0d, (Double) x, EPSILON);
+ checkEmpty(x, false);
+ x = JEXL.createScript("4294967296.0d").execute(null);
+ Assert.assertEquals(4294967296.0d, (Double) x, EPSILON);
+ checkEmpty(x, false);
+ x = JEXL.createScript("0.0d").execute(null);
+ Assert.assertEquals(0.0d, (Double) x, EPSILON);
+ checkEmpty(x, true);
+ x = Double.NaN;
+ checkEmpty(x, true);
- script = jexl.createScript("(x, y)->{ x ^ y }");
- result = script.execute(jc, 35, 7);
- Assert.assertEquals(36L, result);
- result = script.execute(jc, new Var(35), new Var(7));
- Assert.assertEquals(36L, ((Var) result).value);
- // legacy
- script = jexl.createScript("(x, y)->bitwiseXor(x,y)");
- result = script.execute(jc, 35, 7);
- Assert.assertEquals(36L, result);
+ }
- script = jexl.createScript("(x, y)->{ x | y }");
- result = script.execute(jc, 35, 7);
- Assert.assertEquals(39L, result);
- result = script.execute(jc, new Var(35), new Var(7));
- Assert.assertEquals(39L, ((Var) result).value);
- // legacy
- script = jexl.createScript("(x, y)->bitwiseOr(x,y)");
- result = script.execute(jc, 35, 7);
- Assert.assertEquals(39L, result);
+ @Test
+ public void testEmptyFloat() {
+ Object x;
+ x = JEXL.createScript("4294967296.f").execute(null);
+ Assert.assertEquals(4294967296.0f, (Float) x, EPSILON);
+ checkEmpty(x, false);
+ x = JEXL.createScript("4294967296.0f").execute(null);
+ Assert.assertEquals(4294967296.0f, (Float) x, EPSILON);
+ checkEmpty(x, false);
+ x = JEXL.createScript("0.0f").execute(null);
+ Assert.assertEquals(0.0f, (Float) x, EPSILON);
+ checkEmpty(x, true);
+ x = Float.NaN;
+ checkEmpty(x, true);
+ }
- script = jexl.createScript("(x, y)->{ x << y }");
- result = script.execute(jc, 35, 1);
- Assert.assertEquals(70L, result);
- result = script.execute(jc, new Var(35), new Var(1));
- Assert.assertEquals(70L, ((Var) result).value);
+ @Test
+ public void testEmptyLong() {
+ Object x;
+ x = JEXL.createScript("new('java.lang.Long', 4294967296)").execute(null);
+ Assert.assertEquals(4294967296L, ((Long) x).longValue());
+ x = JEXL.createScript("new Long(4294967296)").execute(null);
+ Assert.assertEquals(4294967296L, ((Long) x).longValue());
+ x = JEXL.createScript("new('java.lang.Long', '4294967296')").execute(null);
+ Assert.assertEquals(4294967296L, ((Long) x).longValue());
+ x = JEXL.createScript("4294967296l").execute(null);
+ Assert.assertEquals(4294967296L, ((Long) x).longValue());
+ x = JEXL.createScript("4294967296L").execute(null);
+ Assert.assertEquals(4294967296L, ((Long) x).longValue());
+ checkEmpty(x, false);
+ x = JEXL.createScript("0L").execute(null);
+ Assert.assertEquals(0, ((Long) x).longValue());
+ checkEmpty(x, true);
+ }
- script = jexl.createScript("(x, y)->{ x >> y }");
- result = script.execute(jc, 42, 1);
- Assert.assertEquals(21L, result);
- result = script.execute(jc, new Var(42), new Var(1));
- Assert.assertEquals(21, ((Var) result).value);
+ @Test
+ public void testInfiniteArithmetic() throws Exception {
+ final Map<String, Object> ns = new HashMap<>();
+ ns.put("math", Math.class);
+ final JexlEngine jexl = new JexlBuilder().arithmetic(new Arithmetic132()).namespaces(ns).create();
- script = jexl.createScript("(x, y)->{ x >>> y }");
- result = script.execute(jc, 84, 2);
- Assert.assertEquals(21L, result);
- result = script.execute(jc, new Var(84), new Var(2));
- Assert.assertEquals(21, ((Var) result).value);
+ Object evaluate = jexl.createExpression("1/0").evaluate(null);
+ Assert.assertTrue(Double.isInfinite((Double) evaluate));
- script = jexl.createScript("(x, y)->{ x & y }");
- result = script.execute(jc, 35, 7);
- Assert.assertEquals(3L, result);
- result = script.execute(jc, new Var(35), new Var(7));
- Assert.assertEquals(3L, ((Var) result).value);
- // legacy
- script = jexl.createScript("(x, y)->bitwiseAnd(x,y)");
- result = script.execute(jc, 35, 7);
- Assert.assertEquals(3L, result);
+ evaluate = jexl.createExpression("-1/0").evaluate(null);
+ Assert.assertTrue(Double.isInfinite((Double) evaluate));
- script = jexl.createScript("(x, y)->{ x =^ y }");
- result = script.execute(jc, 3115, 31);
- Assert.assertFalse((Boolean) result);
- result = script.execute(jc, new Var(3115), new Var(31));
- Assert.assertTrue((Boolean) result);
+ evaluate = jexl.createExpression("1.0/0.0").evaluate(null);
+ Assert.assertTrue(Double.isInfinite((Double) evaluate));
- script = jexl.createScript("(x, y)->{ x !^ y }");
- result = script.execute(jc, 3115, 31);
- Assert.assertTrue((Boolean) result);
- result = script.execute(jc, new Var(3115), new Var(31));
- Assert.assertFalse((Boolean) result);
+ evaluate = jexl.createExpression("-1.0/0.0").evaluate(null);
+ Assert.assertTrue(Double.isInfinite((Double) evaluate));
- script = jexl.createScript("(x, y)->{ x =$ y }");
- result = script.execute(jc, 3115, 15);
- Assert.assertFalse((Boolean) result);
- result = script.execute(jc, new Var(3115), new Var(15));
- Assert.assertTrue((Boolean) result);
+ evaluate = jexl.createExpression("math:abs(-42)").evaluate(null);
+ Assert.assertEquals(42, evaluate);
+ }
- script = jexl.createScript("(x, y)->{ x !$ y }");
- result = script.execute(jc, 3115, 15);
- Assert.assertTrue((Boolean) result);
- result = script.execute(jc, new Var(3115), new Var(15));
- Assert.assertFalse((Boolean) result);
+ @Test
+ public void testIntegerCoercionEdges() {
+ assertNullOperand(() -> jexla.toBoolean(null));
+ Assert.assertTrue(jexla.toBoolean(date));
+ // int coercions
+ assertNullOperand(() -> jexla.toInteger(null));
+ Assert.assertEquals(0, jexlb.toInteger(null));
+ assertArithmeticException(() -> jexla.toInteger(date));
+ Assert.assertEquals(0, jexla.toInteger(Double.NaN));
+ Assert.assertEquals(0, jexla.toInteger(""));
+ Assert.assertEquals('b', jexla.toInteger('b'));
+ Assert.assertEquals(1, jexla.toInteger(new AtomicBoolean(true)));
+ Assert.assertEquals(0, jexla.toInteger(new AtomicBoolean(false)));
- script = jexl.createScript("(x, y)->{ x =~ y }");
- result = script.execute(jc, 3155, 15);
- Assert.assertFalse((Boolean) result);
- result = script.execute(jc, new Var(3155), new Var(15));
- Assert.assertFalse((Boolean) result);
- result = script.execute(jc, new Var(15), new Var(3155));
- Assert.assertTrue((Boolean) result);
+ // long coercions
+ assertNullOperand(() -> jexla.toLong(null));
+ Assert.assertEquals(0L, jexlb.toLong(null));
+ assertArithmeticException(() -> jexla.toLong(date));
+ Assert.assertEquals(0L, jexla.toLong(Double.NaN));
+ Assert.assertEquals(0L, jexla.toLong(""));
+ Assert.assertEquals('b', jexla.toLong('b'));
+ Assert.assertEquals(1L, jexla.toLong(new AtomicBoolean(true)));
+ Assert.assertEquals(0L, jexla.toLong(new AtomicBoolean(false)));
+ }
- script = jexl.createScript("(x, y)->{ x !~ y }");
- result = script.execute(jc, 3115, 15);
- Assert.assertTrue((Boolean) result);
- result = script.execute(jc, new Var(3155), new Var(15));
- Assert.assertTrue((Boolean) result);
- result = script.execute(jc, new Var(15), new Var(3155));
- Assert.assertFalse((Boolean) result);
+ @Test
+ public void testIsFloatingPointPattern() {
+ final JexlArithmetic ja = new JexlArithmetic(true);
- script = jexl.createScript("(x)->{ !x }");
- try {
- result = script.execute(jc, new Var(-42));
- Assert.fail("should fail");
- } catch (final JexlException xany) {
- Assert.assertTrue(xany instanceof JexlException.Operator);
- }
- }
+ Assert.assertFalse(ja.isFloatingPointNumber("floating point"));
+ Assert.assertFalse(ja.isFloatingPointNumber("a1."));
+ Assert.assertFalse(ja.isFloatingPointNumber("b1.2"));
+ Assert.assertFalse(ja.isFloatingPointNumber("-10.2a-34"));
+ Assert.assertFalse(ja.isFloatingPointNumber("+10.2a+34"));
+ Assert.assertFalse(ja.isFloatingPointNumber("0"));
+ Assert.assertFalse(ja.isFloatingPointNumber("1"));
+ Assert.assertFalse(ja.isFloatingPointNumber("12A"));
+ Assert.assertFalse(ja.isFloatingPointNumber("2F3"));
+ Assert.assertFalse(ja.isFloatingPointNumber("23"));
+ Assert.assertFalse(ja.isFloatingPointNumber("+3"));
+ Assert.assertFalse(ja.isFloatingPointNumber("+34"));
+ Assert.assertFalse(ja.isFloatingPointNumber("+3-4"));
+ Assert.assertFalse(ja.isFloatingPointNumber("+3.-4"));
+ Assert.assertFalse(ja.isFloatingPointNumber("3ee4"));
- public static class Callable173 {
- public Object call(final String... arg) {
- return 42;
- }
- public Object call(final Integer... arg) {
- return arg[0] * arg[1];
- }
+ Assert.assertTrue(ja.isFloatingPointNumber("0."));
+ Assert.assertTrue(ja.isFloatingPointNumber("1."));
+ Assert.assertTrue(ja.isFloatingPointNumber("1.2"));
+ Assert.assertTrue(ja.isFloatingPointNumber("1.2e3"));
+ Assert.assertTrue(ja.isFloatingPointNumber("2e3"));
+ Assert.assertTrue(ja.isFloatingPointNumber("+2e-3"));
+ Assert.assertTrue(ja.isFloatingPointNumber("+23E-34"));
+ Assert.assertTrue(ja.isFloatingPointNumber("+23.E-34"));
+ Assert.assertTrue(ja.isFloatingPointNumber("-23.4E+45"));
+ Assert.assertTrue(ja.isFloatingPointNumber("1.2e34"));
+ Assert.assertTrue(ja.isFloatingPointNumber("10.2e34"));
+ Assert.assertTrue(ja.isFloatingPointNumber("+10.2e34"));
+ Assert.assertTrue(ja.isFloatingPointNumber("-10.2e34"));
+ Assert.assertTrue(ja.isFloatingPointNumber("10.2e-34"));
+ Assert.assertTrue(ja.isFloatingPointNumber("10.2e+34"));
+ Assert.assertTrue(ja.isFloatingPointNumber("-10.2e-34"));
+ Assert.assertTrue(ja.isFloatingPointNumber("+10.2e+34"));
+ Assert.assertTrue(ja.isFloatingPointNumber("-10.2E-34"));
+ Assert.assertTrue(ja.isFloatingPointNumber("+10.2E+34"));
}
@Test
@@ -1430,548 +1386,592 @@ public class ArithmeticTest extends JexlTestCase {
}
- public static class Arithmetic132 extends JexlArithmetic {
- public Arithmetic132() {
- super(false);
- }
+ @Test
+ public void testLeftNullOperand() throws Exception {
+ asserter.setVariable("left", null);
+ asserter.setVariable("right", Integer.valueOf(8));
+ asserter.setStrict(true);
+ asserter.failExpression("left + right", ".*null.*");
+ asserter.failExpression("left - right", ".*null.*");
+ asserter.failExpression("left * right", ".*null.*");
+ asserter.failExpression("left / right", ".*null.*");
+ asserter.failExpression("left % right", ".*null.*");
+ asserter.failExpression("left & right", ".*null.*");
+ asserter.failExpression("left | right", ".*null.*");
+ asserter.failExpression("left ^ right", ".*null.*");
+ asserter.failExpression("left < right", ".*null.*");
+ asserter.failExpression("left <= right", ".*null.*");
+ asserter.failExpression("left > right", ".*null.*");
+ asserter.failExpression("left >= right", ".*null.*");
+ }
- protected double divideZero(final BigDecimal x) {
- final int ls = x.signum();
- if (ls < 0) {
- return Double.NEGATIVE_INFINITY;
- }
- if (ls > 0) {
- return Double.POSITIVE_INFINITY;
- }
- return Double.NaN;
- }
+ @Test
+ public void testLeftNullOperand2() throws Exception {
+ asserter.setVariable("x.left", null);
+ asserter.setVariable("right", Integer.valueOf(8));
+ asserter.setStrict(true);
+ asserter.failExpression("x.left + right", ".*null.*");
+ asserter.failExpression("x.left - right", ".*null.*");
+ asserter.failExpression("x.left * right", ".*null.*");
+ asserter.failExpression("x.left / right", ".*null.*");
+ asserter.failExpression("x.left % right", ".*null.*");
+ asserter.failExpression("x.left & right", ".*null.*");
+ asserter.failExpression("x.left | right", ".*null.*");
+ asserter.failExpression("x.left ^ right", ".*null.*");
+ asserter.failExpression("x.left < right", ".*null.*");
+ asserter.failExpression("x.left <= right", ".*null.*");
+ asserter.failExpression("x.left > right", ".*null.*");
+ asserter.failExpression("x.left >= right", ".*null.*");
+ }
- protected double divideZero(final BigInteger x) {
- final int ls = x.signum();
- if (ls < 0) {
- return Double.NEGATIVE_INFINITY;
- }
- if (ls > 0) {
- return Double.POSITIVE_INFINITY;
- }
- return Double.NaN;
- }
+ // JEXL-24: long integers (and doubles)
+ @Test
+ public void testLongLiterals() {
+ final JexlEvalContext ctxt = new JexlEvalContext();
+ final JexlOptions options = ctxt.getEngineOptions();
+ options.setStrictArithmetic(true);
+ final String stmt = "{a = 10L; b = 10l; c = 42.0D; d = 42.0d; e=56.3F; f=56.3f; g=63.5; h=0x10; i=010; j=0x10L; k=010l}";
+ final JexlScript expr = JEXL.createScript(stmt);
+ /* Object value = */ expr.execute(ctxt);
+ Assert.assertEquals(10L, ctxt.get("a"));
+ Assert.assertEquals(10L, ctxt.get("b"));
+ Assert.assertEquals(42.0D, ctxt.get("c"));
+ Assert.assertEquals(42.0d, ctxt.get("d"));
+ Assert.assertEquals(56.3f, ctxt.get("e"));
+ Assert.assertEquals(56.3f, ctxt.get("f"));
+ Assert.assertEquals(63.5d, ctxt.get("g"));
+ Assert.assertEquals(0x10, ctxt.get("h"));
+ Assert.assertEquals(010, ctxt.get("i")); // octal 010
+ Assert.assertEquals(0x10L, ctxt.get("j")); // octal 010L
+ Assert.assertEquals(010L, ctxt.get("k"));
+ }
- @Override
- public Object divide(final Object left, final Object right) {
- if (left == null && right == null) {
- return controlNullNullOperands(JexlOperator.DIVIDE);
- }
- // if either are bigdecimal use that type
- if (left instanceof BigDecimal || right instanceof BigDecimal) {
- final BigDecimal l = toBigDecimal(left);
- final BigDecimal r = toBigDecimal(right);
- if (BigDecimal.ZERO.equals(r)) {
- return divideZero(l);
- }
- final BigDecimal result = l.divide(r, getMathContext());
- return narrowBigDecimal(left, right, result);
- }
- // if either are floating point (double or float) use double
- if (isFloatingPointNumber(left) || isFloatingPointNumber(right)) {
- final double l = toDouble(left);
- final double r = toDouble(right);
- return Double.valueOf(l / r);
- }
- // otherwise treat as integers
- final BigInteger l = toBigInteger(left);
- final BigInteger r = toBigInteger(right);
- if (BigInteger.ZERO.equals(r)) {
- return divideZero(l);
- }
- final BigInteger result = l.divide(r);
- return narrowBigInteger(left, right, result);
- }
+ @Test
+ public void testMinusClass() {
+ final JexlEngine jexl = new JexlBuilder().create();
+ final JexlContext jc = new MapContext();
+ final Object ra = jexl.createExpression("463.0d - 0.1").evaluate(jc);
+ Assert.assertEquals(Double.class, ra.getClass());
+ final Object r0 = jexl.createExpression("463.0B - 0.1").evaluate(jc);
+ Assert.assertEquals(java.math.BigDecimal.class, r0.getClass());
+ final Object r1 = jexl.createExpression("463.0B - 0.1B").evaluate(jc);
+ Assert.assertEquals(java.math.BigDecimal.class, r1.getClass());
+ }
- @Override
- public Object mod(final Object left, final Object right) {
- if (left == null && right == null) {
- return controlNullNullOperands(JexlOperator.MOD);
- }
- // if either are bigdecimal use that type
- if (left instanceof BigDecimal || right instanceof BigDecimal) {
- final BigDecimal l = toBigDecimal(left);
- final BigDecimal r = toBigDecimal(right);
- if (BigDecimal.ZERO.equals(r)) {
- return divideZero(l);
- }
- final BigDecimal remainder = l.remainder(r, getMathContext());
- return narrowBigDecimal(left, right, remainder);
- }
- // if either are floating point (double or float) use double
- if (isFloatingPointNumber(left) || isFloatingPointNumber(right)) {
- final double l = toDouble(left);
- final double r = toDouble(right);
- return Double.valueOf(l % r);
- }
- // otherwise treat as integers
- final BigInteger l = toBigInteger(left);
- final BigInteger r = toBigInteger(right);
- final BigInteger result = l.mod(r);
- if (BigInteger.ZERO.equals(r)) {
- return divideZero(l);
- }
- return narrowBigInteger(left, right, result);
- }
+ @Test
+ public void testMinusMinusPostfix() throws Exception {
+ asserter.setVariable("aByte", Byte.valueOf((byte) 2));
+ asserter.setVariable("aShort", Short.valueOf((short) 3));
+ asserter.setVariable("anInteger", Integer.valueOf(4));
+ asserter.setVariable("aLong", Long.valueOf(5));
+ asserter.setVariable("aFloat", Float.valueOf((float) 6.6));
+ asserter.setVariable("aDouble", Double.valueOf(7.7));
+ asserter.setVariable("aBigInteger", new BigInteger("8"));
+ asserter.setVariable("aBigDecimal", new BigDecimal("9.9"));
+ asserter.setVariable("aString", "forty-two");
+
+ asserter.assertExpression("aByte--",Byte.valueOf((byte) 2));
+ asserter.assertExpression("aShort--", Short.valueOf((short) 3));
+ asserter.assertExpression("anInteger--", Integer.valueOf(4));
+ asserter.assertExpression("aLong--", Long.valueOf(5));
+ asserter.assertExpression("aFloat--", Float.valueOf((float) 6.6));
+ asserter.assertExpression("aDouble--", Double.valueOf(7.7));
+ asserter.assertExpression("aBigInteger--", new BigInteger("8"));
+ asserter.assertExpression("aBigDecimal--", new BigDecimal("9.9"));
+
+ asserter.assertExpression("aByte", Byte.valueOf((byte) 1));
+ asserter.assertExpression("aShort", Short.valueOf((short) 2));
+ asserter.assertExpression("anInteger", Integer.valueOf(3));
+ asserter.assertExpression("aLong", Long.valueOf(4));
+ asserter.assertExpression("aFloat", Float.valueOf((float) 5.6));
+ asserter.assertExpression("aDouble", Double.valueOf(6.7));
+ asserter.assertExpression("aBigInteger", new BigInteger("7"));
+ asserter.assertExpression("aBigDecimal", new BigDecimal("8.9"));
+
+ asserter.failExpression("aString--", "--", String::contains);
+ }
+
+ @Test
+ public void testMinusMinusPrefix() throws Exception {
+ asserter.setVariable("aByte", Byte.valueOf((byte) 2));
+ asserter.setVariable("aShort", Short.valueOf((short) 3));
+ asserter.setVariable("anInteger", Integer.valueOf(4));
+ asserter.setVariable("aLong", Long.valueOf(5));
+ asserter.setVariable("aFloat", Float.valueOf((float) 6.6));
+ asserter.setVariable("aDouble", Double.valueOf(7.7));
+ asserter.setVariable("aBigInteger", new BigInteger("8"));
+ asserter.setVariable("aBigDecimal", new BigDecimal("9.9"));
+ asserter.setVariable("aString", "forty-two");
+
+ asserter.assertExpression("--aByte", Byte.valueOf((byte) 1));
+ asserter.assertExpression("--aShort", Short.valueOf((short) 2));
+ asserter.assertExpression("--anInteger", Integer.valueOf(3));
+ asserter.assertExpression("--aLong", Long.valueOf(4));
+ asserter.assertExpression("--aFloat", Float.valueOf((float) 5.6));
+ asserter.assertExpression("--aDouble", Double.valueOf(6.7));
+ asserter.assertExpression("--aBigInteger", new BigInteger("7"));
+ asserter.assertExpression("--aBigDecimal", new BigDecimal("8.9"));
+
+ asserter.failExpression("aString--", "--", String::contains);
+ }
+
+ @Test
+ public void testModEdge() {
+ assertNullOperand(() -> jexla.mod(null, null));
+ Assert.assertEquals(0, jexlb.mod(null, null));
+ assertArithmeticException(() -> jexla.mod(1, 0));
+ assertArithmeticException(() -> jexla.mod(1L, 0L));
+ assertArithmeticException(() -> jexla.mod(1f, 0f));
+ assertArithmeticException(() -> jexla.mod(1d, 0d));
+ assertArithmeticException(() -> jexla.mod(BigInteger.ONE, BigInteger.ZERO));
+ assertArithmeticException(() -> jexla.mod(BigInteger.ONE, BigDecimal.ZERO));
+ assertNullOperand(() -> jexla.divide(null, null));
+ }
+
+ /**
+ * JEXL-156.
+ */
+ @Test
+ public void testMultClass(){
+ final JexlEngine jexl = new JexlBuilder().create();
+ final JexlContext jc = new MapContext();
+ final Object ra = jexl.createExpression("463.0d * 0.1").evaluate(jc);
+ Assert.assertEquals(Double.class, ra.getClass());
+ final Object r0 = jexl.createExpression("463.0B * 0.1").evaluate(jc);
+ Assert.assertEquals(java.math.BigDecimal.class, r0.getClass());
+ final Object r1 = jexl.createExpression("463.0B * 0.1B").evaluate(jc);
+ Assert.assertEquals(java.math.BigDecimal.class, r1.getClass());
+ }
+
+ @Test
+ public void testNaN() {
+ final Map<String, Object> ns = new HashMap<>();
+ ns.put("double", Double.class);
+ final JexlEngine jexl = new JexlBuilder().namespaces(ns).create();
+ JexlScript script;
+ Object result;
+ script = jexl.createScript("#NaN");
+ result = script.execute(null);
+ Assert.assertTrue(Double.isNaN((Double) result));
+ script = jexl.createScript("NaN");
+ result = script.execute(null);
+ Assert.assertTrue(Double.isNaN((Double) result));
+ script = jexl.createScript("double:isNaN(#NaN)");
+ result = script.execute(null);
+ Assert.assertTrue((Boolean) result);
+ script = jexl.createScript("double:isNaN(NaN)");
+ result = script.execute(null);
+ Assert.assertTrue((Boolean) result);
}
@Test
- public void testInfiniteArithmetic() throws Exception {
- final Map<String, Object> ns = new HashMap<>();
- ns.put("math", Math.class);
- final JexlEngine jexl = new JexlBuilder().arithmetic(new Arithmetic132()).namespaces(ns).create();
-
- Object evaluate = jexl.createExpression("1/0").evaluate(null);
- Assert.assertTrue(Double.isInfinite((Double) evaluate));
-
- evaluate = jexl.createExpression("-1/0").evaluate(null);
- Assert.assertTrue(Double.isInfinite((Double) evaluate));
-
- evaluate = jexl.createExpression("1.0/0.0").evaluate(null);
- Assert.assertTrue(Double.isInfinite((Double) evaluate));
-
- evaluate = jexl.createExpression("-1.0/0.0").evaluate(null);
- Assert.assertTrue(Double.isInfinite((Double) evaluate));
+ public void testNarrowBig() throws Exception {
+ final List<String> ls = Arrays.asList("zero", "one", "two");
+ asserter.setVariable("list",ls);
+ asserter.setVariable("aBigDecimal", new BigDecimal("1"));
+ asserter.setVariable("aBigInteger", new BigDecimal("1"));
+ asserter.assertExpression("list.get(aBigDecimal)", "one");
+ asserter.assertExpression("list.get(aBigInteger)", "one");
+ }
- evaluate = jexl.createExpression("math:abs(-42)").evaluate(null);
- Assert.assertEquals(42, evaluate);
+ @Test
+ public void testNarrowBigDecimal() throws Exception {
+ asserter.setVariable("bi420", BigInteger.valueOf(420));
+ asserter.setVariable("bi10", BigInteger.valueOf(10));
+ asserter.setVariable("bd420", new BigDecimal("420"));
+ asserter.setVariable("bd10", new BigDecimal("10"));
+ asserter.assertExpression("420 / bi10", 42);
+ asserter.assertExpression("420l / bi10", 42L);
+ asserter.assertExpression("bi420 / 420", 1);
+ asserter.assertExpression("bi420 / 420l", 1L);
+ asserter.assertExpression("bd420 / 10", new BigDecimal("42"));
}
- private static Document getDocument(final String xml) throws Exception {
- final DocumentBuilder xmlBuilder = DocumentBuilderFactory.newInstance().newDocumentBuilder();
- final InputStream stringInputStream = new ByteArrayInputStream(xml.getBytes(StandardCharsets.UTF_8));
- return xmlBuilder.parse(stringInputStream);
+ @Test
+ public void testNullArgs() {
+ final JexlEngine jexl = new JexlBuilder().arithmetic(new JexlArithmetic(true) {
+ @Override public boolean isStrict(final JexlOperator op) {
+ return JexlOperator.ADD == op? false: super.isStrict(op);
+ }
+ }).create();
+ final JexlScript script = jexl.createScript("'1.2' + x ", "x");
+ final Object result = script.execute(null);
+ Assert.assertEquals("1.2", result);
}
- public static class XmlArithmetic extends JexlArithmetic {
- public XmlArithmetic(final boolean astrict) {
- super(astrict);
- }
+ @Test
+ public void testNullOperand() throws Exception {
+ asserter.setVariable("right", null);
+ asserter.failExpression("~right", ".*null.*");
+ }
- public XmlArithmetic(final boolean astrict, final MathContext bigdContext, final int bigdScale) {
- super(astrict, bigdContext, bigdScale);
- }
+ @Test
+ public void testNullOperands() throws Exception {
+ asserter.setVariable("left", null);
+ asserter.setVariable("right", null);
+ asserter.failExpression("left + right", ".*null.*");
+ asserter.failExpression("left - right", ".*null.*");
+ asserter.failExpression("left * right", ".*null.*");
+ asserter.failExpression("left / right", ".*null.*");
+ asserter.failExpression("left % right", ".*null.*");
+ asserter.failExpression("left & right", ".*null.*");
+ asserter.failExpression("left | right", ".*null.*");
+ asserter.failExpression("left ^ right", ".*null.*");
+ }
- public boolean empty(final org.w3c.dom.Element elt) {
- return !elt.hasAttributes() && !elt.hasChildNodes();
- }
+ @Test
+ public void testOperatorsEdges() {
+ assertNullOperand(() -> jexla.multiply(null, null));
+ Assert.assertEquals(0, jexlb.multiply(null, null));
+ assertNullOperand(() -> jexla.add(null, null));
+ Assert.assertEquals(0, jexlb.add(null, null));
+ assertNullOperand(() -> jexla.subtract(null, null));
+ Assert.assertEquals(0, jexlb.subtract(null, null));
- public int size(final org.w3c.dom.Element elt) {
- return elt.getChildNodes().getLength();
- }
+ Assert.assertTrue(jexla.contains(null, null));
+ Assert.assertFalse(jexla.contains(true, null));
+ Assert.assertFalse(jexla.contains(null, true));
+ Assert.assertTrue(jexla.endsWith(null, null));
+ Assert.assertFalse(jexla.endsWith(true, null));
+ Assert.assertFalse(jexla.endsWith(null, true));
+ Assert.assertTrue(jexla.startsWith(null, null));
+ Assert.assertFalse(jexla.startsWith(true, null));
+ Assert.assertFalse(jexla.startsWith(null, true));
+ Assert.assertTrue(jexla.isEmpty(null));
}
- /**
- * Inspired by JEXL-16{1,2}.
- */
@Test
- public void testXmlArithmetic() throws Exception {
- Document xml;
- Node x;
- Boolean empty;
- int size;
- final JexlEvalContext ctxt = new JexlEvalContext();
- final JexlEngine jexl = new JexlBuilder().strict(true).safe(false).arithmetic(new XmlArithmetic(false)).create();
- final JexlScript e0 = jexl.createScript("x.empty()", "x");
- final JexlScript e1 = jexl.createScript("empty(x)", "x");
- final JexlScript s0 = jexl.createScript("x.size()", "x");
- final JexlScript s1 = jexl.createScript("size(x)", "x");
+ public void testOption() {
+ final Map<String, Object> vars = new HashMap<>();
+ final JexlEvalContext context = new JexlEvalContext(vars);
+ final JexlOptions options = context.getEngineOptions();
+ options.setStrictArithmetic(true);
+ final JexlScript script = JEXL.createScript("0 + '1.2' ");
+ Object result;
- empty = (Boolean) e1.execute(null, (Object) null);
- Assert.assertTrue(empty);
- size = (Integer) s1.execute(null, (Object) null);
- Assert.assertEquals(0, size);
+ options.setStrictArithmetic(true);
+ result = script.execute(context);
+ Assert.assertEquals("01.2", result);
- try {
- final Object xx = e0.execute(null, (Object) null);
- Assert.assertNull(xx);
- } catch (final JexlException.Variable xvar) {
- Assert.assertNotNull(xvar);
- }
- try {
- final Object xx = s0.execute(null, (Object) null);
- Assert.assertNull(xx);
- } catch (final JexlException.Variable xvar) {
- Assert.assertNotNull(xvar);
- }
- final JexlOptions options = ctxt.getEngineOptions();
- options.setSafe(true);
- final Object x0 = e0.execute(ctxt, (Object) null);
- Assert.assertNull(x0);
- final Object x1 = s0.execute(ctxt, (Object) null);
- Assert.assertNull(x1);
+ options.setStrictArithmetic(false);
+ result = script.execute(context);
+ Assert.assertEquals(1.2d, (Double) result, EPSILON);
+ }
- xml = getDocument("<node info='123'/>");
- x = xml.getLastChild();
- empty = (Boolean) e0.execute(null, x);
- Assert.assertFalse(empty);
- empty = (Boolean) e1.execute(null, x);
- Assert.assertFalse(empty);
- size = (Integer) s0.execute(null, x);
- Assert.assertEquals(0, size);
- size = (Integer) s1.execute(null, x);
- Assert.assertEquals(0, size);
- xml = getDocument("<node><a/><b/></node>");
- x = xml.getLastChild();
- empty = (Boolean) e0.execute(null, x);
- Assert.assertFalse(empty);
- empty = (Boolean) e1.execute(null, x);
- Assert.assertFalse(empty);
- size = (Integer) s0.execute(null, x);
- Assert.assertEquals(2, size);
- size = (Integer) s1.execute(null, x);
- Assert.assertEquals(2, size);
- xml = getDocument("<node/>");
- x = xml.getLastChild();
- empty = (Boolean) e0.execute(null, x);
- Assert.assertTrue(empty);
- empty = (Boolean) e1.execute(null, x);
- Assert.assertTrue(empty);
- size = (Integer) s0.execute(null, x);
- Assert.assertEquals(0, size);
- size = (Integer) s1.execute(null, x);
- Assert.assertEquals(0, size);
- xml = getDocument("<node info='123'/>");
- NamedNodeMap nnm = xml.getLastChild().getAttributes();
- Attr info = (Attr) nnm.getNamedItem("info");
- Assert.assertEquals("123", info.getValue());
+ @Test
+ public void testOverflows() throws Exception {
+ asserter.assertExpression("1 + 2147483647", Long.valueOf("2147483648"));
+ asserter.assertExpression("3 + " + (Long.MAX_VALUE - 2), BigInteger.valueOf(Long.MAX_VALUE).add(BigInteger.ONE));
+ asserter.assertExpression("-2147483648 - 1", Long.valueOf("-2147483649"));
+ asserter.assertExpression("-3 + " + (Long.MIN_VALUE + 2), BigInteger.valueOf(Long.MIN_VALUE).subtract(BigInteger.ONE));
+ asserter.assertExpression("1 + 9223372036854775807", new BigInteger("9223372036854775808"));
+ asserter.assertExpression("-1 + (-9223372036854775808)", new BigInteger("-9223372036854775809"));
+ asserter.assertExpression("-9223372036854775808 - 1", new BigInteger("-9223372036854775809"));
+ final BigInteger maxl = BigInteger.valueOf(Long.MAX_VALUE);
+ asserter.assertExpression(maxl + " * " + maxl , maxl.multiply(maxl));
+ }
- // JEXL-161
+ @Test
+ public void testPlusClass() {
+ final JexlEngine jexl = new JexlBuilder().create();
final JexlContext jc = new MapContext();
- jc.set("x", xml.getLastChild());
- final String y = "456";
- jc.set("y", y);
- final JexlScript s = jexl.createScript("x.attribute.info = y");
- Object r;
- try {
- r = s.execute(jc);
- nnm = xml.getLastChild().getAttributes();
- info = (Attr) nnm.getNamedItem("info");
- Assert.assertEquals(y, r);
- Assert.assertEquals(y, info.getValue());
- } catch (final JexlException.Property xprop) {
- // test fails in java > 11 because modules, etc; need investigation
- Assert.assertTrue(xprop.getMessage().contains("info"));
- Assert.assertTrue(getJavaVersion() > 11);
- }
+ final Object ra = jexl.createExpression("463.0d + 0.1").evaluate(jc);
+ Assert.assertEquals(Double.class, ra.getClass());
+ final Object r0 = jexl.createExpression("463.0B + 0.1").evaluate(jc);
+ Assert.assertEquals(java.math.BigDecimal.class, r0.getClass());
+ final Object r1 = jexl.createExpression("463.0B + 0.1B").evaluate(jc);
+ Assert.assertEquals(java.math.BigDecimal.class, r1.getClass());
}
- /**
- * Returns the Java version as an int value.
- * @return the Java version as an int value (8, 9, etc.)
- */
- private static int getJavaVersion() {
- String version = System.getProperty("java.version");
- if (version.startsWith("1.")) {
- version = version.substring(2);
- }
- int sep = version.indexOf(".");
- if (sep < 0) {
- sep = version.indexOf("-");
- }
- if (sep > 0) {
- version = version.substring(0, sep);
- }
- return Integer.parseInt(version);
+ @Test
+ public void testPlusPlusPostfix() throws Exception {
+ asserter.setVariable("aByte", Byte.valueOf((byte) 0));
+ asserter.setVariable("aShort", Short.valueOf((short) 1));
+ asserter.setVariable("anInteger", Integer.valueOf(2));
+ asserter.setVariable("aLong", Long.valueOf(3));
+ asserter.setVariable("aFloat", Float.valueOf((float) 4.4));
+ asserter.setVariable("aDouble", Double.valueOf(5.5));
+ asserter.setVariable("aBigInteger", new BigInteger("6"));
+ asserter.setVariable("aBigDecimal", new BigDecimal("7.7"));
+ asserter.setVariable("aString", "forty-two");
+
+ asserter.assertExpression("aByte++", Byte.valueOf((byte) 0));
+ asserter.assertExpression("aShort++", Short.valueOf((short) 1));
+ asserter.assertExpression("anInteger++", Integer.valueOf(2));
+ asserter.assertExpression("aLong++", Long.valueOf(3));
+ asserter.assertExpression("aFloat++", Float.valueOf((float) 4.4));
+ asserter.assertExpression("aDouble++", Double.valueOf(5.5));
+ asserter.assertExpression("aBigInteger++", new BigInteger("6"));
+ asserter.assertExpression("aBigDecimal++", new BigDecimal("7.7"));
+
+ asserter.assertExpression("aByte", Byte.valueOf((byte) 1));
+ asserter.assertExpression("aShort", Short.valueOf((short) 2));
+ asserter.assertExpression("anInteger", Integer.valueOf(3));
+ asserter.assertExpression("aLong", Long.valueOf(4));
+ asserter.assertExpression("aFloat", Float.valueOf((float) 5.4));
+ asserter.assertExpression("aDouble", Double.valueOf(6.5));
+ asserter.assertExpression("aBigInteger", new BigInteger("7"));
+ asserter.assertExpression("aBigDecimal", new BigDecimal("8.7"));
+
+ asserter.failExpression("aString++", "++", String::contains);
}
@Test
- public void testEmptyLong() {
- Object x;
- x = JEXL.createScript("new('java.lang.Long', 4294967296)").execute(null);
- Assert.assertEquals(4294967296L, ((Long) x).longValue());
- x = JEXL.createScript("new Long(4294967296)").execute(null);
- Assert.assertEquals(4294967296L, ((Long) x).longValue());
- x = JEXL.createScript("new('java.lang.Long', '4294967296')").execute(null);
- Assert.assertEquals(4294967296L, ((Long) x).longValue());
- x = JEXL.createScript("4294967296l").execute(null);
- Assert.assertEquals(4294967296L, ((Long) x).longValue());
- x = JEXL.createScript("4294967296L").execute(null);
- Assert.assertEquals(4294967296L, ((Long) x).longValue());
- checkEmpty(x, false);
- x = JEXL.createScript("0L").execute(null);
- Assert.assertEquals(0, ((Long) x).longValue());
- checkEmpty(x, true);
+ public void testPlusPlusPrefix() throws Exception {
+ asserter.setVariable("aByte", Byte.valueOf((byte) 0));
+ asserter.setVariable("aShort", Short.valueOf((short) 1));
+ asserter.setVariable("anInteger", Integer.valueOf(2));
+ asserter.setVariable("aLong", Long.valueOf(3));
+ asserter.setVariable("aFloat", Float.valueOf((float) 4.4));
+ asserter.setVariable("aDouble", Double.valueOf(5.5));
+ asserter.setVariable("aBigInteger", new BigInteger("6"));
+ asserter.setVariable("aBigDecimal", new BigDecimal("7.7"));
+ asserter.setVariable("aString", "forty-two");
+
+ asserter.assertExpression("++aByte", Byte.valueOf((byte) 1));
+ asserter.assertExpression("++aShort", Short.valueOf((short) 2));
+ asserter.assertExpression("++anInteger", Integer.valueOf(3));
+ asserter.assertExpression("++aLong", Long.valueOf(4));
+ asserter.assertExpression("++aFloat", Float.valueOf((float) 5.4));
+ asserter.assertExpression("++aDouble", Double.valueOf(6.5));
+ asserter.assertExpression("++aBigInteger", new BigInteger("7"));
+ asserter.assertExpression("++aBigDecimal", new BigDecimal("8.7"));
+
+ asserter.failExpression("++aString", "++", String::contains);
}
@Test
- public void testEmptyFloat() {
- Object x;
- x = JEXL.createScript("4294967296.f").execute(null);
- Assert.assertEquals(4294967296.0f, (Float) x, EPSILON);
- checkEmpty(x, false);
- x = JEXL.createScript("4294967296.0f").execute(null);
- Assert.assertEquals(4294967296.0f, (Float) x, EPSILON);
- checkEmpty(x, false);
- x = JEXL.createScript("0.0f").execute(null);
- Assert.assertEquals(0.0f, (Float) x, EPSILON);
- checkEmpty(x, true);
- x = Float.NaN;
- checkEmpty(x, true);
+ public void testRealCoercionEdges() {
+ assertNullOperand(() -> jexla.toDouble(null));
+ Assert.assertEquals(0.0d, jexlb.toDouble(null), EPSILON);
+ Assert.assertEquals(32.0d, jexlb.toDouble((char) 32), EPSILON);
+ assertArithmeticException(() -> jexla.toDouble(date));
+ Assert.assertTrue(Double.isNaN(jexla.toDouble("")));
+ Assert.assertEquals("", jexla.toString(Double.NaN));
+
+ assertNullOperand(() -> jexla.toBigInteger(null));
+ assertArithmeticException(() -> jexla.toBigInteger(date));
+ Assert.assertEquals(BigInteger.ZERO, jexla.toBigInteger(Double.NaN));
+ Assert.assertEquals(BigInteger.ZERO, jexla.toBigInteger(""));
+ Assert.assertEquals(BigInteger.ZERO, jexla.toBigInteger((char) 0));
+
+ assertNullOperand(() -> jexla.toBigDecimal(null));
+ assertArithmeticException(() -> jexla.toBigDecimal(date));
+
+ Assert.assertEquals(BigDecimal.ZERO, jexla.toBigDecimal(Double.NaN));
+ Assert.assertEquals(BigDecimal.ZERO, jexla.toBigDecimal(""));
+ Assert.assertEquals(BigDecimal.ZERO, jexla.toBigDecimal((char) 0));
}
@Test
- public void testEmptyDouble() {
- Object x;
- x = JEXL.createScript("4294967296.d").execute(null);
- Assert.assertEquals(4294967296.0d, (Double) x, EPSILON);
- checkEmpty(x, false);
- x = JEXL.createScript("4294967296.0d").execute(null);
- Assert.assertEquals(4294967296.0d, (Double) x, EPSILON);
- checkEmpty(x, false);
- x = JEXL.createScript("0.0d").execute(null);
- Assert.assertEquals(0.0d, (Double) x, EPSILON);
- checkEmpty(x, true);
- x = Double.NaN;
- checkEmpty(x, true);
-
+ public void testRightNullOperand() throws Exception {
+ asserter.setVariable("left", Integer.valueOf(9));
+ asserter.setVariable("right", null);
+ asserter.failExpression("left + right", ".*null.*");
+ asserter.failExpression("left - right", ".*null.*");
+ asserter.failExpression("left * right", ".*null.*");
+ asserter.failExpression("left / right", ".*null.*");
+ asserter.failExpression("left % right", ".*null.*");
+ asserter.failExpression("left & right", ".*null.*");
+ asserter.failExpression("left | right", ".*null.*");
+ asserter.failExpression("left ^ right", ".*null.*");
+ asserter.failExpression("left < right", ".*null.*");
+ asserter.failExpression("left <= right", ".*null.*");
+ asserter.failExpression("left > right", ".*null.*");
+ asserter.failExpression("left >= right", ".*null.*");
}
- void checkEmpty(final Object x, final boolean expect) {
- final JexlScript s0 = JEXL.createScript("empty(x)", "x");
- boolean empty = (Boolean) s0.execute(null, x);
- Assert.assertEquals(expect, empty);
- final JexlScript s1 = JEXL.createScript("empty x", "x");
- empty = (Boolean) s1.execute(null, x);
- Assert.assertEquals(expect, empty);
- final JexlScript s2 = JEXL.createScript("x.empty()", "x");
- empty = (Boolean) s2.execute(null, x);
- Assert.assertEquals(expect, empty);
+ @Test
+ public void testRightNullOperand2() throws Exception {
+ asserter.setVariable("left", Integer.valueOf(9));
+ asserter.setVariable("y.right", null);
+ asserter.failExpression("left + y.right", ".*null.*");
+ asserter.failExpression("left - y.right", ".*null.*");
+ asserter.failExpression("left * y.right", ".*null.*");
+ asserter.failExpression("left / y.right", ".*null.*");
+ asserter.failExpression("left % y.right", ".*null.*");
+ asserter.failExpression("left & y.right", ".*null.*");
+ asserter.failExpression("left | y.right", ".*null.*");
+ asserter.failExpression("left ^ y.right", ".*null.*");
+ asserter.failExpression("left < y.right", ".*null.*");
+ asserter.failExpression("left <= y.right", ".*null.*");
+ asserter.failExpression("left > y.right", ".*null.*");
+ asserter.failExpression("left >= y.right", ".*null.*");
}
+ /**
+ * test some simple mathematical calculations
+ */
@Test
- public void testCoerceInteger() {
- final JexlArithmetic ja = JEXL.getArithmetic();
- final JexlEvalContext ctxt = new JexlEvalContext();
- final JexlOptions options = ctxt.getEngineOptions();
- options.setStrictArithmetic(true);
- final String stmt = "a = 34L; b = 45.0D; c=56.0F; d=67B; e=78H;";
- final JexlScript expr = JEXL.createScript(stmt);
- /* Object value = */ expr.execute(ctxt);
- Assert.assertEquals(34, ja.toInteger(ctxt.get("a")));
- Assert.assertEquals(45, ja.toInteger(ctxt.get("b")));
- Assert.assertEquals(56, ja.toInteger(ctxt.get("c")));
- Assert.assertEquals(67, ja.toInteger(ctxt.get("d")));
- Assert.assertEquals(78, ja.toInteger(ctxt.get("e")));
- Assert.assertEquals(10, ja.toInteger("10"));
- Assert.assertEquals(1, ja.toInteger(true));
- Assert.assertEquals(0, ja.toInteger(false));
+ public void testUnaryMinus() throws Exception {
+ asserter.setVariable("aByte", Byte.valueOf((byte) 1));
+ asserter.setVariable("aShort", Short.valueOf((short) 2));
+ asserter.setVariable("anInteger", Integer.valueOf(3));
+ asserter.setVariable("aLong", Long.valueOf(4));
+ asserter.setVariable("aFloat", Float.valueOf((float) 5.5));
+ asserter.setVariable("aDouble", Double.valueOf(6.6));
+ asserter.setVariable("aBigInteger", new BigInteger("7"));
+ asserter.setVariable("aBigDecimal", new BigDecimal("8.8"));
+
+ // loop to allow checking caching of constant numerals (debug)
+ for(int i = 0 ; i < 2; ++i) {
+ asserter.assertExpression("-3", Integer.valueOf("-3"));
+ asserter.assertExpression("-3.0", Double.valueOf("-3.0"));
+ asserter.assertExpression("-aByte", Byte.valueOf((byte) -1));
+ asserter.assertExpression("-aShort", Short.valueOf((short) -2));
+ asserter.assertExpression("-anInteger", Integer.valueOf(-3));
+ asserter.assertExpression("-aLong", Long.valueOf(-4));
+ asserter.assertExpression("-aFloat", Float.valueOf((float) -5.5));
+ asserter.assertExpression("-aDouble", Double.valueOf(-6.6));
+ asserter.assertExpression("-aBigInteger", new BigInteger("-7"));
+ asserter.assertExpression("-aBigDecimal", new BigDecimal("-8.8"));
+ }
}
@Test
- public void testCoerceLong() {
- final JexlArithmetic ja = JEXL.getArithmetic();
- final JexlEvalContext ctxt = new JexlEvalContext();
- final JexlOptions options = ctxt.getEngineOptions();
- options.setStrictArithmetic(true);
- final String stmt = "a = 34L; b = 45.0D; c=56.0F; d=67B; e=78H;";
- final JexlScript expr = JEXL.createScript(stmt);
- /* Object value = */ expr.execute(ctxt);
- Assert.assertEquals(34L, ja.toLong(ctxt.get("a")));
- Assert.assertEquals(45L, ja.toLong(ctxt.get("b")));
- Assert.assertEquals(56L, ja.toLong(ctxt.get("c")));
- Assert.assertEquals(67L, ja.toLong(ctxt.get("d")));
- Assert.assertEquals(78L, ja.toLong(ctxt.get("e")));
- Assert.assertEquals(10L, ja.toLong("10"));
- Assert.assertEquals(1L, ja.toLong(true));
- Assert.assertEquals(0L, ja.toLong(false));
+ public void testUnaryopsEdges() {
+ assertArithmeticException(() -> jexla.positivize(date));
+ assertNullOperand(() -> jexla.positivize(null));
+ Assert.assertNull(jexlb.positivize(null));
+ Assert.assertEquals(42, jexla.positivize((char) 42));
+ Assert.assertEquals(Boolean.TRUE, jexla.positivize(Boolean.TRUE));
+ Assert.assertEquals(Boolean.FALSE, jexla.positivize(Boolean.FALSE));
+ Assert.assertEquals(Boolean.TRUE, jexla.positivize(new AtomicBoolean(true)));
+ Assert.assertEquals(Boolean.FALSE, jexla.positivize(new AtomicBoolean(false)));
+
+ assertNullOperand(() -> jexla.negate(null));
+ Assert.assertNull(jexlb.negate(null));
+ assertArithmeticException(() -> jexla.negate(date));
+ Assert.assertEquals(Boolean.FALSE, jexla.negate(Boolean.TRUE));
+ Assert.assertEquals(Boolean.TRUE, jexla.negate(Boolean.FALSE));
}
+ /**
+ * test some simple mathematical calculations
+ */
@Test
- public void testCoerceDouble() {
- final JexlArithmetic ja = JEXL.getArithmetic();
- final JexlEvalContext ctxt = new JexlEvalContext();
- final JexlOptions options = ctxt.getEngineOptions();
- options.setStrictArithmetic(true);
- final String stmt = "{a = 34L; b = 45.0D; c=56.0F; d=67B; e=78H; }";
- final JexlScript expr = JEXL.createScript(stmt);
- /* Object value = */ expr.execute(ctxt);
- Assert.assertEquals(34, ja.toDouble(ctxt.get("a")), EPSILON);
- Assert.assertEquals(45, ja.toDouble(ctxt.get("b")), EPSILON);
- Assert.assertEquals(56, ja.toDouble(ctxt.get("c")), EPSILON);
- Assert.assertEquals(67, ja.toDouble(ctxt.get("d")), EPSILON);
- Assert.assertEquals(78, ja.toDouble(ctxt.get("e")), EPSILON);
- Assert.assertEquals(10d, ja.toDouble("10"), EPSILON);
- Assert.assertEquals(1.D, ja.toDouble(true), EPSILON);
- Assert.assertEquals(0.D, ja.toDouble(false), EPSILON);
+ public void testUnaryPlus() throws Exception {
+ asserter.setVariable("aByte", Byte.valueOf((byte) 1));
+ asserter.setVariable("aShort", Short.valueOf((short) 2));
+ asserter.setVariable("anInteger", Integer.valueOf(3));
+ asserter.setVariable("aLong", Long.valueOf(4));
+ asserter.setVariable("aFloat", Float.valueOf((float) 5.5));
+ asserter.setVariable("aDouble", Double.valueOf(6.6));
+ asserter.setVariable("aBigInteger", new BigInteger("7"));
+ asserter.setVariable("aBigDecimal", new BigDecimal("8.8"));
+
+ // loop to allow checking caching of constant numerals (debug)
+ for(int i = 0 ; i < 2; ++i) {
+ asserter.assertExpression("+3", Integer.valueOf("3"));
+ asserter.assertExpression("+3.0", Double.valueOf("3.0"));
+ asserter.assertExpression("+aByte", Integer.valueOf(1));
+ asserter.assertExpression("+aShort", Integer.valueOf(2));
+ asserter.assertExpression("+anInteger", Integer.valueOf(3));
+ asserter.assertExpression("+aLong", Long.valueOf(4));
+ asserter.assertExpression("+aFloat", Float.valueOf((float) 5.5));
+ asserter.assertExpression("+aDouble", Double.valueOf(6.6));
+ asserter.assertExpression("+aBigInteger", new BigInteger("7"));
+ asserter.assertExpression("+aBigDecimal", new BigDecimal("8.8"));
+ }
}
@Test
- public void testCoerceBigInteger() {
- final JexlArithmetic ja = JEXL.getArithmetic();
- final JexlEvalContext ctxt = new JexlEvalContext();
- final JexlOptions options = ctxt.getEngineOptions();
- options.setStrictArithmetic(true);
- final String stmt = "{a = 34L; b = 45.0D; c=56.0F; d=67B; e=78H; }";
- final JexlScript expr = JEXL.createScript(stmt);
- /* Object value = */ expr.execute(ctxt);
- Assert.assertEquals(BigInteger.valueOf(34), ja.toBigInteger(ctxt.get("a")));
- Assert.assertEquals(BigInteger.valueOf(45), ja.toBigInteger(ctxt.get("b")));
- Assert.assertEquals(BigInteger.valueOf(56), ja.toBigInteger(ctxt.get("c")));
- Assert.assertEquals(BigInteger.valueOf(67), ja.toBigInteger(ctxt.get("d")));
- Assert.assertEquals(BigInteger.valueOf(78), ja.toBigInteger(ctxt.get("e")));
- Assert.assertEquals(BigInteger.valueOf(10), ja.toBigInteger("10"));
- Assert.assertEquals(BigInteger.valueOf(1), ja.toBigInteger(true));
- Assert.assertEquals(BigInteger.valueOf(0), ja.toBigInteger(false));
+ public void testUndefinedVar() throws Exception {
+ asserter.failExpression("objects[1].status", ".*variable 'objects' is undefined.*");
}
+ /**
+ * Inspired by JEXL-16{1,2}.
+ */
@Test
- public void testCoerceBigDecimal() {
- final JexlArithmetic ja = JEXL.getArithmetic();
+ public void testXmlArithmetic() throws Exception {
+ Document xml;
+ Node x;
+ Boolean empty;
+ int size;
final JexlEvalContext ctxt = new JexlEvalContext();
- final JexlOptions options = ctxt.getEngineOptions();
- options.setStrictArithmetic(true);
- final String stmt = "{a = 34L; b = 45.0D; c=56.0F; d=67B; e=78H; }";
- final JexlScript expr = JEXL.createScript(stmt);
- /* Object value = */ expr.execute(ctxt);
- Assert.assertEquals(BigDecimal.valueOf(34), ja.toBigDecimal(ctxt.get("a")));
- Assert.assertEquals(BigDecimal.valueOf(45.), ja.toBigDecimal(ctxt.get("b")));
- Assert.assertEquals(BigDecimal.valueOf(56.), ja.toBigDecimal(ctxt.get("c")));
- Assert.assertEquals(BigDecimal.valueOf(67), ja.toBigDecimal(ctxt.get("d")));
- Assert.assertEquals(BigDecimal.valueOf(78), ja.toBigDecimal(ctxt.get("e")));
- Assert.assertEquals(BigDecimal.valueOf(10), ja.toBigDecimal("10"));
- Assert.assertEquals(BigDecimal.valueOf(1.), ja.toBigDecimal(true));
- Assert.assertEquals(BigDecimal.valueOf(0.), ja.toBigDecimal(false));
- }
-
- @Test
- public void testAtomicBoolean() {
- // in a condition
- JexlScript e = JEXL.createScript("if (x) 1 else 2;", "x");
- final JexlContext jc = new MapContext();
- final AtomicBoolean ab = new AtomicBoolean(false);
- Object o;
- o = e.execute(jc, ab);
- Assert.assertEquals("Result is not 2", Integer.valueOf(2), o);
- ab.set(true);
- o = e.execute(jc, ab);
- Assert.assertEquals("Result is not 1", Integer.valueOf(1), o);
- // in a binary logical op
- e = JEXL.createScript("x && y", "x", "y");
- ab.set(true);
- o = e.execute(jc, ab, Boolean.FALSE);
- Assert.assertFalse((Boolean) o);
- ab.set(true);
- o = e.execute(jc, ab, Boolean.TRUE);
- Assert.assertTrue((Boolean) o);
- ab.set(false);
- o = e.execute(jc, ab, Boolean.FALSE);
- Assert.assertFalse((Boolean) o);
- ab.set(false);
- o = e.execute(jc, ab, Boolean.FALSE);
- Assert.assertFalse((Boolean) o);
- // in arithmetic op
- e = JEXL.createScript("x + y", "x", "y");
- ab.set(true);
- o = e.execute(jc, ab, 10);
- Assert.assertEquals(11, o);
- o = e.execute(jc, 10, ab);
- Assert.assertEquals(11, o);
- o = e.execute(jc, ab, 10.d);
- Assert.assertEquals(11.d, (Double) o, EPSILON);
- o = e.execute(jc, 10.d, ab);
- Assert.assertEquals(11.d, (Double) o, EPSILON);
-
- final BigInteger bi10 = BigInteger.TEN;
- ab.set(false);
- o = e.execute(jc, ab, bi10);
- Assert.assertEquals(bi10, o);
- o = e.execute(jc, bi10, ab);
- Assert.assertEquals(bi10, o);
-
- final BigDecimal bd10 = BigDecimal.TEN;
- ab.set(false);
- o = e.execute(jc, ab, bd10);
- Assert.assertEquals(bd10, o);
- o = e.execute(jc, bd10, ab);
- Assert.assertEquals(bd10, o);
+ final JexlEngine jexl = new JexlBuilder().strict(true).safe(false).arithmetic(new XmlArithmetic(false)).create();
+ final JexlScript e0 = jexl.createScript("x.empty()", "x");
+ final JexlScript e1 = jexl.createScript("empty(x)", "x");
+ final JexlScript s0 = jexl.createScript("x.size()", "x");
+ final JexlScript s1 = jexl.createScript("size(x)", "x");
- // in a (the) monadic op
- e = JEXL.createScript("!x", "x");
- ab.set(true);
- o = e.execute(jc, ab);
- Assert.assertFalse((Boolean) o);
- ab.set(false);
- o = e.execute(jc, ab);
- Assert.assertTrue((Boolean) o);
+ empty = (Boolean) e1.execute(null, (Object) null);
+ Assert.assertTrue(empty);
+ size = (Integer) s1.execute(null, (Object) null);
+ Assert.assertEquals(0, size);
- // in a (the) monadic op
- e = JEXL.createScript("-x", "x");
- ab.set(true);
- o = e.execute(jc, ab);
- Assert.assertFalse((Boolean) o);
- ab.set(false);
- o = e.execute(jc, ab);
- Assert.assertTrue((Boolean) o);
- }
+ try {
+ final Object xx = e0.execute(null, (Object) null);
+ Assert.assertNull(xx);
+ } catch (final JexlException.Variable xvar) {
+ Assert.assertNotNull(xvar);
+ }
+ try {
+ final Object xx = s0.execute(null, (Object) null);
+ Assert.assertNull(xx);
+ } catch (final JexlException.Variable xvar) {
+ Assert.assertNotNull(xvar);
+ }
+ final JexlOptions options = ctxt.getEngineOptions();
+ options.setSafe(true);
+ final Object x0 = e0.execute(ctxt, (Object) null);
+ Assert.assertNull(x0);
+ final Object x1 = s0.execute(ctxt, (Object) null);
+ Assert.assertNull(x1);
- @Test
- public void testCompare() {
- // JEXL doesn't support more than one operator in the same expression, for example: 1 == 1 == 1
- final Object[] EXPRESSIONS = {
- // Basic compare
- "1 == 1", true,
- "1 != 1", false,
- "1 != 2", true,
- "1 > 2", false,
- "1 >= 2", false,
- "1 < 2", true,
- "1 <= 2", true,
- // Int <-> Float Coercion
- "1.0 == 1", true,
- "1 == 1.0", true,
- "1.1 != 1", true,
- "1.1 < 2", true,
- // Big Decimal <-> Big Integer Coercion
- "1.0b == 1h", true,
- "1h == 1.0b", true,
- "1.1b != 1h", true,
- "1.1b < 2h", true,
- // Mix all type of numbers
- "1l == 1.0", true, // long and int
- "1.0d == 1.0f", true, // double and float
- "1l == 1.0b", true,
- "1l == 1h", true,
- "1.0d == 1.0b", true,
- "1.0f == 1.0b", true,
- "1.0d == 1h", true,
- "1.0f == 1h", true,
- // numbers and strings
- "'1' == 1", true,
- "'1' == 1l", true,
- "'1' == 1h", true,
- "'' == 0", true, // empty string is coerced to zero (ECMA compliance)
- "'1.0' == 1", true,
- "'1.0' == 1.0f", true,
- "'1.0' == 1.0d", true,
- "'1.0' == 1.0b", true,
- "'1.01' == 1.01", true,
- "'1.01' == 1", false,
- "'1.01' == 1b", false,
- "'1.01' == 1h", false,
- "'1.00001' == 1b", false,
- "'1.00001' == 1h", false,
- "'1.00000001' == 1", false,
- "'1.00000001' == 1b", false,
- "'1.00000001' == 1h", false,
- "1.0 >= '1'", true,
- "1.0 > '1'", false,
- };
- final JexlEngine jexl = new JexlBuilder().create();
- final JexlContext jc = new EmptyTestContext();
- JexlExpression expression;
+ xml = getDocument("<node info='123'/>");
+ x = xml.getLastChild();
+ empty = (Boolean) e0.execute(null, x);
+ Assert.assertFalse(empty);
+ empty = (Boolean) e1.execute(null, x);
+ Assert.assertFalse(empty);
+ size = (Integer) s0.execute(null, x);
+ Assert.assertEquals(0, size);
+ size = (Integer) s1.execute(null, x);
+ Assert.assertEquals(0, size);
+ xml = getDocument("<node><a/><b/></node>");
+ x = xml.getLastChild();
+ empty = (Boolean) e0.execute(null, x);
+ Assert.assertFalse(empty);
+ empty = (Boolean) e1.execute(null, x);
+ Assert.assertFalse(empty);
+ size = (Integer) s0.execute(null, x);
+ Assert.assertEquals(2, size);
+ size = (Integer) s1.execute(null, x);
+ Assert.assertEquals(2, size);
+ xml = getDocument("<node/>");
+ x = xml.getLastChild();
+ empty = (Boolean) e0.execute(null, x);
+ Assert.assertTrue(empty);
+ empty = (Boolean) e1.execute(null, x);
+ Assert.assertTrue(empty);
+ size = (Integer) s0.execute(null, x);
+ Assert.assertEquals(0, size);
+ size = (Integer) s1.execute(null, x);
+ Assert.assertEquals(0, size);
+ xml = getDocument("<node info='123'/>");
+ NamedNodeMap nnm = xml.getLastChild().getAttributes();
+ Attr info = (Attr) nnm.getNamedItem("info");
+ Assert.assertEquals("123", info.getValue());
- for (int e = 0; e < EXPRESSIONS.length; e += 2) {
- final String stext = (String) EXPRESSIONS[e];
- final Object expected = EXPRESSIONS[e + 1];
- expression = jexl.createExpression(stext);
- final Object result = expression.evaluate(jc);
- Assert.assertEquals("failed on " + stext, expected, result);
+ // JEXL-161
+ final JexlContext jc = new MapContext();
+ jc.set("x", xml.getLastChild());
+ final String y = "456";
+ jc.set("y", y);
+ final JexlScript s = jexl.createScript("x.attribute.info = y");
+ Object r;
+ try {
+ r = s.execute(jc);
+ nnm = xml.getLastChild().getAttributes();
+ info = (Attr) nnm.getNamedItem("info");
+ Assert.assertEquals(y, r);
+ Assert.assertEquals(y, info.getValue());
+ } catch (final JexlException.Property xprop) {
+ // test fails in java > 11 because modules, etc; need investigation
+ Assert.assertTrue(xprop.getMessage().contains("info"));
+ Assert.assertTrue(getJavaVersion() > 11);
}
}
}
diff --git a/src/test/java/org/apache/commons/jexl3/ArrayAccessTest.java b/src/test/java/org/apache/commons/jexl3/ArrayAccessTest.java
index 16d9970c..e4066dea 100644
--- a/src/test/java/org/apache/commons/jexl3/ArrayAccessTest.java
+++ b/src/test/java/org/apache/commons/jexl3/ArrayAccessTest.java
@@ -34,7 +34,15 @@ import org.junit.Test;
@SuppressWarnings({"UnnecessaryBoxing", "AssertEqualsBetweenInconvertibleTypes"})
public class ArrayAccessTest extends JexlTestCase {
- private Asserter asserter;
+ public static class Sample {
+ private int[] array;
+ public int[] getFoo() {
+ return array;
+ }
+ public void setFoo(final int[] a) {
+ array = a;
+ }
+ }
private static final String GET_METHOD_STRING = "GetMethod string";
@@ -46,6 +54,8 @@ public class ArrayAccessTest extends JexlTestCase {
static final String[][] GET_METHOD_ARRAY2 =
{ {"One", "Two", "Three"},{"Four", "Five", "Six"} };
+ private Asserter asserter;
+
public ArrayAccessTest() {
super("ArrayAccessTest");
}
@@ -111,98 +121,6 @@ public class ArrayAccessTest extends JexlTestCase {
asserter.assertExpression("foo[\"bar\"] == foo.bar", Boolean.TRUE);
}
- /**
- * test some simple double array lookups
- */
- @Test
- public void testDoubleArrays() throws Exception {
- final Object[][] foo = new Object[2][2];
-
- foo[0][0] = "one";
- foo[0][1] = "two";
- asserter.setVariable("foo", foo);
- asserter.assertExpression("foo[0][1]", "two");
- asserter.assertExpression("foo[0][1] = 'three'", "three");
- asserter.assertExpression("foo[0][1]", "three");
-
- foo[0][0] = "one";
- foo[0][1] = "two";
- asserter.assertExpression("foo.0[1]", "two");
- asserter.assertExpression("foo.0[1] = 'three'", "three");
- asserter.assertExpression("foo.0[1]", "three");
-
- foo[0][0] = "one";
- foo[0][1] = "two";
- asserter.assertExpression("foo.0.'1'", "two");
- asserter.assertExpression("foo.0.'1' = 'three'", "three");
- asserter.assertExpression("foo.0.'1'", "three");
-
- foo[0][0] = "one";
- foo[0][1] = "two";
- asserter.assertExpression("foo.'0'.'1'", "two");
- asserter.assertExpression("foo.'0'.'1' = 'three'", "three");
- asserter.assertExpression("foo.'0'.'1'", "three");
-
-
- foo[0][0] = "one";
- foo[0][1] = "two";
- asserter.assertExpression("foo.0.1", "two");
- asserter.assertExpression("foo.0.1 = 'three'", "three");
- asserter.assertExpression("foo.0.1", "three");
- }
-
- @Test
- public void testDoubleMaps() throws Exception {
- final Map<Object, Map<Object, Object>> foo = new HashMap<>();
- final Map<Object, Object> foo0 = new HashMap<>();
- foo.put(0, foo0);
- foo0.put(0, "one");
- foo0.put(1, "two");
- foo0.put("3.0", "three");
- asserter.setVariable("foo", foo);
- asserter.assertExpression("foo[0][1]", "two");
- asserter.assertExpression("foo[0][1] = 'three'", "three");
- asserter.assertExpression("foo[0][1]", "three");
- asserter.assertExpression("foo[0]['3.0']", "three");
-
- foo0.put(0, "one");
- foo0.put(1, "two");
- asserter.assertExpression("foo.0[1]", "two");
- asserter.assertExpression("foo.0[1] = 'three'", "three");
- asserter.assertExpression("foo.0[1]", "three");
- asserter.assertExpression("foo.0['3.0']", "three");
-
- foo0.put(0, "one");
- foo0.put(1, "two");
- asserter.assertExpression("foo.0.'1'", "two");
- asserter.assertExpression("foo.0.'1' = 'three'", "three");
- asserter.assertExpression("foo.0.'1'", "three");
-
- foo0.put(0, "one");
- foo0.put(1, "two");
- asserter.assertExpression("foo.'0'.'1'", "two");
- asserter.assertExpression("foo.'0'.'1' = 'three'", "three");
- asserter.assertExpression("foo.'0'.'1'", "three");
-
- foo0.put(0, "one");
- foo0.put(1, "two");
- asserter.assertExpression("foo.0.1", "two");
- asserter.assertExpression("foo.0.1 = 'three'", "three");
- asserter.assertExpression("foo.0.1", "three");
- }
-
- @Test
- public void testArrayProperty() throws Exception {
- final Foo foo = new Foo();
-
- asserter.setVariable("foo", foo);
-
- asserter.assertExpression("foo.array[1]", GET_METHOD_ARRAY[1]);
- asserter.assertExpression("foo.array.1", GET_METHOD_ARRAY[1]);
- asserter.assertExpression("foo.array2[1][1]", GET_METHOD_ARRAY2[1][1]);
- asserter.assertExpression("foo.array2[1].1", GET_METHOD_ARRAY2[1][1]);
- }
-
// This is JEXL-26
@Test
public void testArrayAndDottedConflict() throws Exception {
@@ -219,31 +137,6 @@ public class ArrayAccessTest extends JexlTestCase {
asserter.assertExpression("base.objects.1.status", null);
}
- @Test
- public void testArrayIdentifierParsing() throws Exception {
- final Map<Object, Number> map = new HashMap<>();
- map.put("00200", -42.42d);
- map.put(200, 42.42d);
- asserter.setVariable("objects", map);
- asserter.assertExpression("objects.get('00200')", -42.42d);
- asserter.assertExpression("objects.'00200'", -42.42d);
- asserter.assertExpression("objects.get(200)", 42.42d);
- asserter.assertExpression("objects.'200'", 42.42d);
- asserter.assertExpression("objects.200", 42.42d);
- }
-
- @Test
- public void testArrayMethods() throws Exception {
- final Object[] objects = {"an", "array", Long.valueOf(0)};
-
- asserter.setVariable("objects", objects);
- asserter.assertExpression("objects.get(1)", "array");
- asserter.assertExpression("objects.size()", Integer.valueOf(3));
- // setting an index returns the old value
- asserter.assertExpression("objects.set(1, 'dion')", "array");
- asserter.assertExpression("objects[1]", "dion");
- }
-
@Test
public void testArrayArray() throws Exception {
final Integer i42 = Integer.valueOf(42);
@@ -311,15 +204,6 @@ public class ArrayAccessTest extends JexlTestCase {
}
}
- public static class Sample {
- private int[] array;
- public void setFoo(final int[] a) {
- array = a;
- }
- public int[] getFoo() {
- return array;
- }
- }
@Test
public void testArrayGetSet() throws Exception {
final Sample bar = new Sample();
@@ -329,4 +213,120 @@ public class ArrayAccessTest extends JexlTestCase {
asserter.assertExpression("bar.foo = []", new int[0]);
//asserter.assertExpression("bar.foo[0]", 42);
}
+
+ @Test
+ public void testArrayIdentifierParsing() throws Exception {
+ final Map<Object, Number> map = new HashMap<>();
+ map.put("00200", -42.42d);
+ map.put(200, 42.42d);
+ asserter.setVariable("objects", map);
+ asserter.assertExpression("objects.get('00200')", -42.42d);
+ asserter.assertExpression("objects.'00200'", -42.42d);
+ asserter.assertExpression("objects.get(200)", 42.42d);
+ asserter.assertExpression("objects.'200'", 42.42d);
+ asserter.assertExpression("objects.200", 42.42d);
+ }
+
+ @Test
+ public void testArrayMethods() throws Exception {
+ final Object[] objects = {"an", "array", Long.valueOf(0)};
+
+ asserter.setVariable("objects", objects);
+ asserter.assertExpression("objects.get(1)", "array");
+ asserter.assertExpression("objects.size()", Integer.valueOf(3));
+ // setting an index returns the old value
+ asserter.assertExpression("objects.set(1, 'dion')", "array");
+ asserter.assertExpression("objects[1]", "dion");
+ }
+
+ @Test
+ public void testArrayProperty() throws Exception {
+ final Foo foo = new Foo();
+
+ asserter.setVariable("foo", foo);
+
+ asserter.assertExpression("foo.array[1]", GET_METHOD_ARRAY[1]);
+ asserter.assertExpression("foo.array.1", GET_METHOD_ARRAY[1]);
+ asserter.assertExpression("foo.array2[1][1]", GET_METHOD_ARRAY2[1][1]);
+ asserter.assertExpression("foo.array2[1].1", GET_METHOD_ARRAY2[1][1]);
+ }
+
+ /**
+ * test some simple double array lookups
+ */
+ @Test
+ public void testDoubleArrays() throws Exception {
+ final Object[][] foo = new Object[2][2];
+
+ foo[0][0] = "one";
+ foo[0][1] = "two";
+ asserter.setVariable("foo", foo);
+ asserter.assertExpression("foo[0][1]", "two");
+ asserter.assertExpression("foo[0][1] = 'three'", "three");
+ asserter.assertExpression("foo[0][1]", "three");
+
+ foo[0][0] = "one";
+ foo[0][1] = "two";
+ asserter.assertExpression("foo.0[1]", "two");
+ asserter.assertExpression("foo.0[1] = 'three'", "three");
+ asserter.assertExpression("foo.0[1]", "three");
+
+ foo[0][0] = "one";
+ foo[0][1] = "two";
+ asserter.assertExpression("foo.0.'1'", "two");
+ asserter.assertExpression("foo.0.'1' = 'three'", "three");
+ asserter.assertExpression("foo.0.'1'", "three");
+
+ foo[0][0] = "one";
+ foo[0][1] = "two";
+ asserter.assertExpression("foo.'0'.'1'", "two");
+ asserter.assertExpression("foo.'0'.'1' = 'three'", "three");
+ asserter.assertExpression("foo.'0'.'1'", "three");
+
+
+ foo[0][0] = "one";
+ foo[0][1] = "two";
+ asserter.assertExpression("foo.0.1", "two");
+ asserter.assertExpression("foo.0.1 = 'three'", "three");
+ asserter.assertExpression("foo.0.1", "three");
+ }
+ @Test
+ public void testDoubleMaps() throws Exception {
+ final Map<Object, Map<Object, Object>> foo = new HashMap<>();
+ final Map<Object, Object> foo0 = new HashMap<>();
+ foo.put(0, foo0);
+ foo0.put(0, "one");
+ foo0.put(1, "two");
+ foo0.put("3.0", "three");
+ asserter.setVariable("foo", foo);
+ asserter.assertExpression("foo[0][1]", "two");
+ asserter.assertExpression("foo[0][1] = 'three'", "three");
+ asserter.assertExpression("foo[0][1]", "three");
+ asserter.assertExpression("foo[0]['3.0']", "three");
+
+ foo0.put(0, "one");
+ foo0.put(1, "two");
+ asserter.assertExpression("foo.0[1]", "two");
+ asserter.assertExpression("foo.0[1] = 'three'", "three");
+ asserter.assertExpression("foo.0[1]", "three");
+ asserter.assertExpression("foo.0['3.0']", "three");
+
+ foo0.put(0, "one");
+ foo0.put(1, "two");
+ asserter.assertExpression("foo.0.'1'", "two");
+ asserter.assertExpression("foo.0.'1' = 'three'", "three");
+ asserter.assertExpression("foo.0.'1'", "three");
+
+ foo0.put(0, "one");
+ foo0.put(1, "two");
+ asserter.assertExpression("foo.'0'.'1'", "two");
+ asserter.assertExpression("foo.'0'.'1' = 'three'", "three");
+ asserter.assertExpression("foo.'0'.'1'", "three");
+
+ foo0.put(0, "one");
+ foo0.put(1, "two");
+ asserter.assertExpression("foo.0.1", "two");
+ asserter.assertExpression("foo.0.1 = 'three'", "three");
+ asserter.assertExpression("foo.0.1", "three");
+ }
}
\ No newline at end of file
diff --git a/src/test/java/org/apache/commons/jexl3/ArrayLiteralTest.java b/src/test/java/org/apache/commons/jexl3/ArrayLiteralTest.java
index 816dae55..c1f1b7b2 100644
--- a/src/test/java/org/apache/commons/jexl3/ArrayLiteralTest.java
+++ b/src/test/java/org/apache/commons/jexl3/ArrayLiteralTest.java
@@ -33,6 +33,24 @@ public class ArrayLiteralTest extends JexlTestCase {
super("ArrayLiteralTest");
}
+ @Test
+ public void testChangeThroughVariables() throws Exception {
+ final JexlContext jc = new MapContext();
+ final JexlExpression e147 = JEXL.createExpression("quux = [one, two]");
+
+ jc.set("one", 1);
+ jc.set("two", 2);
+ final int[] o1 = (int[]) e147.evaluate(jc);
+ Assert.assertEquals(1, o1[0]);
+ Assert.assertEquals(2, o1[1]);
+
+ jc.set("one", 10);
+ jc.set("two", 20);
+ final int[] o2 = (int[]) e147.evaluate(jc);
+ Assert.assertEquals(10, o2[0]);
+ Assert.assertEquals(20, o2[1]);
+ }
+
@Test
public void testEmptyArrayLiteral() throws Exception {
final JexlContext jc = new MapContext();
@@ -57,17 +75,6 @@ public class ArrayLiteralTest extends JexlTestCase {
}
}
- @Test
- public void testLiteralWithStrings() throws Exception {
- final Object[] check = {"foo", "bar"};
- final List<String> sources = Arrays.asList("[ 'foo' , 'bar' ]", "[ 'foo' , 'bar', ]");
- for(final String src : sources) {
- final JexlExpression e = JEXL.createExpression(src);
- final Object o = e.evaluate(null);
- Assert.assertArrayEquals(check, (Object[]) o);
- }
- }
-
@Test
public void testLiteralWithElipsis() throws Exception {
final JexlExpression e = JEXL.createExpression("[ 'foo' , 'bar', ... ]");
@@ -86,25 +93,13 @@ public class ArrayLiteralTest extends JexlTestCase {
}
@Test
- public void testLiteralWithOneEntry() throws Exception {
- final Object[] check = {"foo"};
- final List<String> sources = Arrays.asList("[ 'foo']", "[ 'foo' , ]");
- for(final String src : sources) {
- final JexlExpression e = JEXL.createExpression(src);
- final Object o = e.evaluate(null);
- Assert.assertArrayEquals(check, (Object[]) o);
- }
- }
-
- @Test
- public void testLiteralWithNumbers() throws Exception {
- final JexlExpression e = JEXL.createExpression("[ 5.0 , 10 ]");
+ public void testLiteralWithIntegers() throws Exception {
+ final JexlExpression e = JEXL.createExpression("[ 5 , 10 ]");
final JexlContext jc = new MapContext();
final Object o = e.evaluate(jc);
- final Object[] check = {Double.valueOf(5), Integer.valueOf(10)};
- Assert.assertArrayEquals(check, (Object[]) o);
- Assert.assertTrue(o.getClass().isArray() && o.getClass().getComponentType().equals(Number.class));
+ final int[] check = {5, 10};
+ Assert.assertArrayEquals(check, (int[]) o);
}
@Test
@@ -133,31 +128,36 @@ public class ArrayLiteralTest extends JexlTestCase {
}
@Test
- public void testLiteralWithIntegers() throws Exception {
- final JexlExpression e = JEXL.createExpression("[ 5 , 10 ]");
+ public void testLiteralWithNumbers() throws Exception {
+ final JexlExpression e = JEXL.createExpression("[ 5.0 , 10 ]");
final JexlContext jc = new MapContext();
final Object o = e.evaluate(jc);
- final int[] check = {5, 10};
- Assert.assertArrayEquals(check, (int[]) o);
+ final Object[] check = {Double.valueOf(5), Integer.valueOf(10)};
+ Assert.assertArrayEquals(check, (Object[]) o);
+ Assert.assertTrue(o.getClass().isArray() && o.getClass().getComponentType().equals(Number.class));
}
@Test
- public void testSizeOfSimpleArrayLiteral() throws Exception {
- final JexlExpression e = JEXL.createExpression("size([ 'foo' , 'bar' ])");
- final JexlContext jc = new MapContext();
-
- final Object o = e.evaluate(jc);
- Assert.assertEquals(Integer.valueOf(2), o);
+ public void testLiteralWithOneEntry() throws Exception {
+ final Object[] check = {"foo"};
+ final List<String> sources = Arrays.asList("[ 'foo']", "[ 'foo' , ]");
+ for(final String src : sources) {
+ final JexlExpression e = JEXL.createExpression(src);
+ final Object o = e.evaluate(null);
+ Assert.assertArrayEquals(check, (Object[]) o);
+ }
}
@Test
- public void testNotestCallingMethodsOnNewMapLiteral() throws Exception {
- final JexlExpression e = JEXL.createExpression("size({ 'foo' : 'bar' }.values())");
- final JexlContext jc = new MapContext();
-
- final Object o = e.evaluate(jc);
- Assert.assertEquals(Integer.valueOf(1), o);
+ public void testLiteralWithStrings() throws Exception {
+ final Object[] check = {"foo", "bar"};
+ final List<String> sources = Arrays.asList("[ 'foo' , 'bar' ]", "[ 'foo' , 'bar', ]");
+ for(final String src : sources) {
+ final JexlExpression e = JEXL.createExpression(src);
+ final Object o = e.evaluate(null);
+ Assert.assertArrayEquals(check, (Object[]) o);
+ }
}
@Test
@@ -170,20 +170,20 @@ public class ArrayLiteralTest extends JexlTestCase {
}
@Test
- public void testChangeThroughVariables() throws Exception {
+ public void testNotestCallingMethodsOnNewMapLiteral() throws Exception {
+ final JexlExpression e = JEXL.createExpression("size({ 'foo' : 'bar' }.values())");
final JexlContext jc = new MapContext();
- final JexlExpression e147 = JEXL.createExpression("quux = [one, two]");
- jc.set("one", 1);
- jc.set("two", 2);
- final int[] o1 = (int[]) e147.evaluate(jc);
- Assert.assertEquals(1, o1[0]);
- Assert.assertEquals(2, o1[1]);
+ final Object o = e.evaluate(jc);
+ Assert.assertEquals(Integer.valueOf(1), o);
+ }
- jc.set("one", 10);
- jc.set("two", 20);
- final int[] o2 = (int[]) e147.evaluate(jc);
- Assert.assertEquals(10, o2[0]);
- Assert.assertEquals(20, o2[1]);
+ @Test
+ public void testSizeOfSimpleArrayLiteral() throws Exception {
+ final JexlExpression e = JEXL.createExpression("size([ 'foo' , 'bar' ])");
+ final JexlContext jc = new MapContext();
+
+ final Object o = e.evaluate(jc);
+ Assert.assertEquals(Integer.valueOf(2), o);
}
}
diff --git a/src/test/java/org/apache/commons/jexl3/AssignTest.java b/src/test/java/org/apache/commons/jexl3/AssignTest.java
index b25ceb7c..80d23795 100644
--- a/src/test/java/org/apache/commons/jexl3/AssignTest.java
+++ b/src/test/java/org/apache/commons/jexl3/AssignTest.java
@@ -34,12 +34,12 @@ public class AssignTest extends JexlTestCase {
public Froboz(final int v) {
value = v;
}
- public void setValue(final int v) {
- value = v;
- }
public int getValue() {
return value;
}
+ public void setValue(final int v) {
+ value = v;
+ }
}
public static class Quux {
@@ -54,14 +54,14 @@ public class AssignTest extends JexlTestCase {
return froboz;
}
- public void setFroboz(final Froboz froboz) {
- this.froboz = froboz;
- }
-
public String getStr() {
return str;
}
+ public void setFroboz(final Froboz froboz) {
+ this.froboz = froboz;
+ }
+
public void setStr(final String str) {
this.str = str;
}
@@ -71,6 +71,25 @@ public class AssignTest extends JexlTestCase {
super("AssignTest", new JexlBuilder().cache(512).strict(true).silent(false).create());
}
+ @Test
+ public void testAmbiguous() {
+ final JexlExpression assign = JEXL.createExpression("froboz.nosuchbean = 10");
+ final JexlContext jc = new MapContext();
+ final Froboz froboz = new Froboz(-169);
+ jc.set("froboz", froboz);
+ Object o = null;
+ try {
+ o = assign.evaluate(jc);
+ }
+ catch (final RuntimeException xrt) {
+ final String str = xrt.toString();
+ Assert.assertTrue(str.contains("nosuchbean"));
+ }
+ finally {
+ Assert.assertNull("Should have failed", o);
+ }
+ }
+
/**
* Make sure bean assignment works
*
@@ -98,11 +117,11 @@ public class AssignTest extends JexlTestCase {
}
@Test
- public void testBeanish() {
- final JexlExpression assign = JEXL.createExpression("froboz.value = 10");
- final JexlExpression check = JEXL.createExpression("froboz.value");
+ public void testArray() {
+ final JexlExpression assign = JEXL.createExpression("froboz[\"value\"] = 10");
+ final JexlExpression check = JEXL.createExpression("froboz[\"value\"]");
final JexlContext jc = new MapContext();
- final Froboz froboz = new Froboz(-169);
+ final Froboz froboz = new Froboz(0);
jc.set("froboz", froboz);
Object o = assign.evaluate(jc);
Assert.assertEquals("Result is not 10", Integer.valueOf(10), o);
@@ -111,37 +130,32 @@ public class AssignTest extends JexlTestCase {
}
@Test
- public void testAmbiguous() {
- final JexlExpression assign = JEXL.createExpression("froboz.nosuchbean = 10");
+ public void testBeanish() {
+ final JexlExpression assign = JEXL.createExpression("froboz.value = 10");
+ final JexlExpression check = JEXL.createExpression("froboz.value");
final JexlContext jc = new MapContext();
final Froboz froboz = new Froboz(-169);
jc.set("froboz", froboz);
- Object o = null;
- try {
- o = assign.evaluate(jc);
- }
- catch (final RuntimeException xrt) {
- final String str = xrt.toString();
- Assert.assertTrue(str.contains("nosuchbean"));
- }
- finally {
- Assert.assertNull("Should have failed", o);
- }
- }
-
- @Test
- public void testArray() {
- final JexlExpression assign = JEXL.createExpression("froboz[\"value\"] = 10");
- final JexlExpression check = JEXL.createExpression("froboz[\"value\"]");
- final JexlContext jc = new MapContext();
- final Froboz froboz = new Froboz(0);
- jc.set("froboz", froboz);
Object o = assign.evaluate(jc);
Assert.assertEquals("Result is not 10", Integer.valueOf(10), o);
o = check.evaluate(jc);
Assert.assertEquals("Result is not 10", Integer.valueOf(10), o);
}
+ @Test
+ public void testGetInError1() {
+ try {
+ JEXL.getProperty("the_x_value", "y");
+ } catch (final JexlException.Property xprop) {
+ Assert.assertEquals("y", xprop.getProperty());
+ }
+ try {
+ JEXL.getProperty(null, "y");
+ } catch (final JexlException xprop) {
+ //
+ }
+ }
+
@Test
public void testMini() {
final JexlContext jc = new MapContext();
@@ -167,35 +181,6 @@ public class AssignTest extends JexlTestCase {
Assert.assertEquals("Result is not 10", Integer.valueOf(10), o);
}
- @Test
- public void testUtil() {
- final Quux quux = JEXL.newInstance(Quux.class, "xuuq", Integer.valueOf(100));
- Assert.assertNotNull(quux);
- JEXL.setProperty(quux, "froboz.value", Integer.valueOf(100));
- Object o = JEXL.getProperty(quux, "froboz.value");
- Assert.assertEquals("Result is not 100", Integer.valueOf(100), o);
- JEXL.setProperty(quux, "['froboz'].value", Integer.valueOf(1000));
- o = JEXL.getProperty(quux, "['froboz']['value']");
- Assert.assertEquals("Result is not 1000", Integer.valueOf(1000), o);
- }
-
- @Test
- public void testRejectLocal() {
- final JexlContext jc = new MapContext();
- JexlScript assign = JEXL.createScript("var quux = null; quux.froboz.value = 10");
- try {
- final Object o = assign.execute(jc);
- Assert.fail("quux is local and null, should fail");
- } catch (final JexlException xjexl) {
- final String x = xjexl.toString();
- final String y = x;
- }
- // quux is a global antish var
- assign = JEXL.createScript("quux.froboz.value = 10");
- final Object o = assign.execute(jc);
- Assert.assertEquals(10, o);
- }
-
@Test
public void testPropertyInError0() {
JexlScript script;
@@ -218,6 +203,23 @@ public class AssignTest extends JexlTestCase {
}
}
+ @Test
+ public void testRejectLocal() {
+ final JexlContext jc = new MapContext();
+ JexlScript assign = JEXL.createScript("var quux = null; quux.froboz.value = 10");
+ try {
+ final Object o = assign.execute(jc);
+ Assert.fail("quux is local and null, should fail");
+ } catch (final JexlException xjexl) {
+ final String x = xjexl.toString();
+ final String y = x;
+ }
+ // quux is a global antish var
+ assign = JEXL.createScript("quux.froboz.value = 10");
+ final Object o = assign.execute(jc);
+ Assert.assertEquals(10, o);
+ }
+
@Test
public void testSetInError1() {
try {
@@ -232,16 +234,14 @@ public class AssignTest extends JexlTestCase {
}
}
@Test
- public void testGetInError1() {
- try {
- JEXL.getProperty("the_x_value", "y");
- } catch (final JexlException.Property xprop) {
- Assert.assertEquals("y", xprop.getProperty());
- }
- try {
- JEXL.getProperty(null, "y");
- } catch (final JexlException xprop) {
- //
- }
+ public void testUtil() {
+ final Quux quux = JEXL.newInstance(Quux.class, "xuuq", Integer.valueOf(100));
+ Assert.assertNotNull(quux);
+ JEXL.setProperty(quux, "froboz.value", Integer.valueOf(100));
+ Object o = JEXL.getProperty(quux, "froboz.value");
+ Assert.assertEquals("Result is not 100", Integer.valueOf(100), o);
+ JEXL.setProperty(quux, "['froboz'].value", Integer.valueOf(1000));
+ o = JEXL.getProperty(quux, "['froboz']['value']");
+ Assert.assertEquals("Result is not 1000", Integer.valueOf(1000), o);
}
}
diff --git a/src/test/java/org/apache/commons/jexl3/BitwiseOperatorTest.java b/src/test/java/org/apache/commons/jexl3/BitwiseOperatorTest.java
index f9d7fb54..d7b713be 100644
--- a/src/test/java/org/apache/commons/jexl3/BitwiseOperatorTest.java
+++ b/src/test/java/org/apache/commons/jexl3/BitwiseOperatorTest.java
@@ -28,13 +28,6 @@ import org.junit.Test;
public class BitwiseOperatorTest extends JexlTestCase {
private Asserter asserter;
- @Override
- @Before
- public void setUp() {
- asserter = new Asserter(JEXL);
- asserter.setStrict(false, false);
- }
-
/**
* Create the named test.
*/
@@ -42,19 +35,11 @@ public class BitwiseOperatorTest extends JexlTestCase {
super("BitwiseOperatorTest");
}
- @Test
- public void testAndWithTwoNulls() throws Exception {
- asserter.assertExpression("null & null", Long.valueOf(0));
- }
-
- @Test
- public void testAndWithLeftNull() throws Exception {
- asserter.assertExpression("null & 1", Long.valueOf(0));
- }
-
- @Test
- public void testAndWithRightNull() throws Exception {
- asserter.assertExpression("1 & null", Long.valueOf(0));
+ @Override
+ @Before
+ public void setUp() {
+ asserter = new Asserter(JEXL);
+ asserter.setStrict(false, false);
}
@Test
@@ -77,8 +62,18 @@ public class BitwiseOperatorTest extends JexlTestCase {
}
@Test
- public void testComplementWithNull() throws Exception {
- asserter.assertExpression("~null", Long.valueOf(-1));
+ public void testAndWithLeftNull() throws Exception {
+ asserter.assertExpression("null & 1", Long.valueOf(0));
+ }
+
+ @Test
+ public void testAndWithRightNull() throws Exception {
+ asserter.assertExpression("1 & null", Long.valueOf(0));
+ }
+
+ @Test
+ public void testAndWithTwoNulls() throws Exception {
+ asserter.assertExpression("null & null", Long.valueOf(0));
}
@Test
@@ -99,18 +94,8 @@ public class BitwiseOperatorTest extends JexlTestCase {
}
@Test
- public void testOrWithTwoNulls() throws Exception {
- asserter.assertExpression("null | null", Long.valueOf(0));
- }
-
- @Test
- public void testOrWithLeftNull() throws Exception {
- asserter.assertExpression("null | 1", Long.valueOf(1));
- }
-
- @Test
- public void testOrWithRightNull() throws Exception {
- asserter.assertExpression("1 | null", Long.valueOf(1));
+ public void testComplementWithNull() throws Exception {
+ asserter.assertExpression("~null", Long.valueOf(-1));
}
@Test
@@ -133,18 +118,25 @@ public class BitwiseOperatorTest extends JexlTestCase {
}
@Test
- public void testXorWithTwoNulls() throws Exception {
- asserter.assertExpression("null ^ null", Long.valueOf(0));
+ public void testOrWithLeftNull() throws Exception {
+ asserter.assertExpression("null | 1", Long.valueOf(1));
}
@Test
- public void testXorWithLeftNull() throws Exception {
- asserter.assertExpression("null ^ 1", Long.valueOf(1));
+ public void testOrWithRightNull() throws Exception {
+ asserter.assertExpression("1 | null", Long.valueOf(1));
}
@Test
- public void testXorWithRightNull() throws Exception {
- asserter.assertExpression("1 ^ null", Long.valueOf(1));
+ public void testOrWithTwoNulls() throws Exception {
+ asserter.assertExpression("null | null", Long.valueOf(0));
+ }
+
+ @Test
+ public void testParenthesized() throws Exception {
+ asserter.assertExpression("(2 | 1) & 3", Long.valueOf(3L));
+ asserter.assertExpression("(2 & 1) | 3", Long.valueOf(3L));
+ asserter.assertExpression("~(120 | 42)", Long.valueOf(~(120 | 42)));
}
@Test
@@ -167,10 +159,18 @@ public class BitwiseOperatorTest extends JexlTestCase {
}
@Test
- public void testParenthesized() throws Exception {
- asserter.assertExpression("(2 | 1) & 3", Long.valueOf(3L));
- asserter.assertExpression("(2 & 1) | 3", Long.valueOf(3L));
- asserter.assertExpression("~(120 | 42)", Long.valueOf(~(120 | 42)));
+ public void testXorWithLeftNull() throws Exception {
+ asserter.assertExpression("null ^ 1", Long.valueOf(1));
+ }
+
+ @Test
+ public void testXorWithRightNull() throws Exception {
+ asserter.assertExpression("1 ^ null", Long.valueOf(1));
+ }
+
+ @Test
+ public void testXorWithTwoNulls() throws Exception {
+ asserter.assertExpression("null ^ null", Long.valueOf(0));
}
}
diff --git a/src/test/java/org/apache/commons/jexl3/BlockTest.java b/src/test/java/org/apache/commons/jexl3/BlockTest.java
index 678590b4..d295fdc5 100644
--- a/src/test/java/org/apache/commons/jexl3/BlockTest.java
+++ b/src/test/java/org/apache/commons/jexl3/BlockTest.java
@@ -33,14 +33,6 @@ public class BlockTest extends JexlTestCase {
super("BlockTest");
}
- @Test
- public void testBlockSimple() throws Exception {
- final JexlScript e = JEXL.createScript("if (true) { 'hello'; }");
- final JexlContext jc = new MapContext();
- final Object o = e.execute(jc);
- Assert.assertEquals("Result is wrong", "hello", o);
- }
-
@Test
public void testBlockExecutesAll() throws Exception {
final JexlScript e = JEXL.createScript("if (true) { x = 'Hello'; y = 'World';}");
@@ -51,14 +43,6 @@ public class BlockTest extends JexlTestCase {
Assert.assertEquals("Block result is wrong", "World", o);
}
- @Test
- public void testEmptyBlock() throws Exception {
- final JexlScript e = JEXL.createScript("if (true) { }");
- final JexlContext jc = new MapContext();
- final Object o = e.execute(jc);
- Assert.assertNull("Result is wrong", o);
- }
-
@Test
public void testBlockLastExecuted01() throws Exception {
final JexlScript e = JEXL.createScript("if (true) { x = 1; } else { x = 2; }");
@@ -75,6 +59,22 @@ public class BlockTest extends JexlTestCase {
Assert.assertEquals("Block result is wrong", Integer.valueOf(2), o);
}
+ @Test
+ public void testBlockSimple() throws Exception {
+ final JexlScript e = JEXL.createScript("if (true) { 'hello'; }");
+ final JexlContext jc = new MapContext();
+ final Object o = e.execute(jc);
+ Assert.assertEquals("Result is wrong", "hello", o);
+ }
+
+ @Test
+ public void testEmptyBlock() throws Exception {
+ final JexlScript e = JEXL.createScript("if (true) { }");
+ final JexlContext jc = new MapContext();
+ final Object o = e.execute(jc);
+ Assert.assertNull("Result is wrong", o);
+ }
+
@Test
public void testNestedBlock() throws Exception {
final JexlScript e = JEXL.createScript("if (true) { x = 'hello'; y = 'world';" + " if (true) { x; } y; }");
diff --git a/src/test/java/org/apache/commons/jexl3/BuilderTest.java b/src/test/java/org/apache/commons/jexl3/BuilderTest.java
index 812a6bc9..c9c233f9 100644
--- a/src/test/java/org/apache/commons/jexl3/BuilderTest.java
+++ b/src/test/java/org/apache/commons/jexl3/BuilderTest.java
@@ -52,14 +52,6 @@ public class BuilderTest {
Assert.assertFalse(builder().strict(false).strict());
}
- @Test
- public void testValues() {
- Assert.assertEquals(1, builder().collectMode(1).collectMode());
- Assert.assertEquals(0, builder().collectMode(0).collectMode());
- Assert.assertEquals(32, builder().cacheThreshold(32).cacheThreshold());
- Assert.assertEquals(8, builder().stackOverflow(8).stackOverflow());
- }
-
@Test
public void testOther() {
final ClassLoader cls = getClass().getClassLoader().getParent();
@@ -73,4 +65,12 @@ public class BuilderTest {
Assert.assertEquals(sandbox, builder().sandbox(sandbox).sandbox());
Assert.assertEquals(uberspect, builder().uberspect(uberspect).uberspect());
}
+
+ @Test
+ public void testValues() {
+ Assert.assertEquals(1, builder().collectMode(1).collectMode());
+ Assert.assertEquals(0, builder().collectMode(0).collectMode());
+ Assert.assertEquals(32, builder().cacheThreshold(32).cacheThreshold());
+ Assert.assertEquals(8, builder().stackOverflow(8).stackOverflow());
+ }
}
diff --git a/src/test/java/org/apache/commons/jexl3/CacheTest.java b/src/test/java/org/apache/commons/jexl3/CacheTest.java
index 9c1125dd..cb1ccb2a 100644
--- a/src/test/java/org/apache/commons/jexl3/CacheTest.java
+++ b/src/test/java/org/apache/commons/jexl3/CacheTest.java
@@ -34,61 +34,151 @@ import org.junit.Test;
*/
@SuppressWarnings({"UnnecessaryBoxing", "AssertEqualsBetweenInconvertibleTypes"})
public class CacheTest extends JexlTestCase {
- // LOOPS & THREADS
- private static final int LOOPS = 4096;
- private static final int NTHREADS = 4;
- // A pseudo random mix of accessors
- private static final int[] MIX = {
- 0, 0, 3, 3, 4, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 1, 1, 1, 2, 2, 2,
- 3, 3, 3, 4, 4, 4, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 2, 2, 3, 3, 0
- };
+ /**
+ * A task to check boolean assignment.
+ */
+ public static class AssignBooleanTask extends Task {
+ public AssignBooleanTask(final int loops) {
+ super(loops);
+ }
- public CacheTest() {
- super("CacheTest", null);
- }
- private static final JexlEngine jexlCache = new JexlBuilder().cache(1024).debug(true).strict(true).create();
- private static final JexlEngine jexlNoCache = new JexlBuilder().cache(0).debug(true).strict(true).create();
- private static JexlEngine jexl = jexlCache;
+ @Override
+ public Integer call() throws Exception {
+ return runAssignBoolean(Boolean.TRUE);
+ }
- @Before
- @Override
- public void setUp() throws Exception {
- // ensure jul logging is only error to avoid warning in silent mode
- java.util.logging.Logger.getLogger(JexlEngine.class.getName()).setLevel(java.util.logging.Level.SEVERE);
+ /** The actual test function. */
+ private Integer runAssignBoolean(final Boolean value) {
+ args.value = new Object[]{value};
+ final JexlExpression cacheGetValue = jexl.createExpression("cache.flag");
+ final JexlExpression cacheSetValue = jexl.createExpression("cache.flag = value");
+ Object result;
+
+ for (int l = 0; l < loops; ++l) {
+ final int px = (int) Thread.currentThread().getId();
+ final int mix = MIX[(l + px) % MIX.length];
+
+ vars.put("cache", args.ca[mix]);
+ vars.put("value", args.value[0]);
+ result = cacheSetValue.evaluate(jc);
+ Assert.assertEquals(cacheSetValue.toString(), args.value[0], result);
+
+ result = cacheGetValue.evaluate(jc);
+ Assert.assertEquals(cacheGetValue.toString(), args.value[0], result);
+
+ }
+
+ return Integer.valueOf(loops);
+ }
}
+ /**
+ * A task to check list assignment.
+ */
+ public static class AssignListTask extends Task {
+ public AssignListTask(final int loops) {
+ super(loops);
+ }
+ @Override
+ public Integer call() throws Exception {
+ return runAssignList();
+ }
- @After
- @Override
- public void tearDown() throws Exception {
- debuggerCheck(jexl);
+ /** The actual test function. */
+ private Integer runAssignList() {
+ args.value = new Object[]{"foo"};
+ final java.util.ArrayList<String> c1 = new java.util.ArrayList<>(2);
+ c1.add("foo");
+ c1.add("bar");
+ args.ca = new Object[]{
+ new String[]{"one", "two"},
+ c1
+ };
+
+ final JexlExpression cacheGetValue = jexl.createExpression("cache.0");
+ final JexlExpression cacheSetValue = jexl.createExpression("cache[0] = value");
+ Object result;
+
+ for (int l = 0; l < loops; ++l) {
+ final int px = (int) Thread.currentThread().getId();
+ final int mix = MIX[(l + px) % MIX.length] % args.ca.length;
+
+ vars.put("cache", args.ca[mix]);
+ vars.put("value", args.value[0]);
+ result = cacheSetValue.evaluate(jc);
+ Assert.assertEquals(cacheSetValue.toString(), args.value[0], result);
+
+ result = cacheGetValue.evaluate(jc);
+ Assert.assertEquals(cacheGetValue.toString(), args.value[0], result);
+ }
+
+ return Integer.valueOf(loops);
+ }
+ }
+ /**
+ * A task to check null assignment.
+ */
+ public static class AssignNullTask extends Task {
+ public AssignNullTask(final int loops) {
+ super(loops);
+ }
+
+ @Override
+ public Integer call() throws Exception {
+ return runAssign(null);
+ }
}
+ /**
+ * A task to check assignment.
+ */
+ public static class AssignTask extends Task {
+ public AssignTask(final int loops) {
+ super(loops);
+ }
+
+ @Override
+ public Integer call() throws Exception {
+ return runAssign("foo");
+ }
+ }
/**
* A set of classes that define different getter/setter methods for the same properties.
* The goal is to verify that the cached JexlPropertyGet / JexlPropertySet in the AST Nodes are indeed
* volatile and do not generate errors even when multiple threads concurently hammer them.
*/
public static class Cached {
- public String compute(String arg) {
+ public static String COMPUTE(final int arg) {
+ return "CACHED@i#" + arg;
+ }
+
+ public static String COMPUTE(final int arg0, final int arg1) {
+ return "CACHED@i#" + arg0 + ",i#" + arg1;
+ }
+
+ public static String COMPUTE(String arg) {
if (arg == null) {
arg = "na";
}
- return getClass().getSimpleName() + "@s#" + arg;
+ return "CACHED@s#" + arg;
}
- public String compute(String arg0, String arg1) {
+ public static String COMPUTE(String arg0, String arg1) {
if (arg0 == null) {
arg0 = "na";
}
if (arg1 == null) {
arg1 = "na";
}
- return getClass().getSimpleName() + "@s#" + arg0 + ",s#" + arg1;
+ return "CACHED@s#" + arg0 + ",s#" + arg1;
}
- public String compute(final Integer arg) {
- return getClass().getSimpleName() + "@i#" + arg;
+ public String ambiguous(final int arg0, final Integer arg1) {
+ return getClass().getSimpleName() + "!i#" + arg0 + ",i#" + arg1;
+ }
+
+ public String ambiguous(final Integer arg0, final int arg1) {
+ return getClass().getSimpleName() + "!i#" + arg0 + ",i#" + arg1;
}
public String compute(final float arg) {
@@ -99,40 +189,27 @@ public class CacheTest extends JexlTestCase {
return getClass().getSimpleName() + "@i#" + arg0 + ",i#" + arg1;
}
- public String ambiguous(final Integer arg0, final int arg1) {
- return getClass().getSimpleName() + "!i#" + arg0 + ",i#" + arg1;
- }
-
- public String ambiguous(final int arg0, final Integer arg1) {
- return getClass().getSimpleName() + "!i#" + arg0 + ",i#" + arg1;
+ public String compute(final Integer arg) {
+ return getClass().getSimpleName() + "@i#" + arg;
}
- public static String COMPUTE(String arg) {
+ public String compute(String arg) {
if (arg == null) {
arg = "na";
}
- return "CACHED@s#" + arg;
+ return getClass().getSimpleName() + "@s#" + arg;
}
- public static String COMPUTE(String arg0, String arg1) {
+ public String compute(String arg0, String arg1) {
if (arg0 == null) {
arg0 = "na";
}
if (arg1 == null) {
arg1 = "na";
}
- return "CACHED@s#" + arg0 + ",s#" + arg1;
- }
-
- public static String COMPUTE(final int arg) {
- return "CACHED@i#" + arg;
- }
-
- public static String COMPUTE(final int arg0, final int arg1) {
- return "CACHED@i#" + arg0 + ",i#" + arg1;
+ return getClass().getSimpleName() + "@s#" + arg0 + ",s#" + arg1;
}
}
-
public static class Cached0 extends Cached {
protected String value = "Cached0:new";
protected Boolean flag = Boolean.FALSE;
@@ -144,22 +221,21 @@ public class CacheTest extends JexlTestCase {
return value;
}
- public void setValue(String arg) {
- if (arg == null) {
- arg = "na";
- }
- value = "Cached0:" + arg;
+ public boolean isFlag() {
+ return flag;
}
public void setFlag(final boolean b) {
flag = Boolean.valueOf(b);
}
- public boolean isFlag() {
- return flag;
+ public void setValue(String arg) {
+ if (arg == null) {
+ arg = "na";
+ }
+ value = "Cached0:" + arg;
}
}
-
public static class Cached1 extends Cached0 {
@Override
public void setValue(String arg) {
@@ -202,6 +278,7 @@ public class CacheTest extends JexlTestCase {
}
}
+
public static class Cached3 extends java.util.TreeMap<String, Object> {
private static final long serialVersionUID = 1L;
boolean flag = false;
@@ -216,6 +293,10 @@ public class CacheTest extends JexlTestCase {
return super.get(key.toString());
}
+ public boolean isflag() {
+ return flag;
+ }
+
@Override
public final Object put(final String key, Object arg) {
if (arg == null) {
@@ -226,299 +307,36 @@ public class CacheTest extends JexlTestCase {
}
public void setflag(final boolean b) {
- flag = b;
- }
-
- public boolean isflag() {
- return flag;
- }
- }
-
- public static class Cached4 extends java.util.ArrayList<String> {
- private static final long serialVersionUID = 1L;
-
- public Cached4() {
- super.add("Cached4:new");
- super.add("false");
- }
-
- public String getValue() {
- return super.get(0);
- }
-
- public void setValue(String arg) {
- if (arg == null) {
- arg = "na";
- }
- super.set(0, "Cached4:" + arg);
- }
-
- public void setflag(final Boolean b) {
- super.set(1, b.toString());
- }
-
- public boolean isflag() {
- return Boolean.parseBoolean(super.get(1));
- }
- }
-
- /**
- * A helper class to pass arguments in tests (instances of getter/setter exercising classes).
- */
- static class TestCacheArguments {
- Cached0 c0 = new Cached0();
- Cached1 c1 = new Cached1();
- Cached2 c2 = new Cached2();
- Cached3 c3 = new Cached3();
- Cached4 c4 = new Cached4();
- Object[] ca = {
- c0, c1, c2, c3, c4
- };
- Object[] value = null;
- }
-
- /**
- * Run same test function in NTHREADS in parallel.
- * @param ctask the task / test
- * @param loops number of loops to perform
- * @param cache whether jexl cache is used or not
- * @throws Exception if anything goes wrong
- */
- @SuppressWarnings("boxing")
- void runThreaded(final Class<? extends Task> ctask, int loops, final boolean cache) throws Exception {
- if (loops == 0) {
- loops = MIX.length;
- }
- if (!cache) {
- jexl = jexlNoCache;
- } else {
- jexl = jexlCache;
- }
- final java.util.concurrent.ExecutorService execs = java.util.concurrent.Executors.newFixedThreadPool(NTHREADS);
- final List<Callable<Integer>> tasks = new ArrayList<>(NTHREADS);
- for (int t = 0; t < NTHREADS; ++t) {
- tasks.add(jexl.newInstance(ctask, loops));
- }
- // let's not wait for more than a minute
- final List<Future<Integer>> futures = execs.invokeAll(tasks, 60, TimeUnit.SECONDS);
- // check that all returned loops
- for (final Future<Integer> future : futures) {
- Assert.assertEquals(Integer.valueOf(loops), future.get());
- }
- }
-
- /**
- * The base class for MT tests.
- */
- public abstract static class Task implements Callable<Integer> {
- final TestCacheArguments args = new TestCacheArguments();
- final int loops;
- final Map<String, Object> vars = new HashMap<>();
- final JexlEvalContext jc = new JexlEvalContext(vars);
-
- Task(final int loops) {
- this.loops = loops;
- }
-
- @Override
- public abstract Integer call() throws Exception;
-
- /**
- * The actual test function; assigns and checks.
- * <p>
- * The expression will be evaluated against different classes in parallel.
- * This verifies that neither the volatile cache in the AST nor the expression cache in the JEXL engine
- * induce errors.</p>
- * <p>
- * Using it as a micro benchmark, it shows creating expression as the dominating cost; the expression
- * cache takes care of this.
- * By moving the expression creations out of the main loop, it also shows that the volatile cache speeds
- * things up around 2x.
- * </p>
- * @param value the argument value to control
- * @return the number of loops performed
- */
- public Integer runAssign(final Object value) {
- args.value = new Object[]{value};
- Object result;
-
- final JexlExpression cacheGetValue = jexl.createExpression("cache.value");
- final JexlExpression cacheSetValue = jexl.createExpression("cache.value = value");
- for (int l = 0; l < loops; ++l) {
- final int px = (int) Thread.currentThread().getId();
- final int mix = MIX[(l + px) % MIX.length];
-
- vars.put("cache", args.ca[mix]);
- vars.put("value", args.value[0]);
- result = cacheSetValue.evaluate(jc);
- if (args.value[0] == null) {
- Assert.assertNull(cacheSetValue.toString(), result);
- } else {
- Assert.assertEquals(cacheSetValue.toString(), args.value[0], result);
- }
-
- result = cacheGetValue.evaluate(jc);
- if (args.value[0] == null) {
- Assert.assertEquals(cacheGetValue.toString(), "Cached" + mix + ":na", result);
- } else {
- Assert.assertEquals(cacheGetValue.toString(), "Cached" + mix + ":" + args.value[0], result);
- }
-
- }
-
- return Integer.valueOf(loops);
- }
- }
-
- /**
- * A task to check assignment.
- */
- public static class AssignTask extends Task {
- public AssignTask(final int loops) {
- super(loops);
- }
-
- @Override
- public Integer call() throws Exception {
- return runAssign("foo");
- }
- }
-
- /**
- * A task to check null assignment.
- */
- public static class AssignNullTask extends Task {
- public AssignNullTask(final int loops) {
- super(loops);
- }
-
- @Override
- public Integer call() throws Exception {
- return runAssign(null);
- }
- }
-
- /**
- * A task to check boolean assignment.
- */
- public static class AssignBooleanTask extends Task {
- public AssignBooleanTask(final int loops) {
- super(loops);
- }
-
- @Override
- public Integer call() throws Exception {
- return runAssignBoolean(Boolean.TRUE);
- }
-
- /** The actual test function. */
- private Integer runAssignBoolean(final Boolean value) {
- args.value = new Object[]{value};
- final JexlExpression cacheGetValue = jexl.createExpression("cache.flag");
- final JexlExpression cacheSetValue = jexl.createExpression("cache.flag = value");
- Object result;
-
- for (int l = 0; l < loops; ++l) {
- final int px = (int) Thread.currentThread().getId();
- final int mix = MIX[(l + px) % MIX.length];
-
- vars.put("cache", args.ca[mix]);
- vars.put("value", args.value[0]);
- result = cacheSetValue.evaluate(jc);
- Assert.assertEquals(cacheSetValue.toString(), args.value[0], result);
-
- result = cacheGetValue.evaluate(jc);
- Assert.assertEquals(cacheGetValue.toString(), args.value[0], result);
-
- }
-
- return Integer.valueOf(loops);
- }
- }
-
- /**
- * A task to check list assignment.
- */
- public static class AssignListTask extends Task {
- public AssignListTask(final int loops) {
- super(loops);
- }
-
- @Override
- public Integer call() throws Exception {
- return runAssignList();
- }
-
- /** The actual test function. */
- private Integer runAssignList() {
- args.value = new Object[]{"foo"};
- final java.util.ArrayList<String> c1 = new java.util.ArrayList<>(2);
- c1.add("foo");
- c1.add("bar");
- args.ca = new Object[]{
- new String[]{"one", "two"},
- c1
- };
-
- final JexlExpression cacheGetValue = jexl.createExpression("cache.0");
- final JexlExpression cacheSetValue = jexl.createExpression("cache[0] = value");
- Object result;
-
- for (int l = 0; l < loops; ++l) {
- final int px = (int) Thread.currentThread().getId();
- final int mix = MIX[(l + px) % MIX.length] % args.ca.length;
-
- vars.put("cache", args.ca[mix]);
- vars.put("value", args.value[0]);
- result = cacheSetValue.evaluate(jc);
- Assert.assertEquals(cacheSetValue.toString(), args.value[0], result);
-
- result = cacheGetValue.evaluate(jc);
- Assert.assertEquals(cacheGetValue.toString(), args.value[0], result);
- }
-
- return Integer.valueOf(loops);
- }
- }
-
- @Test
- public void testNullAssignNoCache() throws Exception {
- runThreaded(AssignNullTask.class, LOOPS, false);
- }
-
- @Test
- public void testNullAssignCache() throws Exception {
- runThreaded(AssignNullTask.class, LOOPS, true);
+ flag = b;
+ }
}
- @Test
- public void testAssignNoCache() throws Exception {
- runThreaded(AssignTask.class, LOOPS, false);
- }
+ public static class Cached4 extends java.util.ArrayList<String> {
+ private static final long serialVersionUID = 1L;
- @Test
- public void testAssignCache() throws Exception {
- runThreaded(AssignTask.class, LOOPS, true);
- }
+ public Cached4() {
+ super.add("Cached4:new");
+ super.add("false");
+ }
- @Test
- public void testAssignBooleanNoCache() throws Exception {
- runThreaded(AssignBooleanTask.class, LOOPS, false);
- }
+ public String getValue() {
+ return super.get(0);
+ }
- @Test
- public void testAssignBooleanCache() throws Exception {
- runThreaded(AssignBooleanTask.class, LOOPS, true);
- }
+ public boolean isflag() {
+ return Boolean.parseBoolean(super.get(1));
+ }
- @Test
- public void testAssignListNoCache() throws Exception {
- runThreaded(AssignListTask.class, LOOPS, false);
- }
+ public void setflag(final Boolean b) {
+ super.set(1, b.toString());
+ }
- @Test
- public void testAssignListCache() throws Exception {
- runThreaded(AssignListTask.class, LOOPS, true);
+ public void setValue(String arg) {
+ if (arg == null) {
+ arg = "na";
+ }
+ super.set(0, "Cached4:" + arg);
+ }
}
/**
@@ -603,16 +421,6 @@ public class CacheTest extends JexlTestCase {
}
}
- @Test
- public void testComputeNoCache() throws Exception {
- runThreaded(ComputeTask.class, LOOPS, false);
- }
-
- @Test
- public void testComputeCache() throws Exception {
- runThreaded(ComputeTask.class, LOOPS, true);
- }
-
public static class JexlContextNS extends JexlEvalContext {
final Map<String, Object> funcs;
@@ -628,6 +436,105 @@ public class CacheTest extends JexlTestCase {
}
+ /**
+ * The base class for MT tests.
+ */
+ public abstract static class Task implements Callable<Integer> {
+ final TestCacheArguments args = new TestCacheArguments();
+ final int loops;
+ final Map<String, Object> vars = new HashMap<>();
+ final JexlEvalContext jc = new JexlEvalContext(vars);
+
+ Task(final int loops) {
+ this.loops = loops;
+ }
+
+ @Override
+ public abstract Integer call() throws Exception;
+
+ /**
+ * The actual test function; assigns and checks.
+ * <p>
+ * The expression will be evaluated against different classes in parallel.
+ * This verifies that neither the volatile cache in the AST nor the expression cache in the JEXL engine
+ * induce errors.</p>
+ * <p>
+ * Using it as a micro benchmark, it shows creating expression as the dominating cost; the expression
+ * cache takes care of this.
+ * By moving the expression creations out of the main loop, it also shows that the volatile cache speeds
+ * things up around 2x.
+ * </p>
+ * @param value the argument value to control
+ * @return the number of loops performed
+ */
+ public Integer runAssign(final Object value) {
+ args.value = new Object[]{value};
+ Object result;
+
+ final JexlExpression cacheGetValue = jexl.createExpression("cache.value");
+ final JexlExpression cacheSetValue = jexl.createExpression("cache.value = value");
+ for (int l = 0; l < loops; ++l) {
+ final int px = (int) Thread.currentThread().getId();
+ final int mix = MIX[(l + px) % MIX.length];
+
+ vars.put("cache", args.ca[mix]);
+ vars.put("value", args.value[0]);
+ result = cacheSetValue.evaluate(jc);
+ if (args.value[0] == null) {
+ Assert.assertNull(cacheSetValue.toString(), result);
+ } else {
+ Assert.assertEquals(cacheSetValue.toString(), args.value[0], result);
+ }
+
+ result = cacheGetValue.evaluate(jc);
+ if (args.value[0] == null) {
+ Assert.assertEquals(cacheGetValue.toString(), "Cached" + mix + ":na", result);
+ } else {
+ Assert.assertEquals(cacheGetValue.toString(), "Cached" + mix + ":" + args.value[0], result);
+ }
+
+ }
+
+ return Integer.valueOf(loops);
+ }
+ }
+
+ /**
+ * A helper class to pass arguments in tests (instances of getter/setter exercising classes).
+ */
+ static class TestCacheArguments {
+ Cached0 c0 = new Cached0();
+ Cached1 c1 = new Cached1();
+ Cached2 c2 = new Cached2();
+ Cached3 c3 = new Cached3();
+ Cached4 c4 = new Cached4();
+ Object[] ca = {
+ c0, c1, c2, c3, c4
+ };
+ Object[] value = null;
+ }
+
+ // LOOPS & THREADS
+ private static final int LOOPS = 4096;
+
+ private static final int NTHREADS = 4;
+
+ // A pseudo random mix of accessors
+ private static final int[] MIX = {
+ 0, 0, 3, 3, 4, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 1, 1, 1, 2, 2, 2,
+ 3, 3, 3, 4, 4, 4, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 2, 2, 3, 3, 0
+ };
+
+ private static final JexlEngine jexlCache = new JexlBuilder().cache(1024).debug(true).strict(true).create();
+
+ private static final JexlEngine jexlNoCache = new JexlBuilder().cache(0).debug(true).strict(true).create();
+
+ private static JexlEngine jexl = jexlCache;
+
+ public CacheTest() {
+ super("CacheTest", null);
+ }
+
/**
* The remaining tests exercise the namespaced namespaces; not MT.
* @param x
@@ -682,23 +589,116 @@ public class CacheTest extends JexlTestCase {
}
}
+ /**
+ * Run same test function in NTHREADS in parallel.
+ * @param ctask the task / test
+ * @param loops number of loops to perform
+ * @param cache whether jexl cache is used or not
+ * @throws Exception if anything goes wrong
+ */
+ @SuppressWarnings("boxing")
+ void runThreaded(final Class<? extends Task> ctask, int loops, final boolean cache) throws Exception {
+ if (loops == 0) {
+ loops = MIX.length;
+ }
+ if (!cache) {
+ jexl = jexlNoCache;
+ } else {
+ jexl = jexlCache;
+ }
+ final java.util.concurrent.ExecutorService execs = java.util.concurrent.Executors.newFixedThreadPool(NTHREADS);
+ final List<Callable<Integer>> tasks = new ArrayList<>(NTHREADS);
+ for (int t = 0; t < NTHREADS; ++t) {
+ tasks.add(jexl.newInstance(ctask, loops));
+ }
+ // let's not wait for more than a minute
+ final List<Future<Integer>> futures = execs.invokeAll(tasks, 60, TimeUnit.SECONDS);
+ // check that all returned loops
+ for (final Future<Integer> future : futures) {
+ Assert.assertEquals(Integer.valueOf(loops), future.get());
+ }
+ }
+
+ @Before
+ @Override
+ public void setUp() throws Exception {
+ // ensure jul logging is only error to avoid warning in silent mode
+ java.util.logging.Logger.getLogger(JexlEngine.class.getName()).setLevel(java.util.logging.Level.SEVERE);
+ }
+
+ @After
+ @Override
+ public void tearDown() throws Exception {
+ debuggerCheck(jexl);
+ }
+
@Test
- public void testCOMPUTENoCache() throws Exception {
+ public void testAssignBooleanCache() throws Exception {
+ runThreaded(AssignBooleanTask.class, LOOPS, true);
+ }
+
+ @Test
+ public void testAssignBooleanNoCache() throws Exception {
+ runThreaded(AssignBooleanTask.class, LOOPS, false);
+ }
+
+ @Test
+ public void testAssignCache() throws Exception {
+ runThreaded(AssignTask.class, LOOPS, true);
+ }
+
+ @Test
+ public void testAssignListCache() throws Exception {
+ runThreaded(AssignListTask.class, LOOPS, true);
+ }
+
+ @Test
+ public void testAssignListNoCache() throws Exception {
+ runThreaded(AssignListTask.class, LOOPS, false);
+ }
+
+ @Test
+ public void testAssignNoCache() throws Exception {
+ runThreaded(AssignTask.class, LOOPS, false);
+ }
+
+ @Test
+ public void testComputeCache() throws Exception {
+ runThreaded(ComputeTask.class, LOOPS, true);
+ }
+
+ @Test
+ public void testCOMPUTECache() throws Exception {
final TestCacheArguments args = new TestCacheArguments();
args.ca = new Object[]{
Cached.class, Cached1.class, Cached2.class
};
args.value = new Object[]{Integer.valueOf(2), "quux"};
- doCOMPUTE(args, LOOPS, false);
+ doCOMPUTE(args, LOOPS, true);
}
@Test
- public void testCOMPUTECache() throws Exception {
+ public void testComputeNoCache() throws Exception {
+ runThreaded(ComputeTask.class, LOOPS, false);
+ }
+
+ @Test
+ public void testCOMPUTENoCache() throws Exception {
final TestCacheArguments args = new TestCacheArguments();
args.ca = new Object[]{
Cached.class, Cached1.class, Cached2.class
};
args.value = new Object[]{Integer.valueOf(2), "quux"};
- doCOMPUTE(args, LOOPS, true);
+ doCOMPUTE(args, LOOPS, false);
+ }
+
+ @Test
+ public void testNullAssignCache() throws Exception {
+ runThreaded(AssignNullTask.class, LOOPS, true);
+ }
+
+ @Test
+ public void testNullAssignNoCache() throws Exception {
+ runThreaded(AssignNullTask.class, LOOPS, false);
}
}
diff --git a/src/test/java/org/apache/commons/jexl3/CaptureLog.java b/src/test/java/org/apache/commons/jexl3/CaptureLog.java
index 9b3a004a..af76d345 100644
--- a/src/test/java/org/apache/commons/jexl3/CaptureLog.java
+++ b/src/test/java/org/apache/commons/jexl3/CaptureLog.java
@@ -24,13 +24,13 @@ import org.apache.commons.logging.Log;
* A log implementation to help control tests results.
*/
public class CaptureLog implements Log {
- private final List<Object[]> captured = new ArrayList<>();
-
static Object caller() {
final StackTraceElement[] stack = new Exception().fillInStackTrace().getStackTrace();
return stack[2];
}
+ private final List<Object[]> captured = new ArrayList<>();
+
public CaptureLog() {
this("org.apache.commons.jexl3");
}
@@ -39,10 +39,6 @@ public class CaptureLog implements Log {
//super(name);
}
- public boolean isEmpty() {
- return captured.isEmpty();
- }
-
public int count(final String type) {
int count = 0;
for (final Object[] l : captured) {
@@ -53,11 +49,6 @@ public class CaptureLog implements Log {
return count;
}
- //@Override
- public boolean isEnabledFor(final int /*Priority*/ p) {
- return true;
- }
-
@Override
public void debug(final Object o) {
captured.add(new Object[]{"debug", caller(), o});
@@ -103,6 +94,15 @@ public class CaptureLog implements Log {
return true;
}
+ public boolean isEmpty() {
+ return captured.isEmpty();
+ }
+
+ //@Override
+ public boolean isEnabledFor(final int /*Priority*/ p) {
+ return true;
+ }
+
@Override
public boolean isErrorEnabled() {
return true;
diff --git a/src/test/java/org/apache/commons/jexl3/ClassCreator.java b/src/test/java/org/apache/commons/jexl3/ClassCreator.java
index 4c0ecbab..fda0e32c 100644
--- a/src/test/java/org/apache/commons/jexl3/ClassCreator.java
+++ b/src/test/java/org/apache/commons/jexl3/ClassCreator.java
@@ -39,21 +39,11 @@ import javax.tools.ToolProvider;
*/
public class ClassCreator {
- //private final JexlEngine jexl;
- private final File base;
- private File packageDir;
- private int seed;
- private String ctorBody = "";
- private String className;
- private String sourceName;
- private ClassLoader loader;
public static final boolean canRun = true;//comSunToolsJavacMain();
-
static final String JEXL_PACKAGE = "org.apache.commons.jexl3";
static final String GEN_PACKAGE = "org.apache.commons.jexl3.generated";
static final String GEN_PATH = "/" + GEN_PACKAGE.replace(".", "/");///org/apache/commons/jexl3/generated";
static final String GEN_CLASS = GEN_PACKAGE + ".";
-
/**
* Check if we can invoke Sun's java compiler.
*
@@ -67,6 +57,16 @@ public class ClassCreator {
return false;
}
}
+ //private final JexlEngine jexl;
+ private final File base;
+ private File packageDir;
+
+ private int seed;
+ private String ctorBody = "";
+ private String className;
+ private String sourceName;
+
+ private ClassLoader loader;
public ClassCreator(final JexlEngine theJexl, final File theBase) throws Exception {
//jexl = theJexl;
@@ -83,33 +83,40 @@ public class ClassCreator {
loader = null;
}
- public void setSeed(final int s) {
- seed = s;
- className = "foo" + s;
- sourceName = className + ".java";
- packageDir = new File(base, seed + GEN_PATH);
- packageDir.mkdirs();
- loader = null;
- }
+ Class<?> compile() throws Exception {
+ final String source = packageDir.getPath() + "/" + sourceName;
+ final JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
+ final DiagnosticCollector<JavaFileObject> diagnosticsCollector = new DiagnosticCollector<>();
+ final StandardJavaFileManager fileManager = compiler.getStandardFileManager(diagnosticsCollector, null, null);
+ final Iterable<? extends JavaFileObject> compilationUnits = fileManager
+ .getJavaFileObjectsFromStrings(Collections.singletonList(source));
- public void setCtorBody(final String arg) {
- ctorBody = arg;
- }
+ final List<String> options = new ArrayList<>();
+ options.add("-classpath");
+ // only add hbase classes to classpath. This is a little bit tricky: assume
+ // the classpath is {hbaseSrc}/target/classes.
+ final String currentDir = new File(".").getAbsolutePath();
+ final String classpath = currentDir + File.separator + "target" + File.separator + "classes"
+ //+ File.pathSeparator + System.getProperty("java.class.path")
+ + File.pathSeparator + System.getProperty("surefire.test.class.path");
- public String getClassName() {
- return GEN_CLASS + className;
- }
+ options.add(classpath);
+ //LOG.debug("Setting classpath to: " + classpath);
- public Class<?> getClassInstance() throws Exception {
- return getClassLoader().loadClass(getClassName());
- }
+ final JavaCompiler.CompilationTask task = compiler.getTask(null, fileManager, diagnosticsCollector, options,
+ null, compilationUnits);
+ final boolean success = task.call();
+ fileManager.close();
+ if (success) {
+ return getClassLoader().loadClass(GEN_CLASS + className);
+ }
+ final List<Diagnostic<? extends JavaFileObject>> diagnostics = diagnosticsCollector.getDiagnostics();
+ for (final Diagnostic<? extends JavaFileObject> diagnostic : diagnostics) {
+ // read error dertails from the diagnostic object
+ System.out.println(diagnostic.getMessage(null));
- public ClassLoader getClassLoader() throws Exception {
- if (loader == null) {
- final URL classpath = new File(base, Integer.toString(seed)).toURI().toURL();
- loader = new URLClassLoader(new URL[]{classpath}, getClass().getClassLoader());
}
- return loader;
+ return null;
}
public Class<?> createClass() throws Exception {
@@ -133,10 +140,6 @@ public class ClassCreator {
throw new Exception("failed to validate foo" + seed);
}
- Object newInstance(final Class<?> clazz, final JexlContext ctxt) throws Exception {
- return clazz.getConstructor(JexlContext.class).newInstance(ctxt);
- }
-
void generate(final boolean ftor) throws Exception {
try (final FileWriter writer = new FileWriter(new File(packageDir, sourceName), false)) {
writer.write("package ");
@@ -167,6 +170,30 @@ public class ClassCreator {
}
}
+ public Class<?> getClassInstance() throws Exception {
+ return getClassLoader().loadClass(getClassName());
+ }
+
+ public ClassLoader getClassLoader() throws Exception {
+ if (loader == null) {
+ final URL classpath = new File(base, Integer.toString(seed)).toURI().toURL();
+ loader = new URLClassLoader(new URL[]{classpath}, getClass().getClassLoader());
+ }
+ return loader;
+ }
+
+ public String getClassName() {
+ return GEN_CLASS + className;
+ }
+
+ Object newInstance(final Class<?> clazz, final JexlContext ctxt) throws Exception {
+ return clazz.getConstructor(JexlContext.class).newInstance(ctxt);
+ }
+
+ public void setCtorBody(final String arg) {
+ ctorBody = arg;
+ }
+
// Class<?> compile0() throws Exception {
// String source = packageDir.getPath() + "/" + sourceName;
// Class<?> javac = getClassLoader().loadClass("com.sun.tools.javac.Main");
@@ -189,40 +216,13 @@ public class ClassCreator {
// return null;
// }
- Class<?> compile() throws Exception {
- final String source = packageDir.getPath() + "/" + sourceName;
- final JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
- final DiagnosticCollector<JavaFileObject> diagnosticsCollector = new DiagnosticCollector<>();
- final StandardJavaFileManager fileManager = compiler.getStandardFileManager(diagnosticsCollector, null, null);
- final Iterable<? extends JavaFileObject> compilationUnits = fileManager
- .getJavaFileObjectsFromStrings(Collections.singletonList(source));
-
- final List<String> options = new ArrayList<>();
- options.add("-classpath");
- // only add hbase classes to classpath. This is a little bit tricky: assume
- // the classpath is {hbaseSrc}/target/classes.
- final String currentDir = new File(".").getAbsolutePath();
- final String classpath = currentDir + File.separator + "target" + File.separator + "classes"
- //+ File.pathSeparator + System.getProperty("java.class.path")
- + File.pathSeparator + System.getProperty("surefire.test.class.path");
-
- options.add(classpath);
- //LOG.debug("Setting classpath to: " + classpath);
-
- final JavaCompiler.CompilationTask task = compiler.getTask(null, fileManager, diagnosticsCollector, options,
- null, compilationUnits);
- final boolean success = task.call();
- fileManager.close();
- if (success) {
- return getClassLoader().loadClass(GEN_CLASS + className);
- }
- final List<Diagnostic<? extends JavaFileObject>> diagnostics = diagnosticsCollector.getDiagnostics();
- for (final Diagnostic<? extends JavaFileObject> diagnostic : diagnostics) {
- // read error dertails from the diagnostic object
- System.out.println(diagnostic.getMessage(null));
-
- }
- return null;
+ public void setSeed(final int s) {
+ seed = s;
+ className = "foo" + s;
+ sourceName = className + ".java";
+ packageDir = new File(base, seed + GEN_PATH);
+ packageDir.mkdirs();
+ loader = null;
}
Object validate(final Class<?> clazz) throws Exception {
diff --git a/src/test/java/org/apache/commons/jexl3/ClassCreatorTest.java b/src/test/java/org/apache/commons/jexl3/ClassCreatorTest.java
index fd1bb5b4..c10460c0 100644
--- a/src/test/java/org/apache/commons/jexl3/ClassCreatorTest.java
+++ b/src/test/java/org/apache/commons/jexl3/ClassCreatorTest.java
@@ -38,43 +38,6 @@ import org.junit.Test;
*/
@SuppressWarnings({"UnnecessaryBoxing", "AssertEqualsBetweenInconvertibleTypes"})
public class ClassCreatorTest extends JexlTestCase {
- static final Log logger = LogFactory.getLog(JexlTestCase.class);
- static final int LOOPS = 8;
- private File base;
- private JexlEngine jexl;
-
- public ClassCreatorTest() {
- super("ClassCreatorTest");
- }
-
- @Before
- @Override
- public void setUp() throws Exception {
- base = new File(System.getProperty("java.io.tmpdir"), "jexl" + System.currentTimeMillis());
- jexl = JEXL;
-
- }
-
- @After
- @Override
- public void tearDown() throws Exception {
- deleteDirectory(base);
- }
-
- private void deleteDirectory(final File dir) {
- if (dir.isDirectory()) {
- for (final File file : dir.listFiles()) {
- if (file.isFile()) {
- file.delete();
- }
- }
- }
- dir.delete();
- }
-
- // A space hog class
- static final int MEGA = 1024 * 1024;
-
public static class BigObject {
@SuppressWarnings("unused")
private final byte[] space = new byte[MEGA];
@@ -88,14 +51,27 @@ public class ClassCreatorTest extends JexlTestCase {
return id;
}
}
-
// A weak reference on class
static final class ClassReference extends WeakReference<Class<?>> {
ClassReference(final Class<?> clazz, final ReferenceQueue<Object> queue) {
super(clazz, queue);
}
}
+ public static class ContextualCtor {
+ int value = -1;
+
+ public ContextualCtor(final JexlContext ctxt) {
+ value = (Integer) ctxt.get("value");
+ }
+ public ContextualCtor(final JexlContext ctxt, final int v) {
+ value = (Integer) ctxt.get("value") + v;
+ }
+
+ public int getValue() {
+ return value;
+ }
+ }
// A soft reference on instance
static final class InstanceReference extends SoftReference<Object> {
InstanceReference(final Object obj, final ReferenceQueue<Object> queue) {
@@ -103,80 +79,140 @@ public class ClassCreatorTest extends JexlTestCase {
}
}
- @Test
- public void testOne() throws Exception {
- // abort test if class creator can not run
- if (!ClassCreator.canRun) {
- logger.warn("unable to create classes");
- return;
+ public static class NsTest implements JexlContext.NamespaceFunctor {
+ private final String className;
+
+ public NsTest(final String cls) {
+ className = cls;
}
- final ClassCreator cctor = new ClassCreator(jexl, base);
- cctor.setSeed(1);
- final Class<?> foo1 = cctor.createClass();
- Assert.assertEquals("foo1", foo1.getSimpleName());
- cctor.clear();
+ @Override
+ public Object createFunctor(final JexlContext context) {
+ final JexlEngine jexl = JexlEngine.getThreadEngine();
+ return jexl.newInstance(className, context);
+ }
+
}
- @Test
- public void testFunctorOne() throws Exception {
+ public static class TwoCtors {
+ int value;
+
+ public TwoCtors(final int v) {
+ this.value = v;
+ }
+
+ public TwoCtors(final Number x) {
+ this.value = -x.intValue();
+ }
+
+ public int getValue() {
+ return value;
+ }
+ }
+
+ static final Log logger = LogFactory.getLog(JexlTestCase.class);
+
+ static final int LOOPS = 8;
+
+ // A space hog class
+ static final int MEGA = 1024 * 1024;
+
+ private File base;
+
+ private JexlEngine jexl;
+
+ public ClassCreatorTest() {
+ super("ClassCreatorTest");
+ }
+
+ private void deleteDirectory(final File dir) {
+ if (dir.isDirectory()) {
+ for (final File file : dir.listFiles()) {
+ if (file.isFile()) {
+ file.delete();
+ }
+ }
+ }
+ dir.delete();
+ }
+
+ void functorTwo(final Object nstest) throws Exception {
+ // create jexl2 with a 'test' namespace
+ final Map<String, Object> ns = new HashMap<>();
+ ns.put("test", nstest);
+ final JexlEngine jexl2 = new JexlBuilder().namespaces(ns).create();
final JexlContext ctxt = new MapContext();
ctxt.set("value", 1000);
- // create a class foo1 with a ctor whose body gets a value
- // from the context to initialize its value
+ // inject 'foo2' as test namespace functor class
final ClassCreator cctor = new ClassCreator(jexl, base);
- cctor.setSeed(1);
+ cctor.setSeed(2);
cctor.setCtorBody("value = (Integer) ctxt.get(\"value\") + 10;");
Class<?> foo1 = cctor.createClass(true);
Assert.assertSame(foo1.getClassLoader(), cctor.getClassLoader());
- Assert.assertEquals("foo1", foo1.getSimpleName());
+ Assert.assertEquals("foo2", foo1.getSimpleName());
Object result = cctor.newInstance(foo1, ctxt);
Assert.assertEquals(foo1, result.getClass());
- jexl.setClassLoader(cctor.getClassLoader());
+ jexl2.setClassLoader(cctor.getClassLoader());
cctor.clear();
- // check we can invoke that ctor using its name or class
- final JexlScript script = jexl.createScript("(c)->{ new(c).value; }");
- result = script.execute(ctxt, foo1);
- Assert.assertEquals(1010, result);
+ // check the namespace functor behavior
+ final JexlScript script = jexl2.createScript("test:getValue()");
result = script.execute(ctxt, foo1.getName());
Assert.assertEquals(1010, result);
- // re-create foo1 with a different body!
- cctor.setSeed(1);
+ // change the body
+ cctor.setSeed(2);
cctor.setCtorBody("value = (Integer) ctxt.get(\"value\") + 99;");
final Class<?> foo11 = cctor.createClass(true);
- Assert.assertEquals("foo1", foo1.getSimpleName());
+ Assert.assertEquals("foo2", foo1.getSimpleName());
Assert.assertNotSame(foo11, foo1);
foo1 = foo11;
- result = cctor.newInstance(foo1, ctxt);
+ result = cctor .newInstance(foo1, ctxt);
Assert.assertEquals(foo1, result.getClass());
// drum rolll....
- jexl.setClassLoader(foo1.getClassLoader());
+ jexl2.setClassLoader(foo1.getClassLoader());
result = script.execute(ctxt, foo1.getName());
// tada!
Assert.assertEquals(1099, result);
- result = script.execute(ctxt, foo1);
- Assert.assertEquals(1099, result);
}
- public static class NsTest implements JexlContext.NamespaceFunctor {
- private final String className;
+ @Before
+ @Override
+ public void setUp() throws Exception {
+ base = new File(System.getProperty("java.io.tmpdir"), "jexl" + System.currentTimeMillis());
+ jexl = JEXL;
- public NsTest(final String cls) {
- className = cls;
- }
- @Override
- public Object createFunctor(final JexlContext context) {
- final JexlEngine jexl = JexlEngine.getThreadEngine();
- return jexl.newInstance(className, context);
- }
+ }
+ @After
+ @Override
+ public void tearDown() throws Exception {
+ deleteDirectory(base);
}
@Test
- public void testFunctor2Name() throws Exception {
- functorTwo(ClassCreator.GEN_CLASS + "foo2");
+ public void testBasicCtor() throws Exception {
+ final JexlScript s = jexl.createScript("(c, v)->{ var ct2 = new(c, v); ct2.value; }");
+ Object r = s.execute(null, TwoCtors.class, 10);
+ Assert.assertEquals(10, r);
+ r = s.execute(null, TwoCtors.class, 5 + 5);
+ Assert.assertEquals(10, r);
+ r = s.execute(null, TwoCtors.class, 10d);
+ Assert.assertEquals(-10, r);
+ r = s.execute(null, TwoCtors.class, 100f);
+ Assert.assertEquals(-100, r);
+ }
+
+ @Test
+ public void testContextualCtor() throws Exception {
+ final MapContext ctxt = new MapContext();
+ ctxt.set("value", 42);
+ JexlScript s = jexl.createScript("(c)->{ new(c).value }");
+ Object r = s.execute(ctxt, ContextualCtor.class);
+ Assert.assertEquals(42, r);
+ s = jexl.createScript("(c, v)->{ new(c, v).value }");
+ r = s.execute(ctxt, ContextualCtor.class, 100);
+ Assert.assertEquals(142, r);
}
@Test
@@ -184,45 +220,52 @@ public class ClassCreatorTest extends JexlTestCase {
functorTwo(new NsTest(ClassCreator.GEN_CLASS + "foo2"));
}
- void functorTwo(final Object nstest) throws Exception {
- // create jexl2 with a 'test' namespace
- final Map<String, Object> ns = new HashMap<>();
- ns.put("test", nstest);
- final JexlEngine jexl2 = new JexlBuilder().namespaces(ns).create();
+ @Test
+ public void testFunctor2Name() throws Exception {
+ functorTwo(ClassCreator.GEN_CLASS + "foo2");
+ }
+
+ @Test
+ public void testFunctorOne() throws Exception {
final JexlContext ctxt = new MapContext();
ctxt.set("value", 1000);
- // inject 'foo2' as test namespace functor class
+ // create a class foo1 with a ctor whose body gets a value
+ // from the context to initialize its value
final ClassCreator cctor = new ClassCreator(jexl, base);
- cctor.setSeed(2);
+ cctor.setSeed(1);
cctor.setCtorBody("value = (Integer) ctxt.get(\"value\") + 10;");
Class<?> foo1 = cctor.createClass(true);
Assert.assertSame(foo1.getClassLoader(), cctor.getClassLoader());
- Assert.assertEquals("foo2", foo1.getSimpleName());
+ Assert.assertEquals("foo1", foo1.getSimpleName());
Object result = cctor.newInstance(foo1, ctxt);
Assert.assertEquals(foo1, result.getClass());
- jexl2.setClassLoader(cctor.getClassLoader());
+ jexl.setClassLoader(cctor.getClassLoader());
cctor.clear();
- // check the namespace functor behavior
- final JexlScript script = jexl2.createScript("test:getValue()");
+ // check we can invoke that ctor using its name or class
+ final JexlScript script = jexl.createScript("(c)->{ new(c).value; }");
+ result = script.execute(ctxt, foo1);
+ Assert.assertEquals(1010, result);
result = script.execute(ctxt, foo1.getName());
Assert.assertEquals(1010, result);
- // change the body
- cctor.setSeed(2);
+ // re-create foo1 with a different body!
+ cctor.setSeed(1);
cctor.setCtorBody("value = (Integer) ctxt.get(\"value\") + 99;");
final Class<?> foo11 = cctor.createClass(true);
- Assert.assertEquals("foo2", foo1.getSimpleName());
+ Assert.assertEquals("foo1", foo1.getSimpleName());
Assert.assertNotSame(foo11, foo1);
foo1 = foo11;
- result = cctor .newInstance(foo1, ctxt);
+ result = cctor.newInstance(foo1, ctxt);
Assert.assertEquals(foo1, result.getClass());
// drum rolll....
- jexl2.setClassLoader(foo1.getClassLoader());
+ jexl.setClassLoader(foo1.getClassLoader());
result = script.execute(ctxt, foo1.getName());
// tada!
Assert.assertEquals(1099, result);
+ result = script.execute(ctxt, foo1);
+ Assert.assertEquals(1099, result);
}
@Test
@@ -356,60 +399,17 @@ public class ClassCreatorTest extends JexlTestCase {
}
}
- public static class TwoCtors {
- int value;
-
- public TwoCtors(final int v) {
- this.value = v;
- }
-
- public TwoCtors(final Number x) {
- this.value = -x.intValue();
- }
-
- public int getValue() {
- return value;
- }
- }
-
@Test
- public void testBasicCtor() throws Exception {
- final JexlScript s = jexl.createScript("(c, v)->{ var ct2 = new(c, v); ct2.value; }");
- Object r = s.execute(null, TwoCtors.class, 10);
- Assert.assertEquals(10, r);
- r = s.execute(null, TwoCtors.class, 5 + 5);
- Assert.assertEquals(10, r);
- r = s.execute(null, TwoCtors.class, 10d);
- Assert.assertEquals(-10, r);
- r = s.execute(null, TwoCtors.class, 100f);
- Assert.assertEquals(-100, r);
- }
-
- public static class ContextualCtor {
- int value = -1;
-
- public ContextualCtor(final JexlContext ctxt) {
- value = (Integer) ctxt.get("value");
- }
-
- public ContextualCtor(final JexlContext ctxt, final int v) {
- value = (Integer) ctxt.get("value") + v;
- }
-
- public int getValue() {
- return value;
+ public void testOne() throws Exception {
+ // abort test if class creator can not run
+ if (!ClassCreator.canRun) {
+ logger.warn("unable to create classes");
+ return;
}
- }
-
- @Test
- public void testContextualCtor() throws Exception {
- final MapContext ctxt = new MapContext();
- ctxt.set("value", 42);
- JexlScript s = jexl.createScript("(c)->{ new(c).value }");
- Object r = s.execute(ctxt, ContextualCtor.class);
- Assert.assertEquals(42, r);
- s = jexl.createScript("(c, v)->{ new(c, v).value }");
- r = s.execute(ctxt, ContextualCtor.class, 100);
- Assert.assertEquals(142, r);
+ final ClassCreator cctor = new ClassCreator(jexl, base);
+ cctor.setSeed(1);
+ final Class<?> foo1 = cctor.createClass();
+ Assert.assertEquals("foo1", foo1.getSimpleName());
+ cctor.clear();
}
}
diff --git a/src/test/java/org/apache/commons/jexl3/CollectionLiteralTest.java b/src/test/java/org/apache/commons/jexl3/CollectionLiteralTest.java
index c8c75378..88756204 100644
--- a/src/test/java/org/apache/commons/jexl3/CollectionLiteralTest.java
+++ b/src/test/java/org/apache/commons/jexl3/CollectionLiteralTest.java
@@ -36,11 +36,6 @@ import org.junit.Test;
* </p>
*/
public class CollectionLiteralTest extends JexlTestCase {
- public CollectionLiteralTest() {
- super("CollectionLiteralTest");
- }
-
-
public static class Arithmetic363 extends JexlArithmetic {
final AtomicInteger maps = new AtomicInteger(0);
final AtomicInteger sets = new AtomicInteger(0);
@@ -50,27 +45,30 @@ public class CollectionLiteralTest extends JexlTestCase {
super(strict);
}
+ @Override public ArrayBuilder arrayBuilder(final int size, final boolean extended) {
+ return new CountingArrayBuilder(arrays, size, extended);
+ }
@Override public MapBuilder mapBuilder(final int size, final boolean extended) {
return new CountingMapBuilder(maps, size, extended);
}
@Override public SetBuilder setBuilder(final int size, final boolean extended) {
return new CountingSetBuilder(sets, size, extended);
}
- @Override public ArrayBuilder arrayBuilder(final int size, final boolean extended) {
- return new CountingArrayBuilder(arrays, size, extended);
- }
}
- static class CountingSetBuilder extends SetBuilder {
+
+ static class CountingArrayBuilder extends ArrayBuilder {
final AtomicInteger count;
- public CountingSetBuilder(final AtomicInteger ai, final int size, final boolean extended) {
+
+ public CountingArrayBuilder(final AtomicInteger ai, final int size, final boolean extended) {
super(size, extended);
count = ai;
}
- @Override public Set<?> create() {
- final Set<?> set = super.create();
+
+ @Override public Object create(final boolean extended) {
+ final Object array = super.create(extended);
count.incrementAndGet();
- return set;
+ return array;
}
}
@@ -87,72 +85,74 @@ public class CollectionLiteralTest extends JexlTestCase {
}
}
- static class CountingArrayBuilder extends ArrayBuilder {
+ static class CountingSetBuilder extends SetBuilder {
final AtomicInteger count;
-
- public CountingArrayBuilder(final AtomicInteger ai, final int size, final boolean extended) {
+ public CountingSetBuilder(final AtomicInteger ai, final int size, final boolean extended) {
super(size, extended);
count = ai;
}
-
- @Override public Object create(final boolean extended) {
- final Object array = super.create(extended);
+ @Override public Set<?> create() {
+ final Set<?> set = super.create();
count.incrementAndGet();
- return array;
+ return set;
}
}
+ public CollectionLiteralTest() {
+ super("CollectionLiteralTest");
+ }
+
@Test
- public void testMapLBuilder() {
+ public void testArrayBuilder() {
final Arithmetic363 jc = new Arithmetic363(true);
final JexlEngine jexl = new JexlBuilder().cache(4).arithmetic(jc).create();
JexlScript script;
Object result;
- script = jexl.createScript("{ 'x':(x)->{ 1 + x; }, 'y' : (y)->{ y - 1; } }");
+ script = jexl.createScript("[ (x)->{ 1 + x; }, (y)->{ y - 1; } ]");
Object previous = null;
for(int i = 0; i < 4; ++i) {
result = script.execute(null);
Assert.assertNotNull(result);
Assert.assertNotSame(previous, result);
previous = result;
- Assert.assertEquals(1 + i, jc.maps.get());
+ Assert.assertEquals( 1 + i, jc.arrays.get());
}
}
@Test
- public void testSetBuilder() {
+ public void testMapLBuilder() {
final Arithmetic363 jc = new Arithmetic363(true);
final JexlEngine jexl = new JexlBuilder().cache(4).arithmetic(jc).create();
JexlScript script;
Object result;
- script = jexl.createScript("{ (x)->{ 1 + x; }, (y)->{ y - 1; } }");
+ script = jexl.createScript("{ 'x':(x)->{ 1 + x; }, 'y' : (y)->{ y - 1; } }");
Object previous = null;
for(int i = 0; i < 4; ++i) {
result = script.execute(null);
Assert.assertNotNull(result);
Assert.assertNotSame(previous, result);
previous = result;
- Assert.assertEquals(1 + i, jc.sets.get());
+ Assert.assertEquals(1 + i, jc.maps.get());
}
}
@Test
- public void testArrayBuilder() {
+ public void testSetBuilder() {
final Arithmetic363 jc = new Arithmetic363(true);
final JexlEngine jexl = new JexlBuilder().cache(4).arithmetic(jc).create();
JexlScript script;
Object result;
- script = jexl.createScript("[ (x)->{ 1 + x; }, (y)->{ y - 1; } ]");
+ script = jexl.createScript("{ (x)->{ 1 + x; }, (y)->{ y - 1; } }");
Object previous = null;
for(int i = 0; i < 4; ++i) {
result = script.execute(null);
Assert.assertNotNull(result);
Assert.assertNotSame(previous, result);
previous = result;
- Assert.assertEquals( 1 + i, jc.arrays.get());
+ Assert.assertEquals(1 + i, jc.sets.get());
}
}
diff --git a/src/test/java/org/apache/commons/jexl3/ComposePermissionsTest.java b/src/test/java/org/apache/commons/jexl3/ComposePermissionsTest.java
index 47328771..c0ca0112 100644
--- a/src/test/java/org/apache/commons/jexl3/ComposePermissionsTest.java
+++ b/src/test/java/org/apache/commons/jexl3/ComposePermissionsTest.java
@@ -38,25 +38,6 @@ public class ComposePermissionsTest extends JexlTestCase {
super("PermissionsTest");
}
- @Test
- public void testComposePermissions() throws Exception {
- runComposePermissions(JexlPermissions.UNRESTRICTED);
- }
-
- @Test
- public void testComposePermissions1() throws Exception {
- runComposePermissions(new JexlPermissions.Delegate(JexlPermissions.UNRESTRICTED) {
- @Override public String toString() {
- return "delegate:" + base.toString();
- }
- });
- }
-
- @Test
- public void testComposePermissions2() throws Exception {
- runComposePermissions(new JexlPermissions.ClassPermissions(JexlPermissions.UNRESTRICTED, Collections.emptySet()));
- }
-
void runComposePermissions(final JexlPermissions p) throws Exception {
final String check = "http://example.com/content.jpg";
final File jsonFile = new File(SAMPLE_JSON);
@@ -96,4 +77,23 @@ public class ComposePermissionsTest extends JexlTestCase {
final Object r1 = s1.execute(null, json);
Assert.assertEquals(check, r0);
}
+
+ @Test
+ public void testComposePermissions() throws Exception {
+ runComposePermissions(JexlPermissions.UNRESTRICTED);
+ }
+
+ @Test
+ public void testComposePermissions1() throws Exception {
+ runComposePermissions(new JexlPermissions.Delegate(JexlPermissions.UNRESTRICTED) {
+ @Override public String toString() {
+ return "delegate:" + base.toString();
+ }
+ });
+ }
+
+ @Test
+ public void testComposePermissions2() throws Exception {
+ runComposePermissions(new JexlPermissions.ClassPermissions(JexlPermissions.UNRESTRICTED, Collections.emptySet()));
+ }
}
diff --git a/src/test/java/org/apache/commons/jexl3/ContextNamespaceTest.java b/src/test/java/org/apache/commons/jexl3/ContextNamespaceTest.java
index ae9917a8..555f8c50 100644
--- a/src/test/java/org/apache/commons/jexl3/ContextNamespaceTest.java
+++ b/src/test/java/org/apache/commons/jexl3/ContextNamespaceTest.java
@@ -30,8 +30,41 @@ import org.junit.Test;
@SuppressWarnings({"AssertEqualsBetweenInconvertibleTypes"})
public class ContextNamespaceTest extends JexlTestCase {
- public ContextNamespaceTest() {
- super("ContextNamespaceTest");
+ public static class Context346 extends MapContext {
+ public int func(final int y) { return 42 * y;}
+ }
+
+ public static class ContextNs348 extends MapContext implements JexlContext.NamespaceResolver {
+ ContextNs348() { }
+
+ @Override
+ public Object resolveNamespace(final String name) {
+ return "ns".equals(name)? new Ns348() : null;
+ }
+ }
+
+ public static class Ns348 {
+ public static int func(final int y) { return 42 * y;}
+ }
+
+ public static class NsNs {
+ private final int constVar;
+ public NsNs(final JexlContext ctxt) {
+ nsnsCtor.incrementAndGet();
+ final Object n = ctxt.get("NUMBER");
+ constVar = n instanceof Number ? ((Number) n).intValue() : -1;
+ }
+
+ public int callIt(final int n) {
+ return n + constVar;
+ }
+ }
+
+ public static class StaticNs {
+ public static int callIt(final int n) {
+ return n + 19;
+ }
+ private StaticNs() { }
}
/*
@@ -40,14 +73,14 @@ public class ContextNamespaceTest extends JexlTestCase {
public static class Taxes {
private final double vat;
- public Taxes(final TaxesContext ctxt) {
- vat = ctxt.getVAT();
- }
-
public Taxes(final double d) {
vat = d;
}
+ public Taxes(final TaxesContext ctxt) {
+ vat = ctxt.getVAT();
+ }
+
public double vat(final double n) {
return n * vat / 100.;
}
@@ -64,6 +97,10 @@ public class ContextNamespaceTest extends JexlTestCase {
this.vat = vat;
}
+ public double getVAT() {
+ return vat;
+ }
+
@Override
public Object resolveNamespace(final String name) {
if ("taxes".equals(name)) {
@@ -74,37 +111,130 @@ public class ContextNamespaceTest extends JexlTestCase {
}
return null;
}
+ }
+
+ public static class Vat {
+ private double vat;
+
+ Vat(final double vat) {
+ this.vat = vat;
+ }
+
+ public double getvat() {
+ throw new UnsupportedOperationException("no way");
+ }
public double getVAT() {
return vat;
}
+
+ public void setvat(final double vat) {
+ throw new UnsupportedOperationException("no way");
+ }
+
+ public void setVAT(final double vat) {
+ this.vat = vat;
+ }
}
- @Test
- public void testThreadedContext() {
- final JexlEngine jexl = new JexlBuilder().create();
- final JexlContext context = new TaxesContext(18.6);
- final String strs = "taxes:vat(1000)";
- final JexlScript staxes = jexl.createScript(strs);
- final Object result = staxes.execute(context);
- Assert.assertEquals(186., result);
+ static AtomicInteger nsnsCtor = new AtomicInteger(0);
+
+ public ContextNamespaceTest() {
+ super("ContextNamespaceTest");
}
- @Test
- public void testNamespacePragma() {
- final JexlEngine jexl = new JexlBuilder().create();
- final JexlContext context = new TaxesContext(18.6);
- // local namespace tax declared
- final String strs =
- "#pragma jexl.namespace.tax org.apache.commons.jexl3.ContextNamespaceTest$Taxes\n"
- + "tax:vat(2000)";
- final JexlScript staxes = jexl.createScript(strs);
- final Object result = staxes.execute(context);
- Assert.assertEquals(372., result);
+ private void run348a(final JexlEngine jexl, final JexlContext ctxt) {
+ run348a(jexl, ctxt, "ns : ");
}
- public static class Context346 extends MapContext {
- public int func(final int y) { return 42 * y;}
+ private void run348a(final JexlEngine jexl, final JexlContext ctxt, final String ns) {
+ final String src = "empty(x) ? "+ns+"func(y) : z";
+ // local vars
+ final JexlScript script = jexl.createScript(src, "x", "y", "z");
+ Object result = script.execute(ctxt, null, 1, 169);
+ Assert.assertEquals(42, result);
+ result = script.execute(ctxt, "42", 1, 169);
+ Assert.assertEquals(169, result);
+ }
+
+ private void run348b(final JexlEngine jexl, final JexlContext ctxt) {
+ run348b(jexl, ctxt, "ns : ");
+ }
+
+ private void run348b(final JexlEngine jexl, final JexlContext ctxt, final String ns) {
+ final String src = "empty(x) ? "+ns+"func(y) : z";
+ // global vars
+ final JexlScript script = jexl.createScript(src);
+ ctxt.set("x", null);
+ ctxt.set("y", 1);
+ ctxt.set("z", 169);
+ Object result = script.execute(ctxt);
+ Assert.assertEquals(42, result);
+ ctxt.set("x", "42");
+ result = script.execute(ctxt);
+ Assert.assertEquals(169, result);
+ //ctxt.set("x", "42");
+ result = script.execute(ctxt);
+ Assert.assertEquals(169, result);
+ }
+
+ private void run348c(final JexlEngine jexl, final JexlContext ctxt) {
+ run348c(jexl, ctxt, "ns : ");
+ }
+ private void run348c(final JexlEngine jexl, final JexlContext ctxt, final String ns) {
+ final String src = "empty(x) ? z : "+ns+"func(y)";
+ // local vars
+ final JexlScript script = jexl.createScript(src, "x", "z", "y");
+ Object result = script.execute(ctxt, null, 169, 1);
+ Assert.assertEquals(src, 169, result);
+ result = script.execute(ctxt, "42", 169, 1);
+ Assert.assertEquals(src, 42, result);
+ }
+
+ private void run348d(final JexlEngine jexl, final JexlContext ctxt) {
+ run348d(jexl, ctxt, "ns : ");
+ }
+ private void run348d(final JexlEngine jexl, final JexlContext ctxt, final String ns) {
+ final String src = "empty(x) ? z : "+ns+"func(y)";
+ // global vars
+ JexlScript script = null;
+ try {
+ script = jexl.createScript(src);
+ } catch (final JexlException.Parsing xparse) {
+ Assert.fail(src);
+ }
+ ctxt.set("x", null);
+ ctxt.set("z", 169);
+ ctxt.set("y", 1);
+ Object result = script.execute(ctxt);
+ Assert.assertEquals(src, 169, result);
+ ctxt.set("x", "42");
+ result = script.execute(ctxt);
+ Assert.assertEquals(src,42, result);
+ }
+
+ private void runNsNsContext(final Map<String,Object> nsMap) {
+ final JexlContext ctxt = new MapContext();
+ ctxt.set("NUMBER", 19);
+ final JexlEngine jexl = new JexlBuilder().strict(true).silent(false).cache(32)
+ .namespaces(nsMap).create();
+ final JexlScript script = jexl.createScript("x ->{ nsns:callIt(x); nsns:callIt(x); }");
+ Number result = (Number) script.execute(ctxt, 23);
+ Assert.assertEquals(42, result);
+ Assert.assertEquals(1, nsnsCtor.get());
+ result = (Number) script.execute(ctxt, 623);
+ Assert.assertEquals(642, result);
+ Assert.assertEquals(2, nsnsCtor.get());
+ }
+ private void runStaticNsContext(final Map<String,Object> nsMap) {
+ final JexlContext ctxt = new MapContext();
+ final JexlEngine jexl = new JexlBuilder().strict(true).silent(false).cache(32)
+ .namespaces(nsMap).create();
+ final JexlScript script = jexl.createScript("x ->{ sns:callIt(x); sns:callIt(x); }");
+ Number result = (Number) script.execute(ctxt, 23);
+ Assert.assertEquals(42, result);
+ result = (Number) script.execute(ctxt, 623);
+ Assert.assertEquals(642, result);
}
@Test
@@ -118,7 +248,6 @@ public class ContextNamespaceTest extends JexlTestCase {
result = script.execute(ctxt, 169, -169);
Assert.assertEquals(169, result);
}
-
@Test
public void testNamespace346b() {
final JexlContext ctxt = new MapContext();
@@ -134,19 +263,6 @@ public class ContextNamespaceTest extends JexlTestCase {
Assert.assertEquals(169, result);
}
- public static class Ns348 {
- public static int func(final int y) { return 42 * y;}
- }
-
- public static class ContextNs348 extends MapContext implements JexlContext.NamespaceResolver {
- ContextNs348() { }
-
- @Override
- public Object resolveNamespace(final String name) {
- return "ns".equals(name)? new Ns348() : null;
- }
- }
-
@Test
public void testNamespace348a() {
final JexlContext ctxt = new MapContext();
@@ -196,72 +312,17 @@ public class ContextNamespaceTest extends JexlTestCase {
run348d(jexl, ctxt);
}
- private void run348a(final JexlEngine jexl, final JexlContext ctxt) {
- run348a(jexl, ctxt, "ns : ");
- }
- private void run348a(final JexlEngine jexl, final JexlContext ctxt, final String ns) {
- final String src = "empty(x) ? "+ns+"func(y) : z";
- // local vars
- final JexlScript script = jexl.createScript(src, "x", "y", "z");
- Object result = script.execute(ctxt, null, 1, 169);
- Assert.assertEquals(42, result);
- result = script.execute(ctxt, "42", 1, 169);
- Assert.assertEquals(169, result);
- }
-
- private void run348b(final JexlEngine jexl, final JexlContext ctxt) {
- run348b(jexl, ctxt, "ns : ");
- }
- private void run348b(final JexlEngine jexl, final JexlContext ctxt, final String ns) {
- final String src = "empty(x) ? "+ns+"func(y) : z";
- // global vars
- final JexlScript script = jexl.createScript(src);
- ctxt.set("x", null);
- ctxt.set("y", 1);
- ctxt.set("z", 169);
- Object result = script.execute(ctxt);
- Assert.assertEquals(42, result);
- ctxt.set("x", "42");
- result = script.execute(ctxt);
- Assert.assertEquals(169, result);
- //ctxt.set("x", "42");
- result = script.execute(ctxt);
- Assert.assertEquals(169, result);
- }
-
- private void run348c(final JexlEngine jexl, final JexlContext ctxt) {
- run348c(jexl, ctxt, "ns : ");
- }
- private void run348c(final JexlEngine jexl, final JexlContext ctxt, final String ns) {
- final String src = "empty(x) ? z : "+ns+"func(y)";
- // local vars
- final JexlScript script = jexl.createScript(src, "x", "z", "y");
- Object result = script.execute(ctxt, null, 169, 1);
- Assert.assertEquals(src, 169, result);
- result = script.execute(ctxt, "42", 169, 1);
- Assert.assertEquals(src, 42, result);
- }
-
- private void run348d(final JexlEngine jexl, final JexlContext ctxt) {
- run348d(jexl, ctxt, "ns : ");
- }
- private void run348d(final JexlEngine jexl, final JexlContext ctxt, final String ns) {
- final String src = "empty(x) ? z : "+ns+"func(y)";
- // global vars
- JexlScript script = null;
- try {
- script = jexl.createScript(src);
- } catch (final JexlException.Parsing xparse) {
- Assert.fail(src);
- }
- ctxt.set("x", null);
- ctxt.set("z", 169);
- ctxt.set("y", 1);
- Object result = script.execute(ctxt);
- Assert.assertEquals(src, 169, result);
- ctxt.set("x", "42");
- result = script.execute(ctxt);
- Assert.assertEquals(src,42, result);
+ @Test
+ public void testNamespacePragma() {
+ final JexlEngine jexl = new JexlBuilder().create();
+ final JexlContext context = new TaxesContext(18.6);
+ // local namespace tax declared
+ final String strs =
+ "#pragma jexl.namespace.tax org.apache.commons.jexl3.ContextNamespaceTest$Taxes\n"
+ + "tax:vat(2000)";
+ final JexlScript staxes = jexl.createScript(strs);
+ final Object result = staxes.execute(context);
+ Assert.assertEquals(372., result);
}
@Test
@@ -277,28 +338,17 @@ public class ContextNamespaceTest extends JexlTestCase {
Assert.assertEquals("0042", result);
}
- public static class Vat {
- private double vat;
-
- Vat(final double vat) {
- this.vat = vat;
- }
-
- public double getVAT() {
- return vat;
- }
-
- public void setVAT(final double vat) {
- this.vat = vat;
- }
-
- public double getvat() {
- throw new UnsupportedOperationException("no way");
- }
+ @Test
+ public void testNsNsContext0() {
+ nsnsCtor.set(0);
+ final String clsName = NsNs.class.getName();
+ runNsNsContext(Collections.singletonMap("nsns", clsName));
+ }
- public void setvat(final double vat) {
- throw new UnsupportedOperationException("no way");
- }
+ @Test
+ public void testNsNsContext1() {
+ nsnsCtor.set(0);
+ runNsNsContext(Collections.singletonMap("nsns", NsNs.class));
}
@Test
@@ -325,55 +375,6 @@ public class ContextNamespaceTest extends JexlTestCase {
}
}
- static AtomicInteger nsnsCtor = new AtomicInteger(0);
-
- public static class NsNs {
- private final int constVar;
- public NsNs(final JexlContext ctxt) {
- nsnsCtor.incrementAndGet();
- final Object n = ctxt.get("NUMBER");
- constVar = n instanceof Number ? ((Number) n).intValue() : -1;
- }
-
- public int callIt(final int n) {
- return n + constVar;
- }
- }
-
- @Test
- public void testNsNsContext0() {
- nsnsCtor.set(0);
- final String clsName = NsNs.class.getName();
- runNsNsContext(Collections.singletonMap("nsns", clsName));
- }
-
- @Test
- public void testNsNsContext1() {
- nsnsCtor.set(0);
- runNsNsContext(Collections.singletonMap("nsns", NsNs.class));
- }
-
- private void runNsNsContext(final Map<String,Object> nsMap) {
- final JexlContext ctxt = new MapContext();
- ctxt.set("NUMBER", 19);
- final JexlEngine jexl = new JexlBuilder().strict(true).silent(false).cache(32)
- .namespaces(nsMap).create();
- final JexlScript script = jexl.createScript("x ->{ nsns:callIt(x); nsns:callIt(x); }");
- Number result = (Number) script.execute(ctxt, 23);
- Assert.assertEquals(42, result);
- Assert.assertEquals(1, nsnsCtor.get());
- result = (Number) script.execute(ctxt, 623);
- Assert.assertEquals(642, result);
- Assert.assertEquals(2, nsnsCtor.get());
- }
-
- public static class StaticNs {
- private StaticNs() { }
- public static int callIt(final int n) {
- return n + 19;
- }
- }
-
@Test
public void testStaticNs0() {
runStaticNsContext(Collections.singletonMap("sns", StaticNs.class));
@@ -384,14 +385,13 @@ public class ContextNamespaceTest extends JexlTestCase {
runStaticNsContext(Collections.singletonMap("sns", StaticNs.class.getName()));
}
- private void runStaticNsContext(final Map<String,Object> nsMap) {
- final JexlContext ctxt = new MapContext();
- final JexlEngine jexl = new JexlBuilder().strict(true).silent(false).cache(32)
- .namespaces(nsMap).create();
- final JexlScript script = jexl.createScript("x ->{ sns:callIt(x); sns:callIt(x); }");
- Number result = (Number) script.execute(ctxt, 23);
- Assert.assertEquals(42, result);
- result = (Number) script.execute(ctxt, 623);
- Assert.assertEquals(642, result);
+ @Test
+ public void testThreadedContext() {
+ final JexlEngine jexl = new JexlBuilder().create();
+ final JexlContext context = new TaxesContext(18.6);
+ final String strs = "taxes:vat(1000)";
+ final JexlScript staxes = jexl.createScript(strs);
+ final Object result = staxes.execute(context);
+ Assert.assertEquals(186., result);
}
}
diff --git a/src/test/java/org/apache/commons/jexl3/DoWhileTest.java b/src/test/java/org/apache/commons/jexl3/DoWhileTest.java
index 39aeeb59..fed77a65 100644
--- a/src/test/java/org/apache/commons/jexl3/DoWhileTest.java
+++ b/src/test/java/org/apache/commons/jexl3/DoWhileTest.java
@@ -35,51 +35,19 @@ public class DoWhileTest extends JexlTestCase {
}
@Test
- public void testSimpleWhileFalse() throws Exception {
- JexlScript e = JEXL.createScript("do {} while (false)");
- final JexlContext jc = new MapContext();
-
- Object o = e.execute(jc);
- Assert.assertNull("Result is not null", o);
- e = JEXL.createScript("do {} while (false); 23");
- o = e.execute(jc);
- Assert.assertEquals(23, o);
-
- }
-
- @Test
- public void testWhileExecutesExpressionWhenLooping() throws Exception {
- JexlScript e = JEXL.createScript("do x = x + 1 while (x < 10)");
+ public void testEmptyBody() throws Exception {
+ final JexlScript e = JEXL.createScript("var i = 0; do ; while((i+=1) < 10); i");
final JexlContext jc = new MapContext();
- jc.set("x", 1);
-
- Object o = e.execute(jc);
+ final Object o = e.execute(jc);
Assert.assertEquals(10, o);
- Assert.assertEquals(10, jc.get("x"));
-
- e = JEXL.createScript("var x = 0; do x += 1; while (x < 23)");
- o = e.execute(jc);
- Assert.assertEquals(23, o);
-
-
- jc.set("x", 1);
- e = JEXL.createScript("do x += 1; while (x < 23); return 42;");
- o = e.execute(jc);
- Assert.assertEquals(23, jc.get("x"));
- Assert.assertEquals(42, o);
}
@Test
- public void testWhileWithBlock() throws Exception {
- final JexlScript e = JEXL.createScript("do { x = x + 1; y = y * 2; } while (x < 10)");
+ public void testEmptyStmtBody() throws Exception {
+ final JexlScript e = JEXL.createScript("var i = 0; do {} while((i+=1) < 10); i");
final JexlContext jc = new MapContext();
- jc.set("x", Integer.valueOf(1));
- jc.set("y", Integer.valueOf(1));
-
final Object o = e.execute(jc);
- Assert.assertEquals("Result is wrong", Integer.valueOf(512), o);
- Assert.assertEquals("x is wrong", Integer.valueOf(10), jc.get("x"));
- Assert.assertEquals("y is wrong", Integer.valueOf(512), jc.get("y"));
+ Assert.assertEquals(10, o);
}
@Test
@@ -110,38 +78,6 @@ public class DoWhileTest extends JexlTestCase {
Assert.assertNotNull(e);
}
- @Test
- public void testEmptyBody() throws Exception {
- final JexlScript e = JEXL.createScript("var i = 0; do ; while((i+=1) < 10); i");
- final JexlContext jc = new MapContext();
- final Object o = e.execute(jc);
- Assert.assertEquals(10, o);
- }
-
- @Test
- public void testEmptyStmtBody() throws Exception {
- final JexlScript e = JEXL.createScript("var i = 0; do {} while((i+=1) < 10); i");
- final JexlContext jc = new MapContext();
- final Object o = e.execute(jc);
- Assert.assertEquals(10, o);
- }
-
- @Test
- public void testWhileEmptyBody() throws Exception {
- final JexlScript e = JEXL.createScript("var i = 0; while((i+=1) < 10); i");
- final JexlContext jc = new MapContext();
- final Object o = e.execute(jc);
- Assert.assertEquals(10, o);
- }
-
- @Test
- public void testWhileEmptyStmtBody() throws Exception {
- final JexlScript e = JEXL.createScript("var i = 0; while((i+=1) < 10) {}; i");
- final JexlContext jc = new MapContext();
- final Object o = e.execute(jc);
- Assert.assertEquals(10, o);
- }
-
@Test public void testForLoop0() {
final String src = "(l)->{ for(let x = 0; x < 4; ++x) { l.add(x); } }";
final JexlEngine jexl = new JexlBuilder().safe(true).create();
@@ -172,4 +108,68 @@ public class DoWhileTest extends JexlTestCase {
Assert.assertNotNull(result);
Assert.assertEquals(Arrays.asList(0, 1, 2, 3), l);
}
+
+ @Test
+ public void testSimpleWhileFalse() throws Exception {
+ JexlScript e = JEXL.createScript("do {} while (false)");
+ final JexlContext jc = new MapContext();
+
+ Object o = e.execute(jc);
+ Assert.assertNull("Result is not null", o);
+ e = JEXL.createScript("do {} while (false); 23");
+ o = e.execute(jc);
+ Assert.assertEquals(23, o);
+
+ }
+
+ @Test
+ public void testWhileEmptyBody() throws Exception {
+ final JexlScript e = JEXL.createScript("var i = 0; while((i+=1) < 10); i");
+ final JexlContext jc = new MapContext();
+ final Object o = e.execute(jc);
+ Assert.assertEquals(10, o);
+ }
+
+ @Test
+ public void testWhileEmptyStmtBody() throws Exception {
+ final JexlScript e = JEXL.createScript("var i = 0; while((i+=1) < 10) {}; i");
+ final JexlContext jc = new MapContext();
+ final Object o = e.execute(jc);
+ Assert.assertEquals(10, o);
+ }
+
+ @Test
+ public void testWhileExecutesExpressionWhenLooping() throws Exception {
+ JexlScript e = JEXL.createScript("do x = x + 1 while (x < 10)");
+ final JexlContext jc = new MapContext();
+ jc.set("x", 1);
+
+ Object o = e.execute(jc);
+ Assert.assertEquals(10, o);
+ Assert.assertEquals(10, jc.get("x"));
+
+ e = JEXL.createScript("var x = 0; do x += 1; while (x < 23)");
+ o = e.execute(jc);
+ Assert.assertEquals(23, o);
+
+
+ jc.set("x", 1);
+ e = JEXL.createScript("do x += 1; while (x < 23); return 42;");
+ o = e.execute(jc);
+ Assert.assertEquals(23, jc.get("x"));
+ Assert.assertEquals(42, o);
+ }
+
+ @Test
+ public void testWhileWithBlock() throws Exception {
+ final JexlScript e = JEXL.createScript("do { x = x + 1; y = y * 2; } while (x < 10)");
+ final JexlContext jc = new MapContext();
+ jc.set("x", Integer.valueOf(1));
+ jc.set("y", Integer.valueOf(1));
+
+ final Object o = e.execute(jc);
+ Assert.assertEquals("Result is wrong", Integer.valueOf(512), o);
+ Assert.assertEquals("x is wrong", Integer.valueOf(10), jc.get("x"));
+ Assert.assertEquals("y is wrong", Integer.valueOf(512), jc.get("y"));
+ }
}
diff --git a/src/test/java/org/apache/commons/jexl3/ExceptionTest.java b/src/test/java/org/apache/commons/jexl3/ExceptionTest.java
index badbc8c7..df671fad 100644
--- a/src/test/java/org/apache/commons/jexl3/ExceptionTest.java
+++ b/src/test/java/org/apache/commons/jexl3/ExceptionTest.java
@@ -25,13 +25,15 @@ import org.junit.Test;
*/
@SuppressWarnings({"UnnecessaryBoxing", "AssertEqualsBetweenInconvertibleTypes"})
public class ExceptionTest extends JexlTestCase {
- /** create a named test */
- public ExceptionTest() {
- super("ExceptionTest");
- }
-
public static class ThrowNPE {
boolean doThrow = false;
+ public boolean getFail() {
+ if (doThrow) {
+ throw new NullPointerException("ThrowNPE/get");
+ }
+ return doThrow;
+ }
+
public String npe() {
throw new NullPointerException("ThrowNPE");
}
@@ -42,80 +44,59 @@ public class ExceptionTest extends JexlTestCase {
throw new NullPointerException("ThrowNPE/set");
}
}
-
- public boolean getFail() {
- if (doThrow) {
- throw new NullPointerException("ThrowNPE/get");
- }
- return doThrow;
- }
}
- @Test
- public void testWrappedEx() throws Exception {
- final JexlEngine jexl = new Engine();
- final JexlExpression e = jexl.createExpression("npe()");
- final JexlContext jc = new ObjectContext<>(jexl, new ThrowNPE());
- try {
- e.evaluate(jc);
- Assert.fail("Should have thrown NPE");
- } catch (final JexlException xany) {
- final Throwable xth = xany.getCause();
- Assert.assertEquals(NullPointerException.class, xth.getClass());
- }
+ /** create a named test */
+ public ExceptionTest() {
+ super("ExceptionTest");
}
- @Test
- public void testWrappedExmore() throws Exception {
- final JexlEngine jexl = new Engine();
- final ThrowNPE npe = new ThrowNPE();
- try {
- final Object r = jexl.getProperty(npe, "foo");
- Assert.fail("Should have thrown JexlException.Property");
- } catch (final JexlException.Property xany) {
- final Throwable xth = xany.getCause();
- Assert.assertNull(xth);
- }
- try {
- jexl.setProperty(npe, "foo", 42);
- Assert.fail("Should have thrown JexlException.Property");
- } catch (final JexlException.Property xany) {
- final Throwable xth = xany.getCause();
- Assert.assertNull(xth);
- }
-
- final boolean b = (Boolean) jexl.getProperty(npe, "fail");
- Assert.assertFalse(b);
+ private void doTest206(final String src, final boolean strict, final boolean silent) throws Exception {
+ final CaptureLog l = new CaptureLog();
+ final JexlContext jc = new MapContext();
+ final JexlEngine jexl = new JexlBuilder().logger(l).strict(strict).silent(silent).create();
+ JexlScript e;
+ Object r = -1;
+ e = jexl.createScript(src);
try {
- jexl.setProperty(npe, "fail", false);
- jexl.setProperty(npe, "fail", true);
- Assert.fail("Should have thrown JexlException.Property");
- } catch (final JexlException.Property xany) {
- final Throwable xth = xany.getCause();
- Assert.assertEquals(NullPointerException.class, xth.getClass());
+ r = e.execute(jc);
+ if (strict && !silent) {
+ Assert.fail("should have thrown an exception");
+ }
+ } catch (final JexlException xjexl) {
+ if (!strict || silent) {
+ Assert.fail(src + ": should not have thrown an exception");
+ }
}
- try {
- jexl.getProperty(npe, "fail");
- Assert.fail("Should have thrown JexlException.Property");
- } catch (final JexlException.Property xany) {
- final Throwable xth = xany.getCause();
- Assert.assertEquals(NullPointerException.class, xth.getClass());
+ if (strict) {
+ if (silent && l.count("warn") == 0) {
+ Assert.fail(src + ": should have generated a warning");
+ }
+ } else {
+ if (l.count("debug") == 0) {
+ Assert.fail(src + ": should have generated a debug");
+ }
+ Assert.assertEquals(42, r);
}
+ }
- try {
- jexl.invokeMethod(npe, "foo", 42);
- Assert.fail("Should have thrown JexlException.Method");
- } catch (final JexlException.Method xany) {
- final Throwable xth = xany.getCause();
- Assert.assertNull(xth);
- }
- try {
- jexl.invokeMethod(npe, "npe");
- Assert.fail("Should have thrown NullPointerException");
- } catch (final JexlException.Method xany) {
- final Throwable xth = xany.getCause();
- Assert.assertEquals(NullPointerException.class, xth.getClass());
- }
+ @Test
+ public void test206() throws Exception {
+ String src = "null.1 = 2; return 42";
+ doTest206(src, false, false);
+ doTest206(src, false, true);
+ doTest206(src, true, false);
+ doTest206(src, true, true);
+ src = "x = null.1; return 42";
+ doTest206(src, false, false);
+ doTest206(src, false, true);
+ doTest206(src, true, false);
+ doTest206(src, true, true);
+ src = "x = y.1; return 42";
+ doTest206(src, false, false);
+ doTest206(src, false, true);
+ doTest206(src, true, false);
+ doTest206(src, true, true);
}
// Unknown vars and properties versus null operands
@@ -171,6 +152,38 @@ public class ExceptionTest extends JexlTestCase {
}
}
+ // Unknown vars and properties versus null operands
+ @Test
+ public void testExMethod() throws Exception {
+ final JexlEngine jexl = createEngine(false);
+ final JexlExpression e = jexl.createExpression("c.e.foo()");
+ final JexlEvalContext ctxt = new JexlEvalContext();
+ final JexlOptions options = ctxt.getEngineOptions();
+ // ensure errors will throw
+ options.setSilent(false);
+ // make unknown vars throw
+ options.setStrict(true);
+ // empty cotext
+ try {
+ /* Object o = */ e.evaluate(ctxt);
+ Assert.fail("c not declared as variable should throw");
+ } catch (final JexlException.Variable xjexl) {
+ final String msg = xjexl.getMessage();
+ Assert.assertTrue(msg.indexOf("variable 'c.e'") > 0);
+ }
+
+ // disallow null operands
+ options.setStrictArithmetic(true);
+ ctxt.set("c.e", null);
+ try {
+ /* Object o = */ e.evaluate(ctxt);
+ Assert.fail("c.e as null operand should throw");
+ } catch (final JexlException xjexl) {
+ final String msg = xjexl.getMessage();
+ Assert.assertTrue(msg.indexOf("variable 'c.e'") > 0);
+ }
+ }
+
// null local vars and strict arithmetic effects
@Test
public void testExVar() throws Exception {
@@ -201,82 +214,69 @@ public class ExceptionTest extends JexlTestCase {
}
}
- // Unknown vars and properties versus null operands
@Test
- public void testExMethod() throws Exception {
- final JexlEngine jexl = createEngine(false);
- final JexlExpression e = jexl.createExpression("c.e.foo()");
- final JexlEvalContext ctxt = new JexlEvalContext();
- final JexlOptions options = ctxt.getEngineOptions();
- // ensure errors will throw
- options.setSilent(false);
- // make unknown vars throw
- options.setStrict(true);
- // empty cotext
+ public void testWrappedEx() throws Exception {
+ final JexlEngine jexl = new Engine();
+ final JexlExpression e = jexl.createExpression("npe()");
+ final JexlContext jc = new ObjectContext<>(jexl, new ThrowNPE());
try {
- /* Object o = */ e.evaluate(ctxt);
- Assert.fail("c not declared as variable should throw");
- } catch (final JexlException.Variable xjexl) {
- final String msg = xjexl.getMessage();
- Assert.assertTrue(msg.indexOf("variable 'c.e'") > 0);
+ e.evaluate(jc);
+ Assert.fail("Should have thrown NPE");
+ } catch (final JexlException xany) {
+ final Throwable xth = xany.getCause();
+ Assert.assertEquals(NullPointerException.class, xth.getClass());
+ }
+ }
+ @Test
+ public void testWrappedExmore() throws Exception {
+ final JexlEngine jexl = new Engine();
+ final ThrowNPE npe = new ThrowNPE();
+ try {
+ final Object r = jexl.getProperty(npe, "foo");
+ Assert.fail("Should have thrown JexlException.Property");
+ } catch (final JexlException.Property xany) {
+ final Throwable xth = xany.getCause();
+ Assert.assertNull(xth);
+ }
+ try {
+ jexl.setProperty(npe, "foo", 42);
+ Assert.fail("Should have thrown JexlException.Property");
+ } catch (final JexlException.Property xany) {
+ final Throwable xth = xany.getCause();
+ Assert.assertNull(xth);
}
- // disallow null operands
- options.setStrictArithmetic(true);
- ctxt.set("c.e", null);
+ final boolean b = (Boolean) jexl.getProperty(npe, "fail");
+ Assert.assertFalse(b);
try {
- /* Object o = */ e.evaluate(ctxt);
- Assert.fail("c.e as null operand should throw");
- } catch (final JexlException xjexl) {
- final String msg = xjexl.getMessage();
- Assert.assertTrue(msg.indexOf("variable 'c.e'") > 0);
+ jexl.setProperty(npe, "fail", false);
+ jexl.setProperty(npe, "fail", true);
+ Assert.fail("Should have thrown JexlException.Property");
+ } catch (final JexlException.Property xany) {
+ final Throwable xth = xany.getCause();
+ Assert.assertEquals(NullPointerException.class, xth.getClass());
+ }
+ try {
+ jexl.getProperty(npe, "fail");
+ Assert.fail("Should have thrown JexlException.Property");
+ } catch (final JexlException.Property xany) {
+ final Throwable xth = xany.getCause();
+ Assert.assertEquals(NullPointerException.class, xth.getClass());
}
- }
- @Test
- public void test206() throws Exception {
- String src = "null.1 = 2; return 42";
- doTest206(src, false, false);
- doTest206(src, false, true);
- doTest206(src, true, false);
- doTest206(src, true, true);
- src = "x = null.1; return 42";
- doTest206(src, false, false);
- doTest206(src, false, true);
- doTest206(src, true, false);
- doTest206(src, true, true);
- src = "x = y.1; return 42";
- doTest206(src, false, false);
- doTest206(src, false, true);
- doTest206(src, true, false);
- doTest206(src, true, true);
- }
- private void doTest206(final String src, final boolean strict, final boolean silent) throws Exception {
- final CaptureLog l = new CaptureLog();
- final JexlContext jc = new MapContext();
- final JexlEngine jexl = new JexlBuilder().logger(l).strict(strict).silent(silent).create();
- JexlScript e;
- Object r = -1;
- e = jexl.createScript(src);
try {
- r = e.execute(jc);
- if (strict && !silent) {
- Assert.fail("should have thrown an exception");
- }
- } catch (final JexlException xjexl) {
- if (!strict || silent) {
- Assert.fail(src + ": should not have thrown an exception");
- }
+ jexl.invokeMethod(npe, "foo", 42);
+ Assert.fail("Should have thrown JexlException.Method");
+ } catch (final JexlException.Method xany) {
+ final Throwable xth = xany.getCause();
+ Assert.assertNull(xth);
}
- if (strict) {
- if (silent && l.count("warn") == 0) {
- Assert.fail(src + ": should have generated a warning");
- }
- } else {
- if (l.count("debug") == 0) {
- Assert.fail(src + ": should have generated a debug");
- }
- Assert.assertEquals(42, r);
+ try {
+ jexl.invokeMethod(npe, "npe");
+ Assert.fail("Should have thrown NullPointerException");
+ } catch (final JexlException.Method xany) {
+ final Throwable xth = xany.getCause();
+ Assert.assertEquals(NullPointerException.class, xth.getClass());
}
}
}
diff --git a/src/test/java/org/apache/commons/jexl3/FeaturesTest.java b/src/test/java/org/apache/commons/jexl3/FeaturesTest.java
index c19a50fc..b05e655d 100644
--- a/src/test/java/org/apache/commons/jexl3/FeaturesTest.java
+++ b/src/test/java/org/apache/commons/jexl3/FeaturesTest.java
@@ -38,6 +38,16 @@ public class FeaturesTest extends JexlTestCase {
super("FeaturesTest");
}
+ private void assertOk(final JexlFeatures features, final String[] scripts) {
+ for(final String str : scripts) {
+ try {
+ final JexlScript e = jexl.createScript(str);
+ } catch (final JexlException.Feature xfeature) {
+ Assert.fail(str + " :: should not fail parse: " + xfeature.getMessage());
+ }
+ }
+ }
+
/**
* Checks that the script is valid with all features on then verifies it
* throws a feature exception with the given set (in features param).
@@ -59,35 +69,188 @@ public class FeaturesTest extends JexlTestCase {
}
}
- private void assertOk(final JexlFeatures features, final String[] scripts) {
- for(final String str : scripts) {
- try {
- final JexlScript e = jexl.createScript(str);
- } catch (final JexlException.Feature xfeature) {
- Assert.fail(str + " :: should not fail parse: " + xfeature.getMessage());
- }
+ @Test
+ public void test410a() {
+ long x = JexlFeatures.createAll().getFlags();
+ Assert.assertEquals(CONST_CAPTURE + 1, Long.bitCount(x));
+ Assert.assertTrue((x & (1L << CONST_CAPTURE)) != 0);
+
+ JexlFeatures all = JexlFeatures.createAll();
+ final JexlEngine jexl = new JexlBuilder().features(all).create();
+ JexlScript script = jexl.createScript("#0 * #1", "#0", "#1");
+ Object r = script.execute(null, 6, 7);
+ Assert.assertEquals(42, r);
+ }
+
+ @Test
+ public void test410b() {
+ JexlFeatures features = JexlFeatures.createScript();
+ Assert.assertTrue(features.isLexical());
+ Assert.assertTrue(features.isLexicalShade());
+ Assert.assertTrue(features.supportsConstCapture());
+ //features.pragmaAnywhere(false);
+ Assert.assertFalse(features.supportsPragmaAnywhere());
+ //features.comparatorNames(false);
+ Assert.assertFalse(features.supportsComparatorNames());
+
+ final JexlEngine jexl = new JexlBuilder().features(features).create();
+ Collection<String> reserved = features.getReservedNames();
+ for(String varName : reserved) {
+ String src = "var " + varName;
+ //JexlScript script = jexl.createScript(src);
+ Assert.assertThrows(JexlException.Feature.class, () -> jexl.createScript(src));
+ }
+ final String[] cmpNameScripts = {
+ "1 eq 1",
+ "2 ne 3",
+ "1 lt 2",
+ "3 le 3",
+ "4 gt 2",
+ "3 ge 2"
+ };
+ for(String src : cmpNameScripts) {
+ Assert.assertThrows(JexlException.Ambiguous.class, () -> jexl.createScript(src));
}
}
@Test
- public void testNoScript() throws Exception {
- final JexlFeatures f = new JexlFeatures().script(false);
+ public void testAnnotations() throws Exception {
+ final JexlFeatures f = new JexlFeatures().annotation(false);
+ final String[] scripts = {
+ "@synchronized(2) { return 42; }",
+ "@two var x = 3;"
+ };
+ checkFeature(f, scripts);
+ }
+
+ @Test
+ public void testArrayRefs() throws Exception {
+ final JexlFeatures f = new JexlFeatures().arrayReferenceExpr(false);
+
+ final String[] scripts = {
+ "x[y]",
+ "x['a'][b]",
+ "x()['a'][b]",
+ "x.y['a'][b]"
+ };
+ checkFeature(f, scripts);
+ assertOk(f, scripts);
+ // same ones with constant array refs should work
+ final String[] scriptsOk = {
+ "x['y']",
+ "x['a'][1]",
+ "x()['a']['b']",
+ "x.y['a']['b']"
+ };
+ assertOk(f, scriptsOk);
+ }
+
+ @Test
+ public void testConstCapture() throws Exception {
+ final JexlFeatures f = new JexlFeatures().constCapture(true);
+ final String[] scripts = {
+ "let x = 0; const f = y -> x += y; f(42)",
+ "let x = 0; function f(y) { z -> x *= y }; f(42)"
+ };
+ checkFeature(f, scripts);
+ final JexlFeatures nof = new JexlFeatures().constCapture(true);
+ assertOk(nof, scripts);
+ }
+
+ @Test
+ public void testCreate() {
+ final JexlFeatures f = JexlFeatures.createNone();
Assert.assertTrue(f.supportsExpression());
+
+ Assert.assertFalse(f.supportsAnnotation());
+ Assert.assertFalse(f.supportsArrayReferenceExpr());
+ Assert.assertFalse(f.supportsComparatorNames());
+ Assert.assertFalse(f.supportsFatArrow());
+ Assert.assertFalse(f.supportsImportPragma());
+ Assert.assertFalse(f.supportsLambda());
+ Assert.assertFalse(f.supportsLocalVar());
+ Assert.assertFalse(f.supportsLoops());
+ Assert.assertFalse(f.supportsMethodCall());
+ Assert.assertFalse(f.supportsNamespacePragma());
+ Assert.assertFalse(f.supportsNewInstance());
+ Assert.assertFalse(f.supportsPragma());
+ Assert.assertFalse(f.supportsPragmaAnywhere());
+ Assert.assertFalse(f.supportsScript());
+ Assert.assertFalse(f.supportsStructuredLiteral());
+
+ Assert.assertFalse(f.isLexical());
+ Assert.assertFalse(f.isLexicalShade());
+ Assert.assertFalse(f.supportsConstCapture());
+
+ JexlEngine jnof = new JexlBuilder().features(f).create();
+ Assert.assertThrows(JexlException.Feature.class, ()->jnof.createScript("{ 3 + 4 }"));
+ Assert.assertNotNull(jnof.createExpression("3 + 4"));
+ }
+
+ @Test
+ public void testIssue409() {
+ final JexlFeatures baseFeatures = JexlFeatures.createDefault();
+ Assert.assertFalse(baseFeatures.isLexical());
+ Assert.assertFalse(baseFeatures.isLexicalShade());
+ Assert.assertFalse(baseFeatures.supportsConstCapture());
+
+ final JexlFeatures scriptFeatures = JexlFeatures.createScript();
+ Assert.assertTrue(scriptFeatures.isLexical());
+ Assert.assertTrue(scriptFeatures.isLexicalShade());
+ scriptFeatures.lexical(false);
+ Assert.assertFalse(scriptFeatures.isLexical());
+ Assert.assertFalse(scriptFeatures.isLexicalShade());
+ }
+
+ @Test
+ public void testMethodCalls() throws Exception {
+ final JexlFeatures f = new JexlFeatures().methodCall(false);
final String[] scripts = {
- "if (false) { block(); }",
- "{ noway(); }",
- "while(true);",
- "for(var i : {0 .. 10}) { bar(i); }"
+ "x.y(z)",
+ "x['a'].m(b)",
+ "x()['a'](b)",
+ "x.y['a'](b)"
};
checkFeature(f, scripts);
+ // same ones with constant array refs should work
+ final String[] scriptsOk = {
+ "x('y')",
+ "x('a')[1]",
+ "x()['a']['b']",
+ };
+ assertOk(f, scriptsOk);
}
@Test
- public void testNoLoop() throws Exception {
- final JexlFeatures f = new JexlFeatures().loops(false);
+ public void testMixedFeatures() throws Exception {
+ // no new, no local, no lambda, no loops, no-side effects
+ final JexlFeatures f = new JexlFeatures()
+ .newInstance(false)
+ .localVar(false)
+ .lambda(false)
+ .loops(false)
+ .sideEffectGlobal(false);
final String[] scripts = {
- "while(true);",
- "for(var i : {0 .. 10}) { bar(i); }"
+ "return new(clazz);",
+ "()->{ return 0 };",
+ "var x = 0;",
+ "(x, y)->{ return 0 };",
+ "for(var i : {0 .. 10}) { bar(i); }",
+ "x += 1",
+ "x.y += 1"
+ };
+ checkFeature(f, scripts);
+ }
+ @Test
+ public void testNoComparatorNames() throws Exception {
+ final JexlFeatures f = new JexlFeatures().comparatorNames(false);
+ final String[] scripts = {
+ "1 eq 1",
+ "2 ne 3",
+ "1 lt 2",
+ "3 le 3",
+ "4 gt 2",
+ "3 ge 2"
};
checkFeature(f, scripts);
}
@@ -106,6 +269,26 @@ public class FeaturesTest extends JexlTestCase {
checkFeature(f, scripts);
}
+ @Test
+ public void testNoLocals() throws Exception {
+ final JexlFeatures f = new JexlFeatures().localVar(false);
+ final String[] scripts = {
+ "var x = 0;",
+ "(x)->{ x }"
+ };
+ checkFeature(f, scripts);
+ }
+
+
+ @Test
+ public void testNoLoop() throws Exception {
+ final JexlFeatures f = new JexlFeatures().loops(false);
+ final String[] scripts = {
+ "while(true);",
+ "for(var i : {0 .. 10}) { bar(i); }"
+ };
+ checkFeature(f, scripts);
+ }
@Test
public void testNoNew() throws Exception {
final JexlFeatures f = new JexlFeatures().newInstance(false);
@@ -116,6 +299,19 @@ public class FeaturesTest extends JexlTestCase {
checkFeature(f, scripts);
}
+ @Test
+ public void testNoScript() throws Exception {
+ final JexlFeatures f = new JexlFeatures().script(false);
+ Assert.assertTrue(f.supportsExpression());
+ final String[] scripts = {
+ "if (false) { block(); }",
+ "{ noway(); }",
+ "while(true);",
+ "for(var i : {0 .. 10}) { bar(i); }"
+ };
+ checkFeature(f, scripts);
+ }
+
@Test
public void testNoSideEffects() throws Exception {
final JexlFeatures f = new JexlFeatures().sideEffect(false);
@@ -172,11 +368,20 @@ public class FeaturesTest extends JexlTestCase {
}
@Test
- public void testNoLocals() throws Exception {
- final JexlFeatures f = new JexlFeatures().localVar(false);
+ public void testPragma() throws Exception {
+ final JexlFeatures f = new JexlFeatures().pragma(false);
final String[] scripts = {
- "var x = 0;",
- "(x)->{ x }"
+ "#pragma foo 42",
+ "#pragma foo 'bar'\n@two var x = 3;"
+ };
+ checkFeature(f, scripts);
+ }
+
+ @Test
+ public void testPragmaAnywhere() throws Exception {
+ final JexlFeatures f = new JexlFeatures().pragmaAnywhere(false);
+ final String[] scripts = {
+ "var x = 3;\n#pragma foo 42",
};
checkFeature(f, scripts);
}
@@ -198,46 +403,6 @@ public class FeaturesTest extends JexlTestCase {
assertOk(f, scriptsOk);
}
- @Test
- public void testArrayRefs() throws Exception {
- final JexlFeatures f = new JexlFeatures().arrayReferenceExpr(false);
-
- final String[] scripts = {
- "x[y]",
- "x['a'][b]",
- "x()['a'][b]",
- "x.y['a'][b]"
- };
- checkFeature(f, scripts);
- assertOk(f, scripts);
- // same ones with constant array refs should work
- final String[] scriptsOk = {
- "x['y']",
- "x['a'][1]",
- "x()['a']['b']",
- "x.y['a']['b']"
- };
- assertOk(f, scriptsOk);
- }
- @Test
- public void testMethodCalls() throws Exception {
- final JexlFeatures f = new JexlFeatures().methodCall(false);
- final String[] scripts = {
- "x.y(z)",
- "x['a'].m(b)",
- "x()['a'](b)",
- "x.y['a'](b)"
- };
- checkFeature(f, scripts);
- // same ones with constant array refs should work
- final String[] scriptsOk = {
- "x('y')",
- "x('a')[1]",
- "x()['a']['b']",
- };
- assertOk(f, scriptsOk);
- }
-
@Test
public void testStructuredLiterals() throws Exception {
final JexlFeatures f = new JexlFeatures().structuredLiteral(false);
@@ -250,169 +415,4 @@ public class FeaturesTest extends JexlTestCase {
checkFeature(f, scripts);
assertOk(f, scripts);
}
-
- @Test
- public void testAnnotations() throws Exception {
- final JexlFeatures f = new JexlFeatures().annotation(false);
- final String[] scripts = {
- "@synchronized(2) { return 42; }",
- "@two var x = 3;"
- };
- checkFeature(f, scripts);
- }
-
-
- @Test
- public void testPragma() throws Exception {
- final JexlFeatures f = new JexlFeatures().pragma(false);
- final String[] scripts = {
- "#pragma foo 42",
- "#pragma foo 'bar'\n@two var x = 3;"
- };
- checkFeature(f, scripts);
- }
- @Test
- public void testPragmaAnywhere() throws Exception {
- final JexlFeatures f = new JexlFeatures().pragmaAnywhere(false);
- final String[] scripts = {
- "var x = 3;\n#pragma foo 42",
- };
- checkFeature(f, scripts);
- }
-
- @Test
- public void testMixedFeatures() throws Exception {
- // no new, no local, no lambda, no loops, no-side effects
- final JexlFeatures f = new JexlFeatures()
- .newInstance(false)
- .localVar(false)
- .lambda(false)
- .loops(false)
- .sideEffectGlobal(false);
- final String[] scripts = {
- "return new(clazz);",
- "()->{ return 0 };",
- "var x = 0;",
- "(x, y)->{ return 0 };",
- "for(var i : {0 .. 10}) { bar(i); }",
- "x += 1",
- "x.y += 1"
- };
- checkFeature(f, scripts);
- }
-
- @Test
- public void testNoComparatorNames() throws Exception {
- final JexlFeatures f = new JexlFeatures().comparatorNames(false);
- final String[] scripts = {
- "1 eq 1",
- "2 ne 3",
- "1 lt 2",
- "3 le 3",
- "4 gt 2",
- "3 ge 2"
- };
- checkFeature(f, scripts);
- }
-
- @Test
- public void testConstCapture() throws Exception {
- final JexlFeatures f = new JexlFeatures().constCapture(true);
- final String[] scripts = {
- "let x = 0; const f = y -> x += y; f(42)",
- "let x = 0; function f(y) { z -> x *= y }; f(42)"
- };
- checkFeature(f, scripts);
- final JexlFeatures nof = new JexlFeatures().constCapture(true);
- assertOk(nof, scripts);
- }
-
- @Test
- public void testIssue409() {
- final JexlFeatures baseFeatures = JexlFeatures.createDefault();
- Assert.assertFalse(baseFeatures.isLexical());
- Assert.assertFalse(baseFeatures.isLexicalShade());
- Assert.assertFalse(baseFeatures.supportsConstCapture());
-
- final JexlFeatures scriptFeatures = JexlFeatures.createScript();
- Assert.assertTrue(scriptFeatures.isLexical());
- Assert.assertTrue(scriptFeatures.isLexicalShade());
- scriptFeatures.lexical(false);
- Assert.assertFalse(scriptFeatures.isLexical());
- Assert.assertFalse(scriptFeatures.isLexicalShade());
- }
-
- @Test
- public void testCreate() {
- final JexlFeatures f = JexlFeatures.createNone();
- Assert.assertTrue(f.supportsExpression());
-
- Assert.assertFalse(f.supportsAnnotation());
- Assert.assertFalse(f.supportsArrayReferenceExpr());
- Assert.assertFalse(f.supportsComparatorNames());
- Assert.assertFalse(f.supportsFatArrow());
- Assert.assertFalse(f.supportsImportPragma());
- Assert.assertFalse(f.supportsLambda());
- Assert.assertFalse(f.supportsLocalVar());
- Assert.assertFalse(f.supportsLoops());
- Assert.assertFalse(f.supportsMethodCall());
- Assert.assertFalse(f.supportsNamespacePragma());
- Assert.assertFalse(f.supportsNewInstance());
- Assert.assertFalse(f.supportsPragma());
- Assert.assertFalse(f.supportsPragmaAnywhere());
- Assert.assertFalse(f.supportsScript());
- Assert.assertFalse(f.supportsStructuredLiteral());
-
- Assert.assertFalse(f.isLexical());
- Assert.assertFalse(f.isLexicalShade());
- Assert.assertFalse(f.supportsConstCapture());
-
- JexlEngine jnof = new JexlBuilder().features(f).create();
- Assert.assertThrows(JexlException.Feature.class, ()->jnof.createScript("{ 3 + 4 }"));
- Assert.assertNotNull(jnof.createExpression("3 + 4"));
- }
-
- @Test
- public void test410a() {
- long x = JexlFeatures.createAll().getFlags();
- Assert.assertEquals(CONST_CAPTURE + 1, Long.bitCount(x));
- Assert.assertTrue((x & (1L << CONST_CAPTURE)) != 0);
-
- JexlFeatures all = JexlFeatures.createAll();
- final JexlEngine jexl = new JexlBuilder().features(all).create();
- JexlScript script = jexl.createScript("#0 * #1", "#0", "#1");
- Object r = script.execute(null, 6, 7);
- Assert.assertEquals(42, r);
- }
-
- @Test
- public void test410b() {
- JexlFeatures features = JexlFeatures.createScript();
- Assert.assertTrue(features.isLexical());
- Assert.assertTrue(features.isLexicalShade());
- Assert.assertTrue(features.supportsConstCapture());
- //features.pragmaAnywhere(false);
- Assert.assertFalse(features.supportsPragmaAnywhere());
- //features.comparatorNames(false);
- Assert.assertFalse(features.supportsComparatorNames());
-
- final JexlEngine jexl = new JexlBuilder().features(features).create();
- Collection<String> reserved = features.getReservedNames();
- for(String varName : reserved) {
- String src = "var " + varName;
- //JexlScript script = jexl.createScript(src);
- Assert.assertThrows(JexlException.Feature.class, () -> jexl.createScript(src));
- }
- final String[] cmpNameScripts = {
- "1 eq 1",
- "2 ne 3",
- "1 lt 2",
- "3 le 3",
- "4 gt 2",
- "3 ge 2"
- };
- for(String src : cmpNameScripts) {
- Assert.assertThrows(JexlException.Ambiguous.class, () -> jexl.createScript(src));
- }
- }
}
diff --git a/src/test/java/org/apache/commons/jexl3/Foo.java b/src/test/java/org/apache/commons/jexl3/Foo.java
index 3789c4a2..9f17f2d8 100644
--- a/src/test/java/org/apache/commons/jexl3/Foo.java
+++ b/src/test/java/org/apache/commons/jexl3/Foo.java
@@ -27,45 +27,38 @@ import java.util.List;
*/
public class Foo {
- private boolean beenModified;
- private String property1 = "some value";
- public Foo() {}
public class Cheezy {
public Iterator<String> iterator() {
return getCheeseList().iterator();
}
}
+ private boolean beenModified;
+ private String property1 = "some value";
+ public Foo() {}
public String bar()
{
return JexlTest.METHOD_STRING;
}
- public String getBar()
+ public String convertBoolean(final boolean b)
{
- return JexlTest.GET_METHOD_STRING;
+ return "Boolean : " + b;
}
- public Foo getInnerFoo()
+ public String[] getArray()
{
- return new Foo();
- }
-
- public String getQuux() {
- return "String : quux";
- }
-
- public String repeat(final String str) {
- return "Repeat : " + str;
+ return ArrayAccessTest.GET_METHOD_ARRAY;
}
- public String convertBoolean(final boolean b)
+ public String[][] getArray2()
{
- return "Boolean : " + b;
+ return ArrayAccessTest.GET_METHOD_ARRAY2;
}
- public int getCount() {
- return 5;
+ public String getBar()
+ {
+ return JexlTest.GET_METHOD_STRING;
}
public List<String> getCheeseList()
@@ -82,24 +75,31 @@ public class Foo {
return new Cheezy();
}
- public String[] getArray()
- {
- return ArrayAccessTest.GET_METHOD_ARRAY;
+ public int getCount() {
+ return 5;
}
- public String[][] getArray2()
+ public Foo getInnerFoo()
{
- return ArrayAccessTest.GET_METHOD_ARRAY2;
+ return new Foo();
}
- public boolean isSimple()
+ public boolean getModified()
{
- return true;
+ return beenModified;
}
- public int square(final int value)
+ public String getProperty1() {
+ return property1;
+ }
+
+ public String getQuux() {
+ return "String : quux";
+ }
+
+ public int getSize()
{
- return value * value;
+ return 22;
}
public boolean getTrueAndModify()
@@ -108,22 +108,22 @@ public class Foo {
return true;
}
- public boolean getModified()
+ public boolean isSimple()
{
- return beenModified;
+ return true;
}
- public int getSize()
- {
- return 22;
- }
-
- public String getProperty1() {
- return property1;
+ public String repeat(final String str) {
+ return "Repeat : " + str;
}
public void setProperty1(final String newValue) {
property1 = newValue;
}
+
+ public int square(final int value)
+ {
+ return value * value;
+ }
}
diff --git a/src/test/java/org/apache/commons/jexl3/ForEachTest.java b/src/test/java/org/apache/commons/jexl3/ForEachTest.java
index ae4ee2dd..ab7ef64f 100644
--- a/src/test/java/org/apache/commons/jexl3/ForEachTest.java
+++ b/src/test/java/org/apache/commons/jexl3/ForEachTest.java
@@ -38,48 +38,48 @@ public class ForEachTest extends JexlTestCase {
super("ForEachTest");
}
- @Test public void testForLoop0b0() {
- final String src = "(l)->{ for(let x = 0, y = 0; x < 4; ++x) l.add(x) }";
- final JexlEngine jexl = new JexlBuilder().safe(false).create();
- final JexlScript script = jexl.createScript(src);
- final List<Integer> l = new ArrayList<>();
- final Object result = script.execute(null, l);
- Assert.assertNotNull(result);
- Assert.assertEquals(Arrays.asList(0, 1, 2, 3), l);
- final String resrc = toString(script);
- Assert.assertEquals(src, resrc);
- }
-
- @Test public void testForLoop0a() {
- final String src = "(l)->{ for(let x = 0; x < 4; ++x) { l.add(x); } }";
- final JexlEngine jexl = new JexlBuilder().safe(false).create();
- final JexlScript script = jexl.createScript(src);
- final List<Integer> l = new ArrayList<>();
- final Object result = script.execute(null, l);
- Assert.assertNotNull(result);
- Assert.assertEquals(Arrays.asList(0, 1, 2, 3), l);
- final String resrc = toString(script);
- Assert.assertEquals(src, resrc);
+ @Test
+ public void testForEachBreakBroken() throws Exception {
+ try {
+ final JexlScript e = JEXL.createScript("if (true) { break; }");
+ Assert.fail("break is out of loop!");
+ } catch (final JexlException.Parsing xparse) {
+ final String str = xparse.detailedMessage();
+ Assert.assertTrue(str.contains("break"));
+ }
}
@Test
- public void testForEachWithEmptyStatement() throws Exception {
- final JexlScript e = JEXL.createScript("for(item : list) ;");
+ public void testForEachBreakMethod() throws Exception {
+ final JexlScript e = JEXL.createScript(
+ "var rr = -1; for(var item : [1, 2, 3 ,4 ,5, 6]) { if (item == 3) { rr = item; break; }} rr"
+ );
final JexlContext jc = new MapContext();
- jc.set("list", Collections.emptyList());
-
+ jc.set("list", new Foo());
final Object o = e.execute(jc);
- Assert.assertNull("Result is not null", o);
+ Assert.assertEquals("Result is not last evaluated expression", 3, o);
}
@Test
- public void testForEachWithEmptyList() throws Exception {
- final JexlScript e = JEXL.createScript("for(item : list) 1+1");
- final JexlContext jc = new MapContext();
- jc.set("list", Collections.emptyList());
+ public void testForEachContinueBroken() throws Exception {
+ try {
+ final JexlScript e = JEXL.createScript("var rr = 0; continue;");
+ Assert.fail("continue is out of loop!");
+ } catch (final JexlException.Parsing xparse) {
+ final String str = xparse.detailedMessage();
+ Assert.assertTrue(str.contains("continue"));
+ }
+ }
+ @Test
+ public void testForEachContinueMethod() throws Exception {
+ final JexlScript e = JEXL.createScript(
+ "var rr = 0; for(var item : [1, 2, 3 ,4 ,5, 6]) { if (item <= 3) continue; rr = rr + item;}"
+ );
+ final JexlContext jc = new MapContext();
+ jc.set("list", new Foo());
final Object o = e.execute(jc);
- Assert.assertNull("Result is not null", o);
+ Assert.assertEquals("Result is not last evaluated expression", 15, o);
}
@Test
@@ -91,6 +91,17 @@ public class ForEachTest extends JexlTestCase {
Assert.assertEquals("Result is not last evaluated expression", "World", o);
}
+ @Test
+ public void testForEachWithBlock() throws Exception {
+ final JexlScript exs0 = JEXL.createScript("for(var in : list) { x = x + in; }");
+ final JexlContext jc = new MapContext();
+ jc.set("list", new Object[]{2, 3});
+ jc.set("x", Integer.valueOf(1));
+ final Object o = exs0.execute(jc);
+ Assert.assertEquals("Result is wrong", Integer.valueOf(6), o);
+ Assert.assertEquals("x is wrong", Integer.valueOf(6), jc.get("x"));
+ }
+
@Test
public void testForEachWithCollection() throws Exception {
final JexlScript e = JEXL.createScript("for(var item : list) item");
@@ -100,6 +111,26 @@ public class ForEachTest extends JexlTestCase {
Assert.assertEquals("Result is not last evaluated expression", "World", o);
}
+ @Test
+ public void testForEachWithEmptyList() throws Exception {
+ final JexlScript e = JEXL.createScript("for(item : list) 1+1");
+ final JexlContext jc = new MapContext();
+ jc.set("list", Collections.emptyList());
+
+ final Object o = e.execute(jc);
+ Assert.assertNull("Result is not null", o);
+ }
+
+ @Test
+ public void testForEachWithEmptyStatement() throws Exception {
+ final JexlScript e = JEXL.createScript("for(item : list) ;");
+ final JexlContext jc = new MapContext();
+ jc.set("list", Collections.emptyList());
+
+ final Object o = e.execute(jc);
+ Assert.assertNull("Result is not null", o);
+ }
+
@Test
public void testForEachWithEnumeration() throws Exception {
final JexlScript e = JEXL.createScript("for(var item : list) item");
@@ -119,27 +150,14 @@ public class ForEachTest extends JexlTestCase {
}
@Test
- public void testForEachWithMap() throws Exception {
- final JexlScript e = JEXL.createScript("for(item : list) item");
+ public void testForEachWithIteratorMethod() throws Exception {
+ final JexlScript e = JEXL.createScript("for(var item : list.cheezy) item");
final JexlContext jc = new MapContext();
- final Map<?, ?> map = System.getProperties();
- final String lastProperty = (String) new ArrayList<Object>(map.values()).get(System.getProperties().size() - 1);
- jc.set("list", map);
+ jc.set("list", new Foo());
final Object o = e.execute(jc);
- Assert.assertEquals("Result is not last evaluated expression", lastProperty, o);
+ Assert.assertEquals("Result is not last evaluated expression", "brie", o);
}
- @Test
- public void testForEachWithBlock() throws Exception {
- final JexlScript exs0 = JEXL.createScript("for(var in : list) { x = x + in; }");
- final JexlContext jc = new MapContext();
- jc.set("list", new Object[]{2, 3});
- jc.set("x", Integer.valueOf(1));
- final Object o = exs0.execute(jc);
- Assert.assertEquals("Result is wrong", Integer.valueOf(6), o);
- Assert.assertEquals("x is wrong", Integer.valueOf(6), jc.get("x"));
- }
-
@Test
public void testForEachWithListExpression() throws Exception {
final JexlScript e = JEXL.createScript("for(var item : list.keySet()) item");
@@ -152,64 +170,46 @@ public class ForEachTest extends JexlTestCase {
}
@Test
- public void testForEachWithProperty() throws Exception {
- final JexlScript e = JEXL.createScript("for(var item : list.cheeseList) item");
+ public void testForEachWithMap() throws Exception {
+ final JexlScript e = JEXL.createScript("for(item : list) item");
final JexlContext jc = new MapContext();
- jc.set("list", new Foo());
+ final Map<?, ?> map = System.getProperties();
+ final String lastProperty = (String) new ArrayList<Object>(map.values()).get(System.getProperties().size() - 1);
+ jc.set("list", map);
final Object o = e.execute(jc);
- Assert.assertEquals("Result is not last evaluated expression", "brie", o);
+ Assert.assertEquals("Result is not last evaluated expression", lastProperty, o);
}
@Test
- public void testForEachWithIteratorMethod() throws Exception {
- final JexlScript e = JEXL.createScript("for(var item : list.cheezy) item");
+ public void testForEachWithProperty() throws Exception {
+ final JexlScript e = JEXL.createScript("for(var item : list.cheeseList) item");
final JexlContext jc = new MapContext();
jc.set("list", new Foo());
final Object o = e.execute(jc);
Assert.assertEquals("Result is not last evaluated expression", "brie", o);
}
- @Test
- public void testForEachBreakMethod() throws Exception {
- final JexlScript e = JEXL.createScript(
- "var rr = -1; for(var item : [1, 2, 3 ,4 ,5, 6]) { if (item == 3) { rr = item; break; }} rr"
- );
- final JexlContext jc = new MapContext();
- jc.set("list", new Foo());
- final Object o = e.execute(jc);
- Assert.assertEquals("Result is not last evaluated expression", 3, o);
- }
-
- @Test
- public void testForEachContinueMethod() throws Exception {
- final JexlScript e = JEXL.createScript(
- "var rr = 0; for(var item : [1, 2, 3 ,4 ,5, 6]) { if (item <= 3) continue; rr = rr + item;}"
- );
- final JexlContext jc = new MapContext();
- jc.set("list", new Foo());
- final Object o = e.execute(jc);
- Assert.assertEquals("Result is not last evaluated expression", 15, o);
- }
-
- @Test
- public void testForEachContinueBroken() throws Exception {
- try {
- final JexlScript e = JEXL.createScript("var rr = 0; continue;");
- Assert.fail("continue is out of loop!");
- } catch (final JexlException.Parsing xparse) {
- final String str = xparse.detailedMessage();
- Assert.assertTrue(str.contains("continue"));
- }
+ @Test public void testForLoop0a() {
+ final String src = "(l)->{ for(let x = 0; x < 4; ++x) { l.add(x); } }";
+ final JexlEngine jexl = new JexlBuilder().safe(false).create();
+ final JexlScript script = jexl.createScript(src);
+ final List<Integer> l = new ArrayList<>();
+ final Object result = script.execute(null, l);
+ Assert.assertNotNull(result);
+ Assert.assertEquals(Arrays.asList(0, 1, 2, 3), l);
+ final String resrc = toString(script);
+ Assert.assertEquals(src, resrc);
}
- @Test
- public void testForEachBreakBroken() throws Exception {
- try {
- final JexlScript e = JEXL.createScript("if (true) { break; }");
- Assert.fail("break is out of loop!");
- } catch (final JexlException.Parsing xparse) {
- final String str = xparse.detailedMessage();
- Assert.assertTrue(str.contains("break"));
- }
+ @Test public void testForLoop0b0() {
+ final String src = "(l)->{ for(let x = 0, y = 0; x < 4; ++x) l.add(x) }";
+ final JexlEngine jexl = new JexlBuilder().safe(false).create();
+ final JexlScript script = jexl.createScript(src);
+ final List<Integer> l = new ArrayList<>();
+ final Object result = script.execute(null, l);
+ Assert.assertNotNull(result);
+ Assert.assertEquals(Arrays.asList(0, 1, 2, 3), l);
+ final String resrc = toString(script);
+ Assert.assertEquals(src, resrc);
}
}
diff --git a/src/test/java/org/apache/commons/jexl3/IfTest.java b/src/test/java/org/apache/commons/jexl3/IfTest.java
index c0b76aef..b65ce1f4 100644
--- a/src/test/java/org/apache/commons/jexl3/IfTest.java
+++ b/src/test/java/org/apache/commons/jexl3/IfTest.java
@@ -30,62 +30,6 @@ public class IfTest extends JexlTestCase {
super("IfTest");
}
- /**
- * Make sure if true executes the true statement
- *
- * @throws Exception on any error
- */
- @Test
- public void testSimpleIfTrue() throws Exception {
- final JexlScript e = JEXL.createScript("if (true) 1");
- final JexlContext jc = new MapContext();
-
- final Object o = e.execute(jc);
- Assert.assertEquals("Result is not 1", Integer.valueOf(1), o);
- }
-
- /**
- * Make sure if false doesn't execute the true statement
- *
- * @throws Exception on any error
- */
- @Test
- public void testSimpleIfFalse() throws Exception {
- final JexlScript e = JEXL.createScript("if (false) 1");
- final JexlContext jc = new MapContext();
-
- final Object o = e.execute(jc);
- Assert.assertNull("Return value is not empty", o);
- }
-
- /**
- * Make sure if false executes the false statement
- *
- * @throws Exception on any error
- */
- @Test
- public void testSimpleElse() throws Exception {
- final JexlScript e = JEXL.createScript("if (false) 1 else 2;");
- final JexlContext jc = new MapContext();
-
- final Object o = e.execute(jc);
- Assert.assertEquals("Result is not 2", Integer.valueOf(2), o);
- }
-
- /**
- * Test the if statement handles blocks correctly
- *
- * @throws Exception on any error
- */
- @Test
- public void testBlockIfTrue() throws Exception {
- final JexlScript e = JEXL.createScript("if (true) { 'hello'; }");
- final JexlContext jc = new MapContext();
-
- final Object o = e.execute(jc);
- Assert.assertEquals("Result is wrong", "hello", o);
- }
-
/**
* Test the if statement handles blocks in the else statement correctly
*
@@ -101,18 +45,17 @@ public class IfTest extends JexlTestCase {
}
/**
- * Test the if statement evaluates expressions correctly
+ * Test the if statement handles blocks correctly
*
* @throws Exception on any error
*/
@Test
- public void testIfWithSimpleExpression() throws Exception {
- final JexlScript e = JEXL.createScript("if (x == 1) true;");
+ public void testBlockIfTrue() throws Exception {
+ final JexlScript e = JEXL.createScript("if (true) { 'hello'; }");
final JexlContext jc = new MapContext();
- jc.set("x", Integer.valueOf(1));
final Object o = e.execute(jc);
- Assert.assertEquals("Result is not true", Boolean.TRUE, o);
+ Assert.assertEquals("Result is wrong", "hello", o);
}
@Test
@@ -127,9 +70,9 @@ public class IfTest extends JexlTestCase {
}
@Test
- public void testIfElseIfReturnExpression0() throws Exception {
+ public void testIfElseIfReturnExpression() throws Exception {
final JexlScript e = JEXL.createScript(
- "if (x == 1) return 10; if (x == 2) return 20; else if (x == 3) return 30 else { return 40 }",
+ "if (x == 1) return 10; if (x == 2) return 20 else if (x == 3) return 30; else return 40;",
"x");
Object o = e.execute(null, 1);
Assert.assertEquals(10, o);
@@ -142,9 +85,9 @@ public class IfTest extends JexlTestCase {
}
@Test
- public void testIfElseIfReturnExpression() throws Exception {
+ public void testIfElseIfReturnExpression0() throws Exception {
final JexlScript e = JEXL.createScript(
- "if (x == 1) return 10; if (x == 2) return 20 else if (x == 3) return 30; else return 40;",
+ "if (x == 1) return 10; if (x == 2) return 20; else if (x == 3) return 30 else { return 40 }",
"x");
Object o = e.execute(null, 1);
Assert.assertEquals(10, o);
@@ -171,6 +114,22 @@ public class IfTest extends JexlTestCase {
Assert.assertEquals("Result is not true", Boolean.TRUE, o);
}
+ /**
+ * Test the if statement works with assignment
+ *
+ * @throws Exception on any error
+ */
+ @Test
+ public void testIfWithAssignment() throws Exception {
+ final JexlScript e = JEXL.createScript("if ((x * 2) == 5) {y = 1} else {y = 2;}");
+ final JexlContext jc = new MapContext();
+ jc.set("x", Float.valueOf(2.5f));
+
+ e.execute(jc);
+ final Object result = jc.get("y");
+ Assert.assertEquals("y has the wrong value", Integer.valueOf(1), result);
+ }
+
/**
* Test the if statement evaluates decimal arithmetic expressions correctly
*
@@ -187,19 +146,98 @@ public class IfTest extends JexlTestCase {
}
/**
- * Test the if statement works with assignment
+ * Test the if statement evaluates expressions correctly
*
* @throws Exception on any error
*/
@Test
- public void testIfWithAssignment() throws Exception {
- final JexlScript e = JEXL.createScript("if ((x * 2) == 5) {y = 1} else {y = 2;}");
+ public void testIfWithSimpleExpression() throws Exception {
+ final JexlScript e = JEXL.createScript("if (x == 1) true;");
final JexlContext jc = new MapContext();
- jc.set("x", Float.valueOf(2.5f));
+ jc.set("x", Integer.valueOf(1));
- e.execute(jc);
- final Object result = jc.get("y");
- Assert.assertEquals("y has the wrong value", Integer.valueOf(1), result);
+ final Object o = e.execute(jc);
+ Assert.assertEquals("Result is not true", Boolean.TRUE, o);
+ }
+
+ @Test
+ public void testNullCoaelescing() throws Exception {
+ Object o;
+ final JexlEvalContext jc = new JexlEvalContext();
+ final JexlExpression xtrue = JEXL.createExpression("x??true");
+ o = xtrue.evaluate(jc);
+ Assert.assertEquals("Should be true", true, o);
+ jc.set("x", false);
+ o = xtrue.evaluate(jc);
+ Assert.assertEquals("Should be false", false, o);
+ final JexlExpression yone = JEXL.createExpression("y??1");
+ o = yone.evaluate(jc);
+ Assert.assertEquals("Should be 1", 1, o);
+ jc.set("y", 0);
+ o = yone.evaluate(jc);
+ Assert.assertEquals("Should be 0", 0, o);
+ debuggerCheck(JEXL);
+ }
+
+ @Test
+ public void testNullCoaelescingScript() throws Exception {
+ Object o;
+ final JexlEvalContext jc = new JexlEvalContext();
+ final JexlScript xtrue = JEXL.createScript("x??true");
+ o = xtrue.execute(jc);
+ Assert.assertEquals("Should be true", true, o);
+ jc.set("x", false);
+ o = xtrue.execute(jc);
+ Assert.assertEquals("Should be false", false, o);
+ final JexlScript yone = JEXL.createScript("y??1");
+ o = yone.execute(jc);
+ Assert.assertEquals("Should be 1", 1, o);
+ jc.set("y", 0);
+ o = yone.execute(jc);
+ Assert.assertEquals("Should be 0", 0, o);
+ debuggerCheck(JEXL);
+ }
+
+ /**
+ * Make sure if false executes the false statement
+ *
+ * @throws Exception on any error
+ */
+ @Test
+ public void testSimpleElse() throws Exception {
+ final JexlScript e = JEXL.createScript("if (false) 1 else 2;");
+ final JexlContext jc = new MapContext();
+
+ final Object o = e.execute(jc);
+ Assert.assertEquals("Result is not 2", Integer.valueOf(2), o);
+ }
+
+ /**
+ * Make sure if false doesn't execute the true statement
+ *
+ * @throws Exception on any error
+ */
+ @Test
+ public void testSimpleIfFalse() throws Exception {
+ final JexlScript e = JEXL.createScript("if (false) 1");
+ final JexlContext jc = new MapContext();
+
+ final Object o = e.execute(jc);
+ Assert.assertNull("Return value is not empty", o);
+ }
+
+ /**
+ * Make sure if true executes the true statement
+ *
+ * @throws Exception on any error
+ */
+ @Test
+ public void testSimpleIfTrue() throws Exception {
+ final JexlScript e = JEXL.createScript("if (true) 1");
+ final JexlContext jc = new MapContext();
+
+ final Object o = e.execute(jc);
+ Assert.assertEquals("Result is not 1", Integer.valueOf(1), o);
}
/**
@@ -262,6 +300,24 @@ public class IfTest extends JexlTestCase {
debuggerCheck(jexl);
}
+ @Test
+ public void testTernaryFail() throws Exception {
+ final JexlEvalContext jc = new JexlEvalContext();
+ final JexlOptions options = jc.getEngineOptions();
+ final JexlExpression e = JEXL.createExpression("false ? bar : quux");
+ Object o;
+ options.setStrict(true);
+ options.setSilent(false);
+ try {
... 18852 lines suppressed ...