Merge branch 'UT' of https://codefirst.iut.uca.fr/git/nicolas.barbosa/mastermind into UT

Sources/ConsoleApp/Program.cs

@@ -9,8 +9,8 @@ using Persistance.Persistance;
 namespace ConsoleApp
 {
     /// <summary>
-    /// Permet de jouer une partie de mastermind, avec les règles classiques 
+    /// Permet de jouer une partie de mastermind, avec les regles classiques
-    /// (2 joueurs, 12 tours, un code à 4 couleurs parmi 6)
+    /// (2 joueurs, 12 tours, un code a code couleurs parmi 6) 
     /// </summary>
     [ExcludeFromCodeCoverage]
     public static class Program

Sources/UnitTesting/CodeUT.cs

@@ -5,8 +5,14 @@ using Xunit;
 
 namespace UnitTesting
 {
+    /// <summary>
+    /// 
+    /// </summary>
     public class CodeUT
     {
+        /// <summary>
+        /// 
+        /// </summary>
         [Fact]
         public void TestPremierConstructeurValide()
         {
@@ -18,12 +24,18 @@ namespace UnitTesting
             Assert.True(code.Vide);
         }
 
+        /// <summary>
+        /// 
+        /// </summary>
         [Fact]
         public void TestPremierConstructeurInvalide()
         {
             Assert.Throws<TailleCodeException>(() => new Code(-1));
         }
 
+        /// <summary>
+        /// 
+        /// </summary>
         [Fact]
         public void TestAjouterJetonValide()
         {
@@ -34,6 +46,9 @@ namespace UnitTesting
             Assert.Equal(jeton, code.Jetons.ElementAt(0));
         }
 
+        /// <summary>
+        /// 
+        /// </summary>
         [Fact]
         public void TestAjouterJetonInvalide()
         {
@@ -45,6 +60,9 @@ namespace UnitTesting
             Assert.Throws<CodeCompletException>(() => code.AjouterJeton(new Jeton(Couleur.Rouge)));
         }
 
+        /// <summary>
+        /// 
+        /// </summary>
         [Fact]
         public void TestSupprimerDernierJetonValide()
         {
@@ -57,6 +75,9 @@ namespace UnitTesting
             Assert.Equal(2, code.Taille);
         }
 
+        /// <summary>
+        /// 
+        /// </summary>
         [Fact]
         public void TestSupprimerDernierJetonInvalide()
         {
@@ -64,6 +85,9 @@ namespace UnitTesting
             Assert.Throws<CodeVideException>(() => code.SupprimerDernierJeton());
         }
 
+        /// <summary>
+        /// 
+        /// </summary>
         [Fact]
         public void TestRecupererJetonValide()
         {
@@ -77,6 +101,9 @@ namespace UnitTesting
             Assert.Equal(jetonAttendu.Couleur, jeton.Couleur);
         }
 
+        /// <summary>
+        /// 
+        /// </summary>
         [Fact]
         public void TestRecupererJetonInvalide()
         {
@@ -85,6 +112,9 @@ namespace UnitTesting
             Assert.Throws<IndiceCodeException>(() => code.RecupererJeton(4));
         }
 
+        /// <summary>
+        /// 
+        /// </summary>
         [Fact]
         public void TestRecupererJetonNull()
         {
@@ -92,6 +122,9 @@ namespace UnitTesting
             Assert.Throws<IndiceCodeException>(() => code.RecupererJeton(1));
         }
 
+        /// <summary>
+        /// 
+        /// </summary>
         [Fact]
         public void TestJetonsValide()
         {
@@ -112,6 +145,9 @@ namespace UnitTesting
             }
         }
 
+        /// <summary>
+        /// 
+        /// </summary>
         [Fact]
         public void TestEstCompletValide()
         {
@@ -124,6 +160,9 @@ namespace UnitTesting
             Assert.True(estComplet);
         }
 
+        /// <summary>
+        /// 
+        /// </summary>
         [Fact]
         public void TestEstCompletInvalide()
         {
@@ -132,6 +171,9 @@ namespace UnitTesting
             Assert.False(estComplet);
         }
 
+        /// <summary>
+        /// 
+        /// </summary>
         [Fact]
         public void TestTailleMaximaleValide()
         {
@@ -145,6 +187,9 @@ namespace UnitTesting
             Assert.Equal(jetons.Length, tailleMaximale);
         }
 
+        /// <summary>
+        /// 
+        /// </summary>
         [Fact]
         public void TestComparerValide()
         {
@@ -165,6 +210,9 @@ namespace UnitTesting
             Assert.Equal(3, indicateurs.Count);
         }
 
+        /// <summary>
+        /// 
+        /// </summary>
         [Fact]
         public void TestComparerDifferent()
         {
@@ -185,6 +233,9 @@ namespace UnitTesting
             Assert.Empty(indicateurs);
         }
 
+        /// <summary>
+        /// 
+        /// </summary>
         [Fact]
         public void TestComparerMonCodeIncomplet()
         {
@@ -201,6 +252,9 @@ namespace UnitTesting
             Assert.Empty(indicateurs);
         }
 
+        /// <summary>
+        /// 
+        /// </summary>
         [Fact]
         public void TestComparerSonCodeIncomplet()
         {
@@ -215,6 +269,9 @@ namespace UnitTesting
             Assert.Throws<CodeIncompletException>(() => code1.Comparer(code2));
         }
 
+        /// <summary>
+        /// 
+        /// </summary>
         [Fact]
         public void TestToString()
         {
@@ -227,6 +284,9 @@ namespace UnitTesting
             Assert.Equal("Code(1)", code.ToString());
         }
 
+        /// <summary>
+        /// 
+        /// </summary>
         [Fact]
         public void TestComparerCodeInvalide()
         {
@@ -239,6 +299,9 @@ namespace UnitTesting
             Assert.Throws<CodeInvalideException>(() => code.Comparer(code1));
         }
 
+        /// <summary>
+        /// 
+        /// </summary>
         [Fact]
         public void TestComparerCodeCorrect()
         {

Sources/UnitTesting/JetonUT.cs

@@ -3,8 +3,14 @@ using Xunit;
 
 namespace UnitTesting
 {
+    /// <summary>
+    /// 
+    /// </summary>
     public class JetonUT
-    {
+    {
+        /// <summary>
+        /// 
+        /// </summary>
         [Fact]
         public void TestConstructeurValide()
         {
@@ -15,8 +21,11 @@ namespace UnitTesting
                 Jeton jeton = new Jeton(listeCouleurs[i]);
                 Assert.Equal(listeCouleurs[i], jeton.Couleur);
             }
-        }
+        }
-
+
+        /// <summary>
+        /// 
+        /// </summary>
         [Fact]
         public void TestEquals()
         {

Sources/UnitTesting/JoueurUT.cs

@@ -9,8 +9,14 @@ using Xunit;
 
 namespace UnitTesting
 {
+    /// <summary>
+    /// 
+    /// </summary>
     public class JoueurUT
     {
+        /// <summary>
+        /// 
+        /// </summary>
         [Fact]
         public void TestConstructeur1Valide()
         {
@@ -22,7 +28,9 @@ namespace UnitTesting
             Assert.Equal(nom, joueur.Nom);
         }
 
-
+        /// <summary>
+        /// 
+        /// </summary>
         [Fact]
         public void TestConstructeur2Valide()
         {
@@ -34,6 +42,9 @@ namespace UnitTesting
             Assert.Equal(nom, joueur.Nom);
         }
 
+        /// <summary>
+        /// 
+        /// </summary>
         [Fact]
         public void TestQuandJoueurSeConnecter()
         {
@@ -56,6 +67,9 @@ namespace UnitTesting
             Assert.Equal(joueur2, eventArgs?.Joueur);
         }
 
+        /// <summary>
+        /// 
+        /// </summary>
         [Fact]
         public void TestSeConnecterDeclencheEvenement()
         {
@@ -77,6 +91,9 @@ namespace UnitTesting
             Assert.Equal(joueur2, eventArgs?.Joueur);
         }
 
+        /// <summary>
+        /// 
+        /// </summary>
         [Fact]
         public void TestToStringValide()
         {
@@ -86,6 +103,9 @@ namespace UnitTesting
             Assert.Equal(nom, result);
         }
 
+        /// <summary>
+        /// 
+        /// </summary>
         [Fact]
         public void TestToStringVide()
         {
@@ -95,6 +115,9 @@ namespace UnitTesting
             Assert.Equal("", result);
         }
 
+        /// <summary>
+        /// 
+        /// </summary>
         [Fact]
         public void TestStatistiqueNonDefinie()
         {
@@ -107,6 +130,9 @@ namespace UnitTesting
             Assert.Equal(0, result);
         }
 
+        /// <summary>
+        /// 
+        /// </summary>
         [Fact]
         public void TestStatistiqueDefinie()
         {
@@ -120,6 +146,9 @@ namespace UnitTesting
             Assert.Equal(1, result);
         }
 
+        /// <summary>
+        /// 
+        /// </summary>
         [Fact]
         public void TestIncrementerStatistiqueUn()
         {
@@ -133,6 +162,9 @@ namespace UnitTesting
             Assert.Equal(1, result);
         }
 
+        /// <summary>
+        /// 
+        /// </summary>
         [Fact]
         public void TestIncrementerStatistiqueDeux()
         {

Sources/UnitTesting/ManageurUT.cs

@@ -11,8 +11,14 @@ using Xunit;
 
 namespace UnitTesting
 {
+    /// <summary>
+    /// Classe test pour la classe Manageur.
+    /// </summary>
     public class ManageurUT
-    {
+    {
+        /// <summary>
+        /// Test le constructeur de Manageur.
+        /// </summary>
         [Fact]
         public void TestConstruteur()
         {
@@ -27,8 +33,11 @@ namespace UnitTesting
 
             Assert.NotNull(manageur.PartiesNonTerminees);
             Assert.NotEmpty(manageur.Joueurs);
-        }
+        }
-
+
+        /// <summary>
+        /// Test la méthode Sauvegarder d'une partie.
+        /// </summary>
         [Fact]
         public void TestSauvegarder()
         {
@@ -38,8 +47,11 @@ namespace UnitTesting
             MethodInfo? infosMethode = typeof(Manageur).GetMethod("Sauvegarder", BindingFlags.NonPublic | BindingFlags.Instance);
             Assert.NotNull(infosMethode);
             infosMethode.Invoke(manageur, []);
-        }
+        }
-
+
+        /// <summary>
+        /// Test la méthode ChargerPartie qui charge une partie.
+        /// </summary>
         [Fact]
         public void TestChargerPartie()
         {
@@ -55,8 +67,11 @@ namespace UnitTesting
 
             Assert.Contains(nouvellePartie, manageur.Parties);
             Assert.Contains(nouvellePartie, manageur.PartiesNonTerminees);
-        }
+        }
-
+
+        /// <summary>
+        /// Test la méthode NouvellePartie de Manageur.
+        /// </summary>
         [Fact]
         public void TestNouvellePartie()
         {
@@ -67,8 +82,11 @@ namespace UnitTesting
 
             Assert.Contains(nouvellePartie, manageur.Parties);
             Assert.Contains(nouvellePartie, manageur.PartiesNonTerminees);
-        }
+        }
-
+
+        /// <summary>
+        /// Premier test de la méthode EcouterPartie de Manageur. 
+        /// </summary>
         [Fact]
         public void TestEcouterPartie()
         {
@@ -154,8 +172,11 @@ namespace UnitTesting
             Assert.NotEmpty(PartieDemanderJoueurJouer.GetInvocationList());
             Assert.NotEmpty(PartiePasserLaMain.GetInvocationList());
             Assert.NotEmpty(PartiePartieTerminee.GetInvocationList());
-        }
+        }
-
+
+        /// <summary>
+        /// Deuxième test de la méthode EcouterPartie de Manageur. 
+        /// </summary>
         [Fact]
         public void TestEcouterPartie2()
         {
@@ -203,8 +224,11 @@ namespace UnitTesting
             Assert.Equal(1, celeste.Statistique(new ReglesClassiques(), Statistique.PartieGagnee));
             Assert.Equal(0, celeste.Statistique(new ReglesClassiques(), Statistique.PartieEgalite));
             Assert.Equal(0, celeste.Statistique(new ReglesClassiques(), Statistique.PartiePerdue));
-        }
+        }
-
+
+        /// <summary>
+        /// Troisième test de la méthode EcouterPartie de Manageur. 
+        /// </summary>
         [Fact]
         public void TestEcouterPartie3()
         {
@@ -252,8 +276,11 @@ namespace UnitTesting
             Assert.Equal(0, celeste.Statistique(new ReglesClassiques(), Statistique.PartieGagnee));
             Assert.Equal(0, celeste.Statistique(new ReglesClassiques(), Statistique.PartieEgalite));
             Assert.Equal(1, celeste.Statistique(new ReglesClassiques(), Statistique.PartiePerdue));
-        }
+        }
-
+
+        /// <summary>
+        /// Quatrième test de la méthode EcouterPartie de Manageur. 
+        /// </summary>
         [Fact]
         public void TestEcouterPartie4()
         {
@@ -301,8 +328,11 @@ namespace UnitTesting
             Assert.Equal(0, celeste.Statistique(new ReglesClassiques(), Statistique.PartieGagnee));
             Assert.Equal(1, celeste.Statistique(new ReglesClassiques(), Statistique.PartieEgalite));
             Assert.Equal(0, celeste.Statistique(new ReglesClassiques(), Statistique.PartiePerdue));
-        }
+        }
-
+
+        /// <summary>
+        /// Cinquième test de la méthode EcouterPartie de Manageur. 
+        /// </summary>
         [Fact]
         public void TestEcouterPartie5()
         {
@@ -350,8 +380,11 @@ namespace UnitTesting
             Assert.Equal(0, celeste.Statistique(new ReglesClassiques(), Statistique.PartieGagnee));
             Assert.Equal(0, celeste.Statistique(new ReglesClassiques(), Statistique.PartieEgalite));
             Assert.Equal(1, celeste.Statistique(new ReglesClassiques(), Statistique.PartiePerdue));
-        }
+        }
-
+
+        /// <summary>
+        /// Test de la méthode DemanderJoueurExistant de Manageur.
+        /// </summary>
         [Fact]
         public void TestDemanderJoueurExistant()
         {
@@ -367,8 +400,11 @@ namespace UnitTesting
 
             object? toto = infosMethode.Invoke(manageur, ["Toto"]);
             Assert.Null(toto);
-        }
+        }
-
+
+        /// <summary>
+        /// Test de la méthode DemanderJoueur de Manageur.
+        /// </summary>
         [Fact]
         public void TestDemanderJoueur()
         {

Sources/UnitTesting/PartieUT.cs

@@ -10,18 +10,26 @@ using CoreLibrary.Exceptions;
 
 namespace UnitTesting
 {
+    /// <summary>
+    /// Classe test pour la classe Partie.
+    /// </summary>
     public class PartieUT
-    {
+    {
+        /// <summary>
+        /// Test le premier constructeur de Partie valide.
+        /// </summary>
         [Fact]
-
         public void TestPremierConstructeurValide()
         {
             IRegles regle = new ReglesClassiques();
 
             Partie partie = new Partie(regle);
             Assert.Equal(regle, partie.Regles);
-        }
+        }
-
+
+        /// <summary>
+        /// Test le deuxième constructeur de Partie valide.
+        /// </summary>
         [Fact]
         public void TestSecondConstructeurValide()
         {
@@ -106,8 +114,11 @@ namespace UnitTesting
                 }
 
             }
-        }
+        }
-
+
+        /// <summary>
+        /// Test la méthode JouerDemanderJoueur de Partie.
+        /// </summary>
         [Fact]
         public void TestJouerDemanderJouer()
         {
@@ -128,8 +139,11 @@ namespace UnitTesting
                 partie.Jouer();
                 Assert.True(demanderJoueurCalled);
             }
-        }
+        }
-
+
+        /// <summary>
+        /// Test la méthode JouerDebutPartie de Partie.
+        /// </summary>
         [Fact]
         public void TestJouerDebutPartie()
         {
@@ -151,8 +165,11 @@ namespace UnitTesting
                 partie.Jouer();
                 Assert.True(debutPartieCalled);
             }
-        }
+        }
-
+
+        /// <summary>
+        /// Test la méthode DemanderJoueur de Partie.
+        /// </summary>
         [Fact]
         public void TestDemanderJoueur()
         {
@@ -177,8 +194,11 @@ namespace UnitTesting
                 joueurDemande.SeConnecter(joueurDemande);
                 Assert.True(joueurConnecteCalled);
             }
-        }
+        }
-
+
+        /// <summary>
+        /// Test l'événement JoueurSeConnecterEventArgs de Partie.
+        /// </summary>
         [Fact]
         public void TestJoueurConnecte()
         {
@@ -249,8 +269,11 @@ namespace UnitTesting
                     Assert.Equal(1, tour);
                 }
             }
-        }
+        }
-
+
+        /// <summary>
+        /// Test l'exception JoueurDejaPresentException de Partie.
+        /// </summary>
         [Fact]
         public void TestJoueurConnecteDejaPresent()
         {
@@ -272,8 +295,11 @@ namespace UnitTesting
             partie.Jouer();
 
             Assert.True(appelee);
-        }
+        }
-
+
+        /// <summary>
+        /// Test l'exception NomJoueurInterditException de Partie.
+        /// </summary>
         [Fact]
         public void TestJoueurConnecteNomInterdit()
         {
@@ -292,8 +318,11 @@ namespace UnitTesting
             partie.Jouer();
 
             Assert.True(appelee);
-        }
+        }
-
+
+        /// <summary>
+        /// Test la création d'un robot.
+        /// </summary>
         [Fact]
         public void TestRobot()
         {
@@ -311,8 +340,11 @@ namespace UnitTesting
             partie.Jouer();
 
             Assert.NotEmpty(partie.Robots);
-        }
+        }
-
+
+        /// <summary>
+        /// Test la méthode DebutPartie de Partie.
+        /// </summary>
         [Fact]
         public void TestDebutPartie()
         {
@@ -361,8 +393,11 @@ namespace UnitTesting
                     }
                 }
             }
-        }
+        }
-
+
+        /// <summary>
+        /// Test la méthode NouveauTour de Partie.
+        /// </summary>
         [Fact]
         public void TestNouveauTour()
         {
@@ -399,8 +434,11 @@ namespace UnitTesting
 
             Assert.True(demanderJoueurJouerEventTriggered);
             Assert.True(nouveauTourEventTriggered);
-        }
+        }
-
+
+        /// <summary>
+        /// Test la méthode AjouterCode de Partie et vérifie qu'il y a eu une incrémentation pour le nombre de tour.
+        /// </summary>
         [Fact]
         public void TestPlateauAjouterCodeIncrementation()
         {
@@ -451,8 +489,11 @@ namespace UnitTesting
                 Assert.Equal(1, partie.Tour);
             }
 
-        }
+        }
-
+
+        /// <summary>
+        /// Test la méthode AjouterCode de Partie et vérifie que la partie est terminée.
+        /// </summary>
         [Fact]
         public void PlateauAjouterCodeTerminee()
         {
@@ -491,8 +532,11 @@ namespace UnitTesting
                     Assert.True(partie.Termine);
                 }
             }
-        }
+        }
-
+
+        /// <summary>
+        /// Test la méthode PartieTerminee de Partie et vérifie les gagnants et perdants.
+        /// </summary>
         [Fact]
         public void TestPartieTerminee()
         {
@@ -534,8 +578,11 @@ namespace UnitTesting
 
                 }
             }
-        }
+        }
-
+
+        /// <summary>
+        /// Test tous les événements de Partie.
+        /// </summary>
         [Fact]
         public void TestPartieEcoute()
         {
@@ -603,8 +650,11 @@ namespace UnitTesting
             Assert.True(appel4);
             Assert.True(appel5);
             Assert.True(appel6);
-        }
+        }
-
+
+        /// <summary>
+        /// Test la méthode AjouterCode de Partie avec toutes ses composantes et les différentes fin.
+        /// </summary>
         [Fact]
         public void TestPartiePlateauAjouterCode()
         {

Sources/UnitTesting/PlateauUT.cs

@@ -1,73 +1,91 @@
-using CoreLibrary.Exceptions;
+using CoreLibrary.Exceptions;
-using System.Reflection;
+using System.Reflection;
-using CoreLibrary.Core;
+using CoreLibrary.Core;
-using Xunit;
+using Xunit;
-
+
-namespace UnitTesting
+namespace UnitTesting
-{
+{
-    public class PlateauUT
+    /// <summary>
-    {
+    /// Classe test pour la classe Plateau.
-        [Fact]
+    /// </summary>
-        public void TestConstructeurValide()
+    public class PlateauUT
-        {
+    {
-            Plateau plateau = new Plateau(4,12);
+        /// <summary>
-            Assert.NotNull(plateau);
+        /// Test que le constructeur de Plateau soit valide.
-            Assert.False(plateau.Victoire);
+        /// </summary>
-        }
+        [Fact]
-
+        public void TestConstructeurValide()
-        [Fact]
+        {
-        public void TestConstructeurInvalide()
+            Plateau plateau = new Plateau(4,12);
-        {
+            Assert.NotNull(plateau);
-            Assert.Throws<TailleCodeException>(() => new Plateau(-1, 10));
+            Assert.False(plateau.Victoire);
-            Assert.Throws<TailleGrilleException>(() => new Plateau(3, -1));
+        }
-        }
+
-
+        /// <summary>
-        [Fact]
+        /// Test que le constructeur de Plateau soit invalide.
-        public void TestEstCompletTrue()
+        /// </summary>
-        {
+        [Fact]
-            Plateau plateau = new Plateau(4, 3);
+        public void TestConstructeurInvalide()
-            Jeton[] jetons = [new Jeton(Couleur.Rouge), new Jeton(Couleur.Bleu), new Jeton(Couleur.Blanc), new Jeton(Couleur.Jaune)];
+        {
-            Code code = new Code(4);
+            Assert.Throws<TailleCodeException>(() => new Plateau(-1, 10));
-            code.AjouterJeton(jetons[0]);
+            Assert.Throws<TailleGrilleException>(() => new Plateau(3, -1));
-            code.AjouterJeton(jetons[1]);
+        }
-            code.AjouterJeton(jetons[2]);
+
-            code.AjouterJeton(jetons[3]);
+        /// <summary>
-            plateau.AjouterCode(code);
+        /// Test la méthode EstComplet de Plateau et vérifie qu'il renvoie True.
-            plateau.AjouterCode(code);
+        /// </summary>
-            plateau.AjouterCode(code);
+        [Fact]
-
+        public void TestEstCompletTrue()
-            bool estComplet = plateau.Complet;
+        {
-
+            Plateau plateau = new Plateau(4, 3);
-            Assert.True(estComplet);
+            Jeton[] jetons = [new Jeton(Couleur.Rouge), new Jeton(Couleur.Bleu), new Jeton(Couleur.Blanc), new Jeton(Couleur.Jaune)];
-        }
+            Code code = new Code(4);
-
+            code.AjouterJeton(jetons[0]);
-        [Fact]
+            code.AjouterJeton(jetons[1]);
-        public void TestEstCompletFalse()
+            code.AjouterJeton(jetons[2]);
-        {
+            code.AjouterJeton(jetons[3]);
-            Plateau plateau = new Plateau(4, 3);
+            plateau.AjouterCode(code);
-            Jeton[] jetons = [new Jeton(Couleur.Rouge), new Jeton(Couleur.Bleu), new Jeton(Couleur.Blanc), new Jeton(Couleur.Jaune)];
+            plateau.AjouterCode(code);
-            Code code = new Code(4);
+            plateau.AjouterCode(code);
-            code.AjouterJeton(jetons[0]);
+
-            code.AjouterJeton(jetons[1]);
+            bool estComplet = plateau.Complet;
-            code.AjouterJeton(jetons[2]);
+
-            code.AjouterJeton(jetons[3]);
+            Assert.True(estComplet);
-            plateau.AjouterCode(code);
+        }
-            plateau.AjouterCode(code);
+
-
+        /// <summary>
-            bool estComplet = plateau.Complet;
+        /// Test la méthode EstComplet de Plateau et vérifie qu'il renvoie False.
-
+        /// </summary>
-            Assert.False(estComplet);
+        [Fact]
-        }
+        public void TestEstCompletFalse()
-
+        {
+            Plateau plateau = new Plateau(4, 3);
+            Jeton[] jetons = [new Jeton(Couleur.Rouge), new Jeton(Couleur.Bleu), new Jeton(Couleur.Blanc), new Jeton(Couleur.Jaune)];
+            Code code = new Code(4);
+            code.AjouterJeton(jetons[0]);
+            code.AjouterJeton(jetons[1]);
+            code.AjouterJeton(jetons[2]);
+            code.AjouterJeton(jetons[3]);
+            plateau.AjouterCode(code);
+            plateau.AjouterCode(code);
+
+            bool estComplet = plateau.Complet;
+
+            Assert.False(estComplet);
+        }
+
+        /// <summary>
+        /// Test l'exception CodeCompletException de Plateau avec une taille de code supérieure à ce qui est défini.
+        /// </summary>
         [Fact]
         public void TestAjouterCodeTailleIncorrecte()
         {
             Plateau plateau = new Plateau(4, 10);
             Jeton[] jetons = new Jeton[]
-            {
+            {
-                new Jeton(Couleur.Rouge),
+                new Jeton(Couleur.Rouge),
-                new Jeton(Couleur.Bleu),
+                new Jeton(Couleur.Bleu),
-                new Jeton(Couleur.Blanc),
+                new Jeton(Couleur.Blanc),
                 new Jeton(Couleur.Jaune)
             };
             Code code = new Code(4);
@@ -78,45 +96,54 @@ namespace UnitTesting
 
             Assert.Throws<CodeCompletException>(() => code.AjouterJeton(new Jeton(Couleur.Bleu)));
 
-        }
+        }
-
+
-        [Fact]
+        /// <summary>
-        public void TestAjouterCodeIncomplet()
+        /// Test l'exception CodeIncompletException de Plateau avec un code incomplet.
-        {
+        /// </summary>
-            Plateau plateau = new Plateau(4, 10);
+        [Fact]
-            Code code = new Code(4);
+        public void TestAjouterCodeIncomplet()
-
+        {
-            Assert.Throws<CodeIncompletException>(() => plateau.AjouterCode(code));
+            Plateau plateau = new Plateau(4, 10);
-        }
+            Code code = new Code(4);
-
+
-        [Fact]
+            Assert.Throws<CodeIncompletException>(() => plateau.AjouterCode(code));
-        public void TestAjouterCodeBonCode()
+        }
-        {
+
-            Plateau plateau = new Plateau(4, 10);
+        /// <summary>
-
+        /// Test la méthode AjouterCode de Plateau avec un bon code.
-            Type type = typeof(Plateau);
+        /// </summary>
-
+        [Fact]
-            FieldInfo? fieldInfo = type.GetField("codeSecret", BindingFlags.NonPublic | BindingFlags.Instance);
+        public void TestAjouterCodeBonCode()
-            Assert.NotNull(fieldInfo);
+        {
-
+            Plateau plateau = new Plateau(4, 10);
-            Code? codeSecret = (Code?)fieldInfo.GetValue(plateau);
+
-
+            Type type = typeof(Plateau);
-            Assert.NotNull(codeSecret);
+
-            plateau.AjouterCode(codeSecret);
+            FieldInfo? fieldInfo = type.GetField("codeSecret", BindingFlags.NonPublic | BindingFlags.Instance);
-            Assert.True(plateau.Victoire);
+            Assert.NotNull(fieldInfo);
-        }
+
-
+            Code? codeSecret = (Code?)fieldInfo.GetValue(plateau);
-        [Fact]
+
-        public void TestGrilleAjouterCode()
+            Assert.NotNull(codeSecret);
-        {
+            plateau.AjouterCode(codeSecret);
-            Code code = new Code(4);
+            Assert.True(plateau.Victoire);
-            Couleur[] couleurs = Enum.GetValues<Couleur>();
+        }
+
+        /// <summary>
+        /// Test la méthode AjouterCode de Plateau et vérifie la grille et ses composants.
+        /// </summary>
+        [Fact]
+        public void TestGrilleAjouterCode()
+        {
+            Code code = new Code(4);
+            Couleur[] couleurs = Enum.GetValues<Couleur>();
             Plateau plateau = new Plateau(4, 12);
             Jeton[] jetons = new Jeton[]
-            {
+            {
-                new Jeton(Couleur.Rouge),
+                new Jeton(Couleur.Rouge),
-                new Jeton(Couleur.Bleu),
+                new Jeton(Couleur.Bleu),
-                new Jeton(Couleur.Blanc),
+                new Jeton(Couleur.Blanc),
                 new Jeton(Couleur.Jaune)
             };
             code.AjouterJeton(jetons[0]);
@@ -124,59 +151,67 @@ namespace UnitTesting
             code.AjouterJeton(jetons[2]);
             code.AjouterJeton(jetons[3]);
 
-            plateau.AjouterCode(code);
+            plateau.AjouterCode(code);
-            (IEnumerable<IEnumerable<Jeton>>, IEnumerable<IEnumerable<Indicateur>>) grille = plateau.Grille;
+            (IEnumerable<IEnumerable<Jeton>>, IEnumerable<IEnumerable<Indicateur>>) grille = plateau.Grille;
-
+
-            var (jetonsGrille, indicateurs) = grille;
+            var (jetonsGrille, indicateurs) = grille;
-
+
- 
+ 
-            Assert.Single(jetonsGrille);
+            Assert.Single(jetonsGrille);
-            Assert.Equal(4, jetonsGrille.First().Count());
+            Assert.Equal(4, jetonsGrille.First().Count());
-
+
-            Assert.Single(indicateurs);
+            Assert.Single(indicateurs);
-        }
+        }
-
+
-        [Fact]
+        /// <summary>
-        public void TestGrilleEstVide()
+        /// Test que la grille du plateau est vide.
-        {
+        /// </summary>
-            Plateau plateau = new Plateau(4, 12);
+        [Fact]
-            (IEnumerable<IEnumerable<Jeton>>, IEnumerable<IEnumerable<Indicateur>>) grille = plateau.Grille;
+        public void TestGrilleEstVide()
-
+        {
-            var (jetons, indicateurs) = grille;
+            Plateau plateau = new Plateau(4, 12);
-
+            (IEnumerable<IEnumerable<Jeton>>, IEnumerable<IEnumerable<Indicateur>>) grille = plateau.Grille;
-            Assert.Empty(jetons);
+
-            Assert.Empty(indicateurs);
+            var (jetons, indicateurs) = grille;
-        }
+
-
+            Assert.Empty(jetons);
-        [Fact]
+            Assert.Empty(indicateurs);
-        public void TestAjouterCode_GrilleComplete_ThrowsGrilleCompleteException()
+        }
-        {
+
-            Plateau plateau = new Plateau(4, 2);
+        /// <summary>
-            Code codeComplet1 = new Code(4);
+        /// Test l'exception GrilleCompleteException de Plateau.
-            Code codeComplet2 = new Code(4);
+        /// </summary>
-            Code codeComplet3 = new Code(4);
+        [Fact]
-            Jeton[] jetons = new Jeton[]
+        public void TestAjouterCode_GrilleComplete_ThrowsGrilleCompleteException()
-            {
+        {
-                new Jeton(Couleur.Rouge),
+            Plateau plateau = new Plateau(4, 2);
-                new Jeton(Couleur.Bleu),
+            Code codeComplet1 = new Code(4);
-                new Jeton(Couleur.Blanc),
+            Code codeComplet2 = new Code(4);
-                new Jeton(Couleur.Jaune)
+            Code codeComplet3 = new Code(4);
-            };
+            Jeton[] jetons = new Jeton[]
-            foreach (Jeton jeton in jetons)
+            {
-            {
+                new Jeton(Couleur.Rouge),
-                codeComplet1.AjouterJeton(jeton);
+                new Jeton(Couleur.Bleu),
-                codeComplet2.AjouterJeton(jeton);
+                new Jeton(Couleur.Blanc),
-                codeComplet3.AjouterJeton(jeton);
+                new Jeton(Couleur.Jaune)
-            }
+            };
-
+            foreach (Jeton jeton in jetons)
-            plateau.AjouterCode(codeComplet1);
+            {
-            plateau.AjouterCode(codeComplet2);
+                codeComplet1.AjouterJeton(jeton);
-
+                codeComplet2.AjouterJeton(jeton);
-            Assert.Throws<GrilleCompleteException>(() => plateau.AjouterCode(codeComplet3));
+                codeComplet3.AjouterJeton(jeton);
-        }
+            }
-
+
-
+            plateau.AjouterCode(codeComplet1);
-        [Fact]
+            plateau.AjouterCode(codeComplet2);
+
+            Assert.Throws<GrilleCompleteException>(() => plateau.AjouterCode(codeComplet3));
+        }
+
+        /// <summary>
+        /// Test l'événement QuandPlateauAjouterCode de Plateau.
+        /// </summary>
+        [Fact]
         public void TestPlateauEcoute()
         {
             Plateau plateau = new Plateau(4, 2);
@@ -193,10 +228,12 @@ namespace UnitTesting
             QuandPlateauAjouterCodeInfo?.Invoke(plateau, []);
 
             Assert.True(appel);
-        }
+        }
-
+
-
+        /// <summary>
-        [Fact]
+        /// Test la méthode AjouterCode de Plateau et vérifie tous les cas d'arrêts. 
+        /// </summary>
+        [Fact]
         public void TestAjouterCodeVictoire()
         {
             // Cas 1 : Victoire : false, code correct : false
@@ -266,6 +303,6 @@ namespace UnitTesting
             VictoireInfo4.SetValue(plateau4, true);
 
             plateau4.AjouterCode(code4);
-        }
+        }
-    }
+    }
-}
+}

Sources/UnitTesting/ReglesClassiquesUT.cs

@@ -3,8 +3,14 @@ using Xunit;
 
 namespace UnitTesting
 {
+    /// <summary>
+    /// Classe de test pour la classe ReglesClassiques.
+    /// </summary>
     public class ReglesClassiquesUT
     {
+        /// <summary>
+        /// Test les attributs de ReglesClassiques et vérifie qu'ils soient égaux.
+        /// </summary>
         [Fact]
         public void Test()
         {

Sources/UnitTesting/ReglesDifficilesUT.cs

@@ -3,8 +3,14 @@ using Xunit;
 
 namespace UnitTesting
 {
+    /// <summary>
+    /// Classe de test pour la classe ReglesDifficiles.
+    /// </summary>
     public class ReglesDifficilesUT
-    {
+    {
+        /// <summary>
+        /// Test les attributs de ReglesDifficiles et vérifie qu'ils soient égaux.
+        /// </summary>
         [Fact]
         public void Test()
         {