Define offsets in lazy animate item placement tests in floats
It makes the test results more reliable. There are multiple ways to define an offset based on the fraction. First one is
startPosition + ((endPosition - startPosition) * fraction).roundToInt()
And the second one is:
endPosition - ((endPosition - startPosition) * fraction).roundToInt()
Lets say startPosition is 0 and startPosition is 9. Then for the first expression we have
0 + ((9 - 0) * 0.5).roundToInt() = 4.5.roundToInt() = 5
And for the second one we have
9 - ((9 - 0) * 0.5).roundToInt() = 9 - 4.5.roundToInt() = 9 - 5 = 4
But if instead we will be using floats for calculations and only round the result to int right before doing the assertion both expressions will produce 4.5f which we round to 5.
Test: run those tests
Change-Id: I9e590a066b2e41b6e00a293e7a7fcde09a312b69
diff --git a/compose/foundation/foundation/src/androidAndroidTest/kotlin/androidx/compose/foundation/lazy/grid/LazyGridAnimateItemPlacementTest.kt b/compose/foundation/foundation/src/androidAndroidTest/kotlin/androidx/compose/foundation/lazy/grid/LazyGridAnimateItemPlacementTest.kt
index 587736a..e30dfef 100644
--- a/compose/foundation/foundation/src/androidAndroidTest/kotlin/androidx/compose/foundation/lazy/grid/LazyGridAnimateItemPlacementTest.kt
+++ b/compose/foundation/foundation/src/androidAndroidTest/kotlin/androidx/compose/foundation/lazy/grid/LazyGridAnimateItemPlacementTest.kt
@@ -35,6 +35,7 @@
import androidx.compose.runtime.setValue
import androidx.compose.runtime.snapshotFlow
import androidx.compose.ui.Modifier
+import androidx.compose.ui.geometry.Offset
import androidx.compose.ui.platform.testTag
import androidx.compose.ui.test.SemanticsNodeInteraction
import androidx.compose.ui.test.assertHeightIsEqualTo
@@ -50,6 +51,7 @@
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.height
import androidx.compose.ui.unit.isSpecified
+import androidx.compose.ui.unit.round
import androidx.compose.ui.unit.width
import androidx.test.filters.LargeTest
import com.google.common.truth.Truth.assertThat
@@ -73,15 +75,15 @@
@get:Rule
val rule = createComposeRule()
- private val itemSize: Int = 50
+ private val itemSize: Float = 50f
private var itemSizeDp: Dp = Dp.Infinity
- private val itemSize2: Int = 30
+ private val itemSize2: Float = 30f
private var itemSize2Dp: Dp = Dp.Infinity
- private val itemSize3: Int = 20
+ private val itemSize3: Float = 20f
private var itemSize3Dp: Dp = Dp.Infinity
- private val containerSize: Int = itemSize * 5
+ private val containerSize: Float = itemSize * 5
private var containerSizeDp: Dp = Dp.Infinity
- private val spacing: Int = 10
+ private val spacing: Float = 10f
private var spacingDp: Dp = Dp.Infinity
private val itemSizePlusSpacing = itemSize + spacing
private var itemSizePlusSpacingDp = Dp.Infinity
@@ -112,8 +114,8 @@
}
assertPositions(
- 0 to AxisIntOffset(0, 0),
- 1 to AxisIntOffset(0, itemSize)
+ 0 to AxisOffset(0f, 0f),
+ 1 to AxisOffset(0f, itemSize)
)
rule.runOnIdle {
@@ -122,8 +124,8 @@
onAnimationFrame { fraction ->
assertPositions(
- 0 to AxisIntOffset(0, 0 + (itemSize * fraction).roundToInt()),
- 1 to AxisIntOffset(0, itemSize - (itemSize * fraction).roundToInt()),
+ 0 to AxisOffset(0f, 0f + itemSize * fraction),
+ 1 to AxisOffset(0f, itemSize - itemSize * fraction),
fraction = fraction
)
}
@@ -141,10 +143,10 @@
}
assertPositions(
- 0 to AxisIntOffset(0, 0),
- 1 to AxisIntOffset(itemSize, 0),
- 2 to AxisIntOffset(0, itemSize),
- 3 to AxisIntOffset(itemSize, itemSize)
+ 0 to AxisOffset(0f, 0f),
+ 1 to AxisOffset(itemSize, 0f),
+ 2 to AxisOffset(0f, itemSize),
+ 3 to AxisOffset(itemSize, itemSize)
)
rule.runOnIdle {
@@ -152,13 +154,13 @@
}
onAnimationFrame { fraction ->
- val increasing = 0 + (itemSize * fraction).roundToInt()
- val decreasing = itemSize - (itemSize * fraction).roundToInt()
+ val increasing = 0 + itemSize * fraction
+ val decreasing = itemSize - itemSize * fraction
assertPositions(
- 0 to AxisIntOffset(increasing, increasing),
- 1 to AxisIntOffset(decreasing, increasing),
- 2 to AxisIntOffset(increasing, decreasing),
- 3 to AxisIntOffset(decreasing, decreasing),
+ 0 to AxisOffset(increasing, increasing),
+ 1 to AxisOffset(decreasing, increasing),
+ 2 to AxisOffset(increasing, decreasing),
+ 3 to AxisOffset(decreasing, decreasing),
fraction = fraction
)
}
@@ -176,10 +178,10 @@
}
assertLayoutInfoPositions(
- 0 to AxisIntOffset(0, 0),
- 1 to AxisIntOffset(itemSize, 0),
- 2 to AxisIntOffset(0, itemSize),
- 3 to AxisIntOffset(itemSize, itemSize)
+ 0 to AxisOffset(0f, 0f),
+ 1 to AxisOffset(itemSize, 0f),
+ 2 to AxisOffset(0f, itemSize),
+ 3 to AxisOffset(itemSize, itemSize)
)
rule.runOnIdle {
@@ -189,10 +191,10 @@
onAnimationFrame {
// fraction doesn't affect the offsets in layout info
assertLayoutInfoPositions(
- 3 to AxisIntOffset(0, 0),
- 2 to AxisIntOffset(itemSize, 0),
- 1 to AxisIntOffset(0, itemSize),
- 0 to AxisIntOffset(itemSize, itemSize)
+ 3 to AxisOffset(0f, 0f),
+ 2 to AxisOffset(itemSize, 0f),
+ 1 to AxisOffset(0f, itemSize),
+ 0 to AxisOffset(itemSize, itemSize)
)
}
}
@@ -209,11 +211,11 @@
}
assertPositions(
- 0 to AxisIntOffset(0, 0),
- 1 to AxisIntOffset(0, itemSize),
- 2 to AxisIntOffset(0, itemSize * 2),
- 3 to AxisIntOffset(0, itemSize * 3),
- 4 to AxisIntOffset(0, itemSize * 4)
+ 0 to AxisOffset(0f, 0f),
+ 1 to AxisOffset(0f, itemSize),
+ 2 to AxisOffset(0f, itemSize * 2),
+ 3 to AxisOffset(0f, itemSize * 3),
+ 4 to AxisOffset(0f, itemSize * 4)
)
rule.runOnIdle {
@@ -222,11 +224,11 @@
onAnimationFrame { fraction ->
assertPositions(
- 0 to AxisIntOffset(0, 0 + (itemSize * 4 * fraction).roundToInt()),
- 1 to AxisIntOffset(0, itemSize),
- 2 to AxisIntOffset(0, itemSize * 2),
- 3 to AxisIntOffset(0, itemSize * 3),
- 4 to AxisIntOffset(0, itemSize * 4 - (itemSize * 4 * fraction).roundToInt()),
+ 0 to AxisOffset(0f, 0f + itemSize * 4 * fraction),
+ 1 to AxisOffset(0f, itemSize),
+ 2 to AxisOffset(0f, itemSize * 2),
+ 3 to AxisOffset(0f, itemSize * 3),
+ 4 to AxisOffset(0f, itemSize * 4 - itemSize * 4 * fraction),
fraction = fraction
)
}
@@ -244,12 +246,12 @@
}
assertPositions(
- 0 to AxisIntOffset(0, 0),
- 1 to AxisIntOffset(itemSize, 0),
- 2 to AxisIntOffset(0, itemSize),
- 3 to AxisIntOffset(itemSize, itemSize),
- 4 to AxisIntOffset(0, itemSize * 2),
- 5 to AxisIntOffset(itemSize, itemSize * 2)
+ 0 to AxisOffset(0f, 0f),
+ 1 to AxisOffset(itemSize, 0f),
+ 2 to AxisOffset(0f, itemSize),
+ 3 to AxisOffset(itemSize, itemSize),
+ 4 to AxisOffset(0f, itemSize * 2),
+ 5 to AxisOffset(itemSize, itemSize * 2)
)
rule.runOnIdle {
@@ -257,15 +259,15 @@
}
onAnimationFrame { fraction ->
- val increasingX = 0 + (itemSize * fraction).roundToInt()
- val decreasingX = itemSize - (itemSize * fraction).roundToInt()
+ val increasingX = 0 + itemSize * fraction
+ val decreasingX = itemSize - itemSize * fraction
assertPositions(
- 0 to AxisIntOffset(increasingX, 0 + (itemSize * 2 * fraction).roundToInt()),
- 1 to AxisIntOffset(decreasingX, 0),
- 2 to AxisIntOffset(increasingX, itemSize - (itemSize * fraction).roundToInt()),
- 3 to AxisIntOffset(decreasingX, itemSize),
- 4 to AxisIntOffset(increasingX, itemSize * 2 - (itemSize * fraction).roundToInt()),
- 5 to AxisIntOffset(decreasingX, itemSize * 2),
+ 0 to AxisOffset(increasingX, 0f + itemSize * 2 * fraction),
+ 1 to AxisOffset(decreasingX, 0f),
+ 2 to AxisOffset(increasingX, itemSize - itemSize * fraction),
+ 3 to AxisOffset(decreasingX, itemSize),
+ 4 to AxisOffset(increasingX, itemSize * 2 - itemSize * fraction),
+ 5 to AxisOffset(decreasingX, itemSize * 2),
fraction = fraction
)
}
@@ -292,10 +294,10 @@
onAnimationFrame { fraction ->
assertPositions(
- 0 to AxisIntOffset(0, 0),
- 1 to AxisIntOffset(0, itemSize),
- 2 to AxisIntOffset(0, itemSize * 2 + (itemSize * fraction).roundToInt()),
- 3 to AxisIntOffset(0, itemSize * 3 + (itemSize * fraction).roundToInt()),
+ 0 to AxisOffset(0f, 0f),
+ 1 to AxisOffset(0f, itemSize),
+ 2 to AxisOffset(0f, itemSize * 2 + itemSize * fraction),
+ 3 to AxisOffset(0f, itemSize * 3 + itemSize * fraction),
fraction = fraction
)
}
@@ -318,11 +320,11 @@
onAnimationFrame { fraction ->
assertPositions(
- 0 to AxisIntOffset(0, itemSize * 4),
- 1 to AxisIntOffset(0, itemSize - (itemSize * fraction).roundToInt()),
- 2 to AxisIntOffset(0, itemSize),
- 3 to AxisIntOffset(0, itemSize * 3 - (itemSize * fraction).roundToInt()),
- 4 to AxisIntOffset(0, itemSize * 3),
+ 0 to AxisOffset(0f, itemSize * 4),
+ 1 to AxisOffset(0f, itemSize - itemSize * fraction),
+ 2 to AxisOffset(0f, itemSize),
+ 3 to AxisOffset(0f, itemSize * 3 - itemSize * fraction),
+ 4 to AxisOffset(0f, itemSize * 3),
fraction = fraction
)
}
@@ -347,11 +349,11 @@
onAnimationFrame(duration = Duration * 2) { fraction ->
val shorterAnimFraction = (fraction * 2).coerceAtMost(1f)
assertPositions(
- 0 to AxisIntOffset(0, 0 + (itemSize * 4 * shorterAnimFraction).roundToInt()),
- 1 to AxisIntOffset(0, itemSize - (itemSize * fraction).roundToInt()),
- 2 to AxisIntOffset(0, itemSize * 2 - (itemSize * shorterAnimFraction).roundToInt()),
- 3 to AxisIntOffset(0, itemSize * 3 - (itemSize * fraction).roundToInt()),
- 4 to AxisIntOffset(0, itemSize * 4 - (itemSize * shorterAnimFraction).roundToInt()),
+ 0 to AxisOffset(0f, 0 + itemSize * 4 * shorterAnimFraction),
+ 1 to AxisOffset(0f, itemSize - itemSize * fraction),
+ 2 to AxisOffset(0f, itemSize * 2 - itemSize * shorterAnimFraction),
+ 3 to AxisOffset(0f, itemSize * 3 - itemSize * fraction),
+ 4 to AxisOffset(0f, itemSize * 4 - itemSize * shorterAnimFraction),
fraction = fraction
)
}
@@ -370,10 +372,10 @@
}
assertPositions(
- 0 to AxisIntOffset(0, 0),
- 1 to AxisIntOffset(0, 0),
- 2 to AxisIntOffset(0, itemSize),
- 3 to AxisIntOffset(0, itemSize)
+ 0 to AxisOffset(0f, 0f),
+ 1 to AxisOffset(0f, 0f),
+ 2 to AxisOffset(0f, itemSize),
+ 3 to AxisOffset(0f, itemSize)
)
rule.runOnIdle {
@@ -382,10 +384,10 @@
onAnimationFrame { fraction ->
assertPositions(
- 0 to AxisIntOffset(0, 0 + (itemSize * fraction).roundToInt()),
- 1 to AxisIntOffset(0, 0 + (itemSize * fraction).roundToInt()),
- 2 to AxisIntOffset(0, itemSize - (itemSize * fraction).roundToInt()),
- 3 to AxisIntOffset(0, itemSize - (itemSize * fraction).roundToInt()),
+ 0 to AxisOffset(0f, 0 + itemSize * fraction),
+ 1 to AxisOffset(0f, 0 + itemSize * fraction),
+ 2 to AxisOffset(0f, itemSize - itemSize * fraction),
+ 3 to AxisOffset(0f, itemSize - itemSize * fraction),
fraction = fraction
)
}
@@ -409,10 +411,10 @@
onAnimationFrame { fraction ->
assertPositions(
- 0 to AxisIntOffset(0, 0 + (itemSize * fraction).roundToInt()),
- 1 to AxisIntOffset(0, itemSize),
- 2 to AxisIntOffset(0, itemSize - (itemSize * fraction).roundToInt()),
- 3 to AxisIntOffset(0, 0),
+ 0 to AxisOffset(0f, 0 + itemSize * fraction),
+ 1 to AxisOffset(0f, itemSize),
+ 2 to AxisOffset(0f, itemSize - itemSize * fraction),
+ 3 to AxisOffset(0f, 0f),
fraction = fraction
)
}
@@ -435,9 +437,9 @@
}
assertPositions(
- 1 to AxisIntOffset(0, itemSize),
- 2 to AxisIntOffset(0, itemSize * 2),
- 3 to AxisIntOffset(0, itemSize * 3),
+ 1 to AxisOffset(0f, itemSize),
+ 2 to AxisOffset(0f, itemSize * 2),
+ 3 to AxisOffset(0f, itemSize * 3),
)
rule.runOnIdle {
@@ -447,9 +449,9 @@
onAnimationFrame { fraction ->
assertPositions(
- 1 to AxisIntOffset(0, itemSize - (itemSize * fraction).roundToInt()),
- 2 to AxisIntOffset(0, itemSize * 2),
- 3 to AxisIntOffset(0, itemSize * 3 + (itemSize * fraction).roundToInt()),
+ 1 to AxisOffset(0f, itemSize - itemSize * fraction),
+ 2 to AxisOffset(0f, itemSize * 2),
+ 3 to AxisOffset(0f, itemSize * 3 + itemSize * fraction),
fraction = fraction
)
}
@@ -469,12 +471,12 @@
}
assertPositions(
- 0 to AxisIntOffset(0, 0),
- 1 to AxisIntOffset(itemSize, 0),
- 2 to AxisIntOffset(0, itemSize),
- 3 to AxisIntOffset(itemSize, itemSize),
- 4 to AxisIntOffset(0, itemSize * 2),
- 5 to AxisIntOffset(itemSize, itemSize * 2)
+ 0 to AxisOffset(0f, 0f),
+ 1 to AxisOffset(itemSize, 0f),
+ 2 to AxisOffset(0f, itemSize),
+ 3 to AxisOffset(itemSize, itemSize),
+ 4 to AxisOffset(0f, itemSize * 2),
+ 5 to AxisOffset(itemSize, itemSize * 2)
)
rule.runOnIdle {
@@ -483,20 +485,20 @@
onAnimationFrame { fraction ->
// item 1 moves to and item 8 moves from `gridSize`, right after the end edge
- val item1Offset = AxisIntOffset(itemSize, 0 + (gridSize * fraction).roundToInt())
+ val item1Offset = AxisOffset(itemSize, 0 + gridSize * fraction)
val item8Offset =
- AxisIntOffset(itemSize, gridSize - (gridSize * fraction).roundToInt())
- val expected = mutableListOf<Pair<Any, IntOffset>>().apply {
- add(0 to AxisIntOffset(0, 0))
+ AxisOffset(itemSize, gridSize - gridSize * fraction)
+ val expected = mutableListOf<Pair<Any, Offset>>().apply {
+ add(0 to AxisOffset(0f, 0f))
if (item1Offset.mainAxis < itemSize * 3) {
add(1 to item1Offset)
} else {
rule.onNodeWithTag("1").assertIsNotDisplayed()
}
- add(2 to AxisIntOffset(0, itemSize))
- add(3 to AxisIntOffset(itemSize, itemSize))
- add(4 to AxisIntOffset(0, itemSize * 2))
- add(5 to AxisIntOffset(itemSize, itemSize * 2))
+ add(2 to AxisOffset(0f, itemSize))
+ add(3 to AxisOffset(itemSize, itemSize))
+ add(4 to AxisOffset(0f, itemSize * 2))
+ add(5 to AxisOffset(itemSize, itemSize * 2))
if (item8Offset.mainAxis < itemSize * 3) {
add(8 to item8Offset)
} else {
@@ -522,12 +524,12 @@
}
assertPositions(
- 6 to AxisIntOffset(0, 0),
- 7 to AxisIntOffset(itemSize, 0),
- 8 to AxisIntOffset(0, itemSize),
- 9 to AxisIntOffset(itemSize, itemSize),
- 10 to AxisIntOffset(0, itemSize * 2),
- 11 to AxisIntOffset(itemSize, itemSize * 2)
+ 6 to AxisOffset(0f, 0f),
+ 7 to AxisOffset(itemSize, 0f),
+ 8 to AxisOffset(0f, itemSize),
+ 9 to AxisOffset(itemSize, itemSize),
+ 10 to AxisOffset(0f, itemSize * 2),
+ 11 to AxisOffset(itemSize, itemSize * 2)
)
rule.runOnIdle {
@@ -536,27 +538,24 @@
onAnimationFrame { fraction ->
// item 1 moves from and item 8 moves to `0 - itemSize`, right before the start edge
- val item8Offset = AxisIntOffset(0, itemSize - (itemSize * 2 * fraction).roundToInt())
- val item1Offset = AxisIntOffset(
- 0,
- -itemSize + (itemSize * 2 * fraction).roundToInt()
- )
- val expected = mutableListOf<Pair<Any, IntOffset>>().apply {
+ val item8Offset = AxisOffset(0f, itemSize - itemSize * 2 * fraction)
+ val item1Offset = AxisOffset(0f, -itemSize + itemSize * 2 * fraction)
+ val expected = mutableListOf<Pair<Any, Offset>>().apply {
if (item1Offset.mainAxis > -itemSize) {
add(1 to item1Offset)
} else {
rule.onNodeWithTag("1").assertIsNotDisplayed()
}
- add(6 to AxisIntOffset(0, 0))
- add(7 to AxisIntOffset(itemSize, 0))
+ add(6 to AxisOffset(0f, 0f))
+ add(7 to AxisOffset(itemSize, 0f))
if (item8Offset.mainAxis > -itemSize) {
add(8 to item8Offset)
} else {
rule.onNodeWithTag("8").assertIsNotDisplayed()
}
- add(9 to AxisIntOffset(itemSize, itemSize))
- add(10 to AxisIntOffset(0, itemSize * 2))
- add(11 to AxisIntOffset(itemSize, itemSize * 2))
+ add(9 to AxisOffset(itemSize, itemSize))
+ add(10 to AxisOffset(0f, itemSize * 2))
+ add(11 to AxisOffset(itemSize, itemSize * 2))
}
assertPositions(
expected = expected.toTypedArray(),
@@ -581,26 +580,26 @@
}
onAnimationFrame { fraction ->
- val increasingX = (fraction * itemSize).roundToInt()
- val decreasingX = (itemSize - itemSize * fraction).roundToInt()
+ val increasingX = fraction * itemSize
+ val decreasingX = itemSize - itemSize * fraction
assertPositions(
- 0 to AxisIntOffset(increasingX, (itemSizePlusSpacing * 3 * fraction).roundToInt()),
- 1 to AxisIntOffset(decreasingX, 0),
- 2 to AxisIntOffset(
+ 0 to AxisOffset(increasingX, itemSizePlusSpacing * 3 * fraction),
+ 1 to AxisOffset(decreasingX, 0f),
+ 2 to AxisOffset(
increasingX,
- itemSizePlusSpacing - (itemSizePlusSpacing * fraction).roundToInt()
+ itemSizePlusSpacing - itemSizePlusSpacing * fraction
),
- 3 to AxisIntOffset(decreasingX, itemSizePlusSpacing),
- 4 to AxisIntOffset(
+ 3 to AxisOffset(decreasingX, itemSizePlusSpacing),
+ 4 to AxisOffset(
increasingX,
- itemSizePlusSpacing * 2 - (itemSizePlusSpacing * fraction).roundToInt()
+ itemSizePlusSpacing * 2 - itemSizePlusSpacing * fraction
),
- 5 to AxisIntOffset(decreasingX, itemSizePlusSpacing * 2),
- 6 to AxisIntOffset(
+ 5 to AxisOffset(decreasingX, itemSizePlusSpacing * 2),
+ 6 to AxisOffset(
increasingX,
- itemSizePlusSpacing * 3 - (itemSizePlusSpacing * fraction).roundToInt()
+ itemSizePlusSpacing * 3 - itemSizePlusSpacing * fraction
),
- 7 to AxisIntOffset(decreasingX, itemSizePlusSpacing * 3),
+ 7 to AxisOffset(decreasingX, itemSizePlusSpacing * 3),
fraction = fraction
)
}
@@ -624,12 +623,12 @@
}
assertPositions(
- 0 to AxisIntOffset(0, 0),
- 1 to AxisIntOffset(itemSize, 0),
- 2 to AxisIntOffset(0, itemSizePlusSpacing),
- 3 to AxisIntOffset(itemSize, itemSizePlusSpacing),
- 4 to AxisIntOffset(0, itemSizePlusSpacing * 2),
- 5 to AxisIntOffset(itemSize, itemSizePlusSpacing * 2)
+ 0 to AxisOffset(0f, 0f),
+ 1 to AxisOffset(itemSize, 0f),
+ 2 to AxisOffset(0f, itemSizePlusSpacing),
+ 3 to AxisOffset(itemSize, itemSizePlusSpacing),
+ 4 to AxisOffset(0f, itemSizePlusSpacing * 2),
+ 5 to AxisOffset(itemSize, itemSizePlusSpacing * 2)
)
rule.runOnIdle {
@@ -638,24 +637,18 @@
onAnimationFrame { fraction ->
// item 1 moves to and item 8 moves from `gridSize`, right after the end edge
- val item1Offset = AxisIntOffset(
- itemSize,
- (gridSize * fraction).roundToInt()
- )
- val item8Offset = AxisIntOffset(
- itemSize,
- gridSize - (gridSize * fraction).roundToInt()
- )
+ val item1Offset = AxisOffset(itemSize, gridSize * fraction)
+ val item8Offset = AxisOffset(itemSize, gridSize - gridSize * fraction)
val screenSize = itemSize * 3 + spacing * 2
- val expected = mutableListOf<Pair<Any, IntOffset>>().apply {
- add(0 to AxisIntOffset(0, 0))
+ val expected = mutableListOf<Pair<Any, Offset>>().apply {
+ add(0 to AxisOffset(0f, 0f))
if (item1Offset.mainAxis < screenSize) {
add(1 to item1Offset)
}
- add(2 to AxisIntOffset(0, itemSizePlusSpacing))
- add(3 to AxisIntOffset(itemSize, itemSizePlusSpacing))
- add(4 to AxisIntOffset(0, itemSizePlusSpacing * 2))
- add(5 to AxisIntOffset(itemSize, itemSizePlusSpacing * 2))
+ add(2 to AxisOffset(0f, itemSizePlusSpacing))
+ add(3 to AxisOffset(itemSize, itemSizePlusSpacing))
+ add(4 to AxisOffset(0f, itemSizePlusSpacing * 2))
+ add(5 to AxisOffset(itemSize, itemSizePlusSpacing * 2))
if (item8Offset.mainAxis < screenSize) {
add(8 to item8Offset)
}
@@ -684,12 +677,12 @@
}
assertPositions(
- 4 to AxisIntOffset(0, 0),
- 5 to AxisIntOffset(itemSize, 0),
- 6 to AxisIntOffset(0, itemSizePlusSpacing),
- 7 to AxisIntOffset(itemSize, itemSizePlusSpacing),
- 8 to AxisIntOffset(0, itemSizePlusSpacing * 2),
- 9 to AxisIntOffset(itemSize, itemSizePlusSpacing * 2)
+ 4 to AxisOffset(0f, 0f),
+ 5 to AxisOffset(itemSize, 0f),
+ 6 to AxisOffset(0f, itemSizePlusSpacing),
+ 7 to AxisOffset(itemSize, itemSizePlusSpacing),
+ 8 to AxisOffset(0f, itemSizePlusSpacing * 2),
+ 9 to AxisOffset(itemSize, itemSizePlusSpacing * 2)
)
rule.runOnIdle {
@@ -698,27 +691,27 @@
onAnimationFrame { fraction ->
// item 8 moves to and item 1 moves from `-itemSize`, right before the start edge
- val item1Offset = AxisIntOffset(
- 0,
- -itemSize + ((itemSize + itemSizePlusSpacing * 2) * fraction).roundToInt()
+ val item1Offset = AxisOffset(
+ 0f,
+ -itemSize + (itemSize + itemSizePlusSpacing * 2) * fraction
)
- val item8Offset = AxisIntOffset(
- 0,
+ val item8Offset = AxisOffset(
+ 0f,
itemSizePlusSpacing * 2 -
- ((itemSize + itemSizePlusSpacing * 2) * fraction).roundToInt()
+ (itemSize + itemSizePlusSpacing * 2) * fraction
)
- val expected = mutableListOf<Pair<Any, IntOffset>>().apply {
+ val expected = mutableListOf<Pair<Any, Offset>>().apply {
if (item1Offset.mainAxis > -itemSize) {
add(1 to item1Offset)
}
- add(4 to AxisIntOffset(0, 0))
- add(5 to AxisIntOffset(itemSize, 0))
- add(6 to AxisIntOffset(0, itemSizePlusSpacing))
- add(7 to AxisIntOffset(itemSize, itemSizePlusSpacing))
+ add(4 to AxisOffset(0f, 0f))
+ add(5 to AxisOffset(itemSize, 0f))
+ add(6 to AxisOffset(0f, itemSizePlusSpacing))
+ add(7 to AxisOffset(itemSize, itemSizePlusSpacing))
if (item8Offset.mainAxis > -itemSize) {
add(8 to item8Offset)
}
- add(9 to AxisIntOffset(itemSize, itemSizePlusSpacing * 2))
+ add(9 to AxisOffset(itemSize, itemSizePlusSpacing * 2))
}
assertPositions(
expected = expected.toTypedArray(),
@@ -750,12 +743,12 @@
val line3Size = itemSize2
val line4Size = itemSize
assertPositions(
- 6 to AxisIntOffset(0, 0),
- 7 to AxisIntOffset(itemSize, 0),
- 8 to AxisIntOffset(0, line3Size),
- 9 to AxisIntOffset(itemSize, line3Size),
- 10 to AxisIntOffset(0, line3Size + line4Size),
- 11 to AxisIntOffset(itemSize, line3Size + line4Size)
+ 6 to AxisOffset(0f, 0f),
+ 7 to AxisOffset(itemSize, 0f),
+ 8 to AxisOffset(0f, line3Size),
+ 9 to AxisOffset(itemSize, line3Size),
+ 10 to AxisOffset(0f, line3Size + line4Size),
+ 11 to AxisOffset(itemSize, line3Size + line4Size)
)
rule.runOnIdle {
@@ -771,31 +764,31 @@
// item 2 moves from and item 4 moves to `0 - item size`, right before the start edge
val startItem2Offset = -item2Size
val item2Offset =
- startItem2Offset + ((itemSize2 - startItem2Offset) * fraction).roundToInt()
+ startItem2Offset + (itemSize2 - startItem2Offset) * fraction
val item8Size = itemSize /* the real size of the item 8 */
val endItem8Offset = -item8Size
- val item8Offset = line3Size - ((line3Size - endItem8Offset) * fraction).roundToInt()
- val expected = mutableListOf<Pair<Any, IntOffset>>().apply {
+ val item8Offset = line3Size - (line3Size - endItem8Offset) * fraction
+ val expected = mutableListOf<Pair<Any, Offset>>().apply {
if (item8Offset > -line4Size) {
- add(8 to AxisIntOffset(0, item8Offset))
+ add(8 to AxisOffset(0f, item8Offset))
} else {
rule.onNodeWithTag("8").assertIsNotDisplayed()
}
- add(6 to AxisIntOffset(0, 0))
- add(7 to AxisIntOffset(itemSize, 0))
+ add(6 to AxisOffset(0f, 0f))
+ add(7 to AxisOffset(itemSize, 0f))
if (item2Offset > -item2Size) {
- add(2 to AxisIntOffset(0, item2Offset))
+ add(2 to AxisOffset(0f, item2Offset))
} else {
rule.onNodeWithTag("2").assertIsNotDisplayed()
}
- add(9 to AxisIntOffset(itemSize, line3Size))
- add(10 to AxisIntOffset(
- 0,
- line3Size + line4Size - ((itemSize - itemSize3) * fraction).roundToInt()
+ add(9 to AxisOffset(itemSize, line3Size))
+ add(10 to AxisOffset(
+ 0f,
+ line3Size + line4Size - (itemSize - itemSize3) * fraction
))
- add(11 to AxisIntOffset(
+ add(11 to AxisOffset(
itemSize,
- line3Size + line4Size - ((itemSize - itemSize3) * fraction).roundToInt()
+ line3Size + line4Size - (itemSize - itemSize3) * fraction
))
}
assertPositions(
@@ -828,12 +821,12 @@
val line0Size = itemSize2
val line1Size = itemSize
assertPositions(
- 0 to AxisIntOffset(0, 0),
- 1 to AxisIntOffset(itemSize, 0),
- 2 to AxisIntOffset(0, line0Size),
- 3 to AxisIntOffset(itemSize, line0Size),
- 4 to AxisIntOffset(0, line0Size + line1Size),
- 5 to AxisIntOffset(itemSize, line0Size + line1Size),
+ 0 to AxisOffset(0f, 0f),
+ 1 to AxisOffset(itemSize, 0f),
+ 2 to AxisOffset(0f, line0Size),
+ 3 to AxisOffset(itemSize, line0Size),
+ 4 to AxisOffset(0f, line0Size + line1Size),
+ 5 to AxisOffset(itemSize, line0Size + line1Size),
)
rule.runOnIdle {
@@ -846,28 +839,28 @@
val endItem2Offset = gridSize
val line4Size = itemSize3
val item2Offset =
- line0Size + ((endItem2Offset - line0Size) * fraction).roundToInt()
+ line0Size + (endItem2Offset - line0Size) * fraction
val item8Offset =
- startItem8Offset - ((startItem8Offset - line0Size) * fraction).roundToInt()
- val expected = mutableListOf<Pair<Any, IntOffset>>().apply {
- add(0 to AxisIntOffset(0, 0))
- add(1 to AxisIntOffset(itemSize, 0))
+ startItem8Offset - (startItem8Offset - line0Size) * fraction
+ val expected = mutableListOf<Pair<Any, Offset>>().apply {
+ add(0 to AxisOffset(0f, 0f))
+ add(1 to AxisOffset(itemSize, 0f))
if (item8Offset < gridSize) {
- add(8 to AxisIntOffset(0, item8Offset))
+ add(8 to AxisOffset(0f, item8Offset))
} else {
rule.onNodeWithTag("8").assertIsNotDisplayed()
}
- add(3 to AxisIntOffset(itemSize, line0Size))
- add(4 to AxisIntOffset(
- 0,
- line0Size + line1Size - ((line1Size - line4Size) * fraction).roundToInt()
+ add(3 to AxisOffset(itemSize, line0Size))
+ add(4 to AxisOffset(
+ 0f,
+ line0Size + line1Size - (line1Size - line4Size) * fraction
))
- add(5 to AxisIntOffset(
+ add(5 to AxisOffset(
itemSize,
- line0Size + line1Size - ((line1Size - line4Size) * fraction).roundToInt()
+ line0Size + line1Size - (line1Size - line4Size) * fraction
))
if (item2Offset < gridSize) {
- add(2 to AxisIntOffset(0, item2Offset))
+ add(2 to AxisOffset(0f, item2Offset))
} else {
rule.onNodeWithTag("2").assertIsNotDisplayed()
}
@@ -922,8 +915,8 @@
// 3 to itemSize * 2,
// crossAxis = listOf(
// 1 to 0,
- // 2 to item2Start + ((item2End - item2Start) * fraction).roundToInt(),
- // 3 to item3Start + ((item3End - item3Start) * fraction).roundToInt(),
+ // 2 to item2Start + ((item2End - item2Start) * fraction,
+ // 3 to item3Start + ((item3End - item3Start) * fraction,
// ),
// fraction = fraction
// )
@@ -960,9 +953,9 @@
// 2 to itemSize,
// 3 to itemSize * 2,
// crossAxis = listOf(
- // 1 to ((containerSize - itemSize) * fraction).roundToInt(),
- // 2 to ((containerSize - itemSize2) * fraction).roundToInt(),
- // 3 to ((containerSize - itemSize3) * fraction).roundToInt()
+ // 1 to ((containerSize - itemSize) * fraction,
+ // 2 to ((containerSize - itemSize2) * fraction,
+ // 3 to ((containerSize - itemSize3) * fraction
// ),
// fraction = fraction
// )
@@ -1013,8 +1006,8 @@
// 3 to itemSize * 2,
// crossAxis = listOf(
// 1 to 0,
- // 2 to ((itemSize / 2 - itemSize2 / 2) * fraction).roundToInt(),
- // 3 to ((itemSize / 2 - itemSize3 / 2) * fraction).roundToInt(),
+ // 2 to ((itemSize / 2 - itemSize2 / 2) * fraction,
+ // 3 to ((itemSize / 2 - itemSize3 / 2) * fraction,
// ),
// fraction = fraction
// )
@@ -1024,8 +1017,8 @@
@Test
fun moveItemToEndCausingNextItemsToAnimate_withContentPadding() {
var list by mutableStateOf(listOf(0, 1, 2, 3, 4))
- val rawStartPadding = 8
- val rawEndPadding = 12
+ val rawStartPadding = 8f
+ val rawEndPadding = 12f
val (startPaddingDp, endPaddingDp) = with(rule.density) {
rawStartPadding.toDp() to rawEndPadding.toDp()
}
@@ -1039,11 +1032,11 @@
val startPadding = if (reverseLayout) rawEndPadding else rawStartPadding
assertPositions(
- 0 to AxisIntOffset(0, startPadding),
- 1 to AxisIntOffset(0, startPadding + itemSize),
- 2 to AxisIntOffset(0, startPadding + itemSize * 2),
- 3 to AxisIntOffset(0, startPadding + itemSize * 3),
- 4 to AxisIntOffset(0, startPadding + itemSize * 4),
+ 0 to AxisOffset(0f, startPadding),
+ 1 to AxisOffset(0f, startPadding + itemSize),
+ 2 to AxisOffset(0f, startPadding + itemSize * 2),
+ 3 to AxisOffset(0f, startPadding + itemSize * 3),
+ 4 to AxisOffset(0f, startPadding + itemSize * 4),
)
rule.runOnIdle {
@@ -1052,22 +1045,22 @@
onAnimationFrame { fraction ->
assertPositions(
- 0 to AxisIntOffset(0, startPadding),
- 1 to AxisIntOffset(
- 0,
- startPadding + itemSize + (itemSize * 3 * fraction).roundToInt()
+ 0 to AxisOffset(0f, startPadding),
+ 1 to AxisOffset(
+ 0f,
+ startPadding + itemSize + itemSize * 3 * fraction
),
- 2 to AxisIntOffset(
- 0,
- startPadding + itemSize * 2 - (itemSize * fraction).roundToInt()
+ 2 to AxisOffset(
+ 0f,
+ startPadding + itemSize * 2 - itemSize * fraction
),
- 3 to AxisIntOffset(
- 0,
- startPadding + itemSize * 3 - (itemSize * fraction).roundToInt()
+ 3 to AxisOffset(
+ 0f,
+ startPadding + itemSize * 3 - itemSize * fraction
),
- 4 to AxisIntOffset(
- 0,
- startPadding + itemSize * 4 - (itemSize * fraction).roundToInt()
+ 4 to AxisOffset(
+ 0f,
+ startPadding + itemSize * 4 - itemSize * fraction
),
fraction = fraction
)
@@ -1122,16 +1115,16 @@
rule.runOnIdle {
runBlocking {
- state.scrollToItem(0, itemSize / 2)
+ state.scrollToItem(0, (itemSize / 2).roundToInt())
}
}
onAnimationFrame { fraction ->
assertPositions(
- 0 to AxisIntOffset(0, -itemSize / 2),
- 1 to AxisIntOffset(0, itemSize / 2),
- 2 to AxisIntOffset(0, itemSize * 3 / 2),
- 3 to AxisIntOffset(0, itemSize * 5 / 2),
+ 0 to AxisOffset(0f, -itemSize / 2),
+ 1 to AxisOffset(0f, itemSize / 2),
+ 2 to AxisOffset(0f, itemSize * 3 / 2),
+ 3 to AxisOffset(0f, itemSize * 5 / 2),
fraction = fraction
)
}
@@ -1155,10 +1148,10 @@
onAnimationFrame { fraction ->
assertPositions(
- 0 to AxisIntOffset(0, -itemSize / 2),
- 1 to AxisIntOffset(0, itemSize / 2),
- 2 to AxisIntOffset(0, itemSize * 3 / 2),
- 3 to AxisIntOffset(0, itemSize * 5 / 2),
+ 0 to AxisOffset(0f, -itemSize / 2),
+ 1 to AxisOffset(0f, itemSize / 2),
+ 2 to AxisOffset(0f, itemSize * 3 / 2),
+ 3 to AxisOffset(0f, itemSize * 5 / 2),
fraction = fraction
)
}
@@ -1182,10 +1175,10 @@
onAnimationFrame { fraction ->
assertPositions(
- 1 to AxisIntOffset(0, -itemSize / 2),
- 2 to AxisIntOffset(0, itemSize / 2),
- 3 to AxisIntOffset(0, itemSize * 3 / 2),
- 4 to AxisIntOffset(0, itemSize * 5 / 2),
+ 1 to AxisOffset(0f, -itemSize / 2),
+ 2 to AxisOffset(0f, itemSize / 2),
+ 3 to AxisOffset(0f, itemSize * 3 / 2),
+ 4 to AxisOffset(0f, itemSize * 5 / 2),
fraction = fraction
)
}
@@ -1209,10 +1202,10 @@
onAnimationFrame { fraction ->
assertPositions(
- 2 to AxisIntOffset(0, -itemSize / 2),
- 3 to AxisIntOffset(0, itemSize / 2),
- 4 to AxisIntOffset(0, itemSize * 3 / 2),
- 5 to AxisIntOffset(0, itemSize * 5 / 2),
+ 2 to AxisOffset(0f, -itemSize / 2),
+ 3 to AxisOffset(0f, itemSize / 2),
+ 4 to AxisOffset(0f, itemSize * 3 / 2),
+ 5 to AxisOffset(0f, itemSize * 5 / 2),
fraction = fraction
)
}
@@ -1236,10 +1229,10 @@
onAnimationFrame { fraction ->
assertPositions(
- 0 to AxisIntOffset(0, -itemSize / 2),
- 1 to AxisIntOffset(0, itemSize / 2),
- 2 to AxisIntOffset(0, itemSize * 3 / 2),
- 3 to AxisIntOffset(0, itemSize * 5 / 2),
+ 0 to AxisOffset(0f, -itemSize / 2),
+ 1 to AxisOffset(0f, itemSize / 2),
+ 2 to AxisOffset(0f, itemSize * 3 / 2),
+ 3 to AxisOffset(0f, itemSize * 5 / 2),
fraction = fraction
)
}
@@ -1263,10 +1256,10 @@
onAnimationFrame { fraction ->
assertPositions(
- 2 to AxisIntOffset(0, -itemSize / 2),
- 3 to AxisIntOffset(0, itemSize / 2),
- 4 to AxisIntOffset(0, itemSize2 + itemSize / 2),
- 5 to AxisIntOffset(0, itemSize2 + itemSize * 3 / 2),
+ 2 to AxisOffset(0f, -itemSize / 2),
+ 3 to AxisOffset(0f, itemSize / 2),
+ 4 to AxisOffset(0f, itemSize2 + itemSize / 2),
+ 5 to AxisOffset(0f, itemSize2 + itemSize * 3 / 2),
fraction = fraction
)
}
@@ -1290,10 +1283,10 @@
onAnimationFrame { fraction ->
assertPositions(
- 0 to AxisIntOffset(0, -itemSize / 2),
- 1 to AxisIntOffset(0, itemSize / 2),
- 2 to AxisIntOffset(0, itemSize2 + itemSize / 2),
- 3 to AxisIntOffset(0, itemSize2 + itemSize * 3 / 2),
+ 0 to AxisOffset(0f, -itemSize / 2),
+ 1 to AxisOffset(0f, itemSize / 2),
+ 2 to AxisOffset(0f, itemSize2 + itemSize / 2),
+ 3 to AxisOffset(0f, itemSize2 + itemSize * 3 / 2),
fraction = fraction
)
}
@@ -1310,12 +1303,12 @@
}
assertPositions(
- 0 to AxisIntOffset(0, 0),
- 1 to AxisIntOffset(itemSize, 0),
- 2 to AxisIntOffset(itemSize * 2, 0),
- 3 to AxisIntOffset(0, itemSize),
- 4 to AxisIntOffset(itemSize, itemSize),
- 5 to AxisIntOffset(itemSize * 2, itemSize)
+ 0 to AxisOffset(0f, 0f),
+ 1 to AxisOffset(itemSize, 0f),
+ 2 to AxisOffset(itemSize * 2, 0f),
+ 3 to AxisOffset(0f, itemSize),
+ 4 to AxisOffset(itemSize, itemSize),
+ 5 to AxisOffset(itemSize * 2, itemSize)
)
rule.runOnIdle {
@@ -1326,15 +1319,15 @@
onAnimationFrame { fraction ->
assertPositions(
- 6 to AxisIntOffset(0, -itemSize / 2),
- 7 to AxisIntOffset(itemSize, -itemSize / 2),
- 8 to AxisIntOffset(itemSize * 2, -itemSize / 2),
- 9 to AxisIntOffset(0, itemSize / 2),
- 10 to AxisIntOffset(itemSize, itemSize / 2),
- 11 to AxisIntOffset(itemSize * 2, itemSize / 2),
- 12 to AxisIntOffset(0, itemSize * 3 / 2),
- 13 to AxisIntOffset(itemSize, itemSize * 3 / 2),
- 14 to AxisIntOffset(itemSize * 2, itemSize * 3 / 2),
+ 6 to AxisOffset(0f, -itemSize / 2),
+ 7 to AxisOffset(itemSize, -itemSize / 2),
+ 8 to AxisOffset(itemSize * 2, -itemSize / 2),
+ 9 to AxisOffset(0f, itemSize / 2),
+ 10 to AxisOffset(itemSize, itemSize / 2),
+ 11 to AxisOffset(itemSize * 2, itemSize / 2),
+ 12 to AxisOffset(0f, itemSize * 3 / 2),
+ 13 to AxisOffset(itemSize, itemSize * 3 / 2),
+ 14 to AxisOffset(itemSize * 2, itemSize * 3 / 2),
fraction = fraction
)
}
@@ -1351,12 +1344,12 @@
}
assertPositions(
- 9 to AxisIntOffset(0, 0),
- 10 to AxisIntOffset(itemSize, 0),
- 11 to AxisIntOffset(itemSize * 2, 0),
- 12 to AxisIntOffset(0, itemSize),
- 13 to AxisIntOffset(itemSize, itemSize),
- 14 to AxisIntOffset(itemSize * 2, itemSize)
+ 9 to AxisOffset(0f, 0f),
+ 10 to AxisOffset(itemSize, 0f),
+ 11 to AxisOffset(itemSize * 2, 0f),
+ 12 to AxisOffset(0f, itemSize),
+ 13 to AxisOffset(itemSize, itemSize),
+ 14 to AxisOffset(itemSize * 2, itemSize)
)
rule.runOnIdle {
@@ -1367,15 +1360,15 @@
onAnimationFrame { fraction ->
assertPositions(
- 0 to AxisIntOffset(0, -itemSize / 2),
- 1 to AxisIntOffset(itemSize, -itemSize / 2),
- 2 to AxisIntOffset(itemSize * 2, -itemSize / 2),
- 3 to AxisIntOffset(0, itemSize / 2),
- 4 to AxisIntOffset(itemSize, itemSize / 2),
- 5 to AxisIntOffset(itemSize * 2, itemSize / 2),
- 6 to AxisIntOffset(0, itemSize * 3 / 2),
- 7 to AxisIntOffset(itemSize, itemSize * 3 / 2),
- 8 to AxisIntOffset(itemSize * 2, itemSize * 3 / 2),
+ 0 to AxisOffset(0f, -itemSize / 2),
+ 1 to AxisOffset(itemSize, -itemSize / 2),
+ 2 to AxisOffset(itemSize * 2, -itemSize / 2),
+ 3 to AxisOffset(0f, itemSize / 2),
+ 4 to AxisOffset(itemSize, itemSize / 2),
+ 5 to AxisOffset(itemSize * 2, itemSize / 2),
+ 6 to AxisOffset(0f, itemSize * 3 / 2),
+ 7 to AxisOffset(itemSize, itemSize * 3 / 2),
+ 8 to AxisOffset(itemSize * 2, itemSize * 3 / 2),
fraction = fraction
)
}
@@ -1396,12 +1389,12 @@
}
assertPositions(
- 0 to AxisIntOffset(0, 0),
- 1 to AxisIntOffset(itemSize, 0),
- 2 to AxisIntOffset(itemSize * 2, 0),
- 3 to AxisIntOffset(0, itemSize),
- 4 to AxisIntOffset(itemSize, itemSize),
- 5 to AxisIntOffset(itemSize * 2, itemSize)
+ 0 to AxisOffset(0f, 0f),
+ 1 to AxisOffset(itemSize, 0f),
+ 2 to AxisOffset(itemSize * 2, 0f),
+ 3 to AxisOffset(0f, itemSize),
+ 4 to AxisOffset(itemSize, itemSize),
+ 5 to AxisOffset(itemSize * 2, itemSize)
)
rule.runOnIdle {
@@ -1412,12 +1405,12 @@
onAnimationFrame { fraction ->
assertPositions(
- 6 to AxisIntOffset(0, -itemSize / 2),
- 7 to AxisIntOffset(itemSize, -itemSize / 2),
- 8 to AxisIntOffset(itemSize * 2, -itemSize / 2),
- 9 to AxisIntOffset(0, itemSize / 2), // 3 spans
- 10 to AxisIntOffset(0, itemSize * 3 / 2), // 2 spans
- 11 to AxisIntOffset(itemSize * 2, itemSize * 3 / 2),
+ 6 to AxisOffset(0f, -itemSize / 2),
+ 7 to AxisOffset(itemSize, -itemSize / 2),
+ 8 to AxisOffset(itemSize * 2, -itemSize / 2),
+ 9 to AxisOffset(0f, itemSize / 2), // 3 spans
+ 10 to AxisOffset(0f, itemSize * 3 / 2), // 2 spans
+ 11 to AxisOffset(itemSize * 2, itemSize * 3 / 2),
fraction = fraction
)
}
@@ -1438,12 +1431,12 @@
}
assertPositions(
- 6 to AxisIntOffset(0, 0),
- 7 to AxisIntOffset(itemSize, 0),
- 8 to AxisIntOffset(itemSize * 2, 0),
- 9 to AxisIntOffset(0, itemSize),
- 10 to AxisIntOffset(itemSize, itemSize),
- 11 to AxisIntOffset(itemSize * 2, itemSize)
+ 6 to AxisOffset(0f, 0f),
+ 7 to AxisOffset(itemSize, 0f),
+ 8 to AxisOffset(itemSize * 2, 0f),
+ 9 to AxisOffset(0f, itemSize),
+ 10 to AxisOffset(itemSize, itemSize),
+ 11 to AxisOffset(itemSize * 2, itemSize)
)
rule.runOnIdle {
@@ -1454,12 +1447,12 @@
onAnimationFrame { fraction ->
assertPositions(
- 0 to AxisIntOffset(0, -itemSize / 2),
- 1 to AxisIntOffset(itemSize, -itemSize / 2),
- 2 to AxisIntOffset(itemSize * 2, -itemSize / 2),
- 3 to AxisIntOffset(0, itemSize / 2), // 3 spans
- 4 to AxisIntOffset(0, itemSize * 3 / 2), // 2 spans
- 5 to AxisIntOffset(itemSize * 2, itemSize * 3 / 2),
+ 0 to AxisOffset(0f, -itemSize / 2),
+ 1 to AxisOffset(itemSize, -itemSize / 2),
+ 2 to AxisOffset(itemSize * 2, -itemSize / 2),
+ 3 to AxisOffset(0f, itemSize / 2), // 3 spans
+ 4 to AxisOffset(0f, itemSize * 3 / 2), // 2 spans
+ 5 to AxisOffset(itemSize * 2, itemSize * 3 / 2),
fraction = fraction
)
}
@@ -1486,12 +1479,12 @@
}
assertPositions(
- 0 to AxisIntOffset(0, 0),
- 1 to AxisIntOffset(itemSize, 0),
- 2 to AxisIntOffset(itemSize * 2, 0),
- 3 to AxisIntOffset(0, itemSize),
- 4 to AxisIntOffset(itemSize, itemSize),
- 5 to AxisIntOffset(itemSize * 2, itemSize)
+ 0 to AxisOffset(0f, 0f),
+ 1 to AxisOffset(itemSize, 0f),
+ 2 to AxisOffset(itemSize * 2, 0f),
+ 3 to AxisOffset(0f, itemSize),
+ 4 to AxisOffset(itemSize, itemSize),
+ 5 to AxisOffset(itemSize * 2, itemSize)
)
rule.runOnIdle {
@@ -1503,12 +1496,12 @@
onAnimationFrame { fraction ->
val startOffset = -itemSize / 2
assertPositions(
- 6 to AxisIntOffset(0, startOffset),
- 7 to AxisIntOffset(itemSize, startOffset),
- 8 to AxisIntOffset(itemSize * 2, startOffset),
- 9 to AxisIntOffset(0, startOffset + itemSize2), // 3 spans
- 10 to AxisIntOffset(0, startOffset + itemSize2 + itemSize3), // 2 spans
- 11 to AxisIntOffset(itemSize * 2, startOffset + itemSize2 + itemSize3),
+ 6 to AxisOffset(0f, startOffset),
+ 7 to AxisOffset(itemSize, startOffset),
+ 8 to AxisOffset(itemSize * 2, startOffset),
+ 9 to AxisOffset(0f, startOffset + itemSize2), // 3 spans
+ 10 to AxisOffset(0f, startOffset + itemSize2 + itemSize3), // 2 spans
+ 11 to AxisOffset(itemSize * 2, startOffset + itemSize2 + itemSize3),
fraction = fraction
)
}
@@ -1535,12 +1528,12 @@
}
assertPositions(
- 6 to AxisIntOffset(0, 0),
- 7 to AxisIntOffset(itemSize, 0),
- 8 to AxisIntOffset(itemSize * 2, 0),
- 9 to AxisIntOffset(0, itemSize),
- 10 to AxisIntOffset(itemSize, itemSize),
- 11 to AxisIntOffset(itemSize * 2, itemSize)
+ 6 to AxisOffset(0f, 0f),
+ 7 to AxisOffset(itemSize, 0f),
+ 8 to AxisOffset(itemSize * 2, 0f),
+ 9 to AxisOffset(0f, itemSize),
+ 10 to AxisOffset(itemSize, itemSize),
+ 11 to AxisOffset(itemSize * 2, itemSize)
)
rule.runOnIdle {
@@ -1552,12 +1545,12 @@
onAnimationFrame { fraction ->
val startOffset = -itemSize2 / 2
assertPositions(
- 0 to AxisIntOffset(0, startOffset),
- 1 to AxisIntOffset(itemSize, startOffset),
- 2 to AxisIntOffset(itemSize * 2, startOffset),
- 3 to AxisIntOffset(0, startOffset + itemSize2), // 3 spans
- 4 to AxisIntOffset(0, startOffset + itemSize2 + itemSize3), // 2 spans
- 5 to AxisIntOffset(itemSize * 2, startOffset + itemSize2 + itemSize3),
+ 0 to AxisOffset(0f, startOffset),
+ 1 to AxisOffset(itemSize, startOffset),
+ 2 to AxisOffset(itemSize * 2, startOffset),
+ 3 to AxisOffset(0f, startOffset + itemSize2), // 3 spans
+ 4 to AxisOffset(0f, startOffset + itemSize2 + itemSize3), // 2 spans
+ 5 to AxisOffset(itemSize * 2, startOffset + itemSize2 + itemSize3),
fraction = fraction
)
}
@@ -1577,10 +1570,10 @@
}
assertLayoutInfoPositions(
- 0 to AxisIntOffset(0, 0),
- 1 to AxisIntOffset(itemSize, 0),
- 2 to AxisIntOffset(0, itemSize),
- 3 to AxisIntOffset(itemSize, itemSize)
+ 0 to AxisOffset(0f, 0f),
+ 1 to AxisOffset(itemSize, 0f),
+ 2 to AxisOffset(0f, itemSize),
+ 3 to AxisOffset(itemSize, itemSize)
)
rule.runOnIdle {
@@ -1588,18 +1581,18 @@
}
onAnimationFrame { fraction ->
- val expected = mutableListOf<Pair<Any, IntOffset>>().apply {
- add(0 to AxisIntOffset(0, 0))
+ val expected = mutableListOf<Pair<Any, Offset>>().apply {
+ add(0 to AxisOffset(0f, 0f))
add(
- 2 to AxisIntOffset(
- (itemSize * fraction).roundToInt(),
- (itemSize * (1f - fraction)).roundToInt()
+ 2 to AxisOffset(
+ itemSize * fraction,
+ itemSize * (1f - fraction)
)
)
- val item4and6MainAxis = gridSize - ((gridSize - itemSize) * fraction).roundToInt()
+ val item4and6MainAxis = gridSize - (gridSize - itemSize) * fraction
if (item4and6MainAxis < gridSize) {
- add(4 to AxisIntOffset(0, item4and6MainAxis))
- add(6 to AxisIntOffset(itemSize, item4and6MainAxis))
+ add(4 to AxisOffset(0f, item4and6MainAxis))
+ add(6 to AxisOffset(itemSize, item4and6MainAxis))
} else {
rule.onNodeWithTag("4").assertIsNotDisplayed()
rule.onNodeWithTag("6").assertIsNotDisplayed()
@@ -1629,10 +1622,10 @@
}
assertLayoutInfoPositions(
- 0 to AxisIntOffset(0, 0),
- 1 to AxisIntOffset(itemSize, 0),
- 2 to AxisIntOffset(0, itemSize),
- 3 to AxisIntOffset(itemSize, itemSize)
+ 0 to AxisOffset(0f, 0f),
+ 1 to AxisOffset(itemSize, 0f),
+ 2 to AxisOffset(0f, itemSize),
+ 3 to AxisOffset(itemSize, itemSize)
)
rule.runOnIdle {
@@ -1640,20 +1633,20 @@
}
onAnimationFrame { fraction ->
- val expected = mutableListOf<Pair<Any, IntOffset>>().apply {
- add(0 to AxisIntOffset(0, 0))
- val item4MainAxis = gridSize - (gridSize * fraction).roundToInt()
+ val expected = mutableListOf<Pair<Any, Offset>>().apply {
+ add(0 to AxisOffset(0f, 0f))
+ val item4MainAxis = gridSize - gridSize * fraction
if (item4MainAxis < gridSize) {
add(
- 4 to AxisIntOffset(itemSize, item4MainAxis)
+ 4 to AxisOffset(itemSize, item4MainAxis)
)
} else {
rule.onNodeWithTag("4").assertIsNotDisplayed()
}
- val item6MainAxis = gridSize + itemSize - (gridSize * fraction).roundToInt()
+ val item6MainAxis = gridSize + itemSize - gridSize * fraction
if (item6MainAxis < gridSize) {
add(
- 6 to AxisIntOffset(0, item6MainAxis)
+ 6 to AxisOffset(0f, item6MainAxis)
)
} else {
rule.onNodeWithTag("6").assertIsNotDisplayed()
@@ -1686,11 +1679,11 @@
onAnimationFrame { fraction ->
// item 1 moves to `gridSize`
- val item1Offset = itemSize + ((gridSize - itemSize) * fraction).roundToInt()
- val expected = mutableListOf<Pair<Any, IntOffset>>().apply {
- add(0 to AxisIntOffset(0, 0))
+ val item1Offset = itemSize + (gridSize - itemSize) * fraction
+ val expected = mutableListOf<Pair<Any, Offset>>().apply {
+ add(0 to AxisOffset(0f, 0f))
if (item1Offset < gridSize) {
- add(1 to AxisIntOffset(0, item1Offset))
+ add(1 to AxisOffset(0f, item1Offset))
} else {
rule.onNodeWithTag("1").assertIsNotDisplayed()
}
@@ -1714,9 +1707,9 @@
}
assertPositions(
- 3 to AxisIntOffset(0, 0),
- 4 to AxisIntOffset(0, itemSize),
- 5 to AxisIntOffset(0, itemSize * 2)
+ 3 to AxisOffset(0f, 0f),
+ 4 to AxisOffset(0f, itemSize),
+ 5 to AxisOffset(0f, itemSize * 2)
)
rule.runOnIdle {
@@ -1725,30 +1718,30 @@
onAnimationFrame { fraction ->
// item 2 moves from and item 5 moves to `-itemSize`, right before the start edge
- val item2Offset = -itemSize + (itemSize * 3 * fraction).roundToInt()
- val item5Offset = itemSize * 2 - (itemSize * 3 * fraction).roundToInt()
+ val item2Offset = -itemSize + itemSize * 3 * fraction
+ val item5Offset = itemSize * 2 - itemSize * 3 * fraction
// item 1 moves from and item 4 moves to `-itemSize * 2`, right before item 2
- val item1Offset = -itemSize * 2 + (itemSize * 3 * fraction).roundToInt()
- val item4Offset = itemSize - (itemSize * 3 * fraction).roundToInt()
- val expected = mutableListOf<Pair<Any, IntOffset>>().apply {
+ val item1Offset = -itemSize * 2 + itemSize * 3 * fraction
+ val item4Offset = itemSize - itemSize * 3 * fraction
+ val expected = mutableListOf<Pair<Any, Offset>>().apply {
if (item1Offset > -itemSize) {
- add(1 to AxisIntOffset(0, item1Offset))
+ add(1 to AxisOffset(0f, item1Offset))
} else {
rule.onNodeWithTag("1").assertIsNotDisplayed()
}
if (item2Offset > -itemSize) {
- add(2 to AxisIntOffset(0, item2Offset))
+ add(2 to AxisOffset(0f, item2Offset))
} else {
rule.onNodeWithTag("2").assertIsNotDisplayed()
}
- add(3 to AxisIntOffset(0, 0))
+ add(3 to AxisOffset(0f, 0f))
if (item4Offset > -itemSize) {
- add(4 to AxisIntOffset(0, item4Offset))
+ add(4 to AxisOffset(0f, item4Offset))
} else {
rule.onNodeWithTag("4").assertIsNotDisplayed()
}
if (item5Offset > -itemSize) {
- add(5 to AxisIntOffset(0, item5Offset))
+ add(5 to AxisOffset(0f, item5Offset))
} else {
rule.onNodeWithTag("5").assertIsNotDisplayed()
}
@@ -1772,9 +1765,9 @@
}
assertPositions(
- 3 to AxisIntOffset(0, 0),
- 4 to AxisIntOffset(0, itemSize),
- 5 to AxisIntOffset(0, itemSize * 2)
+ 3 to AxisOffset(0f, 0f),
+ 4 to AxisOffset(0f, itemSize),
+ 5 to AxisOffset(0f, itemSize * 2)
)
rule.runOnIdle {
@@ -1783,30 +1776,30 @@
onAnimationFrame { fraction ->
// item 2 moves from and item 4 moves to `-itemSize`, right before the start edge
- val item2Offset = -itemSize + (itemSize * 2 * fraction).roundToInt()
- val item4Offset = itemSize - (itemSize * 2 * fraction).roundToInt()
+ val item2Offset = -itemSize + itemSize * 2 * fraction
+ val item4Offset = itemSize - itemSize * 2 * fraction
// item 1 moves from and item 5 moves to `-itemSize * 2`, right before item 2
- val item1Offset = -itemSize * 2 + (itemSize * 4 * fraction).roundToInt()
- val item5Offset = itemSize * 2 - (itemSize * 4 * fraction).roundToInt()
- val expected = mutableListOf<Pair<Any, IntOffset>>().apply {
+ val item1Offset = -itemSize * 2 + itemSize * 4 * fraction
+ val item5Offset = itemSize * 2 - itemSize * 4 * fraction
+ val expected = mutableListOf<Pair<Any, Offset>>().apply {
if (item1Offset > -itemSize) {
- add(1 to AxisIntOffset(0, item1Offset))
+ add(1 to AxisOffset(0f, item1Offset))
} else {
rule.onNodeWithTag("1").assertIsNotDisplayed()
}
if (item2Offset > -itemSize) {
- add(2 to AxisIntOffset(0, item2Offset))
+ add(2 to AxisOffset(0f, item2Offset))
} else {
rule.onNodeWithTag("2").assertIsNotDisplayed()
}
- add(3 to AxisIntOffset(0, 0))
+ add(3 to AxisOffset(0f, 0f))
if (item4Offset > -itemSize) {
- add(4 to AxisIntOffset(0, item4Offset))
+ add(4 to AxisOffset(0f, item4Offset))
} else {
rule.onNodeWithTag("4").assertIsNotDisplayed()
}
if (item5Offset > -itemSize) {
- add(5 to AxisIntOffset(0, item5Offset))
+ add(5 to AxisOffset(0f, item5Offset))
} else {
rule.onNodeWithTag("5").assertIsNotDisplayed()
}
@@ -1830,10 +1823,10 @@
}
assertPositions(
- 2 to AxisIntOffset(0, 0),
- 3 to AxisIntOffset(itemSize, 0),
- 4 to AxisIntOffset(0, itemSize),
- 5 to AxisIntOffset(itemSize, itemSize)
+ 2 to AxisOffset(0f, 0f),
+ 3 to AxisOffset(itemSize, 0f),
+ 4 to AxisOffset(0f, itemSize),
+ 5 to AxisOffset(itemSize, itemSize)
)
rule.runOnIdle {
@@ -1843,21 +1836,21 @@
onAnimationFrame { fraction ->
// items 0 and 2 moves from and items 4 and 5 moves to `-itemSize`,
// right before the start edge
- val items0and1Offset = -itemSize + (itemSize * 2 * fraction).roundToInt()
- val items4and5Offset = itemSize - (itemSize * 2 * fraction).roundToInt()
- val expected = mutableListOf<Pair<Any, IntOffset>>().apply {
+ val items0and1Offset = -itemSize + itemSize * 2 * fraction
+ val items4and5Offset = itemSize - itemSize * 2 * fraction
+ val expected = mutableListOf<Pair<Any, Offset>>().apply {
if (items0and1Offset > -itemSize) {
- add(0 to AxisIntOffset(0, items0and1Offset))
- add(1 to AxisIntOffset(itemSize, items0and1Offset))
+ add(0 to AxisOffset(0f, items0and1Offset))
+ add(1 to AxisOffset(itemSize, items0and1Offset))
} else {
rule.onNodeWithTag("0").assertIsNotDisplayed()
rule.onNodeWithTag("1").assertIsNotDisplayed()
}
- add(2 to AxisIntOffset(0, 0))
- add(3 to AxisIntOffset(itemSize, 0))
+ add(2 to AxisOffset(0f, 0f))
+ add(3 to AxisOffset(itemSize, 0f))
if (items4and5Offset > -itemSize) {
- add(4 to AxisIntOffset(0, items4and5Offset))
- add(5 to AxisIntOffset(itemSize, items4and5Offset))
+ add(4 to AxisOffset(0f, items4and5Offset))
+ add(5 to AxisOffset(itemSize, items4and5Offset))
} else {
rule.onNodeWithTag("4").assertIsNotDisplayed()
rule.onNodeWithTag("5").assertIsNotDisplayed()
@@ -1884,9 +1877,9 @@
}
assertPositions(
- 0 to AxisIntOffset(0, 0),
- 1 to AxisIntOffset(0, itemSize),
- 2 to AxisIntOffset(0, itemSize * 2)
+ 0 to AxisOffset(0f, 0f),
+ 1 to AxisOffset(0f, itemSize),
+ 2 to AxisOffset(0f, itemSize * 2)
)
rule.runOnIdle {
@@ -1895,30 +1888,30 @@
onAnimationFrame { fraction ->
// item 1 moves to and item 3 moves from `gridSize`, right after the end edge
- val item1Offset = itemSize + ((gridSize - itemSize) * fraction).roundToInt()
- val item3Offset = gridSize - ((gridSize - itemSize) * fraction).roundToInt()
+ val item1Offset = itemSize + (gridSize - itemSize) * fraction
+ val item3Offset = gridSize - (gridSize - itemSize) * fraction
// item 2 moves to and item 4 moves from `gridSize + itemSize`, right after item 4
- val item2Offset = itemSize * 2 + ((gridSize - itemSize) * fraction).roundToInt()
- val item4Offset = gridSize + itemSize - ((gridSize - itemSize) * fraction).roundToInt()
- val expected = mutableListOf<Pair<Any, IntOffset>>().apply {
- add(0 to AxisIntOffset(0, 0))
+ val item2Offset = itemSize * 2 + (gridSize - itemSize) * fraction
+ val item4Offset = gridSize + itemSize - (gridSize - itemSize) * fraction
+ val expected = mutableListOf<Pair<Any, Offset>>().apply {
+ add(0 to AxisOffset(0f, 0f))
if (item1Offset < gridSize) {
- add(1 to AxisIntOffset(0, item1Offset))
+ add(1 to AxisOffset(0f, item1Offset))
} else {
rule.onNodeWithTag("1").assertIsNotDisplayed()
}
if (item2Offset < gridSize) {
- add(2 to AxisIntOffset(0, item2Offset))
+ add(2 to AxisOffset(0f, item2Offset))
} else {
rule.onNodeWithTag("2").assertIsNotDisplayed()
}
if (item3Offset < gridSize) {
- add(3 to AxisIntOffset(0, item3Offset))
+ add(3 to AxisOffset(0f, item3Offset))
} else {
rule.onNodeWithTag("3").assertIsNotDisplayed()
}
if (item4Offset < gridSize) {
- add(4 to AxisIntOffset(0, item4Offset))
+ add(4 to AxisOffset(0f, item4Offset))
} else {
rule.onNodeWithTag("4").assertIsNotDisplayed()
}
@@ -1944,9 +1937,9 @@
}
assertPositions(
- 0 to AxisIntOffset(0, 0),
- 1 to AxisIntOffset(0, itemSize),
- 2 to AxisIntOffset(0, itemSize * 2)
+ 0 to AxisOffset(0f, 0f),
+ 1 to AxisOffset(0f, itemSize),
+ 2 to AxisOffset(0f, itemSize * 2)
)
rule.runOnIdle {
@@ -1955,31 +1948,31 @@
onAnimationFrame { fraction ->
// item 2 moves to and item 3 moves from `gridSize`, right after the end edge
- val item2Offset = itemSize * 2 + ((gridSize - itemSize * 2) * fraction).roundToInt()
- val item3Offset = gridSize - ((gridSize - itemSize * 2) * fraction).roundToInt()
+ val item2Offset = itemSize * 2 + (gridSize - itemSize * 2) * fraction
+ val item3Offset = gridSize - (gridSize - itemSize * 2) * fraction
// item 1 moves to and item 4 moves from `gridSize + itemSize`, right after item 4
- val item1Offset = itemSize + ((gridSize + itemSize - itemSize) * fraction).roundToInt()
+ val item1Offset = itemSize + (gridSize + itemSize - itemSize) * fraction
val item4Offset =
- gridSize + itemSize - ((gridSize + itemSize - itemSize) * fraction).roundToInt()
- val expected = mutableListOf<Pair<Any, IntOffset>>().apply {
- add(0 to AxisIntOffset(0, 0))
+ gridSize + itemSize - (gridSize + itemSize - itemSize) * fraction
+ val expected = mutableListOf<Pair<Any, Offset>>().apply {
+ add(0 to AxisOffset(0f, 0f))
if (item1Offset < gridSize) {
- add(1 to AxisIntOffset(0, item1Offset))
+ add(1 to AxisOffset(0f, item1Offset))
} else {
rule.onNodeWithTag("1").assertIsNotDisplayed()
}
if (item2Offset < gridSize) {
- add(2 to AxisIntOffset(0, item2Offset))
+ add(2 to AxisOffset(0f, item2Offset))
} else {
rule.onNodeWithTag("2").assertIsNotDisplayed()
}
if (item3Offset < gridSize) {
- add(3 to AxisIntOffset(0, item3Offset))
+ add(3 to AxisOffset(0f, item3Offset))
} else {
rule.onNodeWithTag("3").assertIsNotDisplayed()
}
if (item4Offset < gridSize) {
- add(4 to AxisIntOffset(0, item4Offset))
+ add(4 to AxisOffset(0f, item4Offset))
} else {
rule.onNodeWithTag("4").assertIsNotDisplayed()
}
@@ -2005,10 +1998,10 @@
}
assertPositions(
- 0 to AxisIntOffset(0, 0),
- 1 to AxisIntOffset(itemSize, 0),
- 2 to AxisIntOffset(0, itemSize),
- 3 to AxisIntOffset(itemSize, itemSize)
+ 0 to AxisOffset(0f, 0f),
+ 1 to AxisOffset(itemSize, 0f),
+ 2 to AxisOffset(0f, itemSize),
+ 3 to AxisOffset(itemSize, itemSize)
)
rule.runOnIdle {
@@ -2018,21 +2011,21 @@
onAnimationFrame { fraction ->
// items 4 and 5 moves from and items 2 and 3 moves to `gridSize`,
// right before the start edge
- val items4and5Offset = gridSize - ((gridSize - itemSize) * fraction).roundToInt()
- val items2and3Offset = itemSize + ((gridSize - itemSize) * fraction).roundToInt()
- val expected = mutableListOf<Pair<Any, IntOffset>>().apply {
- add(0 to AxisIntOffset(0, 0))
- add(1 to AxisIntOffset(itemSize, 0))
+ val items4and5Offset = gridSize - (gridSize - itemSize) * fraction
+ val items2and3Offset = itemSize + (gridSize - itemSize) * fraction
+ val expected = mutableListOf<Pair<Any, Offset>>().apply {
+ add(0 to AxisOffset(0f, 0f))
+ add(1 to AxisOffset(itemSize, 0f))
if (items2and3Offset < gridSize) {
- add(2 to AxisIntOffset(0, items2and3Offset))
- add(3 to AxisIntOffset(itemSize, items2and3Offset))
+ add(2 to AxisOffset(0f, items2and3Offset))
+ add(3 to AxisOffset(itemSize, items2and3Offset))
} else {
rule.onNodeWithTag("2").assertIsNotDisplayed()
rule.onNodeWithTag("3").assertIsNotDisplayed()
}
if (items4and5Offset < gridSize) {
- add(4 to AxisIntOffset(0, items4and5Offset))
- add(5 to AxisIntOffset(itemSize, items4and5Offset))
+ add(4 to AxisOffset(0f, items4and5Offset))
+ add(5 to AxisOffset(itemSize, items4and5Offset))
} else {
rule.onNodeWithTag("4").assertIsNotDisplayed()
rule.onNodeWithTag("5").assertIsNotDisplayed()
@@ -2062,8 +2055,8 @@
onAnimationFrame { fraction ->
assertPositions(
- 0 to AxisIntOffset(0, 0),
- 1 to AxisIntOffset(0, itemSize),
+ 0 to AxisOffset(0f, 0f),
+ 1 to AxisOffset(0f, itemSize),
fraction = fraction
)
rule.onNodeWithTag("2").assertIsNotDisplayed()
@@ -2087,25 +2080,26 @@
onAnimationFrame { fraction ->
assertPositions(
- 0 to AxisIntOffset(0, 0),
- 1 to AxisIntOffset(0, itemSize),
- 2 to AxisIntOffset(0, itemSize * 2),
+ 0 to AxisOffset(0f, 0f),
+ 1 to AxisOffset(0f, itemSize),
+ 2 to AxisOffset(0f, itemSize * 2),
fraction = fraction
)
}
}
- private fun AxisIntOffset(crossAxis: Int, mainAxis: Int) =
- if (isVertical) IntOffset(crossAxis, mainAxis) else IntOffset(mainAxis, crossAxis)
+ private fun AxisOffset(crossAxis: Float, mainAxis: Float) =
+ if (isVertical) Offset(crossAxis, mainAxis) else Offset(mainAxis, crossAxis)
- private val IntOffset.mainAxis: Int get() = if (isVertical) y else x
+ private val Offset.mainAxis: Float get() = if (isVertical) y else x
private fun assertPositions(
- vararg expected: Pair<Any, IntOffset>,
- crossAxis: List<Pair<Any, Int>>? = null,
+ vararg expected: Pair<Any, Offset>,
+ crossAxis: List<Pair<Any, Float>>? = null,
fraction: Float? = null,
autoReverse: Boolean = reverseLayout
) {
+ val roundedExpected = expected.map { it.first to it.second.round() }
with(rule.density) {
val actual = expected.map {
val actualOffset = rule.onNodeWithTag(it.first.toString())
@@ -2123,7 +2117,7 @@
assertWithMessage("Fraction=$fraction").that(actual)
}
subject.isEqualTo(
- listOf(*expected).let { list ->
+ roundedExpected.let { list ->
if (!autoReverse) {
list
} else {
@@ -2169,14 +2163,14 @@
"CrossAxis" + if (fraction != null) "for fraction=$fraction" else ""
)
.that(actualCross)
- .isEqualTo(crossAxis)
+ .isEqualTo(crossAxis.map { it.first to it.second.roundToInt() })
}
}
}
- private fun assertLayoutInfoPositions(vararg offsets: Pair<Any, IntOffset>) {
+ private fun assertLayoutInfoPositions(vararg offsets: Pair<Any, Offset>) {
rule.runOnIdle {
- assertThat(visibleItemsOffsets).isEqualTo(listOf(*offsets))
+ assertThat(visibleItemsOffsets).isEqualTo(offsets.map { it.first to it.second.round() })
}
}
diff --git a/compose/foundation/foundation/src/androidAndroidTest/kotlin/androidx/compose/foundation/lazy/list/LazyListAnimateItemPlacementTest.kt b/compose/foundation/foundation/src/androidAndroidTest/kotlin/androidx/compose/foundation/lazy/list/LazyListAnimateItemPlacementTest.kt
index 2dd0fb3..8a7e8ce 100644
--- a/compose/foundation/foundation/src/androidAndroidTest/kotlin/androidx/compose/foundation/lazy/list/LazyListAnimateItemPlacementTest.kt
+++ b/compose/foundation/foundation/src/androidAndroidTest/kotlin/androidx/compose/foundation/lazy/list/LazyListAnimateItemPlacementTest.kt
@@ -85,15 +85,15 @@
@get:Rule
val rule = createComposeRule()
- private val itemSize: Int = 50
+ private val itemSize: Float = 50f
private var itemSizeDp: Dp = Dp.Infinity
- private val itemSize2: Int = 30
+ private val itemSize2: Float = 30f
private var itemSize2Dp: Dp = Dp.Infinity
- private val itemSize3: Int = 20
+ private val itemSize3: Float = 20f
private var itemSize3Dp: Dp = Dp.Infinity
- private val containerSize: Int = itemSize * 5
+ private val containerSize: Float = itemSize * 5
private var containerSizeDp: Dp = Dp.Infinity
- private val spacing: Int = 10
+ private val spacing: Float = 10f
private var spacingDp: Dp = Dp.Infinity
private val itemSizePlusSpacing = itemSize + spacing
private var itemSizePlusSpacingDp = Dp.Infinity
@@ -123,7 +123,7 @@
}
}
- assertPositions(0 to 0, 1 to itemSize)
+ assertPositions(0 to 0f, 1 to itemSize)
rule.runOnIdle {
list = listOf(1, 0)
@@ -131,8 +131,8 @@
onAnimationFrame { fraction ->
assertPositions(
- 0 to 0 + (itemSize * fraction).roundToInt(),
- 1 to itemSize - (itemSize * fraction).roundToInt(),
+ 0 to 0 + itemSize * fraction,
+ 1 to itemSize - itemSize * fraction,
fraction = fraction
)
}
@@ -149,7 +149,7 @@
}
}
- assertLayoutInfoPositions(0 to 0, 1 to itemSize)
+ assertLayoutInfoPositions(0 to 0f, 1 to itemSize)
rule.runOnIdle {
list = listOf(1, 0)
@@ -157,7 +157,7 @@
onAnimationFrame {
// fraction doesn't affect the offsets in layout info
- assertLayoutInfoPositions(1 to 0, 0 to itemSize)
+ assertLayoutInfoPositions(1 to 0f, 0 to itemSize)
}
}
@@ -173,7 +173,7 @@
}
assertPositions(
- 0 to 0,
+ 0 to 0f,
1 to itemSize,
2 to itemSize * 2,
3 to itemSize * 3,
@@ -186,11 +186,11 @@
onAnimationFrame { fraction ->
assertPositions(
- 0 to 0 + (itemSize * 4 * fraction).roundToInt(),
+ 0 to 0 + itemSize * 4 * fraction,
1 to itemSize,
2 to itemSize * 2,
3 to itemSize * 3,
- 4 to itemSize * 4 - (itemSize * 4 * fraction).roundToInt(),
+ 4 to itemSize * 4 - itemSize * 4 * fraction,
fraction = fraction
)
}
@@ -208,7 +208,7 @@
}
assertPositions(
- 0 to 0,
+ 0 to 0f,
1 to itemSize,
2 to itemSize * 2,
3 to itemSize * 3,
@@ -221,11 +221,11 @@
onAnimationFrame { fraction ->
assertPositions(
- 0 to 0 + (itemSize * 4 * fraction).roundToInt(),
- 1 to itemSize - (itemSize * fraction).roundToInt(),
- 2 to itemSize * 2 - (itemSize * fraction).roundToInt(),
- 3 to itemSize * 3 - (itemSize * fraction).roundToInt(),
- 4 to itemSize * 4 - (itemSize * fraction).roundToInt(),
+ 0 to 0 + itemSize * 4 * fraction,
+ 1 to itemSize - itemSize * fraction,
+ 2 to itemSize * 2 - itemSize * fraction,
+ 3 to itemSize * 3 - itemSize * fraction,
+ 4 to itemSize * 4 - itemSize * fraction,
fraction = fraction
)
}
@@ -255,10 +255,10 @@
onAnimationFrame { fraction ->
assertPositions(
- 0 to 0,
+ 0 to 0f,
1 to itemSize,
- 2 to itemSize * 2 + (itemSize * fraction).roundToInt(),
- 3 to itemSize * 3 + (itemSize * fraction).roundToInt(),
+ 2 to itemSize * 2 + itemSize * fraction,
+ 3 to itemSize * 3 + itemSize * fraction,
fraction = fraction
)
}
@@ -282,9 +282,9 @@
onAnimationFrame { fraction ->
assertPositions(
0 to itemSize * 4,
- 1 to itemSize - (itemSize * fraction).roundToInt(),
+ 1 to itemSize - itemSize * fraction,
2 to itemSize,
- 3 to itemSize * 3 - (itemSize * fraction).roundToInt(),
+ 3 to itemSize * 3 - itemSize * fraction,
4 to itemSize * 3,
fraction = fraction
)
@@ -310,11 +310,11 @@
onAnimationFrame(duration = Duration * 2) { fraction ->
val shorterAnimFraction = (fraction * 2).coerceAtMost(1f)
assertPositions(
- 0 to 0 + (itemSize * 4 * shorterAnimFraction).roundToInt(),
- 1 to itemSize - (itemSize * fraction).roundToInt(),
- 2 to itemSize * 2 - (itemSize * shorterAnimFraction).roundToInt(),
- 3 to itemSize * 3 - (itemSize * fraction).roundToInt(),
- 4 to itemSize * 4 - (itemSize * shorterAnimFraction).roundToInt(),
+ 0 to 0 + itemSize * 4 * shorterAnimFraction,
+ 1 to itemSize - itemSize * fraction,
+ 2 to itemSize * 2 - itemSize * shorterAnimFraction,
+ 3 to itemSize * 3 - itemSize * fraction,
+ 4 to itemSize * 4 - itemSize * shorterAnimFraction,
fraction = fraction
)
}
@@ -333,7 +333,7 @@
}
assertPositions(
- 0 to 0,
+ 0 to 0f,
1 to itemSize,
2 to itemSize * 2,
3 to itemSize * 3,
@@ -345,10 +345,10 @@
onAnimationFrame { fraction ->
assertPositions(
- 0 to 0 + (itemSize * 2 * fraction).roundToInt(),
- 1 to itemSize + (itemSize * 2 * fraction).roundToInt(),
- 2 to itemSize * 2 - (itemSize * 2 * fraction).roundToInt(),
- 3 to itemSize * 3 - (itemSize * 2 * fraction).roundToInt(),
+ 0 to 0 + itemSize * 2 * fraction,
+ 1 to itemSize + itemSize * 2 * fraction,
+ 2 to itemSize * 2 - itemSize * 2 * fraction,
+ 3 to itemSize * 3 - itemSize * 2 * fraction,
fraction = fraction
)
}
@@ -372,9 +372,9 @@
onAnimationFrame { fraction ->
assertPositions(
- 0 to 0 + (itemSize * 2 * fraction).roundToInt(),
+ 0 to 0 + itemSize * 2 * fraction,
1 to itemSize * 3,
- 2 to itemSize * 2 - (itemSize * 2 * fraction).roundToInt(),
+ 2 to itemSize * 2 - itemSize * 2 * fraction,
3 to itemSize,
fraction = fraction
)
@@ -409,9 +409,9 @@
onAnimationFrame { fraction ->
assertPositions(
- 1 to itemSize - (itemSize * fraction).roundToInt(),
+ 1 to itemSize - itemSize * fraction,
2 to itemSize * 2,
- 3 to itemSize * 3 + (itemSize * fraction).roundToInt(),
+ 3 to itemSize * 3 + itemSize * fraction,
fraction = fraction
)
}
@@ -431,7 +431,7 @@
}
assertPositions(
- 0 to 0,
+ 0 to 0f,
1 to itemSize,
2 to itemSize * 2
)
@@ -442,10 +442,10 @@
onAnimationFrame { fraction ->
// item 1 moves to and item 4 moves from `listSize`, right after the end edge
- val item1Offset = itemSize + ((listSize - itemSize) * fraction).roundToInt()
- val item4Offset = listSize - ((listSize - itemSize) * fraction).roundToInt()
- val expected = mutableListOf<Pair<Any, Int>>().apply {
- add(0 to 0)
+ val item1Offset = itemSize + (listSize - itemSize) * fraction
+ val item4Offset = listSize - (listSize - itemSize) * fraction
+ val expected = mutableListOf<Pair<Any, Float>>().apply {
+ add(0 to 0f)
if (item1Offset < itemSize * 3) {
add(1 to item1Offset)
} else {
@@ -477,7 +477,7 @@
}
assertPositions(
- 3 to 0,
+ 3 to 0f,
4 to itemSize,
5 to itemSize * 2
)
@@ -488,15 +488,15 @@
onAnimationFrame { fraction ->
// item 1 moves from and item 4 moves to `0 - itemSize`, right before the start edge
- val item1Offset = -itemSize + (itemSize * 2 * fraction).roundToInt()
- val item4Offset = itemSize - (itemSize * 2 * fraction).roundToInt()
- val expected = mutableListOf<Pair<Any, Int>>().apply {
+ val item1Offset = -itemSize + itemSize * 2 * fraction
+ val item4Offset = itemSize - itemSize * 2 * fraction
+ val expected = mutableListOf<Pair<Any, Float>>().apply {
if (item4Offset > -itemSize) {
add(4 to item4Offset)
} else {
rule.onNodeWithTag("4").assertIsNotDisplayed()
}
- add(3 to 0)
+ add(3 to 0f)
if (item1Offset > -itemSize) {
add(1 to item1Offset)
} else {
@@ -526,7 +526,7 @@
}
assertPositions(
- 3 to 0,
+ 3 to 0f,
4 to itemSize
)
@@ -536,15 +536,15 @@
onAnimationFrame { fraction ->
// item 1 moves from and item 4 moves to `0 - itemSize`, right before the start edge
- val item1Offset = -itemSize + (itemSize * 2 * fraction).roundToInt()
- val item4Offset = itemSize - (itemSize * 2 * fraction).roundToInt()
- val expected = mutableListOf<Pair<Any, Int>>().apply {
+ val item1Offset = -itemSize + itemSize * 2 * fraction
+ val item4Offset = itemSize - itemSize * 2 * fraction
+ val expected = mutableListOf<Pair<Any, Float>>().apply {
if (item4Offset > -itemSize) {
add(4 to item4Offset)
} else {
rule.onNodeWithTag("4").assertIsNotDisplayed()
}
- add(3 to 0)
+ add(3 to 0f)
if (item1Offset > -itemSize) {
add(1 to item1Offset)
} else {
@@ -575,10 +575,10 @@
onAnimationFrame { fraction ->
assertPositions(
- 0 to 0 + (itemSizePlusSpacing * 3 * fraction).roundToInt(),
- 1 to itemSizePlusSpacing - (itemSizePlusSpacing * fraction).roundToInt(),
- 2 to itemSizePlusSpacing * 2 - (itemSizePlusSpacing * fraction).roundToInt(),
- 3 to itemSizePlusSpacing * 3 - (itemSizePlusSpacing * fraction).roundToInt(),
+ 0 to 0 + itemSizePlusSpacing * 3 * fraction,
+ 1 to itemSizePlusSpacing - itemSizePlusSpacing * fraction,
+ 2 to itemSizePlusSpacing * 2 - itemSizePlusSpacing * fraction,
+ 3 to itemSizePlusSpacing * 3 - itemSizePlusSpacing * fraction,
fraction = fraction
)
}
@@ -601,7 +601,7 @@
}
assertPositions(
- 0 to 0,
+ 0 to 0f,
1 to itemSizePlusSpacing,
2 to itemSizePlusSpacing * 2
)
@@ -613,12 +613,12 @@
onAnimationFrame { fraction ->
// item 1 moves to and item 4 moves from `listSize`, right after the end edge
val item1Offset =
- itemSizePlusSpacing + ((listSize - itemSizePlusSpacing) * fraction).roundToInt()
+ itemSizePlusSpacing + (listSize - itemSizePlusSpacing) * fraction
val item4Offset =
- listSize - ((listSize - itemSizePlusSpacing) * fraction).roundToInt()
+ listSize - (listSize - itemSizePlusSpacing) * fraction
val screenSize = itemSize * 3 + spacing * 2
- val expected = mutableListOf<Pair<Any, Int>>().apply {
- add(0 to 0)
+ val expected = mutableListOf<Pair<Any, Float>>().apply {
+ add(0 to 0f)
if (item1Offset < screenSize) {
add(1 to item1Offset)
} else {
@@ -654,7 +654,7 @@
}
assertPositions(
- 3 to 0,
+ 3 to 0f,
4 to itemSizePlusSpacing,
5 to itemSizePlusSpacing * 2
)
@@ -666,16 +666,16 @@
onAnimationFrame { fraction ->
// item 4 moves to and item 1 moves from `-itemSize`, right before the start edge
val item1Offset =
- -itemSize + ((itemSize + itemSizePlusSpacing) * fraction).roundToInt()
+ -itemSize + (itemSize + itemSizePlusSpacing) * fraction
val item4Offset =
- itemSizePlusSpacing - ((itemSize + itemSizePlusSpacing) * fraction).roundToInt()
- val expected = mutableListOf<Pair<Any, Int>>().apply {
+ itemSizePlusSpacing - (itemSize + itemSizePlusSpacing) * fraction
+ val expected = mutableListOf<Pair<Any, Float>>().apply {
if (item4Offset > -itemSize) {
add(4 to item4Offset)
} else {
rule.onNodeWithTag("4").assertIsNotDisplayed()
}
- add(3 to 0)
+ add(3 to 0f)
if (item1Offset > -itemSize) {
add(1 to item1Offset)
} else {
@@ -706,7 +706,7 @@
val item3Size = itemSize2
val item4Size = itemSize
assertPositions(
- 3 to 0,
+ 3 to 0f,
4 to item3Size,
5 to item3Size + item4Size
)
@@ -723,22 +723,22 @@
// item 1 moves from and item 4 moves to `0 - item size`, right before the start edge
val startItem1Offset = -item1Size
val item1Offset =
- startItem1Offset + ((itemSize2 - startItem1Offset) * fraction).roundToInt()
+ startItem1Offset + (itemSize2 - startItem1Offset) * fraction
val endItem4Offset = -item4Size
- val item4Offset = item3Size - ((item3Size - endItem4Offset) * fraction).roundToInt()
- val expected = mutableListOf<Pair<Any, Int>>().apply {
+ val item4Offset = item3Size - (item3Size - endItem4Offset) * fraction
+ val expected = mutableListOf<Pair<Any, Float>>().apply {
if (item4Offset > -item4Size) {
add(4 to item4Offset)
} else {
rule.onNodeWithTag("4").assertIsNotDisplayed()
}
- add(3 to 0)
+ add(3 to 0f)
if (item1Offset > -item1Size) {
add(1 to item1Offset)
} else {
rule.onNodeWithTag("1").assertIsNotDisplayed()
}
- add(5 to item3Size + item4Size - ((item4Size - item1Size) * fraction).roundToInt())
+ add(5 to item3Size + item4Size - (item4Size - item1Size) * fraction)
}
assertPositions(
expected = expected.toTypedArray(),
@@ -765,7 +765,7 @@
val item0Size = itemSize2
val item1Size = itemSize
assertPositions(
- 0 to 0,
+ 0 to 0f,
1 to item0Size,
2 to item0Size + item1Size
)
@@ -780,17 +780,17 @@
val endItem1Offset = listSize
val item4Size = itemSize3
val item1Offset =
- item0Size + ((endItem1Offset - item0Size) * fraction).roundToInt()
+ item0Size + (endItem1Offset - item0Size) * fraction
val item4Offset =
- startItem4Offset - ((startItem4Offset - item0Size) * fraction).roundToInt()
- val expected = mutableListOf<Pair<Any, Int>>().apply {
- add(0 to 0)
+ startItem4Offset - (startItem4Offset - item0Size) * fraction
+ val expected = mutableListOf<Pair<Any, Float>>().apply {
+ add(0 to 0f)
if (item1Offset < listSize) {
add(1 to item1Offset)
} else {
rule.onNodeWithTag("1").assertIsNotDisplayed()
}
- add(2 to item0Size + item1Size - ((item1Size - item4Size) * fraction).roundToInt())
+ add(2 to item0Size + item1Size - (item1Size - item4Size) * fraction)
if (item4Offset < listSize) {
add(4 to item4Offset)
} else {
@@ -823,11 +823,11 @@
val item2Start = itemSize - itemSize2
val item3Start = itemSize - itemSize3
assertPositions(
- 1 to 0,
+ 1 to 0f,
2 to itemSize,
3 to itemSize * 2,
crossAxis = listOf(
- 1 to 0,
+ 1 to 0f,
2 to item2Start,
3 to item3Start,
)
@@ -842,13 +842,13 @@
val item3End = itemSize / 2 - itemSize3 / 2
onAnimationFrame { fraction ->
assertPositions(
- 1 to 0,
+ 1 to 0f,
2 to itemSize,
3 to itemSize * 2,
crossAxis = listOf(
- 1 to 0,
- 2 to item2Start + ((item2End - item2Start) * fraction).roundToInt(),
- 3 to item3Start + ((item3End - item3Start) * fraction).roundToInt(),
+ 1 to 0f,
+ 2 to item2Start + (item2End - item2Start) * fraction,
+ 3 to item3Start + (item3End - item3Start) * fraction,
),
fraction = fraction
)
@@ -881,13 +881,13 @@
val containerSize = itemSize * 2
onAnimationFrame { fraction ->
assertPositions(
- 1 to 0,
+ 1 to 0f,
2 to itemSize,
3 to itemSize * 2,
crossAxis = listOf(
- 1 to ((containerSize - itemSize) * fraction).roundToInt(),
- 2 to ((containerSize - itemSize2) * fraction).roundToInt(),
- 3 to ((containerSize - itemSize3) * fraction).roundToInt()
+ 1 to (containerSize - itemSize) * fraction,
+ 2 to (containerSize - itemSize2) * fraction,
+ 3 to (containerSize - itemSize3) * fraction
),
fraction = fraction
)
@@ -916,13 +916,13 @@
}
assertPositions(
- 1 to 0,
+ 1 to 0f,
2 to itemSize,
3 to itemSize * 2,
crossAxis = listOf(
- 1 to 0,
- 2 to 0,
- 3 to 0,
+ 1 to 0f,
+ 2 to 0f,
+ 3 to 0f,
)
)
@@ -933,13 +933,13 @@
onAnimationFrame { fraction ->
assertPositions(
- 1 to 0,
+ 1 to 0f,
2 to itemSize,
3 to itemSize * 2,
crossAxis = listOf(
- 1 to 0,
- 2 to ((itemSize / 2 - itemSize2 / 2) * fraction).roundToInt(),
- 3 to ((itemSize / 2 - itemSize3 / 2) * fraction).roundToInt(),
+ 1 to 0f,
+ 2 to (itemSize / 2 - itemSize2 / 2) * fraction,
+ 3 to (itemSize / 2 - itemSize3 / 2) * fraction
),
fraction = fraction
)
@@ -949,8 +949,8 @@
@Test
fun moveItemToEndCausingNextItemsToAnimate_withContentPadding() {
var list by mutableStateOf(listOf(0, 1, 2, 3, 4))
- val rawStartPadding = 8
- val rawEndPadding = 12
+ val rawStartPadding = 8f
+ val rawEndPadding = 12f
val (startPaddingDp, endPaddingDp) = with(rule.density) {
rawStartPadding.toDp() to rawEndPadding.toDp()
}
@@ -978,10 +978,10 @@
onAnimationFrame { fraction ->
assertPositions(
0 to startPadding,
- 1 to startPadding + itemSize + (itemSize * 3 * fraction).roundToInt(),
- 2 to startPadding + itemSize * 2 - (itemSize * fraction).roundToInt(),
- 3 to startPadding + itemSize * 3 - (itemSize * fraction).roundToInt(),
- 4 to startPadding + itemSize * 4 - (itemSize * fraction).roundToInt(),
+ 1 to startPadding + itemSize + itemSize * 3 * fraction,
+ 2 to startPadding + itemSize * 2 - itemSize * fraction,
+ 3 to startPadding + itemSize * 3 - itemSize * fraction,
+ 4 to startPadding + itemSize * 4 - itemSize * fraction,
fraction = fraction
)
}
@@ -1035,7 +1035,7 @@
rule.runOnIdle {
runBlocking {
- state.scrollToItem(0, itemSize / 2)
+ state.scrollToItem(0, (itemSize / 2).roundToInt())
}
}
@@ -1231,9 +1231,9 @@
onAnimationFrame { fraction ->
// item 1 moves to `listSize`
- val item1Offset = itemSize + ((listSize - itemSize) * fraction).roundToInt()
- val expected = mutableListOf<Pair<Any, Int>>().apply {
- add(0 to 0)
+ val item1Offset = itemSize + (listSize - itemSize) * fraction
+ val expected = mutableListOf<Pair<Any, Float>>().apply {
+ add(0 to 0f)
if (item1Offset < listSize) {
add(1 to item1Offset)
} else {
@@ -1259,7 +1259,7 @@
}
assertPositions(
- 3 to 0,
+ 3 to 0f,
4 to itemSize,
5 to itemSize * 2
)
@@ -1270,12 +1270,12 @@
onAnimationFrame { fraction ->
// item 2 moves from and item 5 moves to `-itemSize`, right before the start edge
- val item2Offset = -itemSize + (itemSize * 3 * fraction).roundToInt()
- val item5Offset = itemSize * 2 - (itemSize * 3 * fraction).roundToInt()
+ val item2Offset = -itemSize + itemSize * 3 * fraction
+ val item5Offset = itemSize * 2 - itemSize * 3 * fraction
// item 1 moves from and item 4 moves to `-itemSize * 2`, right before item 2
- val item1Offset = -itemSize * 2 + (itemSize * 3 * fraction).roundToInt()
- val item4Offset = itemSize - (itemSize * 3 * fraction).roundToInt()
- val expected = mutableListOf<Pair<Any, Int>>().apply {
+ val item1Offset = -itemSize * 2 + itemSize * 3 * fraction
+ val item4Offset = itemSize - itemSize * 3 * fraction
+ val expected = mutableListOf<Pair<Any, Float>>().apply {
if (item1Offset > -itemSize) {
add(1 to item1Offset)
} else {
@@ -1286,7 +1286,7 @@
} else {
rule.onNodeWithTag("2").assertIsNotDisplayed()
}
- add(3 to 0)
+ add(3 to 0f)
if (item4Offset > -itemSize) {
add(4 to item4Offset)
} else {
@@ -1317,7 +1317,7 @@
}
assertPositions(
- 3 to 0,
+ 3 to 0f,
4 to itemSize,
5 to itemSize * 2
)
@@ -1328,12 +1328,12 @@
onAnimationFrame { fraction ->
// item 2 moves from and item 4 moves to `-itemSize`, right before the start edge
- val item2Offset = -itemSize + (itemSize * 2 * fraction).roundToInt()
- val item4Offset = itemSize - (itemSize * 2 * fraction).roundToInt()
+ val item2Offset = -itemSize + itemSize * 2 * fraction
+ val item4Offset = itemSize - itemSize * 2 * fraction
// item 1 moves from and item 5 moves to `-itemSize * 2`, right before item 2
- val item1Offset = -itemSize * 2 + (itemSize * 4 * fraction).roundToInt()
- val item5Offset = itemSize * 2 - (itemSize * 4 * fraction).roundToInt()
- val expected = mutableListOf<Pair<Any, Int>>().apply {
+ val item1Offset = -itemSize * 2 + itemSize * 4 * fraction
+ val item5Offset = itemSize * 2 - itemSize * 4 * fraction
+ val expected = mutableListOf<Pair<Any, Float>>().apply {
if (item1Offset > -itemSize) {
add(1 to item1Offset)
} else {
@@ -1344,7 +1344,7 @@
} else {
rule.onNodeWithTag("2").assertIsNotDisplayed()
}
- add(3 to 0)
+ add(3 to 0f)
if (item4Offset > -itemSize) {
add(4 to item4Offset)
} else {
@@ -1377,7 +1377,7 @@
}
assertPositions(
- 0 to 0,
+ 0 to 0f,
1 to itemSize,
2 to itemSize * 2
)
@@ -1388,13 +1388,13 @@
onAnimationFrame { fraction ->
// item 1 moves to and item 3 moves from `listSize`, right after the end edge
- val item1Offset = itemSize + ((listSize - itemSize) * fraction).roundToInt()
- val item3Offset = listSize - ((listSize - itemSize) * fraction).roundToInt()
+ val item1Offset = itemSize + (listSize - itemSize) * fraction
+ val item3Offset = listSize - (listSize - itemSize) * fraction
// item 2 moves to and item 4 moves from `listSize + itemSize`, right after item 4
- val item2Offset = itemSize * 2 + ((listSize - itemSize) * fraction).roundToInt()
- val item4Offset = listSize + itemSize - ((listSize - itemSize) * fraction).roundToInt()
- val expected = mutableListOf<Pair<Any, Int>>().apply {
- add(0 to 0)
+ val item2Offset = itemSize * 2 + (listSize - itemSize) * fraction
+ val item4Offset = listSize + itemSize - (listSize - itemSize) * fraction
+ val expected = mutableListOf<Pair<Any, Float>>().apply {
+ add(0 to 0f)
if (item1Offset < listSize) {
add(1 to item1Offset)
} else {
@@ -1437,7 +1437,7 @@
}
assertPositions(
- 0 to 0,
+ 0 to 0f,
1 to itemSize,
2 to itemSize * 2
)
@@ -1448,14 +1448,14 @@
onAnimationFrame { fraction ->
// item 2 moves to and item 3 moves from `listSize`, right after the end edge
- val item2Offset = itemSize * 2 + ((listSize - itemSize * 2) * fraction).roundToInt()
- val item3Offset = listSize - ((listSize - itemSize * 2) * fraction).roundToInt()
+ val item2Offset = itemSize * 2 + (listSize - itemSize * 2) * fraction
+ val item3Offset = listSize - (listSize - itemSize * 2) * fraction
// item 1 moves to and item 4 moves from `listSize + itemSize`, right after item 4
- val item1Offset = itemSize + ((listSize + itemSize - itemSize) * fraction).roundToInt()
+ val item1Offset = itemSize + (listSize + itemSize - itemSize) * fraction
val item4Offset =
- listSize + itemSize - ((listSize + itemSize - itemSize) * fraction).roundToInt()
- val expected = mutableListOf<Pair<Any, Int>>().apply {
- add(0 to 0)
+ listSize + itemSize - (listSize + itemSize - itemSize) * fraction
+ val expected = mutableListOf<Pair<Any, Float>>().apply {
+ add(0 to 0f)
if (item1Offset < listSize) {
add(1 to item1Offset)
} else {
@@ -1501,7 +1501,7 @@
onAnimationFrame { fraction ->
assertPositions(
- 0 to 0,
+ 0 to 0f,
1 to itemSize,
fraction = fraction
)
@@ -1526,7 +1526,7 @@
onAnimationFrame { fraction ->
assertPositions(
- 0 to 0,
+ 0 to 0f,
1 to itemSize,
2 to itemSize * 2,
fraction = fraction
@@ -1535,11 +1535,12 @@
}
private fun assertPositions(
- vararg expected: Pair<Any, Int>,
- crossAxis: List<Pair<Any, Int>>? = null,
+ vararg expected: Pair<Any, Float>,
+ crossAxis: List<Pair<Any, Float>>? = null,
fraction: Float? = null,
autoReverse: Boolean = reverseLayout
) {
+ val roundedExpected = expected.map { it.first to it.second.roundToInt() }
with(rule.density) {
val actual = expected.map {
val actualOffset = rule.onNodeWithTag(it.first.toString())
@@ -1555,7 +1556,7 @@
assertWithMessage("Fraction=$fraction").that(actual)
}
subject.isEqualTo(
- listOf(*expected).let { list ->
+ roundedExpected.let { list ->
if (!autoReverse) {
list
} else {
@@ -1586,14 +1587,16 @@
"CrossAxis" + if (fraction != null) "for fraction=$fraction" else ""
)
.that(actualCross)
- .isEqualTo(crossAxis)
+ .isEqualTo(crossAxis.map { it.first to it.second.roundToInt() })
}
}
}
- private fun assertLayoutInfoPositions(vararg offsets: Pair<Any, Int>) {
+ private fun assertLayoutInfoPositions(vararg offsets: Pair<Any, Float>) {
rule.runOnIdle {
- assertThat(visibleItemsOffsets).isEqualTo(listOf(*offsets))
+ assertThat(visibleItemsOffsets).isEqualTo(offsets.map {
+ it.first to it.second.roundToInt()
+ })
}
}
diff --git a/tv/tv-foundation/src/androidTest/java/androidx/tv/foundation/lazy/grid/LazyGridAnimateItemPlacementTest.kt b/tv/tv-foundation/src/androidTest/java/androidx/tv/foundation/lazy/grid/LazyGridAnimateItemPlacementTest.kt
index 7c4bb72..4275da8 100644
--- a/tv/tv-foundation/src/androidTest/java/androidx/tv/foundation/lazy/grid/LazyGridAnimateItemPlacementTest.kt
+++ b/tv/tv-foundation/src/androidTest/java/androidx/tv/foundation/lazy/grid/LazyGridAnimateItemPlacementTest.kt
@@ -35,6 +35,7 @@
import androidx.compose.runtime.setValue
import androidx.compose.runtime.snapshotFlow
import androidx.compose.ui.Modifier
+import androidx.compose.ui.geometry.Offset
import androidx.compose.ui.platform.testTag
import androidx.compose.ui.test.SemanticsNodeInteraction
import androidx.compose.ui.test.assertHeightIsEqualTo
@@ -50,6 +51,7 @@
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.height
import androidx.compose.ui.unit.isSpecified
+import androidx.compose.ui.unit.round
import androidx.compose.ui.unit.width
import androidx.test.filters.LargeTest
import com.google.common.truth.Truth.assertThat
@@ -73,15 +75,15 @@
@get:Rule
val rule = createComposeRule()
- private val itemSize: Int = 50
+ private val itemSize: Float = 50f
private var itemSizeDp: Dp = Dp.Infinity
- private val itemSize2: Int = 30
+ private val itemSize2: Float = 30f
private var itemSize2Dp: Dp = Dp.Infinity
- private val itemSize3: Int = 20
+ private val itemSize3: Float = 20f
private var itemSize3Dp: Dp = Dp.Infinity
- private val containerSize: Int = itemSize * 5
+ private val containerSize: Float = itemSize * 5
private var containerSizeDp: Dp = Dp.Infinity
- private val spacing: Int = 10
+ private val spacing: Float = 10f
private var spacingDp: Dp = Dp.Infinity
private val itemSizePlusSpacing = itemSize + spacing
private var itemSizePlusSpacingDp = Dp.Infinity
@@ -112,8 +114,8 @@
}
assertPositions(
- 0 to AxisIntOffset(0, 0),
- 1 to AxisIntOffset(0, itemSize)
+ 0 to AxisOffset(0f, 0f),
+ 1 to AxisOffset(0f, itemSize)
)
rule.runOnIdle {
@@ -122,8 +124,8 @@
onAnimationFrame { fraction ->
assertPositions(
- 0 to AxisIntOffset(0, 0 + (itemSize * fraction).roundToInt()),
- 1 to AxisIntOffset(0, itemSize - (itemSize * fraction).roundToInt()),
+ 0 to AxisOffset(0f, 0f + itemSize * fraction),
+ 1 to AxisOffset(0f, itemSize - itemSize * fraction),
fraction = fraction
)
}
@@ -141,10 +143,10 @@
}
assertPositions(
- 0 to AxisIntOffset(0, 0),
- 1 to AxisIntOffset(itemSize, 0),
- 2 to AxisIntOffset(0, itemSize),
- 3 to AxisIntOffset(itemSize, itemSize)
+ 0 to AxisOffset(0f, 0f),
+ 1 to AxisOffset(itemSize, 0f),
+ 2 to AxisOffset(0f, itemSize),
+ 3 to AxisOffset(itemSize, itemSize)
)
rule.runOnIdle {
@@ -152,13 +154,13 @@
}
onAnimationFrame { fraction ->
- val increasing = 0 + (itemSize * fraction).roundToInt()
- val decreasing = itemSize - (itemSize * fraction).roundToInt()
+ val increasing = 0 + itemSize * fraction
+ val decreasing = itemSize - itemSize * fraction
assertPositions(
- 0 to AxisIntOffset(increasing, increasing),
- 1 to AxisIntOffset(decreasing, increasing),
- 2 to AxisIntOffset(increasing, decreasing),
- 3 to AxisIntOffset(decreasing, decreasing),
+ 0 to AxisOffset(increasing, increasing),
+ 1 to AxisOffset(decreasing, increasing),
+ 2 to AxisOffset(increasing, decreasing),
+ 3 to AxisOffset(decreasing, decreasing),
fraction = fraction
)
}
@@ -176,10 +178,10 @@
}
assertLayoutInfoPositions(
- 0 to AxisIntOffset(0, 0),
- 1 to AxisIntOffset(itemSize, 0),
- 2 to AxisIntOffset(0, itemSize),
- 3 to AxisIntOffset(itemSize, itemSize)
+ 0 to AxisOffset(0f, 0f),
+ 1 to AxisOffset(itemSize, 0f),
+ 2 to AxisOffset(0f, itemSize),
+ 3 to AxisOffset(itemSize, itemSize)
)
rule.runOnIdle {
@@ -189,10 +191,10 @@
onAnimationFrame {
// fraction doesn't affect the offsets in layout info
assertLayoutInfoPositions(
- 3 to AxisIntOffset(0, 0),
- 2 to AxisIntOffset(itemSize, 0),
- 1 to AxisIntOffset(0, itemSize),
- 0 to AxisIntOffset(itemSize, itemSize)
+ 3 to AxisOffset(0f, 0f),
+ 2 to AxisOffset(itemSize, 0f),
+ 1 to AxisOffset(0f, itemSize),
+ 0 to AxisOffset(itemSize, itemSize)
)
}
}
@@ -209,11 +211,11 @@
}
assertPositions(
- 0 to AxisIntOffset(0, 0),
- 1 to AxisIntOffset(0, itemSize),
- 2 to AxisIntOffset(0, itemSize * 2),
- 3 to AxisIntOffset(0, itemSize * 3),
- 4 to AxisIntOffset(0, itemSize * 4)
+ 0 to AxisOffset(0f, 0f),
+ 1 to AxisOffset(0f, itemSize),
+ 2 to AxisOffset(0f, itemSize * 2),
+ 3 to AxisOffset(0f, itemSize * 3),
+ 4 to AxisOffset(0f, itemSize * 4)
)
rule.runOnIdle {
@@ -222,11 +224,11 @@
onAnimationFrame { fraction ->
assertPositions(
- 0 to AxisIntOffset(0, 0 + (itemSize * 4 * fraction).roundToInt()),
- 1 to AxisIntOffset(0, itemSize),
- 2 to AxisIntOffset(0, itemSize * 2),
- 3 to AxisIntOffset(0, itemSize * 3),
- 4 to AxisIntOffset(0, itemSize * 4 - (itemSize * 4 * fraction).roundToInt()),
+ 0 to AxisOffset(0f, 0f + itemSize * 4 * fraction),
+ 1 to AxisOffset(0f, itemSize),
+ 2 to AxisOffset(0f, itemSize * 2),
+ 3 to AxisOffset(0f, itemSize * 3),
+ 4 to AxisOffset(0f, itemSize * 4 - itemSize * 4 * fraction),
fraction = fraction
)
}
@@ -244,12 +246,12 @@
}
assertPositions(
- 0 to AxisIntOffset(0, 0),
- 1 to AxisIntOffset(itemSize, 0),
- 2 to AxisIntOffset(0, itemSize),
- 3 to AxisIntOffset(itemSize, itemSize),
- 4 to AxisIntOffset(0, itemSize * 2),
- 5 to AxisIntOffset(itemSize, itemSize * 2)
+ 0 to AxisOffset(0f, 0f),
+ 1 to AxisOffset(itemSize, 0f),
+ 2 to AxisOffset(0f, itemSize),
+ 3 to AxisOffset(itemSize, itemSize),
+ 4 to AxisOffset(0f, itemSize * 2),
+ 5 to AxisOffset(itemSize, itemSize * 2)
)
rule.runOnIdle {
@@ -257,15 +259,15 @@
}
onAnimationFrame { fraction ->
- val increasingX = 0 + (itemSize * fraction).roundToInt()
- val decreasingX = itemSize - (itemSize * fraction).roundToInt()
+ val increasingX = 0 + itemSize * fraction
+ val decreasingX = itemSize - itemSize * fraction
assertPositions(
- 0 to AxisIntOffset(increasingX, 0 + (itemSize * 2 * fraction).roundToInt()),
- 1 to AxisIntOffset(decreasingX, 0),
- 2 to AxisIntOffset(increasingX, itemSize - (itemSize * fraction).roundToInt()),
- 3 to AxisIntOffset(decreasingX, itemSize),
- 4 to AxisIntOffset(increasingX, itemSize * 2 - (itemSize * fraction).roundToInt()),
- 5 to AxisIntOffset(decreasingX, itemSize * 2),
+ 0 to AxisOffset(increasingX, 0f + itemSize * 2 * fraction),
+ 1 to AxisOffset(decreasingX, 0f),
+ 2 to AxisOffset(increasingX, itemSize - itemSize * fraction),
+ 3 to AxisOffset(decreasingX, itemSize),
+ 4 to AxisOffset(increasingX, itemSize * 2 - itemSize * fraction),
+ 5 to AxisOffset(decreasingX, itemSize * 2),
fraction = fraction
)
}
@@ -292,10 +294,10 @@
onAnimationFrame { fraction ->
assertPositions(
- 0 to AxisIntOffset(0, 0),
- 1 to AxisIntOffset(0, itemSize),
- 2 to AxisIntOffset(0, itemSize * 2 + (itemSize * fraction).roundToInt()),
- 3 to AxisIntOffset(0, itemSize * 3 + (itemSize * fraction).roundToInt()),
+ 0 to AxisOffset(0f, 0f),
+ 1 to AxisOffset(0f, itemSize),
+ 2 to AxisOffset(0f, itemSize * 2 + itemSize * fraction),
+ 3 to AxisOffset(0f, itemSize * 3 + itemSize * fraction),
fraction = fraction
)
}
@@ -318,11 +320,11 @@
onAnimationFrame { fraction ->
assertPositions(
- 0 to AxisIntOffset(0, itemSize * 4),
- 1 to AxisIntOffset(0, itemSize - (itemSize * fraction).roundToInt()),
- 2 to AxisIntOffset(0, itemSize),
- 3 to AxisIntOffset(0, itemSize * 3 - (itemSize * fraction).roundToInt()),
- 4 to AxisIntOffset(0, itemSize * 3),
+ 0 to AxisOffset(0f, itemSize * 4),
+ 1 to AxisOffset(0f, itemSize - itemSize * fraction),
+ 2 to AxisOffset(0f, itemSize),
+ 3 to AxisOffset(0f, itemSize * 3 - itemSize * fraction),
+ 4 to AxisOffset(0f, itemSize * 3),
fraction = fraction
)
}
@@ -347,11 +349,11 @@
onAnimationFrame(duration = Duration * 2) { fraction ->
val shorterAnimFraction = (fraction * 2).coerceAtMost(1f)
assertPositions(
- 0 to AxisIntOffset(0, 0 + (itemSize * 4 * shorterAnimFraction).roundToInt()),
- 1 to AxisIntOffset(0, itemSize - (itemSize * fraction).roundToInt()),
- 2 to AxisIntOffset(0, itemSize * 2 - (itemSize * shorterAnimFraction).roundToInt()),
- 3 to AxisIntOffset(0, itemSize * 3 - (itemSize * fraction).roundToInt()),
- 4 to AxisIntOffset(0, itemSize * 4 - (itemSize * shorterAnimFraction).roundToInt()),
+ 0 to AxisOffset(0f, 0 + itemSize * 4 * shorterAnimFraction),
+ 1 to AxisOffset(0f, itemSize - itemSize * fraction),
+ 2 to AxisOffset(0f, itemSize * 2 - itemSize * shorterAnimFraction),
+ 3 to AxisOffset(0f, itemSize * 3 - itemSize * fraction),
+ 4 to AxisOffset(0f, itemSize * 4 - itemSize * shorterAnimFraction),
fraction = fraction
)
}
@@ -370,10 +372,10 @@
}
assertPositions(
- 0 to AxisIntOffset(0, 0),
- 1 to AxisIntOffset(0, 0),
- 2 to AxisIntOffset(0, itemSize),
- 3 to AxisIntOffset(0, itemSize)
+ 0 to AxisOffset(0f, 0f),
+ 1 to AxisOffset(0f, 0f),
+ 2 to AxisOffset(0f, itemSize),
+ 3 to AxisOffset(0f, itemSize)
)
rule.runOnIdle {
@@ -382,10 +384,10 @@
onAnimationFrame { fraction ->
assertPositions(
- 0 to AxisIntOffset(0, 0 + (itemSize * fraction).roundToInt()),
- 1 to AxisIntOffset(0, 0 + (itemSize * fraction).roundToInt()),
- 2 to AxisIntOffset(0, itemSize - (itemSize * fraction).roundToInt()),
- 3 to AxisIntOffset(0, itemSize - (itemSize * fraction).roundToInt()),
+ 0 to AxisOffset(0f, 0 + itemSize * fraction),
+ 1 to AxisOffset(0f, 0 + itemSize * fraction),
+ 2 to AxisOffset(0f, itemSize - itemSize * fraction),
+ 3 to AxisOffset(0f, itemSize - itemSize * fraction),
fraction = fraction
)
}
@@ -409,10 +411,10 @@
onAnimationFrame { fraction ->
assertPositions(
- 0 to AxisIntOffset(0, 0 + (itemSize * fraction).roundToInt()),
- 1 to AxisIntOffset(0, itemSize),
- 2 to AxisIntOffset(0, itemSize - (itemSize * fraction).roundToInt()),
- 3 to AxisIntOffset(0, 0),
+ 0 to AxisOffset(0f, 0 + itemSize * fraction),
+ 1 to AxisOffset(0f, itemSize),
+ 2 to AxisOffset(0f, itemSize - itemSize * fraction),
+ 3 to AxisOffset(0f, 0f),
fraction = fraction
)
}
@@ -435,9 +437,9 @@
}
assertPositions(
- 1 to AxisIntOffset(0, itemSize),
- 2 to AxisIntOffset(0, itemSize * 2),
- 3 to AxisIntOffset(0, itemSize * 3),
+ 1 to AxisOffset(0f, itemSize),
+ 2 to AxisOffset(0f, itemSize * 2),
+ 3 to AxisOffset(0f, itemSize * 3),
)
rule.runOnIdle {
@@ -447,9 +449,9 @@
onAnimationFrame { fraction ->
assertPositions(
- 1 to AxisIntOffset(0, itemSize - (itemSize * fraction).roundToInt()),
- 2 to AxisIntOffset(0, itemSize * 2),
- 3 to AxisIntOffset(0, itemSize * 3 + (itemSize * fraction).roundToInt()),
+ 1 to AxisOffset(0f, itemSize - itemSize * fraction),
+ 2 to AxisOffset(0f, itemSize * 2),
+ 3 to AxisOffset(0f, itemSize * 3 + itemSize * fraction),
fraction = fraction
)
}
@@ -469,12 +471,12 @@
}
assertPositions(
- 0 to AxisIntOffset(0, 0),
- 1 to AxisIntOffset(itemSize, 0),
- 2 to AxisIntOffset(0, itemSize),
- 3 to AxisIntOffset(itemSize, itemSize),
- 4 to AxisIntOffset(0, itemSize * 2),
- 5 to AxisIntOffset(itemSize, itemSize * 2)
+ 0 to AxisOffset(0f, 0f),
+ 1 to AxisOffset(itemSize, 0f),
+ 2 to AxisOffset(0f, itemSize),
+ 3 to AxisOffset(itemSize, itemSize),
+ 4 to AxisOffset(0f, itemSize * 2),
+ 5 to AxisOffset(itemSize, itemSize * 2)
)
rule.runOnIdle {
@@ -483,20 +485,20 @@
onAnimationFrame { fraction ->
// item 1 moves to and item 8 moves from `gridSize`, right after the end edge
- val item1Offset = AxisIntOffset(itemSize, 0 + (gridSize * fraction).roundToInt())
+ val item1Offset = AxisOffset(itemSize, 0 + gridSize * fraction)
val item8Offset =
- AxisIntOffset(itemSize, gridSize - (gridSize * fraction).roundToInt())
- val expected = mutableListOf<Pair<Any, IntOffset>>().apply {
- add(0 to AxisIntOffset(0, 0))
+ AxisOffset(itemSize, gridSize - gridSize * fraction)
+ val expected = mutableListOf<Pair<Any, Offset>>().apply {
+ add(0 to AxisOffset(0f, 0f))
if (item1Offset.mainAxis < itemSize * 3) {
add(1 to item1Offset)
} else {
rule.onNodeWithTag("1").assertIsNotDisplayed()
}
- add(2 to AxisIntOffset(0, itemSize))
- add(3 to AxisIntOffset(itemSize, itemSize))
- add(4 to AxisIntOffset(0, itemSize * 2))
- add(5 to AxisIntOffset(itemSize, itemSize * 2))
+ add(2 to AxisOffset(0f, itemSize))
+ add(3 to AxisOffset(itemSize, itemSize))
+ add(4 to AxisOffset(0f, itemSize * 2))
+ add(5 to AxisOffset(itemSize, itemSize * 2))
if (item8Offset.mainAxis < itemSize * 3) {
add(8 to item8Offset)
} else {
@@ -522,12 +524,12 @@
}
assertPositions(
- 6 to AxisIntOffset(0, 0),
- 7 to AxisIntOffset(itemSize, 0),
- 8 to AxisIntOffset(0, itemSize),
- 9 to AxisIntOffset(itemSize, itemSize),
- 10 to AxisIntOffset(0, itemSize * 2),
- 11 to AxisIntOffset(itemSize, itemSize * 2)
+ 6 to AxisOffset(0f, 0f),
+ 7 to AxisOffset(itemSize, 0f),
+ 8 to AxisOffset(0f, itemSize),
+ 9 to AxisOffset(itemSize, itemSize),
+ 10 to AxisOffset(0f, itemSize * 2),
+ 11 to AxisOffset(itemSize, itemSize * 2)
)
rule.runOnIdle {
@@ -536,27 +538,24 @@
onAnimationFrame { fraction ->
// item 1 moves from and item 8 moves to `0 - itemSize`, right before the start edge
- val item8Offset = AxisIntOffset(0, itemSize - (itemSize * 2 * fraction).roundToInt())
- val item1Offset = AxisIntOffset(
- 0,
- -itemSize + (itemSize * 2 * fraction).roundToInt()
- )
- val expected = mutableListOf<Pair<Any, IntOffset>>().apply {
+ val item8Offset = AxisOffset(0f, itemSize - itemSize * 2 * fraction)
+ val item1Offset = AxisOffset(0f, -itemSize + itemSize * 2 * fraction)
+ val expected = mutableListOf<Pair<Any, Offset>>().apply {
if (item1Offset.mainAxis > -itemSize) {
add(1 to item1Offset)
} else {
rule.onNodeWithTag("1").assertIsNotDisplayed()
}
- add(6 to AxisIntOffset(0, 0))
- add(7 to AxisIntOffset(itemSize, 0))
+ add(6 to AxisOffset(0f, 0f))
+ add(7 to AxisOffset(itemSize, 0f))
if (item8Offset.mainAxis > -itemSize) {
add(8 to item8Offset)
} else {
rule.onNodeWithTag("8").assertIsNotDisplayed()
}
- add(9 to AxisIntOffset(itemSize, itemSize))
- add(10 to AxisIntOffset(0, itemSize * 2))
- add(11 to AxisIntOffset(itemSize, itemSize * 2))
+ add(9 to AxisOffset(itemSize, itemSize))
+ add(10 to AxisOffset(0f, itemSize * 2))
+ add(11 to AxisOffset(itemSize, itemSize * 2))
}
assertPositions(
expected = expected.toTypedArray(),
@@ -581,26 +580,26 @@
}
onAnimationFrame { fraction ->
- val increasingX = (fraction * itemSize).roundToInt()
- val decreasingX = (itemSize - itemSize * fraction).roundToInt()
+ val increasingX = fraction * itemSize
+ val decreasingX = itemSize - itemSize * fraction
assertPositions(
- 0 to AxisIntOffset(increasingX, (itemSizePlusSpacing * 3 * fraction).roundToInt()),
- 1 to AxisIntOffset(decreasingX, 0),
- 2 to AxisIntOffset(
+ 0 to AxisOffset(increasingX, itemSizePlusSpacing * 3 * fraction),
+ 1 to AxisOffset(decreasingX, 0f),
+ 2 to AxisOffset(
increasingX,
- itemSizePlusSpacing - (itemSizePlusSpacing * fraction).roundToInt()
+ itemSizePlusSpacing - itemSizePlusSpacing * fraction
),
- 3 to AxisIntOffset(decreasingX, itemSizePlusSpacing),
- 4 to AxisIntOffset(
+ 3 to AxisOffset(decreasingX, itemSizePlusSpacing),
+ 4 to AxisOffset(
increasingX,
- itemSizePlusSpacing * 2 - (itemSizePlusSpacing * fraction).roundToInt()
+ itemSizePlusSpacing * 2 - itemSizePlusSpacing * fraction
),
- 5 to AxisIntOffset(decreasingX, itemSizePlusSpacing * 2),
- 6 to AxisIntOffset(
+ 5 to AxisOffset(decreasingX, itemSizePlusSpacing * 2),
+ 6 to AxisOffset(
increasingX,
- itemSizePlusSpacing * 3 - (itemSizePlusSpacing * fraction).roundToInt()
+ itemSizePlusSpacing * 3 - itemSizePlusSpacing * fraction
),
- 7 to AxisIntOffset(decreasingX, itemSizePlusSpacing * 3),
+ 7 to AxisOffset(decreasingX, itemSizePlusSpacing * 3),
fraction = fraction
)
}
@@ -624,12 +623,12 @@
}
assertPositions(
- 0 to AxisIntOffset(0, 0),
- 1 to AxisIntOffset(itemSize, 0),
- 2 to AxisIntOffset(0, itemSizePlusSpacing),
- 3 to AxisIntOffset(itemSize, itemSizePlusSpacing),
- 4 to AxisIntOffset(0, itemSizePlusSpacing * 2),
- 5 to AxisIntOffset(itemSize, itemSizePlusSpacing * 2)
+ 0 to AxisOffset(0f, 0f),
+ 1 to AxisOffset(itemSize, 0f),
+ 2 to AxisOffset(0f, itemSizePlusSpacing),
+ 3 to AxisOffset(itemSize, itemSizePlusSpacing),
+ 4 to AxisOffset(0f, itemSizePlusSpacing * 2),
+ 5 to AxisOffset(itemSize, itemSizePlusSpacing * 2)
)
rule.runOnIdle {
@@ -638,24 +637,18 @@
onAnimationFrame { fraction ->
// item 1 moves to and item 8 moves from `gridSize`, right after the end edge
- val item1Offset = AxisIntOffset(
- itemSize,
- (gridSize * fraction).roundToInt()
- )
- val item8Offset = AxisIntOffset(
- itemSize,
- gridSize - (gridSize * fraction).roundToInt()
- )
+ val item1Offset = AxisOffset(itemSize, gridSize * fraction)
+ val item8Offset = AxisOffset(itemSize, gridSize - gridSize * fraction)
val screenSize = itemSize * 3 + spacing * 2
- val expected = mutableListOf<Pair<Any, IntOffset>>().apply {
- add(0 to AxisIntOffset(0, 0))
+ val expected = mutableListOf<Pair<Any, Offset>>().apply {
+ add(0 to AxisOffset(0f, 0f))
if (item1Offset.mainAxis < screenSize) {
add(1 to item1Offset)
}
- add(2 to AxisIntOffset(0, itemSizePlusSpacing))
- add(3 to AxisIntOffset(itemSize, itemSizePlusSpacing))
- add(4 to AxisIntOffset(0, itemSizePlusSpacing * 2))
- add(5 to AxisIntOffset(itemSize, itemSizePlusSpacing * 2))
+ add(2 to AxisOffset(0f, itemSizePlusSpacing))
+ add(3 to AxisOffset(itemSize, itemSizePlusSpacing))
+ add(4 to AxisOffset(0f, itemSizePlusSpacing * 2))
+ add(5 to AxisOffset(itemSize, itemSizePlusSpacing * 2))
if (item8Offset.mainAxis < screenSize) {
add(8 to item8Offset)
}
@@ -684,12 +677,12 @@
}
assertPositions(
- 4 to AxisIntOffset(0, 0),
- 5 to AxisIntOffset(itemSize, 0),
- 6 to AxisIntOffset(0, itemSizePlusSpacing),
- 7 to AxisIntOffset(itemSize, itemSizePlusSpacing),
- 8 to AxisIntOffset(0, itemSizePlusSpacing * 2),
- 9 to AxisIntOffset(itemSize, itemSizePlusSpacing * 2)
+ 4 to AxisOffset(0f, 0f),
+ 5 to AxisOffset(itemSize, 0f),
+ 6 to AxisOffset(0f, itemSizePlusSpacing),
+ 7 to AxisOffset(itemSize, itemSizePlusSpacing),
+ 8 to AxisOffset(0f, itemSizePlusSpacing * 2),
+ 9 to AxisOffset(itemSize, itemSizePlusSpacing * 2)
)
rule.runOnIdle {
@@ -698,27 +691,27 @@
onAnimationFrame { fraction ->
// item 8 moves to and item 1 moves from `-itemSize`, right before the start edge
- val item1Offset = AxisIntOffset(
- 0,
- -itemSize + ((itemSize + itemSizePlusSpacing * 2) * fraction).roundToInt()
+ val item1Offset = AxisOffset(
+ 0f,
+ -itemSize + (itemSize + itemSizePlusSpacing * 2) * fraction
)
- val item8Offset = AxisIntOffset(
- 0,
+ val item8Offset = AxisOffset(
+ 0f,
itemSizePlusSpacing * 2 -
- ((itemSize + itemSizePlusSpacing * 2) * fraction).roundToInt()
+ (itemSize + itemSizePlusSpacing * 2) * fraction
)
- val expected = mutableListOf<Pair<Any, IntOffset>>().apply {
+ val expected = mutableListOf<Pair<Any, Offset>>().apply {
if (item1Offset.mainAxis > -itemSize) {
add(1 to item1Offset)
}
- add(4 to AxisIntOffset(0, 0))
- add(5 to AxisIntOffset(itemSize, 0))
- add(6 to AxisIntOffset(0, itemSizePlusSpacing))
- add(7 to AxisIntOffset(itemSize, itemSizePlusSpacing))
+ add(4 to AxisOffset(0f, 0f))
+ add(5 to AxisOffset(itemSize, 0f))
+ add(6 to AxisOffset(0f, itemSizePlusSpacing))
+ add(7 to AxisOffset(itemSize, itemSizePlusSpacing))
if (item8Offset.mainAxis > -itemSize) {
add(8 to item8Offset)
}
- add(9 to AxisIntOffset(itemSize, itemSizePlusSpacing * 2))
+ add(9 to AxisOffset(itemSize, itemSizePlusSpacing * 2))
}
assertPositions(
expected = expected.toTypedArray(),
@@ -750,12 +743,12 @@
val line3Size = itemSize2
val line4Size = itemSize
assertPositions(
- 6 to AxisIntOffset(0, 0),
- 7 to AxisIntOffset(itemSize, 0),
- 8 to AxisIntOffset(0, line3Size),
- 9 to AxisIntOffset(itemSize, line3Size),
- 10 to AxisIntOffset(0, line3Size + line4Size),
- 11 to AxisIntOffset(itemSize, line3Size + line4Size)
+ 6 to AxisOffset(0f, 0f),
+ 7 to AxisOffset(itemSize, 0f),
+ 8 to AxisOffset(0f, line3Size),
+ 9 to AxisOffset(itemSize, line3Size),
+ 10 to AxisOffset(0f, line3Size + line4Size),
+ 11 to AxisOffset(itemSize, line3Size + line4Size)
)
rule.runOnIdle {
@@ -771,31 +764,31 @@
// item 2 moves from and item 4 moves to `0 - item size`, right before the start edge
val startItem2Offset = -item2Size
val item2Offset =
- startItem2Offset + ((itemSize2 - startItem2Offset) * fraction).roundToInt()
+ startItem2Offset + (itemSize2 - startItem2Offset) * fraction
val item8Size = itemSize /* the real size of the item 8 */
val endItem8Offset = -item8Size
- val item8Offset = line3Size - ((line3Size - endItem8Offset) * fraction).roundToInt()
- val expected = mutableListOf<Pair<Any, IntOffset>>().apply {
+ val item8Offset = line3Size - (line3Size - endItem8Offset) * fraction
+ val expected = mutableListOf<Pair<Any, Offset>>().apply {
if (item8Offset > -line4Size) {
- add(8 to AxisIntOffset(0, item8Offset))
+ add(8 to AxisOffset(0f, item8Offset))
} else {
rule.onNodeWithTag("8").assertIsNotDisplayed()
}
- add(6 to AxisIntOffset(0, 0))
- add(7 to AxisIntOffset(itemSize, 0))
+ add(6 to AxisOffset(0f, 0f))
+ add(7 to AxisOffset(itemSize, 0f))
if (item2Offset > -item2Size) {
- add(2 to AxisIntOffset(0, item2Offset))
+ add(2 to AxisOffset(0f, item2Offset))
} else {
rule.onNodeWithTag("2").assertIsNotDisplayed()
}
- add(9 to AxisIntOffset(itemSize, line3Size))
- add(10 to AxisIntOffset(
- 0,
- line3Size + line4Size - ((itemSize - itemSize3) * fraction).roundToInt()
+ add(9 to AxisOffset(itemSize, line3Size))
+ add(10 to AxisOffset(
+ 0f,
+ line3Size + line4Size - (itemSize - itemSize3) * fraction
))
- add(11 to AxisIntOffset(
+ add(11 to AxisOffset(
itemSize,
- line3Size + line4Size - ((itemSize - itemSize3) * fraction).roundToInt()
+ line3Size + line4Size - (itemSize - itemSize3) * fraction
))
}
assertPositions(
@@ -828,12 +821,12 @@
val line0Size = itemSize2
val line1Size = itemSize
assertPositions(
- 0 to AxisIntOffset(0, 0),
- 1 to AxisIntOffset(itemSize, 0),
- 2 to AxisIntOffset(0, line0Size),
- 3 to AxisIntOffset(itemSize, line0Size),
- 4 to AxisIntOffset(0, line0Size + line1Size),
- 5 to AxisIntOffset(itemSize, line0Size + line1Size),
+ 0 to AxisOffset(0f, 0f),
+ 1 to AxisOffset(itemSize, 0f),
+ 2 to AxisOffset(0f, line0Size),
+ 3 to AxisOffset(itemSize, line0Size),
+ 4 to AxisOffset(0f, line0Size + line1Size),
+ 5 to AxisOffset(itemSize, line0Size + line1Size),
)
rule.runOnIdle {
@@ -846,28 +839,28 @@
val endItem2Offset = gridSize
val line4Size = itemSize3
val item2Offset =
- line0Size + ((endItem2Offset - line0Size) * fraction).roundToInt()
+ line0Size + (endItem2Offset - line0Size) * fraction
val item8Offset =
- startItem8Offset - ((startItem8Offset - line0Size) * fraction).roundToInt()
- val expected = mutableListOf<Pair<Any, IntOffset>>().apply {
- add(0 to AxisIntOffset(0, 0))
- add(1 to AxisIntOffset(itemSize, 0))
+ startItem8Offset - (startItem8Offset - line0Size) * fraction
+ val expected = mutableListOf<Pair<Any, Offset>>().apply {
+ add(0 to AxisOffset(0f, 0f))
+ add(1 to AxisOffset(itemSize, 0f))
if (item8Offset < gridSize) {
- add(8 to AxisIntOffset(0, item8Offset))
+ add(8 to AxisOffset(0f, item8Offset))
} else {
rule.onNodeWithTag("8").assertIsNotDisplayed()
}
- add(3 to AxisIntOffset(itemSize, line0Size))
- add(4 to AxisIntOffset(
- 0,
- line0Size + line1Size - ((line1Size - line4Size) * fraction).roundToInt()
+ add(3 to AxisOffset(itemSize, line0Size))
+ add(4 to AxisOffset(
+ 0f,
+ line0Size + line1Size - (line1Size - line4Size) * fraction
))
- add(5 to AxisIntOffset(
+ add(5 to AxisOffset(
itemSize,
- line0Size + line1Size - ((line1Size - line4Size) * fraction).roundToInt()
+ line0Size + line1Size - (line1Size - line4Size) * fraction
))
if (item2Offset < gridSize) {
- add(2 to AxisIntOffset(0, item2Offset))
+ add(2 to AxisOffset(0f, item2Offset))
} else {
rule.onNodeWithTag("2").assertIsNotDisplayed()
}
@@ -922,8 +915,8 @@
// 3 to itemSize * 2,
// crossAxis = listOf(
// 1 to 0,
- // 2 to item2Start + ((item2End - item2Start) * fraction).roundToInt(),
- // 3 to item3Start + ((item3End - item3Start) * fraction).roundToInt(),
+ // 2 to item2Start + ((item2End - item2Start) * fraction,
+ // 3 to item3Start + ((item3End - item3Start) * fraction,
// ),
// fraction = fraction
// )
@@ -960,9 +953,9 @@
// 2 to itemSize,
// 3 to itemSize * 2,
// crossAxis = listOf(
- // 1 to ((containerSize - itemSize) * fraction).roundToInt(),
- // 2 to ((containerSize - itemSize2) * fraction).roundToInt(),
- // 3 to ((containerSize - itemSize3) * fraction).roundToInt()
+ // 1 to ((containerSize - itemSize) * fraction,
+ // 2 to ((containerSize - itemSize2) * fraction,
+ // 3 to ((containerSize - itemSize3) * fraction
// ),
// fraction = fraction
// )
@@ -1013,8 +1006,8 @@
// 3 to itemSize * 2,
// crossAxis = listOf(
// 1 to 0,
- // 2 to ((itemSize / 2 - itemSize2 / 2) * fraction).roundToInt(),
- // 3 to ((itemSize / 2 - itemSize3 / 2) * fraction).roundToInt(),
+ // 2 to ((itemSize / 2 - itemSize2 / 2) * fraction,
+ // 3 to ((itemSize / 2 - itemSize3 / 2) * fraction,
// ),
// fraction = fraction
// )
@@ -1024,8 +1017,8 @@
@Test
fun moveItemToEndCausingNextItemsToAnimate_withContentPadding() {
var list by mutableStateOf(listOf(0, 1, 2, 3, 4))
- val rawStartPadding = 8
- val rawEndPadding = 12
+ val rawStartPadding = 8f
+ val rawEndPadding = 12f
val (startPaddingDp, endPaddingDp) = with(rule.density) {
rawStartPadding.toDp() to rawEndPadding.toDp()
}
@@ -1039,11 +1032,11 @@
val startPadding = if (reverseLayout) rawEndPadding else rawStartPadding
assertPositions(
- 0 to AxisIntOffset(0, startPadding),
- 1 to AxisIntOffset(0, startPadding + itemSize),
- 2 to AxisIntOffset(0, startPadding + itemSize * 2),
- 3 to AxisIntOffset(0, startPadding + itemSize * 3),
- 4 to AxisIntOffset(0, startPadding + itemSize * 4),
+ 0 to AxisOffset(0f, startPadding),
+ 1 to AxisOffset(0f, startPadding + itemSize),
+ 2 to AxisOffset(0f, startPadding + itemSize * 2),
+ 3 to AxisOffset(0f, startPadding + itemSize * 3),
+ 4 to AxisOffset(0f, startPadding + itemSize * 4),
)
rule.runOnIdle {
@@ -1052,22 +1045,22 @@
onAnimationFrame { fraction ->
assertPositions(
- 0 to AxisIntOffset(0, startPadding),
- 1 to AxisIntOffset(
- 0,
- startPadding + itemSize + (itemSize * 3 * fraction).roundToInt()
+ 0 to AxisOffset(0f, startPadding),
+ 1 to AxisOffset(
+ 0f,
+ startPadding + itemSize + itemSize * 3 * fraction
),
- 2 to AxisIntOffset(
- 0,
- startPadding + itemSize * 2 - (itemSize * fraction).roundToInt()
+ 2 to AxisOffset(
+ 0f,
+ startPadding + itemSize * 2 - itemSize * fraction
),
- 3 to AxisIntOffset(
- 0,
- startPadding + itemSize * 3 - (itemSize * fraction).roundToInt()
+ 3 to AxisOffset(
+ 0f,
+ startPadding + itemSize * 3 - itemSize * fraction
),
- 4 to AxisIntOffset(
- 0,
- startPadding + itemSize * 4 - (itemSize * fraction).roundToInt()
+ 4 to AxisOffset(
+ 0f,
+ startPadding + itemSize * 4 - itemSize * fraction
),
fraction = fraction
)
@@ -1122,16 +1115,16 @@
rule.runOnIdle {
runBlocking {
- state.scrollToItem(0, itemSize / 2)
+ state.scrollToItem(0, (itemSize / 2).roundToInt())
}
}
onAnimationFrame { fraction ->
assertPositions(
- 0 to AxisIntOffset(0, -itemSize / 2),
- 1 to AxisIntOffset(0, itemSize / 2),
- 2 to AxisIntOffset(0, itemSize * 3 / 2),
- 3 to AxisIntOffset(0, itemSize * 5 / 2),
+ 0 to AxisOffset(0f, -itemSize / 2),
+ 1 to AxisOffset(0f, itemSize / 2),
+ 2 to AxisOffset(0f, itemSize * 3 / 2),
+ 3 to AxisOffset(0f, itemSize * 5 / 2),
fraction = fraction
)
}
@@ -1155,10 +1148,10 @@
onAnimationFrame { fraction ->
assertPositions(
- 0 to AxisIntOffset(0, -itemSize / 2),
- 1 to AxisIntOffset(0, itemSize / 2),
- 2 to AxisIntOffset(0, itemSize * 3 / 2),
- 3 to AxisIntOffset(0, itemSize * 5 / 2),
+ 0 to AxisOffset(0f, -itemSize / 2),
+ 1 to AxisOffset(0f, itemSize / 2),
+ 2 to AxisOffset(0f, itemSize * 3 / 2),
+ 3 to AxisOffset(0f, itemSize * 5 / 2),
fraction = fraction
)
}
@@ -1182,10 +1175,10 @@
onAnimationFrame { fraction ->
assertPositions(
- 1 to AxisIntOffset(0, -itemSize / 2),
- 2 to AxisIntOffset(0, itemSize / 2),
- 3 to AxisIntOffset(0, itemSize * 3 / 2),
- 4 to AxisIntOffset(0, itemSize * 5 / 2),
+ 1 to AxisOffset(0f, -itemSize / 2),
+ 2 to AxisOffset(0f, itemSize / 2),
+ 3 to AxisOffset(0f, itemSize * 3 / 2),
+ 4 to AxisOffset(0f, itemSize * 5 / 2),
fraction = fraction
)
}
@@ -1209,10 +1202,10 @@
onAnimationFrame { fraction ->
assertPositions(
- 2 to AxisIntOffset(0, -itemSize / 2),
- 3 to AxisIntOffset(0, itemSize / 2),
- 4 to AxisIntOffset(0, itemSize * 3 / 2),
- 5 to AxisIntOffset(0, itemSize * 5 / 2),
+ 2 to AxisOffset(0f, -itemSize / 2),
+ 3 to AxisOffset(0f, itemSize / 2),
+ 4 to AxisOffset(0f, itemSize * 3 / 2),
+ 5 to AxisOffset(0f, itemSize * 5 / 2),
fraction = fraction
)
}
@@ -1236,10 +1229,10 @@
onAnimationFrame { fraction ->
assertPositions(
- 0 to AxisIntOffset(0, -itemSize / 2),
- 1 to AxisIntOffset(0, itemSize / 2),
- 2 to AxisIntOffset(0, itemSize * 3 / 2),
- 3 to AxisIntOffset(0, itemSize * 5 / 2),
+ 0 to AxisOffset(0f, -itemSize / 2),
+ 1 to AxisOffset(0f, itemSize / 2),
+ 2 to AxisOffset(0f, itemSize * 3 / 2),
+ 3 to AxisOffset(0f, itemSize * 5 / 2),
fraction = fraction
)
}
@@ -1263,10 +1256,10 @@
onAnimationFrame { fraction ->
assertPositions(
- 2 to AxisIntOffset(0, -itemSize / 2),
- 3 to AxisIntOffset(0, itemSize / 2),
- 4 to AxisIntOffset(0, itemSize2 + itemSize / 2),
- 5 to AxisIntOffset(0, itemSize2 + itemSize * 3 / 2),
+ 2 to AxisOffset(0f, -itemSize / 2),
+ 3 to AxisOffset(0f, itemSize / 2),
+ 4 to AxisOffset(0f, itemSize2 + itemSize / 2),
+ 5 to AxisOffset(0f, itemSize2 + itemSize * 3 / 2),
fraction = fraction
)
}
@@ -1290,10 +1283,10 @@
onAnimationFrame { fraction ->
assertPositions(
- 0 to AxisIntOffset(0, -itemSize / 2),
- 1 to AxisIntOffset(0, itemSize / 2),
- 2 to AxisIntOffset(0, itemSize2 + itemSize / 2),
- 3 to AxisIntOffset(0, itemSize2 + itemSize * 3 / 2),
+ 0 to AxisOffset(0f, -itemSize / 2),
+ 1 to AxisOffset(0f, itemSize / 2),
+ 2 to AxisOffset(0f, itemSize2 + itemSize / 2),
+ 3 to AxisOffset(0f, itemSize2 + itemSize * 3 / 2),
fraction = fraction
)
}
@@ -1310,12 +1303,12 @@
}
assertPositions(
- 0 to AxisIntOffset(0, 0),
- 1 to AxisIntOffset(itemSize, 0),
- 2 to AxisIntOffset(itemSize * 2, 0),
- 3 to AxisIntOffset(0, itemSize),
- 4 to AxisIntOffset(itemSize, itemSize),
- 5 to AxisIntOffset(itemSize * 2, itemSize)
+ 0 to AxisOffset(0f, 0f),
+ 1 to AxisOffset(itemSize, 0f),
+ 2 to AxisOffset(itemSize * 2, 0f),
+ 3 to AxisOffset(0f, itemSize),
+ 4 to AxisOffset(itemSize, itemSize),
+ 5 to AxisOffset(itemSize * 2, itemSize)
)
rule.runOnIdle {
@@ -1326,15 +1319,15 @@
onAnimationFrame { fraction ->
assertPositions(
- 6 to AxisIntOffset(0, -itemSize / 2),
- 7 to AxisIntOffset(itemSize, -itemSize / 2),
- 8 to AxisIntOffset(itemSize * 2, -itemSize / 2),
- 9 to AxisIntOffset(0, itemSize / 2),
- 10 to AxisIntOffset(itemSize, itemSize / 2),
- 11 to AxisIntOffset(itemSize * 2, itemSize / 2),
- 12 to AxisIntOffset(0, itemSize * 3 / 2),
- 13 to AxisIntOffset(itemSize, itemSize * 3 / 2),
- 14 to AxisIntOffset(itemSize * 2, itemSize * 3 / 2),
+ 6 to AxisOffset(0f, -itemSize / 2),
+ 7 to AxisOffset(itemSize, -itemSize / 2),
+ 8 to AxisOffset(itemSize * 2, -itemSize / 2),
+ 9 to AxisOffset(0f, itemSize / 2),
+ 10 to AxisOffset(itemSize, itemSize / 2),
+ 11 to AxisOffset(itemSize * 2, itemSize / 2),
+ 12 to AxisOffset(0f, itemSize * 3 / 2),
+ 13 to AxisOffset(itemSize, itemSize * 3 / 2),
+ 14 to AxisOffset(itemSize * 2, itemSize * 3 / 2),
fraction = fraction
)
}
@@ -1351,12 +1344,12 @@
}
assertPositions(
- 9 to AxisIntOffset(0, 0),
- 10 to AxisIntOffset(itemSize, 0),
- 11 to AxisIntOffset(itemSize * 2, 0),
- 12 to AxisIntOffset(0, itemSize),
- 13 to AxisIntOffset(itemSize, itemSize),
- 14 to AxisIntOffset(itemSize * 2, itemSize)
+ 9 to AxisOffset(0f, 0f),
+ 10 to AxisOffset(itemSize, 0f),
+ 11 to AxisOffset(itemSize * 2, 0f),
+ 12 to AxisOffset(0f, itemSize),
+ 13 to AxisOffset(itemSize, itemSize),
+ 14 to AxisOffset(itemSize * 2, itemSize)
)
rule.runOnIdle {
@@ -1367,15 +1360,15 @@
onAnimationFrame { fraction ->
assertPositions(
- 0 to AxisIntOffset(0, -itemSize / 2),
- 1 to AxisIntOffset(itemSize, -itemSize / 2),
- 2 to AxisIntOffset(itemSize * 2, -itemSize / 2),
- 3 to AxisIntOffset(0, itemSize / 2),
- 4 to AxisIntOffset(itemSize, itemSize / 2),
- 5 to AxisIntOffset(itemSize * 2, itemSize / 2),
- 6 to AxisIntOffset(0, itemSize * 3 / 2),
- 7 to AxisIntOffset(itemSize, itemSize * 3 / 2),
- 8 to AxisIntOffset(itemSize * 2, itemSize * 3 / 2),
+ 0 to AxisOffset(0f, -itemSize / 2),
+ 1 to AxisOffset(itemSize, -itemSize / 2),
+ 2 to AxisOffset(itemSize * 2, -itemSize / 2),
+ 3 to AxisOffset(0f, itemSize / 2),
+ 4 to AxisOffset(itemSize, itemSize / 2),
+ 5 to AxisOffset(itemSize * 2, itemSize / 2),
+ 6 to AxisOffset(0f, itemSize * 3 / 2),
+ 7 to AxisOffset(itemSize, itemSize * 3 / 2),
+ 8 to AxisOffset(itemSize * 2, itemSize * 3 / 2),
fraction = fraction
)
}
@@ -1396,12 +1389,12 @@
}
assertPositions(
- 0 to AxisIntOffset(0, 0),
- 1 to AxisIntOffset(itemSize, 0),
- 2 to AxisIntOffset(itemSize * 2, 0),
- 3 to AxisIntOffset(0, itemSize),
- 4 to AxisIntOffset(itemSize, itemSize),
- 5 to AxisIntOffset(itemSize * 2, itemSize)
+ 0 to AxisOffset(0f, 0f),
+ 1 to AxisOffset(itemSize, 0f),
+ 2 to AxisOffset(itemSize * 2, 0f),
+ 3 to AxisOffset(0f, itemSize),
+ 4 to AxisOffset(itemSize, itemSize),
+ 5 to AxisOffset(itemSize * 2, itemSize)
)
rule.runOnIdle {
@@ -1412,12 +1405,12 @@
onAnimationFrame { fraction ->
assertPositions(
- 6 to AxisIntOffset(0, -itemSize / 2),
- 7 to AxisIntOffset(itemSize, -itemSize / 2),
- 8 to AxisIntOffset(itemSize * 2, -itemSize / 2),
- 9 to AxisIntOffset(0, itemSize / 2), // 3 spans
- 10 to AxisIntOffset(0, itemSize * 3 / 2), // 2 spans
- 11 to AxisIntOffset(itemSize * 2, itemSize * 3 / 2),
+ 6 to AxisOffset(0f, -itemSize / 2),
+ 7 to AxisOffset(itemSize, -itemSize / 2),
+ 8 to AxisOffset(itemSize * 2, -itemSize / 2),
+ 9 to AxisOffset(0f, itemSize / 2), // 3 spans
+ 10 to AxisOffset(0f, itemSize * 3 / 2), // 2 spans
+ 11 to AxisOffset(itemSize * 2, itemSize * 3 / 2),
fraction = fraction
)
}
@@ -1438,12 +1431,12 @@
}
assertPositions(
- 6 to AxisIntOffset(0, 0),
- 7 to AxisIntOffset(itemSize, 0),
- 8 to AxisIntOffset(itemSize * 2, 0),
- 9 to AxisIntOffset(0, itemSize),
- 10 to AxisIntOffset(itemSize, itemSize),
- 11 to AxisIntOffset(itemSize * 2, itemSize)
+ 6 to AxisOffset(0f, 0f),
+ 7 to AxisOffset(itemSize, 0f),
+ 8 to AxisOffset(itemSize * 2, 0f),
+ 9 to AxisOffset(0f, itemSize),
+ 10 to AxisOffset(itemSize, itemSize),
+ 11 to AxisOffset(itemSize * 2, itemSize)
)
rule.runOnIdle {
@@ -1454,12 +1447,12 @@
onAnimationFrame { fraction ->
assertPositions(
- 0 to AxisIntOffset(0, -itemSize / 2),
- 1 to AxisIntOffset(itemSize, -itemSize / 2),
- 2 to AxisIntOffset(itemSize * 2, -itemSize / 2),
- 3 to AxisIntOffset(0, itemSize / 2), // 3 spans
- 4 to AxisIntOffset(0, itemSize * 3 / 2), // 2 spans
- 5 to AxisIntOffset(itemSize * 2, itemSize * 3 / 2),
+ 0 to AxisOffset(0f, -itemSize / 2),
+ 1 to AxisOffset(itemSize, -itemSize / 2),
+ 2 to AxisOffset(itemSize * 2, -itemSize / 2),
+ 3 to AxisOffset(0f, itemSize / 2), // 3 spans
+ 4 to AxisOffset(0f, itemSize * 3 / 2), // 2 spans
+ 5 to AxisOffset(itemSize * 2, itemSize * 3 / 2),
fraction = fraction
)
}
@@ -1486,12 +1479,12 @@
}
assertPositions(
- 0 to AxisIntOffset(0, 0),
- 1 to AxisIntOffset(itemSize, 0),
- 2 to AxisIntOffset(itemSize * 2, 0),
- 3 to AxisIntOffset(0, itemSize),
- 4 to AxisIntOffset(itemSize, itemSize),
- 5 to AxisIntOffset(itemSize * 2, itemSize)
+ 0 to AxisOffset(0f, 0f),
+ 1 to AxisOffset(itemSize, 0f),
+ 2 to AxisOffset(itemSize * 2, 0f),
+ 3 to AxisOffset(0f, itemSize),
+ 4 to AxisOffset(itemSize, itemSize),
+ 5 to AxisOffset(itemSize * 2, itemSize)
)
rule.runOnIdle {
@@ -1503,12 +1496,12 @@
onAnimationFrame { fraction ->
val startOffset = -itemSize / 2
assertPositions(
- 6 to AxisIntOffset(0, startOffset),
- 7 to AxisIntOffset(itemSize, startOffset),
- 8 to AxisIntOffset(itemSize * 2, startOffset),
- 9 to AxisIntOffset(0, startOffset + itemSize2), // 3 spans
- 10 to AxisIntOffset(0, startOffset + itemSize2 + itemSize3), // 2 spans
- 11 to AxisIntOffset(itemSize * 2, startOffset + itemSize2 + itemSize3),
+ 6 to AxisOffset(0f, startOffset),
+ 7 to AxisOffset(itemSize, startOffset),
+ 8 to AxisOffset(itemSize * 2, startOffset),
+ 9 to AxisOffset(0f, startOffset + itemSize2), // 3 spans
+ 10 to AxisOffset(0f, startOffset + itemSize2 + itemSize3), // 2 spans
+ 11 to AxisOffset(itemSize * 2, startOffset + itemSize2 + itemSize3),
fraction = fraction
)
}
@@ -1535,12 +1528,12 @@
}
assertPositions(
- 6 to AxisIntOffset(0, 0),
- 7 to AxisIntOffset(itemSize, 0),
- 8 to AxisIntOffset(itemSize * 2, 0),
- 9 to AxisIntOffset(0, itemSize),
- 10 to AxisIntOffset(itemSize, itemSize),
- 11 to AxisIntOffset(itemSize * 2, itemSize)
+ 6 to AxisOffset(0f, 0f),
+ 7 to AxisOffset(itemSize, 0f),
+ 8 to AxisOffset(itemSize * 2, 0f),
+ 9 to AxisOffset(0f, itemSize),
+ 10 to AxisOffset(itemSize, itemSize),
+ 11 to AxisOffset(itemSize * 2, itemSize)
)
rule.runOnIdle {
@@ -1552,12 +1545,12 @@
onAnimationFrame { fraction ->
val startOffset = -itemSize2 / 2
assertPositions(
- 0 to AxisIntOffset(0, startOffset),
- 1 to AxisIntOffset(itemSize, startOffset),
- 2 to AxisIntOffset(itemSize * 2, startOffset),
- 3 to AxisIntOffset(0, startOffset + itemSize2), // 3 spans
- 4 to AxisIntOffset(0, startOffset + itemSize2 + itemSize3), // 2 spans
- 5 to AxisIntOffset(itemSize * 2, startOffset + itemSize2 + itemSize3),
+ 0 to AxisOffset(0f, startOffset),
+ 1 to AxisOffset(itemSize, startOffset),
+ 2 to AxisOffset(itemSize * 2, startOffset),
+ 3 to AxisOffset(0f, startOffset + itemSize2), // 3 spans
+ 4 to AxisOffset(0f, startOffset + itemSize2 + itemSize3), // 2 spans
+ 5 to AxisOffset(itemSize * 2, startOffset + itemSize2 + itemSize3),
fraction = fraction
)
}
@@ -1577,10 +1570,10 @@
}
assertLayoutInfoPositions(
- 0 to AxisIntOffset(0, 0),
- 1 to AxisIntOffset(itemSize, 0),
- 2 to AxisIntOffset(0, itemSize),
- 3 to AxisIntOffset(itemSize, itemSize)
+ 0 to AxisOffset(0f, 0f),
+ 1 to AxisOffset(itemSize, 0f),
+ 2 to AxisOffset(0f, itemSize),
+ 3 to AxisOffset(itemSize, itemSize)
)
rule.runOnIdle {
@@ -1588,18 +1581,18 @@
}
onAnimationFrame { fraction ->
- val expected = mutableListOf<Pair<Any, IntOffset>>().apply {
- add(0 to AxisIntOffset(0, 0))
+ val expected = mutableListOf<Pair<Any, Offset>>().apply {
+ add(0 to AxisOffset(0f, 0f))
add(
- 2 to AxisIntOffset(
- (itemSize * fraction).roundToInt(),
- (itemSize * (1f - fraction)).roundToInt()
+ 2 to AxisOffset(
+ itemSize * fraction,
+ itemSize * (1f - fraction)
)
)
- val item4and6MainAxis = gridSize - ((gridSize - itemSize) * fraction).roundToInt()
+ val item4and6MainAxis = gridSize - (gridSize - itemSize) * fraction
if (item4and6MainAxis < gridSize) {
- add(4 to AxisIntOffset(0, item4and6MainAxis))
- add(6 to AxisIntOffset(itemSize, item4and6MainAxis))
+ add(4 to AxisOffset(0f, item4and6MainAxis))
+ add(6 to AxisOffset(itemSize, item4and6MainAxis))
} else {
rule.onNodeWithTag("4").assertIsNotDisplayed()
rule.onNodeWithTag("6").assertIsNotDisplayed()
@@ -1629,10 +1622,10 @@
}
assertLayoutInfoPositions(
- 0 to AxisIntOffset(0, 0),
- 1 to AxisIntOffset(itemSize, 0),
- 2 to AxisIntOffset(0, itemSize),
- 3 to AxisIntOffset(itemSize, itemSize)
+ 0 to AxisOffset(0f, 0f),
+ 1 to AxisOffset(itemSize, 0f),
+ 2 to AxisOffset(0f, itemSize),
+ 3 to AxisOffset(itemSize, itemSize)
)
rule.runOnIdle {
@@ -1640,20 +1633,20 @@
}
onAnimationFrame { fraction ->
- val expected = mutableListOf<Pair<Any, IntOffset>>().apply {
- add(0 to AxisIntOffset(0, 0))
- val item4MainAxis = gridSize - (gridSize * fraction).roundToInt()
+ val expected = mutableListOf<Pair<Any, Offset>>().apply {
+ add(0 to AxisOffset(0f, 0f))
+ val item4MainAxis = gridSize - gridSize * fraction
if (item4MainAxis < gridSize) {
add(
- 4 to AxisIntOffset(itemSize, item4MainAxis)
+ 4 to AxisOffset(itemSize, item4MainAxis)
)
} else {
rule.onNodeWithTag("4").assertIsNotDisplayed()
}
- val item6MainAxis = gridSize + itemSize - (gridSize * fraction).roundToInt()
+ val item6MainAxis = gridSize + itemSize - gridSize * fraction
if (item6MainAxis < gridSize) {
add(
- 6 to AxisIntOffset(0, item6MainAxis)
+ 6 to AxisOffset(0f, item6MainAxis)
)
} else {
rule.onNodeWithTag("6").assertIsNotDisplayed()
@@ -1686,11 +1679,11 @@
onAnimationFrame { fraction ->
// item 1 moves to `gridSize`
- val item1Offset = itemSize + ((gridSize - itemSize) * fraction).roundToInt()
- val expected = mutableListOf<Pair<Any, IntOffset>>().apply {
- add(0 to AxisIntOffset(0, 0))
+ val item1Offset = itemSize + (gridSize - itemSize) * fraction
+ val expected = mutableListOf<Pair<Any, Offset>>().apply {
+ add(0 to AxisOffset(0f, 0f))
if (item1Offset < gridSize) {
- add(1 to AxisIntOffset(0, item1Offset))
+ add(1 to AxisOffset(0f, item1Offset))
} else {
rule.onNodeWithTag("1").assertIsNotDisplayed()
}
@@ -1714,9 +1707,9 @@
}
assertPositions(
- 3 to AxisIntOffset(0, 0),
- 4 to AxisIntOffset(0, itemSize),
- 5 to AxisIntOffset(0, itemSize * 2)
+ 3 to AxisOffset(0f, 0f),
+ 4 to AxisOffset(0f, itemSize),
+ 5 to AxisOffset(0f, itemSize * 2)
)
rule.runOnIdle {
@@ -1725,30 +1718,30 @@
onAnimationFrame { fraction ->
// item 2 moves from and item 5 moves to `-itemSize`, right before the start edge
- val item2Offset = -itemSize + (itemSize * 3 * fraction).roundToInt()
- val item5Offset = itemSize * 2 - (itemSize * 3 * fraction).roundToInt()
+ val item2Offset = -itemSize + itemSize * 3 * fraction
+ val item5Offset = itemSize * 2 - itemSize * 3 * fraction
// item 1 moves from and item 4 moves to `-itemSize * 2`, right before item 2
- val item1Offset = -itemSize * 2 + (itemSize * 3 * fraction).roundToInt()
- val item4Offset = itemSize - (itemSize * 3 * fraction).roundToInt()
- val expected = mutableListOf<Pair<Any, IntOffset>>().apply {
+ val item1Offset = -itemSize * 2 + itemSize * 3 * fraction
+ val item4Offset = itemSize - itemSize * 3 * fraction
+ val expected = mutableListOf<Pair<Any, Offset>>().apply {
if (item1Offset > -itemSize) {
- add(1 to AxisIntOffset(0, item1Offset))
+ add(1 to AxisOffset(0f, item1Offset))
} else {
rule.onNodeWithTag("1").assertIsNotDisplayed()
}
if (item2Offset > -itemSize) {
- add(2 to AxisIntOffset(0, item2Offset))
+ add(2 to AxisOffset(0f, item2Offset))
} else {
rule.onNodeWithTag("2").assertIsNotDisplayed()
}
- add(3 to AxisIntOffset(0, 0))
+ add(3 to AxisOffset(0f, 0f))
if (item4Offset > -itemSize) {
- add(4 to AxisIntOffset(0, item4Offset))
+ add(4 to AxisOffset(0f, item4Offset))
} else {
rule.onNodeWithTag("4").assertIsNotDisplayed()
}
if (item5Offset > -itemSize) {
- add(5 to AxisIntOffset(0, item5Offset))
+ add(5 to AxisOffset(0f, item5Offset))
} else {
rule.onNodeWithTag("5").assertIsNotDisplayed()
}
@@ -1772,9 +1765,9 @@
}
assertPositions(
- 3 to AxisIntOffset(0, 0),
- 4 to AxisIntOffset(0, itemSize),
- 5 to AxisIntOffset(0, itemSize * 2)
+ 3 to AxisOffset(0f, 0f),
+ 4 to AxisOffset(0f, itemSize),
+ 5 to AxisOffset(0f, itemSize * 2)
)
rule.runOnIdle {
@@ -1783,30 +1776,30 @@
onAnimationFrame { fraction ->
// item 2 moves from and item 4 moves to `-itemSize`, right before the start edge
- val item2Offset = -itemSize + (itemSize * 2 * fraction).roundToInt()
- val item4Offset = itemSize - (itemSize * 2 * fraction).roundToInt()
+ val item2Offset = -itemSize + itemSize * 2 * fraction
+ val item4Offset = itemSize - itemSize * 2 * fraction
// item 1 moves from and item 5 moves to `-itemSize * 2`, right before item 2
- val item1Offset = -itemSize * 2 + (itemSize * 4 * fraction).roundToInt()
- val item5Offset = itemSize * 2 - (itemSize * 4 * fraction).roundToInt()
- val expected = mutableListOf<Pair<Any, IntOffset>>().apply {
+ val item1Offset = -itemSize * 2 + itemSize * 4 * fraction
+ val item5Offset = itemSize * 2 - itemSize * 4 * fraction
+ val expected = mutableListOf<Pair<Any, Offset>>().apply {
if (item1Offset > -itemSize) {
- add(1 to AxisIntOffset(0, item1Offset))
+ add(1 to AxisOffset(0f, item1Offset))
} else {
rule.onNodeWithTag("1").assertIsNotDisplayed()
}
if (item2Offset > -itemSize) {
- add(2 to AxisIntOffset(0, item2Offset))
+ add(2 to AxisOffset(0f, item2Offset))
} else {
rule.onNodeWithTag("2").assertIsNotDisplayed()
}
- add(3 to AxisIntOffset(0, 0))
+ add(3 to AxisOffset(0f, 0f))
if (item4Offset > -itemSize) {
- add(4 to AxisIntOffset(0, item4Offset))
+ add(4 to AxisOffset(0f, item4Offset))
} else {
rule.onNodeWithTag("4").assertIsNotDisplayed()
}
if (item5Offset > -itemSize) {
- add(5 to AxisIntOffset(0, item5Offset))
+ add(5 to AxisOffset(0f, item5Offset))
} else {
rule.onNodeWithTag("5").assertIsNotDisplayed()
}
@@ -1830,10 +1823,10 @@
}
assertPositions(
- 2 to AxisIntOffset(0, 0),
- 3 to AxisIntOffset(itemSize, 0),
- 4 to AxisIntOffset(0, itemSize),
- 5 to AxisIntOffset(itemSize, itemSize)
+ 2 to AxisOffset(0f, 0f),
+ 3 to AxisOffset(itemSize, 0f),
+ 4 to AxisOffset(0f, itemSize),
+ 5 to AxisOffset(itemSize, itemSize)
)
rule.runOnIdle {
@@ -1843,21 +1836,21 @@
onAnimationFrame { fraction ->
// items 0 and 2 moves from and items 4 and 5 moves to `-itemSize`,
// right before the start edge
- val items0and1Offset = -itemSize + (itemSize * 2 * fraction).roundToInt()
- val items4and5Offset = itemSize - (itemSize * 2 * fraction).roundToInt()
- val expected = mutableListOf<Pair<Any, IntOffset>>().apply {
+ val items0and1Offset = -itemSize + itemSize * 2 * fraction
+ val items4and5Offset = itemSize - itemSize * 2 * fraction
+ val expected = mutableListOf<Pair<Any, Offset>>().apply {
if (items0and1Offset > -itemSize) {
- add(0 to AxisIntOffset(0, items0and1Offset))
- add(1 to AxisIntOffset(itemSize, items0and1Offset))
+ add(0 to AxisOffset(0f, items0and1Offset))
+ add(1 to AxisOffset(itemSize, items0and1Offset))
} else {
rule.onNodeWithTag("0").assertIsNotDisplayed()
rule.onNodeWithTag("1").assertIsNotDisplayed()
}
- add(2 to AxisIntOffset(0, 0))
- add(3 to AxisIntOffset(itemSize, 0))
+ add(2 to AxisOffset(0f, 0f))
+ add(3 to AxisOffset(itemSize, 0f))
if (items4and5Offset > -itemSize) {
- add(4 to AxisIntOffset(0, items4and5Offset))
- add(5 to AxisIntOffset(itemSize, items4and5Offset))
+ add(4 to AxisOffset(0f, items4and5Offset))
+ add(5 to AxisOffset(itemSize, items4and5Offset))
} else {
rule.onNodeWithTag("4").assertIsNotDisplayed()
rule.onNodeWithTag("5").assertIsNotDisplayed()
@@ -1884,9 +1877,9 @@
}
assertPositions(
- 0 to AxisIntOffset(0, 0),
- 1 to AxisIntOffset(0, itemSize),
- 2 to AxisIntOffset(0, itemSize * 2)
+ 0 to AxisOffset(0f, 0f),
+ 1 to AxisOffset(0f, itemSize),
+ 2 to AxisOffset(0f, itemSize * 2)
)
rule.runOnIdle {
@@ -1895,30 +1888,30 @@
onAnimationFrame { fraction ->
// item 1 moves to and item 3 moves from `gridSize`, right after the end edge
- val item1Offset = itemSize + ((gridSize - itemSize) * fraction).roundToInt()
- val item3Offset = gridSize - ((gridSize - itemSize) * fraction).roundToInt()
+ val item1Offset = itemSize + (gridSize - itemSize) * fraction
+ val item3Offset = gridSize - (gridSize - itemSize) * fraction
// item 2 moves to and item 4 moves from `gridSize + itemSize`, right after item 4
- val item2Offset = itemSize * 2 + ((gridSize - itemSize) * fraction).roundToInt()
- val item4Offset = gridSize + itemSize - ((gridSize - itemSize) * fraction).roundToInt()
- val expected = mutableListOf<Pair<Any, IntOffset>>().apply {
- add(0 to AxisIntOffset(0, 0))
+ val item2Offset = itemSize * 2 + (gridSize - itemSize) * fraction
+ val item4Offset = gridSize + itemSize - (gridSize - itemSize) * fraction
+ val expected = mutableListOf<Pair<Any, Offset>>().apply {
+ add(0 to AxisOffset(0f, 0f))
if (item1Offset < gridSize) {
- add(1 to AxisIntOffset(0, item1Offset))
+ add(1 to AxisOffset(0f, item1Offset))
} else {
rule.onNodeWithTag("1").assertIsNotDisplayed()
}
if (item2Offset < gridSize) {
- add(2 to AxisIntOffset(0, item2Offset))
+ add(2 to AxisOffset(0f, item2Offset))
} else {
rule.onNodeWithTag("2").assertIsNotDisplayed()
}
if (item3Offset < gridSize) {
- add(3 to AxisIntOffset(0, item3Offset))
+ add(3 to AxisOffset(0f, item3Offset))
} else {
rule.onNodeWithTag("3").assertIsNotDisplayed()
}
if (item4Offset < gridSize) {
- add(4 to AxisIntOffset(0, item4Offset))
+ add(4 to AxisOffset(0f, item4Offset))
} else {
rule.onNodeWithTag("4").assertIsNotDisplayed()
}
@@ -1944,9 +1937,9 @@
}
assertPositions(
- 0 to AxisIntOffset(0, 0),
- 1 to AxisIntOffset(0, itemSize),
- 2 to AxisIntOffset(0, itemSize * 2)
+ 0 to AxisOffset(0f, 0f),
+ 1 to AxisOffset(0f, itemSize),
+ 2 to AxisOffset(0f, itemSize * 2)
)
rule.runOnIdle {
@@ -1955,31 +1948,31 @@
onAnimationFrame { fraction ->
// item 2 moves to and item 3 moves from `gridSize`, right after the end edge
- val item2Offset = itemSize * 2 + ((gridSize - itemSize * 2) * fraction).roundToInt()
- val item3Offset = gridSize - ((gridSize - itemSize * 2) * fraction).roundToInt()
+ val item2Offset = itemSize * 2 + (gridSize - itemSize * 2) * fraction
+ val item3Offset = gridSize - (gridSize - itemSize * 2) * fraction
// item 1 moves to and item 4 moves from `gridSize + itemSize`, right after item 4
- val item1Offset = itemSize + ((gridSize + itemSize - itemSize) * fraction).roundToInt()
+ val item1Offset = itemSize + (gridSize + itemSize - itemSize) * fraction
val item4Offset =
- gridSize + itemSize - ((gridSize + itemSize - itemSize) * fraction).roundToInt()
- val expected = mutableListOf<Pair<Any, IntOffset>>().apply {
- add(0 to AxisIntOffset(0, 0))
+ gridSize + itemSize - (gridSize + itemSize - itemSize) * fraction
+ val expected = mutableListOf<Pair<Any, Offset>>().apply {
+ add(0 to AxisOffset(0f, 0f))
if (item1Offset < gridSize) {
- add(1 to AxisIntOffset(0, item1Offset))
+ add(1 to AxisOffset(0f, item1Offset))
} else {
rule.onNodeWithTag("1").assertIsNotDisplayed()
}
if (item2Offset < gridSize) {
- add(2 to AxisIntOffset(0, item2Offset))
+ add(2 to AxisOffset(0f, item2Offset))
} else {
rule.onNodeWithTag("2").assertIsNotDisplayed()
}
if (item3Offset < gridSize) {
- add(3 to AxisIntOffset(0, item3Offset))
+ add(3 to AxisOffset(0f, item3Offset))
} else {
rule.onNodeWithTag("3").assertIsNotDisplayed()
}
if (item4Offset < gridSize) {
- add(4 to AxisIntOffset(0, item4Offset))
+ add(4 to AxisOffset(0f, item4Offset))
} else {
rule.onNodeWithTag("4").assertIsNotDisplayed()
}
@@ -2005,10 +1998,10 @@
}
assertPositions(
- 0 to AxisIntOffset(0, 0),
- 1 to AxisIntOffset(itemSize, 0),
- 2 to AxisIntOffset(0, itemSize),
- 3 to AxisIntOffset(itemSize, itemSize)
+ 0 to AxisOffset(0f, 0f),
+ 1 to AxisOffset(itemSize, 0f),
+ 2 to AxisOffset(0f, itemSize),
+ 3 to AxisOffset(itemSize, itemSize)
)
rule.runOnIdle {
@@ -2018,21 +2011,21 @@
onAnimationFrame { fraction ->
// items 4 and 5 moves from and items 2 and 3 moves to `gridSize`,
// right before the start edge
- val items4and5Offset = gridSize - ((gridSize - itemSize) * fraction).roundToInt()
- val items2and3Offset = itemSize + ((gridSize - itemSize) * fraction).roundToInt()
- val expected = mutableListOf<Pair<Any, IntOffset>>().apply {
- add(0 to AxisIntOffset(0, 0))
- add(1 to AxisIntOffset(itemSize, 0))
+ val items4and5Offset = gridSize - (gridSize - itemSize) * fraction
+ val items2and3Offset = itemSize + (gridSize - itemSize) * fraction
+ val expected = mutableListOf<Pair<Any, Offset>>().apply {
+ add(0 to AxisOffset(0f, 0f))
+ add(1 to AxisOffset(itemSize, 0f))
if (items2and3Offset < gridSize) {
- add(2 to AxisIntOffset(0, items2and3Offset))
- add(3 to AxisIntOffset(itemSize, items2and3Offset))
+ add(2 to AxisOffset(0f, items2and3Offset))
+ add(3 to AxisOffset(itemSize, items2and3Offset))
} else {
rule.onNodeWithTag("2").assertIsNotDisplayed()
rule.onNodeWithTag("3").assertIsNotDisplayed()
}
if (items4and5Offset < gridSize) {
- add(4 to AxisIntOffset(0, items4and5Offset))
- add(5 to AxisIntOffset(itemSize, items4and5Offset))
+ add(4 to AxisOffset(0f, items4and5Offset))
+ add(5 to AxisOffset(itemSize, items4and5Offset))
} else {
rule.onNodeWithTag("4").assertIsNotDisplayed()
rule.onNodeWithTag("5").assertIsNotDisplayed()
@@ -2062,8 +2055,8 @@
onAnimationFrame { fraction ->
assertPositions(
- 0 to AxisIntOffset(0, 0),
- 1 to AxisIntOffset(0, itemSize),
+ 0 to AxisOffset(0f, 0f),
+ 1 to AxisOffset(0f, itemSize),
fraction = fraction
)
rule.onNodeWithTag("2").assertIsNotDisplayed()
@@ -2087,25 +2080,26 @@
onAnimationFrame { fraction ->
assertPositions(
- 0 to AxisIntOffset(0, 0),
- 1 to AxisIntOffset(0, itemSize),
- 2 to AxisIntOffset(0, itemSize * 2),
+ 0 to AxisOffset(0f, 0f),
+ 1 to AxisOffset(0f, itemSize),
+ 2 to AxisOffset(0f, itemSize * 2),
fraction = fraction
)
}
}
- private fun AxisIntOffset(crossAxis: Int, mainAxis: Int) =
- if (isVertical) IntOffset(crossAxis, mainAxis) else IntOffset(mainAxis, crossAxis)
+ private fun AxisOffset(crossAxis: Float, mainAxis: Float) =
+ if (isVertical) Offset(crossAxis, mainAxis) else Offset(mainAxis, crossAxis)
- private val IntOffset.mainAxis: Int get() = if (isVertical) y else x
+ private val Offset.mainAxis: Float get() = if (isVertical) y else x
private fun assertPositions(
- vararg expected: Pair<Any, IntOffset>,
- crossAxis: List<Pair<Any, Int>>? = null,
+ vararg expected: Pair<Any, Offset>,
+ crossAxis: List<Pair<Any, Float>>? = null,
fraction: Float? = null,
autoReverse: Boolean = reverseLayout
) {
+ val roundedExpected = expected.map { it.first to it.second.round() }
with(rule.density) {
val actual = expected.map {
val actualOffset = rule.onNodeWithTag(it.first.toString())
@@ -2123,7 +2117,7 @@
assertWithMessage("Fraction=$fraction").that(actual)
}
subject.isEqualTo(
- listOf(*expected).let { list ->
+ roundedExpected.let { list ->
if (!autoReverse) {
list
} else {
@@ -2169,14 +2163,14 @@
"CrossAxis" + if (fraction != null) "for fraction=$fraction" else ""
)
.that(actualCross)
- .isEqualTo(crossAxis)
+ .isEqualTo(crossAxis.map { it.first to it.second.roundToInt() })
}
}
}
- private fun assertLayoutInfoPositions(vararg offsets: Pair<Any, IntOffset>) {
+ private fun assertLayoutInfoPositions(vararg offsets: Pair<Any, Offset>) {
rule.runOnIdle {
- assertThat(visibleItemsOffsets).isEqualTo(listOf(*offsets))
+ assertThat(visibleItemsOffsets).isEqualTo(offsets.map { it.first to it.second.round() })
}
}
diff --git a/tv/tv-foundation/src/androidTest/java/androidx/tv/foundation/lazy/list/LazyListAnimateItemPlacementTest.kt b/tv/tv-foundation/src/androidTest/java/androidx/tv/foundation/lazy/list/LazyListAnimateItemPlacementTest.kt
index 3c0b201..4a6e880 100644
--- a/tv/tv-foundation/src/androidTest/java/androidx/tv/foundation/lazy/list/LazyListAnimateItemPlacementTest.kt
+++ b/tv/tv-foundation/src/androidTest/java/androidx/tv/foundation/lazy/list/LazyListAnimateItemPlacementTest.kt
@@ -65,9 +65,9 @@
import org.junit.Before
import org.junit.Rule
import org.junit.Test
-import org.junit.runner.RunWith
import org.junit.runners.Parameterized
import kotlin.math.roundToInt
+import org.junit.runner.RunWith
@LargeTest
@RunWith(Parameterized::class)
@@ -80,15 +80,15 @@
@get:Rule
val rule = createComposeRule()
- private val itemSize: Int = 50
+ private val itemSize: Float = 50f
private var itemSizeDp: Dp = Dp.Infinity
- private val itemSize2: Int = 30
+ private val itemSize2: Float = 30f
private var itemSize2Dp: Dp = Dp.Infinity
- private val itemSize3: Int = 20
+ private val itemSize3: Float = 20f
private var itemSize3Dp: Dp = Dp.Infinity
- private val containerSize: Int = itemSize * 5
+ private val containerSize: Float = itemSize * 5
private var containerSizeDp: Dp = Dp.Infinity
- private val spacing: Int = 10
+ private val spacing: Float = 10f
private var spacingDp: Dp = Dp.Infinity
private val itemSizePlusSpacing = itemSize + spacing
private var itemSizePlusSpacingDp = Dp.Infinity
@@ -118,7 +118,7 @@
}
}
- assertPositions(0 to 0, 1 to itemSize)
+ assertPositions(0 to 0f, 1 to itemSize)
rule.runOnIdle {
list = listOf(1, 0)
@@ -126,8 +126,8 @@
onAnimationFrame { fraction ->
assertPositions(
- 0 to 0 + (itemSize * fraction).roundToInt(),
- 1 to itemSize - (itemSize * fraction).roundToInt(),
+ 0 to 0 + itemSize * fraction,
+ 1 to itemSize - itemSize * fraction,
fraction = fraction
)
}
@@ -144,7 +144,7 @@
}
}
- assertLayoutInfoPositions(0 to 0, 1 to itemSize)
+ assertLayoutInfoPositions(0 to 0f, 1 to itemSize)
rule.runOnIdle {
list = listOf(1, 0)
@@ -152,7 +152,7 @@
onAnimationFrame {
// fraction doesn't affect the offsets in layout info
- assertLayoutInfoPositions(1 to 0, 0 to itemSize)
+ assertLayoutInfoPositions(1 to 0f, 0 to itemSize)
}
}
@@ -168,7 +168,7 @@
}
assertPositions(
- 0 to 0,
+ 0 to 0f,
1 to itemSize,
2 to itemSize * 2,
3 to itemSize * 3,
@@ -181,11 +181,11 @@
onAnimationFrame { fraction ->
assertPositions(
- 0 to 0 + (itemSize * 4 * fraction).roundToInt(),
+ 0 to 0 + itemSize * 4 * fraction,
1 to itemSize,
2 to itemSize * 2,
3 to itemSize * 3,
- 4 to itemSize * 4 - (itemSize * 4 * fraction).roundToInt(),
+ 4 to itemSize * 4 - itemSize * 4 * fraction,
fraction = fraction
)
}
@@ -203,7 +203,7 @@
}
assertPositions(
- 0 to 0,
+ 0 to 0f,
1 to itemSize,
2 to itemSize * 2,
3 to itemSize * 3,
@@ -216,11 +216,11 @@
onAnimationFrame { fraction ->
assertPositions(
- 0 to 0 + (itemSize * 4 * fraction).roundToInt(),
- 1 to itemSize - (itemSize * fraction).roundToInt(),
- 2 to itemSize * 2 - (itemSize * fraction).roundToInt(),
- 3 to itemSize * 3 - (itemSize * fraction).roundToInt(),
- 4 to itemSize * 4 - (itemSize * fraction).roundToInt(),
+ 0 to 0 + itemSize * 4 * fraction,
+ 1 to itemSize - itemSize * fraction,
+ 2 to itemSize * 2 - itemSize * fraction,
+ 3 to itemSize * 3 - itemSize * fraction,
+ 4 to itemSize * 4 - itemSize * fraction,
fraction = fraction
)
}
@@ -250,10 +250,10 @@
onAnimationFrame { fraction ->
assertPositions(
- 0 to 0,
+ 0 to 0f,
1 to itemSize,
- 2 to itemSize * 2 + (itemSize * fraction).roundToInt(),
- 3 to itemSize * 3 + (itemSize * fraction).roundToInt(),
+ 2 to itemSize * 2 + itemSize * fraction,
+ 3 to itemSize * 3 + itemSize * fraction,
fraction = fraction
)
}
@@ -277,9 +277,9 @@
onAnimationFrame { fraction ->
assertPositions(
0 to itemSize * 4,
- 1 to itemSize - (itemSize * fraction).roundToInt(),
+ 1 to itemSize - itemSize * fraction,
2 to itemSize,
- 3 to itemSize * 3 - (itemSize * fraction).roundToInt(),
+ 3 to itemSize * 3 - itemSize * fraction,
4 to itemSize * 3,
fraction = fraction
)
@@ -305,11 +305,11 @@
onAnimationFrame(duration = Duration * 2) { fraction ->
val shorterAnimFraction = (fraction * 2).coerceAtMost(1f)
assertPositions(
- 0 to 0 + (itemSize * 4 * shorterAnimFraction).roundToInt(),
- 1 to itemSize - (itemSize * fraction).roundToInt(),
- 2 to itemSize * 2 - (itemSize * shorterAnimFraction).roundToInt(),
- 3 to itemSize * 3 - (itemSize * fraction).roundToInt(),
- 4 to itemSize * 4 - (itemSize * shorterAnimFraction).roundToInt(),
+ 0 to 0 + itemSize * 4 * shorterAnimFraction,
+ 1 to itemSize - itemSize * fraction,
+ 2 to itemSize * 2 - itemSize * shorterAnimFraction,
+ 3 to itemSize * 3 - itemSize * fraction,
+ 4 to itemSize * 4 - itemSize * shorterAnimFraction,
fraction = fraction
)
}
@@ -328,7 +328,7 @@
}
assertPositions(
- 0 to 0,
+ 0 to 0f,
1 to itemSize,
2 to itemSize * 2,
3 to itemSize * 3,
@@ -340,10 +340,10 @@
onAnimationFrame { fraction ->
assertPositions(
- 0 to 0 + (itemSize * 2 * fraction).roundToInt(),
- 1 to itemSize + (itemSize * 2 * fraction).roundToInt(),
- 2 to itemSize * 2 - (itemSize * 2 * fraction).roundToInt(),
- 3 to itemSize * 3 - (itemSize * 2 * fraction).roundToInt(),
+ 0 to 0 + itemSize * 2 * fraction,
+ 1 to itemSize + itemSize * 2 * fraction,
+ 2 to itemSize * 2 - itemSize * 2 * fraction,
+ 3 to itemSize * 3 - itemSize * 2 * fraction,
fraction = fraction
)
}
@@ -367,9 +367,9 @@
onAnimationFrame { fraction ->
assertPositions(
- 0 to 0 + (itemSize * 2 * fraction).roundToInt(),
+ 0 to 0 + itemSize * 2 * fraction,
1 to itemSize * 3,
- 2 to itemSize * 2 - (itemSize * 2 * fraction).roundToInt(),
+ 2 to itemSize * 2 - itemSize * 2 * fraction,
3 to itemSize,
fraction = fraction
)
@@ -404,9 +404,9 @@
onAnimationFrame { fraction ->
assertPositions(
- 1 to itemSize - (itemSize * fraction).roundToInt(),
+ 1 to itemSize - itemSize * fraction,
2 to itemSize * 2,
- 3 to itemSize * 3 + (itemSize * fraction).roundToInt(),
+ 3 to itemSize * 3 + itemSize * fraction,
fraction = fraction
)
}
@@ -426,7 +426,7 @@
}
assertPositions(
- 0 to 0,
+ 0 to 0f,
1 to itemSize,
2 to itemSize * 2
)
@@ -437,10 +437,10 @@
onAnimationFrame { fraction ->
// item 1 moves to and item 4 moves from `listSize`, right after the end edge
- val item1Offset = itemSize + ((listSize - itemSize) * fraction).roundToInt()
- val item4Offset = listSize - ((listSize - itemSize) * fraction).roundToInt()
- val expected = mutableListOf<Pair<Any, Int>>().apply {
- add(0 to 0)
+ val item1Offset = itemSize + (listSize - itemSize) * fraction
+ val item4Offset = listSize - (listSize - itemSize) * fraction
+ val expected = mutableListOf<Pair<Any, Float>>().apply {
+ add(0 to 0f)
if (item1Offset < itemSize * 3) {
add(1 to item1Offset)
} else {
@@ -472,7 +472,7 @@
}
assertPositions(
- 3 to 0,
+ 3 to 0f,
4 to itemSize,
5 to itemSize * 2
)
@@ -483,15 +483,15 @@
onAnimationFrame { fraction ->
// item 1 moves from and item 4 moves to `0 - itemSize`, right before the start edge
- val item1Offset = -itemSize + (itemSize * 2 * fraction).roundToInt()
- val item4Offset = itemSize - (itemSize * 2 * fraction).roundToInt()
- val expected = mutableListOf<Pair<Any, Int>>().apply {
+ val item1Offset = -itemSize + itemSize * 2 * fraction
+ val item4Offset = itemSize - itemSize * 2 * fraction
+ val expected = mutableListOf<Pair<Any, Float>>().apply {
if (item4Offset > -itemSize) {
add(4 to item4Offset)
} else {
rule.onNodeWithTag("4").assertIsNotDisplayed()
}
- add(3 to 0)
+ add(3 to 0f)
if (item1Offset > -itemSize) {
add(1 to item1Offset)
} else {
@@ -521,7 +521,7 @@
}
assertPositions(
- 3 to 0,
+ 3 to 0f,
4 to itemSize
)
@@ -531,15 +531,15 @@
onAnimationFrame { fraction ->
// item 1 moves from and item 4 moves to `0 - itemSize`, right before the start edge
- val item1Offset = -itemSize + (itemSize * 2 * fraction).roundToInt()
- val item4Offset = itemSize - (itemSize * 2 * fraction).roundToInt()
- val expected = mutableListOf<Pair<Any, Int>>().apply {
+ val item1Offset = -itemSize + itemSize * 2 * fraction
+ val item4Offset = itemSize - itemSize * 2 * fraction
+ val expected = mutableListOf<Pair<Any, Float>>().apply {
if (item4Offset > -itemSize) {
add(4 to item4Offset)
} else {
rule.onNodeWithTag("4").assertIsNotDisplayed()
}
- add(3 to 0)
+ add(3 to 0f)
if (item1Offset > -itemSize) {
add(1 to item1Offset)
} else {
@@ -570,10 +570,10 @@
onAnimationFrame { fraction ->
assertPositions(
- 0 to 0 + (itemSizePlusSpacing * 3 * fraction).roundToInt(),
- 1 to itemSizePlusSpacing - (itemSizePlusSpacing * fraction).roundToInt(),
- 2 to itemSizePlusSpacing * 2 - (itemSizePlusSpacing * fraction).roundToInt(),
- 3 to itemSizePlusSpacing * 3 - (itemSizePlusSpacing * fraction).roundToInt(),
+ 0 to 0 + itemSizePlusSpacing * 3 * fraction,
+ 1 to itemSizePlusSpacing - itemSizePlusSpacing * fraction,
+ 2 to itemSizePlusSpacing * 2 - itemSizePlusSpacing * fraction,
+ 3 to itemSizePlusSpacing * 3 - itemSizePlusSpacing * fraction,
fraction = fraction
)
}
@@ -596,7 +596,7 @@
}
assertPositions(
- 0 to 0,
+ 0 to 0f,
1 to itemSizePlusSpacing,
2 to itemSizePlusSpacing * 2
)
@@ -608,12 +608,12 @@
onAnimationFrame { fraction ->
// item 1 moves to and item 4 moves from `listSize`, right after the end edge
val item1Offset =
- itemSizePlusSpacing + ((listSize - itemSizePlusSpacing) * fraction).roundToInt()
+ itemSizePlusSpacing + (listSize - itemSizePlusSpacing) * fraction
val item4Offset =
- listSize - ((listSize - itemSizePlusSpacing) * fraction).roundToInt()
+ listSize - (listSize - itemSizePlusSpacing) * fraction
val screenSize = itemSize * 3 + spacing * 2
- val expected = mutableListOf<Pair<Any, Int>>().apply {
- add(0 to 0)
+ val expected = mutableListOf<Pair<Any, Float>>().apply {
+ add(0 to 0f)
if (item1Offset < screenSize) {
add(1 to item1Offset)
} else {
@@ -649,7 +649,7 @@
}
assertPositions(
- 3 to 0,
+ 3 to 0f,
4 to itemSizePlusSpacing,
5 to itemSizePlusSpacing * 2
)
@@ -661,16 +661,16 @@
onAnimationFrame { fraction ->
// item 4 moves to and item 1 moves from `-itemSize`, right before the start edge
val item1Offset =
- -itemSize + ((itemSize + itemSizePlusSpacing) * fraction).roundToInt()
+ -itemSize + (itemSize + itemSizePlusSpacing) * fraction
val item4Offset =
- itemSizePlusSpacing - ((itemSize + itemSizePlusSpacing) * fraction).roundToInt()
- val expected = mutableListOf<Pair<Any, Int>>().apply {
+ itemSizePlusSpacing - (itemSize + itemSizePlusSpacing) * fraction
+ val expected = mutableListOf<Pair<Any, Float>>().apply {
if (item4Offset > -itemSize) {
add(4 to item4Offset)
} else {
rule.onNodeWithTag("4").assertIsNotDisplayed()
}
- add(3 to 0)
+ add(3 to 0f)
if (item1Offset > -itemSize) {
add(1 to item1Offset)
} else {
@@ -701,7 +701,7 @@
val item3Size = itemSize2
val item4Size = itemSize
assertPositions(
- 3 to 0,
+ 3 to 0f,
4 to item3Size,
5 to item3Size + item4Size
)
@@ -718,22 +718,22 @@
// item 1 moves from and item 4 moves to `0 - item size`, right before the start edge
val startItem1Offset = -item1Size
val item1Offset =
- startItem1Offset + ((itemSize2 - startItem1Offset) * fraction).roundToInt()
+ startItem1Offset + (itemSize2 - startItem1Offset) * fraction
val endItem4Offset = -item4Size
- val item4Offset = item3Size - ((item3Size - endItem4Offset) * fraction).roundToInt()
- val expected = mutableListOf<Pair<Any, Int>>().apply {
+ val item4Offset = item3Size - (item3Size - endItem4Offset) * fraction
+ val expected = mutableListOf<Pair<Any, Float>>().apply {
if (item4Offset > -item4Size) {
add(4 to item4Offset)
} else {
rule.onNodeWithTag("4").assertIsNotDisplayed()
}
- add(3 to 0)
+ add(3 to 0f)
if (item1Offset > -item1Size) {
add(1 to item1Offset)
} else {
rule.onNodeWithTag("1").assertIsNotDisplayed()
}
- add(5 to item3Size + item4Size - ((item4Size - item1Size) * fraction).roundToInt())
+ add(5 to item3Size + item4Size - (item4Size - item1Size) * fraction)
}
assertPositions(
expected = expected.toTypedArray(),
@@ -760,7 +760,7 @@
val item0Size = itemSize2
val item1Size = itemSize
assertPositions(
- 0 to 0,
+ 0 to 0f,
1 to item0Size,
2 to item0Size + item1Size
)
@@ -775,17 +775,17 @@
val endItem1Offset = listSize
val item4Size = itemSize3
val item1Offset =
- item0Size + ((endItem1Offset - item0Size) * fraction).roundToInt()
+ item0Size + (endItem1Offset - item0Size) * fraction
val item4Offset =
- startItem4Offset - ((startItem4Offset - item0Size) * fraction).roundToInt()
- val expected = mutableListOf<Pair<Any, Int>>().apply {
- add(0 to 0)
+ startItem4Offset - (startItem4Offset - item0Size) * fraction
+ val expected = mutableListOf<Pair<Any, Float>>().apply {
+ add(0 to 0f)
if (item1Offset < listSize) {
add(1 to item1Offset)
} else {
rule.onNodeWithTag("1").assertIsNotDisplayed()
}
- add(2 to item0Size + item1Size - ((item1Size - item4Size) * fraction).roundToInt())
+ add(2 to item0Size + item1Size - (item1Size - item4Size) * fraction)
if (item4Offset < listSize) {
add(4 to item4Offset)
} else {
@@ -818,11 +818,11 @@
val item2Start = itemSize - itemSize2
val item3Start = itemSize - itemSize3
assertPositions(
- 1 to 0,
+ 1 to 0f,
2 to itemSize,
3 to itemSize * 2,
crossAxis = listOf(
- 1 to 0,
+ 1 to 0f,
2 to item2Start,
3 to item3Start,
)
@@ -837,13 +837,13 @@
val item3End = itemSize / 2 - itemSize3 / 2
onAnimationFrame { fraction ->
assertPositions(
- 1 to 0,
+ 1 to 0f,
2 to itemSize,
3 to itemSize * 2,
crossAxis = listOf(
- 1 to 0,
- 2 to item2Start + ((item2End - item2Start) * fraction).roundToInt(),
- 3 to item3Start + ((item3End - item3Start) * fraction).roundToInt(),
+ 1 to 0f,
+ 2 to item2Start + (item2End - item2Start) * fraction,
+ 3 to item3Start + (item3End - item3Start) * fraction,
),
fraction = fraction
)
@@ -876,13 +876,13 @@
val containerSize = itemSize * 2
onAnimationFrame { fraction ->
assertPositions(
- 1 to 0,
+ 1 to 0f,
2 to itemSize,
3 to itemSize * 2,
crossAxis = listOf(
- 1 to ((containerSize - itemSize) * fraction).roundToInt(),
- 2 to ((containerSize - itemSize2) * fraction).roundToInt(),
- 3 to ((containerSize - itemSize3) * fraction).roundToInt()
+ 1 to (containerSize - itemSize) * fraction,
+ 2 to (containerSize - itemSize2) * fraction,
+ 3 to (containerSize - itemSize3) * fraction
),
fraction = fraction
)
@@ -911,13 +911,13 @@
}
assertPositions(
- 1 to 0,
+ 1 to 0f,
2 to itemSize,
3 to itemSize * 2,
crossAxis = listOf(
- 1 to 0,
- 2 to 0,
- 3 to 0,
+ 1 to 0f,
+ 2 to 0f,
+ 3 to 0f,
)
)
@@ -928,13 +928,13 @@
onAnimationFrame { fraction ->
assertPositions(
- 1 to 0,
+ 1 to 0f,
2 to itemSize,
3 to itemSize * 2,
crossAxis = listOf(
- 1 to 0,
- 2 to ((itemSize / 2 - itemSize2 / 2) * fraction).roundToInt(),
- 3 to ((itemSize / 2 - itemSize3 / 2) * fraction).roundToInt(),
+ 1 to 0f,
+ 2 to (itemSize / 2 - itemSize2 / 2) * fraction,
+ 3 to (itemSize / 2 - itemSize3 / 2) * fraction
),
fraction = fraction
)
@@ -944,8 +944,8 @@
@Test
fun moveItemToEndCausingNextItemsToAnimate_withContentPadding() {
var list by mutableStateOf(listOf(0, 1, 2, 3, 4))
- val rawStartPadding = 8
- val rawEndPadding = 12
+ val rawStartPadding = 8f
+ val rawEndPadding = 12f
val (startPaddingDp, endPaddingDp) = with(rule.density) {
rawStartPadding.toDp() to rawEndPadding.toDp()
}
@@ -973,10 +973,10 @@
onAnimationFrame { fraction ->
assertPositions(
0 to startPadding,
- 1 to startPadding + itemSize + (itemSize * 3 * fraction).roundToInt(),
- 2 to startPadding + itemSize * 2 - (itemSize * fraction).roundToInt(),
- 3 to startPadding + itemSize * 3 - (itemSize * fraction).roundToInt(),
- 4 to startPadding + itemSize * 4 - (itemSize * fraction).roundToInt(),
+ 1 to startPadding + itemSize + itemSize * 3 * fraction,
+ 2 to startPadding + itemSize * 2 - itemSize * fraction,
+ 3 to startPadding + itemSize * 3 - itemSize * fraction,
+ 4 to startPadding + itemSize * 4 - itemSize * fraction,
fraction = fraction
)
}
@@ -1030,7 +1030,7 @@
rule.runOnIdle {
runBlocking {
- state.scrollToItem(0, itemSize / 2)
+ state.scrollToItem(0, (itemSize / 2).roundToInt())
}
}
@@ -1226,9 +1226,9 @@
onAnimationFrame { fraction ->
// item 1 moves to `listSize`
- val item1Offset = itemSize + ((listSize - itemSize) * fraction).roundToInt()
- val expected = mutableListOf<Pair<Any, Int>>().apply {
- add(0 to 0)
+ val item1Offset = itemSize + (listSize - itemSize) * fraction
+ val expected = mutableListOf<Pair<Any, Float>>().apply {
+ add(0 to 0f)
if (item1Offset < listSize) {
add(1 to item1Offset)
} else {
@@ -1254,7 +1254,7 @@
}
assertPositions(
- 3 to 0,
+ 3 to 0f,
4 to itemSize,
5 to itemSize * 2
)
@@ -1265,12 +1265,12 @@
onAnimationFrame { fraction ->
// item 2 moves from and item 5 moves to `-itemSize`, right before the start edge
- val item2Offset = -itemSize + (itemSize * 3 * fraction).roundToInt()
- val item5Offset = itemSize * 2 - (itemSize * 3 * fraction).roundToInt()
+ val item2Offset = -itemSize + itemSize * 3 * fraction
+ val item5Offset = itemSize * 2 - itemSize * 3 * fraction
// item 1 moves from and item 4 moves to `-itemSize * 2`, right before item 2
- val item1Offset = -itemSize * 2 + (itemSize * 3 * fraction).roundToInt()
- val item4Offset = itemSize - (itemSize * 3 * fraction).roundToInt()
- val expected = mutableListOf<Pair<Any, Int>>().apply {
+ val item1Offset = -itemSize * 2 + itemSize * 3 * fraction
+ val item4Offset = itemSize - itemSize * 3 * fraction
+ val expected = mutableListOf<Pair<Any, Float>>().apply {
if (item1Offset > -itemSize) {
add(1 to item1Offset)
} else {
@@ -1281,7 +1281,7 @@
} else {
rule.onNodeWithTag("2").assertIsNotDisplayed()
}
- add(3 to 0)
+ add(3 to 0f)
if (item4Offset > -itemSize) {
add(4 to item4Offset)
} else {
@@ -1312,7 +1312,7 @@
}
assertPositions(
- 3 to 0,
+ 3 to 0f,
4 to itemSize,
5 to itemSize * 2
)
@@ -1323,12 +1323,12 @@
onAnimationFrame { fraction ->
// item 2 moves from and item 4 moves to `-itemSize`, right before the start edge
- val item2Offset = -itemSize + (itemSize * 2 * fraction).roundToInt()
- val item4Offset = itemSize - (itemSize * 2 * fraction).roundToInt()
+ val item2Offset = -itemSize + itemSize * 2 * fraction
+ val item4Offset = itemSize - itemSize * 2 * fraction
// item 1 moves from and item 5 moves to `-itemSize * 2`, right before item 2
- val item1Offset = -itemSize * 2 + (itemSize * 4 * fraction).roundToInt()
- val item5Offset = itemSize * 2 - (itemSize * 4 * fraction).roundToInt()
- val expected = mutableListOf<Pair<Any, Int>>().apply {
+ val item1Offset = -itemSize * 2 + itemSize * 4 * fraction
+ val item5Offset = itemSize * 2 - itemSize * 4 * fraction
+ val expected = mutableListOf<Pair<Any, Float>>().apply {
if (item1Offset > -itemSize) {
add(1 to item1Offset)
} else {
@@ -1339,7 +1339,7 @@
} else {
rule.onNodeWithTag("2").assertIsNotDisplayed()
}
- add(3 to 0)
+ add(3 to 0f)
if (item4Offset > -itemSize) {
add(4 to item4Offset)
} else {
@@ -1372,7 +1372,7 @@
}
assertPositions(
- 0 to 0,
+ 0 to 0f,
1 to itemSize,
2 to itemSize * 2
)
@@ -1383,13 +1383,13 @@
onAnimationFrame { fraction ->
// item 1 moves to and item 3 moves from `listSize`, right after the end edge
- val item1Offset = itemSize + ((listSize - itemSize) * fraction).roundToInt()
- val item3Offset = listSize - ((listSize - itemSize) * fraction).roundToInt()
+ val item1Offset = itemSize + (listSize - itemSize) * fraction
+ val item3Offset = listSize - (listSize - itemSize) * fraction
// item 2 moves to and item 4 moves from `listSize + itemSize`, right after item 4
- val item2Offset = itemSize * 2 + ((listSize - itemSize) * fraction).roundToInt()
- val item4Offset = listSize + itemSize - ((listSize - itemSize) * fraction).roundToInt()
- val expected = mutableListOf<Pair<Any, Int>>().apply {
- add(0 to 0)
+ val item2Offset = itemSize * 2 + (listSize - itemSize) * fraction
+ val item4Offset = listSize + itemSize - (listSize - itemSize) * fraction
+ val expected = mutableListOf<Pair<Any, Float>>().apply {
+ add(0 to 0f)
if (item1Offset < listSize) {
add(1 to item1Offset)
} else {
@@ -1432,7 +1432,7 @@
}
assertPositions(
- 0 to 0,
+ 0 to 0f,
1 to itemSize,
2 to itemSize * 2
)
@@ -1443,14 +1443,14 @@
onAnimationFrame { fraction ->
// item 2 moves to and item 3 moves from `listSize`, right after the end edge
- val item2Offset = itemSize * 2 + ((listSize - itemSize * 2) * fraction).roundToInt()
- val item3Offset = listSize - ((listSize - itemSize * 2) * fraction).roundToInt()
+ val item2Offset = itemSize * 2 + (listSize - itemSize * 2) * fraction
+ val item3Offset = listSize - (listSize - itemSize * 2) * fraction
// item 1 moves to and item 4 moves from `listSize + itemSize`, right after item 4
- val item1Offset = itemSize + ((listSize + itemSize - itemSize) * fraction).roundToInt()
+ val item1Offset = itemSize + (listSize + itemSize - itemSize) * fraction
val item4Offset =
- listSize + itemSize - ((listSize + itemSize - itemSize) * fraction).roundToInt()
- val expected = mutableListOf<Pair<Any, Int>>().apply {
- add(0 to 0)
+ listSize + itemSize - (listSize + itemSize - itemSize) * fraction
+ val expected = mutableListOf<Pair<Any, Float>>().apply {
+ add(0 to 0f)
if (item1Offset < listSize) {
add(1 to item1Offset)
} else {
@@ -1496,7 +1496,7 @@
onAnimationFrame { fraction ->
assertPositions(
- 0 to 0,
+ 0 to 0f,
1 to itemSize,
fraction = fraction
)
@@ -1521,7 +1521,7 @@
onAnimationFrame { fraction ->
assertPositions(
- 0 to 0,
+ 0 to 0f,
1 to itemSize,
2 to itemSize * 2,
fraction = fraction
@@ -1530,11 +1530,12 @@
}
private fun assertPositions(
- vararg expected: Pair<Any, Int>,
- crossAxis: List<Pair<Any, Int>>? = null,
+ vararg expected: Pair<Any, Float>,
+ crossAxis: List<Pair<Any, Float>>? = null,
fraction: Float? = null,
autoReverse: Boolean = reverseLayout
) {
+ val roundedExpected = expected.map { it.first to it.second.roundToInt() }
with(rule.density) {
val actual = expected.map {
val actualOffset = rule.onNodeWithTag(it.first.toString())
@@ -1550,7 +1551,7 @@
assertWithMessage("Fraction=$fraction").that(actual)
}
subject.isEqualTo(
- listOf(*expected).let { list ->
+ roundedExpected.let { list ->
if (!autoReverse) {
list
} else {
@@ -1581,14 +1582,16 @@
"CrossAxis" + if (fraction != null) "for fraction=$fraction" else ""
)
.that(actualCross)
- .isEqualTo(crossAxis)
+ .isEqualTo(crossAxis.map { it.first to it.second.roundToInt() })
}
}
}
- private fun assertLayoutInfoPositions(vararg offsets: Pair<Any, Int>) {
+ private fun assertLayoutInfoPositions(vararg offsets: Pair<Any, Float>) {
rule.runOnIdle {
- assertThat(visibleItemsOffsets).isEqualTo(listOf(*offsets))
+ assertThat(visibleItemsOffsets).isEqualTo(offsets.map {
+ it.first to it.second.roundToInt()
+ })
}
}
