Update charted to 0.4.8 and roll

packages/quiver/test/testing/async/fake_async_test.dart

 // Copyright 2014 Google Inc. All Rights Reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //     http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
@@ skipping 154 matching lines @@
 
         test('should process microtasks surrounding each timer', () {
           new FakeAsync().run((async) {
             var microtaskCalls = 0;
             var timerCalls = 0;
             scheduleMicrotasks() {
               for (int i = 0; i < 5; i++) {
                 scheduleMicrotask(() => microtaskCalls++);
               }
             }
+
             scheduleMicrotasks();
             new Timer.periodic(elapseBy ~/ 5, (_) {
               timerCalls++;
               expect(microtaskCalls, 5 * timerCalls);
               scheduleMicrotasks();
             });
             async.elapse(elapseBy);
             expect(timerCalls, 5);
             expect(microtaskCalls, 5 * (timerCalls + 1));
           });
@@ skipping 16 matching lines @@
             scheduleMicrotask(() {
               calledAt = async.getClock(initialTime).now();
             });
             async.elapse(const Duration(minutes: 1));
             expect(calledAt, initialTime);
           });
         });
 
         test('should add event before advancing time', () {
           return new Future(() => new FakeAsync().run((async) {
-            var controller = new StreamController();
-            var ret = controller.stream.first.then((_) {
-              expect(async.getClock(initialTime).now(), initialTime);
-            });
-            controller.add(null);
-            async.elapse(const Duration(minutes: 1));
-            return ret;
-          }));
+                var controller = new StreamController();
+                var ret = controller.stream.first.then((_) {
+                  expect(async.getClock(initialTime).now(), initialTime);
+                });
+                controller.add(null);
+                async.elapse(const Duration(minutes: 1));
+                return ret;
+              }));
         });
 
         test('should increase negative duration timers to zero duration', () {
           new FakeAsync().run((async) {
             var negativeDuration = const Duration(days: -1);
             DateTime calledAt;
             new Timer(negativeDuration, () {
               calledAt = async.getClock(initialTime).now();
             });
             async.elapse(const Duration(minutes: 1));
@@ skipping 50 matching lines @@
             int result;
             new Future.delayed(elapseBy, () => result = 5);
             async.elapse(elapseBy);
             expect(result, 5);
           });
         });
 
         test('should work with Future.timeout', () {
           new FakeAsync().run((async) {
             var completer = new Completer();
-            var timed = completer.future.timeout(elapseBy ~/ 2);
-            expect(timed, throwsA(new isInstanceOf<TimeoutException>()));
+            TimeoutException timeout;
+            completer.future.timeout(elapseBy ~/ 2).catchError((err) {
+              timeout = err;
+            });
             async.elapse(elapseBy);
+            expect(timeout, new isInstanceOf<TimeoutException>());
             completer.complete();
           });
         });
 
         // TODO: Pausing and resuming the timeout Stream doesn't work since
         // it uses `new Stopwatch()`.
         //
         // See https://code.google.com/p/dart/issues/detail?id=18149
         test('should work with Stream.periodic', () {
           new FakeAsync().run((async) {
             var events = <int>[];
             StreamSubscription subscription;
             var periodic =
                 new Stream.periodic(const Duration(minutes: 1), (i) => i);
-            subscription = periodic.listen(events.add, cancelOnError: true);
+            subscription = periodic.listen(events.add);
             async.elapse(const Duration(minutes: 3));
+            expect(events, [0, 1, 2]);
             subscription.cancel();
-            expect(events, [0, 1, 2]);
           });
         });
 
         test('should work with Stream.timeout', () {
           new FakeAsync().run((async) {
             var events = <int>[];
             var errors = [];
             var controller = new StreamController();
             var timed = controller.stream.timeout(const Duration(minutes: 2));
-            var subscription = timed.listen(events.add,
-                onError: errors.add, cancelOnError: true);
+            var subscription = timed.listen(events.add, onError: errors.add);
             controller.add(0);
             async.elapse(const Duration(minutes: 1));
             expect(events, [0]);
             async.elapse(const Duration(minutes: 1));
-            subscription.cancel();
             expect(errors, hasLength(1));
             expect(errors.first, new isInstanceOf<TimeoutException>());
-            return controller.close();
+            subscription.cancel();
+            controller.close();
           });
         });
       });
     });
 
     group('flushMicrotasks', () {
       test('should flush a microtask', () {
         new FakeAsync().run((async) {
           bool microtaskRan = false;
           new Future.microtask(() {
@@ skipping 24 matching lines @@
       });
       test('should not run timers', () {
         new FakeAsync().run((async) {
           final log = [];
           new Future.microtask(() {
             log.add(1);
           });
           new Future(() {
             log.add(2);
           });
-          new Timer.periodic(new Duration(seconds: 1), (_) {
+          new Timer.periodic(const Duration(seconds: 1), (_) {
             log.add(2);
           });
           async.flushMicrotasks();
           expect(log, [1]);
         });
       });
     });
 
     group('flushTimers', () {
       test('should flush timers', () {
@@ skipping 11 matching lines @@
           expect(log, hasLength(0), reason: 'should not flush until asked to');
           async.flushTimers(timeout: elapseBy * 2, flushPeriodicTimers: false);
           expect(log, [1, 2, 3]);
           expect(async.getClock(initialTime).now(), initialTime.add(elapseBy));
         });
       });
 
       test('should run collateral periodic timers', () {
         new FakeAsync().run((async) {
           final log = [];
-          new Future.delayed(new Duration(seconds: 2), () {
+          new Future.delayed(const Duration(seconds: 2), () {
             log.add('delayed');
           });
-          new Timer.periodic(new Duration(seconds: 1), (_) {
+          new Timer.periodic(const Duration(seconds: 1), (_) {
             log.add('periodic');
           });
           expect(log, hasLength(0), reason: 'should not flush until asked to');
           async.flushTimers(flushPeriodicTimers: false);
           expect(log, ['periodic', 'periodic', 'delayed']);
         });
       });
 
       test('should timeout', () {
         new FakeAsync().run((async) {
           int count = 0;
           // Schedule 3 timers. All but the last one should fire.
           for (int delay in [30, 60, 90]) {
             new Future.delayed(new Duration(minutes: delay), () {
               count++;
             });
           }
           expect(() => async.flushTimers(flushPeriodicTimers: false),
               throwsStateError);
           expect(count, 2);
         });
       });
 
       test('should timeout a chain of timers', () {
         new FakeAsync().run((async) {
           int count = 0;
           createTimer() {
-            new Future.delayed(new Duration(minutes: 30), () {
+            new Future.delayed(const Duration(minutes: 30), () {
               count++;
               createTimer();
             });
           }
+
           createTimer();
-          expect(() => async.flushTimers(
-                  timeout: new Duration(hours: 2), flushPeriodicTimers: false),
+          expect(
+              () => async.flushTimers(
+                  timeout: const Duration(hours: 2),
+                  flushPeriodicTimers: false),
               throwsStateError);
           expect(count, 4);
         });
       });
 
       test('should timeout periodic timers', () {
         new FakeAsync().run((async) {
           int count = 0;
-          new Timer.periodic(new Duration(minutes: 30), (Timer timer) {
+          new Timer.periodic(const Duration(minutes: 30), (Timer timer) {
             count++;
           });
-          expect(() => async.flushTimers(timeout: new Duration(hours: 1)),
+          expect(() => async.flushTimers(timeout: const Duration(hours: 1)),
               throwsStateError);
           expect(count, 2);
         });
       });
 
       test('should flush periodic timers', () {
         new FakeAsync().run((async) {
           int count = 0;
-          new Timer.periodic(new Duration(minutes: 30), (Timer timer) {
+          new Timer.periodic(const Duration(minutes: 30), (Timer timer) {
             if (count == 3) {
               timer.cancel();
             }
             count++;
           });
-          async.flushTimers(timeout: new Duration(hours: 20));
+          async.flushTimers(timeout: const Duration(hours: 20));
           expect(count, 4);
         });
       });
 
       test('should compute absolute timeout as elapsed + timeout', () {
         new FakeAsync().run((async) {
           final log = [];
           int count = 0;
           createTimer() {
-            new Future.delayed(new Duration(minutes: 30), () {
+            new Future.delayed(const Duration(minutes: 30), () {
               log.add(count);
               count++;
               if (count < 4) {
                 createTimer();
               }
             });
           }
+
           createTimer();
-          async.elapse(new Duration(hours: 1));
-          async.flushTimers(timeout: new Duration(hours: 1));
+          async.elapse(const Duration(hours: 1));
+          async.flushTimers(timeout: const Duration(hours: 1));
           expect(count, 4);
         });
       });
     });
 
     group('stats', () {
       test('should report the number of pending microtasks', () {
         new FakeAsync().run((async) {
           expect(async.microtaskCount, 0);
           scheduleMicrotask(() => null);
           expect(async.microtaskCount, 1);
           scheduleMicrotask(() => null);
           expect(async.microtaskCount, 2);
           async.flushMicrotasks();
           expect(async.microtaskCount, 0);
         });
       });
 
       test('it should report the number of pending periodic timers', () {
         new FakeAsync().run((async) {
           expect(async.periodicTimerCount, 0);
-          Timer timer = new Timer.periodic(new Duration(minutes: 30),
-              (Timer timer) { });
+          Timer timer =
+              new Timer.periodic(const Duration(minutes: 30), (Timer timer) {});
           expect(async.periodicTimerCount, 1);
-          new Timer.periodic(new Duration(minutes: 20), (Timer timer) { });
+          new Timer.periodic(const Duration(minutes: 20), (Timer timer) {});
           expect(async.periodicTimerCount, 2);
-          async.elapse(new Duration(minutes: 20));
+          async.elapse(const Duration(minutes: 20));
           expect(async.periodicTimerCount, 2);
           timer.cancel();
           expect(async.periodicTimerCount, 1);
         });
       });
 
       test('it should report the number of pending non periodic timers', () {
         new FakeAsync().run((async) {
           expect(async.nonPeriodicTimerCount, 0);
-          Timer timer = new Timer(new Duration(minutes: 30), () { });
+          Timer timer = new Timer(const Duration(minutes: 30), () {});
           expect(async.nonPeriodicTimerCount, 1);
-          new Timer(new Duration(minutes: 20), () { });
+          new Timer(const Duration(minutes: 20), () {});
           expect(async.nonPeriodicTimerCount, 2);
-          async.elapse(new Duration(minutes: 25));
+          async.elapse(const Duration(minutes: 25));
           expect(async.nonPeriodicTimerCount, 1);
           timer.cancel();
           expect(async.nonPeriodicTimerCount, 0);
         });
       });
     });
+
+    group('timers', () {
+      test('should behave like real timers', () {
+        return new FakeAsync().run((async) {
+          var timeout = const Duration(minutes: 1);
+          int counter = 0;
+          var timer;
+          timer = new Timer(timeout, () {
+            counter++;
+            expect(timer.isActive, isFalse,
+                reason: "is not active while executing callback");
+          });
+          expect(timer.isActive, isTrue,
+              reason: "is active before executing callback");
+          async.elapse(timeout);
+          expect(counter, equals(1), reason: "timer executed");
+          expect(timer.isActive, isFalse,
+              reason: "is not active after executing callback");
+        });
+      });
+    });
   });
 }