diff options
Diffstat (limited to 'testrunner/coverage/coverage.py')
| -rwxr-xr-x | testrunner/coverage/coverage.py | 337 |
1 files changed, 337 insertions, 0 deletions
diff --git a/testrunner/coverage/coverage.py b/testrunner/coverage/coverage.py new file mode 100755 index 000000000..570527d56 --- /dev/null +++ b/testrunner/coverage/coverage.py @@ -0,0 +1,337 @@ +#!/usr/bin/python2.4 +# +# +# Copyright 2008, The Android Open Source Project +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Utilities for generating code coverage reports for Android tests.""" + +# Python imports +import glob +import optparse +import os + +# local imports +import android_build +import android_mk +import coverage_target +import coverage_targets +import errors +import logger +import run_command + + +class CoverageGenerator(object): + """Helper utility for obtaining code coverage results on Android. + + Intended to simplify the process of building,running, and generating code + coverage results for a pre-defined set of tests and targets + """ + + # path to EMMA host jar, relative to Android build root + _EMMA_JAR = os.path.join("external", "emma", "lib", "emma.jar") + _TEST_COVERAGE_EXT = "ec" + # root path of generated coverage report files, relative to Android build root + _COVERAGE_REPORT_PATH = os.path.join("out", "emma") + _TARGET_DEF_FILE = "coverage_targets.xml" + _CORE_TARGET_PATH = os.path.join("development", "testrunner", + _TARGET_DEF_FILE) + # vendor glob file path patterns to tests, relative to android + # build root + _VENDOR_TARGET_PATH = os.path.join("vendor", "*", "tests", "testinfo", + _TARGET_DEF_FILE) + + # path to root of target build intermediates + _TARGET_INTERMEDIATES_BASE_PATH = os.path.join("out", "target", "common", + "obj") + + def __init__(self, adb_interface): + self._root_path = android_build.GetTop() + self._output_root_path = os.path.join(self._root_path, + self._COVERAGE_REPORT_PATH) + self._emma_jar_path = os.path.join(self._root_path, self._EMMA_JAR) + self._adb = adb_interface + self._targets_manifest = self._ReadTargets() + + def ExtractReport(self, + test_suite_name, + target, + device_coverage_path, + output_path=None, + test_qualifier=None): + """Extract runtime coverage data and generate code coverage report. + + Assumes test has just been executed. + Args: + test_suite_name: name of TestSuite to generate coverage data for + target: the CoverageTarget to use as basis for coverage calculation + device_coverage_path: location of coverage file on device + output_path: path to place output files in. If None will use + <android_root_path>/<_COVERAGE_REPORT_PATH>/<target>/<test[-qualifier]> + test_qualifier: designates mode test was run with. e.g size=small. + If not None, this will be used to customize output_path as shown above. + + Returns: + absolute file path string of generated html report file. + """ + if output_path is None: + report_name = test_suite_name + if test_qualifier: + report_name = report_name + "-" + test_qualifier + output_path = os.path.join(self._root_path, + self._COVERAGE_REPORT_PATH, + target.GetName(), + report_name) + + coverage_local_name = "%s.%s" % (report_name, + self._TEST_COVERAGE_EXT) + coverage_local_path = os.path.join(output_path, + coverage_local_name) + if self._adb.Pull(device_coverage_path, coverage_local_path): + + report_path = os.path.join(output_path, + report_name) + return self._GenerateReport(report_path, coverage_local_path, [target], + do_src=True) + return None + + def _GenerateReport(self, report_path, coverage_file_path, targets, + do_src=True): + """Generate the code coverage report. + + Args: + report_path: absolute file path of output file, without extension + coverage_file_path: absolute file path of code coverage result file + targets: list of CoverageTargets to use as base for code coverage + measurement. + do_src: True if generate coverage report with source linked in. + Note this will increase size of generated report. + + Returns: + absolute file path to generated report file. + """ + input_metadatas = self._GatherMetadatas(targets) + + if do_src: + src_arg = self._GatherSrcs(targets) + else: + src_arg = "" + + report_file = "%s.html" % report_path + cmd1 = ("java -cp %s emma report -r html -in %s %s %s " % + (self._emma_jar_path, coverage_file_path, input_metadatas, src_arg)) + cmd2 = "-Dreport.html.out.file=%s" % report_file + self._RunCmd(cmd1 + cmd2) + return report_file + + def _GatherMetadatas(self, targets): + """Builds the emma input metadata argument from provided targets. + + Args: + targets: list of CoverageTargets + + Returns: + input metadata argument string + """ + input_metadatas = "" + for target in targets: + input_metadata = os.path.join(self._GetBuildIntermediatePath(target), + "coverage.em") + input_metadatas += " -in %s" % input_metadata + return input_metadatas + + def _GetBuildIntermediatePath(self, target): + return os.path.join( + self._root_path, self._TARGET_INTERMEDIATES_BASE_PATH, target.GetType(), + "%s_intermediates" % target.GetName()) + + def _GatherSrcs(self, targets): + """Builds the emma input source path arguments from provided targets. + + Args: + targets: list of CoverageTargets + Returns: + source path arguments string + """ + src_list = [] + for target in targets: + target_srcs = target.GetPaths() + for path in target_srcs: + src_list.append("-sp %s" % os.path.join(self._root_path, path)) + return " ".join(src_list) + + def _MergeFiles(self, input_paths, dest_path): + """Merges a set of emma coverage files into a consolidated file. + + Args: + input_paths: list of string absolute coverage file paths to merge + dest_path: absolute file path of destination file + """ + input_list = [] + for input_path in input_paths: + input_list.append("-in %s" % input_path) + input_args = " ".join(input_list) + self._RunCmd("java -cp %s emma merge %s -out %s" % (self._emma_jar_path, + input_args, dest_path)) + + def _RunCmd(self, cmd): + """Runs and logs the given os command.""" + run_command.RunCommand(cmd, return_output=False) + + def _CombineTargetCoverage(self): + """Combines all target mode code coverage results. + + Will find all code coverage data files in direct sub-directories of + self._output_root_path, and combine them into a single coverage report. + Generated report is placed at self._output_root_path/android.html + """ + coverage_files = self._FindCoverageFiles(self._output_root_path) + combined_coverage = os.path.join(self._output_root_path, + "android.%s" % self._TEST_COVERAGE_EXT) + self._MergeFiles(coverage_files, combined_coverage) + report_path = os.path.join(self._output_root_path, "android") + # don't link to source, to limit file size + self._GenerateReport(report_path, combined_coverage, + self._targets_manifest.GetTargets(), do_src=False) + + def _CombineTestCoverage(self): + """Consolidates code coverage results for all target result directories.""" + target_dirs = os.listdir(self._output_root_path) + for target_name in target_dirs: + output_path = os.path.join(self._output_root_path, target_name) + target = self._targets_manifest.GetTarget(target_name) + if os.path.isdir(output_path) and target is not None: + coverage_files = self._FindCoverageFiles(output_path) + combined_coverage = os.path.join(output_path, "%s.%s" % + (target_name, self._TEST_COVERAGE_EXT)) + self._MergeFiles(coverage_files, combined_coverage) + report_path = os.path.join(output_path, target_name) + self._GenerateReport(report_path, combined_coverage, [target]) + else: + logger.Log("%s is not a valid target directory, skipping" % output_path) + + def _FindCoverageFiles(self, root_path): + """Finds all files in <root_path>/*/*.<_TEST_COVERAGE_EXT>. + + Args: + root_path: absolute file path string to search from + Returns: + list of absolute file path strings of coverage files + """ + file_pattern = os.path.join(root_path, "*", "*.%s" % + self._TEST_COVERAGE_EXT) + coverage_files = glob.glob(file_pattern) + return coverage_files + + def _ReadTargets(self): + """Parses the set of coverage target data. + + Returns: + a CoverageTargets object that contains set of parsed targets. + Raises: + AbortError if a fatal error occurred when parsing the target files. + """ + core_target_path = os.path.join(self._root_path, self._CORE_TARGET_PATH) + try: + targets = coverage_targets.CoverageTargets() + targets.Parse(core_target_path) + vendor_targets_pattern = os.path.join(self._root_path, + self._VENDOR_TARGET_PATH) + target_file_paths = glob.glob(vendor_targets_pattern) + for target_file_path in target_file_paths: + targets.Parse(target_file_path) + return targets + except errors.ParseError: + raise errors.AbortError + + def TidyOutput(self): + """Runs tidy on all generated html files. + + This is needed to the html files can be displayed cleanly on a web server. + Assumes tidy is on current PATH. + """ + logger.Log("Tidying output files") + self._TidyDir(self._output_root_path) + + def _TidyDir(self, dir_path): + """Recursively tidy all html files in given dir_path.""" + html_file_pattern = os.path.join(dir_path, "*.html") + html_files_iter = glob.glob(html_file_pattern) + for html_file_path in html_files_iter: + os.system("tidy -m -errors -quiet %s" % html_file_path) + sub_dirs = os.listdir(dir_path) + for sub_dir_name in sub_dirs: + sub_dir_path = os.path.join(dir_path, sub_dir_name) + if os.path.isdir(sub_dir_path): + self._TidyDir(sub_dir_path) + + def CombineCoverage(self): + """Create combined coverage reports for all targets and tests.""" + self._CombineTestCoverage() + self._CombineTargetCoverage() + + def GetCoverageTarget(self, name): + """Find the CoverageTarget for given name""" + target = self._targets_manifest.GetTarget(name) + if target is None: + msg = ["Error: test references undefined target %s." % name] + msg.append(" Ensure target is defined in %s" % self._TARGET_DEF_FILE) + raise errors.AbortError(msg) + return target + + def GetCoverageTargetForPath(self, path): + """Find the CoverageTarget for given file system path""" + android_mk_path = os.path.join(path, "Android.mk") + if os.path.exists(android_mk_path): + android_mk_parser = android_mk.CreateAndroidMK(path) + target = coverage_target.CoverageTarget() + target.SetBuildPath(os.path.join(path, "src")) + target.SetName(android_mk_parser.GetVariable(android_mk_parser.PACKAGE_NAME)) + target.SetType("APPS") + return target + else: + msg = "No Android.mk found at %s" % path + raise errors.AbortError(msg) + + +def EnableCoverageBuild(): + """Enable building an Android target with code coverage instrumentation.""" + os.environ["EMMA_INSTRUMENT"] = "true" + +def Run(): + """Does coverage operations based on command line args.""" + # TODO: do we want to support combining coverage for a single target + + try: + parser = optparse.OptionParser(usage="usage: %prog --combine-coverage") + parser.add_option( + "-c", "--combine-coverage", dest="combine_coverage", default=False, + action="store_true", help="Combine coverage results stored given " + "android root path") + parser.add_option( + "-t", "--tidy", dest="tidy", default=False, action="store_true", + help="Run tidy on all generated html files") + + options, args = parser.parse_args() + + coverage = CoverageGenerator(None) + if options.combine_coverage: + coverage.CombineCoverage() + if options.tidy: + coverage.TidyOutput() + except errors.AbortError: + logger.SilentLog("Exiting due to AbortError") + +if __name__ == "__main__": + Run() |