moved the stdlib tests into the same directory as the stdlib, so it works a bit better with maven support in IDEA

libraries/stdlib/test/regressions/Kt1149.kt

@@ -0,0 +1,23 @@
+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/kt1172.kt

@@ -0,0 +1,19 @@
+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

@@ -0,0 +1,120 @@
+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) {
+    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).sure()))
+        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))
+    }
+}