Fix non-unique Koin scope ids in DefaultSimulationContext/DefaultEditingContext

Author: Copilot

core/src/commonMain/kotlin/cz/vutbr/fit/interlockSim/context/ContextScopeIds.kt

@@ -0,0 +1,30 @@
+/* Brno University of Technology
+ * Faculty of Information Technology
+ *
+ * BSc Thesis  2006/2007
+ *
+ * Railway Interlocking Simulator
+ *
+ * Bedrich Hovorka
+ */
+package cz.vutbr.fit.interlockSim.context
+
+import kotlinx.atomicfu.atomic
+
+/**
+ * Generates unique Koin scope ids for [Context] implementations.
+ *
+ * [DefaultEditingContext] and [DefaultSimulationContext] each need a scope id that is
+ * guaranteed unique for the lifetime of the process. Identity hash codes (as used by
+ * [Any.hashCode] on objects that don't override it, or [cz.vutbr.fit.interlockSim.util.platformIdentityCode])
+ * are **not** unique - they live in a 31-bit space and collisions become likely once tens of
+ * thousands of contexts have been created (birthday bound), which throws
+ * `ScopeAlreadyCreatedException` (see Issue #757). A monotonic counter guarantees uniqueness
+ * regardless of how many contexts are created.
+ */
+private val nextContextScopeId = atomic(0L)
+
+/**
+ * Returns a new, process-wide unique id suitable for use as a Koin `scopeId`.
+ */
+internal fun nextContextScopeId(): String = nextContextScopeId.incrementAndGet().toString()

core/src/commonMain/kotlin/cz/vutbr/fit/interlockSim/context/DefaultEditingContext.kt

@@ -92,10 +92,10 @@ open class DefaultEditingContext(
 			.defaultContext()
 			.get()
 			.createScope(
-				// DefaultEditingContext does not override hashCode(), so this.hashCode()
-				// returns the identity hash code (equivalent to System.identityHashCode(this)).
-				// Each context instance gets a unique scope ID.
-				scopeId = this.hashCode().toString(),
+				// Uses a monotonic counter rather than an identity hash code, which is not
+				// guaranteed unique and can collide under high context creation volume
+				// (Issue #757).
+				scopeId = nextContextScopeId(),
 				qualifier =
 					org.koin.core.qualifier
 						.named<DefaultEditingContext>(),

core/src/commonMain/kotlin/cz/vutbr/fit/interlockSim/context/DefaultSimulationContext.kt

@@ -150,7 +150,7 @@ open class DefaultSimulationContext(
 			.defaultContext()
 			.get()
 			.createScope(
-				scopeId = platformIdentityCode(this),
+				scopeId = nextContextScopeId(),
 				qualifier =
 					org.koin.core.qualifier
 						.named<DefaultSimulationContext>(),

core/src/commonMain/kotlin/cz/vutbr/fit/interlockSim/util/PlatformIdentity.kt

@@ -8,5 +8,9 @@ package cz.vutbr.fit.interlockSim.util
  *
  * - **JVM:** delegates to [System.identityHashCode]
  * - **Native:** delegates to [kotlin.native.identityHashCode]
+ *
+ * **Do not use this as a unique identifier** (e.g. as a map/scope key). Identity hash codes live
+ * in a 31-bit space, so collisions become likely at moderate object counts (birthday bound) -
+ * this is for human-readable debug logging only. See Issue #757.
  */
 expect fun platformIdentityCode(obj: Any): String

core/src/commonTest/kotlin/cz/vutbr/fit/interlockSim/context/ContextScopeIdUniquenessTest.kt

@@ -0,0 +1,70 @@
+/* Brno University of Technology
+ * Faculty of Information Technology
+ *
+ * BSc Thesis  2006/2007
+ *
+ * Railway Interlocking Simulator
+ *
+ * Bedrich Hovorka
+ */
+package cz.vutbr.fit.interlockSim.context
+
+import assertk.assertThat
+import assertk.assertions.hasSize
+import cz.vutbr.fit.interlockSim.testutil.commonCoreTestModule
+import org.koin.core.context.startKoin
+import org.koin.core.context.stopKoin
+import kotlin.test.AfterTest
+import kotlin.test.BeforeTest
+import kotlin.test.Test
+
+/**
+ * Regression tests for Issue #757: [DefaultEditingContext] and [DefaultSimulationContext]
+ * used to derive their Koin `scopeId` from an identity hash code (`this.hashCode()` /
+ * [cz.vutbr.fit.interlockSim.util.platformIdentityCode]). Identity hash codes live in a
+ * 31-bit space, so under high context-creation volume (tens of thousands of contexts, e.g.
+ * JMH `AverageTime` benchmarks) two live contexts could collide and Koin would throw
+ * `ScopeAlreadyCreatedException`.
+ *
+ * The fix replaces the identity hash code with a process-wide monotonic counter
+ * ([nextContextScopeId]), which is unique by construction regardless of how many contexts
+ * are created concurrently.
+ */
+class ContextScopeIdUniquenessTest {
+	@BeforeTest
+	fun setUpKoin() {
+		startKoin { modules(commonCoreTestModule) }
+	}
+
+	@AfterTest
+	fun tearDownKoin() {
+		stopKoin()
+	}
+
+	@Test
+	fun scopeIdsAreUniqueAcrossManyEditingContexts() {
+		// Enough instances that identity-hash-code collisions (31-bit space, birthday bound)
+		// would have been likely with the old implementation, without making the test slow.
+		val count = 5_000
+		val scopeIds = mutableSetOf<String>()
+		val contexts = mutableListOf<DefaultEditingContext>()
+		try {
+			repeat(count) {
+				val context = DefaultEditingContext(2, 2)
+				contexts.add(context)
+				scopeIds.add(context.scope.id)
+			}
+			// Every context must have received a distinct scope id: no collisions, and thus
+			// no ScopeAlreadyCreatedException would have been thrown while creating them.
+			assertThat(scopeIds).hasSize(count)
+		} finally {
+			contexts.forEach { it.close() }
+		}
+	}
+
+	@Test
+	fun nextContextScopeIdIsMonotonicAndUnique() {
+		val ids = (1..1_000).map { nextContextScopeId() }
+		assertThat(ids.toSet()).hasSize(ids.size)
+	}
+}