JS backend: testFiles -> testData

js/js.translator/testData/inheritance/cases/abstractVarOverride.kt

@@ -0,0 +1,25 @@
+package foo
+
+open abstract class A() {
+    abstract var pos: Int;
+}
+
+class B() : A() {
+    override var pos: Int = 2
+}
+
+fun box(): Boolean {
+
+    val a: A = B()
+    if (a.pos != 2) {
+        return false;
+    }
+    if (B().pos != 2) {
+        return false;
+    }
+    a.pos = 3;
+    if (a.pos != 3) {
+        return false
+    }
+    return true
+}

js/js.translator/testData/inheritance/cases/baseCall.kt

@@ -0,0 +1,14 @@
+package foo
+
+open class A(val name: String)
+
+class B(val age: Int, name: String) : A(name)
+
+fun box(): String {
+    val b = B(12, "Mike")
+
+    if (b.age != 12) return "b.age != 12, it: ${b.age}"
+    if (b.name != "Mike") return "b.name != 'Mike', it: ${b.name}"
+
+    return "OK"
+}

js/js.translator/testData/inheritance/cases/baseCallOrder.kt

@@ -0,0 +1,19 @@
+package foo
+
+var x = false
+
+open class A {
+    {
+        x = (this as B).a != 3
+    }
+}
+
+class B(val a: Int = 3) : A() {
+
+}
+
+fun box(): String {
+    B()
+    if (!x) return "fail"
+    return "OK"
+}

js/js.translator/testData/inheritance/cases/baseClassDefinedAfterDerived.kt

@@ -0,0 +1,13 @@
+package foo
+
+
+class A() : B() {
+
+}
+
+open class B() {
+
+    val a = 3
+}
+
+fun box() = (A().a == 3)

js/js.translator/testData/inheritance/cases/complexInitializationOrder.kt

@@ -0,0 +1,37 @@
+package foo
+
+open class A() {
+
+    var order = ""
+    {
+        order = order + "A"
+    }
+}
+
+open class B() : A() {
+    {
+        order = order + "B"
+    }
+}
+
+class C() : B() {
+    {
+        order = order + "C"
+    }
+}
+
+class D() : B() {
+    {
+        order = order + "D"
+    }
+}
+
+class E() : A() {
+    {
+        order = order + "E"
+    }
+}
+
+fun box(): Boolean {
+    return (C().order == "ABC") && (D().order == "ABD") && (E().order == "AE")
+}

js/js.translator/testData/inheritance/cases/crazyInheritance.kt

@@ -0,0 +1,56 @@
+package foo
+
+open class A {
+    open fun f1() = "A1"
+    open fun f2() = "A2"
+    open fun f3() = "A3"
+    open fun f4() = "A4"
+
+    fun getSum(): String {
+        return "${f1()}|${f2()}|${f3()}|${f4()}"
+    }
+}
+
+trait T : A {
+    override fun f1() = "T1"
+    override fun f2() = "T2"
+}
+
+trait B : A {
+    override fun f1() = "B1"
+    override fun f3() = "B3"
+}
+
+trait N : B, T {
+    override fun f1() = "N1"
+}
+
+trait X {
+    fun f4() = "X4"
+}
+
+class C : A(), N, X {
+    override fun f4() = "C4"
+}
+
+fun box(): String {
+    val a = A()
+    val t = object : T, A() {
+    }
+    val b = object : B, A() {
+    }
+    val n = object : N, A() {
+    }
+    val x = object : X {
+    }
+    val c = C()
+
+    if (a.getSum() != "A1|A2|A3|A4") return "Bad a.getSum(), it: ${a.getSum()}"
+    if (t.getSum() != "T1|T2|A3|A4") return "Bad t.getSum(), it: ${t.getSum()}"
+    if (b.getSum() != "B1|A2|B3|A4") return "Bad b.getSum(), it: ${b.getSum()}"
+    if (n.getSum() != "N1|T2|B3|A4") return "Bad n.getSum(), it: ${n.getSum()}"
+    if (c.getSum() != "N1|T2|B3|C4") return "Bad c.getSum(), it: ${c.getSum()}"
+
+    if (x.f4() != "X4") return "Bad x.f4(), it: ${x.f4()}"
+    return "OK"
+}

js/js.translator/testData/inheritance/cases/definitionOrder.kt

@@ -0,0 +1,44 @@
+package foo
+
+class C() : B() {
+    {
+        order = order + "C"
+    }
+}
+
+class D() : B() {
+    {
+        order = order + "D"
+    }
+}
+
+class E() : A() {
+    {
+        order = order + "E"
+    }
+}
+
+open class B() : A() {
+    {
+        order = order + "B"
+    }
+}
+
+open class A() : G() {
+
+    var order = ""
+    {
+        order = order + "A"
+    }
+}
+
+// KT-3437
+abstract class G : H()
+abstract class K : H()
+abstract class L
+abstract class H : L()
+abstract class Dummy
+
+fun box(): Boolean {
+    return (C().order == "ABC") && (D().order == "ABD") && (E().order == "AE")
+}

js/js.translator/testData/inheritance/cases/fromFakeClasses.kt

@@ -0,0 +1,44 @@
+package foo
+
+class FromAny : Any()
+
+class FromItrable(val n: Int) : Iterable<Int> {
+    override fun iterator() = object: Iterator<Int> {
+        var i = 0
+        override fun next() = i++
+        override fun hasNext() = i < n
+    }
+}
+
+fun <T> Iterable<T>.stringify(): String {
+    var s = ""
+    for (i in this) s += i
+    return s
+}
+
+fun box(): String {
+    val a = FromAny()
+    val it = FromItrable(3)
+
+    val s = it.stringify()
+    if (s != "012") return "s /*$s*/ != 012"
+
+    var ao = object : Any() {
+    }
+    var ito = object : Iterable<Int> {
+        override public fun iterator() = object: Iterator<Int> {
+            var i = 0
+            override fun next(): Int {
+                var r = i
+                i += 2
+                return r
+            }
+            override fun hasNext() = i < 9
+        }
+    }
+
+    val so = ito.stringify()
+    if (so != "02468") return "so /*$so*/ != 02468"
+
+    return "OK"
+}

js/js.translator/testData/inheritance/cases/initializationOrder.kt

@@ -0,0 +1,26 @@
+package foo
+
+open class A() {
+
+    var order = ""
+    {
+        order = order + "A"
+    }
+}
+
+open class B() : A() {
+    {
+        order = order + "B"
+    }
+
+}
+
+class C() : B() {
+    {
+        order = order + "C"
+    }
+}
+
+fun box(): Boolean {
+    return (C().order == "ABC") && (B().order == "AB") && (A().order == "A")
+}

js/js.translator/testData/inheritance/cases/initializersOfBasicClassExecute.kt

@@ -0,0 +1,13 @@
+package foo
+
+open class A() {
+    var a = 3;
+}
+
+class B() : A() {
+
+}
+
+fun box(): Int {
+    return (B().a)
+}

js/js.translator/testData/inheritance/cases/kt3499.kt

@@ -0,0 +1,13 @@
+package foo
+
+trait A : B, E
+trait B
+open class C {
+    fun foo() = true
+}
+trait D
+trait E
+trait F : G, D
+trait G
+
+fun box() = C().foo()

js/js.translator/testData/inheritance/cases/methodOverride.kt

@@ -0,0 +1,27 @@
+package foo
+
+open class A {
+    fun f1(): Int {
+        return 1
+    }
+    open fun f2(): Int {
+        return 3
+    }
+}
+
+class B : A() {
+    override fun f2(): Int {
+        return 2
+    }
+}
+
+fun box(): String {
+    val a = A()
+    if (a.f1() != 1) return "a.f1() != 1, it: ${a.f1()}"
+    if (a.f2() != 3) return "a.f2() != 3, it: ${a.f2()}"
+
+    val b = B();
+    if (b.f1() != 1) return "b.f1() != 1, it: ${b.f1()}"
+    if (b.f2() != 2) return "b.f2() != 2, it: ${b.f2()}"
+    return "OK"
+}

js/js.translator/testData/inheritance/cases/valOverride.kt

@@ -0,0 +1,15 @@
+package foo
+
+open class C() {
+    open val a = 1
+}
+
+class D() : C() {
+    override val a = 2
+}
+
+fun box(): Boolean {
+    val d: C = D()
+    if (d.a != 2) return false
+    return true
+}

js/js.translator/testData/inheritance/cases/valuePassedToAncestorConstructor.kt

@@ -0,0 +1,12 @@
+package foo
+
+open class C(a: Int) {
+    val b = a
+}
+
+class D(c: Int) : C(c + 2) {
+}
+
+fun box(): Boolean {
+    return (D(0).b == 2)
+}