Bleeding edge change to get frog integrated into the testing infrastructure.

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 333 matching lines @@
   def GetHtmlName(self):
     """Returns the name of the output .html file to create."""
     relpath = os.path.relpath(self.test, self.root_path)
     return relpath.replace(os.sep, '_') + '.html'
 
   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.
-    build_root = utils.GetBuildRoot(OS_GUESS, self.mode, 'dartc')
+    build_root = utils.GetBuildRoot(OS_GUESS, self.mode, 'ia32')
     dartc = os.path.abspath(os.path.join(build_root, 'compiler', 'bin',
                                          'dartc'))
     if utils.IsWindows(): dartc += '.exe'
     cmd = [dartc, '--work', self.temp_dir]
     if self.mode == 'release':
       cmd += ['--optimize']
     cmd += self.vm_options
     cmd += ['--out', self.GetScriptPath()]
     if fatal_static_type_errors:
       # TODO(zundel): update to --fatal_type_errors for both VM and Compiler
@@ skipping 29 matching lines @@
     return 0
 
 
 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):
+    """Returns the path to the Dart test runner (executes the .dart file)."""
+    return utils.GetDart(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 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
@@ skipping 25 matching lines @@
 
 
 # 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 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, component, test):
-    super(RuntimeArchitecture, self).__init__(root_path, arch, mode, component,
-                                              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, component, test):
   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 == 'vm':
-    return RuntimeArchitecture(root_path, arch, mode, component, test)
+  elif component in ['vm', 'frog', 'frogsh']:
+    return StandaloneArchitecture(root_path, arch, mode, component, test)
 
   elif component == 'dartc':
     return DartcArchitecture(root_path, arch, mode, component, test)