Add more Gesture Arena tests

...and clean them up so it's easier to understand them.

packages/unit/test/gestures/arena_test.dart

@@ -3,239 +3,161 @@ import 'package:test/test.dart';
 
 typedef void GestureArenaCallback(Object key);
 
-class TestGestureArenaMember extends GestureArenaMember {
-  TestGestureArenaMember({ this.onAcceptGesture, this.onRejectGesture });
-
-  final GestureArenaCallback onAcceptGesture;
-  final GestureArenaCallback onRejectGesture;
+const int primaryKey = 4;
 
+class TestGestureArenaMember extends GestureArenaMember {
+  bool acceptRan = false;
   void acceptGesture(Object key) {
-    onAcceptGesture(key);
+    expect(key, equals(primaryKey));
+    acceptRan = true;
   }
-
+  bool rejectRan = false;
   void rejectGesture(Object key) {
-    onRejectGesture(key);
+    expect(key, equals(primaryKey));
+    rejectRan = true;
   }
 }
 
-void main() {
-  test('Should win by accepting', () {
+class GestureTester {
   GestureArena arena = new GestureArena();
+  TestGestureArenaMember first = new TestGestureArenaMember();
+  TestGestureArenaMember second = new TestGestureArenaMember();
 
-    int primaryKey = 4;
-    bool firstAcceptRan = false;
-    bool firstRejectRan = false;
-    bool secondAcceptRan = false;
-    bool secondRejectRan = false;
-
-    TestGestureArenaMember first = new TestGestureArenaMember(
-      onAcceptGesture: (int key) {
-        expect(key, equals(primaryKey));
-        firstAcceptRan = true;
-      },
-      onRejectGesture: (int key) {
-        expect(key, equals(primaryKey));
-        firstRejectRan = true;
+  GestureArenaEntry firstEntry;
+  void addFirst() {
+    firstEntry = arena.add(primaryKey, first);
   }
-    );
 
-    TestGestureArenaMember second = new TestGestureArenaMember(
-      onAcceptGesture: (int key) {
-        expect(key, equals(primaryKey));
-        secondAcceptRan = true;
-      },
-      onRejectGesture: (int key) {
-        expect(key, equals(primaryKey));
-        secondRejectRan = true;
+  GestureArenaEntry secondEntry;
+  void addSecond() {
+    secondEntry = arena.add(primaryKey, second);
   }
-    );
-
-    GestureArenaEntry firstEntry = arena.add(primaryKey, first);
-    arena.add(primaryKey, second);
-    arena.close(primaryKey);
-
-    expect(firstAcceptRan, isFalse);
-    expect(firstRejectRan, isFalse);
-    expect(secondAcceptRan, isFalse);
-    expect(secondRejectRan, isFalse);
-
-    firstEntry.resolve(GestureDisposition.accepted);
-
-    expect(firstAcceptRan, isTrue);
-    expect(firstRejectRan, isFalse);
-    expect(secondAcceptRan, isFalse);
-    expect(secondRejectRan, isTrue);
-  });
 
-  test('Should win by sweep', () {
-    GestureArena arena = new GestureArena();
-
-    int primaryKey = 4;
-    bool firstAcceptRan = false;
-    bool firstRejectRan = false;
-    bool secondAcceptRan = false;
-    bool secondRejectRan = false;
-
-    TestGestureArenaMember first = new TestGestureArenaMember(
-      onAcceptGesture: (int key) {
-        expect(key, equals(primaryKey));
-        firstAcceptRan = true;
-      },
-      onRejectGesture: (int key) {
-        expect(key, equals(primaryKey));
-        firstRejectRan = true;
+  void expectNothing() {
+    expect(first.acceptRan, isFalse);
+    expect(first.rejectRan, isFalse);
+    expect(second.acceptRan, isFalse);
+    expect(second.rejectRan, isFalse);
   }
-    );
 
-    TestGestureArenaMember second = new TestGestureArenaMember(
-      onAcceptGesture: (int key) {
-        expect(key, equals(primaryKey));
-        secondAcceptRan = true;
-      },
-      onRejectGesture: (int key) {
-        expect(key, equals(primaryKey));
-        secondRejectRan = true;
+  void expectFirstWin() {
+    expect(first.acceptRan, isTrue);
+    expect(first.rejectRan, isFalse);
+    expect(second.acceptRan, isFalse);
+    expect(second.rejectRan, isTrue);
   }
-    );
-
-    arena.add(primaryKey, first);
-    arena.add(primaryKey, second);
-    arena.close(primaryKey);
 
-    expect(firstAcceptRan, isFalse);
-    expect(firstRejectRan, isFalse);
-    expect(secondAcceptRan, isFalse);
-    expect(secondRejectRan, isFalse);
+  void expectSecondWin() {
+    expect(first.acceptRan, isFalse);
+    expect(first.rejectRan, isTrue);
+    expect(second.acceptRan, isTrue);
+    expect(second.rejectRan, isFalse);
+  }
+}
 
-    arena.sweep(primaryKey);
+void main() {
+  test('Should win by accepting', () {
+    GestureTester tester = new GestureTester();
+    tester.addFirst();
+    tester.addSecond();
+    tester.arena.close(primaryKey);
+    tester.expectNothing();
+    tester.firstEntry.resolve(GestureDisposition.accepted);
+    tester.expectFirstWin();
+  });
 
-    expect(firstAcceptRan, isTrue);
-    expect(firstRejectRan, isFalse);
-    expect(secondAcceptRan, isFalse);
-    expect(secondRejectRan, isTrue);
+  test('Should win by sweep', () {
+    GestureTester tester = new GestureTester();
+    tester.addFirst();
+    tester.addSecond();
+    tester.arena.close(primaryKey);
+    tester.expectNothing();
+    tester.arena.sweep(primaryKey);
+    tester.expectFirstWin();
   });
 
   test('Should win on release after hold sweep release', () {
-    GestureArena arena = new GestureArena();
-
-    int primaryKey = 4;
-    bool firstAcceptRan = false;
-    bool firstRejectRan = false;
-    bool secondAcceptRan = false;
-    bool secondRejectRan = false;
-
-    TestGestureArenaMember first = new TestGestureArenaMember(
-      onAcceptGesture: (int key) {
-        expect(key, equals(primaryKey));
-        firstAcceptRan = true;
-      },
-      onRejectGesture: (int key) {
-        expect(key, equals(primaryKey));
-        firstRejectRan = true;
-      }
-    );
-
-    TestGestureArenaMember second = new TestGestureArenaMember(
-      onAcceptGesture: (int key) {
-        expect(key, equals(primaryKey));
-        secondAcceptRan = true;
-      },
-      onRejectGesture: (int key) {
-        expect(key, equals(primaryKey));
-        secondRejectRan = true;
-      }
-    );
-
-    arena.add(primaryKey, first);
-    arena.add(primaryKey, second);
-    arena.close(primaryKey);
-
-    expect(firstAcceptRan, isFalse);
-    expect(firstRejectRan, isFalse);
-    expect(secondAcceptRan, isFalse);
-    expect(secondRejectRan, isFalse);
-
-    arena.hold(primaryKey);
-
-    expect(firstAcceptRan, isFalse);
-    expect(firstRejectRan, isFalse);
-    expect(secondAcceptRan, isFalse);
-    expect(secondRejectRan, isFalse);
-
-    arena.sweep(primaryKey);
-
-    expect(firstAcceptRan, isFalse);
-    expect(firstRejectRan, isFalse);
-    expect(secondAcceptRan, isFalse);
-    expect(secondRejectRan, isFalse);
-
-    arena.release(primaryKey);
-
-    expect(firstAcceptRan, isTrue);
-    expect(firstRejectRan, isFalse);
-    expect(secondAcceptRan, isFalse);
-    expect(secondRejectRan, isTrue);
+    GestureTester tester = new GestureTester();
+    tester.addFirst();
+    tester.addSecond();
+    tester.arena.close(primaryKey);
+    tester.expectNothing();
+    tester.arena.hold(primaryKey);
+    tester.expectNothing();
+    tester.arena.sweep(primaryKey);
+    tester.expectNothing();
+    tester.arena.release(primaryKey);
+    tester.expectFirstWin();
   });
 
   test('Should win on sweep after hold release sweep', () {
-    GestureArena arena = new GestureArena();
-
-    int primaryKey = 4;
-    bool firstAcceptRan = false;
-    bool firstRejectRan = false;
-    bool secondAcceptRan = false;
-    bool secondRejectRan = false;
-
-    TestGestureArenaMember first = new TestGestureArenaMember(
-      onAcceptGesture: (int key) {
-        expect(key, equals(primaryKey));
-        firstAcceptRan = true;
-      },
-      onRejectGesture: (int key) {
-        expect(key, equals(primaryKey));
-        firstRejectRan = true;
-      }
-    );
-
-    TestGestureArenaMember second = new TestGestureArenaMember(
-      onAcceptGesture: (int key) {
-        expect(key, equals(primaryKey));
-        secondAcceptRan = true;
-      },
-      onRejectGesture: (int key) {
-        expect(key, equals(primaryKey));
-        secondRejectRan = true;
-      }
-    );
-
-    arena.add(primaryKey, first);
-    arena.add(primaryKey, second);
-    arena.close(primaryKey);
-
-    expect(firstAcceptRan, isFalse);
-    expect(firstRejectRan, isFalse);
-    expect(secondAcceptRan, isFalse);
-    expect(secondRejectRan, isFalse);
-
-    arena.hold(primaryKey);
+    GestureTester tester = new GestureTester();
+    tester.addFirst();
+    tester.addSecond();
+    tester.arena.close(primaryKey);
+    tester.expectNothing();
+    tester.arena.hold(primaryKey);
+    tester.expectNothing();
+    tester.arena.release(primaryKey);
+    tester.expectNothing();
+    tester.arena.sweep(primaryKey);
+    tester.expectFirstWin();
+  });
 
-    expect(firstAcceptRan, isFalse);
-    expect(firstRejectRan, isFalse);
-    expect(secondAcceptRan, isFalse);
-    expect(secondRejectRan, isFalse);
+  test('Only first winner should win', () {
+    GestureTester tester = new GestureTester();
+    tester.addFirst();
+    tester.addSecond();
+    tester.arena.close(primaryKey);
+    tester.expectNothing();
+    tester.firstEntry.resolve(GestureDisposition.accepted);
+    tester.secondEntry.resolve(GestureDisposition.accepted);
+    tester.expectFirstWin();
+  });
 
-    arena.release(primaryKey);
+  test('Only first winner should win, regardless of order', () {
+    GestureTester tester = new GestureTester();
+    tester.addFirst();
+    tester.addSecond();
+    tester.arena.close(primaryKey);
+    tester.expectNothing();
+    tester.secondEntry.resolve(GestureDisposition.accepted);
+    tester.firstEntry.resolve(GestureDisposition.accepted);
+    tester.expectSecondWin();
+  });
 
-    expect(firstAcceptRan, isFalse);
-    expect(firstRejectRan, isFalse);
-    expect(secondAcceptRan, isFalse);
-    expect(secondRejectRan, isFalse);
+  test('Win before close is delayed to close', () {
+    GestureTester tester = new GestureTester();
+    tester.addFirst();
+    tester.addSecond();
+    tester.expectNothing();
+    tester.firstEntry.resolve(GestureDisposition.accepted);
+    tester.expectNothing();
+    tester.arena.close(primaryKey);
+    tester.expectFirstWin();
+  });
 
-    arena.sweep(primaryKey);
+  test('Win before close is delayed to close, and only first winner should win', () {
+    GestureTester tester = new GestureTester();
+    tester.addFirst();
+    tester.addSecond();
+    tester.expectNothing();
+    tester.firstEntry.resolve(GestureDisposition.accepted);
+    tester.secondEntry.resolve(GestureDisposition.accepted);
+    tester.expectNothing();
+    tester.arena.close(primaryKey);
+    tester.expectFirstWin();
+  });
 
-    expect(firstAcceptRan, isTrue);
-    expect(firstRejectRan, isFalse);
-    expect(secondAcceptRan, isFalse);
-    expect(secondRejectRan, isTrue);
+  test('Win before close is delayed to close, and only first winner should win, regardless of order', () {
+    GestureTester tester = new GestureTester();
+    tester.addFirst();
+    tester.addSecond();
+    tester.expectNothing();
+    tester.secondEntry.resolve(GestureDisposition.accepted);
+    tester.firstEntry.resolve(GestureDisposition.accepted);
+    tester.expectNothing();
+    tester.arena.close(primaryKey);
+    tester.expectSecondWin();
   });
 }