IssueTracker

Not sure if this is possible because of beta now, but it would be nice to add the start and end values of a swipe as parameters with default values to swipeDown, swipeUp, swipeLeft and swipeRight.

I was working on a test where I wanted to test a swipe upwards, but only to a certain point. Using swipe instead works, but it's not as readable if you have to calculate that in every test.

This is what I had in mind:

fun GestureScope.swipeUp(
    startY: Float = (visibleSize.height * (1 - edgeFuzzFactor)).roundToInt().toFloat(),
    endY: Float = 0.0f
) {
    require(startY >= endY) {
        "Start position $startY needs to be equal or bigger than end position $endY"
    }
    val x = center.x
    val start = Offset(x, startY)
    val end = Offset(x, endY)
    swipe(start, end, 200)
}

fun GestureScope.swipeDown(
    startY: Float = (visibleSize.height * edgeFuzzFactor).roundToInt().toFloat(),
    endY: Float = visibleSize.height.toFloat()
) {
    require(startY <= endY) {
        "End position $endY needs to be equal or bigger than start position $startY"
    }
    val x = center.x
    val start = Offset(x, startY)
    val end = Offset(x, endY)
    swipe(start, end, 200)
}

Here's an example test of where this would be useful:

@Test
@LargeTest
fun bottomDrawer_expandBySwipe_tallDrawer(): Unit = runBlocking {
    val contentTag = "contentTestTag"
    lateinit var drawerState: BottomDrawerState
    rule.setMaterialContent {
        drawerState = rememberBottomDrawerState(BottomDrawerValue.Closed)
        BottomDrawer(
            drawerState = drawerState,
            drawerContent = {
                Box(
                    Modifier.fillMaxSize().testTag(bottomDrawerTag)
                )
            },
            content = { Box(Modifier.fillMaxSize().testTag(contentTag)) }
        )
    }

    val isLandscape = rule.rootWidth() > rule.rootHeight()

    rule.runOnIdle {
        assertThat(drawerState.currentValue).isEqualTo(BottomDrawerValue.Closed)
    }

    val peekHeight = with(rule.density) { rule.rootHeight().toPx() / 2 }

    rule.onNodeWithTag(contentTag)
        .performGesture { 
            swipe(
                startY = (visibleSize.height * (1 - 0.083f)).roundToInt().toFloat(),
                endY = peekHeight
            )
            // We could use this instead
            swipeUp(endY = peekHeight)
        }

    advanceClock()

    rule.runOnIdle {
        assertThat(drawerState.currentValue).isEqualTo(
            if (isLandscape) BottomDrawerValue.Expanded else BottomDrawerValue.Open
        )
    }

    rule.onNodeWithTag(bottomDrawerTag)
        .performGesture { swipeUp() }

    advanceClock()

    rule.runOnIdle {
        assertThat(drawerState.currentValue).isEqualTo(BottomDrawerValue.Expanded)
    }

    rule.onNodeWithTag(bottomDrawerTag)
        .performGesture { 
            swipe(
                startY = (visibleSize.height * (1 - 0.083f)).roundToInt().toFloat(),
                endY = peekHeight
            )
            // We could use this instead
            swipeDown(endY = peekHeight)
        }

    advanceClock()

    rule.runOnIdle {
        assertThat(drawerState.currentValue).isEqualTo(BottomDrawerValue.Open)
    }

    rule.onNodeWithTag(bottomDrawerTag)
        .performGesture { swipeDown() }

    advanceClock()

    rule.runOnIdle {
        assertThat(drawerState.currentValue).isEqualTo(BottomDrawerValue.Closed)
    }

}

What do you think? It doesn't change existing behaviour and is backwards-compatible, but ofc still an API change.