Add unit tests for KotlinNullabilityDetector

rhino-kotlin/build.gradle

@@ -1,10 +1,17 @@
 plugins {
     id 'rhino.library-conventions'
+    id 'org.jetbrains.kotlin.jvm'
 }
 
 dependencies {
     implementation project(':rhino')
     implementation "org.jetbrains.kotlin:kotlin-metadata-jvm:2.1.0"
+
+    testImplementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8:2.1.0"
+}
+
+kotlin {
+    jvmToolchain(11)
 }
 
 publishing {

rhino-kotlin/src/test/java/org/mozilla/kotlin/JavaClass.java

@@ -0,0 +1,15 @@
+package org.mozilla.kotlin;
+
+public class JavaClass {
+    private final String property1;
+    private final String property2;
+
+    public JavaClass(String param1, String param2) {
+        property1 = param1;
+        property2 = param2;
+    }
+
+    public void function(Integer param1, Long param2) {
+        // Do nothing
+    }
+}

rhino-kotlin/src/test/java/org/mozilla/kotlin/KotlinClass.kt

@@ -0,0 +1,14 @@
+package org.mozilla.kotlin
+
+class KotlinClass(
+    val nonNullProperty: String,
+    val nullableProperty: String?
+) {
+    fun function(nullableParam: Int?, nonNullParam: Int, anotherNullableParam: KotlinClass?) {
+        // Do nothing
+    }
+
+    fun function(nonNullParam: Int, anotherNonNullParam: Int) {
+        // Do nothing
+    }
+}

rhino-kotlin/src/test/java/org/mozilla/kotlin/KotlinClassWithOverloadedFunction.kt

@@ -0,0 +1,11 @@
+package org.mozilla.kotlin
+
+class KotlinClassWithOverloadedFunction {
+    fun function(nullableParam: Int?, nonNullParam: Int, anotherNullableParam: KotlinClass?) {
+        // Do nothing
+    }
+
+    fun function(nullableParam: Int?, nonNullParam: Int, anotherNonNullParam: String) {
+        // Do nothing
+    }
+}

rhino-kotlin/src/test/java/org/mozilla/kotlin/KotlinNullabilityDetectorTest.java

@@ -0,0 +1,89 @@
+package org.mozilla.kotlin;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Method;
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+import org.junit.Test;
+
+public class KotlinNullabilityDetectorTest {
+    private final KotlinNullabilityDetector detector = new KotlinNullabilityDetector();
+
+    @Test
+    public void testKotlinFunction() {
+        boolean[] nullability =
+                detector.getParameterNullability(findMethod(KotlinClass.class, "function", 3));
+
+        boolean[] expectedNullability = new boolean[] {true, false, true};
+        assertThat(nullability, is(expectedNullability));
+    }
+
+    @Test
+    public void testKotlinConstructor() {
+        boolean[] nullability =
+                detector.getParameterNullability(findConstructor(KotlinClass.class, 2));
+
+        boolean[] expectedNullability = new boolean[] {false, true};
+        assertThat(nullability, is(expectedNullability));
+    }
+
+    @Test
+    public void testJavaFunction() {
+        boolean[] nullability =
+                detector.getParameterNullability(findMethod(JavaClass.class, "function", 2));
+
+        boolean[] expectedNullability = new boolean[] {false, false};
+        assertThat(nullability, is(expectedNullability));
+    }
+
+    @Test
+    public void testJavaConstructor() {
+        boolean[] nullability =
+                detector.getParameterNullability(findConstructor(JavaClass.class, 2));
+
+        boolean[] expectedNullability = new boolean[] {false, false};
+        assertThat(nullability, is(expectedNullability));
+    }
+
+    @Test
+    public void testKotlinOverloadedFunction() {
+        List<Method> overloadedMethods =
+                findMethods(KotlinClassWithOverloadedFunction.class, "function");
+
+        assertThat(overloadedMethods.size(), is(2));
+        // Since we cannot distinguish overloads with same number of params, we have to fallback to
+        // no-op
+        boolean[] expectedNullability = new boolean[] {false, false, false};
+        overloadedMethods.forEach(
+                method ->
+                        assertThat(
+                                detector.getParameterNullability(method), is(expectedNullability)));
+    }
+
+    private Method findMethod(Class<?> clazz, String methodName, int paramCount) {
+        return Arrays.stream(clazz.getMethods())
+                .filter(
+                        method ->
+                                method.getName().equals(methodName)
+                                        && method.getParameterTypes().length == paramCount)
+                .findFirst()
+                .orElse(null);
+    }
+
+    private Constructor<?> findConstructor(Class<?> clazz, int paramCount) {
+        return Arrays.stream(clazz.getConstructors())
+                .filter(constructor -> constructor.getParameterTypes().length == paramCount)
+                .findFirst()
+                .orElse(null);
+    }
+
+    private List<Method> findMethods(Class<?> clazz, String methodName) {
+        return Arrays.stream(clazz.getMethods())
+                .filter(method -> method.getName().equals(methodName))
+                .collect(Collectors.toList());
+    }
+}

settings.gradle

@@ -1,3 +1,7 @@
+plugins {
+    id 'org.gradle.toolchains.foojay-resolver-convention' version '0.8.0'
+    id 'org.jetbrains.kotlin.jvm' version '2.1.0' apply false
+}
 rootProject.name = 'rhino-root'
 include 'rhino', 'rhino-engine', 'rhino-tools', 'rhino-xml', 'rhino-all', 'examples', 'testutils', 'tests', 'benchmarks'
 include 'rhino-kotlin'