A modern programming language that makes developers happier.

kotlinlang

It’s failing with this output

```expected: Thread[test,5,main]
but was : Thread[main @coroutine#1,5,main]```

I’d say it is the same thread. But i got renamed for diagnostic purpose

How else might I be able to assert that they’re the same thread?

nope, definitely different threads.

```expected: 21
but was : 1```

It also fails while omitting the `UNDISPATCHED` start. I have edited the source example to simplify it further

Well, in general Dispatchers are not necessarily direct mappings to threads. Looks like  TestCoroutineDispatcher is the proof for that then.

As a counter test you could check if it is dispatching away from your single threaded dispatcher

Could you clarify? I believe your hypothesis to be true, which is why a plain old `runBlocking` works.

```@Test fun isolateFailing() = runBlocking(TestCoroutineDispatcher()) {
    var outerThread: Thread? = nullThread.currentThread()
    val singleThreadedContext = newSingleThreadContext("test")
    var innerThread: Thread? = null
    val function = suspend {
      outerThread = Thread.currentThread()
      innerThread = withContext(this@runBlocking.coroutineContext) {
        Thread.currentThread()
      }
    }

    val job = launch {
      withContext(singleThreadedContext) {
        function()
      }
    }

    job.join()
    assertThat(outerThread).isNotEqualTo(innerThread)
  }```

Yup, it’s not dispatching away from the single thread.

```expected not to be: Thread[test,5,main]```

And it is free not to do so. No violation I guess

If this is the case, it’s a real shame this is undocumented functionality

<https://github.com/Kotlin/kotlinx.coroutines/issues/2756>

it is documented behavior:
``` * By default, [TestCoroutineDispatcher] is immediate. That means any tasks scheduled to be run without delay are
 * immediately executed. If they were scheduled with a delay, the virtual clock-time must be advanced via one of the
 * methods on [DelayController].```