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

dart/tools/testing/test_configuration.py

 # 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.
 
 """Common Testconfiguration subclasses used to define a class of tests."""
 
 import atexit
 import fileinput
 import os
 import re
@@ skipping 36 matching lines @@
       if t.run_arch:
         temp_dir = t.run_arch.temp_dir
         if temp_dir:
           dirs.append(temp_dir)
     if not dirs:
       return
     if not utils.Daemonize():
       return
     os.execlp('rm', *(['rm', '-rf'] + dirs))
 
-  def CreateTestCases(self, test_path, path, filename, mode, arch):
+  def CreateTestCases(self, test_path, path, filename, mode, arch, FOOBAR):
     """Given a .dart filename, create a StandardTestCase from it."""
     # Look for VM specified as comments in the source file. If
     # several sets of VM options are specified create a separate
     # test for each set.
     source = file(filename).read()
     vm_options_list = utils.ParseTestOptionsMultiple(VM_OPTIONS_PATTERN,
                                                      source,
                                                      test_path)
     tags = {}
     if filename.endswith('.dart'):
       tags = self.SplitMultiTest(test_path, filename)
-    if arch in ['dartium', 'chromium']:
+    if FOOBAR in ['dartium', 'chromium']:
       if tags:
         return []
       else:
         if vm_options_list:
           tests = []
           for options in vm_options_list:
             tests.append(test_case.BrowserTestCase(
-                self.context, test_path, filename, False, mode, arch, options))
+                self.context, test_path, filename, False, mode, arch, FOOBAR, options))
           return tests
         else:
           return [test_case.BrowserTestCase(
-              self.context, test_path, filename, False, mode, arch)]
+              self.context, test_path, filename, False, mode, arch, FOOBAR)]
     else:
       tests = []
       if tags:
         for tag in sorted(tags):
           kind, test_source = tags[tag]
           if not self.Contains(path, test_path + [tag]):
             continue
           tests.append(test_case.MultiTestCase(self.context,
                                                test_path + [tag],
                                                test_source,
                                                kind,
-                                               mode, arch))
+                                               mode, arch, FOOBAR))
       else:
         if vm_options_list:
           for options in vm_options_list:
             tests.append(test_case.StandardTestCase(self.context,
-                test_path, filename, mode, arch, options))
+                test_path, filename, mode, arch, FOOBAR, options))
         else:
           tests.append(test_case.StandardTestCase(self.context,
-              test_path, filename, mode, arch))
+              test_path, filename, mode, arch, FOOBAR))
       return tests
 
-  def ListTests(self, current_path, path, mode, arch):
+  def ListTests(self, current_path, path, mode, arch, FOOBAR):
     """Searches for *Test.dart files and returns list of TestCases."""
     tests = []
     for root, unused_dirs, files in os.walk(os.path.join(self.root, 'src')):
       for f in [x for x in files if self.IsTest(x)]:
         if f.endswith('.dart'):
           test_path = current_path + [f[:-5]]  # Remove .dart suffix.
         elif f.endswith('.app'):
           # TODO(zundel): .app files are used only the dromaeo test
           # and should be removed.
           test_path = current_path + [f[:-4]]  # Remove .app suffix.
         if not self.Contains(path, test_path):
           continue
         tests.extend(self.CreateTestCases(test_path, path,
                                           os.path.join(root, f),
-                                          mode, arch))
+                                          mode, arch, FOOBAR))
     atexit.register(lambda: self._Cleanup(tests))
     return tests
 
   def IsTest(self, name):
     """Returns True if the file name is a test file."""
     return name.endswith('Test.dart') or name.endswith('Test.app')
 
   def GetTestStatus(self, sections, defs):
     """Reads the .status file of the TestSuite."""
     status = os.path.join(self.root, os.path.basename(self.root) + '.status')
@@ skipping 83 matching lines @@
     return tests
 
 
 class BrowserTestConfiguration(StandardTestConfiguration):
   """A configuration used to run tests inside a browser."""
 
   def __init__(self, context, root, fatal_static_type_errors=False):
     super(BrowserTestConfiguration, self).__init__(context, root)
     self.fatal_static_type_errors = fatal_static_type_errors
 
-  def ListTests(self, current_path, path, mode, arch):
+  def ListTests(self, current_path, path, mode, arch, FOOBAR):
     """Searches for *Test .dart files and returns list of TestCases."""
     tests = []
     for root, unused_dirs, files in os.walk(self.root):
       for f in [x for x in files if self.IsTest(x)]:
         relative = os.path.relpath(root, self.root).split(os.path.sep)
         test_path = current_path + relative + [os.path.splitext(f)[0]]
         if not self.Contains(path, test_path):
           continue
         tests.append(test_case.BrowserTestCase(self.context,
                                                test_path,
                                                os.path.join(root, f),
                                                self.fatal_static_type_errors,
-                                               mode, arch))
+                                               mode, arch, FOOBAR))
     atexit.register(lambda: self._Cleanup(tests))
     return tests
 
   def IsTest(self, name):
     return name.endswith('_tests.dart')
 
 
 class CompilationTestConfiguration(test.TestConfiguration):
   """Configuration that searches specific directories for apps to compile.
 
   Expects a status file named  dartc.status
   """
 
   def __init__(self, context, root):
     super(CompilationTestConfiguration, self).__init__(context, root)
 
-  def ListTests(self, current_path, path, mode, arch):
+  def ListTests(self, current_path, path, mode, arch, FOOBAR):
     """Searches for *Test.dart files and returns list of TestCases."""
     tests = []
     client_path = os.path.normpath(os.path.join(self.root, '..', '..'))
 
     for src_dir in self.SourceDirs():
       for root, dirs, files in os.walk(os.path.join(client_path, src_dir)):
         ignore_dirs = [d for d in dirs if d.startswith('.')]
         for d in ignore_dirs:
           dirs.remove(d)
         for f in files:
           filename = [os.path.basename(client_path)]
           filename.extend(root[len(client_path) + 1:].split(os.path.sep))
           filename.append(f)  # Remove .lib or .app suffix.
           test_path = current_path + filename
           test_dart_file = os.path.join(root, f)
           if (not self.Contains(path, test_path)
               or not self.IsTest(test_dart_file)):
             continue
           tests.append(test_case.CompilationTestCase(test_path,
                                                      self.context,
                                                      test_dart_file,
                                                      mode,
-                                                     arch))
+                                                     arch,
+                                                     FOOBAR))
     atexit.register(lambda: self._Cleanup(tests))
     return tests
 
   def SourceDirs(self):
     """Returns a list of directories to scan for files to compile."""
     raise TestConfigurationError(
         'Subclasses must implement SourceDirs()')
 
   def IsTest(self, name):
     """Returns True if name is a test case to be compiled."""
@@ skipping 11 matching lines @@
 
   def GetTestStatus(self, sections, defs):
     status = os.path.join(self.root, 'dartc.status')
     if os.path.exists(status):
       test.ReadConfigurationInto(status, sections, defs)
 
   def _Cleanup(self, tests):
     if not utils.Daemonize(): return
     os.execlp('rm', *(['rm', '-rf'] + [t.temp_dir for t in tests]))
     raise