feature: tag tests; choose tags on command line

test/backend/declarer_test.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 'package:test/src/backend/group.dart';
 import 'package:test/src/backend/invoker.dart';
 import 'package:test/src/backend/suite.dart';
 import 'package:test/src/backend/test.dart';
@@ skipping 30 matching lines @@
         test("description 1", () {});
         test("description 2", () {});
         test("description 3", () {});
       });
 
       expect(tests, hasLength(3));
       expect(tests[0].name, equals("description 1"));
       expect(tests[1].name, equals("description 2"));
       expect(tests[2].name, equals("description 3"));
     });
+
+    test("declares a test with tags", () {
+      var tests = declare(() {
+        test("tags as String", () {}, tags: "a");
+        test("tags as List", () {}, tags: ["a", "b"]);
+        test("tags as null", () {}, tags: null);
+      });
+
+      expect(tests, hasLength(3));
+      expect(tests[0].metadata.tags, unorderedEquals(["a"]));
+      expect(tests[1].metadata.tags, unorderedEquals(["a", "b"]));
+      expect(tests[2].metadata.tags, isEmpty);
+    });
+
+    test("throws on invalid tags", () {
+      expect(() {
+        declare(() {
+          test("a", () {}, tags: 1);
+        });
+      }, throwsArgumentError);
+    });
   });
 
   group(".setUp()", () {
     test("is run before all tests", () async {
       var setUpRun = false;
       var tests = declare(() {
         setUp(() => setUpRun = true);
 
         test("description 1", expectAsync(() {
           expect(setUpRun, isTrue);
@@ skipping 346 matching lines @@
 
             test("description", expectAsync(() {
               expect(outerSetUpRun, isTrue);
               expect(innerSetUpRun, isTrue);
             }, max: 1));
           });
         });
 
         return _runTest(entries.single.entries.single);
       });
+
+      test("inherits group's tags", () {
+        var tests = declare(() {
+          group("outer", () {
+            group("inner", () {
+              test("with tags", () {}, tags: "d");
+            }, tags: ["b", "c"]);
+          }, tags: "a");
+        });
+
+        var outerGroup = tests.single;
+        var innerGroup = outerGroup.entries.single;
+        var testWithTags = innerGroup.entries.single;
+        expect(outerGroup.metadata.tags, unorderedEquals(["a"]));
+        expect(innerGroup.metadata.tags, unorderedEquals(["a", "b", "c"]));
+        expect(testWithTags.metadata.tags,
+            unorderedEquals(["a", "b", "c", "d"]));
+      });
+
+      test("throws on invalid tags", () {
+        expect(() {
+          declare(() {
+            group("a", () {}, tags: 1);
+          });
+        }, throwsArgumentError);
+      });
     });
 
     group(".tearDown()", () {
       test("is scoped to the group", () async {
         var tearDownRun;
         var entries = declare(() {
           setUp(() => tearDownRun = false);
 
           group("group", () {
             tearDown(() => tearDownRun = true);
@@ skipping 112 matching lines @@
 /// doesn't throw any invisible exceptions.
 Future _runTest(Test test, {bool shouldFail: false}) {
   var liveTest = test.load(_suite);
 
   liveTest.onError.listen(shouldFail
       ? expectAsync((_) {})
       : (error) => registerException(error.error, error.stackTrace));
 
   return liveTest.run();
 }