JS: move more test to box tests

2016-08-30 17:07:29 +03:00
parent 34bf3e6e56
commit 9da1a50cae
68 changed files with 465 additions and 355 deletions
@@ -0,0 +1,21 @@
+import java.util.ArrayList
+
+interface Tr {
+    fun extra(): String = "_"
+}
+
+class N() : ArrayList<Any>(), Tr {
+    override fun add(el: Any): Boolean {
+        super<ArrayList>.add(el)
+        return super<ArrayList>.add(el.toString() + super<Tr>.extra() + el + extra())
+    }
+
+    override fun extra(): String = super<Tr>.extra() + super<Tr>.extra()
+}
+
+fun box(): String {
+    val n = N()
+    n.add("239")
+    if (n.get(0) == "239" && n.get(1) == "239_239__") return "OK";
+    return "fail";
+}
@@ -0,0 +1,22 @@
+open class M() {
+    open var b: Int = 0
+}
+
+class N() : M() {
+    val a: Int
+        get() {
+            super.b = super.b + 1
+            return super.b + 1
+        }
+    override var b: Int = a + 1
+
+    val superb: Int
+        get() = super.b
+}
+
+fun box(): String {
+    val n = N()
+    println("a: " + n.a + " b: " + n.b + " superb: " + n.superb)
+    if (n.b == 3 && n.a == 4 && n.superb == 3) return "OK";
+    return "fail";
+}
@@ -0,0 +1,11 @@
+class C() {
+    companion object {
+        fun create() = C()
+    }
+}
+
+fun box(): String {
+    val c = C.create()
+    return if (c is C) "OK" else "fail"
+}
+
@@ -0,0 +1,7 @@
+fun box(): String {
+    return apply("OK", { arg: String -> arg })
+}
+
+fun apply(arg: String, f: (p: String) -> String): String {
+    return f(arg)
+}
@@ -0,0 +1,7 @@
+fun box(): String {
+    return if (apply(5) { arg: Int -> arg + 13 } == 18) "OK" else "fail"
+}
+
+fun apply(arg: Int, f: (p: Int) -> Int): Int {
+    return f(arg)
+}
@@ -0,0 +1,8 @@
+fun box(): String {
+    val cl = 39
+    return if (sum(200, { val ff = { cl }; ff() }) == 239) "OK" else "FAIL"
+}
+
+fun sum(arg: Int, f: () -> Int): Int {
+    return arg + f()
+}
@@ -0,0 +1,42 @@
+interface BK {
+    fun x(): Int = 50
+}
+
+interface K : BK {
+    override fun x(): Int = super.x() * 2
+}
+
+open class M() {
+    open fun x(): Int = 10
+
+    open var y = 500
+}
+
+open class N() : M(), K {
+
+    override fun x(): Int = 20
+
+    override var y = 200
+
+    inner open class C() : K {
+        fun test1() = x()
+        fun test2() = super<M>@N.x()
+        fun test3() = super<K>@N.x()
+        fun test4() = super<K>.x()
+        fun test5() = y
+        fun test6(): Int {
+            super<M>@N.y += 200
+            return super<M>@N.y
+        }
+    }
+}
+
+fun box(): String {
+    if (N().C().test1() != 100) return "test1 fail";
+    if (N().C().test2() != 10) return "test2 fail";
+    if (N().C().test3() != 100) return "test3 fail";
+    if (N().C().test4() != 100) return "test4 fail";
+    if (N().C().test5() != 200) return "test5 fail";
+    if (N().C().test6() != 700) return "test6 fail";
+    return "OK";
+}
@@ -0,0 +1,8 @@
+fun box(): String {
+    val cl = 39
+    return if (sum(200, { val m = { val r = { cl };  r() }; m() }) == 239) "OK" else "FAIL"
+}
+
+fun sum(arg: Int, f: () -> Int): Int {
+    return arg + f()
+}
@@ -0,0 +1,13 @@
+class Point(val x: Int, val y: Int)
+
+fun box(): String {
+    val answer = apply(Point(3, 5), { scalar: Int ->
+        Point(x * scalar, y * scalar)
+    })
+
+    return if (answer.x == 6 && answer.y == 10) "OK" else "FAIL"
+}
+
+fun apply(arg: Point, f: Point.(scalar: Int) -> Point): Point {
+    return arg.f(2)
+}
@@ -0,0 +1,20 @@
+open class Base() {
+    fun n(n: Int): Int = n + 1
+}
+
+interface Abstract {
+}
+
+class Derived1() : Base(), Abstract {
+}
+class Derived2() : Abstract, Base() {
+}
+
+fun test(s: Base): Boolean = s.n(238) == 239
+
+fun box(): String {
+    if (!test(Base())) return "Fail #1"
+    if (!test(Derived1())) return "Fail #2"
+    if (!test(Derived2())) return "Fail #3"
+    return "OK"
+}
@@ -0,0 +1,14 @@
+class Slot() {
+    var vitality: Int = 10000
+
+    fun increaseVitality(delta: Int) {
+        vitality = vitality + delta
+        if (vitality > 65535) vitality = 65535;
+    }
+}
+
+fun box(): String {
+    val s = Slot()
+    s.increaseVitality(1000)
+    if (s.vitality == 11000) return "OK" else return "fail"
+}
@@ -0,0 +1,48 @@
+// Changed when traits were introduced. May not make sense any more
+
+open class X(val x: Int) {
+}
+interface Y {
+    abstract val y: Int
+}
+
+class YImpl(override val y: Int) : Y {
+}
+
+class Point(x: Int, yy: Int) : X(x), Y {
+    override val y: Int = yy
+}
+
+interface Abstract {
+}
+
+class P1(x: Int, yy: Y) : Abstract, X(x), Y by yy {
+}
+class P2(x: Int, yy: Y) : X(x), Abstract, Y by yy {
+}
+class P3(x: Int, yy: Y) : X(x), Y by yy, Abstract {
+}
+class P4(x: Int, yy: Y) : Y by yy, Abstract, X(x) {
+}
+
+fun box(): String {
+    if (X(239).x != 239) return "FAIL #1"
+    if (YImpl(239).y != 239) return "FAIL #2"
+
+    val p = Point(240, -1)
+    if (p.x + p.y != 239) return "FAIL #3"
+
+    val y = YImpl(-1)
+    val p1 = P1(240, y)
+    if (p1.x + p1.y != 239) return "FAIL #4"
+    val p2 = P2(240, y)
+    if (p2.x + p2.y != 239) return "FAIL #5"
+
+    val p3 = P3(240, y)
+    if (p3.x + p3.y != 239) return "FAIL #6"
+
+    val p4 = P4(240, y)
+    if (p4.x + p4.y != 239) return "FAIL #7"
+
+    return "OK"
+}
@@ -0,0 +1,14 @@
+class Outer() {
+    open class InnerBase() {
+    }
+
+    class InnerDerived() : InnerBase() {
+    }
+
+    public val foo: InnerBase? = InnerDerived()
+}
+
+fun box(): String {
+    val o = Outer()
+    return if (o.foo === null) "fail" else "OK"
+}
@@ -0,0 +1,13 @@
+open class Foo() {
+    fun xyzzy(): String = "xyzzy"
+}
+
+class Bar() : Foo() {
+    fun test(): String = xyzzy()
+}
+
+fun box(): String {
+    val bar = Bar()
+    val f = bar.test()
+    return if (f == "xyzzy") "OK" else "fail"
+}
@@ -0,0 +1,13 @@
+class C() {
+    public var f: Int
+
+    init {
+        f = 610
+    }
+}
+
+fun box(): String {
+    val c = C()
+    if (c.f != 610) return "fail"
+    return "OK"
+}
@@ -0,0 +1,20 @@
+import java.util.*
+import java.io.*
+
+class World() {
+    public val items: ArrayList<Item> = ArrayList<Item>()
+
+    inner class Item() {
+        init {
+            items.add(this)
+        }
+    }
+
+    val foo = Item()
+}
+
+fun box() : String {
+    val w = World()
+    if (w.items.size != 1) return "fail"
+    return "OK"
+}
@@ -0,0 +1,19 @@
+class Outer(val foo: StringBuilder) {
+    inner class Inner() {
+        fun len(): Int {
+            return foo.length
+        }
+    }
+
+    fun test(): Inner {
+        return Inner()
+    }
+}
+
+fun box(): String {
+    val sb = StringBuilder("xyzzy")
+    val o = Outer(sb)
+    val i = o.test()
+    val l = i.len()
+    return if (l != 5) "fail" else "OK"
+}
@@ -0,0 +1,27 @@
+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,11 @@
+class SimpleClass() {
+    fun foo() = 610
+}
+
+fun box(): String {
+    val c = SimpleClass()
+    if (c.foo() == 610) {
+        return "OK"
+    }
+    return "FAIL"
+}
@@ -0,0 +1,25 @@
+import java.util.*
+
+class ArrayWrapper<T>() {
+    val contents = ArrayList<T>()
+
+    fun add(item: T) {
+        contents.add(item)
+    }
+
+    operator fun plus(b: ArrayWrapper<T>): ArrayWrapper<T> {
+        val result = ArrayWrapper<T>()
+        result.contents.addAll(contents)
+        result.contents.addAll(b.contents)
+        return result
+    }
+}
+
+fun box(): String {
+    val v1 = ArrayWrapper<String>()
+    val v2 = ArrayWrapper<String>()
+    v1.add("foo")
+    v2.add("bar")
+    val v3 = v1 + v2
+    return if (v3.contents.size == 2) "OK" else "fail"
+}
@@ -0,0 +1,27 @@
+import java.util.*
+
+class ArrayWrapper<T>() {
+    val contents = ArrayList<T>()
+
+    fun add(item: T) {
+        contents.add(item)
+    }
+
+    operator fun plusAssign(rhs: ArrayWrapper<T>) {
+        contents.addAll(rhs.contents)
+    }
+
+    fun get(index: Int): T {
+        return contents.get(index)
+    }
+}
+
+fun box(): String {
+    var v1 = ArrayWrapper<String>()
+    val v2 = ArrayWrapper<String>()
+    v1.add("foo")
+    val v3 = v1
+    v2.add("bar")
+    v1 += v2
+    return if (v1.contents.size == 2 && v3.contents.size == 2) "OK" else "fail"
+}
@@ -0,0 +1,30 @@
+import java.util.*
+
+class ArrayWrapper<T>() {
+    val contents = ArrayList<T>()
+
+    fun add(item: T) {
+        contents.add(item)
+    }
+
+    operator fun plus(rhs: ArrayWrapper<T>): ArrayWrapper<T> {
+        val result = ArrayWrapper<T>()
+        result.contents.addAll(contents)
+        result.contents.addAll(rhs.contents)
+        return result
+    }
+
+    fun get(index: Int): T {
+        return contents.get(index)
+    }
+}
+
+fun box(): String {
+    var v1 = ArrayWrapper<String>()
+    val v2 = ArrayWrapper<String>()
+    v1.add("foo")
+    val v3 = v1
+    v2.add("bar")
+    v1 += v2
+    return if (v1.contents.size == 2 && v3.contents.size == 1) "OK" else "fail"
+}
@@ -0,0 +1,31 @@
+import java.util.*
+
+class ArrayWrapper<T>() {
+    val contents = ArrayList<T>()
+
+    fun add(item: T) {
+        contents.add(item)
+    }
+
+    operator fun unaryMinus(): ArrayWrapper<T> {
+        val result = ArrayWrapper<T>()
+        result.contents.addAll(contents)
+        var i = contents.size;
+        for (a in contents) {
+            result.contents[--i] = a;
+        }
+        return result
+    }
+
+    operator fun get(index: Int): T {
+        return contents.get(index)
+    }
+}
+
+fun box(): String {
+    val v1 = ArrayWrapper<String>()
+    v1.add("foo")
+    v1.add("bar")
+    val v2 = -v1
+    return if (v2[0] == "bar" && v2[1] == "foo") "OK" else "fail"
+}
@@ -0,0 +1,36 @@
+open class Base() {
+    val plain = 239
+    public val read: Int
+        get() = 239
+
+    public var readwrite: Int = 0
+        get() = field + 1
+        set(n: Int) {
+            field = n
+        }
+}
+
+interface Abstract {
+}
+
+class Derived1() : Base(), Abstract {
+}
+class Derived2() : Abstract, Base() {
+}
+
+fun code(s: Base): Int {
+    if (s.plain != 239) return 1
+    if (s.read != 239) return 2
+    s.readwrite = 238
+    if (s.readwrite != 239) return 3
+    return 0
+}
+
+fun test(s: Base): Boolean = code(s) == 0
+
+fun box(): String {
+    if (!test(Base())) return "Fail #1"
+    if (!test(Derived1())) return "Fail #2"
+    if (!test(Derived2())) return "Fail #3"
+    return "OK"
+}
@@ -0,0 +1,16 @@
+class Outer() {
+    val s = "xyzzy"
+
+    open inner class InnerBase(public val name: String) {
+    }
+
+    inner class InnerDerived() : InnerBase(s) {
+    }
+
+    val x = InnerDerived()
+}
+
+fun box(): String {
+    val o = Outer()
+    return if (o.x.name != "xyzzy") "fail" else "OK"
+}
@@ -0,0 +1,21 @@
+// Changed when traits were introduced. May not make sense any more
+
+interface Left {
+}
+open class Right() {
+    open fun f() = 42
+}
+
+class D() : Left, Right() {
+    override fun f() = 239
+}
+
+fun box(): String {
+    val r: Right = Right()
+    val d: D = D()
+
+    if (r.f() != 42) return "Fail #1"
+    if (d.f() != 239) return "Fail #2"
+
+    return "OK"
+}
@@ -0,0 +1,7 @@
+fun box(): String {
+    return invoker({ "OK" })
+}
+
+fun invoker(gen: () -> String): String {
+    return gen()
+}
@@ -0,0 +1,7 @@
+fun box(): String {
+    return if (int_invoker({ 7 }) == 7) "OK" else "fail"
+}
+
+fun int_invoker(gen: () -> Int): Int {
+    return gen()
+}
@@ -0,0 +1,29 @@
+interface M {
+    var backingB: Int
+    var b: Int
+        get() = backingB
+        set(value: Int) {
+            backingB = value
+        }
+}
+
+class N() : M {
+    override var backingB: Int = 0
+
+    val a: Int
+        get() {
+            super.b = super.b + 1
+            return super.b + 1
+        }
+    override var b: Int = a + 1
+
+    val superb: Int
+        get() = super.b
+}
+
+fun box(): String {
+    val n = N()
+    println("a: " + n.a + " b: " + n.b + " superb: " + n.superb)
+    if (n.b == 3 && n.a == 4 && n.superb == 3) return "OK";
+    return "fail";
+}
@@ -0,0 +1,30 @@
+package foo
+
+class MyList<T>(vararg val data: T) : AbstractList<T>() {
+    override fun get(index: Int) = data[index]
+    override val size: Int get() = data.size
+}
+
+fun <T> test(expected: String, list: List<T>) {
+    var s = ""
+    for (e in list) {
+        s += "$e,"
+    }
+    assertEquals(expected, s)
+
+    val it = list.iterator()
+    s = ""
+    while (it.hasNext()) {
+        val e = it.next()
+        s += "$e,"
+    }
+    assertEquals(expected, s)
+}
+
+fun box(): String {
+
+    test("32,12,23,444,", MyList(32, 12, 23, 444))
+    test("", MyList<Any>())
+
+    return "OK"
+}
@@ -0,0 +1,14 @@
+package foo
+
+import java.util.ArrayList;
+
+fun box(): String {
+    val a = ArrayList<Int>();
+    a.add(1)
+    a.add(2)
+    if (a.size != 2) return "fail1: ${a.size}"
+    if (a.get(1) != 2) return "fail2"
+    if (a.get(0) != 1) return "fail3"
+
+    return "OK"
+}
@@ -0,0 +1,15 @@
+package foo
+
+import java.util.ArrayList;
+
+fun box(): String {
+    val a = ArrayList<Int>();
+    a.add(1)
+    a.add(2)
+    a[1] = 100
+    if (a.size != 2) return "fail1: ${a.size}"
+    if (a[1] != 100) return "fail2"
+    if (a[0] != 1) return "fail3"
+
+    return "OK"
+}
@@ -0,0 +1,8 @@
+package foo
+
+import java.util.ArrayList
+
+fun box(): String {
+    val al = ArrayList<Int>(10)
+    return if (al.size == 0) "OK" else "fail: ${al.size}"
+}
@@ -0,0 +1,17 @@
+package foo
+
+import java.util.ArrayList
+
+var baz = 0
+fun withSideEffect(v: Int): Int {
+    baz = v
+    return v
+}
+
+fun box(): String {
+    val al = ArrayList<Int>(withSideEffect(2))
+    if (al.size != 0) return "fail1: ${al.size}"
+    if (baz != 2) return "fail2: $baz"
+
+    return "OK"
+}
@@ -0,0 +1,16 @@
+package foo
+
+import java.util.ArrayList;
+
+fun box(): String {
+    val list: List<Any?> = arrayListOf(3, "2", -1, null, 0, 8, 5, "3", 77, -15)
+    val subset = arrayListOf(3, "2", -1, null)
+    val empty = arrayListOf<Any?>()
+    val withOtherElements = arrayListOf(3, 54, null)
+
+    if (!list.containsAll(subset)) return "FAIL: $list.containsAll($subset)"
+    if (!list.containsAll(empty)) return "FAIL: $list.containsAll($empty)"
+    if (list.containsAll(withOtherElements)) return "FAIL: $list.containsAll($withOtherElements)"
+
+    return "OK"
+}
@@ -0,0 +1,8 @@
+package foo
+
+import java.util.ArrayList;
+
+fun box(): String {
+    val a = ArrayList<Int>();
+    return if (a.size == 0) "OK" else "fail: ${a.size}"
+}
@@ -0,0 +1,18 @@
+package foo
+
+import java.util.ArrayList;
+
+fun box(): String {
+    val arr = ArrayList<Int>();
+    var i = 0;
+    while (i++ < 10) {
+        arr.add(i);
+    }
+    try {
+        if (arr[10] == 11) return "fail1"
+    }
+    catch (e: Exception) {
+        return "OK"
+    }
+    return "fail2"
+}
@@ -0,0 +1,23 @@
+package foo
+
+import java.util.ArrayList;
+
+fun <T> test(list: List<T>, elements: List<T>, expected: List<Int>, method: List<T>.(T) -> Int, methodName: String): String? {
+    for (i in 0..elements.size - 1) {
+        val actual = list.method(elements[i])
+        if (actual != expected[i]) return "$methodName failed when find: ${elements[i]}, expected: ${expected[i]}, actual: $actual"
+    }
+    return null
+}
+
+fun box(): String {
+    //                0   1    2   3    4   5    6   7     8    9
+    val list = listOf(3, "2", -1, null, 0, "2", -1, null, 0, 8)
+    val findingElements = listOf(77, null, 0, 8, -15, "2", 5, 3, -1, "3")
+    val expectedIndexOf = listOf(-1, 3, 4, 9, -1, 1, -1, 0, 2, -1)
+    val expectedLastIndexOf = listOf(-1, 7, 8, 9, -1, 5, -1, 0, 6, -1)
+
+    return test(list, findingElements, expectedIndexOf, { indexOf(it) }, "indexOf") ?:
+    test(list, findingElements, expectedLastIndexOf, { lastIndexOf(it) }, "lastIndexOf") ?:
+    "OK"
+}
@@ -0,0 +1,11 @@
+package foo
+
+import java.util.ArrayList;
+
+fun box(): String {
+    val a = ArrayList<Int>();
+    a.add(3)
+    if (a.isEmpty()) return "fail1"
+    if (!ArrayList<Int>().isEmpty()) return "fail2"
+    return "OK"
+}
@@ -0,0 +1,19 @@
+package foo
+
+import java.util.ArrayList;
+
+fun box(): String {
+    var i = 0
+    val arr = ArrayList<Int>();
+    while (i++ < 10) {
+        arr.add(i);
+    }
+    var sum = 0
+    for (a in arr) {
+        sum += a;
+    }
+    if (sum != 55) return "fail1: $sum"
+    if (arr.size != 10) return "fail2: ${arr.size}"
+
+    return "OK"
+}
@@ -0,0 +1,50 @@
+package foo
+
+import java.util.ArrayList
+
+fun box(): String {
+    var i = 0
+    val list = ArrayList<Int>()
+    while (i++ < 3) {
+        list.add(i)
+    }
+
+    // test addAt
+    list.add(0, 400)
+    list.removeAt(0);
+    list.add(1, 500)
+    // test contains, addAll
+    if (!list.contains(500) || list.contains(600) || list.addAll(ArrayList<Int>())) {
+        return "fail1"
+    }
+
+    val a = ArrayList<Int>()
+    a.add(3)
+
+    val b = ArrayList<Int>()
+    b.add(4)
+    a.addAll(b)
+    if (a[0] != 3 || a[1] != 4) {
+        return "fail2"
+    }
+
+    if (a.isEmpty() || !ArrayList<Int>().isEmpty()) {
+        return "fail2"
+    }
+
+    assertNotEquals(a, b, "a != b")
+
+    b[0] = a[0]
+    b.add(a[1])
+    assertEquals(a, b, "a == b")
+
+    a.clear()
+    assertEquals(true, a.isEmpty(), "a.isEmpty()")
+
+
+    assertArrayEquals(arrayOf(1, 500, 2, 3), list.toTypedArray(), "list.toTypedArray()")
+    assertEquals("[1,500,2,3]", JSON.stringify(list), "JSON.stringify(list)")
+    assertEquals("[1, 500, 2, 3]", list.toString(), "list.toString()")
+
+    return "OK"
+}
@@ -0,0 +1,22 @@
+package foo
+
+import java.util.ArrayList
+
+fun box(): String {
+    val arr = ArrayList<Int>()
+    for (i in 0..5) {
+        arr.add(i)
+    }
+
+    val removedElement = arr.removeAt(2)
+    val removed = arr.remove(4)
+    if (arr.size != 4) return "fail1: ${arr.size}"
+    if (removedElement != 2) return "fail2: ${removedElement}"
+    if (!removed) return "fail3"
+    if (arr[0] != 0) return "fail4: ${arr[0]}"
+    if (arr[1] != 1) return "fail5: ${arr[1]}"
+    if (arr[2] != 3) return "fail6: ${arr[2]}"
+    if (arr[3] != 5) return "fail7: ${arr[3]}"
+
+    return "OK"
+}
@@ -0,0 +1,26 @@
+package foo
+
+import java.util.ArrayList;
+
+
+fun <T> test(a: List<T>, b: List<T>, removed: Boolean, expected: List<T>): String? {
+    val t = ArrayList<T>(a.size)
+    t.addAll(a)
+
+    if (t.removeAll(b) != removed) return "$a.removeAll($b) != $removed, result list: $t"
+    if (t != expected) return "Wrong result of $a.removeAll($b), expected: $expected, actual: $t"
+
+    return null
+}
+
+fun box(): String {
+    val list = listOf(3, "2", -1, null, 0, 8, 5, "3", 77, -15)
+    val subset = listOf(3, "2", -1, null)
+    val empty = listOf<Any?>()
+    val withOtherElements = listOf(3, 54, null)
+
+    return test(list, subset, removed = true, expected = listOf(0, 8, 5, "3", 77, -15)) ?:
+    test(list, empty, removed = false, expected = list) ?:
+    test(list, withOtherElements, removed = true, expected = listOf("2", -1, 0, 8, 5, "3", 77, -15)) ?:
+    "OK"
+}
@@ -0,0 +1,30 @@
+package foo
+
+import java.util.ArrayList
+
+fun box(): String {
+    var threwForEmptyList = false
+
+    val arr = ArrayList<Int>()
+    try {
+        arr.removeAt(2)
+    }
+    catch(e: IndexOutOfBoundsException) {
+        threwForEmptyList = true
+    }
+
+    for (i in 0..10) {
+        arr.add(i)
+    }
+
+    var threwForFilled = false
+
+    try {
+        arr.removeAt(20)
+    }
+    catch(e: IndexOutOfBoundsException) {
+        threwForFilled = true
+    }
+
+    return if (threwForEmptyList && threwForFilled) "OK" else "fail"
+}
@@ -0,0 +1,26 @@
+package foo
+
+import java.util.ArrayList;
+
+fun <T> test(a: List<T>, b: List<T>, removed: Boolean, expected: List<T>): String? {
+    val t = ArrayList<T>(a.size)
+    t.addAll(a)
+
+    if (t.retainAll(b) != removed) return "$a.retainAll($b) != $removed, result list: $t"
+    if (t != expected) return "Wrong result of $a.retainAll($b), expected: $expected, actual: $t"
+
+    return null
+}
+
+fun box(): String {
+    val list = listOf(3, "2", -1, null, 0, 8, 5, "3", 77, -15)
+    val subset = listOf(3, "2", -1, null)
+    val empty = listOf<Any?>()
+    val withOtherElements = listOf(3, 54, null)
+
+    return test(list, subset, removed = true, expected = subset) ?:
+    test(list, empty, removed = true, expected = empty) ?:
+    test(list, withOtherElements, removed = true, expected = listOf(3, null)) ?:
+    test(list, list, removed = false, expected = list) ?:
+    "OK"
+}
@@ -0,0 +1,18 @@
+package foo
+
+import java.util.ArrayList
+
+fun box(): String {
+    var i = 0
+    val list = ArrayList<Int>()
+    while (i++ < 3) {
+        list.add(i)
+    }
+
+    // test addAt
+    list.add(1, 500)
+
+    val array = list.toTypedArray()
+
+    return if (array[0] == 1 && array[1] == 500 && array[2] == 2 && array[3] == 3 && JSON.stringify(list) == "[1,500,2,3]") "OK" else "fail"
+}