Move some tests from boxWithStdlib/ to box/

Move those tests which do not require neither stdlib nor reflect

compiler/testData/codegen/box/arrays/arrayGetAssignMultiIndex.kt

@@ -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]
+}

compiler/testData/codegen/box/arrays/arrayGetMultiIndex.kt

@@ -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]
+}
+ 

compiler/testData/codegen/box/arrays/cloneArray.kt

@@ -0,0 +1,15 @@
+import java.util.Arrays.equals
+
+fun box(): String {
+    val s = arrayOf("live", "long")
+    val t: Array<String> = s.clone()
+    if (!equals(s, t)) return "Fail string"
+    if (s === t) return "Fail string identity"
+
+    val ss = arrayOf(s, s)
+    val tt: Array<Array<String>> = ss.clone()
+    if (!equals(ss, tt)) return "Fail string[]"
+    if (ss === tt) return "Fail string[] identity"
+
+    return "OK"
+}

compiler/testData/codegen/box/arrays/clonePrimitiveArrays.kt

@@ -0,0 +1,37 @@
+import java.util.Arrays.equals
+
+fun box(): String {
+    val i = intArrayOf(1, 2)
+    if (!equals(i, i.clone())) return "Fail int"
+    if (i.clone() === i) return "Fail int identity"
+
+    val j = longArrayOf(1L, 2L)
+    if (!equals(j, j.clone())) return "Fail long"
+    if (j.clone() === j) return "Fail long identity"
+
+    val s = shortArrayOf(1.toShort(), 2.toShort())
+    if (!equals(s, s.clone())) return "Fail short"
+    if (s.clone() === s) return "Fail short identity"
+
+    val b = byteArrayOf(1.toByte(), 2.toByte())
+    if (!equals(b, b.clone())) return "Fail byte"
+    if (b.clone() === b) return "Fail byte identity"
+
+    val c = charArrayOf('a', 'b')
+    if (!equals(c, c.clone())) return "Fail char"
+    if (c.clone() === c) return "Fail char identity"
+
+    val d = doubleArrayOf(1.0, -1.0)
+    if (!equals(d, d.clone())) return "Fail double"
+    if (d.clone() === d) return "Fail double identity"
+
+    val f = floatArrayOf(1f, -1f)
+    if (!equals(f, f.clone())) return "Fail float"
+    if (f.clone() === f) return "Fail float identity"
+
+    val z = booleanArrayOf(true, false)
+    if (!equals(z, z.clone())) return "Fail boolean"
+    if (z.clone() === z) return "Fail boolean identity"
+
+    return "OK"
+}

compiler/testData/codegen/box/arrays/inProjectionAsParameter.kt

@@ -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
+}

compiler/testData/codegen/box/arrays/inProjectionOfArray.kt

@@ -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
+}

compiler/testData/codegen/box/arrays/iterator.kt

@@ -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"
+}

compiler/testData/codegen/box/arrays/kt1291.kt

@@ -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"
+}

compiler/testData/codegen/box/arrays/kt3771.kt

@@ -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"
+}

compiler/testData/codegen/box/arrays/kt4118.kt

@@ -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"
+}

compiler/testData/codegen/box/arrays/kt4357.kt

@@ -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)
+}

compiler/testData/codegen/box/arrays/kt945.kt

@@ -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"
+}

compiler/testData/codegen/box/arrays/multiDecl/MultiDeclFor.kt

@@ -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"
+}

compiler/testData/codegen/box/arrays/multiDecl/MultiDeclForComponentExtensions.kt

@@ -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"
+}

compiler/testData/codegen/box/arrays/multiDecl/MultiDeclForComponentMemberExtensions.kt

@@ -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"
+}

compiler/testData/codegen/box/arrays/multiDecl/MultiDeclForComponentMemberExtensionsInExtensionFunction.kt

@@ -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"
+}

compiler/testData/codegen/box/arrays/multiDecl/MultiDeclForValCaptured.kt

@@ -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"
+}

compiler/testData/codegen/box/arrays/multiDecl/int/MultiDeclForComponentExtensions.kt

@@ -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"
+}

compiler/testData/codegen/box/arrays/multiDecl/int/MultiDeclForComponentExtensionsValCaptured.kt

@@ -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"
+}

compiler/testData/codegen/box/arrays/multiDecl/int/MultiDeclForComponentMemberExtensions.kt

@@ -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"
+}

compiler/testData/codegen/box/arrays/multiDecl/int/MultiDeclForComponentMemberExtensionsInExtensionFunction.kt

@@ -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"
+}

compiler/testData/codegen/box/arrays/multiDecl/long/MultiDeclForComponentExtensions.kt

@@ -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"
+}

compiler/testData/codegen/box/arrays/multiDecl/long/MultiDeclForComponentExtensionsValCaptured.kt

@@ -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"
+}

compiler/testData/codegen/box/arrays/multiDecl/long/MultiDeclForComponentMemberExtensions.kt

@@ -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"
+}

compiler/testData/codegen/box/arrays/multiDecl/long/MultiDeclForComponentMemberExtensionsInExtensionFunction.kt

@@ -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"
+}

compiler/testData/codegen/box/arrays/nonLocalReturnArrayConstructor.kt

@@ -0,0 +1,21 @@
+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"
+}

compiler/testData/codegen/box/arrays/nonNullArray.kt

@@ -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"

compiler/testData/codegen/box/arrays/stdlib.kt

@@ -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"
+}