Merge isolates to bleeding_edge.

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 322 matching lines @@
 
   def __init__(self, context, path, mode):
     self.path = path
     self.context = context
     self.duration = None
     self.mode = mode
 
   def IsNegative(self):
     return False
 
+  def TestsIsolates(self):
+    return False
+
   def CompareTime(self, other):
     return cmp(other.duration, self.duration)
 
   def DidFail(self, output):
     if output.failed is None:
       output.failed = self.IsFailureOutput(output)
     return output.failed
 
   def IsFailureOutput(self, output):
     return output.exit_code != 0
@@ skipping 142 matching lines @@
         sleep_time = MAX_SLEEP_TIME
   return (process, exit_code, timed_out)
 
 
 def PrintError(str):
   sys.stderr.write(str)
   sys.stderr.write('\n')
 
 
 def CheckedUnlink(name):
-  try:
-    os.unlink(name)
-  except OSError, e:
-    PrintError("os.unlink() " + str(e))
-
+  # On Windows, when run with -jN in parallel processes,
+  # OS often fails to unlink the temp file. Not sure why.
+  # Need to retry.
+  # Idea from https://bugs.webkit.org/attachment.cgi?id=75982&action=prettypatch
+  retry_count = 0
+  while retry_count < 30:
+    try:
+      os.unlink(name)
+      return
+    except OSError, e:
+      retry_count += 1;
+      time.sleep(retry_count * 0.1)
+  PrintError("os.unlink() " + str(e))
 
 def Execute(args, context, timeout=None):
   (fd_out, outname) = tempfile.mkstemp()
   (fd_err, errname) = tempfile.mkstemp()
   (process, exit_code, timed_out) = RunProcess(
     context,
     timeout,
     args = args,
     stdout = fd_out,
     stderr = fd_err,
@@ skipping 486 matching lines @@
     return None
   return ast
 
 
 class ClassifiedTest(object):
 
   def __init__(self, case, outcomes):
     self.case = case
     self.outcomes = outcomes
 
+  def TestsIsolates(self):
+    return self.case.TestsIsolates()
+
 
 class Configuration(object):
   """The parsed contents of a configuration file"""
 
   def __init__(self, sections, defs):
     self.sections = sections
     self.defs = defs
 
   def ClassifyTests(self, cases, env):
     sections = [s for s in self.sections if s.condition.Evaluate(env, self.defs)]
@@ skipping 139 matching lines @@
       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")
+  result.add_option("--isolates", help="Whether to test isolates", default=False, action="store_true")
   result.add_option("--store-unexpected-output",
       help="Store the temporary JS files from tests that fails",
       dest="store_unexpected_output", default=True, action="store_true")
   result.add_option("--no-store-unexpected-output",
       help="Deletes the temporary JS files from tests that fails",
       dest="store_unexpected_output", action="store_false")
   result.add_option("--stress-only",
                     help="Only run tests with --always-opt --stress-opt",
                     default=False, action="store_true")
   result.add_option("--nostress",
@@ skipping 246 matching lines @@
     for rule in globally_unused_rules:
       print "Rule for '%s' was not used." % '/'.join([str(s) for s in rule.path])
 
   if options.report:
     PrintReport(all_cases)
 
   result = None
   def DoSkip(case):
     return SKIP in case.outcomes or SLOW in case.outcomes
   cases_to_run = [ c for c in all_cases if not DoSkip(c) ]
+  if not options.isolates:
+    cases_to_run = [c for c in cases_to_run if not c.TestsIsolates()]
   if len(cases_to_run) == 0:
     print "No tests to run."
     return 0
   else:
     try:
       start = time.time()
       if RunTestCases(cases_to_run, options.progress, options.j):
         result = 0
       else:
         result = 1
@@ skipping 13 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())