Add FutureGroup.onIdle and FutureGroup.isIdle.

test/future_group_test.dart

Index: test/future_group_test.dart
diff --git a/test/future_group_test.dart b/test/future_group_test.dart
index f53508059209dd8f970a4fdb0e9b454089204991..09ea29a0abd0a364fce633b92c92c9d6dc5835de 100644
--- a/test/future_group_test.dart
+++ b/test/future_group_test.dart
@@ -7,6 +7,8 @@ import 'dart:async';
 import 'package:async/src/future_group.dart';
 import 'package:test/test.dart';
 
+import 'utils.dart';
+
 void main() {
   var futureGroup;
   setUp(() {
@@ -18,7 +20,7 @@ void main() {
       var completed = false;
       futureGroup.future.then((_) => completed = true);
 
-      await new Future.delayed(Duration.ZERO);
+      await flushMicrotasks();
       expect(completed, isFalse);
     });
 
@@ -31,18 +33,18 @@ void main() {
   group("with a future that already completed", () {
     test("never completes if nothing happens", () async {
       futureGroup.add(new Future.value());
-      await new Future.delayed(Duration.ZERO);
+      await flushMicrotasks();
 
       var completed = false;
       futureGroup.future.then((_) => completed = true);
 
-      await new Future.delayed(Duration.ZERO);
+      await flushMicrotasks();
       expect(completed, isFalse);
     });
 
     test("completes once it's closed", () async {
       futureGroup.add(new Future.value());
-      await new Future.delayed(Duration.ZERO);
+      await flushMicrotasks();
 
       expect(futureGroup.future, completes);
       futureGroup.close();
@@ -61,7 +63,6 @@ void main() {
   });
 
   test("completes once all contained futures complete", () async {
-    var futureGroup = new FutureGroup();
     var completer1 = new Completer();
     var completer2 = new Completer();
     var completer3 = new Completer();
@@ -75,20 +76,19 @@ void main() {
     futureGroup.future.then((_) => completed = true);
 
     completer1.complete();
-    await new Future.delayed(Duration.ZERO);
+    await flushMicrotasks();
     expect(completed, isFalse);
 
     completer2.complete();
-    await new Future.delayed(Duration.ZERO);
+    await flushMicrotasks();
     expect(completed, isFalse);
 
     completer3.complete();
-    await new Future.delayed(Duration.ZERO);
+    await flushMicrotasks();
     expect(completed, isTrue);
   });
 
   test("completes to the values of the futures in order of addition", () {
-    var futureGroup = new FutureGroup();
     var completer1 = new Completer();
     var completer2 = new Completer();
     var completer3 = new Completer();
@@ -108,7 +108,6 @@ void main() {
 
   test("completes to the first error to be emitted, even if it's not closed",
       () {
-    var futureGroup = new FutureGroup();
     var completer1 = new Completer();
     var completer2 = new Completer();
     var completer3 = new Completer();
@@ -121,4 +120,101 @@ void main() {
     completer1.completeError("error 1");
     expect(futureGroup.future, throwsA("error 2"));
   });
+
+  group("onIdle:", () {
+    test("emits an event when the last pending future completes", () async {
+      var idle = false;
+      futureGroup.onIdle.listen((_) => idle = true);
+
+      var completer1 = new Completer();
+      var completer2 = new Completer();
+      var completer3 = new Completer();
+
+      futureGroup.add(completer1.future);
+      futureGroup.add(completer2.future);
+      futureGroup.add(completer3.future);
+
+      await flushMicrotasks();
+      expect(idle, isFalse);
+      expect(futureGroup.isIdle, isFalse);
+
+      completer1.complete();
+      await flushMicrotasks();
+      expect(idle, isFalse);
+      expect(futureGroup.isIdle, isFalse);
+
+      completer2.complete();
+      await flushMicrotasks();
+      expect(idle, isFalse);
+      expect(futureGroup.isIdle, isFalse);
+
+      completer3.complete();
+      await flushMicrotasks();
+      expect(idle, isTrue);
+      expect(futureGroup.isIdle, isTrue);
+    });
+
+    test("emits an event each time it becomes idle", () async {
+      var idle = false;
+      futureGroup.onIdle.listen((_) => idle = true);
+
+      var completer = new Completer();
+      futureGroup.add(completer.future);
+
+      completer.complete();
+      await flushMicrotasks();
+      expect(idle, isTrue);
+      expect(futureGroup.isIdle, isTrue);
+
+      idle = false;
+      completer = new Completer();
+      futureGroup.add(completer.future);
+
+      await flushMicrotasks();
+      expect(idle, isFalse);
+      expect(futureGroup.isIdle, isFalse);
+
+      completer.complete();
+      await flushMicrotasks();
+      expect(idle, isTrue);
+      expect(futureGroup.isIdle, isTrue);
+    });
+
+    test("emits an event when the group closes", () async {
+      // It's important that the order of events here stays consistent over
+      // time, since code may rely on it in subtle ways.
+      var idle = false;
+      var onIdleDone = false;
+      var futureFired = false;
+
+      futureGroup.onIdle.listen(expectAsync((_) {
+        expect(futureFired, isFalse);
+        idle = true;
+      }), onDone: expectAsync(() {
+        expect(idle, isTrue);
+        expect(futureFired, isFalse);
+        onIdleDone = true;
+      }));
+
+      futureGroup.future.then(expectAsync((_) {
+        expect(idle, isTrue);
+        expect(onIdleDone, isTrue);
+        futureFired = true;
+      }));
+
+      var completer = new Completer();
+      futureGroup.add(completer.future);
+      futureGroup.close();
+
+      await flushMicrotasks();
+      expect(idle, isFalse);
+      expect(futureGroup.isIdle, isFalse);
+
+      completer.complete();
+      await flushMicrotasks();
+      expect(idle, isTrue);
+      expect(futureGroup.isIdle, isTrue);
+      expect(futureFired, isTrue);
+    });
+  });
 }