ui/ui-core/src/androidAndroidTest/kotlin/androidx/ui/core/layout/MeasureAndLayoutDelegateTest.kt - platform/frameworks/support - Git at Google

 /*
  * 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.ui.core.layout

 import androidx.test.filters.SmallTest
 import androidx.ui.core.Constraints
 import androidx.ui.core.ExperimentalLayoutNodeApi
 import androidx.ui.core.LayoutDirection
 import androidx.ui.core.LayoutNode.LayoutState
 import androidx.ui.core.test.AndroidOwnerExtraAssertionsRule
 import com.google.common.truth.Truth.assertThat
 import org.junit.Rule
 import org.junit.Test
 import org.junit.runner.RunWith
 import org.junit.runners.JUnit4

 @SmallTest
 @RunWith(JUnit4::class)
 @OptIn(ExperimentalLayoutNodeApi::class)
 class MeasureAndLayoutDelegateTest {

     private val DifferentSize = 50
     private val DifferentSize2 = 30

     @get:Rule
     val excessiveAssertions = AndroidOwnerExtraAssertionsRule()

     @Test
     fun requiresMeasureWhenJustCreated() {
         val root = root {
             add(node())
         }

         createDelegate(root, firstMeasureCompleted = false)

         assertMeasureRequired(root)
         assertMeasureRequired(root.first)
     }

     @Test
     fun measureNotRequiredAfterFirstMeasure() {
         val root = root {
             add(node())
         }

         createDelegate(root)

         assertMeasuredAndLaidOut(root)
         assertMeasuredAndLaidOut(root.first)
     }

     @Test
     fun relayoutNotRequiredAfterFirstMeasure() {
         val root = root {
             add(node())
         }

         createDelegate(root)

         assertMeasuredAndLaidOut(root)
         assertMeasuredAndLaidOut(root.first)
     }

     @Test
     fun measuredAndLaidOutAfterFirstMeasureAndLayout() {
         val root = root {
             add(node())
         }

         assertRemeasured(root) {
             assertRemeasured(root.first) {
                 createDelegate(root)
             }
         }
     }

     // remeasure request:

     @Test
     fun childRemeasureRequest_remeasureRequired() {
         val root = root {
             add(node())
         }

         val delegate = createDelegate(root)

         delegate.requestRemeasure(root.first)
         assertMeasureRequired(root.first)
     }

     @Test
     fun childRemeasureRequest_childRemeasured() {
         val root = root {
             add(node())
         }

         val delegate = createDelegate(root)

         assertRemeasured(root.first) {
             delegate.requestRemeasure(root.first)
             assertThat(delegate.measureAndLayout()).isFalse()
         }
     }

     @Test
     fun childMeasuredInLayoutBlockRemeasureRequest_childRemeasured() {
         val root = root {
             add(node())
             measureInLayoutBlock()
         }

         val delegate = createDelegate(root)

         assertRemeasured(root.first) {
             delegate.requestRemeasure(root.first)
             assertThat(delegate.measureAndLayout()).isFalse()
         }
     }

     @Test
     fun childRemeasureWithTheSameResult_parentNotRemeasured() {
         val root = root {
             add(node())
         }

         val delegate = createDelegate(root)

         assertNotRemeasured(root) {
             delegate.requestRemeasure(root.first)
             assertThat(delegate.measureAndLayout()).isFalse()
         }
     }

     @Test
     fun childRemeasureWithDifferentResult_parentRemeasured() {
         val root = root {
             wrapChildren = true
             add(node {
                 size = DifferentSize
             })
         }

         val delegate = createDelegate(root)

         assertRemeasured(root) {
             assertRemeasured(root) {
                 root.first.size = DifferentSize2
                 delegate.requestRemeasure(root.first)
                 assertThat(delegate.measureAndLayout()).isTrue()
             }
         }
     }

     @Test
     fun childRemeasureInLayoutBlockWithTheSameResult_parentNotRemeasured() {
         val root = root {
             add(node())
             measureInLayoutBlock()
         }

         val delegate = createDelegate(root)

         assertNotRemeasured(root) {
             delegate.requestRemeasure(root.first)
             assertThat(delegate.measureAndLayout()).isFalse()
         }
     }

     @Test
     fun childRemeasureInLayoutBlockWithDifferentResult_parentNotRemeasured() {
         val root = root {
             add(node())
             measureInLayoutBlock()
         }

         val delegate = createDelegate(root)

         assertNotRemeasured(root) {
             root.first.size = DifferentSize
             delegate.requestRemeasure(root.first)
             assertThat(delegate.measureAndLayout()).isFalse()
         }
     }

     @Test
     fun childRemeasureRequest_childRelaidOut() {
         val root = root {
             add(node())
         }

         val delegate = createDelegate(root)

         assertRelaidOut(root.first) {
             delegate.requestRemeasure(root.first)
             assertThat(delegate.measureAndLayout()).isFalse()
         }
     }

     @Test
     fun childMeasuredInLayoutBlockRelayoutRequest_childRelaidOut() {
         val root = root {
             add(node())
             measureInLayoutBlock()
         }

         val delegate = createDelegate(root)

         assertRelaidOut(root.first) {
             delegate.requestRemeasure(root.first)
             assertThat(delegate.measureAndLayout()).isFalse()
         }
     }

     @Test
     fun childRemeasureWithTheSameResult_parentNotRelaidOut() {
         val root = root {
             add(node())
         }

         val delegate = createDelegate(root)

         assertNotRelaidOut(root) {
             delegate.requestRemeasure(root.first)
             assertThat(delegate.measureAndLayout()).isFalse()
         }
     }

     @Test
     fun childRemeasureInLayoutBlockWithTheSameResult_parentNotRelaidOut() {
         val root = root {
             add(node())
             measureInLayoutBlock()
         }

         val delegate = createDelegate(root)

         assertNotRelaidOut(root) {
             delegate.requestRemeasure(root.first)
             assertThat(delegate.measureAndLayout()).isFalse()
         }
     }

     @Test
     fun childRemeasureInLayoutBlockWithDifferentResult_parentRelaidOut() {
         val root = root {
             add(node())
             measureInLayoutBlock()
         }

         val delegate = createDelegate(root)

         assertRelaidOut(root) {
             root.first.size = DifferentSize
             delegate.requestRemeasure(root.first)
             assertThat(delegate.measureAndLayout()).isFalse()
         }
     }

     @Test
     fun rootRemeasureRequest_childNotAffected() {
         val root = root {
             add(node())
         }

         val delegate = createDelegate(root)

         assertRemeasured(root) {
             assertNotRemeasured(root.first) {
                 assertNotRelaidOut(root.first) {
                     delegate.requestRemeasure(root)
                     assertThat(delegate.measureAndLayout()).isFalse()
                 }
             }
         }
     }

     @Test
     fun parentRemeasureRequest_childNotAffected() {
         val root = root {
             add(node {
                 add(node())
             })
         }

         val delegate = createDelegate(root)

         assertRemeasured(root.first) {
             assertNotRemeasured(root.first.first) {
                 assertNotRelaidOut(root.first.first) {
                     delegate.requestRemeasure(root.first)
                     assertThat(delegate.measureAndLayout()).isFalse()
                 }
             }
         }
     }

     // relayout request:

     @Test
     fun childRelayoutRequest_childRelayoutRequired() {
         val root = root {
             add(node())
         }

         val delegate = createDelegate(root)

         delegate.requestRelayout(root.first)
         assertLayoutRequired(root.first)
     }

     @Test
     fun childRelayoutRequest_childRelaidOut() {
         val root = root {
             add(node())
         }

         val delegate = createDelegate(root)

         assertRelaidOut(root.first) {
             delegate.requestRelayout(root.first)
             assertThat(delegate.measureAndLayout()).isFalse()
         }
     }

     @Test
     fun childRelayoutRequest_childNotRemeasured() {
         val root = root {
             add(node())
         }

         val delegate = createDelegate(root)

         assertNotRemeasured(root.first) {
             delegate.requestRelayout(root.first)
             assertThat(delegate.measureAndLayout()).isFalse()
         }
     }

     @Test
     fun childRelayoutRequest_parentNotRemeasured() {
         val root = root {
             add(node())
         }

         val delegate = createDelegate(root)

         assertNotRemeasured(root) {
             delegate.requestRelayout(root.first)
             assertThat(delegate.measureAndLayout()).isFalse()
         }
     }

     @Test
     fun childRelayoutRequest_parentNotRelaidOut() {
         val root = root {
             add(node())
         }

         val delegate = createDelegate(root)

         assertNotRelaidOut(root) {
             delegate.requestRelayout(root.first)
             assertThat(delegate.measureAndLayout()).isFalse()
         }
     }

     @Test
     fun childMeasuredInLayoutBlockRelayoutRequest_parentNotRemeasured() {
         val root = root {
             add(node())
             measureInLayoutBlock()
         }

         val delegate = createDelegate(root)

         assertNotRemeasured(root) {
             delegate.requestRelayout(root.first)
             assertThat(delegate.measureAndLayout()).isFalse()
         }
     }

     @Test
     fun childMeasuredInLayoutBlockRelayoutRequest_parentNotRelaidOut() {
         val root = root {
             add(node())
             measureInLayoutBlock()
         }

         val delegate = createDelegate(root)

         assertNotRelaidOut(root) {
             delegate.requestRelayout(root.first)
             assertThat(delegate.measureAndLayout()).isFalse()
         }
     }

     @Test
     fun rootRelayoutRequest_childNotAffected() {
         val root = root {
             add(node())
         }

         val delegate = createDelegate(root)

         assertRelaidOut(root) {
             assertNotRelaidOut(root.first) {
                 delegate.requestRelayout(root)
                 assertThat(delegate.measureAndLayout()).isFalse()
             }
         }
     }

     @Test
     fun parentRelayoutRequest_childNotAffected() {
         val root = root {
             add(node {
                 add(node())
             })
         }

         val delegate = createDelegate(root)

         assertRelaidOut(root.first) {
             assertNotRelaidOut(root.first.first) {
                 delegate.requestRelayout(root.first)
                 assertThat(delegate.measureAndLayout()).isFalse()
             }
         }
     }

     // request twice

     @Test
     fun childRemeasureRequestedTwice_childRemeasuredOnce() {
         val root = root {
             add(node())
         }

         val delegate = createDelegate(root)

         assertRemeasured(root.first) {
             delegate.requestRemeasure(root.first)
             delegate.requestRemeasure(root.first)
             assertThat(delegate.measureAndLayout()).isFalse()
         }
     }

     @Test
     fun childRemeasureRequestedTwice_childRelaidOutOnce() {
         val root = root {
             add(node())
         }

         val delegate = createDelegate(root)

         assertRelaidOut(root.first) {
             delegate.requestRemeasure(root.first)
             delegate.requestRemeasure(root.first)
             assertThat(delegate.measureAndLayout()).isFalse()
         }
     }

     @Test
     fun childRemeasureAndRelayoutRequested_childRemeasured() {
         val root = root {
             add(node())
         }

         val delegate = createDelegate(root)

         assertRemeasured(root.first) {
             delegate.requestRemeasure(root.first)
             delegate.requestRelayout(root.first)
             assertThat(delegate.measureAndLayout()).isFalse()
         }
     }

     @Test
     fun childRemeasureAndRelayoutRequested_childRelaidOut() {
         val root = root {
             add(node())
         }

         val delegate = createDelegate(root)

         assertRelaidOut(root.first) {
             delegate.requestRemeasure(root.first)
             delegate.requestRelayout(root.first)
             assertThat(delegate.measureAndLayout()).isFalse()
         }
     }

     @Test
     fun childRelayoutAndRemeasureRequested_childRemeasured() {
         val root = root {
             add(node())
         }

         val delegate = createDelegate(root)

         assertRemeasured(root.first) {
             delegate.requestRelayout(root.first)
             delegate.requestRemeasure(root.first)
             assertThat(delegate.measureAndLayout()).isFalse()
         }
     }

     @Test
     fun childRelayoutAndRemeasureRequested_childRelaidOut() {
         val root = root {
             add(node())
         }

         val delegate = createDelegate(root)

         assertRelaidOut(root.first) {
             delegate.requestRelayout(root.first)
             delegate.requestRemeasure(root.first)
             assertThat(delegate.measureAndLayout()).isFalse()
         }
     }

     // Siblings

     @Test
     fun firstChildRemeasureRequest_onlyFirstChildRemeasured() {
         val root = root {
             add(node())
             add(node())
         }

         val delegate = createDelegate(root)

         assertRemeasured(root.first) {
             assertNotRemeasured(root.second) {
                 delegate.requestRemeasure(root.first)
                 delegate.measureAndLayout()
             }
         }
     }

     @Test
     fun firstChildRelayoutRequest_onlyFirstChildRelaid() {
         val root = root {
             add(node())
             add(node())
         }

         val delegate = createDelegate(root)

         assertRelaidOut(root.first) {
             assertNotRelaidOut(root.second) {
                 delegate.requestRelayout(root.first)
                 assertThat(delegate.measureAndLayout()).isFalse()
             }
         }
     }

     @Test
     fun bothChildrenRemeasureRequest_bothRemeasured() {
         val root = root {
             add(node())
             add(node())
         }

         val delegate = createDelegate(root)

         assertRemeasured(root.first) {
             assertRemeasured(root.second) {
                 delegate.requestRemeasure(root.first)
                 delegate.requestRemeasure(root.second)
                 assertThat(delegate.measureAndLayout()).isFalse()
             }
         }
     }

     @Test
     fun bothChildrenRelayoutRequest_bothRelaidOut() {
         val root = root {
             add(node())
             add(node())
         }

         val delegate = createDelegate(root)

         assertRelaidOut(root.first) {
             assertRelaidOut(root.second) {
                 delegate.requestRelayout(root.first)
                 delegate.requestRelayout(root.second)
                 assertThat(delegate.measureAndLayout()).isFalse()
             }
         }
     }

     @Test
     fun oneChildRelayoutRequestAnotherRemeasure() {
         val root = root {
             add(node())
             add(node())
         }

         val delegate = createDelegate(root)

         assertRemeasured(root.first) {
             assertNotRemeasured(root.second) {
                 assertRelaidOut(root.second) {
                     delegate.requestRemeasure(root.first)
                     delegate.requestRelayout(root.second)
                     assertThat(delegate.measureAndLayout()).isFalse()
                 }
             }
         }
     }

     // different levels

     @Test
     fun remeasureTwoNodesOnDifferentLayers_othersAreNotAffected() {
         val root = root {
             add(node())
             add(node {
                 add(node())
             })
         }

         val delegate = createDelegate(root)

         assertNotRemeasured(root) {
             assertRemeasured(root.first) {
                 assertNotRemeasured(root.second) {
                     assertRemeasured(root.second.first) {
                         delegate.requestRemeasure(root.first)
                         delegate.requestRemeasure(root.second.first)
                         assertThat(delegate.measureAndLayout()).isFalse()
                     }
                 }
             }
         }
     }

     @Test
     fun changeSizeOfTheLeaf_remeasuresUpToTheFixedSizeParent() {
         val root = root {
             wrapChildren = true
             add(node {
                 size = DifferentSize
                 add(node {
                     wrapChildren = true
                     add(node {
                         size = DifferentSize
                     })
                 })
             })
         }

         val delegate = createDelegate(root)

         assertNotRemeasured(root) {
             assertRemeasured(root.first) {
                 assertRemeasured(root.first.first) {
                     val leaf = root.first.first.first
                     assertRemeasured(leaf) {
                         leaf.size = DifferentSize2
                         delegate.requestRemeasure(leaf)
                         assertThat(delegate.measureAndLayout()).isFalse()
                     }
                 }
             }
         }
     }

     @Test
     fun remeasureRequestForItemsOnTheSameLevelButDifferentParents() {
         val root = root {
             add(node {
                 add(node())
             })
             add(node {
                 add(node())
             })
         }

         val delegate = createDelegate(root)

         assertNotRemeasured(root) {
             assertNotRemeasured(root.first) {
                 assertRemeasured(root.first.first) {
                     assertNotRemeasured(root.second) {
                         assertRemeasured(root.second.first) {
                             delegate.requestRemeasure(root.first.first)
                             delegate.requestRemeasure(root.second.first)
                             assertThat(delegate.measureAndLayout()).isFalse()
                         }
                     }
                 }
             }
         }
     }

     @Test
     fun relayoutRequestForItemsOnTheSameLevelButDifferentParents() {
         val root = root {
             add(node {
                 add(node())
             })
             add(node {
                 add(node())
             })
         }

         val delegate = createDelegate(root)

         assertNotRelaidOut(root) {
             assertNotRelaidOut(root.first) {
                 assertRelaidOut(root.first.first) {
                     assertNotRelaidOut(root.second) {
                         assertRelaidOut(root.second.first) {
                             delegate.requestRelayout(root.first.first)
                             delegate.requestRelayout(root.second.first)
                             assertThat(delegate.measureAndLayout()).isFalse()
                         }
                     }
                 }
             }
         }
     }

     @Test
     fun relayoutAndRemeasureRequestForItemsOnTheSameLevelButDifferentParents() {
         val root = root {
             add(node {
                 add(node())
             })
             add(node {
                 add(node())
             })
         }

         val delegate = createDelegate(root)

         assertNotRelaidOut(root) {
             assertNotRelaidOut(root.first) {
                 assertRemeasured(root.first.first) {
                     assertNotRelaidOut(root.second) {
                         assertRelaidOut(root.second.first) {
                             delegate.requestRemeasure(root.first.first)
                             delegate.requestRelayout(root.second.first)
                             assertThat(delegate.measureAndLayout()).isFalse()
                         }
                     }
                 }
             }
         }
     }

     // request during measure

     @Test
     fun requestChildRemeasureDuringMeasure() {
         val root = root {
             add(node())
         }

         val delegate = createDelegate(root)

         assertRemeasured(root) {
             assertRemeasured(root.first) {
                 root.runDuringMeasure {
                     delegate.requestRemeasure(root.first)
                 }
                 delegate.requestRemeasure(root)
                 assertThat(delegate.measureAndLayout()).isFalse()
             }
         }
     }

     @Test
     fun requestGrandchildRemeasureDuringMeasure() {
         val root = root {
             add(node {
                 add(node())
             })
         }

         val delegate = createDelegate(root)

         assertRemeasured(root) {
             assertNotRemeasured(root.first) {
                 assertRemeasured(root.first.first) {
                     root.runDuringMeasure {
                         delegate.requestRemeasure(root.first.first)
                     }
                     delegate.requestRemeasure(root)
                     assertThat(delegate.measureAndLayout()).isFalse()
                 }
             }
         }
     }

     @Test
     fun requestChildRelayoutDuringMeasure() {
         val root = root {
             add(node())
         }

         val delegate = createDelegate(root)

         assertRemeasured(root) {
             assertRelaidOut(root.first) {
                 root.runDuringMeasure {
                     delegate.requestRelayout(root.first)
                 }
                 delegate.requestRemeasure(root)
                 assertThat(delegate.measureAndLayout()).isFalse()
             }
         }
     }

     @Test
     fun requestGrandchildRelayoutDuringMeasure() {
         val root = root {
             add(node {
                 add(node())
             })
         }

         val delegate = createDelegate(root)

         assertRemeasured(root) {
             assertNotRelaidOut(root.first) {
                 assertRelaidOut(root.first.first) {
                     root.runDuringMeasure {
                         delegate.requestRelayout(root.first.first)
                     }
                     delegate.requestRemeasure(root)
                     assertThat(delegate.measureAndLayout()).isFalse()
                 }
             }
         }
     }

     @Test
     fun requestChildRemeasureDuringParentLayout() {
         val root = root {
             add(node())
         }

         val delegate = createDelegate(root)

         assertRelaidOut(root) {
             assertRemeasured(root.first) {
                 root.runDuringLayout {
                     delegate.requestRemeasure(root.first)
                 }
                 delegate.requestRelayout(root)
                 assertThat(delegate.measureAndLayout()).isFalse()
             }
         }
     }

     @Test
     fun requestGrandchildRemeasureDuringParentLayout() {
         val root = root {
             add(node {
                 add(node())
             })
         }

         val delegate = createDelegate(root)

         assertRelaidOut(root) {
             assertNotRelaidOut(root.first) {
                 assertRemeasured(root.first.first) {
                     root.runDuringLayout {
                         delegate.requestRemeasure(root.first.first)
                     }
                     delegate.requestRelayout(root)
                     assertThat(delegate.measureAndLayout()).isFalse()
                 }
             }
         }
     }

     @Test
     fun requestRemeasureForCurrentlyBeingRemeasuredNode() {
         val root = root {
             add(node())
         }

         val delegate = createDelegate(root)

         assertRemeasured(root.first) {
             root.runDuringMeasure {
                 delegate.requestRemeasure(root.first)
             }
             delegate.requestRemeasure(root.first)
             assertThat(delegate.measureAndLayout()).isFalse()
         }
     }

     @Test
     fun requestRelayoutForCurrentlyBeingRemeasuredNode() {
         val root = root {
             add(node())
         }

         val delegate = createDelegate(root)

         assertRemeasured(root.first) {
             assertRelaidOut(root.first) {
                 root.runDuringMeasure {
                     delegate.requestRelayout(root.first)
                 }
                 delegate.requestRemeasure(root.first)
                 assertThat(delegate.measureAndLayout()).isFalse()
             }
         }
     }

     @Test
     fun requestRemeasureForCurrentlyBeingRelayoutNode() {
         val root = root {
             add(node())
         }

         val delegate = createDelegate(root)

         assertRemeasured(root.first) {
             assertRelaidOut(root.first, times = 2) {
                 root.first.runDuringLayout {
                     delegate.requestRemeasure(root.first)
                 }
                 delegate.requestRelayout(root.first)
                 assertThat(delegate.measureAndLayout()).isFalse()
             }
         }
     }

     @Test
     fun requestRelayoutForCurrentlyBeingRelayoutNode() {
         val root = root {
             add(node())
         }

         val delegate = createDelegate(root)

         assertNotRemeasured(root.first) {
             assertRelaidOut(root.first) {
                 root.runDuringLayout {
                     delegate.requestRelayout(root.first)
                 }
                 delegate.requestRelayout(root.first)
                 assertThat(delegate.measureAndLayout()).isFalse()
             }
         }
     }

     // Rtl

     @Test
     fun changeDirectionForChildren() {
         val root = root {
             add(node())
         }

         val delegate = createDelegate(root)

         assertRemeasured(root, withDirection = LayoutDirection.Ltr) {
             assertRemeasured(root.first, withDirection = LayoutDirection.Rtl) {
                 root.childrenDirection = LayoutDirection.Rtl
                 delegate.requestRemeasure(root)
                 assertThat(delegate.measureAndLayout()).isFalse()
             }
         }
     }

     // Updating root constraints / layout direction

     @Test
     fun changingParentParamsToTheSameValue_noRemeasures() {
         val root = root {
             add(node {
                 add(node())
             })
         }

         val delegate = createDelegate(root)

         assertNotRemeasured(root) {
             assertNotRemeasured(root.first) {
                 assertNotRemeasured(root.first.first) {
                     delegate.updateRootParams(
                         defaultRootConstraints(),
                         LayoutDirection.Ltr
                     )
                     assertThat(delegate.measureAndLayout()).isFalse()
                 }
             }
         }
     }

     @Test
     fun changingParentConstraints_remeasureSubTree() {
         val root = root {
             add(node {
                 add(node())
             })
         }

         val delegate = createDelegate(root)

         assertRemeasured(root) {
             assertRemeasured(root.first) {
                 assertRemeasured(root.first.first) {
                     delegate.updateRootParams(
                         Constraints(maxWidth = DifferentSize, maxHeight = DifferentSize),
                         LayoutDirection.Ltr
                     )
                     assertThat(delegate.measureAndLayout()).isTrue()
                 }
             }
         }
     }

     @Test
     fun changingParentConstraints_remeasureOnlyAffectedNodes() {
         val root = root {
             add(node {
                 size = DifferentSize2
                 add(node())
             })
         }

         val delegate = createDelegate(root)

         assertRemeasured(root.first) {
             assertNotRemeasured(root.first.first) {
                 delegate.updateRootParams(
                     Constraints(maxWidth = DifferentSize, maxHeight = DifferentSize),
                     LayoutDirection.Ltr
                 )
                 assertThat(delegate.measureAndLayout()).isTrue()
             }
         }
     }

     @Test
     fun changingParentDirection_remeasureSubTree() {
         val root = root {
             add(node {
                 add(node())
             })
         }

         val delegate = createDelegate(root)

         assertRemeasured(root, withDirection = LayoutDirection.Rtl) {
             assertRemeasured(root.first, withDirection = LayoutDirection.Rtl) {
                 assertRemeasured(root.first.first, withDirection = LayoutDirection.Rtl) {
                     delegate.updateRootParams(
                         defaultRootConstraints(),
                         LayoutDirection.Rtl
                     )
                     assertThat(delegate.measureAndLayout()).isFalse()
                 }
             }
         }
     }

     @Test
     fun changingParentDirection_remeasureOnlyAffectedNodes() {
         val root = root {
             add(node {
                 childrenDirection = LayoutDirection.Rtl
                 add(node())
             })
         }

         val delegate = createDelegate(root)

         assertRemeasured(root, withDirection = LayoutDirection.Rtl) {
             assertRemeasured(root.first, withDirection = LayoutDirection.Rtl) {
                 assertNotRemeasured(root.first.first) {
                     delegate.updateRootParams(
                         defaultRootConstraints(),
                         LayoutDirection.Rtl
                     )
                     assertThat(delegate.measureAndLayout()).isFalse()
                 }
             }
         }
     }

     // LayoutModifier

     @Test
     fun requestRemeasureTriggersModifierRemeasure() {
         val spyModifier = SpyLayoutModifier()
         val root = root {
             add(node {
                 @OptIn(ExperimentalLayoutNodeApi::class)
                 modifier = spyModifier
             })
         }

         val delegate = createDelegate(root)

         assertRemeasured(spyModifier) {
             delegate.requestRemeasure(root.first)
             assertThat(delegate.measureAndLayout()).isFalse()
         }
     }

     @Test
     fun requestRelayoutTriggersModifierRelayout() {
         val spyModifier = SpyLayoutModifier()
         val root = root {
             add(node {
                 @OptIn(ExperimentalLayoutNodeApi::class)
                 modifier = spyModifier
             })
         }

         val delegate = createDelegate(root)

         assertNotRemeasured(spyModifier) {
             assertRelaidOut(spyModifier) {
                 delegate.requestRelayout(root.first)
                 assertThat(delegate.measureAndLayout()).isFalse()
             }
         }
     }

     // Relayout depending on the measured child
     // Illustrates the case when we run layoutChildren() on the parent node, but some of its
     // children are not yet measured even if they are supposed to be measured in the measure
     // block of our parent.
     //
     // Example:
     // val child = Layout(...)
     // Layout(child) { measuruables, constraints ->
     //    val placeable = measurables.first().measure(constraints)
     //    layout(placeable.width, placeable.height) {
     //       placeable.place(0, 0)
     //    }
     // }
     // Then some changes scheduled remeasure for child and relayout for parent.
     // During the measureAndLayout() we will start with the parent as it has lower depth.
     // Inside the layout block we will call placeable.width which is currently dirty as the child
     // was scheduled to remeasure.

     @Test
     fun relayoutDependingOnRemeasuredChild() {
         val root = root {
             // this node will be measured in the measuring block
             add(node())
         }

         val delegate = createDelegate(root)

         assertNotRemeasured(root) {
             assertRelaidOut(root) {
                 assertRemeasured(root.first) {
                     delegate.requestRemeasure(root.first)
                     delegate.requestRelayout(root)
                     root.runDuringLayout {
                         // this means the root.first will be measured before laying out the root
                         @OptIn(ExperimentalLayoutNodeApi::class)
                         assertThat(root.first.layoutState).isEqualTo(LayoutState.NeedsRelayout)
                     }
                     assertThat(delegate.measureAndLayout()).isFalse()
                 }
             }
         }
     }

     @Test
     fun relayoutDependingOnRemeasuredChild_parentRemeasuredBecauseOfChangedSize() {
         val root = root {
             wrapChildren = true
             // this node will be measured in the measuring block
             add(node())
         }

         val delegate = createDelegate(root)

         assertRemeasured(root) {
             assertRemeasured(root.first) {
                 root.first.size = DifferentSize
                 delegate.requestRemeasure(root.first)
                 delegate.requestRelayout(root)
                 assertThat(delegate.measureAndLayout()).isTrue()
             }
         }
     }
 }