Tighten types in test.dart even more.

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 23 matching lines @@
 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();
+typedef Future<AdbCommandResult> StepFunction();
 
 // Some IO tests use these variables and get confused if the host environment
 // variables are inherited so they are excluded.
 const EXCLUDED_ENVIRONMENT_VARIABLES = const [
   'http_proxy',
   'https_proxy',
   'no_proxy',
   'HTTP_PROXY',
   'HTTPS_PROXY',
   'NO_PROXY'
@@ skipping 205 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 = {};
+  static Map<AddFlagsKey, Map<String, String>> environments = {};
 
   static Map<String, String> _getEnvironment(
       Map<String, String> env, List<String> dartFlags) {
     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)
+          () => new Map<String, String>.from(env)
             ..addAll({'DART_FLAGS': flags, 'DART_FORWARDING_PRINT': '1'}));
     }
     return env;
   }
 
   static List<String> _getArguments(List<String> options, String htmlFile) {
     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 Map<String, dynamic> configuration;
   final bool retry;
 
   BrowserTestCommand._(
       String _browser, this.url, this.configuration, this.retry)
       : browser = _browser,
         super._(_browser);
 
   void _buildHashCode(HashCodeBuilder builder) {
     super._buildHashCode(builder);
     builder.addJson(browser);
@@ skipping 17 matching lines @@
       url
     ];
     return parts.map(escapeCommandLineArgument).join(' ');
   }
 
   int get maxNumRetries => 4;
 }
 
 class BrowserHtmlTestCommand extends BrowserTestCommand {
   List<String> expectedMessages;
-  BrowserHtmlTestCommand._(String browser, String url, Map configuration,
-      this.expectedMessages, bool retry)
+  BrowserHtmlTestCommand._(String browser, String url,
+      Map<String, dynamic> configuration, this.expectedMessages, bool retry)
       : super._(browser, url, configuration, retry);
 
   void _buildHashCode(HashCodeBuilder builder) {
     super._buildHashCode(builder);
     builder.addJson(expectedMessages);
   }
 
   bool _equal(BrowserHtmlTestCommand other) =>
       super._equal(other) &&
       identical(expectedMessages, other.expectedMessages);
@@ skipping 226 matching lines @@
       String executable,
       String htmlFile,
       List<String> options,
       List<String> dartFlags,
       Map<String, String> environment) {
     ContentShellCommand command = new ContentShellCommand._(
         executable, htmlFile, options, dartFlags, environment);
     return _getUniqueCommand(command);
   }
 
-  BrowserTestCommand getBrowserTestCommand(
-      String browser, String url, Map configuration, bool retry) {
+  BrowserTestCommand getBrowserTestCommand(String browser, String url,
+      Map<String, dynamic> configuration, bool retry) {
     var command = new BrowserTestCommand._(browser, url, configuration, retry);
     return _getUniqueCommand(command);
   }
 
-  BrowserHtmlTestCommand getBrowserHtmlTestCommand(String browser, String url,
-      Map configuration, List<String> expectedMessages, bool retry) {
+  BrowserHtmlTestCommand getBrowserHtmlTestCommand(
+      String browser,
+      String url,
+      Map<String, dynamic> configuration,
+      List<String> expectedMessages,
+      bool retry) {
     var command = new BrowserHtmlTestCommand._(
         browser, url, configuration, expectedMessages, retry);
     return _getUniqueCommand(command);
   }
 
   CompilationCommand getCompilationCommand(
       String displayName,
       String outputFile,
       bool neverSkipCompilation,
       List<Uri> bootstrapDependencies,
@@ skipping 175 matching lines @@
     // We don't want to keep the entire (large) TestInformation structure,
     // so we copy the needed bools into flags set in a single integer.
     if (info.hasRuntimeError) _expectations |= HAS_RUNTIME_ERROR;
     if (info.hasStaticWarning) _expectations |= HAS_STATIC_WARNING;
     if (info.isNegativeIfChecked) _expectations |= IS_NEGATIVE_IF_CHECKED;
     if (info.hasCompileError) _expectations |= HAS_COMPILE_ERROR;
     if (info.hasCompileErrorIfChecked) {
       _expectations |= HAS_COMPILE_ERROR_IF_CHECKED;
     }
     if (info.hasCompileError ||
-        (configuration['checked'] && info.hasCompileErrorIfChecked)) {
+        ((configuration['checked'] as bool) && info.hasCompileErrorIfChecked)) {
       _expectations |= EXPECT_COMPILE_ERROR;
     }
   }
 
   bool get isNegative => _expectations & IS_NEGATIVE != 0;
   bool get hasRuntimeError => _expectations & HAS_RUNTIME_ERROR != 0;
   bool get hasStaticWarning => _expectations & HAS_STATIC_WARNING != 0;
   bool get isNegativeIfChecked => _expectations & IS_NEGATIVE_IF_CHECKED != 0;
   bool get hasCompileError => _expectations & HAS_COMPILE_ERROR != 0;
   bool get hasCompileErrorIfChecked =>
@@ skipping 22 matching lines @@
     if (commandOutputs.length == 0) {
       throw new Exception("CommandOutputs is empty, maybe no command was run? ("
           "displayName: '$displayName', "
           "configurationString: '$configurationString')");
     }
     return commands[commandOutputs.length - 1];
   }
 
   int get timeout {
     if (expectedOutcomes.contains(Expectation.slow)) {
-      return configuration['timeout'] * SLOW_TIMEOUT_MULTIPLIER;
+      return (configuration['timeout'] as int) * SLOW_TIMEOUT_MULTIPLIER;
     } else {
-      return configuration['timeout'];
+      return configuration['timeout'] as int;
     }
   }
 
   String get configurationString {
-    final compiler = configuration['compiler'];
-    final runtime = configuration['runtime'];
-    final mode = configuration['mode'];
-    final arch = configuration['arch'];
-    final checked = configuration['checked'] ? '-checked' : '';
+    var compiler = configuration['compiler'] as String;
+    var runtime = configuration['runtime'] as String;
+    var mode = configuration['mode'] as String;
+    var arch = configuration['arch'] as String;
+    var checked = configuration['checked'] as bool ? '-checked' : '';
     return "$compiler-$runtime$checked ${mode}_$arch";
   }
 
   List<String> get batchTestArguments {
     assert(commands.last is ProcessCommand);
     return (commands.last as ProcessCommand).arguments;
   }
 
   bool get isFlaky {
     if (expectedOutcomes.contains(Expectation.skip) ||
@@ skipping 16 matching lines @@
 
 /**
  * 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(
       String displayName,
       List<Command> commands,
-      configuration,
+      Map<String, dynamic> 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;
@@ skipping 343 matching lines @@
     'script_onerror',
     'window_compilationerror',
     'print',
     'message_received',
     'dom',
     'debug'
   ];
 
   final Expectation outcome;
   final String htmlDom;
-  final List events;
+  final List<dynamic> events;
 
   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";
       }
     }
 
     try {
       var events = JSON.decode(content);
       if (events != null) {
         validate("Message must be a List", events is List);
 
-        Map<String, List<String>> messagesByType = {};
+        var messagesByType = <String, List<String>>{};
         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'];
-          var value = entry['value'];
+          var value = entry['value'] as String;
           var timestamp = entry['timestamp'];
 
           validate("'type' of an entry must be a String", type is String);
           validate("'type' has to be in $ALLOWED_TYPES.",
               ALLOWED_TYPES.contains(type));
           validate(
               "'timestamp' of an entry must be a number", timestamp is num);
 
           messagesByType[type].add(value);
         }
         validate("The message must have exactly one 'dom' entry.",
             messagesByType['dom'].length == 1);
 
         var dom = messagesByType['dom'][0];
         if (dom.endsWith('\n')) {
           dom = '$dom\n';
         }
 
         return new BrowserTestJsonResult(
-            _getOutcome(messagesByType), dom, events);
+            _getOutcome(messagesByType), dom, events as List<dynamic>);
       }
     } catch (error) {
       // 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;
   }
@@ skipping 578 matching lines @@
 
 // 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(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", "${pids[0]}"], runInShell: true);
-    lines = result.stdout.split('\n');
+    lines = (result.stdout as String).split('\n');
   } else if (io.Platform.isWindows) {
     var result = await io.Process.run(
         "wmic",
         [
           "process",
           "where",
           "(ParentProcessId=${pids[0]})",
           "get",
           "ProcessId"
         ],
         runInShell: true);
-    lines = result.stdout.split('\n');
+    lines = (result.stdout as String).split('\n');
     // Skip first line containing header "ProcessId".
     startLine = 1;
   } else {
     assert(false);
   }
   if (lines.length > startLine) {
     for (var i = startLine; i < lines.length; ++i) {
       var pid = int.parse(lines[i], onError: (source) => null);
       if (pid != null) pids.add(pid);
     }
@@ skipping 95 matching lines @@
               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") ||
+                var isX64 = command.executable.contains("X64") ||
                     command.executable.contains("SIMARM64");
-                var winSdkPath = configuration['win_sdk_path'];
+                var winSdkPath = configuration['win_sdk_path'] as String;
                 if (winSdkPath != null) {
                   executable = winSdkPath +
                       "\\Debuggers\\" +
-                      (is_x64 ? "x64" : "x86") +
+                      (isX64 ? "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 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");
                   try {
                     var result = await io.Process.run(executable, arguments);
-                    diagnostics.addAll(result.stdout.split('\n'));
-                    diagnostics.addAll(result.stderr.split('\n'));
+                    diagnostics.addAll((result.stdout as String).split('\n'));
+                    diagnostics.addAll((result.stderr as String).split('\n'));
                   } catch (error) {
                     diagnostics.add("Unable to capture stack traces: $error");
                   }
                 }
               }
 
               if (!process.kill()) {
                 diagnostics.add("Unable to kill ${process.pid}");
               }
             }
@@ skipping 65 matching lines @@
     commandOutput.diagnostics.addAll(diagnostics);
     return commandOutput;
   }
 
   StreamSubscription _drainStream(
       Stream<List<int>> source, OutputLog destination) {
     return source.listen(destination.add);
   }
 
   Map<String, String> _createProcessEnvironment() {
-    var environment = new Map.from(io.Platform.environment);
+    var environment = new Map<String, String>.from(io.Platform.environment);
 
     if (command.environmentOverrides != null) {
       for (var key in command.environmentOverrides.keys) {
         environment[key] = command.environmentOverrides[key];
       }
     }
     for (var excludedEnvironmentVariable in EXCLUDED_ENVIRONMENT_VARIABLES) {
       environment.remove(excludedEnvironmentVariable);
     }
 
@@ skipping 56 matching lines @@
       _stdoutSubscription.cancel();
       _stderrSubscription.cancel();
     } else {
       doStartTest(command, timeout);
     }
     return _completer.future;
   }
 
   Future<bool> terminate() {
     if (_process == null) return new Future.value(true);
-    Completer terminateCompleter = new Completer<bool>();
+    var terminateCompleter = new Completer<bool>();
     _processExitHandler = (_) {
       terminateCompleter.complete(true);
     };
     _process.kill();
     _stdoutSubscription.cancel();
     _stderrSubscription.cancel();
 
     return terminateCompleter.future;
   }
 
@@ skipping 60 matching lines @@
   void _timeoutHandler() {
     _processExitHandler = makeExitHandler(">>> TEST TIMEOUT");
     _process.kill();
   }
 
   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);
+    var environment = new Map<String, String>.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 419 matching lines @@
         } else {
           return new Future.value(output);
         }
       });
     }
 
     return runCommand(command.maxNumRetries);
   }
 
   Future<CommandOutput> _runCommand(Command command, int timeout) {
-    var batchMode = !globalConfiguration['noBatch'];
-    var dart2jsBatchMode = globalConfiguration['dart2js_batch'];
+    var batchMode = !(globalConfiguration['noBatch'] as bool);
+    var dart2jsBatchMode = globalConfiguration['dart2js_batch'] as bool;
 
     if (command is BrowserTestCommand) {
       return _startBrowserControllerTest(command, timeout);
     } else if (command is KernelCompilationCommand) {
       // For now, we always run dartk in batch mode.
       var name = command.displayName;
       assert(name == 'dartk');
       return _getBatchRunner(name)
           .runCommand(name, command, timeout, command.arguments);
     } else if (command is CompilationCommand && dart2jsBatchMode) {
@@ skipping 37 matching lines @@
     // We copy all the files which the vm precompiler puts into the test
     // directory.
     List<String> files = new io.Directory(testdir)
         .listSync()
         .map((file) => file.path)
         .map((path) => path.substring(path.lastIndexOf('/') + 1))
         .toList();
 
     var timeoutDuration = new Duration(seconds: timeout);
 
-    // All closures are of type "Future<AdbCommandResult> run()"
-    List<Function> steps = [];
+    var steps = <StepFunction>[];
 
     steps.add(() => device.runAdbShellCommand(['rm', '-Rf', deviceTestDir]));
     steps.add(() => device.runAdbShellCommand(['mkdir', '-p', deviceTestDir]));
     steps.add(() =>
         device.pushCachedData(runner, '$devicedir/dart_precompiled_runtime'));
     steps.add(
         () => device.pushCachedData(processTest, '$devicedir/process_test'));
     steps.add(() => device.runAdbShellCommand([
           'chmod',
           '777',
@@ skipping 77 matching lines @@
     }
     _getBrowserTestRunner(browserCommand.browser, browserCommand.configuration)
         .then((testRunner) {
       testRunner.enqueueTest(browserTest);
     });
 
     return completer.future;
   }
 
   Future<BrowserTestRunner> _getBrowserTestRunner(
-      String browser, Map configuration) async {
-    var localIp = globalConfiguration['local_ip'];
+      String browser, Map<String, dynamic> configuration) async {
+    var localIp = globalConfiguration['local_ip'] as String;
     if (_browserTestRunners[configuration] == null) {
       var testRunner = new BrowserTestRunner(
           configuration, localIp, browser, maxBrowserProcesses);
-      if (globalConfiguration['verbose']) {
+      if (globalConfiguration['verbose'] as bool) {
         testRunner.logger = DebugLogger.info;
       }
       _browserTestRunners[configuration] = testRunner;
       await testRunner.start();
     }
     return _browserTestRunners[configuration];
   }
 }
 
 class RecordingCommandExecutor implements CommandExecutor {
@@ skipping 309 matching lines @@
       _graph.events
           .where((event) => event is dgraph.GraphSealedEvent)
           .listen((event) {
         eventAllTestsKnown();
       });
 
       // Queue commands as they become "runnable"
       new CommandEnqueuer(_graph);
 
       // CommandExecutor will execute commands
-      var executor;
+      CommandExecutor executor;
       if (recording) {
         executor = new RecordingCommandExecutor(new Path(recordingOutputFile));
       } else if (replaying) {
         executor = new ReplayingCommandExecutor(new Path(recordedInputFile));
       } else {
         executor = new CommandExecutorImpl(
             _globalConfiguration, maxProcesses, maxBrowserProcesses,
             adbDevicePool: adbDevicePool);
       }
 
@@ skipping 23 matching lines @@
 
       resetDebugTimer();
     }
 
     // Build up the dependency graph
     testCaseEnqueuer = new TestCaseEnqueuer(_graph, (TestCase newTestCase) {
       eventTestAdded(newTestCase);
     });
 
     // Either list or run the tests
-    if (_globalConfiguration['list']) {
+    if (_globalConfiguration['list'] as bool) {
       setupForListing(testCaseEnqueuer);
     } else {
       setupForRunning(testCaseEnqueuer);
     }
 
     // Start enqueing all TestCases
     testCaseEnqueuer.enqueueTestSuites(testSuites);
   }
 
   void freeEnqueueingStructures() {
@@ skipping 19 matching lines @@
     }
   }
 
   void eventAllTestsDone() {
     for (var listener in _eventListener) {
       listener.allDone();
     }
     _allDone();
   }
 }