Collection tests: format and fix usages of deprecated symbols.

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")
     }