Add support for a timeout flag.

lib/src/runner/configuration.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:io';
 import 'dart:math' as math;
 
 import 'package:args/args.dart';
 import 'package:path/path.dart' as p;
 
@@ skipping 54 matching lines @@
         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/".',
         valueHelp: 'port');
+
+    // Note: although we list the 30s default timeout as though it were a
+    // default value for this argument, it's actually encoded in the [Invoker]'s
+    // call to [Timeout.apply].
+    parser.addOption("timeout",
+        help: 'The default test timeout. For example: 15s, 2x, none\n'
+            '(defaults to 30s)');
     parser.addFlag("pause-after-load",
         help: 'Pauses for debugging before any tests execute.\n'
-            'Implies --concurrency=1.\n'
+            'Implies --concurrency=1 and --timeout=none.\n'
             'Currently only supported for browser tests.',
         negatable: false);
 
     parser.addSeparator("======== Output");
     parser.addOption("reporter",
         abbr: 'r',
         help: 'The runner used to print test results.',
         allowed: ['compact', 'expanded', 'json'],
         defaultsTo: Platform.isWindows ? 'expanded' : 'compact',
         allowedHelp: {
@@ skipping 34 matching lines @@
   /// The package root for resolving "package:" URLs.
   final String packageRoot;
 
   /// The name of the reporter to use to display results.
   final String reporter;
 
   /// The URL for the `pub serve` instance from which to load tests, or `null`
   /// if tests should be loaded from the filesystem.
   final Uri pubServeUrl;
 
+  /// The default test timeout.
+  final Timeout timeout;
+
   /// Whether to use command-line color escapes.
   final bool color;
 
   /// How many tests to run concurrently.
   final int concurrency;
 
   /// The from which to load tests.
   final List<String> paths;
 
   /// Whether the load paths were passed explicitly or the default was used.
   final bool explicitPaths;
 
   /// The pattern to match against test names to decide which to run, or `null`
   /// if all tests should be run.
   final Pattern pattern;
 
   /// The set of platforms on which to run tests.
   final List<TestPlatform> platforms;
 
   /// Restricts the set of tests to a set of tags
   final Set<String> tags;
 
   /// Does not run tests with tags from this set
   final Set<String> excludeTags;
 
   /// The global test metadata derived from this configuration.
   Metadata get metadata =>
-      new Metadata(
-          timeout: pauseAfterLoad ? Timeout.none : null,
-          verboseTrace: verboseTrace);
+      new Metadata(timeout: timeout, verboseTrace: verboseTrace);
 
   /// Parses the configuration from [args].
   ///
   /// Throws a [FormatException] if [args] are invalid.
   factory Configuration.parse(List<String> args) {
     var options = _parser.parse(args);
 
     var pattern;
     if (options['name'] != null) {
       if (options["plain-name"] != null) {
@@ skipping 29 matching lines @@
         version: options['version'],
         verboseTrace: options['verbose-trace'],
         jsTrace: options['js-trace'],
         pauseAfterLoad: options['pause-after-load'],
         color: options['color'],
         packageRoot: options['package-root'],
         reporter: options['reporter'],
         pubServePort: _wrapFormatException(options, 'pub-serve', int.parse),
         concurrency: _wrapFormatException(options, 'concurrency', int.parse,
             orElse: () => _defaultConcurrency),
+        timeout: _wrapFormatException(options, 'timeout',
+            (value) => new Timeout.parse(value),
+            orElse: () => new Timeout.factor(1)),
         pattern: pattern,
         platforms: options['platform'].map(TestPlatform.find),
         paths: options.rest.isEmpty ? null : options.rest,
         tags: tags,
         excludeTags: excludeTags);
   }
 
   /// Runs [parse] on the value of the option [name], and wraps any
   /// [FormatException] it throws with additional information.
   static _wrapFormatException(ArgResults options, String name, parse(value),
       {orElse()}) {
     var value = options[name];
     if (value == null) return orElse == null ? null : orElse();
 
     try {
       return parse(value);
     } on FormatException catch (error) {
       throw new FormatException('Couldn\'t parse --$name "${options[name]}": '
           '${error.message}');
     }
   }
 
   Configuration({this.help: false, this.version: false,
           this.verboseTrace: false, this.jsTrace: false,
           bool pauseAfterLoad: false, bool color, String packageRoot,
-          String reporter, int pubServePort, int concurrency, this.pattern,
-          Iterable<TestPlatform> platforms, Iterable<String> paths,
-          Set<String> tags, Set<String> excludeTags})
+          String reporter, int pubServePort, int concurrency, Timeout timeout,
+          this.pattern, Iterable<TestPlatform> platforms,
+          Iterable<String> paths, Set<String> tags, Set<String> excludeTags})
       : pauseAfterLoad = pauseAfterLoad,
         color = color == null ? canUseSpecialChars : color,
         packageRoot = packageRoot == null
             ? p.join(p.current, 'packages')
             : packageRoot,
         reporter = reporter == null ? 'compact' : reporter,
         pubServeUrl = pubServePort == null
             ? null
             : Uri.parse("http://localhost:$pubServePort"),
         concurrency = pauseAfterLoad
             ? 1
             : (concurrency == null ? _defaultConcurrency : concurrency),
+        timeout = pauseAfterLoad
+            ? Timeout.none
+            : (timeout == null ? new Timeout.factor(1) : timeout),
         platforms = platforms == null ? [TestPlatform.vm] : platforms.toList(),
         paths = paths == null ? ["test"] : paths.toList(),
         explicitPaths = paths != null,
         this.tags = tags,
         this.excludeTags = excludeTags;
 }