tests: Update external tests (1.1.2-dev-393)

2017-03-13 12:38:08 +03:00
parent ac56fccb15
commit bc074e6d39
3178 changed files with 22396 additions and 696 deletions
@@ -0,0 +1,9 @@
+enum class A() {
+    ENTRY(){ override fun t() = "OK"};
+
+    abstract fun t(): String
+}
+
+fun f(a: A) = a.t()
+
+fun box()= f(A.ENTRY)
@@ -0,0 +1,10 @@
+enum class E {
+    ENTRY;
+
+    abstract class Nested
+}
+
+fun box(): String {
+    E.ENTRY
+    return "OK"
+}
@@ -0,0 +1,14 @@
+// http://youtrack.jetbrains.com/issue/KT-2167
+
+enum class Season {
+    WINTER,
+    SPRING,
+    SUMMER,
+    AUTUMN
+}
+
+fun foo() = Season.SPRING
+
+fun box() =
+    if (foo() == Season.SPRING) "OK"
+    else "fail"
@@ -0,0 +1,35 @@
+// TODO: muted automatically, investigate should it be ran for JS or not
+// IGNORE_BACKEND: JS, NATIVE
+
+// WITH_RUNTIME
+
+enum class IssueState {
+    DEFAULT,
+    FIXED {
+        override fun ToString() = "K"
+    };
+
+    open fun ToString(): String = "O"
+}
+
+fun box(): String {
+    val field = IssueState::class.java.getField("FIXED")
+
+    val typeName = field.type.name
+    if (typeName != "IssueState") return "Fail type name: $typeName"
+
+    val className = field.get(null).javaClass.name
+    if (className != "IssueState\$FIXED") return "Fail class name: $className"
+
+    val classLoader = IssueState::class.java.classLoader
+    classLoader.loadClass("IssueState\$FIXED")
+    try {
+        classLoader.loadClass("IssueState\$DEFAULT")
+        return "Fail: no class should have been generated for DEFAULT"
+    }
+    catch (e: Exception) {
+        // ok
+    }
+
+    return IssueState.DEFAULT.ToString() + IssueState.FIXED.ToString()
+}
@@ -0,0 +1,22 @@
+enum class Game {
+    ROCK,
+    PAPER,
+    SCISSORS;
+
+    companion object {
+        fun foo() = ROCK
+        val bar = PAPER
+        val values2 = values()
+        val scissors = valueOf("SCISSORS")
+    }
+}
+
+fun box(): String {
+    if (Game.foo() != Game.ROCK) return "Fail 1"
+    if (Game.bar != Game.PAPER) return "Fail 2: ${Game.bar}"
+    if (Game.values().size != 3) return "Fail 3"
+    if (Game.valueOf("SCISSORS") != Game.SCISSORS) return "Fail 4"
+    if (Game.values2.size != 3) return "Fail 5"
+    if (Game.scissors != Game.SCISSORS) return "Fail 6"
+    return "OK"
+}
@@ -0,0 +1,6 @@
+enum class Test(val str: String = "OK") {
+    OK
+}
+
+fun box(): String =
+        Test.OK.str
@@ -0,0 +1,7 @@
+enum class Test(vararg xs: Int) {
+    OK;
+    val values = xs
+}
+
+fun box(): String =
+        if (Test.OK.values.size == 0) "OK" else "Fail"
@@ -0,0 +1,7 @@
+enum class Test(val x: Int, val str: String) {
+    OK;
+    constructor(x: Int = 0) : this(x, "OK")
+}
+
+fun box(): String =
+        Test.OK.str
@@ -0,0 +1,10 @@
+enum class Test(val x: Int, val str: String) {
+    OK;
+    constructor(vararg xs: Int) : this(xs.size + 42, "OK")
+}
+
+fun box(): String =
+        if (Test.OK.x == 42)
+            Test.OK.str
+        else
+            "Fail"
@@ -0,0 +1,8 @@
+package test
+
+enum class My(val s: String) {
+    ENTRY;
+    constructor(): this("OK")
+}
+
+fun box() = My.ENTRY.s
@@ -0,0 +1,13 @@
+enum class Empty
+
+fun box(): String {
+    if (Empty.values().size != 0) return "Fail: ${Empty.values()}"
+
+    try {
+        val found = Empty.valueOf("nonExistentEntry")
+        return "Fail: $found"
+    }
+    catch (e: Exception) {
+        return "OK"
+    }
+}
@@ -0,0 +1,16 @@
+package test
+
+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
+}
@@ -0,0 +1,11 @@
+enum class Color(val rgb: Int) {
+    RED(0xff0000),
+    GREEN(0x00ff00),
+    BLUE(0x0000ff);
+}
+
+fun foo(): Int {
+    return Color.RED.rgb + Color.GREEN.rgb + Color.BLUE.rgb
+}
+
+fun box() = if (foo() == 0xffffff) "OK" else "Fail: ${foo()}"
@@ -0,0 +1,19 @@
+// KT-4423 Enum with function not compiled
+
+enum class Sign(val str: String, val func: (x: Int, y: Int) -> Int){
+    plus("+", { x, y -> x + y }),
+
+    mult("*", { x, y -> x * y }) {
+        override fun toString() = "${func(4,5)}"
+    }
+}
+
+fun box(): String {
+    val sum = Sign.plus.func(2, 3)
+    if (sum != 5) return "Fail 1: $sum"
+
+    val product = Sign.mult.toString()
+    if (product != "20") return "Fail 2: $product"
+
+    return "OK"
+}
@@ -0,0 +1,14 @@
+package test
+
+enum class Season {
+    WINTER,
+    SPRING,
+    SUMMER,
+    AUTUMN
+}
+
+fun foo(): Season = Season.SPRING
+
+fun box() =
+    if (foo() == Season.SPRING) "OK"
+    else "fail"
@@ -0,0 +1,15 @@
+fun box() = if(Context.operatingSystemType == Context.Companion.OsType.OTHER) "OK" else "fail"
+
+public class Context
+{
+        companion object
+        {
+                public enum class OsType {
+                        LINUX,
+                        OTHER;
+                }
+
+                public val operatingSystemType: OsType
+                        get() = OsType.OTHER
+        }
+}
@@ -0,0 +1,7 @@
+class A {
+    enum class E {
+        OK
+    }
+}
+
+fun box() = A.E.OK.toString()
@@ -0,0 +1,8 @@
+class A {
+    companion object {}
+    enum class E {
+        OK
+    }
+}
+
+fun box() = A.E.OK.toString()
@@ -0,0 +1,12 @@
+enum class Direction() {
+    NORTH {
+        val someSpecialValue = "OK"
+
+        override fun f() = someSpecialValue
+    };
+
+
+    abstract fun f():String
+}
+
+fun box() = Direction.NORTH.f()
@@ -0,0 +1,7 @@
+enum class A(val b: String) {
+    E1("OK"){ override fun t() = b };
+
+    abstract fun t(): String
+}
+
+fun box()= A.E1.t()
@@ -0,0 +1,13 @@
+enum class X {
+
+    B {
+        val value2 = "OK"
+        override val value = { value2 }
+    };
+
+    abstract val value: () -> String
+}
+
+fun box(): String {
+    return X.B.value()
+}
@@ -0,0 +1,21 @@
+// TODO: muted automatically, investigate should it be ran for JS or not
+// IGNORE_BACKEND: JS
+
+enum class IssueState {
+
+    FIXED {
+        override fun ToString() = D().k
+
+        fun s()  = "OK"
+
+        class D {
+            val k = s()
+        }
+    };
+
+    open fun ToString() : String = "fail"
+}
+
+fun box(): String {
+    return IssueState.FIXED.ToString()
+}
@@ -0,0 +1,55 @@
+enum class ClassTemplate(
+        // var bug: Int = 1,
+        var code: Int,
+        var nameTemplate: Int = 1,
+
+        val parent: Int  = 1,
+        val previous: Int  = 1,
+        val progressionEquivalent: Int  = 1,
+
+        var idDiscipline: Int = 1,
+        var strictRunningOrder: Int = 1,
+        var pointsMethod: Int = 1,
+
+        var noTimeFaults: Int = 1,
+        var combineHeights: Int = 1,
+
+        var column: Int = 1,
+        var runningOrderSort: Int = 1,
+        var programme: Int = 1,
+        var eliminationTime: Int = 1,
+        var courseTimeCode: Int = 1,
+        var teamSize: Int = 1,
+        var sponsor: Int = 1,
+        var lateEntryCredits: Int = 1,
+        var lateEntryFee: Int = 1,
+
+        var courseLengthNeeded: Int = 1,
+
+        var discretionaryCourseTime: Int = 1,
+        var isRelay: Int = 1,
+        var isQualifier: Int = 1,
+        var generateChildren: Int = 1,
+        var feedFromParent: Int = 1,
+
+        var isNfcAllowed: Int = 1,
+        var isAddOnAllowed: Int = 1,
+        var isSpecialEntry: Int = 1,
+        var isUkaProgression: Int = 1,
+        var canEnterDirectly: Int = 1,
+        var isPointRanked: Int = 1,
+        var isPointRankedDesc: Int = 1
+) {
+    UNDEFINED(code = 56, nameTemplate = 3),
+    BLAH(code = 57, nameTemplate = 4)
+}
+
+fun box(): String {
+    val x = ClassTemplate.UNDEFINED
+    val y = ClassTemplate.BLAH
+
+    if (x.code != 56 || x.nameTemplate != 3 || x.isAddOnAllowed != 1) return "fail 1"
+    if (y.code != 57 || y.nameTemplate != 4 || y.isAddOnAllowed != 1) return "fail 2"
+
+    return "OK"
+}
@@ -0,0 +1,30 @@
+// TODO: muted automatically, investigate should it be ran for JS or not
+// IGNORE_BACKEND: JS, NATIVE
+
+// WITH_RUNTIME
+// FULL_JDK
+
+import java.lang.reflect.Modifier
+
+enum class En {
+    Y
+}
+
+fun box(): String {
+    val klass = En::class.java
+    val superclass = klass.superclass.name
+    if (superclass != "java.lang.Enum") "Fail superclass: $superclass"
+
+    val enumModifiers = klass.modifiers
+    if ((enumModifiers and 0x4000) == 0) return "Fail ACC_ENUM on class"
+    if ((enumModifiers and Modifier.FINAL) == 0) return "Fail FINAL on class"
+
+    val entry = klass.getField("Y")
+    val entryModifiers = entry.modifiers
+    if ((entryModifiers and 0x4000) == 0) return "Fail ACC_ENUM on entry"
+    if ((entryModifiers and Modifier.FINAL) == 0) return "Fail FINAL on entry"
+    if ((entryModifiers and Modifier.STATIC) == 0) return "Fail FINAL on entry"
+    if ((entryModifiers and Modifier.PUBLIC) == 0) return "Fail FINAL on entry"
+
+    return "OK"
+}
@@ -0,0 +1,17 @@
+// TODO: muted automatically, investigate should it be ran for JS or not
+// IGNORE_BACKEND: JS, NATIVE
+
+// WITH_RUNTIME
+
+enum class State {
+    O,
+    K
+}
+
+fun box(): String {
+    val field = State::class.java.getField("O")
+    val className = field.get(null).javaClass.name
+    if (className != "State") return "Fail: $className"
+
+    return "${State.O.name}${State.K.name}"
+}
@@ -0,0 +1,20 @@
+enum class E {
+    ENTRY,
+    SUBCLASS {
+        object O {
+            fun foo() = 2
+        }
+        override fun bar() = O.foo()
+    };
+
+    object O {
+        fun foo() = 1
+    }
+    open fun bar() = O.foo()
+}
+
+fun box(): String {
+    if (E.ENTRY.bar() != 1) return "Fail 1"
+    if (E.SUBCLASS.bar() != 2) return "Fail 2"
+    return "OK"
+}
@@ -0,0 +1,8 @@
+enum class State {
+  _0,
+  _1,
+  _2,
+  _3
+}
+
+fun box() = if(State._0.ordinal == 0 && State._1.ordinal == 1 &&  State._2.ordinal == 2 &&  State._3.ordinal == 3) "OK" else "fail"
@@ -0,0 +1,12 @@
+enum class Season {
+    WINTER,
+    SPRING,
+    SUMMER,
+    AUTUMN
+}
+
+fun foo(): Season = Season.SPRING
+
+fun box() =
+    if (foo() == Season.SPRING) "OK"
+    else "fail"
@@ -0,0 +1,18 @@
+// WITH_RUNTIME
+
+import Game.*
+
+enum class Game {
+    ROCK,
+    PAPER,
+    SCISSORS,
+    LIZARD,
+    SPOCK
+}
+
+fun box(): String {
+    val a = arrayOf(LIZARD, SCISSORS, SPOCK, ROCK, PAPER)
+    a.sort()
+    val str = a.joinToString(" ")
+    return if (str == "ROCK PAPER SCISSORS LIZARD SPOCK") "OK" else "Fail: $str"
+}
@@ -0,0 +1,18 @@
+package test
+
+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() = ""
+}
@@ -0,0 +1,6 @@
+enum class State {
+  O,
+  K
+}
+
+fun box() = "${State.O}${State.K}"
@@ -0,0 +1,22 @@
+enum class Color {
+  RED,
+  BLUE
+}
+
+fun throwsOnGreen(): Boolean {
+    try {
+        Color.valueOf("GREEN")
+        return false
+    }
+    catch (e: Exception) {
+        return true
+    }
+}
+
+fun box() = if(
+     Color.valueOf("RED") == Color.RED
+  && Color.valueOf("BLUE") == Color.BLUE
+  && Color.values()[0] == Color.RED
+  && Color.values()[1] == Color.BLUE
+  && throwsOnGreen()
+  ) "OK" else "fail"