Tighten up a bunch of types in test.dart.

tools/testing/dart/test_runner.dart

 // Copyright (c) 2012, 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.
 
 /**
  * Classes and methods for executing tests.
  *
  * This module includes:
  * - Managing parallel execution of tests, including timeout checks.
  * - Evaluating the output of each test as pass/fail/crash/timeout.
@@ skipping 22 matching lines @@
 const int CRASHING_BROWSER_EXITCODE = -10;
 const int SLOW_TIMEOUT_MULTIPLIER = 4;
 const int NON_UTF_FAKE_EXITCODE = 0xFFFD;
 
 const MESSAGE_CANNOT_OPEN_DISPLAY = 'Gtk-WARNING **: cannot open display';
 const MESSAGE_FAILED_TO_RUN_COMMAND = 'Failed to run command. return code=1';
 
 typedef void TestCaseEvent(TestCase testCase);
 typedef void ExitCodeEvent(int exitCode);
 typedef void EnqueueMoreWork(ProcessQueue queue);
+typedef void Action();
 
 // Some IO tests use these variables and get confused if the host environment
 // variables are inherited so they are excluded.
-const List<String> EXCLUDED_ENVIRONMENT_VARIABLES = const [
+const EXCLUDED_ENVIRONMENT_VARIABLES = const [
   'http_proxy',
   'https_proxy',
   'no_proxy',
   'HTTP_PROXY',
   'HTTPS_PROXY',
   'NO_PROXY'
 ];
 
 /** A command executed as a step in a test case. */
 class Command {
@@ skipping 14 matching lines @@
 
   int get hashCode {
     if (_cachedHashCode == null) {
       var builder = new HashCodeBuilder();
       _buildHashCode(builder);
       _cachedHashCode = builder.value;
     }
     return _cachedHashCode;
   }
 
-  operator ==(other) =>
+  operator ==(Object other) =>
       identical(this, other) ||
-      (runtimeType == other.runtimeType && _equal(other));
+      (runtimeType == other.runtimeType && _equal(other as Command));
 
   void _buildHashCode(HashCodeBuilder builder) {
     builder.addJson(displayName);
   }
 
   bool _equal(covariant Command other) =>
       hashCode == other.hashCode && displayName == other.displayName;
 
   String toString() => reproductionCommand;
 
@@ skipping 146 matching lines @@
 
   int get maxNumRetries => 1;
 }
 
 /// This is just a Pair(String, Map) class with hashCode and operator ==
 class AddFlagsKey {
   final String flags;
   final Map env;
   AddFlagsKey(this.flags, this.env);
   // Just use object identity for environment map
-  bool operator ==(other) =>
+  bool operator ==(Object other) =>
       other is AddFlagsKey && flags == other.flags && env == other.env;
   int get hashCode => flags.hashCode ^ env.hashCode;
 }
 
 class ContentShellCommand extends ProcessCommand {
   ContentShellCommand._(
       String executable,
       String htmlFile,
       List<String> options,
       List<String> dartFlags,
       Map<String, String> environmentOverrides)
       : super._("content_shell", executable, _getArguments(options, htmlFile),
             _getEnvironment(environmentOverrides, dartFlags));
 
   // Cache the modified environments in a map from the old environment and
   // the string of Dart flags to the new environment.  Avoid creating new
   // environment object for each command object.
-  static Map<AddFlagsKey, Map> environments = <AddFlagsKey, Map>{};
+  static Map<AddFlagsKey, Map> environments = {};
 
   static Map<String, String> _getEnvironment(
       Map<String, String> env, List<String> dartFlags) {
-    var needDartFlags = dartFlags != null && dartFlags.length > 0;
+    var needDartFlags = dartFlags != null && dartFlags.isNotEmpty;
     if (needDartFlags) {
       if (env == null) {
         env = const <String, String>{};
       }
       var flags = dartFlags.join(' ');
       return environments.putIfAbsent(
           new AddFlagsKey(flags, env),
           () => new Map.from(env)
             ..addAll({'DART_FLAGS': flags, 'DART_FORWARDING_PRINT': '1'}));
     }
@@ skipping 194 matching lines @@
 
   String get reproductionCommand =>
       "Copying '$_sourceDirectory' to '$_destinationDirectory'.";
 
   Future<ScriptCommandOutputImpl> run() {
     var watch = new Stopwatch()..start();
 
     var destination = new io.Directory(_destinationDirectory);
 
     return destination.exists().then((bool exists) {
-      var cleanDirectoryFuture;
+      Future cleanDirectoryFuture;
       if (exists) {
         cleanDirectoryFuture = TestUtils.deleteDirectory(_destinationDirectory);
       } else {
         cleanDirectoryFuture = new Future.value(null);
       }
       return cleanDirectoryFuture.then((_) {
         return TestUtils.copyDirectory(_sourceDirectory, _destinationDirectory);
       });
     }).then((_) {
       return new ScriptCommandOutputImpl(
@@ skipping 91 matching lines @@
 
   BrowserHtmlTestCommand getBrowserHtmlTestCommand(String browser, String url,
       Map configuration, List<String> expectedMessages, bool retry) {
     var command = new BrowserHtmlTestCommand._(
         browser, url, configuration, expectedMessages, retry);
     return _getUniqueCommand(command);
   }
 
   CompilationCommand getCompilationCommand(
       String displayName,
-      outputFile,
-      neverSkipCompilation,
+      String outputFile,
+      bool neverSkipCompilation,
       List<Uri> bootstrapDependencies,
       String executable,
       List<String> arguments,
       Map<String, String> environment) {
     var command = new CompilationCommand._(
         displayName,
         outputFile,
         neverSkipCompilation,
         bootstrapDependencies,
         executable,
         arguments,
         environment);
     return _getUniqueCommand(command);
   }
 
   CompilationCommand getKernelCompilationCommand(
       String displayName,
-      outputFile,
-      neverSkipCompilation,
+      String outputFile,
+      bool neverSkipCompilation,
       List<Uri> bootstrapDependencies,
       String executable,
       List<String> arguments,
       Map<String, String> environment) {
     var command = new KernelCompilationCommand._(
         displayName,
         outputFile,
         neverSkipCompilation,
         bootstrapDependencies,
         executable,
         arguments,
         environment);
     return _getUniqueCommand(command);
   }
 
-  AnalysisCommand getAnalysisCommand(
-      String displayName, executable, arguments, environmentOverrides,
+  AnalysisCommand getAnalysisCommand(String displayName, String executable,
+      List<String> arguments, Map<String, String> environmentOverrides,
       {String flavor: 'dart2analyzer'}) {
     var command = new AnalysisCommand._(
         flavor, displayName, executable, arguments, environmentOverrides);
     return _getUniqueCommand(command);
   }
 
   VmCommand getVmCommand(String executable, List<String> arguments,
       Map<String, String> environmentOverrides) {
     var command = new VmCommand._(executable, arguments, environmentOverrides);
     return _getUniqueCommand(command);
@@ skipping 12 matching lines @@
       String precompiledRunner,
       String processTest,
       String testDirectory,
       List<String> arguments,
       bool useBlobs) {
     var command = new AdbPrecompilationCommand._(
         precompiledRunner, processTest, testDirectory, arguments, useBlobs);
     return _getUniqueCommand(command);
   }
 
-  Command getJSCommandlineCommand(String displayName, executable, arguments,
-      [environment = null]) {
+  Command getJSCommandlineCommand(
+      String displayName, String executable, List<String> arguments,
+      [Map<String, String> environment]) {
     var command = new JSCommandlineCommand._(
         displayName, executable, arguments, environment);
     return _getUniqueCommand(command);
   }
 
-  Command getProcessCommand(String displayName, executable, arguments,
-      [environment = null, workingDirectory = null]) {
+  Command getProcessCommand(
+      String displayName, String executable, List<String> arguments,
+      [Map<String, String> environment, String workingDirectory]) {
     var command = new ProcessCommand._(
         displayName, executable, arguments, environment, workingDirectory);
     return _getUniqueCommand(command);
   }
 
   Command getCopyCommand(String sourceDirectory, String destinationDirectory) {
     var command =
         new CleanDirectoryCopyCommand._(sourceDirectory, destinationDirectory);
     return _getUniqueCommand(command);
   }
 
   Command getPubCommand(String pubCommand, String pubExecutable,
       String pubspecYamlDirectory, String pubCacheDirectory,
       {List<String> arguments: const <String>[]}) {
     var command = new PubCommand._(pubCommand, pubExecutable,
         pubspecYamlDirectory, pubCacheDirectory, arguments);
     return _getUniqueCommand(command);
   }
 
   Command getMakeSymlinkCommand(String link, String target) {
     return _getUniqueCommand(new MakeSymlinkCommand._(link, target));
   }
 
-  Command _getUniqueCommand(Command command) {
+  T _getUniqueCommand<T extends Command>(T command) {
     // All Command classes implement hashCode and operator==.
     // We check if this command has already been built.
     //  If so, we return the cached one. Otherwise we
     // store the one given as [command] argument.
     if (_cleared) {
       throw new Exception(
           "CommandBuilder.get[type]Command called after cache cleared");
     }
     var cachedCommand = _cachedCommands[command];
     if (cachedCommand != null) {
-      return cachedCommand;
+      return cachedCommand as T;
     }
     _cachedCommands[command] = command;
     return command;
   }
 }
 
 /**
  * TestCase contains all the information needed to run a test and evaluate
  * its output.  Running a test involves starting a separate process, with
  * the executable and arguments given by the TestCase, and recording its
@@ skipping 30 matching lines @@
       new Map<Command, CommandOutput>();
 
   Map configuration;
   String displayName;
   int _expectations = 0;
   int hash = 0;
   Set<Expectation> expectedOutcomes;
 
   TestCase(this.displayName, this.commands, this.configuration,
       this.expectedOutcomes,
-      {isNegative: false, TestInformation info: null}) {
+      {bool isNegative: false, TestInformation info}) {
     if (isNegative || displayName.contains("negative_test")) {
       _expectations |= IS_NEGATIVE;
     }
     if (info != null) {
       _setExpectations(info);
       hash =
           info.originTestPath.relativeTo(TestUtils.dartDir).toString().hashCode;
     }
   }
 
@@ skipping 89 matching lines @@
             commands.length == commandOutputs.length);
   }
 }
 
 /**
  * BrowserTestCase has an extra compilation command that is run in a separate
  * process, before the regular test is run as in the base class [TestCase].
  * If the compilation command fails, then the rest of the test is not run.
  */
 class BrowserTestCase extends TestCase {
-  BrowserTestCase(displayName, commands, configuration, expectedOutcomes, info,
-      isNegative, this._testingUrl)
+  BrowserTestCase(
+      String displayName,
+      List<Command> commands,
+      configuration,
+      Set<Expectation> expectedOutcomes,
+      TestInformation info,
+      bool isNegative,
+      this._testingUrl)
       : super(displayName, commands, configuration, expectedOutcomes,
             isNegative: isNegative, info: info);
 
   String _testingUrl;
 
   String get testingUrl => _testingUrl;
 }
 
 class UnittestSuiteMessagesMixin {
   bool _isAsyncTest(String testOutput) {
@@ skipping 188 matching lines @@
         command.browser == "ie11") {
       DebugLogger.warning("Timeout of ie11 on test page ${command.url}");
       return true;
     }
     return false;
   }
 
   bool _infraFailure;
 
   BrowserCommandOutputImpl(
-      command, exitCode, timedOut, stdout, stderr, time, compilationSkipped)
+      Command command,
+      int exitCode,
+      bool timedOut,
+      List<int> stdout,
+      List<int> stderr,
+      Duration time,
+      bool compilationSkipped)
       : _infraFailure =
             _failedBecauseOfFlakyInfrastructure(command, timedOut, stderr),
         super(command, exitCode, timedOut, stdout, stderr, time,
             compilationSkipped, 0);
 
   Expectation result(TestCase testCase) {
     if (_infraFailure) {
       return Expectation.IGNORE;
     }
     // Handle crashes and timeouts first
@@ skipping 86 matching lines @@
           (!isWindows || exitCode != WHITELISTED_CONTENTSHELL_EXITCODE));
     }
     DebugLogger.warning("Couldn't find 'Content-Type: text/plain' in output. "
         "($command).");
     return true;
   }
 }
 
 class HTMLBrowserCommandOutputImpl extends BrowserCommandOutputImpl {
   HTMLBrowserCommandOutputImpl(
-      command, exitCode, timedOut, stdout, stderr, time, compilationSkipped)
+      Command command,
+      int exitCode,
+      bool timedOut,
+      List<int> stdout,
+      List<int> stderr,
+      Duration time,
+      bool compilationSkipped)
       : super(command, exitCode, timedOut, stdout, stderr, time,
             compilationSkipped);
 
   bool didFail(TestCase testCase) {
     return _getOutcome() != Expectation.PASS;
   }
 
   bool get _browserTestFailure {
     // We should not need to convert back and forward.
     var output = decodeUtf8(super.stdout);
@@ skipping 21 matching lines @@
   BrowserTestJsonResult(this.outcome, this.htmlDom, this.events);
 
   static BrowserTestJsonResult parseFromString(String content) {
     void validate(String assertion, bool value) {
       if (!value) {
         throw "InvalidFormat sent from browser driving page: $assertion:\n\n"
             "$content";
       }
     }
 
-    var events;
     try {
-      events = JSON.decode(content);
+      var events = JSON.decode(content);
       if (events != null) {
         validate("Message must be a List", events is List);
 
         Map<String, List<String>> messagesByType = {};
         ALLOWED_TYPES.forEach((type) => messagesByType[type] = <String>[]);
 
         for (var entry in events) {
           validate("An entry must be a Map", entry is Map);
 
           var type = entry['type'];
@@ skipping 23 matching lines @@
       // If something goes wrong, we know the content was not in the correct
       // JSON format. So we can't parse it.
       // The caller is responsible for falling back to the old way of
       // determining if a test failed.
     }
 
     return null;
   }
 
   static Expectation _getOutcome(Map<String, List<String>> messagesByType) {
-    occured(type) => messagesByType[type].length > 0;
-    searchForMsg(types, message) {
+    occured(String type) => messagesByType[type].length > 0;
+    searchForMsg(List<String> types, String message) {
       return types.any((type) => messagesByType[type].contains(message));
     }
 
     // FIXME(kustermann,ricow): I think this functionality doesn't work in
     // test_controller.js: So far I haven't seen anything being reported on
     // "window.compilationerror"
     if (occured('window_compilationerror')) {
       return Expectation.COMPILETIME_ERROR;
     }
 
@@ skipping 125 matching lines @@
 
 class AnalysisCommandOutputImpl extends CommandOutputImpl {
   // An error line has 8 fields that look like:
   // ERROR|COMPILER|MISSING_SOURCE|file:/tmp/t.dart|15|1|24|Missing source.
   final int ERROR_LEVEL = 0;
   final int ERROR_TYPE = 1;
   final int FILENAME = 3;
   final int FORMATTED_ERROR = 7;
 
   AnalysisCommandOutputImpl(
-      command, exitCode, timedOut, stdout, stderr, time, compilationSkipped)
+      Command command,
+      int exitCode,
+      bool timedOut,
+      List<int> stdout,
+      List<int> stderr,
+      Duration time,
+      bool compilationSkipped)
       : super(command, exitCode, timedOut, stdout, stderr, time,
             compilationSkipped, 0);
 
   Expectation result(TestCase testCase) {
     // TODO(kustermann): If we run the analyzer not in batch mode, make sure
     // that command.exitCodes matches 2 (errors), 1 (warnings), 0 (no warnings,
     // no errors)
 
     // Handle crashes and timeouts first
     if (hasCrashed) return Expectation.CRASH;
@@ skipping 405 matching lines @@
       head = null;
       tail = null;
       _checkUtf8(complete);
     }
     return complete;
   }
 }
 
 // Helper to get a list of all child pids for a parent process.
 // The first element of the list is the parent pid.
-Future<List<int>> _getPidList(pid, diagnostics) async {
-  var pid_list = [pid];
-  var lines;
-  var start_line = 0;
+Future<List<int>> _getPidList(int pid, List<String> diagnostics) async {
+  var pids = [pid];
+  List<String> lines;
+  var startLine = 0;
   if (io.Platform.isLinux || io.Platform.isMacOS) {
-    var result = await io.Process
-        .run("pgrep", ["-P", "${pid_list[0]}"], runInShell: true);
+    var result =
+        await io.Process.run("pgrep", ["-P", "${pids[0]}"], runInShell: true);
     lines = result.stdout.split('\n');
   } else if (io.Platform.isWindows) {
     var result = await io.Process.run(
         "wmic",
         [
           "process",
           "where",
-          "(ParentProcessId=${pid_list[0]})",
+          "(ParentProcessId=${pids[0]})",
           "get",
           "ProcessId"
         ],
         runInShell: true);
     lines = result.stdout.split('\n');
     // Skip first line containing header "ProcessId".
-    start_line = 1;
+    startLine = 1;
   } else {
     assert(false);
   }
-  if (lines.length > start_line) {
-    for (int i = start_line; i < lines.length; ++i) {
+  if (lines.length > startLine) {
+    for (var i = startLine; i < lines.length; ++i) {
       var pid = int.parse(lines[i], onError: (source) => null);
-      if (pid != null) pid_list.add(pid);
+      if (pid != null) pids.add(pid);
     }
   } else {
     diagnostics.add("Could not find child pids");
     diagnostics.addAll(lines);
   }
-  return pid_list;
+  return pids;
 }
 
 /**
  * A RunningProcess actually runs a test, getting the command lines from
  * its [TestCase], starting the test process (and first, a compilation
  * process if the TestCase is a [BrowserTestCase]), creating a timeout
  * timer, and recording the results in a new [CommandOutput] object, which it
  * attaches to the TestCase.  The lifetime of the RunningProcess is limited
  * to the time it takes to start the process, run the process, and record
  * the result; there are no pointers to it, so it should be available to
@@ skipping 32 matching lines @@
         var args = command.arguments;
         Future processFuture = io.Process.start(command.executable, args,
             environment: processEnvironment,
             workingDirectory: command.workingDirectory);
         processFuture.then((io.Process process) {
           StreamSubscription stdoutSubscription =
               _drainStream(process.stdout, stdout);
           StreamSubscription stderrSubscription =
               _drainStream(process.stderr, stderr);
 
-          var stdoutCompleter = new Completer();
-          var stderrCompleter = new Completer();
+          var stdoutCompleter = new Completer<Null>();
+          var stderrCompleter = new Completer<Null>();
 
           bool stdoutDone = false;
           bool stderrDone = false;
           pid = process.pid;
 
           // This timer is used to close stdio to the subprocess once we got
           // the exitCode. Sometimes descendants of the subprocess keep stdio
           // handles alive even though the direct subprocess is dead.
           Timer watchdogTimer;
 
@@ skipping 16 matching lines @@
                 watchdogTimer.cancel();
               }
             }
           }
 
           // Close stdin so that tests that try to block on input will fail.
           process.stdin.close();
           timeoutHandler() async {
             timedOut = true;
             if (process != null) {
-              var executable;
+              String executable;
               if (io.Platform.isLinux) {
                 executable = 'eu-stack';
               } else if (io.Platform.isMacOS) {
                 // Try to print stack traces of the timed out process.
                 // `sample` is a sampling profiler but we ask it sample for 1
                 // second with a 4 second delay between samples so that we only
                 // sample the threads once.
                 executable = '/usr/bin/sample';
               } else if (io.Platform.isWindows) {
                 bool is_x64 = command.executable.contains("X64") ||
                     command.executable.contains("SIMARM64");
-                var win_sdk_path = configuration['win_sdk_path'];
-                if (win_sdk_path != null) {
-                  executable = win_sdk_path +
+                var winSdkPath = configuration['win_sdk_path'];
+                if (winSdkPath != null) {
+                  executable = winSdkPath +
                       "\\Debuggers\\" +
                       (is_x64 ? "x64" : "x86") +
                       "\\cdb.exe";
                   diagnostics.add("Using $executable to print stack traces");
                 } else {
                   diagnostics.add("win_sdk path not found");
                 }
               } else {
                 diagnostics.add("Capturing stack traces on"
                     "${io.Platform.operatingSystem} not supported");
               }
               if (executable != null) {
-                var pid_list = await _getPidList(process.pid, diagnostics);
-                diagnostics.add("Process list including children: $pid_list");
-                for (pid in pid_list) {
-                  var arguments;
+                var pids = await _getPidList(process.pid, diagnostics);
+                diagnostics.add("Process list including children: $pids");
+                for (pid in pids) {
+                  List<String> arguments;
                   if (io.Platform.isLinux) {
                     arguments = ['-p $pid'];
                   } else if (io.Platform.isMacOS) {
                     arguments = ['$pid', '1', '4000', '-mayDie'];
                   } else if (io.Platform.isWindows) {
                     arguments = ['-p', '$pid', '-c', '!uniqstack;qd'];
                   } else {
                     assert(false);
                   }
                   diagnostics.add("Trying to capture stack trace for pid $pid");
@@ skipping 105 matching lines @@
   }
 }
 
 class BatchRunnerProcess {
   Completer<CommandOutput> _completer;
   ProcessCommand _command;
   List<String> _arguments;
   String _runnerType;
 
   io.Process _process;
-  Map _processEnvironmentOverrides;
-  Completer _stdoutCompleter;
-  Completer _stderrCompleter;
+  Map<String, String> _processEnvironmentOverrides;
+  Completer<Null> _stdoutCompleter;
+  Completer<Null> _stderrCompleter;
   StreamSubscription<String> _stdoutSubscription;
   StreamSubscription<String> _stderrSubscription;
   Function _processExitHandler;
 
   bool _currentlyRunning = false;
   OutputLog _testStdout;
   OutputLog _testStderr;
   String _status;
   DateTime _startTime;
   Timer _timer;
 
   Future<CommandOutput> runCommand(String runnerType, ProcessCommand command,
       int timeout, List<String> arguments) {
     assert(_completer == null);
     assert(!_currentlyRunning);
 
-    _completer = new Completer<CommandOutput>();
+    _completer = new Completer();
     bool sameRunnerType = _runnerType == runnerType &&
         _dictEquals(_processEnvironmentOverrides, command.environmentOverrides);
     _runnerType = runnerType;
     _currentlyRunning = true;
     _command = command;
     _arguments = arguments;
     _processEnvironmentOverrides = command.environmentOverrides;
 
     if (_process == null) {
       // Start process if not yet started.
       _startProcess(() {
         doStartTest(command, timeout);
       });
     } else if (!sameRunnerType) {
       // Restart this runner with the right executable for this test if needed.
       _processExitHandler = (_) {
         _startProcess(() {
           doStartTest(command, timeout);
         });
       };
       _process.kill();
       _stdoutSubscription.cancel();
       _stderrSubscription.cancel();
     } else {
       doStartTest(command, timeout);
     }
     return _completer.future;
   }
 
-  Future terminate() {
+  Future<bool> terminate() {
     if (_process == null) return new Future.value(true);
-    Completer terminateCompleter = new Completer();
+    Completer terminateCompleter = new Completer<bool>();
     _processExitHandler = (_) {
       terminateCompleter.complete(true);
     };
     _process.kill();
     _stdoutSubscription.cancel();
     _stderrSubscription.cancel();
 
     return terminateCompleter.future;
   }
 
@@ skipping 55 matching lines @@
     }
 
     return handler;
   }
 
   void _timeoutHandler() {
     _processExitHandler = makeExitHandler(">>> TEST TIMEOUT");
     _process.kill();
   }
 
-  _startProcess(callback) {
+  void _startProcess(Action callback) {
     assert(_command is ProcessCommand);
     var executable = _command.executable;
     var arguments = _command.batchArguments.toList();
     arguments.add('--batch');
     var environment = new Map.from(io.Platform.environment);
     if (_processEnvironmentOverrides != null) {
       for (var key in _processEnvironmentOverrides.keys) {
         environment[key] = _processEnvironmentOverrides[key];
       }
     }
@@ skipping 237 matching lines @@
 
   CommandQueue(this.graph, this.enqueuer, this.executor, this._maxProcesses,
       this._maxBrowserProcesses, this._verbose) {
     var eventCondition = graph.events.where;
     eventCondition((e) => e is dgraph.StateChangedEvent).listen((e) {
       var event = e as dgraph.StateChangedEvent;
       if (event.to == dgraph.NodeState.Enqueuing) {
         assert(event.from == dgraph.NodeState.Initialized ||
             event.from == dgraph.NodeState.Waiting);
         graph.changeState(event.node, dgraph.NodeState.Processing);
-        var command = event.node.userData;
+        var command = event.node.userData as Command;
         if (event.node.dependencies.length > 0) {
           _runQueue.addFirst(command);
         } else {
           _runQueue.add(command);
         }
         Timer.run(() => _tryRunNextCommand());
       }
     });
     // We're finished if the graph is sealed and all nodes are in a finished
     // state (Successful, Failed or UnableToRun).
@@ skipping 197 matching lines @@
       return adbDevicePool.acquireDevice().then((AdbDevice device) {
         return _runAdbPrecompilationCommand(device, command, timeout)
             .whenComplete(() {
           adbDevicePool.releaseDevice(device);
         });
       });
     } else if (command is VmBatchCommand) {
       var name = command.displayName;
       return _getBatchRunner(command.displayName + command.dartFile)
           .runCommand(name, command, timeout, command.arguments);
-    } else {
+    } else if (command is ProcessCommand) {
       return new RunningProcess(command, timeout,
               configuration: globalConfiguration)
           .run();
+    } else {
+      throw new ArgumentError("Unknown command type ${command.runtimeType}.");
     }
   }
 
   Future<CommandOutput> _runAdbPrecompilationCommand(
       AdbDevice device, AdbPrecompilationCommand command, int timeout) async {
     var runner = command.precompiledRunnerFilename;
     var processTest = command.processTestFilename;
     var testdir = command.precompiledTestDirectory;
     var arguments = command.arguments;
     var devicedir = DartPrecompiledAdbRuntimeConfiguration.DeviceDir;
@@ skipping 323 matching lines @@
   }
 }
 
 class ProcessQueue {
   Map _globalConfiguration;
 
   Function _allDone;
   final dgraph.Graph _graph = new dgraph.Graph();
   List<EventListener> _eventListener;
 
-  ProcessQueue(this._globalConfiguration, maxProcesses, maxBrowserProcesses,
-      DateTime startTime, testSuites, this._eventListener, this._allDone,
+  ProcessQueue(
+      this._globalConfiguration,
+      int maxProcesses,
+      int maxBrowserProcesses,
+      DateTime startTime,
+      List<TestSuite> testSuites,
+      this._eventListener,
+      this._allDone,
       [bool verbose = false,
       String recordingOutputFile,
       String recordedInputFile,
       AdbDevicePool adbDevicePool]) {
     void setupForListing(TestCaseEnqueuer testCaseEnqueuer) {
       _graph.events
           .where((event) => event is dgraph.GraphSealedEvent)
           .listen((_) {
-        var testCases = new List.from(testCaseEnqueuer.remainingTestCases);
+        var testCases = testCaseEnqueuer.remainingTestCases.toList();
         testCases.sort((a, b) => a.displayName.compareTo(b.displayName));
 
         print("\nGenerating all matching test cases ....\n");
 
         for (TestCase testCase in testCases) {
           eventFinishedTestCase(testCase);
           print("${testCase.displayName}   "
               "Expectations: ${testCase.expectedOutcomes.join(', ')}   "
               "Configuration: '${testCase.configurationString}'");
         }
         eventAllTestsKnown();
       });
     }
 
-    var testCaseEnqueuer;
+    TestCaseEnqueuer testCaseEnqueuer;
     CommandQueue commandQueue;
 
     void setupForRunning(TestCaseEnqueuer testCaseEnqueuer) {
       Timer _debugTimer;
       // If we haven't seen a single test finishing during a 10 minute period
       // something is definitely wrong, so we dump the debugging information.
       final debugTimerDuration = const Duration(minutes: 10);
 
       void cancelDebugTimer() {
         if (_debugTimer != null) {
@@ skipping 137 matching lines @@
     }
   }
 
   void eventAllTestsDone() {
     for (var listener in _eventListener) {
       listener.allDone();
     }
     _allDone();
   }
 }