001/* 002 * Sonar, open source software quality management tool. 003 * Copyright (C) 2008-2012 SonarSource 004 * mailto:contact AT sonarsource DOT com 005 * 006 * Sonar is free software; you can redistribute it and/or 007 * modify it under the terms of the GNU Lesser General Public 008 * License as published by the Free Software Foundation; either 009 * version 3 of the License, or (at your option) any later version. 010 * 011 * Sonar is distributed in the hope that it will be useful, 012 * but WITHOUT ANY WARRANTY; without even the implied warranty of 013 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 014 * Lesser General Public License for more details. 015 * 016 * You should have received a copy of the GNU Lesser General Public 017 * License along with Sonar; if not, write to the Free Software 018 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02 019 */ 020package org.sonar.api.measures; 021 022import com.google.common.annotations.Beta; 023import com.google.common.collect.Lists; 024import org.apache.commons.lang.StringUtils; 025import org.sonar.api.resources.Scopes; 026import org.sonar.api.utils.SonarException; 027 028import java.lang.reflect.Field; 029import java.util.List; 030 031/** 032 * @since 1.10 033 */ 034public final class CoreMetrics { 035 036 private CoreMetrics() { 037 // only static stuff 038 } 039 040 // the following fields are not final to avoid compile-time constants used by plugins 041 public static String DOMAIN_SIZE = "Size"; 042 public static String DOMAIN_TESTS = "Tests"; 043 public static String DOMAIN_INTEGRATION_TESTS = "Tests (Integration)"; 044 public static String DOMAIN_OVERALL_TESTS = "Tests (Overall)"; 045 public static String DOMAIN_COMPLEXITY = "Complexity"; 046 public static String DOMAIN_DOCUMENTATION = "Documentation"; 047 public static String DOMAIN_RULES = "Rules"; 048 public static String DOMAIN_SCM = "SCM"; 049 public static String DOMAIN_REVIEWS = "Reviews"; 050 051 /** 052 * @deprecated since 2.5 See SONAR-2007 053 */ 054 @Deprecated 055 public static final String DOMAIN_RULE_CATEGORIES = "Rule categories"; 056 057 public static String DOMAIN_GENERAL = "General"; 058 public static String DOMAIN_DUPLICATION = "Duplication"; 059 public static String DOMAIN_DESIGN = "Design"; 060 061 public static final String LINES_KEY = "lines"; 062 public static final Metric LINES = new Metric.Builder(LINES_KEY, "Lines", Metric.ValueType.INT) 063 .setDescription("Lines") 064 .setDirection(Metric.DIRECTION_WORST) 065 .setQualitative(false) 066 .setDomain(DOMAIN_SIZE) 067 .setFormula(new SumChildValuesFormula(false)) 068 .create(); 069 070 public static final String GENERATED_LINES_KEY = "generated_lines"; 071 public static final Metric GENERATED_LINES = new Metric.Builder(GENERATED_LINES_KEY, "Generated Lines", Metric.ValueType.INT) 072 .setDescription("Number of generated lines") 073 .setDirection(Metric.DIRECTION_WORST) 074 .setQualitative(false) 075 .setDomain(DOMAIN_SIZE) 076 .setBestValue(0.0) 077 .setOptimizedBestValue(true) 078 .setFormula(new SumChildValuesFormula(false)) 079 .create(); 080 081 public static final String NCLOC_KEY = "ncloc"; 082 public static final Metric NCLOC = new Metric.Builder(NCLOC_KEY, "Lines of code", Metric.ValueType.INT) 083 .setDescription("Non Commenting Lines of Code") 084 .setDirection(Metric.DIRECTION_WORST) 085 .setQualitative(false) 086 .setDomain(DOMAIN_SIZE) 087 .setFormula(new SumChildValuesFormula(false)) 088 .create(); 089 090 public static final String GENERATED_NCLOC_KEY = "generated_ncloc"; 091 public static final Metric GENERATED_NCLOC = new Metric.Builder(GENERATED_NCLOC_KEY, "Generated lines of code", Metric.ValueType.INT) 092 .setDescription("Generated non Commenting Lines of Code") 093 .setDirection(Metric.DIRECTION_WORST) 094 .setQualitative(false) 095 .setDomain(DOMAIN_SIZE) 096 .setBestValue(0.0) 097 .setOptimizedBestValue(true) 098 .setFormula(new SumChildValuesFormula(false)) 099 .create(); 100 101 public static final String CLASSES_KEY = "classes"; 102 public static final Metric CLASSES = new Metric.Builder(CLASSES_KEY, "Classes", Metric.ValueType.INT) 103 .setDescription("Classes") 104 .setDirection(Metric.DIRECTION_WORST) 105 .setQualitative(false) 106 .setDomain(DOMAIN_SIZE) 107 .setFormula(new SumChildValuesFormula(false)) 108 .create(); 109 110 public static final String FILES_KEY = "files"; 111 public static final Metric FILES = new Metric.Builder(FILES_KEY, "Files", Metric.ValueType.INT) 112 .setDescription("Number of files") 113 .setDirection(Metric.DIRECTION_WORST) 114 .setQualitative(false) 115 .setDomain(DOMAIN_SIZE) 116 .create(); 117 118 public static final String DIRECTORIES_KEY = "directories"; 119 public static final Metric DIRECTORIES = new Metric.Builder(DIRECTORIES_KEY, "Directories", Metric.ValueType.INT) 120 .setDescription("Directories") 121 .setDirection(Metric.DIRECTION_WORST) 122 .setQualitative(false) 123 .setDomain(DOMAIN_SIZE) 124 .create(); 125 126 public static final String PACKAGES_KEY = "packages"; 127 public static final Metric PACKAGES = new Metric.Builder(PACKAGES_KEY, "Packages", Metric.ValueType.INT) 128 .setDescription("Packages") 129 .setDirection(Metric.DIRECTION_WORST) 130 .setQualitative(false) 131 .setDomain(DOMAIN_SIZE) 132 .setFormula(new SumChildValuesFormula(false)) 133 .create(); 134 135 public static final String FUNCTIONS_KEY = "functions"; 136 public static final Metric FUNCTIONS = new Metric.Builder(FUNCTIONS_KEY, "Methods", Metric.ValueType.INT) 137 .setDescription("Methods") 138 .setDirection(Metric.DIRECTION_WORST) 139 .setQualitative(false) 140 .setDomain(DOMAIN_SIZE) 141 .setFormula(new SumChildValuesFormula(false)) 142 .create(); 143 144 public static final String ACCESSORS_KEY = "accessors"; 145 public static final Metric ACCESSORS = new Metric.Builder(ACCESSORS_KEY, "Accessors", Metric.ValueType.INT) 146 .setDescription("Accessors") 147 .setDirection(Metric.DIRECTION_WORST) 148 .setQualitative(false) 149 .setDomain(DOMAIN_SIZE) 150 .setFormula(new SumChildValuesFormula(false)) 151 .create(); 152 153 public static final String STATEMENTS_KEY = "statements"; 154 public static final Metric STATEMENTS = new Metric.Builder(STATEMENTS_KEY, "Statements", Metric.ValueType.INT) 155 .setDescription("Number of statements") 156 .setDirection(Metric.DIRECTION_WORST) 157 .setQualitative(false) 158 .setDomain(DOMAIN_SIZE) 159 .setFormula(new SumChildValuesFormula(false)) 160 .create(); 161 162 public static final String PUBLIC_API_KEY = "public_api"; 163 public static final Metric PUBLIC_API = new Metric.Builder(PUBLIC_API_KEY, "Public API", Metric.ValueType.INT) 164 .setDescription("Public API") 165 .setDirection(Metric.DIRECTION_WORST) 166 .setQualitative(false) 167 .setDomain(DOMAIN_SIZE) 168 .setFormula(new SumChildValuesFormula(false)) 169 .create(); 170 171 /** 172 * @since 3.0 173 */ 174 public static final String PROJECTS_KEY = "projects"; 175 176 /** 177 * @since 3.0 178 */ 179 public static final Metric PROJECTS = new Metric.Builder(PROJECTS_KEY, "Projects", Metric.ValueType.INT) 180 .setDescription("Number of projects") 181 .setDirection(Metric.DIRECTION_WORST) 182 .setQualitative(false) 183 .setDomain(DOMAIN_SIZE) 184 .create(); 185 186 // -------------------------------------------------------------------------------------------------------------------- 187 // 188 // DOCUMENTATION 189 // 190 // -------------------------------------------------------------------------------------------------------------------- 191 192 public static final String COMMENT_LINES_KEY = "comment_lines"; 193 public static final Metric COMMENT_LINES = new Metric.Builder(COMMENT_LINES_KEY, "Comment lines", Metric.ValueType.INT) 194 .setDescription("Number of comment lines") 195 .setDirection(Metric.DIRECTION_BETTER) 196 .setQualitative(false) 197 .setDomain(DOMAIN_DOCUMENTATION) 198 .setFormula(new SumChildValuesFormula(false)) 199 .create(); 200 201 public static final String COMMENT_LINES_DENSITY_KEY = "comment_lines_density"; 202 public static final Metric COMMENT_LINES_DENSITY = new Metric.Builder(COMMENT_LINES_DENSITY_KEY, "Comments (%)", Metric.ValueType.PERCENT) 203 .setDescription("Comments balanced by ncloc + comment lines") 204 .setDirection(Metric.DIRECTION_BETTER) 205 .setQualitative(true) 206 .setDomain(DOMAIN_DOCUMENTATION) 207 .create(); 208 209 /** 210 * @deprecated since 3.3 - see SONAR-3768 211 */ 212 @Deprecated 213 public static final String COMMENT_BLANK_LINES_KEY = "comment_blank_lines"; 214 215 /** 216 * @deprecated since 3.3 - see SONAR-3768 217 */ 218 @Deprecated 219 public static final Metric COMMENT_BLANK_LINES = new Metric.Builder(COMMENT_BLANK_LINES_KEY, "Blank comments", Metric.ValueType.INT) 220 .setDescription("Comments that do not contain comments") 221 .setDirection(Metric.DIRECTION_WORST) 222 .setQualitative(false) 223 .setDomain(DOMAIN_DOCUMENTATION) 224 .setFormula(new SumChildValuesFormula(false)) 225 .setBestValue(0.0) 226 .setOptimizedBestValue(true) 227 .create(); 228 229 public static final String PUBLIC_DOCUMENTED_API_DENSITY_KEY = "public_documented_api_density"; 230 public static final Metric PUBLIC_DOCUMENTED_API_DENSITY = new Metric.Builder(PUBLIC_DOCUMENTED_API_DENSITY_KEY, "Public documented API (%)", Metric.ValueType.PERCENT) 231 .setDescription("Public documented classes and methods balanced by ncloc") 232 .setDirection(Metric.DIRECTION_BETTER) 233 .setQualitative(true) 234 .setDomain(DOMAIN_DOCUMENTATION) 235 .setWorstValue(0.0) 236 .setBestValue(100.0) 237 .setOptimizedBestValue(true) 238 .create(); 239 240 public static final String PUBLIC_UNDOCUMENTED_API_KEY = "public_undocumented_api"; 241 public static final Metric PUBLIC_UNDOCUMENTED_API = new Metric.Builder(PUBLIC_UNDOCUMENTED_API_KEY, "Public undocumented API", Metric.ValueType.INT) 242 .setDescription("Public undocumented classes, methods and variables") 243 .setDirection(Metric.DIRECTION_WORST) 244 .setQualitative(true) 245 .setDomain(DOMAIN_DOCUMENTATION) 246 .setBestValue(0.0) 247 .setDirection(Metric.DIRECTION_WORST) 248 .setOptimizedBestValue(true) 249 .setFormula(new SumChildValuesFormula(false)) 250 .create(); 251 252 public static final String COMMENTED_OUT_CODE_LINES_KEY = "commented_out_code_lines"; 253 public static final Metric COMMENTED_OUT_CODE_LINES = new Metric.Builder(COMMENTED_OUT_CODE_LINES_KEY, "Commented-out LOC", Metric.ValueType.INT) 254 .setDescription("Commented lines of code") 255 .setDirection(Metric.DIRECTION_WORST) 256 .setQualitative(true) 257 .setDomain(DOMAIN_DOCUMENTATION) 258 .setFormula(new SumChildValuesFormula(false)) 259 .setBestValue(0.0) 260 .setOptimizedBestValue(true) 261 .create(); 262 263 // -------------------------------------------------------------------------------------------------------------------- 264 // 265 // COMPLEXITY 266 // 267 // -------------------------------------------------------------------------------------------------------------------- 268 269 public static final String COMPLEXITY_KEY = "complexity"; 270 public static final Metric COMPLEXITY = new Metric.Builder(COMPLEXITY_KEY, "Complexity", Metric.ValueType.INT) 271 .setDescription("Cyclomatic complexity") 272 .setDirection(Metric.DIRECTION_WORST) 273 .setQualitative(false) 274 .setDomain(DOMAIN_COMPLEXITY) 275 .setFormula(new SumChildValuesFormula(false)) 276 .create(); 277 278 public static final String CLASS_COMPLEXITY_KEY = "class_complexity"; 279 public static final Metric CLASS_COMPLEXITY = new Metric.Builder(CLASS_COMPLEXITY_KEY, "Complexity /class", Metric.ValueType.FLOAT) 280 .setDescription("Complexity average by class") 281 .setDirection(Metric.DIRECTION_WORST) 282 .setQualitative(true) 283 .setDomain(DOMAIN_COMPLEXITY) 284 .setFormula(AverageFormula.create(CoreMetrics.COMPLEXITY, CoreMetrics.CLASSES)) 285 .create(); 286 287 public static final String FUNCTION_COMPLEXITY_KEY = "function_complexity"; 288 public static final Metric FUNCTION_COMPLEXITY = new Metric.Builder(FUNCTION_COMPLEXITY_KEY, "Complexity /method", Metric.ValueType.FLOAT) 289 .setDescription("Complexity average by method") 290 .setDirection(Metric.DIRECTION_WORST) 291 .setQualitative(true) 292 .setDomain(DOMAIN_COMPLEXITY) 293 .setFormula(AverageFormula.create(CoreMetrics.COMPLEXITY, CoreMetrics.FUNCTIONS)) 294 .create(); 295 296 public static final String FILE_COMPLEXITY_KEY = "file_complexity"; 297 public static final Metric FILE_COMPLEXITY = new Metric.Builder(FILE_COMPLEXITY_KEY, "Complexity /file", Metric.ValueType.FLOAT) 298 .setDescription("Complexity average by file") 299 .setDirection(Metric.DIRECTION_WORST) 300 .setQualitative(true) 301 .setDomain(DOMAIN_COMPLEXITY) 302 .setFormula(AverageFormula.create(CoreMetrics.COMPLEXITY, CoreMetrics.FILES)) 303 .create(); 304 305 /** 306 * @deprecated in 3.0 - see SONAR-3289 307 */ 308 @Deprecated 309 public static final String CLASS_COMPLEXITY_DISTRIBUTION_KEY = "class_complexity_distribution"; 310 311 /** 312 * @deprecated in 3.0 - see SONAR-3289 313 */ 314 @Deprecated 315 public static final Metric CLASS_COMPLEXITY_DISTRIBUTION = new Metric.Builder(CLASS_COMPLEXITY_DISTRIBUTION_KEY, "Classes distribution /complexity", Metric.ValueType.DISTRIB) 316 .setDescription("Classes distribution /complexity") 317 .setDirection(Metric.DIRECTION_NONE) 318 .setQualitative(true) 319 .setDomain(DOMAIN_COMPLEXITY) 320 .setFormula(new SumChildDistributionFormula().setMinimumScopeToPersist(Scopes.DIRECTORY)) 321 .create(); 322 323 public static final String FUNCTION_COMPLEXITY_DISTRIBUTION_KEY = "function_complexity_distribution"; 324 public static final Metric FUNCTION_COMPLEXITY_DISTRIBUTION = new Metric.Builder(FUNCTION_COMPLEXITY_DISTRIBUTION_KEY, "Functions distribution /complexity", 325 Metric.ValueType.DISTRIB) 326 .setDescription("Functions distribution /complexity") 327 .setDirection(Metric.DIRECTION_NONE) 328 .setQualitative(true) 329 .setDomain(DOMAIN_COMPLEXITY) 330 .setFormula(new SumChildDistributionFormula().setMinimumScopeToPersist(Scopes.DIRECTORY)) 331 .create(); 332 333 public static final String FILE_COMPLEXITY_DISTRIBUTION_KEY = "file_complexity_distribution"; 334 public static final Metric FILE_COMPLEXITY_DISTRIBUTION = new Metric.Builder(FILE_COMPLEXITY_DISTRIBUTION_KEY, "Files distribution /complexity", Metric.ValueType.DISTRIB) 335 .setDescription("Files distribution /complexity") 336 .setDirection(Metric.DIRECTION_NONE) 337 .setQualitative(true) 338 .setDomain(DOMAIN_COMPLEXITY) 339 .setFormula(new SumChildDistributionFormula().setMinimumScopeToPersist(Scopes.DIRECTORY)) 340 .create(); 341 342 // -------------------------------------------------------------------------------------------------------------------- 343 // 344 // UNIT TESTS 345 // 346 // -------------------------------------------------------------------------------------------------------------------- 347 348 public static final String TESTS_KEY = "tests"; 349 350 /** 351 * Value of measure for this metric can be saved from Sensor, taking into account following rules: 352 * <ul> 353 * <li>If tool (like Maven Surefire Plugin) has not been activated to run unit tests, then Sensor should not save anything. For example there is no such tool for COBOL.</li> 354 * <li>If tool has been activated, but there was no unit tests to run, then zero value should be saved for project.</li> 355 * <li>Non-zero value should be saved for resources representing tests. And Sonar provides default Decorator, which will decorate parent resources.</li> 356 * <li>Should include {@link #TEST_FAILURES} and {@link #TEST_ERRORS}, but should not include {@link #SKIPPED_TESTS}.</li> 357 * </ul> 358 */ 359 public static final Metric TESTS = new Metric.Builder(TESTS_KEY, "Unit tests", Metric.ValueType.INT) 360 .setDescription("Number of unit tests") 361 .setDirection(Metric.DIRECTION_WORST) 362 .setQualitative(false) 363 .setDomain(DOMAIN_TESTS) 364 .create(); 365 366 public static final String TEST_EXECUTION_TIME_KEY = "test_execution_time"; 367 public static final Metric TEST_EXECUTION_TIME = new Metric.Builder(TEST_EXECUTION_TIME_KEY, "Unit tests duration", Metric.ValueType.MILLISEC) 368 .setDescription("Execution duration of unit tests") 369 .setDirection(Metric.DIRECTION_WORST) 370 .setQualitative(false) 371 .setDomain(DOMAIN_TESTS) 372 .create(); 373 374 public static final String TEST_ERRORS_KEY = "test_errors"; 375 public static final Metric TEST_ERRORS = new Metric.Builder(TEST_ERRORS_KEY, "Unit test errors", Metric.ValueType.INT) 376 .setDescription("Number of unit test errors") 377 .setDirection(Metric.DIRECTION_WORST) 378 .setQualitative(true) 379 .setDomain(DOMAIN_TESTS) 380 .setBestValue(0.0) 381 .setOptimizedBestValue(true) 382 .create(); 383 384 public static final String SKIPPED_TESTS_KEY = "skipped_tests"; 385 public static final Metric SKIPPED_TESTS = new Metric.Builder(SKIPPED_TESTS_KEY, "Skipped unit tests", Metric.ValueType.INT) 386 .setDescription("Number of skipped unit tests") 387 .setDirection(Metric.DIRECTION_WORST) 388 .setQualitative(true) 389 .setDomain(DOMAIN_TESTS) 390 .setBestValue(0.0) 391 .setOptimizedBestValue(true) 392 .create(); 393 394 public static final String TEST_FAILURES_KEY = "test_failures"; 395 public static final Metric TEST_FAILURES = new Metric.Builder(TEST_FAILURES_KEY, "Unit test failures", Metric.ValueType.INT) 396 .setDescription("Number of unit test failures") 397 .setDirection(Metric.DIRECTION_WORST) 398 .setQualitative(true) 399 .setDomain(DOMAIN_TESTS) 400 .setBestValue(0.0) 401 .setOptimizedBestValue(true) 402 .create(); 403 404 public static final String TEST_SUCCESS_DENSITY_KEY = "test_success_density"; 405 public static final Metric TEST_SUCCESS_DENSITY = new Metric.Builder(TEST_SUCCESS_DENSITY_KEY, "Unit test success (%)", Metric.ValueType.PERCENT) 406 .setDescription("Density of successful unit tests") 407 .setDirection(Metric.DIRECTION_BETTER) 408 .setQualitative(true) 409 .setDomain(DOMAIN_TESTS) 410 .setWorstValue(0.0) 411 .setBestValue(100.0) 412 .setOptimizedBestValue(true) 413 .create(); 414 415 public static final String TEST_DATA_KEY = "test_data"; 416 public static final Metric TEST_DATA = new Metric.Builder(TEST_DATA_KEY, "Unit tests details", Metric.ValueType.DATA) 417 .setDescription("Unit tests details") 418 .setDirection(Metric.DIRECTION_WORST) 419 .setDomain(DOMAIN_TESTS) 420 .create(); 421 422 public static final String COVERAGE_KEY = "coverage"; 423 public static final Metric COVERAGE = new Metric.Builder(COVERAGE_KEY, "Coverage", Metric.ValueType.PERCENT) 424 .setDescription("Coverage by unit tests") 425 .setDirection(Metric.DIRECTION_BETTER) 426 .setQualitative(true) 427 .setDomain(DOMAIN_TESTS) 428 .setWorstValue(0.0) 429 .setBestValue(100.0) 430 .create(); 431 432 public static final String NEW_COVERAGE_KEY = "new_coverage"; 433 public static final Metric NEW_COVERAGE = new Metric.Builder(NEW_COVERAGE_KEY, "New coverage", Metric.ValueType.PERCENT) 434 .setDescription("Coverage of new/changed code") 435 .setDirection(Metric.DIRECTION_BETTER) 436 .setQualitative(true) 437 .setDomain(DOMAIN_TESTS) 438 .setWorstValue(0.0) 439 .setBestValue(100.0) 440 .setDeleteHistoricalData(true) 441 .create(); 442 443 public static final String LINES_TO_COVER_KEY = "lines_to_cover"; 444 445 /** 446 * Use {@link CoverageMeasuresBuilder} to build measure for this metric. 447 */ 448 public static final Metric LINES_TO_COVER = new Metric.Builder(LINES_TO_COVER_KEY, "Lines to cover", Metric.ValueType.INT) 449 .setDescription("Lines to cover") 450 .setDirection(Metric.DIRECTION_BETTER) 451 .setQualitative(false) 452 .setDomain(DOMAIN_TESTS) 453 .setFormula(new SumChildValuesFormula(false)) 454 .create(); 455 456 public static final String NEW_LINES_TO_COVER_KEY = "new_lines_to_cover"; 457 public static final Metric NEW_LINES_TO_COVER = new Metric.Builder(NEW_LINES_TO_COVER_KEY, "New lines to cover", Metric.ValueType.INT) 458 .setDescription("New lines to cover") 459 .setDirection(Metric.DIRECTION_WORST) 460 .setQualitative(false) 461 .setDomain(DOMAIN_TESTS) 462 .setFormula(new SumChildValuesFormula(false)) 463 .setDeleteHistoricalData(true) 464 .create(); 465 466 public static final String UNCOVERED_LINES_KEY = "uncovered_lines"; 467 468 /** 469 * Use {@link CoverageMeasuresBuilder} to build measure for this metric. 470 */ 471 public static final Metric UNCOVERED_LINES = new Metric.Builder(UNCOVERED_LINES_KEY, "Uncovered lines", Metric.ValueType.INT) 472 .setDescription("Uncovered lines") 473 .setDirection(Metric.DIRECTION_WORST) 474 .setDomain(DOMAIN_TESTS) 475 .setFormula(new SumChildValuesFormula(false)) 476 .setBestValue(0.0) 477 .create(); 478 479 public static final String NEW_UNCOVERED_LINES_KEY = "new_uncovered_lines"; 480 public static final Metric NEW_UNCOVERED_LINES = new Metric.Builder(NEW_UNCOVERED_LINES_KEY, "New uncovered lines", Metric.ValueType.INT) 481 .setDescription("New uncovered lines") 482 .setDirection(Metric.DIRECTION_WORST) 483 .setDomain(DOMAIN_TESTS) 484 .setFormula(new SumChildValuesFormula(false)) 485 .setBestValue(0.0) 486 .setDeleteHistoricalData(true) 487 .create(); 488 489 public static final String LINE_COVERAGE_KEY = "line_coverage"; 490 public static final Metric LINE_COVERAGE = new Metric.Builder(LINE_COVERAGE_KEY, "Line coverage", Metric.ValueType.PERCENT) 491 .setDescription("Line coverage") 492 .setDirection(Metric.DIRECTION_BETTER) 493 .setQualitative(true) 494 .setDomain(DOMAIN_TESTS) 495 .setWorstValue(0.0) 496 .setBestValue(100.0) 497 .create(); 498 499 public static final String NEW_LINE_COVERAGE_KEY = "new_line_coverage"; 500 public static final Metric NEW_LINE_COVERAGE = new Metric.Builder(NEW_LINE_COVERAGE_KEY, "New line coverage", Metric.ValueType.PERCENT) 501 .setDescription("Line coverage of added/changed code") 502 .setDirection(Metric.DIRECTION_BETTER) 503 .setQualitative(true) 504 .setWorstValue(0.0) 505 .setBestValue(100.0) 506 .setDomain(DOMAIN_TESTS) 507 .setDeleteHistoricalData(true) 508 .create(); 509 510 public static final String COVERAGE_LINE_HITS_DATA_KEY = "coverage_line_hits_data"; 511 512 /** 513 * Key-value pairs, where key - is a number of line, and value - is a number of hits for this line. 514 * Use {@link CoverageMeasuresBuilder} to build measure for this metric. 515 */ 516 public static final Metric COVERAGE_LINE_HITS_DATA = new Metric.Builder(COVERAGE_LINE_HITS_DATA_KEY, "Coverage hits by line", Metric.ValueType.DATA) 517 .setDomain(DOMAIN_TESTS) 518 .setDeleteHistoricalData(true) 519 .create(); 520 521 public static final String CONDITIONS_TO_COVER_KEY = "conditions_to_cover"; 522 523 /** 524 * Use {@link CoverageMeasuresBuilder} to build measure for this metric. 525 */ 526 public static final Metric CONDITIONS_TO_COVER = new Metric.Builder(CONDITIONS_TO_COVER_KEY, "Conditions to cover", Metric.ValueType.INT) 527 .setDescription("Conditions to cover") 528 .setDomain(DOMAIN_TESTS) 529 .setFormula(new SumChildValuesFormula(false)) 530 .setHidden(true) 531 .create(); 532 533 public static final String NEW_CONDITIONS_TO_COVER_KEY = "new_conditions_to_cover"; 534 public static final Metric NEW_CONDITIONS_TO_COVER = new Metric.Builder(NEW_CONDITIONS_TO_COVER_KEY, "New conditions to cover", Metric.ValueType.INT) 535 .setDescription("New conditions to cover") 536 .setDomain(DOMAIN_TESTS) 537 .setFormula(new SumChildValuesFormula(false)) 538 .setDeleteHistoricalData(true) 539 .create(); 540 541 public static final String UNCOVERED_CONDITIONS_KEY = "uncovered_conditions"; 542 543 /** 544 * Use {@link CoverageMeasuresBuilder} to build measure for this metric. 545 */ 546 public static final Metric UNCOVERED_CONDITIONS = new Metric.Builder(UNCOVERED_CONDITIONS_KEY, "Uncovered conditions", Metric.ValueType.INT) 547 .setDescription("Uncovered conditions") 548 .setDirection(Metric.DIRECTION_WORST) 549 .setDomain(DOMAIN_TESTS) 550 .setFormula(new SumChildValuesFormula(false)) 551 .setBestValue(0.0) 552 .create(); 553 554 public static final String NEW_UNCOVERED_CONDITIONS_KEY = "new_uncovered_conditions"; 555 public static final Metric NEW_UNCOVERED_CONDITIONS = new Metric.Builder(NEW_UNCOVERED_CONDITIONS_KEY, "New uncovered conditions", Metric.ValueType.INT) 556 .setDescription("New uncovered conditions") 557 .setDirection(Metric.DIRECTION_WORST) 558 .setDomain(DOMAIN_TESTS) 559 .setFormula(new SumChildValuesFormula(false)) 560 .setBestValue(0.0) 561 .setDeleteHistoricalData(true) 562 .create(); 563 564 public static final String BRANCH_COVERAGE_KEY = "branch_coverage"; 565 public static final Metric BRANCH_COVERAGE = new Metric.Builder(BRANCH_COVERAGE_KEY, "Branch coverage", Metric.ValueType.PERCENT) 566 .setDescription("Branch coverage") 567 .setDirection(Metric.DIRECTION_BETTER) 568 .setQualitative(true) 569 .setDomain(DOMAIN_TESTS) 570 .setWorstValue(0.0) 571 .setBestValue(100.0) 572 .create(); 573 574 public static final String NEW_BRANCH_COVERAGE_KEY = "new_branch_coverage"; 575 public static final Metric NEW_BRANCH_COVERAGE = new Metric.Builder(NEW_BRANCH_COVERAGE_KEY, "New branch coverage", Metric.ValueType.PERCENT) 576 .setDescription("Branch coverage of new/changed code") 577 .setDirection(Metric.DIRECTION_BETTER) 578 .setQualitative(true) 579 .setDomain(DOMAIN_TESTS) 580 .setWorstValue(0.0) 581 .setBestValue(100.0) 582 .setDeleteHistoricalData(true) 583 .create(); 584 585 /** 586 * @deprecated in 2.7. Replaced by {@link #CONDITIONS_BY_LINE_KEY} and {@link #COVERED_CONDITIONS_BY_LINE_KEY} 587 */ 588 @Deprecated 589 public static final String BRANCH_COVERAGE_HITS_DATA_KEY = "branch_coverage_hits_data"; 590 591 /** 592 * @deprecated in 2.7. Replaced by metrics {@link #CONDITIONS_BY_LINE} and {@link #COVERED_CONDITIONS_BY_LINE} 593 */ 594 @Deprecated 595 public static final Metric BRANCH_COVERAGE_HITS_DATA = new Metric.Builder(BRANCH_COVERAGE_HITS_DATA_KEY, "Branch coverage hits", Metric.ValueType.DATA) 596 .setDomain(DOMAIN_TESTS) 597 .setDeleteHistoricalData(true) 598 .create(); 599 600 public static final String CONDITIONS_BY_LINE_KEY = "conditions_by_line"; 601 602 /** 603 * Use {@link CoverageMeasuresBuilder} to build measure for this metric. 604 * 605 * @since 2.7 606 */ 607 public static final Metric CONDITIONS_BY_LINE = new Metric.Builder(CONDITIONS_BY_LINE_KEY, "Conditions by line", Metric.ValueType.DATA) 608 .setDomain(DOMAIN_TESTS) 609 .setDeleteHistoricalData(true) 610 .create(); 611 612 public static final String COVERED_CONDITIONS_BY_LINE_KEY = "covered_conditions_by_line"; 613 614 /** 615 * Use {@link CoverageMeasuresBuilder} to build measure for this metric. 616 * 617 * @since 2.7 618 */ 619 public static final Metric COVERED_CONDITIONS_BY_LINE = new Metric.Builder(COVERED_CONDITIONS_BY_LINE_KEY, "Covered conditions by line", Metric.ValueType.DATA) 620 .setDomain(DOMAIN_TESTS) 621 .setDeleteHistoricalData(true) 622 .create(); 623 624 // -------------------------------------------------------------------------------------------------------------------- 625 // 626 // INTEGRATION TESTS 627 // 628 // -------------------------------------------------------------------------------------------------------------------- 629 630 /** 631 * @since 2.12 632 */ 633 public static final String IT_COVERAGE_KEY = "it_coverage"; 634 635 /** 636 * @since 2.12 637 */ 638 public static final Metric IT_COVERAGE = new Metric.Builder(IT_COVERAGE_KEY, "IT coverage", Metric.ValueType.PERCENT) 639 .setDescription("Coverage by integration tests") 640 .setDirection(Metric.DIRECTION_BETTER) 641 .setQualitative(true) 642 .setDomain(DOMAIN_INTEGRATION_TESTS) 643 .setWorstValue(0.0) 644 .setBestValue(100.0) 645 .create(); 646 647 /** 648 * @since 2.12 649 */ 650 public static final String NEW_IT_COVERAGE_KEY = "new_it_coverage"; 651 652 /** 653 * @since 2.12 654 */ 655 public static final Metric NEW_IT_COVERAGE = new Metric.Builder(NEW_IT_COVERAGE_KEY, "New coverage by IT", Metric.ValueType.PERCENT) 656 .setDescription("Integration Tests Coverage of new/changed code") 657 .setDirection(Metric.DIRECTION_BETTER) 658 .setQualitative(true) 659 .setDomain(DOMAIN_INTEGRATION_TESTS) 660 .setWorstValue(0.0) 661 .setBestValue(100.0) 662 .setDeleteHistoricalData(true) 663 .create(); 664 665 /** 666 * @since 2.12 667 */ 668 public static final String IT_LINES_TO_COVER_KEY = "it_lines_to_cover"; 669 670 /** 671 * @since 2.12 672 */ 673 public static final Metric IT_LINES_TO_COVER = new Metric.Builder(IT_LINES_TO_COVER_KEY, "IT lines to cover", Metric.ValueType.INT) 674 .setDescription("Lines to cover by Integration Tests") 675 .setDirection(Metric.DIRECTION_BETTER) 676 .setDomain(DOMAIN_INTEGRATION_TESTS) 677 .setQualitative(false) 678 .setFormula(new SumChildValuesFormula(false)) 679 .setHidden(true) 680 .setDeleteHistoricalData(true) 681 .create(); 682 683 /** 684 * @since 2.12 685 */ 686 public static final String NEW_IT_LINES_TO_COVER_KEY = "new_it_lines_to_cover"; 687 688 /** 689 * @since 2.12 690 */ 691 public static final Metric NEW_IT_LINES_TO_COVER = new Metric.Builder(NEW_IT_LINES_TO_COVER_KEY, "New lines to cover by IT", Metric.ValueType.INT) 692 .setDescription("New lines to cover by Integration Tests") 693 .setDirection(Metric.DIRECTION_WORST) 694 .setQualitative(false) 695 .setDomain(DOMAIN_INTEGRATION_TESTS) 696 .setFormula(new SumChildValuesFormula(false)) 697 .setDeleteHistoricalData(true) 698 .create(); 699 700 /** 701 * @since 2.12 702 */ 703 public static final String IT_UNCOVERED_LINES_KEY = "it_uncovered_lines"; 704 705 /** 706 * @since 2.12 707 */ 708 public static final Metric IT_UNCOVERED_LINES = new Metric.Builder(IT_UNCOVERED_LINES_KEY, "IT uncovered lines", Metric.ValueType.INT) 709 .setDescription("IT uncovered lines") 710 .setDirection(Metric.DIRECTION_WORST) 711 .setQualitative(false) 712 .setDomain(DOMAIN_INTEGRATION_TESTS) 713 .setFormula(new SumChildValuesFormula(false)) 714 .create(); 715 716 /** 717 * @since 2.12 718 */ 719 public static final String NEW_IT_UNCOVERED_LINES_KEY = "new_it_uncovered_lines"; 720 721 /** 722 * @since 2.12 723 */ 724 public static final Metric NEW_IT_UNCOVERED_LINES = new Metric.Builder(NEW_IT_UNCOVERED_LINES_KEY, "New uncovered lines by IT", Metric.ValueType.INT) 725 .setDescription("New uncovered lines by Integration Tests") 726 .setDirection(Metric.DIRECTION_WORST) 727 .setDomain(DOMAIN_INTEGRATION_TESTS) 728 .setFormula(new SumChildValuesFormula(false)) 729 .setBestValue(0.0) 730 .setDeleteHistoricalData(true) 731 .create(); 732 733 /** 734 * @since 2.12 735 */ 736 public static final String IT_LINE_COVERAGE_KEY = "it_line_coverage"; 737 738 /** 739 * @since 2.12 740 */ 741 public static final Metric IT_LINE_COVERAGE = new Metric.Builder(IT_LINE_COVERAGE_KEY, "IT line coverage", Metric.ValueType.PERCENT) 742 .setDescription("IT line coverage") 743 .setDirection(Metric.DIRECTION_BETTER) 744 .setQualitative(true) 745 .setDomain(DOMAIN_INTEGRATION_TESTS) 746 .create(); 747 748 /** 749 * @since 2.12 750 */ 751 public static final String NEW_IT_LINE_COVERAGE_KEY = "new_it_line_coverage"; 752 753 /** 754 * @since 2.12 755 */ 756 public static final Metric NEW_IT_LINE_COVERAGE = new Metric.Builder(NEW_IT_LINE_COVERAGE_KEY, "New line coverage by IT", Metric.ValueType.PERCENT) 757 .setDescription("Line Coverage by Integration Tests of added/changed code") 758 .setDirection(Metric.DIRECTION_BETTER) 759 .setQualitative(true) 760 .setWorstValue(0.0) 761 .setBestValue(100.0) 762 .setDomain(DOMAIN_INTEGRATION_TESTS) 763 .setDeleteHistoricalData(true) 764 .create(); 765 766 /** 767 * @since 2.12 768 */ 769 public static final String IT_COVERAGE_LINE_HITS_DATA_KEY = "it_coverage_line_hits_data"; 770 771 /** 772 * @since 2.12 773 */ 774 public static final Metric IT_COVERAGE_LINE_HITS_DATA = new Metric.Builder(IT_COVERAGE_LINE_HITS_DATA_KEY, "IT coverage hits data", Metric.ValueType.DATA) 775 .setDescription("IT Code coverage line hits data") 776 .setDirection(Metric.DIRECTION_NONE) 777 .setQualitative(false) 778 .setDomain(DOMAIN_INTEGRATION_TESTS) 779 .setDeleteHistoricalData(true) 780 .create(); 781 782 /** 783 * @since 2.12 784 */ 785 public static final String IT_CONDITIONS_TO_COVER_KEY = "it_conditions_to_cover"; 786 787 /** 788 * @since 2.12 789 */ 790 public static final Metric IT_CONDITIONS_TO_COVER = new Metric.Builder(IT_CONDITIONS_TO_COVER_KEY, "IT branches to cover", Metric.ValueType.INT) 791 .setDescription("IT Conditions to cover") 792 .setDirection(Metric.DIRECTION_BETTER) 793 .setQualitative(false) 794 .setDomain(DOMAIN_INTEGRATION_TESTS) 795 .setFormula(new SumChildValuesFormula(false)) 796 .setHidden(true) 797 .create(); 798 799 /** 800 * @since 2.12 801 */ 802 public static final String NEW_IT_CONDITIONS_TO_COVER_KEY = "new_it_conditions_to_cover"; 803 804 /** 805 * @since 2.12 806 */ 807 public static final Metric NEW_IT_CONDITIONS_TO_COVER = new Metric.Builder(NEW_IT_CONDITIONS_TO_COVER_KEY, "New conditions to cover by IT", Metric.ValueType.INT) 808 .setDescription("New conditions to cover by Integration Tests") 809 .setDomain(DOMAIN_INTEGRATION_TESTS) 810 .setFormula(new SumChildValuesFormula(false)) 811 .setDeleteHistoricalData(true) 812 .create(); 813 814 /** 815 * @since 2.12 816 */ 817 public static final String IT_UNCOVERED_CONDITIONS_KEY = "it_uncovered_conditions"; 818 819 /** 820 * @since 2.12 821 */ 822 public static final Metric IT_UNCOVERED_CONDITIONS = new Metric.Builder(IT_UNCOVERED_CONDITIONS_KEY, "IT uncovered branches", Metric.ValueType.INT) 823 .setDescription("IT Uncovered conditions") 824 .setDirection(Metric.DIRECTION_WORST) 825 .setDomain(DOMAIN_INTEGRATION_TESTS) 826 .setFormula(new SumChildValuesFormula(false)) 827 .create(); 828 829 /** 830 * @since 2.12 831 */ 832 public static final String NEW_IT_UNCOVERED_CONDITIONS_KEY = "new_it_uncovered_conditions"; 833 834 /** 835 * @since 2.12 836 */ 837 public static final Metric NEW_IT_UNCOVERED_CONDITIONS = new Metric.Builder(NEW_IT_UNCOVERED_CONDITIONS_KEY, "New uncovered conditions by IT", Metric.ValueType.INT) 838 .setDescription("New uncovered conditions by Integration Tests") 839 .setDirection(Metric.DIRECTION_WORST) 840 .setDomain(DOMAIN_INTEGRATION_TESTS) 841 .setFormula(new SumChildValuesFormula(false)) 842 .setBestValue(0.0) 843 .setDeleteHistoricalData(true) 844 .create(); 845 846 /** 847 * @since 2.12 848 */ 849 public static final String IT_BRANCH_COVERAGE_KEY = "it_branch_coverage"; 850 851 /** 852 * @since 2.12 853 */ 854 public static final Metric IT_BRANCH_COVERAGE = new Metric.Builder(IT_BRANCH_COVERAGE_KEY, "IT branch coverage", Metric.ValueType.PERCENT) 855 .setDescription("IT Branch coverage") 856 .setDirection(Metric.DIRECTION_BETTER) 857 .setQualitative(true) 858 .setDomain(DOMAIN_INTEGRATION_TESTS) 859 .setWorstValue(0.0) 860 .setBestValue(100.0) 861 .create(); 862 863 /** 864 * @since 2.12 865 */ 866 public static final String NEW_IT_BRANCH_COVERAGE_KEY = "new_it_branch_coverage"; 867 868 /** 869 * @since 2.12 870 */ 871 public static final Metric NEW_IT_BRANCH_COVERAGE = new Metric.Builder(NEW_IT_BRANCH_COVERAGE_KEY, "New branch coverage by IT", Metric.ValueType.PERCENT) 872 .setDescription("Branch coverage by Integration Tests of new/changed code") 873 .setDirection(Metric.DIRECTION_BETTER) 874 .setQualitative(true) 875 .setDomain(DOMAIN_INTEGRATION_TESTS) 876 .setWorstValue(0.0) 877 .setBestValue(100.0) 878 .setDeleteHistoricalData(true) 879 .create(); 880 881 /** 882 * @since 2.12 883 */ 884 public static final String IT_CONDITIONS_BY_LINE_KEY = "it_conditions_by_line"; 885 886 /** 887 * @since 2.12 888 */ 889 public static final Metric IT_CONDITIONS_BY_LINE = new Metric.Builder(IT_CONDITIONS_BY_LINE_KEY, "IT branches by line", Metric.ValueType.DATA) 890 .setDomain(DOMAIN_INTEGRATION_TESTS) 891 .setDeleteHistoricalData(true) 892 .create(); 893 894 /** 895 * @since 2.12 896 */ 897 public static final String IT_COVERED_CONDITIONS_BY_LINE_KEY = "it_covered_conditions_by_line"; 898 899 /** 900 * @since 2.12 901 */ 902 public static final Metric IT_COVERED_CONDITIONS_BY_LINE = new Metric.Builder(IT_COVERED_CONDITIONS_BY_LINE_KEY, "IT covered branches by line", Metric.ValueType.DATA) 903 .setDomain(DOMAIN_INTEGRATION_TESTS) 904 .setDeleteHistoricalData(true) 905 .create(); 906 907 // -------------------------------------------------------------------------------------------------------------------- 908 // 909 // OVERALL TESTS 910 // 911 // -------------------------------------------------------------------------------------------------------------------- 912 913 /** 914 * @since 3.3 915 */ 916 public static final String OVERALL_COVERAGE_KEY = "overall_coverage"; 917 918 /** 919 * @since 3.3 920 */ 921 public static final Metric OVERALL_COVERAGE = new Metric.Builder(OVERALL_COVERAGE_KEY, "Overall coverage", Metric.ValueType.PERCENT) 922 .setDescription("Overall test coverage") 923 .setDirection(Metric.DIRECTION_BETTER) 924 .setQualitative(true) 925 .setDomain(DOMAIN_OVERALL_TESTS) 926 .setWorstValue(0.0) 927 .setBestValue(100.0) 928 .create(); 929 930 /** 931 * @since 3.3 932 */ 933 public static final String NEW_OVERALL_COVERAGE_KEY = "new_overall_coverage"; 934 935 /** 936 * @since 3.3 937 */ 938 public static final Metric NEW_OVERALL_COVERAGE = new Metric.Builder(NEW_OVERALL_COVERAGE_KEY, "Overall new coverage", Metric.ValueType.PERCENT) 939 .setDescription("Overall coverage of new/changed code") 940 .setDirection(Metric.DIRECTION_BETTER) 941 .setQualitative(true) 942 .setDomain(DOMAIN_OVERALL_TESTS) 943 .setWorstValue(0.0) 944 .setBestValue(100.0) 945 .setDeleteHistoricalData(true) 946 .create(); 947 948 /** 949 * @since 3.3 950 */ 951 public static final String OVERALL_LINES_TO_COVER_KEY = "overall_lines_to_cover"; 952 953 /** 954 * @since 3.3 955 */ 956 public static final Metric OVERALL_LINES_TO_COVER = new Metric.Builder(OVERALL_LINES_TO_COVER_KEY, "Overall lines to cover", Metric.ValueType.INT) 957 .setDescription("Overall lines to cover by all tests") 958 .setDirection(Metric.DIRECTION_BETTER) 959 .setDomain(DOMAIN_OVERALL_TESTS) 960 .setQualitative(false) 961 .setFormula(new SumChildValuesFormula(false)) 962 .setHidden(true) 963 .setDeleteHistoricalData(true) 964 .create(); 965 966 /** 967 * @since 3.3 968 */ 969 public static final String NEW_OVERALL_LINES_TO_COVER_KEY = "new_overall_lines_to_cover"; 970 971 /** 972 * @since 3.3 973 */ 974 public static final Metric NEW_OVERALL_LINES_TO_COVER = new Metric.Builder(NEW_OVERALL_LINES_TO_COVER_KEY, "Overall new lines to cover", Metric.ValueType.INT) 975 .setDescription("New lines to cover by all tests") 976 .setDirection(Metric.DIRECTION_WORST) 977 .setQualitative(false) 978 .setDomain(DOMAIN_OVERALL_TESTS) 979 .setFormula(new SumChildValuesFormula(false)) 980 .setDeleteHistoricalData(true) 981 .create(); 982 983 /** 984 * @since 3.3 985 */ 986 public static final String OVERALL_UNCOVERED_LINES_KEY = "overall_uncovered_lines"; 987 988 /** 989 * @since 3.3 990 */ 991 public static final Metric OVERALL_UNCOVERED_LINES = new Metric.Builder(OVERALL_UNCOVERED_LINES_KEY, "Overall uncovered lines", Metric.ValueType.INT) 992 .setDescription("Uncovered lines by all tests") 993 .setDirection(Metric.DIRECTION_WORST) 994 .setQualitative(false) 995 .setDomain(DOMAIN_OVERALL_TESTS) 996 .setFormula(new SumChildValuesFormula(false)) 997 .create(); 998 999 /** 1000 * @since 3.3 1001 */ 1002 public static final String NEW_OVERALL_UNCOVERED_LINES_KEY = "new_overall_uncovered_lines"; 1003 1004 /** 1005 * @since 3.3 1006 */ 1007 public static final Metric NEW_OVERALL_UNCOVERED_LINES = new Metric.Builder(NEW_OVERALL_UNCOVERED_LINES_KEY, "Overall new lines uncovered", Metric.ValueType.INT) 1008 .setDescription("New lines that are not covered by any tests") 1009 .setDirection(Metric.DIRECTION_WORST) 1010 .setDomain(DOMAIN_OVERALL_TESTS) 1011 .setFormula(new SumChildValuesFormula(false)) 1012 .setBestValue(0.0) 1013 .setDeleteHistoricalData(true) 1014 .create(); 1015 1016 /** 1017 * @since 3.3 1018 */ 1019 public static final String OVERALL_LINE_COVERAGE_KEY = "overall_line_coverage"; 1020 1021 /** 1022 * @since 3.3 1023 */ 1024 public static final Metric OVERALL_LINE_COVERAGE = new Metric.Builder(OVERALL_LINE_COVERAGE_KEY, "Overall line coverage", Metric.ValueType.PERCENT) 1025 .setDescription("Line coverage by all tests") 1026 .setDirection(Metric.DIRECTION_BETTER) 1027 .setQualitative(true) 1028 .setDomain(DOMAIN_OVERALL_TESTS) 1029 .create(); 1030 1031 /** 1032 * @since 3.3 1033 */ 1034 public static final String NEW_OVERALL_LINE_COVERAGE_KEY = "new_overall_line_coverage"; 1035 1036 /** 1037 * @since 3.3 1038 */ 1039 public static final Metric NEW_OVERALL_LINE_COVERAGE = new Metric.Builder(NEW_OVERALL_LINE_COVERAGE_KEY, "Overall new line coverage", Metric.ValueType.PERCENT) 1040 .setDescription("Line coverage of added/changed code by all tests") 1041 .setDirection(Metric.DIRECTION_BETTER) 1042 .setQualitative(true) 1043 .setWorstValue(0.0) 1044 .setBestValue(100.0) 1045 .setDomain(DOMAIN_OVERALL_TESTS) 1046 .setDeleteHistoricalData(true) 1047 .create(); 1048 1049 /** 1050 * @since 3.3 1051 */ 1052 public static final String OVERALL_COVERAGE_LINE_HITS_DATA_KEY = "overall_coverage_line_hits_data"; 1053 1054 /** 1055 * @since 3.3 1056 */ 1057 public static final Metric OVERALL_COVERAGE_LINE_HITS_DATA = new Metric.Builder(OVERALL_COVERAGE_LINE_HITS_DATA_KEY, "Overall coverage hits by line", Metric.ValueType.DATA) 1058 .setDescription("Coverage hits by all tests and by line") 1059 .setDirection(Metric.DIRECTION_NONE) 1060 .setQualitative(false) 1061 .setDomain(DOMAIN_OVERALL_TESTS) 1062 .setDeleteHistoricalData(true) 1063 .create(); 1064 1065 /** 1066 * @since 3.3 1067 */ 1068 public static final String OVERALL_CONDITIONS_TO_COVER_KEY = "overall_conditions_to_cover"; 1069 1070 /** 1071 * @since 3.3 1072 */ 1073 public static final Metric OVERALL_CONDITIONS_TO_COVER = new Metric.Builder(OVERALL_CONDITIONS_TO_COVER_KEY, "Overall branches to cover", Metric.ValueType.INT) 1074 .setDescription("Branches to cover by all tests") 1075 .setDirection(Metric.DIRECTION_BETTER) 1076 .setQualitative(false) 1077 .setDomain(DOMAIN_OVERALL_TESTS) 1078 .setFormula(new SumChildValuesFormula(false)) 1079 .setHidden(true) 1080 .create(); 1081 1082 /** 1083 * @since 3.3 1084 */ 1085 public static final String NEW_OVERALL_CONDITIONS_TO_COVER_KEY = "new_overall_conditions_to_cover"; 1086 1087 /** 1088 * @since 3.3 1089 */ 1090 public static final Metric NEW_OVERALL_CONDITIONS_TO_COVER = new Metric.Builder(NEW_OVERALL_CONDITIONS_TO_COVER_KEY, "Overall new branches to cover", Metric.ValueType.INT) 1091 .setDescription("New branches to cover by all tests") 1092 .setDomain(DOMAIN_OVERALL_TESTS) 1093 .setFormula(new SumChildValuesFormula(false)) 1094 .setDeleteHistoricalData(true) 1095 .create(); 1096 1097 /** 1098 * @since 3.3 1099 */ 1100 public static final String OVERALL_UNCOVERED_CONDITIONS_KEY = "overall_uncovered_conditions"; 1101 1102 /** 1103 * @since 3.3 1104 */ 1105 public static final Metric OVERALL_UNCOVERED_CONDITIONS = new Metric.Builder(OVERALL_UNCOVERED_CONDITIONS_KEY, "Overall uncovered branches", Metric.ValueType.INT) 1106 .setDescription("Uncovered branches by all tests") 1107 .setDirection(Metric.DIRECTION_WORST) 1108 .setDomain(DOMAIN_OVERALL_TESTS) 1109 .setFormula(new SumChildValuesFormula(false)) 1110 .create(); 1111 1112 /** 1113 * @since 3.3 1114 */ 1115 public static final String NEW_OVERALL_UNCOVERED_CONDITIONS_KEY = "new_overall_uncovered_conditions"; 1116 1117 /** 1118 * @since 3.3 1119 */ 1120 public static final Metric NEW_OVERALL_UNCOVERED_CONDITIONS = new Metric.Builder(NEW_OVERALL_UNCOVERED_CONDITIONS_KEY, "Overall new branches uncovered", Metric.ValueType.INT) 1121 .setDescription("New branches that are not covered by any test") 1122 .setDirection(Metric.DIRECTION_WORST) 1123 .setDomain(DOMAIN_OVERALL_TESTS) 1124 .setFormula(new SumChildValuesFormula(false)) 1125 .setBestValue(0.0) 1126 .setDeleteHistoricalData(true) 1127 .create(); 1128 1129 /** 1130 * @since 3.3 1131 */ 1132 public static final String OVERALL_BRANCH_COVERAGE_KEY = "overall_branch_coverage"; 1133 1134 /** 1135 * @since 3.3 1136 */ 1137 public static final Metric OVERALL_BRANCH_COVERAGE = new Metric.Builder(OVERALL_BRANCH_COVERAGE_KEY, "Overall branch coverage", Metric.ValueType.PERCENT) 1138 .setDescription("Branch coverage by all tests") 1139 .setDirection(Metric.DIRECTION_BETTER) 1140 .setQualitative(true) 1141 .setDomain(DOMAIN_OVERALL_TESTS) 1142 .setWorstValue(0.0) 1143 .setBestValue(100.0) 1144 .create(); 1145 1146 /** 1147 * @since 3.3 1148 */ 1149 public static final String NEW_OVERALL_BRANCH_COVERAGE_KEY = "new_overall_branch_coverage"; 1150 1151 /** 1152 * @since 3.3 1153 */ 1154 public static final Metric NEW_OVERALL_BRANCH_COVERAGE = new Metric.Builder(NEW_OVERALL_BRANCH_COVERAGE_KEY, "Overall new branch coverage", Metric.ValueType.PERCENT) 1155 .setDescription("Branch coverage of new/changed code by all tests") 1156 .setDirection(Metric.DIRECTION_BETTER) 1157 .setQualitative(true) 1158 .setDomain(DOMAIN_OVERALL_TESTS) 1159 .setWorstValue(0.0) 1160 .setBestValue(100.0) 1161 .setDeleteHistoricalData(true) 1162 .create(); 1163 1164 /** 1165 * @since 3.3 1166 */ 1167 public static final String OVERALL_CONDITIONS_BY_LINE_KEY = "overall_conditions_by_line"; 1168 1169 /** 1170 * @since 3.3 1171 */ 1172 public static final Metric OVERALL_CONDITIONS_BY_LINE = new Metric.Builder(OVERALL_CONDITIONS_BY_LINE_KEY, "Overall branches by line", Metric.ValueType.DATA) 1173 .setDescription("Overall branches by all tests and by line") 1174 .setDomain(DOMAIN_OVERALL_TESTS) 1175 .setDeleteHistoricalData(true) 1176 .create(); 1177 1178 /** 1179 * @since 3.3 1180 */ 1181 public static final String OVERALL_COVERED_CONDITIONS_BY_LINE_KEY = "overall_covered_conditions_by_line"; 1182 1183 /** 1184 * @since 3.3 1185 */ 1186 public static final Metric OVERALL_COVERED_CONDITIONS_BY_LINE = new Metric.Builder(OVERALL_COVERED_CONDITIONS_BY_LINE_KEY, "Overall covered branches by line", 1187 Metric.ValueType.DATA) 1188 .setDescription("Overall covered branches by all tests and by line") 1189 .setDomain(DOMAIN_OVERALL_TESTS) 1190 .setDeleteHistoricalData(true) 1191 .create(); 1192 1193 // -------------------------------------------------------------------------------------------------------------------- 1194 // 1195 // DUPLICATIONS 1196 // 1197 // -------------------------------------------------------------------------------------------------------------------- 1198 1199 public static final String DUPLICATED_LINES_KEY = "duplicated_lines"; 1200 public static final Metric DUPLICATED_LINES = new Metric.Builder(DUPLICATED_LINES_KEY, "Duplicated lines", Metric.ValueType.INT) 1201 .setDescription("Duplicated lines") 1202 .setDirection(Metric.DIRECTION_WORST) 1203 .setQualitative(true) 1204 .setDomain(DOMAIN_DUPLICATION) 1205 .setBestValue(0.0) 1206 .setOptimizedBestValue(true) 1207 .create(); 1208 1209 public static final String DUPLICATED_BLOCKS_KEY = "duplicated_blocks"; 1210 public static final Metric DUPLICATED_BLOCKS = new Metric.Builder(DUPLICATED_BLOCKS_KEY, "Duplicated blocks", Metric.ValueType.INT) 1211 .setDescription("Duplicated blocks") 1212 .setDirection(Metric.DIRECTION_WORST) 1213 .setQualitative(true) 1214 .setDomain(DOMAIN_DUPLICATION) 1215 .setBestValue(0.0) 1216 .setOptimizedBestValue(true) 1217 .create(); 1218 1219 public static final String DUPLICATED_FILES_KEY = "duplicated_files"; 1220 1221 /** 1222 * For files: if it contains duplicates, then 1, otherwise 0. 1223 * For other resources: amount of files under this resource with duplicates. 1224 */ 1225 public static final Metric DUPLICATED_FILES = new Metric.Builder(DUPLICATED_FILES_KEY, "Duplicated files", Metric.ValueType.INT) 1226 .setDescription("Duplicated files") 1227 .setDirection(Metric.DIRECTION_WORST) 1228 .setQualitative(true) 1229 .setDomain(DOMAIN_DUPLICATION) 1230 .setBestValue(0.0) 1231 .setOptimizedBestValue(true) 1232 .create(); 1233 1234 public static final String DUPLICATED_LINES_DENSITY_KEY = "duplicated_lines_density"; 1235 public static final Metric DUPLICATED_LINES_DENSITY = new Metric.Builder(DUPLICATED_LINES_DENSITY_KEY, "Duplicated lines (%)", Metric.ValueType.PERCENT) 1236 .setDescription("Duplicated lines balanced by statements") 1237 .setDirection(Metric.DIRECTION_WORST) 1238 .setQualitative(true) 1239 .setDomain(DOMAIN_DUPLICATION) 1240 .setWorstValue(50.0) 1241 .setBestValue(0.0) 1242 .setOptimizedBestValue(true) 1243 .create(); 1244 1245 public static final String DUPLICATIONS_DATA_KEY = "duplications_data"; 1246 1247 /** 1248 * Information about duplications, which is represented as an XML string. 1249 * <p> 1250 * Here is the format (since Sonar 2.12): 1251 * <pre> 1252 * {@code<duplications> 1253 * <!-- Multiple groups: --> 1254 * <g> 1255 * <!-- Multiple blocks: --> 1256 * <b r="[resource key]" s="[first line]" l="[number of lines]" /> 1257 * ... 1258 * </g> 1259 * ... 1260 * </duplications>} 1261 * </pre> 1262 * </p> 1263 */ 1264 public static final Metric DUPLICATIONS_DATA = new Metric.Builder(DUPLICATIONS_DATA_KEY, "Duplications details", Metric.ValueType.DATA) 1265 .setDescription("Duplications details") 1266 .setDirection(Metric.DIRECTION_NONE) 1267 .setQualitative(false) 1268 .setDomain(DOMAIN_DUPLICATION) 1269 .setDeleteHistoricalData(true) 1270 .create(); 1271 1272 // -------------------------------------------------------------------------------------------------------------------- 1273 // 1274 // CODING RULES 1275 // 1276 // -------------------------------------------------------------------------------------------------------------------- 1277 1278 /** 1279 * @deprecated since 2.5 See SONAR-2007 1280 */ 1281 @Deprecated 1282 public static final String USABILITY_KEY = "usability"; 1283 1284 /** 1285 * @deprecated since 2.5 See SONAR-2007 1286 */ 1287 @Deprecated 1288 public static final Metric USABILITY = new Metric(USABILITY_KEY, "Usability", "Usability", Metric.ValueType.PERCENT, 1289 Metric.DIRECTION_BETTER, true, DOMAIN_RULE_CATEGORIES).setBestValue(100.0).setOptimizedBestValue(true); 1290 1291 /** 1292 * @deprecated since 2.5 See SONAR-2007 1293 */ 1294 @Deprecated 1295 public static final String RELIABILITY_KEY = "reliability"; 1296 1297 /** 1298 * @deprecated since 2.5 See SONAR-2007 1299 */ 1300 @Deprecated 1301 public static final Metric RELIABILITY = new Metric(RELIABILITY_KEY, "Reliability", "Reliability", Metric.ValueType.PERCENT, 1302 Metric.DIRECTION_BETTER, true, DOMAIN_RULE_CATEGORIES).setBestValue(100.0).setOptimizedBestValue(true); 1303 1304 /** 1305 * @deprecated since 2.5 See SONAR-2007 1306 */ 1307 @Deprecated 1308 public static final String EFFICIENCY_KEY = "efficiency"; 1309 1310 /** 1311 * @deprecated since 2.5 See SONAR-2007 1312 */ 1313 @Deprecated 1314 public static final Metric EFFICIENCY = new Metric(EFFICIENCY_KEY, "Efficiency", "Efficiency", Metric.ValueType.PERCENT, 1315 Metric.DIRECTION_BETTER, true, DOMAIN_RULE_CATEGORIES).setBestValue(100.0).setOptimizedBestValue(true); 1316 1317 /** 1318 * @deprecated since 2.5 See SONAR-2007 1319 */ 1320 @Deprecated 1321 public static final String PORTABILITY_KEY = "portability"; 1322 1323 /** 1324 * @deprecated since 2.5 See SONAR-2007 1325 */ 1326 @Deprecated 1327 public static final Metric PORTABILITY = new Metric(PORTABILITY_KEY, "Portability", "Portability", Metric.ValueType.PERCENT, 1328 Metric.DIRECTION_BETTER, true, DOMAIN_RULE_CATEGORIES).setBestValue(100.0).setOptimizedBestValue(true); 1329 1330 /** 1331 * @deprecated since 2.5 See SONAR-2007 1332 */ 1333 @Deprecated 1334 public static final String MAINTAINABILITY_KEY = "maintainability"; 1335 1336 /** 1337 * @deprecated since 2.5 See SONAR-2007 1338 */ 1339 @Deprecated 1340 public static final Metric MAINTAINABILITY = new Metric.Builder(MAINTAINABILITY_KEY, "Maintainability", Metric.ValueType.PERCENT) 1341 .setDescription("Maintainability") 1342 .setDirection(Metric.DIRECTION_BETTER) 1343 .setQualitative(true) 1344 .setDomain(DOMAIN_RULE_CATEGORIES) 1345 .setBestValue(100.0) 1346 .setOptimizedBestValue(true) 1347 .create(); 1348 1349 public static final String WEIGHTED_VIOLATIONS_KEY = "weighted_violations"; 1350 public static final Metric WEIGHTED_VIOLATIONS = new Metric.Builder(WEIGHTED_VIOLATIONS_KEY, "Weighted violations", Metric.ValueType.INT) 1351 .setDescription("Weighted Violations") 1352 .setDirection(Metric.DIRECTION_WORST) 1353 .setQualitative(true) 1354 .setDomain(DOMAIN_RULES) 1355 .setBestValue(0.0) 1356 .setOptimizedBestValue(true) 1357 .create(); 1358 1359 public static final String VIOLATIONS_DENSITY_KEY = "violations_density"; 1360 public static final Metric VIOLATIONS_DENSITY = new Metric.Builder(VIOLATIONS_DENSITY_KEY, "Rules compliance", Metric.ValueType.PERCENT) 1361 .setDescription("Rules compliance") 1362 .setDirection(Metric.DIRECTION_BETTER) 1363 .setQualitative(true) 1364 .setDomain(DOMAIN_RULES) 1365 .create(); 1366 1367 public static final String VIOLATIONS_KEY = "violations"; 1368 public static final Metric VIOLATIONS = new Metric.Builder(VIOLATIONS_KEY, "Violations", Metric.ValueType.INT) 1369 .setDescription("Violations") 1370 .setDirection(Metric.DIRECTION_WORST) 1371 .setQualitative(true) 1372 .setDomain(DOMAIN_RULES) 1373 .setBestValue(0.0) 1374 .setOptimizedBestValue(true) 1375 .create(); 1376 1377 public static final String BLOCKER_VIOLATIONS_KEY = "blocker_violations"; 1378 public static final Metric BLOCKER_VIOLATIONS = new Metric.Builder(BLOCKER_VIOLATIONS_KEY, "Blocker violations", Metric.ValueType.INT) 1379 .setDescription("Blocker violations") 1380 .setDirection(Metric.DIRECTION_WORST) 1381 .setQualitative(true) 1382 .setDomain(DOMAIN_RULES) 1383 .setBestValue(0.0) 1384 .setOptimizedBestValue(true) 1385 .create(); 1386 1387 public static final String CRITICAL_VIOLATIONS_KEY = "critical_violations"; 1388 public static final Metric CRITICAL_VIOLATIONS = new Metric.Builder(CRITICAL_VIOLATIONS_KEY, "Critical violations", Metric.ValueType.INT) 1389 .setDescription("Critical violations") 1390 .setDirection(Metric.DIRECTION_WORST) 1391 .setQualitative(true) 1392 .setDomain(DOMAIN_RULES) 1393 .setBestValue(0.0) 1394 .setOptimizedBestValue(true) 1395 .create(); 1396 1397 public static final String MAJOR_VIOLATIONS_KEY = "major_violations"; 1398 public static final Metric MAJOR_VIOLATIONS = new Metric.Builder(MAJOR_VIOLATIONS_KEY, "Major violations", Metric.ValueType.INT) 1399 .setDescription("Major violations") 1400 .setDirection(Metric.DIRECTION_WORST) 1401 .setQualitative(true) 1402 .setDomain(DOMAIN_RULES) 1403 .setBestValue(0.0) 1404 .setOptimizedBestValue(true) 1405 .create(); 1406 1407 public static final String MINOR_VIOLATIONS_KEY = "minor_violations"; 1408 public static final Metric MINOR_VIOLATIONS = new Metric.Builder(MINOR_VIOLATIONS_KEY, "Minor violations", Metric.ValueType.INT) 1409 .setDescription("Minor violations") 1410 .setDirection(Metric.DIRECTION_WORST) 1411 .setQualitative(true) 1412 .setDomain(DOMAIN_RULES) 1413 .setBestValue(0.0) 1414 .setOptimizedBestValue(true) 1415 .create(); 1416 1417 public static final String INFO_VIOLATIONS_KEY = "info_violations"; 1418 public static final Metric INFO_VIOLATIONS = new Metric.Builder(INFO_VIOLATIONS_KEY, "Info violations", Metric.ValueType.INT) 1419 .setDescription("Info violations") 1420 .setDirection(Metric.DIRECTION_WORST) 1421 .setQualitative(true) 1422 .setDomain(DOMAIN_RULES) 1423 .setBestValue(0.0) 1424 .setOptimizedBestValue(true) 1425 .create(); 1426 1427 public static final String NEW_VIOLATIONS_KEY = "new_violations"; 1428 public static final Metric NEW_VIOLATIONS = new Metric.Builder(NEW_VIOLATIONS_KEY, "New Violations", Metric.ValueType.INT) 1429 .setDescription("New Violations") 1430 .setDirection(Metric.DIRECTION_WORST) 1431 .setQualitative(true) 1432 .setDomain(DOMAIN_RULES) 1433 .setBestValue(0.0) 1434 .setOptimizedBestValue(true) 1435 .setDeleteHistoricalData(true) 1436 .create(); 1437 1438 public static final String NEW_BLOCKER_VIOLATIONS_KEY = "new_blocker_violations"; 1439 public static final Metric NEW_BLOCKER_VIOLATIONS = new Metric.Builder(NEW_BLOCKER_VIOLATIONS_KEY, "New Blocker violations", Metric.ValueType.INT) 1440 .setDescription("New Blocker violations") 1441 .setDirection(Metric.DIRECTION_WORST) 1442 .setQualitative(true) 1443 .setDomain(DOMAIN_RULES) 1444 .setBestValue(0.0) 1445 .setOptimizedBestValue(true) 1446 .setDeleteHistoricalData(true) 1447 .create(); 1448 1449 public static final String NEW_CRITICAL_VIOLATIONS_KEY = "new_critical_violations"; 1450 public static final Metric NEW_CRITICAL_VIOLATIONS = new Metric.Builder(NEW_CRITICAL_VIOLATIONS_KEY, "New Critical violations", Metric.ValueType.INT) 1451 .setDescription("New Critical violations") 1452 .setDirection(Metric.DIRECTION_WORST) 1453 .setQualitative(true) 1454 .setDomain(DOMAIN_RULES) 1455 .setBestValue(0.0) 1456 .setOptimizedBestValue(true) 1457 .setDeleteHistoricalData(true) 1458 .create(); 1459 1460 public static final String NEW_MAJOR_VIOLATIONS_KEY = "new_major_violations"; 1461 public static final Metric NEW_MAJOR_VIOLATIONS = new Metric.Builder(NEW_MAJOR_VIOLATIONS_KEY, "New Major violations", Metric.ValueType.INT) 1462 .setDescription("New Major violations") 1463 .setDirection(Metric.DIRECTION_WORST) 1464 .setQualitative(true) 1465 .setDomain(DOMAIN_RULES) 1466 .setBestValue(0.0) 1467 .setOptimizedBestValue(true) 1468 .setDeleteHistoricalData(true) 1469 .create(); 1470 1471 public static final String NEW_MINOR_VIOLATIONS_KEY = "new_minor_violations"; 1472 public static final Metric NEW_MINOR_VIOLATIONS = new Metric.Builder(NEW_MINOR_VIOLATIONS_KEY, "New Minor violations", Metric.ValueType.INT) 1473 .setDescription("New Minor violations") 1474 .setDirection(Metric.DIRECTION_WORST) 1475 .setQualitative(true) 1476 .setDomain(DOMAIN_RULES) 1477 .setBestValue(0.0) 1478 .setOptimizedBestValue(true) 1479 .setDeleteHistoricalData(true) 1480 .create(); 1481 1482 public static final String NEW_INFO_VIOLATIONS_KEY = "new_info_violations"; 1483 public static final Metric NEW_INFO_VIOLATIONS = new Metric.Builder(NEW_INFO_VIOLATIONS_KEY, "New Info violations", Metric.ValueType.INT) 1484 .setDescription("New Info violations") 1485 .setDirection(Metric.DIRECTION_WORST) 1486 .setQualitative(true) 1487 .setDomain(DOMAIN_RULES) 1488 .setBestValue(0.0) 1489 .setOptimizedBestValue(true) 1490 .setDeleteHistoricalData(true) 1491 .create(); 1492 1493 // -------------------------------------------------------------------------------------------------------------------- 1494 // 1495 // DESIGN 1496 // 1497 // -------------------------------------------------------------------------------------------------------------------- 1498 1499 public static final String ABSTRACTNESS_KEY = "abstractness"; 1500 public static final Metric ABSTRACTNESS = new Metric.Builder(ABSTRACTNESS_KEY, "Abstractness", Metric.ValueType.PERCENT) 1501 .setDescription("Abstractness") 1502 .setDirection(Metric.DIRECTION_NONE) 1503 .setQualitative(false) 1504 .setDomain(DOMAIN_DESIGN) 1505 .create(); 1506 1507 public static final String INSTABILITY_KEY = "instability"; 1508 public static final Metric INSTABILITY = new Metric.Builder(INSTABILITY_KEY, "Instability", Metric.ValueType.PERCENT) 1509 .setDescription("Instability") 1510 .setDirection(Metric.DIRECTION_NONE) 1511 .setQualitative(false) 1512 .setDomain(DOMAIN_DESIGN) 1513 .create(); 1514 1515 public static final String DISTANCE_KEY = "distance"; 1516 public static final Metric DISTANCE = new Metric.Builder(DISTANCE_KEY, "Distance", Metric.ValueType.FLOAT) 1517 .setDescription("Distance") 1518 .setDirection(Metric.DIRECTION_NONE) 1519 .setQualitative(false) 1520 .setDomain(DOMAIN_DESIGN) 1521 .create(); 1522 1523 public static final String DEPTH_IN_TREE_KEY = "dit"; 1524 public static final Metric DEPTH_IN_TREE = new Metric.Builder(DEPTH_IN_TREE_KEY, "Depth in Tree", Metric.ValueType.INT) 1525 .setDescription("Depth in Inheritance Tree") 1526 .setDirection(Metric.DIRECTION_NONE) 1527 .setQualitative(false) 1528 .setDomain(DOMAIN_DESIGN) 1529 .create(); 1530 1531 public static final String NUMBER_OF_CHILDREN_KEY = "noc"; 1532 public static final Metric NUMBER_OF_CHILDREN = new Metric.Builder(NUMBER_OF_CHILDREN_KEY, "Number of Children", Metric.ValueType.INT) 1533 .setDescription("Number of Children") 1534 .setDirection(Metric.DIRECTION_NONE) 1535 .setQualitative(false) 1536 .setDomain(DOMAIN_DESIGN) 1537 .create(); 1538 1539 public static final String RFC_KEY = "rfc"; 1540 public static final Metric RFC = new Metric.Builder(RFC_KEY, "RFC", Metric.ValueType.INT) 1541 .setDescription("Response for Class") 1542 .setDirection(Metric.DIRECTION_WORST) 1543 .setQualitative(false) 1544 .setDomain(DOMAIN_DESIGN) 1545 .setFormula(new WeightedMeanAggregationFormula(CoreMetrics.FILES, false)) 1546 .create(); 1547 1548 public static final String RFC_DISTRIBUTION_KEY = "rfc_distribution"; 1549 public static final Metric RFC_DISTRIBUTION = new Metric.Builder(RFC_DISTRIBUTION_KEY, "Class distribution /RFC", Metric.ValueType.DISTRIB) 1550 .setDescription("Class distribution /RFC") 1551 .setDirection(Metric.DIRECTION_NONE) 1552 .setQualitative(true) 1553 .setDomain(DOMAIN_DESIGN) 1554 .setFormula(new SumChildDistributionFormula().setMinimumScopeToPersist(Scopes.DIRECTORY)) 1555 .create(); 1556 1557 public static final String LCOM4_KEY = "lcom4"; 1558 public static final Metric LCOM4 = new Metric.Builder(LCOM4_KEY, "LCOM4", Metric.ValueType.FLOAT) 1559 .setDescription("Lack of Cohesion of Methods") 1560 .setDirection(Metric.DIRECTION_WORST) 1561 .setQualitative(true) 1562 .setDomain(DOMAIN_DESIGN) 1563 .setBestValue(1.0) 1564 .setFormula(new WeightedMeanAggregationFormula(CoreMetrics.FILES, false)) 1565 .create(); 1566 1567 public static final String LCOM4_BLOCKS_KEY = "lcom4_blocks"; 1568 public static final Metric LCOM4_BLOCKS = new Metric.Builder(LCOM4_BLOCKS_KEY, "LCOM4 blocks", Metric.ValueType.DATA) 1569 .setDescription("LCOM4 blocks") 1570 .setDirection(Metric.DIRECTION_NONE) 1571 .setQualitative(false) 1572 .setDomain(DOMAIN_DESIGN) 1573 .setHidden(true) 1574 .setDeleteHistoricalData(true) 1575 .create(); 1576 1577 public static final String LCOM4_DISTRIBUTION_KEY = "lcom4_distribution"; 1578 public static final Metric LCOM4_DISTRIBUTION = new Metric.Builder(LCOM4_DISTRIBUTION_KEY, "Class distribution /LCOM4", Metric.ValueType.DISTRIB) 1579 .setDescription("Class distribution /LCOM4") 1580 .setDirection(Metric.DIRECTION_NONE) 1581 .setQualitative(true) 1582 .setDomain(DOMAIN_DESIGN) 1583 .setFormula(new SumChildDistributionFormula().setMinimumScopeToPersist(Scopes.DIRECTORY)) 1584 .create(); 1585 1586 public static final String SUSPECT_LCOM4_DENSITY_KEY = "suspect_lcom4_density"; 1587 public static final Metric SUSPECT_LCOM4_DENSITY = new Metric.Builder(SUSPECT_LCOM4_DENSITY_KEY, "Suspect LCOM4 density", Metric.ValueType.PERCENT) 1588 .setDescription("Density of classes having LCOM4>1") 1589 .setDirection(Metric.DIRECTION_WORST) 1590 .setQualitative(true) 1591 .setDomain(DOMAIN_DESIGN) 1592 .create(); 1593 1594 public static final String AFFERENT_COUPLINGS_KEY = "ca"; 1595 public static final Metric AFFERENT_COUPLINGS = new Metric.Builder(AFFERENT_COUPLINGS_KEY, "Afferent couplings", Metric.ValueType.INT) 1596 .setDescription("Afferent couplings") 1597 .setDirection(Metric.DIRECTION_WORST) 1598 .setQualitative(false) 1599 .setDomain(DOMAIN_DESIGN) 1600 .create(); 1601 1602 public static final String EFFERENT_COUPLINGS_KEY = "ce"; 1603 public static final Metric EFFERENT_COUPLINGS = new Metric.Builder(EFFERENT_COUPLINGS_KEY, "Efferent couplings", Metric.ValueType.INT) 1604 .setDescription("Efferent couplings") 1605 .setDirection(Metric.DIRECTION_WORST) 1606 .setQualitative(false) 1607 .setDomain(DOMAIN_DESIGN) 1608 .create(); 1609 1610 public static final String DEPENDENCY_MATRIX_KEY = "dsm"; 1611 public static final Metric DEPENDENCY_MATRIX = new Metric.Builder(DEPENDENCY_MATRIX_KEY, "Dependency Matrix", Metric.ValueType.DATA) 1612 .setDescription("Dependency Matrix") 1613 .setDirection(Metric.DIRECTION_NONE) 1614 .setQualitative(false) 1615 .setDomain(DOMAIN_DESIGN) 1616 .setDeleteHistoricalData(true) 1617 .create(); 1618 1619 public static final String PACKAGE_CYCLES_KEY = "package_cycles"; 1620 public static final Metric PACKAGE_CYCLES = new Metric.Builder(PACKAGE_CYCLES_KEY, "Package cycles", Metric.ValueType.INT) 1621 .setDescription("Package cycles") 1622 .setDirection(Metric.DIRECTION_WORST) 1623 .setQualitative(true) 1624 .setDomain(DOMAIN_DESIGN) 1625 .setBestValue(0.0) 1626 .setFormula(new SumChildValuesFormula(false)) 1627 .create(); 1628 1629 public static final String PACKAGE_TANGLE_INDEX_KEY = "package_tangle_index"; 1630 public static final Metric PACKAGE_TANGLE_INDEX = new Metric.Builder(PACKAGE_TANGLE_INDEX_KEY, "Package tangle index", Metric.ValueType.PERCENT) 1631 .setDescription("Package tangle index") 1632 .setDirection(Metric.DIRECTION_WORST) 1633 .setQualitative(true) 1634 .setBestValue(0.0) 1635 .setDomain(DOMAIN_DESIGN) 1636 .create(); 1637 1638 public static final String PACKAGE_TANGLES_KEY = "package_tangles"; 1639 public static final Metric PACKAGE_TANGLES = new Metric.Builder(PACKAGE_TANGLES_KEY, "File dependencies to cut", Metric.ValueType.INT) 1640 .setDescription("File dependencies to cut") 1641 .setDirection(Metric.DIRECTION_WORST) 1642 .setQualitative(false) 1643 .setDomain(DOMAIN_DESIGN) 1644 .setFormula(new SumChildValuesFormula(false)) 1645 .create(); 1646 1647 public static final String PACKAGE_FEEDBACK_EDGES_KEY = "package_feedback_edges"; 1648 public static final Metric PACKAGE_FEEDBACK_EDGES = new Metric.Builder(PACKAGE_FEEDBACK_EDGES_KEY, "Package dependencies to cut", Metric.ValueType.INT) 1649 .setDescription("Package dependencies to cut") 1650 .setDirection(Metric.DIRECTION_WORST) 1651 .setQualitative(false) 1652 .setDomain(DOMAIN_DESIGN) 1653 .setFormula(new SumChildValuesFormula(false)) 1654 .setBestValue(0.0) 1655 .create(); 1656 1657 public static final String PACKAGE_EDGES_WEIGHT_KEY = "package_edges_weight"; 1658 public static final Metric PACKAGE_EDGES_WEIGHT = new Metric.Builder(PACKAGE_EDGES_WEIGHT_KEY, "Package edges weight", Metric.ValueType.INT) 1659 .setDescription("Package edges weight") 1660 .setDirection(Metric.DIRECTION_BETTER) 1661 .setQualitative(false) 1662 .setDomain(DOMAIN_DESIGN) 1663 .setFormula(new SumChildValuesFormula(false)) 1664 .setHidden(true) 1665 .setDeleteHistoricalData(true) 1666 .create(); 1667 1668 public static final String FILE_CYCLES_KEY = "file_cycles"; 1669 public static final Metric FILE_CYCLES = new Metric.Builder(FILE_CYCLES_KEY, "File cycles", Metric.ValueType.INT) 1670 .setDescription("File cycles") 1671 .setDirection(Metric.DIRECTION_WORST) 1672 .setQualitative(true) 1673 .setDomain(DOMAIN_DESIGN) 1674 .setHidden(true) 1675 .setDeleteHistoricalData(true) 1676 .setBestValue(0.0) 1677 .create(); 1678 1679 public static final String FILE_TANGLE_INDEX_KEY = "file_tangle_index"; 1680 public static final Metric FILE_TANGLE_INDEX = new Metric.Builder(FILE_TANGLE_INDEX_KEY, "File tangle index", Metric.ValueType.PERCENT) 1681 .setDescription("File tangle index") 1682 .setDirection(Metric.DIRECTION_WORST) 1683 .setQualitative(true) 1684 .setDomain(DOMAIN_DESIGN) 1685 .setHidden(true) 1686 .setDeleteHistoricalData(true) 1687 .setBestValue(0.0) 1688 .create(); 1689 1690 public static final String FILE_TANGLES_KEY = "file_tangles"; 1691 public static final Metric FILE_TANGLES = new Metric.Builder(FILE_TANGLES_KEY, "File tangles", Metric.ValueType.INT) 1692 .setDescription("Files tangles") 1693 .setDirection(Metric.DIRECTION_WORST) 1694 .setQualitative(false) 1695 .setDomain(DOMAIN_DESIGN) 1696 .setHidden(true) 1697 .setDeleteHistoricalData(true) 1698 .create(); 1699 1700 public static final String FILE_FEEDBACK_EDGES_KEY = "file_feedback_edges"; 1701 public static final Metric FILE_FEEDBACK_EDGES = new Metric.Builder(FILE_FEEDBACK_EDGES_KEY, "Suspect file dependencies", Metric.ValueType.INT) 1702 .setDescription("Suspect file dependencies") 1703 .setDirection(Metric.DIRECTION_WORST) 1704 .setQualitative(false) 1705 .setDomain(DOMAIN_DESIGN) 1706 .setHidden(true) 1707 .setDeleteHistoricalData(true) 1708 .setBestValue(0.0) 1709 .create(); 1710 1711 public static final String FILE_EDGES_WEIGHT_KEY = "file_edges_weight"; 1712 public static final Metric FILE_EDGES_WEIGHT = new Metric.Builder(FILE_EDGES_WEIGHT_KEY, "File edges weight", Metric.ValueType.INT) 1713 .setDescription("File edges weight") 1714 .setDirection(Metric.DIRECTION_BETTER) 1715 .setQualitative(false) 1716 .setDomain(DOMAIN_DESIGN) 1717 .setHidden(true) 1718 .setDeleteHistoricalData(true) 1719 .create(); 1720 1721 // -------------------------------------------------------------------------------------------------------------------- 1722 // 1723 // SCM 1724 // These metrics are computed by the SCM Activity plugin, since version 1.2 and introduced here since version 2.7. 1725 // 1726 // -------------------------------------------------------------------------------------------------------------------- 1727 1728 /** 1729 * @since 2.7 1730 */ 1731 public static final String SCM_AUTHORS_BY_LINE_KEY = "authors_by_line"; 1732 1733 /** 1734 * Key-value pairs, where key - is a number of line, and value - is an author for this line. 1735 * 1736 * @see org.sonar.api.utils.KeyValueFormat#formatIntString(java.util.Map) 1737 * @see org.sonar.api.utils.KeyValueFormat#parseIntString(String) 1738 * @since 2.7 1739 */ 1740 public static final Metric SCM_AUTHORS_BY_LINE = new Metric.Builder(SCM_AUTHORS_BY_LINE_KEY, "Authors by line", Metric.ValueType.DATA) 1741 .setDomain(DOMAIN_SCM) 1742 .create(); 1743 1744 /** 1745 * @since 2.7 1746 */ 1747 public static final String SCM_REVISIONS_BY_LINE_KEY = "revisions_by_line"; 1748 1749 /** 1750 * Key-value pairs, where key - is a number of line, and value - is a revision for this line. 1751 * 1752 * @see org.sonar.api.utils.KeyValueFormat#formatIntString(java.util.Map) 1753 * @see org.sonar.api.utils.KeyValueFormat#parseIntString(String) 1754 * @since 2.7 1755 */ 1756 public static final Metric SCM_REVISIONS_BY_LINE = new Metric.Builder(SCM_REVISIONS_BY_LINE_KEY, "Revisions by line", Metric.ValueType.DATA) 1757 .setDomain(DOMAIN_SCM) 1758 .create(); 1759 1760 /** 1761 * @since 2.7 1762 */ 1763 public static final String SCM_LAST_COMMIT_DATETIMES_BY_LINE_KEY = "last_commit_datetimes_by_line"; 1764 1765 /** 1766 * Key-value pairs, where key - is a number of line, and value - is a date of last commit for this line. 1767 * 1768 * @see org.sonar.api.utils.KeyValueFormat#formatIntDateTime(java.util.Map) 1769 * @see org.sonar.api.utils.KeyValueFormat#parseIntDateTime(String) 1770 * @since 2.7 1771 */ 1772 public static final Metric SCM_LAST_COMMIT_DATETIMES_BY_LINE = new Metric.Builder(SCM_LAST_COMMIT_DATETIMES_BY_LINE_KEY, "Last commit dates by line", Metric.ValueType.DATA) 1773 .setDomain(DOMAIN_SCM) 1774 .create(); 1775 1776 // -------------------------------------------------------------------------------------------------------------------- 1777 // 1778 // REVIEWS (since 2.14) 1779 // 1780 // -------------------------------------------------------------------------------------------------------------------- 1781 1782 /** 1783 * @since 2.14 1784 */ 1785 public static final String UNREVIEWED_VIOLATIONS_KEY = "unreviewed_violations"; 1786 1787 /** 1788 * @since 2.14 1789 */ 1790 public static final Metric UNREVIEWED_VIOLATIONS = new Metric.Builder(UNREVIEWED_VIOLATIONS_KEY, "Unreviewed violations", Metric.ValueType.INT) 1791 .setDescription("Violations that have not been reviewed yet") 1792 .setDirection(Metric.DIRECTION_WORST) 1793 .setDomain(DOMAIN_REVIEWS) 1794 .setBestValue(0.0) 1795 .setOptimizedBestValue(true) 1796 .create(); 1797 1798 /** 1799 * @since 2.14 1800 */ 1801 public static final String NEW_UNREVIEWED_VIOLATIONS_KEY = "new_unreviewed_violations"; 1802 1803 /** 1804 * @since 2.14 1805 */ 1806 public static final Metric NEW_UNREVIEWED_VIOLATIONS = new Metric.Builder(NEW_UNREVIEWED_VIOLATIONS_KEY, "New unreviewed violations", Metric.ValueType.INT) 1807 .setDescription("New violations that have not been reviewed yet") 1808 .setDirection(Metric.DIRECTION_WORST) 1809 .setQualitative(true) 1810 .setDomain(DOMAIN_REVIEWS) 1811 .setBestValue(0.0) 1812 .setOptimizedBestValue(true) 1813 .setDeleteHistoricalData(true) 1814 .create(); 1815 1816 /** 1817 * @since 2.14 1818 */ 1819 public static final String FALSE_POSITIVE_REVIEWS_KEY = "false_positive_reviews"; 1820 1821 /** 1822 * @since 2.14 1823 */ 1824 public static final Metric FALSE_POSITIVE_REVIEWS = new Metric.Builder(FALSE_POSITIVE_REVIEWS_KEY, "False-positive reviews", Metric.ValueType.INT) 1825 .setDescription("Active false-positive reviews") 1826 .setDirection(Metric.DIRECTION_WORST) 1827 .setDomain(DOMAIN_REVIEWS) 1828 .setBestValue(0.0) 1829 .setOptimizedBestValue(true) 1830 .create(); 1831 1832 /** 1833 * @since 2.14 1834 */ 1835 public static final String ACTIVE_REVIEWS_KEY = "active_reviews"; 1836 1837 /** 1838 * @since 2.14 1839 */ 1840 public static final Metric ACTIVE_REVIEWS = new Metric.Builder(ACTIVE_REVIEWS_KEY, "Active reviews", Metric.ValueType.INT) 1841 .setDescription("Active open and reopened reviews") 1842 .setDirection(Metric.DIRECTION_WORST) 1843 .setDomain(DOMAIN_REVIEWS) 1844 .setBestValue(0.0) 1845 .setOptimizedBestValue(true) 1846 .create(); 1847 1848 /** 1849 * @since 2.14 1850 */ 1851 public static final String UNASSIGNED_REVIEWS_KEY = "unassigned_reviews"; 1852 1853 /** 1854 * @since 2.14 1855 */ 1856 public static final Metric UNASSIGNED_REVIEWS = new Metric.Builder(UNASSIGNED_REVIEWS_KEY, "Unassigned reviews", Metric.ValueType.INT) 1857 .setDescription("Active unassigned reviews") 1858 .setDirection(Metric.DIRECTION_WORST) 1859 .setDomain(DOMAIN_REVIEWS) 1860 .setBestValue(0.0) 1861 .setOptimizedBestValue(true) 1862 .create(); 1863 1864 /** 1865 * @since 2.14 1866 */ 1867 public static final String UNPLANNED_REVIEWS_KEY = "unplanned_reviews"; 1868 1869 /** 1870 * @since 2.14 1871 */ 1872 public static final Metric UNPLANNED_REVIEWS = new Metric.Builder(UNPLANNED_REVIEWS_KEY, "Unplanned reviews", Metric.ValueType.INT) 1873 .setDescription("Active unplanned reviews") 1874 .setDirection(Metric.DIRECTION_WORST) 1875 .setDomain(DOMAIN_REVIEWS) 1876 .setBestValue(0.0) 1877 .setOptimizedBestValue(true) 1878 .create(); 1879 1880 // -------------------------------------------------------------------------------------------------------------------- 1881 // 1882 // FILE DATA 1883 // 1884 // -------------------------------------------------------------------------------------------------------------------- 1885 1886 /** 1887 * @since 2.14 1888 */ 1889 @Beta 1890 public static final String NCLOC_DATA_KEY = "ncloc_data"; 1891 1892 /** 1893 * Information about lines of code in file. 1894 * Key-value pairs, where key - is a number of line, and value - is an indicator of whether line contains code (1) or not (0). 1895 * 1896 * @see org.sonar.api.measures.FileLinesContext 1897 * @since 2.14 1898 */ 1899 @Beta 1900 public static final Metric NCLOC_DATA = new Metric.Builder(NCLOC_DATA_KEY, "ncloc_data", Metric.ValueType.DATA) 1901 .setHidden(true) 1902 .setDomain(DOMAIN_SIZE) 1903 .create(); 1904 1905 /** 1906 * @since 2.14 1907 */ 1908 @Beta 1909 public static final String COMMENT_LINES_DATA_KEY = "comment_lines_data"; 1910 1911 /** 1912 * Information about comments in file. 1913 * Key-value pairs, where key - is a number of line, and value - is an indicator of whether line contains comment (1) or not (0). 1914 * 1915 * @see org.sonar.api.measures.FileLinesContext 1916 * @since 2.14 1917 */ 1918 @Beta 1919 public static final Metric COMMENT_LINES_DATA = new Metric.Builder(COMMENT_LINES_DATA_KEY, "comment_lines_data", Metric.ValueType.DATA) 1920 .setHidden(true) 1921 .setDomain(DOMAIN_DOCUMENTATION) 1922 .create(); 1923 1924 // -------------------------------------------------------------------------------------------------------------------- 1925 // 1926 // OTHERS 1927 // 1928 // -------------------------------------------------------------------------------------------------------------------- 1929 1930 public static final String ALERT_STATUS_KEY = "alert_status"; 1931 public static final Metric ALERT_STATUS = new Metric.Builder(ALERT_STATUS_KEY, "Alert", Metric.ValueType.LEVEL) 1932 .setDescription("Alert") 1933 .setDirection(Metric.DIRECTION_BETTER) 1934 .setQualitative(true) 1935 .setDomain(DOMAIN_GENERAL) 1936 .create(); 1937 1938 public static final String PROFILE_KEY = "profile"; 1939 public static final Metric PROFILE = new Metric.Builder(PROFILE_KEY, "Profile", Metric.ValueType.DATA) 1940 .setDescription("Selected quality profile") 1941 .setDomain(DOMAIN_GENERAL) 1942 .create(); 1943 1944 /** 1945 * @since 2.9 1946 */ 1947 public static final String PROFILE_VERSION_KEY = "profile_version"; 1948 1949 /** 1950 * @since 2.9 1951 */ 1952 public static final Metric PROFILE_VERSION = new Metric.Builder(PROFILE_VERSION_KEY, "Profile version", Metric.ValueType.INT) 1953 .setDescription("Selected quality profile version") 1954 .setQualitative(false) 1955 .setDomain(DOMAIN_GENERAL) 1956 .setHidden(true) 1957 .create(); 1958 1959 private static final List<Metric> METRICS; 1960 1961 static { 1962 METRICS = Lists.newLinkedList(); 1963 for (Field field : CoreMetrics.class.getFields()) { 1964 if (Metric.class.isAssignableFrom(field.getType())) { 1965 try { 1966 Metric metric = (Metric) field.get(null); 1967 if (!StringUtils.equals(metric.getDomain(), DOMAIN_RULE_CATEGORIES)) { 1968 METRICS.add(metric); 1969 } 1970 } catch (IllegalAccessException e) { 1971 throw new SonarException("can not introspect " + CoreMetrics.class + " to get metrics", e); 1972 } 1973 } 1974 } 1975 } 1976 1977 public static List<Metric> getMetrics() { 1978 return METRICS; 1979 } 1980}