Problème:

J'ai un projet avec jacoco et je veux pouvoir filtrer certaines classes et / ou packages.

Documentation connexe:

J'ai lu la documentation suivante:

Officiel jacocosite: http://www.eclemma.org/jacoco/index.html

Officiel jacoco documents pour gradle: https://gradle.org/docs/current/userguide/jacoco_plugin.html

Officiel jacoco Githubproblèmes, travail sur la couverture: https://github.com/jacoco/jacoco/wiki/FilteringOptions https://github.com/jacoco/jacoco/issues/14

Liens StackOverflow connexes:

JaCoCo & Gradle - Options de filtrage (pas de réponse)

Exclure les packages du rapport Jacoco à l'aide de Sonarrunner et Gradle (sans utilisersonar)

JaCoCo - exclure JSP du rapport (cela semble fonctionner pourMaven, J'utilise gradle)

Configuration Maven Jacoco - Exclure les classes / packages du rapport ne fonctionne pas (cela semble fonctionner pourMaven, J'utilise gradle)

Exclusion du plugin JaCoCo gradle (impossible de faire fonctionner cela)

Gradle Jacoco - les rapports de couverture incluent les classes exclues de la configuration (semble très proche, il a utilisé doFirst, n'a pas fonctionné pour moi)

Exemple de ce que j'ai essayé:

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

Question:

Comment puis-je exclure certains packages et classes lors de la génération du jacoco rapports de couverture?

Merci à Yannick Welsch:

Après avoir recherché Google, lu les documents Gradle et parcouru d'anciens articles StackOverflow, j'ai trouvé cette réponse sur le site officiel gradle forums!

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

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

Solution à mes build.gradleprojets 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/**'])
        })
    }
}

Comme vous pouvez le voir, j'ai réussi à en ajouter exclude:afin de filtrer quelques paquets.

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

Tâches personnalisées pour d'autres projets tels qu'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/**'])
        })
    }
}

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

Pour Gradle version 5.x, le classDirectories = files(...)donne un avertissement d'obsolescence et ne fonctionne pas du tout à partir de Gradle 6.0.C'est la manière non préconisée d'exclure des classes:

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

pour moi, c'est bien de travailler avec

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

comme indiqué dans la documentation https://docs.gradle.org/current/userguide/jacoco_plugin.html#N16E62 et initialement demandé, la réponse est:

donc si vous me demandez: ce n'est pas une question de

excludes = ["projecteuler/**"]

ou

excludes += ["projecteuler/**"]

mais

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

pour exclure un package *.projecteuler.*

et test {}au niveau du projet, non imbriqué dansjacocoTestReport

Pour Gradle6 Utilisez quelque chose comme ci-dessous, car ils ont fait classDirectories as final, nous ne pouvons pas le réattribuer, mais une méthode de setter existe classDirectories.setFromqui peut être utilisée

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

Voici une solution à ce problème dans ANT. Cela peut être adapté pour graduer en ajoutant ce qui suit sous la jacocoTestReporttâche. Bien que cela ne soit pas vraiment documenté par jacoco, cela semble être le seul moyen de filtrer les résultats des tests pour le moment.

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

Cela fait un moment, mais je viens de le découvrir. Je luttais avec toutes les exclusions nécessaires. J'ai trouvé que c'était quelque chose de beaucoup plus simple pour moi. Si vous suivez le style de mise en page du projet Maven / src / main / java et / src / test / java, vous devez simplement mettre buildDir / classes / main dans votre configuration classDirectories comme ceci:

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

Le code ci-dessous exclut également les classes de la vérification de la couverture:

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

certains commentaires mentionnaient l'avertissement de dépréciation. pour résoudre il suffit d'utiliser le getter:

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

Afin de filtrer dans le rapport jacoco, l'exclusion doit être effectuée en deux tâches jacocoTestReport et jacocoTestCoverageVerification.

exemple de code

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

        ...
    }

ajouter ci-dessous la configuration dans le fichier gradle.properties

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