Make tests both more robust and more depressing to look at

Author: qwwdfsad

kotlinx-coroutines-core/jvm/src/CoroutineContext.kt

@@ -185,7 +185,8 @@ internal actual class UndispatchedCoroutine<in T>actual constructor (
      * `withContext` for the sake of logging, MDC, tracing etc., meaning that there exists thousands of
      * undispatched coroutines.
      * Each access to Java's [ThreadLocal] leaves a footprint in the corresponding Thread's `ThreadLocalMap`
-     * that is cleared automatically as soon as the associated thread-local (-> UndispatchedCoroutine) is garbage collected.
+     * that is cleared automatically as soon as the associated thread-local (-> UndispatchedCoroutine) is garbage collected
+     * when either the corresponding thread is GC'ed or it cleans up its stale entries on other TL accesses.
      * When such coroutines are promoted to old generation, `ThreadLocalMap`s become bloated and an arbitrary accesses to thread locals
      * start to consume significant amount of CPU because these maps are open-addressed and cleaned up incrementally on each access.
      * (You can read more about this effect as "GC nepotism").

kotlinx-coroutines-core/jvm/test/ThreadLocalsLeaksTest.kt

@@ -35,42 +35,45 @@ class ThreadLocalCustomContinuationInterceptorTest : TestBase() {
         override fun equals(other: Any?) = false
     }
 
-    @Test
+    @Test(timeout = 20_000L)
     fun testDefaultDispatcherNoSuspension() = ensureCoroutineContextGCed(Dispatchers.Default, suspend = false)
 
-    @Test
+    @Test(timeout = 20_000L)
     fun testDefaultDispatcher() = ensureCoroutineContextGCed(Dispatchers.Default, suspend = true)
 
 
-    @Test
+    @Test(timeout = 20_000L)
     fun testNonCoroutineDispatcher() = ensureCoroutineContextGCed(
         CustomContinuationInterceptor(Dispatchers.Default),
         suspend = true
     )
 
-    @Test
+    @Test(timeout = 20_000L)
     fun testNonCoroutineDispatcherSuspension() = ensureCoroutineContextGCed(
         CustomContinuationInterceptor(Dispatchers.Default),
         suspend = false
     )
 
     // Note asymmetric equals codepath never goes through the undispatched withContext, thus the separate test case
 
-    @Test
+    @Test(timeout = 20_000L)
     fun testNonCoroutineDispatcherAsymmetricEquals() =
         ensureCoroutineContextGCed(
             CustomNeverEqualContinuationInterceptor(Dispatchers.Default),
             suspend = true
         )
 
-    @Test
+    @Test(timeout = 20_000L)
     fun testNonCoroutineDispatcherAsymmetricEqualsSuspension() =
         ensureCoroutineContextGCed(
             CustomNeverEqualContinuationInterceptor(Dispatchers.Default),
             suspend = false
         )
 
 
+    @Volatile
+    private var letThatSinkIn: Any = "What is my purpose? To frag the garbage collctor"
+
     private fun ensureCoroutineContextGCed(coroutineContext: CoroutineContext, suspend: Boolean) {
         runTest {
             lateinit var ref: WeakReference<CoroutineName>
@@ -85,11 +88,10 @@ class ThreadLocalCustomContinuationInterceptorTest : TestBase() {
             }
             job.join()
 
-            // Twice is enough to ensure
-            System.gc()
-            System.gc()
-            assertNull(ref.get())
+            while (ref.get() != null) {
+                System.gc()
+                letThatSinkIn = LongArray(1024 * 1024)
+            }
         }
     }
-
 }