Gradle Jacaco Abdeckung Bericht mit mehr als einem Submodul (en)?

Question

Kann jemand eine Gradle-Datei für Java-jacoco-Bericht konfigurieren, die Codecoverage von mehr als einem Gradle Submodul enthalten?

mein aktueller Ansatz zeigt nur Code Coverage des aktuellen Submoduls, aber nicht Codecoverage eines Geschwister-Submoduls.

Ich habe diese Projektstruktur

- build.gradle (1) 
- corelib/ 
    - build.gradle (2) 
    - src/main/java/package/Core.java 
- extlib/ 
    - build.gradle (3) 
    - src/main/java/package/Ext.java 
    - src/test/java/package/Integrationtest.java 

wenn ich gradlew :extlib:check :extlib:jacocoTestReport der junit-Test „Integrationtest.java“ execute ausgeführt wird und eine Testabdeckung Bericht erzeugt, der nicht wie Testabdeckung Core.java für corelib Klassen enthält

Das Ergebnis sollte die Testabdeckung von Ext.java und Core.java

ich schon gelesen

umfassen

• https://docs.gradle.org/current/userguide/jacoco_plugin.html
• und Filter JaCoCo coverage reports with Gradle

aber keine Hinweise

hier ist Inhalt der gradle Dateien

// root build.gradle (1) 
// Top-level build file where you can add configuration options 
// common to all sub-projects/modules. 
buildscript { 
    repositories { 
     jcenter() 
    } 
    dependencies { 
     classpath 'com.android.tools.build:gradle:2.1.0' 
    } 
} 
allprojects { 
    repositories { 
     jcenter() 
    } 
} 

---

// build.gradle (2) subproject build file for corelib. 
apply plugin: 'java' 
apply plugin: 'jacoco' 

dependencies { 
} 

jacocoTestReport { 
    reports { 
     xml.enabled true 
     html.enabled true 
    } 
} 

---

// build.gradle (3) subproject build file for extlib. 
apply plugin: 'java' 
apply plugin: 'jacoco' 

dependencies { 
    compile project(':corelib') 
    testCompile 'junit:junit:4.11' 

    // this does not compile 
    // jacocoTestReport project(':pixymeta-core-lib') 
} 

jacocoTestReport { 
    reports { 
     xml.enabled true 
     html.enabled true 
    } 
} 

// workaround because android-studio does not make the test resources available 
// see https://code.google.com/p/android/issues/detail?id=64887#c13 
task copyTestResources(type: Copy) { 
    from sourceSets.test.resources 
    into sourceSets.test.output.classesDir 
} 
processTestResources.dependsOn copyTestResources 

---

[Update 2016.08.01]

dank @Benjamin Muschko i auch in der Wurzel gradle Datei versucht

// https://discuss.gradle.org/t/merge-jacoco-coverage-reports-for-multiproject-setups/12100/6 
// https://docs.gradle.org/current/dsl/org.gradle.testing.jacoco.tasks.JacocoMerge.html 
task jacocoMerge(type: JacocoMerge) { 
    subprojects.each { subproject -> 
     executionData subproject.tasks.withType(Test) 
    } 

} 

bekam aber Fehlermeldung (mit gradle- 2,14)

* What went wrong: 
Some problems were found with the configuration of task ':jacocoMerge'. 
> No value has been specified for property 'jacocoClasspath'. 
> No value has been specified for property 'executionData'. 
> No value has been specified for property 'destinationFile'. 

---

es auch die gradle Plugin ist https://github.com/paveldudka/JacocoEverywhere, wo ich für Mulit-Submodul Unterstützung gebeten haben https://github.com/paveldudka/JacocoEverywhere/issues/16

[Update 2016.08.01] fand ich eine Lösung auf Basis von Arbeits https://github.com/palantir/gradle-jacoco-coverage

unter

meine eigene Antwort Siehe

Answer 1

Schließlich fand ich dieses Plugin: https://github.com/palantir/gradle-jacoco-coverage, die den Job für mich getan hat:

Wurzel gradle.bauen

buildscript { 
    repositories { 
     jcenter() 
    } 
    dependencies { 
     // see https://jcenter.bintray.com/com/android/tools/build/gradle/ 
     classpath 'com.android.tools.build:gradle:2.1.0' 
     // classpath 'com.android.tools.build:gradle:2.2.0-alpha1' 

     // https://github.com/palantir/gradle-jacoco-coverage 
     classpath 'com.palantir:jacoco-coverage:0.4.0'  
    } 
} 

// https://github.com/palantir/gradle-jacoco-coverage 
apply plugin: 'com.palantir.jacoco-full-report' 

alle Teilprojekte, die

apply plugin: 'jacoco' 

hat, werden in den Bericht aufgenommen.

Answer 2

Sie müssen eine neue Aufgabe vom Typ JacocoMerge erstellen, die die JaCoCo-Berichte aus allen Teilprojekten aggregiert. Siehe eine ähnliche Diskussion in dieser post.

Answer 3

Eine mögliche Lösung (mit einigen Sonar bestimmten Teilen):

def getJacocoMergeTask(Project proj){ 
    def jmClosure = { 
     doFirst { 
      logger.info "${path} started" 
      executionData.each { ed -> 
       logger.info "${path} data: ${ed}" 
      } 
     } 
     onlyIf { 
      executionData != null && !executionData.isEmpty() 
     } 
    } 

    def jacocoMerge = null 
    if(!proj.tasks.findByName('jacocoMerge')){ 

     jacocoMerge = proj.tasks.create('jacocoMerge', JacocoMerge.class) 
     jacocoMerge.configure jmClosure 

     // sonar specific part 
     proj.rootProject.tasks["sonarqube"].mustRunAfter jacocoMerge 

     proj.sonarqube { 
      properties { 
       property "sonar.jacoco.reportPaths", jacocoMerge.destinationFile.absolutePath 
      } 
     } 
     // end of sonar specific part 

     logger.info "${jacocoMerge.path} created" 
    } else { 
     jacocoMerge = proj.tasks["jacocoMerge"] 
    } 
    jacocoMerge 
} 


afterEvaluate { project -> 
    def jacocoMerge = getJacocoMergeTask(project) 

    project.tasks.withType(Test) { task -> 
     logger.info "${jacocoMerge.path} cfg: ${task.path}" 

     task.finalizedBy jacocoMerge 
     jacocoMerge.dependsOn task 

     task.doLast { 
      logger.info "${jacocoMerge.path} executionData ${task.path}" 
      jacocoMerge.executionData task 
     } 

     def cfg = configurations.getByName("${task.name}Runtime") 
     logger.info "${project.path} process config: ${cfg.name}" 

     cfg.getAllDependencies().withType(ProjectDependency.class).each { pd -> 
      def depProj = pd.dependencyProject 
      logger.info "${task.path} dependsOn ${depProj.path}" 
      def jm = getJacocoMergeTask(depProj) 

      task.finalizedBy jm 
      jm.dependsOn task 

      task.doLast { 
       logger.info "${jm.path} executionData ${task.path}" 
       jm.executionData task 
      } 
     } 
    } 
} 

Dies wird alle executionData aus allen Projekten zusammenführen, die ein bestimmtes Projekt während der Prüfung als Abhängigkeit verwendet.