You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
339 lines
13 KiB
339 lines
13 KiB
#!/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 = "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("target", "common",
|
|
"obj")
|
|
|
|
def __init__(self, adb_interface):
|
|
self._root_path = android_build.GetTop()
|
|
self._out_path = android_build.GetOut()
|
|
self._output_root_path = os.path.join(self._out_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_out_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._out_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._out_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()
|