Been looking at the new test helpers such as

runBlockingTest

,

TestCoroutineDispatcher

,

TestCoroutineScope

, etc. They look promising, however I haven't been able to figure out a way to stub a dependency's

suspend

function using

mockito-kotlin

such that it suspends indefinitely. The goal is to test scenarios within my Android

ViewModel

where

onCleared()

is called before a

suspend

function returns a result. Basically something like:

private fun givenStatusNeverReceived() = runBlocking {
    // loadStatus() is a suspend function
    given(repository.loadStatus()).willAnswer {
        // suspend indefinitely
    }
}

How do I attach a piece of code to run when a

Flow

is cancelled/disposed. Something like

ObservableEmitter.setCancellable { ... }

in the rx world. I want to use

Flow

to model an add/remove listener so that a listener is attached when the flow is “subscribed” to and detached when the subscription is “disposed”. Forgive the rx lingo, pretty new to

Flow

so I will also appreciate reading material that can tie or at least differenciate between my RxJava knowlege and

Flow

I’m trying to run some Android tests, what did I miss? I have

kotlinx-coroutines-test

in my test dependencies.

java.lang.NullPointerException
	at kotlinx.coroutines.CoroutineContextKt.newCoroutineContext(CoroutineContext.kt:57)
	at kotlinx.coroutines.BuildersKt__Builders_commonKt.launch(Builders.common.kt:50)
	at kotlinx.coroutines.BuildersKt.launch(Unknown Source)
	at kotlinx.coroutines.BuildersKt__Builders_commonKt.launch$default(Builders.common.kt:47)
	at kotlinx.coroutines.BuildersKt.launch$default(Unknown Source)

Hello, I would like to use coroutines to handle delay and update of text from an EditText via his TextWatcher listener. In fact, if user continue to type something, I would like to cancel current coroutine and fire another one. It would works like timer/handler implementation for this type of case. Thanks in advance for your time and sorry for my crappy english 😅

Hey guys, I am trying to mock

delay

in the following code:

class A(val coroutineContext: CoroutineContext = EmptyCoroutineContext) {
    fun work(): String {
        val result = runBlocking(coroutineContext) {
            delay(3000)
            return "some_result"
        }
        return result
    }
}

@Test
fun `tests work`() {
    val result = A().work()

    assertEquals("some_result", result)
}

If a pass

TestCoroutineContext()

to runBlocking the

delay

is ignored as expected. However, It’s deprecated in favor of TestCoroutineScope. TestCoroutineScope. However If I pass TestCoroutineScope the test never finishes:

@Test
fun `tests work`() {
    val result = A(TestCoroutineScope(TestCoroutineDispatcher()).coroutineContext).work()
    
    // never reaches here
    assertEquals("some_result", result)
}

What I am missing?

Hello, how i can create Kotlin job and start it later?

Hello guys! is there another way to return a value from a Coroutine without blocking the Main Thread? Maybe using Channels or Flow? . I'm getting an object from Room and I want to return a specific attribute from that object after get it.

Hi! I want to wrap my player callback into suspend function that will just suspend until something completed without returning any value. Is there some alternative for

suspendCoroutine

that doesn’t require passing result value?

Hi everyone, I'm starting to use coroutines in prod and could use a bit of advice. I need to observe state of couple of components, both should offer subscribe/unsubscribe ops. I'm thinking of having a channel for each, created on subscription, canceling does the unsubscribe, and observe both using

select

. Is that fine? Are there any channel constructs that could help?

I find

Flow

very well designed, kudos to the people involved. I like how it reuses the continuation of the consumer and how exceptions and cancellation are propagated. Is it bad to use them in production under their preview status? :yes: or 🇳🇴

If I am writing a function that can call suspendable functions, is there a preference between making that function suspend itself, or defining it on CoroutineScope ? Or in other words, when should one use suspend and when should one use CoroutineScope as a receiver ?

Does

launch

require a corresponding

join

or will the coroutine resources created with

launch

be automatically reclaimed on coroutine completion?

Does

Flow

have a corresponding

select

clause, and if it doesn't, is it planned ?

Is there are any debug facilities for that? e.g. configuring that channels will throw exception after n minutes of suspension

I hope someday channels will be bound to coroutine lifecycles and we no longer need explicitly do coroutineContext[Job]!!.invokeOnCompletion { broadcastChannel.close() }

Hi! Does anyone have any pointer in how you could debug a coroutine that doesn’t seem to wake up at the correct time? I have a test where a message is picked up on a queue which results in a request towards a stub (which returns 404). The problem is that even though the stub is up and ready it seems that the coroutine that is suspending (it’s a post from the ktor http client) is not “woken up” until after about 30 seconds when the same message gets republished on the queue. The coroutine that I suspect to not be woken up correctly is surrounded in a repeat, I see that first repeat happen but then it just goes silent

Is there a reason to NOT use

MainDispatcher.immediate

over just regular

MainDispatcher

?

How change Entity class to Protected? I have message Modifier protected is not applicable inside "file".

Under what circumstances would

delay

suspend forever, if I pass it a value around 500-1500 MS? I have some code that is looping with an interval which works perfectly in one environment but not in another - where it's used as a plugin in some other software. The dispatcher used is a single thread dispatcher created using

Executors.newSingleThreadDispatcher(threadFactory).asCoroutineDispatcher()

The behavior I'm seeing is that it never resumes the coroutine.

Why does flow stream emit a serial of items instead of only the latest one (like observable in rx) when collect (subscribe), Is there any way to work around this behaviour?

I also have a problem with the delay function. I am trying to do a simple while in kotlin multiplatform. The following function works in android but not on iOS. In the logs on iOS side, i see "Before delay" but i don't see the other print.

I’m writing a suspend function that takes a suspend block as an arg, executes it asynchronously, meanwhile monitoring the length of a file and periodically notifying a callback of the current file length. At the moment I have this, but I’m sure there’s a much neater way, for example, not using GlobalScope.

suspend fun File.trackLength(fileLengthCallback: (Long) -> Unit, refreshInterval: Long = 100L, block: suspend () -> Unit) {
    val deferred = GlobalScope.async {
        block()
    }
    while (deferred.isActive) {
        fileLengthCallback(length())
        delay(refreshInterval)
    }
    fileLengthCallback(length())
}

I have a situation where I use coroutines and the upcoming semaphore class for coroutines will be very useful. However I’m pretty sure I will shoot myself in the foot and create a deadlock. Can anyone recommend a good book for understanding and handling these types of threading scenarios and preventing and resolving deadlock and the like?

Whats the difference b/w

coroutineScope

and

launch

? (Its not super clear from the docs)

Suppose I have

suspend fun myFun() {
    repeat(100) {
        someSuspendingFunSpecifyingIODispatcher()
        someQuickNonSuspendingFun()
    }
}

At the top-level of myFun() is it better to have withContext(Dispatchers.IO), coroutineScope {} or leave it as it is?

Hi there, I'm in the middle of learning to use coroutines and I'm having difficulties grasping why my test is passing. The test passes while the console prints out the exception stack trace. If I use

async

(and

.await

in my test) it fails as expected but I want to use

launch

(actual function is in my Android ViewModel) and I am kinda lost. A workaround is to check whether the job

isCancelled

, which works but is a bit clunky (I guess it's possible to create some test rule..). I've read the docs but haven't come up with anything. Maybe I'm going about this the wrong way and there's a better approach? Any pointer or direction is very much appreciated.

// in ViewModel
val job = Job()
val viewModelScope = CoroutineScope(Dispatchers.Main + job)

fun someFunction() = viewModelScope.launch {
  throw IllegalStateException("reasons")
}

...

@Test
fun `should fail`() = runBlocking {
  // prints error but the test passes
  someFunction().join()
}

@Test
fun `successfully failing workaround`() = runBlocking {
  // this feels wrong
  val job = someFunction()
  someFunction.join()
  assertFalse(job.isCancelled)
}

Is it possible to use channels to wait for a signal to do work? Something like:

suspend fun waitForUpdates(): ReceiveChannel<Update> = produce {
  onUpdateHook { update ->
    send(update)
  }
}

fun startWaitingForUpdates() {
  launch {
    waitForUpdates().onReceive { update ->
      doUpdate(update)
    }
  }
}

How could I check if a singlethreaded coroutine context is currently executing or not?

When I use withContext(...){}, how go I get the Job?