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,12 @@
+class C(val p: Boolean) { }
+
+fun box(): String {
+  val c = C(true)
+
+  // Commented for KT-621
+  // return when(c) {
+  //  .p => "OK"
+  //  else => "fail"
+  // }
+  return if (c.p) "OK" else "fail"
+}
@@ -0,0 +1,7 @@
+enum class A { X1, X2 }
+
+fun box(): String {
+    when {}
+    when (A.X1) {}
+    return "OK"
+}
@@ -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,22 @@
+enum class En { A, B, С }
+
+fun box(): String {
+    var res = ""
+    // nullable variable
+    val en2: Any? = En.A
+    if (en2 is En) {
+        when (en2) {
+            En.A -> {res += "O"}
+            En.B -> {}
+            En.С -> {}
+        }
+
+        when (en2 as En) {
+            En.A -> {res += "K"}
+            En.B -> {}
+            En.С -> {}
+        }
+    }
+
+    return res
+}
@@ -0,0 +1,60 @@
+enum class En { A, B, С }
+
+fun main(args: Array<String>) {
+
+}
+
+fun box(): String {
+    var res1 = "fail"
+    var res2 = "fail2"
+
+    val en: En = En.A
+    when (en) {
+        En.A -> {res1 = ""}
+        En.B -> {}
+        En.С -> {}
+    }
+
+    when (en as En) {
+        En.A -> {res1 += "O"}
+        En.B -> {}
+        En.С -> {}
+    }
+
+
+    // nullable variable
+    val en2: Any? = En.A
+    if (en2 is En) {
+        when (en2) {
+            En.A -> {res1 += "K"}
+            En.B -> {}
+            En.С -> {}
+        }
+
+        when (en2 as En) {
+            En.A -> {res2 = ""}
+            En.B -> {}
+            En.С -> {}
+        }
+    }
+
+
+    // not nullable variable
+    val en1: Any = En.A
+    if (en1 is En) {
+        when (en1) {
+            En.A -> {res2 += "O"}
+            En.B -> {}
+            En.С -> {}
+        }
+        // Working without other examples
+        when (en1 as En) {
+            En.A -> {res2 += "K"}
+            En.B -> {}
+            En.С -> {}
+        }
+    }
+
+    if (res1 != res2) return "different results: $res1 != $res2"
+    return res1
+}
@@ -0,0 +1,25 @@
+class EncapsulatedEnum<T : Enum<T>>(val value: T)
+
+enum class MyEnum(val value: String) {
+    VALUE_A("OK"),
+    VALUE_B("fail"),
+}
+
+private fun crash(encapsulated: EncapsulatedEnum<*>) {
+    val myEnum = encapsulated.value
+    if (myEnum !is MyEnum) {
+        return
+    }
+
+    when (myEnum) {
+        MyEnum.VALUE_A -> res = myEnum.value
+        MyEnum.VALUE_B -> res = myEnum.value
+    }
+}
+
+var res = "fail"
+
+fun box(): String {
+    crash(EncapsulatedEnum(MyEnum.VALUE_A))
+    return res
+}
@@ -0,0 +1,25 @@
+
+private fun Any?.doTheThing(): String {
+    when (this) {
+        is String -> return this
+        is Level -> {
+            when (this) {
+                Level.O -> return Level.O.name
+                Level.K -> return Level.K.name
+            }
+        }
+
+        else -> return "fail"
+    }
+}
+
+
+enum class Level {
+    O,
+    K
+}
+
+
+fun box(): String {
+    return "O".doTheThing() + Level.K.doTheThing()
+}
@@ -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,16 @@
+enum class Season {
+    WINTER,
+    SPRING,
+    SUMMER,
+    AUTUMN
+}
+
+fun foo(): Season = Season.SPRING
+fun bar(): Season = Season.SPRING
+
+fun box() : String {
+    when (foo()) {
+        bar() -> return "OK"
+        else -> return "fail"
+    }
+}
@@ -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,14 @@
+enum class E {
+    A,
+    B
+}
+
+fun test(e: E?) = when (e) {
+    E.A -> "Fail A"
+    null -> "OK"
+    E.B -> "Fail B"
+}
+
+fun box(): String {
+    return test(null)
+}
@@ -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,14 @@
+fun isZero(x: Int) = when(x) {
+    0 -> true
+    else -> throw Exception()
+}
+
+fun box(): String {
+    try {
+	isZero(1)
+    }
+    catch (e: Exception) {
+        return "OK"
+    }
+    return "Fail"
+}
@@ -0,0 +1,4 @@
+fun box() : String = when (true) {
+    ((true)) -> "OK"
+    (1 == 2) -> "Not ok"
+}
@@ -0,0 +1,14 @@
+enum class Color { RED, GREEN, BLUE }
+
+fun foo(arr: Array<Color>): Color {
+    loop@ for (color in arr) {
+        when (color) {
+            Color.RED -> return color
+            Color.GREEN -> break@loop
+            Color.BLUE -> if (arr.size == 1) return color else continue@loop
+        }
+    }
+    return Color.GREEN
+}
+
+fun box() = if (foo(arrayOf(Color.BLUE, Color.GREEN)) == Color.GREEN) "OK" else "FAIL"
@@ -0,0 +1,10 @@
+enum class A { V }
+
+fun box(): String {
+  val a: A = A.V
+  val b: Boolean
+  when (a) {
+    A.V -> b = true
+  }
+  return if (b) "OK" else "FAIL"
+}
@@ -0,0 +1,8 @@
+enum class A { V }
+
+fun box(): String {
+    val a: A = A.V
+    when (a) {
+        A.V -> return "OK"
+    }
+}
@@ -0,0 +1,9 @@
+fun test(i: Int): String {
+    when (i) {
+        0 -> return "0"
+        1 -> return "1"
+    }
+    return "OK"
+}
+
+fun box(): String = test(42)
@@ -0,0 +1,28 @@
+// TODO: muted automatically, investigate should it be ran for JS or not
+// IGNORE_BACKEND: JS, NATIVE
+
+// 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,11 @@
+fun typeName(a: Any?) : String {
+    return when(a) {
+        is ArrayList<*> -> "array list"
+        else -> "no idea"
+    }
+}
+
+fun box() : String {
+    if(typeName(ArrayList<Int>()) != "array list") return "array list failed"
+    return "OK"
+}
@@ -0,0 +1,8 @@
+fun foo(i: Int) : Int =
+    when (i) {
+        1 -> 1
+        null -> 1
+        else -> 1
+    }
+
+fun box() : String = if (foo(1) == 1) "OK" else "fail"
@@ -0,0 +1,9 @@
+fun foo(b: Boolean) =
+    when (b) {
+        false -> 0
+        true -> 1
+        else -> 2
+    }
+
+fun box(): String = if (foo(false) == 0 && foo(true) == 1) "OK" else "Fail"
+
@@ -0,0 +1,11 @@
+fun box(): String {
+    val value = 1
+    when (value) {
+        0 -> {}
+        1 -> when (value) {
+            2 -> false
+        }
+    }
+
+    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,9 @@
+class LongR {
+  operator fun contains(l : Long): Boolean = l == 5.toLong()
+}
+
+fun box(): String {
+  if (5 !in LongR()) return "fail 1"
+  if (6 in LongR()) return "fail 2"
+  return "OK"
+}
@@ -0,0 +1,7 @@
+fun foo(i: Int, j: Int?): String =
+    when (i) {
+        j -> "OK"
+        else -> "Fail"
+    }
+
+fun box(): String = foo(0, 0)
@@ -0,0 +1,12 @@
+fun foo(x: Any) =
+        when (x) {
+            0, 1 -> "bit"
+            else -> "something"
+        }
+
+fun box(): String {
+    if (foo(0) != "bit") return "Fail 0"
+    if (foo(1) != "bit") return "Fail 1"
+    if (foo(2) != "something") return "Fail 2"
+    return "OK"
+}
@@ -0,0 +1,9 @@
+enum class En {
+    A,
+    B
+}
+
+fun box(): String = when(En.A) {
+    En.A -> "OK"
+    En.B -> "Fail 1"
+}
@@ -0,0 +1,12 @@
+enum class En {
+    A,
+    B
+}
+
+fun box(): String {
+    when(En.A) {
+        En.A -> "s1"
+        En.B -> "s2"
+    }
+    return "OK"
+}
@@ -0,0 +1,14 @@
+enum class En {
+    A,
+    B
+}
+
+fun box(): String {
+
+  val u: Unit = when(En.A) {
+    En.A -> {}
+    En.B -> {}
+  }
+
+  return "OK"
+}
@@ -0,0 +1,7 @@
+fun box(): String {
+    val x = 1
+    when (x) {
+        1 -> return "OK"
+    }
+    return "Fail 1"
+}
@@ -0,0 +1,8 @@
+fun box(): String {
+    val x = 3
+    when (x) {
+        1 -> {}
+        2 -> {}
+    }
+    return "OK"
+}
@@ -0,0 +1,13 @@
+// KT-2148
+
+
+fun f(p: Int?): Int {
+    return when(p) {
+        null -> 3
+        else -> p!!
+    }
+}
+
+fun box(): String {
+    return if (f(null) == 3) "OK" else "fail"
+}
@@ -0,0 +1,29 @@
+fun isDigit(a: Int) : String {
+    val aa = ArrayList<Int> ()
+    aa.add(239)
+
+    return when(a) {
+      in aa -> "array list"
+      in 0..9 -> "digit"
+     !in 0..100 -> "not small"
+      else -> "something"
+    }
+}
+
+fun assertDigit(i: Int, expected: String): String {
+  val result = isDigit(i)
+  return if (result == expected) "" else "fail: isDigit($i) = \"$result\""
+}
+
+fun box(): String {
+  val result =
+  assertDigit(239, "array list") +
+  assertDigit(0, "digit") +
+  assertDigit(9, "digit") +
+  assertDigit(5, "digit") +
+  assertDigit(19, "something") +
+  assertDigit(190, "not small")
+
+  if (result == "") return "OK"
+  return result
+}
@@ -0,0 +1,15 @@
+sealed class A {
+    object B : A()
+
+    class C : A()
+}
+
+fun box(): String {
+    val a: A = A.C()
+    val b: Boolean
+    when (a) {
+        A.B -> b = true
+        is A.C -> b = false
+    }
+    return if (!b) "OK" else "FAIL"
+}
@@ -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,29 @@
+// TODO: muted automatically, investigate should it be ran for JS or not
+// IGNORE_BACKEND: JS
+
+// 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,28 @@
+// TODO: muted automatically, investigate should it be ran for JS or not
+// IGNORE_BACKEND: JS
+
+// 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,24 @@
+// WITH_RUNTIME
+
+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,17 @@
+// WITH_RUNTIME
+
+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"
+}
@@ -0,0 +1,15 @@
+fun foo(s: Any): String {
+    val x = when (s) {
+        is String -> s
+        is Int -> "$s"
+        else -> return ""
+    }
+
+    val y: String = x
+    return y
+}
+
+fun box() = if (foo("OK") == "OK" && foo(42) == "42" && foo(true) == "") "OK" else "Fail"
+
+
+
@@ -0,0 +1,13 @@
+var x = 0
+fun inc(): Int {
+    x++
+    return 0
+}
+fun box(): String {
+  val al = ArrayList<Int>()
+  when (inc()) {
+      in al -> return "fail 1"
+      else -> {}
+  }
+  return if (x == 1) "OK" else "fail 2"
+}