Problema:

Ho un progetto con jacoco e voglio essere in grado di filtrare determinate classi e / o pacchetti.

Documentazione correlata:

Ho letto la seguente documentazione:

Ufficiale jacocosito: http://www.eclemma.org/jacoco/index.html

Ufficiale jacoco documenti per Gradle: https://gradle.org/docs/current/userguide/jacoco_plugin.html

Ufficiale jacoco Githubproblemi, lavorando sulla copertura: https://github.com/jacoco/jacoco/wiki/FilteringOptions https://github.com/jacoco/jacoco/issues/14

Link StackOverflow correlati:

JaCoCo & Gradle - Opzioni di filtro (Nessuna risposta)

Escludere i pacchetti dal report Jacoco utilizzando Sonarrunner e Gradle (non utilizzandosonar)

JaCoCo - esclude JSP dal rapporto (sembra funzionare perEsperto di, Sto usando Gradle)

Configurazione di Maven Jacoco - Esclude classi / pacchetti dal report che non funziona (sembra funzionare perEsperto di, Sto usando Gradle)

JaCoCo gradle plugin exclude (Impossibile farlo funzionare)

Gradle Jacoco - i rapporti di copertura includono le classi escluse nella configurazione (sembra molto vicino, ha usato doFirst, non ha funzionato per me)

Esempio di quello che ho provato:

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

Domanda:

Come posso escludere determinati pacchetti e classi durante la generazione del file jacoco rapporti di copertura?

Grazie a Yannick Welsch:

Dopo aver cercato su Google, letto i documenti di Gradle e passato attraverso i vecchi post di StackOverflow, ho trovato questa risposta sull'Official Gradle forum!

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

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

Soluzione per i miei build.gradleprogetti 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/**'])
        })
    }
}

Come puoi vedere, sono riuscito ad aggiungerne altri exclude:per filtrare alcuni pacchetti.

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

Attività personalizzate per altri progetti come 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/**'])
        })
    }
}

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

Per Gradle versione 5.x, classDirectories = files(...)fornisce un avviso di deprecazione e non funziona affatto a partire da Gradle 6.0 Questo è il modo non specificato di escludere le classi:

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

per me va bene lavorare con

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

come indicato nella documentazione https://docs.gradle.org/current/userguide/jacoco_plugin.html#N16E62 e inizialmente chiesto quindi la risposta è:

quindi se me lo chiedi: non è una questione di

excludes = ["projecteuler/**"]

o

excludes += ["projecteuler/**"]

ma

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

per escludere un pacchetto *.projecteuler.*

ea test {}livello di progetto, non annidato injacocoTestReport

Per Gradle6 Usa qualcosa come sotto, perché hanno creato classDirectories as final, non possiamo riassegnarlo, ma esiste un metodo setter classDirectories.setFromche può essere utilizzato

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

Ecco una soluzione per questo problema in ANT. Questo può essere adattato al gradle aggiungendo quanto segue sotto l' jacocoTestReportattività. Sebbene questo non sia realmente documentato da Jacoco, sembra l'unico modo per filtrare i risultati del test per ora.

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

È uscito da un po ', ma mi sono imbattuto in questo. Stavo lottando con tutte le esclusioni necessarie. Ho scoperto che era qualcosa di molto più semplice per me. Se segui lo stile di layout del progetto Maven / src / main / java e / src / test / java, devi semplicemente inserire buildDir / classes / main nella configurazione di classDirectories in questo modo:

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

Il codice seguente esclude anche le classi dalla verifica della copertura:

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

alcuni commenti hanno menzionato l'avviso di deprecazione. per risolvere basta usare il getter:

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

Per filtrare nel rapporto jacoco, l'esclusione deve essere eseguita in due attività jacocoTestReporte jacocoTestCoverageVerification.

codice di esempio

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

        ...
    }

aggiungere sotto la configurazione nel file gradle.properties

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