Use fake_async over waiting for timers with delays (#166)

On the web the timers may have some variance.
Replace all usages of `waitForTimer` utility to use `fakeAsync`.
Separate out the call to `Stream.listen` from `setUp` so it
happens in the fake async zone.

Author: natebosch

pubspec.yaml

@@ -8,5 +8,6 @@ environment:
 
 dev_dependencies:
   async: ^2.5.0
+  fake_async: ^1.3.0
   lints: ^2.0.0
   test: ^1.16.0

test/audit_test.dart

@@ -4,6 +4,7 @@
 
 import 'dart:async';
 
+import 'package:fake_async/fake_async.dart';
 import 'package:stream_transform/stream_transform.dart';
 import 'package:test/test.dart';
 
@@ -21,7 +22,7 @@ void main() {
       late StreamSubscription<int> subscription;
 
       group('audit', () {
-        setUp(() async {
+        setUp(() {
           valuesCanceled = false;
           values = createController(streamType)
             ..onCancel = () {
@@ -31,73 +32,106 @@ void main() {
           errors = [];
           isDone = false;
           transformed = values.stream.audit(const Duration(milliseconds: 6));
+        });
+
+        void listen() {
           subscription = transformed
               .listen(emittedValues.add, onError: errors.add, onDone: () {
             isDone = true;
           });
-        });
+        }
 
         test('cancels values', () async {
+          listen();
           await subscription.cancel();
           expect(valuesCanceled, true);
         });
 
-        test('swallows values that come faster than duration', () async {
-          values
-            ..add(1)
-            ..add(2);
-          await values.close();
-          await waitForTimer(5);
-          expect(emittedValues, [2]);
+        test('swallows values that come faster than duration', () {
+          fakeAsync((async) {
+            listen();
+            values
+              ..add(1)
+              ..add(2)
+              ..close();
+            async.elapse(const Duration(milliseconds: 6));
+            expect(emittedValues, [2]);
+          });
         });
 
-        test('outputs multiple values spaced further than duration', () async {
-          values.add(1);
-          await waitForTimer(5);
-          values.add(2);
-          await waitForTimer(5);
-          expect(emittedValues, [1, 2]);
+        test('outputs multiple values spaced further than duration', () {
+          fakeAsync((async) {
+            listen();
+            values.add(1);
+            async.elapse(const Duration(milliseconds: 6));
+            values.add(2);
+            async.elapse(const Duration(milliseconds: 6));
+            expect(emittedValues, [1, 2]);
+          });
         });
 
-        test('waits for pending value to close', () async {
-          values.add(1);
-          await values.close();
-          expect(isDone, false);
-          await waitForTimer(5);
-          expect(isDone, true);
+        test('waits for pending value to close', () {
+          fakeAsync((async) {
+            listen();
+            values
+              ..add(1)
+              ..close();
+            expect(isDone, false);
+            async.elapse(const Duration(milliseconds: 6));
+            expect(isDone, true);
+          });
         });
 
-        test('closes output if there are no pending values', () async {
-          values.add(1);
-          await waitForTimer(5);
-          values.add(2);
-          await values.close();
-          expect(isDone, false);
-          await waitForTimer(5);
-          expect(isDone, true);
+        test('closes output if there are no pending values', () {
+          fakeAsync((async) {
+            listen();
+            values.add(1);
+            async.elapse(const Duration(milliseconds: 6));
+            values
+              ..add(2)
+              ..close();
+            expect(isDone, false);
+            expect(emittedValues, [1]);
+            async.elapse(const Duration(milliseconds: 6));
+            expect(isDone, true);
+            expect(emittedValues, [1, 2]);
+          });
         });
 
         test('does not starve output if many values come closer than duration',
-            () async {
-          values.add(1);
-          await Future.delayed(const Duration(milliseconds: 4));
-          values.add(2);
-          await Future.delayed(const Duration(milliseconds: 4));
-          values.add(3);
-          await waitForTimer(6);
-          expect(emittedValues, [2, 3]);
+            () {
+          fakeAsync((async) {
+            listen();
+            values.add(1);
+            async.elapse(const Duration(milliseconds: 3));
+            values.add(2);
+            async.elapse(const Duration(milliseconds: 3));
+            values.add(3);
+            async.elapse(const Duration(milliseconds: 6));
+            expect(emittedValues, [2, 3]);
+          });
         });
 
         if (streamType == 'broadcast') {
-          test('multiple listeners all get values', () async {
-            var otherValues = [];
-            transformed.listen(otherValues.add);
-            values
-              ..add(1)
-              ..add(2);
-            await waitForTimer(5);
-            expect(emittedValues, [2]);
-            expect(otherValues, [2]);
+          test('multiple listeners all get the values', () {
+            fakeAsync((async) {
+              listen();
+              values.add(1);
+              async.elapse(const Duration(milliseconds: 3));
+              values.add(2);
+              var otherValues = [];
+              transformed.listen(otherValues.add);
+              values.add(3);
+              async.elapse(const Duration(milliseconds: 3));
+              values.add(4);
+              async.elapse(const Duration(milliseconds: 3));
+              values
+                ..add(5)
+                ..close();
+              async.elapse(const Duration(milliseconds: 6));
+              expect(emittedValues, [3, 5]);
+              expect(otherValues, [3, 5]);
+            });
           });
         }
       });