Blame - ui/ui-core/src/test/kotlin/androidx/ui/core/gesture/DragSlopExceededGestureFilterTest.kt - platform/frameworks/support

2019-07-17 14:28:50 -0700

[diff] [blame]

/*

*

* 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

Shep Shapard

2020-05-15 16:20:52 -0700

[diff] [blame]

17

@file:OptIn(ExperimentalPointerInput::class)

18

@file:Suppress("PrivatePropertyName")

19

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

20

package androidx.ui.core.gesture

21

22

import androidx.ui.core.Direction

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

23

import androidx.ui.core.PointerEventPass

24

import androidx.ui.core.consumeDownChange

Shep Shapard

2020-05-15 16:20:52 -0700

[diff] [blame]

25

import androidx.ui.core.gesture.scrollorientationlocking.InternalScrollOrientationLocker

26

import androidx.ui.core.gesture.scrollorientationlocking.Orientation

27

import androidx.ui.core.gesture.scrollorientationlocking.ScrollOrientationLocker

28

import androidx.ui.core.gesture.scrollorientationlocking.ShareScrollOrientationLockerEvent

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

29

import androidx.ui.testutils.consume

30

import androidx.ui.testutils.down

31

import androidx.ui.testutils.invokeOverAllPasses

32

import androidx.ui.testutils.invokeOverPasses

33

import androidx.ui.testutils.moveBy

34

import androidx.ui.testutils.moveTo

35

import androidx.ui.testutils.up

George Mount

842c8c1

2020-01-08 16:03:42 -0800

[diff] [blame]

36

import androidx.ui.unit.Duration

George Mount

842c8c1

2020-01-08 16:03:42 -0800

[diff] [blame]

37

import androidx.ui.unit.milliseconds

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

38

import com.google.common.truth.Truth.assertThat

Shep Shapard

2020-05-15 16:20:52 -0700

[diff] [blame]

39

import com.nhaarman.mockitokotlin2.mock

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

40

import org.junit.Before

41

import org.junit.Test

42

import org.junit.runner.RunWith

43

import org.junit.runners.JUnit4

44

45

// TODO(shepshapard): Write the following tests.

46

// Verify correct shape of slop area (should it be a square or circle)?

47

// Test for cases with more than one pointer

48

// Test for cases where things are reset when last pointer goes up

49

// Verify all methods called during onPostUp

Shep Shapard

2020-04-03 13:22:08 -0700

[diff] [blame]

50

// Verify default behavior when no callback provided for filter or canDrag

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

51

52

// Changing this value will break tests that expect the value to be 10.

53

private const val TestTouchSlop = 10

54

55

@RunWith(JUnit4::class)

Shep Shapard

2020-05-19 15:25:36 -0700

[diff] [blame]

56

class DragSlopExceededGestureFilterTest {

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

57

Shep Shapard

2020-05-19 15:25:36 -0700

[diff] [blame]

58

private val onDragSlopExceeded: () -> Unit = { onDragSlopExceededCallCount++ }

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

59

private val canDrag: (Direction) -> Boolean = { direction ->

60

canDragDirections.add(direction)

61

canDragReturn

62

}

Shep Shapard

2020-05-19 15:25:36 -0700

[diff] [blame]

63

private var onDragSlopExceededCallCount: Int = 0

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

64

private var canDragReturn = false

65

private var canDragDirections: MutableList<Direction> = mutableListOf()

Shep Shapard

2020-05-19 15:25:36 -0700

[diff] [blame]

66

private lateinit var filter: DragSlopExceededGestureFilter

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

67

Shep Shapard

2020-02-13 16:37:14 -0800

[diff] [blame]

68

private val TinyNum = .01f

69

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

70

@Before

71

fun setup() {

Shep Shapard

2020-05-19 15:25:36 -0700

[diff] [blame]

72

onDragSlopExceededCallCount = 0

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

73

canDragReturn = true

74

canDragDirections.clear()

Shep Shapard

2020-04-03 13:22:08 -0700

[diff] [blame]

75

filter =

Nader Jawad

feb99f8

2020-05-21 13:07:36 -0700

[diff] [blame]

76

DragSlopExceededGestureFilter(TestTouchSlop.toFloat())

Shep Shapard

2020-05-15 16:20:52 -0700

[diff] [blame]

77

filter.setDraggableData(null, canDrag)

Shep Shapard

2020-05-19 15:25:36 -0700

[diff] [blame]

78

filter.onDragSlopExceeded = onDragSlopExceeded

Shep Shapard

2020-05-15 16:20:52 -0700

[diff] [blame]

79

filter.scrollOrientationLocker = ScrollOrientationLocker(mock())

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

80

}

81

82

// Verify the circumstances under which canDrag should not be called.

83

84

@Test

85

fun onPointerInputChanges_down_canDragNotCalled() {

Shep Shapard

2020-04-03 13:22:08 -0700

[diff] [blame]

86

filter::onPointerInput.invokeOverAllPasses(down(0))

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

87

assertThat(canDragDirections).isEmpty()

}

@Test

fun onPointerInputChanges_downUp_canDragNotCalled() {

Shep Shapard

2020-01-29 16:35:47 -0800

[diff] [blame]

92

val down = down(0, duration = 0.milliseconds)

Shep Shapard

2020-04-03 13:22:08 -0700

[diff] [blame]

93

filter::onPointerInput.invokeOverAllPasses(down)

Shep Shapard

2019-11-15 11:24:31 -0800

[diff] [blame]

94

val up = down.up(10.milliseconds)

Shep Shapard

2020-04-03 13:22:08 -0700

[diff] [blame]

95

filter::onPointerInput.invokeOverAllPasses(up)

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

96

97

assertThat(canDragDirections).isEmpty()

}

@Test

fun onPointerInputChanges_downMoveFullyConsumed_canDragNotCalled() {

Shep Shapard

2020-01-29 16:35:47 -0800

[diff] [blame]

102

val down = down(0)

Shep Shapard

2020-04-03 13:22:08 -0700

[diff] [blame]

103

filter::onPointerInput.invokeOverAllPasses(down)

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

104

val move = down.moveBy(Duration(milliseconds = 10), 3f, 5f).consume(3f, 5f)

Shep Shapard

2020-04-03 13:22:08 -0700

[diff] [blame]

105

filter::onPointerInput.invokeOverAllPasses(move)

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

106

107

assertThat(canDragDirections).isEmpty()

108

}

109

110

// Verify the circumstances under which canDrag should be called.

111

112

@Test

113

fun onPointerInputChanges_downMove1Dimension_canDragCalledOnce() {

Shep Shapard

2020-01-29 16:35:47 -0800

[diff] [blame]

114

val down = down(0)

Shep Shapard

2020-04-03 13:22:08 -0700

[diff] [blame]

115

filter::onPointerInput.invokeOverAllPasses(down)

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

116

val move = down.moveBy(Duration(milliseconds = 10), 3f, 0f)

Shep Shapard

2020-04-03 13:22:08 -0700

[diff] [blame]

117

filter::onPointerInput.invokeOverAllPasses(move)

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

118

119

// Twice because while under touch slop, TouchSlopExceededGestureDetector checks during PostUp and PostDown

120

assertThat(canDragDirections).hasSize(2)

}

@Test

fun onPointerInputChanges_downMove2Dimensions_canDragCalledTwice() {

Shep Shapard

2020-01-29 16:35:47 -0800

[diff] [blame]

125

val down = down(0)

Shep Shapard

2020-04-03 13:22:08 -0700

[diff] [blame]

126

filter::onPointerInput.invokeOverAllPasses(down)

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

127

val move = down.moveBy(Duration(milliseconds = 10), 3f, 5f)

Shep Shapard

2020-04-03 13:22:08 -0700

[diff] [blame]

128

filter::onPointerInput.invokeOverAllPasses(move)

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

129

130

// 4 times because while under touch slop, TouchSlopExceededGestureDetector checks during PostUp and

131

// PostDown

132

assertThat(canDragDirections).hasSize(4)

}

@Test

fun onPointerInputChanges_downMoveOneDimensionPartiallyConsumed_canDragCalledOnce() {

Shep Shapard

2020-01-29 16:35:47 -0800

[diff] [blame]

137

val down = down(0)

Shep Shapard

2020-04-03 13:22:08 -0700

[diff] [blame]

138

filter::onPointerInput.invokeOverAllPasses(down)

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

139

val move = down.moveBy(Duration(milliseconds = 10), 0f, 5f).consume(0f, 4f)

Shep Shapard

2020-04-03 13:22:08 -0700

[diff] [blame]

140

filter::onPointerInput.invokeOverAllPasses(move)

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

141

142

// Twice because while under touch slop, DragGestureDetector checks during PostUp and

143

// PostDown

144

assertThat(canDragDirections).hasSize(2)

}

@Test

fun onPointerInputChanges_downMoveTwoDimensionPartiallyConsumed_canDragCalledTwice() {

Shep Shapard

2020-01-29 16:35:47 -0800

[diff] [blame]

149

val down = down(0)

Shep Shapard

2020-04-03 13:22:08 -0700

[diff] [blame]

150

filter::onPointerInput.invokeOverAllPasses(down)

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

151

val move = down.moveBy(Duration(milliseconds = 10), 3f, 5f).consume(2f, 4f)

Shep Shapard

2020-04-03 13:22:08 -0700

[diff] [blame]

152

filter::onPointerInput.invokeOverAllPasses(move)

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

153

154

// 4 times because while under touch slop, DragGestureDetector checks during PostUp and

155

// PostDown

156

assertThat(canDragDirections).hasSize(4)

}

@Test

fun onPointerInputChanges_dragPastTouchSlopOneDimensionAndDrag3MoreTimes_canDragCalledOnce() {

Shep Shapard

2020-02-13 16:37:14 -0800

[diff] [blame]

161

val beyondSlop = TestTouchSlop + TinyNum

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

162

Shep Shapard

2020-01-29 16:35:47 -0800

[diff] [blame]

163

val down = down(0)

Shep Shapard

2020-04-03 13:22:08 -0700

[diff] [blame]

164

filter::onPointerInput.invokeOverAllPasses(down)

Shep Shapard

2020-02-13 16:37:14 -0800

[diff] [blame]

165

var move = down.moveTo(10.milliseconds, 0f, beyondSlop)

Shep Shapard

2020-04-03 13:22:08 -0700

[diff] [blame]

166

filter::onPointerInput.invokeOverAllPasses(move)

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

167

repeat(3) {

168

move = move.moveBy(Duration(milliseconds = 10), 0f, 1f)

Shep Shapard

2020-04-03 13:22:08 -0700

[diff] [blame]

169

filter::onPointerInput.invokeOverAllPasses(move)

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

170

}

171

172

// Once because although DragGestureDetector checks during PostUp and PostDown, slop is

173

// surpassed during PostUp, and thus isn't checked again.

174

assertThat(canDragDirections).hasSize(1)

}

@Test

fun onPointerInputChanges_downMoveUnderSlop3Times_canDragCalled3Times() {

Shep Shapard

2020-02-13 16:37:14 -0800

[diff] [blame]

179

val thirdSlop = TestTouchSlop / 3

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

180

Shep Shapard

2020-01-29 16:35:47 -0800

[diff] [blame]

181

val down = down(0)

Shep Shapard

2020-04-03 13:22:08 -0700

[diff] [blame]

182

filter::onPointerInput.invokeOverAllPasses(down)

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

183

var move = down

184

repeat(3) {

Shep Shapard

2020-02-13 16:37:14 -0800

[diff] [blame]

185

move = move.moveBy(Duration(milliseconds = 10), 0f, thirdSlop.toFloat())

Shep Shapard

2020-04-03 13:22:08 -0700

[diff] [blame]

186

filter::onPointerInput.invokeOverAllPasses(move)

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

187

}

188

189

// 6 times because while under touch slop, DragGestureDetector checks during PostUp and

190

// PostDown

191

assertThat(canDragDirections).hasSize(6)

}

@Test

fun onPointerInputChanges_moveBeyondSlopThenIntoTouchSlopAreaAndOutAgain_canDragCalledOnce() {

Shep Shapard

2020-02-13 16:37:14 -0800

[diff] [blame]

196

val beyondSlop = TestTouchSlop + TinyNum

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

197

Shep Shapard

2020-01-29 16:35:47 -0800

[diff] [blame]

198

var event = down(0)

Shep Shapard

2020-04-03 13:22:08 -0700

[diff] [blame]

199

filter::onPointerInput.invokeOverAllPasses(event)

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

200

// Out of touch slop region

Shep Shapard

2020-02-13 16:37:14 -0800

[diff] [blame]

201

event = event.moveBy(Duration(milliseconds = 10), 0f, beyondSlop)

Shep Shapard

2020-04-03 13:22:08 -0700

[diff] [blame]

202

filter::onPointerInput.invokeOverAllPasses(event)

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

203

// Back into touch slop region

Shep Shapard

2020-02-13 16:37:14 -0800

[diff] [blame]

204

event = event.moveBy(Duration(milliseconds = 10), 0f, -beyondSlop)

Shep Shapard

2020-04-03 13:22:08 -0700

[diff] [blame]

205

filter::onPointerInput.invokeOverAllPasses(event)

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

206

// Out of touch slop region again

Shep Shapard

2020-02-13 16:37:14 -0800

[diff] [blame]

207

event = event.moveBy(Duration(milliseconds = 10), 0f, beyondSlop)

Shep Shapard

2020-04-03 13:22:08 -0700

[diff] [blame]

208

filter::onPointerInput.invokeOverAllPasses(event)

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

209

210

// Once because although DragGestureDetector checks during PostUp and PostDown, slop is

211

// surpassed during PostUp, and thus isn't checked again.

212

assertThat(canDragDirections).hasSize(1)

213

}

214

215

// Verification of correctness of values passed to canDrag.

216

217

@Test

218

fun onPointerInputChanges_canDragCalledWithCorrectDirection() {

219

onPointerInputChanges_canDragCalledWithCorrectDirection(

220

-1f, 0f, arrayOf(Direction.LEFT)

221

)

222

onPointerInputChanges_canDragCalledWithCorrectDirection(

223

0f, -1f, arrayOf(Direction.UP)

224

)

225

onPointerInputChanges_canDragCalledWithCorrectDirection(

226

1f, 0f, arrayOf(Direction.RIGHT)

227

)

228

onPointerInputChanges_canDragCalledWithCorrectDirection(

229

0f, 1f, arrayOf(Direction.DOWN)

230

)

231

onPointerInputChanges_canDragCalledWithCorrectDirection(

232

-1f, -1f, arrayOf(Direction.LEFT, Direction.UP)

233

)

234

onPointerInputChanges_canDragCalledWithCorrectDirection(

235

-1f, 1f, arrayOf(Direction.LEFT, Direction.DOWN)

236

)

237

onPointerInputChanges_canDragCalledWithCorrectDirection(

238

1f, -1f, arrayOf(Direction.RIGHT, Direction.UP)

239

)

240

onPointerInputChanges_canDragCalledWithCorrectDirection(

241

1f, 1f, arrayOf(Direction.RIGHT, Direction.DOWN)

)

}

private fun onPointerInputChanges_canDragCalledWithCorrectDirection(

246

dx: Float,

247

dy: Float,

248

expectedDirections: Array<Direction>

249

) {

250

canDragDirections.clear()

Shep Shapard

2020-01-29 16:35:47 -0800

[diff] [blame]

251

val down = down(0)

Shep Shapard

2020-04-03 13:22:08 -0700

[diff] [blame]

252

filter::onPointerInput.invokeOverAllPasses(down)

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

253

val move = down.moveBy(Duration(milliseconds = 10), dx, dy)

Shep Shapard

2020-04-03 13:22:08 -0700

[diff] [blame]

254

filter::onPointerInput.invokeOverAllPasses(move)

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

255

256

// Everything here is twice because DragGestureDetector checks during PostUp and PostDown.

257

assertThat(canDragDirections).hasSize(expectedDirections.size * 2)

258

expectedDirections.forEach { direction ->

259

assertThat(canDragDirections.count { it == direction })

.isEqualTo(2)

}

}

// Verify the circumstances under which onTouchSlopExceeded should not be called.

265

266

// TODO(b/129701831): This test assumes that if a pointer moves by slop in both x and y, we are

267

// still under slop even though sqrt(slop^2 + slop^2) > slop. This may be inaccurate and this

268

// test may therefore need to be updated.

269

@Test

270

fun onPointerInputChanges_downMoveWithinSlop_onTouchSlopExceededNotCalled() {

Shep Shapard

2020-01-29 16:35:47 -0800

[diff] [blame]

271

val down = down(0)

Shep Shapard

2020-04-03 13:22:08 -0700

[diff] [blame]

272

filter::onPointerInput.invokeOverAllPasses(down)

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

273

val move = down.moveBy(

274

Duration(milliseconds = 10),

275

TestTouchSlop.toFloat(),

276

TestTouchSlop.toFloat()

277

)

Shep Shapard

2020-04-03 13:22:08 -0700

[diff] [blame]

278

filter::onPointerInput.invokeOverAllPasses(move)

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

279

Shep Shapard

2020-05-19 15:25:36 -0700

[diff] [blame]

280

assertThat(onDragSlopExceededCallCount).isEqualTo(0)

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

}

@Test

fun onPointerInputChanges_moveBeyondSlopInUnsupportedDirection_onTouchSlopExceededNotCalled() {

Shep Shapard

2020-02-13 16:37:14 -0800

[diff] [blame]

285

val beyondSlop = TestTouchSlop + TinyNum

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

286

canDragReturn = false

287

Shep Shapard

2020-01-29 16:35:47 -0800

[diff] [blame]

288

val down = down(0)

Shep Shapard

2020-04-03 13:22:08 -0700

[diff] [blame]

289

filter::onPointerInput.invokeOverAllPasses(down)

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

290

val move = down.moveBy(

291

Duration(milliseconds = 10),

292

beyondSlop,

293

beyondSlop

294

)

Shep Shapard

2020-04-03 13:22:08 -0700

[diff] [blame]

295

filter::onPointerInput.invokeOverAllPasses(move)

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

296

Shep Shapard

2020-05-19 15:25:36 -0700

[diff] [blame]

297

assertThat(onDragSlopExceededCallCount).isEqualTo(0)

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

}

@Test

fun onPointerInputChanges_moveBeyondSlopButConsumeUnder_onTouchSlopExceededNotCalled() {

302

Shep Shapard

2020-01-29 16:35:47 -0800

[diff] [blame]

303

val down = down(0)

Shep Shapard

2020-04-03 13:22:08 -0700

[diff] [blame]

304

filter::onPointerInput.invokeOverAllPasses(down)

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

305

Shep Shapard

2020-02-13 16:37:14 -0800

[diff] [blame]

306

val move = down.moveBy(10.milliseconds, TestTouchSlop + TinyNum, 0f).consume(dx = 1f)

Shep Shapard

2020-04-03 13:22:08 -0700

[diff] [blame]

307

filter::onPointerInput.invokeOverAllPasses(move)

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

// Assert

Shep Shapard

2020-05-19 15:25:36 -0700

[diff] [blame]

311

assertThat(onDragSlopExceededCallCount).isEqualTo(0)

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

}

@Test

fun onPointerInputChanges_moveUnderToPostUpThenModOverInOppDir_onTouchSlopExceededNotCalled() {

316

Shep Shapard

2020-01-29 16:35:47 -0800

[diff] [blame]

317

val down = down(0)

Shep Shapard

2020-04-03 13:22:08 -0700

[diff] [blame]

318

filter::onPointerInput.invokeOverAllPasses(down)

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

319

Shep Shapard

2020-01-29 16:35:47 -0800

[diff] [blame]

320

val move = down.moveBy(10.milliseconds, TestTouchSlop.toFloat(), 0f)

Shep Shapard

2020-04-03 13:22:08 -0700

[diff] [blame]

321

filter::onPointerInput.invokeOverPasses(

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

322

listOf(move),

Shep Shapard

2019-12-16 17:06:51 -0800

[diff] [blame]

323

listOf(

324

PointerEventPass.InitialDown,

325

PointerEventPass.PreUp,

326

PointerEventPass.PreDown,

327

PointerEventPass.PostUp

328

)

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

329

)

Shep Shapard

2020-02-13 16:37:14 -0800

[diff] [blame]

330

val move2 = move.consume(dx = (TestTouchSlop * 2f + TinyNum))

Shep Shapard

2020-04-03 13:22:08 -0700

[diff] [blame]

331

filter::onPointerInput.invokeOverPasses(

Shep Shapard

2019-12-16 17:06:51 -0800

[diff] [blame]

332

move2,

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

333

PointerEventPass.PostDown

)

// Assert

Shep Shapard

2020-05-19 15:25:36 -0700

[diff] [blame]

338

assertThat(onDragSlopExceededCallCount).isEqualTo(1)

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

339

}

340

341

// TODO(b/129701831): This test assumes that if a pointer moves by slop in both x and y, we are

342

// still under slop even though sqrt(slop^2 + slop^2) > slop. This may be inaccurate and this

343

// test may therefore need to be updated.

344

@Test

345

fun onPointerInputChanges_moveAroundWithinSlop_onTouchSlopExceededNotCalled() {

346

val slop = TestTouchSlop.toFloat()

347

Shep Shapard

2020-01-29 16:35:47 -0800

[diff] [blame]

348

var change = down(0)

Shep Shapard

2020-04-03 13:22:08 -0700

[diff] [blame]

349

filter::onPointerInput.invokeOverAllPasses(change)

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

350

351

// Go around the border of the touch slop area

352

353

// To top left

Shep Shapard

2019-11-15 11:24:31 -0800

[diff] [blame]

354

change = change.moveTo(10.milliseconds, -slop, -slop)

Shep Shapard

2020-04-03 13:22:08 -0700

[diff] [blame]

355

filter::onPointerInput.invokeOverAllPasses(change)

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

356

// To bottom left

Shep Shapard

2019-11-15 11:24:31 -0800

[diff] [blame]

357

change = change.moveTo(20.milliseconds, -slop, slop)

Shep Shapard

2020-04-03 13:22:08 -0700

[diff] [blame]

358

filter::onPointerInput.invokeOverAllPasses(change)

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

359

// To bottom right

Shep Shapard

2019-11-15 11:24:31 -0800

[diff] [blame]

360

change = change.moveTo(30.milliseconds, slop, slop)

Shep Shapard

2020-04-03 13:22:08 -0700

[diff] [blame]

361

filter::onPointerInput.invokeOverAllPasses(change)

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

362

// To top right

Shep Shapard

2019-11-15 11:24:31 -0800

[diff] [blame]

363

change = change.moveTo(40.milliseconds, slop, -slop)

Shep Shapard

2020-04-03 13:22:08 -0700

[diff] [blame]

364

filter::onPointerInput.invokeOverAllPasses(change)

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

365

366

// Jump from corner to opposite corner and back

367

368

// To bottom left

Shep Shapard

2019-11-15 11:24:31 -0800

[diff] [blame]

369

change = change.moveTo(50.milliseconds, -slop, slop)

Shep Shapard

2020-04-03 13:22:08 -0700

[diff] [blame]

370

filter::onPointerInput.invokeOverAllPasses(change)

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

371

// To top right

Shep Shapard

2019-11-15 11:24:31 -0800

[diff] [blame]

372

change = change.moveTo(60.milliseconds, slop, -slop)

Shep Shapard

2020-04-03 13:22:08 -0700

[diff] [blame]

373

filter::onPointerInput.invokeOverAllPasses(change)

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

374

375

// Move the other diagonal

376

377

// To top left

Shep Shapard

2019-11-15 11:24:31 -0800

[diff] [blame]

378

change = change.moveTo(70.milliseconds, -slop, -slop)

Shep Shapard

2020-04-03 13:22:08 -0700

[diff] [blame]

379

filter::onPointerInput.invokeOverAllPasses(change)

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

380

381

// Jump from corner to opposite corner and back

382

383

// To bottom right

Shep Shapard

2019-11-15 11:24:31 -0800

[diff] [blame]

384

change = change.moveTo(80.milliseconds, slop, slop)

Shep Shapard

2020-04-03 13:22:08 -0700

[diff] [blame]

385

filter::onPointerInput.invokeOverAllPasses(change)

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

386

// To top left

Shep Shapard

2019-11-15 11:24:31 -0800

[diff] [blame]

387

change = change.moveTo(90.milliseconds, -slop, -slop)

Shep Shapard

2020-04-03 13:22:08 -0700

[diff] [blame]

388

filter::onPointerInput.invokeOverAllPasses(change)

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

389

Shep Shapard

2020-05-19 15:25:36 -0700

[diff] [blame]

390

assertThat(onDragSlopExceededCallCount).isEqualTo(0)

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

391

}

392

393

// Verify the circumstances under which onTouchSlopExceeded should be called.

394

395

@Test

396

fun onPointerInputChanges_movePassedSlop_onTouchSlopExceededCallOnce() {

Shep Shapard

2020-02-13 16:37:14 -0800

[diff] [blame]

397

val beyondSlop = TestTouchSlop + TinyNum

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

398

Shep Shapard

2020-01-29 16:35:47 -0800

[diff] [blame]

399

val down = down(0)

Shep Shapard

2020-04-03 13:22:08 -0700

[diff] [blame]

400

filter::onPointerInput.invokeOverAllPasses(down)

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

401

val move = down.moveBy(

402

Duration(milliseconds = 100),

Shep Shapard

2020-02-13 16:37:14 -0800

[diff] [blame]

403

beyondSlop,

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

404

0f

405

)

Shep Shapard

2020-04-03 13:22:08 -0700

[diff] [blame]

406

filter::onPointerInput.invokeOverAllPasses(move)

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

407

Shep Shapard

2020-05-19 15:25:36 -0700

[diff] [blame]

408

assertThat(onDragSlopExceededCallCount).isEqualTo(1)

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

}

@Test

fun onPointerInputChanges_movePassedSlopIn2Events_onTouchSlopExceededCallOnce() {

413

Shep Shapard

2020-01-29 16:35:47 -0800

[diff] [blame]

414

val down = down(0)

Shep Shapard

2020-04-03 13:22:08 -0700

[diff] [blame]

415

filter::onPointerInput.invokeOverAllPasses(down)

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

416

val move = down.moveBy(

417

Duration(milliseconds = 100),

418

TestTouchSlop.toFloat(),

419

0f

420

)

Shep Shapard

2020-04-03 13:22:08 -0700

[diff] [blame]

421

filter::onPointerInput.invokeOverAllPasses(move)

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

422

val move2 = down.moveBy(

423

Duration(milliseconds = 100),

424

1f,

425

0f

426

)

Shep Shapard

2020-04-03 13:22:08 -0700

[diff] [blame]

427

filter::onPointerInput.invokeOverAllPasses(move2)

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

428

Shep Shapard

2020-05-19 15:25:36 -0700

[diff] [blame]

429

assertThat(onDragSlopExceededCallCount).isEqualTo(1)

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

}

@Test

fun onPointerInputChanges_passSlopThenInSlopAreaThenOut_onTouchSlopExceededCallOnce() {

Shep Shapard

2020-02-13 16:37:14 -0800

[diff] [blame]

434

val beyondSlop = TestTouchSlop + TinyNum

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

435

Shep Shapard

2020-01-29 16:35:47 -0800

[diff] [blame]

436

var event = down(0)

Shep Shapard

2020-04-03 13:22:08 -0700

[diff] [blame]

437

filter::onPointerInput.invokeOverAllPasses(event)

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

438

// Out of touch slop region

Shep Shapard

2020-02-13 16:37:14 -0800

[diff] [blame]

439

event = event.moveBy(Duration(milliseconds = 10), 0f, beyondSlop)

Shep Shapard

2020-04-03 13:22:08 -0700

[diff] [blame]

440

filter::onPointerInput.invokeOverAllPasses(event)

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

441

// Back into touch slop region

Shep Shapard

2020-02-13 16:37:14 -0800

[diff] [blame]

442

event = event.moveBy(Duration(milliseconds = 10), 0f, -beyondSlop)

Shep Shapard

2020-04-03 13:22:08 -0700

[diff] [blame]

443

filter::onPointerInput.invokeOverAllPasses(event)

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

444

// Out of touch slop region again

Shep Shapard

2020-02-13 16:37:14 -0800

[diff] [blame]

445

event = event.moveBy(Duration(milliseconds = 10), 0f, beyondSlop)

Shep Shapard

2020-04-03 13:22:08 -0700

[diff] [blame]

446

filter::onPointerInput.invokeOverAllPasses(event)

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

447

Shep Shapard

2020-05-19 15:25:36 -0700

[diff] [blame]

448

assertThat(onDragSlopExceededCallCount).isEqualTo(1)

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

}

@Test

fun onPointerInputChanges_downConsumedMovePassedSlop_onTouchSlopExceededCallOnce() {

Shep Shapard

2020-02-13 16:37:14 -0800

[diff] [blame]

453

val beyondSlop = TestTouchSlop + TinyNum

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

454

Shep Shapard

2020-01-29 16:35:47 -0800

[diff] [blame]

455

val down = down(0).consumeDownChange()

Shep Shapard

2020-04-03 13:22:08 -0700

[diff] [blame]

456

filter::onPointerInput.invokeOverAllPasses(down)

Shep Shapard

2020-02-13 16:37:14 -0800

[diff] [blame]

457

val move = down.moveBy(Duration(milliseconds = 100), beyondSlop, 0f)

Shep Shapard

2020-04-03 13:22:08 -0700

[diff] [blame]

458

filter::onPointerInput.invokeOverAllPasses(move)

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

459

Shep Shapard

2020-05-19 15:25:36 -0700

[diff] [blame]

460

assertThat(onDragSlopExceededCallCount).isEqualTo(1)

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

}

@Test

fun onPointerInputChanges_beyondInUnsupportThenBeyondInSupport_onTouchSlopExceededCallOnce() {

Shep Shapard

2020-02-13 16:37:14 -0800

[diff] [blame]

465

val beyondSlop = TestTouchSlop + TinyNum

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

466

Shep Shapard

2020-01-29 16:35:47 -0800

[diff] [blame]

467

var change = down(0)

Shep Shapard

2020-04-03 13:22:08 -0700

[diff] [blame]

468

filter::onPointerInput.invokeOverAllPasses(change)

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

469

canDragReturn = false

470

change = change.moveBy(

471

Duration(milliseconds = 10),

472

0f,

Shep Shapard

2020-02-13 16:37:14 -0800

[diff] [blame]

473

beyondSlop

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

474

)

475

// Sanity check that onTouchSlopExceeded has not been called.

Shep Shapard

2020-05-19 15:25:36 -0700

[diff] [blame]

476

assertThat(onDragSlopExceededCallCount).isEqualTo(0)

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

477

478

canDragReturn = true

Shep Shapard

2020-04-03 13:22:08 -0700

[diff] [blame]

479

filter::onPointerInput.invokeOverAllPasses(change)

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

480

change = change.moveBy(

481

Duration(milliseconds = 10),

482

0f,

Shep Shapard

2020-02-13 16:37:14 -0800

[diff] [blame]

483

-beyondSlop

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

484

)

Shep Shapard

2020-04-03 13:22:08 -0700

[diff] [blame]

485

filter::onPointerInput.invokeOverAllPasses(change)

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

486

Shep Shapard

2020-05-19 15:25:36 -0700

[diff] [blame]

487

assertThat(onDragSlopExceededCallCount).isEqualTo(1)

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

488

}

489

490

@Test

Shep Shapard

2020-05-19 15:25:36 -0700

[diff] [blame]

491

fun onPointerInputChanges_2PointsMoveInOpposite_onTouchSlopExceededNotCalled() {

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

// Arrange

Shep Shapard

2020-02-13 16:37:14 -0800

[diff] [blame]

495

val beyondSlop = TestTouchSlop + TinyNum

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

496

497

var pointer1 = down(1)

498

var pointer2 = down(2)

Shep Shapard

2020-04-03 13:22:08 -0700

[diff] [blame]

499

filter::onPointerInput.invokeOverAllPasses(pointer1, pointer2)

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

// Act

pointer1 = pointer1.moveBy(

504

Duration(milliseconds = 100),

Shep Shapard

2020-02-13 16:37:14 -0800

[diff] [blame]

505

beyondSlop,

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

506

0f

507

)

508

pointer2 = pointer2.moveBy(

509

Duration(milliseconds = 100),

Shep Shapard

2020-02-13 16:37:14 -0800

[diff] [blame]

510

-beyondSlop,

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

511

0f

512

)

Shep Shapard

2020-04-03 13:22:08 -0700

[diff] [blame]

513

filter::onPointerInput.invokeOverAllPasses(pointer1, pointer2)

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

// Assert

Shep Shapard

2020-05-19 15:25:36 -0700

[diff] [blame]

517

assertThat(onDragSlopExceededCallCount).isEqualTo(0)

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

518

}

519

520

@Test

Shep Shapard

2020-05-19 15:25:36 -0700

[diff] [blame]

521

fun onPointerInputChanges_3PointsMoveAverage0_onDragSlopExceededNotCalled() {

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

// Arrange

Shep Shapard

2020-02-13 16:37:14 -0800

[diff] [blame]

525

val beyondSlop = TestTouchSlop + TinyNum

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

526

Shep Shapard

2019-12-16 17:06:51 -0800

[diff] [blame]

527

val pointers = arrayOf(down(0), down(1), down(2))

Shep Shapard

2020-04-03 13:22:08 -0700

[diff] [blame]

528

filter::onPointerInput.invokeOverAllPasses(*pointers)

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

// Act

// These movements average to no movement.

533

pointers[0] =

534

pointers[0].moveBy(

535

Duration(milliseconds = 100),

Shep Shapard

2020-02-13 16:37:14 -0800

[diff] [blame]

536

beyondSlop * -1,

537

beyondSlop * -1

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

)

pointers[1] =

pointers[1].moveBy(

Duration(milliseconds = 100),

Shep Shapard

2020-02-13 16:37:14 -0800

[diff] [blame]

542

beyondSlop * 1,

543

beyondSlop * -1

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

)

pointers[2] =

pointers[2].moveBy(

Duration(milliseconds = 100),

548

0f,

Shep Shapard

2020-02-13 16:37:14 -0800

[diff] [blame]

549

beyondSlop * 2

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

550

)

Shep Shapard

2020-04-03 13:22:08 -0700

[diff] [blame]

551

filter::onPointerInput.invokeOverAllPasses(*pointers)

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

// Assert

Shep Shapard

2020-05-19 15:25:36 -0700

[diff] [blame]

555

assertThat(onDragSlopExceededCallCount).isEqualTo(0)

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

556

}

557

558

@Test

Shep Shapard

2020-05-19 15:25:36 -0700

[diff] [blame]

559

fun onPointerInputChanges_2Points1MoveJustBeyondSlop_onDragSlopExceededNotCalled() {

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

// Arrange

Shep Shapard

2020-02-13 16:37:14 -0800

[diff] [blame]

563

val beyondSlop = TestTouchSlop + TinyNum

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

564

Shep Shapard

2020-05-19 15:25:36 -0700

[diff] [blame]

565

var pointer1 = down(0)

566

var pointer2 = down(1)

567

filter::onPointerInput.invokeOverAllPasses(pointer1, pointer2)

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

// Act

// These movements average to no movement.

Shep Shapard

2020-05-19 15:25:36 -0700

[diff] [blame]

572

573

pointer1 =

574

pointer1.moveBy(

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

575

Duration(milliseconds = 100),

576

0f,

577

0f

578

)

Shep Shapard

2020-05-19 15:25:36 -0700

[diff] [blame]

579

pointer2 =

580

pointer2.moveBy(

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

581

Duration(milliseconds = 100),

Shep Shapard

2020-02-13 16:37:14 -0800

[diff] [blame]

582

beyondSlop * -1,

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

583

0f

584

)

Shep Shapard

2020-05-19 15:25:36 -0700

[diff] [blame]

585

filter::onPointerInput.invokeOverAllPasses(pointer1, pointer2)

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

// Assert

Shep Shapard

2020-05-19 15:25:36 -0700

[diff] [blame]

589

assertThat(onDragSlopExceededCallCount).isEqualTo(0)

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

590

}

591

592

@Test

Shep Shapard

2020-05-19 15:25:36 -0700

[diff] [blame]

593

fun onPointerInputChanges_2Points1MoveJustUnderTwiceSlop_onDragSlopExceededNotCalled() {

// Arrange

val beyondSlop = TestTouchSlop + TinyNum

598

599

var pointer1 = down(0)

600

var pointer2 = down(1)

601

filter::onPointerInput.invokeOverAllPasses(pointer1, pointer2)

// Act

// These movements average to no movement.

pointer1 =

pointer1.moveBy(

Duration(milliseconds = 100),

0f,

0f

)

pointer2 =

pointer2.moveBy(

Duration(milliseconds = 100),

beyondSlop * 2 - 1,

0f

)

filter::onPointerInput.invokeOverAllPasses(pointer1, pointer2)

// Assert

assertThat(onDragSlopExceededCallCount).isEqualTo(0)

}

@Test

fun onPointerInputChanges_2Points1MoveToTwiceSlop_onDragSlopExceededNotCalled() {

// Arrange

val beyondSlop = TestTouchSlop + TinyNum

632

633

var pointer1 = down(0)

634

var pointer2 = down(1)

635

filter::onPointerInput.invokeOverAllPasses(pointer1, pointer2)

// Act

// These movements average to no movement.

pointer1 =

pointer1.moveBy(

Duration(milliseconds = 100),

0f,

0f

)

pointer2 =

pointer2.moveBy(

Duration(milliseconds = 100),

beyondSlop * 2,

0f

)

filter::onPointerInput.invokeOverAllPasses(pointer1, pointer2)

// Assert

assertThat(onDragSlopExceededCallCount).isEqualTo(1)

}

@Test

fun onPointerInputChanges_1PointMovesBeyondSlopAndThenManyTimes_onDragSlopExceededCallOnce() {

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

// Arrange

Shep Shapard

2020-02-13 16:37:14 -0800

[diff] [blame]

665

val beyondSlop = TestTouchSlop + TinyNum

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

666

667

var pointer = down(0)

Shep Shapard

2020-04-03 13:22:08 -0700

[diff] [blame]

668

filter::onPointerInput.invokeOverAllPasses(pointer)

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

// Act

repeat(5) {

Shep Shapard

2020-02-13 16:37:14 -0800

[diff] [blame]

673

pointer = pointer.moveBy(100.milliseconds, beyondSlop, beyondSlop)

Shep Shapard

2020-04-03 13:22:08 -0700

[diff] [blame]

674

filter::onPointerInput.invokeOverAllPasses(pointer)

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

}

// Assert

Shep Shapard

2020-05-19 15:25:36 -0700

[diff] [blame]

679

assertThat(onDragSlopExceededCallCount).isEqualTo(1)

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

680

}

681

682

@Test

Shep Shapard

2020-05-19 15:25:36 -0700

[diff] [blame]

683

fun onPointerInputChanges_1ModifiedToMoveBeyondSlopBeforePostUp_onDragSlopExceededCallOnce() {

Shep Shapard

2020-02-13 16:37:14 -0800

[diff] [blame]

684

val beyondSlop = TestTouchSlop + TinyNum

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

685

Shep Shapard

2020-01-29 16:35:47 -0800

[diff] [blame]

686

val down = down(0)

Shep Shapard

2020-04-03 13:22:08 -0700

[diff] [blame]

687

filter::onPointerInput.invokeOverAllPasses(down)

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

688

Shep Shapard

2020-02-13 16:37:14 -0800

[diff] [blame]

689

val move = down.moveBy(10.milliseconds, 0f, 0f).consume(dx = beyondSlop)

Shep Shapard

2020-04-03 13:22:08 -0700

[diff] [blame]

690

filter::onPointerInput.invokeOverPasses(

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

691

listOf(move),

Shep Shapard

2019-12-16 17:06:51 -0800

[diff] [blame]

692

listOf(

693

PointerEventPass.InitialDown,

694

PointerEventPass.PreUp,

695

PointerEventPass.PreDown,

696

PointerEventPass.PostUp

697

)

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

)

// Assert

Shep Shapard

2020-05-19 15:25:36 -0700

[diff] [blame]

702

assertThat(onDragSlopExceededCallCount).isEqualTo(1)

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

703

}

704

705

@Test

Shep Shapard

2020-05-19 15:25:36 -0700

[diff] [blame]

706

fun onPointerInputChanges_1ModedToMoveBeyondSlopBeforePostDown_onDragSlopExceededCallOnce() {

Shep Shapard

2020-02-13 16:37:14 -0800

[diff] [blame]

707

val beyondSlop = TestTouchSlop + TinyNum

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

708

Shep Shapard

2020-01-29 16:35:47 -0800

[diff] [blame]

709

val down = down(0)

Shep Shapard

2020-04-03 13:22:08 -0700

[diff] [blame]

710

filter::onPointerInput.invokeOverAllPasses(down)

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

711

Shep Shapard

2020-01-29 16:35:47 -0800

[diff] [blame]

712

val move = down.moveBy(10.milliseconds, 0f, 0f)

Shep Shapard

2020-04-03 13:22:08 -0700

[diff] [blame]

713

filter::onPointerInput.invokeOverPasses(

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

714

listOf(move),

Shep Shapard

2019-12-16 17:06:51 -0800

[diff] [blame]

715

listOf(

716

PointerEventPass.InitialDown,

717

PointerEventPass.PreUp,

718

PointerEventPass.PreDown,

719

PointerEventPass.PostUp

720

)

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

721

)

722

Shep Shapard

2020-02-13 16:37:14 -0800

[diff] [blame]

723

val moveConsumed = move.consume(dx = beyondSlop)

Shep Shapard

2020-04-03 13:22:08 -0700

[diff] [blame]

724

filter::onPointerInput.invokeOverPasses(

Shep Shapard

2019-12-16 17:06:51 -0800

[diff] [blame]

725

moveConsumed,

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

726

PointerEventPass.PostDown

)

// Assert

Shep Shapard

2020-05-19 15:25:36 -0700

[diff] [blame]

731

assertThat(onDragSlopExceededCallCount).isEqualTo(1)

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

732

}

733

734

@Test

Shep Shapard

2020-05-19 15:25:36 -0700

[diff] [blame]

735

fun onPointerInputChanges_moveUnderToPostUpThenModOverToPostDown_onDragSlopExceededCallOnce() {

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

736

val halfSlop = TestTouchSlop / 2

Shep Shapard

2020-02-13 16:37:14 -0800

[diff] [blame]

737

val restOfSlopAndBeyond = TestTouchSlop - halfSlop + TinyNum

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

738

Shep Shapard

2020-01-29 16:35:47 -0800

[diff] [blame]

739

val down = down(0)

Shep Shapard

2020-04-03 13:22:08 -0700

[diff] [blame]

740

filter::onPointerInput.invokeOverAllPasses(down)

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

741

Shep Shapard

2020-01-29 16:35:47 -0800

[diff] [blame]

742

val move = down.moveBy(10.milliseconds, halfSlop.toFloat(), 0f)

Shep Shapard

2020-04-03 13:22:08 -0700

[diff] [blame]

743

filter::onPointerInput.invokeOverPasses(

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

744

listOf(move),

Shep Shapard

2019-12-16 17:06:51 -0800

[diff] [blame]

745

listOf(

746

PointerEventPass.InitialDown,

747

PointerEventPass.PreUp,

748

PointerEventPass.PreDown,

749

PointerEventPass.PostUp

750

)

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

751

)

752

Shep Shapard

2020-02-13 16:37:14 -0800

[diff] [blame]

753

val moveConsumed = move.consume(dx = -restOfSlopAndBeyond)

Shep Shapard

2020-04-03 13:22:08 -0700

[diff] [blame]

754

filter::onPointerInput.invokeOverPasses(

Shep Shapard

2019-12-16 17:06:51 -0800

[diff] [blame]

755

moveConsumed,

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

756

PointerEventPass.PostDown

)

// Assert

Shep Shapard

2020-05-19 15:25:36 -0700

[diff] [blame]

761

assertThat(onDragSlopExceededCallCount).isEqualTo(1)

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

762

}

763

764

@Test

Shep Shapard

2020-05-19 15:25:36 -0700

[diff] [blame]

765

fun onPointerInputChanges_moveBeyondSlopAllPassesUpToPostUp_onDragSlopExceededCallOnce() {

Shep Shapard

2020-02-13 16:37:14 -0800

[diff] [blame]

766

val beyondSlop = TestTouchSlop + TinyNum

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

767

Shep Shapard

2020-01-29 16:35:47 -0800

[diff] [blame]

768

val down = down(0)

Shep Shapard

2020-04-03 13:22:08 -0700

[diff] [blame]

769

filter::onPointerInput.invokeOverAllPasses(down)

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

770

Shep Shapard

2020-02-13 16:37:14 -0800

[diff] [blame]

771

val move = down.moveBy(10.milliseconds, beyondSlop, 0f)

Shep Shapard

2020-04-03 13:22:08 -0700

[diff] [blame]

772

filter::onPointerInput.invokeOverPasses(

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

773

listOf(move),

Shep Shapard

2019-12-16 17:06:51 -0800

[diff] [blame]

774

listOf(

775

PointerEventPass.InitialDown,

776

PointerEventPass.PreUp,

777

PointerEventPass.PreDown,

778

PointerEventPass.PostUp

779

)

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

)

// Assert

Shep Shapard

2020-05-19 15:25:36 -0700

[diff] [blame]

784

assertThat(onDragSlopExceededCallCount).isEqualTo(1)

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

785

}

786

787

// Verification that TouchSlopExceededGestureDetector does not consume any changes.

788

789

@Test

790

fun onPointerInputChanges_1Down_nothingConsumed() {

791

Shep Shapard

2020-04-03 13:22:08 -0700

[diff] [blame]

792

val result = filter::onPointerInput.invokeOverAllPasses(down(0))

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

// Assert

Shep Shapard

2019-12-16 17:06:51 -0800

[diff] [blame]

796

assertThat(result.consumed.downChange).isFalse()

Nader Jawad

2020-05-21 13:49:20 -0700

[diff] [blame]

797

assertThat(result.consumed.positionChange.x).isEqualTo(0f)

798

assertThat(result.consumed.positionChange.y).isEqualTo(0f)

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

}

@Test

fun onPointerInputChanges_1MoveUnderSlop_nothingConsumed() {

803

Shep Shapard

2020-01-29 16:35:47 -0800

[diff] [blame]

804

val down = down(0)

Shep Shapard

2020-04-03 13:22:08 -0700

[diff] [blame]

805

filter::onPointerInput.invokeOverAllPasses(down)

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

806

Shep Shapard

2020-01-29 16:35:47 -0800

[diff] [blame]

807

val move = down.moveBy(10.milliseconds, TestTouchSlop.toFloat(), TestTouchSlop.toFloat())

Shep Shapard

2020-04-03 13:22:08 -0700

[diff] [blame]

808

val result = filter::onPointerInput.invokeOverAllPasses(move)

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

// Assert

Shep Shapard

2019-12-16 17:06:51 -0800

[diff] [blame]

812

assertThat(result.consumed.downChange).isFalse()

Nader Jawad

2020-05-21 13:49:20 -0700

[diff] [blame]

813

assertThat(result.consumed.positionChange.x).isEqualTo(0f)

814

assertThat(result.consumed.positionChange.y).isEqualTo(0f)

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

}

@Test

fun onPointerInputChanges_1MoveUnderSlopThenUp_nothingConsumed() {

819

Shep Shapard

2020-01-29 16:35:47 -0800

[diff] [blame]

820

val down = down(0)

Shep Shapard

2020-04-03 13:22:08 -0700

[diff] [blame]

821

filter::onPointerInput.invokeOverAllPasses(down)

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

822

Shep Shapard

2020-01-29 16:35:47 -0800

[diff] [blame]

823

val move = down.moveBy(10.milliseconds, TestTouchSlop.toFloat(), TestTouchSlop.toFloat())

Shep Shapard

2020-04-03 13:22:08 -0700

[diff] [blame]

824

filter::onPointerInput.invokeOverAllPasses(move)

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

825

Shep Shapard

2019-11-15 11:24:31 -0800

[diff] [blame]

826

val up = move.up(20.milliseconds)

Shep Shapard

2020-04-03 13:22:08 -0700

[diff] [blame]

827

val result = filter::onPointerInput.invokeOverAllPasses(up)

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

// Assert

Shep Shapard

2019-12-16 17:06:51 -0800

[diff] [blame]

831

assertThat(result.consumed.downChange).isFalse()

Nader Jawad

2020-05-21 13:49:20 -0700

[diff] [blame]

832

assertThat(result.consumed.positionChange.x).isEqualTo(0f)

833

assertThat(result.consumed.positionChange.y).isEqualTo(0f)

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

}

@Test

fun onPointerInputChanges_1MoveOverSlop_nothingConsumed() {

Shep Shapard

2020-02-13 16:37:14 -0800

[diff] [blame]

838

val beyondSlop = TestTouchSlop + TinyNum

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

839

Shep Shapard

2020-01-29 16:35:47 -0800

[diff] [blame]

840

val down = down(0)

Shep Shapard

2020-04-03 13:22:08 -0700

[diff] [blame]

841

filter::onPointerInput.invokeOverAllPasses(down)

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

842

Shep Shapard

2020-02-13 16:37:14 -0800

[diff] [blame]

843

val move = down.moveBy(10.milliseconds, beyondSlop, beyondSlop)

Shep Shapard

2020-04-03 13:22:08 -0700

[diff] [blame]

844

val result = filter::onPointerInput.invokeOverAllPasses(move)

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

// Assert

Shep Shapard

2019-12-16 17:06:51 -0800

[diff] [blame]

848

assertThat(result.consumed.downChange).isFalse()

Nader Jawad

2020-05-21 13:49:20 -0700

[diff] [blame]

849

assertThat(result.consumed.positionChange.x).isEqualTo(0f)

850

assertThat(result.consumed.positionChange.y).isEqualTo(0f)

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

}

@Test

fun onPointerInputChanges_1MoveOverSlopThenUp_nothingConsumed() {

Shep Shapard

2020-02-13 16:37:14 -0800

[diff] [blame]

855

val beyondSlop = TestTouchSlop + TinyNum

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

856

Shep Shapard

2020-01-29 16:35:47 -0800

[diff] [blame]

857

val down = down(0)

Shep Shapard

2020-04-03 13:22:08 -0700

[diff] [blame]

858

filter::onPointerInput.invokeOverAllPasses(down)

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

859

Shep Shapard

2020-02-13 16:37:14 -0800

[diff] [blame]

860

val move = down.moveBy(10.milliseconds, beyondSlop, beyondSlop)

Shep Shapard

2020-04-03 13:22:08 -0700

[diff] [blame]

861

filter::onPointerInput.invokeOverAllPasses(move)

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

862

Shep Shapard

2019-11-15 11:24:31 -0800

[diff] [blame]

863

val up = move.up(20.milliseconds)

Shep Shapard

2020-04-03 13:22:08 -0700

[diff] [blame]

864

val result = filter::onPointerInput.invokeOverAllPasses(up)

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

// Assert

Shep Shapard

2019-12-16 17:06:51 -0800

[diff] [blame]

868

assertThat(result.consumed.downChange).isFalse()

Nader Jawad

2020-05-21 13:49:20 -0700

[diff] [blame]

869

assertThat(result.consumed.positionChange.x).isEqualTo(0f)

870

assertThat(result.consumed.positionChange.y).isEqualTo(0f)

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

871

}

872

873

// Verification that TouchSlopExceededGestureDetector resets after up correctly.

874

875

@Test

Shep Shapard

2020-05-19 15:25:36 -0700

[diff] [blame]

876

fun onPointerInputChanges_MoveBeyondUpDownMoveBeyond_onDragSlopExceededCalledTwice() {

Shep Shapard

2020-02-13 16:37:14 -0800

[diff] [blame]

877

val beyondSlop = TestTouchSlop + TinyNum

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

878

879

repeat(2) {

Shep Shapard

2020-01-29 16:35:47 -0800

[diff] [blame]

880

val down = down(0)

Shep Shapard

2020-04-03 13:22:08 -0700

[diff] [blame]

881

filter::onPointerInput.invokeOverAllPasses(down)

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

882

Shep Shapard

2020-02-13 16:37:14 -0800

[diff] [blame]

883

val move = down.moveBy(10.milliseconds, beyondSlop, 0f)

Shep Shapard

2020-04-03 13:22:08 -0700

[diff] [blame]

884

filter::onPointerInput.invokeOverAllPasses(move)

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

885

Shep Shapard

2019-11-15 11:24:31 -0800

[diff] [blame]

886

val up = move.up(20.milliseconds)

Shep Shapard

2020-04-03 13:22:08 -0700

[diff] [blame]

887

filter::onPointerInput.invokeOverAllPasses(up)

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

888

}

889

Shep Shapard

2020-05-19 15:25:36 -0700

[diff] [blame]

890

assertThat(onDragSlopExceededCallCount).isEqualTo(2)

shepshapard

2019-07-17 14:28:50 -0700

[diff] [blame]

891

}

Shep Shapard

2019-12-16 17:06:51 -0800

[diff] [blame]

892

Shep Shapard

2020-05-15 16:20:52 -0700

[diff] [blame]

893

// Orientation tests

894

895

// Tests that verify correct behavior when orientation is set.

896

897

@Test

898

fun onPointerInput_filterIsHorizontalMovementVertical_canDragNotCalled() {

899

filter.setDraggableData(Orientation.Horizontal, canDrag)

900

901

val down = down(0)

902

filter::onPointerInput.invokeOverAllPasses(down)

903

val move1 = down.moveBy(Duration(milliseconds = 10), 0f, 1f)

904

filter::onPointerInput.invokeOverAllPasses(move1)

905

val move2 = down.moveBy(Duration(milliseconds = 10), 0f, -1f)

906

filter::onPointerInput.invokeOverAllPasses(move2)

907

908

assertThat(canDragDirections).isEmpty()

}

@Test

fun onPointerInput_filterIsVerticalMovementIsHorizontal_canDragNotCalled() {

913

filter.setDraggableData(Orientation.Vertical, canDrag)

914

915

val down = down(0)

916

filter::onPointerInput.invokeOverAllPasses(down)

917

val move1 = down.moveBy(Duration(milliseconds = 10), 1f, 0f)

918

filter::onPointerInput.invokeOverAllPasses(move1)

919

val move2 = down.moveBy(Duration(milliseconds = 10), -1f, 0f)

920

filter::onPointerInput.invokeOverAllPasses(move2)

921

922

assertThat(canDragDirections).isEmpty()

}

@Test

fun onPointerInput_filterIsHorizontalMovementHorizontal_canDragCalled() {

927

filter.setDraggableData(Orientation.Horizontal, canDrag)

928

929

val down = down(0)

930

filter::onPointerInput.invokeOverAllPasses(down)

931

val move1 = down.moveBy(Duration(milliseconds = 10), 1f, 0f)

932

filter::onPointerInput.invokeOverAllPasses(move1)

933

val move2 = down.moveBy(Duration(milliseconds = 10), -1f, 0f)

934

filter::onPointerInput.invokeOverAllPasses(move2)

935

936

// 2 for each because canDrag is currently checked on both postUp and postDown

937

assertThat(canDragDirections.filter { it == Direction.LEFT }).hasSize(2)

938

assertThat(canDragDirections.filter { it == Direction.RIGHT }).hasSize(2)

}

@Test

fun onPointerInput_filterIsVerticalMovementIsVertical_canDragCalled() {

943

filter.setDraggableData(Orientation.Vertical, canDrag)

944

945

val down = down(0)

946

filter::onPointerInput.invokeOverAllPasses(down)

947

val move1 = down.moveBy(Duration(milliseconds = 10), 0f, 1f)

948

filter::onPointerInput.invokeOverAllPasses(move1)

949

val move2 = down.moveBy(Duration(milliseconds = 10), 0f, -1f)

950

filter::onPointerInput.invokeOverAllPasses(move2)

951

952

// 2 for each because canDrag is currently checked on both postUp and postDown

953

assertThat(canDragDirections.filter { it == Direction.UP }).hasSize(2)

954

assertThat(canDragDirections.filter { it == Direction.DOWN }).hasSize(2)

}

@Test

fun onPointerInput_filterIsHorizontalMoveLeftPassedSlop_onTouchSlopExceededCalled() {

959

onPointerInput_filterHasOrientationMovePassedSlop(Orientation.Horizontal, -1, 0, 1)

}

@Test

fun onPointerInput_filterIsHorizontalMoveUpPassedSlop_onTouchSlopExceededNotCalled() {

964

onPointerInput_filterHasOrientationMovePassedSlop(Orientation.Horizontal, 0, -1, 0)

}

@Test

fun onPointerInput_filterIsHorizontalMoveRightPassedSlop_onTouchSlopExceededCalled() {

969

onPointerInput_filterHasOrientationMovePassedSlop(Orientation.Horizontal, 1, 0, 1)

}

@Test

fun onPointerInput_filterIsHorizontalMoveDownPassedSlop_onTouchSlopExceededNotCalled() {

974

onPointerInput_filterHasOrientationMovePassedSlop(Orientation.Horizontal, 0, 1, 0)

}

@Test

fun onPointerInput_filterIsVerticalMoveLeftPassedSlop_onTouchSlopExceededNotCalled() {

979

onPointerInput_filterHasOrientationMovePassedSlop(Orientation.Vertical, -1, 0, 0)

}

@Test

fun onPointerInput_filterIsVerticalMoveUpPassedSlop_onTouchSlopExceededCalled() {

984

onPointerInput_filterHasOrientationMovePassedSlop(Orientation.Vertical, 0, -1, 1)

}

@Test

fun onPointerInput_filterIsVerticalMoveRightPassedSlop_onTouchSlopExceededNotCalled() {

989

onPointerInput_filterHasOrientationMovePassedSlop(Orientation.Vertical, 1, 0, 0)

}

@Test

fun onPointerInput_filterIsVerticalMoveDownPassedSlop_onTouchSlopExceededCalled() {

994

onPointerInput_filterHasOrientationMovePassedSlop(Orientation.Vertical, 0, 1, 1)

995

}

996

997

private fun onPointerInput_filterHasOrientationMovePassedSlop(

998

filterOrientation: Orientation,

999

horizontalDirection: Int,

1000

verticalDirection: Int,

1001

expectecdOnDragSlopExceededCallCount: Int

1002

) {

1003

val beyondSlop = TestTouchSlop + TinyNum

1004

1005

filter.setDraggableData(filterOrientation, canDrag)

1006

1007

val down = down(0)

1008

filter::onPointerInput.invokeOverAllPasses(down)

1009

val move = down.moveBy(

1010

Duration(milliseconds = 100),

1011

horizontalDirection * beyondSlop,

1012

verticalDirection * beyondSlop

1013

)

1014

filter::onPointerInput.invokeOverAllPasses(move)

1015

1016

assertThat(onDragSlopExceededCallCount).isEqualTo(expectecdOnDragSlopExceededCallCount)

}

@Test

fun onPointerInput_filterHorizontalPointerVerticalMovesLeftPastSlop_callBackNotCalled() {

1021

onPointerInput_pointerIsLockedMovesPassedSlop(

1022

Orientation.Horizontal, Orientation.Vertical, -1, 0, 0

)

}

@Test

fun onPointerInput_filterHorizontalPointerVerticalMovesRightPastSlop_callBackNotCalled() {

1028

onPointerInput_pointerIsLockedMovesPassedSlop(

1029

Orientation.Horizontal, Orientation.Vertical, 1, 0, 0

)

}

@Test

fun onPointerInput_filterHorizontalPointerHorizontalMovesLeftPastSlop_callBackCalled() {

1035

onPointerInput_pointerIsLockedMovesPassedSlop(

1036

Orientation.Horizontal, Orientation.Horizontal, -1, 0, 1

)

}

@Test

fun onPointerInput_filterHorizontalPointerHorizontallMovesRightPastSlop_callBackCalled() {

1042

onPointerInput_pointerIsLockedMovesPassedSlop(

1043

Orientation.Horizontal, Orientation.Horizontal, 1, 0, 1

)

}

@Test

fun onPointerInput_filterVerticalPointerHorizontalMovesUpPastSlop_callBackNotCalled() {

1049

onPointerInput_pointerIsLockedMovesPassedSlop(

1050

Orientation.Vertical, Orientation.Horizontal, 0, -1, 0

)

}

@Test

fun onPointerInput_filterVerticalPointerHorizontalMovesDownPastSlop_callBackNotCalled() {

1056

onPointerInput_pointerIsLockedMovesPassedSlop(

1057

Orientation.Vertical, Orientation.Horizontal, 0, 1, 0

)

}

@Test

fun onPointerInput_filterVerticalPointerVerticalMovesUpPastSlop_callBackCalled() {

1063

onPointerInput_pointerIsLockedMovesPassedSlop(

1064

Orientation.Vertical, Orientation.Vertical, 0, -1, 1

)

}

@Test

fun onPointerInput_filterVerticalPointerVerticalMovesDownPastSlop_callBackCalled() {

1070

onPointerInput_pointerIsLockedMovesPassedSlop(

1071

Orientation.Vertical, Orientation.Vertical, 0, 1, 1

)

}

private fun onPointerInput_pointerIsLockedMovesPassedSlop(

1076

filterOrientation: Orientation,

1077

lockedOrientation: Orientation,

1078

horizontalDirection: Int,

1079

verticalDirection: Int,

1080

expectedOnDragSlopExceededCallCount: Int

1081

) {

1082

val beyondSlop = TestTouchSlop + TinyNum

1083

1084

filter.onInit(mock())

1085

val scrollOrientationLocker = InternalScrollOrientationLocker()

1086

filter::onCustomEvent.invokeOverAllPasses(

1087

ShareScrollOrientationLockerEvent(scrollOrientationLocker)

1088

)

1089

1090

filter.setDraggableData(filterOrientation, canDrag)

1091

1092

val down = down(0)

1093

filter::onPointerInput.invokeOverAllPasses(down)

1094

val move = down.moveBy(

1095

Duration(milliseconds = 100),

1096

horizontalDirection * beyondSlop,

1097

verticalDirection * beyondSlop

1098

)

1099

scrollOrientationLocker.attemptToLockPointers(listOf(move), lockedOrientation)

1100

1101

filter::onPointerInput.invokeOverAllPasses(move)

1102

1103

assertThat(onDragSlopExceededCallCount).isEqualTo(expectedOnDragSlopExceededCallCount)

1104

}

1105

Shep Shapard

2019-12-16 17:06:51 -0800

[diff] [blame]

1106

// Verification that cancellation behavior is correct.

1107

1108

@Test

Shep Shapard

2020-05-19 15:25:36 -0700

[diff] [blame]

1109

fun onCancel_underSlopCancelUnderSlop_onDragSlopExceededNotCalled() {

Shep Shapard

2020-02-13 16:37:14 -0800

[diff] [blame]

1110

val underSlop = TestTouchSlop - TinyNum

Shep Shapard

2019-12-16 17:06:51 -0800

[diff] [blame]

// Arrange

var pointer = down(0, 0.milliseconds, 0f, 0f)

Shep Shapard

2020-04-03 13:22:08 -0700

[diff] [blame]

1115

filter::onPointerInput.invokeOverAllPasses(pointer)

Shep Shapard

2019-12-16 17:06:51 -0800

[diff] [blame]

1116

1117

pointer = pointer.moveTo(

1118

10.milliseconds,

Shep Shapard

2020-02-13 16:37:14 -0800

[diff] [blame]

1119

underSlop,

Shep Shapard

2019-12-16 17:06:51 -0800

[diff] [blame]

1120

0f

1121

)

Shep Shapard

2020-04-03 13:22:08 -0700

[diff] [blame]

1122

filter::onPointerInput.invokeOverAllPasses(pointer)

Shep Shapard

2019-12-16 17:06:51 -0800

[diff] [blame]

// Act

Shep Shapard

2020-04-03 13:22:08 -0700

[diff] [blame]

1126

filter.onCancel()

Shep Shapard

2019-12-16 17:06:51 -0800

[diff] [blame]

1127

1128

pointer = down(0, 0.milliseconds, 0f, 0f)

Shep Shapard

2020-04-03 13:22:08 -0700

[diff] [blame]

1129

filter::onPointerInput.invokeOverAllPasses(pointer)

Shep Shapard

2019-12-16 17:06:51 -0800

[diff] [blame]

1130

1131

pointer = pointer.moveTo(

1132

10.milliseconds,

Shep Shapard

2020-02-13 16:37:14 -0800

[diff] [blame]

1133

underSlop,

Shep Shapard

2019-12-16 17:06:51 -0800

[diff] [blame]

1134

0f

1135

)

Shep Shapard

2020-04-03 13:22:08 -0700

[diff] [blame]

1136

filter::onPointerInput.invokeOverAllPasses(pointer)

Shep Shapard

2019-12-16 17:06:51 -0800

[diff] [blame]

// Assert

Shep Shapard

2020-05-19 15:25:36 -0700

[diff] [blame]

1140

assertThat(onDragSlopExceededCallCount).isEqualTo(0)

Shep Shapard

2019-12-16 17:06:51 -0800

[diff] [blame]

1141

}

1142

1143

@Test

Shep Shapard

6c9f1da

2020-03-24 14:12:35 -0700

[diff] [blame]

1144

fun onCancel_pastSlopCancelPastSlop_onScaleSlopExceededCalledTwice() {

Shep Shapard

2020-02-13 16:37:14 -0800

[diff] [blame]

1145

val overSlop = TestTouchSlop + TinyNum

Shep Shapard

2019-12-16 17:06:51 -0800

[diff] [blame]

// Arrange

var pointer = down(0, 0.milliseconds, 0f, 0f)

Shep Shapard

2020-04-03 13:22:08 -0700

[diff] [blame]

1150

filter::onPointerInput.invokeOverAllPasses(pointer)

Shep Shapard

2019-12-16 17:06:51 -0800

[diff] [blame]

1151

1152

pointer = pointer.moveTo(

1153

10.milliseconds,

Shep Shapard

2020-02-13 16:37:14 -0800

[diff] [blame]

1154

overSlop,

Shep Shapard

2019-12-16 17:06:51 -0800

[diff] [blame]

1155

0f

1156

)

Shep Shapard

2020-04-03 13:22:08 -0700

[diff] [blame]

1157

filter::onPointerInput.invokeOverAllPasses(pointer)

Shep Shapard

2019-12-16 17:06:51 -0800

[diff] [blame]

// Act

Shep Shapard

2020-04-03 13:22:08 -0700

[diff] [blame]

1161

filter.onCancel()

Shep Shapard

2019-12-16 17:06:51 -0800

[diff] [blame]

1162

1163

pointer = down(0, 0.milliseconds, 0f, 0f)

Shep Shapard

2020-04-03 13:22:08 -0700

[diff] [blame]

1164

filter::onPointerInput.invokeOverAllPasses(pointer)

Shep Shapard

2019-12-16 17:06:51 -0800

[diff] [blame]

1165

1166

pointer = pointer.moveTo(

1167

10.milliseconds,

Shep Shapard

2020-02-13 16:37:14 -0800

[diff] [blame]

1168

overSlop,

Shep Shapard

2019-12-16 17:06:51 -0800

[diff] [blame]

1169

0f

1170

)

Shep Shapard

2020-04-03 13:22:08 -0700

[diff] [blame]

1171

filter::onPointerInput.invokeOverAllPasses(pointer)

Shep Shapard

2019-12-16 17:06:51 -0800

[diff] [blame]

// Assert

Shep Shapard

2020-05-19 15:25:36 -0700

[diff] [blame]

1175

assertThat(onDragSlopExceededCallCount).isEqualTo(2)

Shep Shapard

2019-12-16 17:06:51 -0800

[diff] [blame]

1176

}

shepshapard