Reformat stdlib tests and samples

#KT-5558

libraries/stdlib/js/test/core/PromiseTest.kt

@@ -24,33 +24,33 @@ class PromiseTest {
         assertStaticTypeIs<Promise<Int>>(p.then(f, ft))
 
         assertStaticTypeIs<Promise<Int>>(
-                    p.then({
+            p.then({
-                        1
+                       1
-                    } , {
+                   }, {
-                        1
+                       1
-                    })
+                   })
         )
 
         assertStaticTypeIs<Promise<Int>>(
-                    p.then({
+            p.then({
-                        1
+                       1
-                    }) {
+                   }) {
-                        1
+                1
-                    }
+            }
         )
 
         assertStaticTypeIs<Promise<Int>>(
-                    p.then(onFulfilled = {
+            p.then(onFulfilled = {
-                        1
+                1
-                    })
+            })
         )
 
         assertStaticTypeIs<Promise<Int>>(
-                    p.then(onFulfilled = {
+            p.then(onFulfilled = {
-                        1
+                1
-                    }) {
+            }) {
-                        1
+                1
-                    }
+            }
         )
 
         p.then {
@@ -59,12 +59,12 @@ class PromiseTest {
             assertStaticAndRuntimeTypeIs<String>(it)
             ps
         }.then(
-                {
+            {
-                    assertStaticAndRuntimeTypeIs<String>(it)
+                assertStaticAndRuntimeTypeIs<String>(it)
-                },
+            },
-                {
+            {
 
-                }
+            }
         )
     }
 }

libraries/stdlib/jvm/test/collections/CollectionJVMTest.kt

@@ -192,16 +192,16 @@ class CollectionJVMTest {
     }
 
     @Test fun deserializeEmptyList() = testPersistedDeserialization(
-            "ac ed 00 05 73 72 00 1c 6b 6f 74 6c 69 6e 2e 63 6f 6c 6c 65 63 74 69 6f 6e 73 2e 45 6d 70 74 79 4c 69 73 74 99 6f c7 d0 a7 e0 60 32 02 00 00 78 70",
+        "ac ed 00 05 73 72 00 1c 6b 6f 74 6c 69 6e 2e 63 6f 6c 6c 65 63 74 69 6f 6e 73 2e 45 6d 70 74 79 4c 69 73 74 99 6f c7 d0 a7 e0 60 32 02 00 00 78 70",
-            emptyList<Any>())
+        emptyList<Any>())
 
     @Test fun deserializeEmptySet() = testPersistedDeserialization(
-            "ac ed 00 05 73 72 00 1b 6b 6f 74 6c 69 6e 2e 63 6f 6c 6c 65 63 74 69 6f 6e 73 2e 45 6d 70 74 79 53 65 74 2f 46 b0 15 76 d7 e2 f4 02 00 00 78 70",
+        "ac ed 00 05 73 72 00 1b 6b 6f 74 6c 69 6e 2e 63 6f 6c 6c 65 63 74 69 6f 6e 73 2e 45 6d 70 74 79 53 65 74 2f 46 b0 15 76 d7 e2 f4 02 00 00 78 70",
-            emptySet<Any>())
+        emptySet<Any>())
 
     @Test fun deserializeEmptyMap() = testPersistedDeserialization(
-            "ac ed 00 05 73 72 00 1b 6b 6f 74 6c 69 6e 2e 63 6f 6c 6c 65 63 74 69 6f 6e 73 2e 45 6d 70 74 79 4d 61 70 72 72 37 71 cb 04 4c d2 02 00 00 78 70",
+        "ac ed 00 05 73 72 00 1b 6b 6f 74 6c 69 6e 2e 63 6f 6c 6c 65 63 74 69 6f 6e 73 2e 45 6d 70 74 79 4d 61 70 72 72 37 71 cb 04 4c d2 02 00 00 78 70",
-            emptyMap<Any, Any>())
+        emptyMap<Any, Any>())
 
     private fun testPersistedDeserialization(hexValue: String, expected: Any) {
         val actual = deserializeFromHex<Any>(hexValue)

libraries/stdlib/jvm/test/collections/IterableJVMTests.kt

@@ -7,5 +7,5 @@ package test.collections
 
 import java.util.*
 
-class LinkedListTest : OrderedIterableTests<LinkedList<String>>( { LinkedList(it.asList()) }, LinkedList<String>())
+class LinkedListTest : OrderedIterableTests<LinkedList<String>>({ LinkedList(it.asList()) }, LinkedList<String>())
 

libraries/stdlib/jvm/test/concurrent/ThreadTest.kt

@@ -46,7 +46,7 @@ class ThreadTest {
         assertEquals("v3", v.getOrSet { "v2" })
 
 
-        val w = object: ThreadLocal<String>() {
+        val w = object : ThreadLocal<String>() {
             override fun initialValue() = "default"
         }
 

libraries/stdlib/jvm/test/io/Console.kt

@@ -4,6 +4,7 @@
  */
 
 @file:Suppress("INVISIBLE_REFERENCE", "INVISIBLE_MEMBER")
+
 package test.io
 
 import org.junit.Test

libraries/stdlib/jvm/test/io/Files.kt

@@ -521,8 +521,7 @@ class FilesTest {
             }
 
             var conflicts = 0
-            src.copyRecursively(dst) {
+            src.copyRecursively(dst) { _: File, e: IOException ->
-                _: File, e: IOException ->
                 if (e is FileAlreadyExistsException) {
                     conflicts++
                     OnErrorAction.SKIP
@@ -536,8 +535,7 @@ class FilesTest {
                 try {
                     dst.deleteRecursively()
                     var caught = false
-                    assertTrue(src.copyRecursively(dst) {
+                    assertTrue(src.copyRecursively(dst) { _: File, e: IOException ->
-                        _: File, e: IOException ->
                         if (e is AccessDeniedException) {
                             caught = true
                             OnErrorAction.SKIP

libraries/stdlib/jvm/test/io/IOStreams.kt

@@ -36,7 +36,7 @@ class IOStreamsTest {
         val result = mutableListOf<Byte>()
 
         x.inputStream().buffered().use { stream ->
-            for(b in stream) {
+            for (b in stream) {
                 result += b
             }
         }

libraries/stdlib/jvm/test/io/SerializableTest.kt

@@ -87,5 +87,5 @@ private fun hexToBytes(value: String): ByteArray = value.split(" ").map { Intege
 public fun <T> deserializeFromHex(value: String) = deserializeFromByteArray<T>(hexToBytes(value))
 
 public fun <T> serializeToHex(value: T) =
-        serializeToByteArray(value).joinToString(" ") { (it.toInt() and 0xFF).toString(16).padStart(2, '0') }
+    serializeToByteArray(value).joinToString(" ") { (it.toInt() and 0xFF).toString(16).padStart(2, '0') }
 

libraries/stdlib/jvm/test/numbers/BigNumbersTest.kt

@@ -39,7 +39,7 @@ class BigNumbersTest {
         assertEquals(BigInteger("-1"), -a shr 1)
         assertEquals(BigInteger("-1"), -a shr 2)
 
-        assertEquals(BigInteger("2"),  2.toBigInteger())
+        assertEquals(BigInteger("2"), 2.toBigInteger())
         assertEquals(BigInteger("-3"), -3L.toBigInteger())
 
         assertEquals(BigDecimal("2"), a.toBigDecimal())
@@ -50,7 +50,6 @@ class BigNumbersTest {
         assertEquals(BigDecimal("3"), BigInteger("253").toBigDecimal(2, MathContext(1, RoundingMode.UP)))
 
 
-
         var c = 2.toBigInteger()
         assertEquals(BigInteger("2"), c++)
         assertEquals(BigInteger("3"), c)
@@ -79,10 +78,10 @@ class BigNumbersTest {
         assertEquals(BigDecimal("3"), a.inc())
         assertEquals(BigDecimal("1"), a.dec())
 
-        assertEquals(BigDecimal("2"),  2.toBigDecimal())
+        assertEquals(BigDecimal("2"), 2.toBigDecimal())
         assertEquals(BigDecimal("-3"), -3L.toBigDecimal())
         assertEquals(BigDecimal("2.0"), 2f.toBigDecimal())
-        assertEquals(BigDecimal("0.5"),  0.5.toBigDecimal())
+        assertEquals(BigDecimal("0.5"), 0.5.toBigDecimal())
 
         var c = "1.5".toBigDecimal()
         assertEquals(BigDecimal("1.5"), c++)

libraries/stdlib/jvm/test/utils/LazyJVMTest.kt

@@ -87,7 +87,7 @@ class LazyJVMTest {
                      List(threads) { lazy(lock, initializer) }
                  },
                  access = { lazies, runnerIndex -> lazies[runnerIndex].value },
-                 validate = { result -> result.all { (id, initialized) -> initialized == (id != 1)} })
+                 validate = { result -> result.all { (id, initialized) -> initialized == (id != 1) } })
     }
 
     @Test fun publishOnceLazy() {
@@ -95,7 +95,9 @@ class LazyJVMTest {
         val initialized = AtomicBoolean(false)
         val threads = 3
         val values = Random().let { r -> List(threads) { 50 + r.nextInt(50) } }
+
         data class Run(val value: Int, val initialized: Boolean)
+
         val runs = ConcurrentLinkedQueue<Run>()
 
         val initializer = {
@@ -124,11 +126,11 @@ class LazyJVMTest {
     @Test fun publishOnceLazyRace() {
         racyTest(initialize = { lazy(LazyThreadSafetyMode.PUBLICATION) { Thread.currentThread().id } },
                  access = { lazy, _ -> lazy.value },
-                 validate = { result -> result.all { v -> v == result[0] } } )
+                 validate = { result -> result.all { v -> v == result[0] } })
     }
 
     @Test fun lazyInitializationForcedOnSerialization() {
-        for(mode in listOf(LazyThreadSafetyMode.SYNCHRONIZED, LazyThreadSafetyMode.PUBLICATION, LazyThreadSafetyMode.NONE)) {
+        for (mode in listOf(LazyThreadSafetyMode.SYNCHRONIZED, LazyThreadSafetyMode.PUBLICATION, LazyThreadSafetyMode.NONE)) {
             val lazy = lazy(mode) { "initialized" }
             assertFalse(lazy.isInitialized())
             val lazy2 = serializeAndDeserialize(lazy)
@@ -139,10 +141,11 @@ class LazyJVMTest {
     }
 
     private fun <TState : Any, TResult> racyTest(
-            threads: Int = 3, runs: Int = 5000,
+        threads: Int = 3, runs: Int = 5000,
-            initialize: () -> TState,
+        initialize: () -> TState,
-            access: (TState, runnerIndex: Int) -> TResult,
+        access: (TState, runnerIndex: Int) -> TResult,
-            validate: (List<TResult>) -> Boolean) {
+        validate: (List<TResult>) -> Boolean
+    ) {
 
         val runResult = java.util.Collections.synchronizedList(mutableListOf<TResult>())
         val invalidResults = mutableListOf<Pair<Int, List<TResult>>>()
@@ -159,13 +162,15 @@ class LazyJVMTest {
             runId += 1
         }
 
-        val runners = List(threads) { index -> thread {
+        val runners = List(threads) { index ->
-            barrier.await()
+            thread {
-            repeat(runs) {
-                runResult += access(state, index)
                 barrier.await()
+                repeat(runs) {
+                    runResult += access(state, index)
+                    barrier.await()
+                }
             }
-        }}
+        }
 
         runners.forEach { it.join() }
 

libraries/stdlib/samples/test/samples/collections/arrays.kt

@@ -40,9 +40,9 @@ class Arrays {
         @Sample
         fun flattenArray() {
             val deepArray = arrayOf(
-                    arrayOf(1),
+                arrayOf(1),
-                    arrayOf(2, 3),
+                arrayOf(2, 3),
-                    arrayOf(4, 5, 6)
+                arrayOf(4, 5, 6)
             )
 
             assertPrints(deepArray.flatten(), "[1, 2, 3, 4, 5, 6]")
@@ -67,9 +67,9 @@ class Arrays {
         @Sample
         fun contentDeepToString() {
             val matrix = arrayOf(
-                    intArrayOf(3, 7, 9),
+                intArrayOf(3, 7, 9),
-                    intArrayOf(0, 1, 0),
+                intArrayOf(0, 1, 0),
-                    intArrayOf(2, 4, 8)
+                intArrayOf(2, 4, 8)
             )
 
             assertPrints(matrix.contentDeepToString(), "[[3, 7, 9], [0, 1, 0], [2, 4, 8]]")

libraries/stdlib/samples/test/samples/collections/sequences.kt

@@ -40,8 +40,8 @@ class Sequences {
             class LinkedValue<T>(val value: T, val next: LinkedValue<T>? = null)
 
             fun <T> LinkedValue<T>?.asSequence(): Sequence<LinkedValue<T>> = generateSequence(
-                    seedFunction = { this },
+                seedFunction = { this },
-                    nextFunction = { it.next }
+                nextFunction = { it.next }
             )
 
             fun <T> LinkedValue<T>?.valueSequence(): Sequence<T> = asSequence().map { it.value }
@@ -116,7 +116,7 @@ class Sequences {
                 var terms = Pair(0, 1)
 
                 // this sequence is infinite
-                while(true) {
+                while (true) {
                     yield(terms.first)
                     terms = Pair(terms.second, terms.first + terms.second)
                 }

libraries/stdlib/samples/test/samples/comparisons/comparisons.kt

@@ -23,7 +23,7 @@ class Comparisons {
     @Sample
     fun compareValuesByWithSingleSelector() {
         fun compareLength(a: String, b: String): Int =
-                compareValuesBy(a, b) { it.length }
+            compareValuesBy(a, b) { it.length }
 
         assertTrue(compareLength("a", "b") == 0)
         assertTrue(compareLength("bb", "a") > 0)
@@ -33,7 +33,7 @@ class Comparisons {
     @Sample
     fun compareValuesByWithSelectors() {
         fun compareLengthThenString(a: String, b: String): Int =
-                compareValuesBy(a, b, { it.length }, { it })
+            compareValuesBy(a, b, { it.length }, { it })
 
         assertTrue(compareLengthThenString("b", "aa") < 0)
 
@@ -45,7 +45,7 @@ class Comparisons {
     @Sample
     fun compareValuesByWithComparator() {
         fun compareInsensitiveOrder(a: Char, b: Char): Int =
-                compareValuesBy(a, b, String.CASE_INSENSITIVE_ORDER, { c -> c.toString() })
+            compareValuesBy(a, b, String.CASE_INSENSITIVE_ORDER, { c -> c.toString() })
 
         assertTrue(compareInsensitiveOrder('a', 'a') == 0)
         assertTrue(compareInsensitiveOrder('a', 'A') == 0)
@@ -77,8 +77,8 @@ class Comparisons {
         val list = listOf("aa", "b", "bb", "a")
 
         val sorted = list.sortedWith(compareBy(
-                { it.length },
+            { it.length },
-                { it }
+            { it }
         ))
 
         assertPrints(sorted, "[a, b, aa, bb]")
@@ -89,7 +89,7 @@ class Comparisons {
         val list = listOf('B', 'a', 'A', 'b')
 
         val sorted = list.sortedWith(
-                compareBy(String.CASE_INSENSITIVE_ORDER) { v -> v.toString() }
+            compareBy(String.CASE_INSENSITIVE_ORDER) { v -> v.toString() }
         )
 
         assertPrints(sorted, "[a, A, B, b]")
@@ -109,7 +109,7 @@ class Comparisons {
         val list = listOf('B', 'a', 'A', 'b')
 
         val sorted = list.sortedWith(
-                compareByDescending(String.CASE_INSENSITIVE_ORDER) { v -> v.toString() }
+            compareByDescending(String.CASE_INSENSITIVE_ORDER) { v -> v.toString() }
         )
 
         assertPrints(sorted, "[B, b, a, A]")
@@ -134,7 +134,7 @@ class Comparisons {
         assertPrints(list.sortedWith(lengthComparator), "[A, b, a, aa, bb]")
 
         val lengthThenCaseInsensitive = lengthComparator
-                .thenBy(String.CASE_INSENSITIVE_ORDER) { it }
+            .thenBy(String.CASE_INSENSITIVE_ORDER) { it }
         assertPrints(list.sortedWith(lengthThenCaseInsensitive), "[A, a, b, aa, bb]")
     }
 
@@ -157,7 +157,7 @@ class Comparisons {
         assertPrints(list.sortedWith(lengthComparator), "[A, b, a, aa, bb]")
 
         val lengthThenCaseInsensitive = lengthComparator
-                .thenByDescending(String.CASE_INSENSITIVE_ORDER) { it }
+            .thenByDescending(String.CASE_INSENSITIVE_ORDER) { it }
         assertPrints(list.sortedWith(lengthThenCaseInsensitive), "[b, A, a, bb, aa]")
     }
 
@@ -170,7 +170,7 @@ class Comparisons {
         assertPrints(map1, "{d=0, null=0, c=1, a=1, b=2}")
 
         val valueThenKeyComparator = valueComparator
-                .thenComparator({ a, b -> compareValues(a.first, b.first) })
+            .thenComparator({ a, b -> compareValues(a.first, b.first) })
         val map2 = list.sortedWith(valueThenKeyComparator).toMap()
         assertPrints(map2, "{null=0, d=0, a=1, c=1, b=2}")
     }
@@ -180,7 +180,7 @@ class Comparisons {
         val list = listOf("A", "aa", "b", "bb", "a")
 
         val lengthThenCaseInsensitive = compareBy<String> { it.length }
-                .then(String.CASE_INSENSITIVE_ORDER)
+            .then(String.CASE_INSENSITIVE_ORDER)
 
         val sorted = list.sortedWith(lengthThenCaseInsensitive)
 
@@ -192,7 +192,7 @@ class Comparisons {
         val list = listOf("A", "aa", "b", "bb", "a")
 
         val lengthThenCaseInsensitive = compareBy<String> { it.length }
-                .thenDescending(String.CASE_INSENSITIVE_ORDER)
+            .thenDescending(String.CASE_INSENSITIVE_ORDER)
 
         val sorted = list.sortedWith(lengthThenCaseInsensitive)
 
@@ -226,7 +226,7 @@ class Comparisons {
         val list = listOf("aa", "b", "bb", "a")
 
         val lengthThenNatural = compareBy<String> { it.length }
-                .then(naturalOrder())
+            .then(naturalOrder())
 
         val sorted = list.sortedWith(lengthThenNatural)
 

libraries/stdlib/test/ExceptionTest.kt

@@ -29,7 +29,12 @@ class ExceptionTest {
     @Test fun assertionError() = testCreateException(::AssertionError, ::AssertionError, ::AssertionError)
 
 
-    private fun <T : Throwable> testCreateException(noarg: () -> T, fromMessage: (String?) -> T, fromCause: ((Throwable?) -> T)? = null, fromMessageCause: ((String?, Throwable?) -> T)? = null) {
+    private fun <T : Throwable> testCreateException(
+        noarg: () -> T,
+        fromMessage: (String?) -> T,
+        fromCause: ((Throwable?) -> T)? = null,
+        fromMessageCause: ((String?, Throwable?) -> T)? = null
+    ) {
         noarg().let { e ->
             assertEquals(null, e.message)
             assertEquals(null, e.cause)

libraries/stdlib/test/OrderingTest.kt

@@ -14,7 +14,8 @@ data class Item(val name: String, val rating: Int) : Comparable<Item> {
     }
 }
 
-val STRING_CASE_INSENSITIVE_ORDER: Comparator<String> = compareBy { it: String -> it.toUpperCase() }.thenBy { it.toLowerCase() }.thenBy { it }
+val STRING_CASE_INSENSITIVE_ORDER: Comparator<String> =
+    compareBy { it: String -> it.toUpperCase() }.thenBy { it.toLowerCase() }.thenBy { it }
 
 class OrderingTest {
     val v1 = Item("wine", 9)
@@ -72,13 +73,13 @@ class OrderingTest {
         val byRating = compareBy<Item> { it.rating }
         val v3 = Item(v1.name, v1.rating + 1)
         val v4 = Item(v2.name + "_", v2.rating)
-        assertTrue( (byName then byRating).compare(v1, v2) > 0 )
+        assertTrue((byName then byRating).compare(v1, v2) > 0)
-        assertTrue( (byName then byRating).compare(v1, v3) < 0 )
+        assertTrue((byName then byRating).compare(v1, v3) < 0)
-        assertTrue( (byName thenDescending byRating).compare(v1, v3) > 0 )
+        assertTrue((byName thenDescending byRating).compare(v1, v3) > 0)
 
-        assertTrue( (byRating then byName).compare(v1, v2) < 0 )
+        assertTrue((byRating then byName).compare(v1, v2) < 0)
-        assertTrue( (byRating then byName).compare(v4, v2) > 0 )
+        assertTrue((byRating then byName).compare(v4, v2) > 0)
-        assertTrue( (byRating thenDescending byName).compare(v4, v2) < 0 )
+        assertTrue((byRating thenDescending byName).compare(v4, v2) < 0)
     }
 
     @Test
@@ -150,7 +151,8 @@ class OrderingTest {
         assertEquals(v1, items[1])
     }
 
-    @Test fun maxOf() {
+    @Test
+    fun maxOf() {
         assertEquals(Int.MAX_VALUE, maxOf(Int.MAX_VALUE, Int.MIN_VALUE))
         assertEquals(Int.MAX_VALUE, maxOf(Int.MAX_VALUE, Int.MIN_VALUE, 0))
 
@@ -161,14 +163,16 @@ class OrderingTest {
         assertEquals(Double.POSITIVE_INFINITY, maxOf(Double.POSITIVE_INFINITY, Double.MAX_VALUE, Double.MIN_VALUE))
     }
 
-    @Test fun maxOfWith() {
+    @Test
+    fun maxOfWith() {
         assertEquals(v1, maxOf(v1, v2, compareBy { it.name }))
         assertEquals(v1, maxOf(v3, v2, v1, compareBy { it.name }))
         assertEquals(v2, maxOf(v1, v2, compareBy { it.rating }))
         assertEquals(v3, maxOf(v1, v2, v3, compareBy { it.rating }))
     }
 
-    @Test fun minOf() {
+    @Test
+    fun minOf() {
         assertEquals(Int.MIN_VALUE, minOf(Int.MAX_VALUE, Int.MIN_VALUE))
         assertEquals(Int.MIN_VALUE, minOf(Int.MAX_VALUE, Int.MIN_VALUE, 0))
 
@@ -179,7 +183,8 @@ class OrderingTest {
         assertEquals(Double.MIN_VALUE, minOf(Double.POSITIVE_INFINITY, Double.MAX_VALUE, Double.MIN_VALUE))
     }
 
-    @Test fun minOfWith() {
+    @Test
+    fun minOfWith() {
         assertEquals(v2, minOf(v1, v2, compareBy { it.name }))
         assertEquals(v3, minOf(v3, v2, v1, compareBy { it.name }))
         assertEquals(v1, minOf(v1, v2, compareBy { it.rating }))

libraries/stdlib/test/collections/CollectionBehaviors.kt

@@ -10,8 +10,8 @@ import test.collections.CompareContext
 public fun <T> CompareContext<List<T>>.listBehavior() {
     equalityBehavior()
     collectionBehavior()
-    compareProperty( { listIterator() }, { listIteratorBehavior() })
+    compareProperty({ listIterator() }, { listIteratorBehavior() })
-    compareProperty( { listIterator(0) }, { listIteratorBehavior() })
+    compareProperty({ listIterator(0) }, { listIteratorBehavior() })
 
     propertyFails { listIterator(-1) }
     propertyFails { listIterator(size + 1) }
@@ -24,8 +24,8 @@ public fun <T> CompareContext<List<T>>.listBehavior() {
     propertyEquals { indexOf(elementAtOrNull(0)) }
     propertyEquals { lastIndexOf(elementAtOrNull(0)) }
 
-    propertyFails { subList(0, size + 1)}
+    propertyFails { subList(0, size + 1) }
-    propertyFails { subList(-1, 0)}
+    propertyFails { subList(-1, 0) }
     propertyEquals { subList(0, size) }
 }
 
@@ -73,7 +73,7 @@ public fun <K, V> CompareContext<Map<K, V>>.mapBehavior() {
     propertyEquals { size }
     propertyEquals { isEmpty() }
 
-    (object {}).let { propertyEquals { containsKey(it as Any?) }  }
+    (object {}).let { propertyEquals { containsKey(it as Any?) } }
 
     if (expected.isEmpty().not())
         propertyEquals { contains(keys.first()) }
@@ -82,13 +82,13 @@ public fun <K, V> CompareContext<Map<K, V>>.mapBehavior() {
     propertyEquals { containsValue(values.firstOrNull()) }
     propertyEquals { get(null as Any?) }
 
-    compareProperty( { keys }, { setBehavior("keySet") } )
+    compareProperty({ keys }, { setBehavior("keySet") })
-    compareProperty( { entries }, { setBehavior("entrySet") } )
+    compareProperty({ entries }, { setBehavior("entrySet") })
-    compareProperty( { values }, { collectionBehavior("values") })
+    compareProperty({ values }, { collectionBehavior("values") })
 }
 
 public fun <T> CompareContext<T>.equalityBehavior(objectName: String = "") {
-    val prefix = objectName +  if (objectName.isNotEmpty()) "." else ""
+    val prefix = objectName + if (objectName.isNotEmpty()) "." else ""
     equals(objectName)
     propertyEquals(prefix + "hashCode") { hashCode() }
     propertyEquals(prefix + "toString") { toString() }
@@ -96,11 +96,11 @@ public fun <T> CompareContext<T>.equalityBehavior(objectName: String = "") {
 
 
 public fun <T> CompareContext<Collection<T>>.collectionBehavior(objectName: String = "") {
-    val prefix = objectName +  if (objectName.isNotEmpty()) "." else ""
+    val prefix = objectName + if (objectName.isNotEmpty()) "." else ""
-    propertyEquals (prefix + "size") { size }
+    propertyEquals(prefix + "size") { size }
-    propertyEquals (prefix + "isEmpty") { isEmpty() }
+    propertyEquals(prefix + "isEmpty") { isEmpty() }
 
-    (object {}).let { propertyEquals { contains(it as Any?) }  }
+    (object {}).let { propertyEquals { contains(it as Any?) } }
     propertyEquals { contains(firstOrNull()) }
     propertyEquals { containsAll(this) }
 }

libraries/stdlib/test/collections/ComparisonDSL.kt

@@ -9,7 +9,7 @@ import test.*
 import kotlin.reflect.KProperty1
 import kotlin.test.*
 
-public fun <T> compare(expected: T, actual: T, block:CompareContext<T>.() -> Unit) {
+public fun <T> compare(expected: T, actual: T, block: CompareContext<T>.() -> Unit) {
     CompareContext(expected, actual).block()
 }
 
@@ -26,7 +26,11 @@ public class CompareContext<out T>(public val expected: T, public val actual: T)
     public fun <P> propertyEquals(message: String = "", getter: T.() -> P) {
         assertEquals(expected.getter(), actual.getter(), message)
     }
-    public fun propertyFails(getter: T.() -> Unit) { assertFailEquals({expected.getter()}, {actual.getter()}) }
+
+    public fun propertyFails(getter: T.() -> Unit) {
+        assertFailEquals({ expected.getter() }, { actual.getter() })
+    }
+
     public fun <P> compareProperty(getter: T.() -> P, block: CompareContext<P>.() -> Unit) {
         compare(expected.getter(), actual.getter(), block)
     }

libraries/stdlib/test/collections/GroupingTest.kt

@@ -58,16 +58,16 @@ class GroupingTest {
 
         val elements = listOf("foo", "bar", "flea", "zoo", "biscuit")
         val result = elements.groupingBy { it.first() }
-                .fold({ k, _ -> Collector<Char, String>(k)}, { _, acc, e -> acc.accumulateIfEven(e) })
+            .fold({ k, _ -> Collector<Char, String>(k) }, { _, acc, e -> acc.accumulateIfEven(e) })
 
         val ordered = result.values.sortedBy { it.key }.map { it.toPair() }
         assertEquals(listOf('b' to emptyList(), 'f' to listOf("flea"), 'z' to emptyList()), ordered)
 
         val moreElements = listOf("fire", "zero")
         val result2 = moreElements.groupingBy { it.first() }
-                .foldTo(HashMap(result),
+            .foldTo(HashMap(result),
-                        { k, _ -> error("should not be called for $k") },
+                    { k, _ -> error("should not be called for $k") },
-                        { _, acc, e -> acc.accumulateIfEven(e) })
+                    { _, acc, e -> acc.accumulateIfEven(e) })
 
         val ordered2 = result2.values.sortedBy { it.key }.map { it.toPair() }
         assertEquals(listOf('b' to emptyList(), 'f' to listOf("flea", "fire"), 'z' to listOf("zero")), ordered2)
@@ -101,7 +101,7 @@ class GroupingTest {
         assertEquals(mapOf('f' to 2, 'b' to 3, 'a' to 1, 'z' to 2), counts2)
     }
 
-/**
+/*
     @Test fun sumEach() {
         val values = listOf("k" to 50, "b" to 20, "k" to 1000 )
         val summary = values.groupingBy { it.first }.eachSumOf { it.second }

libraries/stdlib/test/collections/IterableTests.kt

@@ -14,7 +14,7 @@ fun <T> Iterable<T>.toIterable(): Iterable<T> = Iterable { this.iterator() }
 class IterableTest : OrderedIterableTests<Iterable<String>>({ iterableOf(*it) }, iterableOf<String>())
 class SetTest : IterableTests<Set<String>>({ setOf(*it) }, setOf())
 class LinkedSetTest : OrderedIterableTests<LinkedHashSet<String>>({ linkedSetOf(*it) }, linkedSetOf())
-class ListTest : OrderedIterableTests<List<String>>( { listOf(*it) }, listOf<String>())
+class ListTest : OrderedIterableTests<List<String>>({ listOf(*it) }, listOf<String>())
 class ArrayListTest : OrderedIterableTests<ArrayList<String>>({ arrayListOf(*it) }, arrayListOf<String>())
 
 abstract class OrderedIterableTests<T : Iterable<String>>(createFrom: (Array<out String>) -> T, empty: T) : IterableTests<T>(createFrom, empty) {
@@ -56,10 +56,10 @@ abstract class OrderedIterableTests<T : Iterable<String>>(createFrom: (Array<out
         assertFails { data.elementAt(-1) }
         assertFails { empty.elementAt(0) }
 
-        expect("foo") { data.elementAtOrElse(0, {""} )}
+        expect("foo") { data.elementAtOrElse(0, { "" }) }
-        expect("zoo") { data.elementAtOrElse(-1, { "zoo" })}
+        expect("zoo") { data.elementAtOrElse(-1, { "zoo" }) }
-        expect("zoo") { data.elementAtOrElse(2, { "zoo" })}
+        expect("zoo") { data.elementAtOrElse(2, { "zoo" }) }
-        expect("zoo") { empty.elementAtOrElse(0) { "zoo" }}
+        expect("zoo") { empty.elementAtOrElse(0) { "zoo" } }
 
         expect(null) { empty.elementAtOrNull(0) }
 
@@ -239,7 +239,8 @@ abstract class IterableTests<T : Iterable<String>>(val createFrom: (Array<out St
         assertEquals(listOf("foo"), foo)
     }
 
-    @Test fun filterIndexed() {
+    @Test
+    fun filterIndexed() {
         val result = data.filterIndexed { index, value -> value.first() == ('a' + index) }
         assertEquals(listOf("bar"), result)
     }
@@ -286,7 +287,7 @@ abstract class IterableTests<T : Iterable<String>>(val createFrom: (Array<out St
         assertTrue(data === newData)
 
         // static types test
-        assertStaticTypeIs<ArrayList<Int>>(arrayListOf(1, 2, 3).onEach {  })
+        assertStaticTypeIs<ArrayList<Int>>(arrayListOf(1, 2, 3).onEach { })
     }
 
     @Test
@@ -490,7 +491,10 @@ abstract class IterableTests<T : Iterable<String>>(val createFrom: (Array<out St
 }
 
 
-fun <T> Iterable<T>.assertSorted(isInOrder: (T, T) -> Boolean): Unit { this.iterator().assertSorted(isInOrder) }
+fun <T> Iterable<T>.assertSorted(isInOrder: (T, T) -> Boolean) {
+    this.iterator().assertSorted(isInOrder)
+}
+
 fun <T> Iterator<T>.assertSorted(isInOrder: (T, T) -> Boolean) {
     if (!hasNext()) return
     var index = 0
@@ -498,7 +502,7 @@ fun <T> Iterator<T>.assertSorted(isInOrder: (T, T) -> Boolean) {
     while (hasNext()) {
         index += 1
         val next = next()
-        assertTrue(isInOrder(prev, next), "Not in order at position $index, element[${index-1}]: $prev, element[$index]: $next")
+        assertTrue(isInOrder(prev, next), "Not in order at position $index, element[${index - 1}]: $prev, element[$index]: $next")
         prev = next
     }
     return

libraries/stdlib/test/collections/IteratorsTest.kt

@@ -8,7 +8,8 @@ package test.collections
 import kotlin.test.*
 
 class IteratorsTest {
-    @Test fun iterationOverIterator() {
+    @Test
+    fun iterationOverIterator() {
         val c = listOf(0, 1, 2, 3, 4, 5)
         var s = ""
         for (i in c.iterator()) {

libraries/stdlib/test/collections/ListBinarySearchTest.kt

@@ -82,7 +82,7 @@ class ListBinarySearchTest {
         val list = values.map { IncomparableDataItem(IncomparableDataItem(it)) }
 
         list.forEachIndexed { index, item ->
-            assertEquals(index, list.binarySearch { comparator.compare(it.value, item.value) } )
+            assertEquals(index, list.binarySearch { comparator.compare(it.value, item.value) })
             assertEquals(notFound(index), list.binarySearch { comparator.compare(it.value, item.value.pred()) })
             assertEquals(notFound(index + 1), list.binarySearch { comparator.compare(it.value, item.value.succ()) })
 
@@ -102,7 +102,7 @@ class ListBinarySearchTest {
         val list = values.flatMap { v1 -> values.map { v2 -> Pair(v1, v2) } }
 
         list.forEachIndexed { index, item ->
-            assertEquals(index,  list.binarySearch { compareValuesBy(it, item, { it.first }, { it.second }) })
+            assertEquals(index, list.binarySearch { compareValuesBy(it, item, { it.first }, { it.second }) })
         }
     }
 }

libraries/stdlib/test/collections/ListSpecificTest.kt

@@ -43,10 +43,10 @@ class ListSpecificTest {
         assertFails { data.get(-1) }
         assertFails { empty.get(0) }
 
-        expect("foo") { data.getOrElse(0, {""} )}
+        expect("foo") { data.getOrElse(0, { "" }) }
-        expect("zoo") { data.getOrElse(-1, { "zoo" })}
+        expect("zoo") { data.getOrElse(-1, { "zoo" }) }
-        expect("zoo") { data.getOrElse(2, { "zoo" })}
+        expect("zoo") { data.getOrElse(2, { "zoo" }) }
-        expect("zoo") { empty.getOrElse(0) { "zoo" }}
+        expect("zoo") { empty.getOrElse(0) { "zoo" } }
 
         expect(null) { empty.getOrNull(0) }
 

libraries/stdlib/test/collections/MutableCollectionsTest.kt

@@ -9,15 +9,15 @@ import kotlin.test.*
 
 
 class MutableCollectionTest {
-    fun <T, C: MutableCollection<T>> testOperation(before: List<T>, after: List<T>, expectedModified: Boolean, toMutableCollection: (List<T>) -> C)
+    fun <T, C : MutableCollection<T>> testOperation(before: List<T>, after: List<T>, expectedModified: Boolean, toMutableCollection: (List<T>) -> C) =
-            = fun(operation: (C.() -> Boolean)) {
+        fun(operation: (C.() -> Boolean)) {
-                val list = toMutableCollection(before)
+            val list = toMutableCollection(before)
-                assertEquals(expectedModified, list.operation())
+            assertEquals(expectedModified, list.operation())
-                assertEquals(toMutableCollection(after), list)
+            assertEquals(toMutableCollection(after), list)
-            }
+        }
 
-    fun <T> testOperation(before: List<T>, after: List<T>, expectedModified: Boolean)
+    fun <T> testOperation(before: List<T>, after: List<T>, expectedModified: Boolean) =
-            = testOperation(before, after, expectedModified, { it.toMutableList() })
+        testOperation(before, after, expectedModified, { it.toMutableList() })
 
 
     @Test fun addAll() {

libraries/stdlib/test/collections/SequenceTest.kt

@@ -90,10 +90,12 @@ public class SequenceTest {
 
     @Test fun mapIndexedNotNull() {
         // find which terms are divisible by their index
-        assertEquals(listOf("1/1", "5/5", "144/12", "46368/24", "75025/25"),
+        assertEquals(
-                fibonacci().mapIndexedNotNull { index, value ->
+            listOf("1/1", "5/5", "144/12", "46368/24", "75025/25"),
-                    if (index > 0 && (value % index) == 0) "$value/$index" else null
+            fibonacci().mapIndexedNotNull { index, value ->
-                }.take(5).toList())
+                if (index > 0 && (value % index) == 0) "$value/$index" else null
+            }.take(5).toList()
+        )
     }
 
 
@@ -457,14 +459,14 @@ public class SequenceTest {
 
     @Test fun flatMapAndTakeExtractTheTransformedElements() {
         val expected = listOf(
-                '3', // fibonacci(4) = 3
+            '3', // fibonacci(4) = 3
-                '5', // fibonacci(5) = 5
+            '5', // fibonacci(5) = 5
-                '8', // fibonacci(6) = 8
+            '8', // fibonacci(6) = 8
-                '1', '3', // fibonacci(7) = 13
+            '1', '3', // fibonacci(7) = 13
-                '2', '1', // fibonacci(8) = 21
+            '2', '1', // fibonacci(8) = 21
-                '3', '4', // fibonacci(9) = 34
+            '3', '4', // fibonacci(9) = 34
-                '5' // fibonacci(10) = 55
+            '5' // fibonacci(10) = 55
-                             )
+        )
 
         assertEquals(expected, fibonacci().drop(4).flatMap { it.toString().asSequence() }.take(10).toList())
     }

libraries/stdlib/test/coroutines/CoroutineContextTest.kt

@@ -154,7 +154,7 @@ class CoroutineContextTest {
         assertNotEquals(ctx3, ctx4)
     }
 
-    private fun  assertContents(ctx: CoroutineContext, vararg elements: CoroutineContext.Element) {
+    private fun assertContents(ctx: CoroutineContext, vararg elements: CoroutineContext.Element) {
         val set = ctx.fold(setOf<CoroutineContext>()) { a, b -> a + b }
         assertEquals(listOf(*elements), set.toList())
         for (elem in elements)

libraries/stdlib/test/coroutines/SequenceBuilderTest.kt

@@ -261,18 +261,18 @@ class SequenceBuilderTest {
             effects.add(")") // marks step end
         }
         assertEquals(
-                listOf(
+            listOf(
-                        "a",
+                "a",
-                        "(", 1, ")",
+                "(", 1, ")",
-                        "(", 2, ")",
+                "(", 2, ")",
-                        "b", "c",
+                "b", "c",
-                        "(", 3, ")",
+                "(", 3, ")",
-                        "d",
+                "d",
-                        "(", 4, ")",
+                "(", 4, ")",
-                        "e", "f",
+                "e", "f",
-                        "(", 5, ")"
+                "(", 5, ")"
-                ),
+            ),
-                effects.toList()
+            effects.toList()
         )
     }
 

libraries/stdlib/test/js/MapJsTest.kt

@@ -29,6 +29,7 @@ class ComplexMapJsTest : MapJsTest() {
     override fun <T : kotlin.Comparable<T>> Collection<T>.toNormalizedList(): List<T> = this.sorted()
     // hashMapOf returns ComlpexHashMap because it is Generic
     override fun emptyMutableMap(): MutableMap<String, Int> = genericHashMapOf()
+
     override fun emptyMutableMapWithNullableKeyValue(): MutableMap<String?, Int?> = genericHashMapOf()
 }
 
@@ -107,24 +108,33 @@ abstract class MapJsTest {
     val KEYS = listOf("zero", "one", "two", "three")
     val VALUES = arrayOf(0, 1, 2, 3).toList()
 
-    val SPECIAL_NAMES = arrayOf("__proto__", "constructor", "toString", "toLocaleString", "valueOf", "hasOwnProperty", "isPrototypeOf", "propertyIsEnumerable")
+    val SPECIAL_NAMES = arrayOf(
+        "__proto__",
+        "constructor",
+        "toString",
+        "toLocaleString",
+        "valueOf",
+        "hasOwnProperty",
+        "isPrototypeOf",
+        "propertyIsEnumerable"
+    )
 
     @Test fun getOrElse() {
         val data = emptyMap()
-        val a = data.getOrElse("foo"){2}
+        val a = data.getOrElse("foo") { 2 }
         assertEquals(2, a)
 
-        val b = data.getOrElse("foo"){3}
+        val b = data.getOrElse("foo") { 3 }
         assertEquals(3, b)
         assertEquals(0, data.size)
     }
 
     @Test fun getOrPut() {
         val data = emptyMutableMap()
-        val a = data.getOrPut("foo"){2}
+        val a = data.getOrPut("foo") { 2 }
         assertEquals(2, a)
 
-        val b = data.getOrPut("foo"){3}
+        val b = data.getOrPut("foo") { 3 }
         assertEquals(2, b)
 
         assertEquals(1, data.size)

libraries/stdlib/test/js/SetJsTest.kt

@@ -29,6 +29,7 @@ class ComplexSetJsTest : SetJsTest() {
 
     // hashSetOf returns ComlpexHashSet because it is Generic
     override fun createEmptyMutableSet(): MutableSet<String> = genericHashSetOf()
+
     override fun createEmptyMutableSetWithNullableValues(): MutableSet<String?> = genericHashSetOf()
 
 
@@ -92,7 +93,16 @@ abstract class SetJsTest {
     val data: Set<String> = createTestMutableSet()
     val empty: Set<String> = createEmptyMutableSet()
 
-    val SPECIAL_NAMES = arrayOf("__proto__", "constructor", "toString", "toLocaleString", "valueOf", "hasOwnProperty", "isPrototypeOf", "propertyIsEnumerable")
+    val SPECIAL_NAMES = arrayOf(
+        "__proto__",
+        "constructor",
+        "toString",
+        "toLocaleString",
+        "valueOf",
+        "hasOwnProperty",
+        "isPrototypeOf",
+        "propertyIsEnumerable"
+    )
 
     @Test
     fun size() {
@@ -270,6 +280,7 @@ abstract class SetJsTest {
 
     //Helpers
     abstract fun createEmptyMutableSet(): MutableSet<String>
+
     abstract fun createEmptyMutableSetWithNullableValues(): MutableSet<String?>
 
     fun createTestMutableSet(): MutableSet<String> {
@@ -278,6 +289,7 @@ abstract class SetJsTest {
         set.add("bar")
         return set
     }
+
     fun createTestMutableSetReversed(): MutableSet<String> {
         val set = createEmptyMutableSet()
         set.add("bar")

libraries/stdlib/test/numbers/MathTest.kt

@@ -133,7 +133,7 @@ class DoubleMathTest {
         assertEquals(0.25, 2.0.pow(-2))
         assertTrue(0.0.pow(Double.NaN).isNaN())
         assertTrue(Double.NaN.pow(-1).isNaN())
-        assertTrue((-7.0).pow(1/3.0).isNaN())
+        assertTrue((-7.0).pow(1 / 3.0).isNaN())
         assertTrue(1.0.pow(Double.POSITIVE_INFINITY).isNaN())
         assertTrue((-1.0).pow(Double.NEGATIVE_INFINITY).isNaN())
 
@@ -322,8 +322,7 @@ class DoubleMathTest {
             val prev = value.nextDown()
             if (prev > 0) {
                 assertEquals(value, prev + prev.ulp)
-            }
+            } else {
-            else {
                 assertEquals(prev, value - value.ulp)
             }
 
@@ -472,7 +471,7 @@ class FloatMathTest {
         assertEquals(0.25F, 2.0F.pow(-2))
         assertTrue(0.0F.pow(Float.NaN).isNaN())
         assertTrue(Float.NaN.pow(-1).isNaN())
-        assertTrue((-7.0F).pow(1/3.0F).isNaN())
+        assertTrue((-7.0F).pow(1 / 3.0F).isNaN())
         assertTrue(1.0F.pow(Float.POSITIVE_INFINITY).isNaN())
         assertTrue((-1.0F).pow(Float.NEGATIVE_INFINITY).isNaN())
 

libraries/stdlib/test/numbers/NaNPropagationTest.kt

@@ -13,9 +13,11 @@ val Float.Companion.values get() = listOf(0.0f, NEGATIVE_INFINITY, MIN_VALUE, MA
 
 class NaNPropagationTest {
 
-    private fun propagateOf2(f2d: (Double, Double) -> Double,
+    private fun propagateOf2(
-                             f2f: (Float, Float) -> Float,
+        f2d: (Double, Double) -> Double,
-                             function: String) {
+        f2f: (Float, Float) -> Float,
+        function: String
+    ) {
         with(Double) {
             for (d in values) {
                 assertTrue(f2d(d, NaN).isNaN(), "$function($d, NaN)")
@@ -30,8 +32,10 @@ class NaNPropagationTest {
         }
     }
 
-    private fun propagateOf3(f3d: (Double, Double, Double) -> Double,
+    private fun propagateOf3(
-                             f3f: (Float, Float, Float) -> Float, function: String) {
+        f3d: (Double, Double, Double) -> Double,
+        f3f: (Float, Float, Float) -> Float, function: String
+    ) {
 
         with(Double) {
             for (d in values) {
@@ -49,62 +53,88 @@ class NaNPropagationTest {
         }
     }
 
-    @Test fun minOf() {
+    @Test
+    fun minOf() {
         propagateOf2(::minOf, ::minOf, "minOf")
         propagateOf3(::minOf, ::minOf, "minOf")
     }
 
-    @Test fun maxOf() {
+    @Test
+    fun maxOf() {
         propagateOf2(::maxOf, ::maxOf, "maxOf")
         propagateOf3(::maxOf, ::maxOf, "maxOf")
     }
 
-    @Test fun arrayMin() {
+    @Test
-        propagateOf2({ a, b -> arrayOf(a, b).min()!! },
+    fun arrayMin() {
-                     { a, b -> arrayOf(a, b).min()!! },
+        propagateOf2(
-                     "arrayOf().min()")
+            { a, b -> arrayOf(a, b).min()!! },
+            { a, b -> arrayOf(a, b).min()!! },
+            "arrayOf().min()"
+        )
     }
 
-    @Test fun arrayMax() {
+    @Test
-        propagateOf2({ a, b -> arrayOf(a, b).max()!! },
+    fun arrayMax() {
-                     { a, b -> arrayOf(a, b).max()!! },
+        propagateOf2(
-                     "arrayOf().max()")
+            { a, b -> arrayOf(a, b).max()!! },
+            { a, b -> arrayOf(a, b).max()!! },
+            "arrayOf().max()"
+        )
     }
 
-    @Test fun primitiveArrayMin() {
+    @Test
-        propagateOf2({ a, b -> doubleArrayOf(a, b).min()!! },
+    fun primitiveArrayMin() {
-                     { a, b -> floatArrayOf(a, b).min()!! },
+        propagateOf2(
-                     "primitiveArrayOf().min()")
+            { a, b -> doubleArrayOf(a, b).min()!! },
+            { a, b -> floatArrayOf(a, b).min()!! },
+            "primitiveArrayOf().min()"
+        )
     }
 
-    @Test fun primitiveArrayMax() {
+    @Test
-        propagateOf2({ a, b -> doubleArrayOf(a, b).max()!! },
+    fun primitiveArrayMax() {
-                     { a, b -> floatArrayOf(a, b).max()!! },
+        propagateOf2(
-                     "primitiveArrayOf().max()")
+            { a, b -> doubleArrayOf(a, b).max()!! },
+            { a, b -> floatArrayOf(a, b).max()!! },
+            "primitiveArrayOf().max()"
+        )
     }
 
-    @Test fun listMin() {
+    @Test
-        propagateOf2({ a, b -> listOf(a, b).min()!! },
+    fun listMin() {
-                     { a, b -> listOf(a, b).min()!! },
+        propagateOf2(
-                     "listOf().min()")
+            { a, b -> listOf(a, b).min()!! },
+            { a, b -> listOf(a, b).min()!! },
+            "listOf().min()"
+        )
     }
 
-    @Test fun listMax() {
+    @Test
-        propagateOf2({ a, b -> listOf(a, b).max()!! },
+    fun listMax() {
-                     { a, b -> listOf(a, b).max()!! },
+        propagateOf2(
-                     "listOf().max()")
+            { a, b -> listOf(a, b).max()!! },
+            { a, b -> listOf(a, b).max()!! },
+            "listOf().max()"
+        )
     }
 
-    @Test fun sequenceMin() {
+    @Test
-        propagateOf2({ a, b -> sequenceOf(a, b).min()!! },
+    fun sequenceMin() {
-                     { a, b -> sequenceOf(a, b).min()!! },
+        propagateOf2(
-                     "sequenceOf().min()")
+            { a, b -> sequenceOf(a, b).min()!! },
+            { a, b -> sequenceOf(a, b).min()!! },
+            "sequenceOf().min()"
+        )
     }
 
-    @Test fun sequenceMax() {
+    @Test
-        propagateOf2({ a, b -> sequenceOf(a, b).max()!! },
+    fun sequenceMax() {
-                     { a, b -> sequenceOf(a, b).max()!! },
+        propagateOf2(
-                     "sequenceOf().max()")
+            { a, b -> sequenceOf(a, b).max()!! },
+            { a, b -> sequenceOf(a, b).max()!! },
+            "sequenceOf().max()"
+        )
     }
 
 }
@@ -113,7 +143,7 @@ class NaNTotalOrderTest {
 
     private fun <T : Comparable<T>> totalOrderMinOf2(f2t: (T, T) -> T, function: String) {
         @Suppress("UNCHECKED_CAST")
-        with (Double) {
+        with(Double) {
             assertEquals<Any>(0.0, f2t(0.0 as T, NaN as T), "$function(0, NaN)")
             assertEquals<Any>(0.0, f2t(NaN as T, 0.0 as T), "$function(NaN, 0)")
         }
@@ -121,39 +151,51 @@ class NaNTotalOrderTest {
 
     private fun <T : Comparable<T>> totalOrderMaxOf2(f2t: (T, T) -> T, function: String) {
         @Suppress("UNCHECKED_CAST")
-        with (Double) {
+        with(Double) {
             assertTrue((f2t(0.0 as T, NaN as T) as Double).isNaN(), "$function(0, NaN)")
             assertTrue((f2t(NaN as T, 0.0 as T) as Double).isNaN(), "$function(NaN, 0)")
         }
     }
 
-    @Test fun minOfT() {
+    @Test
+    fun minOfT() {
         totalOrderMinOf2<Comparable<Any>>(::minOf, "minOf")
     }
-    @Test fun maxOfT() {
+
+    @Test
+    fun maxOfT() {
         totalOrderMaxOf2<Comparable<Any>>(::maxOf, "maxOf")
     }
 
-    @Test fun arrayTMin() {
+    @Test
+    fun arrayTMin() {
         totalOrderMinOf2<Comparable<Any>>({ a, b -> arrayOf(a, b).min()!! }, "arrayOf().min()")
     }
-    @Test fun arrayTMax() {
+
+    @Test
+    fun arrayTMax() {
         totalOrderMaxOf2<Comparable<Any>>({ a, b -> arrayOf(a, b).max()!! }, "arrayOf().max()")
     }
 
 
-    @Test fun listTMin() {
+    @Test
+    fun listTMin() {
         totalOrderMinOf2<Comparable<Any>>({ a, b -> listOf(a, b).min()!! }, "listOf().min()")
     }
-    @Test fun listTMax() {
+
+    @Test
+    fun listTMax() {
         totalOrderMaxOf2<Comparable<Any>>({ a, b -> listOf(a, b).max()!! }, "listOf().max()")
     }
 
 
-    @Test fun sequenceTMin() {
+    @Test
+    fun sequenceTMin() {
         totalOrderMinOf2<Comparable<Any>>({ a, b -> sequenceOf(a, b).min()!! }, "sequenceOf().min()")
     }
-    @Test fun sequenceTMax() {
+
+    @Test
+    fun sequenceTMax() {
         totalOrderMaxOf2<Comparable<Any>>({ a, b -> sequenceOf(a, b).max()!! }, "sequenceOf().max()")
     }
 }

libraries/stdlib/test/properties/delegation/MapAccessorsTest.kt

@@ -71,12 +71,12 @@ class VarByMapExtensionsTest {
 
     @Test fun deprecatedAccessors() {
         assertEquals<Int>(
-                expected = map.getValue(this, VarByMapExtensionsTest::c),
+            expected = map.getValue(this, VarByMapExtensionsTest::c),
-                actual = map.getValue<Int>(this, VarByMapExtensionsTest::c)
+            actual = map.getValue<Int>(this, VarByMapExtensionsTest::c)
         )
         assertEquals<String>(
-                expected = map2.getValue<CharSequence, String>(this, VarByMapExtensionsTest::a2),
+            expected = map2.getValue<CharSequence, String>(this, VarByMapExtensionsTest::a2),
-                actual = map2.getValue<String>(this, VarByMapExtensionsTest::a2)
+            actual = map2.getValue<String>(this, VarByMapExtensionsTest::a2)
         )
     }
 }

libraries/stdlib/test/ranges/ProgressionLastElementTest.kt

@@ -9,7 +9,7 @@ import kotlin.comparisons.*
 import kotlin.test.*
 
 
-class ProgressionLastElementTest  {
+class ProgressionLastElementTest {
 
     private val MAX = Int.MAX_VALUE
     private val MIN = Int.MIN_VALUE

libraries/stdlib/test/ranges/RangeIterationTest.kt

@@ -11,11 +11,11 @@ import kotlin.test.*
 
 public open class RangeIterationTestBase {
     public fun <N : Any> doTest(
-            sequence: Iterable<N>,
+        sequence: Iterable<N>,
-            expectedFirst: N,
+        expectedFirst: N,
-            expectedLast: N,
+        expectedLast: N,
-            expectedIncrement: Number,
+        expectedIncrement: Number,
-            expectedElements: List<N>
+        expectedElements: List<N>
     ) {
         val first: Any
         val last: Any

libraries/stdlib/test/ranges/RangeTest.kt

@@ -357,26 +357,26 @@ public class RangeTest {
 
         assertFailsWithIllegalArgument { 0..5 step 0 }
         assertFailsWithIllegalArgument { 0.toByte()..5.toByte() step 0 }
-        assertFailsWithIllegalArgument { 0.toShort()..5.toShort() step 0  }
+        assertFailsWithIllegalArgument { 0.toShort()..5.toShort() step 0 }
         assertFailsWithIllegalArgument { 0L..5L step 0L }
         assertFailsWithIllegalArgument { 'a'..'z' step 0 }
 
         assertFailsWithIllegalArgument { 0 downTo -5 step 0 }
         assertFailsWithIllegalArgument { 0.toByte() downTo -5.toByte() step 0 }
-        assertFailsWithIllegalArgument { 0.toShort() downTo -5.toShort() step 0  }
+        assertFailsWithIllegalArgument { 0.toShort() downTo -5.toShort() step 0 }
         assertFailsWithIllegalArgument { 0L downTo -5L step 0L }
         assertFailsWithIllegalArgument { 'z' downTo 'a' step 0 }
 
         assertFailsWithIllegalArgument { 0..5 step -2 }
         assertFailsWithIllegalArgument { 0.toByte()..5.toByte() step -2 }
-        assertFailsWithIllegalArgument { 0.toShort()..5.toShort() step -2  }
+        assertFailsWithIllegalArgument { 0.toShort()..5.toShort() step -2 }
         assertFailsWithIllegalArgument { 0L..5L step -2L }
         assertFailsWithIllegalArgument { 'a'..'z' step -2 }
 
 
         assertFailsWithIllegalArgument { 0 downTo -5 step -2 }
         assertFailsWithIllegalArgument { 0.toByte() downTo -5.toByte() step -2 }
-        assertFailsWithIllegalArgument { 0.toShort() downTo -5.toShort() step -2  }
+        assertFailsWithIllegalArgument { 0.toShort() downTo -5.toShort() step -2 }
         assertFailsWithIllegalArgument { 0L downTo -5L step -2L }
         assertFailsWithIllegalArgument { 'z' downTo 'a' step -2 }
     }

libraries/stdlib/test/text/RegexTest.kt

@@ -187,7 +187,7 @@ class RegexTest {
     @Test fun replaceEvaluator() {
         val input = "/12/456/7890/"
         val pattern = "\\d+".toRegex()
-        assertEquals("/2/3/4/", pattern.replace(input, { it.value.length.toString() } ))
+        assertEquals("/2/3/4/", pattern.replace(input, { it.value.length.toString() }))
     }
 
 

libraries/stdlib/test/text/StringNumberConversionTest.kt

@@ -157,24 +157,30 @@ class StringNumberConversionTest {
 
 internal fun doubleTotalOrderEquals(a: Double?, b: Double?): Boolean = (a as Any?) == b
 
-internal fun <T : Any> compareConversion(convertOrFail: (String) -> T,
+internal fun <T : Any> compareConversion(
-                                        convertOrNull: (String) -> T?,
+    convertOrFail: (String) -> T,
-                                        equality: (T, T?) -> Boolean = { a, b -> a == b },
+    convertOrNull: (String) -> T?,
-                                        assertions: ConversionContext<T>.() -> Unit) {
+    equality: (T, T?) -> Boolean = { a, b -> a == b },
+    assertions: ConversionContext<T>.() -> Unit
+) {
     ConversionContext(convertOrFail, convertOrNull, equality).assertions()
 }
 
 
-internal fun <T : Any> compareConversionWithRadix(convertOrFail: String.(Int) -> T,
+internal fun <T : Any> compareConversionWithRadix(
-                                                 convertOrNull: String.(Int) -> T?,
+    convertOrFail: String.(Int) -> T,
-                                                 assertions: ConversionWithRadixContext<T>.() -> Unit) {
+    convertOrNull: String.(Int) -> T?,
+    assertions: ConversionWithRadixContext<T>.() -> Unit
+) {
     ConversionWithRadixContext(convertOrFail, convertOrNull).assertions()
 }
 
 
-internal class ConversionContext<T: Any>(val convertOrFail: (String) -> T,
+internal class ConversionContext<T : Any>(
-                                        val convertOrNull: (String) -> T?,
+    val convertOrFail: (String) -> T,
-                                        val equality: (T, T?) -> Boolean) {
+    val convertOrNull: (String) -> T?,
+    val equality: (T, T?) -> Boolean
+) {
 
     private fun assertEquals(expected: T, actual: T?, input: String, operation: String) {
         assertTrue(equality(expected, actual), "Expected $operation('$input') to produce $expected but was $actual")
@@ -191,8 +197,10 @@ internal class ConversionContext<T: Any>(val convertOrFail: (String) -> T,
     }
 }
 
-internal class ConversionWithRadixContext<T: Any>(val convertOrFail: (String, Int) -> T,
+internal class ConversionWithRadixContext<T : Any>(
-                                                 val convertOrNull: (String, Int) -> T?) {
+    val convertOrFail: (String, Int) -> T,
+    val convertOrNull: (String, Int) -> T?
+) {
     fun assertProduces(radix: Int, input: String, output: T) {
         assertEquals(output, convertOrFail(input.removeLeadingPlusOnJava6(), radix))
         assertEquals(output, convertOrNull(input, radix))

libraries/stdlib/test/text/StringTest.kt

@@ -21,8 +21,9 @@ fun withOneCharSequenceArg(f: ((String) -> CharSequence) -> Unit) {
     for (arg1Builder in charSequenceBuilders) f(arg1Builder)
 }
 
-fun withOneCharSequenceArg(arg1: String, f: (CharSequence) -> Unit)
+fun withOneCharSequenceArg(arg1: String, f: (CharSequence) -> Unit) {
-        = withOneCharSequenceArg { arg1Builder -> f(arg1Builder(arg1)) }
+    withOneCharSequenceArg { arg1Builder -> f(arg1Builder(arg1)) }
+}
 
 fun withTwoCharSequenceArgs(f: ((String) -> CharSequence, (String) -> CharSequence) -> Unit) {
     for (arg1Builder in charSequenceBuilders)
@@ -35,6 +36,7 @@ fun assertContentEquals(expected: String, actual: CharSequence, message: String?
 }
 
 // helper predicates available on both platforms
+
 fun Char.isAsciiDigit() = this in '0'..'9'
 fun Char.isAsciiLetter() = this in 'A'..'Z' || this in 'a'..'z'
 fun Char.isAsciiUpperCase() = this in 'A'..'Z'
@@ -55,8 +57,7 @@ class StringTest {
             val value = case.value?.let { arg1(it) }
             assertEquals(case.isNull || case.isEmpty, value.isNullOrEmpty(), "failed for case '$value'")
             assertEquals(case.isNull || case.isBlank, value.isNullOrBlank(), "failed for case '$value'")
-            if (value != null)
+            if (value != null) {
-            {
                 assertEquals(case.isEmpty, value.isEmpty(), "failed for case '$value'")
                 assertEquals(case.isBlank, value.isBlank(), "failed for case '$value'")
             }
@@ -265,7 +266,7 @@ class StringTest {
         assertContentEquals("sae text", s.removeRange(2, 5))
         assertContentEquals("sa text", s.removeRange(2..5))
 
-        assertContentEquals(s.toString(), s.removeRange(2,2))
+        assertContentEquals(s.toString(), s.removeRange(2, 2))
 
         // symmetry with indices
         assertContentEquals("", s.removeRange(s.indices))
@@ -337,7 +338,7 @@ class StringTest {
 
     @Test fun stringIterator() = withOneCharSequenceArg("239") { data ->
         var sum = 0
-        for(c in data)
+        for (c in data)
             sum += (c - '0')
         assertTrue(sum == 14)
     }
@@ -358,8 +359,8 @@ class StringTest {
         assertContentEquals("a", "\ra".trimStartCS())
         assertContentEquals("a", "\na".trimStartCS())
 
-        assertContentEquals("a=", arg1("-=-=a=").trimStart('-','='))
+        assertContentEquals("a=", arg1("-=-=a=").trimStart('-', '='))
-        assertContentEquals("123a", arg1("ab123a").trimStart {  !it.isAsciiDigit() })
+        assertContentEquals("123a", arg1("ab123a").trimStart { !it.isAsciiDigit() })
     }
 
     @Test fun trimEnd() = withOneCharSequenceArg { arg1 ->
@@ -378,20 +379,21 @@ class StringTest {
         assertContentEquals("a", "a\r".trimEndCS())
         assertContentEquals("a", "a\n".trimEndCS())
 
-        assertContentEquals("=a", arg1("=a=-=-").trimEnd('-','='))
+        assertContentEquals("=a", arg1("=a=-=-").trimEnd('-', '='))
         assertContentEquals("ab123", arg1("ab123a").trimEnd { !it.isAsciiDigit() })
     }
 
     @Test fun trimStartAndEnd() = withOneCharSequenceArg { arg1 ->
-        val examples = arrayOf("a",
+        val examples = arrayOf(
-                " a ",
+            "a",
-                "  a  ",
+            " a ",
-                "  a b  ",
+            "  a  ",
-                "\ta\tb\t",
+            "  a b  ",
-                "\t\ta\t\t",
+            "\ta\tb\t",
-                "\ra\r",
+            "\t\ta\t\t",
-                "\na\n",
+            "\ra\r",
-                " \u00A0 a \u00A0 "
+            "\na\n",
+            " \u00A0 a \u00A0 "
         )
 
         for ((source, example) in examples.map { it to arg1(it) }) {
@@ -399,8 +401,9 @@ class StringTest {
             assertContentEquals(source.trimStart().trimEnd(), example.trim())
         }
 
-        val examplesForPredicate = arrayOf("123",
+        val examplesForPredicate = arrayOf(
-                "-=123=-"
+            "123",
+            "-=123=-"
         )
 
         val trimChars = charArrayOf('-', '=')
@@ -676,9 +679,15 @@ class StringTest {
         assertEquals(2, string.lastIndexOf('e', 3, ignoreCase = true))
 
 
-        for (startIndex in -1..string.length+1){
+        for (startIndex in -1..string.length + 1) {
-            assertEquals(string.indexOfAny(charArrayOf('e'), startIndex, ignoreCase = true), string.indexOf('E', startIndex, ignoreCase = true))
+            assertEquals(
-            assertEquals(string.lastIndexOfAny(charArrayOf('E'), startIndex, ignoreCase = true), string.lastIndexOf('e', startIndex, ignoreCase = true))
+                string.indexOfAny(charArrayOf('e'), startIndex, ignoreCase = true),
+                string.indexOf('E', startIndex, ignoreCase = true)
+            )
+            assertEquals(
+                string.lastIndexOfAny(charArrayOf('E'), startIndex, ignoreCase = true),
+                string.lastIndexOf('e', startIndex, ignoreCase = true)
+            )
         }
     }
 
@@ -738,8 +747,8 @@ class StringTest {
 
     @Test fun replaceFirst() {
         val input = "AbbabA"
-        assertEquals("Abb${'$'}bA", input.replaceFirst('a','$'))
+        assertEquals("Abb${'$'}bA", input.replaceFirst('a', '$'))
-        assertEquals("${'$'}bbabA", input.replaceFirst('a','$', ignoreCase = true))
+        assertEquals("${'$'}bbabA", input.replaceFirst('a', '$', ignoreCase = true))
         // doesn't pass in Rhino JS
         // assertEquals("schrodinger", "schrÖdinger".replaceFirst('ö', 'o', ignoreCase = true))
 
@@ -789,8 +798,8 @@ class StringTest {
         assertTrue(data === newData)
 
         // static types test
-        assertStaticTypeIs<String>("x".onEach {  })
+        assertStaticTypeIs<String>("x".onEach { })
-        assertStaticTypeIs<StringBuilder>(result.onEach {  })
+        assertStaticTypeIs<StringBuilder>(result.onEach { })
     }
 
 
@@ -989,7 +998,7 @@ class StringTest {
     @Test fun fold() = withOneCharSequenceArg { arg1 ->
         // calculate number of digits in the string
         val data = arg1("a1b2c3def")
-        val result = data.fold(0, { digits, c -> if(c.isAsciiDigit()) digits + 1 else digits } )
+        val result = data.fold(0, { digits, c -> if (c.isAsciiDigit()) digits + 1 else digits })
         assertEquals(3, result)
 
         //simulate all method
@@ -1002,7 +1011,7 @@ class StringTest {
     @Test fun foldRight() = withOneCharSequenceArg { arg1 ->
         // calculate number of digits in the string
         val data = arg1("a1b2c3def")
-        val result = data.foldRight(0, { c, digits -> if(c.isAsciiDigit()) digits + 1 else digits })
+        val result = data.foldRight(0, { c, digits -> if (c.isAsciiDigit()) digits + 1 else digits })
         assertEquals(3, result)
 
         //simulate all method
@@ -1070,8 +1079,8 @@ class StringTest {
         // group characters by their case
         val result = data.groupBy { it.isAsciiUpperCase() }
         assertEquals(2, result.size)
-        assertEquals(listOf('a','b','b','a','c'), result[false])
+        assertEquals(listOf('a', 'b', 'b', 'a', 'c'), result[false])
-        assertEquals(listOf('A','A','B','D'), result[true])
+        assertEquals(listOf('A', 'A', 'B', 'D'), result[true])
     }
 
     @Test fun joinToString() {

libraries/stdlib/test/utils/KotlinVersionTest.kt

@@ -29,8 +29,7 @@ class KotlinVersionTest {
                 val (major, minor, patch) = IntArray(3) { index -> if (index == place) component else 0 }
                 if (component in 0..KotlinVersion.MAX_COMPONENT_VALUE) {
                     KotlinVersion(major, minor, patch)
-                }
+                } else {
-                else {
                     assertFailsWith<IllegalArgumentException>("Expected $major.$minor.$patch to be invalid version") {
                         KotlinVersion(major, minor, patch)
                     }

libraries/stdlib/test/utils/TODOTest.kt

@@ -13,6 +13,7 @@ class TODOTest {
         public val prop: String get() = TODO()
         @Suppress("UNREACHABLE_CODE", "CAST_NEVER_SUCCEEDS")
         fun method1() = TODO() as String
+
         public fun method2(): Int = TODO()
 
         public fun method3(switch: Boolean, value: String): String {
@@ -41,11 +42,12 @@ class TODOTest {
     }
 
 
-    @Test fun usage() {
+    @Test
+    fun usage() {
         val inst = PartiallyImplementedClass()
 
         assertNotImplemented { inst.prop }
-        assertNotImplemented{ inst.method1() }
+        assertNotImplemented { inst.method1() }
         assertNotImplemented { inst.method2() }
         assertNotImplemented { inst.method4() }
         assertNotImplementedWithMessage("what if false") { inst.method3(false, "test") }