Roll to pickup pool changes

packages/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:test/test.dart';
@@ skipping 281 matching lines @@
   group("close()", () {
     test("disallows request() and withResource()", () {
       var pool = new Pool(1)..close();
       expect(pool.request, throwsStateError);
       expect(() => pool.withResource(() {}), throwsStateError);
     });
 
     test("pending requests are fulfilled", () async {
       var pool = new Pool(1);
       var resource1 = await pool.request();
-      expect(pool.request().then((resource2) {
-        resource2.release();
-      }), completes);
+      expect(
+          pool.request().then((resource2) {
+            resource2.release();
+          }),
+          completes);
       expect(pool.done, completes);
       expect(pool.close(), completes);
       resource1.release();
     });
 
     test("pending requests are fulfilled with allowRelease", () async {
       var pool = new Pool(1);
       var resource1 = await pool.request();
 
       var completer = new Completer();
-      expect(pool.request().then((resource2) {
-        expect(completer.isCompleted, isTrue);
-        resource2.release();
-      }), completes);
+      expect(
+          pool.request().then((resource2) {
+            expect(completer.isCompleted, isTrue);
+            resource2.release();
+          }),
+          completes);
       expect(pool.close(), completes);
 
       resource1.allowRelease(() => completer.future);
       await new Future.delayed(Duration.ZERO);
 
       completer.complete();
     });
 
     test("doesn't complete until all resources are released", () async {
       var pool = new Pool(2);
       var resource1 = await pool.request();
       var resource2 = await pool.request();
       var resource3Future = pool.request();
 
       var resource1Released = false;
       var resource2Released = false;
       var resource3Released = false;
-      expect(pool.close().then((_) {
-        expect(resource1Released, isTrue);
-        expect(resource2Released, isTrue);
-        expect(resource3Released, isTrue);
-      }), completes);
+      expect(
+          pool.close().then((_) {
+            expect(resource1Released, isTrue);
+            expect(resource2Released, isTrue);
+            expect(resource3Released, isTrue);
+          }),
+          completes);
 
       resource1Released = true;
       resource1.release();
       await new Future.delayed(Duration.ZERO);
 
       resource2Released = true;
       resource2.release();
       await new Future.delayed(Duration.ZERO);
 
       var resource3 = await resource3Future;
       resource3Released = true;
       resource3.release();
     });
 
     test("active onReleases complete as usual", () async {
       var pool = new Pool(1);
       var resource = await pool.request();
 
       // Set up an onRelease callback whose completion is controlled by
       // [completer].
       var completer = new Completer();
       resource.allowRelease(() => completer.future);
-      expect(pool.request().then((_) {
-        expect(completer.isCompleted, isTrue);
-      }), completes);
+      expect(
+          pool.request().then((_) {
+            expect(completer.isCompleted, isTrue);
+          }),
+          completes);
 
       await new Future.delayed(Duration.ZERO);
       pool.close();
 
       await new Future.delayed(Duration.ZERO);
       completer.complete();
     });
 
     test("inactive onReleases fire", () async {
       var pool = new Pool(2);
       var resource1 = await pool.request();
       var resource2 = await pool.request();
 
       var completer1 = new Completer();
       resource1.allowRelease(() => completer1.future);
       var completer2 = new Completer();
       resource2.allowRelease(() => completer2.future);
 
-      expect(pool.close().then((_) {
-        expect(completer1.isCompleted, isTrue);
-        expect(completer2.isCompleted, isTrue);
-      }), completes);
+      expect(
+          pool.close().then((_) {
+            expect(completer1.isCompleted, isTrue);
+            expect(completer2.isCompleted, isTrue);
+          }),
+          completes);
 
       await new Future.delayed(Duration.ZERO);
       completer1.complete();
 
       await new Future.delayed(Duration.ZERO);
       completer2.complete();
     });
 
     test("new allowReleases fire immediately", () async {
       var pool = new Pool(1);
       var resource = await pool.request();
 
       var completer = new Completer();
-      expect(pool.close().then((_) {
-        expect(completer.isCompleted, isTrue);
-      }), completes);
+      expect(
+          pool.close().then((_) {
+            expect(completer.isCompleted, isTrue);
+          }),
+          completes);
 
       await new Future.delayed(Duration.ZERO);
       resource.allowRelease(() => completer.future);
 
       await new Future.delayed(Duration.ZERO);
       completer.complete();
     });
 
     test("an onRelease error is piped to the return value", () async {
       var pool = new Pool(1);
@@ skipping 17 matching lines @@
 Function expectNoAsync() {
   var stack = new Trace.current(1);
   return () => registerException(
       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.
 Matcher get doesNotComplete => predicate((future) {
-  expect(future, new isInstanceOf<Future>());
+      expect(future, new isInstanceOf<Future>());
 
-  var stack = new Trace.current(1);
-  future.then((_) => registerException(
-      new TestFailure("Expected future not to complete."), stack));
-  return true;
-});
+      var stack = new Trace.current(1);
+      future.then((_) => registerException(
+          new TestFailure("Expected future not to complete."), stack));
+      return true;
+    });