Update charted to 0.4.8 and roll

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 78 matching lines @@
           expect(blockedResourceAllocated, isFalse);
           completer.complete();
           return new Future.delayed(new Duration(microseconds: 1));
         }).then((_) {
           expect(blockedResourceAllocated, isTrue);
         });
 
         async.elapse(new Duration(seconds: 1));
       });
     });
+
+    // Regression test for #3.
+    test("can be called immediately before close()", () async {
+      var pool = new Pool(1);
+      pool.withResource(expectAsync(() {}));
+      await pool.close();
+    });
   });
 
   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);
         }
 
@@ skipping 156 matching lines @@
 
         resource.allowRelease(expectAsync(() {
           expect(Zone.current, equals(innerZone));
         }));
       });
 
       pool.request();
     });
   });
 
+  test("done doesn't complete without close", () async {
+    var pool = new Pool(1);
+    pool.done.then(expectAsync1((_) {}, count: 0));
+
+    var resource = await pool.request();
+    resource.release();
+
+    await new Future.delayed(Duration.ZERO);
+  });
+
   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.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) {
@@ skipping 93 matching lines @@
       completer.complete();
     });
 
     test("an onRelease error is piped to the return value", () async {
       var pool = new Pool(1);
       var resource = await pool.request();
 
       var completer = new Completer();
       resource.allowRelease(() => completer.future);
 
+      expect(pool.done, throwsA("oh no!"));
       expect(pool.close(), throwsA("oh no!"));
 
       await new Future.delayed(Duration.ZERO);
       completer.completeError("oh no!");
     });
   });
 }
 
 /// Returns a function that will cause the test to fail if it's called.
 ///
 /// This should only be called within a [FakeAsync.run] zone.
 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>());
 
   var stack = new Trace.current(1);
   future.then((_) => registerException(
       new TestFailure("Expected future not to complete."), stack));
   return true;
 });