Add a new variable environment for testing, to replace the misusage of 'arch'.

dart/tools/test.py

 #!/usr/bin/env python
 #
 # 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.
 #
 
 """Test driver for the Dart project used by continuous build and developers."""
 
 
@@ skipping 399 matching lines @@
 
 
 class TestCase(object):
   """A single test case, like running 'dart' on a single .dart file."""
 
   def __init__(self, context, path):
     self.path = path
     self.context = context
     self.duration = None
     self.arch = []
+    self.component = []
 
   def IsBatchable(self):
     if self.context.use_batch:
-      if self.arch and 'dartc' in self.arch:
+      if self.component and 'dartc' in self.component:
         return True
     return False
 
   def IsNegative(self):
     return False
 
   def CompareTime(self, other):
     return cmp(other.duration, self.duration)
 
   def DidFail(self, output):
@@ skipping 89 matching lines @@
     try:
       (filename, pathname, description) = imp.find_module(
           'testcfg', [self.path])
       module = imp.load_module('testcfg', filename, pathname, description)
       self.config = module.GetConfiguration(context, self.path)
     finally:
       if filename:
         filename.close()
     return self.config
 
-  def ListTests(self, current_path, path, context, mode, arch):
+  def ListTests(self, current_path, path, context, mode, arch, component):
     return self.GetConfiguration(context).ListTests(current_path,
                                                     path,
                                                     mode,
-                                                    arch)
+                                                    arch,
+                                                    component)
 
   def GetTestStatus(self, context, sections, defs):
     self.GetConfiguration(context).GetTestStatus(sections, defs)
 
 
 class LiteralTestSuite(TestSuite):
   """Represents one set of tests."""
 
   def __init__(self, tests):
     super(LiteralTestSuite, self).__init__('root')
     self.tests = tests
 
-  def ListTests(self, current_path, path, context, mode, arch):
+  def ListTests(self, current_path, path, context, mode, arch, component):
     name = path[0]
     result = []
     for test in self.tests:
       test_name = test.GetName()
       if name.match(test_name):
         full_path = current_path + [test_name]
-        result += test.ListTests(full_path, path, context, mode, arch)
+        result += test.ListTests(full_path, path, context, mode, arch, component)
     return result
 
   def GetTestStatus(self, context, sections, defs):
     for test in self.tests:
       test.GetTestStatus(context, sections, defs)
 
 
 class Context(object):
   """A way to send global context for the test run to each test case."""
 
@@ skipping 23 matching lines @@
   def GetExecutable(self, mode, arch, name):
     """Returns the name of the executable used to run the test."""
     if self.executable is not None:
       return self.executable
     path = os.path.abspath(os.path.join(self.GetBuildRoot(mode, arch), name))
     if utils.IsWindows() and not path.endswith('.exe'):
       return path + '.exe'
     else:
       return path
 
-  def GetDart(self, mode, arch):
+  def GetDart(self, mode, arch, component):
     """Returns the path to the Dart test runner (executes the .dart file)."""
-    if arch == 'dartc':
+    if component == 'dartc':
       command = [os.path.abspath(
           os.path.join(self.GetBuildRoot(mode, arch),
                        'compiler', 'bin', 'dartc_test'))]
     else:
       command = [self.GetExecutable(mode, arch, 'dart_bin')]
 
     return command
 
   def GetDartC(self, mode, arch):
     """Returns the path to the Dart --> JS compiler."""
@@ skipping 122 matching lines @@
   """A conditional expression. e.g. ($arch == ia32)."""
 
   def __init__(self, left, op, right):
     super(Operation, self).__init__()
     self.left = left
     self.op = op
     self.right = right
 
   def Evaluate(self, env, defs):
     """Evaluates expression in the .status file. e.g. ($arch == ia32)."""
-
     if self.op == '||' or self.op == ',':
       return self.left.Evaluate(env, defs) or self.right.Evaluate(env, defs)
     elif self.op == 'if':
       return False
     elif self.op == '==':
       outcomes = self.left.GetOutcomes(env, defs)
       inter = outcomes.Intersect(self.right.GetOutcomes(env, defs))
       return not inter.IsEmpty()
     else:
       assert self.op == '&&'
@@ skipping 44 matching lines @@
     self.tokens.append(token)
 
   def SkipSpaces(self):
     while self.HasMore() and self.Current().isspace():
       self.Advance()
 
   def Tokenize(self):
     """Lexical analysis of an expression in a .status file.
 
     Example:
-      [ $mode == debug && ($arch == chromium || $arch == dartc) ]
+      [ $mode == debug && ($component == chromium || $component == dartc) ]
 
     Args:
       None.
 
     Returns:
       A list of tokens on success, None on failure.
     """
 
     self.tokens = []
     while self.HasMore():
@@ skipping 154 matching lines @@
 
   def ClassifyTests(self, cases, env):
     """Matches a test case with the test prefixes requested on the cmdline.
 
     This 'wraps' each TestCase object with some meta information
     about the test.
 
     Args:
       cases: list of TestCase objects to classify.
       env:   dictionary containing values for 'mode',
-             'system', 'arch' and 'checked'.
+             'system', 'component', 'arch' and 'checked'.
 
     Returns:
       A triplet of (result, rules, expected_outcomes).
     """
     sections = [s for s in self.sections
                 if s.condition.Evaluate(env, self.defs)]
     all_rules = reduce(list.__add__, [s.rules for s in sections], [])
     unused_rules = set(all_rules)
     result = []
     all_outcomes = set([])
@@ skipping 149 matching lines @@
       default=False,
       action='store_true')
   result.add_option(
       '--flag',
       help='Pass this additional flag to the VM',
       default=[],
       action='append')
   result.add_option(
       '--arch',
       help='The architecture to run tests for',
-      metavar='[all,ia32,x64,simarm,arm,dartc]',
+      metavar='[all,ia32,x64,simarm,arm]',
       default=ARCH_GUESS)
   result.add_option(
       '--os',
       help='The OS to run tests on',
       default=OS_GUESS)
   result.add_option(
       '--valgrind',
       help='Run tests through valgrind',
       default=False,
       action='store_true')
@@ skipping 12 matching lines @@
       '--executable',
       help='The executable with which to run the tests',
       default=None)
   result.add_option(
       '--keep_temporary_files',
       help='Do not delete temporary files after running the tests',
       default=False,
       action='store_true')
   result.add_option(
       '--batch',
-      help='Run multiple tests for dartc architecture in a single vm',
+      help='Run multiple tests for dartc component in a single vm',
       choices=['true', 'false'],
       default='true',
       type='choice')
   result.add_option(
       '--optimize',
       help='Invoke dart compiler with --optimize flag',
       default=False,
       action='store_true')
+  result.add_option(
+      '-c', '--component',
+      help='The component to test against '
+           '(most, vm, dartc, chromium, dartium)',
+      metavar='[most,vm,dartc,chromium,dartium]',
+      default='vm')
   return result
 
 
 def ProcessOptions(options):
   """Process command line options."""
   if options.arch == 'all':
     options.arch = 'ia32,x64,simarm'
   if options.mode == 'all':
     options.mode = 'debug,release'
+  if options.component == 'most':
+    options.component = 'vm,dartc'
+
+  if 'dartc' in options.arch:
+    options.component = 'dartc'
+  if 'dartium' in options.arch:
+    options.component = 'dartium'
+  if 'chromium' in options.arch:
+    options.component = 'chromium'
+
   # By default we run with a higher timeout setting in when running on
   # a simulated architecture and in debug mode.
   if not options.timeout:
     options.timeout = TIMEOUT_SECS
-    if 'dartc' in options.arch:
+    if 'dartc' in options.component:
       options.timeout *= 4
-    elif 'chromium' in options.arch:
+    elif 'chromium' in options.component:
       options.timeout *= 4
-    elif 'dartium' in options.arch:
+    elif 'dartium' in options.component:
       options.timeout *= 4
     elif 'debug' in options.mode:
       options.timeout *= 2
   options.mode = options.mode.split(',')
   options.arch = options.arch.split(',')
+  options.component = options.component.split(',')
   for mode in options.mode:
     if not mode in ['debug', 'release']:
       print 'Unknown mode %s' % mode
       return False
   for arch in options.arch:
-    if not arch in ['ia32', 'x64', 'simarm', 'arm', 'dartc', 'dartium',
-                    'chromium']:
+    if not arch in ['ia32', 'x64', 'simarm', 'arm']:
       print 'Unknown arch %s' % arch
       return False
+  for component in options.component:
+    if not component in ['vm', 'dartc', 'chromium', 'dartium']:
+      print 'Unknown component %s' % component
+      return False
   options.flags = []
   options.flags.append('--ignore-unrecognized-flags')
   if options.checked:
     options.flags.append('--enable_asserts')
     options.flags.append('--enable_type_checks')
   if options.optimize:
     options.flags.append('--optimize')
   for flag in options.flag:
     options.flags.append(flag)
   if options.verbose:
@@ skipping 176 matching lines @@
   root.GetTestStatus(context, sections, defs)
   config = Configuration(sections, defs)
 
   # List the tests
   all_cases = []
   all_unused = []
   globally_unused_rules = None
   for path in paths:
     for mode in options.mode:
       for arch in options.arch:
-        env = {
-            'mode': mode,
-            'system': utils.GuessOS(),
-            'arch': arch,
-            'checked': options.checked
-        }
-        test_list = root.ListTests([], path, context, mode, arch)
-        (cases, unused_rules, unused_outcomes) = config.ClassifyTests(
-            test_list, env)
-        if globally_unused_rules is None:
-          globally_unused_rules = set(unused_rules)
-        else:
-          globally_unused_rules = (
-              globally_unused_rules.intersection(unused_rules))
-        all_cases += cases
-        all_unused.append(unused_rules)
+        for component in options.component:
+          env = {
+              'mode': mode,
+              'system': utils.GuessOS(),
+              'arch': arch,
+              'component': component,
+              'checked': options.checked
+          }
+          test_list = root.ListTests([], path, context, mode, arch, component)
+          (cases, unused_rules, unused_outcomes) = config.ClassifyTests(
+              test_list, env)
+          if globally_unused_rules is None:
+            globally_unused_rules = set(unused_rules)
+          else:
+            globally_unused_rules = (
+                globally_unused_rules.intersection(unused_rules))
+          all_cases += cases
+          all_unused.append(unused_rules)
 
   if options.report:
     PrintReport(all_cases)
 
   if options.list:
     PrintTests(all_cases)
     return 0
 
   result = None
 
@@ skipping 31 matching lines @@
     for entry in timed_tests[:20]:
       t = FormatTime(entry.duration)
       print '%4i (%s) %s' % (index, t, entry.GetLabel())
       index += 1
 
   return result
 
 
 if __name__ == '__main__':
   sys.exit(Main())