[Test] Merge box against java testdata into codegen black box testsdata

compiler/testData/codegen/reflection/classLiterals/javaClassLiteral.kt

@@ -0,0 +1,17 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// WITH_REFLECT
+// MODULE: lib
+// FILE: J.java
+
+public class J {
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+fun box(): String {
+    val j = J::class
+    if (j.simpleName != "J") return "Fail: ${j.simpleName}"
+
+    return "OK"
+}

compiler/testData/codegen/reflection/mapping/jClass2kClass.kt

@@ -0,0 +1,18 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// WITH_RUNTIME
+// MODULE: lib
+// FILE: J.java
+
+public class J {}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+import kotlin.test.assertEquals
+
+fun box(): String {
+    val j = J::class.java
+    assertEquals(j, j.kotlin.java)
+
+    return "OK"
+}

compiler/testData/codegen/reflection/mapping/javaConstructor.kt

@@ -0,0 +1,27 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// WITH_REFLECT
+// MODULE: lib
+// FILE: J.java
+
+public class J {
+    public final String result;
+
+    public J(String result) {
+        this.result = result;
+    }
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+import kotlin.reflect.*
+import kotlin.reflect.jvm.*
+
+fun box(): String {
+    val reference = ::J
+    val javaConstructor = reference.javaConstructor ?: return "Fail: no Constructor for reference"
+    val j = javaConstructor.newInstance("OK")
+    val kotlinConstructor = javaConstructor.kotlinFunction
+    if (reference != kotlinConstructor) return "Fail: reference != kotlinConstructor"
+    return j.result
+}

compiler/testData/codegen/reflection/mapping/javaFields.kt

@@ -0,0 +1,60 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// WITH_REFLECT
+// FULL_JDK
+// MODULE: lib
+// FILE: J.java
+
+public class J {
+    public final int i;
+    public String s;
+
+    public J(int i, String s) {
+        this.i = i;
+        this.s = s;
+    }
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+import java.lang.reflect.*
+import kotlin.reflect.*
+import kotlin.reflect.jvm.*
+
+fun box(): String {
+    val i = J::i
+    val s = J::s
+
+    // Check that correct reflection objects are created
+    assert(i !is KMutableProperty<*>) { "Fail i class: ${i.javaClass}" }
+    assert(s is KMutableProperty<*>) { "Fail s class: ${s.javaClass}" }
+
+    // Check that no Method objects are created for such properties
+    assert(i.javaGetter == null) { "Fail i getter" }
+    assert(s.javaGetter == null) { "Fail s getter" }
+    assert(s.javaSetter == null) { "Fail s setter" }
+
+    // Check that correct Field objects are created
+    val ji = i.javaField!!
+    val js = s.javaField!!
+    assert(Modifier.isFinal(ji.getModifiers())) { "Fail i final" }
+    assert(!Modifier.isFinal(js.getModifiers())) { "Fail s final" }
+
+    // Check that those Field objects work as expected
+    val a = J(42, "abc")
+    assert(ji.get(a) == 42) { "Fail ji get" }
+    assert(js.get(a) == "abc") { "Fail js get" }
+    js.set(a, "def")
+    assert(js.get(a) == "def") { "Fail js set" }
+    assert(a.s == "def") { "Fail js access" }
+
+    // Check that valid Kotlin reflection objects are created by those Field objects
+    val ki = ji.kotlinProperty as KProperty1<J, Int>
+    val ks = js.kotlinProperty as KMutableProperty1<J, String>
+    assert(ki.get(a) == 42) { "Fail ki get" }
+    assert(ks.get(a) == "def") { "Fail ks get" }
+    ks.set(a, "ghi")
+    assert(ks.get(a) == "ghi") { "Fail ks set" }
+
+    return "OK"
+}

compiler/testData/codegen/reflection/mapping/javaMethods.kt

@@ -0,0 +1,36 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// WITH_REFLECT
+// MODULE: lib
+// FILE: J.java
+
+public class J {
+    public String f(String s) {
+        return s;
+    }
+
+    public static String g(String s) {
+        return s;
+    }
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+import kotlin.reflect.*
+import kotlin.reflect.jvm.*
+
+fun box(): String {
+    val f = J::f
+    val fm = f.javaMethod ?: return "Fail: no Method for f"
+    if (fm.invoke(J(), "abc") != "abc") return "Fail fm"
+    val ff = fm.kotlinFunction ?: return "Fail: no KFunction for fm"
+    if (f != ff) return "Fail f != ff"
+
+    val g = J::g
+    val gm = g.javaMethod ?: return "Fail: no Method for g"
+    if (gm.invoke(null, "ghi") != "ghi") return "Fail gm"
+    val gg = gm.kotlinFunction ?: return "Fail: no KFunction for gm"
+    if (g != gg) return "Fail g != gg"
+
+    return "OK"
+}

compiler/testData/codegen/reflection/properties/equalsHashCodeToString.kt

@@ -0,0 +1,36 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// WITH_REFLECT
+// MODULE: lib
+// FILE: test/J.java
+
+package test;
+
+public class J {
+    public final boolean b;
+    public char c;
+
+    public J() {
+        this.b = false;
+        this.c = '0';
+    }
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+package test
+
+import kotlin.test.*
+
+fun box(): String {
+    assertEquals("val test.J.b: kotlin.Boolean", (J::b).toString())
+    assertEquals("var test.J.c: kotlin.Char", (J::c).toString())
+
+    assertTrue(J::b == J::b)
+    assertFalse(J::c == J::b)
+
+    assertTrue(J::b.hashCode() == J::b.hashCode())
+    assertFalse(J::b.hashCode() == J::c.hashCode())
+
+    return "OK"
+}