backend/tests: Add blackbox tests from Kotlin JVM

Added tests from testData/codegen/box directory. There are blackbox tests in other directories and they are to be added.
2017-01-12 19:43:20 +07:00
parent d5988297b1
commit 1b553ebfaf
2643 changed files with 66666 additions and 0 deletions
@@ -0,0 +1,26 @@
+// WITH_RUNTIME
+
+import kotlin.test.assertEquals
+
+fun simpleIntArray(): Array<Int> = Array(3) { it }
+fun simpleDoubleArray(): Array<Double> = Array(3) { it.toDouble() + 0.1 }
+fun simpleStringArray(): Array<String> = Array(3) { it.toString() }
+
+fun box(): String {
+    val ia = simpleIntArray()
+    assertEquals(0, ia[0])
+    assertEquals(1, ia[1])
+    assertEquals(2, ia[2])
+
+    val da = simpleDoubleArray()
+    assertEquals(0.1, da[0])
+    assertEquals(1.1, da[1])
+    assertEquals(2.1, da[2])
+
+    val sa = simpleStringArray()
+    assertEquals("0", sa[0])
+    assertEquals("1", sa[1])
+    assertEquals("2", sa[2])
+
+    return "OK"
+}
@@ -0,0 +1,11 @@
+operator fun Array<String>.get(index1: Int, index2: Int) = this[index1 + index2]
+operator fun Array<String>.set(index1: Int, index2: Int, elem: String) {
+    this[index1 + index2] = elem
+}
+
+fun box(): String {
+    val s = Array<String>(1, { "" })
+    s[1, -1] = "O"
+    s[2, -2] += "K"
+    return s[-3, 3]
+}
@@ -0,0 +1,11 @@
+operator fun Array<String>.get(index1: Int, index2: Int) = this[index1 + index2]
+operator fun Array<String>.set(index1: Int, index2: Int, elem: String) {
+    this[index1 + index2] = elem
+}
+
+fun box(): String {
+    val s = Array<String>(1, { "" })
+    s[1, -1] = "OK"
+    return s[-2, 2]
+}
+ 
@@ -0,0 +1,29 @@
+// TODO: muted automatically, investigate should it be ran for JS or not
+// IGNORE_BACKEND: JS
+
+//test [], get and iterator calls
+fun test(createIntNotLong: Boolean): String {
+    val a = if (createIntNotLong) IntArray(5) else LongArray(5)
+    if (a is IntArray) {
+        val x = a.iterator()
+        var i = 0
+        while (x.hasNext()) {
+            if (a[i] != x.next()) return "Fail $i"
+            i++
+        }
+        return "O"
+    } else if (a is LongArray) {
+        val x = a.iterator()
+        var i = 0
+        while (x.hasNext()) {
+            if (a.get(i) != x.next()) return "Fail $i"
+            i++
+        }
+        return "K"
+    }
+    return "fail"
+}
+
+fun box(): String {
+    return test(true) + test(false)
+}
@@ -0,0 +1,6 @@
+fun box(): String {
+    val s = IntArray(1)
+    s[0] = 5
+    s[0] += 7
+    return if (s[0] == 12) "OK" else "Fail ${s[0]}"
+}
@@ -0,0 +1,28 @@
+// TODO: muted automatically, investigate should it be ran for JS or not
+// IGNORE_BACKEND: JS
+
+fun foo(x: Cloneable) = x
+
+fun box(): String {
+    foo(arrayOf(""))
+    foo(intArrayOf())
+    foo(longArrayOf())
+    foo(shortArrayOf())
+    foo(byteArrayOf())
+    foo(charArrayOf())
+    foo(doubleArrayOf())
+    foo(floatArrayOf())
+    foo(booleanArrayOf())
+
+    arrayOf("").clone()
+    intArrayOf().clone()
+    longArrayOf().clone()
+    shortArrayOf().clone()
+    byteArrayOf().clone()
+    charArrayOf().clone()
+    doubleArrayOf().clone()
+    floatArrayOf().clone()
+    booleanArrayOf().clone()
+
+    return "OK"
+}
@@ -0,0 +1,18 @@
+// TODO: muted automatically, investigate should it be ran for JS or not
+// IGNORE_BACKEND: JS
+
+// WITH_RUNTIME
+
+fun box(): String {
+    val s = arrayOf("live", "long")
+    val t: Array<String> = s.clone()
+    if (!(s contentEquals t)) return "Fail string"
+    if (s === t) return "Fail string identity"
+
+    val ss = arrayOf(s, s)
+    val tt: Array<Array<String>> = ss.clone()
+    if (!(ss contentEquals tt)) return "Fail string[]"
+    if (ss === tt) return "Fail string[] identity"
+
+    return "OK"
+}
@@ -0,0 +1,40 @@
+// TODO: muted automatically, investigate should it be ran for JS or not
+// IGNORE_BACKEND: JS
+
+// WITH_RUNTIME
+
+fun box(): String {
+    val i = intArrayOf(1, 2)
+    if (!(i contentEquals i.clone())) return "Fail int"
+    if (i.clone() === i) return "Fail int identity"
+
+    val j = longArrayOf(1L, 2L)
+    if (!(j contentEquals j.clone())) return "Fail long"
+    if (j.clone() === j) return "Fail long identity"
+
+    val s = shortArrayOf(1.toShort(), 2.toShort())
+    if (!(s contentEquals s.clone())) return "Fail short"
+    if (s.clone() === s) return "Fail short identity"
+
+    val b = byteArrayOf(1.toByte(), 2.toByte())
+    if (!(b contentEquals b.clone())) return "Fail byte"
+    if (b.clone() === b) return "Fail byte identity"
+
+    val c = charArrayOf('a', 'b')
+    if (!(c contentEquals c.clone())) return "Fail char"
+    if (c.clone() === c) return "Fail char identity"
+
+    val d = doubleArrayOf(1.0, -1.0)
+    if (!(d contentEquals d.clone())) return "Fail double"
+    if (d.clone() === d) return "Fail double identity"
+
+    val f = floatArrayOf(1f, -1f)
+    if (!(f contentEquals f.clone())) return "Fail float"
+    if (f.clone() === f) return "Fail float identity"
+
+    val z = booleanArrayOf(true, false)
+    if (!(z contentEquals z.clone())) return "Fail boolean"
+    if (z.clone() === z) return "Fail boolean identity"
+
+    return "OK"
+}
@@ -0,0 +1,12 @@
+operator fun ArrayList<String>.get(index1: Int, index2: Int) = this[index1 + index2]
+operator fun ArrayList<String>.set(index1: Int, index2: Int, elem: String) {
+    this[index1 + index2] = elem
+}
+
+fun box(): String {
+    val s = ArrayList<String>(1)
+    s.add("")
+    s[1, -1] = "O"
+    s[2, -2] += "K"
+    return s[2, -2]
+}
@@ -0,0 +1,11 @@
+operator fun ArrayList<String>.get(index1: Int, index2: Int) = this[index1 + index2]
+operator fun ArrayList<String>.set(index1: Int, index2: Int, elem: String) {
+    this[index1 + index2] = elem
+}
+
+fun box(): String {
+    val s = ArrayList<String>(1)
+    s.add("")
+    s[1, -1] = "OK"
+    return s[2, -2]
+}
@@ -0,0 +1,6 @@
+fun box(): String {
+    for (x in BooleanArray(5)) {
+        if (x != false) return "Fail $x"
+    }
+    return "OK"
+}
@@ -0,0 +1,6 @@
+fun box(): String {
+    for (x in ByteArray(5)) {
+        if (x != 0.toByte()) return "Fail $x"
+    }
+    return "OK"
+}
@@ -0,0 +1,6 @@
+fun box(): String {
+    for (x in CharArray(5)) {
+        if (x != 0.toChar()) return "Fail $x"
+    }
+    return "OK"
+}
@@ -0,0 +1,6 @@
+fun box(): String {
+    for (x in DoubleArray(5)) {
+        if (x != 0.toDouble()) return "Fail $x"
+    }
+    return "OK"
+}
@@ -0,0 +1,6 @@
+fun box(): String {
+    for (x in FloatArray(5)) {
+        if (x != 0.toFloat()) return "Fail $x"
+    }
+    return "OK"
+}
@@ -0,0 +1,6 @@
+fun box(): String {
+    for (x in IntArray(5)) {
+        if (x != 0) return "Fail $x"
+    }
+    return "OK"
+}
@@ -0,0 +1,6 @@
+fun box(): String {
+    for (x in LongArray(5)) {
+        if (x != 0.toLong()) return "Fail $x"
+    }
+    return "OK"
+}
@@ -0,0 +1,6 @@
+fun box(): String {
+    for (x in ShortArray(5)) {
+        if (x != 0.toShort()) return "Fail $x"
+    }
+    return "OK"
+}
@@ -0,0 +1,9 @@
+operator fun HashMap<String, Int?>.set(index: String, elem: Int?) {
+    this.put(index, elem)
+}
+
+fun box(): String {
+    val s = HashMap<String, Int?>()
+    s["239"] = 239
+    return if (s["239"] == 239) "OK" else "Fail"
+}
@@ -0,0 +1,9 @@
+fun test(y: Array<in Array<String>>) {
+    y[0] = kotlin.arrayOf("OK")
+}
+
+fun box() : String {
+    val x : Array<Array<*>> = kotlin.arrayOf(kotlin.arrayOf(1))
+    test(x)
+    return x[0][0] as String
+}
@@ -0,0 +1,10 @@
+fun box(): String {
+    val x : Array<Array<*>> = arrayOf(arrayOf(1))
+    val y : Array<in Array<String>> = x
+
+    if (y.size != 1) return "fail 1"
+
+    y[0] = arrayOf("OK")
+
+    return x[0][0] as String
+}
@@ -0,0 +1,12 @@
+// WITH_RUNTIME
+
+fun box(): String {
+    val x: Array<List<*>> = arrayOf(listOf(1))
+    val y : Array<in List<String>> = x
+
+    if (y.size != 1) return "fail 1"
+
+    y[0] = listOf("OK")
+
+    return x[0][0] as String
+}
@@ -0,0 +1,11 @@
+// WITH_RUNTIME
+
+fun box(): String {
+    val a = Array<Int>(5, {it})
+    val x = a.indices.iterator()
+    while (x.hasNext()) {
+        val i = x.next()
+        if (a[i] != i) return "Fail $i ${a[i]}"
+    }
+    return "OK"
+}
@@ -0,0 +1,11 @@
+// WITH_RUNTIME
+
+fun box(): String {
+    val a = CharArray(5)
+    val x = a.indices.iterator()
+    while (x.hasNext()) {
+        val i = x.next()
+        if (a[i] != 0.toChar()) return "Fail $i ${a[i]}"
+    }
+    return "OK"
+}
@@ -0,0 +1,9 @@
+fun box(): String {
+    val x = Array<Int>(5, { it } ).iterator()
+    var i = 0
+    while (x.hasNext()) {
+        if (x.next() != i) return "Fail $i"
+        i++
+    }
+    return "OK"
+}
@@ -0,0 +1,10 @@
+fun box(): String {
+    val a = BooleanArray(5)
+    val x = a.iterator()
+    var i = 0
+    while (x.hasNext()) {
+        if (a[i] != x.next()) return "Fail $i"
+        i++
+    }
+    return "OK"
+}
@@ -0,0 +1,10 @@
+fun box(): String {
+    val a = ByteArray(5)
+    val x = a.iterator()
+    var i = 0
+    while (x.hasNext()) {
+        if (a[i] != x.next()) return "Fail $i"
+        i++
+    }
+    return "OK"
+}
@@ -0,0 +1,13 @@
+// TODO: muted automatically, investigate should it be ran for JS or not
+// IGNORE_BACKEND: JS
+
+fun box(): String {
+    val a = ByteArray(5)
+    val x = a.iterator()
+    var i = 0
+    while (x.hasNext()) {
+        if (a[i] != x.nextByte()) return "Fail $i"
+        i++
+    }
+    return "OK"
+}
@@ -0,0 +1,10 @@
+fun box(): String {
+    val a = CharArray(5)
+    val x = a.iterator()
+    var i = 0
+    while (x.hasNext()) {
+        if (a[i] != x.next()) return "Fail $i"
+        i++
+    }
+    return "OK"
+}
@@ -0,0 +1,10 @@
+fun box(): String {
+    val a = DoubleArray(5)
+    val x = a.iterator()
+    var i = 0
+    while (x.hasNext()) {
+        if (a[i] != x.next()) return "Fail $i"
+        i++
+    }
+    return "OK"
+}
@@ -0,0 +1,10 @@
+fun box(): String {
+    val a = FloatArray(5)
+    val x = a.iterator()
+    var i = 0
+    while (x.hasNext()) {
+        if (a[i] != x.next()) return "Fail $i"
+        i++
+    }
+    return "OK"
+}
@@ -0,0 +1,10 @@
+fun box(): String {
+    val a = IntArray(5)
+    val x = a.iterator()
+    var i = 0
+    while (x.hasNext()) {
+        if (a[i] != x.next()) return "Fail $i"
+        i++
+    }
+    return "OK"
+}
@@ -0,0 +1,10 @@
+fun box(): String {
+    val a = LongArray(5)
+    val x = a.iterator()
+    var i = 0
+    while (x.hasNext()) {
+        if (a[i] != x.next()) return "Fail $i"
+        i++
+    }
+    return "OK"
+}
@@ -0,0 +1,13 @@
+// TODO: muted automatically, investigate should it be ran for JS or not
+// IGNORE_BACKEND: JS
+
+fun box(): String {
+    val a = LongArray(5)
+    val x = a.iterator()
+    var i = 0
+    while (x.hasNext()) {
+        if (a[i] != x.nextLong()) return "Fail $i"
+        i++
+    }
+    return "OK"
+}
@@ -0,0 +1,10 @@
+fun box(): String {
+    val a = ShortArray(5)
+    val x = a.iterator()
+    var i = 0
+    while (x.hasNext()) {
+        if (a[i] != x.next()) return "Fail $i"
+        i++
+    }
+    return "OK"
+}
@@ -0,0 +1,27 @@
+var result = 0
+
+fun <T> Iterator<T>.foreach(action: (T) -> Unit) {
+    while (this.hasNext()) {
+        (action)(this.next())
+    }
+}
+
+fun <In, Out> Iterator<In>.select(f: (In) -> Out) : Iterator<Out> {
+    return Selector(this, f);
+}
+
+class Selector<In, Out>(val source: Iterator<In>, val f: (In) -> Out) : Iterator<Out> {
+    override fun hasNext(): Boolean = source.hasNext()
+
+    override fun next(): Out {
+        return (f)(source.next())
+    }
+}
+
+fun box(): String {
+    Array(4, { it + 1 }).iterator()
+            .select({i -> i * 10})
+            .foreach({k -> result += k})
+    if (result != 10+20+30+40) return "Fail: $result"
+    return "OK"
+}
@@ -0,0 +1,58 @@
+fun t1 () {
+    val a1 = arrayOfNulls<String>(1)
+    a1[0] = "0" //ok
+    val s = a1[0] //ok
+}
+
+fun t2 () {
+    val a2 = arrayOfNulls<Int>(1) as Array<Int>
+    a2[0] = 0 //ok
+    var i = a2[0] //ok
+}
+
+fun t3 () {
+    val a3 = arrayOfNulls<Int>(1)
+    a3[0] = 0 //verify error
+    var j = a3[0] //ok
+    var k : Int = a3[0] ?: 5 //ok
+}
+
+fun t4 () {
+    val b1 = StrangeIntArray(10)
+    b1[4] = 5 //ok
+    var i = b1[1] //ok
+}
+
+fun t5 () {
+    val b2 = StrangeArray<Int>(10, 0)
+    b2.set(4, 5) //ok
+    b2[4] = 5 //verify error
+    var i = b2.get(2) //ok
+    i = b2[1] //verify error
+}
+
+fun t6() {
+    val b3 = StrangeArray<Int?>(10, 0)
+    b3.set(5, 6) //ok
+    b3[4] = 5 //verify error
+    val v = b3[1] //ok
+}
+
+fun box() : String {
+    return "OK"
+}
+
+class StrangeArray<T>(size: Int, private var defaultValue: T) {
+    operator fun get(index: Int): T = defaultValue
+    operator fun set(index: Int, v: T) {
+        defaultValue = v
+    }
+}
+
+class StrangeIntArray(size: Int) {
+    private var defaultValue = 0
+    operator fun get(index: Int): Int = defaultValue
+    operator fun set(index: Int, v: Int) {
+        defaultValue = v
+    }
+}
@@ -0,0 +1,77 @@
+//KT-2997 Automatically cast error (Array)
+
+fun foo(a: Any): Int {
+    if (a is IntArray) {
+        a.get(0)
+        a.set(0, 1)
+        a.iterator()
+        return a.size
+    }
+    if (a is ShortArray) {
+        a.get(0)
+        a.set(0, 1)
+        a.iterator()
+        return a.size
+    }
+    if (a is ByteArray) {
+        a.get(0)
+        a.set(0, 1)
+        a.iterator()
+        return a.size
+    }
+    if (a is FloatArray) {
+        a.get(0)
+        a.set(0, 1.toFloat())
+        a.iterator()
+        return a.size
+    }
+    if (a is DoubleArray) {
+        a.get(0)
+        a.set(0, 1.0)
+        a.iterator()
+        return a.size
+    }
+    if (a is BooleanArray) {
+        a.get(0)
+        a.set(0, false)
+        a.iterator()
+        return a.size
+    }
+    if (a is CharArray) {
+        a.get(0)
+        a.set(0, 'a')
+        a.iterator()
+        return a.size
+    }
+    if (a is Array<*>) {
+        if (a.size > 0) a.get(0)
+        a.iterator()
+        return a.size
+    }
+
+    return 0
+}
+
+fun box(): String {
+    val iA = IntArray(1)
+    if (foo(iA) != 1) return "fail int[]"
+    val sA = ShortArray(1)
+    if (foo(sA) != 1) return "fail short[]"
+    val bA = ByteArray(1)
+    if (foo(bA) != 1) return "fail byte[]"
+    val fA = FloatArray(1)
+    if (foo(fA) != 1) return "fail float[]"
+    val dA = DoubleArray(1)
+    if (foo(dA) != 1) return "fail double[]"
+    val boolA = BooleanArray(1)
+    if (foo(boolA) != 1) return "fail boolean[]"
+    val cA = CharArray(1)
+    if (foo(cA) != 1) return "fail char[]"
+    val oA = arrayOfNulls<Int>(1)
+    if (foo(oA) != 1) return "fail Any[]"
+
+    val sArray = arrayOfNulls<String>(0)
+    if (foo(sArray) != 0) return "fail String[]"
+
+    return "OK"
+}
@@ -0,0 +1,6 @@
+fun box () : String {
+    val s = ArrayList<String>()
+    s.add("foo")
+    s[0] += "bar"
+    return if(s[0] == "foobar") "OK" else "fail"
+}
@@ -0,0 +1,14 @@
+fun fill(dest : Array<in String>, v : String) {
+    dest[0] = v
+}
+
+fun box() : String {
+//fun main(args : Array<String>) {
+    val s : String = "bar"
+    val any : Array<Any> = arrayOf(1, "foo", 1.234)
+    fill(any, s)
+    /* shouldn't throw
+ClassCastException: [Ljava.lang.Object; cannot be cast to [Ljava.lang.String;
+     */
+    return "OK"
+}
@@ -0,0 +1,94 @@
+fun Array<String>.test1(): Array<String> {
+    val func = { i:Int  -> this}
+    return func(1)
+}
+
+fun Array<String>.test1Nested(): Array<String> {
+    val func = { i: Int -> { this }()}
+    return func(1)
+}
+
+
+fun Array<String>.test2() : Array<String> {
+    class Z2() {
+        fun run(): Array<String> {
+            return this@test2
+        }
+    }
+    return Z2().run()
+}
+
+fun Array<String>.test2Nested() : Array<String> {
+    class Z2() {
+        fun run(): Array<String> {
+            class Z3 {
+                fun run(): Array<String> {
+                   return this@test2Nested;
+                }
+            }
+            return Z3().run()
+        }
+    }
+    return Z2().run()
+}
+
+fun Array<String>.test3(): Array<String> {
+    fun local(): Array<String> {
+        return this@test3
+    }
+    return local()
+}
+
+fun Array<String>.test3Nested(): Array<String> {
+    fun local(): Array<String> {
+        fun local2(): Array<String> {
+            return this@test3Nested
+        }
+        return local2()
+    }
+    return local()
+}
+
+
+fun Array<String>.test4() : Array<String> {
+    return object {
+                fun run() : Array<String> {
+                    return this@test4
+                }
+            }.run()
+}
+
+fun Array<String>.test4Nested() : Array<String> {
+    return object {
+        fun run() : Array<String> {
+            return object {
+                fun run() : Array<String> {
+                    return this@test4Nested
+                }
+            }.run()
+        }
+    }.run()
+}
+
+fun Array<DoubleArray>.test1(): Array<DoubleArray> {
+    val func = { i: Int -> this}
+    return func(1)
+}
+
+
+fun box() : String {
+    val array = Array<String>(2, { i -> "${i}" })
+    if (array != array.test1()) return "fail 1"
+    if (array != array.test2()) return "fail 2"
+    if (array != array.test3()) return "fail 3"
+    if (array != array.test4()) return "fail 4"
+
+    if (array != array.test1Nested()) return "fail 1Nested"
+    if (array != array.test2Nested()) return "fail 2Nested"
+    if (array != array.test3Nested()) return "fail 3Nested"
+    if (array != array.test4Nested()) return "fail 4Nested"
+
+    val array2 = Array<DoubleArray>(2, { i -> DoubleArray(i) })
+    if (array2 != array2.test1()) return "fail on array of double []"
+    return "OK"
+}
@@ -0,0 +1,17 @@
+operator fun String.get(vararg value: Any) : String {
+    return if (value[0] == 44 && value[1] == "example") "OK" else "fail"
+}
+
+operator fun Int.get(vararg value: Any) : Int {
+    return if (value[0] == 44 && value[1] == "example") 1 else 0
+}
+fun main(args: Array<String>) {
+    12  [44, "example"]
+}
+
+fun box(): String {
+    if ("foo" [44, "example"] != "OK") return "fail1"
+    if (11 [44, "example"] != 1) return "fail2"
+
+    return "OK"
+}
@@ -0,0 +1,8 @@
+fun box(): String {
+    val array = intArrayOf(11, 12, 13)
+    val p = array.get(0)
+    if (p != 11) return "fail 1: $p"
+
+    val stringArray = arrayOf("OK", "FAIL")
+    return stringArray.get(0)
+}
@@ -0,0 +1,32 @@
+// TODO: muted automatically, investigate should it be ran for JS or not
+// IGNORE_BACKEND: JS
+
+fun iarr(vararg a : Int) = a
+fun <T> array(vararg a : T) = a
+
+fun box() : String {
+    val tests = array<IntArray>(
+        iarr(6, 5, 4, 3, 2, 1),
+        iarr(1, 2),
+        iarr(1, 2, 3),
+        iarr(1, 2, 3, 4),
+        iarr(1)
+    )
+
+    var n = 0
+
+    try {
+        var i = 0
+        while (true) {
+            if (thirdElementIsThree(tests[i++]))
+              n++
+        }
+    }
+    catch (e : ArrayIndexOutOfBoundsException) {
+        // No more tests to process
+    }
+    return if(n == 2) "OK" else "fail"
+}
+
+fun thirdElementIsThree(a : IntArray) =
+    a.size >= 3 && a[2] == 3
@@ -0,0 +1,16 @@
+package array_test
+
+fun box() : String {
+    var array : IntArray? = IntArray(10)
+    array?.set(0, 3)
+    if(array?.get(0) != 3) return "fail"
+
+    var a = arrayOfNulls<Array<String?>>(5)
+    var b = arrayOfNulls<String>(1)
+    b.set(0, "239")
+    a?.set(0, b)
+
+    if(a?.get(0)?.get(0) != "239") return "fail"
+
+    return "OK"
+}
@@ -0,0 +1,6 @@
+// TODO: muted automatically, investigate should it be ran for JS or not
+// IGNORE_BACKEND: JS
+
+// WITH_RUNTIME
+
+fun box() = if(arrayOfNulls<Int>(10).isArrayOf<java.lang.Integer>()) "OK" else "fail"
@@ -0,0 +1,6 @@
+// WITH_RUNTIME
+
+fun box() : String {
+    val value = (1 to doubleArrayOf(1.0)).second[0]
+    return if (value == 1.0) "OK" else "fail"
+}
@@ -0,0 +1,32 @@
+// TODO: muted automatically, investigate should it be ran for JS or not
+// IGNORE_BACKEND: JS
+
+fun test(b: Boolean): String {
+    val a = if (b) IntArray(5) else LongArray(5)
+    if (a is IntArray) {
+        val x = a.iterator()
+        var i = 0
+        while (x.hasNext()) {
+            if (a[i] != x.next()) return "Fail $i"
+            i++
+        }
+        return "OK"
+    } else if (a is LongArray) {
+        val x = a.iterator()
+        var i = 0
+        while (x.hasNext()) {
+            if (a[i] != x.next()) return "Fail $i"
+            i++
+        }
+        return "OK"
+    }
+    return "fail"
+}
+
+fun box(): String {
+    if (test(true) != "OK") return "fail 1: ${test(true)}"
+
+    if (test(false) != "OK") return "fail 1: ${test(false)}"
+
+    return "OK"
+}
@@ -0,0 +1,12 @@
+// TODO: muted automatically, investigate should it be ran for JS or not
+// IGNORE_BACKEND: JS
+
+// WITH_RUNTIME
+
+fun foo(x : Any): String {
+    return if(x is Array<*> && x.isArrayOf<String>()) (x as Array<String>)[0] else "fail"
+}
+
+fun box(): String {
+    return foo(arrayOf("OK"))
+}
@@ -0,0 +1,3 @@
+val <T> Array<T>.length : Int get() = this.size
+
+fun box() = if(arrayOfNulls<Int>(10).length == 10) "OK" else "fail"
@@ -0,0 +1,9 @@
+fun box() : String {
+    val data = Array<Array<Boolean>>(3) { Array<Boolean>(4, {false}) }
+    for(d in data) {
+        if(d.size != 4) return "fail"
+        for(b in d) if (b) return "fail"
+    }
+
+    return "OK"
+}
@@ -0,0 +1,7 @@
+operator fun <K, V> MutableMap<K, V>.set(k : K, v : V) = put(k, v)
+
+fun box() : String {
+    val map = HashMap<String,String>()
+    map["239"] = "932"
+    return if(map["239"] == "932") "OK" else "fail"
+}
@@ -0,0 +1,9 @@
+operator fun IntArray.set(index: Long, elem: Int) { this[index.toInt()] = elem }
+operator fun IntArray.get(index: Long) = this[index.toInt()]
+
+fun box(): String {
+    var l = IntArray(1)
+    l[0.toLong()] = 4
+    l[0.toLong()] += 6
+    return if (l[0.toLong()] == 10) "OK" else "Fail"
+}
@@ -0,0 +1,31 @@
+// WITH_RUNTIME
+
+import kotlin.test.assertEquals
+
+fun stringMultiArray(): Array<Array<String>> = Array(3) {
+    i -> Array(3) { j -> "$i-$j" }
+}
+
+fun stringNullableMultiArray(): Array<Array<String?>> = Array(3) {
+    i -> if (i == 1) Array(3) { j -> "$i-$j" } as Array<String?> else arrayOfNulls<String>(3)
+}
+
+fun box(): String {
+    val matrix = stringMultiArray()
+
+    for (i in 0..2) {
+        for (j in 0..2) {
+            assertEquals("$i-$j", matrix[i][j], "matrix")
+        }
+    }
+
+    val matrixNullable = stringNullableMultiArray()
+
+    for (j in 0..2) {
+        assertEquals(null, matrixNullable[0][j], "nullable")
+        assertEquals("1-$j", matrixNullable[1][j], "nullable")
+        assertEquals(null, matrixNullable[2][j], "nullable")
+    }
+
+    return "OK"
+}
@@ -0,0 +1,18 @@
+class C(val i: Int) {
+  operator fun component1() = i + 1
+  operator fun component2() = i + 2
+}
+
+fun doTest(l : Array<C>): String {
+    var s = ""
+    for ((a, b) in l) {
+      s += "$a:$b;"
+    }
+    return s
+}
+
+fun box(): String {
+  val l = Array<C>(3, {x -> C(x)})
+  val s = doTest(l)
+  return if (s == "1:2;2:3;3:4;") "OK" else "fail: $s"
+}
@@ -0,0 +1,19 @@
+class C(val i: Int) {
+}
+
+operator fun C.component1() = i + 1
+operator fun C.component2() = i + 2
+
+fun doTest(l : Array<C>): String {
+    var s = ""
+    for ((a, b) in l) {
+      s += "$a:$b;"
+    }
+    return s
+}
+
+fun box(): String {
+  val l = Array<C>(3, {x -> C(x)})
+  val s = doTest(l)
+  return if (s == "1:2;2:3;3:4;") "OK" else "fail: $s"
+}
@@ -0,0 +1,21 @@
+class C(val i: Int) {
+}
+
+class M {
+  operator fun C.component1() = i + 1
+  operator fun C.component2() = i + 2
+
+  fun doTest(l : Array<C>): String {
+      var s = ""
+      for ((a, b) in l) {
+        s += "$a:$b;"
+      }
+      return s
+  }
+}
+
+fun box(): String {
+  val l = Array<C>(3, {x -> C(x)})
+  val s = M().doTest(l)
+  return if (s == "1:2;2:3;3:4;") "OK" else "fail: $s"
+}
@@ -0,0 +1,21 @@
+class C(val i: Int) {
+}
+
+class M {
+  operator fun C.component1() = i + 1
+  operator fun C.component2() = i + 2
+}
+
+fun M.doTest(l : Array<C>): String {
+    var s = ""
+    for ((a, b) in l) {
+      s += "$a:$b;"
+    }
+    return s
+}
+
+fun box(): String {
+  val l = Array<C>(3, {x -> C(x)})
+  val s = M().doTest(l)
+  return if (s == "1:2;2:3;3:4;") "OK" else "fail: $s"
+}
@@ -0,0 +1,18 @@
+class C(val i: Int) {
+  operator fun component1() = i + 1
+  operator fun component2() = i + 2
+}
+
+fun doTest(l : Array<C>): String {
+    var s = ""
+    for ((a, b) in l) {
+      s += {"$a:$b;"}()
+    }
+    return s
+}
+
+fun box(): String {
+  val l = Array<C>(3, {x -> C(x)})
+  val s = doTest(l)
+  return if (s == "1:2;2:3;3:4;") "OK" else "fail: $s"
+}
@@ -0,0 +1,16 @@
+operator fun Int.component1() = this + 1
+operator fun Int.component2() = this + 2
+
+fun doTest(l : Array<Int>): String {
+    var s = ""
+    for ((a, b) in l) {
+      s += "$a:$b;"
+    }
+    return s
+}
+
+fun box(): String {
+  val l = Array<Int>(3, {x -> x})
+  val s = doTest(l)
+  return if (s == "1:2;2:3;3:4;") "OK" else "fail: $s"
+}
@@ -0,0 +1,16 @@
+operator fun Int.component1() = this + 1
+operator fun Int.component2() = this + 2
+
+fun doTest(l : Array<Int>): String {
+    var s = ""
+    for ((a, b) in l) {
+      s += {"$a:$b;"}()
+    }
+    return s
+}
+
+fun box(): String {
+  val l = Array<Int>(3, {x -> x})
+  val s = doTest(l)
+  return if (s == "1:2;2:3;3:4;") "OK" else "fail: $s"
+}
@@ -0,0 +1,18 @@
+class M {
+  operator fun Int.component1() = this + 1
+  operator fun Int.component2() = this + 2
+
+  fun doTest(l : Array<Int>): String {
+      var s = ""
+      for ((a, b) in l) {
+        s += "$a:$b;"
+      }
+      return s
+  }
+}
+
+fun box(): String {
+  val l = Array<Int>(3, {x -> x})
+  val s = M().doTest(l)
+  return if (s == "1:2;2:3;3:4;") "OK" else "fail: $s"
+}
@@ -0,0 +1,18 @@
+class M {
+  operator fun Int.component1() = this + 1
+  operator fun Int.component2() = this + 2
+}
+
+fun M.doTest(l : Array<Int>): String {
+    var s = ""
+    for ((a, b) in l) {
+      s += "$a:$b;"
+    }
+    return s
+}
+
+fun box(): String {
+  val l = Array<Int>(3, {x -> x})
+  val s = M().doTest(l)
+  return if (s == "1:2;2:3;3:4;") "OK" else "fail: $s"
+}
@@ -0,0 +1,16 @@
+operator fun Long.component1() = this + 1
+operator fun Long.component2() = this + 2
+
+fun doTest(l : Array<Long>): String {
+    var s = ""
+    for ((a, b) in l) {
+      s += "$a:$b;"
+    }
+    return s
+}
+
+fun box(): String {
+  val l = Array<Long>(3, {x -> x.toLong()})
+  val s = doTest(l)
+  return if (s == "1:2;2:3;3:4;") "OK" else "fail: $s"
+}
@@ -0,0 +1,16 @@
+operator fun Long.component1() = this + 1
+operator fun Long.component2() = this + 2
+
+fun doTest(l : Array<Long>): String {
+    var s = ""
+    for ((a, b) in l) {
+      s += {"$a:$b;"}()
+    }
+    return s
+}
+
+fun box(): String {
+  val l = Array<Long>(3, {x -> x.toLong()})
+  val s = doTest(l)
+  return if (s == "1:2;2:3;3:4;") "OK" else "fail: $s"
+}
@@ -0,0 +1,18 @@
+class M {
+  operator fun Long.component1() = this + 1
+  operator fun Long.component2() = this + 2
+
+  fun doTest(l : Array<Long>): String {
+      var s = ""
+      for ((a, b) in l) {
+        s += "$a:$b;"
+      }
+      return s
+  }
+}
+
+fun box(): String {
+  val l = Array<Long>(3, {x -> x.toLong()})
+  val s = M().doTest(l)
+  return if (s == "1:2;2:3;3:4;") "OK" else "fail: $s"
+}
@@ -0,0 +1,18 @@
+class M {
+  operator fun Long.component1() = this + 1
+  operator fun Long.component2() = this + 2
+}
+
+fun M.doTest(l : Array<Long>): String {
+    var s = ""
+    for ((a, b) in l) {
+      s += "$a:$b;"
+    }
+    return s
+}
+
+fun box(): String {
+  val l = Array<Long>(3, {x -> x.toLong()})
+  val s = M().doTest(l)
+  return if (s == "1:2;2:3;3:4;") "OK" else "fail: $s"
+}
@@ -0,0 +1,24 @@
+// TODO: muted automatically, investigate should it be ran for JS or not
+// IGNORE_BACKEND: JS
+
+fun testArray() {
+    Array<String>(5) { i ->
+        if (i == 3) return
+        i.toString()
+    }
+    throw AssertionError()
+}
+
+fun testIntArray() {
+    IntArray(5) { i ->
+        if (i == 3) return
+        i
+    }
+    throw AssertionError()
+}
+
+fun box(): String {
+    testArray()
+    testIntArray()
+    return "OK"
+}
@@ -0,0 +1,8 @@
+class A() {
+    class B(val i: Int) {
+    }
+
+    fun test() = Array<B> (10, { B(it) })
+}
+
+fun box() = if(A().test()[5].i == 5) "OK" else "fail"
@@ -0,0 +1,56 @@
+interface ISized {
+    val size : Int
+}
+
+interface javaUtilIterator<T> : Iterator<T> {
+    fun remove() : Unit {
+        throw UnsupportedOperationException()
+    }
+}
+
+class MyIterator<T>(val array : ReadOnlyArray<T>) : javaUtilIterator<T> {
+    private var index = 0
+
+    override fun hasNext() : Boolean = index < array.size
+
+    override fun next() : T = array.get(index++)
+}
+
+interface ReadOnlyArray<out T> : ISized, Iterable<T> {
+  operator fun get(index : Int) : T
+
+  override fun iterator() : Iterator<T> = MyIterator<T>(this)
+}
+
+interface WriteOnlyArray<in T> : ISized {
+  operator fun set(index : Int, value : T) : Unit
+
+  operator fun set(from: Int, count: Int, value: T) {
+    for(i in from..from+count-1) {
+        set(i, value)
+    }
+  }
+}
+
+class MutableArray<T>(length: Int, init : (Int) -> T) : ReadOnlyArray<T>, WriteOnlyArray<T> {
+    private val array = Array<Any?>(length, init)
+
+    override fun get(index : Int) : T = array[index] as T
+    override fun set(index : Int, value : T) : Unit { array[index] = value }
+
+    override val size : Int
+        get() = array.size
+}
+
+fun box() : String {
+    var a = MutableArray<Int> (4, {0})
+    a [0] = 10
+    a.set(1, 2, 13)
+    a [3] = 40
+    a.iterator()
+    a.iterator().hasNext()
+    for(el in a) {
+        val fl = el
+    }
+    return "OK"
+}