JS: move expressions test to box tests

2016-08-26 19:32:17 +03:00
parent 2bf0199959
commit b159049be8
314 changed files with 2380 additions and 2185 deletions
@@ -0,0 +1,26 @@
+package foo
+
+fun box(): String {
+    if (f(0) != -3) {
+        return "fail1"
+    }
+    if (f(102) != 201) {
+        return "fail2"
+    }
+    if (f(103) != 100) {
+        return "fail3"
+    }
+    if (f(-100) != -100) {
+        return "fail4"
+    }
+    if (f(-99) != -201) {
+        return "fail5"
+    }
+
+    return "OK"
+}
+
+fun f(i: Int): Int {
+    var j = i
+    return --j + (if (j < -100) return -100 else --j) + (if (j > 100) return 100 else 0)
+}
@@ -0,0 +1,97 @@
+package foo
+
+var global: String = ""
+
+fun id(s: String, b: Boolean): Boolean {
+    global += s
+    return b
+}
+
+fun bar(b: Boolean): String {
+    if (id("A", b) && return "A")
+        return "B"
+    else
+        return "C"
+}
+
+fun testBreak(b: Boolean, expected: Int) {
+    global = ""
+    var i = 0
+    while (i++ < 5) {
+        if (i == 2) id("A", b) && break
+    }
+    assertEquals(expected, i, "break 1")
+    assertEquals("A", global, "break 1")
+
+    global = ""
+    i = 0
+    while (i++ < 5) {
+        if (i == 2) {
+            var x = id("A", b) && break
+        }
+    }
+    assertEquals(expected, i, "break 2")
+    assertEquals("A", global, "break 2")
+}
+
+fun testContinue(b: Boolean, expected: Int) {
+    global = ""
+    var i = 0
+    var n = 0
+    while (i++ < 5) {
+        if (i == 2) id("A", b) && continue
+        n++
+    }
+    assertEquals(expected, n, "continue 1")
+    assertEquals("A", global, "continue 1")
+
+    global = ""
+    i = 0
+    n = 0
+    while (i++ < 5) {
+        if (i == 2) {
+            var x = id("A", b) && continue
+            assertEquals(x, b)
+        }
+        n++
+    }
+    assertEquals(expected, n, "continue 2")
+    assertEquals("A", global, "continue 2")
+}
+
+fun box(): String {
+    var b: Boolean
+
+    testBreak(true, 2)
+    testBreak(false, 6)
+
+    global = ""
+    var i = 0
+    while (i++ < 5) {
+        if (i == 2) break && id("A", false)
+    }
+    assertEquals(2, i, "break && false")
+    assertEquals("", global, "break && false")
+
+    testContinue(true, 4)
+    testContinue(false, 5)
+
+    global = ""
+    i = 0
+    var n = 0
+    while (i++ < 5) {
+        if (i == 2) continue && id("A", false)
+        n++
+    }
+    assertEquals(4, n, "continue && false")
+    assertEquals("", global, "continue && false")
+
+    assertEquals("A", bar(true), "bar")
+    assertEquals("A", global, "bar")
+
+    global = ""
+    assertEquals("C", bar(false))
+    assertEquals("A", global, "bar")
+
+    return "OK"
+}
@@ -0,0 +1,81 @@
+package foo
+
+var global: String = ""
+
+fun bar(s: String, value: Boolean): Boolean {
+    global += s
+    return value
+}
+
+fun box(): String {
+
+    // Simple && Simple
+    global = ""
+    assertEquals(true, bar("A", true) && bar("B", true))
+    assertEquals("AB", global)
+
+    global = ""
+    assertEquals(false, bar("A", true) && bar("B", false))
+    assertEquals("AB", global)
+
+    global = ""
+    assertEquals(false, bar("A", false) && bar("B", true))
+    assertEquals("A", global)
+
+    global = ""
+    assertEquals(false, bar("A", false) && bar("B", false))
+    assertEquals("A", global)
+
+    // Simple && Complex
+    global = ""
+    assertEquals(true, bar("A", true) && try { bar("B", true) } finally {})
+    assertEquals("AB", global)
+
+    global = ""
+    assertEquals(false, bar("A", true) && try { bar("B", false) } finally {})
+    assertEquals("AB", global)
+
+    global = ""
+    assertEquals(false, bar("A", false) && try { bar("B", true) } finally {})
+    assertEquals("A", global)
+
+    global = ""
+    assertEquals(false, bar("A", false) && try { bar("B", false) } finally {})
+    assertEquals("A", global)
+
+    // Complex && Simple
+    global = ""
+    assertEquals(true, try { bar("A", true) } finally {} && bar("B", true))
+    assertEquals("AB", global)
+
+    global = ""
+    assertEquals(false, try { bar("A", true) } finally {} && bar("B", false))
+    assertEquals("AB", global)
+
+    global = ""
+    assertEquals(false, try { bar("A", false) } finally {} && bar("B", true))
+    assertEquals("A", global)
+
+    global = ""
+    assertEquals(false, try { bar("A", false) } finally {} && bar("B", false))
+    assertEquals("A", global)
+
+    // Complex && Complex
+    global = ""
+    assertEquals(true, try { bar("A", true) } finally {} && try { bar("B", true) } finally {})
+    assertEquals("AB", global)
+
+    global = ""
+    assertEquals(false, try { bar("A", true) } finally {} && try { bar("B", false) } finally {})
+    assertEquals("AB", global)
+
+    global = ""
+    assertEquals(false, try { bar("A", false) } finally {} && try { bar("B", true) } finally {})
+    assertEquals("A", global)
+
+    global = ""
+    assertEquals(false, try { bar("A", false) } finally {} && try { bar("B", false) } finally {})
+    assertEquals("A", global)
+
+    return "OK"
+}
@@ -0,0 +1,79 @@
+package foo
+
+var global: String = ""
+
+class A {
+    var prop: Int = 0
+}
+
+fun bar(s: String, index: Int): Int {
+    global += s
+    return index
+}
+
+val baz: Int
+    get() {
+        global += ":baz:"; return 1
+    }
+
+fun box(): String {
+    val a = arrayOf(0,1,2,3)
+
+
+    global = ""
+    a[bar("A", 1)] = try { global += "B"; 10 } finally {}
+    assertEquals("AB", global)
+    assertEquals(10, a[1])
+
+    global = ""
+    a[bar("A", 1)] += try { global += "B"; 10 } finally {}
+    assertEquals("AB", global)
+    assertEquals(20, a[1])
+
+    global = ""
+    a[bar("A", 1)] -= try { global += "B"; 10 } finally {}
+    assertEquals("AB", global)
+    assertEquals(10, a[1])
+
+    global = ""
+    a[bar("A", 1)] *= try { global += "B"; 2 } finally {}
+    assertEquals("AB", global)
+    assertEquals(20, a[1])
+
+    global = ""
+    a[bar("A", 1)] /= try { global += "B"; 5 } finally {}
+    assertEquals("AB", global)
+    assertEquals(4, a[1])
+
+    global = ""
+    a[bar("A", 1)] %= try { global += "B"; 3 } finally {}
+    assertEquals("AB", global)
+    assertEquals(1, a[1])
+
+    global = ""
+    a[bar("A", 1)]++
+    assertEquals("A", global)
+    assertEquals(2, a[1])
+
+    global = ""
+    a[try { bar("A", 1)} finally {}]++
+    assertEquals("A", global)
+    assertEquals(3, a[1])
+
+    global = ""
+    ++a[bar("A", 1)]
+    assertEquals("A", global)
+    assertEquals(4, a[1])
+
+    global = ""
+    ++a[try { bar("A", 1)} finally {}]
+    assertEquals("A", global)
+    assertEquals(5, a[1])
+
+    global = ""
+    a[baz] = try { global += "right"; 100 } finally {}
+    assertEquals(":baz:right", global)
+    assertEquals(100, a[1])
+
+    return "OK"
+}
@@ -0,0 +1,59 @@
+package foo
+
+var global: String = ""
+
+class A {
+    var prop: Int = 0
+}
+
+fun bar(s: String, a: A): A {
+    global += s
+    return a
+}
+
+
+fun box(): String {
+    val a = A()
+
+    global = ""
+    bar("A", a).prop = try { global += "B"; 10 } finally {}
+    assertEquals("AB", global)
+    assertEquals(10, a.prop)
+
+    global = ""
+    bar("A", a).prop += try { global += "B"; 20 } finally {}
+    assertEquals("AB", global)
+    assertEquals(30, a.prop)
+
+    global = ""
+    bar("A", a).prop -= try { global += "B"; 20 } finally {}
+    assertEquals("AB", global)
+    assertEquals(10, a.prop)
+
+    global = ""
+    bar("A", a).prop *= try { global += "B"; 2 } finally {}
+    assertEquals("AB", global)
+    assertEquals(20, a.prop)
+
+    global = ""
+    bar("A", a).prop /= try { global += "B"; 5 } finally {}
+    assertEquals("AB", global)
+    assertEquals(4, a.prop)
+
+    global = ""
+    bar("A", a).prop %= try { global += "B"; 3 } finally {}
+    assertEquals("AB", global)
+    assertEquals(1, a.prop)
+
+    global = ""
+    (try { bar("A", a) } finally {}).prop++
+    assertEquals("A", global)
+    assertEquals(2, a.prop)
+
+    global = ""
+    ++(try { bar("A", a) } finally {}).prop
+    assertEquals("A", global)
+    assertEquals(3, a.prop)
+
+    return "OK"
+}
@@ -0,0 +1,48 @@
+package foo
+
+var global = ""
+
+fun addToGlobal(s: String): String {
+    global += s
+    return ""
+}
+
+fun bar(s: String, u: Int) { global += ":bar:${s}" }
+
+class A() {
+    fun memFun(s: String) { global += ":memFun:${s}" }
+}
+
+class B() {
+    fun A.bExt(s: String) { global += ":bExt:${s}" }
+
+    fun baz(s: String, a: A) = a.bExt(s)
+}
+
+fun A.extFun(s: String) { global += ":extFun:${s}" }
+
+fun box(): String {
+
+    bar(addToGlobal("A"), try { global += "B"; 10 } finally {})
+    assertEquals("AB:bar:", global)
+
+    global = ""
+    val a = A()
+    a.memFun(try { "A" } finally {})
+    assertEquals(":memFun:A", global)
+
+    global = ""
+    (try { global += "A"; a } finally {}).memFun("B")
+    assertEquals("A:memFun:B", global)
+
+    global = ""
+    (try { global += "A"; a } finally {}).memFun(try { global += "B"; "C" } finally {})
+    assertEquals("AB:memFun:C", global)
+
+    global = ""
+    val b = B()
+    b.baz("S", a)
+    assertEquals(":bExt:S", global)
+
+    return "OK"
+}
@@ -0,0 +1,29 @@
+package foo
+
+var global: String = ""
+
+fun <T> bar(s: String, value: T): T {
+    global += s
+    return value
+}
+
+fun <T> baz(vararg args: T): String {
+    return "baz: ${args.size}"
+}
+
+fun <T> idVarArg(vararg a: T) = a
+
+fun box(): String {
+    baz(bar("A", 10), try { global += "B"; 20} finally {})
+    assertEquals("AB", global)
+
+    global = ""
+    baz(bar("A", 10), 30, if (true) { while(false){}; global+= "B"; 20 } else { 50 })
+    assertEquals("AB", global)
+
+    global = ""
+    assertEquals("baz: 4", baz(bar("A", 1), *try {bar("B", arrayOf(2, 3))} catch(e: Exception) { bar("C", arrayOf(4, 5))}, bar("D", 6)))
+    assertEquals("ABD", global)
+
+    return "OK"
+}
@@ -0,0 +1,88 @@
+package foo
+
+var global: String = ""
+
+fun f(arg1: String, arg2: String, arg3: String): String {
+    global += ":f:"
+    return arg1 + arg2 + arg3
+}
+
+fun id(s: String): String {
+    global += s
+    return s
+}
+
+fun bar(s: String): String {
+    return f(id(s), if (true) return ":bar:" else return "b", id(s))
+}
+
+fun box(): String {
+    var b: Boolean
+
+    var i = 0
+    while (i++ < 5) {
+        if (i == 2) f(id("A"), break, id("B"))
+    }
+    assertEquals(2, i, "break 1")
+    assertEquals("A", global, "break 1")
+
+    global = ""
+    i = 0
+    while (i++ < 5) {
+        if (i == 2) {
+            var x = f(id("A"), break, id("B"))
+        }
+    }
+    assertEquals(2, i, "break 2")
+    assertEquals("A", global, "break 2")
+
+    global = ""
+    i = 0
+    while (i++ < 5) {
+        if (i == 2) {
+            var x = "B" + f(id("A"), break, id("B"))
+        }
+    }
+    assertEquals(2, i, "break 3")
+    assertEquals("A", global, "break 3")
+
+    global = ""
+    i = 0
+    var n = 0
+    while (i++ < 5) {
+        if (i == 2) f(id("A"), continue, id("B"))
+        n++
+    }
+    assertEquals(4, n, "continue 1")
+    assertEquals("A", global, "continue 1")
+
+    global = ""
+    i = 0
+    n = 0
+    while (i++ < 5) {
+        if (i == 2) {
+            var x = f(id("A"), continue, id("B"))
+        }
+        n++
+    }
+    assertEquals(4, n, "continue 2")
+    assertEquals("A", global, "continue 2")
+
+    global = ""
+    i = 0
+    n = 0
+    while (i++ < 5) {
+        if (i == 2) {
+            var x = "B" + f(id("A"), continue, id("B"))
+        }
+        n++
+    }
+    assertEquals(4, n, "continue 3")
+    assertEquals("A", global, "continue 3")
+
+    global = ""
+    assertEquals(":bar:", bar("A"))
+    assertEquals("A", global, "bar")
+
+    return "OK"
+}
@@ -0,0 +1,120 @@
+package foo
+
+fun castWithReturn(): Int {
+    return (return 23) as Int
+}
+
+fun safeCastWithReturn(): Int? {
+    return (return 23) as Int?
+}
+
+fun isWithReturn(): Int {
+    return if ((return 23) is Int) 2 else 3
+}
+
+fun castWithBreak(): Int {
+    var result = 23
+    while (result < 40) {
+        if ((break as Int) == 0) result += 2 else result += 3
+    }
+    return result
+}
+
+fun safeCastWithBreak(): Int {
+    var result = 23
+    while (result < 40) {
+        if ((break as Int) == 0) result += 2 else result += 3
+    }
+    return result
+}
+
+fun isWithBreak(): Int {
+    var result = 23
+    while (result < 40) {
+        if (break is Int) result += 2 else result += 3
+    }
+    return result
+}
+
+fun castWithContinue(): Int {
+    var result = 25
+    while (result in 24..30) {
+        --result
+        if ((continue as Int) == 0) result += 2 else result += 3
+    }
+    return result
+}
+
+fun castNullableWithContinue(): Int {
+    var result = 25
+    while (result in 24..30) {
+        --result
+        if ((continue as Int?) == 0) result += 2 else result += 3
+    }
+    return result
+}
+
+fun safeCastWithContinue(): Int {
+    var result = 25
+    while (result in 24..30) {
+        --result
+        if ((continue as? Int) == 0) result += 2 else result += 3
+    }
+    return result
+}
+
+fun safeCastNullableWithContinue(): Int {
+    var result = 25
+    while (result in 24..30) {
+        --result
+        if ((continue as? Int?) == 0) result += 2 else result += 3
+    }
+    return result
+}
+
+fun isWithContinue(): Int {
+    var result = 25
+    while (result in 24..30) {
+        --result
+        if (continue is Int) result += 2 else result += 3
+    }
+    return result
+}
+
+fun isNullableWithContinue(): Int {
+    var result = 23
+    while (result in 24..30) {
+        --result
+        if (continue is Int?) result += 2 else result += 3
+    }
+    return result
+}
+
+fun whenWithReturn(): Int {
+    return when ((return 23) as Int) {
+        is Int -> 24
+        else -> 25
+    }
+}
+
+fun box(): String {
+    assertEquals(23, castWithReturn())
+    assertEquals(23, safeCastWithReturn())
+    assertEquals(23, isWithReturn())
+
+    assertEquals(23, castWithBreak())
+    assertEquals(23, safeCastWithBreak())
+    assertEquals(23, isWithBreak())
+
+    assertEquals(23, castWithContinue())
+    assertEquals(23, safeCastWithContinue())
+    assertEquals(23, isWithContinue())
+
+    assertEquals(23, castNullableWithContinue())
+    assertEquals(23, safeCastNullableWithContinue())
+    assertEquals(23, isNullableWithContinue())
+
+    assertEquals(23, whenWithReturn())
+
+    return "OK"
+}
@@ -0,0 +1,61 @@
+package foo
+
+var global: String = ""
+
+fun bar(s: String): String {
+    global += s
+    return s
+}
+
+fun box(): String {
+
+    global = ""
+    assertEquals(true, bar("A") < bar("B"))
+    assertEquals("AB", global)
+
+    global = ""
+    assertEquals(true, bar("A") <= bar("B"))
+    assertEquals("AB", global)
+
+    global = ""
+    assertEquals(false, bar("A") > bar("B"))
+    assertEquals("AB", global)
+
+    global = ""
+    assertEquals(false, bar("A") >= bar("B"))
+    assertEquals("AB", global)
+
+    global = ""
+    assertEquals(true, bar("A") < try { bar("B") } finally {})
+    assertEquals("AB", global)
+
+    global = ""
+    assertEquals(true, bar("A") <= try { bar("B") } finally {})
+    assertEquals("AB", global)
+
+    global = ""
+    assertEquals(false, try { bar("A") } finally {}  > bar("B"))
+    assertEquals("AB", global)
+
+    global = ""
+    assertEquals(false, try { bar("A") } finally {} >= bar("B"))
+    assertEquals("AB", global)
+
+    global = ""
+    assertEquals(true, try { bar("A") } finally {}  < try { bar("B") } finally {})
+    assertEquals("AB", global)
+
+    global = ""
+    assertEquals(true, try { bar("A") } finally {}  <= try { bar("B") } finally {})
+    assertEquals("AB", global)
+
+    global = ""
+    assertEquals(false, try { bar("A") } finally {} > try { bar("B") } finally {})
+    assertEquals("AB", global)
+
+    global = ""
+    assertEquals(false, try { bar("A") } finally {} >= try { bar("B") } finally {})
+    assertEquals("AB", global)
+
+    return "OK"
+}
@@ -0,0 +1,9 @@
+package foo
+
+var i = 0
+
+inline fun f() = i * 2
+
+fun box(): String {
+    return if ((++i + f()) == 3) "OK" else "fail"
+}
@@ -0,0 +1,22 @@
+package foo
+
+fun box(): String {
+    if (f(0) != 201) {
+        return "fail1"
+    }
+    if (f(1) != 104) {
+        return "fail2"
+    }
+    if (f(-2) != -100) {
+        return "fail3"
+    }
+    return "OK"
+}
+
+fun f(i: Int): Int {
+    var j = i
+    return ++j + if (j != 1) {
+        (if (j > 0) 100 else return -100) + 2
+    }
+    else 200
+}
@@ -0,0 +1,22 @@
+package foo
+
+var sideEffect: Int = 0;
+
+class A(val x: Int)
+
+val global_a = A(1)
+val global_b = A(2)
+
+fun nullFun(value: Boolean): Any? = if (value) null else global_a
+
+fun box(): String {
+
+    nullFun(false) ?: global_b
+    assertEquals(global_a, nullFun(false) ?: try { ++sideEffect; global_b } finally {}, "false, global_b")
+    assertEquals(0, sideEffect, "false, global_b side effect")
+
+    assertEquals(global_b, nullFun(true) ?: try { ++sideEffect; global_b } finally {}, "true, global_b")
+    assertEquals(1, sideEffect, "true, global_b side effect")
+
+    return "OK"
+}
@@ -0,0 +1,74 @@
+package foo
+
+class A
+
+fun bar(a: A?): String {
+    if ((a ?: return "A") != null)
+        return "B"
+    else
+        return "C"
+}
+
+fun testBreak(a: A?, expected: Int) {
+    var i = 0
+    while(i++<5) {
+        if (i==2) a ?: break
+    }
+    assertEquals(expected, i, "break 1")
+
+    i = 0
+    while(i++<5) {
+        if (i==2) {
+            var x = a ?: break
+        }
+    }
+    assertEquals(expected, i, "break 2")
+}
+
+fun testContinue(a: A?, expected: Int) {
+    var i = 0
+    var n = 0
+    while(i++<5) {
+        if (i==2) a ?: continue
+        n++
+    }
+    assertEquals(expected, n)
+
+    i = 0
+    n = 0
+    while(i++<5) {
+        if (i==2)  {
+            var x = a ?: continue
+        }
+        n++
+    }
+    assertEquals(expected, n)
+}
+
+fun box(): String {
+
+    testBreak(null, 2)
+    testBreak(A(), 6)
+
+    var i = 0
+    while(i++<5) {
+        if (i==2) break ?: null
+    }
+    assertEquals(2, i, "break ?: null")
+
+    testContinue(null, 4)
+    testContinue(A(), 5)
+
+    i = 0
+    var n = 0
+    while(i++<5) {
+        if (i==2) continue ?: null
+        n++
+    }
+    assertEquals(4, n, "continue ?: null")
+
+    assertEquals("A", bar(null))
+    assertEquals("B", bar(A()))
+
+    return "OK"
+}
@@ -0,0 +1,45 @@
+package foo
+
+var global: String = ""
+
+fun bar(s: String): String {
+    global += s
+    return s
+}
+
+fun box(): String {
+
+    global = ""
+    assertEquals(false, bar("A") == bar("B"))
+    assertEquals("AB", global)
+
+    global = ""
+    assertEquals(true, bar("A") != bar("B"))
+    assertEquals("AB", global)
+
+    global = ""
+    assertEquals(false, bar("A") == try { bar("B") } finally {})
+    assertEquals("AB", global)
+
+    global = ""
+    assertEquals(true, bar("A") != try { bar("B") } finally {})
+    assertEquals("AB", global)
+
+    global = ""
+    assertEquals(false, try { bar("A") } finally {}  == bar("B"))
+    assertEquals("AB", global)
+
+    global = ""
+    assertEquals(true, try { bar("A") } finally {} != bar("B"))
+    assertEquals("AB", global)
+
+    global = ""
+    assertEquals(false, try { bar("A") } finally {}  == try { bar("B") } finally {})
+    assertEquals("AB", global)
+
+    global = ""
+    assertEquals(true, try { bar("A") } finally {} != try { bar("B") } finally {})
+    assertEquals("AB", global)
+
+    return "OK"
+}
@@ -0,0 +1,17 @@
+package foo
+
+var d = 0
+
+fun f(): Int {
+    d = if (d < 0) -100 else 100
+    return d
+}
+
+fun box(): String {
+    d = d-- + f() + when(d) {
+        -100 -> return "OK"
+        1 -> 1
+        else -> return "fail1"
+    }
+    return "fail2"
+}
@@ -0,0 +1,29 @@
+// Order of evaluation differs for JVM and Javascript backend
+// http://youtrack.jetbrains.com/issue/KT-5254
+
+package foo
+
+var s = ""
+
+fun a():String {
+    s += "A"
+    return ""
+}
+
+fun b():String {
+    s += "B"
+    return ""
+}
+
+fun c():String {
+    s += "C"
+    return ""
+}
+
+
+fun box(): String {
+    var res = (if(true) {a()} else "") + b() + (if (true) {c()} else "")
+    assertEquals("ABC", s)
+
+    return "OK"
+}
@@ -0,0 +1,13 @@
+package foo
+
+fun box(): String {
+    var i = 0
+    val c = sum(++i, if (i == 0) return "fail1" else i + 2)
+    if (c != 4) {
+        return "fail2: $c"
+    }
+    return "OK"
+}
+
+
+fun sum(a1: Int, a2: Int) = a1 + a2
@@ -0,0 +1,10 @@
+package foo
+
+fun box(): String {
+    var  i = 0
+    var t = ++i + if (i == 0) 0 else 2
+    if (t != 3) {
+        return "fail: $t"
+    }
+    return "OK"
+}
@@ -0,0 +1,28 @@
+package foo
+
+var sideEffect: Int = 0;
+
+fun id(value: Boolean): Boolean = value
+
+fun box(): String {
+
+    assertEquals(if (id(true)) try { ++sideEffect; 10 } finally {} else 20, 10)
+    assertEquals(1, sideEffect)
+
+    assertEquals(if (id(false)) try { ++sideEffect; 10 } finally {} else 20, 20)
+    assertEquals(1, sideEffect)
+
+    assertEquals(if (id(true)) 100 else try { ++sideEffect; 200 } finally {}, 100)
+    assertEquals(1, sideEffect)
+
+    assertEquals(if (id(false)) 100 else try { ++sideEffect; 200 } finally {}, 200)
+    assertEquals(2, sideEffect)
+
+    assertEquals(if (id(true)) try { ++sideEffect; 1000 } finally {} else try { ++sideEffect; 2000 } finally {}, 1000)
+    assertEquals(3, sideEffect)
+
+    assertEquals(if (id(false)) try { ++sideEffect; 1000 } finally {} else try { ++sideEffect; 2000 } finally {}, 2000)
+    assertEquals(4, sideEffect)
+
+    return "OK"
+}
@@ -0,0 +1,15 @@
+package foo
+
+fun box(): String {
+    var x = 0
+    assertEquals(false, ++x > x)
+    assertEquals(false, ++x > try {x} finally {})
+
+    assertEquals(false, x++ > x)
+    assertEquals(false, x++ > try {x} finally {})
+
+    assertEquals(true, ++x == x)
+    assertEquals(true, ++x == try {x} finally {})
+
+    return "OK"
+}
@@ -0,0 +1,133 @@
+package foo
+
+var global: String = ""
+
+class A {
+    var prop: Boolean = false
+}
+
+fun getA(): A = try { global += "getA"; A() } finally {}
+
+fun barEq(): String {
+    10 == return "eq"
+}
+
+fun barLt(): String {
+    10 < (return "lt") as Int
+}
+
+fun setGlobal(i: Int): Int {
+    global = "setGlobal"
+    return i
+}
+
+fun box(): String {
+    var b: Boolean
+
+    var i = 0
+    while(i++<5) {
+        if (i==2) 10 == break
+    }
+    assertEquals(2, i, "break 1")
+
+    i = 0
+    while(i++<5) {
+        if (i==2) 10 < (break as Int)
+    }
+    assertEquals(2, i, "break 2")
+
+    i = 0
+    while(i++<5) {
+        if (i==2) {
+            var x = 10 == break;
+        }
+    }
+    assertEquals(2, i, "break 3")
+
+    i = 0
+    while(i++<5) {
+        if (i==2) {
+            var x = 10 < (break as Int)
+        }
+    }
+    assertEquals(2, i, "break 4")
+
+    i = 0
+    var bVar: Boolean
+    while(i++<5) {
+        if (i==2) {
+            bVar = 10 < (break as Int)
+        }
+    }
+    assertEquals(2, i, "break 5")
+
+    i = 0
+    var bVarArray = arrayOf(true, false)
+    while(i++<5) {
+        if (i==2) {
+            bVarArray[try { global += "A"; 0} finally {}] = 10 < (break as Int)
+        }
+    }
+    assertEquals(2, i, "break 6")
+    assertEquals("A", global, "break 6")
+
+    i = 0
+    while(i++<5) {
+        if (i==2) {
+            bVarArray[setGlobal(0)] = 10 < (break as Int)
+        }
+    }
+    assertEquals(2, i, "break 6a")
+    assertEquals("setGlobal", global, "break 6a")
+
+    i = 0
+    global = ""
+    while(i++<5) {
+        if (i==2) {
+            getA().prop = 10 < (break as Int)
+        }
+    }
+    assertEquals(2, i, "break 7")
+    assertEquals("getA", global, "break 7")
+
+    i = 0
+    var n = 0
+    while(i++<5) {
+        if (i==2) 10 == continue
+        n++
+    }
+    assertEquals(4, n, "continue 1")
+
+    i = 0
+    n = 0
+    while(i++<5) {
+        if (i==2) 10 < (continue as Int)
+        n++
+    }
+    assertEquals(4, n, "continue 2")
+
+    i = 0
+    n = 0
+    while(i++<5) {
+        if (i==2)  {
+            var x = 10 == continue
+        }
+        n++
+    }
+    assertEquals(4, n, "continue 3")
+
+    i = 0
+    n = 0
+    while(i++<5) {
+        if (i==2)  {
+            var x = 10 < (continue as Int)
+        }
+        n++
+    }
+    assertEquals(4, n, "continue 4")
+
+    assertEquals("eq", barEq())
+    assertEquals("lt", barLt())
+
+    return "OK"
+}
@@ -0,0 +1,35 @@
+// http://youtrack.jetbrains.com/issue/KT-4225
+// Compiler to JavaScript produces semantically wrong code
+
+package  foo
+
+var i = 0
+var j = 0
+
+var global: String = ""
+
+fun incI(){
+    i++
+}
+
+fun incJ(a: Any){
+    j++
+}
+
+fun foo(f: () -> Unit) = f
+
+fun box(): String {
+    val bar = 1
+
+    val f = foo {
+        incI()
+        incJ(if (bar == 2) "A" else "B")
+    }
+
+    global +="i = $i, j = $j"
+    f()
+    global +=" : i = $i, j = $j"
+    assertEquals("i = 0, j = 0 : i = 1, j = 1", global)
+
+    return "OK"
+}
@@ -0,0 +1,87 @@
+package foo
+
+var global: String = ""
+
+
+fun whileReturn(): String {
+    var i = 0
+    while(if (i<2) true else { global += ":return:"; return ":whileReturn:"}) {
+        i++
+        global += "A"
+    }
+    return ":whileReturn:after:"
+}
+
+fun whileImmediateReturn(): String {
+    var i = 0
+    while(return ":whileImmediateReturn:") {
+        global += "A"
+    }
+    return ":whileImmediateReturn:after"
+}
+
+fun doWhileReturn(): String {
+    var i = 0
+    do {
+        i++
+        global += "A"
+    }
+    while(if (i<2) true else { global += ":return:"; return ":doWhileReturn:"})
+    return ":doWhileReturn:after:"
+}
+
+fun doWhileReturnFromCondition(): String {
+    var i = 0
+    do {
+        global += "A"
+    } while(return ":doWhileReturnFromCondition:")
+    return ":doWhileReturnFromCondition:after"
+}
+
+fun doWhileImmediateReturn(): String {
+    var i = 0
+    do {
+        return ":doWhileImmediateReturn:"
+        global += "A"
+    } while(false)
+    return ":doWhileImmediateReturn:after"
+}
+
+fun forReturn(b: Boolean): String {
+    var i = 0
+    for(i in (if (b) 1..2 else { global += ":return:"; return ":forReturn:"})) {
+        global += "A"
+    }
+    return ":forReturn:after:"
+}
+
+fun box(): String {
+    assertEquals(":whileReturn:", whileReturn())
+    assertEquals("AA:return:", global)
+
+    global = ""
+    assertEquals(":whileImmediateReturn:", whileImmediateReturn())
+    assertEquals("", global)
+
+    global = ""
+    assertEquals(":doWhileReturn:", doWhileReturn())
+    assertEquals("AA:return:", global)
+
+    global = ""
+    assertEquals(":doWhileReturnFromCondition:", doWhileReturnFromCondition())
+    assertEquals("A", global)
+
+    global = ""
+    assertEquals(":doWhileImmediateReturn:", doWhileImmediateReturn())
+    assertEquals("", global)
+
+    global = ""
+    assertEquals(":forReturn:after:", forReturn(true))
+    assertEquals("AA", global)
+
+    global = ""
+    assertEquals(":forReturn:", forReturn(false))
+    assertEquals(":return:", global)
+
+    return "OK"
+}
@@ -0,0 +1,94 @@
+package foo
+
+var global: String = ""
+
+fun id(s: String, b: Boolean): Boolean {
+    global += s
+    return b
+}
+
+fun bar(b: Boolean): String {
+    if (id("A",b) || return "A")
+        return "B"
+    else
+        return "C"
+}
+
+fun testBreak(b: Boolean, expected: Int) {
+    global = ""
+    var i = 0
+    while (i++ < 5) {
+        if (i == 2) id("A", b) || break
+    }
+    assertEquals(expected, i, "break 1")
+    assertEquals("A", global, "break 1")
+
+    global = ""
+    i = 0
+    while (i++ < 5) {
+        if (i == 2) {
+            var x = id("A", b) || break
+        }
+    }
+    assertEquals(expected, i, "break 2")
+    assertEquals("A", global, "break 2")
+}
+
+fun testContinue(b: Boolean, expected: Int) {
+    global = ""
+    var i = 0
+    var n = 0
+    while (i++ < 5) {
+        if (i == 2) id("A", b) || continue
+        n++
+    }
+    assertEquals(expected, n, "continue 1")
+    assertEquals("A", global, "continue 1")
+
+    global = ""
+    i = 0
+    n = 0
+    while (i++ < 5) {
+        if (i == 2) {
+            var x = id("A", b) || continue
+        }
+        n++
+    }
+    assertEquals(expected, n, "continue 2")
+    assertEquals("A", global, "continue 2")
+}
+
+fun box(): String {
+
+    testBreak(true, 6)
+    testBreak(false, 2)
+
+    global = ""
+    var i = 0
+    while (i++ < 5) {
+        if (i == 2) break || id("A", true)
+    }
+    assertEquals(2, i, "break || true")
+    assertEquals("", global, "break || false")
+
+    testContinue(true, 5)
+    testContinue(false, 4)
+
+    global = ""
+    i = 0
+    var n = 0
+    while (i++ < 5) {
+        if (i == 2) continue || id("A", true)
+        n++
+    }
+    assertEquals(4, n, "continue || true")
+    assertEquals("", global, "continue || true")
+
+    assertEquals("B", bar(true))
+    assertEquals("A", global, "bar")
+    global = ""
+    assertEquals("A", bar(false))
+    assertEquals("A", global, "bar")
+
+    return "OK"
+}
@@ -0,0 +1,86 @@
+package foo
+
+var global: String = ""
+
+fun bar(s: String, value: Boolean): Boolean {
+    global += s
+    return value
+}
+
+fun box(): String {
+    val a =  if (true || if(bar("A", false)) {2} else {3} == 0) true else false
+    assertEquals("", global)
+
+    true || if(bar("A", false)) {2} else {3} == 0
+    assertEquals("", global)
+
+    // Simple || Simple
+    global = ""
+    assertEquals(true, bar("A", true) || bar("B", true))
+    assertEquals("A", global)
+
+    global = ""
+    assertEquals(true, bar("A", true) || bar("B", false))
+    assertEquals("A", global)
+
+    global = ""
+    assertEquals(true, bar("A", false) || bar("B", true))
+    assertEquals("AB", global)
+
+    global = ""
+    assertEquals(false, bar("A", false) || bar("B", false))
+    assertEquals("AB", global)
+
+    // Simple || Complex
+    global = ""
+    assertEquals(true, bar("A", true) || try { bar("B", true) } finally {})
+    assertEquals("A", global)
+
+    global = ""
+    assertEquals(true, bar("A", true) || try { bar("B", false) } finally {})
+    assertEquals("A", global)
+
+    global = ""
+    assertEquals(true, bar("A", false) || try { bar("B", true) } finally {})
+    assertEquals("AB", global)
+
+    global = ""
+    assertEquals(false, bar("A", false) || try { bar("B", false) } finally {})
+    assertEquals("AB", global)
+
+    // Complex || Simple
+    global = ""
+    assertEquals(true, try { bar("A", true) } finally {} || bar("B", true))
+    assertEquals("A", global)
+
+    global = ""
+    assertEquals(true, try { bar("A", true) } finally {} || bar("B", false))
+    assertEquals("A", global)
+
+    global = ""
+    assertEquals(true, try { bar("A", false) } finally {} || bar("B", true))
+    assertEquals("AB", global)
+
+    global = ""
+    assertEquals(false, try { bar("A", false) } finally {} || bar("B", false))
+    assertEquals("AB", global)
+
+    // Complex || Complex
+    global = ""
+    assertEquals(true, try { bar("A", true) } finally {} || try { bar("B", true) } finally {})
+    assertEquals("A", global)
+
+    global = ""
+    assertEquals(true, try { bar("A", true) } finally {} || try { bar("B", false) } finally {})
+    assertEquals("A", global)
+
+    global = ""
+    assertEquals(true, try { bar("A", false) } finally {} || try { bar("B", true) } finally {})
+    assertEquals("AB", global)
+
+    global = ""
+    assertEquals(false, try { bar("A", false) } finally {} || try { bar("B", false) } finally {})
+    assertEquals("AB", global)
+
+    return "OK"
+}
@@ -0,0 +1,55 @@
+package foo
+
+var log = ""
+
+class A(val value: Int) {
+    operator fun plus(other: A): A {
+        log += "A.plus(${other.value});"
+        return A(value + other.value)
+    }
+}
+
+val _array = arrayOf(A(2))
+
+fun getArray(): Array<A> {
+    log += "getArray();"
+    return _array
+}
+
+fun getArrayIndex(): Int {
+    log += "getArrayIndex();"
+    return 0
+}
+
+class B(value: Int) {
+    var a = A(value)
+}
+
+val _property = B(10)
+val _functionResult = B(100)
+
+val foo: B
+    get() {
+        log += "foo;"
+        return _property
+    }
+
+fun bar(): B {
+    log += "bar();"
+    return _functionResult
+}
+
+fun box(): String {
+    getArray()[getArrayIndex()] += A(3)
+    assertEquals(5, _array[0].value)
+
+    foo.a += A(20)
+    assertEquals(30, _property.a.value)
+
+    bar().a += A(200)
+    assertEquals(300, _functionResult.a.value)
+
+    assertEquals("getArray();getArrayIndex();A.plus(3);foo;A.plus(20);bar();A.plus(200);", log)
+
+    return "OK"
+}
@@ -0,0 +1,15 @@
+package foo
+
+fun box(): String {
+    var  i = 0
+    var t = ++i + when(i) {
+        3 -> 4
+        1 -> 2
+        0 -> 1
+        else -> 100
+    }
+    if (t != 3) {
+        return "fail: $t"
+    }
+    return "OK"
+}
@@ -0,0 +1,38 @@
+package foo
+
+var global: String = ""
+
+fun bar(s: String): Int {
+    global += s
+    return 1
+}
+fun testWhen() {
+    global = ""
+    when(arrayOf(bar("A"),2,3)) {
+        arrayOf(1) -> println("1")
+        arrayOf(2) -> println("2")
+        else  -> println("else")
+    }
+    assertEquals("A", global)
+
+}
+
+fun testIntrinsic() {
+    global = ""
+    val x = arrayOf(bar("A")) == try { arrayOf(bar("B")) } finally {}
+    assertEquals("AB", global)
+}
+
+fun testElvis() {
+    global = ""
+    var x = arrayOf(bar("A")) ?: 10
+    assertEquals("A", global)
+}
+
+fun box(): String {
+    testWhen()
+    testIntrinsic()
+    testElvis()
+
+    return "OK"
+}
@@ -0,0 +1,68 @@
+package foo
+
+var global: String = ""
+
+fun id(s: String, value: Boolean): Boolean {
+    global += s
+    return value
+}
+
+fun box(): String {
+
+    when {
+      id("A", true) || id("B", true) -> 10
+    }
+    assertEquals("A", global)
+
+    global = ""
+    when {
+        id("A", false) || id("B", true) || id("C", true) -> 10
+    }
+    assertEquals("AB", global)
+
+    global = ""
+    var b = true
+    when {
+        try { global += "A"; b } finally {} -> 10
+        try { global += "B"; !b } finally {} -> 20
+    }
+    assertEquals("A", global)
+
+    global = ""
+    b = false
+    when {
+        try { global += "A"; b } finally {} -> 10
+        try { global += "B"; !b } finally {} -> 20
+    }
+    assertEquals("AB", global)
+
+    global = ""
+    b = true
+    when {
+        b || try { global += "A"; !b } finally {} -> 10
+    }
+    assertEquals("", global)
+
+    global = ""
+    b = false
+    when {
+        b || try { global += "A"; !b } finally {} -> 10
+    }
+    assertEquals("A", global)
+
+    global = ""
+    when {
+        false -> {
+            global += "A"
+        }
+        try { global += "B"; false } finally {} -> {
+            global += "D"
+        }
+        else -> {
+            global += "C"
+        }
+    }
+    assertEquals("BC", global)
+
+    return "OK"
+}