Skip to content
This repository was archived by the owner on Jul 2, 2026. It is now read-only.

Commit dc70cd3

Browse files
MaelanP77MaelanP77
committed
Exercice 2 terminé
1 parent e4274d3 commit dc70cd3

3 files changed

Lines changed: 236 additions & 67 deletions

File tree

‎src/main/java/fr/univ_amu/iut/exercice2/JeuDeTennis.java‎

Lines changed: 32 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -2,9 +2,9 @@
22

33
/// Kata 2 - Jeu de tennis.
44
///
5-
/// Classe d'état qui gère le scoring d'un jeu de tennis entre deux joueurs. Pratique idéale pour
6-
/// découvrir comment structurer une **machine à états** et comment un test bien nommé devient une
7-
/// spécification lisible.
5+
/// Classe d'état qui gère le scoring d'un jeu de tennis entre deux joueurs.
6+
/// Pratique idéale pour découvrir comment structurer une **machine à états** et
7+
/// comment un test bien nommé devient une spécification lisible.
88
public class JeuDeTennis {
99

1010
private final String joueur1;
@@ -19,17 +19,38 @@ public JeuDeTennis(String joueur1, String joueur2) {
1919

2020
/// Enregistre un point pour le joueur dont le nom est passé en argument.
2121
public void marquerPoint(String joueur) {
22-
// TODO kata 2 : incrémenter le compteur du joueur qui vient de marquer.
22+
if (joueur.equals(this.joueur1)) {
23+
++points1;
24+
} else {
25+
++points2;
26+
}
2327
}
2428

2529
/// Retourne la représentation textuelle du score courant.
2630
public String getScore() {
27-
// TODO kata 2 : construire la chaîne du score en gérant les cas :
28-
// - <4 points chacun et pas d'égalité à 40 : "X-Y" (ex "15-30")
29-
// - égalité >=3 : "Égalité"
30-
// - après Égalité, un joueur mène d'un point : "Avantage <nom>"
31-
// - un joueur a 4 points et 2 d'avance : "Jeu pour <nom>"
32-
String score = "0-0";
33-
return score;
31+
if (points1 == points2 && points1 >= 3) {
32+
return "Égalité";
33+
}
34+
if (points1 >= 4 || points2 >= 4) {
35+
int ecart = points1 - points2;
36+
if (ecart == 1) return "Avantage " + joueur1;
37+
if (ecart == -1) return "Avantage " + joueur2;
38+
if (ecart >= 2) return "Jeu pour " + joueur1;
39+
if (ecart <= -2) return "Jeu pour " + joueur2;
40+
}
41+
return scorePour(points1) + "-" + scorePour(points2);
42+
}
43+
44+
private static String scorePour(int points) {
45+
switch (points) {
46+
case 0:
47+
return "0";
48+
case 1:
49+
return "15";
50+
case 2:
51+
return "30";
52+
default:
53+
return "40";
54+
}
3455
}
3556
}

‎src/test/java/fr/univ_amu/iut/exercice2/JeuDeTennis.java‎

Lines changed: 0 additions & 56 deletions
This file was deleted.

‎src/test/java/fr/univ_amu/iut/exercice2/JeuDeTennisTest.java‎

Lines changed: 204 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,204 @@
1+
package fr.univ_amu.iut.exercice2;
2+
3+
import static org.assertj.core.api.Assertions.assertThat;
4+
5+
import org.junit.jupiter.api.BeforeEach;
6+
import org.junit.jupiter.api.Test;
7+
8+
/**
9+
* Kata 2 - Tennis scoring.
10+
*
11+
* <p>Progression TDD conçue pour du pair programming ping-pong : chaque test ajoute exactement un
12+
* petit élément à l'implémentation. Résistez à la tentation d'écrire la machine à états complète
13+
* dès le premier "0-0".
14+
*
15+
* <ul>
16+
* <li>Tests 1 à 6 : les comptages simples avant qu'un joueur atteigne 3 points
17+
* <li>Tests 7 à 11 : les libellés "15", "30", "40" pour le premier et le second joueur
18+
* <li>Tests 12 à 14 : la gestion des égalités puis Deuce
19+
* <li>Tests 15 à 18 : Advantage (aller / retour à Deuce)
20+
* <li>Tests 19 à 22 : Win (plusieurs scénarios)
21+
* </ul>
22+
*/
23+
class JeuDeTennisTest {
24+
25+
private JeuDeTennis jeu;
26+
27+
@BeforeEach
28+
void setUp() {
29+
jeu = new JeuDeTennis("Alice", "Bob");
30+
}
31+
32+
// ========= Score initial =========
33+
34+
@Test
35+
void le_score_initial_est_0_0() {
36+
assertThat(jeu.getScore()).isEqualTo("0-0");
37+
}
38+
39+
// ========= Points simples d'Alice =========
40+
41+
@Test
42+
void apres_un_point_d_alice_le_score_est_15_0() {
43+
jeu.marquerPoint("Alice");
44+
assertThat(jeu.getScore()).isEqualTo("15-0");
45+
}
46+
47+
@Test
48+
void apres_deux_points_d_alice_le_score_est_30_0() {
49+
jeu.marquerPoint("Alice");
50+
jeu.marquerPoint("Alice");
51+
assertThat(jeu.getScore()).isEqualTo("30-0");
52+
}
53+
54+
@Test
55+
void apres_trois_points_d_alice_le_score_est_40_0() {
56+
for (int i = 0; i < 3; i++) jeu.marquerPoint("Alice");
57+
assertThat(jeu.getScore()).isEqualTo("40-0");
58+
}
59+
60+
// ========= Points simples de Bob =========
61+
62+
@Test
63+
void apres_un_point_de_bob_le_score_est_0_15() {
64+
jeu.marquerPoint("Bob");
65+
assertThat(jeu.getScore()).isEqualTo("0-15");
66+
}
67+
68+
@Test
69+
void apres_deux_points_de_bob_le_score_est_0_30() {
70+
jeu.marquerPoint("Bob");
71+
jeu.marquerPoint("Bob");
72+
assertThat(jeu.getScore()).isEqualTo("0-30");
73+
}
74+
75+
@Test
76+
void apres_trois_points_de_bob_le_score_est_0_40() {
77+
for (int i = 0; i < 3; i++) jeu.marquerPoint("Bob");
78+
assertThat(jeu.getScore()).isEqualTo("0-40");
79+
}
80+
81+
// ========= Mélanges, pour exercer la matrice =========
82+
83+
@Test
84+
void apres_un_point_chacun_le_score_est_15_15() {
85+
jeu.marquerPoint("Alice");
86+
jeu.marquerPoint("Bob");
87+
assertThat(jeu.getScore()).isEqualTo("15-15");
88+
}
89+
90+
@Test
91+
void apres_deux_points_d_alice_et_un_point_de_bob_le_score_est_30_15() {
92+
jeu.marquerPoint("Alice");
93+
jeu.marquerPoint("Alice");
94+
jeu.marquerPoint("Bob");
95+
assertThat(jeu.getScore()).isEqualTo("30-15");
96+
}
97+
98+
@Test
99+
void apres_trois_points_d_alice_et_un_point_de_bob_le_score_est_40_15() {
100+
for (int i = 0; i < 3; i++) jeu.marquerPoint("Alice");
101+
jeu.marquerPoint("Bob");
102+
assertThat(jeu.getScore()).isEqualTo("40-15");
103+
}
104+
105+
@Test
106+
void apres_trois_points_d_alice_et_deux_points_de_bob_le_score_est_40_30() {
107+
for (int i = 0; i < 3; i++) jeu.marquerPoint("Alice");
108+
for (int i = 0; i < 2; i++) jeu.marquerPoint("Bob");
109+
assertThat(jeu.getScore()).isEqualTo("40-30");
110+
}
111+
112+
@Test
113+
void apres_deux_points_chacun_le_score_est_30_30() {
114+
for (int i = 0; i < 2; i++) jeu.marquerPoint("Alice");
115+
for (int i = 0; i < 2; i++) jeu.marquerPoint("Bob");
116+
assertThat(jeu.getScore()).isEqualTo("30-30");
117+
}
118+
119+
// ========= Deuce =========
120+
121+
@Test
122+
void apres_trois_points_chacun_le_score_est_egalite() {
123+
for (int i = 0; i < 3; i++) {
124+
jeu.marquerPoint("Alice");
125+
jeu.marquerPoint("Bob");
126+
}
127+
assertThat(jeu.getScore()).isEqualTo("Égalité");
128+
}
129+
130+
// ========= Advantage =========
131+
132+
@Test
133+
void apres_egalite_et_un_point_d_alice_le_score_est_avantage_alice() {
134+
for (int i = 0; i < 3; i++) {
135+
jeu.marquerPoint("Alice");
136+
jeu.marquerPoint("Bob");
137+
}
138+
jeu.marquerPoint("Alice");
139+
assertThat(jeu.getScore()).isEqualTo("Avantage Alice");
140+
}
141+
142+
@Test
143+
void apres_egalite_et_un_point_de_bob_le_score_est_avantage_bob() {
144+
for (int i = 0; i < 3; i++) {
145+
jeu.marquerPoint("Alice");
146+
jeu.marquerPoint("Bob");
147+
}
148+
jeu.marquerPoint("Bob");
149+
assertThat(jeu.getScore()).isEqualTo("Avantage Bob");
150+
}
151+
152+
@Test
153+
void apres_avantage_alice_et_un_point_de_bob_le_score_revient_a_egalite() {
154+
for (int i = 0; i < 3; i++) {
155+
jeu.marquerPoint("Alice");
156+
jeu.marquerPoint("Bob");
157+
}
158+
jeu.marquerPoint("Alice");
159+
jeu.marquerPoint("Bob");
160+
assertThat(jeu.getScore()).isEqualTo("Égalité");
161+
}
162+
163+
// ========= Win =========
164+
165+
@Test
166+
void apres_avantage_alice_et_un_point_d_alice_alice_a_gagne() {
167+
for (int i = 0; i < 3; i++) {
168+
jeu.marquerPoint("Alice");
169+
jeu.marquerPoint("Bob");
170+
}
171+
jeu.marquerPoint("Alice");
172+
jeu.marquerPoint("Alice");
173+
assertThat(jeu.getScore()).isEqualTo("Jeu pour Alice");
174+
}
175+
176+
@Test
177+
void apres_quatre_points_d_alice_alice_a_gagne() {
178+
for (int i = 0; i < 4; i++) jeu.marquerPoint("Alice");
179+
assertThat(jeu.getScore()).isEqualTo("Jeu pour Alice");
180+
}
181+
182+
@Test
183+
void apres_quatre_points_de_bob_bob_a_gagne() {
184+
for (int i = 0; i < 4; i++) jeu.marquerPoint("Bob");
185+
assertThat(jeu.getScore()).isEqualTo("Jeu pour Bob");
186+
}
187+
188+
@Test
189+
void apres_quatre_points_d_alice_et_un_point_de_bob_alice_a_gagne() {
190+
for (int i = 0; i < 4; i++) {
191+
jeu.marquerPoint("Alice");
192+
if (i == 1) jeu.marquerPoint("Bob");
193+
}
194+
assertThat(jeu.getScore()).isEqualTo("Jeu pour Alice");
195+
}
196+
197+
@Test
198+
void apres_quatre_points_d_alice_et_deux_points_de_bob_alice_a_gagne() {
199+
for (int i = 0; i < 4; i++) jeu.marquerPoint("Alice");
200+
jeu.marquerPoint("Bob");
201+
jeu.marquerPoint("Bob");
202+
assertThat(jeu.getScore()).isEqualTo("Jeu pour Alice");
203+
}
204+
}

0 commit comments

Comments
 (0)