Merge boxWithJava testData into box, delete BoxWithJava test

2016-03-07 16:54:45 +03:00
parent 16a0ddd2fb
commit f8dfaf4599
117 changed files with 723 additions and 815 deletions
@@ -0,0 +1,29 @@
+// WITH_REFLECT
+// FILE: J.java
+
+@Anno("J")
+public class J {
+    @Anno("foo")
+    public static int foo = 42;
+
+    @Anno("bar")
+    public static void bar() {}
+
+    @Anno("constructor")
+    public J() {}
+}
+
+// FILE: K.kt
+
+import kotlin.test.assertEquals
+
+annotation class Anno(val value: String)
+
+fun box(): String {
+    assertEquals("[@Anno(value=J)]", J::class.annotations.toString())
+    assertEquals("[@Anno(value=foo)]", J::foo.annotations.toString())
+    assertEquals("[@Anno(value=bar)]", J::bar.annotations.toString())
+    assertEquals("[@Anno(value=constructor)]", ::J.annotations.toString())
+
+    return "OK"
+}
@@ -0,0 +1,32 @@
+// WITH_REFLECT
+// FILE: J.java
+
+public class J {
+    private final int param;
+
+    public J(int param) {
+        this.param = param;
+    }
+
+    public String foo(int[] arr, Object[] arr2, Integer y) {
+        return "" + param + arr[0] + arr2[0] + y;
+    }
+}
+
+// FILE: K.kt
+
+import kotlin.reflect.jvm.*
+import kotlin.test.assertEquals
+
+fun box(): String {
+    val f = J::foo
+    assertEquals(
+            listOf(J::class.java, IntArray::class.java, Array<Any>::class.java, Integer::class.java),
+            f.parameters.map { it.type.javaType }
+    )
+    assertEquals(String::class.java, f.returnType.javaType)
+
+    assertEquals("01A2", f.call(J(0), intArrayOf(1), arrayOf("A"), 2))
+
+    return "OK"
+}
@@ -0,0 +1,37 @@
+// WITH_REFLECT
+// FILE: J.java
+
+public class J {
+    private final String result;
+
+    private J(String result) {
+        this.result = result;
+    }
+
+    private String getResult() {
+        return result;
+    }
+}
+
+// FILE: K.kt
+
+import kotlin.reflect.*
+import kotlin.reflect.jvm.*
+import kotlin.test.*
+
+fun box(): String {
+    val c = J::class.constructors.single()
+    assertFalse(c.isAccessible)
+    assertFailsWith(IllegalCallableAccessException::class) { c.call("") }
+
+    c.isAccessible = true
+    assertTrue(c.isAccessible)
+    val j = c.call("OK")
+
+    val m = J::class.members.single { it.name == "getResult" }
+    assertFalse(m.isAccessible)
+    assertFailsWith(IllegalCallableAccessException::class) { m.call(j)!! }
+
+    m.isAccessible = true
+    return m.call(j) as String
+}
@@ -0,0 +1,23 @@
+// WITH_REFLECT
+// FILE: J.java
+
+public class J {
+    public static String foo(int x, int[] arr, Object[] arr2) {
+        return "" + x + arr[0] + arr2[0];
+    }
+}
+
+// FILE: K.kt
+
+import kotlin.reflect.jvm.*
+import kotlin.test.assertEquals
+
+fun box(): String {
+    val f = J::foo
+    assertEquals(listOf(Integer.TYPE, IntArray::class.java, Array<Any>::class.java), f.parameters.map { it.type.javaType })
+    assertEquals(String::class.java, f.returnType.javaType)
+
+    assertEquals("01A", f.call(0, intArrayOf(1), arrayOf("A")))
+
+    return "OK"
+}
@@ -0,0 +1,23 @@
+// WITH_REFLECT
+// FILE: J.java
+
+public class J {
+    public class Inner {}
+
+    public static class Nested {}
+
+    private static class PrivateNested {}
+
+    // This anonymous class should not appear in 'nestedClasses'
+    private final Object o = new Object() {};
+}
+
+// FILE: K.kt
+
+import kotlin.test.assertEquals
+
+fun box(): String {
+    assertEquals(listOf("Inner", "Nested", "PrivateNested"), J::class.nestedClasses.map { it.simpleName!! }.sorted())
+
+    return "OK"
+}
@@ -0,0 +1,77 @@
+// WITH_REFLECT
+// FILE: J.java
+
+public class J {
+    public void publicMemberJ() {}
+    private void privateMemberJ() {}
+    public static void publicStaticJ() {}
+    private static void privateStaticJ() {}
+}
+
+// FILE: K.kt
+
+import kotlin.reflect.*
+import kotlin.test.assertEquals
+
+open class K : J() {
+    public fun publicMemberK() {}
+    private fun privateMemberK() {}
+    public fun Any.publicMemberExtensionK() {}
+    private fun Any.privateMemberExtensionK() {}
+}
+
+class L : K()
+
+fun Collection<KFunction<*>>.names(): Set<String> =
+        this.map { it.name }.toSet()
+
+fun check(c: Collection<KFunction<*>>, names: Set<String>) {
+    assertEquals(names, c.names())
+}
+
+fun box(): String {
+    val any = setOf("equals", "hashCode", "toString")
+
+    val j = J::class
+
+    check(j.staticFunctions,
+          setOf("publicStaticJ", "privateStaticJ"))
+    check(j.declaredFunctions,
+          setOf("publicMemberJ", "privateMemberJ", "publicStaticJ", "privateStaticJ"))
+    check(j.declaredMemberFunctions,
+          setOf("publicMemberJ", "privateMemberJ"))
+    check(j.declaredMemberExtensionFunctions,
+          emptySet())
+
+    check(j.functions, any + j.declaredFunctions.names())
+    check(j.memberFunctions, any + j.declaredMemberFunctions.names())
+    check(j.memberExtensionFunctions, emptySet())
+
+    val k = K::class
+
+    check(k.staticFunctions,
+          emptySet())
+    check(k.declaredFunctions,
+          setOf("publicMemberK", "privateMemberK", "publicMemberExtensionK", "privateMemberExtensionK"))
+    check(k.declaredMemberFunctions,
+          setOf("publicMemberK", "privateMemberK"))
+    check(k.declaredMemberExtensionFunctions,
+          setOf("publicMemberExtensionK", "privateMemberExtensionK"))
+
+    check(k.memberFunctions, any + setOf("publicMemberJ") + k.declaredMemberFunctions.names())
+    check(k.memberExtensionFunctions, k.declaredMemberExtensionFunctions.names())
+    check(k.functions, any + (k.memberFunctions + k.memberExtensionFunctions).names())
+
+
+    val l = L::class
+
+    check(l.staticFunctions, emptySet())
+    check(l.declaredFunctions, emptySet())
+    check(l.declaredMemberFunctions, emptySet())
+    check(l.declaredMemberExtensionFunctions, emptySet())
+    check(l.memberFunctions, any + setOf("publicMemberJ", "publicMemberK"))
+    check(l.memberExtensionFunctions, setOf("publicMemberExtensionK"))
+    check(l.functions, any + (l.memberFunctions + l.memberExtensionFunctions).names())
+
+    return "OK"
+}
@@ -0,0 +1,29 @@
+// WITH_REFLECT
+// FILE: J.java
+
+import kotlin.jvm.functions.Function2;
+import kotlin.reflect.KFunction;
+
+public class J {
+    public static String go() {
+        KFunction<String> fun = K.Companion.getRef();
+        Object result = ((Function2) fun).invoke(new K(), "KO");
+        return (String) result;
+    }
+}
+
+// FILE: K.kt
+
+class K {
+    fun reverse(s: String): String {
+        return s.reversed()
+    }
+
+    companion object {
+        fun getRef() = K::reverse
+    }
+}
+
+fun box(): String {
+    return J.go()
+}
@@ -0,0 +1,28 @@
+// WITH_REFLECT
+// FILE: J.java
+
+public class J {
+    public J() {
+    }
+
+    public void member(String s) {
+    }
+
+    public static void staticMethod(int x) {
+    }
+}
+
+// FILE: K.kt
+
+import kotlin.reflect.*
+import kotlin.test.assertEquals
+
+fun box(): String {
+    assertEquals(listOf("equals", "hashCode", "member", "staticMethod", "toString"), J::class.members.map { it.name }.sorted())
+    assertEquals(listOf("equals", "hashCode", "member", "staticMethod", "toString"), J::class.functions.map { it.name }.sorted())
+    assertEquals(listOf("member", "staticMethod"), J::class.declaredFunctions.map { it.name }.sorted())
+
+    assertEquals(1, J::class.constructors.size)
+
+    return "OK"
+}
@@ -0,0 +1,48 @@
+// WITH_REFLECT
+// FILE: J.java
+
+import java.util.List;
+
+public class J {
+    void simple() {}
+
+    void objectTypes(
+            Object o, String s, Object[] oo, String[] ss
+    ) {}
+
+    void primitives(
+            boolean z, char c, byte b, short s, int i, float f, long j, double d
+    ) {}
+
+    void primitiveArrays(
+            boolean[] z, char[] c, byte[] b, short[] s, int[] i, float[] f, long[] j, double[] d
+    ) {}
+
+    void multiDimensionalArrays(
+            int[][][] i, Cloneable[][][][] c
+    ) {}
+
+    void wildcards(
+            List<? extends Number> l, List<? super Cloneable> m
+    ) {}
+}
+
+// FILE: K.kt
+
+import kotlin.reflect.KFunction
+
+// Initiate descriptor computation in reflection to ensure that nothing fails
+fun test(f: KFunction<*>) {
+    f.parameters
+}
+
+fun box(): String {
+    test(J::simple)
+    test(J::objectTypes)
+    test(J::primitives)
+    test(J::primitiveArrays)
+    test(J::multiDimensionalArrays)
+    test(J::wildcards)
+
+    return "OK"
+}
@@ -0,0 +1,23 @@
+// WITH_RUNTIME
+// FILE: Test.java
+
+class O {}
+class K {}
+
+@Ann(args={O.class, K.class})
+class Test {
+}
+
+// FILE: array.kt
+
+import kotlin.reflect.KClass
+
+@Retention(AnnotationRetention.RUNTIME)
+annotation class Ann(val args: Array<KClass<*>>)
+
+fun box(): String {
+    val args = Test::class.java.getAnnotation(Ann::class.java).args
+    val argName1 = args[0].java.simpleName ?: "fail 1"
+    val argName2 = args[1].java.simpleName ?: "fail 2"
+    return argName1 + argName2
+}
@@ -0,0 +1,20 @@
+// WITH_RUNTIME
+// FILE: Test.java
+
+class OK {}
+
+@Ann(arg=OK.class)
+class Test {
+}
+
+// FILE: basic.kt
+
+import kotlin.reflect.KClass
+
+@Retention(AnnotationRetention.RUNTIME)
+annotation class Ann(val arg: KClass<*>)
+
+fun box(): String {
+    val argName = Test::class.java.getAnnotation(Ann::class.java).arg.java.simpleName ?: "fail 1"
+    return argName
+}
@@ -0,0 +1,23 @@
+// WITH_RUNTIME
+// FILE: Test.java
+
+class O {}
+class K {}
+
+@Ann(args={O.class, K.class})
+class Test {
+}
+
+// FILE: vararg.kt
+
+import kotlin.reflect.KClass
+
+@Retention(AnnotationRetention.RUNTIME)
+annotation class Ann(vararg val args: KClass<*>)
+
+fun box(): String {
+    val args = Test::class.java.getAnnotation(Ann::class.java).args
+    val argName1 = args[0].java.simpleName ?: "fail 1"
+    val argName2 = args[1].java.simpleName ?: "fail 2"
+    return argName1 + argName2
+}
@@ -0,0 +1,19 @@
+// WITH_REFLECT
+// FILE: J.java
+
+public class J {
+    void foo(String s, int i) {}
+
+    static void bar(J j) {}
+}
+
+// FILE: K.kt
+
+import kotlin.test.assertEquals
+
+fun box(): String {
+    assertEquals(listOf(null, null, null), J::foo.parameters.map { it.name })
+    assertEquals(listOf(null), J::bar.parameters.map { it.name })
+
+    return "OK"
+}
@@ -0,0 +1,67 @@
+// WITH_REFLECT
+// FILE: J.java
+
+public class J {
+    public String publicMemberJ;
+    private String privateMemberJ;
+    public static String publicStaticJ;
+    private static String privateStaticJ;
+}
+
+// FILE: K.kt
+
+import kotlin.reflect.*
+import kotlin.test.assertEquals
+
+open class K : J() {
+    public val publicMemberK: String = ""
+    private val privateMemberK: String = ""
+    public val Any.publicMemberExtensionK: String get() = ""
+    private val Any.privateMemberExtensionK: String get() = ""
+}
+
+class L : K()
+
+fun Collection<KProperty<*>>.names(): Set<String> =
+        this.map { it.name }.toSet()
+
+fun check(c: Collection<KProperty<*>>, names: Set<String>) {
+    assertEquals(names, c.names())
+}
+
+fun box(): String {
+    val j = J::class
+
+    check(j.staticProperties,
+          setOf("publicStaticJ", "privateStaticJ"))
+    check(j.declaredMemberProperties,
+          setOf("publicMemberJ", "privateMemberJ"))
+    check(j.declaredMemberExtensionProperties,
+          emptySet())
+
+    check(j.memberProperties, j.declaredMemberProperties.names())
+    check(j.memberExtensionProperties, emptySet())
+
+    val k = K::class
+
+    check(k.staticProperties,
+          emptySet())
+    check(k.declaredMemberProperties,
+          setOf("publicMemberK", "privateMemberK"))
+    check(k.declaredMemberExtensionProperties,
+          setOf("publicMemberExtensionK", "privateMemberExtensionK"))
+
+    check(k.memberProperties, setOf("publicMemberJ") + k.declaredMemberProperties.names())
+    check(k.memberExtensionProperties, k.declaredMemberExtensionProperties.names())
+
+
+    val l = L::class
+
+    check(l.staticProperties, emptySet())
+    check(l.declaredMemberProperties, emptySet())
+    check(l.declaredMemberExtensionProperties, emptySet())
+    check(l.memberProperties, setOf("publicMemberJ", "publicMemberK"))
+    check(l.memberExtensionProperties, setOf("publicMemberExtensionK"))
+
+    return "OK"
+}
@@ -0,0 +1,17 @@
+// FILE: J.java
+
+public class J {
+    public String result = null;
+}
+
+// FILE: K.kt
+
+class K : J()
+
+fun box(): String {
+    val k = K()
+    val p = K::result
+    if (p.get(k) != null) return "Fail"
+    p.set(k, "OK")
+    return p.get(k)
+}
@@ -0,0 +1,23 @@
+// WITH_REFLECT
+// FILE: J.java
+
+public class J {
+    static String x;
+}
+
+// FILE: K.kt
+
+import kotlin.test.assertEquals
+
+fun box(): String {
+    val f = J::x
+    assertEquals("x", f.name)
+
+    assertEquals(f, J::class.members.single { it.name == "x" })
+
+    f.set("OK")
+    assertEquals("OK", J.x)
+    assertEquals("OK", f.getter())
+
+    return f.get()
+}
@@ -0,0 +1,49 @@
+// WITH_REFLECT
+// FILE: J.java
+
+public class J extends K {
+}
+
+// FILE: K.kt
+
+import kotlin.reflect.*
+import kotlin.reflect.jvm.*
+
+public open class K {
+    var prop: String = ":("
+
+    val Int.ext: Int get() = this
+}
+
+fun box(): String {
+    val j = J()
+
+    val prop = J::prop
+    if (prop !is KMutableProperty1<*, *>) return "Fail instanceof"
+    if (prop.name != "prop") return "Fail name: ${prop.name}"
+    if (prop.get(j) != ":(") return "Fail get before: ${prop.get(j)}"
+    prop.set(j, ":)")
+    if (prop.get(j) != ":)") return "Fail get after: ${prop.get(j)}"
+
+
+    if (prop == K::prop) return "Fail J::prop == K::prop (these are different properties)"
+
+
+    val klass = J::class.java.kotlin
+    if (klass.declaredMemberProperties.isNotEmpty()) return "Fail: declaredMemberProperties should be empty"
+    if (klass.declaredMemberExtensionProperties.isNotEmpty()) return "Fail: declaredMemberExtensionProperties should be empty"
+
+    val prop2 = klass.memberProperties.firstOrNull { it.name == "prop" } ?: "Fail: no 'prop' property in memberProperties"
+    if (prop != prop2) return "Fail: property references from :: and from properties differ: $prop != $prop2"
+    if (prop2 !is KMutableProperty1<*, *>) return "Fail instanceof 2"
+    (prop2 as KMutableProperty1<J, String>).set(j, "::)")
+    if (prop.get(j) != "::)") return "Fail get after 2: ${prop.get(j)}"
+
+
+    val ext = klass.memberExtensionProperties.firstOrNull { it.name == "ext" } ?: "Fail: no 'ext' property in memberExtensionProperties"
+    ext as KProperty2<J, Int, Int>
+    val fortyTwo = ext.get(j, 42)
+    if (fortyTwo != 42) return "Fail ext get: $fortyTwo"
+
+    return "OK"
+}
@@ -0,0 +1,19 @@
+// WITH_REFLECT
+// FILE: J.java
+
+public class J {
+    private String result = "Fail";
+}
+
+// FILE: K.kt
+
+import kotlin.reflect.*
+import kotlin.reflect.jvm.*
+
+fun box(): String {
+    val a = J()
+    val p = J::class.members.single { it.name == "result" } as KMutableProperty1<J, String>
+    p.isAccessible = true
+    p.set(a, "OK")
+    return p.get(a)
+}
@@ -0,0 +1,19 @@
+// WITH_REFLECT
+// FILE: J.java
+
+public class J {
+    private static String result = "Fail";
+}
+
+// FILE: K.kt
+
+import kotlin.reflect.*
+import kotlin.reflect.jvm.*
+
+fun box(): String {
+    val a = J()
+    val p = J::class.members.single { it.name == "result" } as KMutableProperty0<String>
+    p.isAccessible = true
+    p.set("OK")
+    return p.get()
+}
@@ -0,0 +1,32 @@
+// WITH_REFLECT
+// FILE: J.java
+
+public class J {
+    public String foo = "";
+}
+
+// FILE: K.kt
+
+import kotlin.test.*
+
+class K : J() {
+    fun getFoo(): String = "K"
+}
+
+fun box(): String {
+    val j = J()
+    val x = J::foo
+    x.set(j, "J")
+    assertEquals("J", x.get(j))
+
+    val k = K()
+    val y = K::foo
+    y.set(k, "K")
+    assertEquals("K", y.get(k))
+    assertEquals("K", x.get(k))
+
+    val z = K::getFoo
+    assertEquals("K", z.invoke(k))
+
+    return "OK"
+}
@@ -0,0 +1,39 @@
+// WITH_REFLECT
+// FILE: J.java
+
+public class J implements K {
+    private String foo;
+
+    @Override
+    public String getFoo() {
+        return foo;
+    }
+
+    @Override
+    public void setFoo(String s) {
+        foo = s;
+    }
+}
+
+// FILE: K.kt
+
+import kotlin.test.assertEquals
+import kotlin.reflect.KParameter
+
+interface K {
+    var foo: String
+}
+
+fun box(): String {
+    val p = J::foo
+    assertEquals("foo", p.name)
+
+    if (p.parameters.size != 1) return "Should have only 1 parameter"
+    if (p.parameters.single().kind != KParameter.Kind.INSTANCE) return "Should have an instance parameter"
+
+    if (J::class.members.none { it == p }) return "No foo in members"
+
+    val j = J()
+    p.setter.call(j, "OK")
+    return p.getter.call(j)
+}
@@ -0,0 +1,15 @@
+// FILE: J.java
+
+public class J extends K {
+    public final int value = 42;
+}
+
+// FILE: K.kt
+
+open class K
+
+fun box(): String {
+    val f = J::value
+    val a = J()
+    return if (f.get(a) == 42) "OK" else "Fail: ${f.get(a)}"
+}
@@ -0,0 +1,22 @@
+// WITH_REFLECT
+// FILE: J.java
+
+public class J {
+    public static String foo() {
+        return "";
+    }
+}
+
+// FILE: K.kt
+
+import kotlin.test.assertNotEquals
+
+fun nonNullString(): String = ""
+fun nullableString(): String? = ""
+
+fun box(): String {
+    assertNotEquals(J::foo.returnType, ::nonNullString.returnType)
+    assertNotEquals(J::foo.returnType, ::nullableString.returnType)
+
+    return "OK"
+}
@@ -0,0 +1,25 @@
+// WITH_REFLECT
+// FILE: J.java
+
+import java.util.List;
+
+public class J {
+    public static String string() {
+        return "";
+    }
+
+    public static List<Object> list() {
+        return null;
+    }
+}
+
+// FILE: K.kt
+
+import kotlin.test.assertEquals
+
+fun box(): String {
+    assertEquals("kotlin.String!", J::string.returnType.toString())
+    assertEquals("kotlin.collections.(Mutable)List<kotlin.Any!>!", J::list.returnType.toString())
+
+    return "OK"
+}