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 &amp; 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 &amp; 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 ...