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,17 @@
+// WITH_REFLECT
+
+import kotlin.reflect.jvm.*
+
+enum class E
+
+fun box(): String {
+    try {
+        val c = E::class.constructors.single()
+        c.isAccessible = true
+        c.call()
+        return "Fail: constructing an enum class should not be allowed"
+    }
+    catch (e: Throwable) {
+        return "OK"
+    }
+}
@@ -0,0 +1,45 @@
+// WITH_REFLECT
+
+import kotlin.reflect.*
+import kotlin.reflect.jvm.*
+
+class A {
+    private var foo: String = ""
+}
+
+object O {
+    @JvmStatic
+    private var bar: String = ""
+}
+
+class CounterTest<T>(t: T) {
+    private var baz: String? = ""
+    private var generic: T = t
+}
+
+fun box(): String {
+    val p = A::class.memberProperties.single() as KMutableProperty1<A, String?>
+    p.isAccessible = true
+    try {
+        p.setter.call(A(), null)
+        return "Fail: exception should have been thrown"
+    } catch (e: IllegalArgumentException) {}
+
+
+    val o = O::class.memberProperties.single() as KMutableProperty1<O, String?>
+    o.isAccessible = true
+    try {
+        o.setter.call(O, null)
+        return "Fail: exception should have been thrown"
+    } catch (e: IllegalArgumentException) {}
+
+
+    val c = CounterTest::class.memberProperties.single { it.name == "baz" } as KMutableProperty1<CounterTest<*>, String?>
+    c.isAccessible = true
+    c.setter.call(CounterTest(""), null) // Should not fail, because CounterTest::baz is nullable
+    val d = CounterTest::class.memberProperties.single { it.name == "generic" } as KMutableProperty1<CounterTest<*>, String?>
+    d.isAccessible = true
+    d.setter.call(CounterTest(""), null) // Also should not fail, because we can't be sure about nullability of 'generic'
+
+    return "OK"
+}
@@ -0,0 +1,27 @@
+// WITH_REFLECT
+
+class A
+
+data class D(val s: String)
+
+fun box(): String {
+    val a = A()
+    assert(A::equals.call(a, a))
+    assert(!A::equals.call(a, 0))
+    assert(A::hashCode.call(a) == A::hashCode.call(a))
+    assert(A::toString.call(a).startsWith("A@"))
+
+    assert(D::equals.call(D("foo"), D("foo")))
+    assert(!D::equals.call(D("foo"), D("bar")))
+    assert(D::hashCode.call(D("foo")) == D::hashCode.call(D("foo")))
+    assert(D::toString.call(D("foo")) == "D(s=foo)")
+
+    assert(Int::equals.call(-1, -1))
+    assert(Int::hashCode.call(0) != Int::hashCode.call(1))
+    assert(Int::toString.call(42) == "42")
+
+    assert(String::equals.call("beer", "beer"))
+    String::hashCode.call("beer")
+
+    return String::toString.call("OK")
+}
@@ -0,0 +1,18 @@
+// WITH_REFLECT
+// FULL_JDK
+
+import java.lang.reflect.InvocationTargetException
+
+fun fail(message: String) {
+    throw AssertionError(message)
+}
+
+fun box(): String {
+    try {
+        ::fail.call("OK")
+    } catch (e: InvocationTargetException) {
+        return e.getTargetException().message.toString()
+    }
+
+    return "Fail: no exception was thrown"
+}
@@ -0,0 +1,12 @@
+// WITH_REFLECT
+
+open class A {
+    fun foo() = "OK"
+}
+
+class B : A()
+
+fun box(): String {
+    val foo = B::class.members.single { it.name == "foo" }
+    return foo.call(B()) as String
+}
@@ -0,0 +1,12 @@
+// WITH_REFLECT
+
+open class A<T>(val t: T) {
+    fun foo() = t
+}
+
+class B(s: String) : A<String>(s)
+
+fun box(): String {
+    val foo = B::class.members.single { it.name == "foo" }
+    return foo.call(B("OK")) as String
+}
@@ -0,0 +1,105 @@
+// WITH_REFLECT
+
+import kotlin.reflect.jvm.isAccessible
+import kotlin.reflect.KCallable
+import kotlin.reflect.KFunction
+import kotlin.reflect.KMutableProperty
+
+var foo: String = ""
+
+class A(private var bar: String = "") {
+    fun getBar() = A::bar
+}
+
+object O {
+    @JvmStatic
+    private var baz: String = ""
+
+    @JvmStatic
+    fun getBaz() = (O::class.members.single { it.name == "baz" } as KMutableProperty<*>).apply { isAccessible = true }
+
+    fun getGetBaz() = O::class.members.single { it.name == "getBaz" } as KFunction<*>
+}
+
+fun check(callable: KCallable<*>, vararg args: Any?) {
+    val expected = callable.parameters.size
+    val actual = args.size
+
+    if (expected == actual) {
+        throw AssertionError("Bad test case: expected and actual number of arguments should differ (was $expected vs $actual)")
+    }
+
+    val expectedExceptionMessage = "Callable expects $expected arguments, but $actual were provided."
+
+    try {
+        callable.call(*args)
+        throw AssertionError("Fail: an IllegalArgumentException should have been thrown")
+    } catch (e: IllegalArgumentException) {
+        if (e.message != expectedExceptionMessage) {
+            // This most probably means that we don't check number of passed arguments in reflection
+            // and the default check from Java reflection yields an IllegalArgumentException, but with a not that helpful message
+            throw AssertionError("Fail: an exception with an unrecognized message was thrown: \"${e.message}\"" +
+                                 "\nExpected message was: $expectedExceptionMessage")
+        }
+    }
+}
+
+fun box(): String {
+    check(::box, null)
+    check(::box, "")
+
+    check(::A)
+    check(::A, null, "")
+
+    check(O.getGetBaz())
+    check(O.getGetBaz(), null, "")
+
+
+    val f = ::foo
+    check(f, null)
+    check(f, null, null)
+    check(f, arrayOf<Any?>(null))
+    check(f, "")
+
+    check(f.getter, null)
+    check(f.getter, null, null)
+    check(f.getter, arrayOf<Any?>(null))
+    check(f.getter, "")
+
+    check(f.setter)
+    check(f.setter, null, null)
+    check(f.setter, null, "")
+
+
+    val b = A().getBar()
+
+    check(b)
+    check(b, null, null)
+    check(b, "", "")
+
+    check(b.getter)
+    check(b.getter, null, null)
+    check(b.getter, "", "")
+
+    check(b.setter)
+    check(b.setter, null)
+    check(b.setter, "")
+
+
+    val z = O.getBaz()
+
+    check(z)
+    check(z, null, null)
+    check(z, "", "")
+
+    check(z.getter)
+    check(z.getter, null, null)
+    check(z.getter, "", "")
+
+    check(z.setter)
+    check(z.setter, null)
+    check(z.setter, "")
+
+
+    return "OK"
+}
@@ -0,0 +1,10 @@
+// WITH_REFLECT
+
+class A {
+    class Nested(val result: String)
+    inner class Inner(val result: String)
+}
+
+fun box(): String {
+    return (A::Nested).call("O").result + (A::Inner).call((::A).call(), "K").result
+}
@@ -0,0 +1,19 @@
+// WITH_REFLECT
+
+object Obj {
+    @JvmStatic
+    fun foo() {}
+}
+
+class C {
+    companion object {
+        @JvmStatic
+        fun bar() {}
+    }
+}
+
+fun box(): String {
+    (Obj::class.members.single { it.name == "foo" }).call(Obj)
+    (C.Companion::class.members.single { it.name == "bar" }).call(C.Companion)
+    return "OK"
+}
@@ -0,0 +1,44 @@
+// WITH_REFLECT
+
+object Obj {
+    @JvmStatic
+    fun foo(s: String) {}
+
+    @JvmStatic
+    fun bar() {}
+
+    @JvmStatic
+    fun sly(obj: Obj) {}
+
+    operator fun get(name: String) = Obj::class.members.single { it.name == name }
+}
+
+fun box(): String {
+    // This should succeed
+    (Obj["foo"]).call(Obj, "")
+    (Obj["bar"]).call(Obj)
+    (Obj["sly"]).call(Obj, Obj)
+
+    // This shouldn't: first argument should always be Obj
+    try {
+        (Obj["foo"]).call(null, "")
+        return "Fail foo"
+    } catch (e: IllegalArgumentException) {}
+
+    try {
+        (Obj["bar"]).call("")
+        return "Fail bar"
+    } catch (e: IllegalArgumentException) {}
+
+    try {
+        (Obj["sly"]).call(Obj)
+        return "Fail sly 1"
+    } catch (e: IllegalArgumentException) {}
+
+    try {
+        (Obj["sly"]).call(null, Obj)
+        return "Fail sly 2"
+    } catch (e: IllegalArgumentException) {}
+
+    return "OK"
+}
@@ -0,0 +1,9 @@
+// WITH_REFLECT
+
+fun box(): String {
+    class Local {
+        fun result(s: String) = s
+    }
+
+    return Local::result.call(Local(), "OK")
+}
@@ -0,0 +1,14 @@
+// WITH_REFLECT
+
+var result = "Fail"
+
+class A<T> {
+    fun foo(t: T) {
+        result = t as String
+    }
+}
+
+fun box(): String {
+    (A<String>::foo).call(A<String>(), "OK")
+    return result
+}
@@ -0,0 +1,19 @@
+// WITH_REFLECT
+
+import kotlin.reflect.*
+import kotlin.reflect.jvm.*
+import kotlin.test.*
+
+class A(private var result: String)
+
+fun box(): String {
+    val a = A("abc")
+
+    val p = A::class.declaredMemberProperties.single() as KMutableProperty1<A, String>
+    p.isAccessible = true
+    assertEquals("abc", p.call(a))
+    assertEquals(Unit, p.setter.call(a, "def"))
+    assertEquals("def", p.getter.call(a))
+
+    return "OK"
+}
@@ -0,0 +1,49 @@
+// WITH_REFLECT
+
+import kotlin.reflect.*
+import kotlin.test.assertEquals
+
+val p0 = 1
+val Int.p1: Int get() = this
+class A {
+    val Int.p2: Int get() = this
+}
+
+var globalCounter = 0
+
+var mp0 = 1
+    set(value) { globalCounter += value }
+var Int.mp1: Int
+    get() = this
+    set(value) { globalCounter += value }
+class B {
+    var Int.mp2: Int
+        get() = this
+        set(value) { globalCounter += value }
+}
+
+
+fun box(): String {
+    assertEquals(1, (::p0).call())
+    assertEquals(1, (::p0).getter.call())
+    assertEquals(2, (Int::p1).call(2))
+    assertEquals(2, (Int::p1).getter.call(2))
+    val p2 = A::class.memberExtensionProperties.single()
+    assertEquals(3, p2.call(A(), 3))
+    assertEquals(3, p2.getter.call(A(), 3))
+
+    assertEquals(1, (::mp0).call())
+    assertEquals(1, (::mp0).getter.call())
+    assertEquals(2, (Int::mp1).call(2))
+    assertEquals(2, (Int::mp1).getter.call(2))
+    val mp2 = B::class.memberExtensionProperties.single() as KMutableProperty2
+    assertEquals(3, mp2.call(B(), 3))
+    assertEquals(3, mp2.getter.call(B(), 3))
+
+    assertEquals(Unit, (::mp0).setter.call(1))
+    assertEquals(Unit, (Int::mp1).setter.call(0, 3))
+    assertEquals(Unit, mp2.setter.call(B(), 0, 5))
+    if (globalCounter != 9) return "Fail: $globalCounter"
+
+    return "OK"
+}
@@ -0,0 +1,26 @@
+// WITH_REFLECT
+
+import kotlin.test.assertEquals
+
+fun foo() {}
+
+class A {
+    fun bar() {}
+}
+
+object O {
+    @JvmStatic fun baz() {}
+}
+
+fun nullableUnit(unit: Boolean): Unit? = if (unit) Unit else null
+
+fun box(): String {
+    assertEquals(Unit, ::foo.call())
+    assertEquals(Unit, A::bar.call(A()))
+    assertEquals(Unit, O::class.members.single { it.name == "baz" }.call(O))
+
+    assertEquals(Unit, (::nullableUnit).call(true))
+    assertEquals(null, (::nullableUnit).call(false))
+
+    return "OK"
+}
@@ -0,0 +1,8 @@
+// WITH_REFLECT
+
+class A(val result: String)
+
+fun box(): String {
+    val a = (::A).call("OK")
+    return a.result
+}
@@ -0,0 +1,18 @@
+// WITH_REFLECT
+
+class A {
+    fun foo(x: Int, y: Int) = x + y
+}
+
+fun box(): String {
+    val x = (A::foo).call(A(), 42, 239)
+    if (x != 281) return "Fail: $x"
+
+    try {
+        (A::foo).call()
+        return "Fail: no exception"
+    }
+    catch (e: Exception) {}
+
+    return "OK"
+}
@@ -0,0 +1,29 @@
+// WITH_REFLECT
+
+fun String.foo(): Int = length
+
+var state = "Fail"
+
+fun bar(result: String) {
+    state = result
+}
+
+fun box(): String {
+    val f = (String::foo).call("abc")
+    if (f != 3) return "Fail: $f"
+
+    try {
+        (String::foo).call()
+        return "Fail: IllegalArgumentException should have been thrown"
+    }
+    catch (e: IllegalArgumentException) {}
+
+    try {
+        (String::foo).call(42)
+        return "Fail: IllegalArgumentException should have been thrown"
+    }
+    catch (e: IllegalArgumentException) {}
+
+    (::bar).call("OK")
+    return state
+}