Collection tests: format and fix usages of deprecated symbols.

libraries/stdlib/test/collections/ArraysJVMTest.kt

@@ -40,14 +40,14 @@ class ArraysJVMTest {
         expect(-4.toLong()) { longArray(1, 2, 3) reduce { a, b -> a - b } }
         expect(-4.toFloat()) { floatArray(1.toFloat(), 2.toFloat(), 3.toFloat()) reduce { a, b -> a - b } }
         expect(-4.0) { doubleArray(1.0, 2.0, 3.0) reduce { a, b -> a - b } }
-        expect('3') { charArray('1', '3', '2') reduce { a, b -> if(a > b) a else b } }
+        expect('3') { charArray('1', '3', '2') reduce { a, b -> if (a > b) a else b } }
         expect(false) { booleanArray(true, true, false) reduce { a, b -> a && b } }
         expect(true) { booleanArray(true, true) reduce { a, b -> a && b } }
         expect(0.toByte()) { byteArray(3, 2, 1) reduce { a, b -> (a - b).toByte() } }
         expect(0.toShort()) { shortArray(3, 2, 1) reduce { a, b -> (a - b).toShort() } }
 
         failsWith (javaClass<UnsupportedOperationException>()) {
-            intArray().reduce { a, b -> a + b}
+            intArray().reduce { a, b -> a + b }
         }
     }
 
@@ -56,14 +56,14 @@ class ArraysJVMTest {
         expect(2.toLong()) { longArray(1, 2, 3) reduceRight { a, b -> a - b } }
         expect(2.toFloat()) { floatArray(1.toFloat(), 2.toFloat(), 3.toFloat()) reduceRight { a, b -> a - b } }
         expect(2.0) { doubleArray(1.0, 2.0, 3.0) reduceRight { a, b -> a - b } }
-        expect('3') { charArray('1', '3', '2') reduceRight { a, b -> if(a > b) a else b } }
+        expect('3') { charArray('1', '3', '2') reduceRight { a, b -> if (a > b) a else b } }
         expect(false) { booleanArray(true, true, false) reduceRight { a, b -> a && b } }
         expect(true) { booleanArray(true, true) reduceRight { a, b -> a && b } }
         expect(2.toByte()) { byteArray(1, 2, 3) reduceRight { a, b -> (a - b).toByte() } }
         expect(2.toShort()) { shortArray(1, 2, 3) reduceRight { a, b -> (a - b).toShort() } }
 
         failsWith (javaClass<UnsupportedOperationException>()) {
-            intArray().reduceRight { a, b -> a + b}
+            intArray().reduceRight { a, b -> a + b }
         }
     }
 

libraries/stdlib/test/collections/ArraysTest.kt

@@ -3,7 +3,7 @@ package test.collections
 import kotlin.test.*
 import org.junit.Test as test
 
-fun <T> checkContent(iter : Iterator<T>, length : Int, value : (Int) -> T) {
+fun <T> checkContent(iter: Iterator<T>, length: Int, value: (Int) -> T) {
     var idx = 0
     while (idx != length && iter.hasNext()) {
         assertEquals(value(idx++), iter.next(), "Invalid element")
@@ -19,7 +19,7 @@ class ArraysTest {
         val arr1 = IntArray(0)
         assertEquals(-1, arr1.lastIndex)
 
-        val arr2 = Array<String>(0, {"$it"})
+        val arr2 = Array<String>(0, { "$it" })
         assertEquals(-1, arr2.lastIndex)
     }
 
@@ -28,7 +28,7 @@ class ArraysTest {
         assertEquals(4, arr1.lastIndex)
         assertEquals(4, arr1[arr1.lastIndex])
 
-        val arr2 = Array<String>(5, {"$it"})
+        val arr2 = Array<String>(5, { "$it" })
         assertEquals(4, arr2.lastIndex)
         assertEquals("4", arr2[arr2.lastIndex])
     }
@@ -124,7 +124,7 @@ class ArraysTest {
         expect(1, { array(1).minBy { it } })
         expect(3, { array(2, 3).minBy { -it } })
         expect('a', { array('a', 'b').minBy { "x$it" } })
-        expect("b", { array("b", "abc").minBy { it.length } })
+        expect("b", { array("b", "abc").minBy { it.length() } })
     }
 
     test fun maxBy() {
@@ -132,7 +132,7 @@ class ArraysTest {
         expect(1, { array(1).maxBy { it } })
         expect(2, { array(2, 3).maxBy { -it } })
         expect('b', { array('a', 'b').maxBy { "x$it" } })
-        expect("abc", { array("b", "abc").maxBy { it.length } })
+        expect("abc", { array("b", "abc").maxBy { it.length() } })
     }
 
     test fun minByEvaluateOnce() {
@@ -162,33 +162,33 @@ class ArraysTest {
         expect(0) { array("cat", "dog", "bird").indexOf("cat") }
         expect(1) { array("cat", "dog", "bird").indexOf("dog") }
         expect(2) { array("cat", "dog", "bird").indexOf("bird") }
-        expect(0) { array(null, "dog", null).indexOf(null)}
+        expect(0) { array(null, "dog", null).indexOf(null) }
     }
 
     test fun plus() {
-        assertEquals(listOf("1","2","3","4"), array("1", "2") + array("3", "4"))
+        assertEquals(listOf("1", "2", "3", "4"), array("1", "2") + array("3", "4"))
-        assertEquals(listOf("1","2","3","4"), listOf("1", "2") + array("3", "4"))
+        assertEquals(listOf("1", "2", "3", "4"), listOf("1", "2") + array("3", "4"))
     }
 
     test fun plusVararg() {
         fun onePlus(vararg a: String) = array("1") + a
-        assertEquals(listOf("1","2"), onePlus("2"))
+        assertEquals(listOf("1", "2"), onePlus("2"))
     }
 
     test fun first() {
-        expect(1) { array(1,2,3).first() }
+        expect(1) { array(1, 2, 3).first() }
-        expect(2) { array(1,2,3).first { it % 2 == 0 } }
+        expect(2) { array(1, 2, 3).first { it % 2 == 0 } }
     }
 
     test fun last() {
-        expect(3) { array(1,2,3).last() }
+        expect(3) { array(1, 2, 3).last() }
-        expect(2) { array(1,2,3).last { it % 2 == 0 } }
+        expect(2) { array(1, 2, 3).last { it % 2 == 0 } }
     }
 
     test fun contains() {
-        assertTrue(array("1","2","3","4").contains("2"))
+        assertTrue(array("1", "2", "3", "4").contains("2"))
-        assertTrue("3" in array("1","2","3","4"))
+        assertTrue("3" in array("1", "2", "3", "4"))
-        assertTrue("0" !in array("1","2","3","4"))
+        assertTrue("0" !in array("1", "2", "3", "4"))
     }
 
     test fun slice() {

libraries/stdlib/test/collections/CollectionJVMTest.kt

@@ -9,7 +9,7 @@ import org.junit.Test as test
 class CollectionJVMTest {
 
     test fun flatMap() {
-        val data = arrayListOf("", "foo", "bar", "x", "")
+        val data = listOf("", "foo", "bar", "x", "")
         val characters = data.flatMap { it.toCharList() }
         println("Got list of characters ${characters}")
         assertEquals(7, characters.size())
@@ -19,7 +19,7 @@ class CollectionJVMTest {
 
 
     test fun filterIntoLinkedList() {
-        val data = arrayListOf("foo", "bar")
+        val data = listOf("foo", "bar")
         val foo = data.filterTo(linkedListOf<String>()) { it.startsWith("f") }
 
         assertTrue {
@@ -33,8 +33,8 @@ class CollectionJVMTest {
         }
     }
 
-    test fun filterNotIntolinkedListOf() {
+    test fun filterNotIntoLinkedListOf() {
-        val data = arrayListOf("foo", "bar")
+        val data = listOf("foo", "bar")
         val foo = data.filterNotTo(linkedListOf<String>()) { it.startsWith("f") }
 
         assertTrue {
@@ -49,7 +49,7 @@ class CollectionJVMTest {
     }
 
     test fun filterNotNullIntoLinkedListOf() {
-        val data = arrayListOf(null, "foo", null, "bar")
+        val data = listOf(null, "foo", null, "bar")
         val foo = data.filterNotNullTo(linkedListOf<String>())
 
         assertEquals(2, foo.size())
@@ -61,8 +61,8 @@ class CollectionJVMTest {
     }
 
     test fun filterIntoSortedSet() {
-        val data = arrayListOf("foo", "bar")
+        val data = listOf("foo", "bar")
-        val sorted = data.filterTo(sortedSetOf<String>()) { it.length == 3 }
+        val sorted = data.filterTo(sortedSetOf<String>()) { it.length() == 3 }
         assertEquals(2, sorted.size())
         assertEquals(sortedSetOf("bar", "foo"), sorted)
         assertTrue {
@@ -71,13 +71,13 @@ class CollectionJVMTest {
     }
 
     test fun first() {
-        assertEquals(19, TreeSet(arrayListOf(90, 47, 19)).first())
+        assertEquals(19, TreeSet(listOf(90, 47, 19)).first())
     }
 
     test fun last() {
-        val data = arrayListOf("foo", "bar")
+        val data = listOf("foo", "bar")
         assertEquals("bar", data.last())
-        assertEquals(25, arrayListOf(15, 19, 20, 25).last())
+        assertEquals(25, listOf(15, 19, 20, 25).last())
         assertEquals('a', linkedListOf('a').last())
     }
 
@@ -90,8 +90,8 @@ class CollectionJVMTest {
     }
 
     test fun toArray() {
-        val data = arrayListOf("foo", "bar")
+        val data = listOf("foo", "bar")
-        val arr = data.toArray()
+        val arr = data.copyToArray()
         println("Got array ${arr}")
         assertEquals(2, arr.size())
         todo {
@@ -106,40 +106,40 @@ class CollectionJVMTest {
     }
 
     test fun filterIsInstanceList() {
-        val src: List<Any> = listOf(1,2,3.toDouble(), "abc", "cde")
+        val values: List<Any> = listOf(1, 2, 3.toDouble(), "abc", "cde")
 
-        val ints: List<Int> = src.filterIsInstance<Int>()
+        val intValues: List<Int> = values.filterIsInstance<Int>()
-        assertEquals(arrayListOf(1,2), ints)
+        assertEquals(listOf(1, 2), intValues)
 
-        val doubles: List<Double> = src.filterIsInstance<Double>()
+        val doubleValues: List<Double> = values.filterIsInstance<Double>()
-        assertEquals(arrayListOf(3.0), doubles)
+        assertEquals(listOf(3.0), doubleValues)
 
-        val strings: List<String> = src.filterIsInstance<String>()
+        val stringValues: List<String> = values.filterIsInstance<String>()
-        assertEquals(arrayListOf("abc", "cde"), strings)
+        assertEquals(listOf("abc", "cde"), stringValues)
 
-        val anys: List<Any> = src.filterIsInstance<Any>()
+        val anyValues: List<Any> = values.filterIsInstance<Any>()
-        assertEquals(src.toList(), anys)
+        assertEquals(values.toList(), anyValues)
 
-        val chars: List<Char> = src.filterIsInstance<Char>()
+        val charValues: List<Char> = values.filterIsInstance<Char>()
-        assertEquals(0, chars.size())
+        assertEquals(0, charValues.size())
     }
 
     test fun filterIsInstanceArray() {
-        val src: Array<Any> = array(1,2,3.toDouble(), "abc", "cde")
+        val src: Array<Any> = array(1, 2, 3.toDouble(), "abc", "cde")
 
-        val ints: List<Int> = src.filterIsInstance<Int>()
+        val intValues: List<Int> = src.filterIsInstance<Int>()
-        assertEquals(arrayListOf(1,2), ints)
+        assertEquals(listOf(1, 2), intValues)
 
-        val doubles: List<Double> = src.filterIsInstance<Double>()
+        val doubleValues: List<Double> = src.filterIsInstance<Double>()
-        assertEquals(arrayListOf(3.0), doubles)
+        assertEquals(listOf(3.0), doubleValues)
 
-        val strings: List<String> = src.filterIsInstance<String>()
+        val stringValues: List<String> = src.filterIsInstance<String>()
-        assertEquals(arrayListOf("abc", "cde"), strings)
+        assertEquals(listOf("abc", "cde"), stringValues)
 
-        val anys: List<Any> = src.filterIsInstance<Any>()
+        val anyValues: List<Any> = src.filterIsInstance<Any>()
-        assertEquals(src.toList(), anys)
+        assertEquals(src.toList(), anyValues)
 
-        val chars: List<Char> = src.filterIsInstance<Char>()
+        val charValues: List<Char> = src.filterIsInstance<Char>()
-        assertEquals(0, chars.size())
+        assertEquals(0, charValues.size())
     }
 }

libraries/stdlib/test/collections/CollectionTest.kt

@@ -7,28 +7,28 @@ import org.junit.Test as test
 class CollectionTest {
 
     test fun joinTo() {
-        val data = arrayListOf("foo", "bar")
+        val data = listOf("foo", "bar")
         val buffer = StringBuilder()
         data.joinTo(buffer, "-", "{", "}")
         assertEquals("{foo-bar}", buffer.toString())
     }
 
     test fun join() {
-        val data = arrayListOf("foo", "bar")
+        val data = listOf("foo", "bar")
         val text = data.join("-", "<", ">")
         assertEquals("<foo-bar>", text)
 
-        val big = arrayListOf("a", "b", "c", "d", "e", "f")
+        val big = listOf("a", "b", "c", "d", "e", "f")
         val text2 = big.join(limit = 3, truncated = "*")
         assertEquals("a, b, c, *", text2)
     }
 
     test fun filterNotNull() {
-        val data = arrayListOf(null, "foo", null, "bar")
+        val data = listOf(null, "foo", null, "bar")
         val foo = data.filterNotNull()
 
         assertEquals(2, foo.size())
-        assertEquals(arrayListOf("foo", "bar"), foo)
+        assertEquals(listOf("foo", "bar"), foo)
 
         assertTrue {
             foo is List<String>
@@ -36,10 +36,10 @@ class CollectionTest {
     }
 
     test fun mapNotNull() {
-        val data = arrayListOf(null, "foo", null, "bar")
+        val data = listOf(null, "foo", null, "bar")
-        val foo = data.mapNotNull { it.length }
+        val foo = data.mapNotNull { it.length() }
         assertEquals(2, foo.size())
-        assertEquals(arrayListOf(3, 3), foo)
+        assertEquals(listOf(3, 3), foo)
 
         assertTrue {
             foo is List<Int>
@@ -47,7 +47,7 @@ class CollectionTest {
     }
 
     test fun filterIntoSet() {
-        val data = arrayListOf("foo", "bar")
+        val data = listOf("foo", "bar")
         val foo = data.filterTo(hashSetOf<String>()) { it.startsWith("f") }
 
         assertTrue {
@@ -64,7 +64,7 @@ class CollectionTest {
     test fun fold() {
         // lets calculate the sum of some numbers
         expect(10) {
-            val numbers = arrayListOf(1, 2, 3, 4)
+            val numbers = listOf(1, 2, 3, 4)
             numbers.fold(0) { a, b -> a + b }
         }
 
@@ -75,47 +75,47 @@ class CollectionTest {
 
         // lets concatenate some strings
         expect("1234") {
-            val numbers = arrayListOf(1, 2, 3, 4)
+            val numbers = listOf(1, 2, 3, 4)
             numbers.map { it.toString() }.fold("") { a, b -> a + b }
         }
     }
 
     test fun foldWithDifferentTypes() {
         expect(7) {
-            val numbers = arrayListOf("a", "ab", "abc")
+            val numbers = listOf("a", "ab", "abc")
             numbers.fold(1) { a, b -> a + b.length() }
         }
 
         expect("1234") {
-            val numbers = arrayListOf(1, 2, 3, 4)
+            val numbers = listOf(1, 2, 3, 4)
             numbers.fold("") { a, b -> a + b }
         }
     }
 
     test fun foldWithNonCommutativeOperation() {
         expect(1) {
-            val numbers = arrayListOf(1, 2, 3)
+            val numbers = listOf(1, 2, 3)
             numbers.fold(7) { a, b -> a - b }
         }
     }
 
     test fun foldRight() {
         expect("1234") {
-            val numbers = arrayListOf(1, 2, 3, 4)
+            val numbers = listOf(1, 2, 3, 4)
             numbers.map { it.toString() }.foldRight("") { a, b -> a + b }
         }
     }
 
     test fun foldRightWithDifferentTypes() {
         expect("1234") {
-            val numbers = arrayListOf(1, 2, 3, 4)
+            val numbers = listOf(1, 2, 3, 4)
             numbers.foldRight("") { a, b -> "" + a + b }
         }
     }
 
     test fun foldRightWithNonCommutativeOperation() {
         expect(-5) {
-            val numbers = arrayListOf(1, 2, 3)
+            val numbers = listOf(1, 2, 3)
             numbers.foldRight(7) { a, b -> a - b }
         }
     }
@@ -135,21 +135,21 @@ class CollectionTest {
     }
 
     test fun partition() {
-        val data = arrayListOf("foo", "bar", "something", "xyz")
+        val data = listOf("foo", "bar", "something", "xyz")
         val pair = data.partition { it.length() == 3 }
 
-        assertEquals(arrayListOf("foo", "bar", "xyz"), pair.first, "pair.first")
+        assertEquals(listOf("foo", "bar", "xyz"), pair.first, "pair.first")
-        assertEquals(arrayListOf("something"), pair.second, "pair.second")
+        assertEquals(listOf("something"), pair.second, "pair.second")
     }
 
     test fun reduce() {
         expect("1234") {
-            val list = arrayListOf("1", "2", "3", "4")
+            val list = listOf("1", "2", "3", "4")
             list.reduce { a, b -> a + b }
         }
 
-//        TODO replace with more accurate version when KT-5987 will be fixed
+        //        TODO replace with more accurate version when KT-5987 will be fixed
-//        failsWith(javaClass<UnsupportedOperationException>()) {
+        //        failsWith(javaClass<UnsupportedOperationException>()) {
         fails {
             arrayListOf<Int>().reduce { a, b -> a + b }
         }
@@ -157,20 +157,20 @@ class CollectionTest {
 
     test fun reduceRight() {
         expect("1234") {
-            val list = arrayListOf("1", "2", "3", "4")
+            val list = listOf("1", "2", "3", "4")
             list.reduceRight { a, b -> a + b }
         }
 
-//        TODO replace with more accurate version when KT-5987 will be fixed
+        //        TODO replace with more accurate version when KT-5987 will be fixed
-//        failsWith(javaClass<UnsupportedOperationException>()) {
+        //        failsWith(javaClass<UnsupportedOperationException>()) {
         fails {
             arrayListOf<Int>().reduceRight { a, b -> a + b }
         }
     }
 
     test fun groupBy() {
-        val words = arrayListOf("a", "abc", "ab", "def", "abcd")
+        val words = listOf("a", "abc", "ab", "def", "abcd")
-        val byLength = words.groupBy { it.length }
+        val byLength = words.groupBy { it.length() }
         assertEquals(4, byLength.size())
 
         // verify that order of keys is preserved
@@ -197,45 +197,45 @@ class CollectionTest {
     }
 
     test fun plus() {
-        val list = arrayListOf("foo", "bar")
+        val list = listOf("foo", "bar")
         val list2 = list + "cheese"
-        assertEquals(arrayListOf("foo", "bar"), list)
+        assertEquals(listOf("foo", "bar"), list)
-        assertEquals(arrayListOf("foo", "bar", "cheese"), list2)
+        assertEquals(listOf("foo", "bar", "cheese"), list2)
 
         // lets use a mutable variable
         var list3 = listOf("a", "b")
         list3 += "c"
-        assertEquals(arrayListOf("a", "b", "c"), list3)
+        assertEquals(listOf("a", "b", "c"), list3)
     }
 
     test fun plusCollectionBug() {
-        val list = arrayListOf("foo", "bar") + arrayListOf("cheese", "wine")
+        val list = listOf("foo", "bar") + listOf("cheese", "wine")
-        assertEquals(arrayListOf("foo", "bar", "cheese", "wine"), list)
+        assertEquals(listOf("foo", "bar", "cheese", "wine"), list)
     }
 
     test fun plusCollection() {
-        val a = arrayListOf("foo", "bar")
+        val a = listOf("foo", "bar")
-        val b = arrayListOf("cheese", "wine")
+        val b = listOf("cheese", "wine")
         val list = a + b
-        assertEquals(arrayListOf("foo", "bar", "cheese", "wine"), list)
+        assertEquals(listOf("foo", "bar", "cheese", "wine"), list)
 
         // lets use a mutable variable
         var ml: List<String> = a
         ml += "beer"
         ml += b
         ml += "z"
-        assertEquals(arrayListOf("foo", "bar", "beer", "cheese", "wine", "z"), ml)
+        assertEquals(listOf("foo", "bar", "beer", "cheese", "wine", "z"), ml)
     }
 
     test fun requireNoNulls() {
         val data = arrayListOf<String?>("foo", "bar")
         val notNull = data.requireNoNulls()
-        assertEquals(arrayListOf("foo", "bar"), notNull)
+        assertEquals(listOf("foo", "bar"), notNull)
 
-        val hasNulls = arrayListOf("foo", null, "bar")
+        val hasNulls = listOf("foo", null, "bar")
 
-//        TODO replace with more accurate version when KT-5987 will be fixed
+        //        TODO replace with more accurate version when KT-5987 will be fixed
-//        failsWith(javaClass<IllegalArgumentException>()) {
+        //        failsWith(javaClass<IllegalArgumentException>()) {
         fails {
             // should throw an exception as we have a null
             hasNulls.requireNoNulls()
@@ -243,49 +243,49 @@ class CollectionTest {
     }
 
     test fun reverse() {
-        val data = arrayListOf("foo", "bar")
+        val data = listOf("foo", "bar")
         val rev = data.reverse()
-        assertEquals(arrayListOf("bar", "foo"), rev)
+        assertEquals(listOf("bar", "foo"), rev)
     }
 
     test fun reverseFunctionShouldReturnReversedCopyForList() {
-        val list: List<Int> = arrayListOf(2, 3, 1)
+        val list: List<Int> = listOf(2, 3, 1)
-        expect(arrayListOf(1, 3, 2)) { list.reverse() }
+        expect(listOf(1, 3, 2)) { list.reverse() }
-        expect(arrayListOf(2, 3, 1)) { list }
+        expect(listOf(2, 3, 1)) { list }
     }
 
     test fun reverseFunctionShouldReturnReversedCopyForIterable() {
-        val iterable: Iterable<Int> = arrayListOf(2, 3, 1)
+        val iterable: Iterable<Int> = listOf(2, 3, 1)
-        expect(arrayListOf(1, 3, 2)) { iterable.reverse() }
+        expect(listOf(1, 3, 2)) { iterable.reverse() }
-        expect(arrayListOf(2, 3, 1)) { iterable }
+        expect(listOf(2, 3, 1)) { iterable }
     }
 
 
     test fun drop() {
-        val coll = arrayListOf("foo", "bar", "abc")
+        val coll = listOf("foo", "bar", "abc")
-        assertEquals(arrayListOf("bar", "abc"), coll.drop(1))
+        assertEquals(listOf("bar", "abc"), coll.drop(1))
-        assertEquals(arrayListOf("abc"), coll.drop(2))
+        assertEquals(listOf("abc"), coll.drop(2))
     }
 
     test fun dropWhile() {
-        val coll = arrayListOf("foo", "bar", "abc")
+        val coll = listOf("foo", "bar", "abc")
-        assertEquals(arrayListOf("bar", "abc"), coll.dropWhile { it.startsWith("f") })
+        assertEquals(listOf("bar", "abc"), coll.dropWhile { it.startsWith("f") })
     }
 
     test fun take() {
-        val coll = arrayListOf("foo", "bar", "abc")
+        val coll = listOf("foo", "bar", "abc")
-        assertEquals(arrayListOf("foo"), coll.take(1))
+        assertEquals(listOf("foo"), coll.take(1))
-        assertEquals(arrayListOf("foo", "bar"), coll.take(2))
+        assertEquals(listOf("foo", "bar"), coll.take(2))
     }
 
     test fun takeWhile() {
-        val coll = arrayListOf("foo", "bar", "abc")
+        val coll = listOf("foo", "bar", "abc")
-        assertEquals(arrayListOf("foo"), coll.takeWhile { it.startsWith("f") })
+        assertEquals(listOf("foo"), coll.takeWhile { it.startsWith("f") })
-        assertEquals(arrayListOf("foo", "bar", "abc"), coll.takeWhile { it.length() == 3 })
+        assertEquals(listOf("foo", "bar", "abc"), coll.takeWhile { it.length() == 3 })
     }
 
     test fun copyToArray() {
-        val data = arrayListOf("foo", "bar")
+        val data = listOf("foo", "bar")
         val arr = data.copyToArray()
         println("Got array ${arr}")
         assertEquals(2, arr.size())
@@ -297,25 +297,25 @@ class CollectionTest {
     }
 
     test fun count() {
-        val data = arrayListOf("foo", "bar")
+        val data = listOf("foo", "bar")
         assertEquals(2, data.count())
         assertEquals(3, hashSetOf(12, 14, 15).count())
         assertEquals(0, ArrayList<Double>().count())
     }
 
     test fun first() {
-        val data = arrayListOf("foo", "bar")
+        val data = listOf("foo", "bar")
         assertEquals("foo", data.first())
-        assertEquals(15, arrayListOf(15, 19, 20, 25).first())
+        assertEquals(15, listOf(15, 19, 20, 25).first())
-        assertEquals('a', arrayListOf('a').first())
+        assertEquals('a', listOf('a').first())
         fails { arrayListOf<Int>().first() }
     }
 
     test fun last() {
-        val data = arrayListOf("foo", "bar")
+        val data = listOf("foo", "bar")
         assertEquals("bar", data.last())
-        assertEquals(25, arrayListOf(15, 19, 20, 25).last())
+        assertEquals(25, listOf(15, 19, 20, 25).last())
-        assertEquals('a', arrayListOf('a').last())
+        assertEquals('a', listOf('a').last())
         fails { arrayListOf<Int>().last() }
     }
 
@@ -339,11 +339,11 @@ class CollectionTest {
         }
 
         list.add("works")
-        assertEquals(arrayListOf("new", "thing", "works"), list)
+        assertEquals(listOf("new", "thing", "works"), list)
     }
 
     test fun indices() {
-        val data = arrayListOf("foo", "bar")
+        val data = listOf("foo", "bar")
         val indices = data.indices
         assertEquals(0, indices.start)
         assertEquals(1, indices.end)
@@ -352,21 +352,21 @@ class CollectionTest {
 
     test fun contains() {
         assertFalse(hashSetOf<Int>().contains(12))
-        assertTrue(arrayListOf(15, 19, 20).contains(15))
+        assertTrue(listOf(15, 19, 20).contains(15))
 
         assertTrue(IterableWrapper(hashSetOf(45, 14, 13)).contains(14))
     }
 
     test fun sortForMutableIterable() {
         val list: MutableIterable<Int> = arrayListOf(2, 3, 1)
-        expect(arrayListOf(1, 2, 3)) { list.sort() }
+        expect(listOf(1, 2, 3)) { list.sort() }
-        expect(arrayListOf(2, 3, 1)) { list }
+        expect(listOf(2, 3, 1)) { list }
     }
 
     test fun sortForIterable() {
         val list: Iterable<Int> = listOf(2, 3, 1)
-        expect(arrayListOf(1, 2, 3)) { list.sort() }
+        expect(listOf(1, 2, 3)) { list.sort() }
-        expect(arrayListOf(2, 3, 1)) { list }
+        expect(listOf(2, 3, 1)) { list }
     }
 
     test fun min() {
@@ -396,7 +396,7 @@ class CollectionTest {
         expect(1, { listOf(1).minBy { it } })
         expect(3, { listOf(2, 3).minBy { -it } })
         expect('a', { listOf('a', 'b').minBy { "x$it" } })
-        expect("b", { listOf("b", "abc").minBy { it.length } })
+        expect("b", { listOf("b", "abc").minBy { it.length() } })
         expect(null, { listOf<Int>().stream().minBy { it } })
         expect(3, { listOf(2, 3).stream().minBy { -it } })
     }
@@ -406,7 +406,7 @@ class CollectionTest {
         expect(1, { listOf(1).maxBy { it } })
         expect(2, { listOf(2, 3).maxBy { -it } })
         expect('b', { listOf('a', 'b').maxBy { "x$it" } })
-        expect("abc", { listOf("b", "abc").maxBy { it.length } })
+        expect("abc", { listOf("b", "abc").maxBy { it.length() } })
         expect(null, { listOf<Int>().stream().maxBy { it } })
         expect(2, { listOf(2, 3).stream().maxBy { -it } })
     }
@@ -431,8 +431,8 @@ class CollectionTest {
 
     test fun sum() {
         expect(0) { arrayListOf<Int>().sum() }
-        expect(14) { arrayListOf(2, 3, 9).sum() }
+        expect(14) { listOf(2, 3, 9).sum() }
-        expect(3.0) { arrayListOf(1.0, 2.0).sum() }
+        expect(3.0) { listOf(1.0, 2.0).sum() }
         expect(3000000000000) { arrayListOf<Long>(1000000000000, 2000000000000).sum() }
         expect(3.0.toFloat()) { arrayListOf<Float>(1.0.toFloat(), 2.0.toFloat()).sum() }
         expect(3.0.toFloat()) { streamOf<Float>(1.0.toFloat(), 2.0.toFloat()).sum() }
@@ -450,27 +450,27 @@ class CollectionTest {
     }
 
     test fun sortBy() {
-        expect(arrayListOf("two" to 2, "three" to 3)) {
+        expect(listOf("two" to 2, "three" to 3)) {
-            arrayListOf("three" to 3, "two" to 2).sortBy { it.second }
+            listOf("three" to 3, "two" to 2).sortBy { it.second }
         }
-        expect(arrayListOf("three" to 3, "two" to 2)) {
+        expect(listOf("three" to 3, "two" to 2)) {
-            arrayListOf("three" to 3, "two" to 2).sortBy { it.first }
+            listOf("three" to 3, "two" to 2).sortBy { it.first }
         }
-        expect(arrayListOf("two" to 2, "three" to 3)) {
+        expect(listOf("two" to 2, "three" to 3)) {
-            arrayListOf("three" to 3, "two" to 2).sortBy { it.first.length }
+            listOf("three" to 3, "two" to 2).sortBy { it.first.length() }
         }
     }
 
     test fun sortFunctionShouldReturnSortedCopyForList() {
-        val list: List<Int> = arrayListOf(2, 3, 1)
+        val list: List<Int> = listOf(2, 3, 1)
-        expect(arrayListOf(1, 2, 3)) { list.sort() }
+        expect(listOf(1, 2, 3)) { list.sort() }
-        expect(arrayListOf(2, 3, 1)) { list }
+        expect(listOf(2, 3, 1)) { list }
     }
 
     test fun sortFunctionShouldReturnSortedCopyForIterable() {
-        val list: Iterable<Int> = arrayListOf(2, 3, 1)
+        val list: Iterable<Int> = listOf(2, 3, 1)
-        expect(arrayListOf(1, 2, 3)) { list.sort() }
+        expect(listOf(1, 2, 3)) { list.sort() }
-        expect(arrayListOf(2, 3, 1)) { list }
+        expect(listOf(2, 3, 1)) { list }
     }
 
     test fun decomposeFirst() {

libraries/stdlib/test/collections/IterableJVMTests.kt

@@ -1,7 +1,5 @@
 package test.collections
 
-import org.junit.Test
-import kotlin.test.*
 import java.util.*
 
 class LinkedSetTest : OrderedIterableTests<Set<String>>(setOf("foo", "bar"), setOf<String>())

libraries/stdlib/test/collections/IterableTests.kt

@@ -4,7 +4,7 @@ import org.junit.Test
 import kotlin.test.*
 import java.util.*
 
-fun <T> iterableOf(vararg items : T) : Iterable<T> = IterableWrapper(items.toList())
+fun <T> iterableOf(vararg items: T): Iterable<T> = IterableWrapper(items.toList())
 
 class IterableWrapper<T>(collection: Iterable<T>) : Iterable<T> {
     private val collection = collection
@@ -89,7 +89,7 @@ abstract class IterableTests<T : Iterable<String>>(val data: T, val empty: T) {
     }
 
     Test fun all() {
-        expect(true) { data.all { it.length == 3 } }
+        expect(true) { data.all { it.length() == 3 } }
         expect(false) { data.all { it.startsWith("b") } }
         expect(true) { empty.all { it.startsWith("b") } }
     }
@@ -97,7 +97,7 @@ abstract class IterableTests<T : Iterable<String>>(val data: T, val empty: T) {
     Test fun none() {
         expect(false) { data.none() }
         expect(true) { empty.none() }
-        expect(false) { data.none { it.length == 3 } }
+        expect(false) { data.none { it.length() == 3 } }
         expect(false) { data.none { it.startsWith("b") } }
         expect(true) { data.none { it.startsWith("x") } }
         expect(true) { empty.none { it.startsWith("b") } }
@@ -121,7 +121,7 @@ abstract class IterableTests<T : Iterable<String>>(val data: T, val empty: T) {
 
     Test fun forEach() {
         var count = 0
-        data.forEach { count += it.length }
+        data.forEach { count += it.length() }
         assertEquals(6, count)
     }
 
@@ -138,7 +138,7 @@ abstract class IterableTests<T : Iterable<String>>(val data: T, val empty: T) {
         expect("foo") { data.single { it.startsWith("f") } }
         expect("bar") { data.single { it.startsWith("b") } }
         fails {
-            data.single { it.length == 3 }
+            data.single { it.length() == 3 }
         }
     }
 
@@ -149,32 +149,32 @@ abstract class IterableTests<T : Iterable<String>>(val data: T, val empty: T) {
         expect("foo") { data.singleOrNull { it.startsWith("f") } }
         expect("bar") { data.singleOrNull { it.startsWith("b") } }
         expect(null) {
-            data.singleOrNull { it.length == 3 }
+            data.singleOrNull { it.length() == 3 }
         }
     }
 
     Test
     fun map() {
-        val lengths = data.map { it.length }
+        val lengths = data.map { it.length() }
         assertTrue {
             lengths.all { it == 3 }
         }
         assertEquals(2, lengths.size())
-        assertEquals(arrayListOf(3, 3), lengths)
+        assertEquals(listOf(3, 3), lengths)
     }
 
     Test
     fun mapIndexed() {
-        val shortened = data.mapIndexed { (index, value)-> value.substring(0..index) }
+        val shortened = data.mapIndexed {(index, value) -> value.substring(0..index) }
         assertEquals(2, shortened.size())
-        assertEquals(arrayListOf("f", "ba"), shortened)
+        assertEquals(listOf("f", "ba"), shortened)
     }
 
     Test
     fun withIndex() {
         val indexed = data.withIndex().map { it.value.substring(0..it.index) }
         assertEquals(2, indexed.size())
-        assertEquals(arrayListOf("f", "ba"), indexed)
+        assertEquals(listOf("f", "ba"), indexed)
     }
 
     Test
@@ -204,7 +204,7 @@ abstract class IterableTests<T : Iterable<String>>(val data: T, val empty: T) {
     Test
     fun withIndices() {
         var index = 0
-        for ((i, d) in data.withIndices()) {
+        for ((i, d) in data.withIndex()) {
             assertEquals(i, index)
             assertEquals(d, data.elementAt(index))
             index++
@@ -214,12 +214,12 @@ abstract class IterableTests<T : Iterable<String>>(val data: T, val empty: T) {
 
     Test
     fun fold() {
-        expect(231) { data.fold(1, {a, b -> a + if (b == "foo") 200 else 30 }) }
+        expect(231) { data.fold(1, { a, b -> a + if (b == "foo") 200 else 30 }) }
     }
 
     Test
     fun reduce() {
-        val reduced = data.reduce {a, b -> a + b }
+        val reduced = data.reduce { a, b -> a + b }
         assertEquals(6, reduced.length())
         assertTrue(reduced == "foobar" || reduced == "barfoo")
     }

libraries/stdlib/test/collections/IteratorsJVMTest.kt

@@ -8,11 +8,11 @@ class IteratorsJVMTest {
 
     test fun testEnumeration() {
         val v = Vector<Int>()
-        for(i in 1..5)
+        for (i in 1..5)
             v.add(i)
 
         var sum = 0
-        for(k in v.elements())
+        for (k in v.elements())
             sum += k
 
         assertEquals(15, sum)

libraries/stdlib/test/collections/IteratorsTest.kt

@@ -5,7 +5,7 @@ import org.junit.Test as test
 
 class IteratorsTest {
     test fun iterationOverIterator() {
-        val c = arrayListOf(0, 1, 2, 3, 4, 5)
+        val c = listOf(0, 1, 2, 3, 4, 5)
         var s = ""
         for (i in c.iterator()) {
             s = s + i.toString()

libraries/stdlib/test/collections/ListSpecificTest.kt

@@ -12,10 +12,9 @@ class ListSpecificTest {
     }
 
     Test fun tail() {
-        val data = arrayListOf("foo", "bar", "whatnot")
+        val data = listOf("foo", "bar", "whatnot")
         val actual = data.drop(1)
-        val expected = arrayListOf("bar", "whatnot")
+        assertEquals(listOf("bar", "whatnot"), actual)
-        assertEquals(expected, actual)
     }
 
     Test fun slice() {

libraries/stdlib/test/collections/MapJVMTest.kt

@@ -9,7 +9,7 @@ class MapJVMTest {
         assertEquals(1, map["a"])
         assertEquals(2, map["b"])
         assertEquals(3, map["c"])
-        assertEquals(arrayListOf("a", "b", "c"), map.keySet().toList())
+        assertEquals(listOf("a", "b", "c"), map.keySet().toList())
     }
 
     test fun toSortedMap() {
@@ -18,13 +18,13 @@ class MapJVMTest {
         assertEquals(1, sorted["a"])
         assertEquals(2, sorted["b"])
         assertEquals(3, sorted["c"])
-        assertEquals(arrayListOf("a", "b", "c"), sorted.keySet().toList())
+        assertEquals(listOf("a", "b", "c"), sorted.keySet().toList())
     }
 
     test fun toSortedMapWithComparator() {
         val map = mapOf(Pair("c", 3), Pair("bc", 2), Pair("bd", 4), Pair("abc", 1))
         val sorted = map.toSortedMap(compareBy<String> { it.length() } thenBy { it })
-        assertEquals(arrayListOf("c", "bc", "bd", "abc"), sorted.keySet().toList())
+        assertEquals(listOf("c", "bc", "bd", "abc"), sorted.keySet().toList())
         assertEquals(1, sorted["abc"])
         assertEquals(2, sorted["bc"])
         assertEquals(3, sorted["c"])

libraries/stdlib/test/collections/MapTest.kt

@@ -51,7 +51,7 @@ class MapTest {
         assertEquals(map.size(), 1)
         assertEquals("James", map["name"])
     }
-   
+
     test fun iterate() {
         val map = mapOf("beverage" to "beer", "location" to "Mells", "name" to "James")
         val list = arrayListOf<String>()
@@ -98,7 +98,7 @@ class MapTest {
         val m1 = mapOf("beverage" to "beer", "location" to "Mells")
         val list = m1.map { it.value + " rocks" }
 
-        assertEquals(arrayListOf("beer rocks", "Mells rocks"), list)
+        assertEquals(listOf("beer rocks", "Mells rocks"), list)
     }
 
     test fun mapValues() {
@@ -132,7 +132,7 @@ class MapTest {
     }
 
     test fun createWithSelector() {
-        val map = listOf("a", "bb", "ccc").toMap { it.length }
+        val map = listOf("a", "bb", "ccc").toMap { it.length() }
         assertEquals(3, map.size())
         assertEquals("a", map.get(1))
         assertEquals("bb", map.get(2))
@@ -140,7 +140,7 @@ class MapTest {
     }
 
     test fun createWithSelectorAndOverwrite() {
-        val map = listOf("aa", "bb", "ccc").toMap { it.length }
+        val map = listOf("aa", "bb", "ccc").toMap { it.length() }
         assertEquals(2, map.size())
         assertEquals("bb", map.get(2))
         assertEquals("ccc", map.get(3))
@@ -158,7 +158,7 @@ class MapTest {
         assertEquals(1, map["a"])
         assertEquals(2, map["b"])
         assertEquals(3, map["c"])
-        assertEquals(arrayListOf("c", "b", "a"), map.keySet().toList())
+        assertEquals(listOf("c", "b", "a"), map.keySet().toList())
     }
 
     test fun filter() {

libraries/stdlib/test/collections/MutableCollectionsTest.kt

@@ -9,7 +9,7 @@ import org.junit.Test as test
 class MutableCollectionTest {
 
     test fun fromIterable() {
-        val data: Iterable<String> = arrayListOf("foo", "bar")
+        val data: Iterable<String> = listOf("foo", "bar")
 
         val collection = ArrayList<String>()
         collection.addAll(data)
@@ -18,7 +18,7 @@ class MutableCollectionTest {
     }
 
     test fun fromStream() {
-        val list = arrayListOf("foo", "bar")
+        val list = listOf("foo", "bar")
         val collection = ArrayList<String>()
 
         collection.addAll(list.stream())

libraries/stdlib/test/collections/StreamJVMTest.kt

@@ -6,21 +6,21 @@ import kotlin.test.assertEquals
 class StreamJVMTest {
 
     test fun filterIsInstance() {
-        val src: Stream<Any> = listOf(1,2,3.toDouble(), "abc", "cde").stream()
+        val src: Stream<Any> = listOf(1, 2, 3.toDouble(), "abc", "cde").stream()
 
-        val ints: Stream<Int> = src.filterIsInstance<Int>()
+        val intValues: Stream<Int> = src.filterIsInstance<Int>()
-        assertEquals(arrayListOf(1,2), ints.toArrayList())
+        assertEquals(listOf(1, 2), intValues.toArrayList())
 
-        val doubles: Stream<Double> = src.filterIsInstance<Double>()
+        val doubleValues: Stream<Double> = src.filterIsInstance<Double>()
-        assertEquals(arrayListOf(3.0), doubles.toArrayList())
+        assertEquals(listOf(3.0), doubleValues.toArrayList())
 
-        val strings: Stream<String> = src.filterIsInstance<String>()
+        val stringValues: Stream<String> = src.filterIsInstance<String>()
-        assertEquals(arrayListOf("abc", "cde"), strings.toArrayList())
+        assertEquals(listOf("abc", "cde"), stringValues.toArrayList())
 
-        val anys: Stream<Any> = src.filterIsInstance<Any>()
+        val anyValues: Stream<Any> = src.filterIsInstance<Any>()
-        assertEquals(src.toList(), anys.toArrayList())
+        assertEquals(src.toList(), anyValues.toArrayList())
 
-        val chars: Stream<Char> = src.filterIsInstance<Char>()
+        val charValues: Stream<Char> = src.filterIsInstance<Char>()
-        assertEquals(0, chars.toArrayList().size())
+        assertEquals(0, charValues.toArrayList().size())
     }
 }

libraries/stdlib/test/collections/StreamTest.kt

@@ -34,7 +34,7 @@ public class StreamTest {
     test fun requireNoNulls() {
         val stream = streamOf<String?>("foo", "bar")
         val notNull = stream.requireNoNulls()
-        assertEquals(arrayListOf("foo", "bar"), notNull.toList())
+        assertEquals(listOf("foo", "bar"), notNull.toList())
 
         val streamWithNulls = streamOf("foo", null, "bar")
         val notNull2 = streamWithNulls.requireNoNulls() // shouldn't fail yet
@@ -47,19 +47,19 @@ public class StreamTest {
     test fun filterNullable() {
         val data = streamOf(null, "foo", null, "bar")
         val filtered = data.filter { it == null || it == "foo" }
-        assertEquals(arrayListOf(null, "foo", null), filtered.toList())
+        assertEquals(listOf(null, "foo", null), filtered.toList())
     }
 
     test fun filterNotNull() {
         val data = streamOf(null, "foo", null, "bar")
         val filtered = data.filterNotNull()
-        assertEquals(arrayListOf("foo", "bar"), filtered.toList())
+        assertEquals(listOf("foo", "bar"), filtered.toList())
     }
 
     test fun mapNotNull() {
         val data = streamOf(null, "foo", null, "bar")
-        val foo = data.mapNotNull { it.length }
+        val foo = data.mapNotNull { it.length() }
-        assertEquals(arrayListOf(3, 3), foo.toList())
+        assertEquals(listOf(3, 3), foo.toList())
 
         assertTrue {
             foo is Stream<Int>
@@ -67,20 +67,20 @@ public class StreamTest {
     }
 
     test fun filterAndTakeWhileExtractTheElementsWithinRange() {
-        assertEquals(arrayListOf(144, 233, 377, 610, 987), fibonacci().filter { it > 100 }.takeWhile { it < 1000 }.toList())
+        assertEquals(listOf(144, 233, 377, 610, 987), fibonacci().filter { it > 100 }.takeWhile { it < 1000 }.toList())
     }
 
     test fun foldReducesTheFirstNElements() {
         val sum = {(a: Int, b: Int) -> a + b }
-        assertEquals(arrayListOf(13, 21, 34, 55, 89).fold(0, sum), fibonacci().filter { it > 10 }.take(5).fold(0, sum))
+        assertEquals(listOf(13, 21, 34, 55, 89).fold(0, sum), fibonacci().filter { it > 10 }.take(5).fold(0, sum))
     }
 
     test fun takeExtractsTheFirstNElements() {
-        assertEquals(arrayListOf(0, 1, 1, 2, 3, 5, 8, 13, 21, 34), fibonacci().take(10).toList())
+        assertEquals(listOf(0, 1, 1, 2, 3, 5, 8, 13, 21, 34), fibonacci().take(10).toList())
     }
 
     test fun mapAndTakeWhileExtractTheTransformedElements() {
-        assertEquals(arrayListOf(0, 3, 3, 6, 9, 15), fibonacci().map { it * 3 }.takeWhile {(i: Int) -> i < 20 }.toList())
+        assertEquals(listOf(0, 3, 3, 6, 9, 15), fibonacci().map { it * 3 }.takeWhile {(i: Int) -> i < 20 }.toList())
     }
 
     test fun joinConcatenatesTheFirstNElementsAboveAThreshold() {
@@ -162,7 +162,7 @@ public class StreamTest {
 
     test fun streamFromFunctionWithInitialValue() {
         val values = stream(3) { n -> if (n > 0) n - 1 else null }
-        assertEquals(arrayListOf(3, 2, 1, 0), values.toList())
+        assertEquals(listOf(3, 2, 1, 0), values.toList())
     }
 
     private fun <T, C : MutableCollection<in T>> Stream<T>.takeWhileTo(result: C, predicate: (T) -> Boolean): C {
@@ -177,7 +177,7 @@ public class StreamTest {
     }
 
     test fun flatMapAndTakeExtractTheTransformedElements() {
-        val expected = arrayListOf(
+        val expected = listOf(
                 '3', // fibonacci(4) = 3
                 '5', // fibonacci(5) = 5
                 '8', // fibonacci(6) = 8
@@ -185,7 +185,7 @@ public class StreamTest {
                 '2', '1', // fibonacci(8) = 21
                 '3', '4', // fibonacci(9) = 34
                 '5' // fibonacci(10) = 55
-                                  )
+                             )
 
         assertEquals(expected, fibonacci().drop(4).flatMap { it.toString().stream() }.take(10).toList())
     }