Parse command-line options into a list of test configurations.

tools/testing/dart/test_options.dart

 // Copyright (c) 2011, 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");
 
 /**
  * Specification of a single test option.
  *
  * The name of the specification is used as the key for the option in
@@ skipping 27 matching lines @@
         [ new _TestOptionSpecification(
               'mode',
               'Mode in which to run the tests',
               ['-m', '--mode'],
               ['all', 'debug', 'release'],
               'debug'),
           new _TestOptionSpecification(
               'component',
               'The component to test against',
               ['-c', '--component'],
-              ['most', 'vm', 'dartc', 'chromium', 'dartium'],
+              ['most', 'vm', 'dartc', 'frog', 'frogsh', 'leg',
+               'chromium', 'dartium', 'frogium', 'webdriver'],
               'vm'),
           new _TestOptionSpecification(
               'architecture',
               'The architecture to run tests for',
               ['-a', '--arch'],
-              ['all', 'ia32', 'x64', 'simarm', 'arm'],
+              ['all', 'ia32', 'x64', 'simarm'],
               'ia32'),
           new _TestOptionSpecification(
               'os',
               'The operating system to run tests on',
               ['-o', '--os'],
               ['linux', 'macos', 'windows'],
               new Platform().operatingSystem()),
           new _TestOptionSpecification(
               'checked',
               'Run tests in checked mode',
               ['--checked'],
               [],
               false,
               'bool'),
           new _TestOptionSpecification(
+              'timeout',
+              'Timeout in seconds',
+              ['-t', '--timeout'],
+              [],
+              -1,
+              'int'),
+          new _TestOptionSpecification(
               'tasks',
               'The number of parallel tasks to run',
               ['-j', '--tasks'],
               [],
               new Platform().numberOfProcessors(),
               'int'),
           new _TestOptionSpecification(
               'help',
               'Print list of options',
               ['-h', '--help'],
               [],
               false,
               'bool')];
   }
 
 
   /**
    * Parse a list of strings as test options.
    *
-   * Returns a Map 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.
+   * 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.
    */
-  Map parse(List<String> arguments) {
+  List<Map> parse(List<String> arguments) {
     var configuration = new Map();
     // Build configuration of default values.
     for (var option in _options) {
       configuration[option.name] = option.defaultValue;
     }
     // Overwrite with the arguments passed to the test script.
     var numArguments = arguments.length;
     for (var i = 0; i < numArguments; i++) {
       // Extract name and value for options.
       var arg = arguments[i];
@@ skipping 44 matching lines @@
         configuration[spec.name] = true;
       } else if (spec.type == 'int') {
         try {
           configuration[spec.name] = Math.parseInt(value);
         } catch (var e) {
           print('Integer value expected for int option $name');
           return null;
         }
       } else {
         assert(spec.type == 'string');
-        if (spec.values.lastIndexOf(value) == -1) {
-          print('Unknown value ($value) for option $name');
-          return null;
+        for (var v in value.split(',')) {
+          if (spec.values.lastIndexOf(v) == -1) {
+            print('Unknown value ($v) for option $name');
+            return null;
+          }
         }
         configuration[spec.name] = value;
       }
     }
-
-    return configuration;
+    
+    return _expandConfigurations(configuration);
   }
 
 
+  /**
+   * Expand a configuration with multiple values per key into a list
+   * of configurations with exactly one value per key.
+   */

[Bill Hesse, 2011/11/11 10:28:50]

Note that it calls itself recursively to expand multiple keys?

[Mads Ager (google), 2011/11/11 10:57:44]

Done.

+  List<Map> _expandConfigurations(Map configuration) {
+    // Expand the pseudo-values such as 'all'.
+    if (configuration['architecture'] == 'all') {
+      configuration['architecture'] = 'ia32,x64,simarm';
+    }
+    if (configuration['mode'] == 'all') {
+      configuration['mode'] = 'debug,release';
+    }
+    if (configuration['component'] == 'most') {
+      configuration['component'] = 'vm,dartc';
+    }
+
+    // Expand the architectures.
+    var archs = configuration['architecture'];
+    if (archs.contains(',')) {
+      var result = new List<Map>();
+      for (var arch in archs.split(',')) {
+        var newConfiguration = new Map.from(configuration);
+        newConfiguration['architecture'] = arch;
+        result.addAll(_expandConfigurations(newConfiguration));
+      }
+      return result;
+    }
+
+    // Expand modes.
+    var modes = configuration['mode'];
+    if (modes.contains(',')) {
+      var result = new List<Map>();
+      for (var mode in modes.split(',')) {
+        var newConfiguration = new Map.from(configuration);
+        newConfiguration['mode'] = mode;
+        result.addAll(_expandConfigurations(newConfiguration));
+      }
+      return result;
+    }
+
+    // Expand components.
+    var components = configuration['component'];
+    if (components.contains(',')) {
+      var result = new List<Map>();
+      for (var component in components.split(',')) {
+        var newConfiguration = new Map.from(configuration);
+        newConfiguration['component'] = component;
+        result.addAll(_expandConfigurations(newConfiguration));
+      }
+      return result;
+    }
+
+    // Adjust default timeout based on mode and component.
+    if (configuration['timeout'] == -1) {
+      var timeout = 60;
+      switch (configuration['component']) {
+        case 'dartc':
+        case 'chromium':
+        case 'dartium':
+        case 'frogium':
+          timeout *= 4;
+          break;
+        default:
+          if (configuration['mode'] == 'debug') {
+            timeout *= 2;
+          }
+          break;
+      }
+      configuration['timeout'] = timeout;
+    }
+
+    return [configuration];
+  }
+
+
   /**
    * Print out usage information.
    */
   void _printHelp() {
     print('usage: dart_bin test.dart [options]\n');
     print('Options:\n');
     for (var option in _options) {
       print('${option.name}: ${option.description}.');
       for (var name in option.keys) {
         assert(name.startsWith('-'));
@@ skipping 33 matching lines @@
       if (option.keys.some((key) => key == name)) {
         return option;
       }
     }
     return null;
   }
 
 
   List<_TestOptionSpecification> _options;
 }
-