Java Severity类代码示例

import org.sonar.api.rule.Severity; //导入依赖的package包/类
@Override
public void define(Context context) {
  for (Language language : languages.all()) {
    NewRepository repo = context
        .createRepository(getRepositoryName(language.getKey()), language.getKey());
    repo.setName("Coverage evolution");

    repo.createRule(decreasingLineCoverageRule)
        .setName("Line-coverage on files should not decrease")
        .setMarkdownDescription("Reports if the line-coverage on a file has decreased.")
        .setTags("bad-practice")
        .setSeverity(Severity.BLOCKER)
    ;
    repo.createRule(decreasingOverallLineCoverageRule)
        .setName("Project-wide line-coverage should not decrease")
        .setMarkdownDescription("Reports if the line-coverage on the project has decreased.")
        .setTags("bad-practice")
        .setSeverity(Severity.BLOCKER)
    ;

    repo.done();
  }
}
 

import org.sonar.api.rule.Severity; //导入依赖的package包/类
@Override
public void define(Context context)
{
    NewRepository repository = context.createRepository(LicenseCheckMetrics.LICENSE_CHECK_KEY, "java");
    repository.setName("License Check");

    repository
        .createRule(LicenseCheckMetrics.LICENSE_CHECK_UNLISTED_KEY)
        .setName("Dependency has unknown license [license-check]")
        .setHtmlDescription("The dependencies license could not be determined!")
        .setSeverity(Severity.BLOCKER);

    repository
        .createRule(LicenseCheckMetrics.LICENSE_CHECK_NOT_ALLOWED_LICENSE_KEY)
        .setName("License is not allowed [license-check]")
        .setHtmlDescription("Violation because the license of the dependency is not allowed.")
        .setSeverity(Severity.BLOCKER);

    repository.done();
}
 

import org.sonar.api.rule.Severity; //导入依赖的package包/类
@Override
public void define(final Context context) {
	

	final NewRepository repository = context.createRepository(REPOSITORY_KEY, LANGUAGE_KEY)
			.setName(REPOSITORY_NAME);

	for (final GeneratedProblemType problemType : GeneratedProblemType.values()) {
		final NewRule newRule = repository.createRule(problemType.name());
		newRule.setName(problemType.getPresentationName());
		newRule.setHtmlDescription(problemType.getDescription());
		newRule.setSeverity(Severity.MAJOR);
		newRule.setStatus(RuleStatus.READY);
		newRule.setTags(XANITIZER_TAG, SECURITY_TAG);

		if (problemType.getPresentationName().startsWith("Application Server:")) {
			newRule.addTags(SERVER_CONFIG_TAG);
		}
	}

	repository.done();
}
 

import org.sonar.api.rule.Severity; //导入依赖的package包/类
@Test
public void testUpdateCountsMustKeepTrackOfAllUniqueSeveritiesAndIncreaseCountForNewIssues() {
	List<Issue> issues = new ArrayList<>();
	Map<String, SeverityCount> result = new HashMap<>();

	Issue issue = new DummyIssue(Severity.BLOCKER, true);
	issues.add(issue);
	issues.add(issue);

	SlackMessageBuilder.updateCountsWithIssues(result, issues);

	assertThat(result.size(), is(1));
	assertThat(result.get(Severity.BLOCKER).getTotalCount(), is(2L));
	assertThat(result.get(Severity.BLOCKER).getNewCount(), is(2L));
	assertThat(result.get(Severity.BLOCKER).getResolvedCount(), is(0L));
}
 

import org.sonar.api.rule.Severity; //导入依赖的package包/类
@Test
public void testUpdateCountsMustKeepTrackOfAllUniqueSeveritiesAndIncreaseCountForResolvedIssues() {
	List<Issue> issues = new ArrayList<>();
	List<Issue> resolvedIssues = new ArrayList<>();
	Map<String, SeverityCount> result = new HashMap<>();

	issues.add(new DummyIssue(Severity.BLOCKER, false));
	issues.add(new DummyIssue(Severity.BLOCKER, true));
	resolvedIssues.add(new DummyIssue(Severity.BLOCKER, false));

	SlackMessageBuilder.updateCountsWithIssues(result, issues);
	SlackMessageBuilder.updateCountsWithResolvedIssues(result, resolvedIssues);

	assertThat(result.size(), is(1));
	assertThat(result.get(Severity.BLOCKER).getTotalCount(), is(2L));
	assertThat(result.get(Severity.BLOCKER).getNewCount(), is(1L));
	assertThat(result.get(Severity.BLOCKER).getResolvedCount(), is(1L));
}
 

import org.sonar.api.rule.Severity; //导入依赖的package包/类
/**
 * Initialization.
 *
 * @param repo the repository in which the rules is registered
 */
public static void init(RulesDefinition.NewRepository repo) {
    final RulesDefinition.NewRule rule = repo.createRule(RULE_KEY)
            .setName("The exception should be used in the catch block")
            .setHtmlDescription("The exception is not used, this is rather bad. You should use the exception " +
                    "object in your log, or rethrow it.")
            .addTags("error-handling")
            .setSeverity(Severity.MAJOR)
            .setDebtSubCharacteristic(RulesDefinition.SubCharacteristics.LOGIC_RELIABILITY);

    rule.createParam("exceptions").setType(RuleParamType.STRING)
            .setDescription("List of exceptions which should not be checked")
            .setDefaultValue("" + CaughtExceptionTouchedCheck.EXCLUDED_EXCEPTION_TYPE);

    rule.setDebtRemediationFunction(rule.debtRemediationFunctions().constantPerIssue("10min"));
}
 

import org.sonar.api.rule.Severity; //导入依赖的package包/类
@Test
public void ruleWithoutDebtRemediation() {
    TsLintRule rule = new TsLintRule(
        "key",
        Severity.MAJOR,
        "name",
        "<html></html>"
    );

    assertEquals("key", rule.key);
    assertEquals(Severity.MAJOR, rule.severity);
    assertEquals("name", rule.name);
    assertEquals("<html></html>", rule.htmlDescription);
    assertEquals(false, rule.hasDebtRemediation);
    assertEquals(DebtRemediationFunction.Type.CONSTANT_ISSUE, rule.debtRemediationFunction);
    assertEquals("0min", rule.debtRemediationScalar);
    assertEquals("0min", rule.debtRemediationOffset);
    assertEquals(null, rule.debtType);
}
 

import org.sonar.api.rule.Severity; //导入依赖的package包/类
@Test
public void ruleWithDebtRemediation() {
    TsLintRule rule = new TsLintRule(
        "key",
        Severity.MAJOR,
        "name",
        "<html></html>",
        DebtRemediationFunction.Type.LINEAR_OFFSET,
        "1min",
        "2min",
        RuleType.CODE_SMELL.name()
    );

    assertEquals("key", rule.key);
    assertEquals(Severity.MAJOR, rule.severity);
    assertEquals("name", rule.name);
    assertEquals("<html></html>", rule.htmlDescription);
    assertEquals(true, rule.hasDebtRemediation);
    assertEquals(DebtRemediationFunction.Type.LINEAR_OFFSET, rule.debtRemediationFunction);
    assertEquals("1min", rule.debtRemediationScalar);
    assertEquals("2min", rule.debtRemediationOffset);
    assertEquals(RuleType.CODE_SMELL.name(), rule.debtType);
}
 

import org.sonar.api.rule.Severity; //导入依赖的package包/类
@Override
public boolean accept(FilterableIssue issue, IssueFilterChain chain) {
  if (disabled) {
    return true;
  }

  IssueKey issueKey = new IssueKey(issue.componentKey(), issue.ruleKey().toString(), issue.line());
  dump.add(issueKey);
  Multiset<IssueKey> componentIssues = getByComponentKey(issueKey.componentKey);
  if (componentIssues.contains(issueKey)) {
    // old issue => no need to persist
    componentIssues.remove(issueKey);
    Preconditions.checkState(Severity.INFO.equals(issue.severity()));
    return false;
  } else {
    // new issue => persist
    different = true;
    differences++;
    return true;
  }
}
 

import org.sonar.api.rule.Severity; //导入依赖的package包/类
@Override
public void define(final NewRepository repository) {
	LOGGER.debug("Defining rule in repostiory {}", repository.key());
	final NewRule afferentCouplingsRule = repository.createRule(RULE_KEY).setType(RuleType.CODE_SMELL)
			.setSeverity(Severity.MAJOR).setName("Afferent Coupling").setHtmlDescription(
					"The number of other packages that depend upon classes within the package is an indicator of the package's responsibility.");
	afferentCouplingsRule.createParam(PARAM_MAXIMUM).setName(PARAM_MAXIMUM)
			.setDescription("Maximum number of other packages allowed to depend upon classes within the package")
			.setType(RuleParamType.INTEGER).setDefaultValue("25");
}
 

import org.sonar.api.rule.Severity; //导入依赖的package包/类
@Override
public void define(final NewRepository repository) {
	LOGGER.debug("Defining rule in repostiory {}", repository.key());
	final NewRule numberOfClassesAndInterfacesRule = repository.createRule(RULE_KEY).setType(RuleType.CODE_SMELL)
			.setSeverity(Severity.MAJOR).setName("Number of Classes and Interfaces").setHtmlDescription(
					"The number of concrete and abstract classes (and interfaces) in the package is an indicator of the extensibility of the package.");
	numberOfClassesAndInterfacesRule.createParam(PARAM_MAXIMUM).setName(PARAM_MAXIMUM)
			.setDescription("Maximum number of classes and interfaces allowed in the package")
			.setType(RuleParamType.INTEGER).setDefaultValue("50");
}
 

import org.sonar.api.rule.Severity; //导入依赖的package包/类
@Override
public void define(final NewRepository repository) {
	LOGGER.debug("Defining rule in repostiory {}", repository.key());
	final NewRule efferentCouplingRule = repository.createRule(RULE_KEY).setType(RuleType.CODE_SMELL)
			.setSeverity(Severity.MAJOR).setName("Efferent Coupling").setHtmlDescription(
					"The number of other packages that the classes in the package depend upon is an indicator of the package's independence.");
	efferentCouplingRule.createParam(PARAM_MAXIMUM).setName(PARAM_MAXIMUM)
			.setDescription(
					"Maximum number of other packages that the classes in the package are allowed to depend upon")
			.setType(RuleParamType.INTEGER).setDefaultValue("25");
}
 

import org.sonar.api.rule.Severity; //导入依赖的package包/类
@Override
public void define(final NewRepository repository) {
	LOGGER.debug("Defining rule in repostiory {}", repository.key());
	final NewRule instabilityRule = repository.createRule(RULE_KEY).setType(RuleType.CODE_SMELL)
			.setSeverity(Severity.MAJOR).setName("Instability").setHtmlDescription(
					"The ratio of efferent coupling (Ce) to total coupling (Ce + Ca) such that I = Ce / (Ce + Ca). This metric is an indicator of the package's resilience to change.<br/>"
							+ "The range for this metric is 0 to 100%, with I=0% indicating a completely stable package and I=100% indicating a completely instable package.");
	instabilityRule.createParam(PARAM_MAXIMUM).setName(PARAM_MAXIMUM)
			.setDescription("Maximum instability (%) of a package allowed").setType(RuleParamType.INTEGER)
			.setDefaultValue("75");
}
 

import org.sonar.api.rule.Severity; //导入依赖的package包/类
@Override
public void define(final NewRepository repository) {
	LOGGER.debug("Defining rule in repostiory {}", repository.key());
	final NewRule abstractnessRule = repository.createRule(RULE_KEY).setType(RuleType.CODE_SMELL)
			.setSeverity(Severity.MAJOR).setName("Abstractness").setHtmlDescription(
					"The ratio of the number of abstract classes (and interfaces) in the analyzed package compared to the total number of classes in the analyzed package.<br/>"
							+ "The range for this metric is 0% to 100%, with A=0% indicating a completely concrete package and A=100% indicating a completely abstract package.");
	abstractnessRule.createParam(PARAM_MAXIMUM).setName(PARAM_MAXIMUM)
			.setDescription("Maximum abstractness of a package allowed").setType(RuleParamType.INTEGER)
			.setDefaultValue("75");
}
 

import org.sonar.api.rule.Severity; //导入依赖的package包/类
@Override
public void define(final NewRepository repository) {
	LOGGER.debug("Defining rule in repostiory {}", repository.key());
	repository.createRule(RULE_KEY).setType(RuleType.CODE_SMELL).setSeverity(Severity.BLOCKER)
			.setName("Missing package-info.java").setHtmlDescription(
					"When a package-info.java file is missing, no issues can be reported on the package level.");
}