Revert r38549, r38552, and r38557.

dart/pkg/pool/test/pool_test.dart

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 import 'dart:async';
 
-import 'package:fake_async/fake_async.dart';
 import 'package:pool/pool.dart';
 import 'package:stack_trace/stack_trace.dart';
 import 'package:unittest/unittest.dart';
 
 void main() {
   group("request()", () {
     test("resources can be requested freely up to the limit", () {
       var pool = new Pool(50);
       var requests = [];
       for (var i = 0; i < 50; i++) {
         expect(pool.request(), completes);
       }
     });
 
     test("resources block past the limit", () {
-      new FakeAsync().run((async) {
-        var pool = new Pool(50);
-        var requests = [];
-        for (var i = 0; i < 50; i++) {
-          expect(pool.request(), completes);
-        }
-        expect(pool.request(), doesNotComplete);
-
-        async.elapse(new Duration(seconds: 1));
-      });
+      var pool = new Pool(50);
+      var requests = [];
+      for (var i = 0; i < 50; i++) {
+        expect(pool.request(), completes);
+      }
+      expect(pool.request(), doesNotComplete);
     });
 
     test("a blocked resource is allocated when another is released", () {
-      new FakeAsync().run((async) {
-        var pool = new Pool(50);
-        var requests = [];
-        for (var i = 0; i < 49; i++) {
-          expect(pool.request(), completes);
-        }
+      var pool = new Pool(50);
+      var requests = [];
+      for (var i = 0; i < 49; i++) {
+        expect(pool.request(), completes);
+      }
 
-        pool.request().then((lastAllocatedResource) {
-          // This will only complete once [lastAllocatedResource] is released.
-          expect(pool.request(), completes);
+      return pool.request().then((lastAllocatedResource) {
+        var blockedResource = pool.request();
 
-          new Future.delayed(new Duration(microseconds: 1)).then((_) {
-            lastAllocatedResource.release();
-          });
+        return pumpEventQueue().then((_) {
+          lastAllocatedResource.release();
+          return pumpEventQueue();
+        }).then((_) {
+          expect(blockedResource, completes);
         });
-
-        async.elapse(new Duration(seconds: 1));
       });
     });
   });
 
   group("withResource()", () {
     test("can be called freely up to the limit", () {
       var pool = new Pool(50);
       var requests = [];
       for (var i = 0; i < 50; i++) {
         pool.withResource(expectAsync(() => new Completer().future));
       }
     });
 
     test("blocks the callback past the limit", () {
-      new FakeAsync().run((async) {
-        var pool = new Pool(50);
-        var requests = [];
-        for (var i = 0; i < 50; i++) {
-          pool.withResource(expectAsync(() => new Completer().future));
-        }
-        pool.withResource(expectNoAsync());
-
-        async.elapse(new Duration(seconds: 1));
-      });
+      var pool = new Pool(50);
+      var requests = [];
+      for (var i = 0; i < 50; i++) {
+        pool.withResource(expectAsync(() => new Completer().future));
+      }
+      pool.withResource(expectNoAsync());
     });
 
     test("a blocked resource is allocated when another is released", () {
-      new FakeAsync().run((async) {
-        var pool = new Pool(50);
-        var requests = [];
-        for (var i = 0; i < 49; i++) {
-          pool.withResource(expectAsync(() => new Completer().future));
-        }
+      var pool = new Pool(50);
+      var requests = [];
+      for (var i = 0; i < 49; i++) {
+        pool.withResource(expectAsync(() => new Completer().future));
+      }
 
-        var completer = new Completer();
-        var lastAllocatedResource = pool.withResource(() => completer.future);
-        var blockedResourceAllocated = false;
-        var blockedResource = pool.withResource(() {
-          blockedResourceAllocated = true;
-        });
+      var completer = new Completer();
+      var lastAllocatedResource = pool.withResource(() => completer.future);
+      var blockedResourceAllocated = false;
+      var blockedResource = pool.withResource(() {
+        blockedResourceAllocated = true;
+      });
 
-        new Future.delayed(new Duration(microseconds: 1)).then((_) {
-          expect(blockedResourceAllocated, isFalse);
-          completer.complete();
-          return new Future.delayed(new Duration(microseconds: 1));
-        }).then((_) {
-          expect(blockedResourceAllocated, isTrue);
-        });
-
-        async.elapse(new Duration(seconds: 1));
+      return pumpEventQueue().then((_) {
+        expect(blockedResourceAllocated, isFalse);
+        completer.complete();
+        return pumpEventQueue();
+      }).then((_) {
+        expect(blockedResourceAllocated, isTrue);
       });
     });
   });
 
-  group("with a timeout", () {
-    test("doesn't time out if there are no pending requests", () {
-      new FakeAsync().run((async) {
-        var pool = new Pool(50, timeout: new Duration(seconds: 5));
-        for (var i = 0; i < 50; i++) {
-          expect(pool.request(), completes);
-        }
+  // TODO(nweiz): Test timeouts when it's easier to use third-party packages.
+  // See r38552.
+}
 
-        async.elapse(new Duration(seconds: 6));
-      });
-    });
-
-    test("resets the timer if a resource is returned", () {
-      new FakeAsync().run((async) {
-        var pool = new Pool(50, timeout: new Duration(seconds: 5));
-        for (var i = 0; i < 49; i++) {
-          expect(pool.request(), completes);
-        }
-
-        pool.request().then((lastAllocatedResource) {
-          // This will only complete once [lastAllocatedResource] is released.
-          expect(pool.request(), completes);
-
-          new Future.delayed(new Duration(seconds: 3)).then((_) {
-            lastAllocatedResource.release();
-            expect(pool.request(), doesNotComplete);
-          });
-        });
-
-        async.elapse(new Duration(seconds: 6));
-      });
-    });
-
-    test("resets the timer if a resource is requested", () {
-      new FakeAsync().run((async) {
-        var pool = new Pool(50, timeout: new Duration(seconds: 5));
-        for (var i = 0; i < 50; i++) {
-          expect(pool.request(), completes);
-        }
-        expect(pool.request(), doesNotComplete);
-
-        new Future.delayed(new Duration(seconds: 3)).then((_) {
-          expect(pool.request(), doesNotComplete);
-        });
-
-        async.elapse(new Duration(seconds: 6));
-      });
-    });    
-
-    test("times out if nothing happens", () {
-      new FakeAsync().run((async) {
-        var pool = new Pool(50, timeout: new Duration(seconds: 5));
-        for (var i = 0; i < 50; i++) {
-          expect(pool.request(), completes);
-        }
-        expect(pool.request(), throwsA(new isInstanceOf<TimeoutException>()));
-
-        async.elapse(new Duration(seconds: 6));
-      });
-    });    
-  });
+/// Returns a [Future] that completes after pumping the event queue [times]
+/// times. By default, this should pump the event queue enough times to allow
+/// any code to run, as long as it's not waiting on some external event.
+Future pumpEventQueue([int times = 20]) {
+  if (times == 0) return new Future.value();
+  // We use a delayed future to allow microtask events to finish. The
+  // Future.value or Future() constructors use scheduleMicrotask themselves and
+  // would therefore not wait for microtask callbacks that are scheduled after
+  // invoking this method.
+  return new Future.delayed(Duration.ZERO, () => pumpEventQueue(times - 1));
 }
 
 /// Returns a function that will cause the test to fail if it's called.
 ///
-/// This should only be called within a [FakeAsync.run] zone.
+/// This won't let the test complete until it's confident that the function
+/// won't be called.
 Function expectNoAsync() {
+  // Make sure the test lasts long enough for the function to get called if it's
+  // going to get called.
+  expect(pumpEventQueue(), completes);
+
   var stack = new Trace.current(1);
   return () => handleExternalError(
       new TestFailure("Expected function not to be called."), "",
       stack);
 }
 
 /// A matcher for Futures that asserts that they don't complete.
 ///
-/// This should only be called within a [FakeAsync.run] zone.
+/// This won't let the test complete until it's confident that the function
+/// won't be called.
 Matcher get doesNotComplete => predicate((future) {
   expect(future, new isInstanceOf<Future>('Future'));
+  // Make sure the test lasts long enough for the function to get called if it's
+  // going to get called.
+  expect(pumpEventQueue(), completes);
 
   var stack = new Trace.current(1);
   future.then((_) => handleExternalError(
       new TestFailure("Expected future not to complete."), "",
       stack));
   return true;
 });