Language independent checks

Java checks

Kotlin checks

Other

Dependency

publicclassDependencyTest {// Analyze all sources in src/main/javaprivatefinalAnalyzerConfigconfig =AnalyzerConfig.maven().main();@TestpublicvoidnoCycles() {assertThat(newDependencyAnalyzer(config).analyze(),hasNoCycles());    }@Testpublicvoiddependency() {// Defines the dependency rules for package org.projclassOrgProjextendsDependencyRuler {// Rules for org.proj.dep, org.proj.model, org.proj.utilDependencyRuledep,model,util;@OverridepublicvoiddefineRules() {base().mayUse(util,dep.allSubOf());//org.proj may use org.proj.util and all subpackages of org.proj.depdep.andAllSub().mustUse(model);//org.proj.dep and all subpackages thereof must use org.proj.modelmodel.mayUse(util).mustNotUse(base());//org.proj.model may use org.proj.util but not org.proj            }        }// All dependencies are forbidden, except the ones defined in OrgProj// java, org, net packages may be used freelyDependencyRulesrules =DependencyRules.denyAll()                .withRelativeRules(newOrgProj())                .withExternals("java.*","org.*","net.*");DependencyResultresult =newDependencyAnalyzer(config).rules(rules).analyze();assertThat(result,matchesRulesExactly());    }}

Test coverage

<plugin>    <groupId>guru.nidi</groupId>    <artifactId>code-assert-maven-plugin</artifactId>    <version>0.9.14</version>    <executions>        <execution>            <goals>                <goal>prepare</goal>                <goal>assert</goal>            </goals>        </execution>    </executions></plugin>

publicclassCodeCoverage {@Testpublicvoidcoverage() {// Coverage of branches must be at least 70%, lines 80% and methods 90%// This is checked globally and for all packages except for entities.JacocoAnalyzeranalyzer =newJacocoAnalyzer(newCoverageCollector(BRANCH,LINE,METHOD)                .just(For.global().setMinima(70,80,90))                .just(For.allPackages().setMinima(70,80,90))                .just(For.thePackage("org.proj.entity.*").setNoMinima()));assertThat(analyzer.analyze(),hasEnoughCoverage());    }}

FindBugs

publicclassFindBugsTest {@TestpublicvoidfindBugs() {// Analyze all sources in src/main/javaAnalyzerConfigconfig =AnalyzerConfig.maven().main();// Only treat bugs with rank < 17 and with NORMAL_PRIORITY or higher// Ignore the given bug types in the given classes / methods.BugCollectorcollector =newBugCollector().maxRank(17).minPriority(Priorities.NORMAL_PRIORITY)                .just(In.everywhere().ignore("UWF_FIELD_NOT_INITIALIZED_IN_CONSTRUCTOR"))                .because("It's checked and OK like this",In.classes(DependencyRules.class,PmdRuleset.class).ignore("DP_DO_INSIDE_DO_PRIVILEGED"),In.classes("*Test","Rulesets")                                .and(In.classes("ClassFileParser").withMethods("doParse"))                                .ignore("URF_UNREAD_FIELD"));FindBugsResultresult =newFindBugsAnalyzer(config,collector).analyze();assertThat(result,hasNoBugs());    }}

Checkstyle

publicclassCheckstyleTest {@Testpublicvoidcheckstyle() {// Analyze all sources in src/main/javaAnalyzerConfigconfig =AnalyzerConfig.maven().main();// Only treat issues with severity WARNING or higherStyleEventCollectorcollector =newStyleEventCollector().severity(SeverityLevel.WARNING)                .just(In.everywhere().ignore("import.avoidStar","javadoc.missing"))                .because("in tests, long lines are ok",In.classes("*Test").ignore("maxLineLen"));//use google checks, but adjust max line lengthfinalStyleCheckschecks =StyleChecks.google().maxLineLen(120);CheckstyleResultresult =newCheckstyleAnalyzer(config,checks,collector).analyze();assertThat(result,hasNoCheckstyleIssues());    }}

PMD

publicclassPmdTest {// Analyze all sources in src/main/javaprivatefinalAnalyzerConfigconfig =AnalyzerConfig.maven().main();@Testpublicvoidpmd() {// Only treat violations with MEDIUM priority or higher// Ignore the given violations in the given classes / methodsPmdViolationCollectorcollector =newPmdViolationCollector().minPriority(RulePriority.MEDIUM)                .because("It's not severe and occurs very often",In.everywhere().ignore("MethodArgumentCouldBeFinal"),In.locs("JavaClassBuilder#from","FindBugsMatchers").ignore("AvoidInstantiatingObjectsInLoops"))                .because("it'a an enum",In.classes("SignatureParser").ignore("SwitchStmtsShouldHaveDefault"))                .just(In.classes("*Test").ignore("TooManyStaticImports"));// Define and configure the rule sets to be usedPmdAnalyzeranalyzer =newPmdAnalyzer(config,collector).withRulesets(basic(),braces(),design(),empty(),optimizations(),codesize().excessiveMethodLength(40).tooManyMethods(30));assertThat(analyzer.analyze(),hasNoPmdViolations());    }@Testpublicvoidcpd() {// Ignore duplications in the given classesCpdMatchCollectorcollector =newCpdMatchCollector()                .because("equals",In.everywhere().ignore("public boolean equals(Object o) {"))                .just(In.classes(DependencyRule.class,Dependencies.class).ignoreAll(),In.classes("SignatureParser").ignoreAll());// Only treat duplications with at least 20 tokensCpdAnalyzeranalyzer =newCpdAnalyzer(config,20,collector);assertThat(analyzer.analyze(),hasNoCodeDuplications());    }}

ktlint

publicclassKtlintTest {@Testpublicvoidanalyze() {// Analyze all sources in src/main/kotlinAnalyzerConfigconfig =AnalyzerConfig.maven(KOTLIN).main();KtlintCollectorcollector =newKtlintCollector()                .just(In.classes("Linker").ignore("no-semi"));KtlintResultresult =newKtlintAnalyzer(config,collector).analyze();assertThat(result,hasNoKtlintIssues());    }}

detekt

publicclassDetektTest {@Testpublicvoidanalyze() {// Analyze all sources in src/main/kotlinAnalyzerConfigconfig =AnalyzerConfig.maven(KOTLIN).main();DetektCollectorcollector =newDetektCollector()                .just(In.classes("Linker").ignore("MaxLineLength"));DetektResultresult =newDetektAnalyzer(config,collector).analyze();assertThat(result,hasNoDetektIssues());    }}

Configuration reuse

privatefinalCollectorTemplate<Ignore>pmdTestCollector =CollectorTemplate.forA(PmdViolationCollector.class)        .because("It's a test",In.classes("*Test")                .ignore("JUnitSpelling","AvoidDuplicateLiterals","SignatureDeclareThrowsException"))        .because("It's compiler generated code",In.languages(KOTLIN)                .ignore("BC_BAD_CAST_TO_ABSTRACT_COLLECTION"));@Testpublicvoidpmd() {PmdViolationCollectorcollector =newPmdViolationCollector().minPriority(RulePriority.MEDIUM)            .apply(pmdTestCollector)            .because("It's not severe and occurs often",In.everywhere().ignore("MethodArgumentCouldBeFinal"));PmdAnalyzeranalyzer =newPmdAnalyzer(config,collector).withRulesets(rules);assertThat(analyzer.analyze(),hasNoPmdViolations());}

Standard tests

//extend CodeAssertTest if you still use JUnit 4publicclassCodeTestextendsCodeAssertJunit5Test {privatestaticfinalAnalyzerConfigCONFIG =AnalyzerConfig.maven().main();@OverrideprotectedDependencyResultanalyzeDependencies() {classMyProjectextendsDependencyRuler {DependencyRulepackages;@OverridepublicvoiddefineRules() {//TODO            }        }finalDependencyRulesrules =denyAll().withExternals("java.*").withRelativeRules(newMyProject());returnnewDependencyAnalyzer(CONFIG).rules(rules).analyze();    }@OverrideprotectedFindBugsResultanalyzeFindBugs() {finalBugCollectorbugCollector =newBugCollector().just(In.classes("*Exception").ignore("SE_BAD_FIELD"));returnnewFindBugsAnalyzer(CONFIG,bugCollector).analyze();    }@OverrideprotectedCheckstyleResultanalyzeCheckstyle() {finalStyleEventCollectorbugCollector =newStyleEventCollector().just(In.everywhere().ignore("javadoc.missing"));returnnewCheckstyleAnalyzer(CONFIG,StyleChecks.google(),bugCollector).analyze();    }@OverrideprotectedPmdResultanalyzePmd() {finalPmdViolationCollectorcollector =newPmdViolationCollector().just(In.everywhere().ignore("MethodArgumentCouldBeFinal"));returnnewPmdAnalyzer(CONFIG,collector).withRulesets(basic(),braces()).analyze();    }}