Integrate leg as a component in test.py. Also update presubmit script to run tests with leg.

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.
 #
 
 import os
 import platform
 import re
 import shutil
 import subprocess
@@ skipping 392 matching lines @@
 
   def GetExecutable(self):
     """Returns the path to the Dart test runner (executes the .dart file)."""
     return utils.GetDartRunner(self.mode, self.arch, self.component)
 
 
   def GetCompileCommand(self, fatal_static_type_errors=False):
     fatal_static_type_errors = fatal_static_type_errors  # shutup lint!
     return None
 
+  def GetOptions(self):
+    return []
+
   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)
-    command = [dart] + self.vm_options
-    if self.mode == 'release':
-      command += ['--optimize']
-    (classname, extension) = os.path.splitext(test_name)
+    command = [dart] + self.GetOptions() + self.vm_options
+    if fatal_static_type_errors:
+      command += self.GetFatalTypeErrorsFlags()
+
     if self.dart_options:
       command += self.dart_options
-    elif extension == '.dart':
-      if fatal_static_type_errors:
-        command += self.GetFatalTypeErrorsFlags()
-      if '_' in classname:
-        (classname, unused_sep, unused_tag) = classname.rpartition('_')
-      command += [test_path]
     else:
-      command += ['--', test_path]
+      command += [self.test]
 
     return command
 
   def GetFatalTypeErrorsFlags(self):
     return []
 
   def RunTest(self, verbose):
     command = self.GetRunCommand()
     return ExecuteCommand(command, verbose)
 
   def Cleanup(self):
     return
 
 
+class LegArchitecture(StandaloneArchitecture):
+
+  def __init__(self, root_path, arch, mode, component, test):
+    super(LegArchitecture, self).__init__(root_path, arch, mode, component,
+                                          test)
+  def GetOptions(self):
+    return ['--enable_leg']
+
+  def GetExecutable(self):
+    """Returns the path to the Dart test runner (executes the .dart file)."""
+    return utils.GetDartRunner(self.mode, self.arch, 'frog')
+
+
 # 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, component, test):
     super(DartcArchitecture, self).__init__(root_path, arch, mode, component, test)
 
+  def GetOptions(self):
+    if self.mode == 'release': return ['--optimize']
+    return []
+
   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
-
 
 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
@@ skipping 11 matching lines @@
   root_path = os.path.abspath(os.path.join(os.path.dirname(sys.argv[0]), '..'))
   if component == 'chromium':
     return ChromiumArchitecture(root_path, arch, mode, component, test)
 
   elif component == 'dartium':
     return DartiumArchitecture(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)