test and add KClass to key

Author: hoc081098

channel-event-bus/build.gradle.kts

@@ -68,6 +68,18 @@ kotlin {
         implementation(libs.coroutines.test)
       }
     }
+
+    jsTest {
+      dependencies {
+        implementation(kotlin("test-js"))
+      }
+    }
+
+    jvmTest {
+      dependencies {
+        implementation(kotlin("test-junit"))
+      }
+    }
   }
 
   sourceSets.matching { it.name.contains("Test") }.all {

channel-event-bus/src/commonMain/kotlin/com/hoc081098/channeleventbus/ChannelEvent.kt

@@ -1,18 +1,31 @@
 package com.hoc081098.channeleventbus
 
+import kotlin.reflect.KClass
+
 /**
  * Represents an event that can be sent to a [ChannelEventBus].
  */
-public interface ChannelEvent<out T : ChannelEvent<T>> {
-  public interface Key<
-    @Suppress("unused")
-    out T : ChannelEvent<T>,
-    >
-
+public interface ChannelEvent<T : ChannelEvent<T>> {
   /**
    * The key to identify a bus for this type of events.
    */
   public val key: Key<T>
+
+  public open class Key<T : ChannelEvent<T>>(public val eventClass: KClass<T>) {
+    final override fun equals(other: Any?): Boolean {
+      if (this === other) return true
+      if (other !is Key<*>) return false
+      return eventClass == other.eventClass
+    }
+
+    final override fun hashCode(): Int = eventClass.hashCode()
+
+    final override fun toString(): String = "ChannelEvent.Key(${eventClass.simpleName})"
+  }
 }
 
-internal typealias ChannelEventKey<T> = ChannelEvent.Key<T>
+/**
+ * Alias for [ChannelEvent.Key].
+ * @see [ChannelEvent.Key]
+ */
+public typealias ChannelEventKey<T> = ChannelEvent.Key<T>

channel-event-bus/src/commonMain/kotlin/com/hoc081098/channeleventbus/ChannelEventBus.kt

@@ -4,6 +4,7 @@ import kotlin.collections.component1
 import kotlin.collections.component2
 import kotlin.collections.set
 import kotlin.jvm.JvmField
+import kotlin.reflect.cast
 import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.InternalCoroutinesApi
 import kotlinx.coroutines.channels.Channel
@@ -210,13 +211,12 @@ private class ChannelEventBusImpl(
     .trySend(event)
     .getOrElse { throw ChannelEventBusException.FailedToSendEvent(event, it) }
 
-  @Suppress("UNCHECKED_CAST")
   override fun <T : ChannelEvent<T>> receiveAsFlow(key: ChannelEventKey<T>): Flow<T> = flow {
     try {
       getOrCreateBusAndMarkAsCollecting(key)
         .channel
         .receiveAsFlow()
-        .map { it as T }
+        .map { key.eventClass.cast(it) }
         .let { emitAll(it) }
     } catch (@Suppress("TooGenericExceptionCaught") e: Throwable) {
       markAsNotCollecting(key)

channel-event-bus/src/commonTest/kotlin/com/hoc081098/channeleventbus/ChannelEventBusTest.kt

@@ -0,0 +1,66 @@
+package com.hoc081098.channeleventbus
+
+import kotlin.test.Test
+import kotlin.test.assertContentEquals
+import kotlinx.coroutines.flow.take
+import kotlinx.coroutines.flow.toList
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.test.runTest
+
+class ChannelEventBusTest {
+  @Test
+  fun sendAndReceiveMultiple() = runTest {
+    val bus = ChannelEventBus(ConsoleChannelEventBusLogger)
+
+    val sentTestEventInts = mutableListOf<TestEventInt>()
+    val sentTestEventStrings = mutableListOf<TestEventString>()
+    val sentTestEventLongs = mutableListOf<TestEventLong>()
+
+    repeat(100 * 3) { i ->
+      launch {
+        when (i % 3) {
+          0 -> bus.send(TestEventInt(i).also { sentTestEventInts += it })
+          1 -> bus.send(TestEventString(i.toString()).also { sentTestEventStrings += it })
+          2 -> bus.send(TestEventLong(i.toLong()).also { sentTestEventLongs += it })
+          else -> error("Unreachable")
+        }
+      }
+    }
+
+    launch {
+      val testEventInts = bus
+        .receiveAsFlow(TestEventInt)
+        .take(100)
+        .toList()
+
+      assertContentEquals(
+        expected = sentTestEventInts,
+        actual = testEventInts,
+      )
+    }
+
+    launch {
+      val testEventStrings = bus
+        .receiveAsFlow(TestEventString)
+        .take(100)
+        .toList()
+
+      assertContentEquals(
+        expected = sentTestEventStrings,
+        actual = testEventStrings,
+      )
+    }
+
+    launch {
+      val testEventStrings = bus
+        .receiveAsFlow(TestEventLong)
+        .take(100)
+        .toList()
+
+      assertContentEquals(
+        expected = sentTestEventLongs,
+        actual = testEventStrings,
+      )
+    }
+  }
+}

channel-event-bus/src/commonTest/kotlin/com/hoc081098/channeleventbus/ChannelEventTest.kt

@@ -0,0 +1,27 @@
+package com.hoc081098.channeleventbus
+
+import kotlin.test.Test
+import kotlin.test.assertEquals
+
+class ChannelEventTest {
+  @Test
+  fun testKeyEquals() {
+    assertEquals(TestEventIntKey, TestEventInt)
+    assertEquals(TestEventStringKey, TestEventString)
+    assertEquals(TestEventLongKey, TestEventLong)
+  }
+
+  @Test
+  fun testKeyHashCode() {
+    assertEquals(TestEventIntKey.hashCode(), TestEventInt.hashCode())
+    assertEquals(TestEventStringKey.hashCode(), TestEventString.hashCode())
+    assertEquals(TestEventLongKey.hashCode(), TestEventLong.hashCode())
+  }
+
+  @Test
+  fun testKeyToString() {
+    assertEquals("ChannelEvent.Key(TestEventInt)", TestEventIntKey.toString())
+    assertEquals("ChannelEvent.Key(TestEventString)", TestEventStringKey.toString())
+    assertEquals("ChannelEvent.Key(TestEventLong)", TestEventLongKey.toString())
+  }
+}

channel-event-bus/src/commonTest/kotlin/com/hoc081098/channeleventbus/events.kt

@@ -0,0 +1,30 @@
+package com.hoc081098.channeleventbus
+
+import kotlin.jvm.JvmField
+
+@JvmField
+val TestEventIntKey = ChannelEventKey(TestEventInt::class)
+
+@JvmField
+val TestEventStringKey = ChannelEventKey(TestEventString::class)
+
+@JvmField
+val TestEventLongKey = ChannelEventKey(TestEventLong::class)
+
+data class TestEventInt(val payload: Int) : ChannelEvent<TestEventInt> {
+  override val key get() = Key
+
+  companion object Key : ChannelEventKey<TestEventInt>(TestEventInt::class)
+}
+
+data class TestEventString(val payload: String) : ChannelEvent<TestEventString> {
+  override val key get() = Key
+
+  companion object Key : ChannelEventKey<TestEventString>(TestEventString::class)
+}
+
+data class TestEventLong(val payload: Long) : ChannelEvent<TestEventLong> {
+  override val key get() = Key
+
+  companion object Key : ChannelEventKey<TestEventLong>(TestEventLong::class)
+}