JS backend: testFiles -> testData

js/js.translator/testData/defaultArguments/cases/constructorCallWithDefArg1.kt

@@ -0,0 +1,30 @@
+package foo
+
+class A(val a: Int = 0)
+
+class B(val a: Int = 0, val b: String = "a")
+
+fun box(): String {
+    val a0 = A()
+    val a1 = A(1)
+    if (a0.a != 0) return "a0.a != 0, it: ${a0.a}"
+    if (a1.a != 1) return "a1.a != 1, it: ${a1.a}"
+
+    val b1 = B()
+    if (b1.a != 0) return "b1.a != 0, it: ${b1.a}"
+    if (b1.b != "a") return "b1.b != 'a', it: ${b1.b}"
+
+    val b2 = B(1)
+    if (b2.a != 1) return "b2.a != 1, it: ${b2.a}"
+    if (b2.b != "a") return "b2.b != 'a', it: ${b2.b}"
+
+    val b3 = B(b = "b")
+    if (b3.a != 0) return "b3.a != 0, it: ${b3.a}"
+    if (b3.b != "b") return "b3.b != 'b', it: ${b3.b}"
+
+    val b4 = B(2, "c")
+    if (b4.a != 2) return "b4.a != 2, it: ${b4.a}"
+    if (b4.b != "c") return "b4.b != 'c', it: ${b4.b}"
+
+    return "OK"
+}

js/js.translator/testData/defaultArguments/cases/constructorCallWithDefArg2.kt

@@ -0,0 +1,36 @@
+package foo
+
+class T4(
+        val c1: Boolean,
+        val c2: Boolean,
+        val c3: Boolean,
+        val c4: String
+) {
+    override fun equals(o: Any?): Boolean {
+        if (o !is T4) return false;
+        return c1 == o.c1 &&
+            c2 == o.c2 &&
+            c3 == o.c3 &&
+            c4 == o.c4
+    }
+}
+
+fun reformat(
+        str: String,
+        normalizeCase: Boolean = true,
+        uppercaseFirstLetter: Boolean = true,
+        divideByCamelHumps: Boolean = true,
+        wordSeparator: String = " "
+) =
+        T4(normalizeCase, uppercaseFirstLetter, divideByCamelHumps, wordSeparator)
+
+
+fun box(): String {
+    val expected = T4(true, true, true, " ")
+    if (reformat("", true, true, true, " ") != expected) return "fail1"
+    if (reformat("", true, true, true) != expected) return "fail2"
+    if (reformat("", true, true) != expected) return "fail3"
+    if (reformat("", true) != expected) return "fail4"
+    if (reformat("") != expected) return "fail5"
+    return "OK"
+}

js/js.translator/testData/defaultArguments/cases/defArgsWithSuperCall.kt

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

js/js.translator/testData/defaultArguments/cases/enumWithDefArg.kt

@@ -0,0 +1,13 @@
+package foo
+
+enum class A(val a: Int = 1) {
+    FIRST: A()
+    SECOND: A(2)
+}
+
+fun box(): String {
+    if (A.FIRST.a == 1 && A.SECOND.a == 2) {
+        return "OK"
+    }
+    return "fail"
+}

js/js.translator/testData/defaultArguments/cases/enumWithOneDefArg.kt

@@ -0,0 +1,12 @@
+package foo
+
+enum class Foo(val a: Int = 1, val b: String) {
+    B: Foo(2, "b")
+    C: Foo(b = "b")
+}
+
+fun box(): String {
+    if (Foo.B.a != 2 || Foo.B.b != "b") return "fail1"
+    if (Foo.C.a != 1 || Foo.C.b != "b") return "fail2"
+    return "OK"
+}

js/js.translator/testData/defaultArguments/cases/enumWithTwoDefArgs.kt

@@ -0,0 +1,16 @@
+package foo
+
+enum class Foo(val a: Int = 1, val b: String = "a") {
+    A: Foo()
+    B: Foo(2, "b")
+    C: Foo(b = "b")
+    D: Foo(a = 2)
+}
+
+fun box(): String {
+    if (Foo.A.a != 1 || Foo.A.b != "a") return "fail1"
+    if (Foo.B.a != 2 || Foo.B.b != "b") return "fail2"
+    if (Foo.C.a != 1 || Foo.C.b != "b") return "fail3"
+    if (Foo.D.a != 2 || Foo.D.b != "a") return "fail4"
+    return "OK"
+}

js/js.translator/testData/defaultArguments/cases/extensionFunWithDefArgs.kt

@@ -0,0 +1,12 @@
+package foo
+
+fun <T> T.toPrefixedString(prefix: String = "", suffix: String = "") = prefix + toString() + suffix
+
+fun box(): String {
+    if ("mama".toPrefixedString(suffix = "321", prefix = "papa") != "papamama321") return "fail1"
+    if ("mama".toPrefixedString(prefix = "papa") != "papamama") return "fail2"
+    if ("mama".toPrefixedString("papa", "239") != "papamama239") return "fail3"
+    if ("mama".toPrefixedString("papa") != "papamama") return "fail4"
+    if ("mama".toPrefixedString() != "mama") return "fail5"
+    return "OK"
+}

js/js.translator/testData/defaultArguments/cases/funInAbstractClassWithDefArg.kt

@@ -0,0 +1,14 @@
+package foo
+
+open abstract class B() {
+    fun foo(arg: Int = 239 + 1): Int = arg
+}
+
+class C() : B() {
+}
+
+fun box(): String {
+    if (C().foo(10) != 10) return "fail1"
+    if (C().foo() != 240) return "fail2"
+    return "OK"
+}

js/js.translator/testData/defaultArguments/cases/overloadFunWithDefArg.kt

@@ -0,0 +1,15 @@
+package foo
+
+open abstract class B() {
+    abstract fun foo2(arg: Int = 239): Int
+}
+
+class C() : B() {
+    override fun foo2(arg: Int): Int = arg
+}
+
+fun box(): String {
+    if (C().foo2() != 239) return "fail1"
+    if (C().foo2(10) != 10) return "fail2"
+    return "OK"
+}

js/js.translator/testData/defaultArguments/cases/overrideValWithDefaultValue.kt

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

js/js.translator/testData/defaultArguments/cases/virtualCallWithDefArg.kt

@@ -0,0 +1,22 @@
+package foo
+
+trait A {
+    fun bar2(arg: Int = 239): Int
+
+    fun bar(arg: Int = 240): Int = bar2(arg / 2)
+}
+
+open abstract class B() : A {
+    override fun bar2(arg: Int): Int = arg
+}
+
+class C() : B() {
+}
+
+fun box(): String {
+    if (C().bar(10) != 5) return "fail1: ${C().bar(10)}"
+    if (C().bar() != 120) return "fail2: ${C().bar()}"
+    if (C().bar2() != 239) return "fail3: ${C().bar2()}"
+    if (C().bar2(10) != 10) return "fail4: ${C().bar2(10)}"
+    return "OK"
+}