JS: create new common directory for all generated tests, migrate several tests there

js/js.translator/testData/box/defaultArguments/complexExpressionAsDefaultArgument.kt

@@ -0,0 +1,28 @@
+// http://youtrack.jetbrains.com/issue/KT-4879
+// JS: extra side effect when use when in default arguments
+
+package foo
+
+var global: String = ""
+
+fun bar(): Int {
+    global += ":bar:"
+    return 100
+}
+
+fun foo(a: Int = when { else -> bar() }): Int = a + 1
+
+fun bar0(x: String = try { global } finally {}): String {
+    return "bar: ${x}"
+}
+
+fun box(): String {
+    global = ""
+    assertEquals(101, foo(100))
+    assertEquals("", global)
+
+    assertEquals(101, foo())
+    assertEquals(":bar:", global)
+
+    return "OK"
+}

js/js.translator/testData/box/defaultArguments/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/box/defaultArguments/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/box/defaultArguments/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/box/defaultArguments/defaultArgumentsInFunctionWithExpressionAsBody.kt

@@ -0,0 +1,17 @@
+// KT-6037: KT-6037 Javascript default function arguments fill code generated in wrong order on method without "return keyword"
+package foo
+
+inline fun <T> id(x: T) = x
+
+fun test(arg: Int = 10) = id(arg)
+
+fun foo(value: String = "K") = "O" + try { value } catch(e: Exception) { "..." }
+
+fun box(): String {
+
+    assertEquals(10, test())
+    assertEquals(100, test(100))
+    assertEquals("OK", foo())
+
+    return "OK"
+}

js/js.translator/testData/box/defaultArguments/enumSuperConstructor.kt

@@ -0,0 +1,16 @@
+package foo
+
+enum class A {
+    B(2);
+
+    val c: Int
+
+    constructor (a: Int, b: Int = 3) {
+        c = a + b
+    }
+}
+
+fun box(): String {
+    assertEquals(5, A.B.c)
+    return "OK"
+}

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

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

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

@@ -0,0 +1,12 @@
+package foo
+
+enum class Foo(val a: Int = 1, val b: String) {
+    B(2, "b"),
+    C(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/box/defaultArguments/enumWithTwoDefArgs.kt

@@ -0,0 +1,16 @@
+package foo
+
+enum class Foo(val a: Int = 1, val b: String = "a") {
+    A(),
+    B(2, "b"),
+    C(b = "b"),
+    D(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/box/defaultArguments/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/box/defaultArguments/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/box/defaultArguments/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/box/defaultArguments/primarySuperConstructor.kt

@@ -0,0 +1,16 @@
+package foo
+
+open class Base(a: Int, b: Int = 3) {
+    val c: Int
+
+    init {
+        c = a + b
+    }
+}
+
+class Derived(a: Int) : Base(a)
+
+fun box(): String {
+    assertEquals(5, Derived(2).c)
+    return "OK"
+}

js/js.translator/testData/box/defaultArguments/secondarySuperConstructor.kt

@@ -0,0 +1,18 @@
+package foo
+
+open class Base {
+    val c: Int
+
+    constructor(a: Int, b: Int = 3) {
+        c = a + b
+    }
+}
+
+class Derived : Base {
+    constructor(a: Int) : super(a)
+}
+
+fun box(): String {
+    assertEquals(5, Derived(2).c)
+    return "OK"
+}

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

@@ -0,0 +1,22 @@
+package foo
+
+interface 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"
+}