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,17 @@
+// TODO: muted automatically, investigate should it be ran for JS or not
+// IGNORE_BACKEND: JS, NATIVE
+
+// WITH_REFLECT
+
+import kotlin.test.assertEquals
+
+class Klass
+
+fun box(): String {
+    assertEquals("Klass", Klass::class.simpleName)
+    assertEquals("Date", java.util.Date::class.simpleName)
+    assertEquals("ObjectRef", kotlin.jvm.internal.Ref.ObjectRef::class.simpleName)
+    assertEquals("Void", java.lang.Void::class.simpleName)
+
+    return "OK"
+}
@@ -0,0 +1,51 @@
+// TODO: muted automatically, investigate should it be ran for JS or not
+// IGNORE_BACKEND: JS, NATIVE
+
+// WITH_REFLECT
+
+import kotlin.reflect.*
+import kotlin.test.*
+
+class A {
+    companion object C
+}
+
+enum class E {
+    ENTRY;
+    companion object {}
+}
+
+fun box(): String {
+    val obj = A::class.companionObject
+    assertNotNull(obj)
+    assertEquals("C", obj!!.simpleName)
+
+    assertEquals(A.C, A::class.companionObjectInstance)
+    assertEquals(A.C, obj.objectInstance)
+
+    assertNull(A.C::class.companionObject)
+    assertNull(A.C::class.companionObjectInstance)
+
+    assertEquals(E.Companion, E::class.companionObjectInstance)
+
+    assertEquals(String, String::class.companionObjectInstance)
+    assertEquals(String, String.Companion::class.objectInstance)
+    assertEquals(Enum, Enum::class.companionObjectInstance)
+    assertEquals(Enum, Enum.Companion::class.objectInstance)
+    assertEquals(Double, Double::class.companionObjectInstance)
+    assertEquals(Double, Double.Companion::class.objectInstance)
+    assertEquals(Float, Float::class.companionObjectInstance)
+    assertEquals(Float, Float.Companion::class.objectInstance)
+    assertEquals(Int, Int::class.companionObjectInstance)
+    assertEquals(Int, Int.Companion::class.objectInstance)
+    assertEquals(Long, Long::class.companionObjectInstance)
+    assertEquals(Long, Long.Companion::class.objectInstance)
+    assertEquals(Short, Short::class.companionObjectInstance)
+    assertEquals(Short, Short.Companion::class.objectInstance)
+    assertEquals(Byte, Byte::class.companionObjectInstance)
+    assertEquals(Byte, Byte.Companion::class.objectInstance)
+    assertEquals(Char, Char::class.companionObjectInstance)
+    assertEquals(Char, Char.Companion::class.objectInstance)
+
+    return "OK"
+}
@@ -0,0 +1,76 @@
+// TODO: muted automatically, investigate should it be ran for JS or not
+// IGNORE_BACKEND: JS, NATIVE
+
+// WITH_REFLECT
+
+import kotlin.reflect.full.createInstance
+import kotlin.test.assertTrue
+import kotlin.test.fail
+
+// Good classes
+
+class Simple
+class PrimaryWithDefaults(val d1: String = "d1", val d2: Int = 2)
+class Secondary(val s: String) {
+    constructor() : this("s")
+}
+class SecondaryWithDefaults(val s: String) {
+    constructor(x: Int = 0) : this(x.toString())
+}
+class SecondaryWithDefaultsNoPrimary {
+    constructor(x: Int) {}
+    constructor(s: String = "") {}
+}
+
+// Bad classes
+
+class NoNoArgConstructor(val s: String) {
+    constructor(x: Int) : this(x.toString())
+}
+class NoArgAndDefault() {
+    constructor(x: Int = 0) : this()
+}
+class DefaultPrimaryAndDefaultSecondary(val s: String = "") {
+    constructor(x: Int = 0) : this(x.toString())
+}
+class SeveralDefaultSecondaries {
+    constructor(x: Int = 0) {}
+    constructor(s: String = "") {}
+    constructor(d: Double = 3.14) {}
+}
+class PrivateConstructor private constructor()
+object Object
+
+// -----------
+
+inline fun <reified T : Any> test() {
+    val instance = T::class.createInstance()
+    assertTrue(instance is T)
+}
+
+inline fun <reified T : Any> testFail() {
+    try {
+        T::class.createInstance()
+        fail("createInstance should have failed on ${T::class}")
+    } catch (e: Exception) {
+        // OK
+    }
+}
+
+fun box(): String {
+    test<Any>()
+    test<Simple>()
+    test<PrimaryWithDefaults>()
+    test<Secondary>()
+    test<SecondaryWithDefaults>()
+    test<SecondaryWithDefaultsNoPrimary>()
+
+    testFail<NoNoArgConstructor>()
+    testFail<NoArgAndDefault>()
+    testFail<DefaultPrimaryAndDefaultSecondary>()
+    testFail<SeveralDefaultSecondaries>()
+    testFail<PrivateConstructor>()
+    testFail<Object>()
+
+    return "OK"
+}
@@ -0,0 +1,53 @@
+// TODO: muted automatically, investigate should it be ran for JS or not
+// IGNORE_BACKEND: JS, NATIVE
+
+// WITH_REFLECT
+// FILE: I.java
+
+public class I {
+    public static void publicStaticI() {}
+    public void publicMemberI() {}
+    private static void privateStaticI() {}
+    private void privateMemberI() {}
+}
+
+// FILE: J.java
+
+public class J extends I {
+    public static void publicStaticJ() {}
+    public void publicMemberJ() {}
+    private static void privateStaticJ() {}
+    private void privateMemberJ() {}
+}
+
+// FILE: K.kt
+
+import kotlin.reflect.full.declaredMembers
+import kotlin.test.assertEquals
+
+open class K : J() {
+    open fun publicKFun() {}
+    private fun privateKFun() {}
+    var publicKProp = Unit
+    private val privateKProp = Unit
+}
+
+class L : K() {
+    fun publicLFun() {}
+    private fun privateLFun() {}
+    val publicLProp = Unit
+    private var privateLProp = Unit
+}
+
+inline fun <reified T> test(vararg names: String) {
+    assertEquals(names.toSet(), T::class.declaredMembers.map { it.name }.toSet())
+}
+
+fun box(): String {
+    test<I>("publicStaticI", "publicMemberI", "privateStaticI", "privateMemberI")
+    test<J>("publicStaticJ", "publicMemberJ", "privateStaticJ", "privateMemberJ")
+    test<K>("publicKFun", "privateKFun", "publicKProp", "privateKProp")
+    test<L>("publicLFun", "privateLFun", "publicLProp", "privateLProp")
+
+    return "OK"
+}
@@ -0,0 +1,45 @@
+// TODO: muted automatically, investigate should it be ran for JS or not
+// IGNORE_BACKEND: JS, NATIVE
+
+// WITH_REFLECT
+
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
+import kotlin.reflect.jvm.jvmName
+
+class Klass {
+    class Nested
+    companion object
+}
+
+fun box(): String {
+    assertEquals("Klass", Klass::class.jvmName)
+    assertEquals("Klass\$Nested", Klass.Nested::class.jvmName)
+    assertEquals("Klass\$Companion", Klass.Companion::class.jvmName)
+
+    assertEquals("java.lang.Object", Any::class.jvmName)
+    assertEquals("int", Int::class.jvmName)
+    assertEquals("[I", IntArray::class.jvmName)
+    assertEquals("java.util.List", List::class.jvmName)
+    assertEquals("java.util.List", MutableList::class.jvmName)
+    assertEquals("java.lang.String", String::class.jvmName)
+    assertEquals("java.lang.String", java.lang.String::class.jvmName)
+
+    assertEquals("[Ljava.lang.Object;", Array<Any>::class.jvmName)
+    assertEquals("[Ljava.lang.Integer;", Array<Int>::class.jvmName)
+    assertEquals("[[Ljava.lang.String;", Array<Array<String>>::class.jvmName)
+
+    assertEquals("java.util.Date", java.util.Date::class.jvmName)
+    assertEquals("kotlin.jvm.internal.Ref\$ObjectRef", kotlin.jvm.internal.Ref.ObjectRef::class.jvmName)
+    assertEquals("java.lang.Void", java.lang.Void::class.jvmName)
+
+    class Local
+    val l = Local::class.jvmName
+    assertTrue(l != null && l.startsWith("JvmNameKt\$") && "\$box\$" in l && l.endsWith("\$Local"))
+
+    val obj = object {}
+    val o = obj.javaClass.kotlin.jvmName
+    assertTrue(o != null && o.startsWith("JvmNameKt\$") && "\$box\$" in o && o.endsWith("\$1"))
+
+    return "OK"
+}
@@ -0,0 +1,42 @@
+// IGNORE_BACKEND: NATIVE
+// WITH_REFLECT
+
+import kotlin.reflect.KClass
+import kotlin.test.assertEquals
+
+fun check(klass: KClass<*>, expectedName: String) {
+    assertEquals(expectedName, klass.simpleName)
+}
+
+fun localInMethod() {
+    fun localInMethod(unused: Any?) {
+        class Local
+        check(Local::class, "Local")
+
+        class `Local$With$Dollars`
+        check(`Local$With$Dollars`::class, "Local\$With\$Dollars")
+    }
+    localInMethod(null)
+
+    class Local
+    check(Local::class, "Local")
+
+    class `Local$With$Dollars`
+    check(`Local$With$Dollars`::class, "Local\$With\$Dollars")
+}
+
+class LocalInConstructor {
+    init {
+        class Local
+        check(Local::class, "Local")
+
+        class `Local$With$Dollars`
+        check(`Local$With$Dollars`::class, "Local\$With\$Dollars")
+    }
+}
+
+fun box(): String {
+    localInMethod()
+    LocalInConstructor()
+    return "OK"
+}
@@ -0,0 +1,62 @@
+// TODO: muted automatically, investigate should it be ran for JS or not
+// IGNORE_BACKEND: JS, NATIVE
+
+// WITH_REFLECT
+// FULL_JDK
+
+import kotlin.reflect.KClass
+import kotlin.reflect.jvm.*
+import kotlin.test.assertEquals
+
+class A {
+    companion object {}
+    inner class Inner
+    class Nested
+    private class PrivateNested
+}
+
+fun nestedNames(c: KClass<*>) = c.nestedClasses.map { it.simpleName ?: throw AssertionError("Unnamed class: ${it.java}") }.sorted()
+
+fun box(): String {
+    // Kotlin class without nested classes
+    assertEquals(emptyList<String>(), nestedNames(A.Inner::class))
+    // Kotlin class with nested classes
+    assertEquals(listOf("Companion", "Inner", "Nested", "PrivateNested"), nestedNames(A::class))
+
+    // Java class without nested classes
+    assertEquals(emptyList<String>(), nestedNames(Error::class))
+    // Java class with nested classes
+    assertEquals(listOf("State", "UncaughtExceptionHandler"), nestedNames(Thread::class))
+
+    // Built-ins
+    assertEquals(emptyList<String>(), nestedNames(Array<Any>::class))
+    assertEquals(emptyList<String>(), nestedNames(CharSequence::class))
+    assertEquals(listOf("Companion"), nestedNames(String::class))
+
+    assertEquals(emptyList<String>(), nestedNames(Collection::class))
+    assertEquals(emptyList<String>(), nestedNames(MutableCollection::class))
+    assertEquals(emptyList<String>(), nestedNames(List::class))
+    assertEquals(emptyList<String>(), nestedNames(MutableList::class))
+    assertEquals(listOf("Entry"), nestedNames(Map::class))
+    assertEquals(emptyList<String>(), nestedNames(Map.Entry::class))
+    assertEquals(emptyList<String>(), nestedNames(MutableMap.MutableEntry::class))
+
+    // TODO: should be MutableEntry. Currently we do not distinguish between Map and MutableMap.
+    assertEquals(listOf("Entry"), nestedNames(MutableMap::class))
+
+    // Primitives
+    for (primitive in listOf(Byte::class, Double::class, Float::class, Int::class, Long::class, Short::class, Char::class)) {
+        assertEquals(listOf("Companion"), nestedNames(primitive))
+    }
+    assertEquals(emptyList<String>(), nestedNames(Boolean::class))
+
+    // Primitive arrays
+    for (primitiveArray in listOf(
+            ByteArray::class, DoubleArray::class, FloatArray::class, IntArray::class,
+            LongArray::class, ShortArray::class, CharArray::class, BooleanArray::class
+    )) {
+        assertEquals(emptyList<String>(), nestedNames(primitiveArray))
+    }
+
+    return "OK"
+}
@@ -0,0 +1,26 @@
+// 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 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,36 @@
+// TODO: muted automatically, investigate should it be ran for JS or not
+// IGNORE_BACKEND: JS, NATIVE
+
+// WITH_REFLECT
+
+import kotlin.test.assertEquals
+
+object Obj {
+    fun foo() = 1
+}
+
+class A {
+    companion object {
+        fun foo() = 2
+    }
+}
+
+class B {
+    companion object Factory {
+        fun foo() = 3
+    }
+}
+
+class C
+
+fun box(): String {
+    assertEquals(1, Obj::class.objectInstance!!.foo())
+    assertEquals(2, A.Companion::class.objectInstance!!.foo())
+    assertEquals(3, B.Factory::class.objectInstance!!.foo())
+
+    assertEquals(null, C::class.objectInstance)
+    assertEquals(null, String::class.objectInstance)
+    assertEquals(Unit, Unit::class.objectInstance)
+
+    return "OK"
+}
@@ -0,0 +1,18 @@
+// TODO: muted automatically, investigate should it be ran for JS or not
+// IGNORE_BACKEND: JS, NATIVE
+
+// WITH_REFLECT
+
+import kotlin.test.assertEquals
+import kotlin.test.assertFalse
+
+fun box(): String {
+    val x = Int::class.javaPrimitiveType!!.kotlin
+    val y = Int::class.javaObjectType.kotlin
+
+    assertEquals(x, y)
+    assertEquals(x.hashCode(), y.hashCode())
+    assertFalse(x === y)
+
+    return "OK"
+}
@@ -0,0 +1,41 @@
+// TODO: muted automatically, investigate should it be ran for JS or not
+// IGNORE_BACKEND: JS, NATIVE
+
+// WITH_REFLECT
+
+import kotlin.test.assertEquals
+
+class Klass {
+    class Nested
+    companion object
+}
+
+fun box(): String {
+    assertEquals("Klass", Klass::class.qualifiedName)
+    assertEquals("Klass.Nested", Klass.Nested::class.qualifiedName)
+    assertEquals("Klass.Companion", Klass.Companion::class.qualifiedName)
+
+    assertEquals("kotlin.Any", Any::class.qualifiedName)
+    assertEquals("kotlin.Int", Int::class.qualifiedName)
+    assertEquals("kotlin.Int.Companion", Int.Companion::class.qualifiedName)
+    assertEquals("kotlin.IntArray", IntArray::class.qualifiedName)
+    assertEquals("kotlin.collections.List", List::class.qualifiedName)
+    assertEquals("kotlin.String", String::class.qualifiedName)
+    assertEquals("kotlin.String", java.lang.String::class.qualifiedName)
+
+    assertEquals("kotlin.Array", Array<Any>::class.qualifiedName)
+    assertEquals("kotlin.Array", Array<Int>::class.qualifiedName)
+    assertEquals("kotlin.Array", Array<Array<String>>::class.qualifiedName)
+
+    assertEquals("java.util.Date", java.util.Date::class.qualifiedName)
+    assertEquals("kotlin.jvm.internal.Ref.ObjectRef", kotlin.jvm.internal.Ref.ObjectRef::class.qualifiedName)
+    assertEquals("java.lang.Void", java.lang.Void::class.qualifiedName)
+
+    class Local
+    assertEquals(null, Local::class.qualifiedName)
+
+    val o = object {}
+    assertEquals(null, o.javaClass.kotlin.qualifiedName)
+
+    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.KTypeProjection
+import kotlin.reflect.full.createType
+import kotlin.reflect.full.starProjectedType
+import kotlin.test.assertEquals
+
+class Foo<K, V>
+
+fun box(): String {
+    val foo = Foo::class.starProjectedType
+    assertEquals(Foo::class, foo.classifier)
+    assertEquals(listOf(KTypeProjection.STAR, KTypeProjection.STAR), foo.arguments)
+    assertEquals(foo, Foo::class.createType(listOf(KTypeProjection.STAR, KTypeProjection.STAR)))
+
+    assertEquals(String::class, String::class.starProjectedType.classifier)
+    assertEquals(listOf(), String::class.starProjectedType.arguments)
+
+    val tp = Foo::class.typeParameters.first()
+    assertEquals(tp.createType(), tp.starProjectedType)
+
+    return "OK"
+}