JS: move more test to box tests

2016-08-30 14:59:26 +03:00
parent 7e2d5b04de
commit 3801052460
112 changed files with 760 additions and 676 deletions
@@ -0,0 +1,4 @@
+package foo
+
+inline fun <reified T> isInstance(x: Any?): Boolean =
+        x is T
@@ -0,0 +1,18 @@
+package foo
+
+// CHECK_NOT_CALLED: test
+// CHECK_NOT_CALLED: test1
+
+class A
+class B
+
+inline fun <reified T> test(x: Any): Boolean = test1<T>(x)
+
+inline fun <reified R> test1(x: Any): Boolean = x is R
+
+fun box(): String {
+    assertEquals(true, test<A>(A()), "test<A>(A())")
+    assertEquals(false, test<A>(B()), "test<A>(B())")
+
+    return "OK"
+}
@@ -0,0 +1,17 @@
+package foo
+
+// CHECK_NOT_CALLED: canBeCastedTo
+
+open class A
+class B
+class C : A()
+
+inline fun <reified T> Any.canBeCastedTo(): Boolean = this is T
+
+fun box(): String {
+    assertEquals(true, A().canBeCastedTo<A>(), "A().canBeCastedTo<A>()")
+    assertEquals(false, A().canBeCastedTo<B>(), "A().canBeCastedTo<B>()")
+    assertEquals(true, C().canBeCastedTo<A>(), "C().canBeCastedTo<A>()")
+
+    return "OK"
+}
@@ -0,0 +1,21 @@
+package foo
+
+class A
+class B
+
+fun <T, R> apply(x: T, fn: T.()->R): R = x.fn()
+
+inline fun <reified T, reified R> test(x: Any, y: Any): Boolean =
+        x is T && apply(y) { this is R }
+
+fun box(): String {
+    val a = A()
+    val b = B()
+
+    assertEquals(true, test<A, B>(a, b), "test<A, B>(a, b)")
+    assertEquals(false, test<A, B>(a, a), "test<A, B>(a, a)")
+    assertEquals(false, test<A, B>(b, b), "test<A, B>(b, b)")
+    assertEquals(false, test<A, B>(b, a), "test<A, B>(b, a)")
+
+    return "OK"
+}
@@ -0,0 +1,27 @@
+package foo
+
+// CHECK_NOT_CALLED: test
+// CHECK_NOT_CALLED: fn
+
+class A(val x: Any? = null) {
+    inline fun <reified T, reified R> test(b: B) = b.fn<T, R>()
+
+    inline fun <reified T, reified R> B.fn() = x is T && y is R
+}
+
+class B(val y: Any? = null)
+
+class X
+class Y
+
+fun box(): String {
+    val x = X()
+    val y = Y()
+
+    assertEquals(true, A(x).test<X, Y>(B(y)), "A(x).test<X, Y>(B(y))")
+    assertEquals(false, A(y).test<X, Y>(B(y)), "A(y).test<X, Y>(B(y))")
+    assertEquals(false, A(y).test<X, Y>(B(x)), "A(y).test<X, Y>(B(x))")
+    assertEquals(false, A(x).test<X, Y>(B(x)), "A(x).test<X, Y>(B(x))")
+
+    return "OK"
+}
@@ -0,0 +1,31 @@
+package foo
+
+// CHECK_NOT_CALLED: typePredicate
+
+open class A
+
+class B
+
+class C : A()
+
+interface TypePredicate {
+    operator fun invoke(x: Any): Boolean
+}
+
+inline fun <reified T> typePredicate(): TypePredicate =
+        object : TypePredicate {
+            override fun invoke(x: Any): Boolean = x is T
+        }
+
+fun box(): String {
+    val isA = typePredicate<A>()
+    val a: Any = A()
+    val b: Any = B()
+    val c: Any = C()
+
+    assertEquals(true, isA(a), "isA(a)")
+    assertEquals(false, isA(b), "isA(b)")
+    assertEquals(true, isA(c), "isA(c)")
+
+    return "OK"
+}
@@ -0,0 +1,15 @@
+package foo
+
+// CHECK_NOT_CALLED: isInstance
+
+fun box(): String {
+    assertEquals(true, isInstance<Boolean>(true))
+    assertEquals(true, isInstance<Boolean>(false))
+    assertEquals(false, isInstance<Boolean>("true"))
+
+    assertEquals(true, isInstance<Boolean?>(true), "isInstance<Boolean?>(true)")
+    assertEquals(true, isInstance<Boolean?>(null), "isInstance<Boolean?>(null)")
+    assertEquals(false, isInstance<Boolean?>("true"), "isInstance<Boolean?>(\"true\")")
+
+    return "OK"
+}
@@ -0,0 +1,15 @@
+package foo
+
+// CHECK_NOT_CALLED: isInstance
+
+fun box(): String {
+    assertEquals(true, isInstance<Char>('c'))
+    assertEquals(false, isInstance<Char>(""))
+    assertEquals(false, isInstance<Char>("cc"))
+
+    assertEquals(true, isInstance<Char?>('c'), "isInstance<Char?>('c')")
+    assertEquals(true, isInstance<Char?>(null), "isInstance<Char?>(null)")
+    assertEquals(false, isInstance<Char?>("cc"), "isInstance<Char?>(\"cc\")")
+
+    return "OK"
+}
@@ -0,0 +1,25 @@
+package foo
+
+// CHECK_NOT_CALLED: isInstance
+
+interface A
+interface B
+
+open class C : A, B
+
+class D : C()
+
+fun box(): String {
+    assertEquals(false, isInstance<A>(0))
+    assertEquals(false, isInstance<A>(""))
+    assertEquals(true, isInstance<A>(C()))
+    assertEquals(true, isInstance<A>(D()))
+    assertEquals(true, isInstance<D>(D()))
+    assertEquals(true, isInstance<C>(D()))
+
+    assertEquals(true, isInstance<D?>(D()), "isInstance<D?>(D())")
+    assertEquals(true, isInstance<D?>(null), "isInstance<D?>(null)")
+    assertEquals(false, isInstance<D?>(C()), "isInstance<D?>(C())")
+
+    return "OK"
+}
@@ -0,0 +1,23 @@
+package foo
+
+// CHECK_NOT_CALLED: isInstance
+
+fun box(): String {
+    assertEquals(true, isInstance<Short>(0.toShort()))
+    assertEquals(true, isInstance<Byte>(0.toByte()))
+    assertEquals(true, isInstance<Int>(0))
+    assertEquals(true, isInstance<Long>(0.toLong()))
+    assertEquals(true, isInstance<Double>(0.toDouble()))
+    assertEquals(true, isInstance<Float>(0.toFloat()))
+
+    assertEquals(true, isInstance<Number>(0))
+    assertEquals(true, isInstance<Number>(0.toLong()))
+    assertEquals(true, isInstance<Number>(0.0))
+    assertEquals(false, isInstance<Number>("0"))
+
+    assertEquals(true, isInstance<Int?>(0), "isInstance<Int?>(0)")
+    assertEquals(true, isInstance<Int?>(null), "isInstance<Int?>(null)")
+    assertEquals(false, isInstance<Int?>(true), "isInstance<Int?>(true)")
+
+    return "OK"
+}
@@ -0,0 +1,14 @@
+package foo
+
+// CHECK_NOT_CALLED: isInstance
+
+fun box(): String {
+    assertEquals(true, isInstance<String>(""))
+    assertEquals(true, isInstance<String>("a"))
+
+    assertEquals(true, isInstance<String?>(""), "isInstance<String?>(\"\")")
+    assertEquals(true, isInstance<String?>(null), "isInstance<String?>(null)")
+    assertEquals(false, isInstance<String?>(10), "isInstance<String?>(10)")
+
+    return "OK"
+}
@@ -0,0 +1,21 @@
+package foo
+
+// CHECK_NOT_CALLED: isTypeOfOrNull
+// CHECK_NULLS_COUNT: function=box count=10
+
+inline
+fun <reified T> Any?.isTypeOfOrNull() = this is T?
+
+class A
+class B
+
+fun box(): String {
+    assertEquals(true, null.isTypeOfOrNull<A>(), "null.isTypeOfOrNull<A>()")
+    assertEquals(true, null.isTypeOfOrNull<A?>(), "null.isTypeOfOrNull<A?>()")
+    assertEquals(true, A().isTypeOfOrNull<A>(), "A().isTypeOfOrNull<A>()")
+    assertEquals(true, A().isTypeOfOrNull<A?>(), "A().isTypeOfOrNull<A?>()")
+    assertEquals(false, A().isTypeOfOrNull<B>(), "A().isTypeOfOrNull<B>()")
+    assertEquals(false, A().isTypeOfOrNull<B?>(), "A().isTypeOfOrNull<B?>()")
+
+    return "OK"
+}
@@ -0,0 +1,39 @@
+package foo
+
+// CHECK_CALLED: doFilter
+// CHECK_NOT_CALLED: filterIsInstance
+
+data class A(val x: Int)
+
+data class B(val x: Int)
+
+// filter from stdlib is not used, because it's important,
+// that filter function is not inline. When lambda is
+// not inlined and captures some local variable,
+// the test crashes on runtime (it's expected behaviour).
+fun <T> Array<T>.doFilter(fn: (T)->Boolean): List<T> {
+    val filtered = arrayListOf<T>()
+
+    for (i in 0..lastIndex) {
+        val element = this[i]
+
+        if (fn(element)) {
+            filtered.add(element)
+        }
+    }
+
+    return filtered
+}
+
+inline fun <reified T> filterIsInstance(arrayOfAnys: Array<Any>): List<T> {
+    return arrayOfAnys.doFilter { it is T }.map { it as T }
+}
+
+fun box(): String {
+    val src: Array<Any> = arrayOf(A(1), B(2), A(3), B(4))
+
+    assertEquals(listOf(A(1), A(3)), filterIsInstance<A>(src))
+    assertEquals(listOf(B(2), B(4)), filterIsInstance<B>(src))
+
+    return "OK"
+}
@@ -0,0 +1,32 @@
+package foo
+
+// CHECK_CALLED: doRun
+// CHECK_NOT_CALLED: test
+
+class X
+class Y
+
+fun <R> doRun(fn: ()->R): R = fn()
+
+inline fun <reified A, reified B> test(x: Any, y: Any): Boolean =
+        doRun {
+            val isA = null
+            x is A
+        }
+        && doRun {
+            val result = y is B
+            val isB = null
+            result
+        }
+
+fun box(): String {
+    val x = X()
+    val y = Y()
+
+    assertEquals(true, test<X, Y>(x, y), "test<X, Y>(x, y)")
+    assertEquals(false, test<X, Y>(x, x), "test<X, Y>(x, x)")
+    assertEquals(false, test<X, Y>(y, x), "test<X, Y>(y, x)")
+    assertEquals(false, test<X, Y>(y, y), "test<X, Y>(y, y)")
+
+    return "OK"
+}
@@ -0,0 +1,16 @@
+package foo
+
+// CHECK_NOT_CALLED: test
+
+class A(val x: Any? = null) {
+    inline fun <reified T> test() = x is T
+}
+
+class B
+
+fun box(): String {
+    assertEquals(true, A(A()).test<A>(), "A(A()).test<A>()")
+    assertEquals(false, A(B()).test<A>(), "A(B()).test<A>()")
+
+    return "OK"
+}
@@ -0,0 +1,20 @@
+package foo
+
+class X
+class Y
+class Z
+
+inline fun <reified A, B, reified C> test(x: Any): String =
+        when (x) {
+            is A -> "A"
+            is C -> "C"
+            else -> "Unknown"
+        }
+
+fun box(): String {
+    assertEquals("A", test<X, Y, Z>(X()))
+    assertEquals("Unknown", test<X, Y, Z>(Y()))
+    assertEquals("C", test<X, Y, Z>(Z()))
+
+    return "OK"
+}
@@ -0,0 +1,18 @@
+package foo
+
+// CHECK_NOT_CALLED: test
+
+class A
+
+inline fun <reified T> test(): String {
+    val a: Any = A()
+
+    return if (a is T) "A" else "Unknown"
+}
+
+fun box(): String {
+    assertEquals("A", test<A>())
+    assertEquals("Unknown", test<String>())
+
+    return "OK"
+}
@@ -0,0 +1,22 @@
+package foo
+
+class A
+class B
+class C
+
+inline fun <reified T, reified R> test(x: Any): String = test1<R, T>(x)
+
+inline fun <reified R, reified T> test1(x: Any): String =
+    when (x) {
+        is R -> "R"
+        is T -> "T"
+        else -> "Unknown"
+    }
+
+fun box(): String {
+    assertEquals("T", test<A, B>(A()), "test<T, R>(T())")
+    assertEquals("R", test<A, B>(B()), "test<T, R>(R())")
+    assertEquals("Unknown", test<A, B>(C()), "test<T, R>(L())")
+
+    return "OK"
+}
@@ -0,0 +1,33 @@
+package foo
+
+// CHECK_NOT_CALLED: test
+
+class A(val x: Int)
+class B(val x: Int)
+
+inline fun <reified T> test(vararg xs: Any): List<T> {
+    val ts = arrayListOf<T>()
+
+    for (x in xs) {
+        if (x is T) {
+            ts.add(x)
+        }
+    }
+
+    return ts
+}
+
+fun box(): String {
+    val a1 = A(1)
+    val b2 = B(2)
+    val a3 = A(3)
+    val b4 = B(4)
+
+    assertEquals(listOf(a1), test<A>(a1, b2), "test(a1, b2)")
+    assertEquals(listOf(b2, b4), test<B>(a1, b2, a3, b4), "test<B>(a1, b2, a3, b4)")
+
+    val objects = arrayOf(a1, b2)
+    assertEquals(listOf(b2, b4), test<B>(a1, a3, *objects, a3, b4), "test<B>(a1, a3, *objects, a3, b4)")
+
+    return "OK"
+}
@@ -0,0 +1,21 @@
+package foo
+
+// NO_INLINE
+// CHECK_CALLED_IN_SCOPE: scope=box function=isInstanceOf
+
+class A
+class B
+
+fun box(): String {
+    val a = A()
+    val b = B()
+
+    assertEquals(true, isInstance<A>(a), "isInstance<A>(a)")
+    assertEquals(false, isInstance<A>(b), "isInstance<A>(b)")
+
+    assertEquals(true, isInstance<A?>(a), "isInstance<A?>(a)")
+    assertEquals(true, isInstance<A?>(null), "isInstance<A?>(null)")
+    assertEquals(false, isInstance<A?>(b), "isInstance<A?>(b)")
+
+    return "OK"
+}