Sources/Model/Games/Game.cs

@@ -3,6 +3,7 @@ using Model.Dice.Faces;
 using Model.Players;
 using System;
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.Linq;
 using System.Numerics;
 using System.Text;
@@ -96,8 +97,17 @@ namespace Model.Games
                 player,
                 ThrowAll()
                 );
+            AddTurn(turn);
+        }
+
+
+        private void AddTurn(Turn turn)
+        {
+            if (!(turns.Contains(turn)))
+            {
                 turns.Add(turn);
             }
+        }
 
         /// <summary>
         /// finds and returns the player whose turn it is

Sources/Model/Games/Turn.cs

@@ -17,7 +17,7 @@ namespace Model.Games
     /// Two turns are equal if they are litterally the same instance in RAM
     /// (default behaviors Equals() and GetHashCode())
     /// </summary>
-    public class Turn
+    public sealed class Turn : IEquatable<Turn>
     {
 
         /// <summary>
@@ -115,5 +115,27 @@ namespace Model.Games
 
             return sb.ToString();
         }
+
+        public bool Equals(Turn other)
+        {
+            return Player.Equals(other.Player) 
+                && When.Equals(other.When) 
+                && DiceNFaces.SequenceEqual(other.DiceNFaces);
+
+        }
+
+        public override bool Equals(object obj)
+        {
+            if (obj is not Turn)
+            {
+                return false;
+            }
+            return Equals(obj as Turn);
+        }
+
+        public override int GetHashCode()
+        {
+            return HashCode.Combine(Player, When, DiceNFaces);
+        }
     }
 }

Sources/Tests/Model_UTs/GameTest.cs

@@ -149,9 +149,6 @@ namespace Tests.Model_UTs
 
             int n = 5;
 
-            IEnumerable<Player> players = game.GetPlayersFromGame();
-            Debug.WriteLine(players);
-
             Player currentPlayer;
             for (int i = 0; i < n; i++)
             {

Sources/Tests/Model_UTs/PlayerTest.cs

@@ -79,16 +79,6 @@ namespace Tests.Model_UTs
             Assert.Equal(expected, actual);
         }
 
-        class Point
-        {
-            public int X { get; set; }
-            public int Y { get; set; }
-            public Point(int x, int y)
-            {
-                X = x; Y = y;
-            }
-        }
-
         [Fact]
         public void TestEqualsFalseIfNotPlayer()
         {

Sources/Tests/Model_UTs/Point.cs

@@ -0,0 +1,19 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Tests.Model_UTs
+{
+    public class Point
+    {
+            public int X { get; private set; }
+            public int Y { get; private set; }
+            public Point(int x, int y)
+            {
+                X = x; Y = y;
+            }
+        
+    }
+}

Sources/Tests/Model_UTs/TurnTest.cs

@@ -13,7 +13,9 @@ namespace Tests.Model_UTs
     public class TurnTest
 
     {
-        private readonly Dictionary<AbstractDie<AbstractDieFace>, AbstractDieFace> DICE_N_FACES;
+        private readonly Dictionary<AbstractDie<AbstractDieFace>, AbstractDieFace> DICE_N_FACES_1;
+        private readonly Dictionary<AbstractDie<AbstractDieFace>, AbstractDieFace> DICE_N_FACES_2;
+
         private static readonly AbstractDieFace FACE_ONE = new NumberDieFace(1);
         private static readonly AbstractDieFace FACE_TWO = new NumberDieFace(12);
         private static readonly AbstractDieFace FACE_THREE = new ImageDieFace(54);
@@ -57,13 +59,19 @@ namespace Tests.Model_UTs
 
         public TurnTest()
         {
-            DICE_N_FACES = new()
+            DICE_N_FACES_1 = new()
             {
                 { NUM1, FACE_ONE },
                 { NUM2, FACE_TWO },
                 { IMG1, FACE_THREE },
                 { CLR1, FACE_FOUR }
             };
+            DICE_N_FACES_2 = new()
+            {
+                { NUM1, FACE_TWO },
+                { IMG1, FACE_THREE },
+                { CLR1, FACE_FOUR }
+            };
         }
 
 
@@ -77,7 +85,7 @@ namespace Tests.Model_UTs
             Assert.NotEqual(DateTimeKind.Utc, dateTime.Kind);
 
             // Act
-            Turn turn = Turn.CreateWithSpecifiedTime(dateTime, player, DICE_N_FACES);
+            Turn turn = Turn.CreateWithSpecifiedTime(dateTime, player, DICE_N_FACES_1);
 
             // Assert
             Assert.Equal(DateTimeKind.Utc, turn.When.Kind);
@@ -95,7 +103,7 @@ namespace Tests.Model_UTs
             Assert.Equal(DateTimeKind.Utc, dateTime.Kind);
 
             // Act
-            Turn turn = Turn.CreateWithSpecifiedTime(dateTime, player, DICE_N_FACES);
+            Turn turn = Turn.CreateWithSpecifiedTime(dateTime, player, DICE_N_FACES_1);
 
             // Assert
             Assert.Equal(DateTimeKind.Utc, turn.When.Kind);
@@ -110,7 +118,7 @@ namespace Tests.Model_UTs
             DateTime dateTime = new(year: 2018, month: 06, day: 15, hour: 16, minute: 30, second: 0, kind: DateTimeKind.Utc);
 
             // Act
-            void action() => Turn.CreateWithSpecifiedTime(dateTime, null, DICE_N_FACES);
+            void action() => Turn.CreateWithSpecifiedTime(dateTime, null, DICE_N_FACES_1);
 
             // Assert
             Assert.Throws<ArgumentNullException>(action);
@@ -137,10 +145,10 @@ namespace Tests.Model_UTs
             // Arrange
             DateTime dateTime = new(year: 2018, month: 06, day: 15, hour: 16, minute: 30, second: 0, kind: DateTimeKind.Utc);
             Player player = new("Chucky");
-            DICE_N_FACES.Clear();
+            DICE_N_FACES_1.Clear();
 
             // Act
-            void action() => Turn.CreateWithSpecifiedTime(dateTime, player, DICE_N_FACES);
+            void action() => Turn.CreateWithSpecifiedTime(dateTime, player, DICE_N_FACES_1);
 
             // Assert
             Assert.Throws<ArgumentException>(action);
@@ -155,7 +163,7 @@ namespace Tests.Model_UTs
             Player player = new("Chloe");
 
             // Act
-            Turn turn = Turn.CreateWithDefaultTime(player, DICE_N_FACES);
+            Turn turn = Turn.CreateWithDefaultTime(player, DICE_N_FACES_1);
 
             // Assert
             Assert.Equal(DateTimeKind.Utc, turn.When.Kind);
@@ -178,7 +186,7 @@ namespace Tests.Model_UTs
                 + FACE_THREE.ToString() + " "
                 + FACE_FOUR.ToString();
 
-            Turn turn = Turn.CreateWithSpecifiedTime(dateTime, player, DICE_N_FACES);
+            Turn turn = Turn.CreateWithSpecifiedTime(dateTime, player, DICE_N_FACES_1);
 
             // Act
             string actual = turn.ToString();
@@ -195,11 +203,120 @@ namespace Tests.Model_UTs
             Player player = new("Erika");
 
             // Act
-            Turn turn = Turn.CreateWithDefaultTime(player, DICE_N_FACES);
-            IEnumerable<KeyValuePair<AbstractDie<AbstractDieFace>, AbstractDieFace>> expected = DICE_N_FACES.AsEnumerable();
+            Turn turn = Turn.CreateWithDefaultTime(player, DICE_N_FACES_1);
+            IEnumerable<KeyValuePair<AbstractDie<AbstractDieFace>, AbstractDieFace>> expected = DICE_N_FACES_1.AsEnumerable();
 
             // Assert
             Assert.Equal(expected, turn.DiceNFaces);
         }
+
+        [Fact]
+        public void TestEqualsFalseIfNotTurn()
+        {
+            // Arrange
+            Point point;
+            Turn turn;
+            Player player = new("Freddie");
+
+            // Act
+            point = new(1, 2);
+            turn = Turn.CreateWithDefaultTime(player, DICE_N_FACES_1);
+
+            // Assert
+            Assert.False(point.Equals(turn));
+            Assert.False(point.GetHashCode().Equals(turn.GetHashCode()));
+            Assert.False(turn.Equals(point));
+            Assert.False(turn.GetHashCode().Equals(point.GetHashCode()));
+        }
+
+        [Fact]
+        public void TestGoesThruToSecondMethodIfObjIsTypeTurn()
+        {
+            // Arrange
+            Object t1;
+            Turn t2;
+            Player player1 = new Player("Marvin");
+            Player player2 = new Player("Noah");
+
+            // Act
+            t1 = Turn.CreateWithDefaultTime(player1, DICE_N_FACES_1);
+            t2 = Turn.CreateWithDefaultTime(player2, DICE_N_FACES_2);
+
+            // Assert
+            Assert.False(t1.Equals(t2));
+            Assert.False(t1.GetHashCode().Equals(t2.GetHashCode()));
+            Assert.False(t2.Equals(t1));
+            Assert.False(t2.GetHashCode().Equals(t1.GetHashCode()));
+        }
+
+
+        [Fact]
+        public void TestEqualsFalseIfNotSamePlayer()
+        {
+            // Arrange
+            Player player1= new("Panama");
+            Player player2= new("Clyde");
+
+            // Act
+            Turn t1 = Turn.CreateWithDefaultTime(player1, DICE_N_FACES_2);
+            Turn t2 = Turn.CreateWithDefaultTime(player2, DICE_N_FACES_2);
+
+            // Assert
+            Assert.False(t1.Equals(t2));
+            Assert.False(t1.GetHashCode().Equals(t2.GetHashCode()));
+            Assert.False(t2.Equals(t1));
+            Assert.False(t2.GetHashCode().Equals(t1.GetHashCode()));
+        }
+
+        [Fact]
+        public void TestEqualsFalseIfNotSameTime()
+        {
+            // Arrange
+            Player player = new("Oscar");
+
+            // Act
+            Turn t1 = Turn.CreateWithSpecifiedTime(new DateTime(1994, 07, 10), player, DICE_N_FACES_1);
+            Turn t2 = Turn.CreateWithSpecifiedTime(new DateTime(1991, 08, 20), player, DICE_N_FACES_1);
+
+            // Assert
+            Assert.False(t1.Equals(t2));
+            Assert.False(t1.GetHashCode().Equals(t2.GetHashCode()));
+            Assert.False(t2.Equals(t1));
+            Assert.False(t2.GetHashCode().Equals(t1.GetHashCode()));
+        }
+
+        [Fact]
+        public void TestEqualsFalseIfNotSameDiceNFaces()
+        {
+            // Arrange
+            Player player = new("Django");
+
+            // Act
+            Turn t1 = Turn.CreateWithDefaultTime(player, DICE_N_FACES_1);
+            Turn t2 = Turn.CreateWithDefaultTime(player, DICE_N_FACES_2);
+
+            // Assert
+            Assert.False(t1.Equals(t2));
+            Assert.False(t1.GetHashCode().Equals(t2.GetHashCode()));
+            Assert.False(t2.Equals(t1));
+            Assert.False(t2.GetHashCode().Equals(t1.GetHashCode()));
+        }
+
+        [Fact]
+        public void TestEqualsTrueIfExactlySameProperties()
+        {
+            // Arrange
+            Player player = new("Elyse");
+
+            // Act
+            Turn t1 = Turn.CreateWithSpecifiedTime(new DateTime(1990, 04, 29), player, DICE_N_FACES_1);
+            Turn t2 = Turn.CreateWithSpecifiedTime(new DateTime(1990, 04, 29), player, DICE_N_FACES_1);
+
+            // Assert
+            Assert.True(t1.Equals(t2));
+            Assert.True(t1.GetHashCode().Equals(t2.GetHashCode()));
+            Assert.True(t2.Equals(t1));
+            Assert.True(t2.GetHashCode().Equals(t1.GetHashCode()));
+        }
     }
 }