Make test.dart strong mode clean!

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 68 matching lines @@
   }
 
   operator ==(other) =>
       identical(this, other) ||
       (runtimeType == other.runtimeType && _equal(other));
 
   void _buildHashCode(HashCodeBuilder builder) {
     builder.addJson(displayName);
   }
 
-  bool _equal(Command other) =>
+  bool _equal(covariant Command other) =>
       hashCode == other.hashCode && displayName == other.displayName;
 
   String toString() => reproductionCommand;
 
   Future<bool> get outputIsUpToDate => new Future.value(false);
 }
 
 class ProcessCommand extends Command {
   /** Path to the executable of this command. */
   String executable;
@@ skipping 158 matching lines @@
       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 = new Map<AddFlagsKey, Map>();
+  static Map<AddFlagsKey, Map> environments = <AddFlagsKey, Map>{};
 
-  static Map _getEnvironment(Map env, List<String> dartFlags) {
+  static Map<String, String> _getEnvironment(
+      Map<String, String> env, List<String> dartFlags) {
     var needDartFlags = dartFlags != null && dartFlags.length > 0;
     if (needDartFlags) {
       if (env == null) {
-        env = const {};
+        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'}));
     }
     return env;
   }
 
   static List<String> _getArguments(List<String> options, String htmlFile) {
-    var arguments = new List.from(options);
+    var arguments = options.toList();
     arguments.add(htmlFile);
     return arguments;
   }
 
   int get maxNumRetries => 3;
 }
 
 class BrowserTestCommand extends Command {
   final String browser;
   final String url;
   final Map configuration;
   final bool retry;
 
   BrowserTestCommand._(
       String _browser, this.url, this.configuration, this.retry)
-      : super._(_browser),
-        browser = _browser;
+      : browser = _browser,
+        super._(_browser);
 
   void _buildHashCode(HashCodeBuilder builder) {
     super._buildHashCode(builder);
     builder.addJson(browser);
     builder.addJson(url);
     builder.add(configuration);
     builder.add(retry);
   }
 
   bool _equal(BrowserTestCommand other) =>
@@ skipping 122 matching lines @@
       String displayName, String executable, List<String> arguments,
       [Map<String, String> environmentOverrides = null])
       : super._(displayName, executable, arguments, environmentOverrides);
 }
 
 class PubCommand extends ProcessCommand {
   final String command;
 
   PubCommand._(String pubCommand, String pubExecutable,
       String pubspecYamlDirectory, String pubCacheDirectory, List<String> args)
-      : super._(
+      : command = pubCommand,
+        super._(
             'pub_$pubCommand',
             new io.File(pubExecutable).absolute.path,
             [pubCommand]..addAll(args),
             {'PUB_CACHE': pubCacheDirectory},
-            pubspecYamlDirectory),
-        command = pubCommand;
+            pubspecYamlDirectory);
 
   void _buildHashCode(HashCodeBuilder builder) {
     super._buildHashCode(builder);
     builder.addJson(command);
   }
 
   bool _equal(PubCommand other) =>
       super._equal(other) && command == other.command;
 }
 
@@ skipping 448 matching lines @@
  */
 abstract class CommandOutput {
   Command get command;
 
   Expectation result(TestCase testCase);
 
   bool get hasCrashed;
 
   bool get hasTimedOut;
 
-  bool didFail(testcase);
+  bool didFail(TestCase testCase);
 
   bool hasFailed(TestCase testCase);
 
   bool get canRunDependendCommands;
 
   bool get successful; // otherwise we might to retry running
 
   Duration get time;
 
   int get exitCode;
@@ skipping 133 matching lines @@
           "zygote crash. Test ignored");
       return true;
     }
     return false;
   }
 
   bool _infraFailure;
 
   BrowserCommandOutputImpl(
       command, exitCode, timedOut, stdout, stderr, time, compilationSkipped)
-      : super(command, exitCode, timedOut, stdout, stderr, time,
-            compilationSkipped, 0),
-        _infraFailure = _failedBecauseOfFlakyInfrastructure(stderr);
+      : _infraFailure = _failedBecauseOfFlakyInfrastructure(stderr),
+        super(command, exitCode, timedOut, stdout, stderr, time,
+            compilationSkipped, 0);
 
   Expectation result(TestCase testCase) {
     // Handle crashes and timeouts first
     if (hasCrashed) return Expectation.CRASH;
     if (hasTimedOut) return Expectation.TIMEOUT;
     if (hasNonUtf8) return Expectation.NON_UTF8_ERROR;
 
     if (_infraFailure) {
       return Expectation.IGNORE;
     }
@@ skipping 1150 matching lines @@
   }
 
   void _timeoutHandler() {
     _processExitHandler = makeExitHandler(">>> TEST TIMEOUT");
     _process.kill();
   }
 
   _startProcess(callback) {
     assert(_command is ProcessCommand);
     var executable = _command.executable;
-    var arguments = []
-      ..addAll(_command.batchArguments)
-      ..add('--batch');
+    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];
       }
     }
     Future processFuture =
         io.Process.start(executable, arguments, environment: environment);
     processFuture.then((io.Process p) {
       _process = p;
@@ skipping 88 matching lines @@
   final command2node = new Map<Command, dgraph.Node>();
   final command2testCases = new Map<Command, List<TestCase>>();
   final remainingTestCases = new Set<TestCase>();
 
   TestCaseEnqueuer(this.graph, this._onTestCaseAdded);
 
   void enqueueTestSuites(List<TestSuite> testSuites) {
     void newTest(TestCase testCase) {
       remainingTestCases.add(testCase);
 
-      var lastNode;
+      dgraph.Node lastNode;
       for (var command in testCase.commands) {
         // Make exactly *one* node in the dependency graph for every command.
         // This ensures that we never have two commands c1 and c2 in the graph
         // with "c1 == c2".
         var node = command2node[command];
         if (node == null) {
-          var requiredNodes = (lastNode != null) ? [lastNode] : [];
+          var requiredNodes = (lastNode != null) ? [lastNode] : <dgraph.Node>[];
           node = graph.newNode(command, requiredNodes);
           command2node[command] = node;
           command2testCases[command] = <TestCase>[];
         }
         // Keep mapping from command to all testCases that refer to it
         command2testCases[command].add(testCase);
 
         lastNode = node;
       }
       _onTestCaseAdded(testCase);
@@ skipping 33 matching lines @@
   static final FINISHED_STATES = [
     dgraph.NodeState.Successful,
     dgraph.NodeState.Failed,
     dgraph.NodeState.UnableToRun
   ];
   final dgraph.Graph _graph;
 
   CommandEnqueuer(this._graph) {
     var eventCondition = _graph.events.where;
 
-    eventCondition((e) => e is dgraph.NodeAddedEvent).listen((event) {
+    eventCondition((e) => e is dgraph.NodeAddedEvent).listen((e) {
+      var event = e as dgraph.NodeAddedEvent;
       dgraph.Node node = event.node;
       _changeNodeStateIfNecessary(node);
     });
 
-    eventCondition((e) => e is dgraph.StateChangedEvent).listen((event) {
+    eventCondition((e) => e is dgraph.StateChangedEvent).listen((e) {
+      var event = e as dgraph.StateChangedEvent;
       if ([dgraph.NodeState.Waiting, dgraph.NodeState.Processing]
           .contains(event.from)) {
         if (FINISHED_STATES.contains(event.to)) {
           for (var dependendNode in event.node.neededFor) {
             _changeNodeStateIfNecessary(dependendNode);
           }
         }
       }
     });
   }
@@ skipping 38 matching lines @@
  * nodes left in the states Initialized/Waiting/Enqueing/Processing
  * and the [executor] has cleaned up it's resources.
  */
 class CommandQueue {
   final dgraph.Graph graph;
   final CommandExecutor executor;
   final TestCaseEnqueuer enqueuer;
 
   final Queue<Command> _runQueue = new Queue<Command>();
   final _commandOutputStream = new StreamController<CommandOutput>(sync: true);
-  final _completer = new Completer();
+  final _completer = new Completer<Null>();
 
   int _numProcesses = 0;
   int _maxProcesses;
   int _numBrowserProcesses = 0;
   int _maxBrowserProcesses;
   bool _finishing = false;
   bool _verbose = false;
 
   CommandQueue(this.graph, this.enqueuer, this.executor, this._maxProcesses,
       this._maxBrowserProcesses, this._verbose) {
     var eventCondition = graph.events.where;
-    eventCondition((event) => event is dgraph.StateChangedEvent)
-        .listen((event) {
+    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;
         if (event.node.dependencies.length > 0) {
           _runQueue.addFirst(command);
         } else {
           _runQueue.add(command);
         }
@@ skipping 107 matching lines @@
  *
  * It provides a [runCommand] method which will complete with a
  * [CommandOutput] object.
  *
  * It provides a [cleanup] method to free all the allocated resources.
  */
 abstract class CommandExecutor {
   Future cleanup();
   // TODO(kustermann): The [timeout] parameter should be a property of Command
   Future<CommandOutput> runCommand(
-      dgraph.Node node, Command command, int timeout);
+      dgraph.Node node, covariant Command command, int timeout);
 }
 
 class CommandExecutorImpl implements CommandExecutor {
   final Map globalConfiguration;
   final int maxProcesses;
   final int maxBrowserProcesses;
   AdbDevicePool adbDevicePool;
 
   // For dart2js and analyzer batch processing,
   // we keep a list of batch processes.
   final _batchProcesses = new Map<String, List<BatchRunnerProcess>>();
   // We keep a BrowserTestRunner for every configuration.
   final _browserTestRunners = new Map<Map, BrowserTestRunner>();
 
   bool _finishing = false;
 
   CommandExecutorImpl(
       this.globalConfiguration, this.maxProcesses, this.maxBrowserProcesses,
       {this.adbDevicePool});
 
   Future cleanup() {
     assert(!_finishing);
     _finishing = true;
 
     Future _terminateBatchRunners() {
-      var futures = [];
+      var futures = <Future>[];
       for (var runners in _batchProcesses.values) {
         futures.addAll(runners.map((runner) => runner.terminate()));
       }
       return Future.wait(futures);
     }
 
     Future _terminateBrowserRunners() {
       var futures =
           _browserTestRunners.values.map((runner) => runner.terminate());
       return Future.wait(futures);
@@ skipping 324 matching lines @@
       _outputs[output.command] = output;
     }, onDone: () {
       _completeTestCasesIfPossible(new List.from(enqueuer.remainingTestCases));
       finishedRemainingTestCases = true;
       assert(enqueuer.remainingTestCases.isEmpty);
       _checkDone();
     });
 
     // Listen for NodeState.Processing -> NodeState.{Successful,Failed}
     // changes.
-    eventCondition((event) => event is dgraph.StateChangedEvent)
-        .listen((dgraph.StateChangedEvent event) {
+    eventCondition((event) => event is dgraph.StateChangedEvent).listen((e) {
+      var event = e as dgraph.StateChangedEvent;
       if (event.from == dgraph.NodeState.Processing &&
           !finishedRemainingTestCases) {
         var command = event.node.userData;
 
         assert(COMPLETED_STATES.contains(event.to));
         assert(_outputs[command] != null);
 
         _completeTestCasesIfPossible(enqueuer.command2testCases[command]);
         _checkDone();
       }
     });
 
     // Listen also for GraphSealedEvent's. If there is not a single node in the
     // graph, we still want to finish after the graph was sealed.
-    eventCondition((event) => event is dgraph.GraphSealedEvent)
-        .listen((dgraph.GraphSealedEvent event) {
+    eventCondition((event) => event is dgraph.GraphSealedEvent).listen((_) {
       if (!_closed && enqueuer.remainingTestCases.isEmpty) {
         _controller.close();
         _closed = true;
       }
     });
   }
 
   Stream<TestCase> get finishedTestCases => _controller.stream;
 
   void _checkDone() {
@@ skipping 43 matching lines @@
 
   ProcessQueue(this._globalConfiguration, maxProcesses, maxBrowserProcesses,
       DateTime startTime, 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((dgraph.GraphSealedEvent event) {
+          .listen((_) {
         var testCases = new List.from(testCaseEnqueuer.remainingTestCases);
         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}'");
@@ skipping 153 matching lines @@
     }
   }
 
   void eventAllTestsDone() {
     for (var listener in _eventListener) {
       listener.allDone();
     }
     _allDone();
   }
 }