diff --git a/Sources/UnitTesting/CodeUT.cs b/Sources/UnitTesting/CodeUT.cs
index c5612b4..59c53c3 100644
--- a/Sources/UnitTesting/CodeUT.cs
+++ b/Sources/UnitTesting/CodeUT.cs
@@ -1,220 +1,252 @@
-using CoreLibrary.Core;
-using CoreLibrary.Exceptions;
-using System.Collections.ObjectModel;
-using Xunit;
-
-namespace UnitTesting
-{
-    public class CodeUT
-    {
-        [Fact]
-        public void TestPremierConstructeurValide()
-        {
-            Code code = new Code(4);
-            Assert.NotNull(code);
-            Assert.Empty(code.Jetons);
-            Assert.Equal(0, code.Taille);
-            Assert.False(code.Complet);
-            Assert.True(code.Vide);
-        }
-
-        [Fact]
-        public void TestPremierConstructeurInvalide()
-        {
-            Assert.Throws<TailleCodeException>(() => new Code(-1));
-        }
-
-        [Fact]
-        public void TestAjouterJetonValide()
-        {
-            Jeton jeton = new Jeton(Couleur.Jaune);
-            Code code = new Code(3);
-            code.AjouterJeton(jeton);
-            Assert.Equal(1, code.Taille);
-            Assert.Equal(jeton, code.Jetons.ElementAt(0));
-        }
-
-        [Fact]
-        public void TestAjouterJetonInvalide()
-        {
-            Jeton jeton = new Jeton(Couleur.Jaune);
-            Code code = new Code(3);
-            code.AjouterJeton(jeton);
-            code.AjouterJeton(jeton);
-            code.AjouterJeton(jeton);
-            Assert.Throws<CodeCompletException>(() => code.AjouterJeton(new Jeton(Couleur.Rouge)));
-        }
-
-        [Fact]
-        public void TestSupprimerDernierJetonValide()
-        {
-            Jeton jeton = new Jeton(Couleur.Rouge);
-            Code code = new Code(3);
-            code.AjouterJeton(jeton);
-            code.AjouterJeton(jeton);
-            code.AjouterJeton(jeton);
-            code.SupprimerDernierJeton();
-            Assert.Equal(2, code.Taille);
-        }
-
-        [Fact]
-        public void TestSupprimerDernierJetonInvalide()
-        {
-            Code code = new Code(4);
-            Assert.Throws<CodeVideException>(() => code.SupprimerDernierJeton());
-        }
-
-        [Fact]
-        public void TestRecupererJetonValide()
-        {
-            Jeton jeton1 = new Jeton(Couleur.Rouge);
-            Jeton jeton2 = new Jeton(Couleur.Bleu);
-            Code code = new Code(3);
-            code.AjouterJeton(jeton1);
-            code.AjouterJeton(jeton2);
-            Jeton jetonAttendu = new Jeton(Couleur.Bleu);
-            Jeton jeton = code.RecupererJeton(1);
-            Assert.Equal(jetonAttendu.Couleur, jeton.Couleur);
-        }
-
-        [Fact]
-        public void TestRecupererJetonInvalide()
-        {
-            Code code = new Code(4);
-            Assert.Throws<IndiceCodeException>(() => code.RecupererJeton(-1));
-            Assert.Throws<IndiceCodeException>(() => code.RecupererJeton(4));
-        }
-
-        [Fact]
-        public void TestRecupererJetonNull()
-        {
-            Code code = new Code(4);
-            Assert.Throws<IndiceCodeException>(() => code.RecupererJeton(1));
-        }
-
-        [Fact]
-        public void TestJetonsValide()
-        {
-            Jeton[] jetonsAttendus = [new Jeton(Couleur.Rouge), new Jeton(Couleur.Bleu), new Jeton(Couleur.Bleu)];
-            Code code = new Code(3);
-            code.AjouterJeton(jetonsAttendus[0]);
-            code.AjouterJeton(jetonsAttendus[1]);
-            code.AjouterJeton(jetonsAttendus[2]);
-            ObservableCollection<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 TestEstCompletValide()
-        {
-            Jeton[] jetons = [new Jeton(Couleur.Rouge), new Jeton(Couleur.Bleu), new Jeton(Couleur.Blanc)];
-            Code code = new Code(3);
-            code.AjouterJeton(jetons[0]);
-            code.AjouterJeton(jetons[1]);
-            code.AjouterJeton(jetons[2]);
-            bool estComplet = code.Complet;
-            Assert.True(estComplet);
-        }
-
-        [Fact]
-        public void TestEstCompletInvalide()
-        {
-            Code code = new Code(3);
-            bool estComplet = code.Complet;
-            Assert.False(estComplet);
-        }
-
-        [Fact]
-        public void TestTailleMaximaleValide()
-        {
-            Jeton[] jetons = [new Jeton(Couleur.Rouge), new Jeton(Couleur.Bleu), new Jeton(Couleur.Bleu)];
-            Code code = new Code(3);
-            code.AjouterJeton(jetons[0]);
-            code.AjouterJeton(jetons[1]);
-            code.AjouterJeton(jetons[2]);
-            int tailleMaximale = code.TailleMax;
-
-            Assert.Equal(jetons.Length, tailleMaximale);
-        }
-
-        [Fact]
-        public void TestComparerValide()
-        {
-            Jeton[] jetons1 = [new Jeton(Couleur.Rouge), new Jeton(Couleur.Bleu), new Jeton(Couleur.Blanc)];
-            Code code1 = new Code(3);
-            code1.AjouterJeton(jetons1[0]);
-            code1.AjouterJeton(jetons1[1]);
-            code1.AjouterJeton(jetons1[2]);
-
-            Jeton[] jetons2 = [new Jeton(Couleur.Rouge), new Jeton(Couleur.Bleu), new Jeton(Couleur.Blanc)];
-            Code code2 = new Code(3);
-            code2.AjouterJeton(jetons2[0]);
-            code2.AjouterJeton(jetons2[1]);
-            code2.AjouterJeton(jetons2[2]);
-
-            IReadOnlyList<Indicateur> indicateurs = code1.Comparer(code2);
-
-            Assert.Equal(3, indicateurs.Count());
-        }
-
-        [Fact]
-        public void TestComparerDifferent()
-        {
-            Jeton[] jetons1 = [new Jeton(Couleur.Noir), new Jeton(Couleur.Jaune), new Jeton(Couleur.Vert)];
-            Code code1 = new Code(3);
-            code1.AjouterJeton(jetons1[0]);
-            code1.AjouterJeton(jetons1[1]);
-            code1.AjouterJeton(jetons1[2]);
-
-            Jeton[] jetons2 = [new Jeton(Couleur.Rouge), new Jeton(Couleur.Bleu), new Jeton(Couleur.Blanc)];
-            Code code2 = new Code(3);
-            code2.AjouterJeton(jetons2[0]);
-            code2.AjouterJeton(jetons2[1]);
-            code2.AjouterJeton(jetons2[2]);
-
-            IReadOnlyList<Indicateur> indicateurs = code1.Comparer(code2);
-
-            Assert.Empty(indicateurs);
-        }
-
-        [Fact]
-        public void TestComparerMonCodeIncomplet()
-        {
-            Code code1 = new Code(3);
-
-            Jeton[] jetons2 = [new Jeton(Couleur.Rouge), new Jeton(Couleur.Bleu), new Jeton(Couleur.Blanc)];
-            Code code2 = new Code(3);
-            code2.AjouterJeton(jetons2[0]);
-            code2.AjouterJeton(jetons2[1]);
-            code2.AjouterJeton(jetons2[2]);
-
-            IEnumerable<Indicateur> indicateurs = code1.Comparer(code2);
-
-            Assert.Empty(indicateurs);
-        }
-
-        [Fact]
-        public void TestComparerSonCodeIncomplet()
-        {
-            Jeton[] jetons1 = [new Jeton(Couleur.Noir), new Jeton(Couleur.Jaune), new Jeton(Couleur.Vert)];
-            Code code1 = new Code(3);
-            code1.AjouterJeton(jetons1[0]);
-            code1.AjouterJeton(jetons1[1]);
+using CoreLibrary.Core;
+using CoreLibrary.Exceptions;
+using System.Collections.ObjectModel;
+using Xunit;
+
+namespace UnitTesting
+{
+    public class CodeUT
+    {
+        [Fact]
+        public void TestPremierConstructeurValide()
+        {
+            Code code = new Code(4);
+            Assert.NotNull(code);
+            Assert.Empty(code.Jetons);
+            Assert.Equal(0, code.Taille);
+            Assert.False(code.Complet);
+            Assert.True(code.Vide);
+        }
+
+        [Fact]
+        public void TestPremierConstructeurInvalide()
+        {
+            Assert.Throws<TailleCodeException>(() => new Code(-1));
+        }
+
+        [Fact]
+        public void TestAjouterJetonValide()
+        {
+            Jeton jeton = new Jeton(Couleur.Jaune);
+            Code code = new Code(3);
+            code.AjouterJeton(jeton);
+            Assert.Equal(1, code.Taille);
+            Assert.Equal(jeton, code.Jetons.ElementAt(0));
+        }
+
+        [Fact]
+        public void TestAjouterJetonInvalide()
+        {
+            Jeton jeton = new Jeton(Couleur.Jaune);
+            Code code = new Code(3);
+            code.AjouterJeton(jeton);
+            code.AjouterJeton(jeton);
+            code.AjouterJeton(jeton);
+            Assert.Throws<CodeCompletException>(() => code.AjouterJeton(new Jeton(Couleur.Rouge)));
+        }
+
+        [Fact]
+        public void TestSupprimerDernierJetonValide()
+        {
+            Jeton jeton = new Jeton(Couleur.Rouge);
+            Code code = new Code(3);
+            code.AjouterJeton(jeton);
+            code.AjouterJeton(jeton);
+            code.AjouterJeton(jeton);
+            code.SupprimerDernierJeton();
+            Assert.Equal(2, code.Taille);
+        }
+
+        [Fact]
+        public void TestSupprimerDernierJetonInvalide()
+        {
+            Code code = new Code(4);
+            Assert.Throws<CodeVideException>(() => code.SupprimerDernierJeton());
+        }
+
+        [Fact]
+        public void TestRecupererJetonValide()
+        {
+            Jeton jeton1 = new Jeton(Couleur.Rouge);
+            Jeton jeton2 = new Jeton(Couleur.Bleu);
+            Code code = new Code(3);
+            code.AjouterJeton(jeton1);
+            code.AjouterJeton(jeton2);
+            Jeton jetonAttendu = new Jeton(Couleur.Bleu);
+            Jeton jeton = code.RecupererJeton(1);
+            Assert.Equal(jetonAttendu.Couleur, jeton.Couleur);
+        }
+
+        [Fact]
+        public void TestRecupererJetonInvalide()
+        {
+            Code code = new Code(4);
+            Assert.Throws<IndiceCodeException>(() => code.RecupererJeton(-1));
+            Assert.Throws<IndiceCodeException>(() => code.RecupererJeton(4));
+        }
+
+        [Fact]
+        public void TestRecupererJetonNull()
+        {
+            Code code = new Code(4);
+            Assert.Throws<IndiceCodeException>(() => code.RecupererJeton(1));
+        }
+
+        [Fact]
+        public void TestJetonsValide()
+        {
+            Jeton[] jetonsAttendus = [new Jeton(Couleur.Rouge), new Jeton(Couleur.Bleu), new Jeton(Couleur.Bleu)];
+            Code code = new Code(3);
+            code.AjouterJeton(jetonsAttendus[0]);
+            code.AjouterJeton(jetonsAttendus[1]);
+            code.AjouterJeton(jetonsAttendus[2]);
+            ObservableCollection<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 TestEstCompletValide()
+        {
+            Jeton[] jetons = [new Jeton(Couleur.Rouge), new Jeton(Couleur.Bleu), new Jeton(Couleur.Blanc)];
+            Code code = new Code(3);
+            code.AjouterJeton(jetons[0]);
+            code.AjouterJeton(jetons[1]);
+            code.AjouterJeton(jetons[2]);
+            bool estComplet = code.Complet;
+            Assert.True(estComplet);
+        }
+
+        [Fact]
+        public void TestEstCompletInvalide()
+        {
+            Code code = new Code(3);
+            bool estComplet = code.Complet;
+            Assert.False(estComplet);
+        }
+
+        [Fact]
+        public void TestTailleMaximaleValide()
+        {
+            Jeton[] jetons = [new Jeton(Couleur.Rouge), new Jeton(Couleur.Bleu), new Jeton(Couleur.Bleu)];
+            Code code = new Code(3);
+            code.AjouterJeton(jetons[0]);
+            code.AjouterJeton(jetons[1]);
+            code.AjouterJeton(jetons[2]);
+            int tailleMaximale = code.TailleMax;
+
+            Assert.Equal(jetons.Length, tailleMaximale);
+        }
+
+        [Fact]
+        public void TestComparerValide()
+        {
+            Jeton[] jetons1 = [new Jeton(Couleur.Rouge), new Jeton(Couleur.Bleu), new Jeton(Couleur.Blanc)];
+            Code code1 = new Code(3);
+            code1.AjouterJeton(jetons1[0]);
+            code1.AjouterJeton(jetons1[1]);
+            code1.AjouterJeton(jetons1[2]);
+
+            Jeton[] jetons2 = [new Jeton(Couleur.Rouge), new Jeton(Couleur.Bleu), new Jeton(Couleur.Blanc)];
+            Code code2 = new Code(3);
+            code2.AjouterJeton(jetons2[0]);
+            code2.AjouterJeton(jetons2[1]);
+            code2.AjouterJeton(jetons2[2]);
+
+            IReadOnlyList<Indicateur> indicateurs = code1.Comparer(code2);
+
+            Assert.Equal(3, indicateurs.Count());
+        }
+
+        [Fact]
+        public void TestComparerDifferent()
+        {
+            Jeton[] jetons1 = [new Jeton(Couleur.Noir), new Jeton(Couleur.Jaune), new Jeton(Couleur.Vert)];
+            Code code1 = new Code(3);
+            code1.AjouterJeton(jetons1[0]);
+            code1.AjouterJeton(jetons1[1]);
+            code1.AjouterJeton(jetons1[2]);
+
+            Jeton[] jetons2 = [new Jeton(Couleur.Rouge), new Jeton(Couleur.Bleu), new Jeton(Couleur.Blanc)];
+            Code code2 = new Code(3);
+            code2.AjouterJeton(jetons2[0]);
+            code2.AjouterJeton(jetons2[1]);
+            code2.AjouterJeton(jetons2[2]);
+
+            IReadOnlyList<Indicateur> indicateurs = code1.Comparer(code2);
+
+            Assert.Empty(indicateurs);
+        }
+
+        [Fact]
+        public void TestComparerMonCodeIncomplet()
+        {
+            Code code1 = new Code(3);
+
+            Jeton[] jetons2 = [new Jeton(Couleur.Rouge), new Jeton(Couleur.Bleu), new Jeton(Couleur.Blanc)];
+            Code code2 = new Code(3);
+            code2.AjouterJeton(jetons2[0]);
+            code2.AjouterJeton(jetons2[1]);
+            code2.AjouterJeton(jetons2[2]);
+
+            IEnumerable<Indicateur> indicateurs = code1.Comparer(code2);
+
+            Assert.Empty(indicateurs);
+        }
+
+        [Fact]
+        public void TestComparerSonCodeIncomplet()
+        {
+            Jeton[] jetons1 = [new Jeton(Couleur.Noir), new Jeton(Couleur.Jaune), new Jeton(Couleur.Vert)];
+            Code code1 = new Code(3);
+            code1.AjouterJeton(jetons1[0]);
+            code1.AjouterJeton(jetons1[1]);
             code1.AjouterJeton(jetons1[2]);
 
-            Code code2 = new Code(3);
-
-            Assert.Throws<CodeIncompletException>(() => code1.Comparer(code2));
-        }
-
-    }
-
-}
+            Code code2 = new Code(3);
+
+            Assert.Throws<CodeIncompletException>(() => code1.Comparer(code2));
+        }
+
+        [Fact]
+        public void TestToString()
+        {
+            Code code = new Code(4);
+
+            Assert.Equal("Code(0)", code.ToString());
+
+            code.AjouterJeton(new Jeton());
+
+            Assert.Equal("Code(1)", code.ToString());
+        }
+
+        [Fact]
+        public void TestComparerCodeInvalide()
+        {
+            Code code = new Code(1);
+            code.AjouterJeton(new Jeton());
+            Code code1 = new Code(2);
+            code1.AjouterJeton(new Jeton());
+            code1.AjouterJeton(new Jeton());
+
+            Assert.Throws<CodeInvalideException>(() => code.Comparer(code1));
+        }
+
+        [Fact]
+        public void TestComparerCodeCorrect()
+        {
+            Code code = new Code(1);
+            code.AjouterJeton(new Jeton());
+            
+            code.Comparer(code);
+        }
+    }
+
+}