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

tools/testing/dart/test_runner.dart

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 /**
  * Classes and methods for executing tests.
  *
  * This module includes:
  * - Managing parallel execution of tests, including timeout checks.
  * - Evaluating the output of each test as pass/fail/crash/timeout.
  */
-import 'dart:async';
-import 'dart:collection';
-import 'dart:convert';
+library test_runner;
+
+import "dart:async";
+import "dart:collection" show Queue;
+import "dart:convert" show LineSplitter, UTF8, JSON;
 // We need to use the 'io' prefix here, otherwise io.exitCode will shadow
 // CommandOutput.exitCode in subclasses of CommandOutput.
-import 'dart:io' as io;
-import 'dart:math' as math;
+import "dart:io" as io;
+import "dart:math" as math;
 
 import 'android.dart';
-import 'browser_controller.dart';
-import 'configuration.dart';
+import "browser_controller.dart";
 import 'dependency_graph.dart' as dgraph;
-import 'expectation.dart';
-import 'path.dart';
+import "expectation.dart";
+import "path.dart";
 import 'record_and_replay.dart';
-import 'runtime_configuration.dart';
-import 'test_progress.dart';
-import 'test_suite.dart';
-import 'utils.dart';
+import "runtime_configuration.dart";
+import "test_progress.dart";
+import "test_suite.dart";
+import "utils.dart";
 
 const int CRASHING_BROWSER_EXITCODE = -10;
 const int SLOW_TIMEOUT_MULTIPLIER = 4;
 const int NON_UTF_FAKE_EXITCODE = 0xFFFD;
 
 const MESSAGE_CANNOT_OPEN_DISPLAY = 'Gtk-WARNING **: cannot open display';
 const MESSAGE_FAILED_TO_RUN_COMMAND = 'Failed to run command. return code=1';
 
 typedef void TestCaseEvent(TestCase testCase);
 typedef void ExitCodeEvent(int exitCode);
@@ skipping 246 matching lines @@
   static List<String> _getArguments(List<String> options, String htmlFile) {
     var arguments = options.toList();
     arguments.add(htmlFile);
     return arguments;
   }
 
   int get maxNumRetries => 3;
 }
 
 class BrowserTestCommand extends Command {
-  Runtime get browser => configuration.runtime;
+  final String browser;
   final String url;
-  final Configuration configuration;
+  final Map<String, dynamic> configuration;
   final bool retry;
 
-  BrowserTestCommand._(this.url, this.configuration, this.retry)
-      : super._(configuration.runtime.name);
+  BrowserTestCommand._(
+      String _browser, this.url, this.configuration, this.retry)
+      : browser = _browser,
+        super._(_browser);
 
   void _buildHashCode(HashCodeBuilder builder) {
     super._buildHashCode(builder);
-    builder.addJson(browser.name);
+    builder.addJson(browser);
     builder.addJson(url);
     builder.add(configuration);
     builder.add(retry);
   }
 
   bool _equal(BrowserTestCommand other) =>
       super._equal(other) &&
       browser == other.browser &&
       url == other.url &&
       identical(configuration, other.configuration) &&
       retry == other.retry;
 
   String get reproductionCommand {
     var parts = [
       io.Platform.resolvedExecutable,
       'tools/testing/dart/launch_browser.dart',
-      browser.name,
+      browser,
       url
     ];
     return parts.map(escapeCommandLineArgument).join(' ');
   }
 
   int get maxNumRetries => 4;
 }
 
 class BrowserHtmlTestCommand extends BrowserTestCommand {
   List<String> expectedMessages;
-  BrowserHtmlTestCommand._(String url, Configuration configuration,
-      this.expectedMessages, bool retry)
-      : super._(url, configuration, retry);
+  BrowserHtmlTestCommand._(String browser, String url,
+      Map<String, dynamic> configuration, this.expectedMessages, bool retry)
+      : super._(browser, url, configuration, retry);
 
   void _buildHashCode(HashCodeBuilder builder) {
     super._buildHashCode(builder);
     builder.addJson(expectedMessages);
   }
 
   bool _equal(BrowserHtmlTestCommand other) =>
       super._equal(other) &&
       identical(expectedMessages, other.expectedMessages);
 }
@@ skipping 225 matching lines @@
       String executable,
       String htmlFile,
       List<String> options,
       List<String> dartFlags,
       Map<String, String> environment) {
     ContentShellCommand command = new ContentShellCommand._(
         executable, htmlFile, options, dartFlags, environment);
     return _getUniqueCommand(command);
   }
 
-  BrowserTestCommand getBrowserTestCommand(
-      String url, Configuration configuration, bool retry) {
-    var command = new BrowserTestCommand._(url, configuration, retry);
+  BrowserTestCommand getBrowserTestCommand(String browser, String url,
+      Map<String, dynamic> configuration, bool retry) {
+    var command = new BrowserTestCommand._(browser, url, configuration, retry);
     return _getUniqueCommand(command);
   }
 
-  BrowserHtmlTestCommand getBrowserHtmlTestCommand(String url,
-      Configuration configuration, List<String> expectedMessages, bool retry) {
+  BrowserHtmlTestCommand getBrowserHtmlTestCommand(
+      String browser,
+      String url,
+      Map<String, dynamic> configuration,
+      List<String> expectedMessages,
+      bool retry) {
     var command = new BrowserHtmlTestCommand._(
-        url, configuration, expectedMessages, retry);
+        browser, url, configuration, expectedMessages, retry);
     return _getUniqueCommand(command);
   }
 
   CompilationCommand getCompilationCommand(
       String displayName,
       String outputFile,
       bool neverSkipCompilation,
       List<Uri> bootstrapDependencies,
       String executable,
       List<String> arguments,
@@ skipping 143 matching lines @@
   /**
    * A list of commands to execute. Most test cases have a single command.
    * Dart2js tests have two commands, one to compile the source and another
    * to execute it. Some isolate tests might even have three, if they require
    * compiling multiple sources that are run in isolation.
    */
   List<Command> commands;
   Map<Command, CommandOutput> commandOutputs =
       new Map<Command, CommandOutput>();
 
-  Configuration configuration;
+  Map configuration;
   String displayName;
   int _expectations = 0;
   int hash = 0;
   Set<Expectation> expectedOutcomes;
 
   TestCase(this.displayName, this.commands, this.configuration,
       this.expectedOutcomes,
       {bool isNegative: false, TestInformation info}) {
     if (isNegative || displayName.contains("negative_test")) {
       _expectations |= IS_NEGATIVE;
     }
     if (info != null) {
       _setExpectations(info);
       hash =
           info.originTestPath.relativeTo(TestUtils.dartDir).toString().hashCode;
     }
   }
 
   void _setExpectations(TestInformation info) {
     // We don't want to keep the entire (large) TestInformation structure,
     // so we copy the needed bools into flags set in a single integer.
     if (info.hasRuntimeError) _expectations |= HAS_RUNTIME_ERROR;
     if (info.hasStaticWarning) _expectations |= HAS_STATIC_WARNING;
     if (info.isNegativeIfChecked) _expectations |= IS_NEGATIVE_IF_CHECKED;
     if (info.hasCompileError) _expectations |= HAS_COMPILE_ERROR;
     if (info.hasCompileErrorIfChecked) {
       _expectations |= HAS_COMPILE_ERROR_IF_CHECKED;
     }
     if (info.hasCompileError ||
-        (configuration.isChecked && info.hasCompileErrorIfChecked)) {
+        ((configuration['checked'] as bool) && info.hasCompileErrorIfChecked)) {
       _expectations |= EXPECT_COMPILE_ERROR;
     }
   }
 
   bool get isNegative => _expectations & IS_NEGATIVE != 0;
   bool get hasRuntimeError => _expectations & HAS_RUNTIME_ERROR != 0;
   bool get hasStaticWarning => _expectations & HAS_STATIC_WARNING != 0;
   bool get isNegativeIfChecked => _expectations & IS_NEGATIVE_IF_CHECKED != 0;
   bool get hasCompileError => _expectations & HAS_COMPILE_ERROR != 0;
   bool get hasCompileErrorIfChecked =>
@@ skipping 21 matching lines @@
   Command get lastCommandExecuted {
     if (commandOutputs.length == 0) {
       throw new Exception("CommandOutputs is empty, maybe no command was run? ("
           "displayName: '$displayName', "
           "configurationString: '$configurationString')");
     }
     return commands[commandOutputs.length - 1];
   }
 
   int get timeout {
-    var result = configuration.timeout;
     if (expectedOutcomes.contains(Expectation.slow)) {
-      result *= SLOW_TIMEOUT_MULTIPLIER;
+      return (configuration['timeout'] as int) * SLOW_TIMEOUT_MULTIPLIER;
+    } else {
+      return configuration['timeout'] as int;
     }
-    return result;
   }
 
   String get configurationString {
-    var compiler = configuration.compiler.name;
-    var runtime = configuration.runtime.name;
-    var mode = configuration.mode.name;
-    var arch = configuration.architecture.name;
-    var checked = configuration.isChecked ? '-checked' : '';
+    var compiler = configuration['compiler'] as String;
+    var runtime = configuration['runtime'] as String;
+    var mode = configuration['mode'] as String;
+    var arch = configuration['arch'] as String;
+    var checked = configuration['checked'] as bool ? '-checked' : '';
     return "$compiler-$runtime$checked ${mode}_$arch";
   }
 
   List<String> get batchTestArguments {
     assert(commands.last is ProcessCommand);
     return (commands.last as ProcessCommand).arguments;
   }
 
   bool get isFlaky {
     if (expectedOutcomes.contains(Expectation.skip) ||
@@ skipping 16 matching lines @@
 
 /**
  * BrowserTestCase has an extra compilation command that is run in a separate
  * process, before the regular test is run as in the base class [TestCase].
  * If the compilation command fails, then the rest of the test is not run.
  */
 class BrowserTestCase extends TestCase {
   BrowserTestCase(
       String displayName,
       List<Command> commands,
-      Configuration configuration,
+      Map<String, dynamic> configuration,
       Set<Expectation> expectedOutcomes,
       TestInformation info,
       bool isNegative,
       this._testingUrl)
       : super(displayName, commands, configuration, expectedOutcomes,
             isNegative: isNegative, info: info);
 
   String _testingUrl;
 
   String get testingUrl => _testingUrl;
@@ skipping 183 matching lines @@
     }
     // TODO(26739): See http://dartbug.com/26739
     if (zygoteCrash.hasMatch(stderr)) {
       DebugLogger.warning("Warning: Failure because of content_shell "
           "zygote crash. Test ignored");
       return true;
     }
     // TODO(28955): See http://dartbug.com/28955
     if (timedOut &&
         command is BrowserTestCommand &&
-        command.browser == Runtime.ie11) {
+        command.browser == "ie11") {
       DebugLogger.warning("Timeout of ie11 on test page ${command.url}");
       return true;
     }
     return false;
   }
 
   bool _infraFailure;
 
   BrowserCommandOutputImpl(
       Command command,
@@ skipping 834 matching lines @@
   int timeout;
   bool timedOut = false;
   DateTime startTime;
   Timer timeoutTimer;
   int pid;
   OutputLog stdout = new OutputLog();
   OutputLog stderr = new OutputLog();
   List<String> diagnostics = <String>[];
   bool compilationSkipped = false;
   Completer<CommandOutput> completer;
-  Configuration configuration;
+  Map configuration;
 
   RunningProcess(this.command, this.timeout, {this.configuration});
 
   Future<CommandOutput> run() {
     completer = new Completer<CommandOutput>();
     startTime = new DateTime.now();
     _runCommand();
     return completer.future;
   }
 
@@ skipping 57 matching lines @@
                 executable = 'eu-stack';
               } else if (io.Platform.isMacOS) {
                 // Try to print stack traces of the timed out process.
                 // `sample` is a sampling profiler but we ask it sample for 1
                 // second with a 4 second delay between samples so that we only
                 // sample the threads once.
                 executable = '/usr/bin/sample';
               } else if (io.Platform.isWindows) {
                 var isX64 = command.executable.contains("X64") ||
                     command.executable.contains("SIMARM64");
-                if (configuration.windowsSdkPath != null) {
-                  executable = configuration.windowsSdkPath +
-                      "\\Debuggers\\${isX64 ? 'x64' : 'x86'}\\cdb.exe";
+                var winSdkPath = configuration['win_sdk_path'] as String;
+                if (winSdkPath != null) {
+                  executable = winSdkPath +
+                      "\\Debuggers\\" +
+                      (isX64 ? "x64" : "x86") +
+                      "\\cdb.exe";
                   diagnostics.add("Using $executable to print stack traces");
                 } else {
-                  diagnostics.add("win_sdk_path not found");
+                  diagnostics.add("win_sdk path not found");
                 }
               } else {
                 diagnostics.add("Capturing stack traces on"
                     "${io.Platform.operatingSystem} not supported");
               }
               if (executable != null) {
                 var pids = await _getPidList(process.pid, diagnostics);
                 diagnostics.add("Process list including children: $pids");
                 for (pid in pids) {
                   List<String> arguments;
@@ skipping 627 matching lines @@
  * It provides a [cleanup] method to free all the allocated resources.
  */
 abstract class CommandExecutor {
   Future cleanup();
   // TODO(kustermann): The [timeout] parameter should be a property of Command
   Future<CommandOutput> runCommand(
       dgraph.Node node, covariant Command command, int timeout);
 }
 
 class CommandExecutorImpl implements CommandExecutor {
-  final Configuration globalConfiguration;
+  final Map globalConfiguration;
   final int maxProcesses;
   final int maxBrowserProcesses;
   AdbDevicePool adbDevicePool;
 
   // For dart2js and analyzer batch processing,
   // we keep a list of batch processes.
   final _batchProcesses = new Map<String, List<BatchRunnerProcess>>();
   // We keep a BrowserTestRunner for every configuration.
-  final _browserTestRunners = new Map<Configuration, BrowserTestRunner>();
+  final _browserTestRunners = new Map<Map, BrowserTestRunner>();
 
   bool _finishing = false;
 
   CommandExecutorImpl(
       this.globalConfiguration, this.maxProcesses, this.maxBrowserProcesses,
       {this.adbDevicePool});
 
   Future cleanup() {
     assert(!_finishing);
     _finishing = true;
@@ skipping 30 matching lines @@
         } else {
           return new Future.value(output);
         }
       });
     }
 
     return runCommand(command.maxNumRetries);
   }
 
   Future<CommandOutput> _runCommand(Command command, int timeout) {
+    var batchMode = !(globalConfiguration['noBatch'] as bool);
+    var dart2jsBatchMode = globalConfiguration['dart2js_batch'] as bool;
+
     if (command is BrowserTestCommand) {
       return _startBrowserControllerTest(command, timeout);
     } else if (command is KernelCompilationCommand) {
       // For now, we always run dartk in batch mode.
       var name = command.displayName;
       assert(name == 'dartk');
       return _getBatchRunner(name)
           .runCommand(name, command, timeout, command.arguments);
-    } else if (command is CompilationCommand &&
-        globalConfiguration.batchDart2JS) {
+    } else if (command is CompilationCommand && dart2jsBatchMode) {
       return _getBatchRunner("dart2js")
           .runCommand("dart2js", command, timeout, command.arguments);
-    } else if (command is AnalysisCommand && globalConfiguration.batch) {
+    } else if (command is AnalysisCommand && batchMode) {
       return _getBatchRunner(command.flavor)
           .runCommand(command.flavor, command, timeout, command.arguments);
     } else if (command is ScriptCommand) {
       return command.run();
     } else if (command is AdbPrecompilationCommand) {
       assert(adbDevicePool != null);
       return adbDevicePool.acquireDevice().then((AdbDevice device) {
         return _runAdbPrecompilationCommand(device, command, timeout)
             .whenComplete(() {
           adbDevicePool.releaseDevice(device);
@@ skipping 113 matching lines @@
           .complete(new BrowserControllerTestOutcome(browserCommand, output));
     };
 
     BrowserTest browserTest;
     if (browserCommand is BrowserHtmlTestCommand) {
       browserTest = new HtmlTest(browserCommand.url, callback, timeout,
           browserCommand.expectedMessages);
     } else {
       browserTest = new BrowserTest(browserCommand.url, callback, timeout);
     }
-    _getBrowserTestRunner(browserCommand.configuration).then((testRunner) {
+    _getBrowserTestRunner(browserCommand.browser, browserCommand.configuration)
+        .then((testRunner) {
       testRunner.enqueueTest(browserTest);
     });
 
     return completer.future;
   }
 
   Future<BrowserTestRunner> _getBrowserTestRunner(
-      Configuration configuration) async {
+      String browser, Map<String, dynamic> configuration) async {
+    var localIp = globalConfiguration['local_ip'] as String;
     if (_browserTestRunners[configuration] == null) {
       var testRunner = new BrowserTestRunner(
-          configuration, globalConfiguration.localIP, maxBrowserProcesses);
-      if (globalConfiguration.isVerbose) {
+          configuration, localIp, browser, maxBrowserProcesses);
+      if (globalConfiguration['verbose'] as bool) {
         testRunner.logger = DebugLogger.info;
       }
       _browserTestRunners[configuration] = testRunner;
       await testRunner.start();
     }
     return _browserTestRunners[configuration];
   }
 }
 
 class RecordingCommandExecutor implements CommandExecutor {
@@ skipping 65 matching lines @@
         if (stdout.any(containsOutOfMemoryMessage) ||
             stderr.any(containsOutOfMemoryMessage)) {
           return true;
         }
       }
     }
 
     // We currently rerun dartium tests, see issue 14074.
     if (command is BrowserTestCommand &&
         command.retry &&
-        command.browser == Runtime.dartium) {
+        command.browser == 'dartium') {
       return true;
     }
 
     // As long as we use a legacy version of our custom content_shell (which
     // became quite flaky after chrome-50 roll) we'll re-run tests on it.
     // The plan is to use chrome's content_shell instead of our own.
     // See http://dartbug.com/29655 .
     if (command is ContentShellCommand) {
       return true;
     }
@@ skipping 112 matching lines @@
       // [TestCase.isFinished] will return true if all commands were executed
       // or if a previous one failed.
       if (testCase.isFinished) {
         completeTestCase(testCase);
       }
     }
   }
 }
 
 class ProcessQueue {
-  Configuration _globalConfiguration;
+  Map _globalConfiguration;
 
   Function _allDone;
   final dgraph.Graph _graph = new dgraph.Graph();
   List<EventListener> _eventListener;
 
   ProcessQueue(
       this._globalConfiguration,
       int maxProcesses,
       int maxBrowserProcesses,
       DateTime startTime,
@@ skipping 134 matching lines @@
 
       resetDebugTimer();
     }
 
     // Build up the dependency graph
     testCaseEnqueuer = new TestCaseEnqueuer(_graph, (TestCase newTestCase) {
       eventTestAdded(newTestCase);
     });
 
     // Either list or run the tests
-    if (_globalConfiguration.listTests) {
+    if (_globalConfiguration['list'] as bool) {
       setupForListing(testCaseEnqueuer);
     } else {
       setupForRunning(testCaseEnqueuer);
     }
 
     // Start enqueing all TestCases
     testCaseEnqueuer.enqueueTestSuites(testSuites);
   }
 
   void freeEnqueueingStructures() {
@@ skipping 19 matching lines @@
     }
   }
 
   void eventAllTestsDone() {
     for (var listener in _eventListener) {
       listener.allDone();
     }
     _allDone();
   }
 }