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.
175 lines
6.6 KiB
175 lines
6.6 KiB
<?xml version="1.0" encoding="UTF-8" ?>
|
|
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
|
|
<html xmlns="http://www.w3.org/1999/xhtml" lang="en">
|
|
<head>
|
|
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
|
|
<link rel="stylesheet" href="resources/doc.css" charset="UTF-8" type="text/css" />
|
|
<link rel="shortcut icon" href="resources/report.gif" type="image/gif" />
|
|
<title>JaCoCo - Coverage Counter</title>
|
|
</head>
|
|
<body>
|
|
|
|
<div class="breadcrumb">
|
|
<a href="../index.html" class="el_report">JaCoCo</a> >
|
|
<a href="index.html" class="el_group">Documentation</a> >
|
|
<span class="el_source">Coverage Counters</span>
|
|
</div>
|
|
<div id="content">
|
|
|
|
<h1>Coverage Counters</h1>
|
|
|
|
<p>
|
|
JaCoCo uses a set of different counters to calculate coverage metrics. All
|
|
these counters are derived from information contained in Java class files
|
|
which basically are Java byte code instructions and debug information
|
|
optionally embedded in class files. This approach allows efficient on-the-fly
|
|
instrumentation and analysis of applications even when no source code is
|
|
available. In most cases the collected information can be mapped back to
|
|
source code and visualized down to line level granularity. Anyhow there are
|
|
limitations to this approach. The class files have to be compiled with debug
|
|
information to calculate line level coverage and provide source highlighting.
|
|
Not all Java language constructs can be directly compiled to corresponding
|
|
byte code. In such cases the Java compiler creates so called <i>synthetic</i>
|
|
code which sometimes results in unexpected code coverage results.
|
|
</p>
|
|
|
|
<h2>Instructions (C0 Coverage)</h2>
|
|
|
|
<p>
|
|
The smallest unit JaCoCo counts are single Java byte code instructions.
|
|
<i>Instruction coverage</i> provides information about the amount of code that
|
|
has been executed or missed. This metric is completely independent from source
|
|
formatting and always available, even in absence of debug information in the
|
|
class files.
|
|
</p>
|
|
|
|
<h2>Branches (C1 Coverage)</h2>
|
|
|
|
<p>
|
|
JaCoCo also calculates <i>branch coverage</i> for all <code>if</code> and
|
|
<code>switch</code> statements. This metric counts the total number of such
|
|
branches in a method and determines the number of executed or missed branches.
|
|
Branch coverage is always available, even in absence of debug information in
|
|
the class files. Note that exception handling is not considered as branches
|
|
in the context of this counter definition.
|
|
</p>
|
|
|
|
<p>
|
|
If the class files haven been compiled with debug information decision points
|
|
can be mapped to source lines and highlighted accordingly:
|
|
</p>
|
|
|
|
<ul>
|
|
<li>No coverage: No branches in the line has been executed (red diamond)</li>
|
|
<li>Partial coverage: Only a part of the branches in the line have been
|
|
executed (yellow diamond)</li>
|
|
<li>Full coverage: All branches in the line have been executed (green diamond)</li>
|
|
</ul>
|
|
|
|
<h2>Cyclomatic Complexity</h2>
|
|
|
|
<p>
|
|
JaCoCo also calculates cyclomatic complexity for each non-abstract method and
|
|
summarizes complexity for classes, packages and groups. According to its
|
|
definition by
|
|
<a href="http://hissa.nist.gov/HHRFdata/Artifacts/ITLdoc/235/title.htm">McCabe1996</a>
|
|
cyclomatic complexity is the minimum number of paths that can, in (linear)
|
|
combination, generate all possible paths through a method. Thus the
|
|
complexity value can serve as an indication for the number of unit test cases
|
|
to fully cover a certain piece of software. Complexity figures can always be
|
|
calculated, even in absence of debug information in the class files.
|
|
</p>
|
|
|
|
<p>
|
|
The formal definition of the cyclomatic complexity v(G) is based on the
|
|
representation of a method's control flow graph as a directed graph:
|
|
</p>
|
|
|
|
<blockquote>
|
|
<p>
|
|
v(G) = E - N + 2
|
|
</p>
|
|
</blockquote>
|
|
|
|
<p>
|
|
Where E is the number of edges and N the number of nodes. JaCoCo calculates
|
|
cyclomatic complexity of a method with the following equivalent equation based
|
|
on the number of branches (B) and the number of decision points (D):
|
|
</p>
|
|
|
|
<blockquote>
|
|
<p>
|
|
v(G) = B - D + 1
|
|
</p>
|
|
</blockquote>
|
|
|
|
<p>
|
|
Based on the coverage status of each branch JaCoCo also calculates covered and
|
|
missed complexity for each method. Missed complexity again is an indication
|
|
for the number of test cases missing to fully cover a module. Note that as
|
|
JaCoCo does not consider exception handling as branches try/catch blocks will
|
|
also not increase complexity.
|
|
</p>
|
|
|
|
<h2>Lines</h2>
|
|
|
|
<p>
|
|
For all class files that have been compiled with debug information, coverage
|
|
information for individual lines can be calculated. A source line is
|
|
considered executed when at least one instruction that is assigned to this
|
|
line has been executed.
|
|
</p>
|
|
|
|
<p>
|
|
Due to the fact that a single line typically compiles to multiple byte code
|
|
instructions the source code highlighting shows three different status for
|
|
each line containing source code:
|
|
</p>
|
|
|
|
<ul>
|
|
<li>No coverage: No instruction in the line has been executed (red
|
|
background)</li>
|
|
<li>Partial coverage: Only a part of the instruction in the line have been
|
|
executed (yellow background)</li>
|
|
<li>Full coverage: All instructions in the line have been executed (green
|
|
background)</li>
|
|
</ul>
|
|
|
|
<p>
|
|
Depending on source formatting a single line of a source code may refer to
|
|
multiple methods or multiple classes. Therefore the line count of methods
|
|
cannot be simply added to obtain the total number for the containing class.
|
|
The same holds true for the lines of multiple classes within a single source
|
|
file. JaCoCo calculates line coverage for classes and source file based on the
|
|
actual source lines covered.
|
|
</p>
|
|
|
|
<h2>Methods</h2>
|
|
|
|
<p>
|
|
Each non-abstract method contains at least one instruction. A method is
|
|
considered as executed when at least one instruction has been executed. As
|
|
JaCoCo works on byte code level also constructors and static initializers are
|
|
counted as methods. Some of these methods may not have a direct correspondence
|
|
in Java source code, like implicit and thus generated default constructors or
|
|
initializers for constants.
|
|
</p>
|
|
|
|
<h2>Classes</h2>
|
|
|
|
<p>
|
|
A class is considered as executed when at least one of its methods has been
|
|
executed. Note that JaCoCo considers constructors as well as static
|
|
initializers as methods. As Java interface types may contain static
|
|
initializers such interfaces are also considered as executable classes.
|
|
</p>
|
|
|
|
</div>
|
|
<div class="footer">
|
|
<span class="right"><a href="@jacoco.home.url@">JaCoCo</a> @qualified.bundle.version@</span>
|
|
<a href="license.html">Copyright</a> © @copyright.years@ Mountainminds GmbH & Co. KG and Contributors
|
|
</div>
|
|
|
|
</body>
|
|
</html>
|