IssueTracker

You can provide your own regex to By.text().
For example, By.text(Pattern.compile("All albums.*", Pattern.DOTALL)) should be equivalent to a multi-line startsWith.

I'm probably dumb but why would it be the default and wanted behavior if not documented properly?

Every known startWith / contains function in Java/Kotlin are multiline, the javadoc says: A UI element will be considered a match if its text value starts with the substring parameter

Many people will fall into this non standard default behavior and loose tons of time trying to figure out why.

If you still consider this default is the correct one, then please document it.

Will be fixed in version 2.3.0-alpha02.

To clarify comment#2: this has been the behavior for many years and we try to avoid changing long-standing behavior like this.
However, looking at this again, it was inconsistent between UiSelector and BySelector, and users are unlikely to be relying on single line matching.

Thanks a lot for the change.

I understand legacy and everything, it was just the close without discussion about proper solution (including doc that would have worked too) that was strange.

Seeing the $ in the regexp took me time, and it's good to avoid this to other users when improvement is possible.

The following release(s) address this bug.It is possible this bug has only been partially addressed:

• androidx.test.uiautomator:uiautomator:2.3.0-alpha02

I tried cutting down the example myself and was not able to reproduce this.

The primary dependency chagnes I made were:

compose-material3 = { module = "androidx.compose.material3:material3", version = "1.3.0-SNAPSHOT" }
compose-foundation = { module = "androidx.compose.foundation:foundation-android", version = "1.7.0-SNAPSHOT" }

I only included the part of the Dialog.kt that was needed by the above,

class DialogState {
    var content: (@Composable () -> Unit)? by mutableStateOf(null)

    @Composable
    fun Intercept() = content?.invoke()

    fun dismiss() {
        content = null
    }

    suspend inline fun <R> dialog(crossinline block: @Composable (CancellableContinuation<R>) -> Unit) = suspendCancellableCoroutine<R> { cont ->
        cont.invokeOnCancellation { dismiss() }
        val realContinuation = object : CancellableContinuation<R> by cont {
            override fun resumeWith(result: Result<R>) {
                dismiss()
                cont.resumeWith(result)
            }
        }
        content = { block(realContinuation) }
    }

    suspend inline fun showSelectActions(
        title: String? = null,
        builder: ActionScope.() -> Unit,
    ) {
        val (items, actions) = buildList { builder(ActionScope { action, that -> add(action to that) }) }.unzip()
        val selected = showSelectItem(items, title)
        actions[selected].invoke()
    }

    suspend fun showSelectItem(
        items: List<String>,
        title: String?,
        respectDefaultWidth: Boolean = true,
    ): Int = showNoButton(respectDefaultWidth) {
        Column(modifier = Modifier.padding(vertical = 8.dp)) {
            if (title != null) {
                Text(
                    text = title,
                    modifier = Modifier.padding(horizontal = 24.dp, vertical = 8.dp),
                    style = MaterialTheme.typography.headlineSmall,
                )
            }
            LazyColumn {
                itemsIndexed(items) { index, text ->
                    CompositionLocalProvider(LocalContentColor provides MaterialTheme.colorScheme.tertiary) {
                        Text(
                            text = text,
                            modifier = Modifier.clickable { dismissWith(index) }.fillMaxWidth()
                                .padding(horizontal = 24.dp, vertical = 16.dp),
                            style = MaterialTheme.typography.titleMedium,
                        )
                    }
                }
            }
        }
    }

    @OptIn(ExperimentalMaterial3Api::class)
    suspend fun <R> showNoButton(respectDefaultWidth: Boolean = true, block: @Composable DismissDialogScope<R>.() -> Unit): R {
        return dialog { cont ->
            val impl = remember(cont) {
                DismissDialogScope<R> {
                    cont.resume(it)
                }
            }
            BasicAlertDialog(
                onDismissRequest = { cont.cancel() },
                properties = DialogProperties(usePlatformDefaultWidth = respectDefaultWidth),
                content = {
                    Surface(
                        modifier = with(Modifier) { if (!respectDefaultWidth) defaultMinSize(280.dp) else width(280.dp) },
                        shape = AlertDialogDefaults.shape,
                        color = AlertDialogDefaults.containerColor,
                        tonalElevation = AlertDialogDefaults.TonalElevation,
                        content = { block(impl) },
                    )
                },
            )
        }
    }
}

fun interface ActionScope {
    fun onSelect(action: String, that: suspend () -> Unit)
}

fun interface DismissDialogScope<R> {
    fun dismissWith(value: R)
}

This shows the "Please wait" and then selection between "a" and "b" as I expected.

This requires compose compiler 1.5.11-dev-k2.0.0-Beta4-21f5e479a96
I will upload a sample project soon

https://github.com/VDostoyevskiy/Sample
Downgrade snapshot to build-11461852 or downgrade compiler to stable will fix it
StackTrace below: https://bin.kv2.dev/~65d6da925de7ed6bfdbdfe3e

Any update on this?
Have you reproduced this with https://github.com/VDostoyevskiy/Sample ?

Sorry! I didn't see you updated this. I must have missed the notification. Trying now.

I have the exception reproducing locally, investigating.

The issue is in the call to dialog when it inlines the crossinline lambda. This lambda instances are getting the same key at both call sights and, when the second dialog shows, it believes it is recomposing the first and then throws as it didn't create the state in this slot table.

The simple work-around now is to change dialog's parameter to noinline instead of crossinline. This ensures that the keys produced for the lambdas are different.

I am investigating what change caused this.

The code generation for crossinline lambda seems to have always been wrong but the extra groups the compiler create that the change removes prevented crashes in most cases. By removing otherwise unnecessary groups, the missing group around a crossinline lambda now causes a crash.

The work-around above, changing the lambda to noinline, is valid because it avoids crossinline and, therefore, avoids the crash.

The key symptom is that currentComposer.inserting is never true for the crossinline lambda passed into the second dialog which indicates it is recomposing over state it didn't produce.

A group is required because a crossinline lambda can be inlined into a lambda instance. The instance created gets the same key but its content has effectively changed as the crossinline lambda acts as a branch point. The runtime assumes that when a different branch of code is executed, it executes in a block with a different key than the previous branch taken. As there is no branch group, the code is recomposed over state it didn't create, which is never valid. Recomposing over state it didn't create will not always create an exception and this was the case for the code generated prior to enabling the optimization to remove otherwise unnecessary groups.

The following release(s) address this bug.It is possible this bug has only been partially addressed:

• androidx.compose.compiler:compiler-hosted:1.5.11