Add a LoadSuite class.

lib/src/executable.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.
 
 // TODO(nweiz): This is under lib so that it can be used by the unittest dummy
 // package. Once that package is no longer being updated, move this back into
 // bin.
 library test.executable;
 
 import 'dart:async';
 import 'dart:io';
 import 'dart:math' as math;
 
 import 'package:args/args.dart';
+import 'package:async/async.dart';
 import 'package:stack_trace/stack_trace.dart';
 import 'package:yaml/yaml.dart';
 
 import 'backend/metadata.dart';
 import 'backend/test_platform.dart';
 import 'runner/engine.dart';
 import 'runner/application_exception.dart';
 import 'runner/load_exception.dart';
-import 'runner/load_exception_suite.dart';
+import 'runner/load_suite.dart';
 import 'runner/loader.dart';
 import 'runner/reporter/compact.dart';
 import 'runner/reporter/expanded.dart';
 import 'util/exit_codes.dart' as exit_codes;
 import 'util/io.dart';
 import 'utils.dart';
 
 /// The argument parser used to parse the executable arguments.
 final _parser = new ArgParser(allowTrailingOptions: true);
 
@@ skipping 170 matching lines @@
 
   var metadata = new Metadata(verboseTrace: options["verbose-trace"]);
   var platforms = options["platform"].map(TestPlatform.find);
   var loader = new Loader(platforms,
       pubServeUrl: pubServeUrl,
       packageRoot: options["package-root"],
       color: color,
       metadata: metadata,
       jsTrace: options["js-trace"]);
 
+  var closed = false;
   var signalSubscription;
   signalSubscription = _signals.listen((_) {
+    closed = true;
     signalSubscription.cancel();
     loader.close();
   });
 
   try {
     var engine = new Engine(concurrency: concurrency);
 
     var watch = options["reporter"] == "compact"
         ? CompactReporter.watch
         : ExpandedReporter.watch;
 
     watch(
         engine,
         color: color,
         verboseTrace: options["verbose-trace"],
         printPath: paths.length > 1 ||
             new Directory(paths.single).existsSync(),
         printPlatform: platforms.length > 1);
 
     // Override the signal handler to close [reporter]. [loader] will still be
     // closed in the [whenComplete] below.
     signalSubscription.onData((_) async {
+      closed = true;
       signalSubscription.cancel();
 
       // Wait a bit to print this message, since printing it eagerly looks weird
       // if the tests then finish immediately.
       var timer = new Timer(new Duration(seconds: 1), () {
         // Print a blank line first to ensure that this doesn't interfere with
         // the compact reporter's unfinished line.
         print("");
         print("Waiting for current test(s) to finish.");
         print("Press Control-C again to terminate immediately.");
       });
 
+      // Make sure we close the engine *before* the loader. Otherwise,
+      // LoadSuites provided by the loader may get into bad states.
       await engine.close();
       timer.cancel();
       await loader.close();
     });
 
     try {
       var results = await Future.wait([
         _loadSuites(paths, pattern, loader, engine),
         engine.run()
       ], eagerError: true);
 
+      if (closed) return;
+
       // Explicitly check "== true" here because [engine.run] can return `null`
       // if the engine was closed prematurely.
       exitCode = results.last == true ? 0 : 1;
     } finally {
       signalSubscription.cancel();
       await engine.close();
     }
 
     if (engine.passed.length == 0 && engine.failed.length == 0 &&
         engine.skipped.length == 0 && pattern != null) {
@@ skipping 23 matching lines @@
   }
 }
 
 /// Load the test suites in [paths] that match [pattern] and pass them to
 /// [engine].
 ///
 /// This completes once all the tests have been added to the engine. It does not
 /// run the engine.
 Future _loadSuites(List<String> paths, Pattern pattern, Loader loader,
     Engine engine) async {
-  var completer = new Completer();
+  var group = new FutureGroup();
 
   mergeStreams(paths.map((path) {
     if (new Directory(path).existsSync()) return loader.loadDir(path);
     if (new File(path).existsSync()) return loader.loadFile(path);
 
-    return new Stream.fromFuture(new Future.error(
-        new LoadException(path, 'Does not exist.'),
-        new Trace.current()));
-  })).map((suite) {
-    if (pattern == null) return suite;
-    return suite.change(
-        tests: suite.tests.where((test) => test.name.contains(pattern)));
-  }).listen((suite) => engine.suiteSink.add(suite),
-      onError: (error, stackTrace) {
-    if (error is LoadException) {
-      engine.suiteSink.add(new LoadExceptionSuite(error, stackTrace));
-    } else if (!completer.isCompleted) {
-      completer.completeError(error, stackTrace);
-    }
-  }, onDone: () => completer.complete());
+    return new Stream.fromIterable([
+      new LoadSuite("loading $path", () =>
+          throw new LoadException(path, 'Does not exist.'))
+    ]);
+  })).listen((loadSuite) {
+    group.add(new Future.sync(() async {
+      engine.suiteSink.add(loadSuite);
 
-  await completer.future;
+      var suite = await loadSuite.suite;
+      if (suite == null) return;
+      if (pattern != null) {
+        suite = suite.change(
+            tests: suite.tests.where((test) => test.name.contains(pattern)));
+      }
+
+      engine.suiteSink.add(suite);
+    }));
+  }, onError: (error, stackTrace) {
+    group.add(new Future.error(error, stackTrace));
+  }, onDone: group.close);
+
+  await group.future;
 
   // Once we've loaded all the suites, notify the engine that no more will be
   // coming.
   engine.suiteSink.close();
 }
 
 /// Print usage information for this command.
 ///
 /// If [error] is passed, it's used in place of the usage message and the whole
 /// thing is printed to stderr instead of stdout.
@@ skipping 64 matching lines @@
       if (description is! Map) return false;
       var path = description["path"];
       if (path is! String) return false;
 
       print("$version (from $path)");
       return true;
 
     default: return false;
   }
 }