Tighten types in test.dart even more.

tools/testing/dart/test_suite.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 enumerating and preparing tests.
  *
  * This library includes:
  *
  * - Creating tests by listing all the Dart files in certain directories,
  *   and creating [TestCase]s for those files that meet the relevant criteria.
  * - Preparing tests, including copying files and frameworks to temporary
  *   directories, and computing the command line and arguments to be run.
  */
 library test_suite;
 
 import "dart:async";
 import "dart:io";
 import "dart:math";
 import "drt_updater.dart";
 import "html_test.dart" as htmlTest;
+import "http_server.dart";
 import "path.dart";
 import "multitest.dart";
 import "expectation.dart";
 import "expectation_set.dart";
 import "summary_report.dart";
 import "test_runner.dart";
 import "utils.dart";
 import "http_server.dart" show PREFIX_BUILDDIR, PREFIX_DARTDIR;
 
 import "compiler_configuration.dart"
@@ skipping 22 matching lines @@
     bool hasStaticWarning,
     String multitestKey});
 
 typedef void VoidFunction();
 
 /**
  * Calls [function] asynchronously. Returns a future that completes with the
  * result of the function. If the function is `null`, returns a future that
  * completes immediately with `null`.
  */
-Future asynchronously(function()) {
-  if (function == null) return new Future.value(null);
+Future asynchronously<T>(T function()) {
+  if (function == null) return new Future<T>.value(null);
 
-  var completer = new Completer();
+  var completer = new Completer<T>();
   Timer.run(() => completer.complete(function()));
 
   return completer.future;
 }
 
 /** A completer that waits until all added [Future]s complete. */
 // TODO(rnystrom): Copied from web_components. Remove from here when it gets
 // added to dart:core. (See #6626.)
 class FutureGroup {
   static const _FINISHED = -1;
@@ skipping 45 matching lines @@
   final String suiteName;
   // This function is set by subclasses before enqueueing starts.
   Function doTest;
   Map<String, String> _environmentOverrides;
   RuntimeConfiguration runtimeConfiguration;
 
   TestSuite(this.configuration, this.suiteName) {
     TestUtils.buildDir(configuration); // Sets configuration_directory.
     if (configuration['configuration_directory'] != null) {
       _environmentOverrides = {
-        'DART_CONFIGURATION': configuration['configuration_directory']
+        'DART_CONFIGURATION': configuration['configuration_directory'] as String
       };
     }
     runtimeConfiguration = new RuntimeConfiguration(configuration);
   }
 
   Map<String, String> get environmentOverrides => _environmentOverrides;
 
   /**
    * Whether or not binaries should be found in the root build directory or
    * in the built SDK.
@@ skipping 10 matching lines @@
     // rebuilding the SDK, and similarly, it should be convenient for pub
     // developers.
     // Third, even if pub can only run from the SDK directory, this is the
     // wrong place to work around that problem. Instead, test_options.dart
     // should have been modified so that configuration['use_sdk'] is always
     // true when testing pub. Attempting to override the value here is brittle
     // because we read configuration['use_sdk'] directly in many places without
     // using this getter.
     if (suiteName == 'pub') return true;
 
-    return configuration['use_sdk'];
+    return configuration['use_sdk'] as bool;
   }
 
   /**
    * The output directory for this suite's configuration.
    */
   String get buildDir => TestUtils.buildDir(configuration);
 
   /**
    * The path to the compiler for this suite's configuration. Returns `null` if
    * no compiler should be used.
    */
   String get compilerPath {
     var compilerConfiguration = new CompilerConfiguration(configuration);
     if (!compilerConfiguration.hasCompiler) return null;
-    String name = compilerConfiguration.computeCompilerPath(buildDir);
+    var name = compilerConfiguration.computeCompilerPath(buildDir);
     // TODO(ahe): Only validate this once, in test_options.dart.
     TestUtils.ensureExists(name, configuration);
     return name;
   }
 
   String get pubPath {
     var prefix = 'sdk/bin/';
-    if (configuration['use_sdk']) {
+    if (configuration['use_sdk'] as bool) {
       prefix = '$buildDir/dart-sdk/bin/';
     }
-    String suffix = getExecutableSuffix('pub');
+    var suffix = getExecutableSuffix('pub');
     var name = '${prefix}pub$suffix';
     TestUtils.ensureExists(name, configuration);
     return name;
   }
 
   /// Returns the name of the Dart VM executable.
   String get dartVmBinaryFileName {
     // Controlled by user with the option "--dart".
-    String dartExecutable = configuration['dart'];
+    var dartExecutable = configuration['dart'] as String;
 
     if (dartExecutable == '') {
-      String suffix = executableBinarySuffix;
+      var suffix = executableBinarySuffix;
       dartExecutable = useSdk
           ? '$buildDir/dart-sdk/bin/dart$suffix'
           : '$buildDir/dart$suffix';
     }
 
     TestUtils.ensureExists(dartExecutable, configuration);
     return dartExecutable;
   }
 
   /// Returns the name of the flutter engine executable.
   String get flutterEngineBinaryFileName {
     // Controlled by user with the option "--flutter".
-    String flutterExecutable = configuration['flutter'];
+    var flutterExecutable = configuration['flutter'] as String;
     TestUtils.ensureExists(flutterExecutable, configuration);
     return flutterExecutable;
   }
 
   String get dartPrecompiledBinaryFileName {
     // Controlled by user with the option "--dart_precompiled".
-    String dartExecutable = configuration['dart_precompiled'];
+    var dartExecutable = configuration['dart_precompiled'] as String;
 
     if (dartExecutable == null || dartExecutable == '') {
-      String suffix = executableBinarySuffix;
+      var suffix = executableBinarySuffix;
       dartExecutable = '$buildDir/dart_precompiled_runtime$suffix';
     }
 
     TestUtils.ensureExists(dartExecutable, configuration);
     return dartExecutable;
   }
 
   String get processTestBinaryFileName {
-    String suffix = executableBinarySuffix;
-    String processTestExecutable = '$buildDir/process_test$suffix';
+    var suffix = executableBinarySuffix;
+    var processTestExecutable = '$buildDir/process_test$suffix';
     TestUtils.ensureExists(processTestExecutable, configuration);
     return processTestExecutable;
   }
 
   String get d8FileName {
     var suffix = getExecutableSuffix('d8');
     var d8Dir = TestUtils.dartDir.append('third_party/d8');
     var d8Path = d8Dir.append('${Platform.operatingSystem}/d8$suffix');
     var d8 = d8Path.toNativePath();
     TestUtils.ensureExists(d8, configuration);
@@ skipping 26 matching lines @@
   String get executableBinarySuffix => Platform.isWindows ? '.exe' : '';
 
   /**
    * Call the callback function onTest with a [TestCase] argument for each
    * test in the suite.  When all tests have been processed, call [onDone].
    *
    * The [testCache] argument provides a persistent store that can be used to
    * cache information about the test suite, so that directories do not need
    * to be listed each time.
    */
-  void forEachTest(TestCaseEvent onTest, Map testCache, [VoidFunction onDone]);
+  Future forEachTest(
+      TestCaseEvent onTest, Map<String, List<TestInformation>> testCache,
+      [VoidFunction onDone]);
 
   // This function will be called for every TestCase of this test suite.
   // It will
   //  - handle sharding
   //  - update SummaryReport
   //  - handle SKIP/SKIP_BY_DESIGN markers
   //  - test if the selector matches
   // and will enqueue the test (if necessary).
   void enqueueNewTestCase(TestCase testCase) {
     if (testCase.isNegative && runtimeConfiguration.shouldSkipNegativeTests) {
       return;
     }
     var expectations = testCase.expectedOutcomes;
 
     // Handle sharding based on the original test path (i.e. all multitests
     // of a given original test belong to the same shard)
-    int shards = configuration['shards'];
-    if (shards > 1 && testCase.hash % shards != configuration['shard'] - 1) {
+    var shards = configuration['shards'] as int;
+    if (shards > 1 &&
+        testCase.hash % shards != (configuration['shard'] as int) - 1) {
       return;
     }
     // Test if the selector includes this test.
-    RegExp pattern = configuration['selectors'][suiteName];
+    var pattern = configuration['selectors'][suiteName] as RegExp;
     if (!pattern.hasMatch(testCase.displayName)) {
       return;
     }
 
-    if (configuration['hot_reload'] || configuration['hot_reload_rollback']) {
+    if ((configuration['hot_reload'] as bool) ||
+        (configuration['hot_reload_rollback'] as bool)) {
       // Handle reload special cases.
       if (expectations.contains(Expectation.compileTimeError) ||
           testCase.hasCompileError ||
           testCase.expectCompileError) {
         // Running a test that expects a compilation error with hot reloading
         // is redundant with a regular run of the test.
         return;
       }
     }
 
     // Update Summary report
-    if (configuration['report']) {
+    if (configuration['report'] as bool) {
       if (testCase.expectCompileError &&
-          TestUtils.isBrowserRuntime(configuration['runtime']) &&
+          TestUtils.isBrowserRuntime(configuration['runtime'] as String) &&
           new CompilerConfiguration(configuration).hasCompiler) {
         summaryReport.addCompileErrorSkipTest();
         return;
       } else {
         summaryReport.add(testCase);
       }
     }
 
     // Handle skipped tests
     if (expectations.contains(Expectation.skip) ||
@@ skipping 43 matching lines @@
     testName = concat(testName, multitestName);
     return testName;
   }
 
   /**
    * Create a directories for generated assets (tests, html files,
    * pubspec checkouts ...).
    */
 
   String createOutputDirectory(Path testPath, String optionsName) {
-    var checked = configuration['checked'] ? '-checked' : '';
-    var strong = configuration['strong'] ? '-strong' : '';
-    var minified = configuration['minified'] ? '-minified' : '';
-    var sdk = configuration['use_sdk'] ? '-sdk' : '';
+    var checked = configuration['checked'] as bool ? '-checked' : '';
+    var strong = configuration['strong'] as bool ? '-strong' : '';
+    var minified = configuration['minified'] as bool ? '-minified' : '';
+    var sdk = configuration['use_sdk'] as bool ? '-sdk' : '';
     var dirName = "${configuration['compiler']}-${configuration['runtime']}"
         "$checked$strong$minified$sdk";
     return createGeneratedTestDirectoryHelper(
         "tests", dirName, testPath, optionsName);
   }
 
   String createCompilationOutputDirectory(Path testPath) {
-    var checked = configuration['checked'] ? '-checked' : '';
-    var strong = configuration['strong'] ? '-strong' : '';
-    var minified = configuration['minified'] ? '-minified' : '';
-    var csp = configuration['csp'] ? '-csp' : '';
-    var sdk = configuration['use_sdk'] ? '-sdk' : '';
+    var checked = configuration['checked'] as bool ? '-checked' : '';
+    var strong = configuration['strong'] as bool ? '-strong' : '';
+    var minified = configuration['minified'] as bool ? '-minified' : '';
+    var csp = configuration['csp'] as bool ? '-csp' : '';
+    var sdk = configuration['use_sdk'] as bool ? '-sdk' : '';
     var dirName = "${configuration['compiler']}"
         "$checked$strong$minified$csp$sdk";
     return createGeneratedTestDirectoryHelper(
         "compilations", dirName, testPath, "");
   }
 
   String createPubspecCheckoutDirectory(Path directoryOfPubspecYaml) {
-    var sdk = configuration['use_sdk'] ? 'sdk' : '';
+    var sdk = configuration['use_sdk'] as bool ? 'sdk' : '';
     return createGeneratedTestDirectoryHelper(
         "pubspec_checkouts", sdk, directoryOfPubspecYaml, "");
   }
 
   String createPubPackageBuildsDirectory(Path directoryOfPubspecYaml) {
     return createGeneratedTestDirectoryHelper(
         "pub_package_builds", 'public_packages', directoryOfPubspecYaml, "");
   }
 }
 
 Future<Iterable<String>> ccTestLister(String runnerPath) {
   return Process.run(runnerPath, ["--list"]).then((ProcessResult result) {
     if (result.exitCode != 0) {
       throw "Failed to list tests: '$runnerPath --list'. "
           "Process exited with ${result.exitCode}";
     }
-    return result.stdout
+    return (result.stdout as String)
         .split('\n')
         .map((line) => line.trim())
         .where((name) => name.isNotEmpty);
   });
 }
 
 /**
  * A specialized [TestSuite] that runs tests written in C to unit test
  * the Dart virtual machine and its API.
  *
@@ skipping 170 matching lines @@
    * * Test files are directly in that directory and end in "_test.dart".
    *
    * If you follow that convention, then you can construct one of these like:
    *
    * new StandardTestSuite.forDirectory(configuration, 'path/to/mytestsuite');
    *
    * instead of having to create a custom [StandardTestSuite] subclass. In
    * particular, if you add 'path/to/mytestsuite' to [TEST_SUITE_DIRECTORIES]
    * in test.dart, this will all be set up for you.
    */
-  factory StandardTestSuite.forDirectory(Map configuration, Path directory) {
+  factory StandardTestSuite.forDirectory(
+      Map<String, dynamic> configuration, Path directory) {
     var name = directory.filename;
     var status_paths = [
       '$directory/$name.status',
       '$directory/.status',
       '$directory/${name}_dart2js.status',
       '$directory/${name}_analyzer2.status',
       '$directory/${name}_kernel.status'
     ];
 
     return new StandardTestSuite(configuration, name, directory, status_paths,
@@ skipping 10 matching lines @@
   bool isTestFile(String filename) {
     // Use the specified predicate, if provided.
     if (isTestFilePredicate != null) return isTestFilePredicate(filename);
     return filename.endsWith("Test.dart");
   }
 
   bool isHtmlTestFile(String filename) => filename.endsWith('_htmltest.html');
 
   List<String> additionalOptions(Path filePath) => [];
 
-  forEachTest(Function onTest, Map testCache, [VoidFunction onDone]) async {
+  Future forEachTest(
+      Function onTest, Map<String, List<TestInformation>> testCache,
+      [VoidFunction onDone]) async {
     await updateDartium();
     doTest = onTest;
     testExpectations = readExpectations();
 
     // Check if we have already found and generated the tests for this suite.
     if (!testCache.containsKey(suiteName)) {
       cachedTests = testCache[suiteName] = <TestInformation>[];
       await enqueueTests();
     } else {
       for (var info in testCache[suiteName]) {
@@ skipping 72 matching lines @@
       cachedTests.add(info);
       enqueueTestCaseFromTestInformation(info);
       return;
     }
     if (!isTestFile(filename)) return;
     Path filePath = new Path(filename);
 
     var optionsFromFile = readOptionsFromFile(filePath);
     CreateTest createTestCase = makeTestCaseCreator(optionsFromFile);
 
-    if (optionsFromFile['isMultitest']) {
+    if (optionsFromFile['isMultitest'] as bool) {
       group.add(doMultitest(
           filePath,
           buildDir,
           suiteDir,
           createTestCase,
-          (configuration['hot_reload'] ||
-              configuration['hot_reload_rollback'])));
+          ((configuration['hot_reload'] as bool) ||
+              (configuration['hot_reload_rollback'] as bool))));
     } else {
-      createTestCase(filePath, filePath, optionsFromFile['hasCompileError'],
-          optionsFromFile['hasRuntimeError'],
-          hasStaticWarning: optionsFromFile['hasStaticWarning']);
+      createTestCase(
+          filePath,
+          filePath,
+          optionsFromFile['hasCompileError'] as bool,
+          optionsFromFile['hasRuntimeError'] as bool,
+          hasStaticWarning: optionsFromFile['hasStaticWarning'] as bool);
     }
   }
 
   static Path _findPubspecYamlFile(Path filePath) {
     final existsCache = TestUtils.existsCache;
 
     Path root = TestUtils.dartDir;
     assert("$filePath".startsWith("$root"));
 
     // We start with the parent directory of [filePath] and go up until
     // the root directory (excluding the root).
     List<String> segments = filePath.directoryPath.relativeTo(root).segments();
     while (segments.length > 0) {
       var pubspecYamlPath = new Path(segments.join('/')).append('pubspec.yaml');
       if (existsCache.doesFileExist(pubspecYamlPath.toNativePath())) {
         return root.join(pubspecYamlPath);
       }
       segments.removeLast();
     }
     return null;
   }
 
   void enqueueTestCaseFromTestInformation(TestInformation info) {
     String testName = buildTestCaseDisplayName(suiteDir, info.originTestPath,
-        multitestName:
-            info.optionsFromFile['isMultitest'] ? info.multitestKey : "");
+        multitestName: info.optionsFromFile['isMultitest'] as bool
+            ? info.multitestKey
+            : "");
     Set<Expectation> expectations = testExpectations.expectations(testName);
     if (info is HtmlTestInformation) {
       enqueueHtmlTest(info, testName, expectations);
       return;
     }
     var optionsFromFile = info.optionsFromFile;
 
     // If this test is inside a package, we will check if there is a
     // pubspec.yaml file and if so, create a custom package root for it.
     List<Command> baseCommands = <Command>[];
     Path packageRoot;
     Path packages;
 
     if (optionsFromFile['packageRoot'] == null &&
         optionsFromFile['packages'] == null) {
       if (configuration['package_root'] != null) {
-        packageRoot = new Path(configuration['package_root']);
+        packageRoot = new Path(configuration['package_root'] as String);
         optionsFromFile['packageRoot'] = packageRoot.toNativePath();
       }
       if (configuration['packages'] != null) {
-        Path packages = new Path(configuration['packages']);
+        Path packages = new Path(configuration['packages'] as String);
         optionsFromFile['packages'] = packages.toNativePath();
       }
     }
     if (new CompilerConfiguration(configuration).hasCompiler &&
         expectCompileError(info)) {
       // If a compile-time error is expected, and we're testing a
       // compiler, we never need to attempt to run the program (in a
       // browser or otherwise).
       enqueueStandardTest(baseCommands, info, testName, expectations);
-    } else if (TestUtils.isBrowserRuntime(configuration['runtime'])) {
-      if (info.optionsFromFile['isMultiHtmlTest']) {
+    } else if (TestUtils.isBrowserRuntime(configuration['runtime'] as String)) {
+      if (info.optionsFromFile['isMultiHtmlTest'] as bool) {
         // A browser multi-test has multiple expectations for one test file.
         // Find all the different sub-test expecations for one entire test file.
-        List<String> subtestNames = info.optionsFromFile['subtestNames'];
-        Map<String, Set<Expectation>> multiHtmlTestExpectations = {};
-        for (String name in subtestNames) {
-          String fullTestName = '$testName/$name';
+        var subtestNames = info.optionsFromFile['subtestNames'] as List<String>;
+        var multiHtmlTestExpectations = <String, Set<Expectation>>{};
+        for (var name in subtestNames) {
+          var fullTestName = '$testName/$name';
           multiHtmlTestExpectations[fullTestName] =
               testExpectations.expectations(fullTestName);
         }
         enqueueBrowserTest(baseCommands, packageRoot, packages, info, testName,
             multiHtmlTestExpectations);
       } else {
         enqueueBrowserTest(
             baseCommands, packageRoot, packages, info, testName, expectations);
       }
     } else {
       enqueueStandardTest(baseCommands, info, testName, expectations);
     }
   }
 
   void enqueueStandardTest(List<Command> baseCommands, TestInformation info,
       String testName, Set<Expectation> expectations) {
     var commonArguments =
         commonArgumentsFromFile(info.filePath, info.optionsFromFile);
 
-    List<List<String>> vmOptionsList = getVmOptions(info.optionsFromFile);
+    var vmOptionsList = getVmOptions(info.optionsFromFile);
     assert(!vmOptionsList.isEmpty);
 
     for (var vmOptionsVariant = 0;
         vmOptionsVariant < vmOptionsList.length;
         vmOptionsVariant++) {
       var vmOptions = vmOptionsList[vmOptionsVariant];
       var allVmOptions = vmOptions;
       if (!extraVmOptions.isEmpty) {
-        allVmOptions = new List.from(vmOptions)..addAll(extraVmOptions);
+        allVmOptions = vmOptions.toList()..addAll(extraVmOptions);
       }
 
       var commands = baseCommands.toList();
       commands.addAll(
           makeCommands(info, vmOptionsVariant, allVmOptions, commonArguments));
       enqueueNewTestCase(new TestCase(
           '$suiteName/$testName', commands, configuration, expectations,
           isNegative: isNegative(info), info: info));
     }
   }
 
   bool expectCompileError(TestInformation info) {
     return info.hasCompileError ||
-        (configuration['checked'] && info.hasCompileErrorIfChecked);
+        ((configuration['checked'] as bool) && info.hasCompileErrorIfChecked);
   }
 
   bool isNegative(TestInformation info) {
     bool negative = expectCompileError(info) ||
-        (configuration['checked'] && info.isNegativeIfChecked);
+        ((configuration['checked'] as bool) && info.isNegativeIfChecked);
     if (info.hasRuntimeError && hasRuntime) {
       negative = true;
     }
     return negative;
   }
 
   List<Command> makeCommands(TestInformation info, int vmOptionsVarient,
       List<String> vmOptions, List<String> args) {
     var commands = <Command>[];
     var compilerConfiguration = new CompilerConfiguration(configuration);
-    List<String> sharedOptions = info.optionsFromFile['sharedOptions'];
+    var sharedOptions = info.optionsFromFile['sharedOptions'] as List<String>;
 
     var compileTimeArguments = <String>[];
     String tempDir;
     if (compilerConfiguration.hasCompiler) {
       compileTimeArguments = compilerConfiguration.computeCompilerArguments(
           vmOptions, sharedOptions, args);
       // Avoid doing this for analyzer.
       var path = info.filePath;
       if (vmOptionsVarient != 0) {
         // Ensure a unique directory for each test case.
         path = path.join(new Path(vmOptionsVarient.toString()));
       }
       tempDir = createCompilationOutputDirectory(path);
 
-      List<String> otherResources = info.optionsFromFile['otherResources'];
+      var otherResources =
+          info.optionsFromFile['otherResources'] as List<String>;
       for (var name in otherResources) {
         var namePath = new Path(name);
         var fromPath = info.filePath.directoryPath.join(namePath);
         new File('$tempDir/$name').parent.createSync(recursive: true);
         new File(fromPath.toNativePath()).copySync('$tempDir/$name');
       }
     }
 
     CommandArtifact compilationArtifact =
         compilerConfiguration.computeCompilationArtifact(
             buildDir,
             tempDir,
             CommandBuilder.instance,
             compileTimeArguments,
             environmentOverrides);
-    if (!configuration['skip-compilation']) {
+    if (!(configuration['skip-compilation'] as bool)) {
       commands.addAll(compilationArtifact.commands);
     }
 
     if (expectCompileError(info) && compilerConfiguration.hasCompiler) {
       // Do not attempt to run the compiled result. A compilation
       // error should be reported by the compilation command.
       return commands;
     }
 
     List<String> runtimeArguments =
@@ skipping 63 matching lines @@
     }
     // Unreachable
     print("Cannot create URL for path $file. Not in build or dart directory.");
     exit(1);
     return null;
   }
 
   Uri _getUriForBrowserTest(String pathComponent, String subtestName) {
     // Note: If we run test.py with the "--list" option, no http servers
     // will be started. So we return a dummy url instead.
-    if (configuration['list']) {
+    if (configuration['list'] as bool) {
       return Uri.parse('http://listing_the_tests_only');
     }
     assert(configuration.containsKey('_servers_'));
-    int serverPort = configuration['_servers_'].port;
-    int crossOriginPort = configuration['_servers_'].crossOriginPort;
+    var servers = configuration['_servers_'] as TestingServers;
+    var serverPort = servers.port;
+    var crossOriginPort = servers.crossOriginPort;
     var parameters = {'crossOriginPort': crossOriginPort.toString()};
     if (subtestName != null) {
       parameters['group'] = subtestName;
     }
     return new Uri(
         scheme: 'http',
-        host: configuration['local_ip'],
+        host: configuration['local_ip'] as String,
         port: serverPort,
         path: pathComponent,
         queryParameters: parameters);
   }
 
   void _createWrapperFile(
       String dartWrapperFilename, Path localDartLibraryFilename) {
     File file = new File(dartWrapperFilename);
     RandomAccessFile dartWrapper = file.openSync(mode: FileMode.WRITE);
 
@@ skipping 17 matching lines @@
    * compilation and many browser runs).
    */
   void enqueueBrowserTest(
       List<Command> baseCommands,
       Path packageRoot,
       Path packages,
       TestInformation info,
       String testName,
       /* Set<Expectation> | Map<String, Set<Expectation>> */ dynamic
           expectations) {
-    RegExp badChars = new RegExp('[-=/]');
-    List VmOptionsList = getVmOptions(info.optionsFromFile);
-    bool multipleOptions = VmOptionsList.length > 1;
-    for (var vmOptions in VmOptionsList) {
-      String optionsName =
+    var badChars = new RegExp('[-=/]');
+    var vmOptionsList = getVmOptions(info.optionsFromFile);
+    var multipleOptions = vmOptionsList.length > 1;
+    for (var vmOptions in vmOptionsList) {
+      var optionsName =
           multipleOptions ? vmOptions.join('-').replaceAll(badChars, '') : '';
-      String tempDir = createOutputDirectory(info.filePath, optionsName);
+      var tempDir = createOutputDirectory(info.filePath, optionsName);
       enqueueBrowserTestWithOptions(baseCommands, packageRoot, packages, info,
           testName, expectations, vmOptions, tempDir);
     }
   }
 
   void enqueueBrowserTestWithOptions(
       List<Command> baseCommands,
       Path packageRoot,
       Path packages,
       TestInformation info,
       String testName,
       /* Set<Expectation> | Map<String, Set<Expectation>> */ expectations,
       List<String> vmOptions,
       String tempDir) {
     // TODO(Issue 14651): If we're on dartium, we need to pass [packageRoot]
     // on to the browser (it may be test specific).
 
     Path filePath = info.filePath;
     String filename = filePath.toString();
 
-    final String compiler = configuration['compiler'];
-    final String runtime = configuration['runtime'];
+    var compiler = configuration['compiler'] as String;
+    var runtime = configuration['runtime'] as String;
     final Map optionsFromFile = info.optionsFromFile;
 
     final String compilationTempDir =
         createCompilationOutputDirectory(info.filePath);
 
     String dartWrapperFilename = '$tempDir/test.dart';
     String compiledDartWrapperFilename = '$compilationTempDir/test.js';
 
     String content = null;
     Path dir = filePath.directoryPath;
@@ skipping 71 matching lines @@
       htmlTest.writeStringSync(content);
       htmlTest.closeSync();
     }
 
     if (compiler != 'none') {
       commands.add(_compileCommand(dartWrapperFilename,
           compiledDartWrapperFilename, compiler, tempDir, optionsFromFile));
     }
 
     // some tests require compiling multiple input scripts.
-    List<String> otherScripts = optionsFromFile['otherScripts'];
-    for (String name in otherScripts) {
-      Path namePath = new Path(name);
-      String fileName = namePath.filename;
-      Path fromPath = filePath.directoryPath.join(namePath);
+    var otherScripts = optionsFromFile['otherScripts'] as List<String>;
+    for (var name in otherScripts) {
+      var namePath = new Path(name);
+      var fileName = namePath.filename;
+      var fromPath = filePath.directoryPath.join(namePath);
       if (compiler != 'none') {
         assert(namePath.extension == 'dart');
         commands.add(_compileCommand(fromPath.toNativePath(),
             '$tempDir/$fileName.js', compiler, tempDir, optionsFromFile));
       }
       if (compiler == 'none') {
         // For the tests that require multiple input scripts but are not
         // compiled, move the input scripts over with the script so they can
         // be accessed.
-        String result = new File(fromPath.toNativePath()).readAsStringSync();
+        var result = new File(fromPath.toNativePath()).readAsStringSync();
         new File('$tempDir/$fileName').writeAsStringSync(result);
       }
     }
 
     // Variables for browser multi-tests.
-    bool multitest = info.optionsFromFile['isMultiHtmlTest'];
-    List<String> subtestNames =
-        multitest ? info.optionsFromFile['subtestNames'] : [null];
-    for (String subtestName in subtestNames) {
+    var multitest = info.optionsFromFile['isMultiHtmlTest'] as bool;
+    var subtestNames = multitest
+        ? (info.optionsFromFile['subtestNames'] as List<String>)
+        : <String>[null];
+    for (var subtestName in subtestNames) {
       // Construct the command that executes the browser test
-      List<Command> commandSet = new List<Command>.from(commands);
+      var commandSet = commands.toList();
 
       var htmlPath_subtest = _createUrlPathFromFile(new Path(htmlPath));
       var fullHtmlPath =
           _getUriForBrowserTest(htmlPath_subtest, subtestName).toString();
 
       if (runtime == "drt") {
         var dartFlags = <String>[];
         var contentShellOptions = ['--no-timeout', '--run-layout-test'];
 
         // Disable the GPU under Linux and Dartium. If the GPU is enabled,
         // Chrome may send a termination signal to a test.  The test will be
         // terminated if a machine (bot) doesn't have a GPU or if a test is
         // still running after a certain period of time.
         if (configuration['system'] == 'linux' &&
             configuration['runtime'] == 'drt') {
           contentShellOptions.add('--disable-gpu');
           // TODO(terry): Roll 50 need this in conjection with disable-gpu.
           contentShellOptions.add('--disable-gpu-early-init');
         }
         if (compiler == 'none') {
           dartFlags.add('--ignore-unrecognized-flags');
-          if (configuration["checked"]) {
+          if (configuration["checked"] as bool) {
             dartFlags.add('--enable_asserts');
             dartFlags.add("--enable_type_checks");
           }
           dartFlags.addAll(vmOptions);
         }
 
         commandSet.add(CommandBuilder.instance.getContentShellCommand(
             contentShellFilename,
             fullHtmlPath,
             contentShellOptions,
             dartFlags,
             environmentOverrides));
       } else {
         commandSet.add(CommandBuilder.instance.getBrowserTestCommand(
             runtime, fullHtmlPath, configuration, !isNegative(info)));
       }
 
       // Create BrowserTestCase and queue it.
       var fullTestName = multitest ? '$testName/$subtestName' : testName;
-      var expectation = multitest ? expectations[fullTestName] : expectations;
+      var expectation = (multitest ? expectations[fullTestName] : expectations)
+          as Set<Expectation>;
       var testCase = new BrowserTestCase('$suiteName/$fullTestName', commandSet,
           configuration, expectation, info, isNegative(info), fullHtmlPath);
 
       enqueueNewTestCase(testCase);
     }
   }
 
   void enqueueHtmlTest(HtmlTestInformation info, String testName,
       Set<Expectation> expectations) {
-    final String compiler = configuration['compiler'];
-    final String runtime = configuration['runtime'];
+    var compiler = configuration['compiler'] as String;
+    var runtime = configuration['runtime'] as String;
     // Html tests work only with the browser controller.
     if (!TestUtils.isBrowserRuntime(runtime) || runtime == 'drt') {
       return;
     }
     bool compileToJS = (compiler == 'dart2js');
 
     final Path filePath = info.filePath;
     final String tempDir = createOutputDirectory(filePath, '');
     final Uri tempUri = new Uri.file('$tempDir/');
     String contents = htmlTest.getContents(info, compileToJS);
@@ skipping 55 matching lines @@
       String dir, Map optionsFromFile) {
     assert(compiler == 'dart2js');
     List<String> args;
     if (compilerPath.endsWith('.dart')) {
       // Run the compiler script via the Dart VM.
       args = [compilerPath];
     } else {
       args = [];
     }
     args.addAll(TestUtils.standardOptions(configuration));
-    String packages = packagesArgument(
-        optionsFromFile['packageRoot'], optionsFromFile['packages']);
+    var packages = packagesArgument(optionsFromFile['packageRoot'] as String,
+        optionsFromFile['packages'] as String);
     if (packages != null) args.add(packages);
     args.add('--out=$outputFile');
     args.add(inputFile);
-    List<String> options = optionsFromFile['sharedOptions'];
+    var options = optionsFromFile['sharedOptions'] as List<String>;
     if (options != null) args.addAll(options);
     return CommandBuilder.instance.getCompilationCommand(
         compiler,
         outputFile,
         !useSdk,
         dart2JsBootstrapDependencies,
         compilerPath,
         args,
         environmentOverrides);
   }
 
   /** Helper to create a Polymer deploy command for a single HTML file. */
   Command _polymerDeployCommand(
       String inputFile, String outputDir, Map optionsFromFile) {
     List<String> args = [];
-    String packages = packagesArgument(
-        optionsFromFile['packageRoot'], optionsFromFile['packages']);
+    String packages = packagesArgument(optionsFromFile['packageRoot'] as String,
+        optionsFromFile['packages'] as String);
     if (packages != null) args.add(packages);
     args
       ..add('package:polymer/deploy.dart')
       ..add('--test')
       ..add(inputFile)
       ..add('--out')
       ..add(outputDir)
       ..add('--file-filter')
       ..add('.svn');
-    if (configuration['csp']) args.add('--csp');
+    if (configuration['csp'] as bool) args.add('--csp');
 
     return CommandBuilder.instance.getProcessCommand(
         'polymer_deploy', dartVmBinaryFileName, args, environmentOverrides);
   }
 
   String get scriptType {
-    switch (configuration['compiler']) {
+    switch (configuration['compiler'] as String) {
       case 'none':
         return 'application/dart';
       case 'dart2js':
       case 'dart2analyzer':
         return 'text/javascript';
       default:
         print('Non-web runtime, so no scriptType for: '
             '${configuration["compiler"]}');
         exit(1);
         return null;
     }
   }
 
   bool get hasRuntime {
-    switch (configuration['runtime']) {
+    switch (configuration['runtime'] as String) {
       case 'none':
         return false;
       default:
         return true;
     }
   }
 
   String get contentShellFilename {
     if (configuration['drt'] != '') {
-      return configuration['drt'];
+      return configuration['drt'] as String;
     }
     if (Platform.operatingSystem == 'macos') {
       final path = dartDir.append(
           '/client/tests/drt/Content Shell.app/Contents/MacOS/Content Shell');
       return path.toNativePath();
     }
     return dartDir.append('client/tests/drt/content_shell').toNativePath();
   }
 
   List<String> commonArgumentsFromFile(Path filePath, Map optionsFromFile) {
     var args = TestUtils.standardOptions(configuration);
 
-    String packages = packagesArgument(
-        optionsFromFile['packageRoot'], optionsFromFile['packages']);
+    String packages = packagesArgument(optionsFromFile['packageRoot'] as String,
+        optionsFromFile['packages'] as String);
     if (packages != null) {
       args.add(packages);
     }
     args.addAll(additionalOptions(filePath));
-    if (configuration['analyzer']) {
+    if (configuration['analyzer'] as bool) {
       args.add('--format=machine');
       args.add('--no-hints');
     }
 
     if (configuration["compiler"] == "dart2analyzer" &&
         (filePath.filename.contains("dart2js") ||
             filePath.directoryPath.segments().last.contains('html_common'))) {
       args.add("--use-dart2js-libraries");
     }
 
-    bool isMultitest = optionsFromFile["isMultitest"];
-    List<String> dartOptions = optionsFromFile["dartOptions"];
+    var isMultitest = optionsFromFile["isMultitest"] as bool;
+    var dartOptions = optionsFromFile["dartOptions"] as List<String>;
 
     assert(!isMultitest || dartOptions == null);
     args.add(filePath.toNativePath());
     if (dartOptions != null) {
       args.addAll(dartOptions);
     }
 
     return args;
   }
 
@@ skipping 151 matching lines @@
       }
       packages = match[1];
       if (packages != 'none') {
         // Packages=none means that no packages or package-root option
         // should be given. Any other value overrides packages and removes
         // any package-root option. Don't use with // PackageRoot=.
         packages = '${filePath.directoryPath.join(new Path(packages))}';
       }
     }
 
-    List<String> otherScripts = new List<String>();
+    var otherScripts = <String>[];
     matches = otherScriptsRegExp.allMatches(contents);
     for (var match in matches) {
       otherScripts.addAll(match[1].split(' ').where((e) => e != '').toList());
     }
 
-    List<String> otherResources = new List<String>();
+    var otherResources = <String>[];
     matches = otherResourcesRegExp.allMatches(contents);
     for (var match in matches) {
       otherResources.addAll(match[1].split(' ').where((e) => e != '').toList());
     }
 
-    bool isMultitest = multiTestRegExp.hasMatch(contents);
-    bool isMultiHtmlTest = multiHtmlTestRegExp.hasMatch(contents);
-    Match isolateMatch = isolateStubsRegExp.firstMatch(contents);
-    String isolateStubs = isolateMatch != null ? isolateMatch[1] : '';
-    bool containsDomImport = domImportRegExp.hasMatch(contents);
+    var isMultitest = multiTestRegExp.hasMatch(contents);
+    var isMultiHtmlTest = multiHtmlTestRegExp.hasMatch(contents);
+    var isolateMatch = isolateStubsRegExp.firstMatch(contents);
+    var isolateStubs = isolateMatch != null ? isolateMatch[1] : '';
+    var containsDomImport = domImportRegExp.hasMatch(contents);
 
-    List<String> subtestNames = [];
-    Iterator matchesIter =
-        multiHtmlTestGroupRegExp.allMatches(contents).iterator;
+    var subtestNames = <String>[];
+    var matchesIter = multiHtmlTestGroupRegExp.allMatches(contents).iterator;
     while (matchesIter.moveNext() && isMultiHtmlTest) {
-      String fullMatch = matchesIter.current.group(0);
+      var fullMatch = matchesIter.current.group(0);
       subtestNames.add(fullMatch.substring(fullMatch.indexOf("'") + 1));
     }
 
     return {
       "vmOptions": result,
-      "sharedOptions": sharedOptions == null ? [] : sharedOptions,
+      "sharedOptions": sharedOptions ?? [],
       "dartOptions": dartOptions,
       "packageRoot": packageRoot,
       "packages": packages,
       "hasCompileError": false,
       "hasRuntimeError": false,
       "hasStaticWarning": false,
       "otherScripts": otherScripts,
       "otherResources": otherResources,
       "isMultitest": isMultitest,
       "isMultiHtmlTest": isMultiHtmlTest,
@@ skipping 29 matching lines @@
       'dart_precompiled',
       'vm',
       'drt',
       'dartium',
       'ContentShellOnAndroid',
       'DartiumOnAndroid'
     ];
     var needsVmOptions = COMPILERS.contains(configuration['compiler']) &&
         RUNTIMES.contains(configuration['runtime']);
     if (!needsVmOptions) return [[]];
-    return optionsFromFile['vmOptions'];
+    return optionsFromFile['vmOptions'] as List<List<String>>;
   }
 
   /**
    * Read options from a co19 test file.
    *
    * The reason this is different from [readOptionsFromFile] is that
    * co19 is developed based on a contract which defines certain test
    * tags. These tags may appear unused, but should not be removed
    * without consulting with the co19 team.
    *
@@ skipping 27 matching lines @@
       "subtestNames": <String>[],
       "isolateStubs": '',
       "containsDomImport": false,
     };
   }
 }
 
 /// Used for testing packages in on off settings, i.e., we pass in the actual
 /// directory that we want to test.
 class PKGTestSuite extends StandardTestSuite {
-  PKGTestSuite(Map configuration, Path directoryPath)
+  PKGTestSuite(Map<String, dynamic> configuration, Path directoryPath)
       : super(configuration, directoryPath.filename, directoryPath,
             ["$directoryPath/.status"],
             isTestFilePredicate: (f) => f.endsWith('_test.dart'),
             recursive: true);
 
   void enqueueBrowserTest(
       List<Command> baseCommands,
       Path packageRoot,
       packages,
       TestInformation info,
       String testName,
       /* Set<Expectation> | Map<String, Set<Expectation>> */ dynamic
           expectations) {
-    String runtime = configuration['runtime'];
-    Path filePath = info.filePath;
-    Path dir = filePath.directoryPath;
-    String nameNoExt = filePath.filenameWithoutExtension;
-    Path customHtmlPath = dir.append('$nameNoExt.html');
-    File customHtml = new File(customHtmlPath.toNativePath());
+    var runtime = configuration['runtime'] as String;
+    var filePath = info.filePath;
+    var dir = filePath.directoryPath;
+    var nameNoExt = filePath.filenameWithoutExtension;
+    var customHtmlPath = dir.append('$nameNoExt.html');
+    var customHtml = new File(customHtmlPath.toNativePath());
     if (!customHtml.existsSync()) {
       super.enqueueBrowserTest(
           baseCommands, packageRoot, packages, info, testName, expectations);
     } else {
-      Path relativeHtml = customHtmlPath.relativeTo(TestUtils.dartDir);
+      var relativeHtml = customHtmlPath.relativeTo(TestUtils.dartDir);
       var commands = baseCommands.toList();
       var fullPath = _createUrlPathFromFile(customHtmlPath);
 
       commands.add(CommandBuilder.instance.getBrowserTestCommand(
           runtime, fullPath, configuration, !isNegative(info)));
-      String testDisplayName = '$suiteName/$testName';
+      var testDisplayName = '$suiteName/$testName';
       enqueueNewTestCase(new BrowserTestCase(
           testDisplayName,
           commands,
           configuration,
-          expectations,
+          expectations as Set<Expectation>,
           info,
           isNegative(info),
           relativeHtml.toNativePath()));
     }
   }
 }
 
 /// A DartcCompilationTestSuite will run dartc on all of the tests.
 ///
 /// Usually, the result of a dartc run is determined by the output of
 /// dartc in connection with annotations in the test file.
 class DartcCompilationTestSuite extends StandardTestSuite {
   List<String> _testDirs;
 
   DartcCompilationTestSuite(
-      Map configuration,
+      Map<String, dynamic> configuration,
       String suiteName,
       String directoryPath,
       List<String> this._testDirs,
       List<String> expectations)
       : super(configuration, suiteName, new Path(directoryPath), expectations);
 
   List<String> additionalOptions(Path filePath) {
     return ['--fatal-warnings', '--fatal-type-errors'];
   }
 
   Future enqueueTests() {
     var group = new FutureGroup();
 
     for (String testDir in _testDirs) {
       Directory dir = new Directory(suiteDir.append(testDir).toNativePath());
       if (dir.existsSync()) {
         enqueueDirectory(dir, group);
       }
     }
 
     return group.future;
   }
 }
 
 class AnalyzeLibraryTestSuite extends DartcCompilationTestSuite {
-  static String libraryPath(Map configuration) => configuration['use_sdk']
-      ? '${TestUtils.buildDir(configuration)}/dart-sdk'
-      : 'sdk';
+  static String libraryPath(Map<String, dynamic> configuration) =>
+      configuration['use_sdk'] as bool
+          ? '${TestUtils.buildDir(configuration)}/dart-sdk'
+          : 'sdk';
 
-  AnalyzeLibraryTestSuite(Map configuration)
+  AnalyzeLibraryTestSuite(Map<String, dynamic> configuration)
       : super(configuration, 'analyze_library', libraryPath(configuration),
             ['lib'], ['tests/lib/analyzer/analyze_library.status']);
 
   List<String> additionalOptions(Path filePath, {bool showSdkWarnings}) {
     var options = super.additionalOptions(filePath);
     options.add('--sdk-warnings');
     return options;
   }
 
   bool isTestFile(String filename) {
@@ skipping 146 matching lines @@
     } else {
       var dir = new Directory(path);
       return dir.delete(recursive: true);
     }
   }
 
   static void deleteTempSnapshotDirectory(Map configuration) {
     if (configuration['compiler'] == 'dart2app' ||
         configuration['compiler'] == 'dart2appjit' ||
         configuration['compiler'] == 'precompiler') {
-      var checked = configuration['checked'] ? '-checked' : '';
-      var strong = configuration['strong'] ? '-strong' : '';
-      var minified = configuration['minified'] ? '-minified' : '';
-      var csp = configuration['csp'] ? '-csp' : '';
-      var sdk = configuration['use_sdk'] ? '-sdk' : '';
+      var checked = (configuration['checked'] as bool) ? '-checked' : '';
+      var strong = (configuration['strong'] as bool) ? '-strong' : '';
+      var minified = (configuration['minified'] as bool) ? '-minified' : '';
+      var csp = (configuration['csp'] as bool) ? '-csp' : '';
+      var sdk = (configuration['use_sdk'] as bool) ? '-sdk' : '';
       var dirName = "${configuration['compiler']}"
           "$checked$strong$minified$csp$sdk";
       String generatedPath = "${TestUtils.buildDir(configuration)}"
           "/generated_compilations/$dirName";
       TestUtils.deleteDirectory(generatedPath);
     }
   }
 
   static final debugLogFilePath = new Path(".debug.log");
 
   /// If a flaky test did fail, infos about it (i.e. test name, stdin, stdout)
   /// will be written to this file.
   ///
   /// This is useful for debugging flaky tests. When running on a buildbot, the
   /// file can be made visible in the waterfall UI.
   static const flakyFileName = ".flaky.log";
 
   /// If test.py was invoked with '--write-test-outcome-log it will write
   /// test outcomes to this file.
   static const testOutcomeFileName = ".test-outcome.log";
 
   static void ensureExists(String filename, Map configuration) {
-    if (!configuration['list'] && !existsCache.doesFileExist(filename)) {
+    if (!(configuration['list'] as bool) &&
+        !existsCache.doesFileExist(filename)) {
       throw "'$filename' does not exist";
     }
   }
 
   static Path absolutePath(Path path) {
     if (!path.isAbsolute) {
       return currentWorkingDirectory.join(path);
     }
     return path;
   }
 
   static String outputDir(Map configuration) {
     var result = '';
-    var system = configuration['system'];
+    var system = configuration['system'] as String;
     if (system == 'fuchsia' ||
         system == 'linux' ||
         system == 'android' ||
         system == 'windows') {
       result = 'out/';
     } else if (system == 'macos') {
       result = 'xcodebuild/';
     } else {
       throw new Exception('Unknown operating system: "$system"');
     }
     return result;
   }
 
   static List<String> standardOptions(Map configuration) {
     var args = ["--ignore-unrecognized-flags"];
-    String compiler = configuration["compiler"];
+    var compiler = configuration["compiler"] as String;
     if (compiler == "dart2js") {
       args = ['--generate-code-with-compile-time-errors', '--test-mode'];
-      if (configuration["checked"]) {
+      if (configuration["checked"] as bool) {
         args.add('--enable-checked-mode');
       }
       // args.add("--verbose");
-      if (!isBrowserRuntime(configuration['runtime'])) {
+      if (!isBrowserRuntime(configuration['runtime'] as String)) {
         args.add("--allow-mock-compilation");
         args.add("--categories=all");
       }
     }
-    if ((compiler == "dart2js") && configuration["minified"]) {
+    if ((compiler == "dart2js") && (configuration["minified"] as bool)) {
       args.add("--minify");
     }
-    if (compiler == "dart2js" && configuration["csp"]) {
+    if (compiler == "dart2js" && (configuration["csp"] as bool)) {
       args.add("--csp");
     }
-    if (compiler == "dart2js" && configuration["fast_startup"]) {
+    if (compiler == "dart2js" && (configuration["fast_startup"] as bool)) {
       args.add("--fast-startup");
     }
-    if (compiler == "dart2js" && configuration["dart2js_with_kernel"]) {
+    if (compiler == "dart2js" &&
+        (configuration["dart2js_with_kernel"] as bool)) {
       args.add("--use-kernel");
     }
     return args;
   }
 
   static bool isBrowserRuntime(String runtime) {
     const BROWSERS = const [
       'drt',
       'dartium',
       'ie9',
@@ skipping 18 matching lines @@
       compiler == 'dart2analyzer';
 
   static String buildDir(Map configuration) {
     // FIXME(kustermann,ricow): Our code assumes that the returned 'buildDir'
     // is relative to the current working directory.
     // Thus, if we pass in an absolute path (e.g. '--build-directory=/tmp/out')
     // we get into trouble.
     if (configuration['build_directory'] == '') {
       configuration['configuration_directory'] =
           configurationDir(configuration);
-      configuration['build_directory'] =
-          outputDir(configuration) + configuration['configuration_directory'];
+      configuration['build_directory'] = outputDir(configuration) +
+          (configuration['configuration_directory'] as String);
     }
-    return configuration['build_directory'];
+    return configuration['build_directory'] as String;
   }
 
   static String configurationDir(Map configuration) {
     // This returns the correct configuration directory (the last component
     // of the output directory path) for regular dart checkouts.
     // Dartium checkouts use the --build-directory option to pass in the
     // correct build directory explicitly.
     // We allow our code to have been cross compiled, i.e., that there
     // is an X in front of the arch. We don't allow both a cross compiled
     // and a normal version to be present (except if you specifically pass
     // in the build_directory).
     String mode;
-    switch (configuration['mode']) {
+    switch (configuration['mode'] as String) {
       case 'debug':
         mode = 'Debug';
         break;
       case 'release':
         mode = 'Release';
         break;
       case 'product':
         mode = 'Product';
         break;
       default:
         throw 'Unrecognized mode configuration: ${configuration['mode']}';
     }
     String os;
-    switch (configuration['system']) {
+    switch (configuration['system'] as String) {
       case 'android':
         os = 'Android';
         break;
       case 'fuchsia':
       case 'linux':
       case 'macos':
       case 'windows':
         os = '';
         break;
       default:
         throw 'Unrecognized operating system: ${configuration['system']}';
     }
-    var arch = configuration['arch'].toUpperCase();
+    var arch = (configuration['arch'] as String).toUpperCase();
     var normal = '$mode$os$arch';
     var cross = '$mode${os}X$arch';
     var outDir = outputDir(configuration);
     var normalDir = new Directory(new Path('$outDir$normal').toNativePath());
     var crossDir = new Directory(new Path('$outDir$cross').toNativePath());
     if (normalDir.existsSync() && crossDir.existsSync()) {
       throw "You can't have both $normalDir and $crossDir, we don't know which"
           " binary to use";
     }
     if (crossDir.existsSync()) {
       return cross;
     }
     return normal;
   }
 
   /**
    * Gets extra options under [key] passed to the testing script.
    */
   static List<String> getExtraOptions(Map configuration, String key) {
     if (configuration[key] == null) return <String>[];
-    return configuration[key]
+    return (configuration[key] as String)
         .split(" ")
         .map((s) => s.trim())
         .where((s) => s.isNotEmpty)
         .toList();
   }
 
   /**
    * Gets extra vm options passed to the testing script.
    */
   static List<String> getExtraVmOptions(Map configuration) =>
@@ skipping 75 matching lines @@
       }
       if (path.length > WINDOWS_SHORTEN_PATH_LIMIT) {
         ++shortNameCounter;
         var pathEnd = path.substring(path.length - WINDOWS_PATH_END_LENGTH);
         path = "short${shortNameCounter}_$pathEnd";
       }
     }
     return path;
   }
 }