diff --git a/Sources/UnitTesting/CodeUT.cs b/Sources/UnitTesting/CodeUT.cs
index dd71ccb..c8078ca 100644
--- a/Sources/UnitTesting/CodeUT.cs
+++ b/Sources/UnitTesting/CodeUT.cs
@@ -1,4 +1,5 @@
 using CoreLibrary;
+using System.Linq;
 using Xunit;
 
 namespace UnitTesting
@@ -66,16 +67,141 @@ namespace UnitTesting
         [Fact]
         public void TestSupprimerDernierJetonInvalid()
         {
-            //Code code = new Code([]);
-            //Assert.Throws<CodeTableauLesJetonsVideException>(() => code.SupprimerDernierJeton());
-            Code code2 = new Code(4);
-            Assert.Throws<CodeTableauLesJetonsVideException>(() => code2.SupprimerDernierJeton());
+            Code code = new Code(4);
+            Assert.Throws<CodeTableauLesJetonsVideException>(() => code.SupprimerDernierJeton());
         }
 
         [Fact]
         public void TestRecupererJetonValid()
         {
+            Code code = new Code([new Jeton(Couleur.ROUGE), new Jeton(Couleur.BLEU), new Jeton(Couleur.BLANC)]);
+            Jeton jetonAttendu = new Jeton(Couleur.BLEU);
+            Jeton jeton = code.RecupererJeton(1);
+            Assert.Equal(jetonAttendu.Couleur, jeton.Couleur);
+        }
+
+        [Fact]
+        public void TestRecupererJetonInvalid()
+        {
+            Code code = new Code(4);
+            Assert.Throws<CodeIndiceHorsDePorteeException>(() => code.RecupererJeton(-1));
+            Assert.Throws<CodeIndiceHorsDePorteeException>(() => code.RecupererJeton(5));
+            Assert.Throws<CodeJetonNullException>(() => code.RecupererJeton(2));
+        }
+
+        [Fact]
+        public void TestJetonsValid()
+        {
+            Jeton[] jetonsAttendus = [new Jeton(Couleur.ROUGE), new Jeton(Couleur.BLEU), new Jeton(Couleur.BLEU)];
+            Code code = new Code(jetonsAttendus);
+            IEnumerable<Jeton?> lesJetons = code.Jetons();
+
+            Assert.Equal(jetonsAttendus.Length, lesJetons.Count());
+
+            int index = 0;
+            foreach (Jeton jetonAttendu in jetonsAttendus)
+            {
+                Assert.Equal(jetonAttendu.Couleur, lesJetons.ElementAt(index)?.Couleur);
+                index++;
+            }
+        }
+
+        [Fact]
+        public void TestEstCompletValid()
+        {
+            Code code = new Code([new Jeton(Couleur.ROUGE), new Jeton(Couleur.BLEU), new Jeton(Couleur.BLANC)]);
+            bool estComplet = code.EstComplet();
+            Assert.True(estComplet);
+        }
+
+        [Fact]
+        public void TestEstCompletInvalid()
+        {
+            Code code = new Code(3);
+            bool estComplet = code.EstComplet();
+            Assert.False(estComplet);
+        }
+
+        [Fact]
+        public void TestTailleMaximaleValid()
+        {
+            Jeton[] jetons = [new Jeton(Couleur.ROUGE), new Jeton(Couleur.BLEU), new Jeton(Couleur.BLEU)];
+            Code code = new Code(jetons);
+            int tailleMaximale = code.TailleMaximale();
+
+            Assert.Equal(jetons.Length, tailleMaximale);
+        }
+
+        [Fact]
+        public void TestComparerValid()
+        {
+            Code code = new Code([new Jeton(Couleur.ROUGE), new Jeton(Couleur.BLEU), new Jeton(Couleur.BLANC)]);
+            Code autreCode = new Code([new Jeton(Couleur.ROUGE), new Jeton(Couleur.BLEU), new Jeton(Couleur.BLANC)]);
+
+            IEnumerable<Indicateur> indicateurs = code.Comparer(autreCode);
+
+            Assert.Equal(3, indicateurs.Count());
+            Assert.Contains(Indicateur.BONNEPLACE, indicateurs);
+            Assert.DoesNotContain(Indicateur.BONNECOULEUR, indicateurs);
+        }
+
+        [Fact]
+        public void TestComparerGoodPlace()
+        {
+            Code code = new Code([new Jeton(Couleur.ROUGE), new Jeton(Couleur.BLEU), new Jeton(Couleur.BLANC)]);
+            Code autreCode = new Code([new Jeton(Couleur.ROUGE), new Jeton(Couleur.BLEU), new Jeton(Couleur.NOIR)]);
+
+            IEnumerable<Indicateur> indicateurs = code.Comparer(autreCode);
+
+            Assert.Equal(2, indicateurs.Count());
+            Assert.Contains(Indicateur.BONNEPLACE, indicateurs);
+            Assert.DoesNotContain(Indicateur.BONNECOULEUR, indicateurs);
+        }
+
+        [Fact]
+        public void TestComparerGoodColor()
+        {
+            Code code = new Code([new Jeton(Couleur.ROUGE), new Jeton(Couleur.BLEU), new Jeton(Couleur.BLANC)]);
+            Code autreCode = new Code([new Jeton(Couleur.BLEU), new Jeton(Couleur.ROUGE), new Jeton(Couleur.NOIR)]);
 
+            IEnumerable<Indicateur> indicateurs = code.Comparer(autreCode);
+
+            Assert.Equal(2, indicateurs.Count());
+            Assert.Contains(Indicateur.BONNECOULEUR, indicateurs);
+            Assert.DoesNotContain(Indicateur.BONNEPLACE, indicateurs);
+        }
+
+        [Fact]
+        public void TestComparerGoodPlaceAndColor()
+        {
+            Code code = new Code([new Jeton(Couleur.ROUGE), new Jeton(Couleur.BLEU), new Jeton(Couleur.BLANC)]);
+            Code autreCode = new Code([new Jeton(Couleur.ROUGE), new Jeton(Couleur.BLANC), new Jeton(Couleur.BLEU)]);
+
+            IEnumerable<Indicateur> indicateurs = code.Comparer(autreCode);
+
+            Assert.Equal(3, indicateurs.Count());
+            Assert.Contains(Indicateur.BONNEPLACE, indicateurs);
+            Assert.Contains(Indicateur.BONNECOULEUR, indicateurs);
+        }
+
+        [Fact]
+        public void TestComparerNoMatch()
+        {
+            Code code = new Code([new Jeton(Couleur.ROUGE), new Jeton(Couleur.BLEU), new Jeton(Couleur.BLANC)]);
+            Code autreCode = new Code([new Jeton(Couleur.VERT), new Jeton(Couleur.JAUNE), new Jeton(Couleur.NOIR)]);
+            IEnumerable<Indicateur> indicateurs = code.Comparer(autreCode);
+
+            Assert.Empty(indicateurs);
+        }
+
+        [Fact]
+        public void TestComparerInvalid()
+        {
+            Code code = new Code([new Jeton(Couleur.ROUGE), new Jeton(Couleur.BLEU), new Jeton(Couleur.BLANC)]);
+            Code autreCode = new Code(3);
+
+            Assert.Throws<CodeTableauLesJetonsIncompletException>(() => code.Comparer(autreCode));
         }
     }
+
 }
diff --git a/Sources/UnitTesting/JoueurUT.cs b/Sources/UnitTesting/JoueurUT.cs
index ea88b3e..d105743 100644
--- a/Sources/UnitTesting/JoueurUT.cs
+++ b/Sources/UnitTesting/JoueurUT.cs
@@ -1,13 +1,18 @@
 using CoreLibrary;
+using Xunit;
 
 namespace UnitTesting
 {
     public class JoueurUT
     {
-        //[Fact]
-        //public void TestConstructorWithValidArguments()
-        //{
-        //    Joueur joueur = new Joueur("MonJoueur", plateau);
-        //}
+        [Fact]
+        public void TestConstructorWithValidArguments()
+        {
+            Plateau plateau = new Plateau(4, 10);
+            Joueur joueur = new Joueur("MonJoueur", plateau);
+
+            Assert.Equal("MonJoueur", joueur.Nom);
+            Assert.Equal(plateau, joueur.Plateau);
+        }
     }
 }
diff --git a/Sources/UnitTesting/PlateauUT.cs b/Sources/UnitTesting/PlateauUT.cs
new file mode 100644
index 0000000..358a7f1
--- /dev/null
+++ b/Sources/UnitTesting/PlateauUT.cs
@@ -0,0 +1,129 @@
+using CoreLibrary;
+using System.Linq;
+using Xunit;
+
+namespace UnitTesting
+{
+    public class PlateauUT
+    {
+        [Fact]
+        public void TestConstructorValid()
+        {
+            Plateau plateau = new Plateau(4,12);
+            Assert.NotNull(plateau);
+            Assert.Equal(1, plateau.Tour);
+            Assert.False(plateau.Victoire);
+        }
+
+        [Fact]
+        public void TestConstructorInvalid()
+        {
+            Assert.Throws<PlateauTailleCodeException>(() => new Plateau(0, 10));
+        }
+
+        [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 TestAjouterCodeValid()
+        {
+            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 TestAjouterCodeIncorrectSize()
+        {
+            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<PlateauTailleCodeException>(() => plateau.AjouterCode(code));
+        }
+
+        [Fact]
+        public void TestAjouterCodeIncomplete()
+        {
+            Plateau plateau = new Plateau(4, 10);
+            Code code = new Code(4);
+
+            Assert.Throws<PlateauCodeIncompletException>(() => plateau.AjouterCode(code));
+        }
+
+        [Fact]
+        public void TestEstBonCodeTrue()
+        {
+            
+        }
+
+        [Fact]
+        public void TestEstBonCodeFalse()
+        {
+            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.False(plateau.EstBonCode(code));
+        }
+
+        [Fact]
+        public void TestGrilleValid()
+        {
+            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 TestGrilleEmpty()
+        {
+            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));
+            }
+        }
+
+    }
+}
diff --git a/Sources/UnitTesting/ReglesClassiquesUT.cs b/Sources/UnitTesting/ReglesClassiquesUT.cs
new file mode 100644
index 0000000..3566577
--- /dev/null
+++ b/Sources/UnitTesting/ReglesClassiquesUT.cs
@@ -0,0 +1,118 @@
+using CoreLibrary;
+using Xunit;
+
+namespace UnitTesting
+{
+    public class ReglesClassiquesUT
+    {
+        [Fact]
+        public void TestConstructor()
+        {
+            ReglesClassiques regles = new ReglesClassiques();
+
+            Assert.NotNull(regles);
+            //Assert.Equal(2, 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 TestJoueurCourantWithPlayer()
+        {
+            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 TestJoueurCourantNoPlayer()
+        {
+            ReglesClassiques regles = new ReglesClassiques();
+            Assert.Throws<ReglesClassiquesJoueurCourantNull>(() => regles.JoueurCourant());
+        }
+
+        [Fact]
+        public void TestPasserLaMainValid()
+        {
+            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 TestPasserLaMainInvalid()
+        {
+            ReglesClassiques regles = new ReglesClassiques();
+            Assert.Throws<ReglesClassiquesJoueurCourantNull>(() => 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 TestEstTermineeTrue()
+        {
+            //
+        }
+
+        [Fact]
+        public void TestEstTermineeFalse()
+        {
+            ReglesClassiques regles = new ReglesClassiques();
+            regles.AjouterJoueur("joueur1");
+            regles.AjouterJoueur("joueur2");
+            regles.CommencerLaPartie();
+
+            bool estTerminee = regles.EstTerminee();
+
+            Assert.False(estTerminee);
+        }
+
+        //Test Gagnants et Perdants + TestEstTermineeTrue + TestConstructor PB
+
+    }
+}