Made changes to the test architecture so that we can run frameworks other than

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.
 #
 
 import os
 import platform
 import re
 import shutil
 import subprocess
@@ skipping 407 matching lines @@
     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 WebDriverArchiecture(FrogChromiumArchitecture):
+class WebDriverArchitecture(FrogChromiumArchitecture):
   """Architecture that runs compiled dart->JS (via frog) through a variety of
   real browsers using WebDriver."""
 
-  def __init__(self, root_path, arch, mode, component, test):
-    super(WebDriverArchiecture, self).__init__(root_path, arch, mode,
+  def __init__(self, root_path, arch, mode, component, test, browser='chrome'):
+    super(WebDriverArchitecture, self).__init__(root_path, arch, mode,
         component, test)
+    self.browser = browser
 
   def GetRunCommand(self, fatal_static_type_errors=False):
     """Returns a command line to execute for the test."""
     selenium_location = os.path.join(self.root_path, 'tools', 'testing',
                                 'run_selenium.py')
     
     html_output_file = os.path.join(self.GetHtmlPath(), self.GetHtmlName())
     f = open(html_output_file, 'w')
     f.write(self.GetHtmlContents())
     f.close()
-    return [selenium_location, html_output_file]
+    return [selenium_location, html_output_file, self.browser]
 
 
 class StandaloneArchitecture(Architecture):
   """Base class for architectures that run tests without a browser."""
 
   def __init__(self, root_path, arch, mode, component, test):
     super(StandaloneArchitecture, self).__init__(root_path, arch, mode, component,
                                                  test)
 
   def GetExecutable(self):
@@ skipping 77 matching lines @@
     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, component, test):
+def GetArchitecture(arch, mode, component, test, flags):

[Siggi Cherem (dart-lang), 2011/11/15 02:16:18]

One suggestion: we might be able to do this without this parameter. 

Since TestCase updates the architecture already to store the flag in
'self.vm_options', we could use that directly in 'GetRunCommand'. (vm_options
might be empty when allocating the architecture, but I believe it should have
the flag when 'GetRunCommand' is called). 

Note: if you decide to keep the flag, make sure to update run.py as well.

   root_path = os.path.abspath(os.path.join(os.path.dirname(sys.argv[0]), '..'))
   if component == 'chromium':
     return DartcChromiumArchitecture(root_path, arch, mode, component, test)
 
   elif component == 'dartium':
     return DartiumArchitecture(root_path, arch, mode, component, test)
 
   elif component == 'frogium':
     return FrogChromiumArchitecture(root_path, arch, mode, component, test)
 
   elif component == 'webdriver':
-    return WebDriverArchiecture(root_path, arch, mode, component, test)
+    browser_flag = 'chrome'
+    if 'ff' in flags or 'firefox' in flags:
+      browser_flag = 'ff'
+    elif 'ie' in flags or 'explorer' in flags or 'internet-explorer' in flags:
+      browser_flag = 'ie'
+    return WebDriverArchitecture(root_path, arch, mode, component, test,
+        browser=browser_flag)
 
   elif component in ['vm', 'frog', 'frogsh']:
     return StandaloneArchitecture(root_path, arch, mode, component, test)
 
   elif component == 'leg':
     return LegArchitecture(root_path, arch, mode, component, test)
 
   elif component == 'dartc':
     return DartcArchitecture(root_path, arch, mode, component, test)