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

js/js.translator/testData/box/enum/accessing.kt

@@ -0,0 +1,30 @@
+package foo
+
+enum class A {
+    FOO,
+
+    BAR() {
+        fun explicitFromEntry() = A.FOO
+        fun implicitFromEntry() = FOO
+    };
+
+    fun explicit() = A.FOO
+    fun implicit() = FOO
+}
+
+fun A.extExplicit() = A.FOO
+//fun A.extImplicit() = FOO
+
+fun box(): String {
+    assertEquals(A.FOO, A.FOO.explicit(), "explicit access")
+    assertEquals(A.FOO, A.FOO.implicit(), "implicit access")
+
+    assertEquals(A.FOO, A.FOO.explicit(), "explicit access from BAR")
+    assertEquals(A.FOO, A.FOO.implicit(), "implicit access from BAR")
+
+    assertEquals(A.FOO, A.FOO.extExplicit(), "explicit access from ext fun")
+    // TODO uncoment when KT-5605 will be fixed
+    //assertEquals(A.FOO, A.FOO.extImplicit(), "implicit access from ext fun")
+
+    return "OK"
+}

js/js.translator/testData/box/enum/enumInheritedFromTrait.kt

@@ -0,0 +1,16 @@
+package foo
+
+fun box() = MyEnum.E1.f() + MyEnum.E2.f()
+
+enum class MyEnum : T {
+    E1 {
+        override fun f() = "O"
+    },
+    E2 {
+        override fun f() = "K"
+    }
+}
+
+interface T {
+    fun f(): String
+}

js/js.translator/testData/box/enum/enumIsComparable.kt

@@ -0,0 +1,24 @@
+package foo
+
+enum class A {
+    one,
+    two
+}
+
+fun box(): String {
+    val x = A.one.compareTo(A.two)
+    if (x != -1) return "Fail cmp(one, two) = $x"
+    val y = A.two.compareTo(A.one)
+    if (y != 1) return "Fail cmp(two, one) = $y"
+
+    if (!(A.one < A.two)) return "Fail !(one < two)"
+    if (A.one >= A.two) return "Fail one >= two"
+
+    if (!(A.two > A.one)) return "Fail !(two > one)"
+    if (A.two <= A.one) return "Fail two <= one"
+
+    val z = A.one.compareTo(A.one)
+    if (z != 0) return "Fail cmp(one, one) = $z"
+
+    return "OK"
+}

js/js.translator/testData/box/enum/enumWithInheritance.kt

@@ -0,0 +1,44 @@
+package foo
+
+enum class B(open val bar: Int) {
+    a(0) {
+        override val bar = 3
+        init {
+            y = 0
+        }
+    },
+    b(4) {
+    },
+    c(5);
+    val x = 1
+    var y = 12;
+}
+
+interface X {
+    val foo: Int
+    fun bar(): Int {
+        return foo;
+    }
+}
+
+enum class Y(override val foo: Int) : X {
+    m(3),
+    n(6)
+}
+
+fun box(): String {
+    if (B.a.x != 1) return "B.a.x != 1, it: ${B.a.x}"
+    if (B.a.y != 0) return "B.a.y != 0, it: ${B.a.y}"
+    if (B.a.bar != 3) return "B.a.bar != 3, it: ${B.a.bar}"
+
+    if (B.b.y != 12) return "B.b.y != 12, it: ${B.b.y}"
+    if (B.b.bar != 4) return "B.b.bar != 4, it: ${B.b.bar}"
+
+    if (B.c.bar != 5) return "B.c.bar != 5, it: ${B.c.bar}"
+    if (B.c.y != 12) return "B.c.y != 12, it: ${B.c.y}"
+
+    if (Y.m.bar() != 3) return "Y.m.bar() != 3, it: ${Y.m.bar()}"
+    if (Y.n.bar() != 6) return "Y.n.bar() != 6, it: ${Y.m.bar()}"
+
+    return "OK"
+}

js/js.translator/testData/box/enum/equals.kt

@@ -0,0 +1,20 @@
+package foo
+
+enum class Foo {
+    A,
+    B
+}
+
+fun box(): String {
+    testFalse { Foo.A == Foo.B }
+    testTrue { Foo.A != Foo.B }
+    testTrue { Foo.A == Foo.A }
+    testFalse { Foo.A != Foo.A }
+
+    testFalse { Foo.A == null }
+    testTrue { Foo.A != null }
+    testFalse { null == Foo.A }
+    testTrue { null != Foo.A }
+
+    return "OK"
+}

js/js.translator/testData/box/enum/implementsComparable.kt

@@ -0,0 +1,14 @@
+package foo
+
+enum class A {
+    X,
+    Y
+}
+
+fun box(): String {
+    val a : Any = A.X
+    assertEquals(0, (a as Comparable<A>).compareTo(A.X))
+    assertTrue((a as Comparable<A>).compareTo(A.Y) < 0)
+
+    return "OK"
+}

js/js.translator/testData/box/enum/initializationOrder.kt

@@ -0,0 +1,33 @@
+package foo
+
+enum class E {
+    A,
+    B {
+        init {
+            log("init B")
+        }
+    },
+    C;
+
+    init {
+        log("init E")
+    }
+}
+
+var l = ""
+fun log(s: String) {
+    l += s + ";"
+}
+
+fun box(): String {
+    log("get Ea.A")
+    E.A.toString()
+    log("get E.B")
+    E.B.toString()
+    log("get E.C")
+    E.C.toString()
+
+    if (l != "get Ea.A;init E;init E;init B;init E;get E.B;get E.C;") return "fail: '$l'"
+
+    return "OK"
+}

js/js.translator/testData/box/enum/nativeEnum.js

@@ -0,0 +1,5 @@
+var JsEnum = {
+    Foo : 1,
+    Bar : "BAR",
+    Baz : { ok : "OK" }
+};

js/js.translator/testData/box/enum/nativeEnum.kt

@@ -0,0 +1,19 @@
+package foo
+
+@native
+enum class JsEnum {
+    Foo,
+    Bar,
+    Baz
+}
+
+// TODO uncomment when KT-5605 will be fixed
+// fun JsEnum.extImplicit() = Foo
+
+fun box(): String {
+    assertEquals(1, JsEnum.Foo)
+    assertEquals("BAR", JsEnum.Bar)
+    assertEquals("OK", JsEnum.Baz.asDynamic().ok)
+
+    return "OK"
+}

js/js.translator/testData/box/enum/simpleEnum.kt

@@ -0,0 +1,9 @@
+package foo
+
+enum class E {
+    OK
+}
+
+fun box(): String {
+    return E.OK.name
+}

js/js.translator/testData/box/enum/standardMethods.kt

@@ -0,0 +1,50 @@
+package foo
+
+enum class EmptyEnum
+
+enum class Simple {
+    OK
+}
+
+enum class A {
+    a() {
+    },
+    b(),
+    c
+}
+
+enum class B {
+    c
+}
+fun box(): String {
+    if (Simple.OK.name != "OK") return "Simple.OK.name != OK, it: ${Simple.OK.name}"
+    val ok = Simple.OK
+    if (ok.ordinal != 0) return "ok = Simple.Ok; ok.ordinal != 0, it: ${ok.ordinal}"
+
+    val ok2 = Simple.valueOf("OK")
+    if (!ok2.equals(ok)) return "ok2 not equal ok"
+    if (ok2.hashCode() != ok.hashCode()) return "hash(ok2) not equal hash(ok)"
+    if (ok2 !== ok) return "ok2 not identity equal ok"
+
+
+    if (EmptyEnum.values().size != 0) return "EmptyEnum.values().size != 0"
+
+    if (A.values().asList() != listOf(A.a, A.b, A.c)) return "Wrong A.values(): " + A.values().toString()
+
+    if (A.c.toString() != "c") return "A.c.toString() != c, it: ${A.c.toString()}"
+    if (A.valueOf("b") != A.b) return "A.valueOf('b') != A.b"
+    if (A.a == A.b) return "A.a == A.b"
+    if (A.a.hashCode() == A.b.hashCode()) return "hash(A.a) == hash(A.b)"
+
+    if (A.a.name != "a") return "A.a.name != a, it: ${A.a.name}"
+    if (A.b.name != "b") return "A.b.name != b, it: ${A.b.name}"
+    if (A.c.name != "c") return "A.c.name != c, it: ${A.c.name}"
+
+    if (A.a.ordinal != 0) return "A.a.ordinal != 0, it: ${A.a.ordinal}"
+    if (A.b.ordinal != 1) return "A.b.ordinal != 1, it: ${A.b.ordinal}"
+    if (A.c.ordinal != 2) return "A.c.ordinal != 2, it: ${A.c.ordinal}"
+
+    if (A.c.equals(B.c)) return "A.c.equals(B.c)"
+
+    return "OK"
+}

js/js.translator/testData/box/enum/superCallInEnumLiteral.kt

@@ -0,0 +1,18 @@
+package foo
+
+fun box() = E.E1.f() + E.E2.f()
+
+enum class E {
+    E1 {
+        override fun f(): String {
+            return super<E>.f() + "O"
+        }
+    },
+    E2 {
+        override fun f(): String {
+            return super.f() + "K"
+        }
+    };
+
+    open fun f() = ""
+}