Problema:

Eu tenho um projeto com Jacoco e eu quero ser capaz de filtrar certas classes e / ou pacotes.

Documentação relacionada:

Eu li a seguinte documentação:

Oficial Jacocosite: http://www.eclemma.org/jacoco/index.html

Oficial Jacoco docs para gradle: https://gradle.org/docs/current/userguide/jacoco_plugin.html

Oficial Jacoco Githubquestões, trabalhando na cobertura: https://github.com/jacoco/jacoco/wiki/FilteringOptions https://github.com/jacoco/jacoco/issues/14

Links StackOverflow relacionados:

JaCoCo & Gradle - Opções de filtragem (sem resposta)

Excluir pacotes do relatório Jacoco usando Sonarrunner e Gradle (não usandosonar)

JaCoCo - excluir JSP do relatório (parece funcionar paramaven, Estou usando gradle)

Configuração Maven Jacoco - Excluir classes / pacotes do relatório que não funcionam (parece funcionar paramaven, Estou usando gradle)

Exclusão do plugin JaCoCo gradle (não foi possível fazer isso funcionar)

Gradle Jacoco - relatórios de cobertura incluem classes excluídas na configuração (parece muito próximo, usou doFirst, não funcionou para mim)

Exemplo do que tentei:

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

Questão:

Como posso excluir certos pacotes e classes ao gerar o Jacoco relatórios de cobertura?

Graças a Yannick Welsch:

Depois de pesquisar no Google, ler os documentos do Gradle e passar por postagens mais antigas do StackOverflow, encontrei esta resposta gradle fóruns!

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

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

Solução para meus build.gradleprojetos 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/**'])
        })
    }
}

Como você pode ver, fui capaz de adicionar mais exclude:para filtrar alguns pacotes.

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

Tarefas personalizadas para outros projetos, como 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

Para o Gradle versão 5.x, o classDirectories = files(...)fornece um aviso de suspensão de uso e não funciona a partir do Gradle 6.0. Esta é a forma não obsoleta de excluir classes:

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

para mim, tudo bem trabalhar com

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

conforme declarado na documentação https://docs.gradle.org/current/userguide/jacoco_plugin.html#N16E62 e inicialmente perguntado, então a resposta é:

então se você me perguntar: não é uma questão de

excludes = ["projecteuler/**"]

ou

excludes += ["projecteuler/**"]

mas

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

excluir um pacote *.projecteuler.*

e test {}no nível do projeto, não aninhado emjacocoTestReport

Para Gradle6 use algo como abaixo, porque eles fizeram classDirectories as final, não podemos reatribuí-lo, mas existe um método setter classDirectories.setFromque pode ser utilizado

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

Aqui está uma solução para esse problema na ANT. Isso pode ser adaptado ao gradle adicionando o seguinte na jacocoTestReporttarefa. Embora isso não seja realmente documentado pelo jacoco, parece ser a única maneira de filtrar os resultados do teste por enquanto.

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

Isso já foi divulgado por um tempo, mas acabei de encontrar isso. Eu estava lutando com todas as exclusões necessárias. Achei que era algo muito mais simples para mim. Se você seguir o estilo de layout do projeto Maven / src / main / java e / src / test / java, você simplesmente precisa colocar buildDir / classes / main em sua configuração classDirectories assim:

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

O código abaixo também exclui classes da verificação de cobertura:

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

alguns comentários mencionaram o aviso de suspensão de uso. para resolver basta usar o getter:

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

Para filtrar no relatório jacoco, a exclusão precisa ser feita em duas tarefas jacocoTestReporte jacocoTestCoverageVerification.

Código de amostra

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

        ...
    }

adicione a configuração abaixo no arquivo gradle.properties

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