Compose UI testing in Android Kotlin - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ ui_behavior

intermediate

What is the output of this Compose UI test code?

Given the Compose UI test code below, what will the test verify successfully?

Android Kotlin

composeTestRule.setContent {
  Button(onClick = {}) {
    Text("Click Me")
  }
}
composeTestRule.onNodeWithText("Click Me").assertIsDisplayed()

A The test fails because the text 'Click Me' is not found in the UI.

B The test fails because the button has no click action defined.

C The test passes because the button with text 'Click Me' is displayed.

D The test passes but does not check if the button is clickable.

💡 Hint

Look for the text inside the Button and what the test is asserting.

The test sets a Button with text 'Click Me' and asserts that a node with this text is displayed. Since the text exists, the test passes.

❓ lifecycle

intermediate

What happens if you call composeTestRule.setContent twice in a test?

In a Compose UI test, what is the effect of calling setContent twice with different Composables?

A The second setContent replaces the first UI content completely.

B Both Composables are shown simultaneously on the screen.

C The test will crash due to multiple setContent calls.

D The first Composable remains visible and the second is ignored.

💡 Hint

Think about how Compose manages UI content in tests.

Calling setContent again replaces the previous UI content with the new Composable, so only the second UI is visible.

🔧 Debug

advanced

Why does this Compose test fail with NoMatchingNodeException?

This test fails with NoMatchingNodeException: composeTestRule.setContent { Text("Hello World") } composeTestRule.onNodeWithText("Hello").assertIsDisplayed()

A The test fails because assertIsDisplayed is not a valid assertion.

B The test fails because the Text composable is not clickable.

C The test fails because setContent was not called on the main thread.

D The text 'Hello' does not exactly match 'Hello World', so no node is found.

💡 Hint

Check the exact text string used in the test and in the UI.

The test looks for a node with exact text 'Hello', but the UI shows 'Hello World'. This mismatch causes NoMatchingNodeException.

❓ navigation

advanced

How to test navigation between two Compose screens?

You have two Composables: ScreenA and ScreenB. ScreenA has a button that navigates to ScreenB. Which test code correctly verifies navigation?

Android Kotlin

composeTestRule.setContent {
  NavHost(navController, startDestination = "screenA") {
    composable("screenA") { ScreenA(navController) }
    composable("screenB") { ScreenB() }
  }
}
composeTestRule.onNodeWithText("Go to B").performClick()
// What assertion verifies navigation?

A composeTestRule.onNodeWithText("Screen B Content").assertIsDisplayed()

B composeTestRule.onNodeWithText("Go to B").assertIsDisplayed()

C composeTestRule.onNodeWithTag("screenA").assertIsDisplayed()

D composeTestRule.onNodeWithText("Screen A Content").assertIsDisplayed()

💡 Hint

After clicking the button, the UI should show ScreenB content.

After performing click on the navigation button, the test should verify that ScreenB's content is displayed to confirm navigation.

🧠 Conceptual

expert

What is the role of Semantics in Compose UI testing?

Why is setting semantics properties important for Compose UI testing?

A They improve the app's performance by reducing recompositions.

B They provide metadata that test code uses to find and interact with UI elements.

C They automatically generate UI screenshots for tests.

D They prevent UI elements from being displayed on the screen.

💡 Hint

Think about how tests identify UI elements beyond visible text.

Semantics add descriptive information to UI elements, enabling tests to locate and interact with them reliably, especially when text is not unique or present.

Practice

1. What is the main purpose of createComposeRule() in Compose UI testing?

easy

A. To create UI elements dynamically during runtime

B. To set up the environment for testing Compose UI components

C. To launch the app on a physical device

D. To generate random test data for UI tests

Solution

1. Step 1: Understand the role of createComposeRule()

   This function sets up the Compose testing environment so you can test UI components safely and isolated.

2. Step 2: Differentiate from other options

   It does not create UI elements dynamically, launch apps, or generate test data; it only prepares the test rule.

3. Final Answer:

   To set up the environment for testing Compose UI components -> Option B

4. Quick Check:

   Compose test setup = B [OK]

Hint: Remember: createComposeRule sets up Compose test environment [OK]

Common Mistakes:

• Thinking it creates UI elements during app runtime
• Confusing it with launching the app on devices
• Assuming it generates test data automatically

2. Which of the following is the correct way to find a UI element by its text in Compose UI testing?

easy

A. composeTestRule.getElementByText("Hello")

B. composeTestRule.findViewByText("Hello")

C. composeTestRule.selectNode("Hello")

D. composeTestRule.onNodeWithText("Hello")

Solution

1. Step 1: Recall Compose testing API for text search

   The correct method to find a node by text is onNodeWithText().

2. Step 2: Verify other options are invalid

   Methods like findViewByText, getElementByText, and selectNode do not exist in Compose testing.

3. Final Answer:

   composeTestRule.onNodeWithText("Hello") -> Option D

4. Quick Check:

   Find by text = onNodeWithText [OK]

Hint: Use onNodeWithText to find text elements in Compose tests [OK]

Common Mistakes:

• Using Android View testing methods instead of Compose methods
• Trying to use non-existent functions
• Confusing node selectors with view selectors

3. Given this Compose test code snippet:

composeTestRule.setContent {
  Text("Welcome")
}

composeTestRule.onNodeWithText("Welcome").assertExists()

What will happen when this test runs?

medium

A. The test will pass because the text "Welcome" exists

B. The test will fail because the text is not found

C. The test will throw a syntax error

D. The test will pass but not check the text

Solution

1. Step 1: Analyze the UI content set

   The UI contains a Text composable with the string "Welcome".

2. Step 2: Understand the assertion

   assertExists() checks that the node with text "Welcome" is present, which it is.

3. Final Answer:

   The test will pass because the text "Welcome" exists -> Option A

4. Quick Check:

   Text present means assertExists passes [OK]

Hint: assertExists passes if UI text is present exactly [OK]

Common Mistakes:

• Assuming assertExists checks content correctness beyond presence
• Thinking the test fails if no interaction is done
• Confusing syntax errors with runtime test failures

4. Identify the error in this Compose UI test code:

composeTestRule.setContent {
  Button(onClick = {}) {
    Text("Click Me")
  }
}

composeTestRule.onNodeWithTag("button").performClick()

medium

A. performClick() is not a valid Compose test function

B. The Button composable cannot be clicked in tests

C. The node is searched by tag but no tag was set on the Button

D. The Text inside Button should be searched instead of Button

Solution

1. Step 1: Check how the node is found

   The test looks for a node with tag "button" but the Button has no tag set.

2. Step 2: Understand Compose testing tags

   To find by tag, the Button must have Modifier.testTag("button") applied, which is missing.

3. Final Answer:

   The node is searched by tag but no tag was set on the Button -> Option C

4. Quick Check:

   Missing testTag causes node not found [OK]

Hint: Always add testTag modifier to find nodes by tag [OK]

Common Mistakes:

• Assuming performClick works without correct node selection
• Searching text inside Button instead of Button itself
• Thinking performClick is invalid in Compose tests

5. You want to test a Compose screen with a list of items. Each item has a unique test tag like "item_1", "item_2", etc. Which approach correctly verifies that the item with tag "item_3" is displayed and clickable?

hard

A. composeTestRule.onNodeWithTag("item_3").assertIsDisplayed().performClick()

B. composeTestRule.onNodeWithText("item_3").assertIsDisplayed().performClick()

C. composeTestRule.onNodeWithTag("item_3").assertExists().performClick()

D. composeTestRule.onNodeWithContentDescription("item_3").assertIsDisplayed().performClick()

Solution

1. Step 1: Identify correct node selector for test tag

   Use onNodeWithTag("item_3") to find the node by its unique test tag.

2. Step 2: Verify visibility and interaction

   assertIsDisplayed() confirms the node is visible, and performClick() simulates a click.

3. Step 3: Eliminate incorrect options

   Searching by text or content description is wrong here; assertExists() alone doesn't check visibility.

4. Final Answer:

   composeTestRule.onNodeWithTag("item_3").assertIsDisplayed().performClick() -> Option A

5. Quick Check:

   Tag + visible + click = composeTestRule.onNodeWithTag("item_3").assertIsDisplayed().performClick() [OK]

Hint: Use onNodeWithTag + assertIsDisplayed before performClick [OK]

Common Mistakes:

• Using onNodeWithText instead of onNodeWithTag for tags
• Skipping assertIsDisplayed before clicking
• Confusing content description with test tag