JS backend: testFiles -> testData

js/js.translator/testData/expression/misc/cases/KT-1052-2.kt

@@ -0,0 +1,52 @@
+package foo
+
+fun box(): Boolean {
+
+    if (!true.and(true)) {
+        return false;
+    }
+    if (false.and(true)) {
+        return false;
+    }
+
+    if (!true.or(false)) {
+        return false;
+    }
+
+
+    if (false.or(false)) {
+        return false;
+    }
+
+
+    if (!true.or(true)) {
+        return false;
+    }
+
+
+    if (false.and(false)) {
+        return false;
+    }
+
+    if (false.xor(false)) {
+        return false;
+    }
+    if (!true.xor(false)) {
+        return false;
+    }
+
+    if (true.xor(true)) {
+        return false;
+    }
+
+    if (true.not()) {
+        return false;
+
+    }
+
+    if (!false.not()) {
+        return false;
+    }
+
+    return true;
+}

js/js.translator/testData/expression/misc/cases/KT-1052.kt

@@ -0,0 +1,17 @@
+fun main(args: Array<String>) {
+    println(true.and1(true))
+}
+
+fun Boolean.and1(other: Boolean): Boolean {
+    if (other == true) {
+        if (this == true) {
+            return true ;
+        }
+        else {
+            return false;
+        }
+    }
+    else {
+        return false;
+    }
+}

js/js.translator/testData/expression/misc/cases/KT-1361-1.kt

@@ -0,0 +1,21 @@
+package foo
+
+class B {
+    val d = true
+
+    fun f(): Boolean {
+        val c = object {
+            fun foo(): Boolean {
+                return d
+            }
+            fun boo(): Boolean {
+                return foo()
+            }
+        }
+        return c.boo()
+    }
+}
+
+fun box(): Boolean {
+    return B().f()
+}

js/js.translator/testData/expression/misc/cases/KT-1361-2.kt

@@ -0,0 +1,51 @@
+package foo
+
+class Data(val rawData: Array<Int>, val width: Int, val height: Int) {
+    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];
+        }
+    }
+
+    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
+}
+
+trait ColorLike {
+    val red: Int;
+    val green: Int;
+    val blue: Int;
+}
+
+fun box(): Boolean {
+    val d = Data(Array(4) { 0 }, 1, 1)
+    if (d[0, 0].red != 0) {
+        return false
+    }
+    if (d[0, 0].green != 0) {
+        return false
+    }
+    if (d[0, 0].blue != 0) {
+        return false
+    }
+    return true
+}

js/js.translator/testData/expression/misc/cases/KT-1865.kt

@@ -0,0 +1,11 @@
+package foo
+
+open class A {
+    open fun foo(a: Int = 1) = a
+}
+
+class B : A() {
+    override fun foo(a: Int) = a + 1
+}
+
+fun box() = (B().foo() == 2)

js/js.translator/testData/expression/misc/cases/KT-2314.kt

@@ -0,0 +1,25 @@
+package foo
+
+import java.util.*
+
+fun box(): Boolean {
+    val data = arrayList("foo", "bar")
+    if (data.head != "foo") {
+        return false
+    }
+    return true
+}
+
+
+public inline fun arrayList<T>(vararg values: T): ArrayList<T> {
+    val c = ArrayList<T>()
+    for (v in values) {
+        c.add(v)
+    }
+    return c
+}
+
+public inline val <T> ArrayList<T>.head: T
+    get() {
+        return get(0)
+    }

js/js.translator/testData/expression/misc/cases/KT-740-2.kt

@@ -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
+    fun get(i: Int): Int {
+        c1++
+        return 0
+    }
+
+    fun set(i: Int, value: Int) {
+        c2++
+    }
+}
+
+val a: A = A()
+    get() {
+        c0++
+        return $a
+    }
+
+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"
+}

js/js.translator/testData/expression/misc/cases/KT-740-3.kt

@@ -0,0 +1,41 @@
+package foo
+
+var c0 = 0
+var c1 = 0
+var c2 = 0
+
+class A() {
+    var p = 0
+    fun divAssign(a: Int) {
+        c1++;
+    }
+    fun times(a: Int): A {
+        c2++;
+        return this;
+    }
+}
+
+var a: A = A()
+    get() {
+        c0++
+        return $a
+    }
+
+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"
+}

js/js.translator/testData/expression/misc/cases/KT-740.kt

@@ -0,0 +1,22 @@
+package foo
+
+var c = 0
+
+class A() {
+    var  p = 0;
+    {
+        c++;
+    }
+}
+
+fun box(): Boolean {
+    ++A().p
+    if (c != 1) {
+        return false;
+    }
+    --A().p
+    if (c != 2) {
+        return false;
+    }
+    return true
+}

js/js.translator/testData/expression/misc/cases/KT-817.kt

@@ -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(): Boolean {
+    val r = Range()
+    if (r.next() != 9) {
+        return false;
+    }
+    if (r.next() != 8) {
+        return false;
+    }
+    return true;
+}

js/js.translator/testData/expression/misc/cases/classWithoutPackage.kt

@@ -0,0 +1,7 @@
+class A(var a: Int) {
+    {
+        $a = 3
+    }
+}
+
+fun box() = (A(1).a == 3)

js/js.translator/testData/expression/misc/cases/elvis.kt

@@ -0,0 +1,21 @@
+package foo
+
+fun box(): Boolean {
+    if (f(null) != false) {
+        return false;
+    }
+    if (f(2) != true) {
+        return false;
+    }
+    if (f(1) != false) {
+        return true;
+    }
+    return true
+}
+
+fun Int.isEven() = (this % 2) == 0
+
+fun f(a: Int?): Boolean {
+    return a?.isEven() ?: false
+
+}

js/js.translator/testData/expression/misc/cases/exclExcl.kt

@@ -0,0 +1,8 @@
+package foo
+
+
+fun box(): Boolean {
+    val a: Int? = 0
+
+    return (a!! + 3) == 3
+}

js/js.translator/testData/expression/misc/cases/exclExclResultIsComputedOnce.kt

@@ -0,0 +1,12 @@
+package foo
+
+var c = 0
+val a: Int?
+    get() {
+        c++
+        return 2
+    }
+
+fun box(): Boolean {
+    return c == 0 && (a!! + 3) == 5 && c == 1
+}

js/js.translator/testData/expression/misc/cases/exclExclThrows.kt

@@ -0,0 +1,8 @@
+package foo
+
+
+fun box(): Boolean {
+    val a: Int? = null
+
+    return (a!! + 3) == 3
+}

js/js.translator/testData/expression/misc/cases/extensionLiteralCalledInsideExtensionFunction.kt

@@ -0,0 +1,18 @@
+package foo
+
+fun A.create(init: A.() -> Unit): A {
+    init()
+    return this
+}
+
+fun box(): Boolean {
+    val a = A().create {
+        c = 1 + t
+    }
+    return a.c == 4
+}
+
+class A() {
+    val t = 3
+    var c = 2
+}

js/js.translator/testData/expression/misc/cases/extensionLiteralCreatedAtPackageLevel.kt

@@ -0,0 +1,19 @@
+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() = (c == 1)

js/js.translator/testData/expression/misc/cases/funInConstructor.kt

@@ -0,0 +1,15 @@
+package foo
+
+class A() {
+    fun lold() = true
+
+    val p = {
+        {
+            lold()
+        }()
+    }
+}
+
+fun box(): Boolean {
+    return A().p()
+}

js/js.translator/testData/expression/misc/cases/funInConstructorBlock.kt

@@ -0,0 +1,14 @@
+package foo
+
+class A() {
+    fun lold() = true
+    val p: () -> Boolean
+    {
+        $p = { { lold() }() }
+    }
+}
+
+
+fun box(): Boolean {
+    return A().p()
+}

js/js.translator/testData/expression/misc/cases/functionExpression.kt

@@ -0,0 +1,28 @@
+package foo
+
+fun Any.foo1(): () -> String {
+    return { "239" + this }
+}
+
+fun Int.foo2(): (i: Int) -> Int {
+    return { x -> x + this }
+}
+
+fun fooT1<T>(t: T) = { t.toString() }
+
+fun fooT2<T>(t: T) = {(x: T) -> t.toString() + x.toString() }
+
+fun box(): Any? {
+    if ( (10.foo1())() != "23910") return "foo1 fail"
+    if ( (10.foo2())(1) != 11 ) return "foo2 fail"
+
+    if (1.{ Int.() -> this + 1 }() != 2) return "test 3 failed";
+    if (  { 1 }() != 1) return "test 4 failed";
+    if (  {(x: Int) -> x }(1) != 1) return "test 5 failed";
+    if (  1.{ Int.(x: Int) -> x + this }(1) != 2) return "test 6 failed";
+    val tmp = 1.({ Int.() -> this })()
+    if (tmp != 1) return "test 7 failed, res: $tmp ${tmp is Int}";
+    if (  (fooT1<String>("mama"))() != "mama") return "test 8 failed";
+    if (  (fooT2<String>("mama"))("papa") != "mamapapa") return "test 9 failed";
+    return "OK"
+}

js/js.translator/testData/expression/misc/cases/ifElseAsExpressionWithThrow.kt

@@ -0,0 +1,3 @@
+package foo
+
+fun box() = if (true) throw Exception() else false

js/js.translator/testData/expression/misc/cases/inheritFromJetIterator.kt

@@ -0,0 +1,11 @@
+package foo
+
+class TabIterator : Iterator<Any?> {
+    override fun hasNext(): Boolean = false
+
+    override fun next(): Any? {
+        return null
+    }
+}
+
+fun box() = !TabIterator().hasNext()

js/js.translator/testData/expression/misc/cases/intRange.kt

@@ -0,0 +1,109 @@
+package foo
+
+import js.*
+
+class RangeIterator(val start: Int, var count: Int, val reversed: Boolean) {
+
+    var i = start
+
+    fun next(): Int {
+        --count
+        if (reversed) {
+            i--
+            return i + 1
+        }
+        else {
+            i++
+            return i - 1
+        }
+    }
+
+
+    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);
+        }
+    }
+
+    fun iterator() = RangeIterator(start, size, reversed);
+}
+
+
+fun box() = testRange() && testReversedRange();
+
+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;
+}

js/js.translator/testData/expression/misc/cases/lazyProperty.kt

@@ -0,0 +1,11 @@
+fun main(args: Array<String>) {
+    println("Hello, world!")
+    println(p)
+}
+
+
+val p: Int
+    get() {
+        println("Gotcha")
+        return 3
+    }

js/js.translator/testData/expression/misc/cases/localProperty.kt

@@ -0,0 +1,14 @@
+package foo
+
+val y = 3
+
+fun f(a: Int): Int {
+    val x = 42
+    val y = 50
+
+    return y
+}
+
+fun box(): Int {
+    return f(y)
+}

js/js.translator/testData/expression/misc/cases/localVarAsFunction.kt

@@ -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
+}

js/js.translator/testData/expression/misc/cases/mainFunInNestedPackage.kt

@@ -0,0 +1,7 @@
+package a.b.c
+
+import js.*
+
+fun main(args: Array<String>) {
+    println("ayee")
+}

js/js.translator/testData/expression/misc/cases/packageLevelVarInPackage.kt

@@ -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
+}

js/js.translator/testData/expression/misc/cases/packageLevelVarInRoot.kt

@@ -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
+}

js/js.translator/testData/expression/misc/cases/packagePropertyCalledAsFun.kt

@@ -0,0 +1,7 @@
+package foo
+
+fun lold() = true
+
+val p = { { lold() }() }
+
+fun box() = p() && foo.p()

js/js.translator/testData/expression/misc/cases/propertiesWithExplicitlyDefinedAccessorsWithoutBodies.kt

@@ -0,0 +1,14 @@
+package foo
+
+
+class A() {
+    private var c: Int = 3
+        private get
+        private set
+
+    fun f() = c + 1
+}
+
+fun box(): Boolean {
+    return A().f() == 4
+}

js/js.translator/testData/expression/misc/cases/propertyAsFunCalledOnConstructor.kt

@@ -0,0 +1,10 @@
+package foo
+
+class A() {
+    val p = { true }
+}
+
+
+fun box(): Boolean {
+    return A().p()
+}

js/js.translator/testData/expression/misc/cases/safecallComputesExpressionOnlyOnce.kt

@@ -0,0 +1,14 @@
+package foo
+
+var i = 0
+
+fun test(): Int? = i++
+
+fun box(): Boolean {
+    if (i != 0) return false
+    test()?.plus(1)
+    if (i != 1) return false
+    test()?.minus(2)
+    if (i != 2) return false
+    return true
+}

js/js.translator/testData/expression/misc/cases/stringInterpolationEvaluationOrder.kt

@@ -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(): Any? {
+    B().test()
+    return if (s != "12345") s else true
+}

js/js.translator/testData/expression/misc/cases/temporaryVariableCreatedInPackageInitializer.kt

@@ -0,0 +1,6 @@
+package foo
+
+var p = 0
+val c = p++ // creates temporary value
+
+fun box() = (p == 1) && (c == 0)

js/js.translator/testData/expression/misc/cases/whenReturnedWithoutBlock.kt

@@ -0,0 +1,18 @@
+package foo
+
+fun box(): Boolean {
+    if (t(1) != 0) {
+        return false
+    }
+    if (t(0) != 1) {
+        return false
+    }
+    return (t(100) == 2)
+
+}
+
+fun t(i: Int) = when(i) {
+    0 -> 1
+    1 -> 0
+    else -> 2
+}