Add tests for Channel closed with an exception (#4517)

Author: murfel

kotlinx-coroutines-core/common/test/channels/BasicOperationsTest.kt

@@ -8,31 +8,31 @@ class BasicOperationsTest : TestBase() {
     @Test
     fun testSimpleSendReceive() = runTest {
         // Parametrized common test :(
-        TestChannelKind.values().forEach { kind -> testSendReceive(kind, 20) }
+        TestChannelKind.entries.forEach { kind -> testSendReceive(kind, 20) }
     }
 
     @Test
     fun testTrySendToFullChannel() = runTest {
-        TestChannelKind.values().forEach { kind -> testTrySendToFullChannel(kind) }
+        TestChannelKind.entries.forEach { kind -> testTrySendToFullChannel(kind) }
     }
 
     @Test
     fun testTrySendAfterClose() = runTest {
-        TestChannelKind.values().forEach { kind -> testTrySendAfterClose(kind) }
+        TestChannelKind.entries.forEach { kind -> testTrySendAfterClose(kind) }
     }
 
     @Test
     fun testSendAfterClose() = runTest {
-        TestChannelKind.values().forEach { kind -> testSendAfterClose(kind) }
+        TestChannelKind.entries.forEach { kind -> testSendAfterClose(kind) }
     }
 
     @Test
     fun testReceiveCatching() = runTest {
-        TestChannelKind.values().forEach { kind -> testReceiveCatching(kind) }
+        TestChannelKind.entries.forEach { kind -> testReceiveCatching(kind) }
     }
 
     @Test
-    fun testInvokeOnClose() = TestChannelKind.values().forEach { kind ->
+    fun testInvokeOnClose() = TestChannelKind.entries.forEach { kind ->
         reset()
         val channel = kind.create<Int>()
         channel.invokeOnClose {
@@ -48,7 +48,7 @@ class BasicOperationsTest : TestBase() {
     }
 
     @Test
-    fun testInvokeOnClosed() = TestChannelKind.values().forEach { kind ->
+    fun testInvokeOnClosed() = TestChannelKind.entries.forEach { kind ->
         reset()
         expect(1)
         val channel = kind.create<Int>()
@@ -59,7 +59,7 @@ class BasicOperationsTest : TestBase() {
     }
 
     @Test
-    fun testMultipleInvokeOnClose() = TestChannelKind.values().forEach { kind ->
+    fun testMultipleInvokeOnClose() = TestChannelKind.entries.forEach { kind ->
         reset()
         val channel = kind.create<Int>()
         channel.invokeOnClose { expect(3) }
@@ -71,14 +71,16 @@ class BasicOperationsTest : TestBase() {
     }
 
     @Test
-    fun testIterator() = runTest {
-        TestChannelKind.values().forEach { kind ->
+    fun testIteratorHasNextMustPrecedeNext() = runTest {
+        TestChannelKind.entries.forEach { kind ->
             val channel = kind.create<Int>()
             val iterator = channel.iterator()
             assertFailsWith<IllegalStateException> { iterator.next() }
             channel.close()
             assertFailsWith<IllegalStateException> { iterator.next() }
             assertFalse(iterator.hasNext())
+            assertFailsWith<NoSuchElementException> { iterator.next() }
+            assertFailsWith<IllegalStateException> { iterator.next() }
         }
     }
 
@@ -109,7 +111,7 @@ class BasicOperationsTest : TestBase() {
             try {
                 expect(2)
                 channel.close()
-            } catch (e: TestException) {
+            } catch (_: TestException) {
                 expect(4)
             }
         }

kotlinx-coroutines-core/common/test/channels/ChannelIteratorTest.kt

@@ -0,0 +1,26 @@
+package kotlinx.coroutines.channels
+
+import kotlinx.coroutines.testing.*
+import kotlin.test.*
+
+class ChannelIteratorTest : TestBase() {
+    @Test
+    fun testIteratorClosedHasNextFalse() = runTest {
+        TestChannelKind.entries.forEach { kind ->
+            val channel = kind.create<Int>()
+            val iterator = channel.iterator()
+            channel.close()
+            assertFalse(iterator.hasNext())
+        }
+    }
+
+    @Test
+    fun testIteratorClosedWithExceptionHasNextThrows() = runTest {
+        TestChannelKind.entries.forEach { kind ->
+            val channel = kind.create<Int>()
+            val iterator = channel.iterator()
+            channel.close(TestException())
+            assertFailsWith<TestException> { iterator.hasNext() }
+        }
+    }
+}

kotlinx-coroutines-core/common/test/channels/ChannelPropertiesTest.kt

@@ -0,0 +1,54 @@
+package kotlinx.coroutines.channels
+
+import kotlinx.coroutines.testing.*
+import kotlin.test.*
+
+/**
+ * Properties stay the same regardless of whether the channel was closed with or without exception.
+ */
+class ChannelPropertiesAfterClosingTest : TestBase() {
+    @Test
+    fun testClosedIsClosedForReceive() = runTest {
+        TestChannelKind.entries.forEach { kind ->
+            for (exception in listOf(null, TestException())) {
+                val channel = kind.create<Int>()
+                assertFalse(channel.isClosedForReceive)
+                channel.close(exception)
+                assertTrue(channel.isClosedForReceive)
+            }
+        }
+    }
+
+    @Test
+    fun testClosedIsEmptyFalse() = runTest {
+        TestChannelKind.entries.forEach { kind ->
+            for (exception in listOf(null, TestException())) {
+                val channel = kind.create<Int>()
+                assertTrue(channel.isEmpty)
+                assertFalse(channel.isClosedForReceive)
+                channel.close(exception)
+                // NB! Not obvious.
+                assertFalse(channel.isEmpty)
+                assertTrue(channel.isClosedForReceive)
+            }
+        }
+    }
+
+    @Test
+    fun testSendClosedReceiveIsEmptyFalse() = runTest {
+        for (exception in listOf(null, TestException())) {
+            val channel = Channel<Int>(1)
+            assertTrue(channel.isEmpty)
+            assertFalse(channel.isClosedForReceive)
+            channel.send(1)
+            assertFalse(channel.isEmpty)
+            assertFalse(channel.isClosedForReceive)
+            channel.close(exception)
+            assertFalse(channel.isEmpty)
+            assertFalse(channel.isClosedForReceive)
+            channel.receive()
+            assertFalse(channel.isEmpty)
+            assertTrue(channel.isClosedForReceive)
+        }
+    }
+}