Add configuration support for choosing test paths.

lib/src/runner/configuration/load.dart

 // Copyright (c) 2016, 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 'package:glob/glob.dart';
 import 'package:path/path.dart' as p;
 import 'package:source_span/source_span.dart';
 import 'package:yaml/yaml.dart';
 
 import '../../utils.dart';
 import '../../frontend/timeout.dart';
 import '../../backend/test_platform.dart';
 import '../configuration.dart';
 import 'values.dart';
 
@@ skipping 46 matching lines @@
         TestPlatform.all.map((platform) => platform.identifier).toSet();
     var platforms = _getList("platforms", (platformNode) {
       _validate(platformNode, "Platforms must be strings.",
           (value) => value is String);
       _validate(platformNode, 'Unknown platform "${platformNode.value}".',
           allPlatformIdentifiers.contains);
 
       return TestPlatform.find(platformNode.value);
     });
 
-    // TODO(nweiz): Add support for using globs to define defaults paths to run.
+    var paths = _getList("paths", (pathNode) {
+      _validate(pathNode, "Paths must be strings.", (value) => value is String);
+      _validate(pathNode, "Paths must be relative.", p.url.isRelative);
+
+      return _parseNode(pathNode, "path", p.fromUri);
+    });
+
+    var filename = _parseValue("filename", (value) => new Glob(value));
 
     return new Configuration(
         verboseTrace: verboseTrace,
         jsTrace: jsTrace,
         reporter: reporter,
         pubServePort: pubServePort,
         concurrency: concurrency,
         timeout: timeout,
-        platforms: platforms);
+        platforms: platforms,
+        paths: paths,
+        filename: filename);
   }
 
   /// Throws an exception with [message] if [test] returns `false` when passed
   /// [node]'s value.
   void _validate(YamlNode node, String message, bool test(value)) {
     if (test(node.value)) return;
     throw new SourceSpanFormatException(message, node.span, _source);
   }
 
   /// Returns the value of the node at [field].
@@ skipping 32 matching lines @@
   /// Asserts that [field] is a list and runs [forElement] for each element it
   /// contains.
   ///
   /// Returns a list of values returned by [forElement].
   List _getList(String field, forElement(YamlNode elementNode)) {
     var node = _getNode(field, "list", (value) => value is List);
     if (node == null) return [];
     return node.nodes.map(forElement).toList();
   }
 
+  /// Asserts that [node] is a string, passes its value to [parse], and returns
+  /// the result.
+  ///
+  /// If [parse] throws a [FormatException], it's wrapped to include [node]'s
+  /// span.
+  _parseNode(YamlNode node, String name, parse(String value)) {
+    _validate(node, "$name must be a string.", (value) => value is String);
+
+    try {
+      return parse(node.value);
+    } on FormatException catch (error) {
+      throw new SourceSpanFormatException(
+          'Invalid $name: ${error.message}', node.span, _source);
+    }
+  }
+
   /// Asserts that [field] is a string, passes it to [parse], and returns the
   /// result.
   ///
   /// If [parse] throws a [FormatException], it's wrapped to include [field]'s
   /// span.
-  _parseValue(String field, parse(value)) {
-    var value = _getString(field);
-    if (value == null) return null;
-
-    try {
-      return parse(value);
-    } on FormatException catch (error) {
-      _error('Invalid $field: ${error.message}', field);
-    }
+  _parseValue(String field, parse(String value)) {
+    var node = _document.nodes[field];
+    if (node == null) return null;
+    return _parseNode(node, field, parse);
   }
 
   /// Throws a [SourceSpanFormatException] with [message] about [field].
   void _error(String message, String field) {
     throw new SourceSpanFormatException(
         message, _document.nodes[field].span, _source);
   }
 }