Nick
06/27/2026, 8:07 PMNick
06/28/2026, 2:47 PMimport android.os.CancellationSignal
import android.os.OperationCanceledException
@RunWith(RobolectricTestRunner::class)
class CancellationSignalTest {
private fun legacyApi(signal: CancellationSignal) {
// in prod, this is Android platform API I can't change
runBlocking {
while (true) {
signal.throwIfCanceled()
delay(10.milliseconds)
// of course the API actually returns something, but I'm working on cancellation so this is omitted here
}
}
}
private suspend inline fun T runWithCancellationSignal(block: (CancellationSignal) -> T): T {
val signal = CancellationSignal()
val job = currentCoroutineContext().job
val listener = job.invokeOnCompletion { e ->
if (e is CancellationException) signal.cancel()
}
try {
return block(signal)
} catch (e: OperationCanceledException) {
throw CancellationException(null, e)
} finally {
listener.dispose()
}
}
//@Test
fun test1DoesNotDeadlock() {
runBlocking {
withTimeout(1000.milliseconds) {
val job = launch {
runWithCancellationSignal(::legacyApi)
}
delay(50.milliseconds)
job.cancelAndJoin()
}
}
}
private suspend inline fun T runWithCancellationSignal2(
crossinline block: (CancellationSignal) -> T,
noinline onCancellation: ((cause: Throwable, value: T, context: CoroutineContext) -> Unit)?
): T {
return suspendCancellableCoroutine { continuation ->
val signal = CancellationSignal()
continuation.invokeOnCancellation { signal.cancel() }
try {
continuation.resume(block(signal), onCancellation)
} catch (e: OperationCanceledException) {
continuation.resumeWithException(CancellationException(null, e))
} catch (t: Throwable) {
continuation.resumeWithException(t)
}
}
}
@Test
fun test2DoesNotDeadlock() {
runBlocking {
withTimeout(1000.milliseconds) {
val job = launch {
runWithCancellationSignal2(::legacyApi, null)
}
delay(50.milliseconds)
job.cancelAndJoin()
}
}
}
@OptIn(InternalCoroutinesApi::class)
private suspend inline fun T runWithCancellationSignal3(block: (CancellationSignal) -> T): T {
val signal = CancellationSignal()
val job = currentCoroutineContext().job
val listener = job.invokeOnCompletion(onCancelling = true) { e ->
if (e is CancellationException) signal.cancel()
}
try {
return block(signal)
} catch (e: OperationCanceledException) {
throw CancellationException(null, e)
} finally {
listener.dispose()
}
}
@Test
fun test3DoesNotDeadlock() {
runBlocking {
withTimeout(1000.milliseconds) {
val job = launch {
runWithCancellationSignal3(::legacyApi)
}
delay(50.milliseconds)
job.cancelAndJoin()
}
}
}
}Wout Werkman
06/30/2026, 5:17 PMcurrentCoroutineContext().job, which is risky, since you're working on the job you get from "above", which is also why the first example deadlocks. The Job that calls your function waits for your to finish, and thus, it never completes.
(Also, invokeOnCompletion has some footguns that can introduce very subtle cancellation race conditions if not used correctly)Vsevolod Artiushkin
07/01/2026, 9:23 AMNick
07/03/2026, 9:03 PM