Revert "Revert "Revert "Refactor test option parsing code."""

tools/testing/dart/test_options.dart

Index: tools/testing/dart/test_options.dart
diff --git a/tools/testing/dart/test_options.dart b/tools/testing/dart/test_options.dart
new file mode 100644
index 0000000000000000000000000000000000000000..06ddec629ea8f66c08ab9c581d0c61a1baa5780d
--- /dev/null
+++ b/tools/testing/dart/test_options.dart
@@ -0,0 +1,1012 @@
+// Copyright (c) 2013, 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.
+
+library test_options_parser;
+
+import "dart:io";
+import "drt_updater.dart";
+import "test_suite.dart";
+import "path.dart";
+import "compiler_configuration.dart" show CompilerConfiguration;
+import "runtime_configuration.dart" show RuntimeConfiguration;
+
+const List<String> defaultTestSelectors = const [
+  'samples',
+  'standalone',
+  'corelib',
+  'co19',
+  'language',
+  'isolate',
+  'vm',
+  'html',
+  'benchmark_smoke',
+  'utils',
+  'lib',
+  'analyze_library',
+  'service',
+  'kernel',
+  'observatory_ui'
+];
+
+/**
+ * Specification of a single test option.
+ *
+ * The name of the specification is used as the key for the option in
+ * the Map returned from the [TestOptionParser] parse method.
+ */
+class _TestOptionSpecification {
+  _TestOptionSpecification(
+      this.name, this.description, this.keys, this.values, this.defaultValue,
+      {this.type: 'string'});
+  String name;
+  String description;
+  List<String> keys;
+  List<String> values;
+  Object defaultValue;
+  String type;
+}
+
+/**
+ * Parser of test options.
+ */
+class TestOptionsParser {
+  /**
+   * Creates a test options parser initialized with the known options.
+   */
+  TestOptionsParser() {
+    _options = [
+      new _TestOptionSpecification('mode', 'Mode in which to run the tests',
+          ['-m', '--mode'], ['all', 'debug', 'release', 'product'], 'debug'),
+      new _TestOptionSpecification(
+          'compiler',
+          '''Specify any compilation step (if needed).
+
+   none: Do not compile the Dart code (run native Dart code on the VM).
+          (only valid with the following runtimes: vm, flutter, drt)
+
+   precompiler: Compile into AOT snapshot before running the test.
+          (only valid with the dart_precompiled runtime)
+
+   dart2js: Compile dart code to JavaScript by running dart2js.
+          (only valid with the following runtimes: d8, drt, chrome,
+          safari, ie9, ie10, ie11, firefox, opera, chromeOnAndroid,
+          none (compile only)),
+
+   dart2analyzer: Perform static analysis on Dart code by running the analyzer
+          (only valid with the following runtimes: none)
+
+   app_jit: Compile the Dart code into an app snapshot before running test
+          (only valid with dart_app runtime)
+
+   dartk: Compile the Dart source into Kernel before running test.
+
+   dartkp: Compiler the Dart source into Kernel and then Kernel into AOT
+          snapshot before running the test.
+          (only valid with the dart_precompiled runtime)
+          ''',
+          ['-c', '--compiler'],
+          [
+            'none',
+            'precompiler',
+            'dart2js',
+            'dart2analyzer',
+            'app_jit',
+            'dartk',
+            'dartkp'
+          ],
+          'none'),
+      // TODO(antonm): fix the option drt.
+      new _TestOptionSpecification(
+          'runtime',
+          '''Where the tests should be run.
+    vm: Run Dart code on the standalone dart vm.
+
+    flutter: Run Dart code on the flutter engine.
+
+    dart_precompiled: Run a precompiled snapshot on a variant of the standalone
+                      dart vm lacking a JIT.
+
+    d8: Run JavaScript from the command line using v8.
+
+    jsshell: Run JavaScript from the command line using firefox js-shell.
+
+    drt: Run Dart or JavaScript in the headless version of Chrome,
+         Content shell.
+
+    dartium: Run Dart or JavaScript in Dartium.
+
+    ContentShellOnAndroid: Run Dart or JavaScript in Dartium content shell
+                      on Android.
+
+    DartiumOnAndroid: Run Dart or Javascript in Dartium on Android.
+
+    [ff | chrome | safari | ie9 | ie10 | ie11 | opera | chromeOnAndroid]:
+        Run JavaScript in the specified browser.
+
+    self_check: Pass each test or its compiled output to every file under
+        `pkg` whose name ends with `_self_check.dart`.
+        Each test is given to the self_check tester as a filename on stdin using
+        the batch-mode protocol.
+
+    none: No runtime, compile only (for example, used for dart2analyzer static
+          analysis tests).''',
+          ['-r', '--runtime'],
+          [
+            'vm',
+            'flutter',
+            'dart_precompiled',
+            'd8',
+            'jsshell',
+            'drt',
+            'dartium',
+            'ff',
+            'firefox',
+            'chrome',
+            'safari',
+            'ie9',
+            'ie10',
+            'ie11',
+            'opera',
+            'chromeOnAndroid',
+            'safarimobilesim',
+            'ContentShellOnAndroid',
+            'DartiumOnAndroid',
+            'self_check',
+            'none'
+          ],
+          'vm'),
+      new _TestOptionSpecification(
+          'arch',
+          'The architecture to run tests for',
+          ['-a', '--arch'],
+          [
+            'all',
+            'ia32',
+            'x64',
+            'arm',
+            'armv6',
+            'armv5te',
+            'arm64',
+            'mips',
+            'simarm',
+            'simarmv6',
+            'simarmv5te',
+            'simarm64',
+            'simmips',
+            'simdbc',
+            'simdbc64',
+          ],
+          'x64'),
+      new _TestOptionSpecification(
+          'system',
+          'The operating system to run tests on',
+          ['-s', '--system'],
+          ['linux', 'macos', 'windows', 'android'],
+          Platform.operatingSystem),
+      new _TestOptionSpecification(
+          'checked', 'Run tests in checked mode', ['--checked'], [], false,
+          type: 'bool'),
+      new _TestOptionSpecification(
+          'strong', 'Run tests in strong mode', ['--strong'], [], false,
+          type: 'bool'),
+      new _TestOptionSpecification('host_checked',
+          'Run compiler in checked mode', ['--host-checked'], [], false,
+          type: 'bool'),
+      new _TestOptionSpecification('minified',
+          'Enable minification in the compiler', ['--minified'], [], false,
+          type: 'bool'),
+      new _TestOptionSpecification(
+          'csp',
+          'Run tests under Content Security Policy restrictions',
+          ['--csp'],
+          [],
+          false,
+          type: 'bool'),
+      new _TestOptionSpecification(
+          'cps_ir',
+          'Run the compiler with the cps based backend',
+          ['--cps-ir'],
+          [],
+          false,
+          type: 'bool'),
+      new _TestOptionSpecification(
+          'fast_startup',
+          'Pass the --fast-startup flag to dart2js',
+          ['--fast-startup'],
+          [],
+          false,
+          type: 'bool'),
+      new _TestOptionSpecification(
+          'dart2js_with_kernel',
+          'Enable the internal pipeline in dart2js to use kernel',
+          ['--dart2js-with-kernel'],
+          [],
+          false,
+          type: 'bool'),
+      new _TestOptionSpecification('hot_reload', 'Run hot reload stress tests',
+          ['--hot-reload'], [], false,
+          type: 'bool'),
+      new _TestOptionSpecification(
+          'hot_reload_rollback',
+          'Run hot reload rollback stress tests',
+          ['--hot-reload-rollback'],
+          [],
+          false,
+          type: 'bool'),
+      new _TestOptionSpecification(
+          'use_blobs',
+          'Use mmap instead of shared libraries for precompilation',
+          ['--use-blobs'],
+          [],
+          false,
+          type: 'bool'),
+      new _TestOptionSpecification(
+          'timeout', 'Timeout in seconds', ['-t', '--timeout'], [], -1,
+          type: 'int'),
+      new _TestOptionSpecification(
+          'progress',
+          'Progress indication mode',
+          ['-p', '--progress'],
+          [
+            'compact',
+            'color',
+            'line',
+            'verbose',
+            'silent',
+            'status',
+            'buildbot',
+            'diff'
+          ],
+          'compact'),
+      new _TestOptionSpecification('failure-summary',
+          'Print failure summary at the end', ['--failure-summary'], [], false,
+          type: 'bool'),
+      new _TestOptionSpecification('step_name',
+          'Step name for use by -pbuildbot', ['--step_name'], [], null),
+      new _TestOptionSpecification(
+          'report',
+          'Print a summary report of the number of tests, by expectation',
+          ['--report'],
+          [],
+          false,
+          type: 'bool'),
+      new _TestOptionSpecification(
+          'tasks',
+          'The number of parallel tasks to run',
+          ['-j', '--tasks'],
+          [],
+          Platform.numberOfProcessors,
+          type: 'int'),
+      new _TestOptionSpecification(
+          'shards',
+          'The number of instances that the tests will be sharded over',
+          ['--shards'],
+          [],
+          1,
+          type: 'int'),
+      new _TestOptionSpecification(
+          'shard',
+          'The index of this instance when running in sharded mode',
+          ['--shard'],
+          [],
+          1,
+          type: 'int'),
+      new _TestOptionSpecification(
+          'help', 'Print list of options', ['-h', '--help'], [], false,
+          type: 'bool'),
+      new _TestOptionSpecification(
+          'verbose', 'Verbose output', ['-v', '--verbose'], [], false,
+          type: 'bool'),
+      new _TestOptionSpecification(
+          'verify-ir', 'Verify kernel IR', ['--verify-ir'], [], false,
+          type: 'bool'),
+      new _TestOptionSpecification('no-tree-shake',
+          'Disable kernel IR tree shaking', ['--no-tree-shake'], [], false,
+          type: 'bool'),
+      new _TestOptionSpecification(
+          'list', 'List tests only, do not run them', ['--list'], [], false,
+          type: 'bool'),
+      new _TestOptionSpecification(
+          'report_in_json',
+          'When doing list, output result summary in json only.',
+          ['--report-in-json'],
+          [],
+          false,
+          type: 'bool'),
+      new _TestOptionSpecification('time',
+          'Print timing information after running tests', ['--time'], [], false,
+          type: 'bool'),
+      new _TestOptionSpecification(
+          'dart', 'Path to dart executable', ['--dart'], [], ''),
+      new _TestOptionSpecification(
+          'flutter', 'Path to flutter executable', ['--flutter'], [], ''),
+      new _TestOptionSpecification(
+          'drt', // TODO(antonm): fix the option name.
+          'Path to content shell executable',
+          ['--drt'],
+          [],
+          ''),
+      new _TestOptionSpecification('dartium',
+          'Path to Dartium Chrome executable', ['--dartium'], [], ''),
+      new _TestOptionSpecification('firefox',
+          'Path to firefox browser executable', ['--firefox'], [], ''),
+      new _TestOptionSpecification(
+          'chrome', 'Path to chrome browser executable', ['--chrome'], [], ''),
+      new _TestOptionSpecification(
+          'safari', 'Path to safari browser executable', ['--safari'], [], ''),
+      new _TestOptionSpecification(
+          'use_sdk',
+          '''Use compiler or runtime from the SDK.
+
+Normally, the compiler or runtimes in PRODUCT_DIR is tested, with this
+option, the compiler or runtime in PRODUCT_DIR/dart-sdk/bin is tested.
+
+Note: currently only implemented for dart2js.''',
+          ['--use-sdk'],
+          [],
+          false,
+          type: 'bool'),
+      new _TestOptionSpecification(
+          'build_directory',
+          'The name of the build directory, where products are placed.',
+          ['--build-directory'],
+          [],
+          ''),
+      new _TestOptionSpecification('noBatch', 'Do not run tests in batch mode',
+          ['-n', '--nobatch'], [], false,
+          type: 'bool'),
+      new _TestOptionSpecification('dart2js_batch',
+          'Run dart2js tests in batch mode', ['--dart2js-batch'], [], false,
+          type: 'bool'),
+      new _TestOptionSpecification(
+          'append_logs',
+          'Do not delete old logs but rather append to them.',
+          ['--append_logs'],
+          [],
+          false,
+          type: 'bool'),
+      new _TestOptionSpecification(
+          'write_debug_log',
+          'Don\'t write debug messages to stdout but rather to a logfile.',
+          ['--write-debug-log'],
+          [],
+          false,
+          type: 'bool'),
+      new _TestOptionSpecification(
+          'write_test_outcome_log',
+          'Write the outcome of all tests executed to a '
+          '"${TestUtils.testOutcomeFileName}" file.',
+          ['--write-test-outcome-log'],
+          [],
+          false,
+          type: 'bool'),
+      new _TestOptionSpecification(
+          'reset_browser_configuration',
+          'Browser specific reset of configuration. '
+          'WARNING: Using this option may remove your bookmarks and '
+          'other settings.',
+          ['--reset-browser-configuration'],
+          [],
+          false,
+          type: 'bool'),
+      new _TestOptionSpecification(
+          'copy_coredumps',
+          'If we see a crash that we did not expect, copy the core dumps. '
+          'to /tmp',
+          ['--copy-coredumps'],
+          [],
+          false,
+          type: 'bool'),
+      new _TestOptionSpecification(
+          'local_ip',
+          'IP address the http servers should listen on.'
+          'This address is also used for browsers to connect.',
+          ['--local_ip'],
+          [],
+          '127.0.0.1'),
+      new _TestOptionSpecification('test_server_port',
+          'Port for test http server.', ['--test_server_port'], [], 0,
+          type: 'int'),
+      new _TestOptionSpecification(
+          'test_server_cross_origin_port',
+          'Port for test http server cross origin.',
+          ['--test_server_cross_origin_port'],
+          [],
+          0,
+          type: 'int'),
+      new _TestOptionSpecification('test_driver_port',
+          'Port for http test driver server.', ['--test_driver_port'], [], 0,
+          type: 'int'),
+      new _TestOptionSpecification(
+          'test_driver_error_port',
+          'Port for http test driver server errors.',
+          ['--test_driver_error_port'],
+          [],
+          0,
+          type: 'int'),
+      new _TestOptionSpecification(
+          'record_to_file',
+          'Records all the commands that need to be executed and writes it '
+          'out to a file.',
+          ['--record_to_file'],
+          [],
+          null),
+      new _TestOptionSpecification(
+          'replay_from_file',
+          'Records all the commands that need to be executed and writes it '
+          'out to a file.',
+          ['--replay_from_file'],
+          [],
+          null),
+      new _TestOptionSpecification(
+          'builder_tag',
+          'Machine specific options that is not captured by the regular '
+          'test options. Used to be able to make sane updates to the '
+          'status files.',
+          ['--builder-tag'],
+          [],
+          ''),
+      new _TestOptionSpecification(
+          'vm_options',
+          'Extra options to send to the vm when running',
+          ['--vm-options'],
+          [],
+          null),
+      new _TestOptionSpecification(
+          'dart2js_options',
+          'Extra options for dart2js compilation step',
+          ['--dart2js-options'],
+          [],
+          null),
+      new _TestOptionSpecification(
+          'suite_dir',
+          'Additional directory to add to the testing matrix',
+          ['--suite-dir'],
+          [],
+          null),
+      new _TestOptionSpecification('package_root',
+          'The package root to use for testing.', ['--package-root'], [], null),
+      new _TestOptionSpecification(
+          'packages',
+          'The package spec file to use for testing.',
+          ['--packages'],
+          [],
+          null),
+      new _TestOptionSpecification(
+          'exclude_suite',
+          'Exclude suites from default selector, only works when no'
+          ' selector has been specified on the command line',
+          ['--exclude-suite'],
+          [],
+          null),
+      new _TestOptionSpecification(
+          'skip-compilation',
+          'Skip the compilation step, using the compilation artifacts left in '
+          ' the output folder from a previous run.'
+          'This flag will often cause false positves and negatives, but can be'
+          ' useful for quick-and-dirty offline testing when not making changes'
+          ' that affect the compiler.',
+          ['--skip-compilation'],
+          [],
+          false,
+          type: 'bool')
+    ];
+  }
+
+  /**
+   * Parse a list of strings as test options.
+   *
+   * Returns a list of configurations in which to run the
+   * tests. Configurations are maps mapping from option keys to
+   * values. When encountering the first non-option string, the rest
+   * of the arguments are stored in the returned Map under the 'rest'
+   * key.
+   */
+  List<Map> parse(List<String> arguments) {
+    var configuration = new Map();
+    // Fill in configuration with arguments passed to the test script.
+    var numArguments = arguments.length;
+    for (var i = 0; i < numArguments; i++) {
+      // Extract name and value for options.
+      String arg = arguments[i];
+      String name = '';
+      String value = '';
+      _TestOptionSpecification spec;
+      if (arg.startsWith('--')) {
+        if (arg == '--help') {
+          _printHelp();
+          return null;
+        }
+        var split = arg.indexOf('=');
+        if (split == -1) {
+          name = arg;
+          spec = _getSpecification(name);
+          // Boolean options do not have a value.
+          if (spec.type != 'bool') {
+            if ((i + 1) >= arguments.length) {
+              print('No value supplied for option $name');
+              return null;
+            }
+            value = arguments[++i];
+          }
+        } else {
+          name = arg.substring(0, split);
+          spec = _getSpecification(name);
+          value = arg.substring(split + 1, arg.length);
+        }
+      } else if (arg.startsWith('-')) {
+        if (arg == '-h') {
+          _printHelp();
+          return null;
+        }
+        if (arg.length > 2) {
+          name = arg.substring(0, 2);
+          spec = _getSpecification(name);
+          value = arg.substring(2, arg.length);
+        } else {
+          name = arg;
+          spec = _getSpecification(name);
+          // Boolean options do not have a value.
+          if (spec.type != 'bool') {
+            if ((i + 1) >= arguments.length) {
+              print('No value supplied for option $name');
+              return null;
+            }
+            value = arguments[++i];
+          }
+        }
+      } else {
+        // The argument does not start with '-' or '--' and is
+        // therefore not an option. We use it as a test selection
+        // pattern.
+        var patterns = configuration.putIfAbsent('selectors', () => <String>[]);
+        patterns.add(arg);
+        continue;
+      }
+
+      // Multiple uses of a flag are an error, because there is no
+      // naturally correct way to handle conflicting options.
+      if (configuration.containsKey(spec.name)) {
+        print('Error: test.dart disallows multiple "--${spec.name}" flags');
+        exit(1);
+      }
+      // Parse the value for the option.
+      if (spec.type == 'bool') {
+        if (!value.isEmpty) {
+          print('No value expected for bool option $name');
+          exit(1);
+        }
+        configuration[spec.name] = true;
+      } else if (spec.type == 'int') {
+        try {
+          configuration[spec.name] = int.parse(value);
+        } catch (e) {
+          print('Integer value expected for int option $name');
+          exit(1);
+        }
+      } else {
+        assert(spec.type == 'string');
+        if (!spec.values.isEmpty) {
+          for (var v in value.split(',')) {
+            if (spec.values.lastIndexOf(v) == -1) {
+              print('Unknown value ($v) for option $name');
+              exit(1);
+            }
+          }
+        }
+        configuration[spec.name] = value;
+      }
+    }
+
+    // Apply default values for unspecified options.
+    for (var option in _options) {
+      if (!configuration.containsKey(option.name)) {
+        configuration[option.name] = option.defaultValue;
+      }
+    }
+
+    List<Map> expandedConfigs = _expandConfigurations(configuration);
+    List<Map> result = expandedConfigs.where(_isValidConfig).toList();
+    for (var config in result) {
+      config['_reproducing_arguments_'] =
+          _constructReproducingCommandArguments(config);
+    }
+    return result.isEmpty ? null : result;
+  }
+
+  // For printing out reproducing command lines, we don't want to add these
+  // options.
+  final _blacklistedOptions = [
+    'append_logs',
+    'build_directory',
+    'chrome',
+    'copy_coredumps',
+    'dart',
+    'flutter',
+    'dartium',
+    'drt',
+    'exclude_suite',
+    'failure-summary',
+    'firefox',
+    'local_ip',
+    'progress',
+    'report',
+    'safari',
+    'shard',
+    'shards',
+    'step_name',
+    'tasks',
+    'time',
+    'verbose',
+    'write_debug_log',
+    'write_test_outcome_log',
+  ].toSet();
+
+  List<String> _constructReproducingCommandArguments(Map config) {
+    var arguments = new List<String>();
+    for (var option in _options) {
+      var name = option.name;
+      if (!config.containsKey(name) || _blacklistedOptions.contains(name)) {
+        continue;
+      }
+      var value = config[name];
+      if (config[name] == option.defaultValue ||
+          (name == 'packages' &&
+              value ==
+                  TestUtils.dartDirUri.resolve('.packages').toFilePath())) {
+        continue;
+      }
+      shortest(String a, String b) => a.length <= b.length ? a : b;
+      var key = option.keys.reduce(shortest);
+      if (option.type == 'bool') {
+        arguments.add(key);
+      } else if (key.startsWith('--')) {
+        // long version
+        arguments.add(key);
+        arguments.add("$value");
+      } else {
+        // short version
+        assert(key.startsWith('-'));
+        arguments.add("$key$value");
+      }
+    }
+    return arguments;
+  }
+
+  /**
+   * Determine if a particular configuration has a valid combination of compiler
+   * and runtime elements.
+   */
+  bool _isValidConfig(Map config) {
+    bool isValid = true;
+    List<String> validRuntimes;
+    switch (config['compiler']) {
+      case 'dart2js':
+        // Note: by adding 'none' as a configuration, if the user
+        // runs test.py -c dart2js -r drt,none the dart2js_none and
+        // dart2js_drt will be duplicating work. If later we don't need 'none'
+        // with dart2js, we should remove it from here.
+        validRuntimes = const [
+          'd8',
+          'jsshell',
+          'drt',
+          'none',
+          'dartium',
+          'ff',
+          'chrome',
+          'safari',
+          'ie9',
+          'ie10',
+          'ie11',
+          'opera',
+          'chromeOnAndroid',
+          'safarimobilesim'
+        ];
+        break;
+      case 'dart2analyzer':
+        validRuntimes = const ['none'];
+        break;
+      case 'app_jit':
+      case 'dartk':
+        validRuntimes = const ['vm', 'self_check', 'none'];
+        break;
+      case 'precompiler':
+      case 'dartkp':
+        validRuntimes = const ['dart_precompiled'];
+        break;
+      case 'none':
+        validRuntimes = const [
+          'vm',
+          'flutter',
+          'drt',
+          'dartium',
+          'ContentShellOnAndroid',
+          'DartiumOnAndroid'
+        ];
+        break;
+    }
+    if (!validRuntimes.contains(config['runtime'])) {
+      isValid = false;
+      print("Warning: combination of compiler '${config['compiler']}' and "
+          "runtime '${config['runtime']}' is invalid. "
+          "Skipping this combination.");
+    }
+    if (config['ie'] && Platform.operatingSystem != 'windows') {
+      isValid = false;
+      print("Warning: cannot run Internet Explorer on non-Windows operating"
+          " system.");
+    }
+    if (config['shard'] < 1 || config['shard'] > config['shards']) {
+      isValid = false;
+      print("Error: shard index is ${config['shard']} out of "
+          "${config['shards']} shards");
+    }
+    if ((config['runtime'] == 'flutter') && (config['flutter'] == '')) {
+      isValid = false;
+      print("-rflutter requires the flutter engine executable to "
+          "be specified using --flutter=");
+    }
+    if ((config['runtime'] == 'flutter') && (config['arch'] != 'x64')) {
+      isValid = false;
+      print("-rflutter is applicable only for --arch=x64");
+    }
+
+    return isValid;
+  }
+
+  /**
+   * Recursively expand a configuration with multiple values per key
+   * into a list of configurations with exactly one value per key.
+   */
+  List<Map> _expandConfigurations(Map configuration) {
+    // Expand the pseudo-values such as 'all'.
+    if (configuration['arch'] == 'all') {
+      configuration['arch'] = 'ia32,x64,simarm,simarm64,simmips,simdbc64';
+    }
+    if (configuration['mode'] == 'all') {
+      configuration['mode'] = 'debug,release,product';
+    }
+
+    if (configuration['report_in_json']) {
+      configuration['list'] = true;
+      configuration['report'] = true;
+    }
+
+    // Use verbose progress indication for verbose output unless buildbot
+    // progress indication is requested.
+    if (configuration['verbose'] && configuration['progress'] != 'buildbot') {
+      configuration['progress'] = 'verbose';
+    }
+
+    // Create the artificial negative options that test status files
+    // expect.
+    configuration['unchecked'] = !configuration['checked'];
+    configuration['host_unchecked'] = !configuration['host_checked'];
+    configuration['unminified'] = !configuration['minified'];
+    configuration['nocsp'] = !configuration['csp'];
+
+    String runtime = configuration['runtime'];
+    if (runtime == 'firefox') {
+      configuration['runtime'] == 'ff';
+    }
+
+    String compiler = configuration['compiler'];
+    configuration['browser'] = TestUtils.isBrowserRuntime(runtime);
+    configuration['analyzer'] = TestUtils.isCommandLineAnalyzer(compiler);
+
+    // Set the javascript command line flag for less verbose status files.
+    configuration['jscl'] = TestUtils.isJsCommandLineRuntime(runtime);
+
+    // Allow suppression that is valid for all ie versions
+    configuration['ie'] = runtime.startsWith('ie');
+
+    // Expand the test selectors into a suite name and a simple
+    // regular expressions to be used on the full path of a test file
+    // in that test suite. If no selectors are explicitly given use
+    // the default suite patterns.
+    var selectors = configuration['selectors'];
+    if (selectors is! Map) {
+      if (selectors == null) {
+        if (configuration['suite_dir'] != null) {
+          var suite_path = new Path(configuration['suite_dir']);
+          selectors = [suite_path.filename];
+        } else {
+          selectors = defaultTestSelectors.toList();
+        }
+
+        var excludeSuites = configuration['exclude_suite'] != null
+            ? configuration['exclude_suite'].split(',')
+            : [];
+        for (var exclude in excludeSuites) {
+          if (selectors.contains(exclude)) {
+            selectors.remove(exclude);
+          } else {
+            print("Warning: default selectors does not contain $exclude");
+          }
+        }
+      }
+      var selectorMap = <String, RegExp>{};
+      for (var i = 0; i < selectors.length; i++) {
+        var pattern = selectors[i];
+        var suite = pattern;
+        var slashLocation = pattern.indexOf('/');
+        if (slashLocation != -1) {
+          suite = pattern.substring(0, slashLocation);
+          pattern = pattern.substring(slashLocation + 1);
+          pattern = pattern.replaceAll('*', '.*');
+        } else {
+          pattern = ".?";
+        }
+        if (selectorMap.containsKey(suite)) {
+          print("Error: '$suite/$pattern'.  Only one test selection"
+              " pattern is allowed to start with '$suite/'");
+          exit(1);
+        }
+        selectorMap[suite] = new RegExp(pattern);
+      }
+      configuration['selectors'] = selectorMap;
+    }
+
+    // Put observatory_ui in a configuration with its own packages override.
+    // Only one value in the configuration map is mutable:
+    selectors = configuration['selectors'];
+    if (selectors.containsKey('observatory_ui')) {
+      if (selectors.length == 1) {
+        configuration['packages'] = TestUtils.dartDirUri
+            .resolve('runtime/observatory/.packages')
+            .toFilePath();
+      } else {
+        // Make a new configuration whose selectors map only contains
+        // observatory_ui, and remove the key from the original selectors.
+        // The only mutable value in the map is the selectors, so a
+        // shallow copy is safe.
+        var observatoryConfiguration = new Map.from(configuration);
+        observatoryConfiguration['selectors'] = {
+          'observatory_ui': selectors['observatory_ui']
+        };
+        selectors.remove('observatory_ui');
+
+        // Set the packages flag.
+        observatoryConfiguration['packages'] = TestUtils.dartDirUri
+            .resolve('runtime/observatory/.packages')
+            .toFilePath();
+
+        // Return the expansions of both configurations. Neither will reach
+        // this line in the recursive call to _expandConfigurations.
+        return _expandConfigurations(configuration)
+          ..addAll(_expandConfigurations(observatoryConfiguration));
+      }
+    }
+    // Set the default package spec explicitly.
+    if (configuration['package_root'] == null &&
+        configuration['packages'] == null) {
+      configuration['packages'] =
+          TestUtils.dartDirUri.resolve('.packages').toFilePath();
+    }
+
+    // Expand the architectures.
+    if (configuration['arch'].contains(',')) {
+      return _expandHelper('arch', configuration);
+    }
+
+    // Expand modes.
+    if (configuration['mode'].contains(',')) {
+      return _expandHelper('mode', configuration);
+    }
+
+    // Expand compilers.
+    if (configuration['compiler'].contains(',')) {
+      return _expandHelper('compiler', configuration);
+    }
+
+    // Expand runtimes.
+    var runtimes = configuration['runtime'];
+    if (runtimes.contains(',')) {
+      return _expandHelper('runtime', configuration);
+    } else {
+      // All runtimes eventually go through this path, after expansion.
+      var updater = runtimeUpdater(configuration);
+      if (updater != null) {
+        updater.update();
+      }
+    }
+
+    // Adjust default timeout based on mode, compiler, and sometimes runtime.
+    if (configuration['timeout'] == -1) {
+      var isReload =
+          configuration['hot_reload'] || configuration['hot_reload_rollback'];
+      int compilerMulitiplier =
+          new CompilerConfiguration(configuration).computeTimeoutMultiplier();
+      int runtimeMultiplier = new RuntimeConfiguration(configuration)
+          .computeTimeoutMultiplier(
+              mode: configuration['mode'],
+              isChecked: configuration['checked'],
+              isReload: isReload,
+              arch: configuration['arch']);
+      configuration['timeout'] = 60 * compilerMulitiplier * runtimeMultiplier;
+    }
+
+    return [configuration];
+  }
+
+  /**
+   * Helper for _expandConfigurations. Creates a new configuration and adds it
+   * to a list, for use in a case when a particular configuration has multiple
+   * results (separated by a ',').
+   * Arguments:
+   * option: The particular test option we are expanding.
+   * configuration: The map containing all test configuration information
+   * specified.
+   */
+  List<Map> _expandHelper(String option, Map configuration) {
+    var result = new List<Map>();
+    var configs = configuration[option];
+    for (var config in configs.split(',')) {
+      var newConfiguration = new Map.from(configuration);
+      newConfiguration[option] = config;
+      result.addAll(_expandConfigurations(newConfiguration));
+    }
+    return result;
+  }
+
+  /**
+   * Print out usage information.
+   */
+  void _printHelp() {
+    print('usage: dart test.dart [options] [selector]');
+    print('');
+    print('The optional selector limits the tests that will be run.');
+    print('For example, the selector "language/issue", or equivalently');
+    print('"language/*issue*", limits to test files matching the regexp');
+    print('".*issue.*\\.dart" in the "tests/language" directory.');
+    print('');
+    print('Options:\n');
+    for (var option in _options) {
+      print('${option.name}: ${option.description}.');
+      for (var name in option.keys) {
+        assert(name.startsWith('-'));
+        var buffer = new StringBuffer();
+        ;
+        buffer.write(name);
+        if (option.type == 'bool') {
+          assert(option.values.isEmpty);
+        } else {
+          buffer.write(name.startsWith('--') ? '=' : ' ');
+          if (option.type == 'int') {
+            assert(option.values.isEmpty);
+            buffer.write('n (default: ${option.defaultValue})');
+          } else {
+            buffer.write('[');
+            bool first = true;
+            for (var value in option.values) {
+              if (!first) buffer.write(", ");
+              if (value == option.defaultValue) buffer.write('*');
+              buffer.write(value);
+              first = false;
+            }
+            buffer.write(']');
+          }
+        }
+        print(buffer.toString());
+      }
+      print('');
+    }
+  }
+
+  /**
+   * Find the test option specification for a given option key.
+   */
+  _TestOptionSpecification _getSpecification(String name) {
+    for (var option in _options) {
+      if (option.keys.contains(name)) {
+        return option;
+      }
+    }
+    print('Unknown test option $name');
+    exit(1);
+    return null; // Unreachable.
+  }
+
+  List<_TestOptionSpecification> _options;
+}