Merge boxWithStdlib testData into box, delete BoxWithStdlib test

2016-03-07 13:36:14 +03:00
parent 22bfc9786a
commit 06a67e6602
535 changed files with 3520 additions and 3871 deletions
@@ -0,0 +1,21 @@
+// WITH_RUNTIME
+
+package test.regressions.kt1149
+
+import java.util.ArrayList
+
+public interface SomeTrait {
+    fun foo()
+}
+
+fun box(): String {
+    val list = ArrayList<SomeTrait>()
+    var res = ArrayList<String>()
+    list.add(object : SomeTrait {
+        override fun foo() {
+            res.add("anonymous.foo()")
+        }
+    })
+    list.forEach{ it.foo() }
+    return if ("anonymous.foo()" == res[0]) "OK" else "fail"
+}
@@ -0,0 +1,19 @@
+// WITH_RUNTIME
+
+package regressions
+
+class Kt1619Test {
+
+    fun doSomething(list: List<String?>): Int {
+        return list.size
+    }
+
+    fun testCollectionNotNullCanBeUsedForNullables(): Int {
+        val list: List<String> = arrayListOf("foo", "bar")
+        return doSomething(list)
+    }
+}
+
+fun box(): String {
+   return if (Kt1619Test().testCollectionNotNullCanBeUsedForNullables() == 2) "OK" else "fail"
+}
@@ -0,0 +1,17 @@
+// WITH_RUNTIME
+
+package regressions
+
+fun f(xs: Iterator<Int>): Int {
+    var answer = 0
+    for (x in xs)  {
+        answer += x
+    }
+    return answer
+}
+
+fun box(): String {
+    val list = arrayListOf(1, 2, 3)
+    val result = f(list.iterator())
+    return if (6 == result) "OK" else "fail"
+}
@@ -0,0 +1,151 @@
+// WITH_RUNTIME
+// FULL_JDK
+
+package collections
+
+import kotlin.test.assertEquals
+import kotlin.test.assertFalse
+import kotlin.test.assertTrue
+import java.security.KeyPair
+
+
+fun <T> testCollectionSize(c: Collection<T>) = assertEquals(0, c.size)
+fun <T> testCollectionIsEmpty(c: Collection<T>) = assertTrue(c.isEmpty())
+fun <T> testCollectionContains(c: Collection<T>) = assertTrue(c.contains(1 as Any?))
+fun <T> testCollectionIterator(c: Collection<T>) {
+    val it = c.iterator()
+    while (it.hasNext()) {
+        assertEquals(1, it.next() as Any?)
+    }
+}
+fun <T> testCollectionContainsAll(c: Collection<T>) = assertTrue(c.containsAll(c))
+fun <T> testMutableCollectionAdd(c: MutableCollection<T>, t: T) {
+    c.add(t)
+    assertEquals(1, c.size)
+    assertTrue(c.contains(t))
+}
+fun <T> testMutableCollectionRemove(c: MutableCollection<T>, t: T) {
+    c.remove(t)
+    assertEquals(0, c.size)
+    assertFalse(c.contains(t))
+}
+fun <T> testMutableCollectionIterator(c: MutableCollection<T>, t: T) {
+    c.add(t)
+    val it = c.iterator()
+    while (it.hasNext()) {
+        it.next()
+        it.remove()
+    }
+    assertEquals(0, c.size)
+}
+fun <T> testMutableCollectionAddAll(c: MutableCollection<T>, t1: T, t2: T) {
+    c.addAll(arrayListOf(t1, t2))
+    assertEquals(arrayListOf(t1, t2), c)
+}
+fun <T> testMutableCollectionRemoveAll(c: MutableCollection<T>, t1: T, t2: T) {
+    c.addAll(arrayListOf(t1, t2))
+    c.removeAll(arrayListOf(t1))
+    assertEquals(arrayListOf(t2), c)
+}
+fun <T> testMutableCollectionRetainAll(c: MutableCollection<T>, t1: T, t2: T) {
+    c.addAll(arrayListOf(t1, t2))
+    c.retainAll(arrayListOf(t1))
+    assertEquals(arrayListOf(t1), c)
+}
+fun <T> testMutableCollectionClear(c: MutableCollection<T>) {
+    c.clear()
+    assertTrue(c.isEmpty())
+}
+
+fun testCollection() {
+    testCollectionSize(arrayListOf<Int>())
+    testCollectionIsEmpty(arrayListOf<String>())
+    testCollectionContains(arrayListOf(1))
+    testCollectionIterator(arrayListOf(1))
+    testCollectionContainsAll(arrayListOf("a", "b"))
+
+    testMutableCollectionAdd(arrayListOf(), "")
+    testMutableCollectionRemove(arrayListOf("a"), "a")
+    testMutableCollectionIterator(arrayListOf(), 1)
+    testMutableCollectionAddAll(arrayListOf(), 1, 2)
+    testMutableCollectionRemoveAll(arrayListOf(), 1, 2)
+    testMutableCollectionRetainAll(arrayListOf(), 1, 2)
+    testMutableCollectionClear(arrayListOf(1, 2))
+}
+
+
+fun <T> testListGet(l: List<T>, t: T) = assertEquals(t, l.get(0))
+fun <T> testListIndexOf(l: List<T>, t: T) = assertEquals(0, l.indexOf(t))
+fun <T> testListIterator(l: List<T>, t1 : T, t2 : T) {
+    val indexes = arrayListOf<Int>()
+    val result = arrayListOf<T>()
+    val it = l.listIterator()
+    while (it.hasNext()) {
+        indexes.add(it.nextIndex())
+        result.add(it.next())
+    }
+    while (it.hasPrevious()) {
+        indexes.add(it.previousIndex())
+        result.add(it.previous())
+    }
+    assertEquals(arrayListOf(0, 1, 1, 0), indexes)
+    assertEquals(arrayListOf(t1, t2, t2, t1), result)
+}
+fun <T> testListSublist(l: List<T>, t: T) = assertEquals(arrayListOf(t), l.subList(0, 1))
+
+fun <T> testMutableListSet(l: MutableList<T>, t: T) {
+    l.set(0, t)
+    assertEquals(arrayListOf(t), l)
+}
+fun <T> testMutableListIterator(l: MutableList<T>, t1: T, t2: T, t3: T) {
+    val it = l.listIterator()
+    while (it.hasNext()) {
+        it.next()
+        it.add(t3)
+    }
+    assertEquals(arrayListOf(t1, t3, t2, t3), l)
+}
+
+fun testList() {
+    testListGet(arrayListOf(1), 1)
+    testListIndexOf(arrayListOf(1), 1)
+    testListIterator(arrayListOf("a", "b"), "a", "b")
+    testListSublist(arrayListOf(1, 2), 1)
+
+    testMutableListSet(arrayListOf(2), 4)
+    testMutableListIterator(arrayListOf(1, 2), 1, 2, 3)
+}
+
+fun <K, V> testMapContainsKey(map: Map<K, V>, k: K) = assertTrue(map.containsKey(k))
+fun <K, V> testMapKeys(map: Map<K, V>, k1: K, k2: K) = assertEqualCollections(hashSetOf(k1, k2), map.keys)
+fun <K, V> testMapValues(map: Map<K, V>, v1: V, v2: V) = assertEqualCollections(hashSetOf(v1, v2), map.values)
+fun <K, V> testMapEntrySet(map: Map<K, V>, k : K, v: V) {
+    for (entry in map.entries) {
+        assertEquals(k, entry.key)
+        assertEquals(v, entry.value)
+    }
+}
+fun <K, V> testMutableMapEntry(map: MutableMap<K, V>, k1 : K, v: V) {
+    for (entry in map.entries) {
+        entry.setValue(v)
+    }
+    assertEquals(hashMapOf(k1 to v), map)
+}
+
+
+fun testMap() {
+    testMapContainsKey(hashMapOf(1 to 'a', 2 to 'b'), 2)
+    testMapKeys(hashMapOf(1 to 'a', 2 to 'b'), 1, 2)
+    testMapValues(hashMapOf(1 to 'a', 2 to 'b'), 'a', 'b')
+    testMapEntrySet(hashMapOf(1 to 'a'), 1, 'a')
+    testMutableMapEntry(hashMapOf(1 to 'a'), 1, 'b')
+}
+
+fun box() : String {
+    testCollection()
+    testList()
+    testMap()
+    return "OK"
+}
+
+fun <T> assertEqualCollections(c1: Collection<T>, c2: Collection<T>) = assertEquals(c1.toCollection(hashSetOf<T>()), c2.toCollection(hashSetOf<T>()))
@@ -0,0 +1,23 @@
+// WITH_RUNTIME
+
+import java.util.*
+
+fun <T> ArrayList<T>.findAll(predicate:  (T) -> Boolean): ArrayList<T> {
+  val result = ArrayList<T>()
+  for(t in this) {
+    if (predicate(t)) result.add(t)
+  }
+  return result
+}
+
+
+fun box(): String {
+  val list: ArrayList<String> = ArrayList<String>()
+  list.add("Prague")
+  list.add("St.Petersburg")
+  list.add("Moscow")
+  list.add("Munich")
+
+  val m: ArrayList<String> = list.findAll<String>({ name: String -> name.startsWith("M")})
+  return if (m.size == 2) "OK" else "fail"
+}
@@ -0,0 +1,25 @@
+// WITH_RUNTIME
+// KT-4485 getGenericInterfaces vs getInterfaces for kotlin classes
+
+class SimpleClass
+
+class ClassWithNonGenericSuperInterface: Cloneable
+
+class ClassWithGenericSuperInterface: java.util.Comparator<String> {
+    override fun compare(a: String, b: String): Int = 0
+}
+
+fun check(klass: Class<*>) {
+    val interfaces = klass.getInterfaces().toList()
+    val genericInterfaces = klass.getGenericInterfaces().toList()
+    if (interfaces.size != genericInterfaces.size) {
+        throw AssertionError("interfaces=$interfaces, genericInterfaces=$genericInterfaces")
+    }
+}
+
+fun box(): String {
+    check(SimpleClass::class.java)
+    check(ClassWithNonGenericSuperInterface::class.java)
+    check(ClassWithGenericSuperInterface::class.java)
+    return "OK"
+}
@@ -0,0 +1,15 @@
+// WITH_RUNTIME
+
+package test.regressions.kt1172
+
+import kotlin.concurrent.*
+import java.util.*
+
+public fun scheduleRefresh(vararg files : Object) {
+    java.util.ArrayList<Object>(files.map{ it })
+}
+
+fun box(): String {
+    scheduleRefresh()
+    return "OK"
+}
@@ -0,0 +1,119 @@
+// WITH_RUNTIME
+// FULL_JDK
+
+package testeval
+
+import java.util.*
+
+interface 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")
+    }
+}
+
+interface 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))
+
+fun box(): String {
+    if (1 != eval(Num(1))) return "fail 1"
+    if (2 != eval(Sum(Num(1), Num(1)))) return "fail 2"
+    if (3 != eval(Mult(Num(3), Num(1)))) return "fail 3"
+    if (6 != eval(Mult(Num(3), Sum(Num(1), Num(1))))) return "fail 4"
+
+    if (1 != eval(parse("1").value)) return "fail 5"
+
+    return "OK"
+}
@@ -0,0 +1,28 @@
+// WITH_RUNTIME
+// FULL_JDK
+
+package pack
+
+import java.util.ArrayList
+import java.util.regex.Pattern
+
+class C{
+    public fun foo(){
+        val items : Collection<Item> = java.util.Collections.singleton(Item())!!
+        val result = ArrayList<Item>()
+        val pattern: Pattern? = Pattern.compile("...")
+        items.filterTo(result) {
+            pattern!!.matcher(it.name())!!.matches()
+        }
+    }
+
+    private fun Item.name() : String = ""
+}
+
+class Item{
+}
+
+fun box() : String {
+    C().foo()
+    return "OK"
+}
@@ -0,0 +1,6 @@
+// WITH_RUNTIME
+
+fun box() : String {
+  val i = 1
+  return if(i.javaClass.getSimpleName() == "int") "OK" else "fail"
+}
@@ -0,0 +1,20 @@
+// WITH_RUNTIME
+
+import kotlin.collections.AbstractIterator
+
+class MyIterator : AbstractIterator<String>() {
+    var i = 0
+    public override fun computeNext() {
+        if(i < 5)
+          setNext((i++).toString())
+    }
+
+}
+
+fun box() : String {
+    var k = ""
+    for (x in MyIterator()) {
+        k+=x
+    }
+    return if(k=="01234") "OK" else k
+}
@@ -0,0 +1,32 @@
+// WITH_RUNTIME
+//KT-1800 error/NonExistentClass generated on runtime
+package i
+
+import java.util.ArrayList
+
+public class User(val firstName: String,
+                  val lastName: String,
+                  val age: Int) {
+    override fun toString() = "$firstName $lastName, age $age"
+}
+
+public fun <T: Comparable<T>> Collection<T>.testMin(): T? {
+    var minValue: T? = null
+    for(value in this) {
+        if (minValue == null || value.compareTo(minValue!!) < 0) {
+            minValue = value
+        }
+    }
+    return minValue
+}
+
+fun box() : String {
+    val users = arrayListOf(
+            User("John", "Doe", 30),
+            User("Jane", "Doe", 27))
+
+    val ages = users.map { it.age }
+
+    val minAge = ages.testMin()
+    return if (minAge == 27) "OK" else "fail"
+}
@@ -0,0 +1,25 @@
+// WITH_RUNTIME
+
+import java.lang.annotation.Annotation
+
+@Retention(AnnotationRetention.RUNTIME)
+annotation class foo(val name : String)
+
+class Test() {
+    @foo("OK") fun hello(input : String) {
+    }
+}
+
+fun box(): String {
+    val test = Test()
+    for (method in Test::class.java.getMethods()!!) {
+        val anns = method?.getAnnotations() as Array<Annotation>
+        if (!anns.isEmpty()) {
+            for (ann in anns) {
+                val fooAnn = ann as foo
+                return fooAnn.name
+            }
+        }
+    }
+    return "fail"
+}
@@ -0,0 +1,6 @@
+// WITH_RUNTIME
+
+fun box(): String {
+    val sorted = arrayListOf("1", "3", "2").sorted()
+    return if (sorted != arrayListOf("1", "2", "3")) "$sorted" else "OK"
+}
@@ -0,0 +1,6 @@
+// WITH_RUNTIME
+
+fun box(): String {
+  kotlin.assert(true)
+  return "OK"
+}
@@ -0,0 +1,13 @@
+// WITH_RUNTIME
+
+fun box(): String {
+    Boolean::class.java
+    Byte::class.java
+    Short::class.java
+    Char::class.java
+    Int::class.java
+    Long::class.java
+    Float::class.java
+    Double::class.java
+    return "OK"
+}
@@ -0,0 +1,10 @@
+// WITH_RUNTIME
+
+fun foo() {
+    if (1==1) {
+        1.javaClass
+    } else {
+    }
+}
+
+fun box() = "OK"
@@ -0,0 +1,15 @@
+// WITH_RUNTIME
+// FULL_JDK
+
+fun box() : String {
+    val vector = java.util.Vector<Int>()
+    vector.add(1)
+    vector.add(2)
+    vector.add(3)
+
+    var sum = 0
+    for(e in vector.elements()) {
+        sum += e
+    }
+    return if(sum == 6) "OK" else "fail"
+}
@@ -0,0 +1,22 @@
+// WITH_RUNTIME
+
+fun box(): String {
+  val bool = true
+  if (bool.javaClass != Boolean::class.java) return "javaClass function on boolean fails"
+  val b = 1.toByte()
+  if (b.javaClass != Byte::class.java) return "javaClass function on byte fails"
+  val s = 1.toShort()
+  if (s.javaClass != Short::class.java) return "javaClass function on short fails"
+  val c = 'c'
+  if (c.javaClass != Char::class.java) return "javaClass function on char fails"
+  val i = 1
+  if (i.javaClass != Int::class.java) return "javaClass function on int fails"
+  val l = 1.toLong()
+  if (l.javaClass != Long::class.java) return "javaClass function on long fails"
+  val f = 1.toFloat()
+  if (f.javaClass != Float::class.java) return "javaClass function on float fails"
+  val d = 1.0
+  if (d.javaClass != Double::class.java) return "javaClass function on double fails"
+
+  return "OK"
+}
@@ -0,0 +1,197 @@
+// WITH_RUNTIME
+
+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"
+        Unit
+    }
+    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++
+        Unit
+    }
+    foo()
+    x -= 55
+    System.out?.println(x)
+    return x == 200
+}
+
+fun t3() : Boolean {
+    var x = true
+    val foo = {
+        x = false
+        Unit
+    }
+    foo()
+    return !x
+}
+
+fun t4() : Boolean {
+    var x = 100.toFloat()
+    val y = x + 22
+    val foo = {
+        x = x + 200.toFloat() + y
+        x += 18
+        Unit
+    }
+    foo()
+    System.out?.println(x)
+    return x == 440.toFloat()
+}
+
+fun t5() : Boolean {
+    var x = 100.toDouble()
+    val y = x + 22
+    val foo = {
+        x = x + 200.toDouble() + y
+        x -= 22
+        Unit
+    }
+    foo()
+    System.out?.println(x)
+    return x == 400.toDouble()
+}
+
+fun t6() : Boolean {
+    var x = 20.toByte()
+    val y = x + 22
+    val foo = {
+        x = (x + 20.toByte() + y).toByte()
+        x = (x + 2).toByte()
+        x--
+        Unit
+    }
+    foo()
+    System.out?.println(x)
+    return x == 83.toByte()
+}
+
+fun t7() : Boolean {
+    var x : Char = 'a'
+    val foo = {
+        x = 'b'
+        Unit
+    }
+    foo()
+    System.out?.println(x)
+    return x == 'b'
+}
+
+fun t8() : Boolean {
+    var x = 20.toShort()
+    val foo = {
+        val bar = {
+            x = 30.toShort()
+            Unit
+        }
+        bar()
+        Unit
+    }
+    foo()
+    return x == 30.toShort()
+}
+
+fun t9(x0: Int) : Boolean {
+    var x = x0
+    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(x0: Int) : Int {
+    var x = x0
+    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 "s0 fail"
+    if (!s1()) return "s1 fail"
+    if (!t1()) return "t1 fail"
+    if (!t2()) return "t2 fail"
+    if (!t3()) return "t3 fail"
+    if (!t4()) return "t4 fail"
+    if (!t5()) return "t5 fail"
+    if (!t6()) return "t6 fail"
+    if (!t7()) return "t7 fail"
+    if (!t8()) return "t8 fail"
+    if (!t9(0)) return "t9 fail"
+    if (!t10()) return "t10 fail"
+    if (t11(1) != 101) return "t11 fail"
+    if (t12(0) != 100) return "t12 fail"
+
+    return "OK"
+}
@@ -0,0 +1,8 @@
+// WITH_RUNTIME
+
+fun box(): String {
+    val m = hashMapOf<String, String?>()
+    m.put("b", null)
+    val oldValue = m.getOrPut("b", { "Foo" })
+    return if (oldValue == "Foo") "OK" else "fail: $oldValue"
+}
@@ -0,0 +1,8 @@
+// WITH_RUNTIME
+
+fun box(): String {
+    val s: String? = "a"
+    val o: Char? = s?.get(0)
+    val c: Any? = o?.javaClass
+    return if (c !=  null) "OK"  else "fail"
+}
@@ -0,0 +1,12 @@
+// WITH_RUNTIME
+
+fun <E : Enum<E>> Byte.toEnum(clazz : Class<E>) : E =
+    (clazz.getMethod("values").invoke(null) as Array<E>)[this.toInt()]
+
+enum class Letters { A, B, C }
+
+fun box(): String {
+    val clazz = Letters::class.java
+    val r = 1.toByte().toEnum(clazz)
+    return if (r == Letters.B) "OK" else "Fail: $r"
+}
@@ -0,0 +1,6 @@
+// WITH_RUNTIME
+
+fun box(): String {
+    val list = arrayOf("a", "c", "b").sorted()
+    return if (list.toString() == "[a, b, c]") "OK" else "Fail: $list"
+}
@@ -0,0 +1,129 @@
+// WITH_RUNTIME
+// FULL_JDK
+
+package mask
+
+import java.io.*
+import java.util.*
+
+fun box() : String {
+    val input = StringReader("/aaa/bbb/ccc/ddd")
+
+    val luhny = Luhny()
+    input.forEachChar {
+        luhny.charIn(it)
+    }
+    luhny.printAll()
+    return "OK"
+}
+
+class Luhny() {
+    val buffer = LinkedList<Char>()
+    val digits = LinkedList<Int>()
+
+    var toBeMasked = 0
+
+    fun charIn(it : Char) {
+        buffer.addLast(it)
+
+        // Commented for KT-621
+        // when (it) {
+        //    .isDigit() => digits.addLast(it.toInt() - '0'.toInt())
+        //    ' ', '-' => {}
+        //    else => {
+        //            printAll()
+        //            digits.clear()
+        //    }
+        // }
+
+        if (it.isDigit()) {
+            digits.addLast(it - '0')
+        } else if (it == ' ' || it == '-') {
+        } else {
+            printAll()
+            digits.clear()
+        }
+
+        if (digits.size > 16)
+          printOneDigit()
+        check()
+    }
+
+    fun check() {
+        if (digits.size < 14) return
+        print("check")
+        val sum = digits.sum { i, d ->
+//            println("$i -> $d")
+            if (i % 2 == digits.size) {
+                val f = d * 2 / 10
+                val s = d * 2 % 10
+//                println("$d: f = $f, s = $s")
+                (f + s).pr {
+//                    println("to be doubled: $i -> $d : $it")
+                }
+            } else d
+        }
+//        println(sum)
+        if (sum % 10 == 0) {print("s"); toBeMasked = digits.size}
+    }
+
+    fun printOneDigit() {
+        while (!buffer.isEmpty()) {
+            val c = buffer.removeFirst()
+            out(c)
+            if (c.isDigit()) {
+                digits.removeFirst()
+                return
+            }
+        }
+    }
+
+    fun printAll() {
+        while (!buffer.isEmpty())
+          out(buffer.removeFirst())
+    }
+
+    fun out(c : Char) {
+        if (toBeMasked > 0) {
+            print('X')
+            toBeMasked--
+        }
+        else {
+            // print(c)
+        }
+    }
+}
+
+fun <T> T.pr(f : (T) -> Unit) : T {
+    f(this)
+    return this
+}
+
+fun LinkedList<Int>.sum(f : (Int, Int )-> Int): Int {
+    var sum = 0
+    for (i in 1..size) {
+        val j = size - i
+        sum += f(j, get(j))
+    }
+    return sum
+}
+
+//fun <T> List<T>.backwards() : Itl<T> = object : Itl<T> {
+//  override fun iterator() : It<T> =
+//      object : It<T> {
+//          var current = size()
+//          override fun next() : T = get(--current)
+//          override fun hasNext() : Boolean = current > 0
+//          override fun remove() {throw UnsupportedOperationException()}
+//      }
+//}
+
+// fun Char.isDigit() = Character.isDigit(this)
+
+fun Reader.forEachChar(body : (Char) -> Unit) {
+    do {
+        var i = read();
+        if (i == -1) break
+        body(i.toChar())
+    } while(true)
+}
@@ -0,0 +1,110 @@
+// WITH_RUNTIME
+// FULL_JDK
+
+package mask
+
+import java.io.*
+import java.util.*
+
+fun box() : String {
+    val input = StringReader("/aaa/bbb/ccc/ddd")
+
+    val luhny = Luhny()
+    input.forEachChar {
+        luhny.process(it)
+    }
+    luhny.printAll()
+    return "OK"
+}
+
+class Luhny() {
+    private val buffer = ArrayDeque<Char>()
+    private val digits = ArrayDeque<Int>(16)
+
+    private var toBeMasked = 0
+
+    fun process(it : Char) {
+        buffer.addLast(it)
+
+        // Commented for KT-621
+        // when (it) {
+        //     .isDigit() => digits.addLast(it.toInt() - '0'.toInt())
+        //     ' ', '-'   => {}
+        //     else       => printAll()
+        // }
+
+        if (it.isDigit()) {
+            digits.addLast(it - '0')
+        } else if (it == ' ' || it == '-') {
+        } else {
+            printAll()
+        }
+
+        if (digits.size > 16)
+          printOneDigit()
+        check()
+    }
+
+    private fun check() {
+        val size = digits.size
+        if (size < 14) return
+        val sum = digits.sum {i, d ->
+            if (i % 2 == size % 2) double(d) else d
+        }
+//        var sum = 0
+//        var i = 0
+//        for (d in digits) {
+//            sum += if (i % 2 == size % 2) double(d) else d
+//            i++
+//        }
+        if (sum % 10 == 0) toBeMasked = digits.size
+    }
+
+    private fun double(d : Int) = d * 2 / 10 + d * 2 % 10
+
+    private fun printOneDigit() {
+        while (!buffer.isEmpty()) {
+            val c = buffer.removeFirst()!!
+            print(c)
+            if (c.isDigit()) {
+                digits.removeFirst()
+                return
+            }
+        }
+    }
+
+    fun printAll() {
+        while (!buffer.isEmpty())
+          print(buffer.removeFirst())
+        digits.clear()
+    }
+
+    private fun print(c : Char) {
+        if (c.isDigit() && toBeMasked > 0) {
+            kotlin.io.print('X')
+            toBeMasked--
+        } else {
+            // kotlin.io.print(c)
+        }
+    }
+}
+
+// fun Char.isDigit() = Character.isDigit(this)
+
+fun Iterable<Int>.sum(f : (index : Int, value : Int) -> Int) : Int {
+    var sum = 0
+    var i = 0
+    for (d in this) {
+        sum += f(i, d)
+        i++
+    }
+    return sum
+}
+
+fun Reader.forEachChar(body : (Char) -> Unit) {
+    do {
+        var i = read();
+        if (i == -1) break
+        body(i.toChar())
+    } while(true)
+}
@@ -0,0 +1,147 @@
+// WITH_RUNTIME
+// FULL_JDK
+
+package mask
+
+import java.io.*
+import java.util.*
+
+fun box() : String {
+    val input = StringReader("/aaa/bbb/ccc/ddd")
+
+    val luhny = Luhny()
+    input.forEachChar {
+        luhny.charIn(it)
+    }
+    luhny.printAll()
+    return "OK"
+
+}
+
+class Luhny() {
+    val buffer = LinkedList<Char>()
+    val digits = LinkedList<Int>()
+
+    var toBeMasked = 0
+
+    fun charIn(it : Char) {
+        buffer.push(it)
+
+        // Commented for KT-621
+        // when (it) {
+        //   .isDigit() => digits.push(it.toInt() - '0'.toInt())
+        //   ' ', '-' => {}
+        //   else => {
+        //           printAll()
+        //           digits.clear()
+        //   }
+        // }
+
+        if (it.isDigit()) {
+            digits.push(it - '0')
+        } else if (it == ' ' || it == '-') {
+        } else {
+            printAll()
+            digits.clear()
+        }
+
+        if (digits.size > 16)
+          printOneDigit()
+        check()
+    }
+
+    fun check() {
+        if (digits.size < 14) return
+        val sum = digits.sum { i, d ->
+            if (i % 2 != 0)
+                d * 2 / 10 +  d * 2 % 10
+            else d
+        }
+        if (sum % 10 == 0) toBeMasked = digits.size
+    }
+
+    fun printOneDigit() {
+        while (!buffer.isEmpty()) {
+            val c = buffer.pop()
+            out(c)
+            if (c.isDigit()) {
+                digits.pop()
+                return
+            }
+        }
+    }
+
+    fun printAll() {
+        while (!buffer.isEmpty())
+          out(buffer.pop())
+    }
+
+    fun out(c : Char) {
+        if (toBeMasked > 0) {
+            print('X')
+            toBeMasked--
+        }
+        else {
+            // print(c)
+        }
+    }
+}
+
+fun LinkedList<Int>.sum(f : (Int, Int) -> Int) : Int {
+    var sum = 0
+    var i = 0
+    for (d in backwards()) {
+        sum += f(i, d)
+        i++
+    }
+    return sum
+}
+
+fun <T> List<T>.backwards() : Iterable<T> = object : Iterable<T> {
+  override fun iterator() : Iterator<T> =
+      object : Iterator<T> {
+          var current = size
+          override fun next() : T = get(--current)
+          override fun hasNext() : Boolean = current > 0
+      }
+}
+
+// fun Char.isDigit() = Character.isDigit(this)
+
+//class Queue<T>(initialBufSize : Int) {
+//
+//    private var bufSize = initialBufSize
+//    private val buf = Array<T>(initialBufSize)
+//    private var head = 0
+//    private var tail = 0
+//    private var size = 0
+//
+//    val empty : Boolean get() = size == 0
+//
+//    private fun prev(i : Int) = (bufSize + i - 1) % bufSize
+//    private fun next(i : Int) = (i + 1) % bufSize
+//
+//    fun push(c : T) {
+//        buf[tail] = c
+//        tail = prev(tail)
+//        size++
+//    }
+//
+//    fun pop() : T {
+//        if (size == 0) throw IllegalStateException()
+//        size--
+//        val result = buf[head]
+//        head = prev(head)
+//        return result
+//    }
+//
+//    fun clear() {}
+//}
+
+fun Reader.forEachChar(body : (Char) -> Unit) {
+    do {
+        var i = read();
+        if (i == -1) break
+        body(i.toChar())
+    } while(true)
+}
@@ -0,0 +1,14 @@
+// WITH_RUNTIME
+
+fun box(): String {
+    run {
+        test("ok")
+        test("ok", 200)
+    }
+    test("ok")
+    test("ok", 300)
+
+    return "OK"
+}
+
+private fun test(arg1: String, default: Int = 0) = Unit
@@ -0,0 +1,13 @@
+// WITH_RUNTIME
+
+fun box(): String {
+    val res = (1..3).map { it ->
+        if (it == 1)
+            2
+    };
+
+    var result = ""
+    for (i in res)
+        result += " "
+    return if (result == "   ") "OK" else result
+}
@@ -0,0 +1,30 @@
+// WITH_RUNTIME
+
+enum class E {
+    VALUE,
+    VALUE2
+}
+
+class C(val nums: Map<E, Int>) {
+    val normalizedNums = loadNormalizedNums()
+
+    private fun loadNormalizedNums(): Map<E, Float> {
+        val vals = nums.values
+        val min = vals.min()!!
+        val max = vals.max()!!
+        val rangeDiff = (max - min).toFloat()
+        val normalizedNums = nums.map { kvp ->
+            val (e, num) = kvp
+            //val e = kvp.key
+            //val num = kvp.value
+            val normalized = (num - min) / rangeDiff
+            Pair(e, normalized)
+        }.toMap()
+        return normalizedNums
+    }
+}
+
+fun box(): String {
+    val res = C(hashMapOf(E.VALUE to 11, E.VALUE2 to 12)).normalizedNums.values.sorted().joinToString()
+    return  if ("0.0, 1.0" == res) "OK" else "fail $res"
+}
@@ -0,0 +1,9 @@
+// WITH_RUNTIME
+
+fun box(): String {
+    val p = 1 to 1
+    val (e, num) = p
+    val a = 1f
+
+    return "OK"
+}
@@ -0,0 +1,22 @@
+// WITH_RUNTIME
+// FULL_JDK
+
+import kotlin.test.assertEquals
+import java.lang.reflect.ParameterizedType
+import java.lang.reflect.Type
+
+open class TypeLiteral<T> {
+    val type: Type
+        get() = (javaClass.getGenericSuperclass() as ParameterizedType).getActualTypeArguments()[0]
+}
+
+inline fun <reified T> typeLiteral(): TypeLiteral<T> = object : TypeLiteral<T>() {}
+
+fun box(): String {
+    assertEquals("class java.lang.String", typeLiteral<String>().type.toString())
+    assertEquals("java.util.List<?>", typeLiteral<List<*>>().type.toString())
+    assertEquals("java.lang.String[]", typeLiteral<Array<String>>().type.toString())
+    assertEquals("java.lang.Integer[]", typeLiteral<Array<Int>>().type.toString())
+    assertEquals("java.lang.String[][]", typeLiteral<Array<Array<String>>>().type.toString())
+    return "OK"
+}
@@ -0,0 +1,16 @@
+// WITH_RUNTIME
+
+import kotlin.*
+
+@Suppress("REIFIED_TYPE_PARAMETER_NO_INLINE")
+inline fun <reified T: Any> javaClass(): Class<T> = T::class.java
+
+val test = "lala".javaClass
+
+val test2 = javaClass<Iterator<Int>> ()
+
+fun box(): String {
+    if(test.getCanonicalName() != "java.lang.String") return "fail"
+    if(test2.getCanonicalName() != "java.util.Iterator") return "fail"
+    return "OK"
+}
@@ -0,0 +1,23 @@
+// WITH_RUNTIME
+// FULL_JDK
+
+import java.io.*
+import java.util.*
+
+fun sample() : Reader {
+    return StringReader("""Hello
+World""");
+  }
+
+  fun box() : String {
+    // NOTE: Also tested in stdlib: LineIteratorTest.useLines
+
+    // TODO compiler error
+    // both these expressions causes java.lang.NoClassDefFoundError: collections/CollectionPackage
+    val list1 = sample().useLines { it.toList() }
+    val list2 = sample().useLines<ArrayList<String>>{ it.toCollection(arrayListOf()) }
+
+    if(arrayListOf("Hello", "World") != list1) return "fail"
+    if(arrayListOf("Hello", "World") != list2) return "fail"
+    return "OK"
+  }
@@ -0,0 +1,36 @@
+// WITH_RUNTIME
+
+fun findPairless(a : IntArray) : Int {
+  loop@ for (i in a.indices) {
+    for (j in a.indices) {
+      if (i != j && a[i] == a[j]) continue@loop
+    }
+    return a[i]
+  }
+  return -1
+}
+
+fun hasDuplicates(a : IntArray) : Boolean {
+  var duplicate = false
+  loop@ for (i in a.indices) {
+    for (j in a.indices) {
+      if (i != j && a[i] == a[j]) {
+        duplicate = true
+        break@loop
+      }
+    }
+  }
+  return duplicate
+}
+
+fun box() : String {
+    val a = IntArray(5)
+    a[0] = 0
+    a[1] = 0
+    a[2] = 1
+    a[3] = 1
+    a[4] = 5
+    if(findPairless(a) != 5) return "fail"
+    return if(hasDuplicates(a))  "OK" else "fail"
+
+}
@@ -0,0 +1,29 @@
+// WITH_RUNTIME
+
+interface Stream<T> {
+    fun iterator(): Iterator<T>
+}
+
+class ZippingStream<T1, T2>(val stream1: Stream<T1>, val stream2: Stream<T2>) : Stream<Pair<T1,T2>> {
+    override fun iterator(): Iterator<Pair<T1,T2>> = object : AbstractIterator<Pair<T1,T2>>() {
+        val iterator1 = stream1.iterator()
+        val iterator2 = stream2.iterator()
+        override fun computeNext() {
+            if (iterator1.hasNext() && iterator2.hasNext()) {
+                setNext(iterator1.next() to iterator2.next())
+            } else {
+                done()
+            }
+        }
+    }
+}
+
+
+object EmptyStream : Stream<Nothing> {
+    override fun iterator() = listOf<Nothing>().iterator()
+}
+
+fun box(): String {
+    ZippingStream(EmptyStream, EmptyStream).iterator().hasNext()
+    return "OK"
+}
@@ -0,0 +1,19 @@
+// WITH_RUNTIME
+// KT-4351 Cannot resolve reference to self in init of class local to function
+
+fun box(): String {
+    var accessedFromConstructor: Class<*>? = null
+
+    class MyClass() {
+        init {
+            accessedFromConstructor = MyClass::class.java
+        }
+    }
+
+    MyClass()
+    if (accessedFromConstructor!!.getName().endsWith("MyClass")) {
+        return "OK"
+    } else {
+        return accessedFromConstructor.toString()
+    }
+}
@@ -0,0 +1,30 @@
+// WITH_RUNTIME
+
+import java.util.ArrayList
+
+// KT-2823 TypeCastException has no message
+// KT-5121 Better error message in on casting null to non-null type
+
+fun box(): String {
+    try {
+        val a: Any? = null
+        a as Array<String>
+    }
+    catch (e: TypeCastException) {
+        if (e.message != "null cannot be cast to non-null type kotlin.Array<kotlin.String>") {
+            return "Fail 1: $e"
+        }
+    }
+
+    try {
+        val x: String? = null
+        x as String
+    }
+    catch (e: TypeCastException) {
+        if (e.message != "null cannot be cast to non-null type kotlin.String") {
+            return "Fail 2: $e"
+        }
+    }
+
+    return "OK"
+}