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,52 @@
+// WITH_RUNTIME
+
+import kotlin.test.assertEquals
+
+enum class BigEnum {
+    ITEM1, ITEM2, ITEM3, ITEM4, ITEM5, ITEM6, ITEM7, ITEM8, ITEM9, ITEM10,
+    ITEM11, ITEM12, ITEM13, ITEM14, ITEM15, ITEM16, ITEM17, ITEM18, ITEM19, ITEM20
+}
+
+fun bar1(x : BigEnum) : String {
+    when (x) {
+        BigEnum.ITEM1, BigEnum.ITEM2, BigEnum.ITEM3 -> return "123"
+        BigEnum.ITEM4, BigEnum.ITEM5, BigEnum.ITEM6 -> return "456"
+    }
+
+    return "-1";
+
+}
+
+fun bar2(x : BigEnum) : String {
+    when (x) {
+        BigEnum.ITEM7, BigEnum.ITEM8, BigEnum.ITEM9 -> return "789"
+        BigEnum.ITEM10 -> return "10"
+        BigEnum.ITEM11, BigEnum.ITEM12 -> return "1112"
+        else -> return "-1"
+    }
+}
+
+fun box() : String {
+    //bar1
+    assertEquals("123", bar1(BigEnum.ITEM1))
+    assertEquals("123", bar1(BigEnum.ITEM2))
+    assertEquals("123", bar1(BigEnum.ITEM3))
+
+    assertEquals("456", bar1(BigEnum.ITEM4))
+    assertEquals("456", bar1(BigEnum.ITEM5))
+    assertEquals("456", bar1(BigEnum.ITEM6))
+
+    assertEquals("-1", bar1(BigEnum.ITEM7))
+
+    //bar2
+    assertEquals("789", bar2(BigEnum.ITEM7))
+    assertEquals("789", bar2(BigEnum.ITEM8))
+    assertEquals("789", bar2(BigEnum.ITEM9))
+
+    assertEquals("10", bar2(BigEnum.ITEM10))
+
+    assertEquals("1112", bar2(BigEnum.ITEM11))
+    assertEquals("1112", bar2(BigEnum.ITEM12))
+
+    return "OK"
+}
@@ -0,0 +1,27 @@
+// WITH_RUNTIME
+
+import kotlin.test.assertEquals
+
+enum class Season {
+    WINTER,
+    SPRING,
+    SUMMER,
+    AUTUMN
+}
+
+fun bar(x : Season) : String {
+    when (x) {
+        Season.WINTER, Season.SPRING -> return "winter_spring"
+        Season.SUMMER, Season.SPRING -> return "summer"
+        else -> return "autumn"
+    }
+}
+
+fun box() : String {
+    assertEquals("winter_spring", bar(Season.WINTER))
+    assertEquals("winter_spring", bar(Season.SPRING))
+    assertEquals("summer", bar(Season.SUMMER))
+    assertEquals("autumn", bar(Season.AUTUMN))
+
+    return "OK"
+}
@@ -0,0 +1,31 @@
+// WITH_RUNTIME
+
+import kotlin.test.assertEquals
+
+class A {
+    companion object {
+        enum class Season {
+            WINTER,
+            SPRING,
+            SUMMER,
+            AUTUMN
+        }
+    }
+}
+
+fun foo(x : A.Companion.Season) : String {
+    return when (x) {
+        A.Companion.Season.WINTER -> "winter"
+        A.Companion.Season.SPRING -> "spring"
+        A.Companion.Season.SUMMER -> "summer"
+        else -> "other"
+    }
+}
+
+fun box() : String {
+    assertEquals("winter", foo(A.Companion.Season.WINTER))
+    assertEquals("spring", foo(A.Companion.Season.SPRING))
+    assertEquals("summer", foo(A.Companion.Season.SUMMER))
+    assertEquals("other", foo(A.Companion.Season.AUTUMN))
+    return "OK"
+}
@@ -0,0 +1,39 @@
+// WITH_RUNTIME
+
+import kotlin.test.assertEquals
+
+enum class Season {
+    WINTER,
+    SPRING,
+    SUMMER,
+    AUTUMN
+}
+
+fun bar1(x : Season) : String {
+    return when (x) {
+        Season.WINTER, Season.SPRING -> "winter_spring"
+        Season.SUMMER -> "summer"
+        else -> "autumn"
+    }
+}
+
+fun bar2(x : Season) : String {
+    return when (x) {
+        Season.WINTER, Season.SPRING -> "winter_spring"
+        Season.SUMMER -> "summer"
+        Season.AUTUMN -> "autumn"
+    }
+}
+
+fun box() : String {
+    assertEquals("winter_spring", bar1(Season.WINTER))
+    assertEquals("winter_spring", bar1(Season.SPRING))
+    assertEquals("summer", bar1(Season.SUMMER))
+    assertEquals("autumn", bar1(Season.AUTUMN))
+
+    assertEquals("winter_spring", bar2(Season.WINTER))
+    assertEquals("winter_spring", bar2(Season.SPRING))
+    assertEquals("summer", bar2(Season.SUMMER))
+    assertEquals("autumn", bar2(Season.AUTUMN))
+    return "OK"
+}
@@ -0,0 +1,17 @@
+enum class Season {
+    WINTER,
+    SPRING,
+    SUMMER,
+    AUTUMN
+}
+
+fun foo(x : Season, block : (Season) -> String) = block(x)
+
+fun box() : String {
+    return foo(Season.SPRING) {
+        x -> when (x) {
+            Season.SPRING -> "OK"
+            else -> "fail"
+        }
+    }
+}
@@ -0,0 +1,52 @@
+// WITH_RUNTIME
+
+import kotlin.test.assertEquals
+
+enum class Season {
+    WINTER,
+    SPRING,
+    SUMMER,
+    AUTUMN
+}
+
+class A {
+    public fun bar1(x : Season) : String {
+        when (x) {
+            Season.WINTER, Season.SPRING -> return "winter_spring"
+            Season.SPRING -> return "spring"
+            Season.SUMMER -> return "summer"
+        }
+
+        return "autumn";
+    }
+
+    public fun bar2(y : Season) : String {
+        return bar3(y) { x ->
+            when (x) {
+                Season.WINTER, Season.SPRING -> "winter_spring"
+                Season.SPRING -> "spring"
+                Season.SUMMER -> "summer"
+                else -> "autumn"
+            }
+        }
+    }
+
+    private fun bar3(x : Season, block : (Season) -> String) = block(x)
+}
+
+fun box() : String {
+    val a = A()
+
+    assertEquals("winter_spring", a.bar1(Season.WINTER))
+    assertEquals("winter_spring", a.bar1(Season.SPRING))
+    assertEquals("summer", a.bar1(Season.SUMMER))
+    assertEquals("autumn", a.bar1(Season.AUTUMN))
+
+    assertEquals("winter_spring", a.bar2(Season.WINTER))
+    assertEquals("winter_spring", a.bar2(Season.SPRING))
+    assertEquals("summer", a.bar2(Season.SUMMER))
+    assertEquals("autumn", a.bar2(Season.AUTUMN))
+
+
+    return "OK"
+}
@@ -0,0 +1,42 @@
+// WITH_RUNTIME
+
+import kotlin.test.assertEquals
+
+enum class Season {
+    WINTER,
+    SPRING,
+    SUMMER,
+    AUTUMN
+}
+
+fun foo1(x : Season?) : String {
+    when(x) {
+        Season.AUTUMN, Season.SPRING -> return "autumn_or_spring";
+        Season.SUMMER, null -> return "summer_or_null"
+    }
+
+    return "other"
+}
+
+fun foo2(x : Season?) : String {
+    when(x) {
+        Season.AUTUMN, Season.SPRING -> return "autumn_or_spring";
+        Season.SUMMER -> return "summer"
+    }
+
+    return "other"
+}
+
+fun box() : String {
+    assertEquals("autumn_or_spring", foo1(Season.AUTUMN))
+    assertEquals("autumn_or_spring", foo1(Season.SPRING))
+    assertEquals("summer_or_null", foo1(Season.SUMMER))
+    assertEquals("summer_or_null", foo1(null))
+
+    assertEquals("autumn_or_spring", foo2(Season.AUTUMN))
+    assertEquals("autumn_or_spring", foo2(Season.SPRING))
+    assertEquals("summer", foo2(Season.SUMMER))
+    assertEquals("other", foo2(null))
+
+    return "OK"
+}
@@ -0,0 +1,28 @@
+// WITH_RUNTIME
+
+import kotlin.test.assertEquals
+
+enum class Season {
+    WINTER,
+    SPRING,
+    SUMMER,
+    AUTUMN
+}
+
+fun foo(x : Any) : String {
+    return when (x) {
+        Season.WINTER -> "winter"
+        Season.SPRING -> "spring"
+        Season.SUMMER -> "summer"
+        else -> "other"
+    }
+}
+
+fun box() : String {
+    assertEquals("winter", foo(Season.WINTER))
+    assertEquals("spring", foo(Season.SPRING))
+    assertEquals("summer", foo(Season.SUMMER))
+    assertEquals("other", foo(Season.AUTUMN))
+    assertEquals("other", foo(123))
+    return "OK"
+}
@@ -0,0 +1,43 @@
+// WITH_RUNTIME
+
+import kotlin.test.assertEquals
+
+enum class Season {
+    WINTER,
+    SPRING,
+    SUMMER,
+    AUTUMN
+}
+
+fun bar1(x : Season) : String {
+    when (x) {
+        Season.WINTER, Season.SPRING -> return "winter_spring"
+        Season.SPRING -> return "spring"
+        Season.SUMMER -> return "summer"
+    }
+    return "autumn"
+}
+
+fun bar2(x : Season) : String {
+    when (x) {
+        Season.WINTER, Season.SPRING -> return "winter_spring"
+        Season.SPRING -> return "spring"
+        Season.SUMMER -> return "summer"
+        Season.AUTUMN -> return "autumn"
+    }
+
+    return "fail unknown"
+}
+
+fun box() : String {
+    assertEquals("winter_spring", bar1(Season.WINTER))
+    assertEquals("winter_spring", bar1(Season.SPRING))
+    assertEquals("summer", bar1(Season.SUMMER))
+    assertEquals("autumn", bar1(Season.AUTUMN))
+
+    assertEquals("winter_spring", bar2(Season.WINTER))
+    assertEquals("winter_spring", bar2(Season.SPRING))
+    assertEquals("summer", bar2(Season.SUMMER))
+    assertEquals("autumn", bar2(Season.AUTUMN))
+    return "OK"
+}
@@ -0,0 +1,25 @@
+// WITH_RUNTIME
+
+fun foo1(x: Int): Boolean {
+    when(x) {
+        2 + 2 -> return true
+        else -> return false
+    }
+}
+
+fun foo2(x: Int): Boolean {
+    when(x) {
+        Integer.MAX_VALUE -> return true
+        else -> return false
+    }
+}
+
+fun box(): String {
+    assert(foo1(4))
+    assert(!foo1(1))
+
+    assert(foo2(Integer.MAX_VALUE))
+    assert(!foo2(1))
+
+    return "OK"
+}
@@ -0,0 +1,22 @@
+// WITH_RUNTIME
+
+class A
+
+class B(val items: Collection<A>)
+
+class C {
+    fun foo(p: Int) {
+        when (p) {
+            1 -> arrayListOf<Int>().add(1)
+        }
+    }
+
+    fun bar() = B(listOf<A>().map { it })
+}
+
+fun box(): String {
+    C().foo(1)
+    if (C().bar().items.isNotEmpty()) return "fail"
+
+    return "OK"
+}
@@ -0,0 +1,21 @@
+// WITH_RUNTIME
+
+import kotlin.test.assertEquals
+
+fun foo(x : String) : String {
+    when (x) {
+        "abc" -> return "abc"
+        "efg", "ghi", "abc" -> return "efg_ghi"
+        else -> return "other"
+    }
+}
+
+fun box() : String {
+    assertEquals("abc", foo("abc"))
+    assertEquals("efg_ghi", foo("efg"))
+    assertEquals("efg_ghi", foo("ghi"))
+
+    assertEquals("other", foo("xyz"))
+
+    return "OK"
+}
@@ -0,0 +1,26 @@
+// WITH_RUNTIME
+
+import kotlin.test.assertEquals
+
+fun foo(x : String) : String {
+    assert("abz]".hashCode() == "aby|".hashCode())
+
+    when (x) {
+        "abz]" -> return "abz"
+        "ghi"  -> return "ghi"
+        "aby|" -> return "aby"
+        "abz]" -> return "fail"
+    }
+
+    return "other"
+}
+
+fun box() : String {
+    assertEquals("abz", foo("abz]"))
+    assertEquals("aby", foo("aby|"))
+    assertEquals("ghi", foo("ghi"))
+
+    assertEquals("other", foo("xyz"))
+
+    return "OK"
+}
@@ -0,0 +1,22 @@
+// WITH_RUNTIME
+
+import kotlin.test.assertEquals
+
+fun foo(x : String) : String {
+    return when (x) {
+        "abc", "cde" -> "abc_cde"
+        "efg", "ghi" -> "efg_ghi"
+        else -> "other"
+    }
+}
+
+fun box() : String {
+    assertEquals("abc_cde", foo("abc"))
+    assertEquals("abc_cde", foo("cde"))
+    assertEquals("efg_ghi", foo("efg"))
+    assertEquals("efg_ghi", foo("ghi"))
+
+    assertEquals("other", foo("xyz"))
+
+    return "OK"
+}
@@ -0,0 +1,43 @@
+// WITH_RUNTIME
+
+import kotlin.test.assertEquals
+
+fun foo1(x : String?) : String {
+    when (x) {
+        "abc", "cde" -> return "abc_cde"
+        "efg", "ghi", null -> return "efg_ghi"
+    }
+
+    return "other"
+}
+
+fun foo2(x : String?) : String {
+    when (x) {
+        "abc", "cde" -> return "abc_cde"
+        "efg", "ghi" -> return "efg_ghi"
+        else -> return "other"
+    }
+}
+
+fun box() : String {
+    //foo1
+    assertEquals("abc_cde", foo1("abc"))
+    assertEquals("abc_cde", foo1("cde"))
+    assertEquals("efg_ghi", foo1("efg"))
+    assertEquals("efg_ghi", foo1("ghi"))
+    assertEquals("efg_ghi", foo1(null))
+
+    assertEquals("other",   foo1("xyz"))
+
+    //foo2
+    assertEquals("abc_cde", foo2("abc"))
+    assertEquals("abc_cde", foo2("cde"))
+    assertEquals("efg_ghi", foo2("efg"))
+    assertEquals("efg_ghi", foo2("ghi"))
+
+
+    assertEquals("other",   foo2("xyz"))
+    assertEquals("other",   foo2(null))
+
+    return "OK"
+}
@@ -0,0 +1,25 @@
+// WITH_RUNTIME
+
+import kotlin.test.assertEquals
+
+fun foo(x : String) : String {
+    assert("abz]".hashCode() == "aby|".hashCode())
+
+    when (x) {
+        "abz]", "cde" -> return "abz_cde"
+        "aby|", "ghi", "abz]" -> return "aby_ghi"
+    }
+
+    return "other"
+}
+
+fun box() : String {
+    assertEquals("abz_cde", foo("abz]"))
+    assertEquals("abz_cde", foo("cde"))
+    assertEquals("aby_ghi", foo("aby|"))
+    assertEquals("aby_ghi", foo("ghi"))
+
+    assertEquals("other", foo("xyz"))
+
+    return "OK"
+}
@@ -0,0 +1,40 @@
+// WITH_RUNTIME
+
+import kotlin.test.assertEquals
+
+fun foo1(x : String) : String {
+    when (x) {
+        "abc", "cde" -> return "abc_cde"
+        "efg", "ghi" -> return "efg_ghi"
+    }
+
+    return "other"
+}
+
+fun foo2(x : String) : String {
+    when (x) {
+        "abc", "cde" -> return "abc_cde"
+        "efg", "ghi" -> return "efg_ghi"
+        else -> return "other"
+    }
+}
+
+fun box() : String {
+    //foo1
+    assertEquals("abc_cde", foo1("abc"))
+    assertEquals("abc_cde", foo1("cde"))
+    assertEquals("efg_ghi", foo1("efg"))
+    assertEquals("efg_ghi", foo1("ghi"))
+
+    assertEquals("other", foo1("xyz"))
+
+    //foo2
+    assertEquals("abc_cde", foo2("abc"))
+    assertEquals("abc_cde", foo2("cde"))
+    assertEquals("efg_ghi", foo2("efg"))
+    assertEquals("efg_ghi", foo2("ghi"))
+
+    assertEquals("other", foo2("xyz"))
+
+    return "OK"
+}
@@ -0,0 +1,26 @@
+// WITH_RUNTIME
+
+import java.util.ArrayList
+
+fun dense(x: Int): Int {
+    return when (x) {
+        -4 -> 9
+        -1 -> 10
+        0 -> 11
+        1 -> 12
+        4 -> 13
+        5 -> 14
+        6 -> 15
+        7 -> 16
+        8 -> 17
+        9 -> 18
+        else -> 19
+    }
+}
+
+fun box(): String {
+    var result = (-5..10).map(::dense).joinToString()
+
+    if (result != "19, 9, 19, 19, 10, 11, 12, 19, 19, 13, 14, 15, 16, 17, 18, 19") return "dense:" + result
+    return "OK"
+}
@@ -0,0 +1,17 @@
+// WITH_RUNTIME
+
+fun foo(x: Int): Int {
+    return when (x) {
+        1, 2, 3 -> 1
+        4, 5, 6 -> 2
+        7, 8, 9 -> 3
+        else -> 4
+    }
+}
+
+fun box(): String {
+    var result = (0..10).map(::foo).joinToString()
+
+    if (result != "4, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4") return result
+    return "OK"
+}
@@ -0,0 +1,19 @@
+// WITH_RUNTIME
+
+import java.util.ArrayList
+
+fun sparse(x: Int): Int {
+    return when ((x % 4) * 100) {
+        100 -> 1
+        200 -> 2
+        300 -> 3
+        else -> 4
+    }
+}
+
+fun box(): String {
+    var result = (0..3).map(::sparse).joinToString()
+
+    if (result != "4, 1, 2, 3") return "sparse:" + result
+    return "OK"
+}
@@ -0,0 +1,35 @@
+// WITH_RUNTIME
+
+fun exhaustive(x: Int): Int {
+    var r: Int
+    when (x) {
+        1 -> r = 1
+        2 -> r = 2
+        3 -> r = 3
+        else -> r = 4
+    }
+
+    return r
+}
+
+fun nonExhaustive(x: Int): Int {
+    var r: Int = 4
+    when (x) {
+        1 -> r = 1
+        2 -> r = 2
+        3 -> r = 3
+    }
+
+    return r
+}
+
+fun box(): String {
+    var result = (0..3).map(::exhaustive).joinToString()
+
+    if (result != "4, 1, 2, 3") return "exhaustive:" + result
+
+    result = (0..3).map(::nonExhaustive).joinToString()
+
+    if (result != "4, 1, 2, 3") return "non-exhaustive:" + result
+    return "OK"
+}
@@ -0,0 +1,56 @@
+// WITH_RUNTIME
+
+fun intFoo(x: Int): Int {
+    return when (x) {
+        1 -> 5
+        2 -> 6
+        3 -> 7
+        else -> 8
+    }
+}
+
+fun shortFoo(x: Short): Int {
+    return when (x) {
+        1.toShort() -> 5
+        2.toShort() -> 6
+        3.toShort() -> 7
+        else -> 8
+    }
+}
+
+fun byteFoo(x: Byte): Int {
+    return when (x) {
+        1.toByte() -> 5
+        2.toByte() -> 6
+        3.toByte() -> 7
+        else -> 8
+    }
+}
+
+fun charFoo(x: Char): Int {
+    return when (x) {
+        'a' -> 5
+        'b' -> 6
+        'c' -> 7
+        else -> 8
+    }
+}
+
+fun box(): String {
+    var result = (1..4).map(::intFoo).joinToString()
+
+    if (result != "5, 6, 7, 8") return "int:" + result
+
+    result = (listOf<Short>(1, 2, 3, 4)).map(::shortFoo).joinToString()
+
+    if (result != "5, 6, 7, 8") return "short:" + result
+
+    result = (listOf<Byte>(1, 2, 3, 4)).map(::byteFoo).joinToString()
+
+    if (result != "5, 6, 7, 8") return "byte:" + result
+
+    result = ('a'..'d').map(::charFoo).joinToString()
+
+    if (result != "5, 6, 7, 8") return "int:" + result
+    return "OK"
+}
@@ -0,0 +1,17 @@
+// WITH_RUNTIME
+
+fun foo(x: Int): Int {
+    return when (x) {
+        2 -> 6
+        1 -> 5
+        3 -> 7
+        else -> 8
+    }
+}
+
+fun box(): String {
+    var result = (0..3).map(::foo).joinToString()
+
+    if (result != "8, 5, 6, 7") return "unordered:" + result
+    return "OK"
+}