Probably, you are using the direct collect() function on Flow. For your syntax, you need to import the collect() extension function. (and I really wish that they did not name these the same…)
This page shows some general techniques. In short, run with enabled assertions (-ea JVM flag). kotlinx-coroutines-debug module is specifically designed for what its name says. This is how I use it in unit tests; runBlocking { DebugProbes.install() val deferred = async { methodUnderTest() } delay(3000) DebugProbes.dumpCoroutines() println(“\nDumping only deferred”) DebugProbes.printJob(deferred) DebugProbes.uninstall() cleanup() } There’s a … Read more
Pankaj’s answer is correct, StateFlow won’t emit the same value twice. As the documentation suggests: Values in state flow are conflated using Any.equals comparison in a similar way to distinctUntilChanged operator. It is used to conflate incoming updates to value in MutableStateFlow and to suppress emission of the values to collectors when new value is … Read more
UPDATED 2023 Add the following dependency on your gradle. Documentation here testImplementation “org.jetbrains.kotlinx:kotlinx-coroutines-test:$coroutines_version” Add the following Custom TestRule as a utility for your tests // Reusable JUnit4 TestRule to override the Main dispatcher @OptIn(ExperimentalCoroutinesApi::class) class MainDispatcherRule( private val testDispatcher: TestDispatcher = UnconfinedTestDispatcher() ) : TestWatcher() { override fun starting(description: Description) { Dispatchers.setMain(testDispatcher) } override fun … Read more
According to this, use Response<Unit> in the retrofit method declaration. retrofit no content issue
Edit: note that the API suggested in the original answer is now marked @ObsoleteCoroutineApi: Ticker channels are not currently integrated with structured concurrency and their api will change in the future. You can now use the Flow API to create your own ticker flow: import kotlin.time.Duration import kotlin.time.Duration.Companion.seconds import kotlinx.coroutines.* import kotlinx.coroutines.flow.* fun tickerFlow(period: Duration, … Read more
A solution is not to cancel the flow, but the Job returned from launching the flow in a scope. val job = scope.launch { flow.cancellable().collect { } } job.cancel() NOTE: cancellable() will ensure the flow is terminated before new items are emitted to collect { } if its job is cancelled, though flow builder and … Read more
For many use cases where the best tool so far was Channel, Flow has become the new best tool. As a specific example, callbackFlow is now the best approach to receiving data from a 3rd-party API’s callback. This works especially well in a GUI setting. It couples the callback, a channel, and the associated receiving … Read more
If you don’t want any delay, why don’t you simply resume the continuation in the schedule call?: class TestUiContext : CoroutineDispatcher(), Delay { override fun scheduleResumeAfterDelay(time: Long, unit: TimeUnit, continuation: CancellableContinuation<Unit>) { continuation.resume(Unit) } override fun dispatch(context: CoroutineContext, block: Runnable) { //CommonPool.dispatch(context, block) // dispatch on CommonPool block.run() // dispatch on calling thread } } … Read more
Coroutine’s analog to ThreadLocal is CoroutineContext. To interoperate with ThreadLocal-using libraries you need to implement a custom ContinuationInterceptor that supports framework-specific thread-locals. Here is an example. Let us assume that we use some framework that relies on a specific ThreadLocal to store some application-specific data (MyData in this example): val myThreadLocal = ThreadLocal<MyData>() To use … Read more