🚚 Organize UTs in folders

Sources/Tests/Data_UTs/Players/PlayerEntityTest.cs

@@ -6,8 +6,9 @@ using System.Text;
 using System.Threading.Tasks;
 using Xunit;
 using Data.EF.Players;
+using Tests.Model_UTs;
 
-namespace Tests.Model_UTs
+namespace Tests.Data_UTs.Players
 {
     public class PlayerEntityTest
     {
@@ -91,7 +92,7 @@ namespace Tests.Model_UTs
         public void TestGoesThruToSecondMethodIfObjIsTypePlayerEntity()
         {
             // Arrange
-            Object p1;
+            object p1;
             PlayerEntity p2;
 
             // Act

Sources/Tests/Data_UTs/Players/PlayerExtensionsTest.cs

@@ -7,7 +7,7 @@ using System.Text;
 using System.Threading.Tasks;
 using Xunit;
 
-namespace Tests.Model_UTs
+namespace Tests.Data_UTs.Players
 {
     public class PlayerExtensionsTest
     {

Sources/Tests/Model_UTs/Games/GameRunnerTest.cs

@@ -1,307 +1,307 @@
-using Model;
-using Model.Dice;
-using Model.Dice.Faces;
-using Model.Games;
-using Model.Players;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using Xunit;
-using Data;
-
-namespace Tests.Model_UTs
-{
-    public class GameRunnerTest
-    {
-        private readonly GameRunner stubGameRunner = new Stub().LoadApp();
-
-        [Fact]
-        public void TestConstructorWhenNoGamesThenNewIEnumerable()
-        {
-            // Arrange
-            GameRunner gameRunner = new(new PlayerManager(), new DieManager());
-            IEnumerable<Game> expected;
-            IEnumerable<Game> actual;
-
-            // Act
-            expected = new List<Game>().AsEnumerable();
-            actual = gameRunner.GetAll();
-
-            // Assert
-            Assert.Equal(expected, actual);
-        }
-
-        [Fact]
-        public void TestConstructorWhenGamesThenGamesIEnumerable()
-        {
-            // Arrange
-            GameRunner gameRunner = new(new PlayerManager(), new DieManager(), stubGameRunner.GetAll().ToList());
-            IEnumerable<Game> expected;
-            IEnumerable<Game> actual;
-
-            // Act
-            expected = stubGameRunner.GetAll();
-            actual = gameRunner.GetAll();
-
-            // Assert
-            Assert.Equal(expected, actual);
-        }
-
-        [Fact]
-        public void TestAddWhenGamesThenDoAddAndReturnGames()
-        {
-            // Arrange
-            GameRunner gameRunner = new(new PlayerManager(), new DieManager());
-            Game game1 = stubGameRunner.GetAll().First();
-            Game game2 = stubGameRunner.GetAll().Last();
-
-            // Act
-            IEnumerable<Game> expected = new List<Game>() { game1, game2 }.AsEnumerable();
-            IEnumerable<Game> actual = new List<Game>()
-            {
-                gameRunner.Add(game1),
-                gameRunner.Add(game2)
-            };
-
-            // Assert
-            Assert.Equal(expected, actual);
-        }
-
-        [Fact]
-        public void TestAddWhenNullThenThrowsException()
-        {
-            // Arrange
-            GameRunner gameRunner = stubGameRunner;
-
-            // Act
-            void action() => gameRunner.Add(null);// Add() returns the added element if succesful
-
-            // Assert
-            Assert.Throws<ArgumentNullException>(action);
-            Assert.DoesNotContain(null, stubGameRunner.GetAll());
-        }
-
-        [Theory]
-        [InlineData("")]
-        [InlineData(null)]
-        [InlineData(" ")]
-        public void TestGetOneByNameWhenInvalidThenThrowsException(string name)
-        {
-            // Arrange
-            GameRunner gameRunner = stubGameRunner;
-
-            // Act
-            void action() => gameRunner.GetOneByName(name);
-
-            // Assert
-            Assert.Throws<ArgumentException>(action);
-        }
-
-        [Fact]
-        public void TestGetOneByNameWhenValidButNotExistThenReturnNull()
-        {
-            // Arrange
-            GameRunner gameRunner = stubGameRunner;
-
-            // Act
-            Game result = gameRunner.GetOneByName("thereisbasicallynowaythatthisgamenamealreadyexists");
-
-            // Assert
-            Assert.Null(result);
-        }
-
-        [Fact]
-        public void TestGetOneByNameWhenValidThenReturnGame()
-        {
-            // Arrange
-            GameRunner gameRunner = new(new PlayerManager(), new DieManager());
-            Game game = stubGameRunner.GetAll().First();
-
-            // Act
-            Game actual = gameRunner.Add(game);
-            Game expected = game;
-
-            // Assert
-            Assert.Equal(expected, actual);
-        }
-
-        [Fact]
-        public void TestWhenRemoveExistsThenSucceeds()
-        {
-            // Arrange
-            GameRunner gameRunner = stubGameRunner;
-            Game game = new("blargh", new PlayerManager(), gameRunner.GetAll().First().Dice);
-            gameRunner.Add(game);
-
-            // Act
-            gameRunner.Remove(game);
-
-            // Assert
-            Assert.DoesNotContain(game, gameRunner.GetAll());
-        }
-
-        [Fact]
-        public void TestRemoveWhenGivenNullThenThrowsException()
-        {
-            // Arrange
-            GameRunner gameRunner = stubGameRunner;
-
-            // Act
-            void action() => gameRunner.Remove(null);
-
-            // Assert
-            Assert.Throws<ArgumentNullException>(action);
-        }
-
-        [Fact]
-        public void TestRemoveWhenGiveenNonExistentThenFailsSilently()
-        {
-            // Arrange
-            GameRunner gameRunner = stubGameRunner;
-            Game notGame = new("blargh", new PlayerManager(), gameRunner.GetAll().First().Dice);
-            IEnumerable<Game> expected = gameRunner.GetAll();
-
-            // Act
-            gameRunner.Remove(notGame);
-            IEnumerable<Game> actual = gameRunner.GetAll();
-
-            // Assert
-            Assert.Equal(actual, expected);
-        }
-
-        [Fact]
-        public void TestUpdateWhenValidThenSucceeds()
-        {
-            // Arrange
-            string oldName = "blargh";
-            string newName = "blargh2.0";
-            GameRunner gameRunner = new(new PlayerManager(), new DieManager());
-            Game game = new(oldName, new PlayerManager(), stubGameRunner.GetAll().First().Dice);
-            game.PlayerManager.Add(new("Alice"));
-            gameRunner.Add(game);
-
-            Game oldGame = gameRunner.GetAll().First();
-            Game newGame = new(newName, oldGame.PlayerManager, oldGame.Dice);
-
-            // Act
-            int oldSize = gameRunner.GetAll().Count();
-            gameRunner.Update(oldGame, newGame);
-            int newSize = gameRunner.GetAll().Count();
-
-            // Assert
-            Assert.NotEqual(oldName, newName);
-            Assert.DoesNotContain(oldGame, gameRunner.GetAll());
-            Assert.Contains(newGame, gameRunner.GetAll());
-            Assert.Equal(oldSize, newSize);
-        }
-
-        [Theory]
-        [InlineData("")]
-        [InlineData(" ")]
-        [InlineData(null)]
-        public void TestUpdateWhenValidBeforeAndInvalidAfterThenDoesNotGo(string badName)
-        {
-            // Arrange
-            GameRunner gameRunner = stubGameRunner;
-            int expectedSize = gameRunner.GetAll().Count();
-            Game oldGame = gameRunner.GetAll().First();
-
-            // Act
-            void action() => gameRunner.Update(oldGame, new(badName, oldGame.PlayerManager, oldGame.Dice));
-            int actualSize = gameRunner.GetAll().Count();
-
-            // Assert
-            Assert.Throws<ArgumentException>(action); // thrown by constructor
-            Assert.Contains(oldGame, gameRunner.GetAll()); // still there
-            Assert.True(expectedSize == actualSize);
-        }
-
-        [Fact]
-        public void TestUpdateWhenValidBeforeAndNullAfterThenDoesNotGo()
-        {
-            // Arrange
-            GameRunner gameRunner = stubGameRunner;
-            int expectedSize = gameRunner.GetAll().Count();
-            Game oldGame = gameRunner.GetAll().First();
-
-            // Act
-            void action() => gameRunner.Update(oldGame, null);
-            int actualSize = gameRunner.GetAll().Count();
-
-            // Assert
-            Assert.Throws<ArgumentNullException>(action); // thrown by constructor
-            Assert.Contains(oldGame, gameRunner.GetAll()); // still there
-            Assert.True(expectedSize == actualSize);
-        }
-
-        [Fact]
-        public void TestUpdateDoesNotGoWithValidAfterAndNullBefore()
-        {
-            // Arrange
-            GameRunner gameRunner = stubGameRunner;
-            int expectedSize = gameRunner.GetAll().Count();
-            Game oldGame = gameRunner.GetAll().First();
-
-            // Act
-            void action() => gameRunner.Update(null, new("newgamename", oldGame.PlayerManager, oldGame.Dice));
-            int actualSize = gameRunner.GetAll().Count();
-
-            // Assert
-            Assert.Throws<ArgumentNullException>(action); // thrown by constructor
-            Assert.Contains(oldGame, gameRunner.GetAll()); // still there
-            Assert.True(expectedSize == actualSize);
-        }
-
-        [Theory]
-        [InlineData("")]
-        [InlineData(" ")]
-        [InlineData(null)]
-        public void TestUpdateWhenInvalidBeforeAndValidAfterThenDoesNotGo(string badName)
-        {
-            // Arrange
-            GameRunner gameRunner = stubGameRunner;
-            int expectedSize = gameRunner.GetAll().Count();
-            Game oldGame = gameRunner.GetAll().First();
-
-            // Act
-            void action() => gameRunner.Update(new(badName, oldGame.PlayerManager, oldGame.Dice), new("valid", oldGame.PlayerManager, oldGame.Dice));
-            int actualSize = gameRunner.GetAll().Count();
-
-            // Assert
-            Assert.Throws<ArgumentException>(action); // thrown by constructor
-            Assert.Contains(oldGame, gameRunner.GetAll()); // still there
-            Assert.True(expectedSize == actualSize);
-        }
-
-        [Fact]
-        public void TestPlayGameWhenPlayThenAddNewTurnToHistory()
-        {
-            // Arrange
-            GameRunner gameRunner = stubGameRunner;
-            Game game = gameRunner.GetAll().First();
-
-            // Act
-            int turnsBefore = game.GetHistory().Count();
-            GameRunner.PlayGame(game);
-            int turnsAfter = game.GetHistory().Count();
-
-            // Assert
-            Assert.Equal(turnsBefore + 1, turnsAfter);
-        }
-
-        [Fact]
-        public void TestStartNewGame()
-        {
-            // Arrange
-            GameRunner gameRunner = stubGameRunner;
-            string name = "blargh";
-
-            // Act
-            Assert.DoesNotContain(gameRunner.GetOneByName(name), gameRunner.GetAll());
-            gameRunner.StartNewGame(name, new PlayerManager(), stubGameRunner.GetAll().First().Dice);
-
-            // Assert
-            Assert.Contains(gameRunner.GetOneByName(name), gameRunner.GetAll());
-        }
-    }
-}
+using Model;
+using Model.Dice;
+using Model.Dice.Faces;
+using Model.Games;
+using Model.Players;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Xunit;
+using Data;
+
+namespace Tests.Model_UTs.Games
+{
+    public class GameRunnerTest
+    {
+        private readonly GameRunner stubGameRunner = new Stub().LoadApp();
+
+        [Fact]
+        public void TestConstructorWhenNoGamesThenNewIEnumerable()
+        {
+            // Arrange
+            GameRunner gameRunner = new(new PlayerManager(), new DieManager());
+            IEnumerable<Game> expected;
+            IEnumerable<Game> actual;
+
+            // Act
+            expected = new List<Game>().AsEnumerable();
+            actual = gameRunner.GetAll();
+
+            // Assert
+            Assert.Equal(expected, actual);
+        }
+
+        [Fact]
+        public void TestConstructorWhenGamesThenGamesIEnumerable()
+        {
+            // Arrange
+            GameRunner gameRunner = new(new PlayerManager(), new DieManager(), stubGameRunner.GetAll().ToList());
+            IEnumerable<Game> expected;
+            IEnumerable<Game> actual;
+
+            // Act
+            expected = stubGameRunner.GetAll();
+            actual = gameRunner.GetAll();
+
+            // Assert
+            Assert.Equal(expected, actual);
+        }
+
+        [Fact]
+        public void TestAddWhenGamesThenDoAddAndReturnGames()
+        {
+            // Arrange
+            GameRunner gameRunner = new(new PlayerManager(), new DieManager());
+            Game game1 = stubGameRunner.GetAll().First();
+            Game game2 = stubGameRunner.GetAll().Last();
+
+            // Act
+            IEnumerable<Game> expected = new List<Game>() { game1, game2 }.AsEnumerable();
+            IEnumerable<Game> actual = new List<Game>()
+            {
+                gameRunner.Add(game1),
+                gameRunner.Add(game2)
+            };
+
+            // Assert
+            Assert.Equal(expected, actual);
+        }
+
+        [Fact]
+        public void TestAddWhenNullThenThrowsException()
+        {
+            // Arrange
+            GameRunner gameRunner = stubGameRunner;
+
+            // Act
+            void action() => gameRunner.Add(null);// Add() returns the added element if succesful
+
+            // Assert
+            Assert.Throws<ArgumentNullException>(action);
+            Assert.DoesNotContain(null, stubGameRunner.GetAll());
+        }
+
+        [Theory]
+        [InlineData("")]
+        [InlineData(null)]
+        [InlineData(" ")]
+        public void TestGetOneByNameWhenInvalidThenThrowsException(string name)
+        {
+            // Arrange
+            GameRunner gameRunner = stubGameRunner;
+
+            // Act
+            void action() => gameRunner.GetOneByName(name);
+
+            // Assert
+            Assert.Throws<ArgumentException>(action);
+        }
+
+        [Fact]
+        public void TestGetOneByNameWhenValidButNotExistThenReturnNull()
+        {
+            // Arrange
+            GameRunner gameRunner = stubGameRunner;
+
+            // Act
+            Game result = gameRunner.GetOneByName("thereisbasicallynowaythatthisgamenamealreadyexists");
+
+            // Assert
+            Assert.Null(result);
+        }
+
+        [Fact]
+        public void TestGetOneByNameWhenValidThenReturnGame()
+        {
+            // Arrange
+            GameRunner gameRunner = new(new PlayerManager(), new DieManager());
+            Game game = stubGameRunner.GetAll().First();
+
+            // Act
+            Game actual = gameRunner.Add(game);
+            Game expected = game;
+
+            // Assert
+            Assert.Equal(expected, actual);
+        }
+
+        [Fact]
+        public void TestWhenRemoveExistsThenSucceeds()
+        {
+            // Arrange
+            GameRunner gameRunner = stubGameRunner;
+            Game game = new("blargh", new PlayerManager(), gameRunner.GetAll().First().Dice);
+            gameRunner.Add(game);
+
+            // Act
+            gameRunner.Remove(game);
+
+            // Assert
+            Assert.DoesNotContain(game, gameRunner.GetAll());
+        }
+
+        [Fact]
+        public void TestRemoveWhenGivenNullThenThrowsException()
+        {
+            // Arrange
+            GameRunner gameRunner = stubGameRunner;
+
+            // Act
+            void action() => gameRunner.Remove(null);
+
+            // Assert
+            Assert.Throws<ArgumentNullException>(action);
+        }
+
+        [Fact]
+        public void TestRemoveWhenGiveenNonExistentThenFailsSilently()
+        {
+            // Arrange
+            GameRunner gameRunner = stubGameRunner;
+            Game notGame = new("blargh", new PlayerManager(), gameRunner.GetAll().First().Dice);
+            IEnumerable<Game> expected = gameRunner.GetAll();
+
+            // Act
+            gameRunner.Remove(notGame);
+            IEnumerable<Game> actual = gameRunner.GetAll();
+
+            // Assert
+            Assert.Equal(actual, expected);
+        }
+
+        [Fact]
+        public void TestUpdateWhenValidThenSucceeds()
+        {
+            // Arrange
+            string oldName = "blargh";
+            string newName = "blargh2.0";
+            GameRunner gameRunner = new(new PlayerManager(), new DieManager());
+            Game game = new(oldName, new PlayerManager(), stubGameRunner.GetAll().First().Dice);
+            game.PlayerManager.Add(new("Alice"));
+            gameRunner.Add(game);
+
+            Game oldGame = gameRunner.GetAll().First();
+            Game newGame = new(newName, oldGame.PlayerManager, oldGame.Dice);
+
+            // Act
+            int oldSize = gameRunner.GetAll().Count();
+            gameRunner.Update(oldGame, newGame);
+            int newSize = gameRunner.GetAll().Count();
+
+            // Assert
+            Assert.NotEqual(oldName, newName);
+            Assert.DoesNotContain(oldGame, gameRunner.GetAll());
+            Assert.Contains(newGame, gameRunner.GetAll());
+            Assert.Equal(oldSize, newSize);
+        }
+
+        [Theory]
+        [InlineData("")]
+        [InlineData(" ")]
+        [InlineData(null)]
+        public void TestUpdateWhenValidBeforeAndInvalidAfterThenDoesNotGo(string badName)
+        {
+            // Arrange
+            GameRunner gameRunner = stubGameRunner;
+            int expectedSize = gameRunner.GetAll().Count();
+            Game oldGame = gameRunner.GetAll().First();
+
+            // Act
+            void action() => gameRunner.Update(oldGame, new(badName, oldGame.PlayerManager, oldGame.Dice));
+            int actualSize = gameRunner.GetAll().Count();
+
+            // Assert
+            Assert.Throws<ArgumentException>(action); // thrown by constructor
+            Assert.Contains(oldGame, gameRunner.GetAll()); // still there
+            Assert.True(expectedSize == actualSize);
+        }
+
+        [Fact]
+        public void TestUpdateWhenValidBeforeAndNullAfterThenDoesNotGo()
+        {
+            // Arrange
+            GameRunner gameRunner = stubGameRunner;
+            int expectedSize = gameRunner.GetAll().Count();
+            Game oldGame = gameRunner.GetAll().First();
+
+            // Act
+            void action() => gameRunner.Update(oldGame, null);
+            int actualSize = gameRunner.GetAll().Count();
+
+            // Assert
+            Assert.Throws<ArgumentNullException>(action); // thrown by constructor
+            Assert.Contains(oldGame, gameRunner.GetAll()); // still there
+            Assert.True(expectedSize == actualSize);
+        }
+
+        [Fact]
+        public void TestUpdateDoesNotGoWithValidAfterAndNullBefore()
+        {
+            // Arrange
+            GameRunner gameRunner = stubGameRunner;
+            int expectedSize = gameRunner.GetAll().Count();
+            Game oldGame = gameRunner.GetAll().First();
+
+            // Act
+            void action() => gameRunner.Update(null, new("newgamename", oldGame.PlayerManager, oldGame.Dice));
+            int actualSize = gameRunner.GetAll().Count();
+
+            // Assert
+            Assert.Throws<ArgumentNullException>(action); // thrown by constructor
+            Assert.Contains(oldGame, gameRunner.GetAll()); // still there
+            Assert.True(expectedSize == actualSize);
+        }
+
+        [Theory]
+        [InlineData("")]
+        [InlineData(" ")]
+        [InlineData(null)]
+        public void TestUpdateWhenInvalidBeforeAndValidAfterThenDoesNotGo(string badName)
+        {
+            // Arrange
+            GameRunner gameRunner = stubGameRunner;
+            int expectedSize = gameRunner.GetAll().Count();
+            Game oldGame = gameRunner.GetAll().First();
+
+            // Act
+            void action() => gameRunner.Update(new(badName, oldGame.PlayerManager, oldGame.Dice), new("valid", oldGame.PlayerManager, oldGame.Dice));
+            int actualSize = gameRunner.GetAll().Count();
+
+            // Assert
+            Assert.Throws<ArgumentException>(action); // thrown by constructor
+            Assert.Contains(oldGame, gameRunner.GetAll()); // still there
+            Assert.True(expectedSize == actualSize);
+        }
+
+        [Fact]
+        public void TestPlayGameWhenPlayThenAddNewTurnToHistory()
+        {
+            // Arrange
+            GameRunner gameRunner = stubGameRunner;
+            Game game = gameRunner.GetAll().First();
+
+            // Act
+            int turnsBefore = game.GetHistory().Count();
+            GameRunner.PlayGame(game);
+            int turnsAfter = game.GetHistory().Count();
+
+            // Assert
+            Assert.Equal(turnsBefore + 1, turnsAfter);
+        }
+
+        [Fact]
+        public void TestStartNewGame()
+        {
+            // Arrange
+            GameRunner gameRunner = stubGameRunner;
+            string name = "blargh";
+
+            // Act
+            Assert.DoesNotContain(gameRunner.GetOneByName(name), gameRunner.GetAll());
+            gameRunner.StartNewGame(name, new PlayerManager(), stubGameRunner.GetAll().First().Dice);
+
+            // Assert
+            Assert.Contains(gameRunner.GetOneByName(name), gameRunner.GetAll());
+        }
+    }
+}

Sources/Tests/Model_UTs/Games/GameTest.cs

@@ -8,7 +8,7 @@ using System.Diagnostics;
 using System.Linq;
 using Xunit;
 
-namespace Tests.Model_UTs
+namespace Tests.Model_UTs.Games
 {
     public class GameTest
     {

Sources/Tests/Model_UTs/Games/TurnTest.cs

@@ -1,322 +1,322 @@
-using Model.Dice;
-using Model.Dice.Faces;
-using Model.Games;
-using Model.Players;
-using System;
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.Linq;
-using Xunit;
-
-namespace Tests.Model_UTs
-{
-    public class TurnTest
-
-    {
-        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);
-        private static readonly AbstractDieFace FACE_FOUR = new ColorDieFace(16548);
-
-        private readonly static NumberDieFace[] FACES1 = new NumberDieFace[]
-        {
-            FACE_ONE as NumberDieFace,
-            new NumberDieFace(2),
-            new NumberDieFace(3),
-            new NumberDieFace(4)
-        };
-
-        private readonly static NumberDieFace[] FACES2 = new NumberDieFace[] {
-                  new NumberDieFace(9),
-                  new NumberDieFace(10),
-                  new NumberDieFace(11),
-                  FACE_TWO as NumberDieFace,
-                  new NumberDieFace(13),
-                  new NumberDieFace(14)
-            };
-
-        private readonly static ImageDieFace[] FACES3 = new ImageDieFace[] {
-                  new ImageDieFace(13),
-                  new ImageDieFace(27),
-                  new ImageDieFace(38),
-                  FACE_THREE as ImageDieFace
-            };
-
-        private readonly static ColorDieFace[] FACES4 = new ColorDieFace[] {
-                  new(11651),
-                  new(24651),
-                  FACE_FOUR as ColorDieFace,
-                  new(412)
-            };
-
-        private readonly AbstractDie<AbstractDieFace> NUM1 = new NumberDie(FACES1);
-        private readonly AbstractDie<AbstractDieFace> NUM2 = new NumberDie(FACES2);
-        private readonly AbstractDie<AbstractDieFace> IMG1 = new ImageDie(FACES3);
-        private readonly AbstractDie<AbstractDieFace> CLR1 = new ColorDie(FACES4);
-
-        public TurnTest()
-        {
-            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 }
-            };
-        }
-
-
-
-        [Fact]
-        public void TestCreateWithSpecifiedTimeNotUTCThenValid()
-        {
-            // Arrange
-            DateTime dateTime = new(year: 2018, month: 06, day: 15, hour: 16, minute: 30, second: 0, kind: DateTimeKind.Local);
-            Player player = new("Alice");
-            Assert.NotEqual(DateTimeKind.Utc, dateTime.Kind);
-
-            // Act
-            Turn turn = Turn.CreateWithSpecifiedTime(dateTime, player, DICE_N_FACES_1);
-
-            // Assert
-            Assert.Equal(DateTimeKind.Utc, turn.When.Kind);
-            Assert.Equal(dateTime.ToUniversalTime(), turn.When);
-        }
-
-
-
-        [Fact]
-        public void TestCreateWithSpecifiedTimeUTCThenValid()
-        {
-            // Arrange
-            DateTime dateTime = new(year: 2018, month: 06, day: 15, hour: 16, minute: 30, second: 0, kind: DateTimeKind.Utc);
-            Player player = new("Bobby");
-            Assert.Equal(DateTimeKind.Utc, dateTime.Kind);
-
-            // Act
-            Turn turn = Turn.CreateWithSpecifiedTime(dateTime, player, DICE_N_FACES_1);
-
-            // Assert
-            Assert.Equal(DateTimeKind.Utc, turn.When.Kind);
-            Assert.Equal(dateTime.ToUniversalTime(), turn.When);
-        }
-
-
-        [Fact]
-        public void TestCreateWithSpecifiedTimeNullPlayerThenException()
-        {
-            // Arrange
-            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_1);
-
-            // Assert
-            Assert.Throws<ArgumentNullException>(action);
-        }
-
-        [Fact]
-        public void TestCreateWithSpecifiedTimeNullFacesThenException()
-        {
-            // Arrange
-            DateTime dateTime = new(year: 2018, month: 06, day: 15, hour: 16, minute: 30, second: 0, kind: DateTimeKind.Utc);
-            Player player = new("Chucky");
-
-            // Act
-            void action() => Turn.CreateWithSpecifiedTime(dateTime, player, null);
-
-            // Assert
-            Assert.Throws<ArgumentNullException>(action);
-        }
-
-
-        [Fact]
-        public void TestCreateWithSpecifiedTimeEmptyFacesThenException()
-        {
-            // 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_1.Clear();
-
-            // Act
-            void action() => Turn.CreateWithSpecifiedTime(dateTime, player, DICE_N_FACES_1);
-
-            // Assert
-            Assert.Throws<ArgumentException>(action);
-        }
-
-
-
-        [Fact]
-        public void TestCreateWithDefaultTimeThenValid()
-        {
-            // Arrange
-            Player player = new("Chloe");
-
-            // Act
-            Turn turn = Turn.CreateWithDefaultTime(player, DICE_N_FACES_1);
-
-            // Assert
-            Assert.Equal(DateTimeKind.Utc, turn.When.Kind);
-            Assert.Equal(DateTime.Now.ToUniversalTime().Date, turn.When.Date);
-            // N.B.: might fail between 11:59:59PM and 00:00:00AM
-        }
-
-
-
-        [Fact]
-        public void TestToStringValidIfAllNormal()
-        {
-            // Arrange
-            DateTime dateTime = new(year: 2018, month: 06, day: 15, hour: 16, minute: 30, second: 0, kind: DateTimeKind.Utc);
-            string name = "Bobby";
-            Player player = new(name);
-            string expected = $"2018-06-15 16:30:00 -- {name} rolled: "
-                + FACE_ONE.ToString() + " "
-                + FACE_TWO.ToString() + " "
-                + FACE_THREE.ToString() + " "
-                + FACE_FOUR.ToString();
-
-            Turn turn = Turn.CreateWithSpecifiedTime(dateTime, player, DICE_N_FACES_1);
-
-            // Act
-            string actual = turn.ToString();
-            Debug.WriteLine(actual);
-
-            // Assert
-            Assert.Equal(expected, actual);
-        }
-
-        [Fact]
-        public void TestDiceNFacesProperty()
-        {
-            // Arrange
-            Player player = new("Erika");
-
-            // Act
-            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()));
-        }
-    }
-}
+using Model.Dice;
+using Model.Dice.Faces;
+using Model.Games;
+using Model.Players;
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using Xunit;
+
+namespace Tests.Model_UTs.Games
+{
+    public class TurnTest
+
+    {
+        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);
+        private static readonly AbstractDieFace FACE_FOUR = new ColorDieFace(16548);
+
+        private readonly static NumberDieFace[] FACES1 = new NumberDieFace[]
+        {
+            FACE_ONE as NumberDieFace,
+            new NumberDieFace(2),
+            new NumberDieFace(3),
+            new NumberDieFace(4)
+        };
+
+        private readonly static NumberDieFace[] FACES2 = new NumberDieFace[] {
+                  new NumberDieFace(9),
+                  new NumberDieFace(10),
+                  new NumberDieFace(11),
+                  FACE_TWO as NumberDieFace,
+                  new NumberDieFace(13),
+                  new NumberDieFace(14)
+            };
+
+        private readonly static ImageDieFace[] FACES3 = new ImageDieFace[] {
+                  new ImageDieFace(13),
+                  new ImageDieFace(27),
+                  new ImageDieFace(38),
+                  FACE_THREE as ImageDieFace
+            };
+
+        private readonly static ColorDieFace[] FACES4 = new ColorDieFace[] {
+                  new(11651),
+                  new(24651),
+                  FACE_FOUR as ColorDieFace,
+                  new(412)
+            };
+
+        private readonly AbstractDie<AbstractDieFace> NUM1 = new NumberDie(FACES1);
+        private readonly AbstractDie<AbstractDieFace> NUM2 = new NumberDie(FACES2);
+        private readonly AbstractDie<AbstractDieFace> IMG1 = new ImageDie(FACES3);
+        private readonly AbstractDie<AbstractDieFace> CLR1 = new ColorDie(FACES4);
+
+        public TurnTest()
+        {
+            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 }
+            };
+        }
+
+
+
+        [Fact]
+        public void TestCreateWithSpecifiedTimeNotUTCThenValid()
+        {
+            // Arrange
+            DateTime dateTime = new(year: 2018, month: 06, day: 15, hour: 16, minute: 30, second: 0, kind: DateTimeKind.Local);
+            Player player = new("Alice");
+            Assert.NotEqual(DateTimeKind.Utc, dateTime.Kind);
+
+            // Act
+            Turn turn = Turn.CreateWithSpecifiedTime(dateTime, player, DICE_N_FACES_1);
+
+            // Assert
+            Assert.Equal(DateTimeKind.Utc, turn.When.Kind);
+            Assert.Equal(dateTime.ToUniversalTime(), turn.When);
+        }
+
+
+
+        [Fact]
+        public void TestCreateWithSpecifiedTimeUTCThenValid()
+        {
+            // Arrange
+            DateTime dateTime = new(year: 2018, month: 06, day: 15, hour: 16, minute: 30, second: 0, kind: DateTimeKind.Utc);
+            Player player = new("Bobby");
+            Assert.Equal(DateTimeKind.Utc, dateTime.Kind);
+
+            // Act
+            Turn turn = Turn.CreateWithSpecifiedTime(dateTime, player, DICE_N_FACES_1);
+
+            // Assert
+            Assert.Equal(DateTimeKind.Utc, turn.When.Kind);
+            Assert.Equal(dateTime.ToUniversalTime(), turn.When);
+        }
+
+
+        [Fact]
+        public void TestCreateWithSpecifiedTimeNullPlayerThenException()
+        {
+            // Arrange
+            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_1);
+
+            // Assert
+            Assert.Throws<ArgumentNullException>(action);
+        }
+
+        [Fact]
+        public void TestCreateWithSpecifiedTimeNullFacesThenException()
+        {
+            // Arrange
+            DateTime dateTime = new(year: 2018, month: 06, day: 15, hour: 16, minute: 30, second: 0, kind: DateTimeKind.Utc);
+            Player player = new("Chucky");
+
+            // Act
+            void action() => Turn.CreateWithSpecifiedTime(dateTime, player, null);
+
+            // Assert
+            Assert.Throws<ArgumentNullException>(action);
+        }
+
+
+        [Fact]
+        public void TestCreateWithSpecifiedTimeEmptyFacesThenException()
+        {
+            // 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_1.Clear();
+
+            // Act
+            void action() => Turn.CreateWithSpecifiedTime(dateTime, player, DICE_N_FACES_1);
+
+            // Assert
+            Assert.Throws<ArgumentException>(action);
+        }
+
+
+
+        [Fact]
+        public void TestCreateWithDefaultTimeThenValid()
+        {
+            // Arrange
+            Player player = new("Chloe");
+
+            // Act
+            Turn turn = Turn.CreateWithDefaultTime(player, DICE_N_FACES_1);
+
+            // Assert
+            Assert.Equal(DateTimeKind.Utc, turn.When.Kind);
+            Assert.Equal(DateTime.Now.ToUniversalTime().Date, turn.When.Date);
+            // N.B.: might fail between 11:59:59PM and 00:00:00AM
+        }
+
+
+
+        [Fact]
+        public void TestToStringValidIfAllNormal()
+        {
+            // Arrange
+            DateTime dateTime = new(year: 2018, month: 06, day: 15, hour: 16, minute: 30, second: 0, kind: DateTimeKind.Utc);
+            string name = "Bobby";
+            Player player = new(name);
+            string expected = $"2018-06-15 16:30:00 -- {name} rolled: "
+                + FACE_ONE.ToString() + " "
+                + FACE_TWO.ToString() + " "
+                + FACE_THREE.ToString() + " "
+                + FACE_FOUR.ToString();
+
+            Turn turn = Turn.CreateWithSpecifiedTime(dateTime, player, DICE_N_FACES_1);
+
+            // Act
+            string actual = turn.ToString();
+            Debug.WriteLine(actual);
+
+            // Assert
+            Assert.Equal(expected, actual);
+        }
+
+        [Fact]
+        public void TestDiceNFacesProperty()
+        {
+            // Arrange
+            Player player = new("Erika");
+
+            // Act
+            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()));
+        }
+    }
+}

Sources/Tests/Model_UTs/Players/PlayerManagerTest.cs

@@ -5,7 +5,7 @@ using System.Collections.ObjectModel;
 using System.Linq;
 using Xunit;
 
-namespace Tests.Model_UTs
+namespace Tests.Model_UTs.Players
 {
     public class PlayerManagerTest
     {

Sources/Tests/Model_UTs/Players/PlayerTest.cs

@@ -2,7 +2,7 @@ using Model.Players;
 using System;
 using Xunit;
 
-namespace Tests.Model_UTs
+namespace Tests.Model_UTs.Players
 {
     public class PlayerTest
     {
@@ -99,7 +99,7 @@ namespace Tests.Model_UTs
         public void TestGoesThruToSecondMethodIfObjIsTypePlayer()
         {
             // Arrange
-            Object p1;
+            object p1;
             Player p2;
 
             // Act