ComposeUiTest

suspend fun awaitIdle(): Unit

Suspends until the UI is idle. Quiescence is reached when there are no more pending changes (e.g. pending recompositions or a pending draw call) and all IdlingResources are idle.

If auto advancement is enabled on the mainClock, this method will advance the clock to process any pending composition, invalidation and animation. If auto advancement is not enabled, the clock will not be advanced which means that the Compose UI appears to be frozen. This is ideal for testing animations in a deterministic way. This method will always wait for all IdlingResources to become idle.

Note that some processes are driven by the host operating system and will therefore still execute when auto advancement is disabled. For example, Android's measure, layout and draw passes can still happen if required by the View system.

@RequiresApi(value = 34)
fun disableAccessibilityChecks(): Unit

Disables accessibility checks.

import androidx.compose.ui.test.ExperimentalTestApi
import androidx.compose.ui.test.onNodeWithTag
import androidx.compose.ui.test.onNodeWithText
import androidx.compose.ui.test.onRoot
import androidx.compose.ui.test.performClick
import androidx.compose.ui.test.performScrollToIndex
import androidx.compose.ui.test.runComposeUiTest
import androidx.compose.ui.test.tryPerformAccessibilityChecks

@Test
@OptIn(ExperimentalTestApi::class)
fun testWithAccessibilityChecks() = runComposeUiTest {
    // Enable accessibility checks with default configuration:
    enableAccessibilityChecks()

    // When enabled, accessibility checks run automatically when performing an action:
    onNodeWithText("Submit").performClick()

    // You can also manually run accessibility checks:
    onRoot().tryPerformAccessibilityChecks()

    // When disabling accessibility checks..
    disableAccessibilityChecks()

    // .. they no longer run when performing an action:
    onNodeWithTag("list").performScrollToIndex(15)
}

@RequiresApi(value = 34)
fun enableAccessibilityChecks(): Unit

Enables accessibility checks that will be run before every action that is expected to change the UI.

Accessibility checks are platform dependent, refer to the documentation of the platform specific variant of ComposeUiTest to see if it is supported and how you can configure it.

On Android, this requires API 34+ (Android U), and currently does not work on Robolectric.

import androidx.compose.ui.test.ExperimentalTestApi
import androidx.compose.ui.test.onNodeWithTag
import androidx.compose.ui.test.onNodeWithText
import androidx.compose.ui.test.onRoot
import androidx.compose.ui.test.performClick
import androidx.compose.ui.test.performScrollToIndex
import androidx.compose.ui.test.runComposeUiTest
import androidx.compose.ui.test.tryPerformAccessibilityChecks

@Test
@OptIn(ExperimentalTestApi::class)
fun testWithAccessibilityChecks() = runComposeUiTest {
    // Enable accessibility checks with default configuration:
    enableAccessibilityChecks()

    // When enabled, accessibility checks run automatically when performing an action:
    onNodeWithText("Submit").performClick()

    // You can also manually run accessibility checks:
    onRoot().tryPerformAccessibilityChecks()

    // When disabling accessibility checks..
    disableAccessibilityChecks()

    // .. they no longer run when performing an action:
    onNodeWithTag("list").performScrollToIndex(15)
}

fun registerIdlingResource(idlingResource: IdlingResource): Unit

Registers an IdlingResource in this test.

fun <T : Any?> runOnIdle(action: () -> T): T

Executes the given action in the same way as runOnUiThread but waits until the app is idle before executing the action. This is the recommended way of doing your assertions on shared variables.

This method blocks until the action is complete.

fun <T : Any?> runOnUiThread(action: () -> T): T

Runs the given action on the UI thread.

This method blocks until the action is complete.

fun setContent(composable: @Composable () -> Unit): Unit

Sets the given composable as the content to be tested. This should be called exactly once per test.

fun unregisterIdlingResource(idlingResource: IdlingResource): Unit

Unregisters an IdlingResource from this test.

fun waitForIdle(): Unit

Waits for the UI to become idle. Quiescence is reached when there are no more pending changes (e.g. pending recompositions or a pending draw call) and all IdlingResources are idle.

If auto advancement is enabled on the mainClock, this method will advance the clock to process any pending composition, invalidation and animation. If auto advancement is not enabled, the clock will not be advanced which means that the Compose UI appears to be frozen. This is ideal for testing animations in a deterministic way. This method will always wait for all IdlingResources to become idle.

Note that some processes are driven by the host operating system and will therefore still execute when auto advancement is disabled. For example, Android's measure, layout and draw passes can still happen if required by the View system.

fun waitUntil(
    conditionDescription: String? = null,
    timeoutMillis: Long,
    condition: () -> Boolean
): Unit

Blocks until the given condition is satisfied.

If auto advancement is enabled on the mainClock, this method will actively advance the clock to process any pending composition, invalidation and animation. If auto advancement is not enabled, the clock will not be advanced actively which means that the Compose UI appears to be frozen. It is still valid to use this method in this way, if the condition will be satisfied by something not driven by our clock.

Compared to MainTestClock.advanceTimeUntil, waitUntil sleeps after every iteration to yield to other processes. This gives waitUntil a better integration with the host, but it is less preferred from a performance viewpoint. Therefore, we recommend that you try using MainTestClock.advanceTimeUntil before resorting to waitUntil.

var accessibilityValidator: AccessibilityValidator?

The AccessibilityValidator that will be used to run Android accessibility checks before every action that is expected to change the UI.

If no validator is set (null), no checks will be performed. You can either supply your own validator directly, or have one configured for you with enableAccessibilityChecks.

The default value is null.

This requires API 34+ (Android U), and currently does not work on Robolectric.

import androidx.activity.ComponentActivity
import androidx.compose.ui.test.ExperimentalTestApi
import androidx.compose.ui.test.runAndroidComposeUiTest

@Test
@OptIn(ExperimentalTestApi::class)
fun testWithAccessibilityChecks() =
    runAndroidComposeUiTest<ComponentActivity> {
        // Enable accessibility checks with your own AccessibilityValidator:
        accessibilityValidator = AccessibilityValidator()
        // By setting a non-null AccessibilityValidator, accessibility checks are enabled

        // Configure the AccessibilityValidator:
        @OptIn(ExperimentalTestApi::class)
        accessibilityValidator!!.setThrowExceptionFor(AccessibilityCheckResultType.ERROR)
    }

val density: Density

Current device screen's density. Note that it is technically possible for a Compose hierarchy to define a different density for a certain subtree. Try to use LayoutInfo.density where possible, which can be obtained from SemanticsNode.layoutInfo.

val mainClock: MainTestClock

Clock that drives frames and recompositions in compose tests.

@ExperimentalTestApi
fun ComposeUiTest.waitUntilAtLeastOneExists(
    matcher: SemanticsMatcher,
    timeoutMillis: Long
): Unit

Blocks until at least one node matches the given matcher.

@ExperimentalTestApi
fun ComposeUiTest.waitUntilDoesNotExist(
    matcher: SemanticsMatcher,
    timeoutMillis: Long
): Unit

Blocks until no nodes match the given matcher.

@ExperimentalTestApi
fun ComposeUiTest.waitUntilExactlyOneExists(
    matcher: SemanticsMatcher,
    timeoutMillis: Long
): Unit

Blocks until exactly one node matches the given matcher.

@ExperimentalTestApi
fun ComposeUiTest.waitUntilNodeCount(
    matcher: SemanticsMatcher,
    count: Int,
    timeoutMillis: Long
): Unit

Blocks until the number of nodes matching the given matcher is equal to the given count.