Méthodes en erreur

Bonjour,

J'ai 3 méthodes dans mon code source qui sont fausses, pourtant je trouve le code logique.

Les méthodes qui sont fausses sont:
ajouter(ListeAdt liste)
supprimer(ListeAdt liste)
contientTout(ListeAdt liste)

Et voici ma classe ainsi que l'interface à implémenter et la classe de test JUnit4

Interface:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
package ca.uqam.inf2120.tp1.adt;
 
import java.util.Iterator;
import java.util.Map;
 
/**
 * Université du  Québec à Montréal
 * Travail Pratique 1
 * Cours   : INF2120 - Groupe 20 
 * Session : Automne 2013  
 * 
 * ListeAdt : Interface définissant des services génériques.  
 *    
 * @author Ismael Doukoure
 * @version 01 octobre 2013
 */
public interface ListeAdt<T> {
 
    /**
     * Si l'élément n'est pas null, il n'existe pas dans la liste courante, il est ajouté dans
     * la liste courante et la méthode retourne vrai, sinon elle retourne faux. L'élément doit 
     * être ajouté à la fin dela liste. 
     *   
     * @param element L'élément à ajouter
     * @return true si l'élément n'est pas null, il n'existe pas dans la liste et qu'il est ajouté
     *         sinon false.
     */
    public boolean ajouter(T element);
 
    /**
     * Ajouter tous les éléments de la liste passée en paramètre dans la liste courante et 
     * retourne un tableau des éléments qui n'ont pas été ajouté, car ils existent déjà. Les
     * éléments doivent être ajoutés à la fin de la liste. 
     *   
     * @param liste La liste dont les éléments doivent être ajoutés
     * @return Le tableau des éléments qui n'ont pas été ajoutés, null si tous les éléments
     *         ont été ajoutés ou la liste passée en paramètre est nulle ou vide 
     */
    public T[] ajouter(ListeAdt<T> liste);
 
    /**
     * L'élément passé en paramètre doit être supprimé s'il existe dans la liste courante.
     * 
     * @param element L'élément à supprimer
     * @return true si l'élément est supprimé, sinon faux 
     */
 
     public boolean supprimer(T element);
 
    /**
     * Tous les éléments de la liste passée en paramètre doivent être supprimés dans la liste
     * courante s'ils existent.     
     *  
     * @param liste La liste dont les éléments doivent être supprimés
     * @return Le tableau des éléments qui n'ont pas été supprimés, null si tous les éléments
     *         ont été supprimés ou la liste passée en paramètre est nulle ou vide
     */
     public T[] supprimer(ListeAdt<T> liste);
 
     /**
      * Si la liste courante contient tous les éléments de la liste passée en paramètre, 
      * la méthode retourne vrai, sinon elle retourne faux.       
      *           
      * @param liste  La liste dont l'existence de tous les éléments doit être vérifiée
      * @return true si la liste courante contient tous les éléments de la liste passée
      *         en paramétre, sinon false
      */
     public boolean contientTout(ListeAdt<T> liste);
 
    /**
     * Remplacer un élément par un autre dans la liste courante. L'élément à remplacer doit 
     * exister et le nouveau élément ne doit pas être null. Après le remplacement, La position
     * du nouveau élément doit être la même que celle de l'élément remplacé. 
     * 
     * @param elementARemplacer L'élement de la liste courante à remplacer
     * @param nouveauElement Le nouveau élément à ajouter
     * @return true si le remplacement a été fait, sinon faux.
     */
     public boolean remplacer(T elementARemplacer, T nouveauElement);
 
     /**
      * Retourner les éléments de la liste courante et leurs positions dans un HashMap
      * (HashMap Clé = position de type Integer, HashMap valeur = élément de type T).
      * Les éléments rétournés dovient être entre les positions de début et de fin 
      * inclusivement. La valeur nulle doit être retournée si la position de début est
      * égale à la position de fin.  
      * 
      * @param positionDebut La position de début
      * @param positionDebut La position de fin
      * @return Le HashMap des éléments de la liste courante dans l'intervalle spécifié et leurs positions.
      * @throws PositionException Cette exception sera lancée si la poisiton de début < 0 ou
      *         si la position de début > la position de fin.
      */
      public  Map<Integer, T> elements(int positionDebut, int positionFin) throws PositionException;
 
     /**
      * Si la liste courante contient l'élément passé en paramètre, la methode retourne 
      * vrai, sinon elle retourne faux.
      * 
      * @param element L'élement dont l'existence doit être vérifiée
      * @return true si l'élément existe, sinon faux
      */
      public boolean estElement(T element);
 
      /**
       * Le nombre total des éléments dans la liste courante doit être retourné.
       * 
       * @return Le nombre total des éléments de la liste courante
       */
       public int nbElements();
 
     /**
     * Vérifier si la liste courante est vide.
     * 
     * @return true si la liste courante est vide, sinon false.
     */
     public boolean estVide();
 
    /**
     * Vider la liste courante,.
     */
     public void vider();
 
     /**
      * Retourne un itérateur sur la liste courante.
      *
      * @return Itérateur sur la liste courante.
      */
     public Iterator<T> iterateur();
}

Classe ListeAdtArraylistImpl

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
 
package ca.uqam.inf2120.tp1.adt.impl;
 
import java.util.HashMap;
 
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.HashMap;
import java.util.Set;
 
import ca.uqam.inf2120.tp1.adt.ListeAdt;
import ca.uqam.inf2120.tp1.adt.PositionException;
 
public class ListeAdtArraylistImpl<T> implements ListeAdt<T> {
 
    ArrayList<T> list;
 
    public ListeAdtArraylistImpl() {
        list = new ArrayList<>();
    }
 
    /**
     * Si l'élément n'est pas null, il n'existe pas dans la liste courante, il
     * est ajouté dans la liste courante et la méthode retourne vrai, sinon elle
     * retourne faux. L'élément doit être ajouté à la fin dela liste.
     * 
     * @param element
     *            L'élément à ajouter
     * @return true si l'élément n'est pas null, il n'existe pas dans la liste
     *         et qu'il est ajouté sinon false.
     */
    @Override
    public boolean ajouter(T element) {
        // TODO Auto-generated method stub
        boolean ajouter = true;
        if (element == null || list.contains(element)) {
            ajouter = false;
        } else {
            list.add(element);
        }
 
        return ajouter;
    }
 
    /**
     * Ajouter tous les éléments de la liste passée en paramètre dans la liste
     * courante et retourne un tableau des éléments qui n'ont pas été ajouté,
     * car ils existent déjà. Les éléments doivent être ajoutés à la fin de la
     * liste.
     * 
     * @param liste
     *            La liste dont les éléments doivent être ajoutés
     * @return Le tableau des éléments qui n'ont pas été ajoutés, null si tous
     *         les éléments ont été ajoutés ou la liste passée en paramètre est
     *         nulle ou vide
     */
    @Override
    public T[] ajouter(ListeAdt liste) {
        // TODO Auto-generated method stub
        List<T> tableau = null;
        Iterator<T> iterateur1 = liste.iterateur();
        while (iterateur1.hasNext()) {
            T temp = iterateur1.next();
            if (list.contains(temp)) {
                tableau.add(temp);
 
            } else {
                list.add(temp);
            }
 
        }
        T[] tab = (T[]) tableau.toArray();
        return tab;
 
    }
 
    /**
     * L'élément passé en paramètre doit être supprimé s'il existe dans la liste
     * courante.
     * 
     * @param element
     *            L'élément à supprimer
     * @return true si l'élément est supprimé, sinon faux
     */
    @Override
    public boolean supprimer(T element) {
        // TODO Auto-generated method stub
        boolean supprimer = false;
        if (list.contains(element)) {
            list.remove(element);
            supprimer = true;
        }
        return supprimer;
    }
 
    /**
     * Tous les éléments de la liste passée en paramètre doivent être supprimés
     * dans la liste courante s'ils existent.
     * 
     * @param liste
     *            La liste dont les éléments doivent être supprimés
     * @return Le tableau des éléments qui n'ont pas été supprimés, null si tous
     *         les éléments ont été supprimés ou la liste passée en paramètre
     *         est nulle ou vide
     */
    @Override
    public T[] supprimer(ListeAdt liste) {
        // TODO Auto-generated method stub
        List<T> tableau = null;
        Iterator<T> iterateur1 = liste.iterateur();
        while (iterateur1.hasNext()) {
            T temp = iterateur1.next();
            if (list.contains(temp)) {
                tableau.remove(temp);
 
            } else {
                list.add(temp);
            }
 
        }
        T[] tab = (T[]) tableau.toArray();
        return tab;
    }
 
    /**
     * Si la liste courante contient tous les éléments de la liste passée en
     * paramètre, la méthode retourne vrai, sinon elle retourne faux.
     * 
     * @param liste
     *            La liste dont l'existence de tous les éléments doit être
     *            vérifiée
     * @return true si la liste courante contient tous les éléments de la liste
     *         passée en paramétre, sinon false
     */
    @Override
    public boolean contientTout(ListeAdt liste) {
        // TODO Auto-generated method stub
 
        return list.containsAll((ArrayList<T>) liste);
    }
 
    /**
     * Remplacer un élément par un autre dans la liste courante. L'élément à
     * remplacer doit exister et le nouveau élément ne doit pas être null. Après
     * le remplacement, La position du nouveau élément doit être la même que
     * celle de l'élément remplacé.
     * 
     * @param elementARemplacer
     *            L'élement de la liste courante à remplacer
     * @param nouveauElement
     *            Le nouveau élément à ajouter
     * @return true si le remplacement a été fait, sinon faux.
     */
    @Override
    public boolean remplacer(T elementARemplacer, T nouveauElement) {
        // TODO Auto-generated method stub
        boolean estRemplacer = false;
        int compteur = 0;
        if (nouveauElement != null && list.contains(elementARemplacer)) {
            estRemplacer = true;
            Iterator<T> iterateur1 = list.iterator();
            while (iterateur1.hasNext() && list.contains(elementARemplacer)) {
                compteur++;
            }
        }
        return estRemplacer;
    }
 
    /**
     * Retourner les éléments de la liste courante et leurs positions dans un
     * HashMap (HashMap Clé = position de type Integer, HashMap valeur = élément
     * de type T). Les éléments rétournés dovient être entre les positions de
     * début et de fin inclusivement. La valeur nulle doit être retournée si la
     * position de début est égale à la position de fin.
     * 
     * @param positionDebut
     *            La position de début
     * @param positionDebut
     *            La position de fin
     * @return Le HashMap des éléments de la liste courante dans l'intervalle
     *         spécifié et leurs positions.
     * @throws PositionException
     *             Cette exception sera lancée si la poisiton de début < 0 ou si
     *             la position de début > la position de fin.
     */
    @Override
    public Map elements(int positionDebut, int positionFin)
            throws PositionException {
        //HashMap<Integer, T> hm = new HashMap<Integer, T>();
        Map<Integer, T> hm = new HashMap<Integer, T>();
        if (positionDebut == positionFin) {
            return null;
        }
        if (positionDebut < 0 || positionDebut > positionFin) {
            throw new PositionException();
        }
        for (int i = positionDebut; i < positionFin; ++i) {
            hm.put(i, list.get(i));
        }
        return hm;
    }
 
    /**
     * Si la liste courante contient l'élément passé en paramètre, la methode
     * retourne vrai, sinon elle retourne faux.
     * 
     * @param element
     *            L'élement dont l'existence doit être vérifiée
     * @return true si l'élément existe, sinon faux
     */
    @Override
    public boolean estElement(T element) {
        // TODO Auto-generated method stub
 
        return list.contains(element);
    }
 
    /**
     * Le nombre total des éléments dans la liste courante doit être retourné.
     * 
     * @return Le nombre total des éléments de la liste courante
     */
    @Override
    public int nbElements() {
        // TODO Auto-generated method stub
        return list.size();
    }
 
    /**
     * Vérifier si la liste courante est vide.
     * 
     * @return true si la liste courante est vide, sinon false.
     */
    @Override
    public boolean estVide() {
 
        // TODO Auto-generated method stub
        return list.isEmpty();
    }
 
    /**
     * Vider la liste courante,.
     */
    @Override
    public void vider() {
        // TODO Auto-generated method stub
        list.clear();
 
    }
 
    /**
     * Permet d'initialiser le message
     * 
     * @param message
     *            Message à afficher
     */
    @Override
    public Iterator<T> iterateur() {
        // TODO Auto-generated method stub
        Iterator<T> li = list.iterator();
        while (li.hasNext()) {
            li.next();
        }
        return li;
    }
 
    public void affiche() {
        Iterator it = list.iterator();
        while (it.hasNext()) {
            System.out.println(it.next());
        }
    }
}

Classe de test JUnit4

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
package ca.uqam.inf2120.tp1.adt.test;
 
import static org.junit.Assert.*;
 
import java.util.HashMap;
import java.util.Map;
 
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
 
import ca.uqam.inf2120.tp1.adt.ListeAdt;
import ca.uqam.inf2120.tp1.adt.impl.ListeAdtArraylistImpl;
 
public class ListeAdtArraylistImplTest {
 
    @Test
    public void testAjouter() {
        ListeAdtArraylistImpl<String> liste3 = new ListeAdtArraylistImpl<String>();
        boolean ajouter;
        liste3.ajouter("watashi");
        ajouter = liste3.ajouter("konnichiwa");
        assertTrue(ajouter);
        ajouter = liste3.ajouter("watashi");
        // liste3.affiche();
        System.out.println(ajouter);
        assertFalse(ajouter);
    }
 
    @Test
    public void testAjouterADT() {
        ListeAdt<String> liste7 = new ListeAdtArraylistImpl<String>();
        ListeAdtArraylistImpl<String> liste8 = new ListeAdtArraylistImpl<String>();
        String tableauAjouter[] = new String[1];
        liste7.ajouter("a");
 
        liste8.ajouter("a");
        // liste8.ajouter("b");
        // liste8.ajouter("c");
 
        tableauAjouter = liste8.ajouter(liste7);
 
        // assertEquals("a",tableauAjouter[0]);
        // assertSame("a",tableauAjouter[0]);
        assertEquals(tableauAjouter[0], "a");
        // assertEquals(tableauAjouter[2],"c");
 
    }
 
    @Test
    public void testSupprimer() {
        boolean supprimer;
        ListeAdtArraylistImpl<String> liste5 = new ListeAdtArraylistImpl<String>();
        liste5.ajouter("nihow");
        liste5.ajouter("psychom");
        supprimer = liste5.supprimer("nihow");
        assertTrue(supprimer);
        supprimer = liste5.supprimer("hi");
        assertFalse(supprimer);
    }
 
    @Test
    public void testSupprimerADT() {
        ListeAdt<String> liste7 = new ListeAdtArraylistImpl<String>();
        ListeAdtArraylistImpl<String> liste8 = new ListeAdtArraylistImpl<String>();
        String tableauSupprimer[] = new String[1];
        liste7.ajouter("allo");
        liste7.ajouter("ami");
        liste7.ajouter("annimation");
        liste7.ajouter("arriver");
 
        liste8.supprimer("allo");
        liste8.supprimer("existepas");
 
        tableauSupprimer = liste7.ajouter(liste8);
 
        assertEquals("existepas", tableauSupprimer[0]);
    }
 
    @Test
    public void testContientTout() {
        boolean contientTous;
        ListeAdtArraylistImpl<String> liste9 = new ListeAdtArraylistImpl<String>();
        ListeAdt<String> liste10 = new ListeAdtArraylistImpl<String>();
        liste9.ajouter("ismail");
        liste9.ajouter("ghedamsi");
 
        liste10.ajouter("ismail");
        liste10.ajouter("ghedamsi");
 
        contientTous = liste9.contientTout(liste10);
        assertTrue(contientTous);
 
    }
 
    @Test
    public void testRemplacer() {
        ListeAdtArraylistImpl<String> liste6 = new ListeAdtArraylistImpl<String>();
        liste6.ajouter("nihow");
        liste6.ajouter("psychom");
        boolean remplacer = liste6.remplacer("nihow", "kawaii");
        assertTrue(remplacer);
    }
 
    @Test
    public void testEstElement() {
        boolean estElement;
        ListeAdtArraylistImpl<String> liste11 = new               ListeAdtArraylistImpl();
        liste11.ajouter("uqam");
        estElement = liste11.estElement("uqam");
        assertTrue(estElement);
        estElement = liste11.estElement("moi");
        assertFalse(estElement);
    }
 
    @Test
    public void testNbElement() {
        ListeAdtArraylistImpl<String> liste1 = new ListeAdtArraylistImpl<String>();
 
        liste1.ajouter("Bienvenue");
        liste1.ajouter("hello");
        liste1.ajouter("gakusei");
        int nbElement = liste1.nbElements();
        assertEquals(nbElement, 3);
    }
 
    @Test
    public void testEstVide() {
        ListeAdtArraylistImpl<String> liste2 = new ListeAdtArraylistImpl<String>();
        liste2.ajouter("revolution");
        liste2.ajouter("neogaf");
 
        boolean bool = liste2.estVide();
        assertFalse(bool);
    }
 
    @Test
    public void testVider() {
        ListeAdtArraylistImpl<String> liste4 = new ListeAdtArraylistImpl<String>();
        liste4.ajouter("i");
        liste4.ajouter("am");
        liste4.ajouter("the");
        liste4.ajouter("that");
        liste4.vider();
        boolean estVide = liste4.estVide();
        assertTrue(estVide);
    }
}

Est-ce que ce sont mes méthodes ou bien mes tests qui sont faux ?

Merci d'avance pour votre aide.