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

dart/tools/test.py

 #!/usr/bin/env python
 #
 # 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.
 #
 
 """Test driver for the Dart project used by continuous build and developers."""
 
 
@@ skipping 593 matching lines @@
 
   def GetBuildRoot(self, mode, arch):
     """The top level directory containing compiler, runtime, tools..."""
     result = utils.GetBuildRoot(self.os, mode, arch)
     return result
 
   def GetBuildConf(self, mode, arch):
     result = utils.GetBuildConf(mode, arch)
     return result
 
-  def GetExecutable(self, mode, arch, name):
+  def GetExecutable(self, mode, arch, path):
     """Returns the name of the executable used to run the test."""
     if self.executable is not None:
       return self.executable
-    path = os.path.abspath(os.path.join(self.GetBuildRoot(mode, arch), name))
     if utils.IsWindows() and not path.endswith('.exe'):
       return path + '.exe'
     else:
       return path
 
   def GetDart(self, mode, arch, component):
-    """Returns the path to the Dart test runner (executes the .dart file)."""
-    if component == 'dartc':
-      command = [os.path.abspath(
-          os.path.join(self.GetBuildRoot(mode, arch),
-                       'compiler', 'bin', 'dartc_test'))]
-    else:
-      command = [self.GetExecutable(mode, arch, 'dart_bin')]
-
-    return command
+    dart = utils.GetDart(mode, arch, component)
+    return [self.GetExecutable(mode, arch, dart)]
 
   def GetDartC(self, mode, arch):
     """Returns the path to the Dart --> JS compiler."""
     dartc = os.path.abspath(os.path.join(
         self.GetBuildRoot(mode, arch), 'compiler', 'bin', 'dartc'))
     if utils.IsWindows(): dartc += '.exe'
     command = [dartc]
 
     # Add the flags from the context to the command line.
     command += self.flags
     return command
 
   def GetRunTests(self, mode, arch):
-    return [self.GetExecutable(mode, arch, 'run_vm_tests')]
+    path = os.path.join(self.GetBuildRoot(mode, arch), 'run_vm_tests')
+    return [self.GetExecutable(mode, arch, path)]
 
 
 def RunTestCases(cases_to_run, progress, tasks, context):
   """Chooses a progress indicator and then starts the tests."""
   progress = PROGRESS_INDICATORS[progress](cases_to_run, context)
   return progress.Run(tasks)
 
 
 # -------------------------------------------
 # --- T e s t   C o n f i g u r a t i o n ---
@@ skipping 555 matching lines @@
       default='true',
       type='choice')
   result.add_option(
       '--optimize',
       help='Invoke dart compiler with --optimize flag',
       default=False,
       action='store_true')
   result.add_option(
       '-c', '--component',
       help='The component to test against '
-           '(most, vm, dartc, chromium, dartium)',
+           '(most, vm, dartc, frog, frogsh, chromium, dartium)',
       metavar='[most,vm,dartc,chromium,dartium]',
       default='vm')
   return result
 
 
 def ProcessOptions(options):
   """Process command line options."""
   if options.arch == 'all':
     options.arch = 'ia32,x64,simarm'
   if options.mode == 'all':
     options.mode = 'debug,release'
   if options.component == 'most':
     options.component = 'vm,dartc'
 
-  if 'dartc' in options.arch:
-    options.component = 'dartc'
-  if 'dartium' in options.arch:
-    options.component = 'dartium'
-  if 'chromium' in options.arch:
-    options.component = 'chromium'
-
   # By default we run with a higher timeout setting in when running on
   # a simulated architecture and in debug mode.
   if not options.timeout:
     options.timeout = TIMEOUT_SECS
     if 'dartc' in options.component:
       options.timeout *= 4
     elif 'chromium' in options.component:
       options.timeout *= 4
     elif 'dartium' in options.component:
       options.timeout *= 4
     elif 'debug' in options.mode:
       options.timeout *= 2
   options.mode = options.mode.split(',')
   options.arch = options.arch.split(',')
   options.component = options.component.split(',')
   for mode in options.mode:
     if not mode in ['debug', 'release']:
       print 'Unknown mode %s' % mode
       return False
   for arch in options.arch:
     if not arch in ['ia32', 'x64', 'simarm', 'arm']:
       print 'Unknown arch %s' % arch
       return False
   for component in options.component:
-    if not component in ['vm', 'dartc', 'chromium', 'dartium']:
+    if not component in ['vm', 'dartc', 'frog', 'frogsh',
+                         'chromium', 'dartium']:
       print 'Unknown component %s' % component
       return False
   options.flags = []
   options.flags.append('--ignore-unrecognized-flags')
   if options.checked:
     options.flags.append('--enable_asserts')
     options.flags.append('--enable_type_checks')
   if options.optimize:
     options.flags.append('--optimize')
   for flag in options.flag:
@@ skipping 248 matching lines @@
     for entry in timed_tests[:20]:
       t = FormatTime(entry.duration)
       print '%4i (%s) %s' % (index, t, entry.GetLabel())
       index += 1
 
   return result
 
 
 if __name__ == '__main__':
   sys.exit(Main())