Split up tests and add some heartbeats to try to make them not timeout.

pkg/watcher/lib/src/directory_watcher.dart

 // Copyright (c) 2013, 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.
 
 library watcher.directory_watcher;
 
 import 'dart:async';
 import 'dart:io';
 
 import 'package:crypto/crypto.dart';
@@ skipping 24 matching lines @@
   /// If the watcher is not currently monitoring the directory (because there
   /// are no subscribers to [events]), this returns a future that isn't
   /// complete yet. It will complete when a subscriber starts listening and
   /// the watcher finishes any initialization work it needs to do.
   ///
   /// If the watcher is already monitoring, this returns an already complete
   /// future.
   Future get ready => _ready.future;
   Completer _ready = new Completer();
 
+  /// The amount of time the watcher pauses between successive polls of the
+  /// directory contents.
+  final Duration pollingDelay;
+
   /// The previous status of the files in the directory.
   ///
   /// Used to tell which files have been modified.
   final _statuses = new Map<String, _FileStatus>();
 
   /// Creates a new [DirectoryWatcher] monitoring [directory].
-  DirectoryWatcher(this.directory) {
+  ///
+  /// If [pollingDelay] is passed, it specifies the amount of time the watcher
+  /// will pause between successive polls of the directory contents. Making
+  /// this shorter will give more immediate feedback at the expense of doing
+  /// more IO and higher CPU usage. Defaults to one second.
+  DirectoryWatcher(this.directory, {Duration pollingDelay})
+      : pollingDelay = pollingDelay != null ? pollingDelay :
+                                              new Duration(seconds: 1) {
     _events = new StreamController<WatchEvent>.broadcast(onListen: () {
       _state = _state.listen(this);
     }, onCancel: () {
       _state = _state.cancel(this);
     });
   }
 
   /// Starts the asynchronous polling process.
   ///
   /// Scans the contents of the directory and compares the results to the
@@ skipping 24 matching lines @@
         _statuses.remove(removed);
       }
 
       var previousState = _state;
       _state = _state.finish(this);
 
       // If we were already sending notifications, add a bit of delay before
       // restarting just so that we don't whale on the file system.
       // TODO(rnystrom): Tune this and/or make it tunable?
       if (_state.shouldNotify) {
-        return new Future.delayed(new Duration(seconds: 1));
+        return new Future.delayed(pollingDelay);
       }
     }).then((_) {
       // Make sure we haven't transitioned to a non-watching state during the
       // delay.
       if (_state.shouldWatch) _watch();
     });
   }
 
   /// Compares the current state of the file at [path] to the state it was in
   /// the last time it was scanned.
@@ skipping 110 matching lines @@
 
 class _FileStatus {
   /// The last time the file was modified.
   DateTime modified;
 
   /// The SHA-1 hash of the contents of the file.
   List<int> hash;
 
   _FileStatus(this.modified, this.hash);
 }