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

dart/tools/testing/architecture.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.
 #
 
-"""Runs a Dart unit test in different configurations.
-
-Currently supported architectures include dartium, chromium, ia32, x64,
-arm, simarm, and dartc.
-
-Example:
-  run.py --arch=dartium --mode=release --test=Test.dart
-
-"""
-
 import os
 import platform
 import re
 import shutil
 import subprocess
 import sys
 import tempfile
 
 import utils
 
@@ skipping 111 matching lines @@
   """Returns True if the source has a #library statement."""
   if LIBRARY_DEFINITION_PATTERN.search(source):
     return True
   if SOURCE_OR_IMPORT_PATTERN.search(source):
     print ('WARNING for %s: Browser tests need a #library '
            'for a file that #import or #source' % test)
   return False
 
 
 class Architecture(object):
-  """Definitions for different ways to test based on the --arch flag."""
+  """Definitions for different ways to test based on the FOOBAR flag."""
 
-  def __init__(self, root_path, arch, mode, test):
+  def __init__(self, root_path, arch, mode, FOOBAR, test):
     self.root_path = root_path
     self.arch = arch
     self.mode = mode
+    self.FOOBAR = FOOBAR
     self.test = test
     self.build_root = utils.GetBuildRoot(OS_GUESS, self.mode, self.arch)
     source = file(test).read()
     self.vm_options = []
     self.dart_options = utils.ParseTestOptions(DART_OPTIONS_PATTERN,
                                                source,
                                                root_path)
     self.is_web_test = _IsWebTest(source)
     self.temp_dir = None
 
   def HasFatalTypeErrors(self):
-    """Returns True if this type of arch supports --fatal-type-errors."""
+    """Returns True if this type of FOOBAR supports --fatal-type-errors."""
     return False
 
   def GetTestFrameworkPath(self):
     """Path to dart source (TestFramework.dart) for testing framework."""
     return os.path.join(self.root_path, 'tests', 'isolate', 'src',
                         'TestFramework.dart')
 
 
 class BrowserArchitecture(Architecture):
   """Architecture that runs compiled dart->JS through a browser."""
 
-  def __init__(self, root_path, arch, mode, test):
-    super(BrowserArchitecture, self).__init__(root_path, arch, mode, test)
+  def __init__(self, root_path, arch, mode, FOOBAR, test):
+    super(BrowserArchitecture, self).__init__(root_path, arch, mode, FOOBAR, test)
     self.temp_dir = tempfile.mkdtemp()
     if not self.is_web_test: self.GenerateWebTestScript()
 
   def GetTestScriptFile(self):
     """Returns the name of the .dart file to compile."""
     if self.is_web_test: return os.path.abspath(self.test)
     return os.path.join(self.temp_dir, 'test.dart')
 
   def GetHtmlContents(self):
     """Fills in the HTML_CONTENTS template with info for this architecture."""
@@ skipping 24 matching lines @@
         os.makedirs(html_path)
       return html_path
 
     return self.temp_dir
 
   def GetTestContents(self, library_file):
     """Pastes a preamble on the front of the .dart file before testing."""
     unittest_path = os.path.join(self.root_path, 'client', 'testing',
                                  'unittest', 'unittest.dart')
 
-    if self.arch == 'chromium':
+    if self.FOOBAR == 'chromium':
       dom_path = os.path.join(self.root_path, 'client', 'testing',
                               'unittest', 'dom_for_unittest.dart')
     else:
       dom_path = os.path.join('dart:dom')
 
     test_framework_path = self.GetTestFrameworkPath()
     test_path = os.path.abspath(self.test)
 
     inputs = {
         'unittest': unittest_path,
@@ skipping 84 matching lines @@
   def Cleanup(self):
     """Removes temporary files created for the test."""
     if self.temp_dir:
       shutil.rmtree(self.temp_dir)
       self.temp_dir = None
 
 
 class ChromiumArchitecture(BrowserArchitecture):
   """Architecture that runs compiled dart->JS through a chromium DRT."""
 
-  def __init__(self, root_path, arch, mode, test):
-    super(ChromiumArchitecture, self).__init__(root_path, arch, mode, test)
+  def __init__(self, root_path, arch, mode, FOOBAR, test):
+    super(ChromiumArchitecture, self).__init__(root_path, arch, mode, FOOBAR, test)
 
   def GetScriptType(self):
     return 'text/javascript'
 
   def GetScriptPath(self):
     """Returns the name of the output .js file to create."""
     path = self.GetTestScriptFile()
     return os.path.abspath(os.path.join(self.temp_dir,
                                         os.path.basename(path) + '.js'))
 
@@ skipping 22 matching lines @@
     cmd.append(self.GetTestScriptFile())
     return cmd
 
   def Compile(self):
     return ExecuteCommand(self.GetCompileCommand())
 
 
 class DartiumArchitecture(BrowserArchitecture):
   """Architecture that runs dart in an VM embedded in DumpRenderTree."""
 
-  def __init__(self, root_path, arch, mode, test):
-    super(DartiumArchitecture, self).__init__(root_path, arch, mode, test)
+  def __init__(self, root_path, arch, mode, FOOBAR, test):
+    super(DartiumArchitecture, self).__init__(root_path, arch, mode, FOOBAR, test)
 
   def GetScriptType(self):
     return 'application/dart'
 
   def GetScriptPath(self):
     return 'file:///' + self.GetTestScriptFile()
 
   def GetHtmlName(self):
     path = os.path.relpath(self.test, self.root_path).replace(os.sep, '_')
     return path + '.dartium.html'
 
   def GetCompileCommand(self, fatal_static_type_errors=False):
     fatal_static_type_errors = fatal_static_type_errors  # shutup lint!
     return None
 
   def Compile(self):
     return 0
 
 
 class StandaloneArchitecture(Architecture):
   """Base class for architectures that run tests without a browser."""
 
-  def __init__(self, root_path, arch, mode, test):
-    super(StandaloneArchitecture, self).__init__(root_path, arch, mode, test)
+  def __init__(self, root_path, arch, mode, FOOBAR, test):
+    super(StandaloneArchitecture, self).__init__(root_path, arch, mode, FOOBAR, test)
 
   def GetCompileCommand(self, fatal_static_type_errors=False):
     fatal_static_type_errors = fatal_static_type_errors  # shutup lint!
     return None
 
   def GetRunCommand(self, fatal_static_type_errors=False):
     """Returns a command line to execute for the test."""
     dart = self.GetExecutable()
     test_name = os.path.basename(self.test)
     test_path = os.path.abspath(self.test)
@@ skipping 23 matching lines @@
 
   def Cleanup(self):
     return
 
 
 # Long term, we should do the running machinery that is currently in
 # DartRunner.java
 class DartcArchitecture(StandaloneArchitecture):
   """Runs the Dart ->JS compiler then runs the result in a standalone JS VM."""
 
-  def __init__(self, root_path, arch, mode, test):
-    super(DartcArchitecture, self).__init__(root_path, arch, mode, test)
+  def __init__(self, root_path, arch, mode, FOOBAR, test):
+    super(DartcArchitecture, self).__init__(root_path, arch, mode, FOOBAR, test)
 
   def GetExecutable(self):
     """Returns the name of the executable to run the test."""
     return os.path.abspath(os.path.join(self.build_root,
                                         'compiler',
                                         'bin',
                                         'dartc_test'))
 
   def GetFatalTypeErrorsFlags(self):
     return ['--fatal-type-errors']
 
   def HasFatalTypeErrors(self):
     return True
 
   def GetRunCommand(self, fatal_static_type_errors=False):
     """Returns a command line to execute for the test."""
     cmd = super(DartcArchitecture, self).GetRunCommand(
         fatal_static_type_errors)
     return cmd
 
 
 class RuntimeArchitecture(StandaloneArchitecture):
   """Executes tests on the standalone VM (runtime)."""
 
-  def __init__(self, root_path, arch, mode, test):
-    super(RuntimeArchitecture, self).__init__(root_path, arch, mode, test)
+  def __init__(self, root_path, arch, mode, FOOBAR, test):
+    super(RuntimeArchitecture, self).__init__(root_path, arch, mode, FOOBAR, test)
 
   def GetExecutable(self):
     """Returns the name of the executable to run the test."""
     return os.path.abspath(os.path.join(self.build_root, 'dart_bin'))
 
 
 def ExecutePipedCommand(cmd, verbose):
   """Execute a command in a subprocess."""
   if verbose:
     print 'Executing: ' + ' '.join(cmd)
   pipe = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
   (output, err) = pipe.communicate()
   if pipe.returncode != 0 and verbose:
     print 'Execution failed: ' + output + '\n' + err
     print output
     print err
   return pipe.returncode, output, err
 
 
 def ExecuteCommand(cmd, verbose=False):
   """Execute a command in a subprocess."""
   if verbose: print 'Executing: ' + ' '.join(cmd)
   return subprocess.call(cmd)
 
 
-def GetArchitecture(arch, mode, test):
+def GetArchitecture(arch, mode, FOOBAR, test):
   root_path = os.path.abspath(os.path.join(os.path.dirname(sys.argv[0]), '..'))
-  if arch == 'chromium':
-    return ChromiumArchitecture(root_path, arch, mode, test)
+  if FOOBAR == 'chromium':
+    return ChromiumArchitecture(root_path, arch, mode, FOOBAR, test)
 
-  elif arch == 'dartium':
-    return DartiumArchitecture(root_path, arch, mode, test)
+  elif FOOBAR == 'dartium':
+    return DartiumArchitecture(root_path, arch, mode, FOOBAR, test)
 
-  elif arch in ['ia32', 'x64', 'simarm', 'arm']:
-    return RuntimeArchitecture(root_path, arch, mode, test)
+  elif FOOBAR in ['vm']:
+    return RuntimeArchitecture(root_path, arch, mode, FOOBAR, test)
 
-  elif arch == 'dartc':
-    return DartcArchitecture(root_path, arch, mode, test)
+  elif FOOBAR == 'dartc':
+    return DartcArchitecture(root_path, arch, mode, FOOBAR, test)