Allow Suites to be added to an Engine over time.

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:stack_trace/stack_trace.dart';
 import 'package:yaml/yaml.dart';
 
 import 'backend/metadata.dart';
 import 'backend/test_platform.dart';
-import 'runner/reporter/compact.dart';
-import 'runner/reporter/expanded.dart';
+import 'runner/engine.dart';
 import 'runner/application_exception.dart';
 import 'runner/load_exception.dart';
 import 'runner/load_exception_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);
 
 /// The default number of test suites to run at once.
 ///
 /// This defaults to half the available processors, since presumably some of
@@ skipping 123 matching lines @@
 
 transformers:
 - test/pub_serve:
     \$include: test/**_test.dart
 ''');
       exitCode = exit_codes.data;
       return;
     }
   }
 
-  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 concurrency = _defaultConcurrency;
   if (options["concurrency"] != null) {
     try {
       concurrency = int.parse(options["concurrency"]);
     } catch (error) {
       _printUsage('Couldn\'t parse --concurrency "${options["concurrency"]}":'
           ' ${error.message}');
       exitCode = exit_codes.usage;
       return;
     }
   }
 
   var paths = options.rest;
   if (paths.isEmpty) {
     if (!new Directory("test").existsSync()) {
       _printUsage('No test files were passed and the default "test/" '
           "directory doesn't exist.");
       exitCode = exit_codes.data;
       return;
     }
     paths = ["test"];
   }
 
+  var pattern;
+  if (options["name"] != null) {
+    if (options["plain-name"] != null) {
+      _printUsage("--name and --plain-name may not both be passed.");
+      exitCode = exit_codes.data;
+      return;
+    }
+    pattern = new RegExp(options["name"]);
+  } else if (options["plain-name"] != null) {
+    pattern = options["plain-name"];
+  }
+
+  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 signalSubscription;
-  var closed = false;
   signalSubscription = _signals.listen((_) {
     signalSubscription.cancel();
-    closed = true;
     loader.close();
   });
 
   try {
-    var suites = await 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()));
-    })).transform(new StreamTransformer.fromHandlers(
-        handleError: (error, stackTrace, sink) {
-      if (error is! LoadException) {
-        sink.addError(error, stackTrace);
-      } else {
-        sink.add(new LoadExceptionSuite(error, stackTrace));
-      }
-    })).toList();
+    var engine = new Engine(concurrency: concurrency);
 
-    if (closed) return;
-    suites = flatten(suites);
+    var watch = options["reporter"] == "compact"
+        ? CompactReporter.watch
+        : ExpandedReporter.watch;
 
-    var pattern;
-    if (options["name"] != null) {
-      if (options["plain-name"] != null) {
-        _printUsage("--name and --plain-name may not both be passed.");
-        exitCode = exit_codes.data;
-        return;
-      }
-      pattern = new RegExp(options["name"]);
-    } else if (options["plain-name"] != null) {
-      pattern = options["plain-name"];
-    }
-
-    if (pattern != null) {
-      suites = suites.map((suite) {
-        // Don't ever filter out load errors.
-        if (suite is LoadExceptionSuite) return suite;
-        return suite.change(
-            tests: suite.tests.where((test) => test.name.contains(pattern)));
-      }).toList();
-
-      if (suites.every((suite) => suite.tests.isEmpty)) {
-        stderr.write('No tests match ');
-
-        if (pattern is RegExp) {
-          stderr.writeln('regular expression "${pattern.pattern}".');
-        } else {
-          stderr.writeln('"$pattern".');
-        }
-        exitCode = exit_codes.data;
-        return;
-      }
-    }
-
-    var reporter = options["reporter"] == "compact"
-        ? new CompactReporter(
-            flatten(suites),
-            concurrency: concurrency,
-            color: color,
-            verboseTrace: options["verbose-trace"])
-        : new ExpandedReporter(
-            flatten(suites),
-            concurrency: concurrency,
-            color: color,
-            verboseTrace: options["verbose-trace"]);
+    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((_) {
+    signalSubscription.onData((_) async {
       signalSubscription.cancel();
-      closed = true;
 
       // 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.");
       });
 
-      reporter.close().then((_) => timer.cancel());
+      await engine.close();
+      timer.cancel();
+      await loader.close();
     });
 
     try {
-      var success = await reporter.run();
-      exitCode = success ? 0 : 1;
+      var results = await Future.wait([
+        _loadSuites(paths, pattern, loader, engine),
+        engine.run()
+      ], eagerError: true);
+
+      // 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 reporter.close();
+      await engine.close();
+    }
+
+    if (engine.passed.length == 0 && engine.failed.length == 0 &&
+        engine.skipped.length == 0 && pattern != null) {
+      stderr.write('No tests match ');
+
+      if (pattern is RegExp) {
+        stderr.writeln('regular expression "${pattern.pattern}".');
+      } else {
+        stderr.writeln('"$pattern".');
+      }
+      exitCode = exit_codes.data;
     }
   } on ApplicationException catch (error) {
     stderr.writeln(error.message);
     exitCode = exit_codes.data;
   } catch (error, stackTrace) {
     stderr.writeln(getErrorMessage(error));
     stderr.writeln(new Trace.from(stackTrace).terse);
     stderr.writeln(
         "This is an unexpected error. Please file an issue at "
             "http://github.com/dart-lang/test\n"
         "with the stack trace and instructions for reproducing the error.");
     exitCode = exit_codes.software;
   } finally {
     signalSubscription.cancel();
     await loader.close();
   }
 }
 
+/// 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();
+
+  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),

[kevmoo, 2015/06/17 22:20:04]

consider using await async here – won't need a completer, etc

[nweiz, 2015/06/17 22:41:08]

We can't use it here, because we need to intercept errors... potentially more
than one.

+      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());
+
+  await completer.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.
 void _printUsage([String error]) {
   var output = stdout;
 
   var message = "Runs tests in this package.";
   if (error != null) {
     message = error;
@@ skipping 58 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;
   }
 }