[JUnit] Tests qui passent sous JUnit mais pas sous ECLEMMA

Bonjour à tous et bonne année ^^,

Dans le cadre d'un projet universitaire, nous avons mis en place une série de test unitaire avec JUnit et JMock.
Nous aimerions maintenant connaître la proportion de code couvert par les tests dans notre application.
J'ai donc installé le plugin eclipse : ECLEMMA (http://www.eclemma.org) pour réaliser la couverture de code.

Et là : "stupeur" plus aucun test ne fonctionne !

Dans notre projet nous avons une classe : ModulesManager :

Code:

1
2
3
4
5
6
7
8
9
10
11
public class ModulesManager {
                private static IGestionType gestionType;
 
                public static IGestionType getGestionType() {
                               if (gestionType == null) {
                                               gestionType = new GestionType();
                               }
                               return gestionType;
                }
...
}

Dans nos tests nous avons une classe : AbstractTest :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
public abstract class AbstractModulesTest extends MockObjectTestCase {
                protected Mockery mockery;
 
                public void setUp() throws Exception {
                               super.setUp();
                               mockery = new Mockery();
                               Field[] champs = ModulesManager.class.getDeclaredFields();
                               for (int i = 0; i < champs.length; ++i) {
                                               champs[i].setAccessible(true);
                                               champs[i].set(ModulesManager.class, mockery.mock(champs[i].getType()));
                               }
                }
}

Nous avons également nos classes de tests :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public class GestionPageEnRamTest extends AbstractModulesTest {
                public void testObtenirPageEnRam() throws Exception {
                               IGestionPageEnRAM module = new GestionPageEnRAM();
                               final Integer numeroPage = 42;
                               final Collection<Byte> resultValue = resultValuePage();
                               final BaseDeDonnees base = new BaseDeDonnees();
                               session.Session.setBaseDeDonneesCourante(base);
 
                               mockery.checking(new Expectations() {
                                               {
                                                               oneOf(ModulesManager.getGestionPageSurDisque()).obtenirPage(
                                                                                              with(base), with(numeroPage));
                                                               will(returnValue(resultValue));
                                               }
                               });
 
                               TesterLEgaliteDeDeuxPages(resultValue, module.obtenirPage(numeroPage));
                               mockery.assertIsSatisfied();
                }
...
}

Lorsque nous lançons nos test JUnit directement dans Eclipse : Ils fonctionnent.

Lorsque nous les lançons par ECLEMMA : Ils ne fonctionnent plus

Nous avons comme pile :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
java.lang.IllegalArgumentException: [[Z is not an interface
                at java.lang.reflect.Proxy.getProxyClass(Unknown Source)
                at java.lang.reflect.Proxy.newProxyInstance(Unknown Source)
                at org.jmock.lib.JavaReflectionImposteriser.imposterise(JavaReflectionImposteriser.java:31)
                at org.jmock.Mockery.mock(Mockery.java:139)
                at org.jmock.Mockery.mock(Mockery.java:120)
                at test.modules.AbstractModulesTest.setUp(AbstractModulesTest.java:23)
                at org.jmock.integration.junit3.VerifyingTestCase.runBare(VerifyingTestCase.java:36)
                at junit.framework.TestResult$1.protect(TestResult.java:110)
                at junit.framework.TestResult.runProtected(TestResult.java:128)
                at junit.framework.TestResult.run(TestResult.java:113)
                at junit.framework.TestCase.run(TestCase.java:124)
                at junit.framework.TestSuite.runTest(TestSuite.java:232)
                at junit.framework.TestSuite.run(TestSuite.java:227)
                at org.junit.internal.runners.JUnit38ClassRunner.run(JUnit38ClassRunner.java:79)
                at org.eclipse.jdt.internal.junit4.runner.JUnit4TestReference.run(JUnit4TestReference.java:46)
                at org.eclipse.jdt.internal.junit.runner.TestExecution.run(TestExecution.java:38)
                at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:467)
                at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:683)
                at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.run(RemoteTestRunner.java:390)
                at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.main(RemoteTestRunner.java:197)

C’est donc la ligne suivante de la classe AbstractModulesTest qui ne passent plus :

Code:

champs[i].set(ModulesManager.class, mockery.mock(champs[i].getType()));

Je dois vous avouer que là, je ne sais plus à quel saint me vouer.

En vous remerciant par avance pour votre aide,

Laur3nT