separate compiler and plugin tests

2011-10-20 16:19:02 +02:00
parent a80398098b
commit ec6dec0d37
586 changed files with 69 additions and 42 deletions
@@ -0,0 +1,10 @@
+class A() {
+    fun foo() {
+        System.out?.println(1)
+    }
+}
+
+fun box() : String {
+    val a : A = A()
+    return "OK"
+}
@@ -0,0 +1,41 @@
+fun main(args: Array<String>?) {
+    val y: Unit = () //do not compile
+    A<Unit>()        //do not compile
+    C<Unit>(())      //do not compile
+        //do not compile
+    System.out?.println(fff<Unit>(()))  //do not compile
+    System.out?.println(id<Unit>(y))  //do not compile
+    System.out?.println(fff<Unit>(id<Unit>(y)) == id<Unit>(foreach(Array<Int>(0,{0}),{(e : Int) : Unit => })))  //do not compile
+}
+class A<T>()
+
+class C<T>(val value: T) {
+    fun foo(): T = value
+}
+
+fun <T> fff(x: T) : T { return x }
+
+fun <T> id(value: T): T = value
+
+fun foreach(array: Array<Int>?, action: fun(Int): Unit) {
+    for (el in array) {
+       action(el) //exception through compilation (see below)
+    }
+}
+
+fun almostFilter(array: Array<Int>, action: fun(Int): Int) {
+    for (el in array) {
+       action(el)
+    }
+}
+
+fun box() : String {
+    val a = Array<Int> (3,{-1})
+    a[0] = 0
+    a[1] = 1
+    a[2] = 2
+    foreach(a, { (el : Int) : Unit => System.out?.println(el) })
+    almostFilter(a, { (el : Int) : Int => el })
+    main(null)
+    return "OK"
+}
@@ -0,0 +1,58 @@
+fun t1 () {
+    val a1 = Array<String?>(1)
+    a1[0] = "0" //ok
+    val s = a1[0] //ok
+}
+
+fun t2 () {
+    val a2 = Array<Int>(1,{0})
+    a2[0] = 0 //ok
+    var i = a2[0] //ok
+}
+
+fun t3 () {
+    val a3 = Array<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) {
+    fun get(index: Int): T = defaultValue
+    fun set(index: Int, v: T) {
+        defaultValue = v
+    }
+}
+
+class StrangeIntArray(size: Int) {
+    private var defaultValue = 0
+    fun get(index: Int): Int = defaultValue
+    fun set(index: Int, v: Int) {
+        defaultValue = v
+    }
+}
@@ -0,0 +1,3 @@
+fun box(i: Int?) {
+    val j = i?.plus(3) //verify error
+}
@@ -0,0 +1,19 @@
+fun box() : String {
+    val i: Int? = 7
+    val j: Int? = null
+    val k = 7
+
+    //verify errors
+    if (i == 7) {}
+    if (7 == i) {}
+
+    if (j == 7) {}
+    if (7 == j) {}
+
+    if (i == k) {}
+    if (k == i) {}
+
+    if (j == k) {}
+    if (k == j) {}
+    return "OK"
+}
@@ -0,0 +1,8 @@
+fun box() : String {
+    val t = java.lang.String.copyValueOf(java.lang.String("s").toCharArray())
+    val i = java.lang.Integer.MAX_VALUE
+    val j = java.lang.Integer.valueOf(15)
+    val s = java.lang.String.valueOf(1)
+    val l = java.util.Collections.emptyList<Int>()
+    return "OK"
+}
@@ -0,0 +1,32 @@
+fun foo() {
+    val l = java.util.ArrayList<Int>(2)
+    l.add(1)
+
+    for (el in l) {}
+
+    //verify error "Expecting to find integer on stack"
+    val iterator = l.iterator()
+
+    //another verify error "Mismatched stack types"
+    while (iterator?.hasNext() ?: false) {
+        val i = iterator?.next()
+    }
+
+    //the same
+    if (iterator != null) {
+        while (iterator.hasNext()) {
+            val i = iterator?.next()
+        }
+    }
+
+    //this way it works
+    if (iterator != null) {
+        while (iterator.hasNext()) {
+            iterator.next() //because of the bug KT-244 i can't write "val i = iterator.next()"
+        }
+    }
+}
+
+fun box() : String {
+    return "OK"
+}
@@ -0,0 +1,38 @@
+fun t1() : Boolean {
+    val s1 : String? = "sff"
+    val s2 : String? = null
+    return s1?.length == 3 && s2?.length == null
+}
+
+fun t2() : Boolean {
+    val c1: C? = C(1)
+    val c2: C? = null
+    return c1?.x == 1 && c2?.x == null
+}
+
+fun t3() {
+    val d: D = D("s")
+    System.out?.println(d?.s)
+    System.out?.println(d?.s == "s") //prints true
+    System.out?.println(d)    //ok
+}
+
+fun t4() {
+    val e: E? = E()
+    System.out?.println(e?.foo() == e) //verify error
+    System.out?.println(e?.foo())  //verify error
+}
+
+fun box() : String {
+    if(!t1 ()) return "fail"
+    if(!t2 ()) return "fail"
+    t3()
+    t4()
+    return "OK"
+}
+
+class C(val x: Int)
+class D(val s: String)
+class E() {
+    fun foo() = 1
+}
@@ -0,0 +1,7 @@
+fun box() : String {
+    val b = true as? Boolean //exception
+    val i = 1 as Int         //exception
+    val j = 1 as Int?        //ok
+    val s = "s" as String    //ok
+    return "OK"
+}
@@ -0,0 +1,35 @@
+namespace x
+
+class Outer(val name: String) {
+    class Inner() {
+        val me = name
+
+        class object {
+           fun bar() = "bar"
+        }
+    }
+
+    class object {
+        class StaticInner() {
+            class object {
+                fun f() = "oo"
+            }
+        }
+    }
+}
+
+fun box (): String {
+    val inner  = Outer("mama").Inner() //verify error
+    if(inner.me != "mama")
+        return "fail"
+
+    val outer = Outer ("papa")
+    val inner2 = outer.Inner ()
+    if(inner2.me != "papa")
+        return "fail"
+
+    if(Outer.StaticInner.f() != "oo" )
+        return "fail"
+
+    return "OK"
+}
@@ -0,0 +1,20 @@
+class A<T>(var t: T) {}
+class B<R>(val r: R) {}
+
+fun box() : String {
+    val ai = A<Int>(1)
+    val aai = A<A<Int>>(ai)
+    if(aai.t.t != 1)  return "fail"
+/*
+    aai.t.t = 2
+    if(aai.t.t != 2)  return "fail"
+
+    if(ai.t != 2)  return "fail"
+    if(aai.t != ai)  return "fail"
+    if(aai.t !== ai) return "fail"
+
+    val abi = A<B<Int>>(B<Int>(1))
+    if(abi.t.r != 1) return "fail"
+*/
+    return "OK"
+}
@@ -0,0 +1,251 @@
+class A() {}
+open class B<T>() {
+    fun isT (a : Any?) : Boolean {
+        return a is T
+    }
+}
+
+class C() : B<String>() {
+}
+
+class D<T>() : B<B<T>>() {
+}
+
+fun t1() : Boolean {
+    val a = A()
+    if(a !is A)   return false
+    return true
+}
+
+fun t2() : Boolean {
+    val a = A()
+    if(a !is A?)   return false
+    return true
+}
+
+fun t3() : Boolean {
+    val a = A()
+    if(null !is A?)   return false
+    return true
+}
+
+fun t4 () : Boolean {
+    val b = B<String>()
+    if(b !is B<String>)   return false
+    return true
+}
+
+fun t5 () : Boolean {
+    val b = B<String>()
+    if(b !is B<String>?)  return false
+    return true
+}
+
+fun t6 () : Boolean {
+    if(null !is B<String>?)  return false
+    return true
+}
+
+fun t7 () : Boolean {
+    val b = B<String>()
+    if(!b.isT("aaa")) return false
+    return true
+}
+
+fun t8 () : Boolean {
+    val b = B<String>()
+    if(b.isT(10))     return false
+    return true
+}
+
+fun t9 () : Boolean {
+    val b = B<String>()
+    if(b.isT(null))   return false
+    return true
+}
+
+fun t10 () : Boolean {
+    val d = B<String?>()
+    if(!d.isT("aaa")) return false
+    return true
+}
+fun t11 () : Boolean {
+    val d = B<String?>()
+    if(d.isT(10))     return false
+    return true
+}
+
+fun t12 () : Boolean {
+    val d = B<String?>()
+    if(!d.isT(null))  return false
+    return true
+}
+
+fun t13 () : Boolean {
+    val f = B<java.lang.String?>()
+    if(!f.isT("aaa")) return false
+    return true
+}
+
+fun t14 () : Boolean {
+    val f = B<java.lang.String?>()
+    if(f.isT(10))     return false
+    return true
+}
+
+fun t15 () : Boolean {
+    val f = B<java.lang.String?>()
+    if(!f.isT(null))  return false
+    return true
+}
+
+fun t16 () : Boolean {
+    val c = B<Int>()
+    if(c.isT("aaa")) return false
+    return true
+}
+
+fun t17 () : Boolean {
+    val c = B<Int>()
+    if(!c.isT(10))   return false
+    return true
+}
+
+fun t18 () : Boolean {
+    val c = B<Int>()
+    if(c.isT(null)) return false
+    return true
+}
+
+fun t19 () : Boolean {
+    val e = B<Int?>()
+    if(e.isT("aaa")) return false
+    return true
+}
+
+fun t20 () : Boolean {
+    val e = B<Int?>()
+    if(!e.isT(10))   return false
+    return true
+}
+
+fun t21 () : Boolean {
+    val e = B<Int?>()
+    if(!e.isT(null)) return false
+    return true
+}
+
+fun t22 () : Boolean {
+    val b = B<String>()
+    val w : B<String>? = b as B<String>   //ok
+    val x = w as B<String>?  //TypeCastException
+    return true
+}
+
+fun t23 () : Boolean {
+    val b = B<String>()
+    val v = b as B<String>   //ok
+    return true
+}
+
+fun t24 () : Boolean {
+    val b = B<String>()
+    val u = b as B<String>?  //TypeCastException
+    return true
+}
+
+fun t25 () : Boolean {
+    val c = C()
+    if(!c.isT("aaa")) return false
+    return true
+}
+
+fun t26 () : Boolean {
+    val d = D<String>()
+    if(!d.isT(B<String>())) return false
+    return true
+}
+
+fun box() : String {
+/*
+    if(!t1()) {
+        return "t1 failed"
+    }
+    if(!t2()) {
+        return "t2 failed"
+    }
+    if(!t3()) {
+        return "t3 failed"
+    }
+    if(!t4()) {
+         return "t4 failed"
+     }
+     if(!t5()) {
+         return "t5 failed"
+     }
+     if(!t6()) {
+         return "t6 failed"
+     }
+     if(!t7()) {
+         return "t7 failed"
+     }
+    if(!t8()) {
+        return "t8 failed"
+    }
+    if(!t9()) {
+        return "t9 failed"
+    }
+    if(!t10()) {
+        return "t10 failed"
+    }
+    if(!t11()) {
+         return "t11 failed"
+     }
+     if(!t12()) {
+         return "t12 failed"
+     }
+     if(!t13()) {
+         return "t13 failed"
+     }
+     if(!t14()) {
+         return "t14 failed"
+     }
+    if(!t15()) {
+        return "t15 failed"
+    }
+    if(!t16()) {
+        return "t16 failed"
+    }
+    if(!t17()) {
+        return "t17 failed"
+    }
+    if(!t18()) {
+         return "t18 failed"
+     }
+     if(!t19()) {
+         return "t19 failed"
+     }
+     if(!t20()) {
+         return "t10 failed"
+     }
+     if(!t21()) {
+         return "t21 failed"
+     }
+     if(!t22()) {
+         return "t22 failed"
+     }
+     if(!t23()) {
+         return "t23 failed"
+     }
+     if(!t24()) {
+         return "t24 failed"
+     }
+     if(!t25()) {
+         return "t25 failed"
+     }
+     */
+     if(!t26()) {
+         return "t26 failed"
+     }
+     return "OK"
+}
@@ -0,0 +1,4 @@
+// KT-297 Overload resolution ambiguity with required in trait
+trait ALE<T> : java.util.ArrayList<T> {
+   fun getOrValue(index: Int, value : T) : T = if(index >= 0 && index < size()) get(index) else value
+}
@@ -0,0 +1,17 @@
+class MyRange1() : Range<Int> {
+    override fun contains(item: Int) = true
+}
+
+class MyRange2() {
+    fun contains(item: Int) = true
+}
+
+fun box(): String {
+    if (1 in MyRange1()) {
+        if (1 in MyRange2()) {
+            return "OK"
+        }
+        return "fail 2"
+    }
+    return "fail 1"
+}
@@ -0,0 +1,49 @@
+namespace test
+
+class List<T>(len: Int) {
+  val a : Array<T> = Array<T>(len)
+
+  fun reverse() {
+    var i = 0
+    var j = a.size-1
+    while(i < j) {
+        val x  = a[i]
+        a[i++] = a[j]
+        a[j--] = x
+    }
+  }
+}
+
+fun box() : String {
+  val d = List<Int>(1)
+  d.a[0] = 10
+  println(d.a[0])
+
+  val a = List<String>(1)
+  a.a[0] = "1"
+  println(a.a[0])
+
+  val b = List<Int?>(1)
+  b.a[0] = 10
+  println(b.a[0])
+
+  val c = List<Array<Int>>(1)
+  c.a[0] = Array<Int>(4,{-1})
+  println(c.a[0].size)
+
+  val e = List<Int>(5)
+  e.a[0] = 0
+  e.a[1] = 1
+  e.a[2] = 2
+  e.a[3] = 3
+  e.a[4] = 4
+  e.reverse()
+  for(el in e.a)
+    println(el)
+
+  return "OK"
+}
+
+fun println(s : Any?) {
+  System.out?.println(s);
+}
@@ -0,0 +1,24 @@
+import java.util.ArrayList
+
+fun launch(f : fun() : Unit) {
+    f()
+}
+
+fun box(): String {
+    val list = ArrayList<Int>()
+    val foo : fun() : Unit = {
+        list.add(2)  //first exception
+    }
+    foo()
+
+    launch({
+        list.add(3)
+    })
+
+    val bar = {
+        val x = 1   //second exception
+    }
+    bar()
+
+    return if (list.size() == 2 && list.get(0) == 2 && list.get(1) == 3) "OK" else "fail"
+}
@@ -0,0 +1,196 @@
+/*
+fun s0() : Boolean {
+    val y = "222"
+    val foo = {
+        val bar = { y }
+        bar ()
+    }
+    return foo() == "222"
+}
+
+fun s1() : Boolean {
+    var x = "222"
+    val foo = {
+        val bar = {
+            x = "aaa"
+        }
+        bar ()
+    }
+    foo()
+    return x == "aaa"
+}
+
+fun t1() : Boolean {
+    var x = "111"
+
+    val y = x + "22"
+    val foo = {
+        x = x + "45" + y
+        x = x.substring(3)
+        x += "aaa"
+        ()
+    }
+    foo()
+
+    x += "bbb"
+    System.out?.println(x)
+    return x == "4511122aaabbb"
+}
+
+fun t2() : Boolean {
+    var x = 111
+    val y = x + 22
+    val foo = {
+        x = x + 5 + y
+        x += 5
+        x++
+        ()
+    }
+    foo()
+    x -= 55
+    System.out?.println(x)
+    return x == 200
+}
+
+fun t3() : Boolean {
+    var x = true
+    val foo = {
+        x = false
+        ()
+    }
+    foo()
+    return !x
+}
+
+fun t4() : Boolean {
+    var x = 100.flt
+    val y = x + 22
+    val foo = {
+        x = x + 200.flt + y
+        x += 18
+        ()
+    }
+    foo()
+    System.out?.println(x)
+    return x == 440.flt
+}
+
+fun t5() : Boolean {
+    var x = 100.dbl
+    val y = x + 22
+    val foo = {
+        x = x + 200.dbl + y
+        x -= 22
+        ()
+    }
+    foo()
+    System.out?.println(x)
+    return x == 400.dbl
+}
+
+fun t6() : Boolean {
+    var x = 20.byt
+    val y = x + 22
+    val foo = {
+        x = (x + 20.byt + y).byt
+        x += 2
+        x--
+        ()
+    }
+    foo()
+    System.out?.println(x)
+    return x == 83.byt
+}
+
+fun t7() : Boolean {
+    var x : Char = 'a'
+    val foo = {
+        x = 'b'
+        ()
+    }
+    foo()
+    System.out?.println(x)
+    return x == 'b'
+}
+
+fun t8() : Boolean {
+    var x = 20.sht
+    val foo = {
+        val bar = {
+            x = 30.sht
+            ()
+        }
+        bar()
+        ()
+    }
+    foo()
+    return x == 30.sht
+}
+
+fun t9(x: Int) : Boolean {
+    while(x < 100) {
+       x++
+    }
+    return x == 100
+}
+
+fun t10() : Boolean {
+    var y = 1
+    val foo = {
+        val bar = {
+            y = y + 1
+        }
+        bar()
+    }
+    foo()
+    return y == 2
+}
+
+fun t11(x: Int) : Int {
+    val foo = {
+        x = x + 1
+        val bar = {
+            x = x + 1
+            x += 3
+        }
+        bar()
+    }
+    while(x < 100) {
+       foo()
+    }
+    return x
+}
+*/
+fun t12(x: Int) : Int {
+    var y = x
+    val runnable = object : Runnable {
+        override fun run () {
+            y = y + 1
+        }
+    }
+    while(y < 100) {
+       runnable.run()
+    }
+    return y
+}
+
+fun box(): String {
+/*
+    if (!s0()) return "fail"
+    if (!s1()) return "fail"
+    if (!t1()) return "fail"
+    if (!t2()) return "fail"
+    if (!t3()) return "fail"
+    if (!t4()) return "fail"
+    if (!t5()) return "fail"
+    if (!t6()) return "fail"
+    if (!t7()) return "fail"
+    if (!t8()) return "fail"
+    if (!t9(0)) return "fail"
+    if (!t10()) return "fail"
+    if (t11(1) != 104) return "fail"
+*/
+    if (t12(0) != 100) return "fail"
+
+    return "OK"
+}
@@ -0,0 +1,29 @@
+class A() {
+    var xi = 0
+    var xin : Int? = 0
+    var xinn : Int? = null
+
+    var xl = 0.lng
+    var xln : Long? = 0.lng
+    var xlnn : Long? = null
+
+    var xb = 0.byt
+    var xbn : Byte? = 0.byt
+    var xbnn : Byte? = null
+
+    var xf = 0.flt
+    var xfn : Float? = 0.flt
+    var xfnn : Float? = null
+
+    var xd = 0.dbl
+    var xdn : Double? = 0.dbl
+    var xdnn : Double? = null
+
+    var xs = 0.sht
+    var xsn : Short? = 0.sht
+    var xsnn : Short? = null
+}
+
+fun box() : String {
+    return "OK"
+}