tests: Update external tests (1.1.2-dev-393)
This commit is contained in:
Ilya Matveev
+54
@@ -0,0 +1,54 @@
|
||||
// TODO: muted automatically, investigate should it be ran for JS or not
|
||||
// IGNORE_BACKEND: JS, NATIVE
|
||||
|
||||
// WITH_REFLECT
|
||||
|
||||
import kotlin.test.assertTrue
|
||||
import kotlin.test.assertFalse
|
||||
|
||||
interface Interface {
|
||||
open fun openFun() {}
|
||||
abstract fun abstractFun()
|
||||
}
|
||||
|
||||
abstract class AbstractClass {
|
||||
final val finalVal = Unit
|
||||
open val openVal = Unit
|
||||
abstract var abstractVar: Unit
|
||||
}
|
||||
|
||||
fun box(): String {
|
||||
assertFalse(Interface::openFun.isFinal)
|
||||
assertTrue(Interface::openFun.isOpen)
|
||||
assertFalse(Interface::openFun.isAbstract)
|
||||
|
||||
assertFalse(Interface::abstractFun.isFinal)
|
||||
assertFalse(Interface::abstractFun.isOpen)
|
||||
assertTrue(Interface::abstractFun.isAbstract)
|
||||
|
||||
assertTrue(AbstractClass::finalVal.isFinal)
|
||||
assertFalse(AbstractClass::finalVal.isOpen)
|
||||
assertFalse(AbstractClass::finalVal.isAbstract)
|
||||
assertTrue(AbstractClass::finalVal.getter.isFinal)
|
||||
assertFalse(AbstractClass::finalVal.getter.isOpen)
|
||||
assertFalse(AbstractClass::finalVal.getter.isAbstract)
|
||||
|
||||
assertFalse(AbstractClass::openVal.isFinal)
|
||||
assertTrue(AbstractClass::openVal.isOpen)
|
||||
assertFalse(AbstractClass::openVal.isAbstract)
|
||||
assertFalse(AbstractClass::openVal.getter.isFinal)
|
||||
assertTrue(AbstractClass::openVal.getter.isOpen)
|
||||
assertFalse(AbstractClass::openVal.getter.isAbstract)
|
||||
|
||||
assertFalse(AbstractClass::abstractVar.isFinal)
|
||||
assertFalse(AbstractClass::abstractVar.isOpen)
|
||||
assertTrue(AbstractClass::abstractVar.isAbstract)
|
||||
assertFalse(AbstractClass::abstractVar.getter.isFinal)
|
||||
assertFalse(AbstractClass::abstractVar.getter.isOpen)
|
||||
assertTrue(AbstractClass::abstractVar.getter.isAbstract)
|
||||
assertFalse(AbstractClass::abstractVar.setter.isFinal)
|
||||
assertFalse(AbstractClass::abstractVar.setter.isOpen)
|
||||
assertTrue(AbstractClass::abstractVar.setter.isAbstract)
|
||||
|
||||
return "OK"
|
||||
}
|
||||
+58
@@ -0,0 +1,58 @@
|
||||
// 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.KProperty
|
||||
import kotlin.reflect.KVisibility
|
||||
import kotlin.test.assertEquals
|
||||
|
||||
open class Foo<in T> {
|
||||
public fun publicFun() {}
|
||||
protected fun protectedFun() {}
|
||||
internal fun internalFun() {}
|
||||
private fun privateFun() {}
|
||||
private fun privateToThisFun(): T = null!!
|
||||
|
||||
fun getProtectedFun() = this::protectedFun
|
||||
fun getPrivateFun() = this::privateFun
|
||||
fun getPrivateToThisFun(): KFunction<*> = this::privateToThisFun
|
||||
|
||||
public val publicVal = Unit
|
||||
protected val protectedVar = Unit
|
||||
internal val internalVal = Unit
|
||||
private val privateVal = Unit
|
||||
private val privateToThisVal: T? = null
|
||||
|
||||
fun getProtectedVar() = this::protectedVar
|
||||
fun getPrivateVal() = this::privateVal
|
||||
fun getPrivateToThisVal(): KProperty<*> = this::privateToThisVal
|
||||
|
||||
public var publicVarPrivateSetter = Unit
|
||||
private set
|
||||
|
||||
fun getPublicVarPrivateSetter() = this::publicVarPrivateSetter
|
||||
}
|
||||
|
||||
fun box(): String {
|
||||
val f = Foo<String>()
|
||||
|
||||
assertEquals(KVisibility.PUBLIC, f::publicFun.visibility)
|
||||
assertEquals(KVisibility.PROTECTED, f.getProtectedFun().visibility)
|
||||
assertEquals(KVisibility.INTERNAL, f::internalFun.visibility)
|
||||
assertEquals(KVisibility.PRIVATE, f.getPrivateFun().visibility)
|
||||
assertEquals(KVisibility.PRIVATE, f.getPrivateToThisFun().visibility)
|
||||
|
||||
assertEquals(KVisibility.PUBLIC, f::publicVal.visibility)
|
||||
assertEquals(KVisibility.PROTECTED, f.getProtectedVar().visibility)
|
||||
assertEquals(KVisibility.INTERNAL, f::internalVal.visibility)
|
||||
assertEquals(KVisibility.PRIVATE, f.getPrivateVal().visibility)
|
||||
assertEquals(KVisibility.PRIVATE, f.getPrivateToThisVal().visibility)
|
||||
|
||||
assertEquals(KVisibility.PUBLIC, f.getPublicVarPrivateSetter().visibility)
|
||||
assertEquals(KVisibility.PUBLIC, f.getPublicVarPrivateSetter().getter.visibility)
|
||||
assertEquals(KVisibility.PRIVATE, f.getPublicVarPrivateSetter().setter.visibility)
|
||||
|
||||
return "OK"
|
||||
}
|
||||
+59
@@ -0,0 +1,59 @@
|
||||
// TODO: muted automatically, investigate should it be ran for JS or not
|
||||
// IGNORE_BACKEND: JS, NATIVE
|
||||
|
||||
// WITH_REFLECT
|
||||
|
||||
import kotlin.test.assertTrue
|
||||
import kotlin.test.assertFalse
|
||||
|
||||
class FinalClass {
|
||||
companion object Companion
|
||||
}
|
||||
open class OpenClass
|
||||
abstract class AbstractClass
|
||||
interface Interface
|
||||
enum class EnumClass
|
||||
enum class EnumClassWithAbstractMember { ; abstract fun foo() }
|
||||
annotation class AnnotationClass
|
||||
object Object
|
||||
|
||||
fun box(): String {
|
||||
assertTrue(FinalClass::class.isFinal)
|
||||
assertFalse(FinalClass::class.isOpen)
|
||||
assertFalse(FinalClass::class.isAbstract)
|
||||
|
||||
assertTrue(FinalClass.Companion::class.isFinal)
|
||||
assertFalse(FinalClass.Companion::class.isOpen)
|
||||
assertFalse(FinalClass.Companion::class.isAbstract)
|
||||
|
||||
assertFalse(OpenClass::class.isFinal)
|
||||
assertTrue(OpenClass::class.isOpen)
|
||||
assertFalse(OpenClass::class.isAbstract)
|
||||
|
||||
assertFalse(AbstractClass::class.isFinal)
|
||||
assertFalse(AbstractClass::class.isOpen)
|
||||
assertTrue(AbstractClass::class.isAbstract)
|
||||
|
||||
assertFalse(Interface::class.isFinal)
|
||||
assertFalse(Interface::class.isOpen)
|
||||
assertTrue(Interface::class.isAbstract)
|
||||
|
||||
assertTrue(EnumClass::class.isFinal)
|
||||
assertFalse(EnumClass::class.isOpen)
|
||||
assertFalse(EnumClass::class.isAbstract)
|
||||
|
||||
assertTrue(EnumClassWithAbstractMember::class.isFinal)
|
||||
assertFalse(EnumClassWithAbstractMember::class.isOpen)
|
||||
assertFalse(EnumClassWithAbstractMember::class.isAbstract)
|
||||
|
||||
// Note that unlike in JVM, annotation classes are final in Kotlin
|
||||
assertTrue(AnnotationClass::class.isFinal)
|
||||
assertFalse(AnnotationClass::class.isOpen)
|
||||
assertFalse(AnnotationClass::class.isAbstract)
|
||||
|
||||
assertTrue(Object::class.isFinal)
|
||||
assertFalse(Object::class.isOpen)
|
||||
assertFalse(Object::class.isAbstract)
|
||||
|
||||
return "OK"
|
||||
}
|
||||
+32
@@ -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.KClass
|
||||
import kotlin.reflect.KVisibility
|
||||
import kotlin.test.assertEquals
|
||||
|
||||
class DefaultVisibilityClass
|
||||
public class PublicClass {
|
||||
protected class ProtectedClass
|
||||
fun getProtectedClass(): KClass<*> = ProtectedClass::class
|
||||
}
|
||||
internal class InternalClass
|
||||
private class PrivateClass
|
||||
|
||||
fun box(): String {
|
||||
assertEquals(KVisibility.PUBLIC, DefaultVisibilityClass::class.visibility)
|
||||
assertEquals(KVisibility.PUBLIC, PublicClass::class.visibility)
|
||||
assertEquals(KVisibility.PROTECTED, PublicClass().getProtectedClass().visibility)
|
||||
assertEquals(KVisibility.INTERNAL, InternalClass::class.visibility)
|
||||
assertEquals(KVisibility.PRIVATE, PrivateClass::class.visibility)
|
||||
|
||||
class Local
|
||||
assertEquals(null, Local::class.visibility)
|
||||
|
||||
val anonymous = object {}
|
||||
assertEquals(null, anonymous::class.visibility)
|
||||
|
||||
return "OK"
|
||||
}
|
||||
@@ -0,0 +1,46 @@
|
||||
// TODO: muted automatically, investigate should it be ran for JS or not
|
||||
// IGNORE_BACKEND: JS, NATIVE
|
||||
|
||||
// WITH_REFLECT
|
||||
|
||||
import kotlin.test.assertTrue
|
||||
import kotlin.test.assertFalse
|
||||
|
||||
sealed class S {
|
||||
data class DataClass(val x: Int) : S()
|
||||
inner class InnerClass
|
||||
companion object
|
||||
object NonCompanionObject
|
||||
}
|
||||
|
||||
fun box(): String {
|
||||
assertTrue(S::class.isSealed)
|
||||
assertFalse(S::class.isFinal)
|
||||
assertFalse(S::class.isOpen)
|
||||
assertFalse(S::class.isAbstract)
|
||||
assertFalse(S::class.isData)
|
||||
assertFalse(S::class.isInner)
|
||||
assertFalse(S::class.isCompanion)
|
||||
|
||||
assertFalse(S.DataClass::class.isSealed)
|
||||
assertTrue(S.DataClass::class.isData)
|
||||
assertFalse(S.DataClass::class.isInner)
|
||||
assertFalse(S.DataClass::class.isCompanion)
|
||||
|
||||
assertFalse(S.InnerClass::class.isSealed)
|
||||
assertFalse(S.InnerClass::class.isData)
|
||||
assertTrue(S.InnerClass::class.isInner)
|
||||
assertFalse(S.InnerClass::class.isCompanion)
|
||||
|
||||
assertFalse(S.Companion::class.isSealed)
|
||||
assertFalse(S.Companion::class.isData)
|
||||
assertFalse(S.Companion::class.isInner)
|
||||
assertTrue(S.Companion::class.isCompanion)
|
||||
|
||||
assertFalse(S.NonCompanionObject::class.isSealed)
|
||||
assertFalse(S.NonCompanionObject::class.isData)
|
||||
assertFalse(S.NonCompanionObject::class.isInner)
|
||||
assertFalse(S.NonCompanionObject::class.isCompanion)
|
||||
|
||||
return "OK"
|
||||
}
|
||||
@@ -0,0 +1,62 @@
|
||||
// TODO: muted automatically, investigate should it be ran for JS or not
|
||||
// IGNORE_BACKEND: JS, NATIVE
|
||||
|
||||
// WITH_REFLECT
|
||||
|
||||
import kotlin.test.assertTrue
|
||||
import kotlin.test.assertFalse
|
||||
|
||||
inline fun inline() {}
|
||||
class External { external fun external() }
|
||||
operator fun Unit.invoke() {}
|
||||
infix fun Unit.infix(unit: Unit) {}
|
||||
// TODO: support or prohibit references to suspend functions
|
||||
// class Suspend { suspend fun suspend(c: Continuation<Unit>) {} }
|
||||
|
||||
val externalGetter = Unit
|
||||
external get
|
||||
|
||||
inline var inlineProperty: Unit
|
||||
get() = Unit
|
||||
set(value) {}
|
||||
|
||||
fun box(): String {
|
||||
assertTrue(::inline.isInline)
|
||||
assertFalse(::inline.isExternal)
|
||||
assertFalse(::inline.isOperator)
|
||||
assertFalse(::inline.isInfix)
|
||||
assertFalse(::inline.isSuspend)
|
||||
|
||||
assertFalse(External::external.isInline)
|
||||
assertTrue(External::external.isExternal)
|
||||
assertFalse(External::external.isOperator)
|
||||
assertFalse(External::external.isInfix)
|
||||
assertFalse(External::external.isSuspend)
|
||||
|
||||
assertFalse(Unit::invoke.isInline)
|
||||
assertFalse(Unit::invoke.isExternal)
|
||||
assertTrue(Unit::invoke.isOperator)
|
||||
assertFalse(Unit::invoke.isInfix)
|
||||
assertFalse(Unit::invoke.isSuspend)
|
||||
|
||||
assertFalse(Unit::infix.isInline)
|
||||
assertFalse(Unit::infix.isExternal)
|
||||
assertFalse(Unit::infix.isOperator)
|
||||
assertTrue(Unit::infix.isInfix)
|
||||
assertFalse(Unit::infix.isSuspend)
|
||||
|
||||
// assertFalse(Suspend::suspend.isInline)
|
||||
// assertFalse(Suspend::suspend.isExternal)
|
||||
// assertFalse(Suspend::suspend.isOperator)
|
||||
// assertFalse(Suspend::suspend.isInfix)
|
||||
// assertTrue(Suspend::suspend.isSuspend)
|
||||
|
||||
assertTrue(::externalGetter.getter.isExternal)
|
||||
assertFalse(::externalGetter.getter.isInline)
|
||||
|
||||
assertFalse(::inlineProperty.getter.isExternal)
|
||||
assertTrue(::inlineProperty.getter.isInline)
|
||||
assertTrue(::inlineProperty.setter.isInline)
|
||||
|
||||
return "OK"
|
||||
}
|
||||
+36
@@ -0,0 +1,36 @@
|
||||
// TODO: muted automatically, investigate should it be ran for JS or not
|
||||
// IGNORE_BACKEND: JS, NATIVE
|
||||
|
||||
// WITH_REFLECT
|
||||
// FILE: J.java
|
||||
|
||||
class J {
|
||||
protected class C {}
|
||||
protected static class D {}
|
||||
|
||||
void foo() {}
|
||||
protected void bar() {}
|
||||
protected static void baz() {}
|
||||
}
|
||||
|
||||
// FILE: K.kt
|
||||
|
||||
import kotlin.test.assertEquals
|
||||
|
||||
fun box(): String {
|
||||
// Package-private class
|
||||
assertEquals(null, J::class.visibility)
|
||||
// Protected+package class
|
||||
assertEquals(null, J.C::class.visibility)
|
||||
// Protected static class
|
||||
assertEquals(null, J.D::class.visibility)
|
||||
|
||||
// Package-private method
|
||||
assertEquals(null, J::foo.visibility)
|
||||
// Protected+package method
|
||||
assertEquals(null, J::bar.visibility)
|
||||
// Protected static method
|
||||
assertEquals(null, J::baz.visibility)
|
||||
|
||||
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.test.assertTrue
|
||||
import kotlin.test.assertFalse
|
||||
|
||||
const val const = "const"
|
||||
val nonConst = "nonConst"
|
||||
|
||||
class A {
|
||||
lateinit var lateinit: Unit
|
||||
var nonLateinit = Unit
|
||||
}
|
||||
|
||||
fun box(): String {
|
||||
assertTrue(::const.isConst)
|
||||
assertFalse(::nonConst.isConst)
|
||||
|
||||
assertTrue(A::lateinit.isLateinit)
|
||||
assertFalse(A::nonLateinit.isLateinit)
|
||||
|
||||
return "OK"
|
||||
}
|
||||
+18
@@ -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.assertTrue
|
||||
import kotlin.test.assertFalse
|
||||
|
||||
class A {
|
||||
fun <T> nonReified(): T = null!!
|
||||
inline fun <reified U> reified(): U = null!!
|
||||
}
|
||||
|
||||
fun box(): String {
|
||||
assertFalse(A::class.members.single { it.name == "nonReified" }.typeParameters.single().isReified)
|
||||
assertTrue(A::class.members.single { it.name == "reified" }.typeParameters.single().isReified)
|
||||
return "OK"
|
||||
}
|
||||
Reference in New Issue
Block a user