ViewModel testing in Android Kotlin - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ ui_behavior

intermediate

What is the output when LiveData is observed in a ViewModel test?

Given a ViewModel with a LiveData that emits a value, what will the observer receive after the value is set?

Android Kotlin

class MyViewModel : ViewModel() {
  private val _data = MutableLiveData<String>()
  val data: LiveData<String> = _data

  fun updateData(value: String) {
    _data.value = value
  }
}

// In test:
val viewModel = MyViewModel()
var observedValue: String? = null
viewModel.data.observeForever { observedValue = it }
viewModel.updateData("Hello")

A observedValue will be "Hello"

B observedValue will be "" (empty string)

C observedValue will be null

D The test will throw an exception

💡 Hint

LiveData notifies observers immediately when value changes.

When updateData sets _data.value to "Hello", the observer receives this new value immediately, so observedValue becomes "Hello".

❓ lifecycle

intermediate

What happens if you observe LiveData without a LifecycleOwner in a ViewModel test?

In a ViewModel test, what is the effect of calling observeForever on LiveData instead of observe with a LifecycleOwner?

Android Kotlin

val liveData = MutableLiveData<Int>()
liveData.observeForever { println(it) }
liveData.value = 5

A The observer receives the value 5 immediately

B The observer never receives any value

C The code throws a NullPointerException

D The observer receives the value only when lifecycle is started

💡 Hint

observeForever does not depend on lifecycle state.

observeForever registers a permanent observer that receives updates immediately regardless of lifecycle state.

🔧 Debug

advanced

Why does this ViewModel test fail to observe LiveData updates?

Consider this test code snippet. Why does observedValue remain null after updateData is called?

Android Kotlin

class MyViewModel : ViewModel() {
  private val _data = MutableLiveData<String>()
  val data: LiveData<String> = _data

  fun updateData(value: String) {
    _data.value = value
  }
}

// Test code:
val viewModel = MyViewModel()
var observedValue: String? = null
viewModel.data.observe { observedValue = it }
viewModel.updateData("Test")

A observedValue is overwritten immediately after assignment

B MutableLiveData value is not set correctly

C updateData is not called on the main thread

D observe requires a LifecycleOwner, which is missing, so observer is not registered

💡 Hint

observe needs a lifecycle to work properly in tests.

The observe method requires a LifecycleOwner to register the observer. Without it, the observer is not active and does not receive updates.

🧠 Conceptual

advanced

What is the main benefit of using a TestCoroutineDispatcher in ViewModel testing?

Why do we use TestCoroutineDispatcher or similar in ViewModel tests that use coroutines?

A It automatically fixes all coroutine bugs in the ViewModel

B It allows controlling coroutine execution and timing for predictable tests

C It disables coroutine execution to speed up tests

D It replaces LiveData with a synchronous data source

💡 Hint

Think about how to make asynchronous code run predictably in tests.

TestCoroutineDispatcher lets tests control when coroutines run and complete, making tests reliable and deterministic.

📝 Syntax

expert

What error does this ViewModel test code produce?

Analyze the following test code snippet. What error will it raise when run?

Android Kotlin

class MyViewModel : ViewModel() {
  private val _count = MutableLiveData<Int>()
  val count: LiveData<Int> = _count

  fun increment() {
    _count.value = (_count.value ?: 0) + 1
  }
}

// Test code:
val viewModel = MyViewModel()
var observedCount: Int? = null
viewModel.count.observeForever { observedCount = it }
viewModel.increment()
viewModel.increment()

A IllegalStateException due to observing LiveData twice

B NullPointerException because _count.value is null initially

C No error, observedCount will be 2

D Compilation error due to missing import

💡 Hint

Check how the Elvis operator ?: handles null values.

The code uses (_count.value ?: 0) + 1, so if _count.value is null, it uses 0. No NullPointerException occurs. After two increments, observedCount is 2.