Parent job is Cancelling

shareIn

WhileSubscribed

repeatOnLifecycle

class MyViewModel(
    dataSource: MyDataSource,
    sharingStarted: SharingStarted = WhileSubscribed(5000)
) : ViewModel() {

    var userInput = MutableStateFlow(1)

    val state = dataSource.dataFlow()
        .combine(userInput) { data, userInput ->
            OutputClass(data, userInput)
        }
        .shareIn(viewModelScope, sharingStarted, 1)

}

@Test
fun testMyViewModel() = runBlockingTest {

    val cut = MyViewModel(
        mockk { coEvery { dataFlow() } returns flowOf(Data()) },
        sharingStarted = SharingStarted.Eagerly
    )

    cut.state.test {

        // Also an emit to the userInput here does not help
        // cut.userInput.emit(2)
        
        assertEquals(OutputClass(...), awaitItem())
    }


}

suspend fun userList(): List<User>
fun userList(): Flow<List<User>>

userListSync

suspend

> Task :semver-core:linkDebugTestLinuxX64 FAILED
e: Compilation failed: Cannot get target from triple x86_64-unknown-linux-gnu.

private val searchString = MutableStateFlow("")
val rooms = searchString.flatMapLatest {
        if (it.isBlank()) {
            fetchPrivateRooms()
        } else {
            fetchPrivateRooms().combineTransform(fetchPublicRooms()) { priv, pub ->
                emit(filterRooms(priv, pub, it))
            }
        }
    }.stateIn(viewModelScope, SharingStarted.Eagerly, emptyList())

fetchPrivateRooms

LiveData<List<Rooms>>

flow

catch

retry

.collect {}

val flowA: MutableSharedFlow<Int>

flowB.collectTo(flowA)

shareIn

fun foo() {
    viewModelScope.launch {
        val inputList = listOf("a", "b", "c")
        val deferredList = mutableListOf<Deferred<String>>()
        repeat(3) { index ->
            deferredList += async {
                delay((1L..10000L).random())
                inputList[index]
            }
        }
        val outputList = deferredList.map { it.await() } // a, b, c
    }
}

runBlockingTest

TICK_DELAY

while (true) {
                    delay(TICK_DELAY)
                    val totalElapsedTime = systemClockProvider.getElapsedRealTime() - startTime
                    tasksDataSource.increaseMillisCompletedToday(
                        selectedTask.id,
                        totalElapsedTime - lastReportedTime
                    )
                    lastReportedTime = totalElapsedTime
                }

suspend fun func() {
  var counter = 0
  someComplexFlow() // <-- potentially calls various withContext() inside its operators
    .collect { counter++ }
}

suspend

fun main() {
    val f = suspend { i: Long ->
        delay(i)
    }

    runBlocking {
        f(1000L)
    }
}

StateFlow

Flow

runBlocking

suspend fun

init

StateFlow

1.6.0-RC

1.6.0-RC2

collect

val stateFlow = MutableStateFlow(State())
        val actionFlow = MutableSharedFlow<Action>()
        launch {
            actionFlow.collect {
                stateFlow.value = stateReducer(stateFlow.value, it)
            }
        }

viewModelScope.launch {
 val thing: String = someSuspendFunctionThatReturnsAValue()
 aMethodCallThatIsAFlow(thing).collect {
   if (it.status == "SUCCESS"){
    state.success = true
    //should I call job.stop() here?
   }
 }
}

internal class MyPresenter @Inject constructor(...) {
 private val _uiState = MutableStateFlow<Foo>(Foo.Loading)
 override val uiState: StateFlow<Foo> = _uiState
 private val _sideEffect = MutableSharedFlow<Foo2>()
 override val sideEffect : SharedFlow<Foo2> = _sideEffect
}

init {
  scope.launch {
    usecase.getBar().fold(
     onSuccess = { _uiState.emit(mapper(whatever)) 
      if(...) _sideEffect.emit(whatever)
     }
     onFailure = { _uiState.emit(handleError(it)) }
  }
}

kotlinx.coroutines.TimeoutCancellationException: Timed out waiting for 1000 ms

(Coroutine boundary)

@Test
fun test() {
  //given with the usecase call and willReturn what I want
  //given with the mapper call and willReturn what I want
  //Init presenter so the init {} method gets fired 
  presenter.uiState.test { 
   assertEquals(WhatIExpect, awaitItem())
   awaitComplete()
}

stateFlow

data class Person(var name: String)

class SomeViewModel : ViewModel() {
    // made public for brevity
    val state = MutableStateFlow( listOf(Person("John")) )

    init {
        // will this change be emitted?
        state.value[0].name = "Bob"
    }

}

init

liveData

stateFlow