tests: Update external tests (1.1.2-dev-393)

2017-03-13 12:38:08 +03:00
parent ac56fccb15
commit bc074e6d39
3178 changed files with 22396 additions and 696 deletions
@@ -0,0 +1,40 @@
+// TODO: muted automatically, investigate should it be ran for JS or not
+// IGNORE_BACKEND: JS, NATIVE
+
+// 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,32 @@
+// TODO: muted automatically, investigate should it be ran for JS or not
+// IGNORE_BACKEND: JS, NATIVE
+
+// 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,26 @@
+// TODO: muted automatically, investigate should it be ran for JS or not
+// IGNORE_BACKEND: JS, NATIVE
+
+// 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,20 @@
+// TODO: muted automatically, investigate should it be ran for JS or not
+// IGNORE_BACKEND: JS, NATIVE
+
+// 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,32 @@
+// TODO: muted automatically, investigate should it be ran for JS or not
+// IGNORE_BACKEND: JS, NATIVE
+
+// 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,23 @@
+// IGNORE_BACKEND: JS, NATIVE
+// WITH_REFLECT
+
+import kotlin.reflect.*
+import kotlin.reflect.jvm.*
+import kotlin.test.assertEquals
+
+inline fun <reified T> f() = 1
+
+fun g() {}
+
+class Foo {
+    inline fun <reified T> h(t: T) = 1
+}
+
+fun box(): String {
+    assertEquals(::g, ::g.javaMethod!!.kotlinFunction)
+
+    val h = Foo::class.members.single { it.name == "h" } as KFunction<*>
+    assertEquals(h, h.javaMethod!!.kotlinFunction)
+
+    return "OK"
+}
@@ -0,0 +1,38 @@
+// TODO: muted automatically, investigate should it be ran for JS or not
+// IGNORE_BACKEND: JS, NATIVE
+
+// 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,25 @@
+// TODO: muted automatically, investigate should it be ran for JS or not
+// IGNORE_BACKEND: JS, NATIVE
+
+// 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,17 @@
+// TODO: muted automatically, investigate should it be ran for JS or not
+// IGNORE_BACKEND: JS, NATIVE
+
+// 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,28 @@
+// TODO: muted automatically, investigate should it be ran for JS or not
+// IGNORE_BACKEND: JS, NATIVE
+
+// 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,39 @@
+// TODO: muted automatically, investigate should it be ran for JS or not
+// IGNORE_BACKEND: JS, NATIVE
+
+// 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,28 @@
+// TODO: muted automatically, investigate should it be ran for JS or not
+// IGNORE_BACKEND: JS, NATIVE
+
+// 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,19 @@
+// TODO: muted automatically, investigate should it be ran for JS or not
+// IGNORE_BACKEND: JS, NATIVE
+
+// WITH_REFLECT
+
+import kotlin.reflect.jvm.kotlinProperty
+
+enum class A {
+    // There's a synthetic field "$VALUES" here
+}
+
+fun box(): String {
+    for (field in A::class.java.getDeclaredFields()) {
+        val prop = field.kotlinProperty
+        if (prop != null) return "Fail, property found: $prop"
+    }
+
+    return "OK"
+}
@@ -0,0 +1,28 @@
+// TODO: muted automatically, investigate should it be ran for JS or not
+// IGNORE_BACKEND: JS, NATIVE
+
+// WITH_REFLECT
+// FILE: test.kt
+
+fun test2() {
+}
+
+// FILE: main.kt
+// See KT-10690 Exception in kotlin.reflect when trying to get kotlinFunction from javaMethod
+
+import kotlin.reflect.jvm.javaMethod
+import kotlin.reflect.jvm.kotlinFunction
+
+fun box(): String {
+    if (::box.javaMethod?.kotlinFunction == null)
+        return "Fail box"
+    if (::test1.javaMethod?.kotlinFunction == null)
+        return "Fail test1"
+    if (::test2.javaMethod?.kotlinFunction == null)
+        return "Fail test2"
+
+    return "OK"
+}
+
+fun test1() {
+}
@@ -0,0 +1,30 @@
+// TODO: muted automatically, investigate should it be ran for JS or not
+// IGNORE_BACKEND: JS, NATIVE
+
+// 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,51 @@
+// TODO: muted automatically, investigate should it be ran for JS or not
+// IGNORE_BACKEND: JS, NATIVE
+
+// WITH_REFLECT
+// FULL_JDK
+
+import java.lang.reflect.GenericArrayType
+import java.lang.reflect.ParameterizedType
+import kotlin.reflect.KClass
+import kotlin.reflect.jvm.javaType
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
+
+annotation class Z
+enum class E
+
+annotation class Anno(
+        val b: Byte,
+        val s: String,
+        val ss: Array<String>,
+        val z: Z,
+        val zs: Array<Z>,
+        val e: E,
+        val es: Array<E>,
+        val k: KClass<*>,
+        val ka: Array<KClass<*>>
+)
+
+fun tmp(): Array<Class<*>> = null!!
+
+fun box(): String {
+    val t = Anno::class.constructors.single().parameters.map { it.type.javaType }
+
+    assertEquals(Byte::class.java, t[0])
+    assertEquals(String::class.java, t[1])
+    assertEquals(Array<String>::class.java, t[2])
+    assertEquals(Z::class.java, t[3])
+    assertEquals(Array<Z>::class.java, t[4])
+    assertEquals(E::class.java, t[5])
+    assertEquals(Array<E>::class.java, t[6])
+
+    assertTrue(t[7] is ParameterizedType)
+    assertEquals(Class::class.java, (t[7] as ParameterizedType).rawType)
+
+    assertTrue(t[8] is GenericArrayType)
+    val e = (t[8] as GenericArrayType).genericComponentType
+    assertTrue(e is ParameterizedType)
+    assertEquals(Class::class.java, (e as ParameterizedType).rawType)
+
+    return "OK"
+}
@@ -0,0 +1,34 @@
+// TODO: muted automatically, investigate should it be ran for JS or not
+// IGNORE_BACKEND: JS, NATIVE
+
+// 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,25 @@
+// TODO: muted automatically, investigate should it be ran for JS or not
+// IGNORE_BACKEND: JS, NATIVE
+
+// 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,37 @@
+// TODO: muted automatically, investigate should it be ran for JS or not
+// IGNORE_BACKEND: JS, NATIVE
+
+// WITH_REFLECT
+// FULL_JDK
+
+import java.lang.reflect.ParameterizedType
+import kotlin.reflect.jvm.javaType
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
+
+class Bar
+fun arrayOfInvBar(): Array<Bar> = null!!
+fun arrayOfInBar(): Array<in Bar> = null!!
+fun arrayOfOutBar(): Array<out Bar> = null!!
+
+fun arrayOfInvList(): Array<List<String>> = null!!
+fun arrayOfInList(): Array<in List<String>> = null!!
+fun arrayOfOutList(): Array<out List<String>> = null!!
+
+fun box(): String {
+    // NB: in "Array<in X>", Java type of X is always Any::class.java because this is the JVM signature generated by the compiler
+
+    assertEquals(Bar::class.java, ::arrayOfInvBar.returnType.arguments.single().type!!.javaType)
+    assertEquals(Any::class.java, ::arrayOfInBar.returnType.arguments.single().type!!.javaType)
+    assertEquals(Bar::class.java, ::arrayOfOutBar.returnType.arguments.single().type!!.javaType)
+
+    val invList = ::arrayOfInvList.returnType.arguments.single().type!!.javaType
+    assertTrue(invList is ParameterizedType && invList.rawType == List::class.java, invList.toString())
+
+    assertEquals(Any::class.java, ::arrayOfInList.returnType.arguments.single().type!!.javaType)
+
+    val outList = ::arrayOfOutList.returnType.arguments.single().type!!.javaType
+    assertTrue(outList is ParameterizedType && outList.rawType == List::class.java, outList.toString())
+
+    return "OK"
+}
@@ -0,0 +1,31 @@
+// TODO: muted automatically, investigate should it be ran for JS or not
+// IGNORE_BACKEND: JS, NATIVE
+
+// WITH_REFLECT
+
+import kotlin.reflect.jvm.javaType
+import kotlin.test.assertEquals
+
+class Outer<A, B> {
+    inner class Inner<C, D> {
+        inner class Innermost<E, F>
+    }
+}
+
+fun foo(): Outer<Int, Number>.Inner<String, Float>.Innermost<Any, Any?> = null!!
+
+fun box(): String {
+    assertEquals(
+            listOf(
+                    Any::class.java,
+                    Any::class.java,
+                    String::class.java,
+                    Float::class.javaObjectType,
+                    Int::class.javaObjectType,
+                    Number::class.java
+            ),
+            ::foo.returnType.arguments.map { it.type!!.javaType }
+    )
+
+    return "OK"
+}
@@ -0,0 +1,28 @@
+// TODO: muted automatically, investigate should it be ran for JS or not
+// IGNORE_BACKEND: JS, NATIVE
+
+// 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,28 @@
+// TODO: muted automatically, investigate should it be ran for JS or not
+// IGNORE_BACKEND: JS, NATIVE
+
+// 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,25 @@
+// TODO: muted automatically, investigate should it be ran for JS or not
+// IGNORE_BACKEND: JS, NATIVE
+
+// WITH_REFLECT
+
+import kotlin.reflect.jvm.javaType
+import kotlin.test.assertEquals
+
+fun listOfStrings(): List<String> = null!!
+
+class Foo<T>
+class Bar
+fun fooOfInvBar(): Foo<Bar> = null!!
+fun fooOfInBar(): Foo<in Bar> = null!!
+fun fooOfOutBar(): Foo<out Bar> = null!!
+
+fun box(): String {
+    assertEquals(String::class.java, ::listOfStrings.returnType.arguments.single().type!!.javaType)
+
+    assertEquals(Bar::class.java, ::fooOfInvBar.returnType.arguments.single().type!!.javaType)
+    assertEquals(Bar::class.java, ::fooOfInBar.returnType.arguments.single().type!!.javaType)
+    assertEquals(Bar::class.java, ::fooOfOutBar.returnType.arguments.single().type!!.javaType)
+
+    return "OK"
+}
@@ -0,0 +1,45 @@
+// TODO: muted automatically, investigate should it be ran for JS or not
+// IGNORE_BACKEND: JS, NATIVE
+
+// 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,29 @@
+// TODO: muted automatically, investigate should it be ran for JS or not
+// IGNORE_BACKEND: JS, NATIVE
+
+// 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,21 @@
+// TARGET_BACKEND: JVM
+
+// WITH_REFLECT
+// FILE: J.java
+
+import java.util.List;
+
+public interface J {
+    List foo();
+}
+
+// FILE: K.kt
+
+import kotlin.reflect.jvm.javaType
+import kotlin.test.assertEquals
+
+fun box(): String {
+    assertEquals(Any::class.java, J::foo.returnType.arguments.single().type!!.javaType)
+
+    return "OK"
+}
@@ -0,0 +1,34 @@
+// TODO: muted automatically, investigate should it be ran for JS or not
+// IGNORE_BACKEND: JS, NATIVE
+
+// WITH_REFLECT
+// FULL_JDK
+
+import java.lang.reflect.ParameterizedType
+import java.lang.reflect.TypeVariable
+import kotlin.reflect.jvm.javaType
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
+import kotlin.test.fail
+
+open class Klass
+interface Interface<T, U>
+interface Interface2
+
+class A<Z> : Interface<String, Z>, Klass(), Interface2
+
+fun box(): String {
+    val (i, k, i2) = A::class.supertypes.map { it.javaType }
+
+    i as? ParameterizedType ?: fail("Not a parameterized type: $i")
+    assertEquals(Interface::class.java, i.rawType)
+    val args = i.actualTypeArguments
+    assertEquals(String::class.java, args[0], "Not String: ${args[0]}")
+    assertTrue(args[1].let { it is TypeVariable<*> && it.name == "Z" && it.genericDeclaration == A::class.java }, "Not Z: ${args[1]}")
+
+    assertEquals(Klass::class.java, k)
+
+    assertEquals(Interface2::class.java, i2)
+
+    return "OK"
+}
@@ -0,0 +1,20 @@
+// TODO: muted automatically, investigate should it be ran for JS or not
+// IGNORE_BACKEND: JS, NATIVE
+
+// 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,24 @@
+// TODO: muted automatically, investigate should it be ran for JS or not
+// IGNORE_BACKEND: JS, NATIVE
+
+// 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,26 @@
+// TODO: muted automatically, investigate should it be ran for JS or not
+// IGNORE_BACKEND: JS, NATIVE
+
+// 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"
+}
@@ -0,0 +1,23 @@
+// TODO: muted automatically, investigate should it be ran for JS or not
+// IGNORE_BACKEND: JS, NATIVE
+
+// WITH_REFLECT
+
+import kotlin.reflect.full.withNullability
+import kotlin.reflect.jvm.javaType
+import kotlin.test.assertEquals
+
+fun nonNull(): String = ""
+fun nullable(): String? = ""
+
+fun box(): String {
+    val nonNull = ::nonNull.returnType
+    val nullable = ::nullable.returnType
+
+    assertEquals(nullable.javaType, nullable.withNullability(false).javaType)
+    assertEquals(nullable.javaType, nullable.withNullability(true).javaType)
+    assertEquals(nonNull.javaType, nonNull.withNullability(false).javaType)
+    assertEquals(nullable.javaType, nonNull.withNullability(true).javaType)
+
+    return "OK"
+}