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"
+}
@@ -0,0 +1,110 @@
+class MyNumber(val i: Int) {
+    fun inc(): MyNumber = MyNumber(i+1)
+}
+
+class MNR(var ref: MyNumber) {}
+
+fun test1() : Boolean {
+    var m  = MyNumber(42)
+
+    m++
+    if (m.i != 43) return false
+    return true
+}
+
+fun test2() : Boolean {
+    var m  = MyNumber(44)
+
+    var m2 = m++
+    if (m2.i != 44) return false
+    if (m.i  != 45) return false
+    return true
+}
+
+fun test3() : Boolean {
+    var mnr  = MNR(MyNumber(42))
+    mnr.ref++
+    if (mnr.ref.i != 43) return false
+    return true
+}
+
+fun test4() : Boolean {
+    var mnr  = MNR(MyNumber(42))
+    val m3 = mnr.ref++
+    if (m3.i  != 42) return false
+    return true
+}
+
+fun test5() : Boolean {
+    var mnr  = Array<MyNumber>(2,{MyNumber(42)})
+    mnr[0]++
+    if (mnr[0].i  != 43) return false
+    return true
+}
+
+fun test6() : Boolean {
+    var mnr  = Array<MyNumber>(2,{it -> MyNumber(42-it)})
+    mnr[1] = mnr[0]++
+    if (mnr[0].i  != 43) return false
+    if (mnr[1].i  != 42) return false
+    return true
+}
+
+// ArrayList without jdk-annotations cannot be used in these tests
+class MyArrayList<T>() {
+    private var value17: T? = null
+    private var value39: T? = null
+    fun get(index: Int): T {
+        if (index == 17) return value17!!
+        if (index == 39) return value39!!
+        throw Exception()
+    }
+    fun set(index: Int, value: T): T? {
+        if (index == 17) value17 = value
+        else if (index == 39) value39 = value
+        else throw Exception()
+        return null
+    }
+}
+
+fun test7() : Boolean {
+    var mnr  = MyArrayList<MyNumber>()
+    mnr[17] = MyNumber(42)
+    mnr[17]++
+    if (mnr[17].i  != 43) return false
+    return true
+}
+
+fun test8() : Boolean {
+    var mnr  = MyArrayList<MyNumber>()
+    mnr[17] = MyNumber(42)
+    mnr[39] = mnr[17]++
+    if (mnr[17].i  != 43) return false
+    if (mnr[39].i  != 42) return false
+    return true
+}
+
+
+fun box() : String {
+    var m  = MyNumber(42)
+
+    if (!test1()) return "fail test 1"
+    if (!test2()) return "fail test 2"
+    if (!test3()) return "fail test 3"
+    if (!test4()) return "fail test 4"
+
+    if (!test5()) return "fail test 5"
+    if (!test6()) return "fail test 6"
+    if (!test7()) return "fail test 7"
+    if (!test8()) return "fail test 8"
+
+
+    ++m
+    if (m.i != 43) return "fail 0"
+
+    var m1 = ++m
+    if (m1.i != 44) return "fail 3"
+    if (m.i  != 44) return "fail 4"
+
+    return "OK"
+}
@@ -0,0 +1,26 @@
+class mInt(val i : Int) {
+    override fun toString() : String = "mint: $i"
+    fun plus(i : Int) = mInt(this.i + i)
+    fun inc() = mInt(i + 1)
+}
+
+class MyArray() {
+    val a = Array<mInt>(10, {mInt(0)})
+    fun get(i : mInt) : mInt = a[i.i]
+    fun set(i : mInt, v : mInt) {
+        a[i.i] = v
+    }
+}
+
+fun box() : String {
+    val a = MyArray()
+    var i = mInt(0)
+      System.out?.println(i)
+    a[i++]// = mInt(1)
+      System.out?.println(i)
+    a[i++] = mInt(1)
+      System.out?.println(i)
+    for (i in 0..9)
+      System.out?.println("ar: ${a[mInt(i)]}")
+    return "OK"
+}
@@ -0,0 +1,18 @@
+class C(val i: Int) {
+  fun component1() = i + 1
+  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) {
+}
+
+fun C.component1() = i + 1
+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 {
+  fun C.component1() = i + 1
+  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 {
+  fun C.component1() = i + 1
+  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) {
+  fun component1() = i + 1
+  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 @@
+fun Int.component1() = this + 1
+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 @@
+fun Int.component1() = this + 1
+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 {
+  fun Int.component1() = this + 1
+  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 {
+  fun Int.component1() = this + 1
+  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 @@
+fun Long.component1() = this + 1
+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 @@
+fun Long.component1() = this + 1
+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 {
+  fun Long.component1() = this + 1
+  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 {
+  fun Long.component1() = this + 1
+  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"
+}