Move regression tests from stdlib to compiler

#KT-5770 FIxed

libraries/stdlib/test/regressions/Kt1149.kt

@@ -1,23 +0,0 @@
-package test.regressions.kt1149
-
-import java.util.ArrayList
-import kotlin.util.*
-import junit.framework.*
-
-public trait SomeTrait {
-    fun foo()
-}
-
-class Kt1149Test() : TestCase() {
-    fun testMe() {
-        val list = ArrayList<SomeTrait>()
-        var res = ArrayList<String>()
-        list.add(object : SomeTrait {
-            override fun foo() {
-                res.add("anonymous.foo()")
-            }
-        })
-        list.forEach{ it.foo() }
-        Assert.assertEquals("anonymous.foo()", res[0])
-    }
-}

libraries/stdlib/test/regressions/Kt1617Test.kt

@@ -1,18 +0,0 @@
-package regressions
-
-// TODO comment out the next line to reproduce KT-1617
-//import kotlin.util.map
-
-import java.io.File
-
-import junit.framework.TestCase
-
-class Kt1617Test: TestCase() {
-    fun testMapFunction() {
-        val coll: Collection<String> = arrayListOf("foo", "bar")
-
-        val files =  coll.map{ File(it) }
-
-        println("Found files: $files")
-    }
-}

libraries/stdlib/test/regressions/Kt1619Test.kt

@@ -1,16 +0,0 @@
-package regressions
-
-import junit.framework.TestCase
-import kotlin.test.expect
-
-class Kt1619Test: TestCase() {
-
-    fun doSomething(list: List<String?>): Int {
-        return list.size()
-    }
-
-    fun testCollectionNotNullCanBeUsedForNullables() {
-        val list: List<String> = arrayListOf("foo", "bar")
-        expect(2) { doSomething(list) }
-    }
-}

libraries/stdlib/test/regressions/Kt2495Test.kt

@@ -1,20 +0,0 @@
-package regressions
-
-import kotlin.test.assertEquals
-import org.junit.Test as test
-
-fun f(xs: Iterator<Int>): Int {
-    var answer = 0
-    for (x in xs)  {
-        answer += x
-    }
-    return answer
-}
-
-class Kt2495Test {
-    test fun duplicateIteratorsBug() {
-        val list = arrayList(1, 2, 3)
-        val result = f(list.iterator())
-        assertEquals(6, result)
-    }
-}

libraries/stdlib/test/regressions/kt1172.kt

@@ -1,19 +0,0 @@
-package test.regressions.kt1172
-
-import kotlin.concurrent.*
-import junit.framework.*
-import java.util.*
-
-public fun scheduleRefresh(vararg files : Object) {
-    // TODO
-    // java.util.ArrayList<Object>(files.map{ it })
-}
-
-fun main(args : Array<String?>?) {
-}
-
-class Kt1172Test() : TestCase() {
-    fun testMe() {
-        main(null)
-    }
-}

libraries/stdlib/test/regressions/kt1202.kt

@@ -1,120 +0,0 @@
-package testeval
-
-import java.util.*
-import junit.framework.TestCase.*
-import junit.framework.Assert.* // TODO unnecessary import
-
-trait Expression
-class Num(val value : Int) : Expression
-class Sum(val left : Expression, val right : Expression) : Expression
-class Mult(val left : Expression, val right : Expression) : Expression
-
-fun eval(e : Expression) : Int {
-    return when (e) {
-        is Num -> e.value
-        is Sum -> eval(e.left) + eval (e.right)
-        is Mult -> eval(e.left) * eval (e.right)
-        else -> throw AssertionError("Unknown expression")
-    }
-}
-
-trait ParseResult<out T> {
-    val success : Boolean
-    val value : T
-}
-
-class Success<T>(override val value : T) : ParseResult<T> {
-    public override val success : Boolean = true
-}
-
-class Failure(val message : String) : ParseResult<Nothing> {
-    override val success = false
-    override val value : Nothing = throw UnsupportedOperationException("Don't call value on a Failure")
-}
-
-open class Token(val text : String) {
-    override fun toString() = text
-}
-object LPAR : Token("(")
-object RPAR : Token(")")
-object PLUS : Token("+")
-object TIMES : Token("*")
-object EOF : Token("EOF")
-class Number(text : String) : Token(text)
-class Error(text : String) : Token("[Error: $text]")
-
-
-fun tokenize(text : String) : Deque<Token> {
-    val result = LinkedList<Token>()
-    for (c in text) {
-        result add when (c) {
-            '(' -> LPAR
-            ')' -> RPAR
-            '+' -> PLUS
-            '*' -> TIMES
-            in '0'..'9' -> Number(c.toString())
-            else -> Error(c.toString())
-        }
-    }
-    result.add(EOF)
-    return result
-}
-
-fun parseSum(tokens : Deque<Token>) : ParseResult<Expression> {
-    val left = parseMult(tokens)
-    if (!left.success) return left
-
-    if (tokens.peek() == PLUS) {
-        tokens.pop()
-        val right = parseSum(tokens)
-        if (!right.success) return right
-        return Success(Sum(left.value, right.value))
-    }
-
-    return left
-}
-
-fun parseMult(tokens : Deque<Token>) : ParseResult<Expression> {
-    val left = parseAtomic(tokens)
-    if (!left.success) return left
-
-    if (tokens.peek() == PLUS) {
-        tokens.pop()
-        val right = parseMult(tokens)
-        if (!right.success) return right
-        return Success(Mult(left.value, right.value))
-    }
-
-    return left
-}
-
-fun parseAtomic(tokens : Deque<Token>) : ParseResult<Expression> {
-    val token = tokens.poll()
-    return when (token) {
-        LPAR -> {
-            val result = parseSum(tokens)
-            val rpar = tokens.poll()
-            if (rpar == RPAR)
-                result
-            else
-                Failure("Expecting ')'")
-        }
-        is Number -> Success(Num(Integer.parseInt((token as Token).text)))
-        else -> Failure("Unexpected EOF")
-    }
-}
-
-fun parse(text : String) : ParseResult<Expression> = parseSum(tokenize(text))
-
-class EvalTest : junit.framework.TestCase() {
-    fun testEval() {
-        assertEquals(1, eval(Num(1)))
-        assertEquals(2, eval(Sum(Num(1), Num(1))))
-        assertEquals(3, eval(Mult(Num(3), Num(1))))
-        assertEquals(6, eval(Mult(Num(3), Sum(Num(1), Num(1)))))
-    }
-
-    fun testParse() {
-        assertEquals(1, eval(parse("1").value))
-    }
-}