Add the ability to run test suites in parallel.

lib/src/executable.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.
 
 // TODO(nweiz): This is under lib so that it can be used by the unittest dummy
 // package. Once that package is no longer being updated, move this back into
 // bin.
 library test.executable;
 
 import 'dart:async';
 import 'dart:io';
 import 'dart:isolate';
+import 'dart:math' as math;
 
 import 'package:args/args.dart';
 import 'package:stack_trace/stack_trace.dart';
 import 'package:yaml/yaml.dart';
 
 import 'backend/test_platform.dart';
 import 'runner/reporter/compact.dart';
 import 'runner/load_exception.dart';
 import 'runner/loader.dart';
 import 'util/exit_codes.dart' as exit_codes;
 import 'util/io.dart';
 import 'utils.dart';
 
 /// The argument parser used to parse the executable arguments.
 final _parser = new ArgParser(allowTrailingOptions: true);
 
+/// The default number of test suites to run at once.
+///
+/// This defaults to half the available processors, since presumably some of
+/// them will be used for the OS and other processes.
+final _defaultConcurrency = math.max(1, Platform.numberOfProcessors ~/ 2);
+
 /// A merged stream of all signals that tell the test runner to shut down
 /// gracefully.
 ///
 /// Signals will only be captured as long as this has an active subscription.
 /// Otherwise, they'll be handled by Dart's default signal handler, which
 /// terminates the program immediately.
 final _signals = mergeStreams([
   ProcessSignal.SIGTERM.watch(), ProcessSignal.SIGINT.watch()
 ]);
 
@@ skipping 34 matching lines @@
           'Regular expression syntax is supported.');
   _parser.addOption("plain-name",
       abbr: 'N',
       help: 'A plain-text substring of the name of the test to run.');
   _parser.addOption("platform",
       abbr: 'p',
       help: 'The platform(s) on which to run the tests.',
       allowed: TestPlatform.all.map((platform) => platform.identifier).toList(),
       defaultsTo: 'vm',
       allowMultiple: true);
+  _parser.addOption("concurrency",
+      abbr: 'j',
+      help: 'The number of concurrent test suites run.\n'
+          '(defaults to $_defaultConcurrency)',
+      valueHelp: 'threads');
   _parser.addOption("pub-serve",
       help: 'The port of a pub serve instance serving "test/".',
       hide: !supportsPubServe,
       valueHelp: 'port');
   _parser.addFlag("color", defaultsTo: null,
       help: 'Whether to use terminal colors.\n(auto-detected by default)');
 
   var options;
   try {
     options = _parser.parse(args);
@@ skipping 27 matching lines @@
       return;
     }
   }
 
   var platforms = options["platform"].map(TestPlatform.find);
   var loader = new Loader(platforms,
       pubServeUrl: pubServeUrl,
       packageRoot: options["package-root"],
       color: color);
 
+  var concurrency = _defaultConcurrency;
+  if (options["concurrency"] != null) {
+    try {
+      concurrency = int.parse(options["concurrency"]);
+    } catch (error) {
+      _printUsage('Couldn\'t parse --concurrency "${options["concurrency"]}":'
+          ' ${error.message}');
+      exitCode = exit_codes.usage;
+      return;
+    }
+  }
+
   var signalSubscription;
   var closed = false;
   signalSubscription = _signals.listen((_) {
     signalSubscription.cancel();
     closed = true;
     loader.close();
   });
 
   new Future.sync(() {
     var paths = options.rest;
@@ skipping 39 matching lines @@
         if (pattern is RegExp) {
           stderr.write('regular expression "${pattern.pattern}".');
         } else {
           stderr.writeln('"$pattern".');
         }
         exitCode = exit_codes.data;
         return null;
       }
     }
 
-    var reporter = new CompactReporter(flatten(suites), color: color);
+    var reporter = new CompactReporter(flatten(suites),
+        concurrency: concurrency, color: color);
 
     // Override the signal handler to close [reporter]. [loader] will still be
     // closed in the [whenComplete] below.
     signalSubscription.onData((_) {
       signalSubscription.cancel();
       closed = true;
 
       // Wait a bit to print this message, since printing it eagerly looks weird
       // if the tests then finish immediately.
       var timer = new Timer(new Duration(seconds: 1), () {
-        print("Waiting for current test to finish.");
+        // Print a blank line first to ensure that this doesn't interfere with
+        // the compact reporter's unfinished line.
+        print("");
+        print("Waiting for current test(s) to finish.");
         print("Press Control-C again to terminate immediately.");
       });
 
       reporter.close().then((_) => timer.cancel());
     });
 
     return reporter.run().then((success) {
       exitCode = success ? 0 : 1;
     }).whenComplete(() {
       signalSubscription.cancel();
@@ skipping 45 matching lines @@
     output = stderr;
   }
 
   output.write("""$message
 
 Usage: pub run test:test [files or directories...]
 
 ${_parser.usage}
 """);
 }