Reapply 7581, Fix tools/test.py to allow CTRL+C to work correctly again.

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 99 matching lines @@
       except Empty:
         return
       case = test.case
       self.lock.acquire()
       self.AboutToRun(case)
       self.lock.release()
       try:
         start = time.time()
         output = case.Run()
         case.duration = (time.time() - start)
+      except BreakNowException:
+        self.terminate = True
       except IOError, e:
         assert self.terminate
         return
       if self.terminate:
         return
       self.lock.acquire()
       if output.UnexpectedOutput():
         self.failed.append(output)
         if output.HasCrashed():
           self.crashed += 1
@@ skipping 181 matching lines @@
   'dots': DotsProgressIndicator,
   'color': ColorProgressIndicator,
   'mono': MonochromeProgressIndicator
 }
 
 
 # -------------------------
 # --- F r a m e w o r k ---
 # -------------------------
 
+class BreakNowException(Exception):
+  def __init__(self, value):
+    self.value = value
+  def __str__(self):
+    return repr(self.value)
+
 
 class CommandOutput(object):
 
   def __init__(self, exit_code, timed_out, stdout, stderr):
     self.exit_code = exit_code
     self.timed_out = timed_out
     self.stdout = stdout
     self.stderr = stderr
     self.failed = None
 
@@ skipping 41 matching lines @@
     pass
 
   def AfterRun(self, result):
     pass
 
   def GetCustomFlags(self, mode):
     return None
 
   def Run(self):
     self.BeforeRun()
-    result = "exception"
+    result = None
     try:
       result = self.RunCommand(self.GetCommand())
+    except:
+      self.terminate = True
+      raise BreakNowException("Used pressed CTRL+C or IO went wrong")
     finally:
       self.AfterRun(result)
     return result
 
   def Cleanup(self):
     return
 
 
 class TestOutput(object):
 
@@ skipping 21 matching lines @@
     if utils.IsWindows():
       return 0x80000000 & self.output.exit_code and not (0x3FFFFF00 & self.output.exit_code)
     else:
       # Timed out tests will have exit_code -signal.SIGTERM.
       if self.output.timed_out:
         return False
       return self.output.exit_code < 0 and \
              self.output.exit_code != -signal.SIGABRT
 
   def HasTimedOut(self):
-    return self.output.timed_out;
+    return self.output.timed_out
 
   def HasFailed(self):
     execution_failed = self.test.DidFail(self.output)
     if self.test.IsNegative():
       return not execution_failed
     else:
       return execution_failed
 
 
 def KillProcessWithID(pid):
@@ skipping 258 matching lines @@
 
   def GetTimeout(self, testcase, mode):
     result = self.timeout * TIMEOUT_SCALEFACTOR[mode]
     if '--stress-opt' in self.GetVmFlags(testcase, mode):
       return result * 2
     else:
       return result
 
 def RunTestCases(cases_to_run, progress, tasks):
   progress = PROGRESS_INDICATORS[progress](cases_to_run)
-  return progress.Run(tasks)
+  result = 0
+  try:
+    result = progress.Run(tasks)
+  except Exception, e:
+    print "\n", e
+  return result
 
 
 def BuildRequirements(context, requirements, mode, scons_flags):
   command_line = (['scons', '-Y', context.workspace, 'mode=' + ",".join(mode)]
                   + requirements
                   + scons_flags)
   output = ExecuteNoCapture(command_line, context)
   return output.exit_code == 0
 
 
@@ skipping 616 matching lines @@
   millis = round(d * 1000) % 1000
   return time.strftime("%M:%S.", time.gmtime(d)) + ("%03i" % millis)
 
 def ShardTests(tests, options):
   if options.shard_count < 2:
     return tests
   if options.shard_run < 1 or options.shard_run > options.shard_count:
     print "shard-run not a valid number, should be in [1:shard-count]"
     print "defaulting back to running all tests"
     return tests
-  count = 0;
+  count = 0
   shard = []
   for test in tests:
     if count % options.shard_count == options.shard_run - 1:
-      shard.append(test);
+      shard.append(test)
     count += 1
   return shard
 
 def Main():
   parser = BuildOptions()
   (options, args) = parser.parse_args()
   if not ProcessOptions(options):
     parser.print_help()
     return 1
 
@@ skipping 124 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())