Testng, Emma, Cobertura, couverture et JDK 7 entraînent ClassFormatError et VerifyError

Question

Je suis passé à la nouvelle version de JDK 7 et je rencontre des problèmes avec l'exécution de la testng unité de test sur l'octet de code qui est trafiqué par emma outil de couverture. Aucun de mes cas de test sont exécutés correctement et pour la plupart d'entre eux, je reçois de telles erreurs.

 java.lang.ClassFormatError: Illegal local variable table length 10 in method measurement.meter.AbstractSerialPortMeter.<init>(Lmeasurement/meter/SerialPort;)V at measurement.meter.Elc3133aTest.setUp(Elc3133aTest.java:42)

J'ai trouvé un article ici JSR 292 Bonté Code Rapide, Outil de Couverture de Moins de 10k, ce qui veut dire que "la JSR 292 introduit une nouvelle instruction bytecode invokedynamic, mais aussi plusieurs nouveau type de constant pool de constantes. Ce qui signifie que la plupart des outils qui analysent bytecode comme l'ASM, BCEL, findbugs ou EMMA devra être mis à jour java 7 compatible."

Vérifié Emma page d'accueil, mais on dirait qu'il n'a pas été mis à jour depuis un long moment.

Personne n'a résolu un problème similaire?

J'ai aussi essayé avec Cobertura. Il cherche à travailler un peu mieux, mais je reçois beaucoup d'exceptions de type VerifyError.

java.lang.VerifyError: Expecting a stackmap frame at branch target 85 in method measurement.meter.AbstractSerialPortMeter.close()V at offset 26
at measurement.meter.AbstractSerialPortMeterTest.setUp(AbstractSerialPortMeterTest.java:27)

Answer 1

J'ai eu le même problème à l'aide de maven cobertura plugin. Tous les tests d'échec lors de l'exécution de couverture:rapport. Mais tous les tests ont réussi lors de l'exécuter directement à partir de plugin surefire. Comme certains d'entre vous l'a déjà dit, le problème est que coberture octet code de l'instrumentation n'est pas compatible avec JDK7.

Vous pouvez voir ici http://vikashazrati.wordpress.com/2011/10/09/quicktip-verifyerror-with-jdk-7/ que l'exception est liée à la "nouveau type checker avec StackMapTable attributs" (voir: -X:+UseSplitVerifier JVM option http://www.oracle.com/technetwork/java/javase/tech/vmoptions-jsp-140102.html).

Donc ma solution est de configurer surefire-plugin pour toujours exécuter les tests avec la JVM arg "-XX:-UseSplitVerifier. Il fonctionne bien avec et sans couverture de l'instrumentation.

Mon infaillible de configuration de maven:

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-surefire-plugin</artifactId>
    <version>2.12</version>
    <configuration>
        <argLine>-XX:-UseSplitVerifier</argLine>
    </configuration>
</plugin>

Answer 2

J'ai eu le même problème. Heureusement, la bêta fonctionne avec JDK 7.
Lien vers le site de mise à jour: http://download.eclipselab.org/eclemma/beta/2.0.0/update/
Ce lien devrait être utilisé dans Eclipse:

 Help -> Install new software... -> Add...
 

Le repos devrait être facile;)

Answer 3

J'ai eu Gradle 1.0M9, Java 7 et EMMA 2.1 travailler avec les patchs suggéré ici: l'utilisation de l'argument jvm.

Les détails ici... http://marcellodesales.wordpress.com/2012/04/03/running-emma-code-test-coverage-with-java-7-and-gradle-1-0m9/?preview=true&preview_id=179&preview_nonce=261e892908

configurations{
  emma
}

dependencies {
  // EMMS Code Coverage
  emma "emma:emma:2.1.5320"
  emma "emma:emma_ant:2.1.5320"
  ...
  testCompile group: 'junit', name: 'junit', version: '4.9'
}

test {
    // add EMMA related JVM args to our tests
    jvmArgs "-XX:-UseSplitVerifier", "-Demma.coverage.out.file=$buildDir/tmp/emma/metadata.emma", "-Demma.coverage.out.merge=true"

    doFirst {
       println "Instrumenting the classes at " + sourceSets.main.output.classesDir.absolutePath
       // define the custom EMMA ant tasks
       ant.taskdef( resource:"emma_ant.properties", classpath: configurations.emma.asPath)

       ant.path(id:"run.classpath") {
          pathelement(location:sourceSets.main.output.classesDir.absolutePath)
       }
       def emmaInstDir = new File(sourceSets.main.output.classesDir.parentFile.parentFile, "tmp/emma/instr")
       emmaInstDir.mkdirs()
       println "Creating $emmaInstDir to instrument from " +       sourceSets.main.output.classesDir.absolutePath
       // instruct our compiled classes and store them at $buildDir/tmp/emma/instr
       ant.emma(enabled: 'true', verbosity:'info'){
          instr(merge:"true", destdir: emmaInstDir.absolutePath, instrpathref:"run.classpath",
                metadatafile: new File(emmaInstDir, '/metadata.emma').absolutePath) {
             instrpath {
             fileset(dir:sourceSets.main.output.classesDir.absolutePath, includes:"**/*.class")
             }
          }
       }
       setClasspath(files("$buildDir/tmp/emma/instr") + configurations.emma +    getClasspath())
    }

    // The report should be generated directly after the tests are done.
    // We create three types (txt, html, xml) of reports here. Running your build script now should
    // result in output like that:
    doLast {
       def srcDir = sourceSets.main.java.srcDirs.toArray()[0]
       println "Creating test coverage reports for classes " + srcDir
       def emmaInstDir = new File(sourceSets.main.output.classesDir.parentFile.parentFile, "tmp/emma")
       ant.emma(enabled:"true"){
          new File("$buildDir/reports/emma").mkdirs()
          report(sourcepath: srcDir){
             fileset(dir: emmaInstDir.absolutePath){
                include(name:"**/*.emma")
             }
             txt(outfile:"$buildDir/reports/emma/coverage.txt")
             html(outfile:"$buildDir/reports/emma/coverage.html")
             xml(outfile:"$buildDir/reports/emma/coverage.xml")
          }
       }
       println "Test coverage reports available at $buildDir/reports/emma."
       println "txt: $buildDir/reports/emma/coverage.txt"
       println "Test $buildDir/reports/emma/coverage.html"
       println "Test $buildDir/reports/emma/coverage.xml"
    }
}

En cours d'exécution "gradle test" donne les éléments suivants:

marcello@hawaii:/u1/development/workspaces/open-source/interviews/vmware$ gradle test
:compileJava
:processResources UP-TO-DATE
:classes
:compileTestJava
:processTestResources UP-TO-DATE
:testClasses
:test
Instrumenting the classes at /u1/development/workspaces/open-source/interviews/vmware/build/classes/main
Creating /u1/development/workspaces/open-source/interviews/vmware/build/tmp/emma/instr to instrument from /u1/development/workspaces/open-source/interviews/vmware/build/classes/main
Creating test coverage reports for classes /u1/development/workspaces/open-source/interviews/vmware/src/main/java
Test coverage reports available at /u1/development/workspaces/open-source/interviews/vmware/build/reports/emma.
txt: /u1/development/workspaces/open-source/interviews/vmware/build/reports/emma/coverage.txt
Test /u1/development/workspaces/open-source/interviews/vmware/build/reports/emma/coverage.html
Test /u1/development/workspaces/open-source/interviews/vmware/build/reports/emma/coverage.xml

BUILD SUCCESSFUL

Answer 4

Emma fonctionne si vous n'utilisez pas de nouvelles fonctionnalités de langage (comme des méthodes avec ressources, etc.). Vous pouvez utiliser Java 7 avec de nouvelles bibliothèques (Paths, DirectoryStream, etc.). Je sais que ce ne serait pas une solution à votre problème, mais si vous voulez uniquement vérifier "comment fonctionne JDK 7", cela peut fonctionner ...

Answer 5

J'avais ce problème. Le passage à la version 2.0.1.201112281951 en utilisant le marché Eclipse a fonctionné pour moi.