xref: /compose/runtime/runtime/src/nonEmulatorCommonTest/kotlin/androidx/compose/runtime/MovableContentTests.kt

/*
 * Copyright 2020 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package androidx.compose.runtime

import androidx.compose.runtime.mock.InlineLinear
import androidx.compose.runtime.mock.Linear
import androidx.compose.runtime.mock.MockViewValidator
import androidx.compose.runtime.mock.View
import androidx.compose.runtime.mock.ViewApplier
import androidx.compose.runtime.mock.compositionTest
import androidx.compose.runtime.mock.expectChanges
import androidx.compose.runtime.mock.revalidate
import androidx.compose.runtime.mock.validate
import androidx.compose.runtime.mock.view
import androidx.compose.runtime.snapshots.Snapshot
import kotlin.random.Random
import kotlin.test.Test
import kotlin.test.assertEquals
import kotlin.test.assertFalse
import kotlin.test.assertNotEquals
import kotlin.test.assertSame
import kotlin.test.assertTrue

@Stable
class MovableContentTests {

    @Test
    fun testMovableContentSharesState() = compositionTest {
        var lastPrivateState: State<Int> = mutableStateOf(0)
        var portrait by mutableStateOf(false)

        val content = movableContentOf {
            val privateState = remember { mutableStateOf(0) }
            lastPrivateState = privateState
            Text("Some text")
            Text("Some other text")
        }

        @Composable
        fun Test() {
            if (portrait) {
                Column { content() }
            } else {
                Row { content() }
            }
        }

        compose { Test() }

        validate {
            fun MockViewValidator.value() {
                Text("Some text")
                Text("Some other text")
            }

            if (portrait) {
                Column { this.value() }
            } else {
                Row { this.value() }
            }
        }

        val firstPrivateState = lastPrivateState
        portrait = true
        Snapshot.sendApplyNotifications()

        expectChanges()
        revalidate()

        assertSame(firstPrivateState, lastPrivateState, "The state should be shared")
    }

    @Test
    fun movableContentPreservesNodes() = compositionTest {
        var portrait by mutableStateOf(false)

        val content = movableContentOf {
            Text("Some text")
            Text("Some other text")
        }

        @Composable
        fun Test() {
            if (portrait) {
                Column { content() }
            } else {
                Row { content() }
            }
        }

        compose { Test() }

        fun MockViewValidator.value() {
            Text("Some text")
            Text("Some other text")
        }

        validate {
            if (portrait) {
                Column { this.value() }
            } else {
                Row { this.value() }
            }
        }

        val firstText = root.findFirst { it.name == "Text" }
        portrait = true

        expectChanges()
        revalidate()

        // Nodes should be shared
        val newFirstText = root.findFirst { it.name == "Text" }
        assertSame(firstText, newFirstText, "Text instance should be identical")
    }

    @Test
    fun movingContent_mainComposer() = compositionTest {
        val rememberedObject = mutableListOf<RememberedObject>()

        @Composable
        fun addRememberedObject() {
            remember { RememberedObject().also { rememberedObject.add(it) } }
        }

        val content = movableContentOf {
            Row {
                addRememberedObject()
                Text("Some text")
                Marker()
            }
        }

        fun MockViewValidator.validateContent() {
            Row {
                Text("Some text")
                Marker()
            }
        }

        var first by mutableStateOf(true)

        compose {
            Row {
                if (first) content()
                Text("Some other text")
            }
            Row {
                Text("Some more text")
                if (!first) content()
            }
        }

        val marker: View = root.findFirst { it.name == "Marker" }

        fun validate() {
            validate {
                Row {
                    if (first) validateContent()
                    Text("Some other text")
                }
                Row {
                    Text("Some more text")
                    if (!first) validateContent()
                }
            }

            assertEquals(
                expected = marker,
                actual = root.findFirst { it.name == "Marker" },
                message = "Expected marker node to move with the movable content"
            )
            assertTrue("Expected all remember observers to be kept alive") {
                rememberedObject.all { it.isLive }
            }
        }

        validate()

        first = false
        expectChanges()
        validate()

        first = true
        expectChanges()
        validate()
    }

    @Test
    fun moveContent_subcompose() = compositionTest {
        val rememberObservers = mutableListOf<RememberedObject>()

        @Composable
        fun addRememberObject() {
            remember { RememberedObject().also { rememberObservers.add(it) } }
        }

        val content = movableContentOf {
            Row {
                addRememberObject()
                Text("Text from value")
                Marker()
            }
        }

        fun MockViewValidator.validateContent() {
            Row {
                Text("Text from value")
                Marker()
            }
        }

        val inMain = 0
        val inSubcompose1 = 1
        val inSubcompose2 = 2

        var position by mutableStateOf(inMain)

        compose {
            Row {
                if (position == inMain) content()
                Subcompose {
                    Row {
                        if (position == inSubcompose1) content()
                        Text("Some other text")
                    }
                }
                Subcompose {
                    Row {
                        Text("Some more text")
                        if (position == inSubcompose2) content()
                    }
                }
            }
        }

        val marker: View = root.findFirst { it.name == "Marker" }

        fun validate() {
            validate {
                Row {
                    if (position == inMain) validateContent()
                    Subcompose {
                        Row {
                            if (position == inSubcompose1) validateContent()
                            Text("Some other text")
                        }
                    }
                    Subcompose {
                        Row {
                            Text("Some more text")
                            if (position == inSubcompose2) validateContent()
                        }
                    }
                }
            }

            assertEquals(
                expected = marker,
                actual = root.findFirst { it.name == "Marker" },
                message = "Expected marker node to move with the movable content"
            )
            assertTrue("Expected all remember observers to be kept alive") {
                rememberObservers.all { it.isLive }
            }
        }

        validate()

        for (newPosition in
            listOf(inSubcompose1, inSubcompose2, inSubcompose1, inMain, inSubcompose2, inMain)) {
            position = newPosition
            expectChanges()
            validate()
        }
    }

    @Test
    fun normalMoveWithContentMove() = compositionTest {
        val random = Random(1337)
        val list = mutableStateListOf(*List(10) { it }.toTypedArray())

        val content = movableContentOf { Marker() }
        var position by mutableStateOf(-1)

        compose {
            Column {
                if (position == -1) content()
                for (item in list) {
                    key(item) {
                        Text("Item $item")
                        if (item == position) content()
                    }
                }
            }
        }

        val marker: View = root.findFirst { it.name == "Marker" }

        fun validate() {
            validate {
                Column {
                    if (position == -1) Marker()
                    for (item in list) {
                        Text("Item $item")
                        if (item == position) Marker()
                    }
                }
            }

            assertEquals(
                expected = marker,
                actual = root.findFirst { it.name == "Marker" },
                message = "Expected marker node to move with the movable content"
            )
        }

        validate()

        repeat(10) {
            position = it
            list.shuffle(random)
            expectChanges()
            validate()
        }

        position = -1
        list.shuffle(random)
        expectChanges()
        validate()
    }

    @Test
    fun removeAndInsertWithMoveAway() = compositionTest {
        var position by mutableStateOf(0)
        var skipItem by mutableStateOf(5)

        val content = movableContentOf { Marker() }
        compose {
            Row {
                if (position == -1) content()
                Column {
                    repeat(10) { item ->
                        key(item) {
                            if (skipItem != item) Text("Item $item")
                            if (position == item) content()
                        }
                    }
                }
            }
        }

        val marker: View = root.findFirst { it.name == "Marker" }

        fun validate() {
            validate {
                Row {
                    if (position == -1) Marker()
                    Column {
                        repeat(10) { item ->
                            if (skipItem != item) Text("Item $item")
                            if (position == item) Marker()
                        }
                    }
                }
            }
            assertEquals(
                expected = marker,
                actual = root.findFirst { it.name == "Marker" },
                message = "Expected marker node to move with the movable content"
            )
        }

        validate()

        repeat(10) { markerPosition ->
            repeat(10) { skip ->
                position = -1
                skipItem = -1
                expectChanges()
                validate()

                // Move the marker and delete an item.
                position = markerPosition
                skipItem = skip
                expectChanges()
                validate()

                // Move the marker away and insert an item
                position = -1
                skipItem = -1
                expectChanges()

                // Move the marker back
                position = markerPosition
                expectChanges()
                validate()

                // Move the marker way and delete an item
                position = -1
                skipItem = skip
                expectChanges()
                validate()
            }
        }
    }

    @Test
    fun invalidationsMoveWithContent() = compositionTest {
        var data by mutableStateOf(0)
        var position by mutableStateOf(-1)
        val content = movableContentOf { Text("data = $data") }

        compose {
            Row {
                if (position == -1) content()
                repeat(10) { item ->
                    key(item) {
                        Text("Item $item")
                        if (position == item) content()
                    }
                }
            }
        }

        validate {
            fun MockViewValidator.content() {
                Text("data = $data")
            }
            Row {
                if (position == -1) this.content()
                repeat(10) { item ->
                    Text("Item $item")
                    if (position == item) this.content()
                }
            }
        }

        repeat(10) { newData ->
            data = newData
            position = newData
            expectChanges()
            revalidate()
        }
    }

    @Test
    fun projectedBinaryTree() = compositionTest {
        class Node(value: Int, left: Node? = null, right: Node? = null) {
            var value by mutableStateOf(value)
            var left by mutableStateOf(left)
            var right by mutableStateOf(right)

            fun validateNode(validator: MockViewValidator) {
                with(validator) { Marker(value) }
                left?.validateNode(validator)
                right?.validateNode(validator)
            }

            fun forEach(block: (node: Node) -> Unit) {
                block(this)
                left?.forEach(block)
                right?.forEach(block)
            }

            fun swap() {
                val oldLeft = left
                val oldRight = right
                left = oldRight
                right = oldLeft
            }

            override fun toString(): String = "$value($left, $right)"
        }

        fun buildTree(level: Int): Node {
            var index = 0
            fun build(level: Int): Node =
                if (level > 1) Node(index++, build(level - 1), build(level - 1)) else Node(index++)
            return build(level)
        }

        val tree = buildTree(6)

        val contents = mutableMapOf<Node?, @Composable () -> Unit>()
        tree.forEach { node ->
            contents[node] = movableContentOf {
                Marker(node.value)
                contents[node.left]?.invoke()
                contents[node.right]?.invoke()
            }
        }

        compose { contents[tree]?.invoke() }

        validate { tree.validateNode(this) }

        tree.forEach { it.swap() }

        expectChanges()

        revalidate()

        tree.forEach { it.swap() }

        expectChanges()

        revalidate()
    }

    @Test
    fun multipleContentsMovingIntoCommonParent() = compositionTest {
        val content1 = movableContentOf {
            Text("1-1")
            Text("1-2")
            Text("1-3")
        }
        val content2 = movableContentOf {
            Text("2-4")
            Text("2-5")
            Text("2-6")
        }
        val content3 = movableContentOf {
            Text("3-7")
            Text("3-8")
            Text("3-9")
        }

        var case by mutableStateOf(0)
        var level by mutableStateOf(0)

        @Composable
        fun sep() {
            Text("-----")
        }

        @Composable
        fun cases() {
            when (case) {
                0 -> {
                    sep()
                    content1()
                    sep()
                    content2()
                    sep()
                    content3()
                    sep()
                }
                1 -> {
                    content2()
                    sep()
                    content3()
                    sep()
                    content1()
                }
                2 -> {
                    sep()
                    content3()
                    content1()
                    content2()
                    sep()
                }
            }
        }

        compose {
            Column {
                if (level == 0) {
                    cases()
                }
                Column {
                    if (level == 1) {
                        cases()
                    }
                }
            }
        }

        validate {
            fun MockViewValidator.sep() {
                Text("-----")
            }

            fun MockViewValidator.value1() {
                Text("1-1")
                Text("1-2")
                Text("1-3")
            }

            fun MockViewValidator.value2() {
                Text("2-4")
                Text("2-5")
                Text("2-6")
            }

            fun MockViewValidator.value3() {
                Text("3-7")
                Text("3-8")
                Text("3-9")
            }

            fun MockViewValidator.cases() {
                when (case) {
                    0 -> {
                        this.sep()
                        this.value1()
                        this.sep()
                        this.value2()
                        this.sep()
                        this.value3()
                        this.sep()
                    }
                    1 -> {
                        this.value2()
                        this.sep()
                        this.value3()
                        this.sep()
                        this.value1()
                    }
                    2 -> {
                        this.sep()
                        this.value3()
                        this.value1()
                        this.value2()
                        this.sep()
                    }
                }
            }

            Column {
                if (level == 0) {
                    this.cases()
                }
                Column {
                    if (level == 1) {
                        this.cases()
                    }
                }
            }
        }

        fun textMap(): Map<String?, View> {
            val result = mutableMapOf<String?, View>()
            fun collect(view: View) {
                if (view.name == "Text") {
                    if (view.text?.contains('-') == false) result[view.text] = view
                }
                for (child in view.children) {
                    collect(child)
                }
            }
            collect(root)
            return result
        }

        val initialMap = textMap()

        fun validateInstances() {
            val currentMap = textMap()
            for (entry in currentMap) {
                if (initialMap[entry.key] !== entry.value) {
                    error("The text value ${entry.key} had a different instance created")
                }
            }
        }

        fun test(l: Int, c: Int) {
            case = c
            level = l
            advance(ignorePendingWork = true)
            revalidate()
            validateInstances()
        }

        test(0, 0)
        test(1, 1)
        test(0, 2)
        test(1, 0)
        test(0, 1)
        test(1, 2)
    }

    @Test
    fun childIndexesAreCorrectlyCalculated() = compositionTest {
        val content = movableContentOf { Marker(0) }

        var vertical by mutableStateOf(false)
        compose {
            if (vertical) {
                Row {
                    Empty()
                    content()
                }
            } else {
                Column {
                    Empty()
                    content()
                }
            }
        }

        validate {
            if (vertical) {
                Row { Marker(0) }
            } else {
                Column { Marker(0) }
            }
        }

        vertical = true
        expectChanges()
        revalidate()
    }

    @Test
    fun validateRecomposeScopesDoNotGetLost() = compositionTest {
        var isHorizontal by mutableStateOf(false)
        val displayValue = mutableStateOf(0)
        val content = movableContentOf { DisplayInt(displayValue) }

        compose { Stack(isHorizontal) { Row { content() } } }

        validate { Stack(isHorizontal) { Row { DisplayInt(displayValue) } } }

        displayValue.value++
        expectChanges()
        revalidate()

        isHorizontal = true
        Snapshot.sendApplyNotifications()
        advanceTimeBy(10)

        displayValue.value++
        expectChanges()
        revalidate()
    }

    @Test
    fun compositionLocalsShouldBeAvailable() = compositionTest {
        var someValue by mutableStateOf(0)
        val local = staticCompositionLocalOf<Int> { error("No value provided for local") }

        compose {
            Wrap(20) {
                CompositionLocalProvider(local provides 10) {
                    // Remember is missing intentionally so it creates a new value to ensure the
                    // new values see the  correct provider scope.
                    val content = movableContentOf {
                        Text("Local = ${local.current}")
                        Text("SomeValue = $someValue")
                    }
                    if (someValue % 2 == 0) content() else content()
                }
            }
        }

        validate {
            Text("Local = 10")
            Text("SomeValue = $someValue")
        }

        someValue++
        advance()

        revalidate()
    }

    @Test
    fun compositionLocalsShouldBeAvailableInNestedContent() = compositionTest {
        var someValue by mutableStateOf(0)
        val local = staticCompositionLocalOf<Int> { error("No value provided for local") }

        val parent = movableContentOf<@Composable () -> Unit> { child -> Wrap { child() } }

        val child = movableContentOf {
            Text("Local = ${local.current}")
            Text("SomeValue = $someValue")
        }

        compose {
            Wrap {
                CompositionLocalProvider(local provides 10) {
                    // Remember is missing intentionally so it creates a new value to ensure the
                    // new values see the  correct provider scope.
                    if (someValue % 2 == 0)
                        parent {
                            Wrap {
                                Text("One")
                                child()
                            }
                        }
                    else
                        parent {
                            child()
                            Text("Two")
                        }
                }
            }
        }

        validate {
            if (someValue % 2 == 0) {
                Text("One")
                Text("Local = 10")
                Text("SomeValue = $someValue")
            } else {
                Text("Local = 10")
                Text("SomeValue = $someValue")
                Text("Two")
            }
        }

        someValue++
        advance()

        revalidate()
    }

    @Test
    fun subcomposeLifetime_no_movable_content() = compositionTest {
        val rememberObject = RememberedObject()
        var useInMain by mutableStateOf(false)
        var useInSub1 by mutableStateOf(false)
        var useInSub2 by mutableStateOf(false)

        @Composable
        fun use() {
            remember { rememberObject }
        }
        compose {
            if (useInMain) use()
            Subcompose { if (useInSub1) use() }
            Subcompose { if (useInSub2) use() }
        }

        fun expectUnused() {
            advance()
            assertFalse(rememberObject.isLive, "RememberObject unexpectedly used")
        }
        fun expectUsed() {
            advance()
            assertTrue(rememberObject.isLive, "Expected RememberObject to be used")
        }

        expectUnused()

        // Add a use in main
        useInMain = true
        expectUsed()

        // Add in sub-composes
        useInSub1 = true
        useInSub2 = true
        expectUsed()

        // Remove it from main
        useInMain = false
        expectUsed()

        // Remove it from sub1
        useInSub1 = false
        expectUsed()

        // Transfer it from sub1 to sub2
        useInSub1 = false
        useInSub2 = true
        expectUsed()

        // Remove it altogether
        useInMain = false
        useInSub1 = false
        useInSub2 = false
        expectUnused()
    }

    @Test
    fun subcomposeLifetime_with_movable_content() = compositionTest {
        val rememberObject = RememberedObject()
        var useInMain by mutableStateOf(false)
        var useInSub1 by mutableStateOf(false)
        var useInSub2 by mutableStateOf(false)

        @Suppress("UNUSED_VARIABLE") // Object not remembered without
        val rememberTheObject = movableContentOf {
            val obj = remember { rememberObject }
        }

        @Composable
        fun use() {
            rememberTheObject()
        }
        compose {
            if (useInMain) use()
            Subcompose { if (useInSub1) use() }
            Subcompose { if (useInSub2) use() }
        }

        fun expectUnused() {
            advance()
            assertFalse(rememberObject.isLive, "RememberObject unexpectedly used")
        }
        fun expectUsed() {
            advance()
            assertTrue(rememberObject.isLive, "Expected RememberObject to be used")
        }

        expectUnused()

        // Add a use in main
        useInMain = true
        expectUsed()

        // Add in sub-composes
        useInSub1 = true
        useInSub2 = true
        expectUsed()

        // Remove it from main
        useInMain = false
        expectUsed()

        // Remove it from sub1
        useInSub1 = false
        expectUsed()

        // Transfer it from sub1 to sub2
        useInSub1 = false
        useInSub2 = true
        expectUsed()

        // Remove it altogether
        useInMain = false
        useInSub1 = false
        useInSub2 = false
        expectUnused()
    }

    @Test // Regression test for 230830644 and 235398298
    fun deferredSubcompose_conditional_rootLevelChildren() = compositionTest {
        var subcompose by mutableStateOf(false)
        var lastPrivateState: State<Int> = mutableStateOf(0)

        val content = movableContentOf {
            lastPrivateState = remember { mutableStateOf(0) }
            Text("Movable content")
        }

        compose {
            Text("Main content start")
            if (!subcompose) {
                content()
            }
            Text("Main content end")
            if (subcompose) {
                DeferredSubcompose {
                    Text("Sub-composed content start")
                    content()
                    Text("Sub-composed content end")
                }
            }
        }

        validate {
            Text("Main content start")
            if (!subcompose) {
                Text("Movable content")
            }
            Text("Main content end")
            if (subcompose) {
                DeferredSubcompose {
                    Text("Sub-composed content start")
                    Text("Movable content")
                    Text("Sub-composed content end")
                }
            }
        }

        val expectedState = lastPrivateState
        subcompose = true
        expectChanges()
        revalidate()

        assertEquals(expectedState, lastPrivateState, "Movable content was unexpectedly recreated")

        subcompose = false
        expectChanges()
        revalidate()

        assertEquals(expectedState, lastPrivateState, "Movable content was unexpectedly recreated")
    }

    @Test // Regression test for 230830644 and 235398298
    fun deferredSubcompose_conditional_nestedChildren() = compositionTest {
        var subcompose by mutableStateOf(false)
        var lastPrivateState: State<Int> = mutableStateOf(0)

        val content = movableContentOf {
            lastPrivateState = remember { mutableStateOf(0) }
            Text("Movable content")
        }

        compose {
            Text("Main content start")
            if (!subcompose) {
                content()
            }
            Text("Main content end")
            if (subcompose) {
                DeferredSubcompose {
                    Column {
                        Text("Sub-composed content start")
                        content()
                        Text("Sub-composed content end")
                    }
                }
            }
        }

        validate {
            Text("Main content start")
            if (!subcompose) {
                Text("Movable content")
            }
            Text("Main content end")
            if (subcompose) {
                DeferredSubcompose {
                    Column {
                        Text("Sub-composed content start")
                        Text("Movable content")
                        Text("Sub-composed content end")
                    }
                }
            }
        }

        val expectedState = lastPrivateState
        subcompose = true
        expectChanges()
        revalidate()

        assertEquals(expectedState, lastPrivateState, "Movable content was unexpectedly recreated")

        subcompose = false
        expectChanges()
        revalidate()

        assertEquals(expectedState, lastPrivateState, "Movable content was unexpectedly recreated")
    }

    @Test // Regression test for 230830644
    fun deferredSubcompose_conditional_and_invalid() = compositionTest {
        var subcompose by mutableStateOf(false)
        var lastPrivateState: State<Int> = mutableStateOf(0)
        var state by mutableStateOf("one")

        val content = movableContentOf {
            lastPrivateState = remember { mutableStateOf(0) }
            Text("Movable content state: $state")
        }

        compose {
            Text("Main content start")
            if (!subcompose) {
                content()
            }
            Text("Main content end")
            if (subcompose) {
                DeferredSubcompose {
                    Text("Sub-composed content start")
                    content()
                    Text("Sub-composed content end")
                }
            }
        }

        validate {
            Text("Main content start")
            if (!subcompose) {
                Text("Movable content state: $state")
            }
            Text("Main content end")
            if (subcompose) {
                DeferredSubcompose {
                    Text("Sub-composed content start")
                    Text("Movable content state: $state")
                    Text("Sub-composed content end")
                }
            }
        }

        val expectedState = lastPrivateState
        subcompose = true
        state = "two"
        expectChanges()
        revalidate()

        assertEquals(expectedState, lastPrivateState)
    }

    @Test
    fun movableContentParameters_One() = compositionTest {
        val data = mutableStateOf(0)
        val content = movableContentOf<Int> { p1 -> Text("Value p1=$p1, data=${data.value}") }

        compose {
            content(1)
            content(2)
        }

        validate {
            Text("Value p1=1, data=${data.value}")
            Text("Value p1=2, data=${data.value}")
        }

        data.value++
        expectChanges()
        revalidate()
    }

    @Test
    fun movableContentParameters_Two() = compositionTest {
        val data = mutableStateOf(0)
        val content =
            movableContentOf<Int, Int> { p1, p2 ->
                Text("Value p1=$p1, p2=$p2, data=${data.value}")
            }

        compose {
            content(1, 2)
            content(3, 4)
        }

        validate {
            Text("Value p1=1, p2=2, data=${data.value}")
            Text("Value p1=3, p2=4, data=${data.value}")
        }

        data.value++
        expectChanges()
        revalidate()
    }

    @Test
    fun movableContentParameters_Three() = compositionTest {
        val data = mutableStateOf(0)
        val content =
            movableContentOf<Int, Int, Int> { p1, p2, p3 ->
                Text("Value p1=$p1, p2=$p2, p3=$p3, data=${data.value}")
            }

        compose {
            content(1, 2, 3)
            content(4, 5, 6)
        }

        validate {
            Text("Value p1=1, p2=2, p3=3, data=${data.value}")
            Text("Value p1=4, p2=5, p3=6, data=${data.value}")
        }

        data.value++
        expectChanges()
        revalidate()
    }

    @Test
    fun movableContentParameters_Four() = compositionTest {
        val data = mutableStateOf(0)
        val content =
            movableContentOf<Int, Int, Int, Int> { p1, p2, p3, p4 ->
                Text("Value p1=$p1, p2=$p2, p3=$p3, p4=$p4, data=${data.value}")
            }

        compose {
            content(1, 2, 3, 4)
            content(5, 6, 7, 8)
        }

        validate {
            Text("Value p1=1, p2=2, p3=3, p4=4, data=${data.value}")
            Text("Value p1=5, p2=6, p3=7, p4=8, data=${data.value}")
        }

        data.value++
        expectChanges()
        revalidate()
    }

    @Test
    fun movableContentReceiver_None() = compositionTest {
        val data = mutableStateOf(0)
        val content =
            movableContentWithReceiverOf<Int>() { Text("Value this=$this, data=${data.value}") }
        val receiver1 = 100
        val receiver2 = 200

        compose {
            receiver1.content()
            receiver2.content()
        }

        validate {
            Text("Value this=100, data=${data.value}")
            Text("Value this=200, data=${data.value}")
        }

        data.value++
        expectChanges()
        revalidate()
    }

    @Test
    fun movableContentReceiver_One() = compositionTest {
        val data = mutableStateOf(0)
        val content =
            movableContentWithReceiverOf<Int, Int>() { p1 ->
                Text("Value this=$this, p1=$p1, data=${data.value}")
            }
        val receiver1 = 100
        val receiver2 = 200

        compose {
            receiver1.content(1)
            receiver2.content(2)
        }

        validate {
            Text("Value this=100, p1=1, data=${data.value}")
            Text("Value this=200, p1=2, data=${data.value}")
        }

        data.value++
        expectChanges()
        revalidate()
    }

    @Test
    fun movableContentReceiver_Two() = compositionTest {
        val data = mutableStateOf(0)
        val content =
            movableContentWithReceiverOf<Int, Int, Int>() { p1, p2 ->
                Text("Value this=$this, p1=$p1, p2=$p2, data=${data.value}")
            }
        val receiver1 = 100
        val receiver2 = 200

        compose {
            receiver1.content(1, 2)
            receiver2.content(3, 4)
        }

        validate {
            Text("Value this=100, p1=1, p2=2, data=${data.value}")
            Text("Value this=200, p1=3, p2=4, data=${data.value}")
        }

        data.value++
        expectChanges()
        revalidate()
    }

    @Test
    fun movableContentReceiver_Three() = compositionTest {
        val data = mutableStateOf(0)
        val content =
            movableContentWithReceiverOf<Int, Int, Int, Int>() { p1, p2, p3 ->
                Text("Value this=$this, p1=$p1, p2=$p2, p3=$p3, data=${data.value}")
            }
        val receiver1 = 100
        val receiver2 = 200

        compose {
            receiver1.content(1, 2, 3)
            receiver2.content(4, 5, 6)
        }

        validate {
            Text("Value this=100, p1=1, p2=2, p3=3, data=${data.value}")
            Text("Value this=200, p1=4, p2=5, p3=6, data=${data.value}")
        }

        data.value++
        expectChanges()
        revalidate()
    }

    @Test
    fun movableContentParameters_changedParameter() = compositionTest {
        val data = mutableStateOf(0)
        val location = mutableStateOf(0)
        val content = movableContentOf<Int> { d -> Text("d=$d") }

        compose {
            if (location.value == 0) content(data.value)
            Column { if (location.value == 1) content(data.value) }
            Row { if (location.value == 2) content(data.value) }
        }

        validate {
            if (location.value == 0) Text("d=${data.value}")
            Column { if (location.value == 1) Text("d=${data.value}") }
            Row { if (location.value == 2) Text("d=${data.value}") }
        }

        location.value++
        data.value++
        expectChanges()
        revalidate()

        location.value++
        expectChanges()
        revalidate()

        location.value++
        data.value++
        expectChanges()
        revalidate()
    }

    @Test
    fun movableContentOfTheSameFunctionShouldHaveStableKeys() = compositionTest {
        val hashList1 = mutableListOf<CompositeKeyHashCode>()
        val hashList2 = mutableListOf<CompositeKeyHashCode>()
        val composable1: @Composable () -> Unit = { hashList1.add(currentCompositeKeyHashCode) }
        val composable2: @Composable () -> Unit = { hashList2.add(currentCompositeKeyHashCode) }
        val movableContent1A = movableContentOf(composable1)
        val movableContent1B = movableContentOf(composable1)
        val movableContent2A = movableContentOf(composable2)
        val movableContent2B = movableContentOf(composable2)
        compose {
            movableContent1A()
            movableContent1B()
            movableContent1A()
            movableContent1B()
            movableContent2A()
            movableContent2B()
            movableContent2A()
            movableContent2B()
        }

        fun List<CompositeKeyHashCode>.assertAllTheSame() = forEach { assertEquals(it, first()) }
        hashList1.assertAllTheSame()
        hashList2.assertAllTheSame()
        assertNotEquals(hashList1.first(), hashList2.first())
    }

    @Test
    fun keyInsideMovableContentShouldntChangeWhenRecomposed() = compositionTest {
        val hashList = mutableListOf<CompositeKeyHashCode>()
        val counter = mutableStateOf(0)
        val movableContent = movableContentOf {
            hashList.add(currentCompositeKeyHashCode)
            Text("counter=${counter.value}")
        }
        compose { movableContent() }

        validate { Text("counter=${counter.value}") }

        counter.value++
        expectChanges()
        revalidate()

        assertEquals(2, hashList.size)
        assertEquals(hashList[0], hashList[1])
    }

    @Test
    fun parameterPassingThroughDeferredSubcompose() = compositionTest {
        var state by mutableStateOf(false)
        var lastSeen: Boolean? = null
        val content = movableContentOf { parameter: Boolean -> Container { lastSeen = parameter } }

        compose {
            if (state) {
                content(true)
            } else {
                DeferredSubcompose { content(state) }
            }
        }

        advanceTimeBy(5_000)

        assertEquals(state, lastSeen)

        repeat(5) {
            state = !state

            expectChanges()

            assertEquals(state, lastSeen, "Failed in iteration $it")
        }
    }

    @Test
    fun stateChangesWhilePendingMove() = compositionTest {
        var state = 0
        var lastSeen: Int? = null
        var deferred by mutableStateOf(false)
        var scope: RecomposeScope? = null

        val content = movableContentOf {
            Container {
                lastSeen = state
                scope = currentRecomposeScope
            }
        }

        compose {
            if (deferred) {
                DeferredSubcompose { content() }
                SideEffect {
                    state++
                    scope?.invalidate()
                }
            } else {
                content()
            }
        }

        advanceTimeBy(5_000)

        assertEquals(state, lastSeen)

        deferred = true

        advance()

        assertEquals(state, lastSeen)
    }

    @Test
    fun movableContent_moveRow() = compositionTest {
        var condition by mutableStateOf(true)

        val movableContent1 = movableContentOf { Text("First") }
        val movableContent2 = movableContentOf { Text("Second") }

        compose {
            if (condition) {
                Linear {
                    Linear { movableContent1() }
                    movableContent2()
                }
            } else {
                Linear {
                    Linear { movableContent1() }
                    movableContent2()
                }
            }
        }

        validate {
            Linear {
                Linear { Text("First") }
                Text("Second")
            }
        }

        condition = false
        expectChanges()

        revalidate()
    }

    @Test
    fun movableContent_rememberOrdering() = compositionTest {
        val movableContent1 = movableContentOf { repeat(100) { Text("Some content") } }
        var includeContent by mutableStateOf(true)
        var rememberKey by mutableStateOf(0)

        compose {
            if (includeContent) {
                movableContent1()
            }
            val a = remember(rememberKey) { SimpleRememberedObject("Key $rememberKey") }
            Text(a.name)
        }

        rememberKey++
        expectChanges()

        includeContent = false
        rememberKey++
        expectChanges()
    }

    @Test
    fun movableContent_nestedMovableContent() = compositionTest {
        var data = 0

        var condition by mutableStateOf(true)

        val nestedContent = movableContentOf {
            val state = remember { data++ }
            Text("Generated state: $state")
        }

        val contentHost = movableContentOf {
            Text("Host")
            if (condition) {
                nestedContent()
            }
        }

        compose {
            if (condition) {
                contentHost()
            }
            Text("Outer")
            if (!condition) {
                contentHost()
                nestedContent()
            }
        }

        validate {
            if (condition) {
                Text("Host")
                Text("Generated state: 0")
            }
            Text("Outer")
            if (!condition) {
                Text("Host")
                Text("Generated state: 0")
            }
        }

        condition = false
        expectChanges()
        revalidate()
        verifyConsistent()

        condition = true
        expectChanges()
        println("Done")
        revalidate()
        verifyConsistent()
    }

    @Test // 362539770
    fun movableContent_nestedMovableContent_direct() = compositionTest {
        var data = 0

        var condition by mutableStateOf(true)

        val common = movableContentOf {
            val state = remember { data++ }
            Text("Generated state: $state")
        }

        val wrapper = movableContentOf {
            Text("Wrapper start")
            common()
            Text("Wrapper end")
        }

        compose {
            Text("Outer")
            if (condition) {
                wrapper()
            } else {
                common()
            }
        }

        validate {
            Text("Outer")
            if (condition) {
                Text("Wrapper start")
            }
            Text("Generated state: 0")
            if (condition) {
                Text("Wrapper end")
            }
        }

        condition = false
        expectChanges()
        revalidate()

        condition = true
        expectChanges()
        revalidate()
    }

    @Test // 362539770
    @OptIn(ExperimentalComposeApi::class)
    fun movableContent_nestedMovableContent_disabled() = compositionTest {
        var data = 0

        var condition by mutableStateOf(true)

        val common = movableContentOf {
            val state = remember { data++ }
            Text("Generated state: $state")
        }

        val wrapper = movableContentOf {
            Text("Wrapper start")
            common()
            Text("Wrapper end")
        }

        compose {
            Text("Outer")
            if (condition) {
                wrapper()
            } else {
                common()
            }
        }

        var expectedState = 0
        validate {
            Text("Outer")
            if (condition) {
                Text("Wrapper start")
            }
            Text("Generated state: $expectedState")
            if (condition) {
                Text("Wrapper end")
            }
        }

        ComposeRuntimeFlags.isMovingNestedMovableContentEnabled = false
        try {
            // With moving nested content disabled the call to common() will generate new
            // state when it moves out of the containing movable content.
            expectedState = 1
            condition = false
            expectChanges()
            revalidate()

            condition = true
            expectChanges()
            revalidate()
        } finally {
            ComposeRuntimeFlags.isMovingNestedMovableContentEnabled = true
        }
    }

    @Test
    fun movableContent_nestedMovableContent_simpleMove() = compositionTest {
        var data = 0

        var condition by mutableStateOf(true)

        val common = movableContentOf {
            val state = remember { data++ }
            Text("Generated state: $state")
        }

        val wrapper = movableContentOf {
            Text("Wrapper start")
            common()
            Text("Wrapper end")
        }

        compose {
            Text("Outer")
            if (condition) {
                Linear { wrapper() }
            } else {
                wrapper()
            }
        }

        validate {
            Text("Outer")
            if (condition) {
                Linear {
                    Text("Wrapper start")
                    Text("Generated state: 0")
                    Text("Wrapper end")
                }
            } else {
                Text("Wrapper start")
                Text("Generated state: 0")
                Text("Wrapper end")
            }
        }

        condition = false
        expectChanges()
        revalidate()

        condition = true
        expectChanges()
        revalidate()
    }

    @Test
    fun movableContent_nestedMovableContent_tree() = compositionTest {
        var data = 0

        @Composable
        fun Leaf() {
            val value = remember { data++ }
            Text("Data $value")
        }

        val level0 = Array(16) { movableContentOf { Leaf() } }
        val level1 =
            Array(8) { it ->
                movableContentOf {
                    level0[it * 2]()
                    level0[it * 2 + 1]()
                }
            }
        val level2 =
            Array(4) {
                movableContentOf {
                    level1[it * 2]()
                    level1[it * 2 + 1]()
                }
            }
        val level3 =
            Array(2) {
                movableContentOf {
                    level2[it * 2]()
                    level2[it * 2 + 1]()
                }
            }

        var displayTree by mutableStateOf(false)

        compose { if (displayTree) level3.forEach { it() } else level0.forEach { it() } }

        validate { repeat(16) { Text("Data $it") } }

        displayTree = true
        expectChanges()
        revalidate()

        displayTree = false
        expectChanges()
        revalidate()
    }

    @Test // 343178423
    fun movableContent_movingContentOutOfDeferredSubcomposition() = compositionTest {
        var toggle by mutableStateOf(true)
        val content = movableContentOf { Text("Toggle = $toggle") }

        compose {
            if (toggle) {
                DeferredSubcompose { content() }
            } else {
                content()
            }
        }
        advanceTimeBy(5_000)

        validate {
            if (toggle) {
                DeferredSubcompose { Text("Toggle = $toggle") }
            } else {
                Text("Toggle = false")
            }
        }

        toggle = !toggle
        expectChanges()
        revalidate()
    }

    @Test // 365802563
    fun movableContent_movingChildOfDeletedNode() = compositionTest {
        var index by mutableIntStateOf(0)
        val content = movableContentOf { Text("Some text") }
        compose {
            for (i in index..3) {
                InlineLinear { content() }
            }
            for (i in 0..index) {
                InlineLinear { content() }
            }
        }
        validate {
            for (i in index..3) {
                Linear { Text("Some text") }
            }
            for (i in 0..index) {
                Linear { Text("Some text") }
            }
        }

        index++
        advance()

        index++
        advance()

        index++
        advance()
    }
}

@Composable
private fun Row(content: @Composable () -> Unit) {
    ComposeNode<View, ViewApplier>(factory = { View().also { it.name = "Row" } }, update = {}) {
        content()
    }
}

private fun MockViewValidator.Row(block: MockViewValidator.() -> Unit) {
    view("Row", block)
}

@Composable
private fun Column(content: @Composable () -> Unit) {
    ComposeNode<View, ViewApplier>(factory = { View().also { it.name = "Column" } }, update = {}) {
        content()
    }
}

@Composable private fun Empty() {}

private fun MockViewValidator.Column(block: MockViewValidator.() -> Unit) {
    view("Column", block)
}

@Composable
private fun Text(text: String) {
    ComposeNode<View, ViewApplier>(
        factory = { View().also { it.name = "Text" } },
        update = { set(text) { attributes["text"] = it } }
    )
}

private fun MockViewValidator.Text(text: String) {
    view("Text")
    assertEquals(text, view.attributes["text"])
}

@Composable
private fun Marker() {
    ComposeNode<View, ViewApplier>(factory = { View().also { it.name = "Marker" } }, update = {})
}

private fun MockViewValidator.Marker() {
    view("Marker")
}

@Composable
private fun Marker(value: Int) {
    ComposeNode<View, ViewApplier>(
        factory = { View().also { it.name = "Marker" } },
        update = { set(value) { attributes["value"] = it } }
    )
}

@Composable
private fun Stack(isHorizontal: Boolean, block: @Composable () -> Unit) {
    if (isHorizontal) {
        Column(block)
    } else {
        Row(block)
    }
}

private fun MockViewValidator.Stack(isHorizontal: Boolean, block: MockViewValidator.() -> Unit) {
    if (isHorizontal) {
        Column(block)
    } else {
        Row(block)
    }
}

@Composable
private fun DisplayInt(value: State<Int>) {
    Text("value=${value.value}")
}

private fun MockViewValidator.DisplayInt(value: State<Int>) {
    Text("value=${value.value}")
}

private fun MockViewValidator.Marker(value: Int) {
    view("Marker")
    assertEquals(value, view.attributes["value"])
}

@Composable
private fun Subcompose(content: @Composable () -> Unit) {
    val host = View().also { it.name = "SubcomposeHost" }
    ComposeNode<View, ViewApplier>(factory = { host }, update = {})
    val parent = rememberCompositionContext()
    val composition = Composition(ViewApplier(host), parent)
    composition.setContent(content)
    DisposableEffect(Unit) { onDispose { composition.dispose() } }
}

@Composable
private fun DeferredSubcompose(content: @Composable () -> Unit) {
    val host = View().also { it.name = "DeferredSubcompose" }
    ComposeNode<View, ViewApplier>(factory = { host }, update = {})
    val parent = rememberCompositionContext()
    val composition = remember { Composition(ViewApplier(host), parent) }
    LaunchedEffect(content as Any) { composition.setContent(content) }
    DisposableEffect(Unit) { onDispose { composition.dispose() } }
}

private fun MockViewValidator.Subcompose(content: MockViewValidator.() -> Unit) {
    view("SubcomposeHost", content)
}

private fun MockViewValidator.DeferredSubcompose(content: MockViewValidator.() -> Unit) {
    view("DeferredSubcompose", content)
}

class RememberedObject : RememberObserver {
    var count: Int = 0
    val isLive: Boolean
        get() = count > 0

    private var rememberedCount = 0
    private var forgottenCount = 0
    private var abandonedCount = 0

    private var died: Boolean = false

    override fun onRemembered() {
        check(!died) { "Remember observer was resurrected" }
        rememberedCount++
        count++
    }

    override fun onForgotten() {
        check(count > 0) { "Abandoned or forgotten more times than remembered" }
        forgottenCount++
        count--
        if (count == 0) died = true
    }

    override fun onAbandoned() {
        check(count > 0) { "Abandoned or forgotten more times than remembered" }
        abandonedCount++
        count--
        if (count == 0) died = true
    }
}

class SimpleRememberedObject(val name: String) : RememberObserver {
    override fun onRemembered() {}

    override fun onForgotten() {}

    override fun onAbandoned() {}
}