Fix VirtualTimeSource not noticing that DefaultDelay is about to get created

Author: dkhalanskyjb

Diff for: kotlinx-coroutines-core/jvm/src/AbstractTimeSource.kt

@@ -99,7 +99,8 @@ internal inline fun unTrackTask(obj: Any) {
 
 /**
  * Increases the registered number of nested loops of the form
- * `while (nanoTime() < deadline) { parkNanos(deadline - nanoTime()) }` running in the current thread.
+ * `while (nanoTime() < deadline) { parkNanos(deadline - nanoTime()) }` corresponding to the object [key]
+ * and signals that the current thread is in such a loop.
  *
  * While at least one such loop is running, other threads are allowed to call [unpark] on the current thread
  * and wake it up. Before [registerTimeLoopThread] is called, [unpark] is not guaranteed to have any effect.

Diff for: kotlinx-coroutines-core/jvm/src/DefaultDelay.kt

@@ -75,6 +75,7 @@ private object DefaultDelayImpl : EventLoopImplBase(), Runnable {
         try {
             ThreadLocalEventLoop.setEventLoop(DelegatingUnconfinedEventLoop)
             registerTimeLoopThread()
+            unTrackTask(this) /** see the comment in [startThreadOrObtainSleepingThread] */
             try {
                 while (true) {
                     Thread.interrupted() // just reset interruption flag
@@ -107,6 +108,17 @@ private object DefaultDelayImpl : EventLoopImplBase(), Runnable {
         This means that whatever thread is going to be running by the end of this function,
         it's going to notice the tasks it's supposed to run.
         We can return `null` unconditionally. */
+        /** If this function is called from a thread that's already registered as a time loop thread,
+        because a time loop thread is not parked right now, the time source will not advance time *currently*,
+        but it may do that as soon as the thread calling this is parked, which may happen earlier than the default
+        delay thread has a chance to run.
+        Because of that, we notify the time source that something is actually happening right now.
+        This would work automatically if instead of [scheduleBackgroundIoTask] we used [CoroutineDispatcher.dispatch] on
+        [Dispatchers.IO], but then, none of the delays would be skipped, as the whole time a [DefaultDelay] thread runs
+        would be considered as a task.
+        Therefore, we register a task right now and mark it as completed as soon as a [DefaultDelay] time loop gets
+        registered. */
+        trackTask(this)
         scheduleBackgroundIoTask(this)
         return null
     }

Diff for: kotlinx-coroutines-core/jvm/test/VirtualTimeSource.kt

@@ -144,7 +144,6 @@ internal class VirtualTimeSource(
         isShutdown = true
         wakeupAll()
         while (!threads.isEmpty()) (this as Object).wait()
-        assert(trackedTasks.isEmpty()) { "There are still tracked tasks: $trackedTasks" }
     }
 
     private fun wakeupAll() {