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 405 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(ChromiumArchitecture):
-  """Architecture that runs compiled dart->JS (via frog) through a variety of
-  real browsers using WebDriver."""
+class WebDriverArchitecture(ChromiumArchitecture):
+  """Architecture that runs compiled dart->JS (via frog) through a
+  real browser (by default, Chrome) using WebDriver."""
 
   def __init__(self, root_path, arch, mode, component, test):
-    super(WebDriverArchiecture, self).__init__(root_path, arch, mode,
+    super(WebDriverArchitecture, self).__init__(root_path, arch, mode,
         component, test)
 
   def GetCompileCommand(self, fatal_static_type_errors=False):
     """Returns cmdline as an array to invoke the compiler on this test."""
     # We need an absolute path because the compilation will run
     # in a temporary directory.
     frog = os.path.abspath(utils.GetDartRunner(self.mode, self.arch, 'frogsh'))
     build_root = utils.GetBuildRoot(OS_GUESS, self.mode, 'ia32')
     cmd = [frog, '--libdir=%s' % os.path.abspath(os.path.join(self.root_path, 
         'frog', 'lib')), '--compile-only',
         '--out=%s' % self.GetScriptPath()]
     cmd.append(self.GetTestScriptFile())
     return cmd
 
-  def GetRunCommand(self, fatal_static_type_errors=False):
+  def GetRunCommand(self, browser='chrome', fatal_static_type_errors=False):

[Siggi Cherem (dart-lang), 2011/11/14 23:56:06]

this will possibly be not compatible with calls that pass these optional
arguments positionally (which the style guide disallows, but it's still
possible). I'd move this as the last argument.

Alternatively, you can make the constructor of WebDriverArchitecture take the
browser as an argument and store it in the object.

     """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, browser]
+
+class FirefoxDriverArchitecture(WebDriverArchitecture):

[Siggi Cherem (dart-lang), 2011/11/14 23:56:06]

if you end up adding the parameter to the constructor, there is little value in
adding these 2 types and you might want to use allocate
WebDriverArchitecture(..., browser = 'ff') directly in line 582.

+
+  def GetRunCommand(self, fatal_static_type_errors=False):
+    """Returns a command line to execute for the test."""
+    return super(FirefoxDriverArchitecture, self).GetRunCommand(browser='ff', 
+        fatal_static_type_errors = fatal_static_type_errors)
+
+class IEDriverArchitecture(WebDriverArchitecture):
+
+  def GetRunCommand(self, fatal_static_type_errors=False):
+    """Returns a command line to execute for the test."""
+    return super(IEDriverArchitecture, self).GetRunCommand(browser='ie', 
+        fatal_static_type_errors = fatal_static_type_errors)
 
 
 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 88 matching lines @@
   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)
+  elif component == 'webdriver' or component == 'webdriverchrome':
+    return WebDriverArchitecture(root_path, arch, mode, component, test)
+
+  elif component == 'webdriverff':

[Siggi Cherem (dart-lang), 2011/11/14 23:56:06]

it might be nice to use - or _ on these names, as long as it doesn't break the
commandline usage
(e.g. webdriver-ff)

+    return FirefoxDriverArchitecture(root_path, arch, mode, component, test)
+
+  elif component == 'webdriverie':
+    return IEDriverArchitecture(root_path, arch, mode, component, test)
 
   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)