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

tools/testing/test_case.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.
 
 """Common TestCase subclasses used to define a single test."""
 
 import os
 import tempfile
 
 import test
 from testing import architecture
 
 
 class Error(Exception):
   pass
 
 
 class StandardTestCase(test.TestCase):
   """A test case defined by a *Test.dart file."""
 
   def __init__(self, context, path, filename, mode, arch, component,
                vm_options=None):
     super(StandardTestCase, self).__init__(context, path)
     self.filename = filename
     self.mode = mode
     self.arch = arch
     self.component = component
     self.run_arch = architecture.GetArchitecture(self.arch, self.mode,
                                                  self.component,
-                                                 self.filename)
+                                                 self.filename,
+                                                 self.context.flags)
     for flag in context.flags:
       self.run_arch.vm_options.append(flag)
 
     if vm_options:
       for flag in vm_options:
         self.run_arch.vm_options.append(flag)
 
   def IsNegative(self):
     return self.GetName().endswith('NegativeTest')
 
@@ skipping 45 matching lines @@
     if self.kind == 'compile-time error':
       return True
     if self.kind == 'runtime error':
       return True
     if self.kind == 'static type error':
       return self.run_arch.HasFatalTypeErrors()
     return False
 
 
 class BrowserTestCase(StandardTestCase):
-  """A test case that executes inside DumpRenderTree."""
+  """A test case that executes inside DumpRenderTree or a browser."""
 
   def __init__(self, context, path, filename,
                fatal_static_type_errors, mode, arch, component, vm_options=None):
     super(BrowserTestCase, self).__init__(
         context, path, filename, mode, arch, component, vm_options)
     self.fatal_static_type_errors = fatal_static_type_errors
 
   def Run(self):
     """Optionally compiles and then runs the specified test."""
     command = self.run_arch.GetCompileCommand(self.fatal_static_type_errors)
@@ skipping 26 matching lines @@
 
   def __init__(self, path, context, filename, mode, arch, component):
     super(CompilationTestCase, self).__init__(context, path)
     self.filename = filename
     self.mode = mode
     self.arch = arch
     self.component = component
     self.run_arch = architecture.GetArchitecture(self.arch,
                                                  self.mode,
                                                  self.component,
-                                                 self.filename)
+                                                 self.filename,
+                                                 self.context.flags)
     self.temp_dir = tempfile.mkdtemp(prefix='dartc-output-')
 
   def IsNegative(self):
     return False
 
   def GetLabel(self):
     return '%s/%s %s %s' % (self.mode, self.arch, self.component,
                             '/'.join(self.path))
 
   def GetCommand(self):
     """Returns a command line to run the test."""
     cmd = self.context.GetDartC(self.mode, self.arch)
     cmd += self.context.flags
     cmd += ['-check-only',
             '-fatal-type-errors',
             '-Werror',
             '-out', self.temp_dir,
             self.filename]
 
     return cmd
 
   def GetName(self):
     return self.path[-1]
 
   def Cleanup(self):
     if not self.context.keep_temporary_files:
       self.run_arch.Cleanup()