Reformat kotlin.test library

libraries/kotlin.test/common/src/main/kotlin/kotlin/test/Assertions.kt

@@ -118,7 +118,8 @@ fun assertFails(message: String?, block: () -> Unit): Throwable {
  *  Since inline method doesn't allow to trace where it was invoked, it is required to pass a [message] to distinguish this method call from others.
  */
 @InlineOnly
-inline fun <reified T : Throwable> assertFailsWith(message: String? = null, noinline block: () -> Unit): T = assertFailsWith(T::class, message, block)
+inline fun <reified T : Throwable> assertFailsWith(message: String? = null, noinline block: () -> Unit): T =
+    assertFailsWith(T::class, message, block)
 
 /** Asserts that a [block] fails with a specific exception of type [exceptionClass] being thrown. */
 fun <T : Throwable> assertFailsWith(exceptionClass: KClass<T>, block: () -> Unit): T = assertFailsWith(exceptionClass, null, block)

libraries/kotlin.test/common/src/main/kotlin/org/junit/Test.kt

@@ -7,7 +7,9 @@ package org.junit
 
 /** @suppress */
 @Suppress("NO_ACTUAL_FOR_EXPECT")
-@Deprecated("Use 'Test' from kotlin.test package",
+@Deprecated(
-            replaceWith = ReplaceWith("kotlin.test.Test", "kotlin.test.Test"),
+    "Use 'Test' from kotlin.test package",
-            level = DeprecationLevel.WARNING)
+    replaceWith = ReplaceWith("kotlin.test.Test", "kotlin.test.Test"),
+    level = DeprecationLevel.WARNING
+)
 expect annotation class Test()

libraries/kotlin.test/common/src/test/kotlin/kotlin/test/tests/AnnotationsTest.kt

@@ -11,23 +11,29 @@ private var value = 5
 
 class AnnotationsTest {
 
-    @BeforeTest fun setup() {
+    @BeforeTest
+    fun setup() {
         value *= 2
     }
 
-    @AfterTest fun teardown() {
+    @AfterTest
+    fun teardown() {
         value /= 2
     }
 
-    @Test fun testValue() {
+    @Test
+    fun testValue() {
         assertEquals(10, value)
     }
 
-    @Test fun testValueAgain() {
+    @Test
+    fun testValueAgain() {
         assertEquals(10, value)
     }
 
-    @Ignore @Test fun testValueWrong() {
+    @Ignore
+    @Test
+    fun testValueWrong() {
         assertEquals(20, value)
     }
 

libraries/kotlin.test/common/src/test/kotlin/kotlin/test/tests/BasicAssertionsTest.kt

@@ -30,24 +30,23 @@ class BasicAssertionsTest {
         assertFailsWith<AssertionError> { throw AssertionError() }
     }
 
-    @Test fun testAssertFailsWithFails() {
+    @Test
+    fun testAssertFailsWithFails() {
         assertTrue(true) // at least one assertion required for qunit
 
-        withDefaultAsserter run@ {
+        withDefaultAsserter run@{
             try {
                 assertFailsWith<IllegalStateException> { throw IllegalArgumentException() }
-            }
+            } catch (e: AssertionError) {
-            catch (e: AssertionError) {
                 return@run
             }
             throw AssertionError("Expected to fail")
         }
 
-        withDefaultAsserter run@ {
+        withDefaultAsserter run@{
             try {
-                assertFailsWith<IllegalStateException> {  }
+                assertFailsWith<IllegalStateException> { }
-            }
+            } catch (e: AssertionError) {
-            catch (e: AssertionError) {
                 return@run
             }
             throw AssertionError("Expected to fail")
@@ -105,7 +104,7 @@ class BasicAssertionsTest {
     @Test
     fun testAssertFalseFails() {
         checkFailedAssertion { assertFalse(true) }
-        checkFailedAssertion{ assertFalse { true } }
+        checkFailedAssertion { assertFalse { true } }
     }
 
     @Test
@@ -115,7 +114,7 @@ class BasicAssertionsTest {
 
     @Test()
     fun testAssertFailsFails() {
-        checkFailedAssertion { assertFails {  } }
+        checkFailedAssertion { assertFails { } }
     }
 
 
@@ -203,8 +202,7 @@ private fun withDefaultAsserter(block: () -> Unit) {
     val current = overrideAsserter(DefaultAsserter())
     try {
         block()
-    }
+    } finally {
-    finally {
         overrideAsserter(current)
     }
 }

libraries/kotlin.test/js/it/src/test/kotlin/MainTest.kt

@@ -5,23 +5,29 @@ var value = 5
 
 class SimpleTest {
 
-    @BeforeTest fun beforeFun() {
+    @BeforeTest
+    fun beforeFun() {
         value *= 2
     }
 
-    @AfterTest fun afterFun() {
+    @AfterTest
+    fun afterFun() {
         value /= 2
     }
 
-    @Test fun testFoo() {
+    @Test
+    fun testFoo() {
         assertNotEquals(value, foo())
     }
 
-    @Test fun testBar() {
+    @Test
+    fun testBar() {
         assertEquals(value, foo())
     }
 
-    @Ignore @Test fun testFooWrong() {
+    @Ignore
+    @Test
+    fun testFooWrong() {
         assertEquals(20, foo())
     }
 
@@ -29,7 +35,8 @@ class SimpleTest {
 
 @Ignore
 class TestTest {
-    @Test fun emptyTest() {
+    @Test
+    fun emptyTest() {
     }
 }
 

libraries/kotlin.test/js/src/main/kotlin/kotlin/test/DefaultJsAsserter.kt

@@ -58,8 +58,7 @@ internal object DefaultJsAsserter : Asserter {
     override fun assertTrue(lazyMessage: () -> String?, actual: Boolean) {
         if (!actual) {
             failWithMessage(lazyMessage)
-        }
+        } else {
-        else {
             invokeHook(true, lazyMessage)
         }
     }
@@ -89,8 +88,7 @@ internal object DefaultJsAsserter : Asserter {
                 override val actual: Any? = a
                 override val lazyMessage: () -> String? = lazyMessage
             })
-        }
+        } finally {
-        finally {
             e = undefined
             a = undefined
         }

libraries/kotlin.test/js/src/main/kotlin/kotlin/test/TestApi.kt

@@ -21,9 +21,8 @@ internal fun setAdapter(adapter: dynamic) {
     if (js("typeof adapter === 'string'")) {
         NAME_TO_ADAPTER[adapter]?.let {
             setAdapter(it.invoke())
-        }?: throw IllegalArgumentException("Unsupported test framework adapter: '$adapter'")
+        } ?: throw IllegalArgumentException("Unsupported test framework adapter: '$adapter'")
-    }
+    } else {
-    else {
         currentAdapter = adapter
     }
 }
@@ -74,8 +73,9 @@ internal fun detectAdapter() = when {
 }
 
 internal val NAME_TO_ADAPTER: Map<String, () -> FrameworkAdapter> = mapOf(
-        "qunit" to ::QUnitAdapter,
+    "qunit" to ::QUnitAdapter,
-        "jasmine" to ::JasmineLikeAdapter,
+    "jasmine" to ::JasmineLikeAdapter,
-        "mocha" to ::JasmineLikeAdapter,
+    "mocha" to ::JasmineLikeAdapter,
-        "jest" to ::JasmineLikeAdapter,
+    "jest" to ::JasmineLikeAdapter,
-        "auto" to ::detectAdapter)
+    "auto" to ::detectAdapter
+)

libraries/kotlin.test/js/src/main/kotlin/kotlin/test/adapters/Externals.kt

@@ -14,9 +14,10 @@ internal external object QUnit {
     fun skip(name: String, testFn: (dynamic) -> Unit): Unit
 }
 
-/**
+/*
  * Jasmine/Mocha/Jest API
  */
+
 internal external fun describe(name: String, fn: () -> Unit)
 internal external fun xdescribe(name: String, fn: () -> Unit)
 internal external fun it(name: String, fn: () -> Unit)

libraries/kotlin.test/js/src/main/kotlin/kotlin/test/adapters/JasmineLikeAdapter.kt

@@ -15,8 +15,7 @@ internal class JasmineLikeAdapter : FrameworkAdapter {
     override fun suite(name: String, ignored: Boolean, suiteFn: () -> Unit) {
         if (ignored) {
             xdescribe(name, suiteFn)
-        }
+        } else {
-        else {
             describe(name, suiteFn)
         }
     }
@@ -24,8 +23,7 @@ internal class JasmineLikeAdapter : FrameworkAdapter {
     override fun test(name: String, ignored: Boolean, testFn: () -> Unit) {
         if (ignored) {
             xit(name, testFn)
-        }
+        } else {
-        else {
             it(name, testFn)
         }
     }

libraries/kotlin.test/js/src/main/kotlin/kotlin/test/adapters/QUnitAdapter.kt

@@ -25,8 +25,7 @@ internal class QUnitAdapter : FrameworkAdapter {
     override fun test(name: String, ignored: Boolean, testFn: () -> Unit) {
         if (ignored or ignoredSuite) {
             QUnit.skip(name, wrapTest(testFn))
-        }
+        } else {
-        else {
             QUnit.test(name, wrapTest(testFn))
         }
     }

libraries/kotlin.test/js/src/main/kotlin/org/junit/junitTest.kt

@@ -5,7 +5,9 @@
 
 package org.junit
 
-@Deprecated("Use 'Test' from kotlin.test package",
+@Deprecated(
-        replaceWith = ReplaceWith("kotlin.test.Test", "kotlin.test.Test"),
+    "Use 'Test' from kotlin.test package",
-        level = DeprecationLevel.WARNING)
+    replaceWith = ReplaceWith("kotlin.test.Test", "kotlin.test.Test"),
+    level = DeprecationLevel.WARNING
+)
 actual typealias Test = kotlin.test.Test

libraries/kotlin.test/junit/src/main/kotlin/Annotations.kt

@@ -6,6 +6,7 @@
 
 @file:Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
 @file:JvmPackageName("kotlin.test.junit.annotations")
+
 package kotlin.test
 
 public actual typealias Test = org.junit.Test

libraries/kotlin.test/jvm/src/main/kotlin/AssertionsImpl.kt

@@ -6,6 +6,7 @@
 @file:kotlin.jvm.JvmMultifileClass
 @file:kotlin.jvm.JvmName("AssertionsKt")
 @file:Suppress("INVISIBLE_REFERENCE", "INVISIBLE_MEMBER")
+
 package kotlin.test
 
 import kotlin.internal.*
@@ -32,7 +33,8 @@ private fun <T : Throwable> assertFailsWithImpl(exceptionClass: Class<T>, messag
 
 
 /** Asserts that a [block] fails with a specific exception of type [exceptionClass] being thrown. */
-actual fun <T : Throwable> assertFailsWith(exceptionClass: KClass<T>, message: String?, block: () -> Unit): T = assertFailsWithImpl(exceptionClass.java, message, block)
+actual fun <T : Throwable> assertFailsWith(exceptionClass: KClass<T>, message: String?, block: () -> Unit): T =
+    assertFailsWithImpl(exceptionClass.java, message, block)
 
 
 /**

libraries/kotlin.test/jvm/src/test/kotlin/CollectionAssertionTest.kt

@@ -4,6 +4,7 @@
  */
 
 @file:Suppress("DEPRECATION")
+
 package kotlin.test.tests
 
 import org.junit.Assert

libraries/kotlin.test/jvm/src/test/kotlin/TestJVMTest.kt

@@ -12,8 +12,7 @@ class TestJVMTest {
     private fun expectAssertion(checkAssertion: (String?) -> Unit, block: () -> Unit) {
         try {
             block()
-        }
+        } catch (e: AssertionError) {
-        catch (e: AssertionError) {
             checkAssertion(e.message)
             return
         }
@@ -30,67 +29,68 @@ class TestJVMTest {
 
     @Test
     fun assertEqualsMessage() {
-        expectAssertion( { msg ->
+        expectAssertion({ msg ->
-            assertNotNull(msg); msg!!
+                            assertNotNull(msg); msg!!
-            assertTrue { msg.contains(expected.toString()) }
+                            assertTrue { msg.contains(expected.toString()) }
-            assertTrue { msg.contains(actual.toString()) }
+                            assertTrue { msg.contains(actual.toString()) }
-            assertFalse { msg.startsWith(".") }
+                            assertFalse { msg.startsWith(".") }
-        }, { assertEquals<Any>(expected, actual) })
+                        }, { assertEquals<Any>(expected, actual) })
 
-        expectAssertion( { msg ->
+        expectAssertion({ msg ->
-            assertNotNull(msg); msg!!
+                            assertNotNull(msg); msg!!
-            assertTrue { msg.contains(message) }
+                            assertTrue { msg.contains(message) }
-            assertTrue { msg.contains(expected.toString()) }
+                            assertTrue { msg.contains(expected.toString()) }
-            assertTrue { msg.contains(actual.toString()) }
+                            assertTrue { msg.contains(actual.toString()) }
-        } , { assertEquals<Any>(expected, actual, message) })
+                        }, { assertEquals<Any>(expected, actual, message) })
     }
 
     @Test
     fun assertNotEqualsMessage() {
-        expectAssertion( { msg ->
+        expectAssertion({ msg ->
-            assertNotNull(msg); msg!!
+                            assertNotNull(msg); msg!!
-            assertTrue { msg.contains(actual.toString()) }
+                            assertTrue { msg.contains(actual.toString()) }
-            assertFalse { msg.startsWith(".") }
+                            assertFalse { msg.startsWith(".") }
-        }, { assertNotEquals(actual, actual) })
+                        }, { assertNotEquals(actual, actual) })
 
-        expectAssertion( { msg ->
+        expectAssertion({ msg ->
-            assertNotNull(msg); msg!!
+                            assertNotNull(msg); msg!!
-            assertTrue { msg.contains(message) }
+                            assertTrue { msg.contains(message) }
-            assertTrue { msg.contains(actual.toString()) }
+                            assertTrue { msg.contains(actual.toString()) }
-        } , { assertNotEquals(actual, actual, message) })
+                        }, { assertNotEquals(actual, actual, message) })
     }
 
 
     @Test
     fun assertTrueMessage() {
-        expectAssertion( { msg -> assertNotNull(msg) }, { assertTrue(false) })
+        expectAssertion({ msg -> assertNotNull(msg) }, { assertTrue(false) })
-        expectAssertion( { msg -> assertNotNull(msg) }, { assertTrue { false } })
+        expectAssertion({ msg -> assertNotNull(msg) }, { assertTrue { false } })
-        expectAssertion( { msg -> assertNotNull(msg) }, { assertTrue(null) { false } })
+        expectAssertion({ msg -> assertNotNull(msg) }, { assertTrue(null) { false } })
-        expectAssertion( { msg -> msg!!.contains(message)}, { assertTrue(false, message)})
+        expectAssertion({ msg -> msg!!.contains(message) }, { assertTrue(false, message) })
-        expectAssertion( { msg -> msg!!.contains(message)}, { assertTrue(message) { false }})
+        expectAssertion({ msg -> msg!!.contains(message) }, { assertTrue(message) { false } })
     }
 
     @Test
     fun assertFalseMessage() {
-        expectAssertion( { msg -> assertNotNull(msg) }, { assertFalse(true) })
+        expectAssertion({ msg -> assertNotNull(msg) }, { assertFalse(true) })
-        expectAssertion( { msg -> assertNotNull(msg) }, { assertFalse { true } })
+        expectAssertion({ msg -> assertNotNull(msg) }, { assertFalse { true } })
-        expectAssertion( { msg -> assertNotNull(msg) }, { assertFalse(null) { true } })
+        expectAssertion({ msg -> assertNotNull(msg) }, { assertFalse(null) { true } })
-        expectAssertion( { msg -> assertTrue(msg!!.contains(message)) }, { assertFalse(true, message)})
+        expectAssertion({ msg -> assertTrue(msg!!.contains(message)) }, { assertFalse(true, message) })
-        expectAssertion( { msg -> assertTrue(msg!!.contains(message)) }, { assertFalse(message) { true }})
+        expectAssertion({ msg -> assertTrue(msg!!.contains(message)) }, { assertFalse(message) { true } })
     }
 
     @Test
     fun assertNotNullMessage() {
-        expectAssertion( { msg -> msg!! }, { assertNotNull(null) })
+        expectAssertion({ msg -> msg!! }, { assertNotNull(null) })
-        expectAssertion( { msg -> assertTrue(msg!!.contains(message)) }, { assertNotNull(null, message)})
+        expectAssertion({ msg -> assertTrue(msg!!.contains(message)) }, { assertNotNull(null, message) })
     }
 
     @Test
     fun assertNullMessage() {
-        expectAssertion( { msg -> msg!! }, { assertNull(actual) })
+        expectAssertion({ msg -> msg!! }, { assertNull(actual) })
-        expectAssertion( { msg -> msg!!
+        expectAssertion({ msg ->
-            assertTrue(msg.contains(message))
+                            msg!!
-            assertTrue(msg.contains(actual.toString()))
+                            assertTrue(msg.contains(message))
-        }, { assertNull(actual, message)})
+                            assertTrue(msg.contains(actual.toString()))
+                        }, { assertNull(actual, message) })
     }
 }

libraries/kotlin.test/testng/src/main/kotlin/Annotations.kt

@@ -6,6 +6,7 @@
 
 @file:Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
 @file:JvmPackageName("kotlin.test.testng.annotations")
+
 package kotlin.test
 
 public actual typealias Test = org.testng.annotations.Test