Reformat stdlib tests and samples

#KT-5558

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/numbers/BigNumbersTest.kt

@@ -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)

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

@@ -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 = {
@@ -142,7 +144,8 @@ class LazyJVMTest {
         threads: Int = 3, runs: Int = 5000,
         initialize: () -> TState,
         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 ->
+            thread {
                 barrier.await()
                 repeat(runs) {
                     runResult += access(state, index)
                     barrier.await()
                 }
-        }}
+            }
+        }
 
         runners.forEach { it.join() }
 

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)
@@ -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/ComparisonDSL.kt

@@ -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

@@ -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

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

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/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)
             assertEquals(expectedModified, list.operation())
             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(
+            listOf("1/1", "5/5", "144/12", "46368/24", "75025/25"),
             fibonacci().mapIndexedNotNull { index, value ->
                 if (index > 0 && (value % index) == 0) "$value/$index" else null
-                }.take(5).toList())
+            }.take(5).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,7 +108,16 @@ 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()

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

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

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(
+        f2d: (Double, Double) -> Double,
         f2f: (Float, Float) -> Float,
-                             function: String) {
+        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() {
+        propagateOf2(
             { a, b -> arrayOf(a, b).min()!! },
-                     "arrayOf().min()")
+            { a, b -> arrayOf(a, b).min()!! },
+            "arrayOf().min()"
+        )
     }
 
-    @Test fun arrayMax() {
+    @Test
-        propagateOf2({ a, b -> arrayOf(a, b).max()!! },
+    fun arrayMax() {
+        propagateOf2(
             { a, b -> arrayOf(a, b).max()!! },
-                     "arrayOf().max()")
+            { a, b -> arrayOf(a, b).max()!! },
+            "arrayOf().max()"
+        )
     }
 
-    @Test fun primitiveArrayMin() {
+    @Test
-        propagateOf2({ a, b -> doubleArrayOf(a, b).min()!! },
+    fun primitiveArrayMin() {
+        propagateOf2(
+            { a, b -> doubleArrayOf(a, b).min()!! },
             { a, b -> floatArrayOf(a, b).min()!! },
-                     "primitiveArrayOf().min()")
+            "primitiveArrayOf().min()"
+        )
     }
 
-    @Test fun primitiveArrayMax() {
+    @Test
-        propagateOf2({ a, b -> doubleArrayOf(a, b).max()!! },
+    fun primitiveArrayMax() {
+        propagateOf2(
+            { a, b -> doubleArrayOf(a, b).max()!! },
             { a, b -> floatArrayOf(a, b).max()!! },
-                     "primitiveArrayOf().max()")
+            "primitiveArrayOf().max()"
+        )
     }
 
-    @Test fun listMin() {
+    @Test
-        propagateOf2({ a, b -> listOf(a, b).min()!! },
+    fun listMin() {
+        propagateOf2(
             { a, b -> listOf(a, b).min()!! },
-                     "listOf().min()")
+            { a, b -> listOf(a, b).min()!! },
+            "listOf().min()"
+        )
     }
 
-    @Test fun listMax() {
+    @Test
-        propagateOf2({ a, b -> listOf(a, b).max()!! },
+    fun listMax() {
+        propagateOf2(
             { a, b -> listOf(a, b).max()!! },
-                     "listOf().max()")
+            { a, b -> listOf(a, b).max()!! },
+            "listOf().max()"
+        )
     }
 
-    @Test fun sequenceMin() {
+    @Test
-        propagateOf2({ a, b -> sequenceOf(a, b).min()!! },
+    fun sequenceMin() {
+        propagateOf2(
             { a, b -> sequenceOf(a, b).min()!! },
-                     "sequenceOf().min()")
+            { a, b -> sequenceOf(a, b).min()!! },
+            "sequenceOf().min()"
+        )
     }
 
-    @Test fun sequenceMax() {
+    @Test
-        propagateOf2({ a, b -> sequenceOf(a, b).max()!! },
+    fun sequenceMax() {
+        propagateOf2(
             { a, b -> sequenceOf(a, b).max()!! },
-                     "sequenceOf().max()")
+            { a, b -> sequenceOf(a, b).max()!! },
+            "sequenceOf().max()"
+        )
     }
 
 }
@@ -127,33 +157,45 @@ class NaNTotalOrderTest {
         }
     }
 
-    @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/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(
+    convertOrFail: (String) -> T,
     convertOrNull: (String) -> T?,
     equality: (T, T?) -> Boolean = { a, b -> a == b },
-                                        assertions: ConversionContext<T>.() -> Unit) {
+    assertions: ConversionContext<T>.() -> Unit
+) {
     ConversionContext(convertOrFail, convertOrNull, equality).assertions()
 }
 
 
-internal fun <T : Any> compareConversionWithRadix(convertOrFail: String.(Int) -> T,
+internal fun <T : Any> compareConversionWithRadix(
+    convertOrFail: String.(Int) -> T,
     convertOrNull: String.(Int) -> T?,
-                                                 assertions: ConversionWithRadixContext<T>.() -> Unit) {
+    assertions: ConversionWithRadixContext<T>.() -> Unit
+) {
     ConversionWithRadixContext(convertOrFail, convertOrNull).assertions()
 }
 
 
-internal class ConversionContext<T: Any>(val convertOrFail: (String) -> T,
+internal class ConversionContext<T : Any>(
+    val convertOrFail: (String) -> T,
     val convertOrNull: (String) -> T?,
-                                        val equality: (T, T?) -> Boolean) {
+    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'")
             }
@@ -383,7 +384,8 @@ class StringTest {
     }
 
     @Test fun trimStartAndEnd() = withOneCharSequenceArg { arg1 ->
-        val examples = arrayOf("a",
+        val examples = arrayOf(
+            "a",
             " a ",
             "  a  ",
             "  a b  ",
@@ -399,7 +401,8 @@ class StringTest {
             assertContentEquals(source.trimStart().trimEnd(), example.trim())
         }
 
-        val examplesForPredicate = arrayOf("123",
+        val examplesForPredicate = arrayOf(
+            "123",
             "-=123=-"
         )
 
@@ -677,8 +680,14 @@ class StringTest {
 
 
         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)
+            )
         }
     }
 

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,7 +42,8 @@ class TODOTest {
     }
 
 
-    @Test fun usage() {
+    @Test
+    fun usage() {
         val inst = PartiallyImplementedClass()
 
         assertNotImplemented { inst.prop }