Les événements sont bien appelés dans la class Partie

Sources/UnitTesting/PartieUT.cs

@@ -7,5 +7,162 @@ namespace UnitTesting
 {
     public class PartieUT
     {
+        [Fact]
+        public void TestPartieInitialiseCorrectement()
+        {
+            
+            IRegles regles = new ReglesClassiques();
+            Partie partie = new Partie(regles);
+
+            Assert.NotNull(partie);
+        }
+
+        [Fact]
+        public void TestJouerAppelleDemanderJoueurEvent()
+        {
+            IRegles regles = new ReglesClassiques();
+            Partie partie = new Partie(regles);
+            bool eventAppelle = false;
+
+
+            partie.DemanderJoueur += (sender, e) =>
+            {
+                eventAppelle = true;
+                return $"Joueur {e.Numero}";
+            };
+
+            partie.Jouer();
+            Assert.True(eventAppelle);
+        }
+
+
+        [Fact]
+        public void TestJouerAppelleDemanderJetonEvent()
+        {
+            IRegles regles = new ReglesClassiques();
+            Partie partie = new Partie(regles);
+            bool eventAppelle = false;
+
+            partie.DemanderJeton += (sender, e) =>
+            {
+                eventAppelle = true;
+                return new Jeton();
+            };
+              
+            partie.Jouer();
+            Assert.True(eventAppelle);
+        }
+
+        [Fact]
+        public void TestJouerAppelleAjouterJoueurEvent()
+        {
+            IRegles regles = new ReglesClassiques();
+            Partie partie = new Partie(regles);
+            bool eventAppelle = false;
+
+            partie.AjouterJoueur += (sender, e) =>
+            {
+                eventAppelle = true;
+               
+            };
+            partie.Jouer();
+            Assert.True(eventAppelle);
+
+        }
+
+        [Fact]
+        public void TestJouerAppelleDebutPartieEvent()
+        {
+            IRegles regles = new ReglesClassiques();
+            Partie partie = new Partie(regles);
+            bool eventAppelle = false;
+
+            partie.DebutPartie += (sender, e) =>
+            {
+                eventAppelle = true;
+            };
+            partie.Jouer();
+            Assert.True(eventAppelle);
+        }
+
+        [Fact]
+        public void TestJouerAppelleNouveauTourEvent()
+        {
+            IRegles regles = new ReglesClassiques();
+            Partie partie = new Partie(regles);
+            bool eventAppelle = false;
+
+            partie.NouveauTour += (sender, e) =>
+            {
+                eventAppelle = true;
+            };
+
+            partie.Jouer();
+            Assert.True(eventAppelle);
+        }
+
+        [Fact]
+        public void TestJouerAppelleNouveauJetonEvent()
+        {
+            IRegles regles = new ReglesClassiques();
+            Partie partie = new Partie(regles);
+            bool eventAppelle = false;
+
+            partie.AjouterJeton += (sender, e) =>
+            {
+                eventAppelle = true;
+            };
+
+            partie.Jouer();
+            Assert.True(eventAppelle);
+        }
+      
+        [Fact]
+        public void TestJouerAppelleNouveauCodeEvent()
+        {
+            IRegles regles = new ReglesClassiques();
+            Partie partie = new Partie(regles);
+            bool eventAppelle = false;
+
+            partie.AjouterCode += (sender, e) =>
+            {
+                eventAppelle = true;
+            };
+
+            partie.Jouer();
+            Assert.True(eventAppelle);
+        }
+
+        [Fact]
+        public void TestJouerAppellePasserMainEvent()
+        {
+            IRegles regles = new ReglesClassiques();
+            Partie partie = new Partie(regles);
+            bool eventAppelle = false;
+
+            partie.PasserMain += (sender, e) =>
+            {
+                eventAppelle = true;
+            };
+
+            partie.Jouer();
+            Assert.True(eventAppelle);
+        }
+
+        [Fact]
+        public void TestJouerAppellePartieTermineeEvent()
+        {
+            IRegles regles = new ReglesClassiques();
+            Partie partie = new Partie(regles);
+            bool eventAppelle = false;
+
+            partie.PartieTerminee += (sender, e) =>
+            {
+                eventAppelle = true;
+            };
+
+            partie.Jouer();
+            Assert.True(eventAppelle);
+        }
     }
 }

Sources/UnitTesting/PlateauUT.cs

@@ -1,231 +1,231 @@
-using CoreLibrary;
-using CoreLibrary.Exceptions;
-using System.Reflection;
-using Xunit;
-
-namespace UnitTesting
-{
-    public class PlateauUT
-    {
-        [Fact]
-        public void TestConstructeurValide()
-        {
-            Plateau plateau = new Plateau(4,12);
-            Assert.NotNull(plateau);
-            Assert.Equal(1, plateau.Tour);
-            Assert.False(plateau.Victoire);
-        }
-
-        [Fact]
-        public void TestConstructeurInvalide()
-        {
-            Assert.Throws<TailleCodeException>(() => new Plateau(0, 10));
-            Assert.Throws<TailleGrilleException>(() => new Plateau(3, 0));
-        }
-
-        [Fact]
-        public void TestEstCompletTrue()
-        {
-            Plateau plateau = new Plateau(4, 3);
-            Code code = new Code([new Jeton(Couleur.ROUGE), new Jeton(Couleur.BLEU), new Jeton(Couleur.BLANC), new Jeton(Couleur.JAUNE)]);
-            plateau.AjouterCode(code);
-            plateau.AjouterCode(code);
-            plateau.AjouterCode(code);
-
-            bool estComplet = plateau.EstComplet();
-
-            Assert.True(estComplet);
-        }
-
-        [Fact]
-        public void TestEstCompletFalse()
-        {
-            Plateau plateau = new Plateau(4, 3);
-            Code code = new Code([new Jeton(Couleur.ROUGE), new Jeton(Couleur.BLEU), new Jeton(Couleur.BLANC), new Jeton(Couleur.JAUNE)]);
-            plateau.AjouterCode(code);
-            plateau.AjouterCode(code);
-
-            bool estComplet = plateau.EstComplet();
-
-            Assert.False(estComplet);
-        }
-
-        [Fact]
-        public void TestAjouterCodeValide()
-        {
-            Plateau plateau = new Plateau(4, 10);
-            Code code = new Code([new Jeton(Couleur.BLEU), new Jeton(Couleur.BLANC), new Jeton(Couleur.JAUNE), new Jeton(Couleur.BLANC)]);
-
-            plateau.AjouterCode(code);
-
-            Assert.Equal(2, plateau.Tour);
-        }
-
-        [Fact]
-        public void TestAjouterCodeTailleIncorrecte()
-        {
-            Plateau plateau = new Plateau(4, 10);
-            Code code = new Code([new Jeton(Couleur.BLEU), new Jeton(Couleur.BLANC), new Jeton(Couleur.JAUNE), new Jeton(Couleur.BLANC), new Jeton(Couleur.JAUNE)]); 
-            
-            Assert.Throws<CodeInvalideException>(() => plateau.AjouterCode(code));
-        }
-
-        [Fact]
-        public void TestAjouterCodeIncomplet()
-        {
-            Plateau plateau = new Plateau(4, 10);
-            Code code = new Code(4);
-
-            Assert.Throws<CodeIncompletException>(() => plateau.AjouterCode(code));
-        }
-
-        [Fact]
-        public void TestAjouterCodeBonCode()
-        {
-            Plateau plateau = new Plateau(4, 10);
-
-            Type type = typeof(Plateau);
-
-            FieldInfo? fieldInfo = type.GetField("codeSecret", BindingFlags.NonPublic | BindingFlags.Instance);
-            Assert.NotNull(fieldInfo);
-
-            Code? codeSecret = (Code?)fieldInfo.GetValue(plateau);
-
-            Assert.NotNull(codeSecret);
-            plateau.AjouterCode(codeSecret);
-            Assert.True(plateau.Victoire);
-        }
-
-        [Fact]
-        public void TestEstBonCodeTailleException()
-        {
+using CoreLibrary;
+using CoreLibrary.Exceptions;
+using System.Reflection;
+using Xunit;
+
+namespace UnitTesting
+{
+    public class PlateauUT
+    {
+        [Fact]
+        public void TestConstructeurValide()
+        {
+            Plateau plateau = new Plateau(4,12);
+            Assert.NotNull(plateau);
+            Assert.Equal(1, plateau.Tour);
+            Assert.False(plateau.Victoire);
+        }
+
+        [Fact]
+        public void TestConstructeurInvalide()
+        {
+            Assert.Throws<TailleCodeException>(() => new Plateau(0, 10));
+            Assert.Throws<TailleGrilleException>(() => new Plateau(3, 0));
+        }
+
+        [Fact]
+        public void TestEstCompletTrue()
+        {
+            Plateau plateau = new Plateau(4, 3);
+            Code code = new Code([new Jeton(Couleur.ROUGE), new Jeton(Couleur.BLEU), new Jeton(Couleur.BLANC), new Jeton(Couleur.JAUNE)]);
+            plateau.AjouterCode(code);
+            plateau.AjouterCode(code);
+            plateau.AjouterCode(code);
+
+            bool estComplet = plateau.EstComplet();
+
+            Assert.True(estComplet);
+        }
+
+        [Fact]
+        public void TestEstCompletFalse()
+        {
+            Plateau plateau = new Plateau(4, 3);
+            Code code = new Code([new Jeton(Couleur.ROUGE), new Jeton(Couleur.BLEU), new Jeton(Couleur.BLANC), new Jeton(Couleur.JAUNE)]);
+            plateau.AjouterCode(code);
+            plateau.AjouterCode(code);
+
+            bool estComplet = plateau.EstComplet();
+
+            Assert.False(estComplet);
+        }
+
+        [Fact]
+        public void TestAjouterCodeValide()
+        {
+            Plateau plateau = new Plateau(4, 10);
+            Code code = new Code([new Jeton(Couleur.BLEU), new Jeton(Couleur.BLANC), new Jeton(Couleur.JAUNE), new Jeton(Couleur.BLANC)]);
+
+            plateau.AjouterCode(code);
+
+            Assert.Equal(2, plateau.Tour);
+        }
+
+        [Fact]
+        public void TestAjouterCodeTailleIncorrecte()
+        {
+            Plateau plateau = new Plateau(4, 10);
+            Code code = new Code([new Jeton(Couleur.BLEU), new Jeton(Couleur.BLANC), new Jeton(Couleur.JAUNE), new Jeton(Couleur.BLANC), new Jeton(Couleur.JAUNE)]); 
+            
+            Assert.Throws<CodeInvalideException>(() => plateau.AjouterCode(code));
+        }
+
+        [Fact]
+        public void TestAjouterCodeIncomplet()
+        {
+            Plateau plateau = new Plateau(4, 10);
+            Code code = new Code(4);
+
+            Assert.Throws<CodeIncompletException>(() => plateau.AjouterCode(code));
+        }
+
+        [Fact]
+        public void TestAjouterCodeBonCode()
+        {
+            Plateau plateau = new Plateau(4, 10);
+
+            Type type = typeof(Plateau);
+
+            FieldInfo? fieldInfo = type.GetField("codeSecret", BindingFlags.NonPublic | BindingFlags.Instance);
+            Assert.NotNull(fieldInfo);
+
+            Code? codeSecret = (Code?)fieldInfo.GetValue(plateau);
+
+            Assert.NotNull(codeSecret);
+            plateau.AjouterCode(codeSecret);
+            Assert.True(plateau.Victoire);
+        }
+
+        [Fact]
+        public void TestEstBonCodeTailleException()
+        {
             Plateau plateau = new Plateau(3, 5);
             Code code = new Code(4);
 
             Assert.Throws<CodeInvalideException>(() => plateau.EstBonCode(code));
-        }
-
-        [Fact]
-        public void TestEstBonCodeIncomplet()
-        {
+        }
+
+        [Fact]
+        public void TestEstBonCodeIncomplet()
+        {
             Plateau plateau = new Plateau(3, 5);
             Code code = new Code(3);
 
             Assert.Throws<CodeIncompletException>(() => plateau.EstBonCode(code));
-        }
-
-        [Fact]
-        public void TestEstBonCodeTrue()
-        {
-            Plateau plateau = new Plateau(4, 10);
-
-            Type type = typeof(Plateau);
-
-            FieldInfo? fieldInfo = type.GetField("codeSecret", BindingFlags.NonPublic | BindingFlags.Instance);
-            Assert.NotNull(fieldInfo);
-
-            Code? codeSecret = (Code?)fieldInfo.GetValue(plateau);
-
-            Assert.NotNull(codeSecret);
+        }
+
+        [Fact]
+        public void TestEstBonCodeTrue()
+        {
+            Plateau plateau = new Plateau(4, 10);
+
+            Type type = typeof(Plateau);
+
+            FieldInfo? fieldInfo = type.GetField("codeSecret", BindingFlags.NonPublic | BindingFlags.Instance);
+            Assert.NotNull(fieldInfo);
+
+            Code? codeSecret = (Code?)fieldInfo.GetValue(plateau);
+
+            Assert.NotNull(codeSecret);
             Assert.True(plateau.EstBonCode(codeSecret));
-        }
-
-        [Fact]
-        public void TestEstBonCodeFalse()
-        {
-            List<Couleur> couleurs = new List<Couleur>((Couleur[])Enum.GetValues(typeof(Couleur)));
-
-            Plateau plateau = new Plateau(4, 10);
-
-            Type type = typeof(Plateau);
-
-            FieldInfo? fieldInfo = type.GetField("codeSecret", BindingFlags.NonPublic | BindingFlags.Instance);
-            Assert.NotNull(fieldInfo);
-
-            Code? codeSecret = (Code?)fieldInfo.GetValue(plateau);
-            Assert.NotNull(codeSecret);
-
-            Jeton[] jetons = codeSecret.Jetons().Where(jeton => jeton.HasValue).Select(jeton => jeton!.Value).ToArray();
-
-            Couleur couleurJeton = jetons[0].Couleur;
-            int indice = couleurs.IndexOf(couleurJeton) + 1;
-            if (indice >= couleurs.Count)
-                indice = 0;
-
-            jetons[0] = new Jeton(couleurs[indice]);
-
-            Code code = new Code(jetons);
-
-            Assert.False(plateau.EstBonCode(code));
-        }
-
-        [Fact]
-        public void TestEstBonCodeAucunIndicateur()
-        {
-            List<Couleur> couleurs = new List<Couleur>((Couleur[])Enum.GetValues(typeof(Couleur)));
-            Plateau plateau = new Plateau(4, 10);
-            Type type = typeof(Plateau);
-
-            FieldInfo? fieldInfo = type.GetField("codeSecret", BindingFlags.NonPublic | BindingFlags.Instance);
-            Assert.NotNull(fieldInfo);
-
-            Code? codeSecret = (Code?)fieldInfo.GetValue(plateau);
-            Assert.NotNull(codeSecret);
-
-            Jeton[] jetons = codeSecret.Jetons().Where(jeton => jeton.HasValue).Select(jeton => jeton!.Value).ToArray();
-
+        }
+
+        [Fact]
+        public void TestEstBonCodeFalse()
+        {
+            List<Couleur> couleurs = new List<Couleur>((Couleur[])Enum.GetValues(typeof(Couleur)));
+
+            Plateau plateau = new Plateau(4, 10);
+
+            Type type = typeof(Plateau);
+
+            FieldInfo? fieldInfo = type.GetField("codeSecret", BindingFlags.NonPublic | BindingFlags.Instance);
+            Assert.NotNull(fieldInfo);
+
+            Code? codeSecret = (Code?)fieldInfo.GetValue(plateau);
+            Assert.NotNull(codeSecret);
+
+            Jeton[] jetons = codeSecret.Jetons().Where(jeton => jeton.HasValue).Select(jeton => jeton!.Value).ToArray();
+
+            Couleur couleurJeton = jetons[0].Couleur;
+            int indice = couleurs.IndexOf(couleurJeton) + 1;
+            if (indice >= couleurs.Count)
+                indice = 0;
+
+            jetons[0] = new Jeton(couleurs[indice]);
+
+            Code code = new Code(jetons);
+
+            Assert.False(plateau.EstBonCode(code));
+        }
+
+        [Fact]
+        public void TestEstBonCodeAucunIndicateur()
+        {
+            List<Couleur> couleurs = new List<Couleur>((Couleur[])Enum.GetValues(typeof(Couleur)));
+            Plateau plateau = new Plateau(4, 10);
+            Type type = typeof(Plateau);
+
+            FieldInfo? fieldInfo = type.GetField("codeSecret", BindingFlags.NonPublic | BindingFlags.Instance);
+            Assert.NotNull(fieldInfo);
+
+            Code? codeSecret = (Code?)fieldInfo.GetValue(plateau);
+            Assert.NotNull(codeSecret);
+
+            Jeton[] jetons = codeSecret.Jetons().Where(jeton => jeton.HasValue).Select(jeton => jeton!.Value).ToArray();
+
             for (int i=0; i<jetons.Length; ++i)
             {
                 Couleur couleurJeton = jetons[i].Couleur;
                 couleurs.Remove(couleurJeton);
-            }
-
-            Code code = new Code(
-                [
-                    new Jeton(couleurs[0]),
+            }
+
+            Code code = new Code(
+                [
+                    new Jeton(couleurs[0]),
                     new Jeton(couleurs[0]),
                     new Jeton(couleurs[0]),
                     new Jeton(couleurs[0])
-                ]
-             );
-
+                ]
+             );
+
             Assert.False(plateau.EstBonCode(code));
-        }
-
-        [Fact]
-        public void TestGrilleValide()
-        {
-            Plateau plateau = new Plateau(4, 3);
-            Code code1 = new Code([new Jeton(Couleur.BLEU), new Jeton(Couleur.BLANC), new Jeton(Couleur.JAUNE), new Jeton(Couleur.BLANC)]);
-            Code code2 = new Code([new Jeton(Couleur.VERT), new Jeton(Couleur.JAUNE), new Jeton(Couleur.ROUGE), new Jeton(Couleur.NOIR)]);
-
-            plateau.AjouterCode(code1);
-            plateau.AjouterCode(code2);
-
-            IEnumerable<IEnumerable<Jeton?>> grille = plateau.Grille();
-
-            Assert.Equal(4, grille.First().Count());
-            Assert.Equal(4, grille.Last().Count());
-            Assert.Equal(code1.Jetons(), grille.ElementAt(0));
-            Assert.Equal(code2.Jetons(), grille.ElementAt(1));
-
-        }
-
-        [Fact]
-        public void TestGrilleVide()
-        {
-            Plateau plateau = new Plateau(4, 3);
-
-            IEnumerable<IEnumerable<Jeton?>> grille = plateau.Grille();
-
-            foreach (IEnumerable<Jeton?> tour in grille)
-            {
-                Assert.All(tour, jeton => Assert.Null(jeton));
-            }
-        }
-
-        [Fact]
-        public void TestIndicateursVide()
+        }
+
+        [Fact]
+        public void TestGrilleValide()
+        {
+            Plateau plateau = new Plateau(4, 3);
+            Code code1 = new Code([new Jeton(Couleur.BLEU), new Jeton(Couleur.BLANC), new Jeton(Couleur.JAUNE), new Jeton(Couleur.BLANC)]);
+            Code code2 = new Code([new Jeton(Couleur.VERT), new Jeton(Couleur.JAUNE), new Jeton(Couleur.ROUGE), new Jeton(Couleur.NOIR)]);
+
+            plateau.AjouterCode(code1);
+            plateau.AjouterCode(code2);
+
+            IEnumerable<IEnumerable<Jeton?>> grille = plateau.Grille();
+
+            Assert.Equal(4, grille.First().Count());
+            Assert.Equal(4, grille.Last().Count());
+            Assert.Equal(code1.Jetons(), grille.ElementAt(0));
+            Assert.Equal(code2.Jetons(), grille.ElementAt(1));
+
+        }
+
+        [Fact]
+        public void TestGrilleVide()
+        {
+            Plateau plateau = new Plateau(4, 3);
+
+            IEnumerable<IEnumerable<Jeton?>> grille = plateau.Grille();
+
+            foreach (IEnumerable<Jeton?> tour in grille)
+            {
+                Assert.All(tour, jeton => Assert.Null(jeton));
+            }
+        }
+
+        [Fact]
+        public void TestIndicateursVide()
         {
             Plateau plateau = new Plateau(4, 5);
 
@@ -233,13 +233,13 @@ namespace UnitTesting
             {
                 Assert.Null(indicateur);
             }
-        }
-
-        [Fact]
-        public void TestIndicateursAjouterDeuxCodes()
-        {
-            Plateau plateau = new Plateau(4, 5);
-            Code code1 = new Code([new Jeton(Couleur.BLEU), new Jeton(Couleur.BLANC), new Jeton(Couleur.JAUNE), new Jeton(Couleur.BLANC)]);
+        }
+
+        [Fact]
+        public void TestIndicateursAjouterDeuxCodes()
+        {
+            Plateau plateau = new Plateau(4, 5);
+            Code code1 = new Code([new Jeton(Couleur.BLEU), new Jeton(Couleur.BLANC), new Jeton(Couleur.JAUNE), new Jeton(Couleur.BLANC)]);
             Code code2 = new Code([new Jeton(Couleur.VERT), new Jeton(Couleur.JAUNE), new Jeton(Couleur.ROUGE), new Jeton(Couleur.NOIR)]);
 
             plateau.AjouterCode(code1);
@@ -250,6 +250,6 @@ namespace UnitTesting
             Assert.Null(plateau.Indicateurs().ElementAt(2));
             Assert.Null(plateau.Indicateurs().ElementAt(3));
             Assert.Null(plateau.Indicateurs().ElementAt(4));
-        }
-    }
-}
+        }
+    }
+}

Sources/UnitTesting/ReglesClassiquesUT.cs

@@ -1,131 +1,131 @@
-using CoreLibrary;
-using CoreLibrary.Exceptions;
-using System.Reflection;
-using Xunit;
-
-namespace UnitTesting
-{
-    public class ReglesClassiquesUT
-    {
-        [Fact]
+using CoreLibrary;
+using CoreLibrary.Exceptions;
+using System.Reflection;
+using Xunit;
+
+namespace UnitTesting
+{
+    public class ReglesClassiquesUT
+    {
+        [Fact]
         public void TestNom()
         {
             ReglesClassiques regle = new ReglesClassiques();
             Assert.Equal("Règles classiques", regle.Nom);
-        }
-        [Fact]
-        public void TestConstructeur()
-        {
-            ReglesClassiques regles = new ReglesClassiques();
-
-            Assert.NotNull(regles);
-            Assert.Equal(0, regles.NbJoueurs);
-            Assert.Equal(2, regles.NbJoueursMaximum);
-        }
-
-        [Fact]
-        public void TestAjouterJoueur() 
-        {
-            ReglesClassiques regles = new ReglesClassiques();
-
-            regles.AjouterJoueur("MonJoueur");
-
-            Assert.Equal(1, regles.NbJoueurs);
-        }
-
-        [Fact]
-        public void TestJoueurCourantAvecJoueur()
-        {
-            ReglesClassiques regles = new ReglesClassiques();
-            regles.AjouterJoueur("joueur1");
-            regles.AjouterJoueur("joueur2");
-            regles.CommencerLaPartie();
-
-            Joueur joueurCourant = regles.JoueurCourant();
-
-            Assert.NotNull(joueurCourant);
-            Assert.Equal("joueur1", joueurCourant.Nom);
-        }
-
-        [Fact]
-        public void TestJoueurCourantSansJoueur()
-        {
-            ReglesClassiques regles = new ReglesClassiques();
-            Assert.Throws<PartieNonCommenceeException>(() => regles.JoueurCourant());
-        }
-
-        [Fact]
-        public void TestPasserLaMainValide()
-        {
-            ReglesClassiques regles = new ReglesClassiques();
-            regles.AjouterJoueur("joueur1");
-            regles.AjouterJoueur("joueur2");
-
-            regles.CommencerLaPartie();
-            Joueur joueurCourantInitial = regles.JoueurCourant();
-            regles.PasserLaMain();
-            Joueur joueurCourantSuivant = regles.JoueurCourant();
-
-            Assert.NotEqual(joueurCourantInitial, joueurCourantSuivant);
-            Assert.Equal("joueur2", joueurCourantSuivant.Nom);
-        }
-
-        [Fact]
+        }
+        [Fact]
+        public void TestConstructeur()
+        {
+            ReglesClassiques regles = new ReglesClassiques();
+
+            Assert.NotNull(regles);
+            Assert.Equal(0, regles.NbJoueurs);
+            Assert.Equal(2, regles.NbJoueursMaximum);
+        }
+
+        [Fact]
+        public void TestAjouterJoueur() 
+        {
+            ReglesClassiques regles = new ReglesClassiques();
+
+            regles.AjouterJoueur("MonJoueur");
+
+            Assert.Equal(1, regles.NbJoueurs);
+        }
+
+        [Fact]
+        public void TestJoueurCourantAvecJoueur()
+        {
+            ReglesClassiques regles = new ReglesClassiques();
+            regles.AjouterJoueur("joueur1");
+            regles.AjouterJoueur("joueur2");
+            regles.CommencerLaPartie();
+
+            Joueur joueurCourant = regles.JoueurCourant();
+
+            Assert.NotNull(joueurCourant);
+            Assert.Equal("joueur1", joueurCourant.Nom);
+        }
+
+        [Fact]
+        public void TestJoueurCourantSansJoueur()
+        {
+            ReglesClassiques regles = new ReglesClassiques();
+            Assert.Throws<PartieNonCommenceeException>(() => regles.JoueurCourant());
+        }
+
+        [Fact]
+        public void TestPasserLaMainValide()
+        {
+            ReglesClassiques regles = new ReglesClassiques();
+            regles.AjouterJoueur("joueur1");
+            regles.AjouterJoueur("joueur2");
+
+            regles.CommencerLaPartie();
+            Joueur joueurCourantInitial = regles.JoueurCourant();
+            regles.PasserLaMain();
+            Joueur joueurCourantSuivant = regles.JoueurCourant();
+
+            Assert.NotEqual(joueurCourantInitial, joueurCourantSuivant);
+            Assert.Equal("joueur2", joueurCourantSuivant.Nom);
+        }
+
+        [Fact]
         public void TestPasserLaMainCompteurReinitialise()
         {
-            ReglesClassiques regles = new ReglesClassiques();
+            ReglesClassiques regles = new ReglesClassiques();
             Type type = typeof(ReglesClassiques);
 
             regles.AjouterJoueur("joueur1");
-            regles.AjouterJoueur("joueur2");
-            regles.CommencerLaPartie();
-
-            FieldInfo? fieldInfo = type.GetField("joueurCourant", BindingFlags.NonPublic | BindingFlags.Instance);
-            Assert.NotNull(fieldInfo);
+            regles.AjouterJoueur("joueur2");
+            regles.CommencerLaPartie();
+
+            FieldInfo? fieldInfo = type.GetField("joueurCourant", BindingFlags.NonPublic | BindingFlags.Instance);
+            Assert.NotNull(fieldInfo);
             int? joueurCourant = (int?)fieldInfo.GetValue(regles);
 
             regles.PasserLaMain();
             regles.PasserLaMain();
-            regles.PasserLaMain();
-
+            regles.PasserLaMain();
+
             Assert.NotNull(joueurCourant);
             Assert.Equal(0, joueurCourant);
-        }
-
-        [Fact]
-        public void TestPasserLaMainInvalide()
-        {
-            ReglesClassiques regles = new ReglesClassiques();
-            Assert.Throws<PartieNonCommenceeException>(() => regles.PasserLaMain());
-        }
-
-        [Fact]
-        public void TestGenererCode()
-        {
-            ReglesClassiques regles = new ReglesClassiques();
-            Code code = regles.GenererCode();
-
-            Assert.NotNull(code);
-            Assert.Equal(regles.TailleCodeMaximum, code.TailleMaximale());
-        }
-
-        [Fact]
-        public void TestCommencerLaPartie()
-        {
-            ReglesClassiques regles = new ReglesClassiques();
-            regles.AjouterJoueur("joueur1");
-            regles.AjouterJoueur("joueur2");
-
-            regles.CommencerLaPartie();
-            Joueur joueurCourant = regles.JoueurCourant();
-
-            Assert.NotNull(joueurCourant);
-            Assert.Equal("joueur1", joueurCourant.Nom);
-        }
-
-        [Fact]
-        public void TestEstTermineeFalseUnJoueur()
-        {
+        }
+
+        [Fact]
+        public void TestPasserLaMainInvalide()
+        {
+            ReglesClassiques regles = new ReglesClassiques();
+            Assert.Throws<PartieNonCommenceeException>(() => regles.PasserLaMain());
+        }
+
+        [Fact]
+        public void TestGenererCode()
+        {
+            ReglesClassiques regles = new ReglesClassiques();
+            Code code = regles.GenererCode();
+
+            Assert.NotNull(code);
+            Assert.Equal(regles.TailleCodeMaximum, code.TailleMaximale());
+        }
+
+        [Fact]
+        public void TestCommencerLaPartie()
+        {
+            ReglesClassiques regles = new ReglesClassiques();
+            regles.AjouterJoueur("joueur1");
+            regles.AjouterJoueur("joueur2");
+
+            regles.CommencerLaPartie();
+            Joueur joueurCourant = regles.JoueurCourant();
+
+            Assert.NotNull(joueurCourant);
+            Assert.Equal("joueur1", joueurCourant.Nom);
+        }
+
+        [Fact]
+        public void TestEstTermineeFalseUnJoueur()
+        {
             ReglesClassiques regles = new ReglesClassiques();
             regles.AjouterJoueur("joueur1");
             regles.CommencerLaPartie();
@@ -133,23 +133,23 @@ namespace UnitTesting
 
             bool result = regles.EstTerminee();
 
-            Assert.False(result);
-        }
-
-        [Fact]
-        public void TestEstTermineeFalse()
-        {
-            ReglesClassiques regles = new ReglesClassiques();
-            regles.AjouterJoueur("joueur1");
-            regles.AjouterJoueur("joueur2");
-            regles.CommencerLaPartie();
-
-            bool estTerminee = regles.EstTerminee();
-
-            Assert.False(estTerminee);
-        }
-
-        [Fact]
+            Assert.False(result);
+        }
+
+        [Fact]
+        public void TestEstTermineeFalse()
+        {
+            ReglesClassiques regles = new ReglesClassiques();
+            regles.AjouterJoueur("joueur1");
+            regles.AjouterJoueur("joueur2");
+            regles.CommencerLaPartie();
+
+            bool estTerminee = regles.EstTerminee();
+
+            Assert.False(estTerminee);
+        }
+
+        [Fact]
         public void TestGagnantsAucunGagnants()
         {
             ReglesClassiques regles = new ReglesClassiques();
@@ -160,7 +160,7 @@ namespace UnitTesting
             IEnumerable<Joueur> gagnants = regles.Gagnants();
 
             Assert.Empty(gagnants);
-        }
-
-    }
-}
+        }
+
+    }
+}