• 质量管理工具Sonar中名词解释


    Metrics are the heart of Sonar, using Sonar efficiently means perfectly understanding the definition and calculation algorithm of each one.

    Name Key Description
    Physical lines lines Number of carriage returns
    Comment lines comment_lines Number of javadoc, multi-comment and single-comment lines. Empty comment lines like, header file comments (mainly used to define the license) and commented-out lines of code are not included.
    /**
     * This is a javadoc block
     *           <- empty comment line considered as a blank line
     */          <- empty comment line considered as a blank line
    /*
     * This is a multi-comment block
     */
    // This is a single-comment block
    // log("Debug information"); <- commented-out line of code is not a comment line
    Commented-out lines of code commented_out_code_lines Number of commented-out lines of code. Javadoc blocks are not scanned.
    /*
    * someoneCommentMeOutOneDay();
    * nobodyKnowWhatAmISupposedToDo();
    */
    Lines of code ncloc Number of physical lines of code - number of blank lines - number of comment lines - number of header file comments - commented-out lines of code
    Density of comment lines comment_lines_density Number of comment lines / (lines of code + number of comments lines) * 100
    Packages packages Number of packages
    Classes classes Number of classes including nested classes, interfaces, enums and annotations
    Files files Number of analyzed files
    Directories directories Number of analyzed directories
    Accessors accessors Number of getter and setter methods used to get(reading) or set(writing) a class' property .
    // Getters
    public String getName(){
         return this.name;
    }
    public boolean isParent(){
         return this.isParent;
    }
    // Setters
    public void setName(String name){
         this.name = name;
    }
    public void setIsParent(boolean isParent){
         this.isParent = isParent;
    }
    Methods functions Number of Methods without including accessors. A constructor is considered to be a method.
    Public API public_api Number of public classes, public methods (without accessors) and public properties (without public final static ones)
    Public undocumented API public_undocumented_api Number of public API without a Javadoc block
    Density of public documented API public_documented_api_density (Number of public API - Number of undocumented public API) / Number of public API * 100
    Duplicated lines duplicated_lines Number of physical lines touched by a duplication
    Duplicated blocks duplicated_blocks Number of duplicated blocks of lines
    Duplicated files duplicated_files Number of files involved in a duplication of lines
    Density of duplicated lines duplicated_lines_density Duplicated lines / Physical lines * 100
    Statements statements Number of statements as defined in the Java Language Specification but without block definitions. Statements counter gets incremented by one each time an expression, if, else, while, do, for, switch, break, continue, return, throw, synchronized, catch, finally is encountered :
    //
    i = 0;
    if (ok)
    if (exit) {
    if (3 == 4);
    if (4 == 4) { ; }
    } else {
    try{}
    while(true){}
    for(...){}
    ...
    Statements counter is not incremented by a class, method, field, annotation definition or by a package and import declaration.
    Complexity complexity The Cyclomatic Complexity Number is also known as McCabe Metric. It all comes down to simply counting 'if', 'for', 'while' statements etc. in a method. Whenever the control flow of a method splits, the Cyclomatic counter gets incremented by one.
    Each method has a minimum value of 1 per default except accessors which are not considered as method and so don't increment complexity. For each of the following Java keywords/statements this value gets incremented by one:
    if
    for
    while
    case
    catch
    throw
    return (that isn't the last statement of a method)
    &&
    ||
    ?
    Note that else, default, and finally don't increment the CCN value any further. On the other hand, a simple method with a switch statement and a huge block of case statements can have a surprisingly high CCN value (still it has the same value when converting a switch block to an equivalent sequence of if statements).
    For instance the following method has a complexity of 5
    public void process(Car myCar){          <- +1
        if(myCar.isNotMine()){               <- +1
             return;                         <- +1
        }
        car.paint("red");
        car.changeWheel();
        while(car.hasGazol() && car.getDriver().isNotStressed()){   <- +2
             car.drive();
        }
        return;
    }
    Average complexity by method function_complexity Average cyclomatic complexity number by method
    Complexity distribution by method function_complexity_distribution Number of methods for given complexities
    Average complexity by class class_complexity Average cyclomatic complexity by class
    Complexity distribution by class class_complexity_distribution Number of classes for given complexities
    Average complexity by file file_complexity Average cyclomatic complexity by file
    Violations violations Total number of rule violations
    New Violations new_violations Total number of new violations
    xxxxx violations xxxxx_violations Number of violations with severity xxxxx, xxxxx being blocker, critical, major, minor or info
    New xxxxx violations new_xxxxx_violations Number of new 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 at each priority (Sum(xxxxx_violations * xxxxx_weight))
    Rules compliance index violations_density 100 - weighted_violations / Lines of code * 100
    Unit tests tests Number of unit tests
    Unit tests duration test_execution_time Time required to execute unit tests
    Unit test error test_errors Number of unit tests that failed
    Unit test failures test_failures Number of unit tests that failed with an unexpected exception
    Unit test success density test_success_density (Unit tests - (errors + failures))/ Unit tests * 100
    Skipped unit tests skipped_tests Number of skipped unit tests
    Line Coverage line_coverage On a given line of code, line coverage simply answers the question: "Is this line of code executed during unit test execution?". At project level, this is the density of covered lines:
    Line coverage = LC / EL
     
    where
     
    LC - lines covered (lines_to_cover - uncovered_lines)
    EL - total number of executable lines (lines_to_cover)
    New Line Coverage new_line_coverage identical to line_coverage but restricted to new / update source code
    Branch coverage branch_coverage On each line of code containing some boolean expressions, the branch coverage simply answers the question: "Has each boolean expression evaluated both to true and false ?". At project level, this is the density of possible branches in flow control structures that have been followed.
    Branch coverage = (CT + CF) / (2*B)
     
    where
     
    CT - branches that evaluated to "true" at least once
    CF - branches that evaluated to "false" at least once
    (CT + CF = conditions_to_cover - uncovered_conditions)
     
    B - total number of branches (2*B = conditions_to_cover)
    New Branch Coverage new_branch_coverage identical to branch_coverage but restricted to new / update source code
    Coverage coverage Coverage metric is a mix of the two previous line coverage and branch coverage metrics to get an even more accurate answer to the question "how much of a source-code is being executed by your unit tests?".
    The Coverage is calculated with the following formula :
    coverage = (CT + CF + LC)/(2*B + EL)
     
    where
     
    CT - branches that evaluated to "true" at least once
    CF - branches that evaluated to "false" at least once
    LC - lines covered (lines_to_cover - uncovered_lines)
     
    B - total number of branches (2*B = conditions_to_cover)
    EL - total number of executable lines (lines_to_cover)
    New Coverage new_coverage identical to coverage but restricted to new / update source code
    Conditions to Cover conditions_to_cover Total number of conditions which could be covered by unit tests.
    New Conditions to Cover new_conditions_to_cover identical to conditions_to_cover but restricted to new / update source code
    Lines to Cover lines_to_cover Total number of lines of code which could be covered by unit tests.
    New Lines to Cover new_lines_to_cover identical to lines_to_cover but restricted to new / update source code
    Uncovered Conditions uncovered_conditions Total number of conditions which are not covered by unit tests.
    New Uncovered Conditions new_uncovered_conditions identical to uncovered_conditions but restricted to new / update source code
    Uncovered Lines uncovered_lines Total number of lines of code which are not covered by unit tests.
    New Uncovered Lines new_uncovered_lines identical to uncovered_lines but restricted to new / update source code
    Depth of inheritance tree dit The depth of inheritance tree (DIT) metric provides for each class a measure of the inheritance levels from the object hierarchy top. In Java where all classes inherit Object the minimum value of DIT is 1.
    Number of children noc A class's number of children (NOC) metric simply measures the number of direct and indirect descendants of the class.
    Response for class rfc The response set of a class is a set of methods that can potentially be executed in response to a message received by an object of that class. RFC is simply the number of methods in the set.
    Afferent couplings ca A class's afferent couplings is a measure of how many other classes use the specific class.
    Efferent couplings ce A class's efferent couplings is a measure of how many different classes are used by the specific class.
    Lack of cohesion of methods lcom4 LCOM4 measures the number of "connected components" in a class. A connected component is a set of related methods and fields. There should be only one such component in each class. If there are 2 or more components, the class should be split into so many smaller classes.
    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.
    File dependencies to cut package_tangles Number of file dependencies to cut in order to remove all cycles between packages.
    Package edges weight package_edges_weight Total number of file dependencies between packages.
    Package tangle index package_tangle_index Gives the level of tangle of the packages, best value 0% meaning that there is no cycles and worst value 100% meaning that packages are really tangled. The index is calculated using : 2 * (package_tangles / package_edges_weight) * 100.
    File cycles file_cycles Minimal number of file cycles detected inside a package to be able to identify all undesired dependencies.
    Suspect file dependencies file_feedback_edges File dependencies to cut in order to remove cycles between files inside a package. Warning : cycles are not always bad between files inside a package.
    File tangle file_tangles file_tangles = file_feedback_edges.
    File edges weight file_edges_weight Total number of file dependencies inside a package.
    File tangle index file_tangle_index 2 * (file_tangles / file_edges_weight) * 100.
    Commits commits The number of commits
    Last commit date last_commit_date The latest commit date on a resource
    Revision revision The latest revision of a resource
    Authors by line authors_by_line The last committer on each line of code
    Revisions by line revisions_by_line The revision number on each line of code

    From http://docs.codehaus.org/display/SONAR/Metric+definitions

  • 相关阅读:
    Cheatsheet: 2011 09.07 ~ 09.12
    Cheatsheet: 2011 10.01 ~ 10.10
    Cheatsheet: 2011 10.11 ~ 10.17
    Cheatsheet: 2011 09.01 ~ 09.06
    Cheatsheet: 2011 09.20 ~ 09.25
    Cheatsheet: 2011 08.17 ~ 08.22
    Cheatsheet: 2011 09.13 ~ 09.19
    Cheatsheet: 2011 08.08 ~ 08.16
    Cheatsheet: 2011 09.26 ~ 09.30
    Java05文件与流——课堂测试1
  • 原文地址:https://www.cnblogs.com/ericsun/p/2215294.html
Copyright © 2020-2023  润新知