Add support for sharding test runs.

lib/src/runner.dart

 // 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 'dart:io';
 
 import 'package:async/async.dart';
 
 import 'backend/group.dart';
@@ skipping 226 matching lines @@
       if (new File(path).existsSync()) return _loader.loadFile(path);
 
       return new Stream.fromIterable([
         new LoadSuite.forLoadException(
             new LoadException(path, 'Does not exist.'))
       ]);
     })).map((loadSuite) {
       return loadSuite.changeSuite((suite) {
         _warnForUnknownTags(suite);
 
-        return suite.filter((test) {
+        return _shardSuite(suite.filter((test) {
           // Skip any tests that don't match all the given patterns.
           if (!_config.patterns.every(test.name.contains)) {
             return false;
           }
 
           // If the user provided tags, skip tests that don't match all of them.
           if (!_config.includeTags.evaluate(test.metadata.tags)) return false;
 
           // Skip tests that do match any tags the user wants to exclude.
           if (_config.excludeTags.evaluate(test.metadata.tags)) return false;
 
           return true;
-        });
+        }));
       });
     });
   }
 
   /// Prints a warning for any unknown tags referenced in [suite] or its
   /// children.
   void _warnForUnknownTags(Suite suite) {
     if (_tagWarningSuites.contains(suite.path)) return;
     _tagWarningSuites.add(suite.path);
 
@@ skipping 59 matching lines @@
     return unknownTags;
   }
 
   /// Returns a human-readable description of [entry], including its type.
   String _entryDescription(GroupEntry entry) {
     if (entry is Test) return 'the test "${entry.name}"';
     if (entry.name != null) return 'the group "${entry.name}"';
     return 'the suite itself';
   }
 
+  /// If sharding is enabled, filters [suite] to only include the tests that
+  /// should be run in this shard.
+  ///
+  /// We just take a slice of the tests in each suite corresponding to the shard
+  /// index. This makes the tests pretty tests across shards, and since the
+  /// tests are continuous, makes us more likely to be able to re-use
+  /// `setUpAll()` logic.
+  Suite _shardSuite(Suite suite) {
+    if (_config.totalShards == null) return suite;
+
+    var shardSize = suite.group.testCount / _config.totalShards;
+    var shardStart = (shardSize * _config.shardIndex).round();
+    var shardEnd = (shardSize * (_config.shardIndex + 1)).round();
+
+    var count = -1;
+    var filtered = suite.filter((test) {
+      count++;
+      return count >= shardStart && count < shardEnd;
+    });
+
+    return filtered;
+  }
+
   /// Loads each suite in [suites] in order, pausing after load for platforms
   /// that support debugging.
   Future<bool> _loadThenPause(Stream<LoadSuite> suites) async {
     if (_config.platforms.contains(TestPlatform.vm)) {
       warn("Debugging is currently unsupported on the Dart VM.",
           color: _config.color);
     }
 
     _suiteSubscription = suites.asyncMap((loadSuite) async {
       _debugOperation = debug(_config, _engine, _reporter, loadSuite);
       await _debugOperation.valueOrCancellation();
     }).listen(null);
 
     var results = await Future.wait([
       _suiteSubscription.asFuture().then((_) => _engine.suiteSink.close()),
       _engine.run()
     ]);
     return results.last;
   }
 }