JS: move more test to box tests

2016-08-30 13:59:50 +03:00
parent 9bf124af3f
commit 7e2d5b04de
68 changed files with 607 additions and 578 deletions
@@ -0,0 +1,11 @@
+package foo
+
+class Test() {
+    var a: Int = 100
+}
+
+fun box(): String {
+    var test = Test()
+    test.a = 1
+    return if (1 == test.a) "OK" else "fail: ${test.a}"
+}
@@ -0,0 +1,17 @@
+package foo
+
+var a = 0
+
+class A() {
+    init {
+        a++
+    }
+
+}
+
+fun box(): String {
+    var c = A()
+    c = A()
+    c = A()
+    return if (a == 3) "OK" else "fail: $a"
+}
@@ -0,0 +1,13 @@
+package foo
+
+class Test() {
+    val a: Int
+        get() {
+            return 5;
+        }
+}
+
+fun box(): String {
+    var test = Test()
+    return if (test.a == 5) "OK" else "fail: ${test.a}"
+}
@@ -0,0 +1,14 @@
+package foo
+
+class Test() {
+    var a: Int = 5
+        set(b: Int) {
+            field = 3
+        }
+}
+
+fun box(): String {
+    var test = Test()
+    test.a = 5
+    return if (test.a == 3) "OK" else "fail: ${test.a}"
+}
@@ -0,0 +1,49 @@
+// FILE: enumerable.kt
+package foo
+
+@native
+fun <T> _enumerate(o: T): T = noImpl
+
+@native
+fun <T> _findFirst(o: Any): T = noImpl
+
+class Test() {
+    val a: Int = 100
+    val b: String = "s"
+}
+
+class P() {
+    @enumerable
+    val a: Int = 100
+    val b: String = "s"
+}
+
+fun box(): String {
+    val test = _enumerate(Test())
+    val p = _enumerate(P())
+    if (100 != test.a) return "fail1: ${test.a}"
+    if ("s" != test.b) return "fail2: ${test.b}"
+    if (p.a != 100) return "fail3: ${p.a}"
+
+    val result = _findFirst<Int>(object {
+        val test = 100
+    })
+    if (result != 100) return "fail4: $result"
+
+    return "OK"
+}
+
+// FILE: enumerate.js
+function _enumerate(o) {
+    var r = {};
+    for (var p in o) {
+        r[p] = o[p];
+    }
+    return r;
+}
+
+function _findFirst(o) {
+    for (var p in o) {
+        return o[p];
+    }
+}
@@ -0,0 +1,14 @@
+package foo
+
+fun f(a: Int?, b: Int.(Int) -> Int) = a?.b(2)
+
+fun box(): String {
+    val c1 = f (null) {
+        it + this
+    } != null
+    if (c1) return "fail1"
+    if (f(3) {
+        it + this
+    } != 5) return "fail2"
+    return "OK"
+}
@@ -0,0 +1,16 @@
+package foo
+
+class A {
+    var a: Int = 0
+        get() = field + 1
+        set(arg) {
+            field = arg
+        }
+}
+
+fun box(): String {
+    val a = A()
+    a.a = 1
+    if (a.a != 2) return "A().a != 2, it: ${a.a}"
+    return "OK"
+}
@@ -0,0 +1,16 @@
+package foo
+
+class Test() {
+    val a: Int = 100
+    var b: Int = a
+    val c: Int = a + b
+}
+
+fun box(): String {
+    val test = Test()
+    if (100 != test.a) return "fail1: ${test.a}"
+    if (100 != test.b) return "fail2: ${test.b}"
+    if (200 != test.c) return "fail3: ${test.c}"
+
+    return "OK"
+}
@@ -0,0 +1,52 @@
+package foo
+
+class A {
+    val a: Int
+    val aa: Int
+        get() {
+            return field
+        }
+
+    var aR = 0
+    var aaR = 0
+    init {
+        a = 1
+        aa = 2
+
+        aR = a
+        aaR = aa
+    }
+}
+
+class B {
+    private val a: Int
+    private val aa: Int
+        get() {
+            return field
+        }
+
+    var aR = 0
+    var aaR = 0
+    init {
+        a = 3
+        aa = 4
+
+        aR = a
+        aaR = aa
+    }
+}
+
+fun box(): String {
+    val a = A()
+
+    if (a.a != 1) return "a.a != 1, it: ${a.a}"
+    if (a.aa != 2) return "a.aa != 2, it: ${a.aa}"
+    if (a.aR != 1) return "a.aR != 1, it: ${a.aR}"
+    if (a.aaR != 2) return "a.aaR != 2, it: ${a.aaR}"
+
+    val b = B()
+    if (b.aR != 3) return "b.aR != 3, it: ${b.aR}"
+    if (b.aaR != 4) return "b.aaR != 4, it: ${b.aaR}"
+
+    return "OK"
+}
@@ -0,0 +1,17 @@
+package foo
+
+val PACKAGE = "kotlin.modules.JS_TESTS.foo"
+
+class A
+@native val Any.__proto__: String get() = noImpl
+@native val A.__proto__: String get() = noImpl
+
+fun box(): String {
+    val a = A()
+    val any: Any = a
+    val protoA = eval("$PACKAGE.A.prototype")
+    if (a.__proto__ != any.__proto__ || a.__proto__ != protoA)
+        return "a.__proto__ != any.__proto__ /*${a.__proto__ != any.__proto__}*/ || a.__proto__ != $PACKAGE.A.prototype /*${a.__proto__ != protoA}*/"
+
+    return "OK"
+}
@@ -0,0 +1,19 @@
+package foo
+
+interface I {
+    fun test(): String
+}
+
+class P : I {
+    override fun test(): String {
+        return "O" + test("K")
+    }
+
+    private fun test(p: String): String {
+        return p
+    }
+}
+
+fun box(): String {
+    return P().test()
+}
@@ -0,0 +1,15 @@
+package foo
+
+var a: Int
+
+
+    get() {
+        return 5
+    }
+    set(b) {
+
+    }
+
+fun box(): String {
+    return if (a == 5) "OK" else "fail: $a"
+}
@@ -0,0 +1,5 @@
+package foo
+
+val b = 3
+
+fun box() = if (b == 3) "OK" else "fail: $b"
@@ -0,0 +1,8 @@
+package foo
+
+var b = 3
+
+fun box(): String {
+    b = 2
+    return if (b == 2) "OK" else "fail: $b"
+}
@@ -0,0 +1,22 @@
+package foo
+
+object A {
+    private val foo = 23
+
+    fun bar(): Int {
+        // Erase object so that we ensure that access to 'foo' property is performed via 'this'
+        // It's no crucial from runtime standpoind, but JS code looks more concise and natural this way.
+        erase()
+        return foo
+    }
+
+    fun erase() {
+        js("_.foo.A = null")
+    }
+}
+
+fun box(): String {
+    var result = A.bar()
+    if (result != 23) return "failed: ${result}"
+    return "OK"
+}
@@ -0,0 +1,21 @@
+// See https://youtrack.jetbrains.com/issue/KT-10785
+package foo
+
+class A(var x: Int) {
+    operator fun plusAssign(other: A) {
+        x += other.x
+    }
+}
+
+object B {
+    private var holder = A(42)
+
+    val foo: A
+        get() = holder
+}
+
+fun box(): String {
+    B.foo += A(23)
+    if (B.foo.x != 65) return "failed: ${B.foo.x}"
+    return "OK"
+}
@@ -0,0 +1,13 @@
+package foo
+
+class Test() {
+    var a: Int = 1
+}
+
+fun box(): String {
+    var b = Test()
+    assertEquals(1, b.a)
+    b.a = 100
+    assertEquals(100, b.a)
+    return "OK"
+}
@@ -0,0 +1,16 @@
+package foo
+
+class A() {
+    val a: Int = 1
+}
+
+class B() {
+    val b: Int = 2
+}
+
+fun box(): String {
+    if (A().a != 1) return "fail1"
+    if (B().b != 2) return "fail2"
+
+    return "OK"
+}