[test] Make missing files result in a proper test runner error.

tools/testrunner/local/pool.py

 #!/usr/bin/env python
 # Copyright 2014 the V8 project authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 from Queue import Empty
 from multiprocessing import Event, Process, Queue
 import traceback
 
 
@@ skipping 91 matching lines @@
 
     Args:
       process_context_fn: Function executed once by each worker. Expected to
           return a process-context object. If present, this object is passed
           as additional argument to each call to fn.
       process_context_args: List of arguments for the invocation of
           process_context_fn. All arguments will be pickled and sent beyond the
           process boundary.
     """
     try:
+      internal_error = False
       gen = iter(gen)
       self.advance = self._advance_more
 
       for w in xrange(self.num_workers):
         p = Process(target=Worker, args=(fn,
                                          self.work_queue,
                                          self.done_queue,
                                          self.done,
                                          process_context_fn,
                                          process_context_args))
         self.processes.append(p)
         p.start()
 
       self.advance(gen)
       while self.count > 0:
         while True:
           try:
             result = self.done_queue.get(timeout=self.heartbeat_timeout)
             break
           except Empty:
             # Indicate a heartbeat. The iterator will continue fetching the
             # next result.
             yield MaybeResult.create_heartbeat()
         self.count -= 1
         if result.exception:
-          # Ignore items with unexpected exceptions.
+          # TODO(machenbach): Handle a few known types of internal errors
+          # gracefully, e.g. missing test files.
+          internal_error = True
           continue
         elif result.break_now:
           # A keyboard interrupt happened in one of the worker processes.
           raise KeyboardInterrupt
         else:
           yield MaybeResult.create_result(result.result)
         self.advance(gen)
     finally:
       self.terminate()
+    if internal_error:
+      raise Exception("Internal error in a worker process.")
 
   def _advance_more(self, gen):
     while self.count < self.num_workers * self.BUFFER_FACTOR:
       try:
         self.work_queue.put(gen.next())
         self.count += 1
       except StopIteration:
         self.advance = self._advance_empty
         break
 
@@ skipping 25 matching lines @@
 
     # Drain the queues to prevent failures when queues are garbage collected.
     try:
       while True: self.work_queue.get(False)
     except:
       pass
     try:
       while True: self.done_queue.get(False)
     except:
       pass