Revert "Revert "Replace the configuration map with a typed object.""

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"
-    show CommandArtifact, CompilerConfiguration;
-
-import "runtime_configuration.dart" show RuntimeConfiguration;
+import 'dart:async';
+import 'dart:io';
+import 'dart:math';
 
 import 'browser_test.dart';
+import 'compiler_configuration.dart';
+import 'configuration.dart';
+import 'drt_updater.dart';
+import 'expectation.dart';
+import 'expectation_set.dart';
+import 'html_test.dart' as html_test;
+import 'http_server.dart';
+import 'multitest.dart';
+import 'path.dart';
+import 'summary_report.dart';
+import 'test_configurations.dart';
+import 'test_runner.dart';
+import 'utils.dart';
 
 RegExp multiHtmlTestGroupRegExp = new RegExp(r"\s*[^/]\s*group\('[^,']*");
 RegExp multiHtmlTestRegExp = new RegExp(r"useHtmlIndividualConfiguration()");
 // Require at least one non-space character before '//[/#]'
 RegExp multiTestRegExp = new RegExp(r"\S *"
     r"//[#/] \w+:(.*)");
 RegExp dartExtension = new RegExp(r'\.dart$');
 
 /**
  * A simple function that tests [arg] and returns `true` or `false`.
@@ skipping 36 matching lines @@
   /**
    * Wait for [task] to complete (assuming this barrier has not already been
    * marked as completed, otherwise you'll get an exception indicating that a
    * future has already been completed).
    */
   void add(Future task) {
     if (_pending == _FINISHED) {
       throw new Exception("FutureFutureAlreadyCompleteException");
     }
     _pending++;
-    var handledTaskFuture = task.catchError((e) {
+    var handledTaskFuture = task.catchError((e, StackTrace s) {
       if (!wasCompleted) {
-        _completer.completeError(e);
+        _completer.completeError(e, s);
         wasCompleted = true;
       }
     }).then((_) {
       _pending--;
       if (_pending == 0) {
         _pending = _FINISHED;
         if (!wasCompleted) {
           _completer.complete(futures);
           wasCompleted = true;
         }
       }
     });
     futures.add(handledTaskFuture);
   }
 
   Future<List> get future => _completer.future;
 }
 
 /**
  * A TestSuite represents a collection of tests.  It creates a [TestCase]
  * object for each test to be run, and passes the test cases to a callback.
  *
  * Most TestSuites represent a directory or directory tree containing tests,
  * and a status file containing the expected results when these tests are run.
  */
 abstract class TestSuite {
-  final Map<String, dynamic> configuration;
+  final Configuration configuration;
   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'] as String
-      };
-    }
-    runtimeConfiguration = new RuntimeConfiguration(configuration);
+    _environmentOverrides = {
+      'DART_CONFIGURATION': configuration.configurationDirectory
+    };
   }
 
   Map<String, String> get environmentOverrides => _environmentOverrides;
 
   /**
    * Whether or not binaries should be found in the root build directory or
    * in the built SDK.
    */
   bool get useSdk {
     // The pub suite always uses the SDK.
     // TODO(rnystrom): Eventually, all test suites should run out of the SDK
     // and this check should go away.
     // TODO(ahe): This check is broken for several reasons:
     // First, it is not true that all tests should be running out of the
     // SDK. It is absolutely critical to VM development that you can test the
     // VM without building the SDK.
     // Second, it is convenient for dart2js developers to run tests without
     // 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'] as bool;
+    return configuration.useSdk;
   }
 
   /**
    * The output directory for this suite's configuration.
    */
-  String get buildDir => TestUtils.buildDir(configuration);
+  String get buildDir => configuration.buildDirectory;
 
   /**
    * 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);
+    var compilerConfiguration = configuration.compilerConfiguration;
     if (!compilerConfiguration.hasCompiler) return null;
     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'] as bool) {
+    if (configuration.useSdk) {
       prefix = '$buildDir/dart-sdk/bin/';
     }
     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".
-    var dartExecutable = configuration['dart'] as String;
+    var dartExecutable = configuration.dartPath;
 
-    if (dartExecutable == '') {
+    if (dartExecutable == null) {
       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".
-    var flutterExecutable = configuration['flutter'] as String;
+    var flutterExecutable = configuration.flutterPath;
     TestUtils.ensureExists(flutterExecutable, configuration);
     return flutterExecutable;
   }
 
   String get dartPrecompiledBinaryFileName {
     // Controlled by user with the option "--dart_precompiled".
-    var dartExecutable = configuration['dart_precompiled'] as String;
+    var dartExecutable = configuration.dartPrecompiledPath;
 
     if (dartExecutable == null || dartExecutable == '') {
       var suffix = executableBinarySuffix;
       dartExecutable = '$buildDir/dart_precompiled_runtime$suffix';
     }
 
     TestUtils.ensureExists(dartExecutable, configuration);
     return dartExecutable;
   }
 
@@ skipping 51 matching lines @@
       [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) {
+    if (testCase.isNegative &&
+        configuration.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)
-    var shards = configuration['shards'] as int;
-    if (shards > 1 &&
-        testCase.hash % shards != (configuration['shard'] as int) - 1) {
+    if (configuration.shardCount > 1 &&
+        testCase.hash % configuration.shardCount != configuration.shard - 1) {
       return;
     }
+
     // Test if the selector includes this test.
-    var pattern = configuration['selectors'][suiteName] as RegExp;
+    var pattern = configuration.selectors[suiteName];
     if (!pattern.hasMatch(testCase.displayName)) {
       return;
     }
 
-    if ((configuration['hot_reload'] as bool) ||
-        (configuration['hot_reload_rollback'] as bool)) {
+    if (configuration.hotReload || configuration.hotReloadRollback) {
       // 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'] as bool) {
+    if (configuration.printReport) {
       if (testCase.expectCompileError &&
-          TestUtils.isBrowserRuntime(configuration['runtime'] as String) &&
-          new CompilerConfiguration(configuration).hasCompiler) {
+          configuration.runtime.isBrowser &&
+          configuration.compilerConfiguration.hasCompiler) {
         summaryReport.addCompileErrorSkipTest();
         return;
       } else {
         summaryReport.add(testCase);
       }
     }
 
     // Handle skipped tests
     if (expectations.contains(Expectation.skip) ||
         expectations.contains(Expectation.skipByDesign) ||
@@ skipping 42 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'] 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']}"
+    var checked = configuration.isChecked ? '-checked' : '';
+    var strong = configuration.isStrong ? '-strong' : '';
+    var minified = configuration.isMinified ? '-minified' : '';
+    var sdk = configuration.useSdk ? '-sdk' : '';
+    var dirName = "${configuration.compiler.name}-${configuration.runtime.name}"
         "$checked$strong$minified$sdk";
     return createGeneratedTestDirectoryHelper(
         "tests", dirName, testPath, optionsName);
   }
 
   String createCompilationOutputDirectory(Path testPath) {
-    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']}"
+    var checked = configuration.isChecked ? '-checked' : '';
+    var strong = configuration.isStrong ? '-strong' : '';
+    var minified = configuration.isMinified ? '-minified' : '';
+    var csp = configuration.isCsp ? '-csp' : '';
+    var sdk = configuration.useSdk ? '-sdk' : '';
+    var dirName = "${configuration.compiler.name}"
         "$checked$strong$minified$csp$sdk";
     return createGeneratedTestDirectoryHelper(
         "compilations", dirName, testPath, "");
   }
 
   String createPubspecCheckoutDirectory(Path directoryOfPubspecYaml) {
-    var sdk = configuration['use_sdk'] as bool ? 'sdk' : '';
+    var sdk = configuration.useSdk ? 'sdk' : '';
     return createGeneratedTestDirectoryHelper(
         "pubspec_checkouts", sdk, directoryOfPubspecYaml, "");
   }
 
   String createPubPackageBuildsDirectory(Path directoryOfPubspecYaml) {
     return createGeneratedTestDirectoryHelper(
         "pub_package_builds", 'public_packages', directoryOfPubspecYaml, "");
   }
 }
 
@@ skipping 18 matching lines @@
  * The executable lists its tests when run with the --list command line flag.
  * Individual tests are run by specifying them on the command line.
  */
 class CCTestSuite extends TestSuite {
   final String testPrefix;
   String targetRunnerPath;
   String hostRunnerPath;
   final String dartDir;
   List<String> statusFilePaths;
 
-  CCTestSuite(Map<String, dynamic> configuration, String suiteName,
-      String runnerName, this.statusFilePaths,
+  CCTestSuite(Configuration configuration, String suiteName, String runnerName,
+      this.statusFilePaths,
       {this.testPrefix: ''})
       : dartDir = TestUtils.dartDir.toNativePath(),
         super(configuration, suiteName) {
     // For running the tests we use the given '$runnerName' binary
     targetRunnerPath = '$buildDir/$runnerName';
 
     // For listing the tests we use the '$runnerName.host' binary if it exists
     // and use '$runnerName' if it doesn't.
     var binarySuffix = Platform.operatingSystem == 'windows' ? '.exe' : '';
     var hostBinary = '$targetRunnerPath.host$binarySuffix';
     if (new File(hostBinary).existsSync()) {
       hostRunnerPath = hostBinary;
     } else {
       hostRunnerPath = targetRunnerPath;
     }
   }
 
   void testNameHandler(ExpectationSet testExpectations, String testName) {
     // Only run the tests that match the pattern. Use the name
     // "suiteName/testName" for cc tests.
     String constructedName = '$suiteName/$testPrefix$testName';
 
     var expectations = testExpectations.expectations('$testPrefix$testName');
 
-    var args = TestUtils.standardOptions(configuration);
-    var compilerConfiguration = new CompilerConfiguration(configuration);
-    if (compilerConfiguration.useDfe) {
+    var args = configuration.standardOptions.toList();
+    if (configuration.compilerConfiguration.useDfe) {
       args.add('--use-dart-frontend');
       // '--dfe' has to be the first argument for run_vm_test to pick it up.
       args.insert(0, '--dfe=$buildDir/gen/kernel-service.dart.snapshot');
     }
+
     args.add(testName);
 
     var command = CommandBuilder.instance.getProcessCommand(
         'run_vm_unittest', targetRunnerPath, args, environmentOverrides);
     enqueueNewTestCase(
         new TestCase(constructedName, [command], configuration, expectations));
   }
 
   Future<Null> forEachTest(Function onTest, Map testCache,
       [VoidFunction onDone]) async {
@@ skipping 14 matching lines @@
     } catch (error) {
       print("Fatal error occured: $error");
       exit(1);
     }
   }
 }
 
 class TestInformation {
   Path filePath;
   Path originTestPath;
-  Map optionsFromFile;
+  Map<String, dynamic> optionsFromFile;
   bool hasCompileError;
   bool hasRuntimeError;
   bool isNegativeIfChecked;
   bool hasCompileErrorIfChecked;
   bool hasStaticWarning;
   String multitestKey;
 
   TestInformation(
       this.filePath,
       this.originTestPath,
@@ skipping 32 matching lines @@
   final Path suiteDir;
   final List<String> statusFilePaths;
   ExpectationSet testExpectations;
   List<TestInformation> cachedTests;
   final Path dartDir;
   Predicate<String> isTestFilePredicate;
   final bool listRecursively;
   final List<String> extraVmOptions;
   List<Uri> _dart2JsBootstrapDependencies;
 
-  StandardTestSuite(Map<String, dynamic> configuration, String suiteName,
+  StandardTestSuite(Configuration configuration, String suiteName,
       Path suiteDirectory, this.statusFilePaths,
       {this.isTestFilePredicate, bool recursive: false})
       : dartDir = TestUtils.dartDir,
         listRecursively = recursive,
         suiteDir = TestUtils.dartDir.join(suiteDirectory),
-        extraVmOptions = TestUtils.getExtraVmOptions(configuration),
+        extraVmOptions = configuration.vmOptions,
         super(configuration, suiteName) {
     if (!useSdk) {
       _dart2JsBootstrapDependencies = [];
     } else {
       var snapshotPath = TestUtils
           .absolutePath(
               new Path(buildDir).join(new Path('dart-sdk/bin/snapshots/'
                   'utils_wrapper.dart.snapshot')))
           .toString();
       _dart2JsBootstrapDependencies = [
@@ skipping 23 matching lines @@
    *
    * 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<String, dynamic> configuration, Path directory) {
+      Configuration 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 38 matching lines @@
     doTest = null;
     if (onDone != null) onDone();
   }
 
   /**
    * If Content shell/Dartium is required, and not yet updated, waits for
    * the update then completes. Otherwise completes immediately.
    */
   Future updateDartium() {
     var completer = new Completer();
-    var updater = runtimeUpdater(configuration);
+    var updater = runtimeUpdater(configuration.runtime, configuration.drtPath,
+        configuration.dartiumPath);
     if (updater == null || updater.updated) {
       return new Future.value(null);
     }
 
     assert(updater.isActive);
     updater.onUpdated.add(() => completer.complete(null));
 
     return completer.future;
   }
 
@@ skipping 30 matching lines @@
         .list(recursive: listRecursively)
         .where((fse) => fse is File)
         .forEach((FileSystemEntity entity) {
       enqueueFile((entity as File).path, group);
     });
     group.add(lister);
   }
 
   void enqueueFile(String filename, FutureGroup group) {
     if (isHtmlTestFile(filename)) {
-      var info = htmlTest.getInformation(filename);
+      var info = html_test.getInformation(filename);
       if (info == null) {
         DebugLogger
             .error("HtmlTest $filename does not contain required annotations");
         return;
       }
       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'] as bool) {
-      group.add(doMultitest(
-          filePath,
-          buildDir,
-          suiteDir,
-          createTestCase,
-          ((configuration['hot_reload'] as bool) ||
-              (configuration['hot_reload_rollback'] as bool))));
+      group.add(doMultitest(filePath, buildDir, suiteDir, createTestCase,
+          configuration.hotReload || configuration.hotReloadRollback));
     } else {
       createTestCase(
           filePath,
           filePath,
           optionsFromFile['hasCompileError'] as bool,
           optionsFromFile['hasRuntimeError'] as bool,
           hasStaticWarning: optionsFromFile['hasStaticWarning'] as bool);
     }
   }
 
@@ skipping 29 matching lines @@
     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'] as String);
+      if (configuration.packageRoot != null) {
+        packageRoot = new Path(configuration.packageRoot);
         optionsFromFile['packageRoot'] = packageRoot.toNativePath();
       }
-      if (configuration['packages'] != null) {
-        Path packages = new Path(configuration['packages'] as String);
+      if (configuration.packages != null) {
+        Path packages = new Path(configuration.packages);
         optionsFromFile['packages'] = packages.toNativePath();
       }
     }
-    if (new CompilerConfiguration(configuration).hasCompiler &&
+    if (configuration.compilerConfiguration.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'] as String)) {
+    } else if (configuration.runtime.isBrowser) {
       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.
         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);
         }
@@ skipping 29 matching lines @@
       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'] as bool) && info.hasCompileErrorIfChecked);
+        (configuration.isChecked && info.hasCompileErrorIfChecked);
   }
 
   bool isNegative(TestInformation info) {
     bool negative = expectCompileError(info) ||
-        ((configuration['checked'] as bool) && info.isNegativeIfChecked);
+        (configuration.isChecked && 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);
+    var compilerConfiguration = configuration.compilerConfiguration;
     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) {
@@ skipping 12 matching lines @@
       }
     }
 
     CommandArtifact compilationArtifact =
         compilerConfiguration.computeCompilationArtifact(
             buildDir,
             tempDir,
             CommandBuilder.instance,
             compileTimeArguments,
             environmentOverrides);
-    if (!(configuration['skip-compilation'] as bool)) {
+    if (!configuration.skipCompilation) {
       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 =
         compilerConfiguration.computeRuntimeArguments(
-            runtimeConfiguration,
+            configuration.runtimeConfiguration,
             buildDir,
             info,
             vmOptions,
             sharedOptions,
             args,
             compilationArtifact);
 
     return commands
-      ..addAll(runtimeConfiguration.computeRuntimeCommands(
+      ..addAll(configuration.runtimeConfiguration.computeRuntimeCommands(
           this,
           CommandBuilder.instance,
           compilationArtifact,
           runtimeArguments,
           environmentOverrides));
   }
 
-  CreateTest makeTestCaseCreator(Map optionsFromFile) {
+  CreateTest makeTestCaseCreator(Map<String, dynamic> optionsFromFile) {
     return (Path filePath, Path originTestPath, bool hasCompileError,
         bool hasRuntimeError,
         {bool isNegativeIfChecked: false,
         bool hasCompileErrorIfChecked: false,
         bool hasStaticWarning: false,
         String multitestKey}) {
       // Cache the test information for each test case.
       var info = new TestInformation(
           filePath,
           originTestPath,
@@ skipping 13 matching lines @@
    * _createUrlPathFromFile takes a [file], which is either located in the dart
    * or in the build directory, and will return a String representing
    * the relative path to either the dart or the build directory.
    * Thus, the returned [String] will be the path component of the URL
    * corresponding to [file] (the http server serves files relative to the
    * dart/build directories).
    */
   String _createUrlPathFromFile(Path file) {
     file = TestUtils.absolutePath(file);
 
-    var relativeBuildDir = new Path(TestUtils.buildDir(configuration));
+    var relativeBuildDir = new Path(configuration.buildDirectory);
     var buildDir = TestUtils.absolutePath(relativeBuildDir);
     var dartDir = TestUtils.absolutePath(TestUtils.dartDir);
 
     var fileString = file.toString();
     if (fileString.startsWith(buildDir.toString())) {
       var fileRelativeToBuildDir = file.relativeTo(buildDir);
       return "/$PREFIX_BUILDDIR/$fileRelativeToBuildDir";
     } else if (fileString.startsWith(dartDir.toString())) {
       var fileRelativeToDartDir = file.relativeTo(dartDir);
       return "/$PREFIX_DARTDIR/$fileRelativeToDartDir";
     }
     // 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'] as bool) {
+    if (configuration.listTests) {
       return Uri.parse('http://listing_the_tests_only');
     }
-    assert(configuration.containsKey('_servers_'));
-    var servers = configuration['_servers_'] as TestingServers;
-    var serverPort = servers.port;
-    var crossOriginPort = servers.crossOriginPort;
+
+    var serverPort = configuration.servers.port;
+    var crossOriginPort = configuration.servers.crossOriginPort;
     var parameters = {'crossOriginPort': crossOriginPort.toString()};
     if (subtestName != null) {
       parameters['group'] = subtestName;
     }
     return new Uri(
         scheme: 'http',
-        host: configuration['local_ip'] as String,
+        host: configuration.localIP,
         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 41 matching lines @@
       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();
+    var filePath = info.filePath;
+    var fileName = filePath.toString();
 
-    var compiler = configuration['compiler'] as String;
-    var runtime = configuration['runtime'] as String;
-    final Map optionsFromFile = info.optionsFromFile;
+    var optionsFromFile = info.optionsFromFile;
 
-    final String compilationTempDir =
-        createCompilationOutputDirectory(info.filePath);
+    var compilationTempDir = createCompilationOutputDirectory(info.filePath);
 
-    String dartWrapperFilename = '$tempDir/test.dart';
-    String compiledDartWrapperFilename = '$compilationTempDir/test.js';
+    var dartWrapperFilename = '$tempDir/test.dart';
+    var compiledDartWrapperFilename = '$compilationTempDir/test.js';
 
     String content = null;
-    Path dir = filePath.directoryPath;
-    String nameNoExt = filePath.filenameWithoutExtension;
+    var dir = filePath.directoryPath;
+    var nameNoExt = filePath.filenameWithoutExtension;
 
-    String customHtmlPath = dir.append('$nameNoExt.html').toNativePath();
-    File customHtml = new File(customHtmlPath);
+    var customHtmlPath = dir.append('$nameNoExt.html').toNativePath();
+    var customHtml = new File(customHtmlPath);
 
     // Construct the command(s) that compile all the inputs needed by the
     // browser test. For running Dart in DRT, this will be noop commands.
-    List<Command> commands = []..addAll(baseCommands);
+    var commands = baseCommands.toList();
 
     // Use existing HTML document if available.
     String htmlPath;
     if (customHtml.existsSync()) {
       // If necessary, run the Polymer deploy steps.
       // TODO(jmesserly): this should be generalized for any tests that
       // require Pub deploy, not just polymer.
       if (customHtml.readAsStringSync().contains('<!--polymer-test')) {
-        if (compiler != 'none') {
+        if (configuration.compiler != Compiler.none) {
           commands.add(
               _polymerDeployCommand(customHtmlPath, tempDir, optionsFromFile));
 
           Path pubspecYamlFile = _findPubspecYamlFile(filePath);
           Path homeDir =
               (pubspecYamlFile == null) ? dir : pubspecYamlFile.directoryPath;
           htmlPath = '$tempDir/${dir.relativeTo(homeDir)}/$nameNoExt.html';
           dartWrapperFilename = '${htmlPath}_bootstrap.dart';
           compiledDartWrapperFilename = '$dartWrapperFilename.js';
         } else {
           htmlPath = customHtmlPath;
         }
       } else {
         htmlPath = '$tempDir/test.html';
         dartWrapperFilename = filePath.toNativePath();
 
         var htmlContents = customHtml.readAsStringSync();
-        if (compiler == 'none') {
+        if (configuration.compiler == Compiler.none) {
           var dartUrl = _createUrlPathFromFile(filePath);
           var dartScript =
               '<script type="application/dart" src="$dartUrl"></script>';
           var jsUrl = '/packages/browser/dart.js';
           var jsScript =
               '<script type="text/javascript" src="$jsUrl"></script>';
           htmlContents = htmlContents.replaceAll(
               '%TEST_SCRIPTS%', '$dartScript\n$jsScript');
         } else {
           compiledDartWrapperFilename = '$tempDir/$nameNoExt.js';
           var jsUrl = '$nameNoExt.js';
           htmlContents = htmlContents.replaceAll(
               '%TEST_SCRIPTS%', '<script src="$jsUrl"></script>');
         }
         new File(htmlPath).writeAsStringSync(htmlContents);
       }
     } else {
       htmlPath = '$tempDir/test.html';
-      if (configuration['compiler'] != 'dart2js') {
+      if (configuration.compiler != Compiler.dart2js) {
         // test.dart will import the dart test.
         _createWrapperFile(dartWrapperFilename, filePath);
       } else {
-        dartWrapperFilename = filename;
+        dartWrapperFilename = fileName;
       }
 
       // Create the HTML file for the test.
-      RandomAccessFile htmlTest =
-          new File(htmlPath).openSync(mode: FileMode.WRITE);
+      var htmlTest = new File(htmlPath).openSync(mode: FileMode.WRITE);
 
-      String scriptPath = dartWrapperFilename;
-      if (compiler != 'none') {
+      var scriptPath = dartWrapperFilename;
+      if (configuration.compiler != Compiler.none) {
         scriptPath = compiledDartWrapperFilename;
       }
       scriptPath = _createUrlPathFromFile(new Path(scriptPath));
 
-      content = getHtmlContents(filename, scriptType, new Path("$scriptPath"));
+      content = getHtmlContents(fileName, scriptType, new Path("$scriptPath"));
       htmlTest.writeStringSync(content);
       htmlTest.closeSync();
     }
 
-    if (compiler != 'none') {
+    if (configuration.compiler != Compiler.none) {
+      assert(configuration.compiler == Compiler.dart2js);
+
       commands.add(_compileCommand(dartWrapperFilename,
-          compiledDartWrapperFilename, compiler, tempDir, optionsFromFile));
+          compiledDartWrapperFilename, tempDir, optionsFromFile));
     }
 
     // some tests require compiling multiple input scripts.
     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') {
+
+      if (configuration.compiler != Compiler.none) {
+        assert(configuration.compiler == Compiler.dart2js);
         assert(namePath.extension == 'dart');
+
         commands.add(_compileCommand(fromPath.toNativePath(),
-            '$tempDir/$fileName.js', compiler, tempDir, optionsFromFile));
+            '$tempDir/${namePath.filename}.js', tempDir, optionsFromFile));
       }
-      if (compiler == 'none') {
+
+      if (configuration.compiler == 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.
         var result = new File(fromPath.toNativePath()).readAsStringSync();
-        new File('$tempDir/$fileName').writeAsStringSync(result);
+        new File('$tempDir/${namePath.filename}').writeAsStringSync(result);
       }
     }
 
     // Variables for browser multi-tests.
     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
       var commandSet = commands.toList();
 
       var htmlPath_subtest = _createUrlPathFromFile(new Path(htmlPath));
       var fullHtmlPath =
           _getUriForBrowserTest(htmlPath_subtest, subtestName).toString();
 
-      if (runtime == "drt") {
+      if (configuration.runtime == 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') {
+        if (configuration.system == System.linux &&
+            configuration.runtime == 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') {
+
+        if (configuration.compiler == Compiler.none) {
           dartFlags.add('--ignore-unrecognized-flags');
-          if (configuration["checked"] as bool) {
+          if (configuration.isChecked) {
             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)));
+            fullHtmlPath, configuration, !isNegative(info)));
       }
 
       // Create BrowserTestCase and queue it.
       var fullTestName = multitest ? '$testName/$subtestName' : testName;
       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) {
-    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');
+    var compiler = configuration.compiler;
+    var runtime = configuration.runtime;
 
-    final Path filePath = info.filePath;
-    final String tempDir = createOutputDirectory(filePath, '');
-    final Uri tempUri = new Uri.file('$tempDir/');
-    String contents = htmlTest.getContents(info, compileToJS);
-    final commands = <Command>[];
+    // HTML tests work only with the browser controller.
+    if (!runtime.isBrowser || runtime == Runtime.drt) return;
 
-    void Fail(String message) {
+    var compileToJS = compiler == Compiler.dart2js;
+
+    var filePath = info.filePath;
+    var tempDir = createOutputDirectory(filePath, '');
+    var tempUri = new Uri.file('$tempDir/');
+    var contents = html_test.getContents(info, compileToJS);
+    var commands = <Command>[];
+
+    void fail(String message) {
       var msg = "$message: ${info.filePath}";
       DebugLogger.warning(msg);
-      contents = htmlTest.makeFailingHtmlFile(msg);
+      contents = html_test.makeFailingHtmlFile(msg);
     }
 
     if (info.scripts.length > 0) {
-      Uri testUri = new Uri.file(filePath.toNativePath());
-      for (String scriptPath in info.scripts) {
+      var testUri = new Uri.file(filePath.toNativePath());
+      for (var scriptPath in info.scripts) {
         if (!scriptPath.endsWith('.dart') && !scriptPath.endsWith('.js')) {
-          Fail('HTML test scripts must be dart or javascript: $scriptPath');
+          fail('HTML test scripts must be dart or javascript: $scriptPath');
           break;
         }
-        Uri uri = Uri.parse(scriptPath);
+
+        var uri = Uri.parse(scriptPath);
         if (uri.isAbsolute) {
-          Fail('HTML test scripts must have relative paths: $scriptPath');
+          fail('HTML test scripts must have relative paths: $scriptPath');
           break;
         }
+
         if (uri.pathSegments.length > 1) {
-          Fail('HTML test scripts must be in test directory: $scriptPath');
+          fail('HTML test scripts must be in test directory: $scriptPath');
           break;
         }
-        Uri script = testUri.resolveUri(uri);
-        Uri copiedScript = tempUri.resolveUri(uri);
-        if (compiler == 'none' || scriptPath.endsWith('.js')) {
+
+        var script = testUri.resolveUri(uri);
+        var copiedScript = tempUri.resolveUri(uri);
+        if (compiler == Compiler.none || scriptPath.endsWith('.js')) {
           new File.fromUri(copiedScript)
               .writeAsStringSync(new File.fromUri(script).readAsStringSync());
         } else {
           var destination = copiedScript.toFilePath();
           if (compileToJS) {
             destination = destination.replaceFirst(dartExtension, '.js');
           }
-          commands.add(_compileCommand(script.toFilePath(), destination,
-              compiler, tempDir, info.optionsFromFile));
+
+          assert(compiler == Compiler.dart2js);
+
+          commands.add(_compileCommand(
+              script.toFilePath(), destination, tempDir, info.optionsFromFile));
         }
       }
     }
-    final Uri htmlFile = tempUri.resolve(filePath.filename);
+
+    var htmlFile = tempUri.resolve(filePath.filename);
     new File.fromUri(htmlFile).writeAsStringSync(contents);
 
     var htmlPath = _createUrlPathFromFile(new Path(htmlFile.toFilePath()));
     var fullHtmlPath = _getUriForBrowserTest(htmlPath, null).toString();
-    commands.add(CommandBuilder.instance.getBrowserHtmlTestCommand(runtime,
+    commands.add(CommandBuilder.instance.getBrowserHtmlTestCommand(
         fullHtmlPath, configuration, info.expectedMessages, !isNegative(info)));
-    String testDisplayName = '$suiteName/$testName';
+    var testDisplayName = '$suiteName/$testName';
     var testCase = new BrowserTestCase(testDisplayName, commands, configuration,
         expectations, info, isNegative(info), fullHtmlPath);
     enqueueNewTestCase(testCase);
-    return;
   }
 
   /** Helper to create a compilation command for a single input file. */
-  Command _compileCommand(String inputFile, String outputFile, String compiler,
-      String dir, Map optionsFromFile) {
-    assert(compiler == 'dart2js');
-    List<String> args;
+  Command _compileCommand(String inputFile, String outputFile, String dir,
+      Map<String, dynamic> optionsFromFile) {
+    var args = <String>[];
+
     if (compilerPath.endsWith('.dart')) {
       // Run the compiler script via the Dart VM.
-      args = [compilerPath];
-    } else {
-      args = [];
+      args.add(compilerPath);
     }
-    args.addAll(TestUtils.standardOptions(configuration));
+
+    args.addAll(configuration.standardOptions);
+
     var packages = packagesArgument(optionsFromFile['packageRoot'] as String,
         optionsFromFile['packages'] as String);
     if (packages != null) args.add(packages);
+
     args.add('--out=$outputFile');
     args.add(inputFile);
+
     var options = optionsFromFile['sharedOptions'] as List<String>;
     if (options != null) args.addAll(options);
+
     return CommandBuilder.instance.getCompilationCommand(
-        compiler,
+        Compiler.dart2js.name,
         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'] as String,
+  Command _polymerDeployCommand(String inputFile, String outputDir,
+      Map<String, dynamic> optionsFromFile) {
+    var args = <String>[];
+    var 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'] as bool) args.add('--csp');
+    if (configuration.isCsp) args.add('--csp');
 
     return CommandBuilder.instance.getProcessCommand(
         'polymer_deploy', dartVmBinaryFileName, args, environmentOverrides);
   }
 
   String get scriptType {
-    switch (configuration['compiler'] as String) {
-      case 'none':
+    switch (configuration.compiler) {
+      case Compiler.none:
         return 'application/dart';
-      case 'dart2js':
-      case 'dart2analyzer':
+      case Compiler.dart2js:
+      case Compiler.dart2analyzer:
         return 'text/javascript';
       default:
         print('Non-web runtime, so no scriptType for: '
-            '${configuration["compiler"]}');
+            '${configuration.compiler.name}');
         exit(1);
         return null;
     }
   }
 
-  bool get hasRuntime {
-    switch (configuration['runtime'] as String) {
-      case 'none':
-        return false;
-      default:
-        return true;
-    }
-  }
+  bool get hasRuntime => configuration.runtime != Runtime.none;
 
   String get contentShellFilename {
-    if (configuration['drt'] != '') {
-      return configuration['drt'] as String;
-    }
+    if (configuration.drtPath != null) return configuration.drtPath;
+
     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);
+  List<String> commonArgumentsFromFile(
+      Path filePath, Map<String, dynamic> optionsFromFile) {
+    var args = configuration.standardOptions.toList();
 
     String packages = packagesArgument(optionsFromFile['packageRoot'] as String,
         optionsFromFile['packages'] as String);
     if (packages != null) {
       args.add(packages);
     }
     args.addAll(additionalOptions(filePath));
-    if (configuration['analyzer'] as bool) {
+    if (configuration.compiler == Compiler.dart2analyzer) {
       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");
+      if (filePath.filename.contains("dart2js") ||
+          filePath.directoryPath.segments().last.contains('html_common')) {
+        args.add("--use-dart2js-libraries");
+      }
     }
 
     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);
     }
@@ skipping 71 matching lines @@
    *   an image, if the expectation ends in .png. 'test.dart' will compare the
    *   snapshot to the expectation file. When tests fail, 'test.dart' saves the
    *   new snapshot into a file so it can be visualized or copied over.
    *   Expectations can be recorded for the first time by creating an empty file
    *   with the right name (touch test_name_test.png), running the test, and
    *   executing the copy command printed by the test script.
    *
    * This method is static as the map is cached and shared amongst
    * configurations, so it may not use [configuration].
    */
-  Map readOptionsFromFile(Path filePath) {
+  Map<String, dynamic> readOptionsFromFile(Path filePath) {
     if (filePath.filename.endsWith('.dill')) {
       return optionsFromKernelFile();
     } else if (filePath.segments().contains('co19')) {
       return readOptionsFromCo19File(filePath);
     }
     RegExp testOptionsRegExp = new RegExp(r"// VMOptions=(.*)");
     RegExp sharedOptionsRegExp = new RegExp(r"// SharedOptions=(.*)");
     RegExp dartOptionsRegExp = new RegExp(r"// DartOptions=(.*)");
     RegExp otherScriptsRegExp = new RegExp(r"// OtherScripts=(.*)");
     RegExp otherResourcesRegExp = new RegExp(r"// OtherResources=(.*)");
     RegExp packageRootRegExp = new RegExp(r"// PackageRoot=(.*)");
     RegExp packagesRegExp = new RegExp(r"// Packages=(.*)");
     RegExp isolateStubsRegExp = new RegExp(r"// IsolateStubs=(.*)");
     // TODO(gram) Clean these up once the old directives are not supported.
     RegExp domImportRegExp = new RegExp(
         r"^[#]?import.*dart:(html|web_audio|indexed_db|svg|web_sql)",
         multiLine: true);
 
     var bytes = new File(filePath.toNativePath()).readAsBytesSync();
     String contents = decodeUtf8(bytes);
     bytes = null;
 
     // Find the options in the file.
     var result = <List<String>>[];
     List<String> dartOptions;
     List<String> sharedOptions;
     String packageRoot;
     String packages;
 
-    Iterable<Match> matches = testOptionsRegExp.allMatches(contents);
+    var matches = testOptionsRegExp.allMatches(contents);
     for (var match in matches) {
       result.add(match[1].split(' ').where((e) => e != '').toList());
     }
     if (result.isEmpty) result.add([]);
 
     matches = dartOptionsRegExp.allMatches(contents);
     for (var match in matches) {
       if (dartOptions != null) {
         throw new Exception(
             'More than one "// DartOptions=" line in test $filePath');
@@ skipping 77 matching lines @@
       "otherScripts": otherScripts,
       "otherResources": otherResources,
       "isMultitest": isMultitest,
       "isMultiHtmlTest": isMultiHtmlTest,
       "subtestNames": subtestNames,
       "isolateStubs": isolateStubs,
       "containsDomImport": containsDomImport
     };
   }
 
-  Map optionsFromKernelFile() {
+  Map<String, dynamic> optionsFromKernelFile() {
     return const {
       "vmOptions": const [const []],
       "sharedOptions": const [],
       "dartOptions": null,
       "packageRoot": null,
       "packages": null,
       "hasCompileError": false,
       "hasRuntimeError": false,
       "hasStaticWarning": false,
       "otherScripts": const [],
       "isMultitest": false,
       "isMultiHtmlTest": false,
       "subtestNames": const [],
       "isolateStubs": '',
       "containsDomImport": false,
     };
   }
 
-  List<List<String>> getVmOptions(Map optionsFromFile) {
-    var COMPILERS = const ['none', 'dartk', 'dartkp', 'precompiler', 'app_jit'];
-    var RUNTIMES = const [
-      'none',
-      'dart_precompiled',
-      'vm',
-      'drt',
-      'dartium',
-      'ContentShellOnAndroid',
-      'DartiumOnAndroid'
+  List<List<String>> getVmOptions(Map<String, dynamic> optionsFromFile) {
+    const compilers = const [
+      Compiler.none,
+      Compiler.dartk,
+      Compiler.dartkp,
+      Compiler.precompiler,
+      Compiler.appJit
     ];
-    var needsVmOptions = COMPILERS.contains(configuration['compiler']) &&
-        RUNTIMES.contains(configuration['runtime']);
+
+    const runtimes = const [
+      Runtime.none,
+      Runtime.dartPrecompiled,
+      Runtime.vm,
+      Runtime.drt,
+      Runtime.dartium,
+      Runtime.contentShellOnAndroid,
+      Runtime.dartiumOnAndroid
+    ];
+
+    var needsVmOptions = compilers.contains(configuration.compiler) &&
+        runtimes.contains(configuration.runtime);
     if (!needsVmOptions) return [[]];
     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.
    *
    * Also, [readOptionsFromFile] recognizes a number of additional
    * tags that are not appropriate for use in general tests of
    * conformance to the Dart language. Any Dart implementation must
    * pass the co19 test suite as is, and not require extra flags,
    * environment variables, configuration files, etc.
    */
-  Map readOptionsFromCo19File(Path filePath) {
+  Map<String, dynamic> readOptionsFromCo19File(Path filePath) {
     String contents =
         decodeUtf8(new File(filePath.toNativePath()).readAsBytesSync());
 
     bool hasCompileError = contents.contains("@compile-error");
     bool hasRuntimeError = contents.contains("@runtime-error");
     bool hasStaticWarning = contents.contains("@static-warning");
     bool isMultitest = multiTestRegExp.hasMatch(contents);
 
     return {
       "vmOptions": <List>[[]],
@@ skipping 10 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<String, dynamic> configuration, Path directoryPath)
+  PKGTestSuite(Configuration 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) {
-    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 {
       var relativeHtml = customHtmlPath.relativeTo(TestUtils.dartDir);
       var commands = baseCommands.toList();
       var fullPath = _createUrlPathFromFile(customHtmlPath);
 
-      commands.add(CommandBuilder.instance.getBrowserTestCommand(
-          runtime, fullPath, configuration, !isNegative(info)));
+      commands.add(CommandBuilder.instance
+          .getBrowserTestCommand(fullPath, configuration, !isNegative(info)));
       var testDisplayName = '$suiteName/$testName';
       enqueueNewTestCase(new BrowserTestCase(
           testDisplayName,
           commands,
           configuration,
           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<String, dynamic> configuration,
+      Configuration 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<String, dynamic> configuration) =>
-      configuration['use_sdk'] as bool
-          ? '${TestUtils.buildDir(configuration)}/dart-sdk'
-          : 'sdk';
+  static String libraryPath(Configuration configuration) =>
+      configuration.useSdk ? '${configuration.buildDirectory}/dart-sdk' : 'sdk';
 
-  AnalyzeLibraryTestSuite(Map<String, dynamic> configuration)
+  AnalyzeLibraryTestSuite(Configuration 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 142 matching lines @@
           throw new Exception('Can\'t delete path $native_path. '
               'This path might be too long');
         }
       });
     } 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'] 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']}"
+  static void deleteTempSnapshotDirectory(Configuration configuration) {
+    if (configuration.compiler == Compiler.appJit ||
+        configuration.compiler == Compiler.precompiler) {
+      var checked = configuration.isChecked ? '-checked' : '';
+      var strong = configuration.isStrong ? '-strong' : '';
+      var minified = configuration.isMinified ? '-minified' : '';
+      var csp = configuration.isCsp ? '-csp' : '';
+      var sdk = configuration.useSdk ? '-sdk' : '';
+      var dirName = "${configuration.compiler.name}"
           "$checked$strong$minified$csp$sdk";
-      String generatedPath = "${TestUtils.buildDir(configuration)}"
-          "/generated_compilations/$dirName";
+      var generatedPath =
+          configuration.buildDirectory + "/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'] as bool) &&
-        !existsCache.doesFileExist(filename)) {
+  static void ensureExists(String filename, Configuration configuration) {
+    if (!configuration.listTests && !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'] 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"];
-    var compiler = configuration["compiler"] as String;
-    if (compiler == "dart2js") {
-      args = ['--generate-code-with-compile-time-errors', '--test-mode'];
-      if (configuration["checked"] as bool) {
-        args.add('--enable-checked-mode');
-      }
-      // args.add("--verbose");
-      if (!isBrowserRuntime(configuration['runtime'] as String)) {
-        args.add("--allow-mock-compilation");
-        args.add("--categories=all");
-      }
-    }
-    if ((compiler == "dart2js") && (configuration["minified"] as bool)) {
-      args.add("--minify");
-    }
-    if (compiler == "dart2js" && (configuration["csp"] as bool)) {
-      args.add("--csp");
-    }
-    if (compiler == "dart2js" && (configuration["fast_startup"] as bool)) {
-      args.add("--fast-startup");
-    }
-    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',
-      'ie10',
-      'ie11',
-      'safari',
-      'opera',
-      'chrome',
-      'ff',
-      'chromeOnAndroid',
-      'safarimobilesim',
-      'ContentShellOnAndroid',
-      'DartiumOnAndroid'
-    ];
-    return BROWSERS.contains(runtime);
-  }
-
-  static bool isJsCommandLineRuntime(String runtime) =>
-      const ['d8', 'jsshell'].contains(runtime);
-
-  static bool isCommandLineAnalyzer(String compiler) =>
-      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'] as String);
-    }
-    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'] 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'] 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'] 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] 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) =>
-      getExtraOptions(configuration, 'vm_options');
-
   static int shortNameCounter = 0; // Make unique short file names on Windows.
 
   static String getShortName(String path) {
     final PATH_REPLACEMENTS = const {
       "pkg_polymer_e2e_test_bad_import_test": "polymer_bi",
       "pkg_polymer_e2e_test_canonicalization_test": "polymer_c16n",
       "pkg_polymer_e2e_test_experimental_boot_test": "polymer_boot",
       "pkg_polymer_e2e_test_good_import_test": "polymer_gi",
       "tests_co19_src_Language_12_Expressions_14_Function_Invocation_":
           "co19_fn_invoke_",
@@ skipping 63 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;
   }
 }