Merge boxWithStdlib testData into box, delete BoxWithStdlib test

2016-03-07 13:36:14 +03:00
parent 22bfc9786a
commit 06a67e6602
535 changed files with 3520 additions and 3871 deletions
@@ -0,0 +1,37 @@
+// WITH_REFLECT
+
+import kotlin.reflect.*
+import kotlin.reflect.jvm.*
+
+class K {
+    class Nested
+    inner class Inner
+}
+
+class Secondary {
+    constructor(x: Int) {}
+}
+
+fun check(f: KFunction<Any>) {
+    assert(f.javaMethod == null) { "Fail f method" }
+    assert(f.javaConstructor != null) { "Fail f constructor" }
+    val c = f.javaConstructor!!
+
+    assert(c.kotlinFunction != null) { "Fail m function" }
+    val ff = c.kotlinFunction!!
+
+    assert(f == ff) { "Fail f != ff" }
+}
+
+fun box(): String {
+    check(::K)
+
+    // Workaround KT-8596
+    val nested = K::Nested
+    check(nested)
+
+    check(K::Inner)
+    check(::Secondary)
+
+    return "OK"
+}
@@ -0,0 +1,29 @@
+// WITH_REFLECT
+
+import kotlin.reflect.jvm.*
+import kotlin.test.assertEquals
+
+class K(var value: Long)
+
+var K.ext: Double
+    get() = value.toDouble()
+    set(value) {
+        this.value = value.toLong()
+    }
+
+fun box(): String {
+    val p = K::ext
+
+    val getter = p.javaGetter!!
+    val setter = p.javaSetter!!
+
+    assertEquals(getter, Class.forName("ExtensionPropertyKt").getMethod("getExt", K::class.java))
+    assertEquals(setter, Class.forName("ExtensionPropertyKt").getMethod("setExt", K::class.java, Double::class.java))
+
+    val k = K(42L)
+    assert(getter.invoke(null, k) == 42.0) { "Fail k getter" }
+    setter.invoke(null, k, -239.0)
+    assert(getter.invoke(null, k) == -239.0) { "Fail k setter" }
+
+    return "OK"
+}
@@ -0,0 +1,23 @@
+// WITH_REFLECT
+// KT-8131 Cannot find backing field in ancestor class via reflection
+
+import kotlin.reflect.*
+import kotlin.reflect.jvm.*
+
+open class TestBase {
+    var id = 0L
+}
+
+class TestChild : TestBase()
+
+fun box(): String {
+    val property = TestChild::class.memberProperties.first { it.name == "id" } as KMutableProperty<*>
+    if (property.javaField == null)
+        return "Fail: no field"
+    if (property.javaGetter == null)
+        return "Fail: no getter"
+    if (property.javaSetter == null)
+        return "Fail: no setter"
+
+    return "OK"
+}
@@ -0,0 +1,17 @@
+// WITH_REFLECT
+
+import kotlin.reflect.*
+import kotlin.reflect.jvm.*
+
+open class TestBase {
+    fun id() = 0L
+}
+
+class TestChild : TestBase()
+
+fun box(): String {
+    if (TestChild::class.memberFunctions.first { it.name == "id" }.javaMethod == null)
+        return "No method for TestChild.id()"
+
+    return "OK"
+}
@@ -0,0 +1,29 @@
+// WITH_REFLECT
+
+import kotlin.reflect.*
+import kotlin.reflect.jvm.*
+
+class K {
+    fun foo(s: String): Int = s.length
+}
+fun bar(s: String): Int = s.length
+fun String.baz(): Int = this.length
+
+fun check(f: KFunction<Int>) {
+    assert(f.javaConstructor == null) { "Fail f constructor" }
+    assert(f.javaMethod != null) { "Fail f method" }
+    val m = f.javaMethod!!
+
+    assert(m.kotlinFunction != null) { "Fail m function" }
+    val ff = m.kotlinFunction!!
+
+    assert(f == ff) { "Fail f != ff" }
+}
+
+fun box(): String {
+    check(K::foo)
+    check(::bar)
+    check(String::baz)
+
+    return "OK"
+}
@@ -0,0 +1,35 @@
+// WITH_REFLECT
+
+import kotlin.reflect.KFunction
+import kotlin.reflect.jvm.*
+import kotlin.test.*
+
+class C {
+    companion object {
+        @JvmStatic
+        fun foo(s: String): Int = s.length
+    }
+}
+
+fun box(): String {
+    val foo = C.Companion::class.members.single { it.name == "foo" } as KFunction<*>
+
+    val j = foo.javaMethod ?: return "Fail: no Java method found for C::foo"
+    assertEquals(3, j.invoke(C, "abc"))
+
+    val k = j.kotlinFunction ?: return "Fail: no Kotlin function found for Java method C::foo"
+    assertEquals(3, k.call(C, "def"))
+
+
+    val staticMethod = C::class.java.getDeclaredMethod("foo", String::class.java)
+    val k2 = staticMethod.kotlinFunction ?:
+             return "Fail: no Kotlin function found for static bridge for @JvmStatic method in companion object C::foo"
+    assertEquals(3, k2.call(C, "ghi"))
+
+    assertFailsWith(NullPointerException::class) { k2.call(null, "")!! }
+
+    val j2 = k2.javaMethod
+    assertEquals(j, j2)
+
+    return "OK"
+}
@@ -0,0 +1,22 @@
+// WITH_REFLECT
+
+import kotlin.reflect.KFunction
+import kotlin.reflect.jvm.*
+import kotlin.test.assertEquals
+
+object O {
+    @JvmStatic
+    fun foo(s: String): Int = s.length
+}
+
+fun box(): String {
+    val foo = O::class.members.single { it.name == "foo" } as KFunction<*>
+
+    val j = foo.javaMethod ?: return "Fail: no Java method found for O::foo"
+    assertEquals(3, j.invoke(null, "abc"))
+
+    val k = j.kotlinFunction ?: return "Fail: no Kotlin function found for Java method O::foo"
+    assertEquals(3, k.call(O, "def"))
+
+    return "OK"
+}
@@ -0,0 +1,14 @@
+// WITH_REFLECT
+
+class A
+
+fun box(): String {
+    val a1 = A::class.java.kotlin
+    val a2 = A::class
+
+    if (a1 != a2) return "Fail equals"
+    if (a1.hashCode() != a2.hashCode()) return "Fail hashCode"
+    if (a1.toString() != a2.toString()) return "Fail toString"
+
+    return "OK"
+}
@@ -0,0 +1,25 @@
+// WITH_REFLECT
+
+import kotlin.reflect.jvm.*
+import kotlin.test.assertEquals
+
+class K(var value: Long)
+
+fun box(): String {
+    val p = K::value
+
+    assert(p.javaField != null) { "Fail p field" }
+
+    val getter = p.javaGetter!!
+    val setter = p.javaSetter!!
+
+    assertEquals(getter, K::class.java.getMethod("getValue"))
+    assertEquals(setter, K::class.java.getMethod("setValue", Long::class.java))
+
+    val k = K(42L)
+    assert(getter.invoke(k) == 42L) { "Fail k getter" }
+    setter.invoke(k, -239L)
+    assert(getter.invoke(k) == -239L) { "Fail k setter" }
+
+    return "OK"
+}
@@ -0,0 +1,36 @@
+// WITH_REFLECT
+
+import kotlin.reflect.jvm.*
+import kotlin.test.*
+
+var foo = "foo"
+
+class A {
+    var bar = "bar"
+}
+
+fun box(): String {
+    val fooGetter = ::foo.getter.javaMethod ?: return "Fail fooGetter"
+    assertEquals("foo", fooGetter.invoke(null))
+
+    val fooSetter = ::foo.setter.javaMethod ?: return "Fail fooSetter"
+    fooSetter.invoke(null, "foof")
+    assertEquals("foof", foo)
+
+    assertNull(::foo.getter.javaConstructor)
+    assertNull(::foo.setter.javaConstructor)
+
+
+    val a = A()
+    val barGetter = A::bar.getter.javaMethod ?: return "Fail barGetter"
+    assertEquals("bar", barGetter.invoke(a))
+
+    val barSetter = A::bar.setter.javaMethod ?: return "Fail barSetter"
+    barSetter.invoke(a, "barb")
+    assertEquals("barb", a.bar)
+
+    assertNull(A::bar.getter.javaConstructor)
+    assertNull(A::bar.setter.javaConstructor)
+
+    return "OK"
+}
@@ -0,0 +1,25 @@
+// WITH_REFLECT
+
+import kotlin.reflect.jvm.*
+
+var state: String = "value"
+    @JvmName("getter")
+    get
+    @JvmName("setter")
+    set
+
+fun box(): String {
+    val p = ::state
+
+    if (p.name != "state") return "Fail name: ${p.name}"
+    if (p.get() != "value") return "Fail get: ${p.get()}"
+    p.set("OK")
+
+    val getterName = p.javaGetter!!.getName()
+    if (getterName != "getter") return "Fail getter name: $getterName"
+
+    val setterName = p.javaSetter!!.getName()
+    if (setterName != "setter") return "Fail setter name: $setterName"
+
+    return p.get()
+}
@@ -0,0 +1,16 @@
+// WITH_REFLECT
+
+import kotlin.reflect.jvm.kotlin
+
+enum class A {
+    // There's a synthetic field "$VALUES" here
+}
+
+fun box(): String {
+    for (field in A::class.java.getDeclaredFields()) {
+        val prop = field.kotlin
+        if (prop != null) return "Fail, property found: $prop"
+    }
+
+    return "OK"
+}
@@ -0,0 +1,27 @@
+// WITH_REFLECT
+
+import kotlin.reflect.jvm.*
+import kotlin.test.assertEquals
+
+var topLevel = "123"
+
+fun box(): String {
+    val p = ::topLevel
+
+    assert(p.javaField != null) { "Fail p field" }
+    val field = p.javaField!!
+    val className = field.getDeclaringClass().getName()
+    assertEquals("TopLevelPropertyKt", className)
+
+    val getter = p.javaGetter!!
+    val setter = p.javaSetter!!
+
+    assertEquals(getter, Class.forName("TopLevelPropertyKt").getMethod("getTopLevel"))
+    assertEquals(setter, Class.forName("TopLevelPropertyKt").getMethod("setTopLevel", String::class.java))
+
+    assert(getter.invoke(null) == "123") { "Fail k getter" }
+    setter.invoke(null, "456")
+    assert(getter.invoke(null) == "456") { "Fail k setter" }
+
+    return "OK"
+}
@@ -0,0 +1,31 @@
+// WITH_REFLECT
+// FULL_JDK
+
+import java.lang.reflect.GenericArrayType
+import java.lang.reflect.TypeVariable
+import java.lang.reflect.ParameterizedType
+import kotlin.reflect.jvm.*
+import kotlin.test.assertEquals
+
+fun foo(strings: Array<String>, integers: Array<Int>, objectArrays: Array<Array<Any>>) {}
+
+fun bar(): Array<List<String>> = null!!
+class A<T> {
+    fun baz(): Array<T> = null!!
+}
+
+fun box(): String {
+    assertEquals(Array<String>::class.java, ::foo.parameters[0].type.javaType)
+    assertEquals(Array<Int>::class.java, ::foo.parameters[1].type.javaType)
+    assertEquals(Array<Array<Any>>::class.java, ::foo.parameters[2].type.javaType)
+
+    val g = ::bar.returnType.javaType
+    if (g !is GenericArrayType || g.genericComponentType !is ParameterizedType)
+        return "Fail: should be array of parameterized type, but was $g (${g.javaClass})"
+
+    val h = A<String>::baz.returnType.javaType
+    if (h !is GenericArrayType || h.genericComponentType !is TypeVariable<*>)
+        return "Fail: should be array of type variable, but was $h (${h.javaClass})"
+
+    return "OK"
+}
@@ -0,0 +1,22 @@
+// WITH_REFLECT
+
+import kotlin.reflect.*
+import kotlin.reflect.jvm.*
+import kotlin.test.assertEquals
+
+class A(d: Double, s: String, parent: A?) {
+    class Nested(a: A)
+    inner class Inner(nested: Nested)
+}
+
+fun box(): String {
+    assertEquals(listOf(java.lang.Double.TYPE, String::class.java, A::class.java), ::A.parameters.map { it.type.javaType })
+    assertEquals(listOf(A::class.java), A::Nested.parameters.map { it.type.javaType })
+    assertEquals(listOf(A::class.java, A.Nested::class.java), A::Inner.parameters.map { it.type.javaType })
+
+    assertEquals(A::class.java, ::A.returnType.javaType)
+    assertEquals(A.Nested::class.java, A::Nested.returnType.javaType)
+    assertEquals(A.Inner::class.java, A::Inner.returnType.javaType)
+
+    return "OK"
+}
@@ -0,0 +1,25 @@
+// WITH_REFLECT
+
+import kotlin.reflect.jvm.javaType
+import kotlin.test.assertEquals
+
+class A {
+    fun foo(t: Long?): Long = t!!
+}
+
+object O {
+    @JvmStatic
+    fun bar(a: A): String = ""
+}
+
+fun box(): String {
+    val foo = A::foo
+    assertEquals(listOf(A::class.java, java.lang.Long::class.java), foo.parameters.map { it.type.javaType })
+    assertEquals(java.lang.Long.TYPE, foo.returnType.javaType)
+
+    val bar = O::class.members.single { it.name == "bar" }
+    assertEquals(listOf(O::class.java, A::class.java), bar.parameters.map { it.type.javaType })
+    assertEquals(String::class.java, bar.returnType.javaType)
+
+    return "OK"
+}
@@ -0,0 +1,25 @@
+// WITH_REFLECT
+
+import kotlin.reflect.jvm.*
+import kotlin.test.*
+
+interface I {
+    fun foo(): Any
+}
+
+class A : I {
+    override fun foo(): Int = 0
+    fun bar(x: Long): Int = x.toInt()
+}
+
+fun box(): String {
+    assertEquals(Integer::class.java, A::foo.returnType.javaType)
+    assertNotEquals(Integer.TYPE, A::foo.returnType.javaType)
+
+    assertNotEquals(Integer::class.java, A::bar.returnType.javaType)
+    assertEquals(Integer.TYPE, A::bar.returnType.javaType)
+
+    assertEquals(java.lang.Long.TYPE, A::bar.parameters.last().type.javaType)
+
+    return "OK"
+}
@@ -0,0 +1,42 @@
+// WITH_REFLECT
+// FULL_JDK
+
+import java.lang.reflect.ParameterizedType
+import kotlin.reflect.*
+import kotlin.reflect.jvm.javaType
+import kotlin.test.assertEquals
+
+class A(private var foo: List<String>)
+
+object O {
+    @JvmStatic
+    private var bar: List<String> = listOf()
+}
+
+fun topLevel(): List<String> = listOf()
+fun Any.extension(): List<String> = listOf()
+
+fun assertGenericType(type: KType) {
+    val javaType = type.javaType
+    if (javaType !is ParameterizedType) {
+        throw AssertionError("Type should be a parameterized type, but was $javaType (${javaType.javaClass})")
+    }
+}
+
+fun box(): String {
+    val foo = A::class.members.single { it.name == "foo" } as KMutableProperty<*>
+    assertGenericType(foo.returnType)
+    assertGenericType(foo.getter.returnType)
+    assertGenericType(foo.setter.parameters.last().type)
+
+    val bar = O::class.members.single { it.name == "bar" } as KMutableProperty<*>
+    assertGenericType(bar.returnType)
+    assertGenericType(bar.getter.returnType)
+    assertGenericType(bar.setter.parameters.last().type)
+
+    assertGenericType(::topLevel.returnType)
+    assertGenericType(Any::extension.returnType)
+    assertGenericType(::A.parameters.single().type)
+
+    return "OK"
+}
@@ -0,0 +1,26 @@
+// WITH_REFLECT
+
+import kotlin.reflect.KMutableProperty
+import kotlin.reflect.jvm.javaType
+import kotlin.test.assertEquals
+
+class A(private var foo: String)
+
+object O {
+    @JvmStatic
+    private var bar: String = ""
+}
+
+fun box(): String {
+    val foo = A::class.members.single { it.name == "foo" } as KMutableProperty<*>
+    assertEquals(listOf(A::class.java), foo.parameters.map { it.type.javaType })
+    assertEquals(listOf(A::class.java), foo.getter.parameters.map { it.type.javaType })
+    assertEquals(listOf(A::class.java, String::class.java), foo.setter.parameters.map { it.type.javaType })
+
+    val bar = O::class.members.single { it.name == "bar" } as KMutableProperty<*>
+    assertEquals(listOf(O::class.java), bar.parameters.map { it.type.javaType })
+    assertEquals(listOf(O::class.java), bar.getter.parameters.map { it.type.javaType })
+    assertEquals(listOf(O::class.java, String::class.java), bar.setter.parameters.map { it.type.javaType })
+
+    return "OK"
+}
@@ -0,0 +1,17 @@
+// WITH_REFLECT
+
+import kotlin.reflect.jvm.*
+import kotlin.test.assertEquals
+
+fun free(s: String): Int = s.length
+
+fun Any.extension() {}
+
+fun box(): String {
+    assertEquals(java.lang.Integer.TYPE, ::free.returnType.javaType)
+    assertEquals(String::class.java, ::free.parameters.single().type.javaType)
+
+    assertEquals(Any::class.java, Any::extension.parameters.single().type.javaType)
+
+    return "OK"
+}
@@ -0,0 +1,21 @@
+// WITH_REFLECT
+// FULL_JDK
+
+import java.lang.reflect.TypeVariable
+import kotlin.reflect.jvm.*
+import kotlin.test.assertEquals
+
+class A<T> {
+    fun foo(t: T) {}
+}
+
+fun box(): String {
+    val f = A<String>::foo
+    val t = f.parameters.last().type.javaType
+    if (t !is TypeVariable<*>) return "Fail, t should be a type variable: $t"
+
+    assertEquals("T", t.name)
+    assertEquals("A", (t.genericDeclaration as Class<*>).name)
+
+    return "OK"
+}
@@ -0,0 +1,23 @@
+// WITH_REFLECT
+
+import kotlin.reflect.jvm.*
+import kotlin.test.assertEquals
+
+fun foo(unitParam: Unit, nullableUnitParam: Unit?): Unit {}
+
+var bar: Unit = Unit
+
+fun box(): String {
+    assert(Unit::class.java != java.lang.Void.TYPE)
+
+    assertEquals(Unit::class.java, ::foo.parameters[0].type.javaType)
+    assertEquals(Unit::class.java, ::foo.parameters[1].type.javaType)
+    assertEquals(java.lang.Void.TYPE, ::foo.returnType.javaType)
+
+    assertEquals(Unit::class.java, ::bar.returnType.javaType)
+    assertEquals(Unit::class.java, ::bar.getter.returnType.javaType)
+    assertEquals(Unit::class.java, ::bar.setter.parameters.single().type.javaType)
+    assertEquals(java.lang.Void.TYPE, ::bar.setter.returnType.javaType)
+
+    return "OK"
+}