Coroutine execution always performed with dispatch if the dispatcher is bound to a DuplicatedContext about vertx-lang-kotlin HOT 5 CLOSED

  override fun invokeOnTimeout(timeMillis: Long, block: Runnable, context: CoroutineContext): DisposableHandle {
    return (delegate as Delay).invokeOnTimeout(timeMillis, block, context)
  }

      try {
        withTimeout(100) {
          delay(1000)
        }
      } catch (e: TimeoutCancellationException) {

  @InternalCoroutinesApi
  @Test
  fun `test select-onTimeout execution dispatched on Vertx coroutine executor`(testContext: TestContext) {
    val latch = testContext.async()
    val context = (vertx as VertxInternal).getOrCreateContext()
    val duplicatedContext = context.duplicate()
    val invokeTimeoutOnDuplicatedContextDispatcher = object : CoroutineDispatcher(), Delay {
      override fun dispatch(context: CoroutineContext, block: Runnable) {
        testContext.fail()
      }

      override fun isDispatchNeeded(context: CoroutineContext): Boolean {
        return false
      }

      override fun scheduleResumeAfterDelay(timeMillis: Long, continuation: CancellableContinuation<Unit>) {
        testContext.fail()
      }

      override fun invokeOnTimeout(timeMillis: Long, block: Runnable, context: CoroutineContext): DisposableHandle {
        return super.invokeOnTimeout(timeMillis, block, context)
//        val delay = VertxCoroutineExecutor(duplicatedContext).asCoroutineDispatcher() as Delay
//        return delay.invokeOnTimeout(timeMillis, block, context)
      }
    }
    val promise = Promise.promise<Any>()
    duplicatedContext.runOnContext {
      GlobalScope.launch(vertx.dispatcher()) {
        val neverEndingJob = launch {
          promise.future().await()
        }
        withContext(invokeTimeoutOnDuplicatedContextDispatcher) {
          // still on Vert.x
          testContext.assertEquals(duplicatedContext, ContextInternal.current())
          select<Unit> {
            neverEndingJob.onJoin {
            }
            onTimeout(100) {
              testContext.assertEquals(duplicatedContext, ContextInternal.current())
              neverEndingJob.cancel()
              latch.complete()
            }
          }
        }
      }
    }
  }