feature: tag tests; choose tags on command line

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.
 
 library test.runner.configuration;
 
 import 'dart:io';
 import 'dart:math' as math;
 
 import 'package:args/args.dart';
@@ skipping 60 matching lines @@
       'compact': 'A single line, updated continuously.',
       'expanded': 'A separate line for each update.'
     });
     parser.addFlag("verbose-trace", negatable: false,
         help: 'Whether to emit stack traces with core library frames.');
     parser.addFlag("js-trace", negatable: false,
         help: 'Whether to emit raw JavaScript stack traces for browser tests.');
     parser.addFlag("color", defaultsTo: null,
         help: 'Whether to use terminal colors.\n(auto-detected by default)');
     parser.addOption("tags",
-      help: 'Comma-separated list of tags to run',
-      allowMultiple: true,
-      splitCommas: true);
+        abbr: 't',
+        help: 'Comma-separated list of tags to run',
+        allowMultiple: true,
+        splitCommas: true);
+    parser.addOption("tag",
+        hide: true,
+        allowMultiple: true,
+        splitCommas: true);
+    parser.addOption("exclude-tags",
+        abbr: 'x',
+        help: 'Comma-separated list of tags not to run',
+        allowMultiple: true,
+        splitCommas: true);
+    parser.addOption("exclude-tag",
+        hide: true,
+        allowMultiple: true,
+        splitCommas: true);
 
     return parser;
   })();
 
   /// The usage string for the command-line arguments.
   static String get usage => _parser.usage;
 
   /// Whether `--help` was passed.
   final bool help;
 
@@ skipping 34 matching lines @@
   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 List<String> 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);
 
   /// 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) {
         throw new FormatException(
             "--name and --plain-name may not both be passed.");
       }
 
       pattern = _wrapFormatException(
           options, 'name', (value) => new RegExp(value));
     } else if (options['plain-name'] != null) {
       pattern = options['plain-name'];
     }
 
+    var tags = new Set<String>();
+    tags.addAll(options['tags'] ?? []);
+    tags.addAll(options['tag'] ?? []);
+
+    var excludeTags = new Set<String>();
+    excludeTags.addAll(options['exclude-tags'] ?? []);
+    excludeTags.addAll(options['exclude-tag'] ?? []);
+
+    var tagIntersection = tags.intersection(excludeTags);
+    if (tagIntersection.isNotEmpty) {
+      throw new FormatException('Included and excluded tag sets may not'
+          ' intersect. Found intersection: ${tagIntersection.join(', ')}');
+    }
+
     return new Configuration(
         help: options['help'],
         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),
         pattern: pattern,
         platforms: options['platform'].map(TestPlatform.find),
         paths: options.rest.isEmpty ? null : options.rest,
-        tags: options['tags']);
+        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,
-          List<String> tags})
+          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),
         platforms = platforms == null ? [TestPlatform.vm] : platforms.toList(),
         paths = paths == null ? ["test"] : paths.toList(),
         explicitPaths = paths != null,
-        this.tags = tags == null
-            ? const <String>[]
-            : tags;
+        this.tags = tags,
+        this.excludeTags = excludeTags;
 }