Problem:

Ich habe ein Projekt mit Jacoco und ich möchte in der Lage sein, bestimmte Klassen und / oder Pakete zu filtern.

Dazugehörige Dokumentation:

Ich habe die folgende Dokumentation gelesen:

Offiziell JacocoWebsite: http://www.eclemma.org/jacoco/index.html

Offiziell Jacoco Dokumente für gradle: https://gradle.org/docs/current/userguide/jacoco_plugin.html

Offiziell Jacoco GithubProbleme, die an der Berichterstattung arbeiten: https://github.com/jacoco/jacoco/wiki/FilteringOptions https://github.com/jacoco/jacoco/issues/14

Verwandte StackOverflow-Links:

JaCoCo & Gradle - Filteroptionen (Keine Antwort)

Schließen Sie Pakete aus dem Jacoco-Bericht mit Sonarrunner und Gradle aus (nicht mitSonar)

JaCoCo - JSP vom Bericht ausschließen (es scheint zu funktionierenMaven, Ich benutze gradle)

Maven Jacoco-Konfiguration - Schließen Sie Klassen / Pakete von Berichten aus, die nicht funktionieren (es scheint zu funktionierenMaven, Ich benutze gradle)

JaCoCo Gradle Plugin ausschließen (Konnte dies nicht zum Laufen bringen )

Gradle Jacoco - Berichterstattungsberichte enthalten Klassen, die in der Konfiguration ausgeschlossen sind (Scheint sehr nahe, es hat verwendet doFirst, hat bei mir nicht funktioniert)

Beispiel für das, was ich versucht habe:

apply plugin: 'java'
apply plugin: 'jacoco'

buildscript {
    repositories {
        mavenCentral()
        jcenter()
    }
}

repositories {
    jcenter()
}

jacocoTestReport {
    reports {
        xml {
            enabled true // coveralls plugin depends on xml format report
        }

        html {
            enabled true
        }
    }

    test {
        jacoco {
            destinationFile = file("$buildDir/jacoco/jacocoTest.exec")
            classDumpFile = file("$buildDir/jacoco/classpathdumps")
            excludes = ["projecteuler/**"] // <-- does not work
            // excludes = ["projecteuler"]
        }
    }
}

Frage:

Wie kann ich bestimmte Pakete und Klassen beim Generieren der ausschließen? Jacoco Berichterstattungsberichte?

Danke an Yannick Welsch:

Nachdem ich Google durchsucht, die Gradle-Dokumente gelesen und ältere StackOverflow-Beiträge durchgesehen hatte, fand ich diese Antwort im Official gradle Foren!

jacocoTestReport {
    afterEvaluate {
        classDirectories = files(classDirectories.files.collect {
            fileTree(dir: it, exclude: 'com/blah/**')
        })
    }
}

Quelle: https://issues.gradle.org/browse/GRADLE-2955

Lösung für meine build.gradleJava / Groovy-Projekte:

apply plugin: 'java'
apply plugin: 'jacoco'

jacocoTestReport {
    reports {
        xml {
            enabled true // coveralls plugin depends on xml format report
        }

        html {
            enabled true
        }
    }

    afterEvaluate {
        classDirectories = files(classDirectories.files.collect {
            fileTree(dir: it,
                    exclude: ['codeeval/**',
                              'crackingthecode/part3knowledgebased/**',
                              '**/Chapter7ObjectOrientedDesign**',
                              '**/Chapter11Testing**',
                              '**/Chapter12SystemDesignAndMemoryLimits**',
                              'projecteuler/**'])
        })
    }
}

Wie Sie sehen, konnte ich erfolgreich weitere hinzufügen, exclude:um einige Pakete zu filtern.

Quelle: https://github.com/jaredsburrows/CS-Interview-Questions/blob/master/build.gradle

Benutzerdefinierte Aufgaben für andere Projekte wie Android:

apply plugin: 'jacoco'

task jacocoReport(type: JacocoReport) {
    reports {
        xml {
            enabled true // coveralls plugin depends on xml format report
        }

        html {
            enabled true
        }
    }

    afterEvaluate {
        classDirectories = files(classDirectories.files.collect {
            fileTree(dir: it,
                    exclude: ['codeeval/**',
                              'crackingthecode/part3knowledgebased/**',
                              '**/Chapter7ObjectOrientedDesign**',
                              '**/Chapter11Testing**',
                              '**/Chapter12SystemDesignAndMemoryLimits**',
                              'projecteuler/**'])
        })
    }
}

Quelle: https://github.com/jaredsburrows/android-gradle-java-app-template/blob/master/gradle/quality.gradle#L59

Für Gradle Version 5.x classDirectories = files(...)gibt das eine Warnung vor Verfall aus und funktioniert ab Gradle 6.0 überhaupt nicht. Dies ist die nicht veraltete Methode zum Ausschließen von Klassen:

jacocoTestReport {
    afterEvaluate {
        classDirectories.setFrom(files(classDirectories.files.collect {
            fileTree(dir: it, exclude: 'com/exclude/**')
        }))
    }
}

Für mich ist es gut, damit zu arbeiten

test {
  jacoco {
    excludes += ['codeeval/**',
                 'crackingthecode/part3knowledgebased/**',
                 '**/Chapter7ObjectOrientedDesign**',
                 '**/Chapter11Testing**',
                 '**/Chapter12SystemDesignAndMemoryLimits**',
                 'projecteuler/**']
  }
}

Wie in der Dokumentation https://docs.gradle.org/current/userguide/jacoco_plugin.html#N16E62 angegeben und ursprünglich gefragt, lautet die Antwort:

Also, wenn Sie mich fragen: Es ist keine Frage von

excludes = ["projecteuler/**"]

oder

excludes += ["projecteuler/**"]

aber

excludes = ["**/projecteuler/**"]

ein Paket ausschließen *.projecteuler.*

und test {}auf Projektebene nicht verschachteltjacocoTestReport

Für Gradle6 Verwenden Sie etwas wie das Folgende, da es gemacht wurde classDirectories as final, können wir es nicht neu zuweisen, aber es gibt eine Setter-Methode, classDirectories.setFromdie verwendet werden kann

    jacocoTestReport {
    reports {
        xml.enabled true
        html.enabled true
        html.destination file("$buildDir/reports/jacoco")
    }

    afterEvaluate {
        classDirectories.setFrom(files(classDirectories.files.collect {
            fileTree(dir: it,
                    exclude: ['**/server/**',
                              '**/model/**',
                              '**/command/**'
                    ]
            )
        }))
    }
}

Hier ist eine Lösung für dieses Problem in ANT. Dies kann an Gradle angepasst werden, indem unter der jacocoTestReportAufgabe Folgendes hinzugefügt wird . Obwohl dies von jacoco nicht wirklich dokumentiert ist, scheint es die einzige Möglichkeit zu sein, die Testergebnisse vorerst zu filtern.

afterEvaluate {
    classDirectories = files(classDirectories.files.collect {
        fileTree(dir: it, exclude: 'excluded/files/**')
    })
}

Das ist schon eine Weile weg, aber ich bin gerade darauf gestoßen. Ich hatte mit allen notwendigen Ausschlüssen zu kämpfen. Ich fand es viel einfacher für mich. Wenn Sie dem Maven-Projektlayoutstil / src / main / java und / src / test / java folgen, müssen Sie buildDir / classes / main einfach wie folgt in Ihre classDirectories- Konfiguration einfügen :

afterEvaluate {
    jacocoTestReport {
        def coverageSourceDirs = ['src/main/java']
        reports {
            xml.enabled false
            csv.enabled false
            html.destination "${buildDir}/reports/jacocoHtml"
        }
        sourceDirectories = files(coverageSourceDirs)
        classDirectories = fileTree(
                dir: "${project.buildDir}/classes/main",
                excludes: [
                      //whatever here like JavaConfig etc. in /src/main/java
                     ]
        )
    }
}

Der folgende Code schließt Klassen ebenfalls von der Überprüfung der Abdeckung aus:

jacocoTestCoverageVerification {
    afterEvaluate {
        classDirectories = files(classDirectories.files.collect {
            fileTree(dir: "${project.buildDir}/classes/main",
                    exclude: ['**/packagename/**'])
        })
    }
}

In einigen Kommentaren wurde die Abwertungswarnung erwähnt. zum lösen benutze einfach den getter:

afterEvaluate {
    getClassDirectories().from(files(classDirectories.files.collect {
        fileTree(dir: it, exclude: 'com/blah/**')
    }))
}

Um im Jacoco-Bericht zu filtern, muss der Ausschluss in zwei Aufgaben jacocoTestReportund erfolgen jacocoTestCoverageVerification.

Beispielcode

    def jacocoExclude = ['**/example/**', '**/*Module*.class']

    jacocoTestReport {
        afterEvaluate {
            getClassDirectories().setFrom(classDirectories.files.collect {
                fileTree(dir: it, exclude: jacocoExclude)
            })
        }
    }

    jacocoTestCoverageVerification {
        afterEvaluate {
            getClassDirectories().setFrom(classDirectories.files.collect {
                fileTree(dir: it, exclude: jacocoExclude)
            })
        }

        ...
    }

Fügen Sie die folgende Konfiguration in die Datei gradle.properties ein

coverageExcludeClasses=["com.example.package.elasticsearch.*", "com.example.package2.*",]