JEXL: added some Unit Tests
diff --git a/src/main/java/org/apache/commons/jexl3/internal/Engine.java b/src/main/java/org/apache/commons/jexl3/internal/Engine.java
index 837a66d..0dc1341 100644
--- a/src/main/java/org/apache/commons/jexl3/internal/Engine.java
+++ b/src/main/java/org/apache/commons/jexl3/internal/Engine.java
@@ -209,7 +209,7 @@
options.setMathContext(arithmetic.getMathContext());
options.setMathScale(arithmetic.getMathScale());
options.setStrictArithmetic(arithmetic.isStrict());
- this.functions = conf.namespaces() == null ? Collections.<String, Object>emptyMap() : conf.namespaces();
+ this.functions = conf.namespaces() == null ? Collections.emptyMap() : conf.namespaces();
// parsing & features:
final JexlFeatures features = conf.features() == null? DEFAULT_FEATURES : conf.features();
this.expressionFeatures = new JexlFeatures(features).script(false);
diff --git a/src/main/java/org/apache/commons/jexl3/internal/introspection/ArrayListWrapper.java b/src/main/java/org/apache/commons/jexl3/internal/introspection/ArrayListWrapper.java
index fb31742..65177ec 100644
--- a/src/main/java/org/apache/commons/jexl3/internal/introspection/ArrayListWrapper.java
+++ b/src/main/java/org/apache/commons/jexl3/internal/introspection/ArrayListWrapper.java
@@ -83,4 +83,4 @@
public boolean contains(final Object o) {
return indexOf(o) != -1;
}
-}
\ No newline at end of file
+}
diff --git a/src/main/java/org/apache/commons/jexl3/internal/introspection/Permissions.java b/src/main/java/org/apache/commons/jexl3/internal/introspection/Permissions.java
index aac052e..5cac080 100644
--- a/src/main/java/org/apache/commons/jexl3/internal/introspection/Permissions.java
+++ b/src/main/java/org/apache/commons/jexl3/internal/introspection/Permissions.java
@@ -42,7 +42,7 @@
* @return true if JEXL is allowed to introspect, false otherwise
*/
public boolean allow(final Package pack) {
- if (pack != null && pack.getAnnotation(NoJexl.class) != null) {
+ if (pack == null || pack.getAnnotation(NoJexl.class) != null) {
return false;
}
return true;
diff --git a/src/test/java/org/apache/commons/jexl3/internal/introspection/MiscIntrospectionTest.java b/src/test/java/org/apache/commons/jexl3/internal/introspection/MiscIntrospectionTest.java
new file mode 100644
index 0000000..1afafcc
--- /dev/null
+++ b/src/test/java/org/apache/commons/jexl3/internal/introspection/MiscIntrospectionTest.java
@@ -0,0 +1,201 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.commons.jexl3.internal.introspection;
+
+import org.apache.commons.jexl3.JexlEngine;
+import org.apache.commons.jexl3.annotations.NoJexl;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.NoSuchElementException;
+
+/**
+ * Checks the CacheMap.MethodKey implementation
+ */
+
+public class MiscIntrospectionTest {
+ @Test
+ public void testEmptyContext() {
+ try {
+ JexlEngine.EMPTY_CONTEXT.set("nope", 42);
+ Assert.fail("empty context should be readonly");
+ } catch(UnsupportedOperationException xun) {
+ Assert.assertNotNull(xun);
+ }
+ }
+ @Test
+ public void testArrayIterator() {
+ // not on lists
+ try {
+ new ArrayIterator(new ArrayList<>());
+ } catch(IllegalArgumentException xill) {
+ Assert.assertNotNull(xill);
+ }
+ // wih null?
+ ArrayIterator ai0 = new ArrayIterator(null);
+ Assert.assertFalse(ai0.hasNext());
+ try {
+ ai0.next();
+ Assert.fail("should have failed");
+ } catch(NoSuchElementException no) {
+ Assert.assertNotNull(no);
+ }
+ // an array
+ ai0 = new ArrayIterator(new int[]{42});
+ Assert.assertTrue(ai0.hasNext());
+ Assert.assertEquals(42, ai0.next());
+ Assert.assertFalse(ai0.hasNext());
+ try {
+ ai0.next();
+ Assert.fail("iterator on null?");
+ } catch(NoSuchElementException no) {
+ Assert.assertNotNull(no);
+ }
+ // no remove
+ try {
+ ai0.remove();
+ Assert.fail("should have failed");
+ } catch(UnsupportedOperationException no) {
+ Assert.assertNotNull(no);
+ }
+ }
+
+ @Test
+ public void testArrayListWrapper() {
+ ArrayListWrapper alw ;
+ try {
+ new ArrayListWrapper(1);
+ Assert.fail("non-array wrap?");
+ } catch(IllegalArgumentException xil) {
+ Assert.assertNotNull(xil);
+ }
+ Integer[] ai = new Integer[]{1, 2};
+ alw = new ArrayListWrapper(ai);
+ Assert.assertEquals(1, alw.indexOf(2));
+ Assert.assertEquals(-1, alw.indexOf(null));
+ }
+
+ public static class A {
+ public int i;
+ public A() {}
+ public int method() { return 0; }
+ }
+
+ @NoJexl
+ public interface InterNoJexl0 {
+ int method();
+ }
+
+ public interface InterNoJexl1 {
+ @NoJexl
+ int method();
+ }
+
+
+ public static class A0 extends A implements InterNoJexl0 {
+ @NoJexl public int i0;
+ @NoJexl public A0() {}
+ @Override public int method() { return 1; }
+ }
+
+ public static class A1 extends A implements InterNoJexl1 {
+ private int i1;
+ @NoJexl public A1() {}
+ @Override public int method() { return 2; }
+ }
+
+ @NoJexl
+ public static class A2 extends A {
+ public A2() {}
+ @Override public int method() { return 3; }
+ }
+
+ protected static class A3 {
+ protected int i3;
+ protected A3() {}
+ int method() { return 4; }
+ }
+
+ public static class A5 implements InterNoJexl5 {
+ public A5() {}
+ @Override public int method() { return 0; }
+ }
+
+ @NoJexl
+ public interface InterNoJexl5 {
+ int method();
+ }
+
+ @Test
+ public void testPermissions() throws Exception {
+ Permissions p = Permissions.DEFAULT;
+ Assert.assertFalse(p.allow((Field) null));
+ Assert.assertFalse(p.allow((Package) null));
+ Assert.assertFalse(p.allow((Method) null));
+ Assert.assertFalse(p.allow((Constructor<?>) null));
+ Assert.assertFalse(p.allow((Class<?>) null));
+
+ Assert.assertTrue(p.allow(A2.class));
+ Assert.assertFalse(p.allow(A3.class));
+ Assert.assertFalse(p.allow(A5.class));
+
+ Method mA = A.class.getMethod("method");
+ Assert.assertNotNull(mA);
+ Method mA0 = A0.class.getMethod("method");
+ Assert.assertNotNull(mA0);
+ Method mA1 = A1.class.getMethod("method");
+ Assert.assertNotNull(mA1);
+ Method mA2 = A2.class.getMethod("method");
+ Assert.assertNotNull(mA1);
+ Method mA3 = A2.class.getDeclaredMethod("method");
+ Assert.assertNotNull(mA1);
+
+ Assert.assertTrue(p.allow(mA));
+ Assert.assertFalse(p.allow(mA0));
+ Assert.assertFalse(p.allow(mA1));
+ Assert.assertFalse(p.allow(mA2));
+ Assert.assertFalse(p.allow(mA3));
+
+ Field fA = A.class.getField("i");
+ Assert.assertNotNull(fA);
+ Assert.assertTrue(p.allow(fA));
+
+ Field fA0 = A0.class.getField("i0");
+ Assert.assertNotNull(fA0);
+ Assert.assertFalse(p.allow(fA0));
+ Field fA1 = A1.class.getDeclaredField("i1");
+ Assert.assertNotNull(fA1);
+ Assert.assertFalse(p.allow(fA0));
+
+ Constructor<?> cA = A.class.getConstructor();
+ Assert.assertNotNull(cA);
+ Assert.assertTrue(p.allow(cA));
+
+ Constructor<?> cA0 = A0.class.getConstructor();
+ Assert.assertNotNull(cA0);
+ Assert.assertFalse(p.allow(cA0));
+
+ Constructor<?> cA3 = A3.class.getDeclaredConstructor();
+ Assert.assertNotNull(cA3);
+ Assert.assertFalse(p.allow(cA3));
+ }
+}
