Reformat stdlib tests and samples

#KT-5558

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

@@ -26,7 +26,7 @@ class PromiseTest {
         assertStaticTypeIs<Promise<Int>>(
             p.then({
                        1
-                    } , {
+                   }, {
                        1
                    })
         )

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

@@ -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)
@@ -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/samples/test/samples/collections/sequences.kt

@@ -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/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) }
 }
 
@@ -82,9 +82,9 @@ 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 = "") {
@@ -97,8 +97,8 @@ public fun <T> CompareContext<T>.equalityBehavior(objectName: String = "") {
 
 public fun <T> CompareContext<Collection<T>>.collectionBehavior(objectName: String = "") {
     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?) } }
     propertyEquals { contains(firstOrNull()) }

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,7 +58,7 @@ 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)
@@ -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)
     }
@@ -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()) })
 

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)
             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,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(
+        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()"
+        )
     }
 
 }
@@ -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/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(
+    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'")
             }
@@ -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,7 +359,7 @@ 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() })
     }
 
@@ -378,12 +379,13 @@ 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 b  ",
@@ -399,7 +401,8 @@ class StringTest {
             assertContentEquals(source.trimStart().trimEnd(), example.trim())
         }
 
-        val examplesForPredicate = arrayOf("123",
+        val examplesForPredicate = arrayOf(
+            "123",
             "-=123=-"
         )
 
@@ -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))
 
@@ -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") }