JS: move inline test to box tests

2016-08-29 11:55:22 +03:00
parent b159049be8
commit efb82a044f
150 changed files with 1417 additions and 1430 deletions
@@ -0,0 +1,26 @@
+package foo
+
+// CHECK_NOT_CALLED: buzz
+
+private var LOG = ""
+
+fun log(string: String) {
+    LOG += "$string;"
+}
+
+fun pullLog(): String {
+    val string = LOG
+    LOG = ""
+    return string
+}
+
+fun <T> fizz(x: T): T {
+    log("fizz($x)")
+    return x
+}
+
+inline
+fun <T> buzz(x: T): T {
+    log("buzz($x)")
+    return x
+}
@@ -0,0 +1,13 @@
+package foo
+
+fun sum(x: Int, y: Int): Int {
+    log("sum($x, $y)")
+    return x + y
+}
+
+fun box(): String {
+    assertEquals(3, sum(fizz(1), buzz(2)))
+    assertEquals("fizz(1);buzz(2);sum(1, 2);", pullLog())
+
+    return "OK"
+}
@@ -0,0 +1,13 @@
+package foo
+
+fun sum(a: Int, b: Int, c: Int, d: Int): Int {
+    log("sum($a, $b, $c, $d)")
+    return a + b + c + d
+}
+
+fun box(): String {
+    assertEquals(10, sum(fizz(1), buzz(2), fizz(3), buzz(4)))
+    assertEquals("fizz(1);buzz(2);fizz(3);buzz(4);sum(1, 2, 3, 4);", pullLog())
+
+    return "OK"
+}
@@ -0,0 +1,19 @@
+package foo
+
+// CHECK_NOT_CALLED: max
+
+inline fun max(a: Int, b: Int): Int {
+    log("max($a, $b)")
+
+    if (a > b) return a
+
+    return b
+}
+
+fun box(): String {
+    val test = max(fizz(1), max(fizz(2), buzz(3)))
+    assertEquals(3, test)
+    assertEquals("fizz(1);fizz(2);buzz(3);max(2, 3);max(1, 3);", pullLog())
+
+    return "OK"
+}
@@ -0,0 +1,16 @@
+package foo
+
+class Sum(x: Int, y: Int) {
+    init {
+        log("new Sum($x, $y)")
+    }
+
+    val value = x + y
+}
+
+fun box(): String {
+    assertEquals(3, Sum(fizz(1), buzz(2)).value)
+    assertEquals("fizz(1);buzz(2);new Sum(1, 2);", pullLog())
+
+    return "OK"
+}
@@ -0,0 +1,8 @@
+package foo
+
+fun box(): String {
+    assertEquals(2, fizz(arrayOf(1, 2))[buzz(1)])
+    assertEquals("fizz(1,2);buzz(1);", pullLog())
+
+    return "OK"
+}
@@ -0,0 +1,8 @@
+package foo
+
+fun box(): String {
+    assertEquals(2, arrayOf(1, 2)[fizz(0) + buzz(1)])
+    assertEquals("fizz(0);buzz(1);", pullLog())
+
+    return "OK"
+}
@@ -0,0 +1,8 @@
+package foo
+
+fun box(): String {
+    assertEquals(2, arrayOf(1, fizz(2))[fizz(0) + buzz(1)])
+    assertEquals("fizz(2);fizz(0);buzz(1);", pullLog())
+
+    return "OK"
+}
@@ -0,0 +1,16 @@
+package foo
+
+var global = ""
+
+class A(val data: Array<Int>)
+
+fun box(): String {
+    val a = A(arrayOf(1, 2, 3))
+    a.data[0] = listOf(1, 2, 3).fold(0) { a, b ->
+        global += "$b;"
+        a + b
+    }
+    assertEquals(6, a.data[0])
+    assertEquals("1;2;3;", global)
+    return "OK"
+}
@@ -0,0 +1,8 @@
+package foo
+
+fun box(): String {
+    assertArrayEquals(arrayOf(1, 2), arrayOf(fizz(1), buzz(2)))
+    assertEquals("fizz(1);buzz(2);", pullLog())
+
+    return "OK"
+}
@@ -0,0 +1,8 @@
+package foo
+
+fun box(): String {
+    assertArrayEquals(arrayOf(1, 2, 3, 4), arrayOf(fizz(1), buzz(2), fizz(3), buzz(4)))
+    assertEquals("fizz(1);buzz(2);fizz(3);buzz(4);", pullLog())
+
+    return "OK"
+}
@@ -0,0 +1,8 @@
+package foo
+
+fun box(): String {
+    assertArrayEquals(arrayOf(arrayOf(1, 2), arrayOf(3, 4)), arrayOf(arrayOf(fizz(1), buzz(2)), arrayOf(fizz(3), buzz(4))))
+    assertEquals("fizz(1);buzz(2);fizz(3);buzz(4);", pullLog())
+
+    return "OK"
+}
@@ -0,0 +1,14 @@
+package foo
+
+class A(var x: Int) {
+    override fun toString(): String = "A($x)"
+}
+
+fun box(): String {
+    val a = A(10)
+    fizz(a).x = buzz(20)
+    assertEquals(20, a.x)
+    assertEquals("fizz(A(10));buzz(20);", pullLog())
+
+    return "OK"
+}
@@ -0,0 +1,8 @@
+package foo
+
+fun box(): String {
+    assertEquals(3, fizz(1) + buzz(2))
+    assertEquals("fizz(1);buzz(2);", pullLog())
+
+    return "OK"
+}
@@ -0,0 +1,8 @@
+package foo
+
+fun box(): String {
+    assertEquals(10, (fizz(1) + buzz(2)) + (fizz(3) + buzz(4)))
+    assertEquals("fizz(1);buzz(2);fizz(3);buzz(4);", pullLog())
+
+    return "OK"
+}
@@ -0,0 +1,13 @@
+package foo
+
+fun multiplyFun(): (Int, Int)->Int {
+    log("multiplyFun()")
+    return { x, y -> x * y }
+}
+
+fun box(): String {
+    assertEquals(6, multiplyFun()(fizz(2), buzz(3)))
+    assertEquals("multiplyFun();fizz(2);buzz(3);", pullLog())
+
+    return "OK"
+}
@@ -0,0 +1,21 @@
+package foo
+
+// CHECK_NOT_CALLED: multiplyFunInline
+
+fun multiplyFun(): (Int, Int)->Int {
+    log("multiplyFun()")
+    return { x, y -> x * y }
+}
+
+inline
+fun multiplyFunInline(): (Int, Int)->Int {
+    log("multiplyFunInline()")
+    return { x, y -> x * y }
+}
+
+fun box(): String {
+    assertEquals(6, arrayOf(multiplyFun(), multiplyFunInline())[0](fizz(2), fizz(3)))
+    assertEquals("multiplyFun();multiplyFunInline();fizz(2);fizz(3);", pullLog())
+
+    return "OK"
+}
@@ -0,0 +1,13 @@
+package foo
+
+fun test(x: Boolean): Boolean =
+        if (fizz(x)) buzz(true) else buzz(false)
+
+fun box(): String {
+    assertEquals(true, test(true))
+    assertEquals("fizz(true);buzz(true);", pullLog())
+    assertEquals(false, test(false))
+    assertEquals("fizz(false);buzz(false);", pullLog())
+
+    return "OK"
+}
@@ -0,0 +1,14 @@
+package foo
+
+fun test(x: Boolean?): Boolean = fizz(x) ?: buzz(true)
+
+fun box(): String {
+    assertEquals(true, test(null))
+    assertEquals("fizz(null);buzz(true);", pullLog())
+    assertEquals(false, test(false))
+    assertEquals("fizz(false);", pullLog())
+    assertEquals(true, test(true))
+    assertEquals("fizz(true);", pullLog())
+
+    return "OK"
+}
@@ -0,0 +1,23 @@
+package foo
+
+fun test(x: Boolean, y: Boolean): Int =
+        if (fizz(x))
+            if (fizz(y)) buzz(1) else buzz(2)
+        else
+            if (fizz(y)) buzz(3) else buzz(4)
+
+fun box(): String {
+    assertEquals(1, test(true, true))
+    assertEquals("fizz(true);fizz(true);buzz(1);", pullLog())
+
+    assertEquals(2, test(true, false))
+    assertEquals("fizz(true);fizz(false);buzz(2);", pullLog())
+
+    assertEquals(3, test(false, true))
+    assertEquals("fizz(false);fizz(true);buzz(3);", pullLog())
+
+    assertEquals(4, test(false, false))
+    assertEquals("fizz(false);fizz(false);buzz(4);", pullLog())
+
+    return "OK"
+}
@@ -0,0 +1,13 @@
+package foo
+
+fun test(x: Boolean): Boolean =
+        if (buzz(x)) buzz(true) else fizz(false)
+
+fun box(): String {
+    assertEquals(true, test(true))
+    assertEquals("buzz(true);buzz(true);", pullLog())
+    assertEquals(false, test(false))
+    assertEquals("buzz(false);fizz(false);", pullLog())
+
+    return "OK"
+}
@@ -0,0 +1,14 @@
+package foo
+
+fun test(x: Boolean?): Boolean = buzz(x) ?: fizz(true)
+
+fun box(): String {
+    assertEquals(true, test(null))
+    assertEquals("buzz(null);fizz(true);", pullLog())
+    assertEquals(false, test(false))
+    assertEquals("buzz(false);", pullLog())
+    assertEquals(true, test(true))
+    assertEquals("buzz(true);", pullLog())
+
+    return "OK"
+}
@@ -0,0 +1,35 @@
+package foo
+
+private inline fun bar(predicate: (Char) -> Boolean): Int {
+    var i = -1
+    val str = "abc "
+    do {
+        i++
+        if (i == 1) continue
+        log(i.toString())
+    } while (predicate(str[i]) && i < 3)
+    return i
+}
+
+private fun test(c: Char): Int {
+    return bar {
+        log(it.toString())
+        it != c
+    }
+}
+
+fun box(): String {
+    assertEquals(0, test('a'))
+    assertEquals("0;a;", pullLog())
+
+    assertEquals(1, test('b'))
+    assertEquals("0;a;b;", pullLog())
+
+    assertEquals(2, test('c'))
+    assertEquals("0;a;b;2;c;", pullLog())
+
+    assertEquals(3, test('*'))
+    assertEquals("0;a;b;2;c;3; ;", pullLog())
+
+    return "OK"
+}
@@ -0,0 +1,14 @@
+package foo
+
+fun box(): String {
+    var c = 2
+
+    do {
+        if (c > 4) throw Exception("Timeout!")
+        c++
+    } while (buzz(c) < 4)
+
+    assertEquals("buzz(3);buzz(4);", pullLog())
+
+    return "OK"
+}
@@ -0,0 +1,14 @@
+package foo
+
+fun box(): String {
+    var c = 1
+
+    do {
+        if (c > 4) throw Exception("Timeout!")
+        c++
+    } while (fizz(c) % 2 == 0 || buzz(c) % 3 == 0)
+
+    assertEquals("fizz(2);fizz(3);buzz(3);fizz(4);fizz(5);buzz(5);", pullLog())
+
+    return "OK"
+}
@@ -0,0 +1,11 @@
+package foo
+
+fun box(): String {
+    for (i in fizz(1)..buzz(3)) {
+        fizz(i)
+    }
+
+    assertEquals("fizz(1);buzz(3);fizz(1);fizz(2);fizz(3);", pullLog())
+
+    return "OK"
+}
@@ -0,0 +1,23 @@
+package foo
+
+fun test(x: Boolean, y: Boolean): Boolean {
+    if (fizz(x) && buzz(y)) {
+        return true
+    }
+
+    return false
+}
+
+
+fun box(): String {
+    assertEquals(false, test(false, true))
+    assertEquals("fizz(false);", pullLog())
+
+    assertEquals(false, test(true, false))
+    assertEquals("fizz(true);buzz(false);", pullLog())
+
+    assertEquals(true, test(true, true))
+    assertEquals("fizz(true);buzz(true);", pullLog())
+
+    return "OK"
+}
@@ -0,0 +1,101 @@
+// See KT-11711
+package foo
+
+interface A {
+    val b: B
+}
+
+interface B {
+    fun c(a: Any?)
+}
+
+val a: A
+    get() {
+        log("a.get")
+        return object : A {
+            override val b: B
+                get() {
+                    log("b.get")
+                    return object : B {
+                        override fun c(a: Any?) {
+                            log("c()")
+                        }
+                    }
+                }
+        }
+    }
+
+val g: Any?
+    get() {
+        log("g.get")
+        return "c"
+    }
+
+inline fun foo(): Any? {
+    log("foo()")
+    return g;
+}
+
+inline fun bar(): Any? {
+    return g;
+}
+
+inline fun baz(): Any? {
+    return log("baz()");
+}
+
+inline fun boo(a: Any?): Any? {
+    return log("boo()");
+}
+
+fun box(): String {
+    log("--1--")
+    a.b.c(g)
+
+    log("--2--")
+
+    a.b.c(foo())
+
+    log("--3--")
+
+    a.b.c(bar())
+
+    log("--4--")
+
+    a.b.c(baz())
+
+    log("--5--")
+
+    a.b.c(boo(g))
+
+    assertEquals("""--1--
+a.get
+b.get
+g.get
+c()
+--2--
+a.get
+b.get
+foo()
+g.get
+c()
+--3--
+a.get
+b.get
+g.get
+c()
+--4--
+a.get
+b.get
+baz()
+c()
+--5--
+a.get
+b.get
+g.get
+boo()
+c()
+""", pullLog().replace(';', '\n'))
+
+    return "OK"
+}
@@ -0,0 +1,24 @@
+// See KT-7674
+package foo
+
+class A(val a: Int) {
+    val plus: (Int)->Int
+        get() {
+            log("get plus fun")
+            return {
+                log("do plus")
+                a + it
+            }
+        }
+}
+
+inline fun <T : Any> id(x: T): T {
+    log(x.toString())
+    return x
+}
+
+fun box(): String {
+    assertEquals(3, A(id(1)).plus(id(2)))
+    assertEquals("1;get plus fun;2;do plus;", pullLog())
+    return "OK"
+}
@@ -0,0 +1,49 @@
+package foo
+
+/* This tests checks, that lambda fabric invocation is not extracted.
+
+   An example:
+       fun foo() {
+         val status = "OK"
+         run { println(status) }
+       }
+
+   It's compiled to something like:
+        function foo() {
+          var status = "OK";
+          run(foo$(status));
+        }
+
+        function foo$(status) {
+          return function() {
+            console.log(status);
+          };
+        }
+
+   Thus, we need to be sure, that foo$() is not extracted to some temporary var.
+ */
+
+// CHECK_NOT_CALLED: max
+// CHECK_NOT_CALLED: box$f
+// CHECK_NOT_CALLED: box$f_0
+
+inline fun max(getA: ()->Int, b: Int): Int {
+    val a = getA()
+    log("max($a, $b)")
+
+    if (a > b) return a
+
+    return b
+}
+
+fun box(): String {
+    val one = 1
+    val two = 2
+    val three = 3
+
+    val test = max({ fizz(one) }, max({ fizz(two) }, buzz(three)))
+    assertEquals(3, test)
+    assertEquals("buzz(3);fizz(2);max(2, 3);fizz(1);max(1, 3);", pullLog())
+
+    return "OK"
+}
@@ -0,0 +1,14 @@
+package foo
+
+fun box(): String {
+    assertEquals(false, fizz(false) && buzz(false))
+    assertEquals("fizz(false);", pullLog())
+
+    assertEquals(false, fizz(true) && buzz(false))
+    assertEquals("fizz(true);buzz(false);", pullLog())
+
+    assertEquals(true, fizz(true) && buzz(true))
+    assertEquals("fizz(true);buzz(true);", pullLog())
+
+    return "OK"
+}
@@ -0,0 +1,8 @@
+package foo
+
+fun box(): String {
+    assertEquals(true, fizz(true) || buzz(true) && (fizz(false) || buzz(true)))
+    assertEquals("fizz(true);", pullLog())
+
+    return "OK"
+}
@@ -0,0 +1,14 @@
+package foo
+
+fun box(): String {
+    assertEquals(true, fizz(true) || buzz(false))
+    assertEquals("fizz(true);", pullLog())
+
+    assertEquals(true, fizz(false) || buzz(true))
+    assertEquals("fizz(false);buzz(true);", pullLog())
+
+    assertEquals(false, fizz(false) || buzz(false))
+    assertEquals("fizz(false);buzz(false);", pullLog())
+
+    return "OK"
+}
@@ -0,0 +1,14 @@
+package foo
+
+// Test for KT-7502
+
+class A(val value: Int) {
+    fun plus(num: Int): Int = this.value + num
+}
+
+fun box(): String {
+    assertEquals(15, A(fizz(5)).plus(buzz(10)))
+    assertEquals("fizz(5);buzz(10);", pullLog())
+
+    return "OK"
+}
@@ -0,0 +1,8 @@
+package foo
+
+fun box(): String {
+    val v = mapOf(1 to "1", 2 to "2").mapValues { it.value.map { it.toString() } }
+    assertEquals(2, v.size)
+
+    return "OK"
+}
@@ -0,0 +1,15 @@
+package foo
+
+// Test for KT-7502
+// CHECK_NOT_CALLED: plus
+
+class A(val value: Int) {
+    inline fun plus(num: Int): Int = this.value + num
+}
+
+fun box(): String {
+    assertEquals(15, A(fizz(5)).plus(buzz(10)))
+    assertEquals("fizz(5);buzz(10);", pullLog())
+
+    return "OK"
+}
@@ -0,0 +1,18 @@
+package foo
+
+// CHECK_NOT_CALLED: component2
+
+class A(val x: Int, val y: Int)
+
+operator fun A.component1(): Int = fizz(x)
+
+inline operator fun A.component2(): Int = buzz(y)
+
+fun box(): String {
+    val (a, b) = A(1, 2)
+    assertEquals(a, 1)
+    assertEquals(b, 2)
+    assertEquals("fizz(1);buzz(2);", pullLog())
+
+    return "OK"
+}
@@ -0,0 +1,30 @@
+package foo
+
+// CHECK_NOT_CALLED: component2
+// CHECK_NOT_CALLED: component3
+// CHECK_NOT_CALLED: component5
+
+class A(val a: Int, val b: Int, val c: Int, val d: Int, val e: Int)
+
+operator fun A.component1(): Int = fizz(a)
+
+inline operator fun A.component2(): Int = buzz(b)
+
+inline operator fun A.component3(): Int = buzz(c)
+
+operator fun A.component4(): Int = fizz(d)
+
+inline operator fun A.component5(): Int = buzz(e)
+
+fun box(): String {
+    val (a, b, c, d, e) = A(1, 2, 3, 4, 5)
+
+    assertEquals(1, a)
+    assertEquals(2, b)
+    assertEquals(3, c)
+    assertEquals(4, d)
+    assertEquals(5, e)
+    assertEquals("fizz(1);buzz(2);buzz(3);fizz(4);buzz(5);", pullLog())
+
+    return "OK"
+}
@@ -0,0 +1,28 @@
+package foo
+
+private inline fun bar(predicate: (Int) -> Boolean) {
+    var i = -1
+    outer@do {
+        i++
+        if (i == 1) continue
+        var j = -1
+        do {
+            ++j
+            if (j == 1) {
+                if (i == 3) continue@outer else continue
+            }
+            log("i$j")
+        } while (j < 3)
+        log("o$i")
+    } while (predicate(i))
+}
+
+fun box(): String {
+    bar {
+        log("p$it")
+        it < 5
+    }
+    assertEquals("i0;i2;i3;o0;p0;p1;i0;i2;i3;o2;p2;i0;p3;i0;i2;i3;o4;p4;i0;i2;i3;o5;p5;", pullLog())
+
+    return "OK"
+}
@@ -0,0 +1,8 @@
+package foo
+
+fun box(): String {
+    assertEquals(3, buzz(fizz(1) + buzz(2)))
+    assertEquals("fizz(1);buzz(2);buzz(3);", pullLog())
+
+    return "OK"
+}
@@ -0,0 +1,20 @@
+package foo
+
+class A(val x: Int = fizz(1) + 1) {
+    val y = buzz(x) + 1
+    val z: Int
+
+    init {
+        z = fizz(x) + buzz(y)
+    }
+}
+
+fun box(): String {
+    val a = A()
+    assertEquals(2, a.x)
+    assertEquals(3, a.y)
+    assertEquals(5, a.z)
+    assertEquals("fizz(1);buzz(2);fizz(2);buzz(3);", pullLog())
+
+    return "OK"
+}
@@ -0,0 +1,17 @@
+package foo
+
+class A {
+    val x: Int
+
+    init {
+        x = fizz(1) + buzz(2)
+    }
+}
+
+fun box(): String {
+    val a = A()
+    assertEquals(3, a.x)
+    assertEquals("fizz(1);buzz(2);", pullLog())
+
+    return "OK"
+}
@@ -0,0 +1,16 @@
+package foo
+
+class A {
+    var x = 23
+}
+
+inline fun bar(value: Int, a: A): Int {
+    a.x = 42
+    return value
+}
+
+fun box(): String {
+    val a = A()
+    assertEquals(23, bar(a.x, a))
+    return "OK"
+}
@@ -0,0 +1,21 @@
+package foo
+
+object A {
+    init {
+        log("A.init")
+    }
+
+    val x = 23
+}
+
+inline fun bar(value: Int) {
+    log("bar->begin")
+    log("value=$value")
+    log("bar->end")
+}
+
+fun box(): String {
+    bar(A.x)
+    assertEquals("A.init;bar->begin;value=23;bar->end;", pullLog())
+    return "OK"
+}
@@ -0,0 +1,39 @@
+package foo
+
+var g: Any?
+    get() {
+        log("g.get")
+        return null
+    }
+    set(v) {
+        log("g.set")
+    }
+
+public inline fun Array<String>.boo() {
+    var a = g
+    for (element in this);
+}
+
+public inline fun Iterable<String>.boo(i: Any?) {
+    var a = i
+    for (element in this);
+}
+
+fun test1(f: () -> Array<String>) {
+    f().boo()
+}
+
+fun test2(f: () -> Iterable<String>) {
+    f().boo(g)
+}
+
+
+fun box(): String {
+    test1 { log("lambda1"); arrayOf() }
+    assertEquals("lambda1;g.get;", pullLog())
+
+    test2 { log("lambda2"); listOf() }
+    assertEquals("lambda2;g.get;", pullLog())
+
+    return "OK"
+}
@@ -0,0 +1,20 @@
+// Looks similar to KT-7674
+package foo
+
+inline fun bar(): Int {
+    log("bar")
+    return 10
+}
+
+val x: Int
+    get() {
+        log("x")
+        return 1
+    }
+
+fun box(): String {
+    assertEquals(12, x + bar() + x)
+    assertEquals("x;bar;x;", pullLog())
+
+    return "OK"
+}
@@ -0,0 +1,27 @@
+// See KT-7043, KT-11711
+package foo
+
+inline fun foo(b: Any) {
+    val t = aa[0]
+    val a = b
+}
+
+val a: Array<String>
+    get() {
+        log("a.get")
+        return arrayOf("a")
+    }
+
+val aa: Array<String>
+    get() {
+        log("aa.get")
+        return arrayOf("aa")
+    }
+
+fun box(): String {
+    foo(a[0])
+
+    assertEquals("a.get;aa.get;", pullLog())
+
+    return "OK"
+}
@@ -0,0 +1,20 @@
+package foo
+
+// CHECK_NOT_CALLED: bar_vux9f0$
+
+inline fun bar(n: Int, x: Int) = if (n <= 5) x else 10
+
+fun test(n: Int): Int = bar(n, fizz(n))
+
+fun box(): String {
+    var result = test(4)
+    if (result != 4) return "fail1: $result"
+
+    result = test(8)
+    if (result != 10) return "fail2: $result"
+
+    var log = pullLog()
+    if (log != "fizz(4);fizz(8);") return "fail_log: $log"
+
+    return "OK"
+}
@@ -0,0 +1,14 @@
+package foo
+
+fun box(): String {
+    var c = 2
+
+    while (buzz(c) <= 4) {
+        if (c > 4) throw Exception("Timeout!")
+        c++
+    }
+
+    assertEquals("buzz(2);buzz(3);buzz(4);buzz(5);", pullLog())
+
+    return "OK"
+}
@@ -0,0 +1,14 @@
+package foo
+
+fun box(): String {
+    var c = 2
+
+    while (fizz(c) % 2 == 0 || buzz(c) % 3 == 0) {
+        if (c > 4) throw Exception("Timeout!")
+        c++
+    }
+
+    assertEquals("fizz(2);fizz(3);buzz(3);fizz(4);fizz(5);buzz(5);", pullLog())
+
+    return "OK"
+}
@@ -0,0 +1,24 @@
+// See KT-8005
+package foo
+
+private inline fun bar(predicate: (Char) -> Boolean): Int {
+    var i = 0
+    val str = "abc "
+    while (predicate(str[i]) && i < 3) {
+        i++
+    }
+    return i
+}
+
+private fun test(c: Char): Int {
+    return bar { it != c }
+}
+
+fun box(): String {
+    assertEquals(0, test('a'))
+    assertEquals(1, test('b'))
+    assertEquals(2, test('c'))
+    assertEquals(3, test('*'))
+
+    return "OK"
+}