common/easymock-tools/Documentation_fr.html

<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="fr">

<head>
<meta http-equiv="Content-Type" content="text/html;charset=utf-8" />
<title>EasyMock 3.1 Readme</title>
<link rel="stylesheet" href="easymock.css" />
</head>
<body><div class="bodywidth">

<h2>EasyMock 3.1 Readme</h2>

<p>Documentation de la version 3.1 (2011-11-10)<br />
&copy; 2001-2011 <a href="http://www.offis.de">OFFIS</a>, <a href="http://tammofreese.de">Tammo Freese</a>, <a href="http://www.ossia-conseil.com/blog/henri/">Henri Tremblay</a>.
</p>
<p><i>Documentation traduite originellement de l'anglais par <a href="http://alexdp.free.fr">Alexandre de Pellegrin</a>.
Maintenue par Henri Tremblay.</i>
</p>
<p>
EasyMock est une librairie fournissant un moyen simple d'utiliser des Mock Objects pour
une interface ou classe donne. EasyMock est disponible sous <a href="http://www.apache.org/licenses/LICENSE-2.0.txt">license Apache 2</a>.
</p>
<p>
Les Mock Objects simulent le comportement du code
mtier et sont capables de vrifier s'il est utilis
comme prvu.
Les classes mtier peuvent tre testes
de faon isole en simulant leurs objets
lis par des Mock Objects.
</p>
<p>
crire et maintenir des Mock Objects est souvent une
tche pnible et source d'erreurs. EasyMock gnre les
Mock Objects dynamiquement - pas besoin de les crire, pas
de code gnr!
</p>
<h3>
Avantages d'EasyMock
</h3>
<ul>
<li>Pas d'criture manuelle des Mock Objects.
</li>
<li>Supporte le refactoring sur les Mock Objects : le code de test ne sera pas cass au runtime lors du renommage de
    mthodes ou de la rorganisations de paramtres
</li>
<li>Supporte les valeurs de retour et les exceptions.
</li>
<li>Supporte la vrification de l'ordre d'appel des mthodes, sur un ou plusieurs Mock Objects.
</li>
</ul>
<h2>
Environnement Requis
</h2>
<ul>
<li>EasyMock 2 fonctionne uniquement avec Java 1.5.0 ou suprieur.</li>
<li>cglib (2.2) and Objenesis (1.2) doivent tre prsent dans le classpath pour faire du mocking de classes</li>
</ul>
<h2>
Installation
</h2>
<h3>Avec Maven</h3>
EasyMock est disponible dans le rfrentiel central de Maven. Ajoutez la dpendance
suivante  votre pom.xml:
<pre>
    &lt;dependency&gt;
      &lt;groupId&gt;org.easymock&lt;/groupId&gt;
      &lt;artifactId&gt;easymock&lt;/artifactId&gt;
      &lt;version&gt;3.1&lt;/version&gt;
      &lt;scope&gt;test&lt;/scope&gt;
    &lt;/dependency&gt;
</pre>
Vous pouvez, bien videmment, n'importe quel outil de gestion de dpendances compatible
avec le rfrentiel Maven.
<h3>Manuellement</h3>
<ul>
<li>Dcompressez le fichier zip d'EasyMock (<code>easymock-3.1.zip</code>).</li>
<li>Allez dans le rpertoire <code>easymock-3.1</code>.</li>
<li>Ajoutez le jar d'EasyMock (<code>easymock.jar</code>)  votre classpath.</li>
<li>Pour pouvoir mocker des classes, ajoutez aussi <a href="http://www.objenesis.org">Objenesis</a> et <a href="http://cglib.sourceforge.net/">Cglib</a>  votre classpath.</li>
<li>Les tests sont dans <code>easymock-3.1-tests.jar</code> et peuvent tre lancs  l'aide d'un JUnit TestRunner
en ayant JUnit 4.7, EasyMock, cglib et Objenesis dans votre classpath.</li>
<li>Le code source d'EasyMock est situ dans <code>easymock-3.1-sources.jar</code>.</li>
</ul>
<h2>
Utilisation
</h2>
<p>
La plupart des lments d'un logiciel ne fonctionnent
pas de manire isole mais en collaboration avec
d'autres lments (objets lis) pour effectuer leur
tche.
Dans beaucoup de cas, nous ne nous soucions pas d'utiliser des objets
lis pour nos tests unitaires du moment
que nous avons confiance en eux. Si
ce n'est pas le cas, les Mock Objects peuvent nous aider
tester unitairement de faon isole. Les Mock Objects
remplacent les objets lis de l'lment test.
</p>
<p>
Les exemples suivants utilisent l'interface <code>Collaborator</code>:
</p>
<pre>
package org.easymock.samples;

public interface Collaborator {
    void documentAdded(String title);
    void documentChanged(String title);
    void documentRemoved(String title);
    byte voteForRemoval(String title);
    byte[] voteForRemovals(String[] title);
}
</pre>
<p>
Les implmentations de cette interface sont des
objets lis (des listeners dans ce cas)  la classe nomme <code>ClassUnderTest</code>:
</p>
<pre>
public class ClassUnderTest {
    // ...
    public void addListener(Collaborator listener) {
        // ...
    }
    public void addDocument(String title, byte[] document) {
        // ...
    }
    public boolean removeDocument(String title) {
        // ...
    }
    public boolean removeDocuments(String[] titles) {
        // ...
    }
}
</pre>
<p>
Le code de la classe et de l'interface est disponible dans
le package <code>org.easymock.samples</code> dans <code>easymock-3.1-samples.jar</code>
inclue dans la livraison d'EasyMock.
</p>
<p>
Les exemples qui suivent supposent que vous tes familier avec le framework de test JUnit.
Bien que les tests montrs ici utilisent JUnit 4, vous pouvez galement utiliser JUnit 3 ou TestNG.
</p>
<h3>
Votre premier Mock Object
</h3>
<p>
Nous allons maintenant construire un cas de test et jouer avec pour
comprendre les fonctionnalits du package EasyMock. Le
fichier <code>easymock-3.1-samples.jar</code> contient une version modifie de ce test.
Notre premier test devra vrifier que la suppression d'un document non existant <strong>ne doit pas</strong>
provoquer la notification de l'objet li. Voici le test dans la dfinition du Mock Object:
</p>
<pre>
package org.easymock.samples;

import org.junit.*;

public class ExampleTest {

    private ClassUnderTest classUnderTest;
    private Collaborator mock;

    @Before
    public void setUp() {
        classUnderTest = new ClassUnderTest();
        classUnderTest.addListener(mock);
    }

    @Test
    public void testRemoveNonExistingDocument() {
        // This call should not lead to any notification
        // of the Mock Object:
        classUnderTest.removeDocument("Does not exist");
    }
}
</pre>
<p>
Pour beaucoup de tests utilisant EasyMock, nous avons
uniquement besoin de l'import statique des mthodes de la classe
<code>org.easymock.EasyMock</code>.
Cette classe est la seule non interne et non dprcie d'EasyMock 2.
</p>
<pre>
import static org.easymock.EasyMock.*;
import org.junit.*;

public class ExampleTest {

    private ClassUnderTest classUnderTest;
    private Collaborator mock;

}
</pre>
<p>
Pour obtenir un Mock Object, il faut:
</p>
<ol>
<li>crer un Mock Object pour l'interface  simuler,
</li>
<li>enregistrer le comportement attendu, puis
</li>
<li>basculer le Mock Object  l'tat 'replay'.
</li>
</ol>
<p>
Voici le premier exemple:
</p>
<pre>
    @Before
    public void setUp() {
        mock = createMock(Collaborator.class); // 1
        classUnderTest = new ClassUnderTest();
        classUnderTest.addListener(mock);
    }

    @Test
    public void testRemoveNonExistingDocument() {
        // 2 (we do not expect anything)
        replay(mock); // 3
        classUnderTest.removeDocument("Does not exist");
    }
</pre>
<p>
Aprs activation  l'tape 3, <code>mock</code>
est un Mock Object de l'interface <code>Collaborator</code>
qui n'attend aucun appel. Cela signifie que si nous changeons notre <code>ClassUnderTest</code>
pour appeler n'importe quelle mthode de l'interface, le Mock Object lvera
une <code>AssertionError</code>:
</p>
<pre>
java.lang.AssertionError:
  Unexpected method call documentRemoved("Does not exist"):
    at org.easymock.internal.MockInvocationHandler.invoke(MockInvocationHandler.java:29)
    at org.easymock.internal.ObjectMethodsFilter.invoke(ObjectMethodsFilter.java:44)
    at $Proxy0.documentRemoved(Unknown Source)
    at org.easymock.samples.ClassUnderTest.notifyListenersDocumentRemoved(ClassUnderTest.java:74)
    at org.easymock.samples.ClassUnderTest.removeDocument(ClassUnderTest.java:33)
    at org.easymock.samples.ExampleTest.testRemoveNonExistingDocument(ExampleTest.java:24)
    ...
</pre>

<h3>
   Ajouter un comportement
</h3>
<p>
crivons un second test. Si un document est ajout
la classe teste, nous nous attendons  un appel
<code>mock.documentAdded()</code>
sur le Mock Object avec le titre du document en argument:
</p>
<pre>
    @Test
    public void testAddDocument() {
        mock.documentAdded("New Document"); // 2
        replay(mock); // 3
        classUnderTest.addDocument("New Document", new byte[0]);
    }
</pre>
<p>
Aussi, dans l'tape d'enregistrement (avant d'appeler <code>replay</code>),
le Mock Object ne se comporte pas comme<em></em> un Mock Object mais enregistre
les appels de mthode. Aprs l'appel  <code>replay</code>,
il se comporte comme un Mock Object, vrifiant que les appels
de mthode attendus ont bien lieu.
</p>
<p>
Si <code>classUnderTest.addDocument("New Document", new byte[0])</code>
appelle la mthode attendue avec un mauvais argument, le
Mock Object lvera une <code>AssertionError</code>:
</p>
<pre>
java.lang.AssertionError:
  Unexpected method call documentAdded("Wrong title"):
    documentAdded("New Document"): expected: 1, actual: 0
    at org.easymock.internal.MockInvocationHandler.invoke(MockInvocationHandler.java:29)
    at org.easymock.internal.ObjectMethodsFilter.invoke(ObjectMethodsFilter.java:44)
    at $Proxy0.documentAdded(Unknown Source)
    at org.easymock.samples.ClassUnderTest.notifyListenersDocumentAdded(ClassUnderTest.java:61)
    at org.easymock.samples.ClassUnderTest.addDocument(ClassUnderTest.java:28)
    at org.easymock.samples.ExampleTest.testAddDocument(ExampleTest.java:30)
    ...
</pre>
<p>
Tous les appels attendus n'ayant pas eu lieu sont montrs, ainsi
que tous les appels faits alors qu'ils taient non attendus
(aucun dans notre cas). Si l'appel  la mthode est
effectu trop de fois, le Mock Object le signale
galement:
</p>
<pre>
java.lang.AssertionError:
  Unexpected method call documentAdded("New Document"):
    documentAdded("New Document"): expected: 1, actual: 2
    at org.easymock.internal.MockInvocationHandler.invoke(MockInvocationHandler.java:29)
    at org.easymock.internal.ObjectMethodsFilter.invoke(ObjectMethodsFilter.java:44)
    at $Proxy0.documentAdded(Unknown Source)
    at org.easymock.samples.ClassUnderTest.notifyListenersDocumentAdded(ClassUnderTest.java:62)
    at org.easymock.samples.ClassUnderTest.addDocument(ClassUnderTest.java:29)
    at org.easymock.samples.ExampleTest.testAddDocument(ExampleTest.java:30)
    ...
</pre>
<h3>
Vrifier le comportement
</h3>
<p>
Il y a un type d'erreur dont nous ne nous sommes pas
proccups jusqu' prsent: si nous dcrivons un
comportement, nous voulons vrifier qu'il est bien respect.
Le test qui suit passe si une mthode du Mock Object est appele.
Pour vrifier cela, nous devons appeler <code>verify(mock)</code>:
</p>
<pre>
    @Test
    public void testAddDocument() {
        mock.documentAdded("New Document"); // 2
        replay(mock); // 3
        classUnderTest.addDocument("New Document", new byte[0]);
        verify(mock);
    }
</pre>
<p>
Si la mthode du Mock Object n'est pas appele,
l'exception suivante sera leve :
</p>
<pre>
java.lang.AssertionError:
  Expectation failure on verify:
    documentAdded("New Document"): expected: 1, actual: 0
    at org.easymock.internal.MocksControl.verify(MocksControl.java:70)
    at org.easymock.EasyMock.verify(EasyMock.java:536)
    at org.easymock.samples.ExampleTest.testAddDocument(ExampleTest.java:31)
    ...
</pre>
<p>
Le message de l'exception liste tous les appels attendus qui n'ont pas eu lieu.
</p>
<h3>
Attendre un nombre explicite d'appels
</h3>
<p>
Jusqu' maintenant, nos tests ont t faits uniquement
sur un seul appel de mthode. Le test suivant
vrifiera que l'ajout d'un document dj existant
dclenche l'appel  <code>mock.documentChanged()</code>
avec l'argument appropri. Pour en tre certain, nous
vrifions cela trois fois (aprs tout, c'est un exemple
;-)):
</p>
<pre>
    @Test
    public void testAddAndChangeDocument() {
        mock.documentAdded("Document");
        mock.documentChanged("Document");
        mock.documentChanged("Document");
        mock.documentChanged("Document");
        replay(mock);
        classUnderTest.addDocument("Document", new byte[0]);
        classUnderTest.addDocument("Document", new byte[0]);
        classUnderTest.addDocument("Document", new byte[0]);
        classUnderTest.addDocument("Document", new byte[0]);
        verify(mock);
    }
</pre>
<p>
Afin d'viter la rptition de <code>mock.documentChanged("Document")</code>,
EasyMock fournit un raccourci. Nous pouvons spcifier le nombre d'appel avec la mthode
<code>times(int times)</code> sur l'objet retourn par <code>expectLastCall()</code>.
Le code ressemble alors  cela:
</p>
<pre>
    @Test
    public void testAddAndChangeDocument() {
        mock.documentAdded("Document");
        mock.documentChanged("Document");
        expectLastCall().times(3);
        replay(mock);
        classUnderTest.addDocument("Document", new byte[0]);
        classUnderTest.addDocument("Document", new byte[0]);
        classUnderTest.addDocument("Document", new byte[0]);
        classUnderTest.addDocument("Document", new byte[0]);
        verify(mock);
    }
</pre>
<p>
Si la mthode est appele un trop grand nombre de fois,
une exception sera leve nous indiquant que la mthode a
t appele trop de fois.
L'erreur est leve immdiatement aprs le premier
appel dpassant la limite:
</p>
<pre>
java.lang.AssertionError:
  Unexpected method call documentChanged("Document"):
    documentChanged("Document"): expected: 3, actual: 4
	at org.easymock.internal.MockInvocationHandler.invoke(MockInvocationHandler.java:29)
	at org.easymock.internal.ObjectMethodsFilter.invoke(ObjectMethodsFilter.java:44)
	at $Proxy0.documentChanged(Unknown Source)
	at org.easymock.samples.ClassUnderTest.notifyListenersDocumentChanged(ClassUnderTest.java:67)
	at org.easymock.samples.ClassUnderTest.addDocument(ClassUnderTest.java:26)
	at org.easymock.samples.ExampleTest.testAddAndChangeDocument(ExampleTest.java:43)
    ...
</pre>
<p>
S'il y a trop peu d'appels, <code>verify(mock)</code>
lve une <code>AssertionError</code>:
</p>
<pre>
java.lang.AssertionError:
  Expectation failure on verify:
    documentChanged("Document"): expected: 3, actual: 2
	at org.easymock.internal.MocksControl.verify(MocksControl.java:70)
	at org.easymock.EasyMock.verify(EasyMock.java:536)
	at org.easymock.samples.ExampleTest.testAddAndChangeDocument(ExampleTest.java:43)
    ...
</pre>
<h3>
Spcifier des valeurs de retour
</h3>
<p>
Pour spcifier des valeurs de retour, nous encapsulons l'appel attendu dans
<code>expect(T value)</code> et spcifions la valeur de retour avec la
mthode <code>andReturn(Object returnValue)</code> sur l'objet retourn par
<code>expect(T value)</code>.
</p>
<p>
Prenons par exemple la vrification du workflow lors de la suppression d'un document.
Si <code>ClassUnderTest</code> fait un appel pour supprimer un document,
il doit demander aux objets lis de voter pour cette suppression
par appel  <code>byte voteForRemoval(String title)</code>.
Une rponse positive approuve la suppression. Si la somme de
toutes les rponses est positive, alors le document est
supprim et l'appel  <code>documentRemoved(String title)</code>
est effectu sur les objets lis:
</p>
<pre>
    @Test
    public void testVoteForRemoval() {
        mock.documentAdded("Document");   // expect document addition
        // expect to be asked to vote for document removal, and vote for it
        expect(mock.voteForRemoval("Document")).andReturn((byte) 42);
        mock.documentRemoved("Document"); // expect document removal
        replay(mock);
        classUnderTest.addDocument("Document", new byte[0]);
        assertTrue(classUnderTest.removeDocument("Document"));
        verify(mock);
    }

    @Test
    public void testVoteAgainstRemoval() {
        mock.documentAdded("Document");   // expect document addition
        // expect to be asked to vote for document removal, and vote against it
        expect(mock.voteForRemoval("Document")).andReturn((byte) -42);
        replay(mock);
        classUnderTest.addDocument("Document", new byte[0]);
        assertFalse(classUnderTest.removeDocument("Document"));
        verify(mock);
    }
</pre>
<p>
Le type de la valeur de retour est vrifi  la
compilation. Par exemple, le code suivant ne compilera pas du fait que
le type fourni ne correspond au type retourn par la
mthode:
</p>
<pre>
    expect(mock.voteForRemoval("Document")).andReturn("wrong type");
</pre>
<p>
Au lieu d'appeler <code>expect(T value)</code> pour
rcuprer l'objet auquel affecter une valeur de retour,
nous pouvons aussi utiliser l'objet retourn par <code>expectLastCall()</code>.
Ainsi, au lieu de
</p>
<pre>
    expect(mock.voteForRemoval("Document")).andReturn((byte) 42);
</pre>
<p>
nous pouvons crire
</p>
<pre>
    mock.voteForRemoval("Document");
    expectLastCall().andReturn((byte) 42);
</pre>
<p>
Ce type d'criture doit uniquement tre utilis
si la ligne est trop longue car il n'inclut pas la vrification
du type  la compilation.
</p>
<h3>
Travailler avec les exceptions
</h3>
<p>
Afin de spcifier les exceptions (plus prcisment:
les Throwables) devant tre leves, l'objet
retourn par <code>expectLastCall()</code> et <code>expect(T value)</code>
fournit la mthode <code>andThrow(Throwable throwable)</code>.
Cette mthode doit tre appele durant l'tape
d'enregistrement aprs l'appel au Mock Object pour lequel le <code>Throwable</code>
doit tre lev.
</p>
<p>
Les exception non "checkes" (comme <code>RuntimeException</code>,
<code>Error</code> ainsi que toutes leurs sous classes) peuvent
tre leves de n'importe quelle mthode. Les
exceptions "checkes" ne doivent tre leves que
pour mthodes o cela est prvu.
</p>
<h3>
Crer des valeurs de retour ou des exceptions
</h3>
<p>
Parfois, nous voulons que notre Mock Object retourne une valeur ou
lve une exception cre au moment de l'appel.
Depuis la version 2.2 d'EasyMock, l'objet retourn
par <code>expectLastCall()</code> et <code>expect(T value)</code> fournit la mthode
<code>andAnswer(IAnswer answer)</code> permettant de spcifier une implmentation
de l'interface <code>IAnswer</code> utilise pour crer
une valeur de retour ou une exception.
</p>
<p>
Au sein d'<code>IAnswer</code>, les arguments passs lors de l'appel au mock sont
disponibles via <code>EasyMock.getCurrentArguments()</code>.
Si vous utilisez cela, les refactorings du type rorganisation
de l'ordre des arguments briseront vos tests. Vous tes prvenu.
</p>
<p>
Une alternative  <code>IAnswer</code> sont les mthodes <code>andDelegateTo</code> et
<code>andStubDelegateTo</code>. Elles permettent de dlguer un appel  une
implmentation concrte de l'interface "mockes" et qui fournira la valeur de retour.
L'avantage est que les paramtres normalement rcupr avec <code>EasyMock.getCurrentArguments()</code>
pour <code>IAnswer</code> sont maintenant passs  la mthode de l'implmentation concrte.
a supporte donc le refactoring. Le dsavantage est qu'il faut fournir une implmentation...
ce qui resemble un peu  faire un mock  la main. Ce que vous tentez d'viter en utilisant
EasyMock. Il peut aussi tre pnible d'implmenter l'interface si celle-ci  beaucoup de mthodes. Finalement,
le type de l'implmentation ne peut tre vrifi statiquement par rapport au type du Mock Object.
Si pour une quelconque raison, la class concrte n'implmente plus la mthode sur laquelle est
dlgu l'appel, vous aurez une exception lors de la phase de "replay". Ce cas devrait toutefois
tre assez rare.
</p>
<p>
Pour bien comprendre les deux options, voici un exemple:
</p>
<pre>
    List&lt;String&gt; l = createMock(List.class);

    // andAnswer style
    expect(l.remove(10)).andAnswer(new IAnswer&lt;String&gt;() {
        public String answer() throws Throwable {
            return getCurrentArguments()[0].toString();
        }
    });

    // andDelegateTo style
    expect(l.remove(10)).andDelegateTo(new ArrayList&lt;String&gt;() {
        @Override
        public String remove(int index) {
            return Integer.toString(index);
        }
    });
</pre>
<h3>
Changer de comportement sur le mme appel de mthode
</h3>
<p>
Il est galement possible de spcifier un changement de comportement pour une mthode.
Les mthodes <code>times</code>, <code>andReturn</code> et <code>andThrow</code>
peuvent tre chanes. Comme exemple,
nous dfinissons <code>voteForRemoval("Document")</code> pour
</p>
<ul>
<li>retourner 42 pour les trois premiers appels,
</li>
<li>lever une <code>RuntimeException</code> sur le quatrime appel,
</li>
<li>renvoyer -42 une fois.
</li>
</ul>
<pre>
    expect(mock.voteForRemoval("Document"))
        .andReturn((byte) 42).times(3)
        .andThrow(new RuntimeException(), 4)
        .andReturn((byte) -42);
</pre>
<h3>
tre plus permissif sur le nombre d'appels
</h3>
<p>
Afin d'tre plus permissif sur le nombre d'appels attendus,
des mthodes additionnelles peuvent tre
utilises  la place de <code>times(int count)</code>:
</p>
<dl>
<dt><code>times(int min, int max)</code></dt>
<dd>pour attendre entre <code>min</code> and <code>max</code> appels,</dd>
<dt><code>atLeastOnce()</code></dt>
<dd>pour attendre au moins un appel, et</dd>
<dt><code>anyTimes()</code></dt>
<dd>pour attendre une quantit non dfinie d'appels.</dd>
</dl>
<p>
Si aucun nombre d'appels n'est explicitement dfini,
alors seul un appel est attendu. Pour le dfinir explicitement,
vous pouvez utiliser <code>once()</code> ou <code>times(1)</code>.
</p>
<h3>
Mocks stricts
</h3>
<p>
Sur un Mock Object retourn par <code>EasyMock.createMock()</code>,
l'ordre d'appel des mthodes n'est pas vrifi.
Si vous souhaitez avoir un Mock Object 'strict' vrifiant cet ordre,
utilisez <code>EasyMock.create<i>Strict</i>Mock()</code>.</p>
<p>
Lorsqu'un appel inattendu  une mthode est fait sur
un Mock Object 'strict', le message de l'exception contient les appels
de mthode attendus  ce moment, suivi du premier appel en
conflit. <code>verify(mock)</code> montre tous les appels de mthode manqus.
</p>
<h3>
Activer/Dsactiver la vrification de l'ordre d'appel des mthodes
</h3>
<p>
Il est parfois ncessaire qu'un Mock Object vrifie
l'ordre d'appel sur certains appels uniquement. Pendant la phase
d'enregistrement, vous pouvez activer la vrification de l'ordre
d'appel en utilisant <code>checkOrder(mock, true)</code> et la
dsactiver en utilisant <code>checkOrder(mock, false)</code>.
</p>
<p>
Il y a deux diffrences entre un Mock Object 'strict' et un Mock Object 'normal':
</p>
<ol>
	<li> Un mock 'strict' a la vrification de l'ordre d'appel activ  la cration. </li>
	<li> Un mock 'strict' a la vrification de l'ordre d'appel activ aprs un reset (voir <em>Rutilisation d'un Mock Object</em>). </li>
</ol>
<h3>
Dfinir des comparateurs d'arguments pour plus de souplesse
</h3>
<p>
Pour vrifier la correspondance  un appel de mthode prvu sur un Mock Object,
les arguments<code> de type Object</code> sont compars, par dfaut, avec
<code>equals()</code>. Cela peut introduire des problmes. Considrons l'exemple suivant:
</p>
<pre>
String[] documents = new String[] { "Document 1", "Document 2" };
expect(mock.voteForRemovals(documents)).andReturn(42);
</pre>
<p>
Si la mthode est appele avec un autre tableau ayant le mme contenu,
cela provoque une exception du fait que <code>equals()</code> compare l'identit
des objets pour les tableaux:
</p>
<pre>
java.lang.AssertionError:
  Unexpected method call voteForRemovals([Ljava.lang.String;@9a029e):
    voteForRemovals([Ljava.lang.String;@2db19d): expected: 1, actual: 0
    documentRemoved("Document 1"): expected: 1, actual: 0
    documentRemoved("Document 2"): expected: 1, actual: 0
	at org.easymock.internal.MockInvocationHandler.invoke(MockInvocationHandler.java:29)
	at org.easymock.internal.ObjectMethodsFilter.invoke(ObjectMethodsFilter.java:44)
	at $Proxy0.voteForRemovals(Unknown Source)
	at org.easymock.samples.ClassUnderTest.listenersAllowRemovals(ClassUnderTest.java:88)
	at org.easymock.samples.ClassUnderTest.removeDocuments(ClassUnderTest.java:48)
	at org.easymock.samples.ExampleTest.testVoteForRemovals(ExampleTest.java:83)
    ...
</pre>
<p>
Pour spcifier que seule l'galit de tableau
est ncessaire pour cet appel, utilisez la mthode
<code>aryEq</code>, importe statiquement de la classe <code>EasyMock</code>:
</p>
<pre>
String[] documents = new String[] { "Document 1", "Document 2" };
expect(mock.voteForRemovals(aryEq(documents))).andReturn(42);
</pre>
<p>
Si vous souhaitez utiliser les comparateurs lors d'un appel, vous devez
en utiliser pour chaque argument de la mthode appele.
</p>
<p>
Voici quelques comparateurs prdfinis disponible:
</p>
<dl>

<dt><code>eq(X value)</code></dt>
<dd>Vrifie que la valeur reue gale la valeur attendue. Disponible pour tous les types primitifs et objets.</dd>

<dt><code>anyBoolean()</code>, <code>anyByte()</code>, <code>anyChar()</code>, <code>anyDouble()</code>, <code>anyFloat()</code>, <code>anyInt()</code>, <code>anyLong()</code>, <code>anyObject()</code>, <code>anyObject(Class clazz)</code>, <code>anyShort()</code></dt>
<dd>Laisse passer n'importe quelle valeur. Disponible pour tous les types primitifs et objets.</dd>

<dt><code>eq(X value, X delta)</code></dt>
<dd>Vrifie que la valeur reue gale la valeur attendue, plus ou moins un delta. Disponible pour les <code>float</code> et <code>double</code>.</dd>

<dt><code>aryEq(X value)</code></dt>
<dd>Vrifie que la valeur reue gale la valeur attendue en s'appuyant sur <code>Arrays.equals()</code>. Disponible pour les tableaux d'objets et de types primitifs.</dd>

<dt><code>isNull()</code>, <code>isNull(Class clazz)</code></dt>
<dd>Vrifie que la valeur reue est nulle. Disponible pour les objets.</dd>

<dt><code>notNull()</code>, <code>notNull(Class clazz)</code></dt>
<dd>Vrifie que la valeur reue n'est pas nulle. Disponible pour les objets.</dd>

<dt><code>same(X value)</code></dt>
<dd>Vrifie que la valeur reue est la mme que la value attendue. Disponible pour les objets.</dd>

<dt><code>isA(Class clazz)</code></dt>
<dd>Vrifie que la valeur reue est une instance de clazz ou d'une classe hrite ou implmente clazz. Disponible pour les objets.</dd>

<dt><code>lt(X value)</code>, <code>leq(X value)</code>, <code>geq(X value)</code>, <code>gt(X value)</code></dt>
<dd>Vrifie que la valeur reue est infrieure/infrieure ou gale/suprieure
ou gale/suprieure  la valeur attendue. Disponible pour tous les types primitifs numriques et les implmentations de <code>Comparable</code>.</dd>

<dt><code>startsWith(String prefix), contains(String substring), endsWith(String suffix)</code></dt>
<dd>Vrifie que la valeur reue commence par/contient/se termine par la valeur attendue. Disponible pour les <code>String</code>s.</dd>

<dt><code>matches(String regex), find(String regex)</code></dt>
<dd>Vrifie que la valeur reue/une sous-chane de la valeur reue correspond  l'expression r. Disponible pour les <code>String</code>s.</dd>

<dt><code>and(X first, X second)</code></dt>
<dd>Est valide si les rsultats des deux comparateurs utiliss en <code>first</code> et <code>second</code> sont vrifis. Disponible pour tous les types primitifs et objets.</dd>

<dt><code>or(X first, X second)</code></dt>
<dd>Est valide si l'un des rsultats des deux comparateurs utiliss en <code>first</code> et <code>second</code> est vrifi. Disponible pour tous les types primitifs et objets.</dd>

<dt><code>not(X value)</code></dt>
<dd>Est valide si le rsultat du comparateur utilis dans <code>value</code> est ngatif.</dd>

<dt><code>cmpEq(X value)</code></dt>
<dd>Vrifie que la valeur reue gale la valeur attendue du point de vue de <code>Comparable.compareTo(X o)</code>. Disponible pour tous les types primitifs numriques et les implmentations de <code>Comparable</code>.</dd>

<dt><code>cmp(X value, Comparator&lt;X&gt; comparator, LogicalOperator operator)</code></dt>
<dd>Vrifie que <code>comparator.compare(reue, value) operator 0</code> o <code>operator</code> est &lt;,&lt;=,&gt;,&gt;= ou ==.</dd>

<dt><code>capture(Capture&lt;T&gt; capture)</code>, <code>captureXXX(Capture&lt;T&gt; capture)</code></dt>
<dd>Laisse passer n'importe quelle valeur mais la capture dans le paramtre <code>Capture</code> pour un usage ultrieurs. Vous pouvez utiliser <code>and(someMatcher(...), capture(c))</code> pour
capturer le paramtre d'un appel de mthode en particulier. Vous pouvez aussi spcifier le <code>CaptureType</code> pour indiquer  l'objet
<code>Capture</code> de conserver le premier (<code>FIRST</code>), le dernier (<code>LAST</code>), tous (<code>ALL</code>) ou aucun (<code>NONE</code>) des objets capturs</dd>

</dl>

<h3>
Dfinir son propre comparateur d'arguments
</h3>
<p>
Il peut tre intressant de dfinir son propre
comparateur d'argument. Prenons un comparateur dont le rle
serait de vrifier une exception par rapport  son
type et message. Il pourrait tre utilis de la faon suivante:
</p>
<pre>
    IllegalStateException e = new IllegalStateException("Operation not allowed.")
    expect(mock.logThrowable(eqException(e))).andReturn(true);
</pre>
<p>
Deux tapes sont ncessaires pour raliser cela: le nouveau comparateur
doit tre dfini et la mthode statique <code>eqException</code>
doit tre dclare.
</p>
<p>
Pour dfinir le nouveau comparateur d'argument, nous implmentons l'interface <code>org.easymock.IArgumentMatcher</code>.
Cette interface contient deux mthodes: <code>matches(Object actual)</code>, vrifiant
que l'argument reu est bien celui attendu, et <code>appendTo(StringBuffer buffer)</code>,
ajoutant au StringBuffer une chane de caractres reprsentative du comparateur d'argument.
L'implmentation est la suivante :
</p>
<pre>
import org.easymock.IArgumentMatcher;

public class ThrowableEquals implements IArgumentMatcher {
    private Throwable expected;

    public ThrowableEquals(Throwable expected) {
        this.expected = expected;
    }

    public boolean matches(Object actual) {
        if (!(actual instanceof Throwable)) {
            return false;
        }
        String actualMessage = ((Throwable) actual).getMessage();
        return expected.getClass().equals(actual.getClass())
                &amp;&amp; expected.getMessage().equals(actualMessage);
    }

    public void appendTo(StringBuffer buffer) {
        buffer.append("eqException(");
        buffer.append(expected.getClass().getName());
        buffer.append(" with message \"");
        buffer.append(expected.getMessage());
        buffer.append("\"")");

    }
}
</pre>
<p>
La mthode <code>eqException</code> doit instancier le
comparateur d'argument avec l'objet Throwable donn, le fournir
 EasyMock via la mthode statique <code>reportMatcher(IArgumentMatcher matcher)</code>
et retourner une valeur afin d'tre utilise au sein de l'appel  la mthode mocke
(typiquement <code>0</code>, <code>null</code> ou <code>false</code>). Une premire tentative ressemblerait  ceci:
</p>
<pre>
public static Throwable eqException(Throwable in) {
    EasyMock.reportMatcher(new ThrowableEquals(in));
    return null;
}
</pre>
<p>
Cependant, cela ne fonctionnerait que si la mthode <code>logThrowable</code>
de l'exemple acceptait <code>Throwable</code>s et quelque chose de plus spcifique du style de <code>RuntimeException</code>.
Dans ce dernier cas, le code de notre exemple ne compilerait pas:
</p>
<pre>
    IllegalStateException e = new IllegalStateException("Operation not allowed.")
    expect(mock.logThrowable(eqException(e))).andReturn(true);
</pre>
<p>
Java 5.0  la rescousse: Au lieu de dfinir <code>eqException</code>
avec un <code>Throwable</code> en paramtre, nous utilisons un type gnrique
qui hrite de <code>Throwable</code>:
</p>
<pre>
public static &lt;T extends Throwable&gt; T eqException(T in) {
    reportMatcher(new ThrowableEquals(in));
    return null;
}
</pre>
<h3>
Rutilisation d'un Mock Object
</h3>
<p>
Les Mock Objects peuvent tre rinitialiss avec <code>reset(mock)</code>.
</p>
<p>
Au besoin, un Mock Object peut aussi tre converti d'un type  l'autre en appelant <code>resetToNice(mock)</code>,
<code>resetToDefault(mock)</code> ou <code>resetToStrict(mock)</code>.
</p>
<h3>
Utilisation d'un comportement de "stub" pour les mthodes
</h3>
<p>
Dans certains cas, nous voudrions que nos Mock Object rpondent
 certains appels, mais sans tenir compte du nombre de fois, de l'ordre
ni mme s'ils ont t eu lieu.
Ce comportement de "stub" peut tre dfini en utilisant
les mthodes <code>andStubReturn(Object value)</code>,
<code>andStubThrow(Throwable throwable)</code>, <code>andStubAnswer(IAnswer&lt;t&gt; answer)</code>
et <code>asStub()</code>. Le code suivant configure le Mock Object pour rpondre 42
 <code>voteForRemoval("Document")</code> une fois et -1 pour tous les autres arguments:
</p>
<pre>
    expect(mock.voteForRemoval("Document")).andReturn(42);
    expect(mock.voteForRemoval(not(eq("Document")))).andStubReturn(-1);
</pre>
<h3>
Cration de mocks dits "gentils"
</h3>
<p>
Pour un Mock Object retourn par <code>createMock()</code>, le comportement par dfaut pour toutes
les mthodes est de lever une <code>AssertionError</code> pour tous les appels non prvus.
Si vous souhaitez avoir un Mock Object "gentil" autorisant, par dfaut, l'appel
toutes les mthodes et retournant la valeur vide approprie (<code>0</code>, <code>null</code>
ou <code>false</code>), utilisez <code>create<i>Nice</i>Mock()</code> au lieu de <code>createMock()</code>.
</p>

<a id="Object_Methods"/><h3>Mthodes de la classe Object</h3>
<p>
Les comportements des quatre mthodes <code>equals()</code>,
<code>hashCode()</code>, <code>toString()</code> et <code>finalize()</code>
ne peuvent tre changs sur des Mock Objects crs avec EasyMock,
mme si elles font partie de l'interface duquel le Mock Object est cr.
</p>
<h3>Vrifier l'ordre d'appel des mthodes entre plusieurs Mocks</h3>
<p>
Jusqu' prsent, nous avons vu un Mock Object comme tant
seul et configur par les mthodes statiques de la classe <code>EasyMock</code>.
Mais beaucoup de ces mthodes statiques font rfrence  l'objet "control"
cach de chaque Mock Object et lui dlgue l'appel. Un
Mock Control est un objet implmentant l'interface <code>IMocksControl</code>.
</p>
<p>
Du coup, au lieu de
</p>
<pre>
    IMyInterface mock = createStrictMock(IMyInterface.class);
    replay(mock);
    verify(mock);
    reset(mock);
</pre>
<p>
nous pourrions utiliser le code quivalent:
</p>
<pre>
    IMocksControl ctrl = createStrictControl();
    IMyInterface mock = ctrl.createMock(IMyInterface.class);
    ctrl.replay();
    ctrl.verify();
    ctrl.reset();
</pre>
<p>
L'interface <code>IMocksControl</code> permet de crer plus d'un seul Mock Object.
Ainsi, il est possible de vrifier l'ordre d'appel des mthodes entre les mocks.
Par exemple, configurons deux mock objects pour l'interface <code>IMyInterface</code> pour lesquels
nous attendons respectivement les appels  <code>mock1.a()</code> et <code>mock2.a()</code>,
un nombre indfini d'appels  <code>mock1.c()</code> et <code>mock2.c()</code>,
et enfin <code>mock2.b()</code> et <code>mock1.b()</code>, dans cet ordre:
</p>
<pre>
    IMocksControl ctrl = createStrictControl();
    IMyInterface mock1 = ctrl.createMock(IMyInterface.class);
    IMyInterface mock2 = ctrl.createMock(IMyInterface.class);

    mock1.a();
    mock2.a();

    ctrl.checkOrder(false);

    mock1.c();
    expectLastCall().anyTimes();
    mock2.c();
    expectLastCall().anyTimes();

    ctrl.checkOrder(true);

    mock2.b();
    mock1.b();

    ctrl.replay();
</pre>
<h3>Nommer un Mock Object</h3>
<p>
Les Mock Objects peuvent  nomms  leur cration en utilisant
<code>createMock(String name, Class&lt;T&gt; toMock)</code>,
<code>createStrictMock(String name, Class&lt;T&gt; toMock)</code> ou
<code>createNiceMock(String name, Class&lt;T&gt; toMock)</code>.
Les noms seront affichs dans le message des <code>AssertionError</code>.
</p>
<h3>Srializer un Mock Object</h3>
<p>
Un Mock Object peut tre srializ  n'importe quelle tape de son
existence. Il y a toutefois des contraintes videntes:
</p>
<ul>
<li>Les comparateurs d'arguments utiliss doivent tre srializable (ceux fournis avec EasyMock le sont)
</li>
<li>Les paramtres enregistrs doivent tre srializable
</li>
</ul>
<h3>Traitement multifil</h3>
<p>
Pendant la phase d'enregistrement un Mock Object <b>n'est pas</b>  fil scuris. Un Mock Object donn (ou des Mock Objects lis au
mme <code>IMocksControl</code>) ne peut tre enregistr que d'un seul fil. Toutefois, plusieurs Mock Objects peuvent tre enregistrs
simultanment dans des fils diffrents.
</p>
<p>
Durant la phase de rejeu, un Mock Object sera  fil scuris par dfaut. Ceci peut tre chang en appelant <code>makeThreadSafe(mock, false)</code>.
durant la phase d'enregistrement. Cela peut permettre d'viter des interblocages dans certaines rares situations.
</p>
<p>
Finallement, appeler <code>checkIsUsedInOneThread(mock, true)</code> permet de s'assurer qu'un Mock Object ne sera appel que d'un seul
fil. Une exception sera lanc sinon. Cela peut tre pratique dans le cas o l'objet "mock" n'est pas  fil scuris et que l'on veut
s'assurer qu'il est utilis correctement.
</p>
<h3>EasyMockSupport</h3>
<p>
<code>EasyMockSupport</code> est une classe ayant pour but d'tre utilise comme classe utilitaire ou comme classe de base de vos classes
de test. Elle se souvient de tous les "Mock Objects" crs (ou en fait de tous les "Mock Controls" crs) pour pouvoir faire un replay,
reset ou verify de tous en un seul coup. Voici un exemple utilisant JUnit:
</p>
<pre>
public class SupportTest extends EasyMockSupport {

    private Collaborator firstCollaborator;
    private Collaborator secondCollaborator;
    private ClassTested classUnderTest;

    @Before
    public void setup() {
        classUnderTest = new ClassTested();
    }

    @Test
    public void addDocument() {
        // phase de cration
        firstCollaborator = createMock(Collaborator.class);
        secondCollaborator = createMock(Collaborator.class);
        classUnderTest.addListener(firstCollaborator);
        classUnderTest.addListener(secondCollaborator);

        // phase d'enregistrement
        firstCollaborator.documentAdded("New Document");
        secondCollaborator.documentAdded("New Document");

        replayAll(); // tous les mocks d'un seul coup

        // test
        classUnderTest.addDocument("New Document", new byte[0]);

        verifyAll(); // tous les mocks d'un seul coup
    }
}
</pre>
<h3>Modifier les comportements par dfaut d'EasyMock</h3>
<p>
EasyMock fournit un mcanisme de gestion de proprits permettant de modifier son comportement. Il vise
principalement  permettre le retour  un comportement antrieur  la version courante. Les proprits
actuellement supportes sont:
</p>
<dl>
<dt><code>easymock.notThreadSafeByDefault</code></dt>
<dd>Si true, les Mock Objects ne seront pas  fil scuris par dfaut. Values possibles: "true" ou "false". Dfaut: false</dd>
<dt><code>easymock.enableThreadSafetyCheckByDefault</code></dt>
<dd>Si true, un mock ne pourra tre appel que d'un seul fil. Values possibles: "true" ou "false". Dfaut: false</dd>
<dt><code>easymock.disableClassMocking</code></dt>
<dd>Ne pas permettre le mocking de classes (permettre uniquement le mocking d'interfaces). Valeurs possibles: "true" ou "false". Dfaut: false</dd>
</dl>
<p>
Les proprits peuvent tre mise de trois faons. Chaque tape de la liste peut craser une prcdente.
</p>
<ul>
<li>Dans le fichier <code>easymock.properties</code> mis dans le package dfaut du classpath
</li>
<li>Comme proprit systme
</li>
<li>En appelant <code>EasyMock.setEasyMockProperty</code>. Des constantes sont disponibles
dans la classe <code>EasyMock</code>
</li>
</ul>
<h3>
Compatibilit avec les anciennes versions
</h3>
<p>EasyMock 3 fournit toujours le project Class Extension (qui est toutefois dprci) pour
permettre une migration plus facile de EasyMock 2 vers EasyMock 3. Il s'agit d'une compatibilit des
sources et non des binaires. Le code devra donc tre recompil.
</p>
<p>EasyMock 2.1 introduisait une fonctionnalit de callback
qui a t retire dans EasyMock 2.2, car trop complexe.
Depuis EasyMock 2.2, l'interface <code>IAnswer</code>
fournit la fonctionnalit de callback.
</p>
<h3>OSGi</h3>
<p>
Le jar d'EasyMock peut tre utilis comme bundle OSGi. Il export les packages
<code>org.easymock</code>, <code>org.easymock.internal</code>
et <code>org.easymock.internal.matchers</code>. Toutefois, pour importer les deux
derniers, vous spcifier l'attribut <code>poweruser</code>  "true" (<code>poweruser=true</code>).
Ces packages sont prvus d'tre utiliss pour tendre EasyMock, ils n'ont donc pas besoins d'tre
imports habituellement.
</p>
<h3>Mocking partiel</h3>
<p>
Dans certains cas, vous pouvez avoir besoin de "mocker" uniquement certaines
mthodes d'une classe et de conserver un comportement normal pour
les autres. Cela arrive habituellement lorsque pour souhaitez tester une
mthode appelant d'autres mthodes de la mme classe.
Vous voulez donc garder le comportement normal de la mthode teste
et "mocker" les autres.
</p>
<p>
Dans ce cas, la premier rflexe  avoir est
d'envisager un refactoring car, bien souvent, ce problme est la
consquence d'un mauvais design. Si ce n'est pas le cas ou si
vous ne pouvez faire autrement pour une quelconque contrainte de
dveloppement, voici la solution:
</p>
<pre>
ToMock mock = createMockBuilder(ToMock.class)
   .addMockedMethod("mockedMethod").createMock();
</pre>
<p>Seules les mthodes ajoutes avec <code>addMockedMethod(s)</code> seront
"mockes" (<code>mockedMethod()</code> dans l'exemple). Les autres conservent leur
comportement habituel. Une exception: les mthodes abstraites sont "mockes" par dfaut.
</p>
<p><code>createMockBuilder</code> retourne l'interface <code>IMockBuilder</code>. Elle contient
diverses mthodes pour facilement crer un mock partiel. Jettez un coup d'oeil  la javadoc
pour en savoir plus.
</p>
<p><b>Remarque:</b> EasyMock fournit un comportement par dfault pour les mthodes de la classe
Object (<i>equals, hashCode, toString, finalize</i>). Toutefois, pour un mock partiel, si ces mthodes ne sont pas
mockes explicitement, elles auront leur comportement normal et non celui par dfaut d'EasyMock.
</p>
<h3>Test interne d'une classe</h3>
<p>
Il est possible de crer un mock en appelant un constructeur de la classe. Ceci
peut tre utile lorsqu'une mthode doit tre teste mais d'autres
dans la mme classe "mockes". Pour cela vous devez faire quelque chose comme
</p>
<pre>
ToMock mock = createMockBuilder(ToMock.class)
   .withConstructor(1, 2, 3); // 1, 2, 3 sont les paramtres passs au constructeur
</pre>
<p>
Voir <code>ConstructorCalledMockTest</code> pour un exemple d'utilisation.
</p>
<h3>Remplacer l'instantiateur de classes par dfaut</h3>
<p>
Parfois (habituellement  cause d'une JVM non supporte), il est possible
que EasyMock ne soit pas capable de crer un mock dans votre environnement java.
Sous le capot, l'instantiation de classes est implmente par un pattern "factory".
En cas de problme, vous pouvez remplacer l'instantiateur par dfaut avec:
</p>
<ul>
<li>L'ancien <code>DefaultClassInstantiator</code> qui fonctionne trs bien avec les classes
srializable et sinon tente de deviner quel constructeur appeler et quels paramtres lui passer.</li>
<li>Votre propre instantiateur. Celui-ci doit implmenter <code>IClassInstantiator</code>.</li>
</ul>
<p>
Vous assignez ce nouvel instantiateur  l'aide de <code>ClassInstantiatorFactory.setInstantiator()</code>.
Vous pouvez remettre celui par dfaut avec <code>setDefaultInstantiator()</code>.
</p>
<p>
<b>Important:</b>
L'instantiateur est gard statiquement et reste donc entre deux tests. Assurez-vous
de le rinitialiser si ncessaire.
</p>
<h3>Srializer une classe mocke</h3>
<p>
Une class mocke peut aussi tre srializ. Toutefois, comme celle-ci tant une classe srializable,
cette dernire peut avoir un comportement spcial d  l'implmentation de mthodes tels
que <code>writeObject</code>. Ces mthodes seront toujours appeles lorsque le mock sera srializ
et peuvent potentiellement chouer. Habituellement, le contournement consiste  crer le mock
en appelant un constructeur.
</p>
<p>
Aussi, il est possible que la d-srialization d'un mock ne fonctionne pas si elle est effectue dans
un class loader diffrent de la srialization. Ce cas n'a pas t test.
</p>
<h3>Limitations du mocking de classes</h3>
<p>
Pour tre cohrent avec le mocking d'interfaces, EasyMock fournit aussi un comportement par dfaut
pour <code>equals()</code>, <code>toString()</code>, <code>hashCode()</code> et <code>finalize()</code> pour les classes mockes.
Cela signifie que vous ne pourrez enregistrer votre propre comportement pour ces mthodes. Cette
limitation tre considre comme une fonctionnalit permettant de ne pas s'occuper de ces
mthodes.
</p>
<p>
Les mthodes finales ne peuvent pas tre "mockes". Si
appeles, leur code normal sera excut.
</p>
<p>
Les mthodes prives ne peuvent tre "mockes". Si
appeles, leur code normal sera excut. Pour un mock partiel, si
la mthode teste appelle une mthode prive, vous devrez aussi tester
cette dernire tant donn que vous ne pouvez pas la mocker.
</p>
<p>
L'instantiation des classes est faite par
<a href="http://objenesis.googlecode.com/svn/docs/index.html">Objenesis</a>.
Les JVMs supportes sont listes <a href="http://code.google.com/p/objenesis/wiki/ListOfCurrentlySupportedVMs">ici</a>.
</p>

<h2>
Dveloppement d'EasyMock
</h2>
<p>
EasyMock a t dvelopp par Tammo Freese chez OFFIS. La maintenance est effectue
par Henri Tremblay depuis 2007. Le dveloppement d'EasyMock est hberg par
<a href="http://sourceforge.net/projects/easymock/">SourceForge</a>
pour permettre  d'autres dveloppeurs et socits d'y contribuer.
</p>
<p>
Les Mock Objects de classes (prcdemment appel EasyMock Class Extension) ont t initialement
dveloppe par Joel Shellman, Chad Woolley et Henri Tremblay dans la section
fichiers du of Yahoo!Groups.
</p>
<p>
Remerciements  ceux qui nous ont fourni retour d'exprience et rustines, incluant
Nascif Abousalh-Neto, Dave Astels, Francois Beausoleil, George Dinwiddie, Shane Duan,
Wolfgang Frech, Steve Freeman, Oren Gross, John D. Heintz, Dale King, Brian Knorr,
Dierk Koenig, Chris Kreussling, Robert Leftwich, Patrick Lightbody, Johannes Link,
Rex Madden, David McIntosh, Karsten Menne, Bill Michell,
Stephan Mikaty, Ivan Moore, Ilja Preuss, Justin Sampson, Markus Schmidlin, Richard Scott,
Joel Shellman, Ji Mare, Alexandre de Pellegrin
Shaun Smith, Marco Struck, Ralf Stuckert, Victor Szathmary, Bill Uetrecht,
Frank Westphal, Chad Woolley, Bernd Worsch,
Rodrigo Damazio, Bruno Fonseca, Ben Hutchison et de nombreux autres.
</p>
<p>
Merci de consulter la <a href="http://www.easymock.org">page d'accueil EasyMock</a>
pour tre inform des nouvelles versions et transmettez vos bogues et suggestions
<a href="mailto:easymock (a] yahoogroups.com?subject=EasyMock ${project.version} feedback">EasyMock Yahoo!Group</a> (en anglais SVP).
Si vous souhaitez souscrire au EasyMock Yahoo!Group, envoyez un message
<a href="mailto:easymock-subscribe (a] yahoogroups.com">easymock-subscribe (a] yahoogroups.com</a>.
</p>
<h3>
EasyMock Version 3.1 (2011-11-10), Notes de Mise  Jour
</h3>
<p>
Nouveau dans la version 3.1:
</p>
<ul>
<li>NoClassDefFoundError en appelant EasyMock.replay/reset/verify sur un mock d'interface si cglib n'est pas dans le classpath (EASYMOCK-40)
</li>
<li>Il est possible de compiler en Java 7 (les mthodes de capture des types primitifs sont renommes et dprcies) (EASYMOCK-100)
</li>
<li>Rparer la fuite mmoire lors de l'enregistrement du callback dans cglib (EASYMOCK-89)
</li>
<li>Ignorer les appels  <code>finalize</code> sur un Mock Object (EASYMOCK-21)
</li>
<li>MockBuilder.addMockedMethod doit refuser les mthodes finales (EASYMOCK-44)
</li>
<li>Les mthodes "bridge" ne doivent pas tre considrer par MockBuilder.addMockedMethod (EASYMOCK-90)
</li>
<li>Faire un test basique avec PowerMock pour vrifier qu'il fonctionne correctement (EASYMOCK-88)
</li>
<li>Ajout du nom de classe ou interface dans les messages d'erreur pour chaque invocation (EASYMOCK-104)
</li>
</ul>
<p>
Nouveau dans la version 3.0:
</p>
<ul>
<li>EasyMock CE is maintenant fusionn avec EasyMock (2325762)
</li>
<li>Ajout de "boolean capture(...)" par compltion (je ne pense pas que c'est utile)
</li>
<li>Impossible de rpondre en dlguant  une mthode protge (2891256)
</li>
<li>Un chec lors de la phase d'enregistrement peut impacter les tests subsquents (2914683)
</li>
<li>Returner une erreur spcifique lorsqu'un null est enregistr comme retour sur une mthode retournant un type primitif (2936175)
</li>
<li>Dsactiver le mocking de classes  l'aide de <code>EasyMock.DISABLE_CLASS_MOCKING</code>
</li>
<li>Retirer les classes dprcies d'EasyMock 1
</li>
<li>Ne pas lancer d'exception si on mock n'a pas de mthode <code>toString</code> (2937916)
</li>
<li>Message d'erreur plus clair lorsque des paramtres nues sont mlangs avec des matchers lors de l'enregistrement d'une mthode (2860190)
</li>
<li>Vrifier s'il reste des rsultats disponible dans un comportement enregistr avant de matcher avec celui-ci (2940400)
</li>
<li>Permettre les mocks de classes provenant d'un plugin Eclipse (2994002)
</li>
<li>Ajout de <code>isNull(Class&lt;T&gt;)</code>, <code>notNull(Class&lt;T&gt;)</code> et <code>anyObject(Class&lt;T&gt;)</code> pour faciliter la gestion des gnriques (2958636)
</li>
</ul>
<p>
Pour des notes de mise  jour plus anciennes, voir la <a href="Documentation.html">documentation de EasyMock 2 et EasyMock 2 Class Extension</a>.
</p>
</div>
</body>
</html>