Refactored tests using Array constructor:

Some moved to tests with stdlib Some changed to use arrayOfNulls
2014-12-11 10:45:15 +03:00
parent abbcf61183
commit 654411a0b0
68 changed files with 266 additions and 253 deletions
@@ -0,0 +1,11 @@
+fun Array<String>.get(index1: Int, index2: Int) = this[index1 + index2]
+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 @@
+fun Array<String>.get(index1: Int, index2: Int) = this[index1 + index2]
+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,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,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,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,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,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 @@
+trait ISized {
+    val size : Int
+}
+
+trait 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++)
+}
+
+trait ReadOnlyArray<out T> : ISized, Iterable<T> {
+  fun get(index : Int) : T
+
+  override fun iterator() : Iterator<T> = MyIterator<T>(this)
+}
+
+trait WriteOnlyArray<in T> : ISized {
+  fun set(index : Int, value : T) : Unit
+
+  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"
+}