Discussion :

[AttilaMarkus]

Bonjour,

Occupé à faire des test unitaires sur mon code, je rencontre un soucis avec celui-ci:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
@Test
    public void testGetCas1(){
         Stock stock = new Stock(new Tile(3),new Tile(-2),new Tile(1),new Tile(-4));
         Tile expected=new Tile(3);
         Tile answer=stock.get(TileType.SUSHI, 0);
         assertEquals(expected, answer);
    }

Mon test vérifie la méthode suivante:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 /**
     * The method show the tile number <b>pos</b>(since position 0) of Tiletype
     * get at parameter.
     *
     * @param type the tiletype(sushi or fishbone)
     * @param pos the position in the list(sushiList or fishboneList)
     * @return the tile corresponding of parameters
     */
    public Tile get(TileType type, int pos) {
        Tile domino;
        if (type.equals(TileType.SUSHI)) {
            domino = sushiList.get(pos);
        } else {
            domino = fishboneList.get(pos);
        }
        return domino;
    }

Mon test me renvoi comme erreur:

expected: g42015.sushibar.model.Tile<Valeur du domino: 3> but was: g42015.sushibar.model.Tile<Valeur du domino: 3>

junit.framework.AssertionFailedError
at g42015.sushibar.model.StockTest.testGetCas1(StockTest.java:57)

Il semble donc y avoir une erreur dans mon assertEquals. J'ai l'impression d'avoir mal rédigé mon Tile expected, mais je n'en suis pas certain.

Est-ce que quelqu'un peut m'aider?

merci

[adiGuba]

Salut,


Il faudrait voir le code de la méthode equals() de ta classe Tile...


a++

[AttilaMarkus]

Bonjour,

Voici mon code equals:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
@Override
    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }
        if (obj == null) {
            return false;
        }
        if (getClass() != obj.getClass()) {
            return false;
        }
        final Tile other = (Tile) obj;
        if (this.value != other.value) {
            return false;
        }
        return true;
    }

[joel.drigo]

Salut,

Donne le code complet de la classe Tile (au moins son contructeur et sa méthode toString())... Et celui du constructeur de Stock...

[AttilaMarkus]

Salut,

Voici ma classe Tile:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
public class Tile {
    //=========================================================================
    //ATTRIBUT   
 
    /**
     * A integer value represent the tile.
     */
    private int value;
 
    //=========================================================================
    //CONSTRUCTOR
    /**
     * The method instancie a object of type Tile. Each tile get a value
     *
     * @param value
     */
    public Tile(int value) {
        this.value = value;
    }
 
    //======================================================================
    //METHODS
 
    /**
     * The method indicate the TileType of a tile: Sushi or Fishbone. 
     * Sushi, if the value is negative.
     * Fishbone, if the value is positive.
     * @return the tileType of the tile
     */
    public TileType getType(){
        TileType type;
        if(value>=1){
            type=TileType.SUSHI;
        }else if(value<0)
            type=TileType.FISHBONE;
        else
            throw new IllegalArgumentException("Erreur de valeur: "+value);
        return type;
    }
 
 
    /**
     * The method get the value of the tile.
     * @return a integer number
     */
    public int getValue() {
        return value;
    }
 
    /**
     * The method display the value of the tile.
     * @return a string with the value
     */
    @Override
    public String toString() {
        return " "+value;
    }
 
    @Override
    public int hashCode() {
        int hash = 5;
        hash = 23 * hash + this.value;
        return hash;
    }
 
    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
 
        if (obj == null) return false;
 
        if (getClass() != obj.getClass()) {
            return false;
        }
        final Tile other = (Tile) obj;
        if (this.value != other.value) {
            return false;
        }
        return true;
    }
 
}

Voici ma classe Stock:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
public class Stock {
//=========================================================================
    //ATTRIBUTS
 
    /**
     * The class have two attributs, two lists wich represents two range of
     * tiles to win.
     * <b>sushiList</b> the range of sushi tiles
     * <b>fishbone</b> the range of fishbone tiles
     */
    private List<Tile> sushiList;
    private List<Tile> fishboneList;
 
    //=========================================================================
    //CONSTRUCTOR
    /**
     * The constructor receive several parameters and classify the tiles into
     * two lists.
     *
     * @param tile
     */
    public Stock(Tile... tile) {
        this.sushiList = new ArrayList<>();
        this.fishboneList = new ArrayList<>();
        for (int i = 0; i < tile.length; i++) {
            if (tile[i].getValue() > 0) {
                this.sushiList.add(tile[i]);
            } else {
                this.fishboneList.add(tile[i]);
            }
        }
 
    }

Merci!

[tchize_]

Je n'arrive pas à reporduire le problème avec le code que tu donne.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
public class Main{
 
     public static void main(String []args){
         Stock stock = new Stock(new Tile(3),new Tile(-2),new Tile(1),new Tile(-4));
         Tile expected=new Tile(3);
         Tile answer=stock.get(TileType.SUSHI, 0);
         System.out.println("equals? "+expected.equals(answer));
     }
}

ça me renvoie bien "true"

[AttilaMarkus]

Bonjour Tchize,

Oui, cette erreur m'étonne car dans le message d'erreur, l'expected et l'answer sont identique.

Merci quand même pour la confirmation.

[tchize_]

C'est surtout que ton message d'erreur n'a rien à voir avec ton code.

g42015.sushibar.model.Tile<Valeur du domino: 3>

Le toString de ton code n'affiche pas le texte "Valeur du domino" et ce texte n'est nulle part dans ton code

Tu es sûr de travailler avec les bonne classes?

[AttilaMarkus]

Bonjour,

Pour les classes, je pense que oui. Etrangement, cette erreur ne s'affiche plus, mon test passe correctement. Cela semble résolu.

Par contre j'ai une autre question, si cela ne vous dérange pas? (je ne sais pas si je peux continuer dans cette discussion ou si je dois clôturer cette discussion et en ouvrir une autre?)

J'ai une méthode roll(), qui me permet de faire rouler un dé. Son entête est public void roll(){}.
Je ne sais pas comment tester cette méthode. Quand je créée une méthode main (public static void main ()), un message d'erreur me dit que je ne peux pas tester une méthode de type void ici (sous-entendu dans un static). Comment est ce que je peux tester une méthode void dans un main (j'ai le même problème avec d'autres méthode void)?


Merci

[tchize_]

On teste toujours une méthode en testant son comportement. Souvent le comportement c'est la valeur de retour, mais pas toujours. Cette méthode roll est censée faire quoi en pratique? Qu'est-ce qui doit être changé dans ton programme quand elle a fini de s'exécuter.

[AttilaMarkus]

Dans ma classe Dice, roll() est une méthode qui lance un dé. Mais on ne demande pas de valeur de retour. Je mets le code de la classe ci-dessous, ainsi que mon test dans main localisé dans la classe. Dice possède un attribut value qui est soit SUSHI, FISHBONE, RED_CHOPSTICK, BLUE_CHOPSTICK. Je peux récupérer la valeur du dé par getValue().

Une autre classe, DiceBucket, possède également une méthode roll() (également void), qui lance 5 dés.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
public class Dice {
 
    /**
     * Value display of dice. This value can not be change by the user.
     *
     * @see getValue
     */
    private DiceValue value;
 
    /**
     * The constructor initialize the dice with a value(these value is a
     * choice). The value is initialized with Sushi.
     */
    public Dice() {
        this.value =DiceValue.SUSHI;
    }
 
    /**
     * This method give the value of dice.
     *
     * @return the value display of dice
     */
    public DiceValue getValue() {
        return value;
    }
 
    /**
     * This method throw a dice.
     */
    public void roll() {
        this.convert(this.diceGet());
    }
 
    /**
     * This method display a string.
     *
     * @return a display of the value
     */
    @Override
    public String toString() {
        return "" + getValue();
    }
//=============================================================================
    //Mes méthodes privées
 
    //Cette méthode lance un dé à 6 faces et retourne un entier
    private int diceGet() {
 
        return 1+ (int) (Math.random()*(6-1+1));
 
    }
 
    /*Cette méthode reçoit un entier et la convertie une valeur DiceValue 
      *corresponante.
     */
    private DiceValue convert(int nb) {
        DiceValue displayVal = DiceValue.SUSHI;
 
        switch (nb) {
            case 1:
            case 2:
                displayVal = DiceValue.SUSHI;
                break;
            case 3:
            case 4:
                displayVal = DiceValue.FISHBONE;
                break;
            case 5:
                displayVal = DiceValue.BLUE_CHOPSTICK;
                break;
            case 6:
                displayVal = DiceValue.RED_CHOPSTICK;
                break;
            default:
                System.out.println("ERROR");
        }
        return displayVal;
    }
 
//==============================================================================    
//Cette partie est privée et sert à tester les méthodes privées
    public static void main(String[] args) {
        Dice dé = new Dice();
        for (int i = 0; i < 50; i++) {
            System.out.println(dé.convert(dé.diceGet()));
        }
       // System.out.println(dé.roll());
 
    }
}

Voici le code de DiceBucket:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
public class DiceBucket {
//=========================================================================
    //ATTRIBUTS
 
    /**
     * actives is the list of dices that can be throw. asides is the list of
     * dices that cannot throw any more.
     */
    private final List<Dice> actives;
    private final List<Dice> asides;
//=========================================================================
    //CONSTRUCTOR
 
    /**
     * The constructor generates five dice and puts them in the list
     * <b>actives</b>
     */
    public DiceBucket() {
        this.actives = new ArrayList<>();
        for (int i = 0; i < 5; i++) {
            this.actives.add(i, new Dice());
 
        }
        this.asides = new ArrayList<>();
    }
//============================================================================
    //METHODS
 
    /**
     * The method throw the actives dice.
     */
    public void roll() {
        for (Dice dice : actives) {
            dice.roll();
        }
    }
 
    /**
     * The method move a dice from actives list to asides list.
     *
     * @param pos the position of the dice
     */
    public void putAsides(int pos) {
        asides.add(actives.get(pos));
        actives.remove(pos);
    }
 
    /**
     * The method take back the dice from asides list and puts them in the
     * actives list. The value remains unch
     */
    public void takeBackAll() {
        actives.addAll(asides);
        asides.removeAll(asides);    
    }
 
    /**
     * The method count in each list (actives and asides), how many dice have a
     * same value.
     *
     * @param value the value researched
     * @return the number of dice
     */
    public int getNb(DiceValue value) {
        int cptA = 0;
        int cptB = 0;
        for (Dice active : actives) {
            if (active.getValue() == value) {
                cptA += 1;
            }
        }
        for (Dice aside : asides) {
            if (aside.getValue() == value) {
                cptB += 1;
            }
        }
        return cptA + cptB;
    }
 
    /**
     * The method gives the active dice.
     *
     * @return a list of active dice
     */
    public List<Dice> getActives() {
        return actives;
    }
 
    /**
     * The method give the dice that are placed aside.
     *
     * @return a list of set aside dice
     */
    public List<Dice> getAsides() {
        return asides;
    }
 
    /**
     * The methode toString show the state of all th dice.
     *
     * @return a String list of different value of dice
     */
    @Override
    public String toString() {
 
        return "Les valeurs de mes 5 dés sont: " + getActives() + getAsides();
 
    }

[tchize_]

Je peux récupérer la valeur du dé par getValue()

Donc tu as besoin de tester que getValue() renvoie non null après un appel à roll()

Après, si tu veux tester que toutes les valeurs sont possibles, c'est plus compliqué, il faut mocker Math.random() pour qu'il retourne une série de valeurs uniformes non aléatoire et montrer qu'on passe bien par toutes les valeurs possible de jet.

D'une manière général, tester l'aléatoire en unit test, c'est complexe

[AttilaMarkus]

Un très grand merci, je vais tester tout de suite!

Pour le test aléatoire, j'ai réussi à tester cela dans une méthode principale:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
public static void main(String[] args) {
        Dice dé = new Dice();
        for (int i = 0; i < 50; i++) {
            System.out.println(dé.convert(dé.diceGet()));
        }
    }

Je crois que cela fonctionne bien.
Merci parce que j'ai appris deux ou trois truc.