Remove deprecation leftovers in reactive modules

Author: qwwdfsad

reactive/kotlinx-coroutines-reactive/test/IntegrationTest.kt

@@ -52,9 +52,6 @@ class IntegrationTest(
         assertEquals("ELSE", pub.awaitFirstOrElse { "ELSE" })
         assertFailsWith<NoSuchElementException> { pub.awaitLast() }
         assertFailsWith<NoSuchElementException> { pub.awaitSingle() }
-        assertEquals("OK", pub.awaitSingleOrDefault("OK"))
-        assertNull(pub.awaitSingleOrNull())
-        assertEquals("ELSE", pub.awaitSingleOrElse { "ELSE" })
         var cnt = 0
         pub.collect { cnt++ }
         assertEquals(0, cnt)
@@ -72,9 +69,6 @@ class IntegrationTest(
         assertEquals("OK", pub.awaitFirstOrElse { "ELSE" })
         assertEquals("OK", pub.awaitLast())
         assertEquals("OK", pub.awaitSingle())
-        assertEquals("OK", pub.awaitSingleOrDefault("!"))
-        assertEquals("OK", pub.awaitSingleOrNull())
-        assertEquals("OK", pub.awaitSingleOrElse { "ELSE" })
         var cnt = 0
         pub.collect {
             assertEquals("OK", it)
@@ -189,10 +183,6 @@ class IntegrationTest(
             onError(dummyThrowable)
             onComplete()
         }
-        assertDetectsBadPublisher<Int>({ awaitSingleOrDefault(2) }, "terminal state") {
-            onComplete()
-            onError(dummyThrowable)
-        }
         assertDetectsBadPublisher<Int>({ awaitFirst() }, "terminal state") {
             onNext(0)
             onComplete()
@@ -251,4 +241,4 @@ internal suspend inline fun <reified E: Throwable> assertCallsExceptionHandlerWi
             it
         }
     }
-}
+}

reactive/kotlinx-coroutines-reactor/test/FluxSingleTest.kt

@@ -68,72 +68,6 @@ class FluxSingleTest : TestBase() {
         }
     }
 
-    @Test
-    fun testAwaitSingleOrDefault() {
-        val flux = flux {
-            send(Flux.empty<String>().awaitSingleOrDefault("O") + "K")
-        }
-
-        checkSingleValue(flux) {
-            assertEquals("OK", it)
-        }
-    }
-
-    @Test
-    fun testAwaitSingleOrDefaultException() {
-        val flux = flux {
-            send(Flux.just("O", "#").awaitSingleOrDefault("!") + "K")
-        }
-
-        checkErroneous(flux) {
-            assert(it is IllegalArgumentException)
-        }
-    }
-
-    @Test
-    fun testAwaitSingleOrNull() {
-        val flux = flux<String?> {
-            send(Flux.empty<String>().awaitSingleOrNull() ?: "OK")
-        }
-
-        checkSingleValue(flux) {
-            assertEquals("OK", it)
-        }
-    }
-
-    @Test
-    fun testAwaitSingleOrNullException() {
-        val flux = flux {
-            send((Flux.just("O", "#").awaitSingleOrNull() ?: "!") + "K")
-        }
-
-        checkErroneous(flux) {
-            assert(it is IllegalArgumentException)
-        }
-    }
-
-    @Test
-    fun testAwaitSingleOrElse() {
-        val flux = flux {
-            send(Flux.empty<String>().awaitSingleOrElse { "O" } + "K")
-        }
-
-        checkSingleValue(flux) {
-            assertEquals("OK", it)
-        }
-    }
-
-    @Test
-    fun testAwaitSingleOrElseException() {
-        val flux = flux {
-            send(Flux.just("O", "#").awaitSingleOrElse { "!" } + "K")
-        }
-
-        checkErroneous(flux) {
-            assert(it is IllegalArgumentException)
-        }
-    }
-
     @Test
     fun testAwaitFirst() {
         val flux = flux {

reactive/kotlinx-coroutines-reactor/test/MonoTest.kt

@@ -119,29 +119,6 @@ class MonoTest : TestBase() {
         assertNull(Mono.empty<Int>().awaitSingleOrNull())
     }
 
-    /** Tests that the versions of the await methods specialized for Mono for deprecation behave correctly and we don't
-     * break any code by introducing them. */
-    @Test
-    @Suppress("DEPRECATION")
-    fun testDeprecatedAwaitMethods() = runBlocking {
-        val filledMono = mono<String> { "OK" }
-        assertEquals("OK", filledMono.awaitFirst())
-        assertEquals("OK", filledMono.awaitFirstOrDefault("!"))
-        assertEquals("OK", filledMono.awaitFirstOrNull())
-        assertEquals("OK", filledMono.awaitFirstOrElse { "ELSE" })
-        assertEquals("OK", filledMono.awaitLast())
-        assertEquals("OK", filledMono.awaitSingleOrDefault("!"))
-        assertEquals("OK", filledMono.awaitSingleOrElse { "ELSE" })
-        val emptyMono = mono<String> { null }
-        assertFailsWith<NoSuchElementException> { emptyMono.awaitFirst() }
-        assertEquals("OK", emptyMono.awaitFirstOrDefault("OK"))
-        assertNull(emptyMono.awaitFirstOrNull())
-        assertEquals("ELSE", emptyMono.awaitFirstOrElse { "ELSE" })
-        assertFailsWith<NoSuchElementException> { emptyMono.awaitLast() }
-        assertEquals("OK", emptyMono.awaitSingleOrDefault("OK"))
-        assertEquals("ELSE", emptyMono.awaitSingleOrElse { "ELSE" })
-    }
-
     /** Tests that calls to [awaitSingleOrNull] (and, thus, to the rest of such functions) throw [CancellationException]
      * and unsubscribe from the publisher when their [Job] is cancelled. */
     @Test