anchor.diff:          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),
  +                  timeout: const Duration(hours: 2),
  +                  flushPeriodicTimers: false),
                 throwsStateError);
             expect(count, 4);
           });
  
positive.code:       test('should flush periodic timers', () {
          new FakeAsync().run((async) {
            int count = 0;
            new Timer.periodic(new Duration(minutes: 30), (Timer timer) {
              if (count == 3) {
                timer.cancel();
              }
              count++;
            });
            async.flushTimers(timeout: new Duration(hours: 20));
            expect(count, 4);
          });
        });
  
negative.code:       test('should run collateral periodic timers', () {
          new FakeAsync().run((async) {
            final log = [];
            new Future.delayed(const Duration(seconds: 2), () {
              log.add('delayed');
            });
            new Timer.periodic(const Duration(seconds: 1), (_) {
              log.add('periodic');
            });
            expect(log, hasLength(0), reason: 'should not flush until asked to');
  