[go: nahoru, domu]
Google Git
Sign in
android / platform / frameworks / support / e6a9b33d0b113a6f7521ab8a06560963f7a4f116 / . / ui / ui-core / src / test / java / androidx / ui / core / gesture / DragSlopExceededGestureFilterTest.kt
blob: cd4a7fc4f2f706a21ce3dbe7f870e50836aa7708 [file] [log] [blame]
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]1/*
2 * Copyright 2019 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17package androidx.ui.core.gesture
18
19import androidx.ui.core.Direction
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]20import androidx.ui.core.PointerEventPass
21import androidx.ui.core.consumeDownChange
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]22import androidx.ui.testutils.consume
23import androidx.ui.testutils.down
24import androidx.ui.testutils.invokeOverAllPasses
25import androidx.ui.testutils.invokeOverPasses
26import androidx.ui.testutils.moveBy
27import androidx.ui.testutils.moveTo
28import androidx.ui.testutils.up
George Mount842c8c12020-01-08 16:03:42 -0800[diff] [blame]29import androidx.ui.unit.Duration
George Mount842c8c12020-01-08 16:03:42 -0800[diff] [blame]30import androidx.ui.unit.milliseconds
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]31import com.google.common.truth.Truth.assertThat
32import org.junit.Before
33import org.junit.Test
34import org.junit.runner.RunWith
35import org.junit.runners.JUnit4
36
37// TODO(shepshapard): Write the following tests.
38// Verify correct shape of slop area (should it be a square or circle)?
39// Test for cases with more than one pointer
40// Test for cases where things are reset when last pointer goes up
41// Verify all methods called during onPostUp
Shep Shapardad4e8152020-04-03 13:22:08 -0700[diff] [blame]42// Verify default behavior when no callback provided for filter or canDrag
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]43
44// Changing this value will break tests that expect the value to be 10.
45private const val TestTouchSlop = 10
46
47@RunWith(JUnit4::class)
Shep Shaparddd9e2bc2020-05-19 15:25:36 -0700[diff] [blame]48class DragSlopExceededGestureFilterTest {
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]49
Shep Shaparddd9e2bc2020-05-19 15:25:36 -0700[diff] [blame]50 private val onDragSlopExceeded: () -> Unit = { onDragSlopExceededCallCount++ }
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]51 private val canDrag: (Direction) -> Boolean = { direction ->
52 canDragDirections.add(direction)
53 canDragReturn
54 }
Shep Shaparddd9e2bc2020-05-19 15:25:36 -0700[diff] [blame]55 private var onDragSlopExceededCallCount: Int = 0
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]56 private var canDragReturn = false
57 private var canDragDirections: MutableList<Direction> = mutableListOf()
Shep Shaparddd9e2bc2020-05-19 15:25:36 -0700[diff] [blame]58 private lateinit var filter: DragSlopExceededGestureFilter
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]59
Shep Shapard4babf792020-02-13 16:37:14 -0800[diff] [blame]60 private val TinyNum = .01f
61
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]62 @Before
63 fun setup() {
Shep Shaparddd9e2bc2020-05-19 15:25:36 -0700[diff] [blame]64 onDragSlopExceededCallCount = 0
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]65 canDragReturn = true
66 canDragDirections.clear()
Shep Shapardad4e8152020-04-03 13:22:08 -0700[diff] [blame]67 filter =
Nader Jawadfeb99f82020-05-21 13:07:36 -0700[diff] [blame]68 DragSlopExceededGestureFilter(TestTouchSlop.toFloat())
Shep Shapardad4e8152020-04-03 13:22:08 -0700[diff] [blame]69 filter.canDrag = canDrag
Shep Shaparddd9e2bc2020-05-19 15:25:36 -0700[diff] [blame]70 filter.onDragSlopExceeded = onDragSlopExceeded
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]71 }
72
73 // Verify the circumstances under which canDrag should not be called.
74
75 @Test
76 fun onPointerInputChanges_down_canDragNotCalled() {
Shep Shapardad4e8152020-04-03 13:22:08 -0700[diff] [blame]77 filter::onPointerInput.invokeOverAllPasses(down(0))
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]78 assertThat(canDragDirections).isEmpty()
79 }
80
81 @Test
82 fun onPointerInputChanges_downUp_canDragNotCalled() {
Shep Shapard091fd692020-01-29 16:35:47 -0800[diff] [blame]83 val down = down(0, duration = 0.milliseconds)
Shep Shapardad4e8152020-04-03 13:22:08 -0700[diff] [blame]84 filter::onPointerInput.invokeOverAllPasses(down)
Shep Shaparde261df92019-11-15 11:24:31 -0800[diff] [blame]85 val up = down.up(10.milliseconds)
Shep Shapardad4e8152020-04-03 13:22:08 -0700[diff] [blame]86 filter::onPointerInput.invokeOverAllPasses(up)
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]87
88 assertThat(canDragDirections).isEmpty()
89 }
90
91 @Test
92 fun onPointerInputChanges_downMoveFullyConsumed_canDragNotCalled() {
Shep Shapard091fd692020-01-29 16:35:47 -0800[diff] [blame]93 val down = down(0)
Shep Shapardad4e8152020-04-03 13:22:08 -0700[diff] [blame]94 filter::onPointerInput.invokeOverAllPasses(down)
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]95 val move = down.moveBy(Duration(milliseconds = 10), 3f, 5f).consume(3f, 5f)
Shep Shapardad4e8152020-04-03 13:22:08 -0700[diff] [blame]96 filter::onPointerInput.invokeOverAllPasses(move)
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]97
98 assertThat(canDragDirections).isEmpty()
99 }
100
101 // Verify the circumstances under which canDrag should be called.
102
103 @Test
104 fun onPointerInputChanges_downMove1Dimension_canDragCalledOnce() {
Shep Shapard091fd692020-01-29 16:35:47 -0800[diff] [blame]105 val down = down(0)
Shep Shapardad4e8152020-04-03 13:22:08 -0700[diff] [blame]106 filter::onPointerInput.invokeOverAllPasses(down)
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]107 val move = down.moveBy(Duration(milliseconds = 10), 3f, 0f)
Shep Shapardad4e8152020-04-03 13:22:08 -0700[diff] [blame]108 filter::onPointerInput.invokeOverAllPasses(move)
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]109
110 // Twice because while under touch slop, TouchSlopExceededGestureDetector checks during PostUp and PostDown
111 assertThat(canDragDirections).hasSize(2)
112 }
113
114 @Test
115 fun onPointerInputChanges_downMove2Dimensions_canDragCalledTwice() {
Shep Shapard091fd692020-01-29 16:35:47 -0800[diff] [blame]116 val down = down(0)
Shep Shapardad4e8152020-04-03 13:22:08 -0700[diff] [blame]117 filter::onPointerInput.invokeOverAllPasses(down)
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]118 val move = down.moveBy(Duration(milliseconds = 10), 3f, 5f)
Shep Shapardad4e8152020-04-03 13:22:08 -0700[diff] [blame]119 filter::onPointerInput.invokeOverAllPasses(move)
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]120
121 // 4 times because while under touch slop, TouchSlopExceededGestureDetector checks during PostUp and
122 // PostDown
123 assertThat(canDragDirections).hasSize(4)
124 }
125
126 @Test
127 fun onPointerInputChanges_downMoveOneDimensionPartiallyConsumed_canDragCalledOnce() {
Shep Shapard091fd692020-01-29 16:35:47 -0800[diff] [blame]128 val down = down(0)
Shep Shapardad4e8152020-04-03 13:22:08 -0700[diff] [blame]129 filter::onPointerInput.invokeOverAllPasses(down)
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]130 val move = down.moveBy(Duration(milliseconds = 10), 0f, 5f).consume(0f, 4f)
Shep Shapardad4e8152020-04-03 13:22:08 -0700[diff] [blame]131 filter::onPointerInput.invokeOverAllPasses(move)
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]132
133 // Twice because while under touch slop, DragGestureDetector checks during PostUp and
134 // PostDown
135 assertThat(canDragDirections).hasSize(2)
136 }
137
138 @Test
139 fun onPointerInputChanges_downMoveTwoDimensionPartiallyConsumed_canDragCalledTwice() {
Shep Shapard091fd692020-01-29 16:35:47 -0800[diff] [blame]140 val down = down(0)
Shep Shapardad4e8152020-04-03 13:22:08 -0700[diff] [blame]141 filter::onPointerInput.invokeOverAllPasses(down)
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]142 val move = down.moveBy(Duration(milliseconds = 10), 3f, 5f).consume(2f, 4f)
Shep Shapardad4e8152020-04-03 13:22:08 -0700[diff] [blame]143 filter::onPointerInput.invokeOverAllPasses(move)
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]144
145 // 4 times because while under touch slop, DragGestureDetector checks during PostUp and
146 // PostDown
147 assertThat(canDragDirections).hasSize(4)
148 }
149
150 @Test
151 fun onPointerInputChanges_dragPastTouchSlopOneDimensionAndDrag3MoreTimes_canDragCalledOnce() {
Shep Shapard4babf792020-02-13 16:37:14 -0800[diff] [blame]152 val beyondSlop = TestTouchSlop + TinyNum
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]153
Shep Shapard091fd692020-01-29 16:35:47 -0800[diff] [blame]154 val down = down(0)
Shep Shapardad4e8152020-04-03 13:22:08 -0700[diff] [blame]155 filter::onPointerInput.invokeOverAllPasses(down)
Shep Shapard4babf792020-02-13 16:37:14 -0800[diff] [blame]156 var move = down.moveTo(10.milliseconds, 0f, beyondSlop)
Shep Shapardad4e8152020-04-03 13:22:08 -0700[diff] [blame]157 filter::onPointerInput.invokeOverAllPasses(move)
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]158 repeat(3) {
159 move = move.moveBy(Duration(milliseconds = 10), 0f, 1f)
Shep Shapardad4e8152020-04-03 13:22:08 -0700[diff] [blame]160 filter::onPointerInput.invokeOverAllPasses(move)
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]161 }
162
163 // Once because although DragGestureDetector checks during PostUp and PostDown, slop is
164 // surpassed during PostUp, and thus isn't checked again.
165 assertThat(canDragDirections).hasSize(1)
166 }
167
168 @Test
169 fun onPointerInputChanges_downMoveUnderSlop3Times_canDragCalled3Times() {
Shep Shapard4babf792020-02-13 16:37:14 -0800[diff] [blame]170 val thirdSlop = TestTouchSlop / 3
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]171
Shep Shapard091fd692020-01-29 16:35:47 -0800[diff] [blame]172 val down = down(0)
Shep Shapardad4e8152020-04-03 13:22:08 -0700[diff] [blame]173 filter::onPointerInput.invokeOverAllPasses(down)
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]174 var move = down
175 repeat(3) {
Shep Shapard4babf792020-02-13 16:37:14 -0800[diff] [blame]176 move = move.moveBy(Duration(milliseconds = 10), 0f, thirdSlop.toFloat())
Shep Shapardad4e8152020-04-03 13:22:08 -0700[diff] [blame]177 filter::onPointerInput.invokeOverAllPasses(move)
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]178 }
179
180 // 6 times because while under touch slop, DragGestureDetector checks during PostUp and
181 // PostDown
182 assertThat(canDragDirections).hasSize(6)
183 }
184
185 @Test
186 fun onPointerInputChanges_moveBeyondSlopThenIntoTouchSlopAreaAndOutAgain_canDragCalledOnce() {
Shep Shapard4babf792020-02-13 16:37:14 -0800[diff] [blame]187 val beyondSlop = TestTouchSlop + TinyNum
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]188
Shep Shapard091fd692020-01-29 16:35:47 -0800[diff] [blame]189 var event = down(0)
Shep Shapardad4e8152020-04-03 13:22:08 -0700[diff] [blame]190 filter::onPointerInput.invokeOverAllPasses(event)
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]191 // Out of touch slop region
Shep Shapard4babf792020-02-13 16:37:14 -0800[diff] [blame]192 event = event.moveBy(Duration(milliseconds = 10), 0f, beyondSlop)
Shep Shapardad4e8152020-04-03 13:22:08 -0700[diff] [blame]193 filter::onPointerInput.invokeOverAllPasses(event)
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]194 // Back into touch slop region
Shep Shapard4babf792020-02-13 16:37:14 -0800[diff] [blame]195 event = event.moveBy(Duration(milliseconds = 10), 0f, -beyondSlop)
Shep Shapardad4e8152020-04-03 13:22:08 -0700[diff] [blame]196 filter::onPointerInput.invokeOverAllPasses(event)
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]197 // Out of touch slop region again
Shep Shapard4babf792020-02-13 16:37:14 -0800[diff] [blame]198 event = event.moveBy(Duration(milliseconds = 10), 0f, beyondSlop)
Shep Shapardad4e8152020-04-03 13:22:08 -0700[diff] [blame]199 filter::onPointerInput.invokeOverAllPasses(event)
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]200
201 // Once because although DragGestureDetector checks during PostUp and PostDown, slop is
202 // surpassed during PostUp, and thus isn't checked again.
203 assertThat(canDragDirections).hasSize(1)
204 }
205
206 // Verification of correctness of values passed to canDrag.
207
208 @Test
209 fun onPointerInputChanges_canDragCalledWithCorrectDirection() {
210 onPointerInputChanges_canDragCalledWithCorrectDirection(
211 -1f, 0f, arrayOf(Direction.LEFT)
212 )
213 onPointerInputChanges_canDragCalledWithCorrectDirection(
214 0f, -1f, arrayOf(Direction.UP)
215 )
216 onPointerInputChanges_canDragCalledWithCorrectDirection(
217 1f, 0f, arrayOf(Direction.RIGHT)
218 )
219 onPointerInputChanges_canDragCalledWithCorrectDirection(
220 0f, 1f, arrayOf(Direction.DOWN)
221 )
222 onPointerInputChanges_canDragCalledWithCorrectDirection(
223 -1f, -1f, arrayOf(Direction.LEFT, Direction.UP)
224 )
225 onPointerInputChanges_canDragCalledWithCorrectDirection(
226 -1f, 1f, arrayOf(Direction.LEFT, Direction.DOWN)
227 )
228 onPointerInputChanges_canDragCalledWithCorrectDirection(
229 1f, -1f, arrayOf(Direction.RIGHT, Direction.UP)
230 )
231 onPointerInputChanges_canDragCalledWithCorrectDirection(
232 1f, 1f, arrayOf(Direction.RIGHT, Direction.DOWN)
233 )
234 }
235
236 private fun onPointerInputChanges_canDragCalledWithCorrectDirection(
237 dx: Float,
238 dy: Float,
239 expectedDirections: Array<Direction>
240 ) {
241 canDragDirections.clear()
Shep Shapard091fd692020-01-29 16:35:47 -0800[diff] [blame]242 val down = down(0)
Shep Shapardad4e8152020-04-03 13:22:08 -0700[diff] [blame]243 filter::onPointerInput.invokeOverAllPasses(down)
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]244 val move = down.moveBy(Duration(milliseconds = 10), dx, dy)
Shep Shapardad4e8152020-04-03 13:22:08 -0700[diff] [blame]245 filter::onPointerInput.invokeOverAllPasses(move)
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]246
247 // Everything here is twice because DragGestureDetector checks during PostUp and PostDown.
248 assertThat(canDragDirections).hasSize(expectedDirections.size * 2)
249 expectedDirections.forEach { direction ->
250 assertThat(canDragDirections.count { it == direction })
251 .isEqualTo(2)
252 }
253 }
254
255 // Verify the circumstances under which onTouchSlopExceeded should not be called.
256
257 // TODO(b/129701831): This test assumes that if a pointer moves by slop in both x and y, we are
258 // still under slop even though sqrt(slop^2 + slop^2) > slop. This may be inaccurate and this
259 // test may therefore need to be updated.
260 @Test
261 fun onPointerInputChanges_downMoveWithinSlop_onTouchSlopExceededNotCalled() {
Shep Shapard091fd692020-01-29 16:35:47 -0800[diff] [blame]262 val down = down(0)
Shep Shapardad4e8152020-04-03 13:22:08 -0700[diff] [blame]263 filter::onPointerInput.invokeOverAllPasses(down)
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]264 val move = down.moveBy(
265 Duration(milliseconds = 10),
266 TestTouchSlop.toFloat(),
267 TestTouchSlop.toFloat()
268 )
Shep Shapardad4e8152020-04-03 13:22:08 -0700[diff] [blame]269 filter::onPointerInput.invokeOverAllPasses(move)
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]270
Shep Shaparddd9e2bc2020-05-19 15:25:36 -0700[diff] [blame]271 assertThat(onDragSlopExceededCallCount).isEqualTo(0)
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]272 }
273
274 @Test
275 fun onPointerInputChanges_moveBeyondSlopInUnsupportedDirection_onTouchSlopExceededNotCalled() {
Shep Shapard4babf792020-02-13 16:37:14 -0800[diff] [blame]276 val beyondSlop = TestTouchSlop + TinyNum
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]277 canDragReturn = false
278
Shep Shapard091fd692020-01-29 16:35:47 -0800[diff] [blame]279 val down = down(0)
Shep Shapardad4e8152020-04-03 13:22:08 -0700[diff] [blame]280 filter::onPointerInput.invokeOverAllPasses(down)
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]281 val move = down.moveBy(
282 Duration(milliseconds = 10),
283 beyondSlop,
284 beyondSlop
285 )
Shep Shapardad4e8152020-04-03 13:22:08 -0700[diff] [blame]286 filter::onPointerInput.invokeOverAllPasses(move)
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]287
Shep Shaparddd9e2bc2020-05-19 15:25:36 -0700[diff] [blame]288 assertThat(onDragSlopExceededCallCount).isEqualTo(0)
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]289 }
290
291 @Test
292 fun onPointerInputChanges_moveBeyondSlopButConsumeUnder_onTouchSlopExceededNotCalled() {
293
Shep Shapard091fd692020-01-29 16:35:47 -0800[diff] [blame]294 val down = down(0)
Shep Shapardad4e8152020-04-03 13:22:08 -0700[diff] [blame]295 filter::onPointerInput.invokeOverAllPasses(down)
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]296
Shep Shapard4babf792020-02-13 16:37:14 -0800[diff] [blame]297 val move = down.moveBy(10.milliseconds, TestTouchSlop + TinyNum, 0f).consume(dx = 1f)
Shep Shapardad4e8152020-04-03 13:22:08 -0700[diff] [blame]298 filter::onPointerInput.invokeOverAllPasses(move)
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]299
300 // Assert
301
Shep Shaparddd9e2bc2020-05-19 15:25:36 -0700[diff] [blame]302 assertThat(onDragSlopExceededCallCount).isEqualTo(0)
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]303 }
304
305 @Test
306 fun onPointerInputChanges_moveUnderToPostUpThenModOverInOppDir_onTouchSlopExceededNotCalled() {
307
Shep Shapard091fd692020-01-29 16:35:47 -0800[diff] [blame]308 val down = down(0)
Shep Shapardad4e8152020-04-03 13:22:08 -0700[diff] [blame]309 filter::onPointerInput.invokeOverAllPasses(down)
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]310
Shep Shapard091fd692020-01-29 16:35:47 -0800[diff] [blame]311 val move = down.moveBy(10.milliseconds, TestTouchSlop.toFloat(), 0f)
Shep Shapardad4e8152020-04-03 13:22:08 -0700[diff] [blame]312 filter::onPointerInput.invokeOverPasses(
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]313 listOf(move),
Shep Shapardbf513c52019-12-16 17:06:51 -0800[diff] [blame]314 listOf(
315 PointerEventPass.InitialDown,
316 PointerEventPass.PreUp,
317 PointerEventPass.PreDown,
318 PointerEventPass.PostUp
319 )
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]320 )
Shep Shapard4babf792020-02-13 16:37:14 -0800[diff] [blame]321 val move2 = move.consume(dx = (TestTouchSlop * 2f + TinyNum))
Shep Shapardad4e8152020-04-03 13:22:08 -0700[diff] [blame]322 filter::onPointerInput.invokeOverPasses(
Shep Shapardbf513c52019-12-16 17:06:51 -0800[diff] [blame]323 move2,
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]324 PointerEventPass.PostDown
325 )
326
327 // Assert
328
Shep Shaparddd9e2bc2020-05-19 15:25:36 -0700[diff] [blame]329 assertThat(onDragSlopExceededCallCount).isEqualTo(1)
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]330 }
331
332 // TODO(b/129701831): This test assumes that if a pointer moves by slop in both x and y, we are
333 // still under slop even though sqrt(slop^2 + slop^2) > slop. This may be inaccurate and this
334 // test may therefore need to be updated.
335 @Test
336 fun onPointerInputChanges_moveAroundWithinSlop_onTouchSlopExceededNotCalled() {
337 val slop = TestTouchSlop.toFloat()
338
Shep Shapard091fd692020-01-29 16:35:47 -0800[diff] [blame]339 var change = down(0)
Shep Shapardad4e8152020-04-03 13:22:08 -0700[diff] [blame]340 filter::onPointerInput.invokeOverAllPasses(change)
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]341
342 // Go around the border of the touch slop area
343
344 // To top left
Shep Shaparde261df92019-11-15 11:24:31 -0800[diff] [blame]345 change = change.moveTo(10.milliseconds, -slop, -slop)
Shep Shapardad4e8152020-04-03 13:22:08 -0700[diff] [blame]346 filter::onPointerInput.invokeOverAllPasses(change)
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]347 // To bottom left
Shep Shaparde261df92019-11-15 11:24:31 -0800[diff] [blame]348 change = change.moveTo(20.milliseconds, -slop, slop)
Shep Shapardad4e8152020-04-03 13:22:08 -0700[diff] [blame]349 filter::onPointerInput.invokeOverAllPasses(change)
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]350 // To bottom right
Shep Shaparde261df92019-11-15 11:24:31 -0800[diff] [blame]351 change = change.moveTo(30.milliseconds, slop, slop)
Shep Shapardad4e8152020-04-03 13:22:08 -0700[diff] [blame]352 filter::onPointerInput.invokeOverAllPasses(change)
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]353 // To top right
Shep Shaparde261df92019-11-15 11:24:31 -0800[diff] [blame]354 change = change.moveTo(40.milliseconds, slop, -slop)
Shep Shapardad4e8152020-04-03 13:22:08 -0700[diff] [blame]355 filter::onPointerInput.invokeOverAllPasses(change)
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]356
357 // Jump from corner to opposite corner and back
358
359 // To bottom left
Shep Shaparde261df92019-11-15 11:24:31 -0800[diff] [blame]360 change = change.moveTo(50.milliseconds, -slop, slop)
Shep Shapardad4e8152020-04-03 13:22:08 -0700[diff] [blame]361 filter::onPointerInput.invokeOverAllPasses(change)
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]362 // To top right
Shep Shaparde261df92019-11-15 11:24:31 -0800[diff] [blame]363 change = change.moveTo(60.milliseconds, slop, -slop)
Shep Shapardad4e8152020-04-03 13:22:08 -0700[diff] [blame]364 filter::onPointerInput.invokeOverAllPasses(change)
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]365
366 // Move the other diagonal
367
368 // To top left
Shep Shaparde261df92019-11-15 11:24:31 -0800[diff] [blame]369 change = change.moveTo(70.milliseconds, -slop, -slop)
Shep Shapardad4e8152020-04-03 13:22:08 -0700[diff] [blame]370 filter::onPointerInput.invokeOverAllPasses(change)
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]371
372 // Jump from corner to opposite corner and back
373
374 // To bottom right
Shep Shaparde261df92019-11-15 11:24:31 -0800[diff] [blame]375 change = change.moveTo(80.milliseconds, slop, slop)
Shep Shapardad4e8152020-04-03 13:22:08 -0700[diff] [blame]376 filter::onPointerInput.invokeOverAllPasses(change)
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]377 // To top left
Shep Shaparde261df92019-11-15 11:24:31 -0800[diff] [blame]378 change = change.moveTo(90.milliseconds, -slop, -slop)
Shep Shapardad4e8152020-04-03 13:22:08 -0700[diff] [blame]379 filter::onPointerInput.invokeOverAllPasses(change)
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]380
Shep Shaparddd9e2bc2020-05-19 15:25:36 -0700[diff] [blame]381 assertThat(onDragSlopExceededCallCount).isEqualTo(0)
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]382 }
383
384 // Verify the circumstances under which onTouchSlopExceeded should be called.
385
386 @Test
387 fun onPointerInputChanges_movePassedSlop_onTouchSlopExceededCallOnce() {
Shep Shapard4babf792020-02-13 16:37:14 -0800[diff] [blame]388 val beyondSlop = TestTouchSlop + TinyNum
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]389
Shep Shapard091fd692020-01-29 16:35:47 -0800[diff] [blame]390 val down = down(0)
Shep Shapardad4e8152020-04-03 13:22:08 -0700[diff] [blame]391 filter::onPointerInput.invokeOverAllPasses(down)
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]392 val move = down.moveBy(
393 Duration(milliseconds = 100),
Shep Shapard4babf792020-02-13 16:37:14 -0800[diff] [blame]394 beyondSlop,
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]395 0f
396 )
Shep Shapardad4e8152020-04-03 13:22:08 -0700[diff] [blame]397 filter::onPointerInput.invokeOverAllPasses(move)
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]398
Shep Shaparddd9e2bc2020-05-19 15:25:36 -0700[diff] [blame]399 assertThat(onDragSlopExceededCallCount).isEqualTo(1)
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]400 }
401
402 @Test
403 fun onPointerInputChanges_movePassedSlopIn2Events_onTouchSlopExceededCallOnce() {
404
Shep Shapard091fd692020-01-29 16:35:47 -0800[diff] [blame]405 val down = down(0)
Shep Shapardad4e8152020-04-03 13:22:08 -0700[diff] [blame]406 filter::onPointerInput.invokeOverAllPasses(down)
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]407 val move = down.moveBy(
408 Duration(milliseconds = 100),
409 TestTouchSlop.toFloat(),
410 0f
411 )
Shep Shapardad4e8152020-04-03 13:22:08 -0700[diff] [blame]412 filter::onPointerInput.invokeOverAllPasses(move)
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]413 val move2 = down.moveBy(
414 Duration(milliseconds = 100),
415 1f,
416 0f
417 )
Shep Shapardad4e8152020-04-03 13:22:08 -0700[diff] [blame]418 filter::onPointerInput.invokeOverAllPasses(move2)
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]419
Shep Shaparddd9e2bc2020-05-19 15:25:36 -0700[diff] [blame]420 assertThat(onDragSlopExceededCallCount).isEqualTo(1)
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]421 }
422
423 @Test
424 fun onPointerInputChanges_passSlopThenInSlopAreaThenOut_onTouchSlopExceededCallOnce() {
Shep Shapard4babf792020-02-13 16:37:14 -0800[diff] [blame]425 val beyondSlop = TestTouchSlop + TinyNum
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]426
Shep Shapard091fd692020-01-29 16:35:47 -0800[diff] [blame]427 var event = down(0)
Shep Shapardad4e8152020-04-03 13:22:08 -0700[diff] [blame]428 filter::onPointerInput.invokeOverAllPasses(event)
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]429 // Out of touch slop region
Shep Shapard4babf792020-02-13 16:37:14 -0800[diff] [blame]430 event = event.moveBy(Duration(milliseconds = 10), 0f, beyondSlop)
Shep Shapardad4e8152020-04-03 13:22:08 -0700[diff] [blame]431 filter::onPointerInput.invokeOverAllPasses(event)
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]432 // Back into touch slop region
Shep Shapard4babf792020-02-13 16:37:14 -0800[diff] [blame]433 event = event.moveBy(Duration(milliseconds = 10), 0f, -beyondSlop)
Shep Shapardad4e8152020-04-03 13:22:08 -0700[diff] [blame]434 filter::onPointerInput.invokeOverAllPasses(event)
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]435 // Out of touch slop region again
Shep Shapard4babf792020-02-13 16:37:14 -0800[diff] [blame]436 event = event.moveBy(Duration(milliseconds = 10), 0f, beyondSlop)
Shep Shapardad4e8152020-04-03 13:22:08 -0700[diff] [blame]437 filter::onPointerInput.invokeOverAllPasses(event)
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]438
Shep Shaparddd9e2bc2020-05-19 15:25:36 -0700[diff] [blame]439 assertThat(onDragSlopExceededCallCount).isEqualTo(1)
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]440 }
441
442 @Test
443 fun onPointerInputChanges_downConsumedMovePassedSlop_onTouchSlopExceededCallOnce() {
Shep Shapard4babf792020-02-13 16:37:14 -0800[diff] [blame]444 val beyondSlop = TestTouchSlop + TinyNum
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]445
Shep Shapard091fd692020-01-29 16:35:47 -0800[diff] [blame]446 val down = down(0).consumeDownChange()
Shep Shapardad4e8152020-04-03 13:22:08 -0700[diff] [blame]447 filter::onPointerInput.invokeOverAllPasses(down)
Shep Shapard4babf792020-02-13 16:37:14 -0800[diff] [blame]448 val move = down.moveBy(Duration(milliseconds = 100), beyondSlop, 0f)
Shep Shapardad4e8152020-04-03 13:22:08 -0700[diff] [blame]449 filter::onPointerInput.invokeOverAllPasses(move)
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]450
Shep Shaparddd9e2bc2020-05-19 15:25:36 -0700[diff] [blame]451 assertThat(onDragSlopExceededCallCount).isEqualTo(1)
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]452 }
453
454 @Test
455 fun onPointerInputChanges_beyondInUnsupportThenBeyondInSupport_onTouchSlopExceededCallOnce() {
Shep Shapard4babf792020-02-13 16:37:14 -0800[diff] [blame]456 val beyondSlop = TestTouchSlop + TinyNum
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]457
Shep Shapard091fd692020-01-29 16:35:47 -0800[diff] [blame]458 var change = down(0)
Shep Shapardad4e8152020-04-03 13:22:08 -0700[diff] [blame]459 filter::onPointerInput.invokeOverAllPasses(change)
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]460 canDragReturn = false
461 change = change.moveBy(
462 Duration(milliseconds = 10),
463 0f,
Shep Shapard4babf792020-02-13 16:37:14 -0800[diff] [blame]464 beyondSlop
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]465 )
466 // Sanity check that onTouchSlopExceeded has not been called.
Shep Shaparddd9e2bc2020-05-19 15:25:36 -0700[diff] [blame]467 assertThat(onDragSlopExceededCallCount).isEqualTo(0)
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]468
469 canDragReturn = true
Shep Shapardad4e8152020-04-03 13:22:08 -0700[diff] [blame]470 filter::onPointerInput.invokeOverAllPasses(change)
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]471 change = change.moveBy(
472 Duration(milliseconds = 10),
473 0f,
Shep Shapard4babf792020-02-13 16:37:14 -0800[diff] [blame]474 -beyondSlop
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]475 )
Shep Shapardad4e8152020-04-03 13:22:08 -0700[diff] [blame]476 filter::onPointerInput.invokeOverAllPasses(change)
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]477
Shep Shaparddd9e2bc2020-05-19 15:25:36 -0700[diff] [blame]478 assertThat(onDragSlopExceededCallCount).isEqualTo(1)
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]479 }
480
481 @Test
Shep Shaparddd9e2bc2020-05-19 15:25:36 -0700[diff] [blame]482 fun onPointerInputChanges_2PointsMoveInOpposite_onTouchSlopExceededNotCalled() {
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]483
484 // Arrange
485
Shep Shapard4babf792020-02-13 16:37:14 -0800[diff] [blame]486 val beyondSlop = TestTouchSlop + TinyNum
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]487
488 var pointer1 = down(1)
489 var pointer2 = down(2)
Shep Shapardad4e8152020-04-03 13:22:08 -0700[diff] [blame]490 filter::onPointerInput.invokeOverAllPasses(pointer1, pointer2)
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]491
492 // Act
493
494 pointer1 = pointer1.moveBy(
495 Duration(milliseconds = 100),
Shep Shapard4babf792020-02-13 16:37:14 -0800[diff] [blame]496 beyondSlop,
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]497 0f
498 )
499 pointer2 = pointer2.moveBy(
500 Duration(milliseconds = 100),
Shep Shapard4babf792020-02-13 16:37:14 -0800[diff] [blame]501 -beyondSlop,
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]502 0f
503 )
Shep Shapardad4e8152020-04-03 13:22:08 -0700[diff] [blame]504 filter::onPointerInput.invokeOverAllPasses(pointer1, pointer2)
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]505
506 // Assert
507
Shep Shaparddd9e2bc2020-05-19 15:25:36 -0700[diff] [blame]508 assertThat(onDragSlopExceededCallCount).isEqualTo(0)
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]509 }
510
511 @Test
Shep Shaparddd9e2bc2020-05-19 15:25:36 -0700[diff] [blame]512 fun onPointerInputChanges_3PointsMoveAverage0_onDragSlopExceededNotCalled() {
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]513
514 // Arrange
515
Shep Shapard4babf792020-02-13 16:37:14 -0800[diff] [blame]516 val beyondSlop = TestTouchSlop + TinyNum
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]517
Shep Shapardbf513c52019-12-16 17:06:51 -0800[diff] [blame]518 val pointers = arrayOf(down(0), down(1), down(2))
Shep Shapardad4e8152020-04-03 13:22:08 -0700[diff] [blame]519 filter::onPointerInput.invokeOverAllPasses(*pointers)
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]520
521 // Act
522
523 // These movements average to no movement.
524 pointers[0] =
525 pointers[0].moveBy(
526 Duration(milliseconds = 100),
Shep Shapard4babf792020-02-13 16:37:14 -0800[diff] [blame]527 beyondSlop * -1,
528 beyondSlop * -1
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]529 )
530 pointers[1] =
531 pointers[1].moveBy(
532 Duration(milliseconds = 100),
Shep Shapard4babf792020-02-13 16:37:14 -0800[diff] [blame]533 beyondSlop * 1,
534 beyondSlop * -1
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]535 )
536 pointers[2] =
537 pointers[2].moveBy(
538 Duration(milliseconds = 100),
539 0f,
Shep Shapard4babf792020-02-13 16:37:14 -0800[diff] [blame]540 beyondSlop * 2
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]541 )
Shep Shapardad4e8152020-04-03 13:22:08 -0700[diff] [blame]542 filter::onPointerInput.invokeOverAllPasses(*pointers)
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]543
544 // Assert
545
Shep Shaparddd9e2bc2020-05-19 15:25:36 -0700[diff] [blame]546 assertThat(onDragSlopExceededCallCount).isEqualTo(0)
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]547 }
548
549 @Test
Shep Shaparddd9e2bc2020-05-19 15:25:36 -0700[diff] [blame]550 fun onPointerInputChanges_2Points1MoveJustBeyondSlop_onDragSlopExceededNotCalled() {
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]551
552 // Arrange
553
Shep Shapard4babf792020-02-13 16:37:14 -0800[diff] [blame]554 val beyondSlop = TestTouchSlop + TinyNum
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]555
Shep Shaparddd9e2bc2020-05-19 15:25:36 -0700[diff] [blame]556 var pointer1 = down(0)
557 var pointer2 = down(1)
558 filter::onPointerInput.invokeOverAllPasses(pointer1, pointer2)
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]559
560 // Act
561
562 // These movements average to no movement.
Shep Shaparddd9e2bc2020-05-19 15:25:36 -0700[diff] [blame]563
564 pointer1 =
565 pointer1.moveBy(
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]566 Duration(milliseconds = 100),
567 0f,
568 0f
569 )
Shep Shaparddd9e2bc2020-05-19 15:25:36 -0700[diff] [blame]570 pointer2 =
571 pointer2.moveBy(
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]572 Duration(milliseconds = 100),
Shep Shapard4babf792020-02-13 16:37:14 -0800[diff] [blame]573 beyondSlop * -1,
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]574 0f
575 )
Shep Shaparddd9e2bc2020-05-19 15:25:36 -0700[diff] [blame]576 filter::onPointerInput.invokeOverAllPasses(pointer1, pointer2)
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]577
578 // Assert
579
Shep Shaparddd9e2bc2020-05-19 15:25:36 -0700[diff] [blame]580 assertThat(onDragSlopExceededCallCount).isEqualTo(0)
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]581 }
582
583 @Test
Shep Shaparddd9e2bc2020-05-19 15:25:36 -0700[diff] [blame]584 fun onPointerInputChanges_2Points1MoveJustUnderTwiceSlop_onDragSlopExceededNotCalled() {
585
586 // Arrange
587
588 val beyondSlop = TestTouchSlop + TinyNum
589
590 var pointer1 = down(0)
591 var pointer2 = down(1)
592 filter::onPointerInput.invokeOverAllPasses(pointer1, pointer2)
593
594 // Act
595
596 // These movements average to no movement.
597
598 pointer1 =
599 pointer1.moveBy(
600 Duration(milliseconds = 100),
601 0f,
602 0f
603 )
604 pointer2 =
605 pointer2.moveBy(
606 Duration(milliseconds = 100),
607 beyondSlop * 2 - 1,
608 0f
609 )
610 filter::onPointerInput.invokeOverAllPasses(pointer1, pointer2)
611
612 // Assert
613
614 assertThat(onDragSlopExceededCallCount).isEqualTo(0)
615 }
616
617 @Test
618 fun onPointerInputChanges_2Points1MoveToTwiceSlop_onDragSlopExceededNotCalled() {
619
620 // Arrange
621
622 val beyondSlop = TestTouchSlop + TinyNum
623
624 var pointer1 = down(0)
625 var pointer2 = down(1)
626 filter::onPointerInput.invokeOverAllPasses(pointer1, pointer2)
627
628 // Act
629
630 // These movements average to no movement.
631
632 pointer1 =
633 pointer1.moveBy(
634 Duration(milliseconds = 100),
635 0f,
636 0f
637 )
638 pointer2 =
639 pointer2.moveBy(
640 Duration(milliseconds = 100),
641 beyondSlop * 2,
642 0f
643 )
644 filter::onPointerInput.invokeOverAllPasses(pointer1, pointer2)
645
646 // Assert
647
648 assertThat(onDragSlopExceededCallCount).isEqualTo(1)
649 }
650
651 @Test
652 fun onPointerInputChanges_1PointMovesBeyondSlopAndThenManyTimes_onDragSlopExceededCallOnce() {
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]653
654 // Arrange
655
Shep Shapard4babf792020-02-13 16:37:14 -0800[diff] [blame]656 val beyondSlop = TestTouchSlop + TinyNum
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]657
658 var pointer = down(0)
Shep Shapardad4e8152020-04-03 13:22:08 -0700[diff] [blame]659 filter::onPointerInput.invokeOverAllPasses(pointer)
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]660
661 // Act
662
663 repeat(5) {
Shep Shapard4babf792020-02-13 16:37:14 -0800[diff] [blame]664 pointer = pointer.moveBy(100.milliseconds, beyondSlop, beyondSlop)
Shep Shapardad4e8152020-04-03 13:22:08 -0700[diff] [blame]665 filter::onPointerInput.invokeOverAllPasses(pointer)
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]666 }
667
668 // Assert
669
Shep Shaparddd9e2bc2020-05-19 15:25:36 -0700[diff] [blame]670 assertThat(onDragSlopExceededCallCount).isEqualTo(1)
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]671 }
672
673 @Test
Shep Shaparddd9e2bc2020-05-19 15:25:36 -0700[diff] [blame]674 fun onPointerInputChanges_1ModifiedToMoveBeyondSlopBeforePostUp_onDragSlopExceededCallOnce() {
Shep Shapard4babf792020-02-13 16:37:14 -0800[diff] [blame]675 val beyondSlop = TestTouchSlop + TinyNum
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]676
Shep Shapard091fd692020-01-29 16:35:47 -0800[diff] [blame]677 val down = down(0)
Shep Shapardad4e8152020-04-03 13:22:08 -0700[diff] [blame]678 filter::onPointerInput.invokeOverAllPasses(down)
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]679
Shep Shapard4babf792020-02-13 16:37:14 -0800[diff] [blame]680 val move = down.moveBy(10.milliseconds, 0f, 0f).consume(dx = beyondSlop)
Shep Shapardad4e8152020-04-03 13:22:08 -0700[diff] [blame]681 filter::onPointerInput.invokeOverPasses(
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]682 listOf(move),
Shep Shapardbf513c52019-12-16 17:06:51 -0800[diff] [blame]683 listOf(
684 PointerEventPass.InitialDown,
685 PointerEventPass.PreUp,
686 PointerEventPass.PreDown,
687 PointerEventPass.PostUp
688 )
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]689 )
690
691 // Assert
692
Shep Shaparddd9e2bc2020-05-19 15:25:36 -0700[diff] [blame]693 assertThat(onDragSlopExceededCallCount).isEqualTo(1)
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]694 }
695
696 @Test
Shep Shaparddd9e2bc2020-05-19 15:25:36 -0700[diff] [blame]697 fun onPointerInputChanges_1ModedToMoveBeyondSlopBeforePostDown_onDragSlopExceededCallOnce() {
Shep Shapard4babf792020-02-13 16:37:14 -0800[diff] [blame]698 val beyondSlop = TestTouchSlop + TinyNum
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]699
Shep Shapard091fd692020-01-29 16:35:47 -0800[diff] [blame]700 val down = down(0)
Shep Shapardad4e8152020-04-03 13:22:08 -0700[diff] [blame]701 filter::onPointerInput.invokeOverAllPasses(down)
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]702
Shep Shapard091fd692020-01-29 16:35:47 -0800[diff] [blame]703 val move = down.moveBy(10.milliseconds, 0f, 0f)
Shep Shapardad4e8152020-04-03 13:22:08 -0700[diff] [blame]704 filter::onPointerInput.invokeOverPasses(
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]705 listOf(move),
Shep Shapardbf513c52019-12-16 17:06:51 -0800[diff] [blame]706 listOf(
707 PointerEventPass.InitialDown,
708 PointerEventPass.PreUp,
709 PointerEventPass.PreDown,
710 PointerEventPass.PostUp
711 )
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]712 )
713
Shep Shapard4babf792020-02-13 16:37:14 -0800[diff] [blame]714 val moveConsumed = move.consume(dx = beyondSlop)
Shep Shapardad4e8152020-04-03 13:22:08 -0700[diff] [blame]715 filter::onPointerInput.invokeOverPasses(
Shep Shapardbf513c52019-12-16 17:06:51 -0800[diff] [blame]716 moveConsumed,
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]717 PointerEventPass.PostDown
718 )
719
720 // Assert
721
Shep Shaparddd9e2bc2020-05-19 15:25:36 -0700[diff] [blame]722 assertThat(onDragSlopExceededCallCount).isEqualTo(1)
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]723 }
724
725 @Test
Shep Shaparddd9e2bc2020-05-19 15:25:36 -0700[diff] [blame]726 fun onPointerInputChanges_moveUnderToPostUpThenModOverToPostDown_onDragSlopExceededCallOnce() {
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]727 val halfSlop = TestTouchSlop / 2
Shep Shapard4babf792020-02-13 16:37:14 -0800[diff] [blame]728 val restOfSlopAndBeyond = TestTouchSlop - halfSlop + TinyNum
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]729
Shep Shapard091fd692020-01-29 16:35:47 -0800[diff] [blame]730 val down = down(0)
Shep Shapardad4e8152020-04-03 13:22:08 -0700[diff] [blame]731 filter::onPointerInput.invokeOverAllPasses(down)
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]732
Shep Shapard091fd692020-01-29 16:35:47 -0800[diff] [blame]733 val move = down.moveBy(10.milliseconds, halfSlop.toFloat(), 0f)
Shep Shapardad4e8152020-04-03 13:22:08 -0700[diff] [blame]734 filter::onPointerInput.invokeOverPasses(
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]735 listOf(move),
Shep Shapardbf513c52019-12-16 17:06:51 -0800[diff] [blame]736 listOf(
737 PointerEventPass.InitialDown,
738 PointerEventPass.PreUp,
739 PointerEventPass.PreDown,
740 PointerEventPass.PostUp
741 )
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]742 )
743
Shep Shapard4babf792020-02-13 16:37:14 -0800[diff] [blame]744 val moveConsumed = move.consume(dx = -restOfSlopAndBeyond)
Shep Shapardad4e8152020-04-03 13:22:08 -0700[diff] [blame]745 filter::onPointerInput.invokeOverPasses(
Shep Shapardbf513c52019-12-16 17:06:51 -0800[diff] [blame]746 moveConsumed,
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]747 PointerEventPass.PostDown
748 )
749
750 // Assert
751
Shep Shaparddd9e2bc2020-05-19 15:25:36 -0700[diff] [blame]752 assertThat(onDragSlopExceededCallCount).isEqualTo(1)
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]753 }
754
755 @Test
Shep Shaparddd9e2bc2020-05-19 15:25:36 -0700[diff] [blame]756 fun onPointerInputChanges_moveBeyondSlopAllPassesUpToPostUp_onDragSlopExceededCallOnce() {
Shep Shapard4babf792020-02-13 16:37:14 -0800[diff] [blame]757 val beyondSlop = TestTouchSlop + TinyNum
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]758
Shep Shapard091fd692020-01-29 16:35:47 -0800[diff] [blame]759 val down = down(0)
Shep Shapardad4e8152020-04-03 13:22:08 -0700[diff] [blame]760 filter::onPointerInput.invokeOverAllPasses(down)
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]761
Shep Shapard4babf792020-02-13 16:37:14 -0800[diff] [blame]762 val move = down.moveBy(10.milliseconds, beyondSlop, 0f)
Shep Shapardad4e8152020-04-03 13:22:08 -0700[diff] [blame]763 filter::onPointerInput.invokeOverPasses(
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]764 listOf(move),
Shep Shapardbf513c52019-12-16 17:06:51 -0800[diff] [blame]765 listOf(
766 PointerEventPass.InitialDown,
767 PointerEventPass.PreUp,
768 PointerEventPass.PreDown,
769 PointerEventPass.PostUp
770 )
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]771 )
772
773 // Assert
774
Shep Shaparddd9e2bc2020-05-19 15:25:36 -0700[diff] [blame]775 assertThat(onDragSlopExceededCallCount).isEqualTo(1)
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]776 }
777
778 // Verification that TouchSlopExceededGestureDetector does not consume any changes.
779
780 @Test
781 fun onPointerInputChanges_1Down_nothingConsumed() {
782
Shep Shapardad4e8152020-04-03 13:22:08 -0700[diff] [blame]783 val result = filter::onPointerInput.invokeOverAllPasses(down(0))
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]784
785 // Assert
786
Shep Shapardbf513c52019-12-16 17:06:51 -0800[diff] [blame]787 assertThat(result.consumed.downChange).isFalse()
Nader Jawade6a9b332020-05-21 13:49:20 -0700[diff] [blame^]788 assertThat(result.consumed.positionChange.x).isEqualTo(0f)
789 assertThat(result.consumed.positionChange.y).isEqualTo(0f)
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]790 }
791
792 @Test
793 fun onPointerInputChanges_1MoveUnderSlop_nothingConsumed() {
794
Shep Shapard091fd692020-01-29 16:35:47 -0800[diff] [blame]795 val down = down(0)
Shep Shapardad4e8152020-04-03 13:22:08 -0700[diff] [blame]796 filter::onPointerInput.invokeOverAllPasses(down)
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]797
Shep Shapard091fd692020-01-29 16:35:47 -0800[diff] [blame]798 val move = down.moveBy(10.milliseconds, TestTouchSlop.toFloat(), TestTouchSlop.toFloat())
Shep Shapardad4e8152020-04-03 13:22:08 -0700[diff] [blame]799 val result = filter::onPointerInput.invokeOverAllPasses(move)
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]800
801 // Assert
802
Shep Shapardbf513c52019-12-16 17:06:51 -0800[diff] [blame]803 assertThat(result.consumed.downChange).isFalse()
Nader Jawade6a9b332020-05-21 13:49:20 -0700[diff] [blame^]804 assertThat(result.consumed.positionChange.x).isEqualTo(0f)
805 assertThat(result.consumed.positionChange.y).isEqualTo(0f)
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]806 }
807
808 @Test
809 fun onPointerInputChanges_1MoveUnderSlopThenUp_nothingConsumed() {
810
Shep Shapard091fd692020-01-29 16:35:47 -0800[diff] [blame]811 val down = down(0)
Shep Shapardad4e8152020-04-03 13:22:08 -0700[diff] [blame]812 filter::onPointerInput.invokeOverAllPasses(down)
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]813
Shep Shapard091fd692020-01-29 16:35:47 -0800[diff] [blame]814 val move = down.moveBy(10.milliseconds, TestTouchSlop.toFloat(), TestTouchSlop.toFloat())
Shep Shapardad4e8152020-04-03 13:22:08 -0700[diff] [blame]815 filter::onPointerInput.invokeOverAllPasses(move)
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]816
Shep Shaparde261df92019-11-15 11:24:31 -0800[diff] [blame]817 val up = move.up(20.milliseconds)
Shep Shapardad4e8152020-04-03 13:22:08 -0700[diff] [blame]818 val result = filter::onPointerInput.invokeOverAllPasses(up)
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]819
820 // Assert
821
Shep Shapardbf513c52019-12-16 17:06:51 -0800[diff] [blame]822 assertThat(result.consumed.downChange).isFalse()
Nader Jawade6a9b332020-05-21 13:49:20 -0700[diff] [blame^]823 assertThat(result.consumed.positionChange.x).isEqualTo(0f)
824 assertThat(result.consumed.positionChange.y).isEqualTo(0f)
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]825 }
826
827 @Test
828 fun onPointerInputChanges_1MoveOverSlop_nothingConsumed() {
Shep Shapard4babf792020-02-13 16:37:14 -0800[diff] [blame]829 val beyondSlop = TestTouchSlop + TinyNum
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]830
Shep Shapard091fd692020-01-29 16:35:47 -0800[diff] [blame]831 val down = down(0)
Shep Shapardad4e8152020-04-03 13:22:08 -0700[diff] [blame]832 filter::onPointerInput.invokeOverAllPasses(down)
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]833
Shep Shapard4babf792020-02-13 16:37:14 -0800[diff] [blame]834 val move = down.moveBy(10.milliseconds, beyondSlop, beyondSlop)
Shep Shapardad4e8152020-04-03 13:22:08 -0700[diff] [blame]835 val result = filter::onPointerInput.invokeOverAllPasses(move)
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]836
837 // Assert
838
Shep Shapardbf513c52019-12-16 17:06:51 -0800[diff] [blame]839 assertThat(result.consumed.downChange).isFalse()
Nader Jawade6a9b332020-05-21 13:49:20 -0700[diff] [blame^]840 assertThat(result.consumed.positionChange.x).isEqualTo(0f)
841 assertThat(result.consumed.positionChange.y).isEqualTo(0f)
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]842 }
843
844 @Test
845 fun onPointerInputChanges_1MoveOverSlopThenUp_nothingConsumed() {
Shep Shapard4babf792020-02-13 16:37:14 -0800[diff] [blame]846 val beyondSlop = TestTouchSlop + TinyNum
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]847
Shep Shapard091fd692020-01-29 16:35:47 -0800[diff] [blame]848 val down = down(0)
Shep Shapardad4e8152020-04-03 13:22:08 -0700[diff] [blame]849 filter::onPointerInput.invokeOverAllPasses(down)
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]850
Shep Shapard4babf792020-02-13 16:37:14 -0800[diff] [blame]851 val move = down.moveBy(10.milliseconds, beyondSlop, beyondSlop)
Shep Shapardad4e8152020-04-03 13:22:08 -0700[diff] [blame]852 filter::onPointerInput.invokeOverAllPasses(move)
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]853
Shep Shaparde261df92019-11-15 11:24:31 -0800[diff] [blame]854 val up = move.up(20.milliseconds)
Shep Shapardad4e8152020-04-03 13:22:08 -0700[diff] [blame]855 val result = filter::onPointerInput.invokeOverAllPasses(up)
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]856
857 // Assert
858
Shep Shapardbf513c52019-12-16 17:06:51 -0800[diff] [blame]859 assertThat(result.consumed.downChange).isFalse()
Nader Jawade6a9b332020-05-21 13:49:20 -0700[diff] [blame^]860 assertThat(result.consumed.positionChange.x).isEqualTo(0f)
861 assertThat(result.consumed.positionChange.y).isEqualTo(0f)
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]862 }
863
864 // Verification that TouchSlopExceededGestureDetector resets after up correctly.
865
866 @Test
Shep Shaparddd9e2bc2020-05-19 15:25:36 -0700[diff] [blame]867 fun onPointerInputChanges_MoveBeyondUpDownMoveBeyond_onDragSlopExceededCalledTwice() {
Shep Shapard4babf792020-02-13 16:37:14 -0800[diff] [blame]868 val beyondSlop = TestTouchSlop + TinyNum
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]869
870 repeat(2) {
Shep Shapard091fd692020-01-29 16:35:47 -0800[diff] [blame]871 val down = down(0)
Shep Shapardad4e8152020-04-03 13:22:08 -0700[diff] [blame]872 filter::onPointerInput.invokeOverAllPasses(down)
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]873
Shep Shapard4babf792020-02-13 16:37:14 -0800[diff] [blame]874 val move = down.moveBy(10.milliseconds, beyondSlop, 0f)
Shep Shapardad4e8152020-04-03 13:22:08 -0700[diff] [blame]875 filter::onPointerInput.invokeOverAllPasses(move)
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]876
Shep Shaparde261df92019-11-15 11:24:31 -0800[diff] [blame]877 val up = move.up(20.milliseconds)
Shep Shapardad4e8152020-04-03 13:22:08 -0700[diff] [blame]878 filter::onPointerInput.invokeOverAllPasses(up)
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]879 }
880
Shep Shaparddd9e2bc2020-05-19 15:25:36 -0700[diff] [blame]881 assertThat(onDragSlopExceededCallCount).isEqualTo(2)
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]882 }
Shep Shapardbf513c52019-12-16 17:06:51 -0800[diff] [blame]883
884 // Verification that cancellation behavior is correct.
885
886 @Test
Shep Shaparddd9e2bc2020-05-19 15:25:36 -0700[diff] [blame]887 fun onCancel_underSlopCancelUnderSlop_onDragSlopExceededNotCalled() {
Shep Shapard4babf792020-02-13 16:37:14 -0800[diff] [blame]888 val underSlop = TestTouchSlop - TinyNum
Shep Shapardbf513c52019-12-16 17:06:51 -0800[diff] [blame]889
890 // Arrange
891
892 var pointer = down(0, 0.milliseconds, 0f, 0f)
Shep Shapardad4e8152020-04-03 13:22:08 -0700[diff] [blame]893 filter::onPointerInput.invokeOverAllPasses(pointer)
Shep Shapardbf513c52019-12-16 17:06:51 -0800[diff] [blame]894
895 pointer = pointer.moveTo(
896 10.milliseconds,
Shep Shapard4babf792020-02-13 16:37:14 -0800[diff] [blame]897 underSlop,
Shep Shapardbf513c52019-12-16 17:06:51 -0800[diff] [blame]898 0f
899 )
Shep Shapardad4e8152020-04-03 13:22:08 -0700[diff] [blame]900 filter::onPointerInput.invokeOverAllPasses(pointer)
Shep Shapardbf513c52019-12-16 17:06:51 -0800[diff] [blame]901
902 // Act
903
Shep Shapardad4e8152020-04-03 13:22:08 -0700[diff] [blame]904 filter.onCancel()
Shep Shapardbf513c52019-12-16 17:06:51 -0800[diff] [blame]905
906 pointer = down(0, 0.milliseconds, 0f, 0f)
Shep Shapardad4e8152020-04-03 13:22:08 -0700[diff] [blame]907 filter::onPointerInput.invokeOverAllPasses(pointer)
Shep Shapardbf513c52019-12-16 17:06:51 -0800[diff] [blame]908
909 pointer = pointer.moveTo(
910 10.milliseconds,
Shep Shapard4babf792020-02-13 16:37:14 -0800[diff] [blame]911 underSlop,
Shep Shapardbf513c52019-12-16 17:06:51 -0800[diff] [blame]912 0f
913 )
Shep Shapardad4e8152020-04-03 13:22:08 -0700[diff] [blame]914 filter::onPointerInput.invokeOverAllPasses(pointer)
Shep Shapardbf513c52019-12-16 17:06:51 -0800[diff] [blame]915
916 // Assert
917
Shep Shaparddd9e2bc2020-05-19 15:25:36 -0700[diff] [blame]918 assertThat(onDragSlopExceededCallCount).isEqualTo(0)
Shep Shapardbf513c52019-12-16 17:06:51 -0800[diff] [blame]919 }
920
921 @Test
Shep Shapard6c9f1da2020-03-24 14:12:35 -0700[diff] [blame]922 fun onCancel_pastSlopCancelPastSlop_onScaleSlopExceededCalledTwice() {
Shep Shapard4babf792020-02-13 16:37:14 -0800[diff] [blame]923 val overSlop = TestTouchSlop + TinyNum
Shep Shapardbf513c52019-12-16 17:06:51 -0800[diff] [blame]924
925 // Arrange
926
927 var pointer = down(0, 0.milliseconds, 0f, 0f)
Shep Shapardad4e8152020-04-03 13:22:08 -0700[diff] [blame]928 filter::onPointerInput.invokeOverAllPasses(pointer)
Shep Shapardbf513c52019-12-16 17:06:51 -0800[diff] [blame]929
930 pointer = pointer.moveTo(
931 10.milliseconds,
Shep Shapard4babf792020-02-13 16:37:14 -0800[diff] [blame]932 overSlop,
Shep Shapardbf513c52019-12-16 17:06:51 -0800[diff] [blame]933 0f
934 )
Shep Shapardad4e8152020-04-03 13:22:08 -0700[diff] [blame]935 filter::onPointerInput.invokeOverAllPasses(pointer)
Shep Shapardbf513c52019-12-16 17:06:51 -0800[diff] [blame]936
937 // Act
938
Shep Shapardad4e8152020-04-03 13:22:08 -0700[diff] [blame]939 filter.onCancel()
Shep Shapardbf513c52019-12-16 17:06:51 -0800[diff] [blame]940
941 pointer = down(0, 0.milliseconds, 0f, 0f)
Shep Shapardad4e8152020-04-03 13:22:08 -0700[diff] [blame]942 filter::onPointerInput.invokeOverAllPasses(pointer)
Shep Shapardbf513c52019-12-16 17:06:51 -0800[diff] [blame]943
944 pointer = pointer.moveTo(
945 10.milliseconds,
Shep Shapard4babf792020-02-13 16:37:14 -0800[diff] [blame]946 overSlop,
Shep Shapardbf513c52019-12-16 17:06:51 -0800[diff] [blame]947 0f
948 )
Shep Shapardad4e8152020-04-03 13:22:08 -0700[diff] [blame]949 filter::onPointerInput.invokeOverAllPasses(pointer)
Shep Shapardbf513c52019-12-16 17:06:51 -0800[diff] [blame]950
951 // Assert
952
Shep Shaparddd9e2bc2020-05-19 15:25:36 -0700[diff] [blame]953 assertThat(onDragSlopExceededCallCount).isEqualTo(2)
Shep Shapardbf513c52019-12-16 17:06:51 -0800[diff] [blame]954 }
shepshapard648840f2019-07-17 14:28:50 -0700[diff] [blame]955}