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,22 @@
+// WITH_REFLECT
+
+import kotlin.reflect.*
+import kotlin.test.assertEquals
+
+class A {
+    fun foo() = "foo"
+    val bar = "bar"
+}
+
+fun checkEqual(x: Any, y: Any) {
+    assertEquals(x, y)
+    assertEquals(y, x)
+    assertEquals(x.hashCode(), y.hashCode())
+}
+
+fun box(): String {
+    checkEqual(A::foo, A::class.members.single { it.name == "foo" })
+    checkEqual(A::bar, A::class.members.single { it.name == "bar" })
+
+    return "OK"
+}
@@ -0,0 +1,30 @@
+// WITH_REFLECT
+
+import kotlin.test.*
+
+class A {
+    class Nested
+
+    companion object
+}
+
+fun box(): String {
+    assertEquals("class A", "${A::class}")
+    assertEquals("class A\$Nested", "${A.Nested::class}")
+    assertEquals("class A\$Companion", "${A.Companion::class}")
+
+    assertEquals("class kotlin.Any", "${Any::class}")
+    assertEquals("class kotlin.Int", "${Int::class}")
+    assertEquals("class kotlin.Int\$Companion", "${Int.Companion::class}")
+    assertEquals("class kotlin.IntArray", "${IntArray::class}")
+    assertEquals("class kotlin.String", "${String::class}")
+    assertEquals("class kotlin.String", "${java.lang.String::class}")
+
+    assertEquals("class kotlin.Array", "${Array<Any>::class}")
+    assertEquals("class kotlin.Array", "${Array<Int>::class}")
+    assertEquals("class kotlin.Array", "${Array<Array<String>>::class}")
+
+    assertEquals("class java.lang.Runnable", "${Runnable::class}")
+
+    return "OK"
+}
@@ -0,0 +1,88 @@
+// WITH_REFLECT
+
+import kotlin.reflect.KProperty1
+import kotlin.test.assertEquals
+
+fun check(expected: String, p: KProperty1<*, *>) {
+    var s = p.toString()
+
+    // Strip "val" or "var"
+    assert(s.startsWith("val ") || s.startsWith("var ")) { "Fail val/var: $s" }
+    s = s.substring(4)
+
+    // Strip property type
+    s = s.substringBeforeLast(':')
+
+    // Strip property name, leave only receiver class
+    s = s.substringBeforeLast('.')
+
+    assertEquals(expected, s)
+}
+
+val Boolean.x: Any get() = this
+val Char.x: Any get() = this
+val Byte.x: Any get() = this
+val Short.x: Any get() = this
+val Int.x: Any get() = this
+val Float.x: Any get() = this
+val Long.x: Any get() = this
+val Double.x: Any get() = this
+
+val BooleanArray.x: Any get() = this
+val CharArray.x: Any get() = this
+val ByteArray.x: Any get() = this
+val ShortArray.x: Any get() = this
+val IntArray.x: Any get() = this
+val FloatArray.x: Any get() = this
+val LongArray.x: Any get() = this
+val DoubleArray.x: Any get() = this
+
+val Array<Int>.a1: Any get() = this
+val Array<Any>.a2: Any get() = this
+val Array<Array<String>>.a3: Any get() = this
+val Array<BooleanArray>.a4: Any get() = this
+
+val Any?.n1: Any get() = Any()
+val Int?.n2: Any get() = Any()
+val Array<Any>?.n3: Any get() = Any()
+val Array<Any?>.n4: Any get() = Any()
+val Array<Any?>?.n5: Any get() = Any()
+
+val Map<String, Runnable>.m: Any get() = this
+val List<MutableSet<Array<CharSequence>>>.l: Any get() = this
+
+fun box(): String {
+    check("kotlin.Boolean", Boolean::x)
+    check("kotlin.Char", Char::x)
+    check("kotlin.Byte", Byte::x)
+    check("kotlin.Short", Short::x)
+    check("kotlin.Int", Int::x)
+    check("kotlin.Float", Float::x)
+    check("kotlin.Long", Long::x)
+    check("kotlin.Double", Double::x)
+
+    check("kotlin.BooleanArray", BooleanArray::x)
+    check("kotlin.CharArray", CharArray::x)
+    check("kotlin.ByteArray", ByteArray::x)
+    check("kotlin.ShortArray", ShortArray::x)
+    check("kotlin.IntArray", IntArray::x)
+    check("kotlin.FloatArray", FloatArray::x)
+    check("kotlin.LongArray", LongArray::x)
+    check("kotlin.DoubleArray", DoubleArray::x)
+
+    check("kotlin.Any?", Any?::n1)
+    check("kotlin.Int?", Int?::n2)
+    check("kotlin.Array<kotlin.Any>?", Array<Any>?::n3)
+    check("kotlin.Array<kotlin.Any?>", Array<Any?>::n4)
+    check("kotlin.Array<kotlin.Any?>?", Array<Any?>?::n5)
+
+    check("kotlin.Array<kotlin.Int>", Array<Int>::a1)
+    check("kotlin.Array<kotlin.Any>", Array<Any>::a2)
+    check("kotlin.Array<kotlin.Array<kotlin.String>>", Array<Array<String>>::a3)
+    check("kotlin.Array<kotlin.BooleanArray>", Array<BooleanArray>::a4)
+
+    check("kotlin.collections.Map<kotlin.String, java.lang.Runnable>", Map<String, Runnable>::m)
+    check("kotlin.collections.List<kotlin.collections.MutableSet<kotlin.Array<kotlin.CharSequence>>>", List<MutableSet<Array<CharSequence>>>::l)
+
+    return "OK"
+}
@@ -0,0 +1,33 @@
+// WITH_REFLECT
+
+import kotlin.test.*
+
+fun top() = 42
+
+fun Int.intExt(): Int = this
+
+class A {
+    fun mem() {}
+}
+
+class B {
+    fun mem() {}
+}
+
+
+fun checkEqual(x: Any, y: Any) {
+    assertEquals(x, y)
+    assertEquals(x.hashCode(), y.hashCode(), "Elements are equal but their hash codes are not: ${x.hashCode()} != ${y.hashCode()}")
+}
+
+fun box(): String {
+    checkEqual(::top, ::top)
+    checkEqual(Int::intExt, Int::intExt)
+    checkEqual(A::mem, A::mem)
+
+    assertFalse(::top == Int::intExt)
+    assertFalse(::top == A::mem)
+    assertFalse(A::mem == B::mem)
+
+    return "OK"
+}
@@ -0,0 +1,26 @@
+// WITH_REFLECT
+
+package test
+
+import kotlin.test.assertEquals
+
+fun top() = 42
+
+fun String.ext(): Int = 0
+fun IntRange?.ext2(): Array<Int?> = arrayOfNulls(0)
+
+class A {
+    fun mem(): String = ""
+}
+
+fun assertToString(s: String, x: Any) {
+    assertEquals(s, x.toString())
+}
+
+fun box(): String {
+    assertToString("fun top(): kotlin.Int", ::top)
+    assertToString("fun kotlin.String.ext(): kotlin.Int", String::ext)
+    assertToString("fun kotlin.ranges.IntRange?.ext2(): kotlin.Array<kotlin.Int?>", IntRange::ext2)
+    assertToString("fun test.A.mem(): kotlin.String", A::mem)
+    return "OK"
+}
@@ -0,0 +1,21 @@
+// WITH_REFLECT
+
+import kotlin.reflect.*
+
+class A {
+    var String.id: String
+        get() = this
+        set(value) {}
+
+    fun Int.foo(): Double = toDouble()
+}
+
+fun box(): String {
+    val p = A::class.java.kotlin.memberExtensionProperties.single()
+    return if ("$p" == "var A.(kotlin.String.)id: kotlin.String") "OK" else "Fail $p"
+
+    val q = A::class.java.kotlin.declaredFunctions.single()
+    if ("$q" != "fun A.(kotlin.Int.)foo(): kotlin.Double") return "Fail q $q"
+
+    return "OK"
+}
@@ -0,0 +1,28 @@
+// WITH_REFLECT
+
+import kotlin.test.*
+
+class A {
+    fun foo(s: String, x: Int) {}
+    fun bar(x: Int) {}
+    val baz = 42
+}
+
+fun box(): String {
+    // Dispatch receiver parameters of different callables are not equal
+    assertNotEquals(A::foo.parameters[0], A::bar.parameters[0])
+    assertNotEquals(A::foo.parameters[0], A::baz.parameters[0])
+
+    assertNotEquals(A::foo.parameters[1], A::bar.parameters[1])
+    assertNotEquals(A::foo.parameters[1], A::foo.parameters[2])
+    assertNotEquals(A::bar.parameters[1], A::foo.parameters[2])
+
+    assertEquals(A::foo.parameters[0], A::foo.parameters[0])
+    assertEquals(A::foo.parameters[0].hashCode(), A::foo.parameters[0].hashCode())
+    assertEquals(A::foo.parameters[1], A::foo.parameters[1])
+    assertEquals(A::foo.parameters[1].hashCode(), A::foo.parameters[1].hashCode())
+    assertEquals(A::bar.parameters[0], A::bar.parameters[0])
+    assertEquals(A::bar.parameters[0].hashCode(), A::bar.parameters[0].hashCode())
+
+    return "OK"
+}
@@ -0,0 +1,30 @@
+// WITH_REFLECT
+
+import kotlin.test.*
+
+fun Int.foo(s: String) {}
+
+class A {
+    fun bar() {}
+}
+
+fun baz(name: String) {}
+
+fun box(): String {
+    assertEquals(
+            listOf("extension receiver of ${Int::foo}", "parameter #1 s of ${Int::foo}"),
+            Int::foo.parameters.map(Any::toString)
+    )
+
+    assertEquals(
+            listOf("instance of ${A::bar}"),
+            A::bar.parameters.map(Any::toString)
+    )
+
+    assertEquals(
+            listOf("parameter #0 name of ${::baz}"),
+            ::baz.parameters.map(Any::toString)
+    )
+
+    return "OK"
+}
@@ -0,0 +1,31 @@
+// WITH_REFLECT
+
+import kotlin.test.*
+
+val top = 42
+var top2 = -23
+
+val Int.intExt: Int get() = this
+val Char.charExt: Int get() = this.toInt()
+
+class A(var mem: String)
+class B(var mem: String)
+
+
+fun checkEqual(x: Any, y: Any) {
+    assertEquals(x, y)
+    assertEquals(x.hashCode(), y.hashCode(), "Elements are equal but their hash codes are not: ${x.hashCode()} != ${y.hashCode()}")
+}
+
+fun box(): String {
+    checkEqual(::top, ::top)
+    checkEqual(::top2, ::top2)
+    checkEqual(Int::intExt, Int::intExt)
+    checkEqual(A::mem, A::mem)
+
+    assertFalse(::top == ::top2)
+    assertFalse(Int::intExt == Char::charExt)
+    assertFalse(A::mem == B::mem)
+
+    return "OK"
+}
@@ -0,0 +1,28 @@
+// WITH_REFLECT
+
+package test
+
+import kotlin.test.assertEquals
+
+val top = 42
+var top2 = -23
+
+val String.ext: Int get() = 0
+var IntRange?.ext2: Int get() = 0; set(value) {}
+
+class A(val mem: String)
+class B(var mem: String)
+
+fun assertToString(s: String, x: Any) {
+    assertEquals(s, x.toString())
+}
+
+fun box(): String {
+    assertToString("val top: kotlin.Int", ::top)
+    assertToString("var top2: kotlin.Int", ::top2)
+    assertToString("val kotlin.String.ext: kotlin.Int", String::ext)
+    assertToString("var kotlin.ranges.IntRange?.ext2: kotlin.Int", IntRange::ext2)
+    assertToString("val test.A.mem: kotlin.String", A::mem)
+    assertToString("var test.B.mem: kotlin.String", B::mem)
+    return "OK"
+}
@@ -0,0 +1,30 @@
+// WITH_REFLECT
+
+import kotlin.reflect.KType
+import kotlin.test.assertEquals
+import kotlin.test.assertNotEquals
+
+fun unit(p: Unit): Unit {}
+
+fun nullable(s: String): String? = s
+
+class A {
+    fun <T> typeParam(t: T): T = t
+}
+
+
+fun box(): String {
+    fun check(t1: KType, t2: KType) {
+        assertEquals(t1, t2)
+        assertEquals(t1.hashCode(), t2.hashCode())
+    }
+
+    check(::unit.parameters.single().type, ::unit.returnType)
+
+    assertNotEquals(::nullable.parameters.single().type, ::nullable.returnType)
+
+    val typeParam = A::class.members.single { it.name == "typeParam" }
+    check(typeParam.parameters.last().type, typeParam.returnType)
+
+    return "OK"
+}
@@ -0,0 +1,37 @@
+// WITH_REFLECT
+
+import kotlin.test.assertEquals
+
+fun String?.foo(x: Int, y: Array<Int>, z: IntArray, w: List<Map<Any, A<*>>>) {}
+
+class A<T> {
+    fun <U> bar(t: T, u: U): T? = null
+}
+
+fun baz(inProjection: A<in Number>, outProjection: A<out Number>) {}
+
+fun box(): String {
+    assertEquals(
+            listOf(
+                    "kotlin.String?",
+                    "kotlin.Int",
+                    "kotlin.Array<kotlin.Int>",
+                    "kotlin.IntArray",
+                    "kotlin.collections.List<kotlin.collections.Map<kotlin.Any, A<*>>>"
+            ),
+            String?::foo.parameters.map { it.type.toString() }
+    )
+
+    assertEquals("kotlin.Unit", String?::foo.returnType.toString())
+
+    val bar = A::class.members.single { it.name == "bar" }
+    assertEquals(listOf("A<T>", "T", "U"), bar.parameters.map { it.type.toString() })
+    assertEquals("T?", bar.returnType.toString())
+
+    assertEquals(
+            listOf("A<in kotlin.Number>", "A<out kotlin.Number>"),
+            ::baz.parameters.map { it.type.toString() }
+    )
+
+    return "OK"
+}