Problem:

Mam projekt z jacoco i chcę mieć możliwość filtrowania określonych klas i / lub pakietów.

Powiązana dokumentacja:

Przeczytałem następującą dokumentację:

Urzędnik jacocosite: http://www.eclemma.org/jacoco/index.html

Urzędnik jacoco dokumenty dla gradle: https://gradle.org/docs/current/userguide/jacoco_plugin.html

Urzędnik jacoco Githubzagadnienia, praca nad zasięgiem: https://github.com/jacoco/jacoco/wiki/FilteringOptions https://github.com/jacoco/jacoco/issues/14

Powiązane łącza StackOverflow:

JaCoCo i Gradle - Opcje filtrowania (brak odpowiedzi)

Wyklucz pakiety z raportu Jacoco za pomocą Sonarrunner i Gradle (nie używasonar)

JaCoCo - wyklucz JSP z raportu (wydaje się, że działa w przypadkumaven, Ja używam gradle)

Konfiguracja Maven Jacoco - wykluczenie klas / pakietów z raportu nie działa (wydaje się działać dlamaven, Ja używam gradle)

Wykluczenie wtyczki JaCoCo gradle (nie udało się tego uruchomić)

Gradle Jacoco - raporty pokrycia obejmują klasy wykluczone w konfiguracji (Wydaje się bardzo zbliżone, używane doFirst, nie działały u mnie)

Przykład tego, czego próbowałem:

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"]
        }
    }
}

Pytanie:

Jak mogę wykluczyć niektóre pakiety i klasy podczas generowania pliku jacoco raporty zasięgu?

Dzięki Yannick Welsch:

Po przeszukaniu Google, przeczytaniu dokumentów Gradle i przejrzeniu starszych postów StackOverflow, znalazłem tę odpowiedź w oficjalnym gradle fora!

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

Źródło: https://issues.gradle.org/browse/GRADLE-2955

Rozwiązanie dla moich build.gradleprojektów Java / Groovy:

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/**'])
        })
    }
}

Jak widać, udało mi się dodać więcej exclude:, aby przefiltrować kilka pakietów.

Źródło: https://github.com/jaredsburrows/CS-Interview-Questions/blob/master/build.gradle

Niestandardowe zadania dla innych projektów, takich jak 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/**'])
        })
    }
}

Źródło: https://github.com/jaredsburrows/android-gradle-java-app-template/blob/master/gradle/quality.gradle#L59

W przypadku programu Gradle w wersji 5.x classDirectories = files(...)ostrzega o wycofaniu i nie działa w ogóle, począwszy od wersji Gradle 6.0. Jest to niezalecany sposób wykluczania klas:

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

dla mnie dobrze się pracuje z

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

jak stwierdzono w dokumentacji https://docs.gradle.org/current/userguide/jacoco_plugin.html#N16E62 i początkowo zapytano, więc odpowiedź brzmi:

więc jeśli mnie zapytasz: to nie jest kwestia

excludes = ["projecteuler/**"]

lub

excludes += ["projecteuler/**"]

ale

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

aby wykluczyć pakiet *.projecteuler.*

i test {}na poziomie projektu, nie zagnieżdżone wjacocoTestReport

Dla Gradle6 Użyj czegoś takiego jak poniżej, ponieważ stworzyli classDirectories as final, nie możemy go ponownie przypisać, ale istnieje metoda ustawiająca, classDirectories.setFromktórą można wykorzystać

    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/**'
                    ]
            )
        }))
    }
}

Oto rozwiązanie tego problemu w ANT. Można to dostosować do gradle, dodając w jacocoTestReportzadaniu następujące elementy . Chociaż jacoco tak naprawdę nie jest udokumentowane, wydaje się, że na razie jest to jedyny sposób na przefiltrowanie wyników testu.

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

To było przez jakiś czas, ale właśnie się z tym spotkałem. Walczyłem ze wszystkimi potrzebnymi wykluczeniami. Okazało się, że to dla mnie coś znacznie prostszego. Jeśli podążasz za stylem projektu Maven / src / main / java i / src / test / java, po prostu musisz umieścić buildDir / classes / main w swojej konfiguracji classDirectories w następujący sposób:

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
                     ]
        )
    }
}

Poniższy kod wyłącza również klasy z weryfikacji pokrycia:

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

w niektórych komentarzach wspomniano o ostrzeżeniu o wycofaniu. aby rozwiązać po prostu użyj gettera:

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

Aby filtrować w raporcie jacoco, wykluczenie należy wykonać w dwóch zadaniach jacocoTestReporti jacocoTestCoverageVerification.

przykładowy kod

    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)
            })
        }

        ...
    }

dodaj poniższą konfigurację w pliku gradle.properties

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