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,45 @@
+package foo
+
+object EmptyObject {}
+
+object SomeObject {
+    val foo = 1
+    var bar = "t"
+    fun baz() {}
+}
+
+val emptyObjectExpr = object {}
+
+val someObjectExpr = object {
+    val foo = 1
+    var bar = "t"
+    fun baz() {}
+}
+
+val o = js("Object")
+
+fun keys(a: Any): List<String> {
+    val arr: Array<String> = o.keys(a)
+    return arr.toList()
+}
+
+fun getOwnPropertyNames(a: Any): List<String> {
+    val arr: Array<String> = o.getOwnPropertyNames(a)
+    return arr.toList()
+}
+
+fun box(): String {
+    assertEquals(listOf(), getOwnPropertyNames(EmptyObject))
+    assertEquals(listOf(), keys(EmptyObject))
+
+    assertEquals(listOf("foo", "bar"), getOwnPropertyNames(SomeObject))
+    assertEquals(listOf("foo", "bar"), keys(SomeObject))
+
+    assertEquals(listOf(), getOwnPropertyNames(emptyObjectExpr))
+    assertEquals(listOf(), keys(emptyObjectExpr))
+
+    assertEquals(listOf("foo", "bar"), getOwnPropertyNames(someObjectExpr))
+    assertEquals(listOf("foo", "bar"), keys(someObjectExpr))
+
+    return "OK"
+}
@@ -0,0 +1,18 @@
+// copied from JVM backend tests
+package foo
+
+open class X(private val n: String) {
+
+    fun foo(): String {
+        return object : X("inner") {
+            fun print(): String {
+                return n;
+            }
+        }.print()
+    }
+}
+
+
+fun box(): String {
+  return X("OK").foo()
+}
@@ -0,0 +1,10 @@
+package foo
+
+object A {
+    object B {
+        val lambda = { "OK" }
+    }
+}
+
+fun box() = A.B.lambda()
+
@@ -0,0 +1,25 @@
+package foo
+
+class A {
+
+}
+
+object test {
+    var c = 2;
+    var b = 1;
+}
+
+object aWrapper {
+    var a = A();
+}
+
+fun box(): String {
+    if (test.c != 2) return "fail1: ${test.c}"
+
+    if (test.b != 1) return "fail2: ${test.b}"
+    test.c += 10
+    if (test.c != 12) "fail3: ${test.c}"
+    if (aWrapper.a !is A) "fail4"
+
+    return "OK"
+}
@@ -0,0 +1,12 @@
+package foo
+
+object State {
+    val c = 2
+    val b = 1
+}
+
+fun box(): String {
+    if (State.c != 2) return "fail1: ${State.c}"
+    if (State.b != 1) return "fail2: ${State.b}"
+    return "OK"
+}
@@ -0,0 +1,12 @@
+package foo
+
+class A() {
+    fun f(): String {
+        val z = object {
+            val c = "OK"
+        }
+        return z.c
+    }
+}
+
+fun box() = A().f();
@@ -0,0 +1,37 @@
+package foo
+
+object A {
+    object query {
+        val status = "complete"
+    }
+}
+
+object B {
+    private val ov = "d"
+    object query {
+        val status = "complete" + ov
+    }
+}
+
+class C {
+    companion object {
+        fun ov() = "d"
+    }
+    object query {
+        val status = "complete" + ov()
+    }
+}
+
+fun box(): String {
+    var result = A.query.status
+    if (result != "complete") return "fail1: $result"
+
+    result = B.query.status
+    if (result != "completed") return "fail2: $result"
+
+    result = C.query.status
+    if (result != "completed") return "fail3: $result"
+
+    return "OK"
+}
+
@@ -0,0 +1,18 @@
+package foo
+
+class Foo {
+    fun bar(param: String): String {
+        val local = "K"
+        var a = object {
+            val b = object {
+                val bar = param + local
+            }
+        }
+        return a.b.bar
+    }
+}
+
+fun box(): String {
+    return Foo().bar("O")
+}
+
@@ -0,0 +1,25 @@
+package foo
+
+interface Foo {
+    fun execute(handler: () -> Unit) {
+        execute(false, handler)
+    }
+
+    fun execute(onlyIfAttached: Boolean, handler: () -> Unit)
+}
+
+object foo : Foo {
+    override fun execute(onlyIfAttached: Boolean, handler: () -> Unit) {
+        handler()
+    }
+}
+
+private var result = "fail"
+
+fun box(): String {
+    foo.execute() {
+        result = "OK"
+    }
+
+    return result
+}
@@ -0,0 +1,9 @@
+package foo
+
+abstract class A(val s: String) {
+}
+
+object B : A("test") {
+}
+
+fun box() = if (B.s == "test") "OK" else "fail: ${B.s}"
@@ -0,0 +1,22 @@
+package foo
+
+class Test {
+    private val a = object {
+        fun c() = 3
+        fun b() = 2
+    }
+
+    fun doTest(): String {
+        if (a.c() != 3) {
+            return "fail1"
+        }
+        if (a.b() != 2) {
+            return "fail2"
+        }
+        return "OK"
+    }
+}
+
+fun box(): String {
+    return Test().doTest();
+}
@@ -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"
+}
@@ -0,0 +1,50 @@
+package foo
+
+interface A {
+    val bal: Int
+        get() {
+            return 42
+        }
+}
+
+open class B {
+    open val bal = 239
+}
+
+class C1 : B(), A {
+    override val bal: Int = 14
+
+    fun getBalA(): Int {
+        return super<A>.bal
+    }
+
+    fun getBalB(): Int {
+        return super<B>.bal
+    }
+}
+
+class C2 : A, B() {
+    override val bal: Int = 14
+
+    fun getBalA(): Int {
+        return super<A>.bal
+    }
+
+    fun getBalB(): Int {
+        return super<B>.bal
+    }
+}
+
+fun box(): String {
+    val c1 = C1();
+    if (c1.bal != 14) return "c1.bal != 14, it: ${c1.bal}"
+    if (c1.getBalA() != 42) return "c1.getBalA() != 42, it: ${c1.getBalA()}"
+    if (c1.getBalB() != 239) return "c1.getBalB() != 239, it: ${c1.getBalB()}"
+
+    val c2 = C2();
+    if (c2.bal != 14) return "c2.bal != 14, it: ${c2.bal}"
+    if (c2.getBalA() != 42) return "c2.getBalA() != 42, it: ${c2.getBalA()}"
+    if (c2.getBalB() != 239) return "c2.getBalB() != 239, it: ${c2.getBalB()}"
+
+    return "OK"
+}
@@ -0,0 +1,21 @@
+// Test for KT-5673
+
+package foo
+
+interface Holder {
+    val element: String
+}
+
+class BasicHolder : Holder {
+    override val element: String
+
+    init {
+        element = "ok"
+    }
+}
+
+fun box(): String {
+    assertEquals("ok", BasicHolder().element)
+
+    return "OK"
+}
@@ -0,0 +1,30 @@
+// Test for KT-5673
+
+package foo
+
+interface Holder {
+    val element: String
+}
+
+open class BasicHolder : Holder {
+    override val element: String
+        get() = field + field
+
+    init {
+        element = "1"
+    }
+}
+
+class AdvancedHolder : BasicHolder() {
+    override val element: String
+
+    init {
+        element = super.element + super.element
+    }
+}
+
+fun box(): String {
+    assertEquals("1111", AdvancedHolder().element)
+
+    return "OK"
+}
@@ -0,0 +1,21 @@
+// Test for KT-5673
+
+package foo
+
+interface Holder {
+    val element: String
+}
+
+class BasicHolder : Holder {
+    override val element: String
+
+    init {
+        this.element = "ok"
+    }
+}
+
+fun box(): String {
+    assertEquals("ok", BasicHolder().element)
+
+    return "OK"
+}
@@ -0,0 +1,21 @@
+// Test for KT-5673
+
+package foo
+
+interface Holder {
+    var element: String
+}
+
+class BasicHolder : Holder {
+    override var element: String = "not ok"
+
+    init {
+        element = "ok"
+    }
+}
+
+fun box(): String {
+    assertEquals("ok", BasicHolder().element)
+
+    return "OK"
+}
@@ -0,0 +1,28 @@
+package foo
+
+open class A {
+    private val a = 1
+
+    private val b = 2
+        get() {
+            return field + 10 + 100 * a
+        }
+    fun getBInA(): Int {
+        return b
+    }
+}
+
+class B : A() {
+    val a = 13
+    val b = 42
+}
+
+
+fun box(): String {
+    val b = B()
+    if (b.getBInA() != 112) return "b.getBInA() != 112, it: ${b.getBInA()}"
+
+    if (b.a != 13) return "b.a != 13, it: ${b.a}"
+    if (b.b != 42) return "b.b != 42, it: ${b.b}"
+    return "OK"
+}
@@ -0,0 +1,25 @@
+package foo
+
+class T
+
+open class A {
+    open val T.foo: Int
+        get() {
+            return 34
+        }
+    fun test(): Int {
+        return T().foo
+    }
+}
+
+class B : A() {
+    override val T.foo: Int get() = 5
+}
+
+
+fun box(): String {
+    if (A().test() != 34) return "A().test() != 34, it: ${A().test() != 34}"
+    if (B().test() != 5) return "B().test() != 5, it: ${B().test() != 5}"
+
+    return "OK"
+}
@@ -0,0 +1,35 @@
+package foo
+
+open class A {
+    open var a = 1
+    fun getAInA(): Int = a
+}
+
+open class AA : A()
+
+class B : AA() {
+    override var a = 2
+
+    fun getSuperA(): Int {
+        return super.a
+    }
+
+    fun setSuperA(value: Int) {
+        super.a = value
+    }
+}
+
+fun box(): String {
+    val a = A()
+    val b = B()
+    if (a.getAInA() != 1) return "a.getAInA() != 1, it: ${a.getAInA()}"
+    if (b.getAInA() != 2) return "b.getAInA() != 2, it: ${b.getAInA()}"
+
+    if (b.getSuperA() != 1) return "b.getSuperA() != 1, it: ${b.getSuperA()}"
+    b.setSuperA(3)
+    if (b.getSuperA() != 3) return "b.getSuperA() != 3, it: ${b.getSuperA()}"
+
+    if (b.getAInA() != 2) return "b.getAInA() != 2 after b.setAInB(3), it: ${b.getAInA()}"
+
+    return "OK"
+}
@@ -0,0 +1,99 @@
+package foo
+
+interface A {
+    val bal: Int
+        get() {
+            return 5
+        }
+    var bar: Int
+        get() {
+            return realBar
+        }
+        set(value: Int) {
+            realBar = value
+        }
+
+    var realBar: Int
+}
+
+
+interface B {
+    val bal: Int
+        get() {
+            return 42
+        }
+    var bar: Int
+        get() {
+            return realBar + 1000
+        }
+        set(value: Int) {
+            realBar = value + 1000
+        }
+
+    var realBar: Int
+}
+
+class C : A, B {
+    override val bal: Int = 1
+    override var bar: Int = 2
+        get() {
+            return field + 20
+        }
+        set(value: Int) {
+            field = value + 20
+        }
+    override var realBar: Int = 3
+
+    fun supBalA(): Int {
+        return super<A>.bal
+    }
+
+    fun supBalB(): Int {
+        return super<B>.bal
+    }
+
+    fun supBarA(): Int {
+        return super<A>.bar
+    }
+
+    fun supBarB(): Int {
+        return super<B>.bar
+    }
+
+    fun setBarA(value: Int) {
+        super<A>.bar = value
+    }
+
+    fun setBarB(value: Int) {
+        super<B>.bar = value
+    }
+}
+
+fun box(): String {
+    val c = C()
+
+    if (c.bal != 1) return "c.bal != 1, it: ${c.bal}"
+    if (c.bar != 22) return "c.bar != 22, it: ${c.bar}"
+    if (c.realBar != 3) return "c.realBar != 3, it: ${c.realBar}"
+
+    c.bar = 50
+    if (c.bar != 90) return "c.bar != 90, it: ${c.bar}"
+
+    if (c.supBalA() != 5) return "c.supBalA() != 5, it: ${c.supBalA()}"
+    if (c.supBalB() != 42) return "c.supBalB() != 42, it: ${c.supBalB()}"
+
+    if (c.supBarA() != 3) return "c.supBarA() != 3, it: ${c.supBarA()}"
+    if (c.supBarB() != 1003) return "c.supBarB() != 1003, it: ${c.supBarB()}"
+
+    c.setBarA(239)
+    if (c.realBar != 239) return "c.realBar != 239, it: ${c.realBar}"
+    if (c.supBarA() != 239) return "c.supBarA() != 239, it: ${c.supBarA()}"
+    if (c.supBarB() != 1239) return "c.supBarB() != 1239, it: ${c.supBarB()}"
+
+    c.setBarB(239)
+    if (c.realBar != 1239) return "c.realBar != 1239, it: ${c.realBar}"
+    if (c.supBarA() != 1239) return "c.supBarA() != 1239, it: ${c.supBarA()}"
+    if (c.supBarB() != 2239) return "c.supBarB() != 2239, it: ${c.supBarB()}"
+
+    return "OK"
+}
@@ -0,0 +1,25 @@
+package foo
+
+open class A {
+    open val a = 2
+        get() {
+            return field + 1
+        }
+}
+
+class B : A() {
+    override val a: Int = 5
+        get() {
+            return super.a + 10 * field + 100
+        }
+}
+
+fun box(): String {
+    val a = A()
+    val b = B()
+
+    if (a.a != 3) return "a.a != 3, it: ${a.a}"
+    if (b.a != 153) return "b.a != 153, it: ${b.a}"
+
+    return "OK"
+}
@@ -0,0 +1,33 @@
+package foo
+
+open class A {
+    open var a = 1
+    fun getAInA(): Int = a
+}
+
+class B : A() {
+    override var a = 2
+
+    fun getSuperA(): Int {
+        return super.a
+    }
+
+    fun setSuperA(value: Int) {
+        super.a = value
+    }
+}
+
+fun box(): String {
+    val a = A()
+    val b = B()
+    if (a.getAInA() != 1) return "a.getAInA() != 1, it: ${a.getAInA()}"
+    if (b.getAInA() != 2) return "b.getAInA() != 2, it: ${b.getAInA()}"
+
+    if (b.getSuperA() != 1) return "b.getSuperA() != 1, it: ${b.getSuperA()}"
+    b.setSuperA(3)
+    if (b.getSuperA() != 3) return "b.getSuperA() != 3, it: ${b.getSuperA()}"
+
+    if (b.getAInA() != 2) return "b.getAInA() != 2 after b.setAInB(3), it: ${b.getAInA()}"
+
+    return "OK"
+}
@@ -0,0 +1,15 @@
+package foo
+
+fun box(): String {
+
+    val intProgression = IntProgression.fromClosedRange(0, 10, 2)
+    assertEquals(10, intProgression.last)
+
+    val longProgression = LongProgression.fromClosedRange(0, 420004200042000L, 420004200042000L)
+    assertEquals(420004200042000L, longProgression.last)
+
+    val charProgression = CharProgression.fromClosedRange('a', 'z', 2)
+    assertEquals('y', charProgression.last)
+
+    return "OK"
+}
@@ -0,0 +1,27 @@
+package foo
+
+fun box(): String {
+
+    var twoToFive = IntRange(2, 5)
+
+    if (twoToFive.contains(6)) return "fail1"
+    if (twoToFive.contains(1)) return "fail2"
+    if (twoToFive.contains(0)) return "fail3"
+    if (twoToFive.contains(-100)) return "fail4"
+    if (twoToFive.contains(10)) return "fail5"
+    if (!twoToFive.contains(2)) return "fail6"
+    if (!twoToFive.contains(3)) return "fail7"
+    if (!twoToFive.contains(4)) return "fail8"
+    if (!twoToFive.contains(5)) return "fail9"
+    if (!(twoToFive.start == 2)) return "fail10"
+    if (!(twoToFive.endInclusive == 5)) return "fail11"
+
+    var sum = 0;
+    for (i in twoToFive) {
+        sum += i;
+    }
+
+    if (sum != 14) return "fail12"
+
+    return "OK"
+}
@@ -0,0 +1,24 @@
+package foo
+
+import java.util.ArrayList
+
+fun testDownTo() {
+    var elems = ArrayList<Int>()
+    for (i in 4 downTo 0) {
+        elems.add(i)
+    }
+    assertTrue(elems[0] == 4 && elems[1] == 3 && elems[2] == 2 && elems[3] == 1 &&  elems[4] == 0)
+}
+
+fun testDownToDoesNotIterate() {
+    for (i in 0 downTo 1) {
+        fail()
+    }
+}
+
+fun box(): String {
+    testDownTo()
+    testDownToDoesNotIterate()
+
+    return "OK"
+}
@@ -0,0 +1,14 @@
+package foo
+
+
+fun box(): String {
+
+    if (1 in -2..0) return "fail1"
+    if (1 in -10..-4) return "fail2"
+    if (!(1 in 0..2)) return "fail3"
+
+    if (!(1 in 1..2)) return "fail4"
+    if (!(1 in -2..5)) return "fail5"
+
+    return "OK"
+}
@@ -0,0 +1,18 @@
+package foo
+
+import java.util.ArrayList
+
+fun box(): String {
+    var elems = ArrayList<Int>()
+    for (i in 0.rangeTo(5)) {
+        elems.add(i)
+    }
+    if (elems[0] != 0) return "fail1: ${elems[0]}"
+    if (elems[1] != 1) return "fail2: ${elems[1]}"
+    if (elems[2] != 2) return "fail3: ${elems[2]}"
+    if (elems[3] != 3) return "fail4: ${elems[3]}"
+    if (elems[4] != 4) return "fail5: ${elems[4]}"
+    if (elems[5] != 5) return "fail6: ${elems[5]}"
+
+    return "OK"
+}
@@ -0,0 +1,35 @@
+package foo
+
+fun box(): String {
+
+    var d = 0
+    for (i in 1..6) {
+        d += i
+    }
+    if (d != 21) return "fail1: $d"
+
+    for (x in 100..199) {
+        d += 1
+    }
+    if (d != 121) {
+        return "fail2: $d"
+    }
+
+    for (y in 1..1) {
+        d = 100
+    }
+
+    if (d != 100) {
+        return "fail3: $d"
+    }
+
+    for (c in 100..100) {
+        d += 1;
+    }
+
+    if (d != 101) {
+        return "fail4: $d"
+    }
+
+    return "OK"
+}
@@ -0,0 +1,12 @@
+package foo
+
+fun box(): String {
+
+    assertEquals(true, 2..1 == 4..2, "2..1 == 4..2")
+    assertEquals(true, 2L..1L == 318238945677L..2L, "2L..1L == 318238945677L..2L")
+    assertEquals(false, (2..1) as Any == (4L..2L) as Any, "(2..1): Any == (4L..2L): Any")
+    assertEquals(true, 'B'..'A' == 'W'..'B', "'B'..'A' == 'W'..'B'")
+    assertEquals(false, (2..1) as Any == ('B'..'A') as Any, "(2..1): Any == ('B'..'A'): Any")
+
+    return "OK"
+}
@@ -0,0 +1,27 @@
+package foo
+
+fun box(): String {
+
+    var twoToFive = 2..5
+
+    if (twoToFive.contains(6)) return "fail1"
+    if (twoToFive.contains(1)) return "fail2"
+    if (twoToFive.contains(0)) return "fail3"
+    if (twoToFive.contains(-100)) return "fail4"
+    if (twoToFive.contains(10)) return "fail5"
+    if (!twoToFive.contains(2)) return "fail6"
+    if (!twoToFive.contains(3)) return "fail7"
+    if (!twoToFive.contains(4)) return "fail8"
+    if (!twoToFive.contains(5)) return "fail9"
+    if (!(twoToFive.start == 2)) return "fail10"
+    if (!(twoToFive.endInclusive == 5)) return "fail11"
+
+    var sum = 0;
+    for (i in twoToFive) {
+        sum += i;
+    }
+
+    if (sum != 14) return "fail12"
+
+    return "OK"
+}
@@ -0,0 +1,10 @@
+package foo
+
+import java.util.ArrayList
+
+fun box(): String {
+    for (i in 0.rangeTo(-1)) {
+        return "fail"
+    }
+    return "OK"
+}
@@ -0,0 +1,8 @@
+package foo
+
+fun box(): String {
+    assertEquals(listOf(7, 6, 5, 4, 3), (3..7).reversed().toList())
+    assertEquals(listOf(10, 11, 12, 13), (13 downTo 10).reversed().toList())
+
+    return "OK"
+}