ui/ui-layout/src/androidTest/java/androidx/ui/layout/test/ConstraintLayoutTest.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.layout.test

 import androidx.test.filters.SmallTest
 import androidx.ui.core.Alignment
 import androidx.ui.core.Modifier
 import androidx.ui.core.Ref
 import androidx.ui.core.tag
 import androidx.ui.core.globalPosition
 import androidx.ui.core.onPositioned
 import androidx.ui.core.positionInParent
 import androidx.ui.foundation.Box
 import androidx.ui.layout.ConstrainScope
 import androidx.ui.layout.ConstraintLayout
 import androidx.ui.layout.ConstraintSet2
 import androidx.ui.layout.Dimension
 import androidx.ui.layout.ExperimentalLayout
 import androidx.ui.layout.aspectRatio
 import androidx.ui.layout.fillMaxSize
 import androidx.ui.layout.fillMaxWidth
 import androidx.ui.layout.preferredSize
 import androidx.ui.layout.preferredWidth
 import androidx.ui.layout.rtl
 import androidx.ui.layout.size
 import androidx.ui.layout.wrapContentSize
 import androidx.ui.test.createComposeRule
 import androidx.ui.test.runOnIdleCompose
 import androidx.ui.unit.IntPxSize
 import androidx.ui.unit.PxPosition
 import androidx.ui.unit.dp
 import androidx.ui.unit.ipx
 import org.junit.Assert
 import org.junit.Rule
 import org.junit.Test
 import org.junit.runner.RunWith
 import org.junit.runners.JUnit4

 @SmallTest
 @RunWith(JUnit4::class)
 @OptIn(ExperimentalLayout::class)
 class ConstraintLayoutTest : LayoutTest() {
     @get:Rule
     val composeTestRule = createComposeRule()

     // region sizing tests

     @Test
     fun dividerMatchTextHeight_spread() = with(density) {
         val aspectRatioBoxSize = Ref<IntPxSize>()
         val dividerSize = Ref<IntPxSize>()
         composeTestRule.setContent {
             ConstraintLayout(
                 // Make CL fixed width and wrap content height.
                 modifier = Modifier.wrapContentSize(Alignment.TopStart).fillMaxWidth()
             ) {
                 val (aspectRatioBox, divider) = createRefs()
                 val guideline = createGuidelineFromAbsoluteLeft(0.5f)

                 Box(Modifier
                     .constrainAs(aspectRatioBox) {
                         centerTo(parent)
                         start.linkTo(guideline)
                         width = Dimension.preferredWrapContent
                         height = Dimension.wrapContent
                     }
                     // Try to be large to make wrap content impossible.
                     .preferredWidth((composeTestRule.displayMetrics.widthPixels).ipx.toDp())
                     // This could be any (width in height out child) e.g. text
                     .aspectRatio(2f)
                     .onPositioned { coordinates ->
                         aspectRatioBoxSize.value = coordinates.size
                     }
                 )
                 Box(Modifier
                     .constrainAs(divider) {
                         centerTo(parent)
                         width = Dimension.value(1.dp)
                         height = Dimension.fillToConstraints
                     }.onPositioned { coordinates ->
                         dividerSize.value = coordinates.size
                     }
                 )
             }
         }

         runOnIdleCompose {
             // The aspect ratio could not wrap and it is wrap suggested, so it respects constraints.
             assertEquals(
                 (composeTestRule.displayMetrics.widthPixels / 2).ipx,
                 aspectRatioBoxSize.value!!.width
             )
             // Aspect ratio is preserved.
             assertEquals(
                 (composeTestRule.displayMetrics.widthPixels / 2 / 2).ipx,
                 aspectRatioBoxSize.value!!.height
             )
             // Divider has fixed width 1.dp in constraint set.
             assertEquals(1.dp.toIntPx(), dividerSize.value!!.width)
             // Divider has spread height so it should spread to fill the height of the CL,
             // which in turns is given by the size of the aspect ratio box.
             assertEquals(aspectRatioBoxSize.value!!.height, dividerSize.value!!.height)
         }
     }

     @Test
     fun dividerMatchTextHeight_percent() = with(density) {
         val aspectRatioBoxSize = Ref<IntPxSize>()
         val dividerSize = Ref<IntPxSize>()
         composeTestRule.setContent {
             ConstraintLayout(
                 // Make CL fixed width and wrap content height.
                 modifier = Modifier.wrapContentSize(Alignment.TopStart).fillMaxWidth()
             ) {
                 val (aspectRatioBox, divider) = createRefs()
                 val guideline = createGuidelineFromAbsoluteLeft(0.5f)

                 Box(Modifier
                     .constrainAs(aspectRatioBox) {
                         centerTo(parent)
                         start.linkTo(guideline)
                         width = Dimension.preferredWrapContent
                         height = Dimension.wrapContent
                     }
                     // Try to be large to make wrap content impossible.
                     .preferredWidth((composeTestRule.displayMetrics.widthPixels).ipx.toDp())
                     // This could be any (width in height out child) e.g. text
                     .aspectRatio(2f)
                     .onPositioned { coordinates ->
                         aspectRatioBoxSize.value = coordinates.size
                     }
                 )
                 Box(Modifier
                     .constrainAs(divider) {
                         centerTo(parent)
                         width = Dimension.value(1.dp)
                         height = Dimension.percent(0.8f)
                     }
                     .onPositioned { coordinates ->
                         dividerSize.value = coordinates.size
                     }
                 )
             }
         }

         runOnIdleCompose {
             // The aspect ratio could not wrap and it is wrap suggested, so it respects constraints.
             assertEquals(
                 (composeTestRule.displayMetrics.widthPixels / 2).ipx,
                 aspectRatioBoxSize.value!!.width
             )
             // Aspect ratio is preserved.
             assertEquals(
                 (composeTestRule.displayMetrics.widthPixels / 2 / 2).ipx,
                 aspectRatioBoxSize.value!!.height
             )
             // Divider has fixed width 1.dp in constraint set.
             assertEquals(1.dp.toIntPx(), dividerSize.value!!.width)
             // Divider has percent height so it should spread to fill 0.8 of the height of the CL,
             // which in turns is given by the size of the aspect ratio box.
             assertEquals(aspectRatioBoxSize.value!!.height * 0.8f, dividerSize.value!!.height)
         }
     }

     @Test
     fun dividerMatchTextHeight_inWrapConstraintLayout_longText() = with(density) {
         val aspectRatioBoxSize = Ref<IntPxSize>()
         val dividerSize = Ref<IntPxSize>()
         composeTestRule.setContent {
             ConstraintLayout(
                 // Make CL wrap width and height.
                 modifier = Modifier.wrapContentSize(Alignment.TopStart)
             ) {
                 val (aspectRatioBox, divider) = createRefs()
                 val guideline = createGuidelineFromAbsoluteLeft(0.5f)

                 Box(Modifier
                     .constrainAs(aspectRatioBox) {
                         centerTo(parent)
                         start.linkTo(guideline)
                         width = Dimension.preferredWrapContent
                         height = Dimension.wrapContent
                     }
                     // Try to be large to make wrap content impossible.
                     .preferredWidth((composeTestRule.displayMetrics.widthPixels).ipx.toDp())
                     // This could be any (width in height out child) e.g. text
                     .aspectRatio(2f)
                     .onPositioned { coordinates ->
                         aspectRatioBoxSize.value = coordinates.size
                     }
                 )
                 Box(Modifier
                     .constrainAs(divider) {
                         centerTo(parent)
                         width = Dimension.value(1.dp)
                         height = Dimension.percent(0.8f)
                     }
                     .onPositioned { coordinates ->
                         dividerSize.value = coordinates.size
                     }
                 )
             }
         }

         runOnIdleCompose {
             // The aspect ratio could not wrap and it is wrap suggested, so it respects constraints.
             assertEquals(
                 (composeTestRule.displayMetrics.widthPixels / 2).ipx,
                 aspectRatioBoxSize.value!!.width
             )
             // Aspect ratio is preserved.
             assertEquals(
                 (composeTestRule.displayMetrics.widthPixels / 2 / 2).ipx,
                 aspectRatioBoxSize.value!!.height
             )
             // Divider has fixed width 1.dp in constraint set.
             assertEquals(1.dp.toIntPx(), dividerSize.value!!.width)
             // Divider has percent height so it should spread to fill 0.8 of the height of the CL,
             // which in turns is given by the size of the aspect ratio box.
             // TODO(popam; b/150277566): uncomment
             assertEquals(aspectRatioBoxSize.value!!.height * 0.8f, dividerSize.value!!.height)
         }
     }

     @Test
     fun dividerMatchTextHeight_inWrapConstraintLayout_shortText() = with(density) {
         val constraintLayoutSize = Ref<IntPxSize>()
         val aspectRatioBoxSize = Ref<IntPxSize>()
         val dividerSize = Ref<IntPxSize>()
         val size = 40.ipx.toDp()
         composeTestRule.setContent {
             ConstraintLayout(
                 // Make CL wrap width and height.
                 modifier = Modifier.wrapContentSize(Alignment.TopStart).onPositioned {
                     constraintLayoutSize.value = it.size
                 }
             ) {
                 val (aspectRatioBox, divider) = createRefs()
                 val guideline = createGuidelineFromAbsoluteLeft(0.5f)

                 Box(Modifier
                     .constrainAs(aspectRatioBox) {
                         centerTo(parent)
                         start.linkTo(guideline)
                         width = Dimension.preferredWrapContent
                         height = Dimension.wrapContent
                     }
                     // Small width for the CL to wrap it.
                     .preferredWidth(size)
                     // This could be any (width in height out child) e.g. text
                     .aspectRatio(2f)
                     .onPositioned { coordinates ->
                         aspectRatioBoxSize.value = coordinates.size
                     }
                 )
                 Box(Modifier
                     .constrainAs(divider) {
                         centerTo(parent)
                         width = Dimension.value(1.dp)
                         height = Dimension.fillToConstraints
                     }
                     .onPositioned { coordinates ->
                         dividerSize.value = coordinates.size
                     }
                 )
             }
         }

         runOnIdleCompose {
             // The width of the ConstraintLayout should be twice the width of the aspect ratio box.
             assertEquals(size.toIntPx() * 2, constraintLayoutSize.value!!.width)
             // The height of the ConstraintLayout should be the height of the aspect ratio box.
             assertEquals(size.toIntPx() / 2, constraintLayoutSize.value!!.height)
             // The aspect ratio gets the requested size.
             assertEquals(size.toIntPx(), aspectRatioBoxSize.value!!.width)
             // Aspect ratio is preserved.
             assertEquals(size.toIntPx() / 2, aspectRatioBoxSize.value!!.height)
             // Divider has fixed width 1.dp in constraint set.
             assertEquals(1.dp.toIntPx(), dividerSize.value!!.width)
             // Divider should have the height of the aspect ratio box.
             assertEquals(aspectRatioBoxSize.value!!.height, dividerSize.value!!.height)
         }
     }

     // endregion

     // region positioning tests

     @Test
     fun testConstraintLayout_withInlineDSL() = with(density) {
         val boxSize = 100.ipx
         val offset = 150.ipx

         val position = Array(3) { Ref<PxPosition>() }

         composeTestRule.setContent {
             ConstraintLayout(Modifier.fillMaxSize()) {
                 val (box0, box1, box2) = createRefs()
                 Box(Modifier
                     .constrainAs(box0) {
                         centerTo(parent)
                     }
                     .preferredSize(boxSize.toDp(), boxSize.toDp())
                     .onPositioned {
                         position[0].value = it.globalPosition
                     }
                 )
                 val half = createGuidelineFromAbsoluteLeft(fraction = 0.5f)
                 Box(Modifier
                     .constrainAs(box1) {
                         start.linkTo(half, margin = offset.toDp())
                         bottom.linkTo(box0.top)
                     }
                     .preferredSize(boxSize.toDp(), boxSize.toDp())
                     .onPositioned {
                         position[1].value = it.globalPosition
                     }
                 )
                 Box(Modifier
                     .constrainAs(box2) {
                         start.linkTo(parent.start, margin = offset.toDp())
                         bottom.linkTo(parent.bottom, margin = offset.toDp())
                     }
                     .preferredSize(boxSize.toDp(), boxSize.toDp())
                     .onPositioned {
                         position[2].value = it.globalPosition
                     }
                 )
             }
         }

         val displayWidth = composeTestRule.displayMetrics.widthPixels.ipx
         val displayHeight = composeTestRule.displayMetrics.heightPixels.ipx

         runOnIdleCompose {
             assertEquals(
                 PxPosition((displayWidth - boxSize) / 2, (displayHeight - boxSize) / 2),
                 position[0].value
             )
             assertEquals(
                 PxPosition(displayWidth / 2 + offset, (displayHeight - boxSize) / 2 - boxSize),
                 position[1].value
             )
             assertEquals(
                 PxPosition(offset, displayHeight - boxSize - offset),
                 position[2].value
             )
         }
     }

     @Test
     fun testConstraintLayout_withConstraintSet() = with(density) {
         val boxSize = 100.ipx
         val offset = 150.ipx

         val position = Array(3) { Ref<PxPosition>() }

         composeTestRule.setContent {
             ConstraintLayout(
                 ConstraintSet2 {
                     val box0 = createRefFor("box0")
                     val box1 = createRefFor("box1")
                     val box2 = createRefFor("box2")

                     constrain(box0) {
                         centerTo(parent)
                     }

                     val half = createGuidelineFromAbsoluteLeft(fraction = 0.5f)
                     constrain(box1) {
                         start.linkTo(half, margin = offset.toDp())
                         bottom.linkTo(box0.top)
                     }

                     constrain(box2) {
                         start.linkTo(parent.start, margin = offset.toDp())
                         bottom.linkTo(parent.bottom, margin = offset.toDp())
                     }
                 },
                 Modifier.fillMaxSize()
             ) {
                 for (i in 0..2) {
                     Box(Modifier.tag("box$i").preferredSize(boxSize.toDp(), boxSize.toDp())
                         .onPositioned {
                             position[i].value = it.globalPosition
                         }
                     )
                 }
             }
         }

         val displayWidth = composeTestRule.displayMetrics.widthPixels.ipx
         val displayHeight = composeTestRule.displayMetrics.heightPixels.ipx

         runOnIdleCompose {
             assertEquals(
                 PxPosition((displayWidth - boxSize) / 2, (displayHeight - boxSize) / 2),
                 position[0].value
             )
             assertEquals(
                 PxPosition(displayWidth / 2 + offset, (displayHeight - boxSize) / 2 - boxSize),
                 position[1].value
             )
             assertEquals(
                 PxPosition(offset, displayHeight - boxSize - offset),
                 position[2].value
             )
         }
     }

     @Test
     fun testConstraintLayout_rtl() = with(density) {
         val boxSize = 100.ipx
         val offset = 150.ipx

         val position = Array(3) { Ref<PxPosition>() }

         composeTestRule.setContent {
             ConstraintLayout(Modifier.rtl.fillMaxSize()) {
                 val (box0, box1, box2) = createRefs()
                 Box(Modifier
                     .constrainAs(box0) {
                         centerTo(parent)
                     }
                     .preferredSize(boxSize.toDp(), boxSize.toDp())
                     .onPositioned {
                         position[0].value = it.globalPosition
                     }
                 )
                 val half = createGuidelineFromAbsoluteLeft(fraction = 0.5f)
                 Box(Modifier
                     .constrainAs(box1) {
                         start.linkTo(half, margin = offset.toDp())
                         bottom.linkTo(box0.top)
                     }
                     .preferredSize(boxSize.toDp(), boxSize.toDp())
                     .onPositioned {
                         position[1].value = it.globalPosition
                     }
                 )
                 Box(Modifier
                     .constrainAs(box2) {
                         start.linkTo(parent.start, margin = offset.toDp())
                         bottom.linkTo(parent.bottom, margin = offset.toDp())
                     }
                     .preferredSize(boxSize.toDp(), boxSize.toDp())
                     .onPositioned {
                         position[2].value = it.globalPosition
                     }
                 )
             }
         }

         val displayWidth = composeTestRule.displayMetrics.widthPixels.ipx
         val displayHeight = composeTestRule.displayMetrics.heightPixels.ipx

         runOnIdleCompose {
             assertEquals(
                 PxPosition((displayWidth - boxSize) / 2, (displayHeight - boxSize) / 2),
                 position[0].value
             )
             assertEquals(
                 PxPosition(
                     displayWidth / 2 - offset - boxSize,
                     (displayHeight - boxSize) / 2 - boxSize
                 ),
                 position[1].value
             )
             assertEquals(
                 PxPosition(displayWidth - offset - boxSize, displayHeight - boxSize - offset),
                 position[2].value
             )
         }
     }

     @Test
     fun testConstraintLayout_helpers_ltr() = with(density) {
         val size = 200.ipx.toDp()
         val offset = 50.ipx.toDp()

         val position = Array(8) { 0f }
         composeTestRule.setContent {
             ConstraintLayout(Modifier.size(size)) {
                 val guidelines = arrayOf(
                     createGuidelineFromStart(offset),
                     createGuidelineFromAbsoluteLeft(offset),
                     createGuidelineFromEnd(offset),
                     createGuidelineFromAbsoluteRight(offset),
                     createGuidelineFromStart(0.25f),
                     createGuidelineFromAbsoluteLeft(0.25f),
                     createGuidelineFromEnd(0.25f),
                     createGuidelineFromAbsoluteRight(0.25f)
                 )

                 guidelines.forEachIndexed { index, guideline ->
                     val ref = createRef()
                     Box(Modifier.size(1.dp)
                         .constrainAs(ref) {
                             absoluteLeft.linkTo(guideline)
                         }.onPositioned {
                             position[index] = it.positionInParent.x
                         }
                     )
                 }
             }
         }

         runOnIdleCompose {
             Assert.assertEquals(50f, position[0])
             Assert.assertEquals(50f, position[1])
             Assert.assertEquals(150f, position[2])
             Assert.assertEquals(150f, position[3])
             Assert.assertEquals(50f, position[4])
             Assert.assertEquals(50f, position[5])
             Assert.assertEquals(150f, position[6])
             Assert.assertEquals(150f, position[7])
         }
     }

     @Test
     fun testConstraintLayout_helpers_rtl() = with(density) {
         val size = 200.ipx.toDp()
         val offset = 50.ipx.toDp()

         val position = Array(8) { 0f }
         composeTestRule.setContent {
             ConstraintLayout(Modifier.size(size).rtl) {
                 val guidelines = arrayOf(
                     createGuidelineFromStart(offset),
                     createGuidelineFromAbsoluteLeft(offset),
                     createGuidelineFromEnd(offset),
                     createGuidelineFromAbsoluteRight(offset),
                     createGuidelineFromStart(0.25f),
                     createGuidelineFromAbsoluteLeft(0.25f),
                     createGuidelineFromEnd(0.25f),
                     createGuidelineFromAbsoluteRight(0.25f)
                 )

                 guidelines.forEachIndexed { index, guideline ->
                     val ref = createRef()
                     Box(Modifier.size(1.dp)
                         .constrainAs(ref) {
                             absoluteLeft.linkTo(guideline)
                         }.onPositioned {
                             position[index] = it.positionInParent.x
                         }
                     )
                 }
             }
         }

         runOnIdleCompose {
             Assert.assertEquals(150f, position[0])
             Assert.assertEquals(50f, position[1])
             Assert.assertEquals(50f, position[2])
             Assert.assertEquals(150f, position[3])
             Assert.assertEquals(150f, position[4])
             Assert.assertEquals(50f, position[5])
             Assert.assertEquals(50f, position[6])
             Assert.assertEquals(150f, position[7])
         }
     }

     @Test
     fun testConstraintLayout_barriers_ltr() = with(density) {
         val size = 200.ipx.toDp()
         val offset = 50.ipx.toDp()

         val position = Array(4) { 0f }
         composeTestRule.setContent {
             ConstraintLayout(Modifier.size(size)) {
                 val (box1, box2) = createRefs()
                 val guideline1 = createGuidelineFromAbsoluteLeft(offset)
                 val guideline2 = createGuidelineFromAbsoluteRight(offset)
                 Box(Modifier.size(1.ipx.toDp())
                     .constrainAs(box1) {
                         absoluteLeft.linkTo(guideline1)
                     }
                 )
                 Box(Modifier.size(1.ipx.toDp())
                     .constrainAs(box2) {
                         absoluteLeft.linkTo(guideline2)
                     }
                 )

                 val barriers = arrayOf(
                     createStartBarrier(box1, box2),
                     createAbsoluteLeftBarrier(box1, box2),
                     createEndBarrier(box1, box2),
                     createAbsoluteRightBarrier(box1, box2)
                 )

                 barriers.forEachIndexed { index, barrier ->
                     val ref = createRef()
                     Box(Modifier.size(1.dp)
                         .constrainAs(ref) {
                             absoluteLeft.linkTo(barrier)
                         }.onPositioned {
                             position[index] = it.positionInParent.x
                         }
                     )
                 }
             }
         }

         runOnIdleCompose {
             Assert.assertEquals(50f, position[0])
             Assert.assertEquals(50f, position[1])
             Assert.assertEquals(151f, position[2])
             Assert.assertEquals(151f, position[3])
         }
     }

     @Test
     fun testConstraintLayout_barriers_rtl() = with(density) {
         val size = 200.ipx.toDp()
         val offset = 50.ipx.toDp()

         val position = Array(4) { 0f }
         composeTestRule.setContent {
             ConstraintLayout(Modifier.size(size).rtl) {
                 val (box1, box2) = createRefs()
                 val guideline1 = createGuidelineFromAbsoluteLeft(offset)
                 val guideline2 = createGuidelineFromAbsoluteRight(offset)
                 Box(Modifier.size(1.ipx.toDp())
                     .constrainAs(box1) {
                         absoluteLeft.linkTo(guideline1)
                     }
                 )
                 Box(Modifier.size(1.ipx.toDp())
                     .constrainAs(box2) {
                         absoluteLeft.linkTo(guideline2)
                     }
                 )

                 val barriers = arrayOf(
                     createStartBarrier(box1, box2),
                     createAbsoluteLeftBarrier(box1, box2),
                     createEndBarrier(box1, box2),
                     createAbsoluteRightBarrier(box1, box2)
                 )

                 barriers.forEachIndexed { index, barrier ->
                     val ref = createRef()
                     Box(Modifier.size(1.dp)
                         .constrainAs(ref) {
                             absoluteLeft.linkTo(barrier)
                         }.onPositioned {
                             position[index] = it.positionInParent.x
                         }
                     )
                 }
             }
         }

         runOnIdleCompose {
             Assert.assertEquals(151f, position[0])
             Assert.assertEquals(50f, position[1])
             Assert.assertEquals(50f, position[2])
             Assert.assertEquals(151f, position[3])
         }
     }

     @Test
     fun testConstraintLayout_anchors_ltr() = with(density) {
         val size = 200.ipx.toDp()
         val offset = 50.ipx.toDp()

         val position = Array(16) { 0f }
         composeTestRule.setContent {
             ConstraintLayout(Modifier.size(size)) {
                 val box = createRef()
                 val guideline = createGuidelineFromAbsoluteLeft(offset)
                 Box(Modifier.size(1.ipx.toDp())
                     .constrainAs(box) {
                         absoluteLeft.linkTo(guideline)
                     }
                 )

                 val anchors = listOf<ConstrainScope.() -> Unit>(
                     { start.linkTo(box.start) },
                     { absoluteLeft.linkTo(box.start) },
                     { start.linkTo(box.absoluteLeft) },
                     { absoluteLeft.linkTo(box.absoluteLeft) },
                     { end.linkTo(box.start) },
                     { absoluteRight.linkTo(box.start) },
                     { end.linkTo(box.absoluteLeft) },
                     { absoluteRight.linkTo(box.absoluteLeft) },
                     { start.linkTo(box.end) },
                     { absoluteLeft.linkTo(box.end) },
                     { start.linkTo(box.absoluteRight) },
                     { absoluteLeft.linkTo(box.absoluteRight) },
                     { end.linkTo(box.end) },
                     { absoluteRight.linkTo(box.end) },
                     { end.linkTo(box.absoluteRight) },
                     { absoluteRight.linkTo(box.absoluteRight) }
                 )

                 anchors.forEachIndexed { index, anchor ->
                     val ref = createRef()
                     Box(Modifier.size(1.ipx.toDp())
                         .constrainAs(ref) {
                             anchor()
                         }.onPositioned {
                             position[index] = it.positionInParent.x
                         }
                     )
                 }
             }
         }

         runOnIdleCompose {
             Assert.assertEquals(50f, position[0])
             Assert.assertEquals(50f, position[1])
             Assert.assertEquals(50f, position[2])
             Assert.assertEquals(50f, position[3])
             Assert.assertEquals(49f, position[4])
             Assert.assertEquals(49f, position[5])
             Assert.assertEquals(49f, position[6])
             Assert.assertEquals(49f, position[7])
             Assert.assertEquals(51f, position[8])
             Assert.assertEquals(51f, position[9])
             Assert.assertEquals(51f, position[10])
             Assert.assertEquals(51f, position[11])
             Assert.assertEquals(50f, position[12])
             Assert.assertEquals(50f, position[13])
             Assert.assertEquals(50f, position[14])
             Assert.assertEquals(50f, position[15])
         }
     }

     @Test
     fun testConstraintLayout_anchors_rtl() = with(density) {
         val size = 200.ipx.toDp()
         val offset = 50.ipx.toDp()

         val position = Array(16) { 0f }
         composeTestRule.setContent {
             ConstraintLayout(Modifier.size(size).rtl) {
                 val box = createRef()
                 val guideline = createGuidelineFromAbsoluteLeft(offset)
                 Box(Modifier.size(1.ipx.toDp())
                     .constrainAs(box) {
                         absoluteLeft.linkTo(guideline)
                     }
                 )

                 val anchors = listOf<ConstrainScope.() -> Unit>(
                     { start.linkTo(box.start) },
                     { absoluteLeft.linkTo(box.start) },
                     { start.linkTo(box.absoluteLeft) },
                     { absoluteLeft.linkTo(box.absoluteLeft) },
                     { end.linkTo(box.start) },
                     { absoluteRight.linkTo(box.start) },
                     { end.linkTo(box.absoluteLeft) },
                     { absoluteRight.linkTo(box.absoluteLeft) },
                     { start.linkTo(box.end) },
                     { absoluteLeft.linkTo(box.end) },
                     { start.linkTo(box.absoluteRight) },
                     { absoluteLeft.linkTo(box.absoluteRight) },
                     { end.linkTo(box.end) },
                     { absoluteRight.linkTo(box.end) },
                     { end.linkTo(box.absoluteRight) },
                     { absoluteRight.linkTo(box.absoluteRight) }
                 )

                 anchors.forEachIndexed { index, anchor ->
                     val ref = createRef()
                     Box(Modifier.size(1.ipx.toDp())
                         .constrainAs(ref) {
                             anchor()
                         }.onPositioned {
                             position[index] = it.positionInParent.x
                         }
                     )
                 }
             }
         }

         runOnIdleCompose {
             Assert.assertEquals(50f, position[0])
             Assert.assertEquals(51f, position[1])
             Assert.assertEquals(49f, position[2])
             Assert.assertEquals(50f, position[3])
             Assert.assertEquals(51f, position[4])
             Assert.assertEquals(50f, position[5])
             Assert.assertEquals(50f, position[6])
             Assert.assertEquals(49f, position[7])
             Assert.assertEquals(49f, position[8])
             Assert.assertEquals(50f, position[9])
             Assert.assertEquals(50f, position[10])
             Assert.assertEquals(51f, position[11])
             Assert.assertEquals(50f, position[12])
             Assert.assertEquals(49f, position[13])
             Assert.assertEquals(51f, position[14])
             Assert.assertEquals(50f, position[15])
         }
     }

     @Test
     fun testConstraintLayout_barriers_margins() = with(density) {
         val size = 200.ipx.toDp()
         val offset = 50.ipx.toDp()

         val position = Array(2) { PxPosition(0f, 0f) }
         composeTestRule.setContent {
             ConstraintLayout(Modifier.size(size)) {
                 val box = createRef()
                 val guideline1 = createGuidelineFromAbsoluteLeft(offset)
                 val guideline2 = createGuidelineFromTop(offset)
                 Box(Modifier.size(1.ipx.toDp())
                     .constrainAs(box) {
                         absoluteLeft.linkTo(guideline1)
                         top.linkTo(guideline2)
                     }
                 )

                 val leftBarrier = createAbsoluteLeftBarrier(box, margin = 10.ipx.toDp())
                 val topBarrier = createTopBarrier(box, margin = 10.ipx.toDp())
                 val rightBarrier = createAbsoluteRightBarrier(box, margin = 10.ipx.toDp())
                 val bottomBarrier = createBottomBarrier(box, margin = 10.ipx.toDp())

                 Box(Modifier.size(1.dp)
                     .constrainAs(createRef()) {
                         absoluteLeft.linkTo(leftBarrier)
                         top.linkTo(topBarrier)
                     }.onPositioned {
                         position[0] = it.positionInParent
                     }
                 )

                 Box(Modifier.size(1.dp)
                     .constrainAs(createRef()) {
                         absoluteLeft.linkTo(rightBarrier)
                         top.linkTo(bottomBarrier)
                     }.onPositioned {
                         position[1] = it.positionInParent
                     }
                 )
             }
         }

         runOnIdleCompose {
             Assert.assertEquals(PxPosition(60f, 60f), position[0])
             Assert.assertEquals(PxPosition(61f, 61f), position[1])
         }
     }
 }