Complexity

Name	Key	Description
Complexity	complexity	It is the cyclomatic complexity, also known as McCabe metric. Whenever the control flow of a method splits, the complexity counter gets incremented by one. Each method has a minimum value of 1 per default. More details
Complexity /class	class_complexity	Average complexity by class.
Complexity /file	file_complexity	Average complexity by file.
Complexity /method	function_complexity	Average complexity by method.

Design

Name	Key	Description
Afferent couplings	ca	A class afferent couplings is a measure of how many other classes use the specific class.
Depth in Tree	dit	The depth of inheritance tree (DIT) metric provides for each class a measure of the inheritance levels from the object hierarchy top. More details
Efferent couplings	ce	A class efferent couplings is a measure of how many different classes are used by the specific class.
File cycles	file_cycles	Minimal number of file cycles detected inside a package to be able to identify all undesired dependencies.
File edges weight	file_edges_weight	Number of file dependencies inside a package.
File dependencies to cut	package_tangles	Number of file dependencies to cut in order to remove all cycles between packages.
File tangle	file_tangles	File tangle = Suspect file dependencies
File tangle index	file_tangle_index	File tangle index = 2 * (File tangle / File edges weight) * 100.
LCOM4	lcom4	Lack of cohesion of methods. See LCOM4 documentation page.
Number of children	noc	The number of children of a class is the number of direct and indirect descendants of this class.
Package cycles	package_cycles	Minimal number of package cycles detected to be able to identify all undesired dependencies.
Package dependencies to cut	package_feedback_edges	Number of package dependencies to cut in order to remove all cycles between packages.
Package tangle index	package_tangle_index	Level of tangle of the packages. Best value (0%) means that there is no cycle and worst value (100%) means that packages are really tangled. This metric is computed with the following formula: 2 * (File dependencies to cut / Number of file dependencies between packages) * 100.
Response for class	rfc	See RFC documentation page.
Package edges weight	package_edges_weight	Number of file dependencies between packages.
Suspect file dependencies	file_feedback_edges	File dependencies to cut in order to remove cycles between files inside a package. Note that cycles between files inside a package does not always mean a bad quality architecture.
Suspect LCOM4 density	suspect_lcom4_density	Density of files having a LCOM4 density greater than 1.

Documentation

Name	Key	Description
Blank comments	comment_blank_lines	Number of non-significant comment lines (empty comment line, comment line containing only special characters, etc.).
Comment lines	comment_lines	Number of lines containing a comment. More details
Comments (%)	comment_lines_density	Density of comment lines = Comment lines / (Lines of code + Comment lines) * 100 With such a formula: 50% means that the number of lines of code equals the number of comment lines 100% means that the file only contains comment lines
Comments in Procedure Divisions		Comments in Procedure divisions (Cobol only)
Public documented API (%)	public_documented_api_density	Density of public documented API = (Public API - Public undocumented API) / Public API * 100
Public undocumented API	public_undocumented_api	Public API without comments header.

Duplications

Name	Key	Description
Duplicated blocks	duplicated_blocks	Number of duplicated blocks of lines.
Duplicated files	duplicated_files	Number of files involved in a duplication.
Duplicated lines	duplicated_lines	Number of lines involved in a duplication.
Duplicated lines (%)	duplicated_lines_density	Density of duplication = Duplicated lines / Lines * 100

Reviews

Name	Key	Description
Active reviews	active_reviews	Number of active reviews (status not closed).
False-positive reviews	false_positive_reviews	Number fo false-positive reviews.
New unreviewed violations	new_unreviewed_violations	Number of new unreviewed violations.
Unassigned reviews	unassigned_reviews	Number of unassigned reviews.
Unplanned reviews	unplanned_reviews	Number of unplanned reviews (not associated with an action plan).
Unreviewed violations	unreviewed_violations	Number of unreviewed violations.

Rules

Name	Key	Description
New violations	new_violations	Number of new violations.
New xxxxx violations	new_xxxxx_violations	Number of new violations with severity xxxxx, xxxxx being Blocker, Critical, Major, Minor or Info.
Violations	violations	Number of violations.
xxxxx violations	xxxxx_violations	Number of violations with severity xxxxx, xxxxx being Blocker, Critical, Major, Minor or Info.
Weighted violations	weighted_violations	Sum of the violations weighted by the coefficient associated to each severity (Sum(xxxxx_violations * xxxxx_weight)). To set the weight of each severity, log in as an administrator, go to Settings > Configuration > General Settings > General and set the Rules weight property.
Rules compliance	violations_density	Rules compliance index (RCI) = 100 - (Weighted violations / Lines of code * 100)

Size

Metric	Key	Description
Accessors	accessors	Number of getter and setter methods used to get (reading) or set (writing) a class property. More details
Classes	classes	Number of classes (including nested classes, interfaces, enums and annotations).
Directories	directories	Number of directories.
Files	files	Number of files.
Generated Lines	generated_lines	Number of lines generated by Cobol code generators like CA-Telon.
Generated lines of code	generated_ncloc	Number of lines of code generated by Cobol code generators like CA-Telon.
Inside Control Flow Statements	cobol_inside_ctrlflow_statements	Number of inside (intra program) control flow statements (GOBACK, STOP RUN, DISPLAY, CONTINUE, EXIT, RETURN, PERFORM paragraph1 THRU paragraph2). Cobol only.
Lines	lines	Number of physical lines (number of carriage returns).
Lines of code	ncloc	Number of physical lines that contain at least one character which is neither a whitespace or a tabulation or part of a comment. More details
LOCs in Data Divisions	cobol_data_division_ncloc	Number of lines of code in Data divisions. Generated lines of code are excluded. Cobol only.
LOCs in Procedure Divisions	cobol_procedure_division_ncloc	Number of lines of code in Procedure divisions. Generated lines of code are excluded. Cobol only.
Methods	functions	Number of methods/functions. More details
Outside Control Flow Statements	cobol_outside_ctrlflow_statements	Number of outside (inter programs) control flow statements (CALL, EXEC CICS LINK, EXEC CICS XCTL, EXEC SQL, EXEC CICS RETURN). Cobol only.
Packages	packages	Number of packages.
Projects	projects	Number of projects in a view.
Public API	public_api	Number of public Classes + number of public Methods + number of public Properties M ore details
Statements	statements	Number of statements. More details

Tests

Metric

Key

Description

Branch coverage

branch_coverage

On each line of code containing some boolean expressions, the branch coverage simply answers the following question: 'Has each boolean expression been evaluated both to true and false?'. This is the density of possible branches in flow control structures that have been followed during unit tests execution.

Branch coverage = (CT + CF) / (2*B)

where

CT = branches that have been evaluated to 'true' at least once
CF = branches that have been evaluated to 'false' at least once

B = total number of branches

Coverage

coverage

It is a mix of Line coverage and Branch coverage. Its goal is to provide an even more accurate answer to the following question: 'How much of the source code has been covered by the unit tests?".

Coverage = (CT + CF + LC)/(2*B + EL)

where

CT = branches that have been evaluated to 'true' at least once
CF = branches that have been evaluated to 'false' at least once
LC = covered lines = lines_to_cover - uncovered_lines

B = total number of branches
EL = total number of executable lines (lines_to_cover)

Line coverage

line_coverage

On a given line of code, Line coverage simply answers the following question: 'Has this line of code been executed during the execution of the unit tests?'. It is the density of covered lines by unit tests:

Line coverage = LC / EL

where

LC = covered lines (lines_to_cover - uncovered_lines)
EL = total number of executable lines (lines_to_cover)

Lines to cover

lines_to_cover

Number of lines of code which could be covered by unit tests (for example, blank lines or full comments lines are not considered as lines to cover).

New branch coverage

new_branch_coverage

Identical to Branch coverage but restricted to new / updated source code.

New coverage

new_coverage

Identical to Coverage but restricted to new / updated source code.

New line coverage

new_line_coverage

Identical to Line coverage but restricted to new / updated source code.

New lines to cover

new_lines_to_cover

Identical to Lines to cover but restricted to new / updated source code.

New uncovered lines

new_uncovered_lines

Identical to Uncovered lines but restricted to new / updated source code.

Skipped unit tests

skipped_tests

Number of skipped unit tests.

Uncovered branches

uncovered_branches

Number of branches which are not covered by unit tests.

Uncovered lines

uncovered_lines

Number of lines of code which are not covered by unit tests.

Unit tests

tests

Number of unit tests.

Unit tests duration

test_execution_time

Time required to execute all the unit tests.

Unit test errors

test_errors

Number of unit tests that have failed.

Unit test failures

test_failures

Number of unit tests that have failed with an unexpected exception.

Unit test success density (%)

test_success_density

Test success density = (Unit tests - (Unit test errors + Unit test failures)) / Unit tests * 100

The same kinds of metrics exist for Integration tests coverage and Overall tests coverage (Units tests + Integration tests).

Metrics on tests execution does not exist for Integration tests and Overall tests.