Replace the configuration map with a typed object.

tools/testing/dart/test_progress.dart

 // 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_progress;
+import 'dart:convert' show JSON;
+import 'dart:io';
 
-import "dart:convert" show JSON;
-import "dart:io";
-
-import "expectation.dart";
-import "http_server.dart";
-import "path.dart";
-import "summary_report.dart";
-import "test_runner.dart";
-import "test_suite.dart";
-import "utils.dart";
+import 'configuration.dart';
+import 'expectation.dart';
+import 'path.dart';
+import 'summary_report.dart';
+import 'test_runner.dart';
+import 'test_suite.dart';
+import 'utils.dart';
 
 /// Controls how message strings are processed before being displayed.
 class Formatter {
   /// Messages are left as-is.
   static const normal = const Formatter._();
 
   /// Messages are wrapped in ANSI escape codes to color them for display on a
   /// terminal.
   static const color = const _ColorFormatter();
 
@@ skipping 102 matching lines @@
    *           duration: 2400.44,
    *         },
    *         {
    *           name: 'ff',
    *           duration: 200.2,
    *         },
    *       ],
    *     }
    *  },
    */
-
-  static final INTERESTED_CONFIGURATION_PARAMETERS = [
-    'mode',
-    'arch',
-    'compiler',
-    'runtime',
-    'checked',
-    'strong',
-    'host_checked',
-    'minified',
-    'csp',
-    'system',
-    'vm_options',
-    'use_sdk',
-    'builder_tag'
-  ];
-
   IOSink _sink;
 
   void done(TestCase test) {
     var name = test.displayName;
-    var configuration = {};
-    for (var key in INTERESTED_CONFIGURATION_PARAMETERS) {
-      configuration[key] = test.configuration[key];
-    }
+    var configuration = {
+      'mode': test.configuration.mode.name,
+      'arch': test.configuration.architecture.name,
+      'compiler': test.configuration.compiler.name,
+      'runtime': test.configuration.runtime.name,
+      'checked': test.configuration.isChecked,
+      'strong': test.configuration.isStrong,
+      'host_checked': test.configuration.isHostChecked,
+      'minified': test.configuration.isMinified,
+      'csp': test.configuration.isCsp,
+      'system': test.configuration.system.name,
+      'vm_options': test.configuration.vmOptions,
+      'use_sdk': test.configuration.useSdk,
+      'builder_tag': test.configuration.builderTag
+    };
+
     var outcome = '${test.lastCommandOutput.result(test)}';
     var expectations =
         test.expectedOutcomes.map((expectation) => "$expectation").toList();
 
     var commandResults = [];
     double totalDuration = 0.0;
     for (var command in test.commands) {
       var output = test.commandOutputs[command];
       if (output != null) {
         double duration = output.time.inMicroseconds / 1000.0;
@@ skipping 44 matching lines @@
       //
       // For debugging purposes we need to archive the crashed binary as well.
       //
       // To simplify the archiving code we simply copy binaries into current
       // folder next to core dumps and name them
       // `binary.${mode}_${arch}_${binary_name}`.
       var binName = lastCommand.executable;
       var binFile = new File(binName);
       var binBaseName = new Path(binName).filename;
       if (!archivedBinaries.containsKey(binName) && binFile.existsSync()) {
-        var mode = test.configuration['mode'] as String;
-        var arch = test.configuration['arch'] as String;
+        var mode = test.configuration.mode.name;
+        var arch = test.configuration.architecture.name;
         var archived = "binary.${mode}_${arch}_${binBaseName}";
         TestUtils.copyFile(new Path(binName), new Path(archived));
         archivedBinaries[binName] = archived;
       }
 
       if (archivedBinaries.containsKey(binName)) {
         // We have found and copied the binary.
         RandomAccessFile unexpectedCrashesFile;
         try {
           unexpectedCrashesFile =
@@ skipping 194 matching lines @@
 
         print(_buildSummaryEnd(_failedTests));
       }
     }
   }
 }
 
 class ProgressIndicator extends EventListener {
   ProgressIndicator(this._startTime);
 
-  static EventListener fromName(
-      String name, DateTime startTime, Formatter formatter) {
-    switch (name) {
-      case 'compact':
+  static EventListener fromProgress(
+      Progress progress, DateTime startTime, Formatter formatter) {
+    switch (progress) {
+      case Progress.compact:
         return new CompactProgressIndicator(startTime, formatter);
-      case 'line':
+      case Progress.line:
         return new LineProgressIndicator();
-      case 'verbose':
+      case Progress.verbose:
         return new VerboseProgressIndicator(startTime);
-      case 'status':
+      case Progress.status:
         return new ProgressIndicator(startTime);
-      case 'buildbot':
+      case Progress.buildbot:
         return new BuildbotProgressIndicator(startTime);
-      default:
-        throw new ArgumentError('Unknown progress indicator "$name".');
     }
+
+    throw "unreachable";
   }
 
   void testAdded() {
     _foundTests++;
   }
 
   void done(TestCase test) {
     if (test.unexpectedOutput) {
       _failedTests++;
     } else {
@@ skipping 135 matching lines @@
     if (test.commandOutputs.length != test.commands.length &&
         !test.expectCompileError) {
       output.add('Unexpected compile-time error.');
     } else {
       if (test.expectCompileError) {
         output.add('Compile-time error expected.');
       }
       if (test.hasRuntimeError) {
         output.add('Runtime error expected.');
       }
-      if ((test.configuration['checked'] as bool) && test.isNegativeIfChecked) {
+      if (test.configuration.isChecked && test.isNegativeIfChecked) {
         output.add('Dynamic type error expected.');
       }
     }
   }
 
   for (var i = 0; i < test.commands.length; i++) {
     var command = test.commands[i];
     var commandOutput = test.commandOutputs[command];
     if (commandOutput != null) {
       output.add("CommandOutput[${command.displayName}]:");
@@ skipping 12 matching lines @@
       if (!commandOutput.stderr.isEmpty) {
         output.add('');
         output.add('stderr:');
         output.addAll(_linesWithoutCarriageReturn(commandOutput.stderr));
       }
     }
   }
 
   if (test is BrowserTestCase) {
     // Additional command for rerunning the steps locally after the fact.
-    var command = (test.configuration["_servers_"] as TestingServers)
-        .httpServerCommandLine();
+    var command = test.configuration.servers.httpServerCommandLine();
     output.add('');
     output.add('To retest, run:  $command');
   }
 
   for (var i = 0; i < test.commands.length; i++) {
     var command = test.commands[i];
     var commandOutput = test.commandOutputs[command];
     output.add('');
     output.add('Command[${command.displayName}]: $command');
     if (commandOutput != null) {
       output.add('Took ${commandOutput.time}');
     } else {
       output.add('Did not run');
     }
   }
 
   var arguments = ['python', 'tools/test.py'];
-  arguments
-      .addAll(test.configuration['_reproducing_arguments_'] as List<String>);
+  arguments.addAll(test.configuration.reproducingArguments);
   arguments.add(test.displayName);
   var testPyCommandline = arguments.map(escapeCommandLineArgument).join(' ');
 
   output.add('');
   output.add('Short reproduction command (experimental):');
   output.add("    $testPyCommandline");
   return output;
 }
 
 String _buildSummaryEnd(int failedTests) {
   if (failedTests == 0) {
     return '\n===\n=== All tests succeeded\n===\n';
   } else {
     var pluralSuffix = failedTests != 1 ? 's' : '';
     return '\n===\n=== ${failedTests} test$pluralSuffix failed\n===\n';
   }
 }