Add a ResetTimer class.

test/reset_timer_test.dart

Index: test/reset_timer_test.dart
diff --git a/test/reset_timer_test.dart b/test/reset_timer_test.dart
new file mode 100644
index 0000000000000000000000000000000000000000..6d0b81169885c8a9e96b34f03645c7e45c739a6f
--- /dev/null
+++ b/test/reset_timer_test.dart
@@ -0,0 +1,91 @@
+// Copyright (c) 2015, 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:async/async.dart';
+import 'package:fake_async/fake_async.dart';
+import 'package:test/test.dart';
+
+main() {
+  test("runs the callback once the duration has elapsed", () {
+    new FakeAsync().run((async) {
+      var fired = false;
+      var timer = new ResetTimer(new Duration(seconds: 5), () => fired = true);

[Lasse Reichstein Nielsen, 2015/10/27 09:45:14]

Use braces, not =>, for functions where the return value isn't relevant (dittos
below).


Consider having 

  const second = const Duration(seconds: 1);

declared somewhere, so you can just write "second * 5" for the duration.
Also makes it fit in a line when changing => to {;}.

[nweiz, 2015/10/27 21:08:12]

Done.
I'm not a huge fan of creating an idiosyncratic way of declaring durations just
to avoid a few characters.

+
+      async.elapse(new Duration(seconds: 4));
+      expect(fired, isFalse);
+
+      async.elapse(new Duration(seconds: 1));
+      expect(fired, isTrue);
+    });
+  });
+
+  test("doesn't run the callback if the timer is canceled", () {
+    new FakeAsync().run((async) {
+      var fired = false;
+      var timer = new ResetTimer(new Duration(seconds: 5), () => fired = true);
+
+      async.elapse(new Duration(seconds: 4));
+      expect(fired, isFalse);
+      timer.cancel();
+
+      async.elapse(new Duration(seconds: 4));

[Lasse Reichstein Nielsen, 2015/10/27 09:45:14]

Interesting - this looks like it's synchronous, so how does it fire timer
callbacks (which should be called from a top-level event loop)?

[nweiz, 2015/10/27 21:08:12]

I believe it just creates an entire simulated event loop using a
ZoneSpecification.

+      expect(fired, isFalse);
+    });
+  });
+
+  test("resets the duration if the timer is reset before it fires", () {
+    new FakeAsync().run((async) {
+      var fired = false;
+      var timer = new ResetTimer(new Duration(seconds: 5), () => fired = true);
+
+      async.elapse(new Duration(seconds: 4));
+      expect(fired, isFalse);
+      timer.reset();
+
+      async.elapse(new Duration(seconds: 4));
+      expect(fired, isFalse);
+
+      async.elapse(new Duration(seconds: 1));
+      expect(fired, isTrue);
+    });
+  });
+
+  test("re-runs the callback if the timer is reset after firing", () {
+    new FakeAsync().run((async) {
+      var fired = 0;
+      var timer = new ResetTimer(new Duration(seconds: 5), () => fired++);
+
+      async.elapse(new Duration(seconds: 5));
+      expect(fired, equals(1));
+      timer.reset();
+
+      async.elapse(new Duration(seconds: 5));
+      expect(fired, equals(2));
+      timer.reset();
+
+      async.elapse(new Duration(seconds: 5));
+      expect(fired, equals(3));
+    });
+  });
+
+  test("runs the callback if the timer is reset after being canceled", () {
+    new FakeAsync().run((async) {
+      var fired = false;
+      var timer = new ResetTimer(new Duration(seconds: 5), () => fired = true);
+
+      async.elapse(new Duration(seconds: 4));
+      expect(fired, isFalse);
+      timer.cancel();
+
+      async.elapse(new Duration(seconds: 4));
+      expect(fired, isFalse);
+      timer.reset();
+
+      async.elapse(new Duration(seconds: 5));
+      expect(fired, isTrue);
+    });
+  });

[Lasse Reichstein Nielsen, 2015/10/27 09:45:14]

Check that the timer is not periodic: Wait at least 10 seconds, and see that it
fires only once.

[nweiz, 2015/10/27 21:08:12]

Done.

+}