Set coverage path globs on a per-Test basis instead of in main().

scripts/slave/unittests/expect_tests/pipeline.py

 # Copyright 2014 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 import Queue
 import glob
 import logging
 import multiprocessing
 import re
 import signal
 import traceback
 
 from cStringIO import StringIO
 
 from .type_definitions import (
     Test, UnknownError, TestError, NoMatchingTestsError, MultiTest,
     Result, ResultStageAbort)
 
+from . import util
+
 
 class ResetableStringIO(object):
   def __init__(self):
     self._stream = StringIO()
 
   def reset(self):
     self._stream = StringIO()
 
   def __getattr__(self, key):
     return getattr(self._stream, key)
@@ skipping 24 matching lines @@
     matcher = re.compile('^.*$')
 
   neg_matcher = re.compile(
       '^%s$' % '|'.join('(?:%s)' % glob.fnmatch.translate(g[1:])
                         for g in globs if g[0] == '-'))
 
   def generate_tests():
     paths_seen = set()
     seen_tests = False
     try:
-      for root_test in gen():
+      with cover_ctx:
+        gen_inst = gen()
+
+      while not kill_switch.is_set():
+        with cover_ctx:
+          root_test = next(gen_inst)
+
         if kill_switch.is_set():
           break
 
         ok_tests = []
 
         if isinstance(root_test, MultiTest):
           subtests = root_test.tests
         else:
           subtests = [root_test]
 
@@ skipping 14 matching lines @@
             name = subtest.name
             if not neg_matcher.match(name) and matcher.match(name):
               ok_tests.append(subtest)
 
         if ok_tests:
           seen_tests = True
           yield root_test.restrict(ok_tests)
 
       if not seen_tests:
         result_queue.put_nowait(NoMatchingTestsError())
+    except StopIteration:
+      pass
     except KeyboardInterrupt:
       pass
     finally:
       for _ in xrange(opts.jobs):
         test_queue.put_nowait(None)
 
 
   next_stage = (result_queue if opts.handler.SKIP_RUNLOOP else test_queue)
-  with cover_ctx:
-    opts.handler.gen_stage_loop(opts, generate_tests(), next_stage.put_nowait,
-                                result_queue.put_nowait)
+  opts.handler.gen_stage_loop(opts, generate_tests(), next_stage.put_nowait,
+                              result_queue.put_nowait)
 
 
 def run_loop_process(test_queue, result_queue, opts, kill_switch, cover_ctx):
   """Consume `Test` instances from |test_queue|, run them, and yield the results
   into opts.run_stage_loop().
 
   Generates coverage data as a side-effect.
+
   @type test_queue: multiprocessing.Queue()
   @type result_queue: multiprocessing.Queue()
   @type opts: argparse.Namespace
   @type kill_switch: multiprocessing.Event()
   @type cover_ctx: cover.CoverageContext().create_subprocess_context()
   """
   logstream = ResetableStringIO()
   logger = logging.getLogger()
   logger.setLevel(logging.DEBUG)
   shandler = logging.StreamHandler(logstream)
   shandler.setFormatter(
       logging.Formatter('%(levelname)s: %(message)s'))
   logger.addHandler(shandler)
 
   SKIP = object()
   def process_test(subtest):
     logstream.reset()
-    subresult = subtest.run()
+    with cover_ctx(include=subtest.coverage_includes()):
+      subresult = subtest.run()
     if isinstance(subresult, TestError):
       result_queue.put_nowait(subresult)
       return SKIP
     elif not isinstance(subresult, Result):
       result_queue.put_nowait(
           TestError(
               subtest,
               'Got non-Result instance from test: %r' % subresult))
       return SKIP
     return subresult
@@ skipping 12 matching lines @@
           for subtest, subresult in test.process(process_test):
             if subresult is not SKIP:
               yield subtest, subresult, logstream.getvalue().splitlines()
         except Exception:
           result_queue.put_nowait(
               TestError(test, traceback.format_exc(),
                         logstream.getvalue().splitlines()))
     except KeyboardInterrupt:
       pass
 
-  with cover_ctx:
-    opts.handler.run_stage_loop(opts, generate_tests_results(),
-                                result_queue.put_nowait)
+  opts.handler.run_stage_loop(opts, generate_tests_results(),
+                              result_queue.put_nowait)
 
 
 def result_loop(test_gen, cover_ctx, opts):
   kill_switch = multiprocessing.Event()
   def handle_killswitch(*_):
     kill_switch.set()
     # Reset the signal to DFL so that double ctrl-C kills us for sure.
     signal.signal(signal.SIGINT, signal.SIG_DFL)
     signal.signal(signal.SIGTERM, signal.SIG_DFL)
   signal.signal(signal.SIGINT, handle_killswitch)
   signal.signal(signal.SIGTERM, handle_killswitch)
 
   test_queue = multiprocessing.Queue()
   result_queue = multiprocessing.Queue()
 
+  gen_cover_ctx = cover_ctx
+  if cover_ctx.enabled:
+    gen_cover_ctx = cover_ctx(include=util.get_cover_list(test_gen))
+
   test_gen_args = (
-      test_gen, test_queue, result_queue, opts, kill_switch, cover_ctx)
+      test_gen, test_queue, result_queue, opts, kill_switch, gen_cover_ctx)
 
   procs = []
   if opts.handler.SKIP_RUNLOOP:
     gen_loop_process(*test_gen_args)
   else:
     procs = [multiprocessing.Process(
         target=gen_loop_process, args=test_gen_args)]
 
     procs += [
         multiprocessing.Process(
@@ skipping 33 matching lines @@
   except ResultStageAbort:
     pass
 
   for p in procs:
     p.join()
 
   if not kill_switch.is_set() and not result_queue.empty():
     error = True
 
   return error, kill_switch.is_set()