Handle missing EMMA files.

build/android/emma_coverage_stats.py

 #!/usr/bin/python
 # Copyright 2015 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.
 
 """Generates incremental code coverage reports for Java code in Chromium.
 
 Usage:
 
-  build/android/coverage.py -v --out <output file path> --emma-dir
+  build/android/emma_coverage_stats.py -v --out <output file path> --emma-dir
     <EMMA file directory> --lines-for-coverage-file
     <path to file containing lines for coverage>
 
   Creates a JSON representation of the overall and file coverage stats and saves
   this information to the specified output file.
 """
 
 import argparse
 import collections
 import json
@@ skipping 228 matching lines @@
 
     Returns:
       A dict containing coverage stats for the given dict of files and lines.
         Contains absolute coverage stats for each file, coverage stats for each
         file's lines specified in |lines_for_coverage|, line by line coverage
         for each file, and overall coverage stats for the lines specified in
         |lines_for_coverage|.
     """
     file_coverage = {}
     for file_path, line_numbers in lines_for_coverage.iteritems():
-      file_coverage[file_path] = self.GetCoverageDictForFile(
-          file_path, line_numbers)
+      if file_path in self._source_to_emma:
+        file_coverage[file_path] = self.GetCoverageDictForFile(
+            file_path, line_numbers)
+      else:
+        logging.warning(
+            'No code coverage data for %s, skipping.', file_path)
 
     covered_statuses = [s['incremental'] for s in file_coverage.itervalues()]
     num_covered_lines = sum(s['covered'] for s in covered_statuses)
     num_total_lines = sum(s['total'] for s in covered_statuses)
     return {
       'files': file_coverage,
       'patch': {
         'incremental': {
           'covered': num_covered_lines,
           'total': num_total_lines
         }
       }
     }
 
   def GetCoverageDictForFile(self, file_path, line_numbers):
     """Returns a dict containing detailed coverage info for the given file.
 
     Args:
       file_path: The path to the Java source file that we want to create the
         coverage dict for.
       line_numbers: A list of integer line numbers to retrieve additional stats
         for.
 
     Returns:
       A dict containing absolute, incremental, and line by line coverage for
         a file.
     """
-    total_line_coverage = self._GetLineCoverageForFile(file_path)
+    emma_file = self._source_to_emma[file_path]

[mikecase (-- gone --), 2015/08/17 18:53:57]

nit: This will get a key error if file_path is not in self._source_to_emma which
could create some confusion in the future.

I would either...
(1) Add to the documentation for Args:file_path that this file must have
coverage info generated for it.

Or...
(2) Just return None is file_path is not in self._source_to_emma in this
function. If you do this you might want to change your logic where you call this
to something like....

for file_path, line_numbers in lines_for_coverage.iteritems():
  coverage_dict = self.GetcoverageDictForFile(file_path, line_number)
  if coverage_dict:
    file_coverage[file_path] = coverage_dict

[estevenson1, 2015/08/17 19:06:17]

Done. Added a test for it as well.

+    total_line_coverage = self._emma_parser.GetLineCoverage(emma_file)
     incremental_line_coverage = [line for line in total_line_coverage
                                  if line.lineno in line_numbers]
     line_by_line_coverage = [
       {
         'line': line.source,
         'coverage': line.covered_status,
         'changed': line.lineno in line_numbers,
       }
       for line in total_line_coverage
     ]
@@ skipping 32 matching lines @@
       if status == NOT_EXECUTABLE:
         continue
       covered_status_totals[status] += 1
       if status == PARTIALLY_COVERED:
         partially_covered_sum += line.fractional_line_coverage
 
     total_covered = covered_status_totals[COVERED] + partially_covered_sum
     total_lines = sum(covered_status_totals.values())
     return total_covered, total_lines
 
-  def _GetLineCoverageForFile(self, file_path):
-    """Gets a list of LineCoverage objects corresponding to the given file path.
-
-    Args:
-      file_path: String representing the path to the Java source file.
-
-    Returns:
-      A list of LineCoverage objects, or None if there is no EMMA file
-        for the given Java source file.
-    """
-    if file_path in self._source_to_emma:
-      emma_file = self._source_to_emma[file_path]
-      return self._emma_parser.GetLineCoverage(emma_file)
-    else:
-      logging.warning(
-          'No code coverage data for %s, skipping.', file_path)
-      return None
-
   def _GetSourceFileToEmmaFileDict(self, files):
     """Gets a dict used to correlate Java source files with EMMA HTML files.
 
     This method gathers the information needed to correlate EMMA HTML
     files with Java source files. EMMA XML and plain text reports do not provide
     line by line coverage data, so HTML reports must be used instead.
     Unfortunately, the HTML files that are created are given garbage names
     (i.e 1.html) so we need to manually correlate EMMA HTML files
     with the original Java source files.
 
@@ skipping 12 matching lines @@
         source_to_package[file_path] = package
       else:
         logging.warning("Skipping %s because it doesn\'t have a package "
                         "statement.", file_path)
 
     # Maps package names to EMMA report HTML files.
     # Example: org.chromium.file.java -> out/coverage/1a.html.
     package_to_emma = self._emma_parser.GetPackageNameToEmmaFileDict()
     # Finally, we have a dict mapping Java file paths to EMMA report files.
     # Example: /usr/code/file.java -> out/coverage/1a.html.
-    source_to_emma = {source: package_to_emma.get(package)
-                      for source, package in source_to_package.iteritems()}
+    source_to_emma = {source: package_to_emma[package]
+                      for source, package in source_to_package.iteritems()
+                      if  package in package_to_emma}
     return source_to_emma
 
   @staticmethod
   def NeedsCoverage(file_path):
     """Checks to see if the file needs to be analyzed for code coverage.
 
     Args:
       file_path: A string representing path to the file.
 
     Returns:
@@ skipping 37 matching lines @@
   Args:
     line_coverage_file: The path to a file which contains a dict mapping file
       names to lists of line numbers. Example: {file1: [1, 2, 3], ...} means
       that we should compute coverage information on lines 1 - 3 for file1.
     out_file_path: A string representing the location to write the JSON report.
     coverage_dir: A string representing the file path where the EMMA
       HTML coverage files are located (i.e. folder where index.html is located).
   """
   with open(line_coverage_file) as f:
     potential_files_for_coverage = json.load(f)
+
   files_for_coverage = {f: lines
                         for f, lines in potential_files_for_coverage.iteritems()
                         if _EmmaCoverageStats.NeedsCoverage(f)}
 
   coverage_results = {}
   if files_for_coverage:
     code_coverage = _EmmaCoverageStats(coverage_dir, files_for_coverage.keys())
     coverage_results = code_coverage.GetCoverageDict(
         files_for_coverage)
   else:
@@ skipping 16 matching lines @@
                          'code for which coverage information is desired.')
   argparser.add_argument('-v', '--verbose', action='count',
                          help='Print verbose log information.')
   args = argparser.parse_args()
   run_tests_helper.SetLogLevel(args.verbose)
   GenerateCoverageReport(args.lines_for_coverage_file, args.out, args.emma_dir)
 
 
 if __name__ == '__main__':
   sys.exit(main())