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