Add names and plain_names fields.

test/runner/configuration/configuration_test.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.
 
 @TestOn("vm")
 
 import 'package:boolean_selector/boolean_selector.dart';
 import 'package:path/path.dart' as p;
 import 'package:test/test.dart';
 
@@ skipping 12 matching lines @@
         expect(merged.version, isFalse);
         expect(merged.verboseTrace, isFalse);
         expect(merged.jsTrace, isFalse);
         expect(merged.skip, isFalse);
         expect(merged.skipReason, isNull);
         expect(merged.pauseAfterLoad, isFalse);
         expect(merged.color, equals(canUseSpecialChars));
         expect(merged.packageRoot, equals(p.join(p.current, 'packages')));
         expect(merged.reporter, equals(defaultReporter));
         expect(merged.pubServeUrl, isNull);
-        expect(merged.pattern, isNull);
         expect(merged.platforms, equals([TestPlatform.vm]));
         expect(merged.paths, equals(["test"]));
       });
 
       test("if only the old configuration's is defined, uses it", () {
         var merged = new Configuration(
                 help: true,
                 version: true,
                 verboseTrace: true,
                 jsTrace: true,
                 skip: true,
                 skipReason: "boop",
                 pauseAfterLoad: true,
                 color: true,
                 packageRoot: "root",
                 reporter: "json",
                 pubServePort: 1234,
-                pattern: "foo",
                 platforms: [TestPlatform.chrome],
                 paths: ["bar"])
             .merge(new Configuration());
 
         expect(merged.help, isTrue);
         expect(merged.version, isTrue);
         expect(merged.verboseTrace, isTrue);
         expect(merged.jsTrace, isTrue);
         expect(merged.skip, isTrue);
         expect(merged.skipReason, equals("boop"));
         expect(merged.pauseAfterLoad, isTrue);
         expect(merged.color, isTrue);
         expect(merged.packageRoot, equals("root"));
         expect(merged.reporter, equals("json"));
         expect(merged.pubServeUrl.port, equals(1234));
-        expect(merged.pattern, equals("foo"));
         expect(merged.platforms, equals([TestPlatform.chrome]));
         expect(merged.paths, equals(["bar"]));
       });
 
       test("if only the new configuration's is defined, uses it", () {
         var merged = new Configuration().merge(new Configuration(
             help: true,
             version: true,
             verboseTrace: true,
             jsTrace: true,
             skip: true,
             skipReason: "boop",
             pauseAfterLoad: true,
             color: true,
             packageRoot: "root",
             reporter: "json",
             pubServePort: 1234,
-            pattern: "foo",
             platforms: [TestPlatform.chrome],
             paths: ["bar"]));
 
         expect(merged.help, isTrue);
         expect(merged.version, isTrue);
         expect(merged.verboseTrace, isTrue);
         expect(merged.jsTrace, isTrue);
         expect(merged.skip, isTrue);
         expect(merged.skipReason, equals("boop"));
         expect(merged.pauseAfterLoad, isTrue);
         expect(merged.color, isTrue);
         expect(merged.packageRoot, equals("root"));
         expect(merged.reporter, equals("json"));
         expect(merged.pubServeUrl.port, equals(1234));
-        expect(merged.pattern, equals("foo"));
         expect(merged.platforms, equals([TestPlatform.chrome]));
         expect(merged.paths, equals(["bar"]));
       });
 
       test("if the two configurations conflict, uses the new configuration's "
           "values", () {
         var older = new Configuration(
             help: true,
             version: false,
             verboseTrace: true,
             jsTrace: false,
             skip: true,
             skipReason: "foo",
             pauseAfterLoad: true,
             color: false,
             packageRoot: "root",
             reporter: "json",
             pubServePort: 1234,
-            pattern: "foo",
             platforms: [TestPlatform.chrome],
             paths: ["bar"]);
         var newer = new Configuration(
             help: false,
             version: true,
             verboseTrace: false,
             jsTrace: true,
             skip: true,
             skipReason: "bar",
             pauseAfterLoad: false,
             color: true,
             packageRoot: "boot",
             reporter: "compact",
             pubServePort: 5678,
-            pattern: "gonk",
             platforms: [TestPlatform.dartium],
             paths: ["blech"]);
         var merged = older.merge(newer);
 
         expect(merged.help, isFalse);
         expect(merged.version, isTrue);
         expect(merged.verboseTrace, isFalse);
         expect(merged.jsTrace, isTrue);
         expect(merged.skipReason, equals("bar"));
         expect(merged.pauseAfterLoad, isFalse);
         expect(merged.color, isTrue);
         expect(merged.packageRoot, equals("boot"));
         expect(merged.reporter, equals("compact"));
         expect(merged.pubServeUrl.port, equals(5678));
-        expect(merged.pattern, equals("gonk"));
         expect(merged.platforms, equals([TestPlatform.dartium]));
         expect(merged.paths, equals(["blech"]));
       });
     });
 
     group("for testOn", () {
       test("if neither is defined, preserves the default", () {
         var merged = new Configuration().merge(new Configuration());
         expect(merged.testOn, equals(PlatformSelector.all));
       });
@@ skipping 67 matching lines @@
         expect(merged.excludeTags,
             equals(new BooleanSelector.parse("(baz || bang) || qux")));
       });
     });
 
     group("for sets", () {
       test("if neither is defined, preserves the default", () {
         var merged = new Configuration().merge(new Configuration());
         expect(merged.addTags, isEmpty);
         expect(merged.chosenPresets, isEmpty);
+        expect(merged.patterns, isEmpty);
       });
 
       test("if only the old configuration's is defined, uses it", () {
         var merged = new Configuration(
-                addTags: new Set.from(["foo", "bar"]),
-                chosenPresets: new Set.from(["baz", "bang"]))
+                addTags: ["foo", "bar"],
+                chosenPresets: ["baz", "bang"],
+                patterns: ["beep", "boop"])
             .merge(new Configuration());
 
         expect(merged.addTags, unorderedEquals(["foo", "bar"]));
         expect(merged.chosenPresets, equals(["baz", "bang"]));
+        expect(merged.patterns, equals(["beep", "boop"]));
       });
 
       test("if only the new configuration's is defined, uses it", () {
         var merged = new Configuration().merge(new Configuration(
-            addTags: new Set.from(["foo", "bar"]),
-            chosenPresets: new Set.from(["baz", "bang"])));
+            addTags: ["foo", "bar"],
+            chosenPresets: ["baz", "bang"],
+            patterns: ["beep", "boop"]));
 
         expect(merged.addTags, unorderedEquals(["foo", "bar"]));
         expect(merged.chosenPresets, equals(["baz", "bang"]));
+        expect(merged.patterns, equals(["beep", "boop"]));
       });
 
       test("if both are defined, unions them", () {
         var older = new Configuration(
-            addTags: new Set.from(["foo", "bar"]),
-            chosenPresets: new Set.from(["baz", "bang"]));
+            addTags: ["foo", "bar"],
+            chosenPresets: ["baz", "bang"],
+            patterns: ["beep", "boop"]);
         var newer = new Configuration(
-            addTags: new Set.from(["blip"]),
-            chosenPresets: new Set.from(["qux"]));
+            addTags: ["blip"],
+            chosenPresets: ["qux"],
+            patterns: ["bonk"]);
         var merged = older.merge(newer);
 
         expect(merged.addTags, unorderedEquals(["foo", "bar", "blip"]));
         expect(merged.chosenPresets, equals(["baz", "bang", "qux"]));
+        expect(merged.patterns, unorderedEquals(["beep", "boop", "bonk"]));
       });
     });
 
     group("for timeout", () {
       test("if neither is defined, preserves the default", () {
         var merged = new Configuration().merge(new Configuration());
         expect(merged.timeout, equals(new Timeout.factor(1)));
       });
 
       test("if only the old configuration's is defined, uses it", () {
@@ skipping 139 matching lines @@
             .merge(new Configuration());
 
         expect(configuration.presets, isEmpty);
         expect(configuration.chosenPresets, equals(["foo"]));
         expect(configuration.knownPresets, equals(["foo"]));
         expect(configuration.verboseTrace, isTrue);
       });
     });
   });
 }