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,27 @@
+// TODO: muted automatically, investigate should it be ran for JS or not
+// IGNORE_BACKEND: JS, NATIVE
+
+// WITH_REFLECT
+import kotlin.reflect.KParameter
+import kotlin.test.assertEquals
+
+class Outer(val s1: String) {
+    inner class Inner(val s2: String, val s3: String = "K") {
+        val result = s1 + s2 + s3
+    }
+}
+
+fun KParameter.check(name: String) {
+    assertEquals(name, this.name!!)
+    assertEquals(KParameter.Kind.VALUE, this.kind)
+}
+
+fun box(): String {
+    val ctor = Outer("O")::Inner
+    val ctorPararms = ctor.parameters
+
+    ctorPararms[0].check("s2")
+    ctorPararms[1].check("s3")
+
+    return "OK"
+}
@@ -0,0 +1,26 @@
+// TODO: 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
+
+object Host {
+    fun foo(i: Int, s: String) {}
+}
+
+fun box(): String {
+    val fooParams = Host::foo.parameters
+
+    assertEquals(2, fooParams.size)
+
+    assertEquals("i", fooParams[0].name)
+    assertEquals(Int::class.java, fooParams[0].type.javaType)
+
+    assertEquals("s", fooParams[1].name)
+    assertEquals(String::class.java, fooParams[1].type.javaType)
+
+    return "OK"
+}
@@ -0,0 +1,35 @@
+// TODO: 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.*
+
+class C {
+    fun foo() {}
+    var bar = "OK"
+}
+
+fun C.extFun(i: Int) {}
+
+fun KParameter.check(name: String) {
+    assertEquals(name, this.name!!)
+    assertEquals(KParameter.Kind.VALUE, this.kind)
+}
+
+fun box(): String {
+    val cFoo = C()::foo
+    val cBar = C()::bar
+    val cExtFun = C()::extFun
+
+    assertEquals(0, cFoo.parameters.size)
+    assertEquals(0, cBar.getter.parameters.size)
+    assertEquals(1, cBar.setter.parameters.size)
+
+    assertEquals(1, cExtFun.parameters.size)
+    cExtFun.parameters[0].check("i")
+
+    return "OK"
+}
@@ -0,0 +1,27 @@
+// TODO: muted automatically, investigate should it be ran for JS or not
+// IGNORE_BACKEND: JS, NATIVE
+
+// WITH_REFLECT
+// FILE: J.java
+
+public class J {
+    public void bar(int x) {}
+}
+
+// FILE: K.kt
+
+import kotlin.reflect.full.findParameterByName
+import kotlin.test.assertEquals
+import kotlin.test.assertNull
+
+fun foo(x: Int) = x
+
+fun box(): String {
+    assertEquals(::foo.parameters.single(), ::foo.findParameterByName("x"))
+    assertNull(::foo.findParameterByName("y"))
+
+    assertNull(J::bar.findParameterByName("x"))
+    assertNull(J::bar.findParameterByName("y"))
+
+    return "OK"
+}
@@ -0,0 +1,36 @@
+// TODO: muted automatically, investigate should it be ran for JS or not
+// IGNORE_BACKEND: JS, NATIVE
+
+// WITH_REFLECT
+
+import kotlin.reflect.*
+import kotlin.test.assertEquals
+
+fun foo(bar: String): Int = bar.length
+
+class A(val c: String) {
+    fun foz(baz: Int) {}
+
+    fun Double.mext(mez: Long) {}
+}
+
+fun Int.qux(zux: String) {}
+
+fun checkParameters(f: KFunction<*>, names: List<String?>) {
+    val params = f.parameters
+    assertEquals(names, params.map { it.name })
+    assertEquals(params.indices.toList(), params.map { it.index })
+}
+
+fun box(): String {
+    checkParameters(::box, listOf())
+    checkParameters(::foo, listOf("bar"))
+    checkParameters(A::foz, listOf(null, "baz"))
+    checkParameters(Int::qux, listOf(null, "zux"))
+
+    checkParameters(A::class.functions.single { it.name == "mext" }, listOf(null, null, "mez"))
+
+    checkParameters(::A, listOf("c"))
+
+    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.full.*
+import kotlin.test.assertEquals
+import kotlin.test.assertNotNull
+import kotlin.test.assertNull
+
+class A {
+    fun String.memExt(param: Int) {}
+}
+
+fun topLevel() {}
+
+fun Int.ext(vararg o: Any) {}
+
+fun box(): String {
+    A::class.members.single { it.name == "memExt" }.let {
+        assertNotNull(it.instanceParameter)
+        assertNotNull(it.extensionReceiverParameter)
+        assertEquals(1, it.valueParameters.size)
+    }
+
+    ::topLevel.let {
+        assertNull(it.instanceParameter)
+        assertNull(it.extensionReceiverParameter)
+        assertEquals(0, it.valueParameters.size)
+    }
+
+    Int::ext.let {
+        assertNull(it.instanceParameter)
+        assertNotNull(it.extensionReceiverParameter)
+        assertEquals(1, it.valueParameters.size)
+    }
+
+    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.*
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
+
+class A {
+    fun <T, U : Any> foo(p1: String, p2: String?, p3: T, p4: U, p5: U?) { }
+}
+
+fun Any?.ext() {}
+
+fun box(): String {
+    val ps = A::class.declaredFunctions.single().parameters.map { it.type.isMarkedNullable }
+    assertEquals(listOf(false, false, true, false, false, true), ps)
+
+    assertTrue(Any?::ext.parameters.single().type.isMarkedNullable)
+
+    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.test.*
+
+open class A {
+    open fun foo(x: Int, y: Int = 1) {}
+}
+
+class B : A() {
+    override fun foo(x: Int, y: Int) {}
+}
+
+class C : A()
+
+
+fun Int.extFun() {}
+
+fun box(): String {
+    assertEquals(listOf(false, false, true), A::foo.parameters.map { it.isOptional })
+    assertEquals(listOf(false, false, true), B::foo.parameters.map { it.isOptional })
+    assertEquals(listOf(false, false, true), C::foo.parameters.map { it.isOptional })
+
+    assertFalse(Int::extFun.parameters.single().isOptional)
+
+    return "OK"
+}
@@ -0,0 +1,30 @@
+// TODO: muted automatically, investigate should it be ran for JS or not
+// IGNORE_BACKEND: JS, NATIVE
+
+// WITH_REFLECT
+// FILE: J.java
+
+public @interface J {
+    short s();
+    long j();
+    boolean z();
+    int i();
+    float f();
+    char c();
+    double d();
+}
+
+// FILE: K.kt
+
+import kotlin.reflect.KParameter
+import kotlin.test.assertEquals
+
+fun box(): String {
+    val ctor = J::class.constructors.single()
+
+    // We sort parameters by name for consistency
+    assertEquals(listOf("c", "d", "f", "i", "j", "s", "z"), ctor.parameters.map { it.name })
+    assert(ctor.parameters.all { it.kind == KParameter.Kind.VALUE })
+
+    return "OK"
+}
@@ -0,0 +1,22 @@
+// TODO: muted automatically, investigate should it be ran for JS or not
+// IGNORE_BACKEND: JS, NATIVE
+
+// 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,23 @@
+// TODO: muted automatically, investigate should it be ran for JS or not
+// IGNORE_BACKEND: JS, NATIVE
+
+// WITH_REFLECT
+
+import kotlin.reflect.*
+import kotlin.reflect.KParameter.Kind.*
+import kotlin.test.assertEquals
+
+class A {
+    fun Int.foo(x: String) {}
+
+    inner class Inner(s: String) {}
+}
+
+fun box(): String {
+    val foo = A::class.memberExtensionFunctions.single()
+
+    assertEquals(listOf(INSTANCE, EXTENSION_RECEIVER, VALUE), foo.parameters.map { it.kind })
+    assertEquals(listOf(INSTANCE, VALUE), A::Inner.parameters.map { it.kind })
+
+    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.*
+import kotlin.test.assertEquals
+
+var default: Int = 0
+
+var defaultAnnotated: Int = 0
+    public set
+
+var custom: Int = 0
+    set(myName: Int) {}
+
+fun checkPropertySetterParam(property: KMutableProperty<*>, name: String?) {
+    val parameter = property.setter.parameters.single()
+    assertEquals(0, parameter.index)
+    assertEquals(name, parameter.name)
+}
+
+fun box(): String {
+    checkPropertySetterParam(::default, null)
+    checkPropertySetterParam(::defaultAnnotated, null)
+    checkPropertySetterParam(::custom, "myName")
+
+    return "OK"
+}