Fix two problems with the analyzer suite:

pkg/testing/lib/src/run.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.md file.
 
 library testing.run;
 
 import 'dart:async' show
     Future,
     Stream;
 
@@ skipping 101 matching lines @@
 /// The optional argument [configurationPath] should be used when
 /// `testing.json` isn't located in the current working directory and is a path
 /// relative to `Uri.base`.
 Future<Null> run(
     List<String> arguments, List<String> suiteNames,
     [String configurationPath]) {
   return withErrorHandling(() async {
     TestRoot root = await computeTestRoot(configurationPath, Uri.base);
     List<Suite> suites = root.suites.where(
         (Suite suite) => suiteNames.contains(suite.name)).toList();
-    SuiteRunner runner = new SuiteRunner(suites, <String, String>{}, null);
+    SuiteRunner runner = new SuiteRunner(suites, <String, String>{}, null,
+        new Set<String>(), new Set<String>());
     String program = await runner.generateDartProgram();
     await runner.analyze(root.packages);
     if (program != null) {
       await runProgram(program, root.packages);
     }
   });
 }
 
 Future<Null> runProgram(String program, Uri packages) async {
   logMessage("Running:");
@@ skipping 18 matching lines @@
       : new Future<Null>.error(error[0], new StackTrace.fromString(error[1]));
 }
 
 class SuiteRunner {
   final List<Suite> suites;
 
   final Map<String, String> environment;
 
   final List<String> selectors;
 
-  List<Uri> testUris;
+  final Set<String> selectedSuites;
 
-  SuiteRunner(this.suites, this.environment, Iterable<String> selectors)
+  final Set<String> skippedSuites;
+
+  final List<Uri> testUris = <Uri>[];
+
+  SuiteRunner(this.suites, this.environment, Iterable<String> selectors,
+      this.selectedSuites, this.skippedSuites)
       : selectors = selectors.toList(growable: false);
 
+  bool shouldRunSuite(Suite suite) {
+    return !skippedSuites.contains(suite.name) &&
+        (selectedSuites.isEmpty || selectedSuites.contains(suite.name));
+  }
+
   Future<String> generateDartProgram() async {
-    List<TestDescription> descriptions = await list().toList();
-    testUris = <Uri>[];
+    testUris.clear();
     StringBuffer imports = new StringBuffer();
     StringBuffer dart = new StringBuffer();
     StringBuffer chain = new StringBuffer();
+    bool hasRunnableTests = false;
 
-    for (TestDescription description in descriptions) {
-      testUris.add(await Isolate.resolvePackageUri(description.uri));
+    await for (TestDescription description in listDescriptions()) {
+      hasRunnableTests = true;
       description.writeImportOn(imports);
       description.writeClosureOn(dart);
     }
 
-    for (Chain suite in suites.where((Suite suite) => suite is Chain)) {
-      testUris.add(await Isolate.resolvePackageUri(suite.source));
+    await for (Chain suite in listChainSuites()) {
+      hasRunnableTests = true;
       suite.writeImportOn(imports);
       suite.writeClosureOn(chain);
     }
 
-    bool hasTestDartSuite = false;
-    for (TestDart suite in suites.where((Suite suite) => suite is TestDart)) {
-      if (!hasTestDartSuite) {
+    bool isFirstTestDartSuite = true;
+    for (TestDart suite in listTestDartSuites()) {
+      hasRunnableTests = true;
+      if (!isFirstTestDartSuite) {
         suite.writeFirstImportOn(imports);
       }
-      hasTestDartSuite = true;
+      isFirstTestDartSuite = true;
       suite.writeRunCommandOn(chain);
     }
 
-    if (testUris.isEmpty && !hasTestDartSuite) return null;
+    if (hasRunnableTests) return null;
 
     return """
 library testing.generated;
 
 import 'dart:async' show Future;
 
 import 'dart:convert' show JSON;
 
 import 'package:testing/src/run_tests.dart' show runTests;
 
 import 'package:testing/src/chain.dart' show runChain;
 
 import 'package:testing/src/log.dart' show enableVerboseOutput, isVerbose;
 
 ${imports.toString().trim()}
 
 Future<Null> main() async {
   if ($isVerbose) enableVerboseOutput();
   Map<String, String> environment = JSON.decode('${JSON.encode(environment)}');
   Set<String> selectors = JSON.decode('${JSON.encode(selectors)}').toSet();
   await runTests(<String, Function> {
       ${splitLines(dart.toString().trim()).join('      ')}
   });
   ${splitLines(chain.toString().trim()).join('  ')}
 }
 """;
   }
 
-  Future<Null> analyze(Uri packages) async {
-    for (Analyze suite in suites.where((Suite suite) => suite is Analyze)) {
+  Future<bool> analyze(Uri packages) async {
+    bool hasAnalyzerSuites = false;
+    for (Analyze suite in listAnalyzerSuites()) {
+      hasAnalyzerSuites = true;
       await suite.run(packages, testUris);
     }
+    return hasAnalyzerSuites;
   }
 
-  Stream<TestDescription> list() async* {
+  Stream<TestDescription> listDescriptions() async* {
     for (Dart suite in suites.where((Suite suite) => suite is Dart)) {
       await for (TestDescription description in
                      listTests(<Uri>[suite.uri], pattern: "")) {
-        String path = description.file.uri.path;
-        if (suite.exclude.any((RegExp r) => path.contains(r))) continue;
-        if (suite.pattern.any((RegExp r) => path.contains(r))) {
-          yield description;
+        testUris.add(await Isolate.resolvePackageUri(description.uri));
+        if (shouldRunSuite(suite)) {
+          String path = description.file.uri.path;
+          if (suite.exclude.any((RegExp r) => path.contains(r))) continue;
+          if (suite.pattern.any((RegExp r) => path.contains(r))) {
+            yield description;
+          }
         }
       }
     }
   }
+
+  Stream<Chain> listChainSuites() async* {
+    for (Chain suite in suites.where((Suite suite) => suite is Chain)) {
+      testUris.add(await Isolate.resolvePackageUri(suite.source));
+      if (shouldRunSuite(suite)) {
+        yield suite;
+      }
+    }
+  }
+
+  Iterable<Suite> listTestDartSuites() {
+    return suites.where((Suite suite) => suite is TestDart);
+  }
+
+  Iterable<Suite> listAnalyzerSuites() {
+    return suites.where((Suite suite) => suite is Analyze);
+  }
 }