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,52 @@
+package foo
+
+fun box(): String {
+
+    if (!true.and(true)) {
+        return "fail1"
+    }
+    if (false.and(true)) {
+        return "fail2"
+    }
+
+    if (!true.or(false)) {
+        return "fail3"
+    }
+
+
+    if (false.or(false)) {
+        return "fail3"
+    }
+
+
+    if (!true.or(true)) {
+        return "fail4"
+    }
+
+
+    if (false.and(false)) {
+        return "fail5"
+    }
+
+    if (false.xor(false)) {
+        return "fail6"
+    }
+    if (!true.xor(false)) {
+        return "fail7"
+    }
+
+    if (true.xor(true)) {
+        return "fail8"
+    }
+
+    if (true.not()) {
+        return "fail9"
+
+    }
+
+    if (!false.not()) {
+        return "fail10"
+    }
+
+    return "OK"
+}
@@ -0,0 +1,26 @@
+var log = ""
+
+fun printlnLog(message: Any) {
+    log += "$message\n"
+}
+
+fun box(): String {
+    printlnLog(true.and1(true))
+
+    if (log != "true\n") return "fail: $log"
+    return "OK"
+}
+
+fun Boolean.and1(other: Boolean): Boolean {
+    if (other == true) {
+        if (this == true) {
+            return true ;
+        }
+        else {
+            return false;
+        }
+    }
+    else {
+        return false;
+    }
+}
@@ -0,0 +1,21 @@
+package foo
+
+class B {
+    val d = "OK"
+
+    fun f(): String {
+        val c = object {
+            fun foo(): String {
+                return d
+            }
+            fun boo(): String {
+                return foo()
+            }
+        }
+        return c.boo()
+    }
+}
+
+fun box(): String {
+    return B().f()
+}
@@ -0,0 +1,51 @@
+package foo
+
+class Data(val rawData: Array<Int>, val width: Int, val height: Int) {
+    operator fun get(x: Int, y: Int): ColorLike {
+        return object : ColorLike {
+            override val red: Int = rawData[(y * width + x) * 4 + 0];
+            override val green: Int = rawData[(y * width + x) * 4 + 1];
+            override val blue: Int = rawData[(y * width + x) * 4 + 2];
+        }
+    }
+
+    operator fun set(x: Int, y: Int, color: ColorLike) {
+        rawData[(y * width + x) * 4 + 0] = color.red;
+        rawData[(y * width + x) * 4 + 1] = color.green;
+        rawData[(y * width + x) * 4 + 2] = color.blue;
+    }
+
+    fun each(block: (x: Int, y: Int) -> Unit) {
+        for (x in 0..width - 1) {
+            for (y in 0..height - 1) {
+                block(x, y)
+            }
+        }
+    }
+}
+
+class Color(r: Int, g: Int, b: Int) : ColorLike {
+    override val red: Int = r
+    override val green: Int = g
+    override val blue: Int = b
+}
+
+interface ColorLike {
+    val red: Int;
+    val green: Int;
+    val blue: Int;
+}
+
+fun box(): String {
+    val d = Data(Array(4) { 0 }, 1, 1)
+    if (d[0, 0].red != 0) {
+        return "fail1"
+    }
+    if (d[0, 0].green != 0) {
+        return "fail2"
+    }
+    if (d[0, 0].blue != 0) {
+        return "fail3"
+    }
+    return "OK"
+}
@@ -0,0 +1,15 @@
+package foo
+
+open class A {
+    open fun foo(a: Int = 1) = a
+}
+
+class B : A() {
+    override fun foo(a: Int) = a + 1
+}
+
+fun box(): String {
+    val result = B().foo()
+    if (result != 2) return "fail: $result"
+    return "OK"
+}
@@ -0,0 +1,25 @@
+package foo
+
+import java.util.*
+
+fun box(): String {
+    val data = myArrayList("foo", "bar")
+    if (data.myHead != "foo") {
+        return "fail: ${data.myHead}"
+    }
+    return "OK"
+}
+
+
+inline public fun <T> myArrayList(vararg values: T): ArrayList<T> {
+    val c = ArrayList<T>()
+    for (v in values) {
+        c.add(v)
+    }
+    return c
+}
+
+public val <T> ArrayList<T>.myHead: T
+    get() {
+        return get(0)
+    }
@@ -0,0 +1,25 @@
+package foo
+
+fun test():Any {
+    val a: Any = "OK"
+    val f: Any =
+            if (true) {
+                when {
+                    false -> "1"
+                    ((a as? String)?.size ?: 0 > 0) -> a
+                    else -> "2"
+                }
+            }
+            else {
+                "3"
+
+            }
+
+    return f
+}
+
+fun box(): Any {
+    var result = test()
+    return result
+}
+
@@ -0,0 +1,57 @@
+package foo
+
+var c0 = 0
+var c1 = 0
+var c2 = 0
+var c3 = 0
+
+fun cStr(): String {
+    return "${c0}${c1}${c2}${c3}"
+}
+
+fun get1(): Int {
+    c3++
+    return 1
+}
+
+class A() {
+    var p = 0
+    operator fun get(i: Int): Int {
+        c1++
+        return 0
+    }
+
+    operator fun set(i: Int, value: Int) {
+        c2++
+    }
+}
+
+val a: A = A()
+    get() {
+        c0++
+        return field
+    }
+
+fun box(): String {
+    var d = a[1]
+    if (cStr() != "1100") {
+        return "Fail: d = a[1], cStr(): ${cStr()}"
+    }
+
+    ++a[1]
+    if (cStr() != "2310") {
+        return "Fail: ++a[1], cStr(): ${cStr()}"
+    }
+
+    --a[1]
+    if (cStr() != "3520") {
+        return "Fail: --a[1], cStr(): ${cStr()}"
+    }
+
+    ++a[get1()]
+    if (cStr() != "4731") {
+        return "Fail: ++a[get1()], cStr(): ${cStr()}"
+    }
+
+    return "OK"
+}
@@ -0,0 +1,41 @@
+package foo
+
+var c0 = 0
+var c1 = 0
+var c2 = 0
+
+class A() {
+    var p = 0
+    operator fun divAssign(a: Int) {
+        c1++;
+    }
+    operator fun times(a: Int): A {
+        c2++;
+        return this;
+    }
+}
+
+var a: A = A()
+    get() {
+        c0++
+        return field
+    }
+
+fun box(): String {
+
+    a /= 3
+    if (c0 != 1) {
+        return "1"
+    }
+    if (c1 != 1) {
+        return "2"
+    }
+    a *= 3
+    if (c0 != 2) {
+        return "3"
+    }
+    if (c2 != 1) {
+        return "4"
+    }
+    return "OK"
+}
@@ -0,0 +1,22 @@
+package foo
+
+var c = 0
+
+class A() {
+    var  p = 0;
+    init {
+        c++;
+    }
+}
+
+fun box(): String {
+    ++A().p
+    if (c != 1) {
+        return "fail1: $c"
+    }
+    --A().p
+    if (c != 2) {
+        return "fail2: $c"
+    }
+    return "OK"
+}
@@ -0,0 +1,21 @@
+package foo
+
+class Range() {
+
+    val reversed = false;
+    val start = 0;
+    var count = 10;
+
+    fun next() = start + if (reversed) -(--count) else (--count);
+}
+
+fun box(): String {
+    val r = Range()
+    if (r.next() != 9) {
+        return "fail1"
+    }
+    if (r.next() != 8) {
+        return "fail2"
+    }
+    return "OK"
+}
@@ -0,0 +1,11 @@
+class A(var a: Int) {
+    init {
+        a = 3
+    }
+}
+
+fun box(): String {
+    val result = A(1).a
+    if (result != 3) return "fail: $result"
+    return "OK"
+}
@@ -0,0 +1,21 @@
+package foo
+
+fun box(): String {
+    if (f(null) != false) {
+        return "fail1"
+    }
+    if (f(2) != true) {
+        return "fail2"
+    }
+    if (f(1) != false) {
+        return "fail3"
+    }
+    return "OK"
+}
+
+fun Int.isEven() = (this % 2) == 0
+
+fun f(a: Int?): Boolean {
+    return a?.isEven() ?: false
+
+}
@@ -0,0 +1,23 @@
+/*
+ * Issue: KT-4159 Kotlin to JS compiler crashes on code with ?: return
+ *
+ * Expression like "val s1 : String = s ?: return null" causes compiler to crash
+ */
+
+package foo
+
+fun firstNotNullLen(s1 : String?, s2 : String?, s3 : String?) : Int {
+    val len = (s1?.length ?: s2?.length) ?:
+                (s2?.length ?: s3?.length) ?:
+                    return 0
+    return len
+}
+
+fun box(): String {
+    assertEquals(1, firstNotNullLen("a", null, null))
+    assertEquals(2, firstNotNullLen(null, "ab", null))
+    assertEquals(3, firstNotNullLen(null, null, "abc"))
+    assertEquals(0, firstNotNullLen(null, null, null))
+
+    return "OK"
+}
@@ -0,0 +1,28 @@
+/*
+ * Issue: KT-4159 Kotlin to JS compiler crashes on code with ?: return
+ *
+ * Expression like "val s1 : String = s ?: return null" causes compiler to crash
+ */
+
+package foo
+
+fun stringLen(s : String?) : Int {
+    val s1 : String = s ?: return 0
+    return s1.length
+}
+
+fun stringReturnInLeftLen(s : String?) : Int {
+    val s1 = (if (s != null) { return s.length } else { null }) ?: return 0
+}
+
+fun box(): String {
+    assertEquals(3, stringLen("box"))
+    assertEquals(0, stringLen(""))
+    assertEquals(0, stringLen(null))
+
+    assertEquals(3, stringReturnInLeftLen("box"))
+    assertEquals(0, stringReturnInLeftLen(""))
+    assertEquals(0, stringReturnInLeftLen(null))
+
+    return "OK"
+}
@@ -0,0 +1,31 @@
+package foo
+
+var i = 0
+fun bar(): Any? {
+    i++
+    return null
+}
+
+@native
+val Exception.message: String get() = noImpl
+
+fun box(): String {
+    val a: String? = null
+    try {
+        a ?: throw Exception("a")
+    }
+    catch (e: Exception) {
+        assertEquals("a", e.message)
+    }
+
+    try {
+        bar() ?: throw Exception("bar()")
+    }
+    catch (e: Exception) {
+        assertEquals("bar()", e.message)
+    }
+
+    assertEquals(1, i)
+
+    return "OK"
+}
@@ -0,0 +1,10 @@
+package foo
+
+
+fun box(): String {
+    val a: Int? = 0
+
+    val result = (a!! + 3)
+    if (result != 3) return "fail: $result"
+    return "OK"
+}
@@ -0,0 +1,12 @@
+package foo
+
+var c = 0
+val a: Int?
+    get() {
+        c++
+        return 2
+    }
+
+fun box(): String {
+    return if (c == 0 && (a!! + 3) == 5 && c == 1) return "OK" else "fail"
+}
@@ -0,0 +1,14 @@
+package foo
+
+
+fun box(): String {
+    val a: Int? = null
+
+    try {
+        if ((a!! + 3) == 3) return "fail1"
+    }
+    catch (e: Throwable) {
+        return "OK"
+    }
+    return "fail2"
+}
@@ -0,0 +1,20 @@
+package foo
+
+fun A.create(init: A.() -> Unit): A {
+    init()
+    return this
+}
+
+fun box(): String {
+    val a = A().create {
+        c = 1 + t
+    }
+    if (a.c != 4) return "fail: ${a.c}"
+
+    return "OK"
+}
+
+class A() {
+    val t = 3
+    var c = 2
+}
@@ -0,0 +1,22 @@
+package foo
+
+class A() {
+    fun foo() = 1
+    fun a(f: A.() -> Int): Int {
+        return f()
+    }
+}
+
+var d = 0
+
+val p: A.() -> Int = {
+    d = foo()
+    d++
+}
+
+val c = A().a(p)
+
+fun box(): String {
+    if (c != 1) return "fail: $c"
+    return "OK"
+}
@@ -0,0 +1,15 @@
+package foo
+
+class A() {
+    fun lold() = "OK"
+
+    val p = {
+        {
+            lold()
+        }()
+    }
+}
+
+fun box(): String {
+    return A().p()
+}
@@ -0,0 +1,14 @@
+package foo
+
+class A() {
+    fun lold() = "OK"
+    val p: () -> String
+    init {
+        p = { { lold() }() }
+    }
+}
+
+
+fun box(): String {
+    return A().p()
+}
@@ -0,0 +1,13 @@
+package foo
+
+class TabIterator : Iterator<Any?> {
+    override fun hasNext(): Boolean = false
+
+    override fun next(): Any? {
+        return null
+    }
+}
+
+fun box(): String {
+    return if (!TabIterator().hasNext()) return "OK" else "fail"
+}
@@ -0,0 +1,109 @@
+package foo
+
+class RangeIterator(val start: Int, var count: Int, val reversed: Boolean) {
+
+    var i = start
+
+    operator fun next(): Int {
+        --count
+        if (reversed) {
+            i--
+            return i + 1
+        }
+        else {
+            i++
+            return i - 1
+        }
+    }
+
+
+    operator fun hasNext() = (count > 0);
+}
+
+class NumberRange(val start: Int, val size: Int, val reversed: Boolean) {
+
+    val end: Int
+        get() = if (reversed) start - size + 1 else start + size - 1
+
+    fun contains(number: Int): Boolean {
+        if (reversed) {
+            return (number <= start) && (number > start - size);
+        }
+        else {
+            return (number >= start) && (number < start + size);
+        }
+    }
+
+    operator fun iterator() = RangeIterator(start, size, reversed);
+}
+
+
+fun box(): String {
+    return if (testRange() && testReversedRange()) "OK" else "fail"
+}
+
+fun testRange(): Boolean {
+
+    val oneToFive = NumberRange(1, 4, false);
+    if (oneToFive.contains(5)) return false;
+    if (oneToFive.contains(0)) return false;
+    if (oneToFive.contains(-100)) return false;
+    if (oneToFive.contains(10)) return false;
+    if (!oneToFive.contains(1)) return false;
+    if (!oneToFive.contains(2)) return false;
+    if (!oneToFive.contains(3)) return false;
+    if (!oneToFive.contains(4)) return false;
+    if (!(oneToFive.start == 1)) return false;
+    if (!(oneToFive.size == 4)) return false;
+    if (!(oneToFive.end == 4)) return false;
+
+    var sum = 0;
+    for (i in oneToFive) {
+        sum += i;
+    }
+    for (i in oneToFive) {
+        print(i)
+    }
+
+    if (sum != 10) return false;
+
+    return true;
+
+}
+
+fun testReversedRange(): Boolean {
+
+    println("Testing reversed range.");
+
+    val tenToFive = NumberRange(10, 5, true);
+
+    if (tenToFive.contains(5)) return false;
+    if (tenToFive.contains(11)) return false;
+    if (tenToFive.contains(-100)) return false;
+    if (tenToFive.contains(1000)) return false;
+    if (!tenToFive.contains(6)) return false;
+    if (!tenToFive.contains(7)) return false;
+    if (!tenToFive.contains(8)) return false;
+    if (!tenToFive.contains(9)) return false;
+    if (!tenToFive.contains(10)) return false;
+
+    if (!(tenToFive.start == 10)) return false;
+    if (!(tenToFive.size == 5)) return false;
+    if (!(tenToFive.end == 6)) return false;
+
+    for (i in tenToFive) {
+        println(i)
+    }
+
+
+    var sum = 0;
+    for (i in tenToFive) {
+        sum += i;
+    }
+
+    if (sum != 40) {
+        return false;
+    }
+
+    return true;
+}
@@ -0,0 +1,20 @@
+package foo
+
+abstract class BaseClass {
+    protected open val menuId: Int = 0
+
+    public fun run(): Pair<String, Boolean> =
+            "$menuId" to (menuId == 0)
+}
+
+class ImplClass: BaseClass() {
+    override val menuId: Int = 3
+}
+
+public fun box(): String {
+    val result = ImplClass().run()
+
+    if (result != ("3" to false)) return "Fail: $result"
+
+    return "OK"
+}
@@ -0,0 +1,20 @@
+var log = ""
+
+fun printlnLog(message: Any) {
+    log += "$message\n"
+}
+
+fun box(): String {
+    printlnLog("Hello, world!")
+    printlnLog(p)
+
+    if (log != "Hello, world!\nGotcha\n3\n") return "fail: $log"
+    return "OK"
+}
+
+
+val p: Int
+    get() {
+        printlnLog("Gotcha")
+        return 3
+    }
@@ -0,0 +1,15 @@
+package foo
+
+val y = 3
+
+fun f(a: Int): Int {
+    val x = 42
+    val y = 50
+
+    return y
+}
+
+fun box(): String {
+    val r = f(y)
+    return if (r == 50) "OK" else "Fail, r = $r"
+}
@@ -0,0 +1,18 @@
+package foo
+
+var c = 2
+
+fun loop(times: Int) {
+    var left = times
+    while (left > 0) {
+        val u: (value: Int) -> Unit = {
+            c++
+        }
+        u(left--)
+    }
+}
+
+fun box(): Any? {
+    loop(5)
+    return if (c == 7) return "OK" else c
+}
@@ -0,0 +1,14 @@
+package foo
+
+var c = 2
+
+fun incC(i: Int) {
+    c += c + i
+}
+
+fun box(): Any? {
+    for (i in 0..2) {
+        incC(i)
+    }
+    return if (c == 20) "OK" else c
+}
@@ -0,0 +1,12 @@
+var c = 2
+
+fun incC(i: Int) {
+    c += c + i
+}
+
+fun box(): Any? {
+    for (i in 0..2) {
+        incC(i)
+    }
+    return if (c == 20) "OK" else c
+}
@@ -0,0 +1,11 @@
+package foo
+
+fun lold() = true
+
+val p = { { lold() }() }
+
+fun box(): String {
+    if (!p()) return "fail1"
+    if (!foo.p()) return "fail2"
+    return "OK"
+}
@@ -0,0 +1,16 @@
+package foo
+
+
+class A() {
+    private var c: Int = 3
+        private get
+        private set
+
+    fun f() = c + 1
+}
+
+fun box(): String {
+    val result = A().f()
+    if (result != 4) return "fail: $result"
+    return "OK"
+}
@@ -0,0 +1,10 @@
+package foo
+
+class A() {
+    val p = { "OK" }
+}
+
+
+fun box(): String {
+    return A().p()
+}
@@ -0,0 +1,14 @@
+// http://youtrack.jetbrains.com/issue/KT-5320
+// KT-5320 Invalid JS code generated for typecast inside ternary operator
+
+package foo
+
+fun test(x: Any?): Int = if (x as Boolean) 1 else 2;
+
+fun box(): String {
+    assertEquals(1, test(true), "true")
+    assertEquals(2, test(false), "false")
+    assertEquals("OK", if (if (0 < 1) false else true) "Not OK" else "OK")
+
+    return "OK"
+}
@@ -0,0 +1,14 @@
+package foo
+
+var i = 0
+
+fun test(): Int? = i++
+
+fun box(): String {
+    if (i != 0) return "fail1: $i"
+    test()?.plus(1)
+    if (i != 1) return "fail2: $i"
+    test()?.minus(2)
+    if (i != 2) return "fail3: $i"
+    return "OK"
+}
@@ -0,0 +1,33 @@
+package foo
+
+var s = ""
+
+class A() {
+    fun test(v: String) {
+        s += "4"
+    }
+}
+
+fun f(): String {
+    s += "3"
+    return ""
+}
+
+class B() {
+    val a: A
+        get() {
+            s += "2"
+            return A()
+        }
+
+    fun test() {
+        s += "1"
+        a.test("${if (true) f() else 4}")
+        s += "5"
+    }
+}
+
+fun box(): String {
+    B().test()
+    return if (s != "12345") "fail: $s" else "OK"
+}
@@ -0,0 +1,8 @@
+package foo
+
+var p = 0
+val c = p++ // creates temporary value
+
+fun box(): String {
+    return if ((p == 1) && (c == 0)) "OK" else "fail"
+}
@@ -0,0 +1,16 @@
+package foo
+
+fun test() {
+    throw throw Exception("catch me")
+}
+
+fun box(): String {
+    try {
+        test()
+        error("exception not thrown")
+    }
+    catch (e: Exception) {
+        assertEquals("catch me", e.message)
+    }
+    return "OK"
+}
@@ -0,0 +1,13 @@
+package foo
+
+fun sequenceFromFunctionWithInitialValue() {
+    val values = generateSequence(3) { n -> if (n > 0) n - 1 else null }
+    assertEquals(arrayListOf(3, 2, 1, 0), values.toList())
+}
+
+fun box(): String {
+
+    sequenceFromFunctionWithInitialValue()
+
+    return "OK"
+}
@@ -0,0 +1,20 @@
+package foo
+
+fun box(): String {
+    if (t(1) != 0) {
+        return "fail1"
+    }
+    if (t(0) != 1) {
+        return "fail2"
+    }
+    if (t(100) != 2) {
+        return "fail3"
+    }
+    return "OK"
+}
+
+fun t(i: Int) = when(i) {
+    0 -> 1
+    1 -> 0
+    else -> 2
+}