Rework Timer interface.

pkg/unittest/lib/unittest.dart

 // Copyright (c) 2011, 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.
 
 /**
  * A library for writing dart unit tests.
  *
  * To import this library, use the pub package manager.
  * Create a pubspec.yaml file in your project and add
  * a dependency on unittest with the following lines:
@@ skipping 72 matching lines @@
  * function into a new callback and will not consider the test complete until
  * that callback is run. A count argument can be provided to specify the number
  * of times the callback should be called (the default is 1).
  *
  *     import 'package:unittest/unittest.dart';
  *     import 'dart:isolate';
  *     main() {
  *       test('callback is executed once', () {
  *         // wrap the callback of an asynchronous call with [expectAsync0] if
  *         // the callback takes 0 arguments...
- *         var timer = new Timer(0, (_) => expectAsync0(() {
+ *         var timer = Timer.run(expectAsync0(() {
  *           int x = 2 + 3;
  *           expect(x, equals(5));
  *         }));
  *       });
  *
  *       test('callback is executed twice', () {
- *         var callback = (_) => expectAsync0(() {
+ *         var callback = expectAsync0(() {
  *           int x = 2 + 3;
  *           expect(x, equals(5));
  *         }, count: 2); // <-- we can indicate multiplicity to [expectAsync0]
- *         new Timer(0, callback);
- *         new Timer(0, callback);
+ *         Timer.run(callback);
+ *         Timer.run(callback);
  *       });
  *     }
  *
  * expectAsyncX() will wrap the callback code in a try/catch handler to handle
  * exceptions (treated as test failures). There may be times when the number of
  * times a callback should be called is non-deterministic. In this case a dummy
  * callback can be created with expectAsync0((){}) and this can be called from
  * the real callback when it is finally complete. In this case the body of the
  * callback should be protected within a call to guardAsync(); this will ensure
  * that exceptions are properly handled.
  *
  * Note: due to some language limitations we have to use different functions
  * depending on the number of positional arguments of the callback. In the
  * future, we plan to expose a single `expectAsync` function that can be used
  * regardless of the number of positional arguments. This requires new langauge
  * features or fixes to the current spec (e.g. see
  * [Issue 2706](http://dartbug.com/2706)).
  *
  * Meanwhile, we plan to add this alternative API for callbacks of more than 2
  * arguments or that take named parameters. (this is not implemented yet,
  * but will be coming here soon).
  *
  *     import 'package:unittest/unittest.dart';
  *     import 'dart:isolate';
  *     main() {
  *       test('callback is executed', () {
  *         // indicate ahead of time that an async callback is expected.
  *         var async = startAsync();
- *         new Timer(0, (_) {
+ *         Timer.run(() {
  *           // Guard the body of the callback, so errors are propagated
  *           // correctly.
  *           guardAsync(() {
  *             int x = 2 + 3;
  *             expect(x, equals(5));
  *           });
  *           // indicate that the asynchronous callback was invoked.
  *           async.complete();
  *         });
  *       });
@@ skipping 756 matching lines @@
 }
 
 /** Enable a test by ID. */
 void enableTest(int testId) => _setTestEnabledState(testId, true);
 
 /** Disable a test by ID. */
 void disableTest(int testId) => _setTestEnabledState(testId, false);
 
 /** Signature for a test function. */
 typedef void TestFunction();