dismissible_test.dart 34.7 KB
Newer Older
Ian Hickson's avatar
Ian Hickson committed
1
// Copyright 2014 The Flutter Authors. All rights reserved.
Hixie's avatar
Hixie committed
2 3 4
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

5 6 7 8 9 10
// TODO(gspencergoog): Remove this tag once this test's state leaks/test
// dependencies have been fixed.
// https://github.com/flutter/flutter/issues/85160
// Fails with "flutter test --test-randomize-ordering-seed=456"
@Tags(<String>['no-shuffle'])

11
import 'package:flutter/gestures.dart' show DragStartBehavior;
12
import 'package:flutter/widgets.dart';
Ian Hickson's avatar
Ian Hickson committed
13
import 'package:flutter_test/flutter_test.dart';
14

15
const double itemExtent = 100.0;
16
Axis scrollDirection = Axis.vertical;
17
DismissDirection dismissDirection = DismissDirection.horizontal;
18
late DismissDirection reportedDismissDirection;
19
List<int> dismissedItems = <int>[];
20
Widget? background;
21
const double crossAxisEndOffset = 0.5;
22

23
Widget buildTest({
24
  double? startToEndThreshold,
25
  TextDirection textDirection = TextDirection.ltr,
26
  Future<bool?> Function(BuildContext context, DismissDirection direction)? confirmDismiss,
27
  ScrollController? controller,
28
}) {
29
  return Directionality(
Ian Hickson's avatar
Ian Hickson committed
30
    textDirection: textDirection,
31
    child: StatefulBuilder(
Ian Hickson's avatar
Ian Hickson committed
32 33
      builder: (BuildContext context, StateSetter setState) {
        Widget buildDismissibleItem(int item) {
34
          return Dismissible(
35
            dragStartBehavior: DragStartBehavior.down,
36
            key: ValueKey<int>(item),
Ian Hickson's avatar
Ian Hickson committed
37
            direction: dismissDirection,
38 39 40
            confirmDismiss: confirmDismiss == null ? null : (DismissDirection direction) {
              return confirmDismiss(context, direction);
            },
Ian Hickson's avatar
Ian Hickson committed
41 42 43 44 45 46 47 48
            onDismissed: (DismissDirection direction) {
              setState(() {
                reportedDismissDirection = direction;
                expect(dismissedItems.contains(item), isFalse);
                dismissedItems.add(item);
              });
            },
            onResize: () {
49
              expect(dismissedItems.contains(item), isFalse);
Ian Hickson's avatar
Ian Hickson committed
50 51 52 53 54
            },
            background: background,
            dismissThresholds: startToEndThreshold == null
                ? <DismissDirection, double>{}
                : <DismissDirection, double>{DismissDirection.startToEnd: startToEndThreshold},
55
            crossAxisEndOffset: crossAxisEndOffset,
56
            child: SizedBox(
Ian Hickson's avatar
Ian Hickson committed
57 58
              width: itemExtent,
              height: itemExtent,
59
              child: Text(item.toString()),
Ian Hickson's avatar
Ian Hickson committed
60 61 62 63
            ),
          );
        }

64
        return Container(
Ian Hickson's avatar
Ian Hickson committed
65
          padding: const EdgeInsets.all(10.0),
66
          child: ListView(
67
            controller: controller,
68
            dragStartBehavior: DragStartBehavior.down,
Ian Hickson's avatar
Ian Hickson committed
69 70
            scrollDirection: scrollDirection,
            itemExtent: itemExtent,
71
            children: <int>[0, 1, 2, 3, 4, 5, 6, 7, 8]
Ian Hickson's avatar
Ian Hickson committed
72
              .where((int i) => !dismissedItems.contains(i))
73
              .map<Widget>(buildDismissibleItem).toList(),
74 75
          ),
        );
Ian Hickson's avatar
Ian Hickson committed
76 77
      },
    ),
78 79 80
  );
}

81
typedef DismissMethod = Future<void> Function(WidgetTester tester, Finder finder, { required AxisDirection gestureDirection });
82

83
Future<void> dismissElement(WidgetTester tester, Finder finder, { required AxisDirection gestureDirection }) async {
84 85
  Offset downLocation;
  Offset upLocation;
86
  switch (gestureDirection) {
Ian Hickson's avatar
Ian Hickson committed
87
    case AxisDirection.left:
88
      // getTopRight() returns a point that's just beyond itemWidget's right
89
      // edge and outside the Dismissible event listener's bounds.
90 91
      downLocation = tester.getTopRight(finder) + const Offset(-0.1, 0.0);
      upLocation = tester.getTopLeft(finder);
92
      break;
Ian Hickson's avatar
Ian Hickson committed
93
    case AxisDirection.right:
94
      // we do the same thing here to keep the test symmetric
95 96
      downLocation = tester.getTopLeft(finder) + const Offset(0.1, 0.0);
      upLocation = tester.getTopRight(finder);
97
      break;
Ian Hickson's avatar
Ian Hickson committed
98
    case AxisDirection.up:
99
      // getBottomLeft() returns a point that's just below itemWidget's bottom
100
      // edge and outside the Dismissible event listener's bounds.
101 102
      downLocation = tester.getBottomLeft(finder) + const Offset(0.0, -0.1);
      upLocation = tester.getTopLeft(finder);
103
      break;
Ian Hickson's avatar
Ian Hickson committed
104
    case AxisDirection.down:
105
      // again with doing the same here for symmetry
106 107
      downLocation = tester.getTopLeft(finder) + const Offset(0.1, 0.0);
      upLocation = tester.getBottomLeft(finder);
108 109 110
      break;
  }

Ian Hickson's avatar
Ian Hickson committed
111
  final TestGesture gesture = await tester.startGesture(downLocation);
112 113
  await gesture.moveTo(upLocation);
  await gesture.up();
Hixie's avatar
Hixie committed
114 115
}

116
Future<void> flingElement(WidgetTester tester, Finder finder, { required AxisDirection gestureDirection, double initialOffsetFactor = 0.0 }) async {
Ian Hickson's avatar
Ian Hickson committed
117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133
  Offset delta;
  switch (gestureDirection) {
    case AxisDirection.left:
      delta = const Offset(-300.0, 0.0);
      break;
    case AxisDirection.right:
      delta = const Offset(300.0, 0.0);
      break;
    case AxisDirection.up:
      delta = const Offset(0.0, -300.0);
      break;
    case AxisDirection.down:
      delta = const Offset(0.0, 300.0);
      break;
  }
  await tester.fling(finder, delta, 1000.0, initialOffset: delta * initialOffsetFactor);
}
Hixie's avatar
Hixie committed
134

135
Future<void> flingElementFromZero(WidgetTester tester, Finder finder, { required AxisDirection gestureDirection }) async {
Ian Hickson's avatar
Ian Hickson committed
136 137
  // This is a special case where we drag in one direction, then fling back so
  // that at the point of release, we're at exactly the point at which we
Josh Soref's avatar
Josh Soref committed
138
  // started, but with velocity. This is needed to check a boundary condition
Ian Hickson's avatar
Ian Hickson committed
139 140 141 142
  // in the flinging behavior.
  await flingElement(tester, finder, gestureDirection: gestureDirection, initialOffsetFactor: -1.0);
}

143 144 145
Future<void> dismissItem(
  WidgetTester tester,
  int item, {
146
  required AxisDirection gestureDirection,
147
  DismissMethod mechanism = dismissElement,
Ian Hickson's avatar
Ian Hickson committed
148 149
}) async {
  assert(gestureDirection != null);
150
  final Finder itemFinder = find.text(item.toString());
151
  expect(itemFinder, findsOneWidget);
Hixie's avatar
Hixie committed
152

Ian Hickson's avatar
Ian Hickson committed
153
  await mechanism(tester, itemFinder, gestureDirection: gestureDirection);
154

155 156 157 158 159
  await tester.pump(); // start the slide
  await tester.pump(const Duration(seconds: 1)); // finish the slide and start shrinking...
  await tester.pump(); // first frame of shrinking animation
  await tester.pump(const Duration(seconds: 1)); // finish the shrinking and call the callback...
  await tester.pump(); // rebuild after the callback removes the entry
160 161
}

162 163 164
Future<void> checkFlingItemBeforeMovementEnd(
  WidgetTester tester,
  int item, {
165
  required AxisDirection gestureDirection,
166
  DismissMethod mechanism = rollbackElement,
167 168 169 170 171 172 173 174 175 176 177
}) async {
  assert(gestureDirection != null);
  final Finder itemFinder = find.text(item.toString());
  expect(itemFinder, findsOneWidget);

  await mechanism(tester, itemFinder, gestureDirection: gestureDirection);

  await tester.pump(); // start the slide
  await tester.pump(const Duration(milliseconds: 100));
}

178 179 180
Future<void> checkFlingItemAfterMovement(
  WidgetTester tester,
  int item, {
181
  required AxisDirection gestureDirection,
182
  DismissMethod mechanism = rollbackElement,
183 184 185 186 187 188 189 190 191 192 193
}) async {
  assert(gestureDirection != null);
  final Finder itemFinder = find.text(item.toString());
  expect(itemFinder, findsOneWidget);

  await mechanism(tester, itemFinder, gestureDirection: gestureDirection);

  await tester.pump(); // start the slide
  await tester.pump(const Duration(milliseconds: 300));
}

194
Future<void> rollbackElement(WidgetTester tester, Finder finder, { required AxisDirection gestureDirection, double initialOffsetFactor = 0.0 }) async {
195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212
  Offset delta;
  switch (gestureDirection) {
    case AxisDirection.left:
      delta = const Offset(-30.0, 0.0);
      break;
    case AxisDirection.right:
      delta = const Offset(30.0, 0.0);
      break;
    case AxisDirection.up:
      delta = const Offset(0.0, -30.0);
      break;
    case AxisDirection.down:
      delta = const Offset(0.0, 30.0);
      break;
  }
  await tester.fling(finder, delta, 1000.0, initialOffset: delta * initialOffsetFactor);
}

213
class Test1215DismissibleWidget extends StatelessWidget {
214
  const Test1215DismissibleWidget(this.text, { Key? key }) : super(key: key);
215

Hixie's avatar
Hixie committed
216
  final String text;
217 218

  @override
Hixie's avatar
Hixie committed
219
  Widget build(BuildContext context) {
220
    return Dismissible(
221
      dragStartBehavior: DragStartBehavior.down,
222 223
      key: ObjectKey(text),
      child: AspectRatio(
Hixie's avatar
Hixie committed
224
        aspectRatio: 1.0,
225
        child: Text(text),
226
      ),
Hixie's avatar
Hixie committed
227 228 229 230
    );
  }
}

231
void main() {
232 233 234 235 236
  setUp(() {
    dismissedItems = <int>[];
    background = null;
  });

237
  testWidgets('Horizontal drag triggers dismiss scrollDirection=vertical', (WidgetTester tester) async {
238 239
    scrollDirection = Axis.vertical;
    dismissDirection = DismissDirection.horizontal;
240

241
    await tester.pumpWidget(buildTest());
242
    expect(dismissedItems, isEmpty);
243

Ian Hickson's avatar
Ian Hickson committed
244
    await dismissItem(tester, 0, gestureDirection: AxisDirection.right);
245
    expect(find.text('0'), findsNothing);
246
    expect(dismissedItems, equals(<int>[0]));
247
    expect(reportedDismissDirection, DismissDirection.startToEnd);
248

Ian Hickson's avatar
Ian Hickson committed
249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293
    await dismissItem(tester, 1, gestureDirection: AxisDirection.left);
    expect(find.text('1'), findsNothing);
    expect(dismissedItems, equals(<int>[0, 1]));
    expect(reportedDismissDirection, DismissDirection.endToStart);
  });

  testWidgets('Horizontal fling triggers dismiss scrollDirection=vertical', (WidgetTester tester) async {
    scrollDirection = Axis.vertical;
    dismissDirection = DismissDirection.horizontal;

    await tester.pumpWidget(buildTest());
    expect(dismissedItems, isEmpty);

    await dismissItem(tester, 0, gestureDirection: AxisDirection.right, mechanism: flingElement);
    expect(find.text('0'), findsNothing);
    expect(dismissedItems, equals(<int>[0]));
    expect(reportedDismissDirection, DismissDirection.startToEnd);

    await dismissItem(tester, 1, gestureDirection: AxisDirection.left, mechanism: flingElement);
    expect(find.text('1'), findsNothing);
    expect(dismissedItems, equals(<int>[0, 1]));
    expect(reportedDismissDirection, DismissDirection.endToStart);
  });

  testWidgets('Horizontal fling does not trigger at zero offset, but does otherwise', (WidgetTester tester) async {
    scrollDirection = Axis.vertical;
    dismissDirection = DismissDirection.horizontal;

    await tester.pumpWidget(buildTest(startToEndThreshold: 0.95));
    expect(dismissedItems, isEmpty);

    await dismissItem(tester, 0, gestureDirection: AxisDirection.right, mechanism: flingElementFromZero);
    expect(find.text('0'), findsOneWidget);
    expect(dismissedItems, equals(<int>[]));

    await dismissItem(tester, 0, gestureDirection: AxisDirection.left, mechanism: flingElementFromZero);
    expect(find.text('0'), findsOneWidget);
    expect(dismissedItems, equals(<int>[]));

    await dismissItem(tester, 0, gestureDirection: AxisDirection.right, mechanism: flingElement);
    expect(find.text('0'), findsNothing);
    expect(dismissedItems, equals(<int>[0]));
    expect(reportedDismissDirection, DismissDirection.startToEnd);

    await dismissItem(tester, 1, gestureDirection: AxisDirection.left, mechanism: flingElement);
294
    expect(find.text('1'), findsNothing);
295
    expect(dismissedItems, equals(<int>[0, 1]));
296
    expect(reportedDismissDirection, DismissDirection.endToStart);
297 298
  });

299
  testWidgets('Vertical drag triggers dismiss scrollDirection=horizontal', (WidgetTester tester) async {
300 301
    scrollDirection = Axis.horizontal;
    dismissDirection = DismissDirection.vertical;
302

303
    await tester.pumpWidget(buildTest());
304
    expect(dismissedItems, isEmpty);
305

Ian Hickson's avatar
Ian Hickson committed
306
    await dismissItem(tester, 0, gestureDirection: AxisDirection.up);
307
    expect(find.text('0'), findsNothing);
308
    expect(dismissedItems, equals(<int>[0]));
309
    expect(reportedDismissDirection, DismissDirection.up);
310

Ian Hickson's avatar
Ian Hickson committed
311
    await dismissItem(tester, 1, gestureDirection: AxisDirection.down);
312
    expect(find.text('1'), findsNothing);
313
    expect(dismissedItems, equals(<int>[0, 1]));
314
    expect(reportedDismissDirection, DismissDirection.down);
315 316
  });

Ian Hickson's avatar
Ian Hickson committed
317
  testWidgets('drag-left with DismissDirection.endToStart triggers dismiss (LTR)', (WidgetTester tester) async {
318 319
    scrollDirection = Axis.vertical;
    dismissDirection = DismissDirection.endToStart;
320

321
    await tester.pumpWidget(buildTest());
322
    expect(dismissedItems, isEmpty);
323

Ian Hickson's avatar
Ian Hickson committed
324
    await dismissItem(tester, 0, gestureDirection: AxisDirection.right);
325 326
    expect(find.text('0'), findsOneWidget);
    expect(dismissedItems, isEmpty);
Ian Hickson's avatar
Ian Hickson committed
327
    await dismissItem(tester, 1, gestureDirection: AxisDirection.right);
328

Ian Hickson's avatar
Ian Hickson committed
329
    await dismissItem(tester, 0, gestureDirection: AxisDirection.left);
330
    expect(find.text('0'), findsNothing);
331
    expect(dismissedItems, equals(<int>[0]));
Ian Hickson's avatar
Ian Hickson committed
332
    await dismissItem(tester, 1, gestureDirection: AxisDirection.left);
333 334
  });

Ian Hickson's avatar
Ian Hickson committed
335
  testWidgets('drag-right with DismissDirection.startToEnd triggers dismiss (LTR)', (WidgetTester tester) async {
336 337
    scrollDirection = Axis.vertical;
    dismissDirection = DismissDirection.startToEnd;
338

339
    await tester.pumpWidget(buildTest());
340
    expect(dismissedItems, isEmpty);
341

Ian Hickson's avatar
Ian Hickson committed
342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374
    await dismissItem(tester, 0, gestureDirection: AxisDirection.left);
    expect(find.text('0'), findsOneWidget);
    expect(dismissedItems, isEmpty);

    await dismissItem(tester, 0, gestureDirection: AxisDirection.right);
    expect(find.text('0'), findsNothing);
    expect(dismissedItems, equals(<int>[0]));
  });

  testWidgets('drag-right with DismissDirection.endToStart triggers dismiss (RTL)', (WidgetTester tester) async {
    scrollDirection = Axis.vertical;
    dismissDirection = DismissDirection.endToStart;

    await tester.pumpWidget(buildTest(textDirection: TextDirection.rtl));
    expect(dismissedItems, isEmpty);

    await dismissItem(tester, 0, gestureDirection: AxisDirection.left);
    expect(find.text('0'), findsOneWidget);
    expect(dismissedItems, isEmpty);

    await dismissItem(tester, 0, gestureDirection: AxisDirection.right);
    expect(find.text('0'), findsNothing);
    expect(dismissedItems, equals(<int>[0]));
  });

  testWidgets('drag-left with DismissDirection.startToEnd triggers dismiss (RTL)', (WidgetTester tester) async {
    scrollDirection = Axis.vertical;
    dismissDirection = DismissDirection.startToEnd;

    await tester.pumpWidget(buildTest(textDirection: TextDirection.rtl));
    expect(dismissedItems, isEmpty);

    await dismissItem(tester, 0, gestureDirection: AxisDirection.right);
375 376
    expect(find.text('0'), findsOneWidget);
    expect(dismissedItems, isEmpty);
Ian Hickson's avatar
Ian Hickson committed
377
    await dismissItem(tester, 1, gestureDirection: AxisDirection.right);
378

Ian Hickson's avatar
Ian Hickson committed
379
    await dismissItem(tester, 0, gestureDirection: AxisDirection.left);
380
    expect(find.text('0'), findsNothing);
381
    expect(dismissedItems, equals(<int>[0]));
Ian Hickson's avatar
Ian Hickson committed
382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450
    await dismissItem(tester, 1, gestureDirection: AxisDirection.left);
  });

  testWidgets('fling-left with DismissDirection.endToStart triggers dismiss (LTR)', (WidgetTester tester) async {
    scrollDirection = Axis.vertical;
    dismissDirection = DismissDirection.endToStart;

    await tester.pumpWidget(buildTest());
    expect(dismissedItems, isEmpty);

    await dismissItem(tester, 0, gestureDirection: AxisDirection.right);
    expect(find.text('0'), findsOneWidget);
    expect(dismissedItems, isEmpty);
    await dismissItem(tester, 1, gestureDirection: AxisDirection.right);

    await dismissItem(tester, 0, gestureDirection: AxisDirection.left);
    expect(find.text('0'), findsNothing);
    expect(dismissedItems, equals(<int>[0]));
    await dismissItem(tester, 1, gestureDirection: AxisDirection.left);
  });

  testWidgets('fling-right with DismissDirection.startToEnd triggers dismiss (LTR)', (WidgetTester tester) async {
    scrollDirection = Axis.vertical;
    dismissDirection = DismissDirection.startToEnd;

    await tester.pumpWidget(buildTest());
    expect(dismissedItems, isEmpty);

    await dismissItem(tester, 0, mechanism: flingElement, gestureDirection: AxisDirection.left);
    expect(find.text('0'), findsOneWidget);
    expect(dismissedItems, isEmpty);

    await dismissItem(tester, 0, mechanism: flingElement, gestureDirection: AxisDirection.right);
    expect(find.text('0'), findsNothing);
    expect(dismissedItems, equals(<int>[0]));
  });

  testWidgets('fling-right with DismissDirection.endToStart triggers dismiss (RTL)', (WidgetTester tester) async {
    scrollDirection = Axis.vertical;
    dismissDirection = DismissDirection.endToStart;

    await tester.pumpWidget(buildTest(textDirection: TextDirection.rtl));
    expect(dismissedItems, isEmpty);

    await dismissItem(tester, 0, mechanism: flingElement, gestureDirection: AxisDirection.left);
    expect(find.text('0'), findsOneWidget);
    expect(dismissedItems, isEmpty);

    await dismissItem(tester, 0, mechanism: flingElement, gestureDirection: AxisDirection.right);
    expect(find.text('0'), findsNothing);
    expect(dismissedItems, equals(<int>[0]));
  });

  testWidgets('fling-left with DismissDirection.startToEnd triggers dismiss (RTL)', (WidgetTester tester) async {
    scrollDirection = Axis.vertical;
    dismissDirection = DismissDirection.startToEnd;

    await tester.pumpWidget(buildTest(textDirection: TextDirection.rtl));
    expect(dismissedItems, isEmpty);

    await dismissItem(tester, 0, mechanism: flingElement, gestureDirection: AxisDirection.right);
    expect(find.text('0'), findsOneWidget);
    expect(dismissedItems, isEmpty);
    await dismissItem(tester, 1, mechanism: flingElement, gestureDirection: AxisDirection.right);

    await dismissItem(tester, 0, mechanism: flingElement, gestureDirection: AxisDirection.left);
    expect(find.text('0'), findsNothing);
    expect(dismissedItems, equals(<int>[0]));
    await dismissItem(tester, 1, mechanism: flingElement, gestureDirection: AxisDirection.left);
451 452
  });

453
  testWidgets('drag-up with DismissDirection.up triggers dismiss', (WidgetTester tester) async {
454 455
    scrollDirection = Axis.horizontal;
    dismissDirection = DismissDirection.up;
456

457
    await tester.pumpWidget(buildTest());
458
    expect(dismissedItems, isEmpty);
459

Ian Hickson's avatar
Ian Hickson committed
460
    await dismissItem(tester, 0, gestureDirection: AxisDirection.down);
461 462
    expect(find.text('0'), findsOneWidget);
    expect(dismissedItems, isEmpty);
463

Ian Hickson's avatar
Ian Hickson committed
464
    await dismissItem(tester, 0, gestureDirection: AxisDirection.up);
465
    expect(find.text('0'), findsNothing);
466
    expect(dismissedItems, equals(<int>[0]));
467 468
  });

469
  testWidgets('drag-down with DismissDirection.down triggers dismiss', (WidgetTester tester) async {
470 471
    scrollDirection = Axis.horizontal;
    dismissDirection = DismissDirection.down;
472

473
    await tester.pumpWidget(buildTest());
474
    expect(dismissedItems, isEmpty);
475

Ian Hickson's avatar
Ian Hickson committed
476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508
    await dismissItem(tester, 0, gestureDirection: AxisDirection.up);
    expect(find.text('0'), findsOneWidget);
    expect(dismissedItems, isEmpty);

    await dismissItem(tester, 0, gestureDirection: AxisDirection.down);
    expect(find.text('0'), findsNothing);
    expect(dismissedItems, equals(<int>[0]));
  });

  testWidgets('fling-up with DismissDirection.up triggers dismiss', (WidgetTester tester) async {
    scrollDirection = Axis.horizontal;
    dismissDirection = DismissDirection.up;

    await tester.pumpWidget(buildTest());
    expect(dismissedItems, isEmpty);

    await dismissItem(tester, 0, mechanism: flingElement, gestureDirection: AxisDirection.down);
    expect(find.text('0'), findsOneWidget);
    expect(dismissedItems, isEmpty);

    await dismissItem(tester, 0, mechanism: flingElement, gestureDirection: AxisDirection.up);
    expect(find.text('0'), findsNothing);
    expect(dismissedItems, equals(<int>[0]));
  });

  testWidgets('fling-down with DismissDirection.down triggers dismiss', (WidgetTester tester) async {
    scrollDirection = Axis.horizontal;
    dismissDirection = DismissDirection.down;

    await tester.pumpWidget(buildTest());
    expect(dismissedItems, isEmpty);

    await dismissItem(tester, 0, mechanism: flingElement, gestureDirection: AxisDirection.up);
509 510
    expect(find.text('0'), findsOneWidget);
    expect(dismissedItems, isEmpty);
511

Ian Hickson's avatar
Ian Hickson committed
512
    await dismissItem(tester, 0, mechanism: flingElement, gestureDirection: AxisDirection.down);
513
    expect(find.text('0'), findsNothing);
514
    expect(dismissedItems, equals(<int>[0]));
515
  });
516

517
  testWidgets('drag-left has no effect on dismissible with a high dismiss threshold', (WidgetTester tester) async {
518 519 520 521 522 523
    scrollDirection = Axis.vertical;
    dismissDirection = DismissDirection.horizontal;

    await tester.pumpWidget(buildTest(startToEndThreshold: 1.0));
    expect(dismissedItems, isEmpty);

Ian Hickson's avatar
Ian Hickson committed
524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540
    await dismissItem(tester, 0, gestureDirection: AxisDirection.right);
    expect(find.text('0'), findsOneWidget);
    expect(dismissedItems, isEmpty);

    await dismissItem(tester, 0, gestureDirection: AxisDirection.left);
    expect(find.text('0'), findsNothing);
    expect(dismissedItems, equals(<int>[0]));
  });

  testWidgets('fling-left has no effect on dismissible with a high dismiss threshold', (WidgetTester tester) async {
    scrollDirection = Axis.vertical;
    dismissDirection = DismissDirection.horizontal;

    await tester.pumpWidget(buildTest(startToEndThreshold: 1.0));
    expect(dismissedItems, isEmpty);

    await dismissItem(tester, 0, mechanism: flingElement, gestureDirection: AxisDirection.right);
541 542 543
    expect(find.text('0'), findsOneWidget);
    expect(dismissedItems, isEmpty);

Ian Hickson's avatar
Ian Hickson committed
544
    await dismissItem(tester, 0, mechanism: flingElement, gestureDirection: AxisDirection.left);
545 546 547 548
    expect(find.text('0'), findsNothing);
    expect(dismissedItems, equals(<int>[0]));
  });

549 550 551 552 553 554
  // This is a regression test for an fn2 bug where dragging a card caused an
  // assert "'!_disqualifiedFromEverAppearingAgain' is not true". The old URL
  // was https://github.com/domokit/sky_engine/issues/1068 but that issue is 404
  // now since we migrated to the new repo. The bug was fixed by
  // https://github.com/flutter/engine/pull/1134 at the time, and later made
  // irrelevant by fn3, but just in case...
555
  testWidgets('Verify that drag-move events do not assert', (WidgetTester tester) async {
556 557 558
    scrollDirection = Axis.horizontal;
    dismissDirection = DismissDirection.down;

559
    await tester.pumpWidget(buildTest());
560
    final Offset location = tester.getTopLeft(find.text('0'));
561
    const Offset offset = Offset(0.0, 5.0);
562
    final TestGesture gesture = await tester.startGesture(location, pointer: 5);
563
    await gesture.moveBy(offset);
564
    await tester.pumpWidget(buildTest());
565
    await gesture.moveBy(offset);
566
    await tester.pumpWidget(buildTest());
567
    await gesture.moveBy(offset);
568
    await tester.pumpWidget(buildTest());
569
    await gesture.moveBy(offset);
570
    await tester.pumpWidget(buildTest());
571
    await gesture.up();
572
  });
Hixie's avatar
Hixie committed
573

574
  // This one is for a case where dismissing a widget above a previously
575
  // dismissed widget threw an exception, which was documented at the
576 577 578
  // now-obsolete URL https://github.com/flutter/engine/issues/1215 (the URL
  // died in the migration to the new repo). Don't copy this test; it doesn't
  // actually remove the dismissed widget, which is a violation of the
579
  // Dismissible contract. This is not an example of good practice.
580
  testWidgets('dismissing bottom then top (smoketest)', (WidgetTester tester) async {
Ian Hickson's avatar
Ian Hickson committed
581
    await tester.pumpWidget(
582
      Directionality(
Ian Hickson's avatar
Ian Hickson committed
583
        textDirection: TextDirection.ltr,
584
        child: Center(
585
          child: SizedBox(
Ian Hickson's avatar
Ian Hickson committed
586 587
            width: 100.0,
            height: 1000.0,
588
            child: Column(
589
              children: const <Widget>[
590 591
                Test1215DismissibleWidget('1'),
                Test1215DismissibleWidget('2'),
Ian Hickson's avatar
Ian Hickson committed
592 593 594
              ],
            ),
          ),
595 596
        ),
      ),
Ian Hickson's avatar
Ian Hickson committed
597
    );
598 599
    expect(find.text('1'), findsOneWidget);
    expect(find.text('2'), findsOneWidget);
Ian Hickson's avatar
Ian Hickson committed
600
    await dismissElement(tester, find.text('2'), gestureDirection: AxisDirection.right);
601
    await tester.pump(); // start the slide away
602
    await tester.pump(const Duration(seconds: 1)); // finish the slide away
603 604
    expect(find.text('1'), findsOneWidget);
    expect(find.text('2'), findsNothing);
Ian Hickson's avatar
Ian Hickson committed
605
    await dismissElement(tester, find.text('1'), gestureDirection: AxisDirection.right);
606
    await tester.pump(); // start the slide away
607
    await tester.pump(const Duration(seconds: 1)); // finish the slide away (at which point the child is no longer included in the tree)
608 609
    expect(find.text('1'), findsNothing);
    expect(find.text('2'), findsNothing);
Hixie's avatar
Hixie committed
610
  });
611

612
  testWidgets('Dismissible starts from the full size when collapsing', (WidgetTester tester) async {
613 614
    scrollDirection = Axis.vertical;
    dismissDirection = DismissDirection.horizontal;
615
    background = const Text('background');
616

617
    await tester.pumpWidget(buildTest());
618
    expect(dismissedItems, isEmpty);
619

620
    final Finder itemFinder = find.text('0');
621
    expect(itemFinder, findsOneWidget);
Ian Hickson's avatar
Ian Hickson committed
622
    await dismissElement(tester, itemFinder, gestureDirection: AxisDirection.right);
623
    await tester.pump();
624

625
    expect(find.text('background'), findsOneWidget); // The other four have been culled.
626
    final RenderBox backgroundBox = tester.firstRenderObject(find.text('background'));
627
    expect(backgroundBox.size.height, equals(100.0));
628
  });
629 630 631 632 633 634 635 636 637 638 639 640

  testWidgets('Checking fling item before movementDuration completes', (WidgetTester tester) async {
    await tester.pumpWidget(buildTest());
    expect(dismissedItems, isEmpty);

    await checkFlingItemBeforeMovementEnd(tester, 0, gestureDirection: AxisDirection.left, mechanism: flingElement);
    expect(find.text('0'), findsOneWidget);

    await checkFlingItemBeforeMovementEnd(tester, 1, gestureDirection: AxisDirection.right, mechanism: flingElement);
    expect(find.text('1'), findsOneWidget);
  });

641
  testWidgets('Checking fling item after movementDuration', (WidgetTester tester) async {
642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678
    await tester.pumpWidget(buildTest());
    expect(dismissedItems, isEmpty);

    await checkFlingItemAfterMovement(tester, 1, gestureDirection: AxisDirection.left, mechanism: flingElement);
    expect(find.text('1'), findsNothing);

    await checkFlingItemAfterMovement(tester, 0, gestureDirection: AxisDirection.right, mechanism: flingElement);
    expect(find.text('0'), findsNothing);
  });

  testWidgets('Horizontal fling less than threshold', (WidgetTester tester) async {
    scrollDirection = Axis.horizontal;
    await tester.pumpWidget(buildTest());
    expect(dismissedItems, isEmpty);

    await checkFlingItemAfterMovement(tester, 0, gestureDirection: AxisDirection.left, mechanism: rollbackElement);
    expect(find.text('0'), findsOneWidget);
    expect(dismissedItems, isEmpty);

    await checkFlingItemAfterMovement(tester, 1, gestureDirection: AxisDirection.right, mechanism: rollbackElement);
    expect(find.text('1'), findsOneWidget);
    expect(dismissedItems, isEmpty);
  });

  testWidgets('Vertical fling less than threshold', (WidgetTester tester) async {
    scrollDirection = Axis.vertical;
    await tester.pumpWidget(buildTest());
    expect(dismissedItems, isEmpty);

    await checkFlingItemAfterMovement(tester, 0, gestureDirection: AxisDirection.left, mechanism: rollbackElement);
    expect(find.text('0'), findsOneWidget);
    expect(dismissedItems, isEmpty);

    await checkFlingItemAfterMovement(tester, 1, gestureDirection: AxisDirection.right, mechanism: rollbackElement);
    expect(find.text('1'), findsOneWidget);
    expect(dismissedItems, isEmpty);
  });
679 680 681 682

  testWidgets('confirmDismiss returns values: true, false, null', (WidgetTester tester) async {
    scrollDirection = Axis.vertical;
    dismissDirection = DismissDirection.horizontal;
683
    late DismissDirection confirmDismissDirection;
684

685
    Widget buildFrame(bool? confirmDismissValue) {
686 687 688
      return buildTest(
        confirmDismiss: (BuildContext context, DismissDirection dismissDirection) {
          confirmDismissDirection = dismissDirection;
689
          return Future<bool?>.value(confirmDismissValue);
690
        },
691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737
      );
    }

    // Dismiss is confirmed IFF confirmDismiss() returns true.
    await tester.pumpWidget(buildFrame(true));
    expect(dismissedItems, isEmpty);

    await dismissItem(tester, 0, gestureDirection: AxisDirection.right, mechanism: flingElement);
    expect(find.text('0'), findsNothing);
    expect(dismissedItems, equals(<int>[0]));
    expect(reportedDismissDirection, DismissDirection.startToEnd);
    expect(confirmDismissDirection, DismissDirection.startToEnd);

    await dismissItem(tester, 1, gestureDirection: AxisDirection.left, mechanism: flingElement);
    expect(find.text('1'), findsNothing);
    expect(dismissedItems, equals(<int>[0, 1]));
    expect(reportedDismissDirection, DismissDirection.endToStart);
    expect(confirmDismissDirection, DismissDirection.endToStart);

    // Dismiss is not confirmed if confirmDismiss() returns false
    dismissedItems = <int>[];
    await tester.pumpWidget(buildFrame(false));

    await dismissItem(tester, 0, gestureDirection: AxisDirection.right, mechanism: flingElement);
    expect(find.text('0'), findsOneWidget);
    expect(dismissedItems, isEmpty);
    expect(confirmDismissDirection, DismissDirection.startToEnd);

    await dismissItem(tester, 1, gestureDirection: AxisDirection.left, mechanism: flingElement);
    expect(find.text('1'), findsOneWidget);
    expect(dismissedItems, isEmpty);
    expect(confirmDismissDirection, DismissDirection.endToStart);

    // Dismiss is not confirmed if confirmDismiss() returns null
    dismissedItems = <int>[];
    await tester.pumpWidget(buildFrame(null));

    await dismissItem(tester, 0, gestureDirection: AxisDirection.right, mechanism: flingElement);
    expect(find.text('0'), findsOneWidget);
    expect(dismissedItems, isEmpty);
    expect(confirmDismissDirection, DismissDirection.startToEnd);

    await dismissItem(tester, 1, gestureDirection: AxisDirection.left, mechanism: flingElement);
    expect(find.text('1'), findsOneWidget);
    expect(dismissedItems, isEmpty);
    expect(confirmDismissDirection, DismissDirection.endToStart);
  });
738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765

  testWidgets('setState that does not remove the Dismissible from tree should throws Error', (WidgetTester tester) async {
    scrollDirection = Axis.vertical;
    dismissDirection = DismissDirection.horizontal;

    await tester.pumpWidget(Directionality(
      textDirection: TextDirection.ltr,
      child: StatefulBuilder(
        builder: (BuildContext context, StateSetter setState) {
          return ListView(
            dragStartBehavior: DragStartBehavior.down,
            scrollDirection: scrollDirection,
            itemExtent: itemExtent,
            children: <Widget>[
              Dismissible(
                dragStartBehavior: DragStartBehavior.down,
                key: const ValueKey<int>(1),
                direction: dismissDirection,
                onDismissed: (DismissDirection direction) {
                  setState(() {
                    reportedDismissDirection = direction;
                    expect(dismissedItems.contains(1), isFalse);
                    dismissedItems.add(1);
                  });
                },
                background: background,
                dismissThresholds: const <DismissDirection, double>{},
                crossAxisEndOffset: crossAxisEndOffset,
766
                child: SizedBox(
767 768 769 770 771
                  width: itemExtent,
                  height: itemExtent,
                  child: Text(1.toString()),
                ),
              ),
772
            ],
773 774 775 776 777 778 779 780 781 782
          );
        },
      ),
    ));
    expect(dismissedItems, isEmpty);
    await dismissItem(tester, 1, gestureDirection: AxisDirection.right);
    expect(dismissedItems, equals(<int>[1]));
    final dynamic exception =  tester.takeException();
    expect(exception, isNotNull);
    expect(exception, isFlutterError);
783
    final FlutterError error = exception as FlutterError;
784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801
    expect(error.diagnostics.last.level, DiagnosticLevel.hint);
    expect(
      error.diagnostics.last.toStringDeep(),
      equalsIgnoringHashCodes(
        'Make sure to implement the onDismissed handler and to immediately\n'
        'remove the Dismissible widget from the application once that\n'
        'handler has fired.\n',
      ),
    );
    expect(
      error.toStringDeep(),
      'FlutterError\n'
      '   A dismissed Dismissible widget is still part of the tree.\n'
      '   Make sure to implement the onDismissed handler and to immediately\n'
      '   remove the Dismissible widget from the application once that\n'
      '   handler has fired.\n',
    );
  });
802 803 804 805

  testWidgets('Dismissible.behavior should behave correctly during hit testing', (WidgetTester tester) async {
    bool didReceivePointerDown = false;

806
    Widget buildStack({required Widget child}) {
807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870
      return Directionality(
        textDirection: TextDirection.ltr,
        child: Stack(
          children: <Widget>[
            Listener(
              onPointerDown: (_) {
                didReceivePointerDown = true;
              },
              child: Container(
                width: 100.0,
                height: 100.0,
                color: const Color(0xFF00FF00),
              ),
            ),
            child,
          ],
        ),
      );
    }

    await tester.pumpWidget(
      buildStack(
        child: const Dismissible(
          key: ValueKey<int>(1),
          child: SizedBox(
            width: 100.0,
            height: 100.0,
          ),
        ),
      ),
    );
    await tester.tapAt(const Offset(10.0, 10.0));
    expect(didReceivePointerDown, isFalse);

    Future<void> pumpWidgetTree(HitTestBehavior behavior) {
      return tester.pumpWidget(
        buildStack(
          child: Dismissible(
            key: const ValueKey<int>(1),
            behavior: behavior,
            child: const SizedBox(
              width: 100.0,
              height: 100.0,
            ),
          ),
        ),
      );
    }

    didReceivePointerDown = false;
    await pumpWidgetTree(HitTestBehavior.deferToChild);
    await tester.tapAt(const Offset(10.0, 10.0));
    expect(didReceivePointerDown, isTrue);

    didReceivePointerDown = false;
    await pumpWidgetTree(HitTestBehavior.opaque);
    await tester.tapAt(const Offset(10.0, 10.0));
    expect(didReceivePointerDown, isFalse);

    didReceivePointerDown = false;
    await pumpWidgetTree(HitTestBehavior.translucent);
    await tester.tapAt(const Offset(10.0, 10.0));
    expect(didReceivePointerDown, isTrue);
  });
871 872 873 874 875 876 877 878 879 880 881 882 883

  testWidgets('DismissDirection.none does not trigger dismiss', (WidgetTester tester) async {
    dismissDirection = DismissDirection.none;

    await tester.pumpWidget(buildTest());
    expect(dismissedItems, isEmpty);

    await dismissItem(tester, 0, gestureDirection: AxisDirection.left);
    await dismissItem(tester, 0, gestureDirection: AxisDirection.right);
    await dismissItem(tester, 0, gestureDirection: AxisDirection.up);
    await dismissItem(tester, 0, gestureDirection: AxisDirection.down);
    expect(find.text('0'), findsOneWidget);
  });
884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901

  testWidgets('DismissDirection.none does not prevent scrolling', (WidgetTester tester) async {
    dismissDirection = DismissDirection.none;
    final ScrollController controller = ScrollController();

    await tester.pumpWidget(buildTest(controller: controller));
    expect(dismissedItems, isEmpty);
    expect(controller.offset, 0.0);

    await dismissItem(tester, 0, gestureDirection: AxisDirection.left);
    expect(controller.offset, 0.0);
    await dismissItem(tester, 0, gestureDirection: AxisDirection.right);
    expect(controller.offset, 0.0);
    await dismissItem(tester, 0, gestureDirection: AxisDirection.down);
    expect(controller.offset, 0.0);
    await dismissItem(tester, 0, gestureDirection: AxisDirection.up);
    expect(controller.offset, 99.9);
  });
902
}