Patch by Erik Kay to allow specifying which shell to...

tools/test.py

 #!/usr/bin/env python
 #
 # Copyright 2008 the V8 project authors. All rights reserved.
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions are
 # met:
 #
 #     * Redistributions of source code must retain the above copyright
 #       notice, this list of conditions and the following disclaimer.
 #     * Redistributions in binary form must reproduce the above
@@ skipping 461 matching lines @@
     stderr = fd_err,
   )
   os.close(fd_out)
   os.close(fd_err)
   output = file(outname).read()
   errors = file(errname).read()
   def CheckedUnlink(name):
     try:
       os.unlink(name)
     except OSError, e:
-      PrintError(str(e))
+      PrintError("os.unlink() " + str(e))
   CheckedUnlink(outname)
   CheckedUnlink(errname)
   return CommandOutput(exit_code, timed_out, output, errors)
 
 
 def ExecuteNoCapture(args, context, timeout=None):
   (process, exit_code, timed_out) = RunProcess(
     context,
     timeout,
     args = args,
@@ skipping 90 matching lines @@
       if not name or name.match(test_name):
         full_path = current_path + [test_name]
         result += test.ListTests(full_path, path, context, mode)
     return result
 
   def GetTestStatus(self, context, sections, defs):
     for test in self.tests:
       test.GetTestStatus(context, sections, defs)
 
 
-PREFIX = {'debug': '_g', 'release': ''}
+SUFFIX = {'debug': '_g', 'release': ''}
 
 
 class Context(object):
 
   def __init__(self, workspace, buildspace, verbose, vm, timeout, processor, suppress_dialogs):
     self.workspace = workspace
     self.buildspace = buildspace
     self.verbose = verbose
     self.vm_root = vm
     self.timeout = timeout
     self.processor = processor
     self.suppress_dialogs = suppress_dialogs
 
   def GetVm(self, mode):
-    name = self.vm_root + PREFIX[mode]
-    if utils.IsWindows():
-      return name + '.exe'
-    else:
-      return name
+    name = self.vm_root + SUFFIX[mode]
+    if utils.IsWindows() and not name.endswith('.exe'):
+      name = name + '.exe'
+    return name
 
 def RunTestCases(all_cases, progress, tasks):
   def DoSkip(case):
     return SKIP in c.outcomes or SLOW in c.outcomes
   cases_to_run = [ c for c in all_cases if not DoSkip(c) ]
   progress = PROGRESS_INDICATORS[progress](cases_to_run)
   return progress.Run(tasks)
 
 
 def BuildRequirements(context, requirements, mode, scons_flags):
@@ skipping 462 matching lines @@
   result.add_option("--warn-unused", help="Report unused rules",
       default=False, action="store_true")
   result.add_option("-j", help="The number of parallel tasks to run",
       default=1, type="int")
   result.add_option("--time", help="Print timing information after running",
       default=False, action="store_true")
   result.add_option("--suppress-dialogs", help="Suppress Windows dialogs for crashing tests",
         dest="suppress_dialogs", default=True, action="store_true")
   result.add_option("--no-suppress-dialogs", help="Display Windows dialogs for crashing tests",
         dest="suppress_dialogs", action="store_false")
+  result.add_option("--shell", help="Path to V8 shell", default="shell");
   return result
 
 
 def ProcessOptions(options):
   global VERBOSE
   VERBOSE = options.verbose
   options.mode = options.mode.split(',')
   for mode in options.mode:
     if not mode in ['debug', 'release']:
       print "Unknown mode %s" % mode
@@ skipping 110 matching lines @@
     for arg in args:
       path = SplitPath(arg)
       paths.append(path)
 
   # Check for --valgrind option. If enabled, we overwrite the special
   # command flag with a command that uses the run-valgrind.py script.
   if options.valgrind:
     run_valgrind = join(workspace, "tools", "run-valgrind.py")
     options.special_command = "python -u " + run_valgrind + " @"
 
-  # First build the required targets
-  buildspace = abspath('.')
+  shell = abspath(options.shell)
+  buildspace = dirname(shell)
   context = Context(workspace, buildspace, VERBOSE,
-                    join(buildspace, 'shell'),
+                    shell,
                     options.timeout,
                     GetSpecialCommandProcessor(options.special_command),
                     options.suppress_dialogs)
-  if options.j != 1:
-    options.scons_flags += ['-j', str(options.j)]
+  # First build the required targets
   if not options.no_build:
     reqs = [ ]
     for path in paths:
       reqs += root.GetBuildRequirements(path, context)
     reqs = list(set(reqs))
     if len(reqs) > 0:
+      if options.j != 1:
+        options.scons_flags += ['-j', str(options.j)]
       if not BuildRequirements(context, reqs, options.mode, options.scons_flags):
         return 1
 
   # Get status for tests
   sections = [ ]
   defs = { }
   root.GetTestStatus(context, sections, defs)
   config = Configuration(sections, defs)
 
   # List the tests
   all_cases = [ ]
   all_unused = [ ]
   unclassified_tests = [ ]
   globally_unused_rules = None
   for path in paths:
     for mode in options.mode:
+      if not exists(context.GetVm(mode)):
+        print "Can't find shell executable: '%s'" % context.GetVm(mode)
+        continue
       env = {
         'mode': mode,
         'system': utils.GuessOS(),
         'arch': options.arch
       }
       test_list = root.ListTests([], path, context, mode)
       unclassified_tests += test_list
       (cases, unused_rules, all_outcomes) = config.ClassifyTests(test_list, env)
       if globally_unused_rules is None:
         globally_unused_rules = set(unused_rules)
@@ skipping 49 matching lines @@
     for entry in timed_tests[:20]:
       t = FormatTime(entry.duration)
       sys.stderr.write("%4i (%s) %s\n" % (index, t, entry.GetLabel()))
       index += 1
 
   return result
 
 
 if __name__ == '__main__':
   sys.exit(Main())