JS backend: testFiles -> testData

js/js.translator/testData/java/arrayList/cases/access.kt

@@ -0,0 +1,10 @@
+package foo
+
+import java.util.ArrayList;
+
+fun box(): Boolean {
+    val a = ArrayList<Int>();
+    a.add(1)
+    a.add(2)
+    return (a.size() == 2) && (a.get(1) == 2) && (a.get(0) == 1);
+}

js/js.translator/testData/java/arrayList/cases/arrayAccess.kt

@@ -0,0 +1,11 @@
+package foo
+
+import java.util.ArrayList;
+
+fun box(): Boolean {
+    val a = ArrayList<Int>();
+    a.add(1)
+    a.add(2)
+    a[1] = 100
+    return (a.size() == 2) && (a[1] == 100) && (a[0] == 1);
+}

js/js.translator/testData/java/arrayList/cases/constructWithCapacity.kt

@@ -0,0 +1,8 @@
+package foo
+
+import java.util.ArrayList
+
+fun box(): Boolean {
+    val al = ArrayList<Int>(10)
+    return al.size() == 0
+}

js/js.translator/testData/java/arrayList/cases/constructWithSideEffectParam.kt

@@ -0,0 +1,14 @@
+package foo
+
+import java.util.ArrayList
+
+var baz = 0
+fun withSideEffect(v: Int): Int {
+    baz = v
+    return v
+}
+
+fun box(): Boolean {
+    val al = ArrayList<Int>(withSideEffect(2))
+    return al.size() == 0 && baz == 2
+}

js/js.translator/testData/java/arrayList/cases/containsAll.kt

@@ -0,0 +1,28 @@
+package foo
+
+import java.util.ArrayList;
+
+
+// TODO: drop when arrayListOf will be available here.
+fun arrayListOf<T>(vararg a: T): ArrayList<T> {
+    val list = ArrayList<T>();
+
+    for (e in a) {
+        list.add(e)
+    }
+
+    return list
+}
+
+fun box(): String {
+    val list = 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"
+}

js/js.translator/testData/java/arrayList/cases/emptyList.kt

@@ -0,0 +1,8 @@
+package foo
+
+import java.util.ArrayList;
+
+fun box(): Boolean {
+    val a = ArrayList<Int>();
+    return a.size() == 0;
+}

js/js.translator/testData/java/arrayList/cases/indexOOB.kt

@@ -0,0 +1,12 @@
+package foo
+
+import java.util.ArrayList;
+
+fun box(): Boolean {
+    val arr = ArrayList<Int>();
+    var i = 0;
+    while (i++ < 10) {
+        arr.add(i);
+    }
+    return (arr[10] == 11)
+}

js/js.translator/testData/java/arrayList/cases/indexOf.kt

@@ -0,0 +1,34 @@
+package foo
+
+import java.util.ArrayList;
+
+// TODO: drop when listOf will be available here.
+fun listOf<T>(vararg a: T): List<T> {
+    val list = ArrayList<T>();
+
+    for (e in a) {
+        list.add(e)
+    }
+
+    return list
+}
+
+fun test<T>(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"
+}

js/js.translator/testData/java/arrayList/cases/isEmpty.kt

@@ -0,0 +1,9 @@
+package foo
+
+import java.util.ArrayList;
+
+fun box(): Boolean {
+    val a = ArrayList<Int>();
+    a.add(3)
+    return !(a.isEmpty()) && (ArrayList<Int>().isEmpty());
+}

js/js.translator/testData/java/arrayList/cases/iterate.kt

@@ -0,0 +1,16 @@
+package foo
+
+import java.util.ArrayList;
+
+fun box(): Boolean {
+    var i = 0
+    val arr = ArrayList<Int>();
+    while (i++ < 10) {
+        arr.add(i);
+    }
+    var sum = 0
+    for (a in arr) {
+        sum += a;
+    }
+    return (sum == 55) && (arr.size() == 10)
+}

js/js.translator/testData/java/arrayList/cases/misc.kt

@@ -0,0 +1,59 @@
+package foo
+
+import java.util.ArrayList
+
+fun assertThat(a: Any, b: Any) {
+    if (a != b) {
+        throw Exception("$a is not equal to $b")
+    }
+}
+
+fun box(): Boolean {
+    var i = 0
+    val list = ArrayList<Int>()
+    while (i++ < 3) {
+        list.add(i)
+    }
+
+    // test addAt
+    list.add(0, 400)
+    list.remove(0);
+    list.add(1, 500)
+    // test contains, addAll
+    if (!list.contains(500) || list.contains(600) || list.addAll(ArrayList<Int>())) {
+        return false;
+    }
+
+    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 false
+    }
+
+    if (a.isEmpty() || !ArrayList<Int>().isEmpty()) {
+        return false
+    }
+
+    assertThat(a.equals(b), false)
+
+    b[0] = a[0]
+    b.add(a[1])
+    assertThat(a.equals(b), true)
+
+    a.clear()
+    assertThat(a.isEmpty(), true)
+
+    val array = list.copyToArray()
+
+    assertThat(array[0], 1)
+    assertThat(array[1], 500)
+    assertThat(array[2], 2)
+    assertThat(array[3], 3)
+    assertThat(JSON.stringify(list), "[1,500,2,3]")
+    assertThat(list.toString(), "[1, 500, 2, 3]")
+    return true;
+}

js/js.translator/testData/java/arrayList/cases/remove.kt

@@ -0,0 +1,14 @@
+package foo
+
+import java.util.ArrayList
+
+fun box(): Boolean {
+    val arr = ArrayList<Int>()
+    for (i in 0..5) {
+        arr.add(i)
+    }
+
+    val removedElement = arr.remove(2)
+    val removed = arr.remove(4: Any)
+    return arr.size() == 4 && removedElement == 2 && removed && arr[0] == 0 && arr[1] == 1 && arr[2] == 3 && arr[3] == 5
+}

js/js.translator/testData/java/arrayList/cases/removeAll.kt

@@ -0,0 +1,37 @@
+package foo
+
+import java.util.ArrayList;
+
+
+// TODO: drop when listOf will be available here.
+fun listOf<T>(vararg a: T): List<T> {
+    val list = ArrayList<T>();
+
+    for (e in a) {
+        list.add(e)
+    }
+
+    return list
+}
+
+fun test<T>(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"
+}

js/js.translator/testData/java/arrayList/cases/removeWithIndexOutOfBounds.kt

@@ -0,0 +1,30 @@
+package foo
+
+import java.util.ArrayList
+
+fun box(): Boolean {
+    var threwForEmptyList = false
+
+    val arr = ArrayList<Int>()
+    try {
+        arr.remove(2)
+    }
+    catch(e: IndexOutOfBoundsException) {
+        threwForEmptyList = true
+    }
+
+    for (i in 0..10) {
+        arr.add(i)
+    }
+
+    var threwForFilled = false
+
+    try {
+        arr.remove(20)
+    }
+    catch(e: IndexOutOfBoundsException) {
+        threwForFilled = true
+    }
+
+    return threwForEmptyList && threwForFilled
+}

js/js.translator/testData/java/arrayList/cases/retainAll.kt

@@ -0,0 +1,38 @@
+package foo
+
+import java.util.ArrayList;
+
+
+// TODO: drop when listOf will be available here.
+fun listOf<T>(vararg a: T): List<T> {
+    val list = ArrayList<T>();
+
+    for (e in a) {
+        list.add(e)
+    }
+
+    return list
+}
+
+fun test<T>(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"
+}

js/js.translator/testData/java/arrayList/cases/toArray.kt

@@ -0,0 +1,17 @@
+package foo
+
+import java.util.ArrayList
+
+fun box(): Boolean {
+    var i = 0
+    val list = ArrayList<Int>()
+    while (i++ < 3) {
+        list.add(i)
+    }
+
+    // test addAt
+    list.add(1, 500)
+
+    val array = list.copyToArray()
+    return array[0] == 1 && array[1] == 500 && array[2] == 2 && array[3] == 3 && JSON.stringify(list) == "[1,500,2,3]";
+}