fix merging conflict

Sources/App/Program.cs

@@ -5,6 +5,7 @@ using Model.Games;
 using Model.Players;
 using System;
 using System.Collections.Generic;
+using System.Drawing;
 using System.Linq;
 
 namespace App
@@ -61,7 +62,7 @@ namespace App
                             Console.WriteLine("make at least one dice group first, then try again");
                             break;
                         }
-                        IEnumerable<AbstractDie<AbstractDieFace>> newGameDice = PrepareDice(gameRunner);
+                        IEnumerable<Die> newGameDice = PrepareDice(gameRunner);
 
                         string newGameName;
                         Console.WriteLine("give this new game a name\n>");
@@ -83,11 +84,11 @@ namespace App
                         Console.WriteLine("give this new dice group a name");
                         newGroupName = Console.ReadLine();
 
-                        List<AbstractDie<AbstractDieFace>> newGroupDice = new();
+                        List<Die> newGroupDice = new();
                         string menuChoiceNewDice = "";
                         while (!(menuChoiceNewDice.Equals("ok") && newGroupDice.Any()))
                         {
-                            AbstractDie<AbstractDieFace> die = null;
+                            Die die = null;
                             Console.WriteLine("create a die you want to add (at least one), or enter 'ok' if you're finished");
                             Console.WriteLine("what type of die ?\n" +
                                 "n... number\n" +
@@ -114,7 +115,7 @@ namespace App
                                 newGroupDice.Add(die);
                             }
                         }
-                        gameRunner.GlobalDieManager.Add(new KeyValuePair<string, IEnumerable<AbstractDie<AbstractDieFace>>>(newGroupName, newGroupDice));
+                        gameRunner.GlobalDieManager.Add(new KeyValuePair<string, IEnumerable<Die>>(newGroupName, newGroupDice));
                         break;
 
                     default:
@@ -173,7 +174,7 @@ namespace App
         private static NumberDie MakeNumberDie()
         {
             NumberDie die;
-            List<NumberDieFace> faces = new();
+            List<NumberFace> faces = new();
             string menuChoiceNewFaces = "";
 
             while (menuChoiceNewFaces != "ok")
@@ -194,14 +195,14 @@ namespace App
         private static ColorDie MakeColorDie()
         {
             ColorDie die;
-            List<ColorDieFace> faces = new();
+            List<ColorFace> faces = new();
             string menuChoiceNewFaces = "";
 
             while (!menuChoiceNewFaces.Equals("ok"))
             {
-                Console.WriteLine("create a face with an color hex code, or enter 'ok' if you're finished");
+                Console.WriteLine("create a face with an color name, or enter 'ok' if you're finished");
                 menuChoiceNewFaces = Console.ReadLine();
-                if (menuChoiceNewFaces != "ok") faces.Add(new(menuChoiceNewFaces));
+                if (menuChoiceNewFaces != "ok") faces.Add(new(Color.FromName(menuChoiceNewFaces)));
             }
 
             die = new ColorDie(faces.ToArray());
@@ -211,27 +212,41 @@ namespace App
         private static ImageDie MakeImageDie()
         {
             ImageDie die;
-            List<ImageDieFace> faces = new();
+            List<ImageFace> faces = new();
             string menuChoiceNewFaces = "";
 
             while (!menuChoiceNewFaces.Equals("ok"))
             {
-                Console.WriteLine("create a face with an image url, or enter 'ok' if you're finished");
+                Console.WriteLine("create a face with an image uri, or enter 'ok' if you're finished");
                 menuChoiceNewFaces = Console.ReadLine();
 
-                if (menuChoiceNewFaces != "ok") faces.Add(new(menuChoiceNewFaces));
+                if (menuChoiceNewFaces != "ok")
+                {
+                    try
+                    {
+                        faces.Add(new(new Uri(menuChoiceNewFaces)));
+                    }
+                    catch (ArgumentNullException ex)
+                    {
+                        Console.WriteLine(ex.Message);
+                    }
+                    catch (UriFormatException ex)
+                    {
+                        Console.WriteLine("that URI was not valid");
+                        Console.WriteLine(ex.Message);
+                    }
+                }
             }
-
             die = new ImageDie(faces.ToArray());
             return die;
         }
 
-        private static IEnumerable<AbstractDie<AbstractDieFace>> PrepareDice(GameRunner gameRunner)
+        private static IEnumerable<Die> PrepareDice(GameRunner gameRunner)
         {
-            List<AbstractDie<AbstractDieFace>> result = new();
+            List<Die> result = new();
             Console.WriteLine("add dice to the game");
             Console.WriteLine("all known dice or groups of dice:");
-            foreach ((string name, IEnumerable<AbstractDie<AbstractDieFace>> dice) in gameRunner.GlobalDieManager.GetAll())
+            foreach ((string name, IEnumerable<Die> dice) in gameRunner.GlobalDieManager.GetAll())
             {
                 Console.WriteLine($"{name} -- {dice}");
             }
@@ -243,8 +258,8 @@ namespace App
                 //  no checks, this is temporary
                 if (!menuChoiceDice.Equals("ok"))
                 {
-                    IEnumerable<AbstractDie<AbstractDieFace>> chosenDice = gameRunner.GlobalDieManager.GetOneByName(menuChoiceDice).Value;
-                    foreach (AbstractDie<AbstractDieFace> die in chosenDice)
+                    IEnumerable<Die> chosenDice = gameRunner.GlobalDieManager.GetOneByName(menuChoiceDice).Value;
+                    foreach (Die die in chosenDice)
                     {
                         result.Add(die);
                     }

Sources/Data/Stub.cs

@@ -4,6 +4,7 @@ using Model.Dice.Faces;
 using Model.Games;
 using Model.Players;
 using System.Collections.Generic;
+using System.Drawing;
 
 namespace Data
 {
@@ -20,18 +21,42 @@ namespace Data
             gr.GlobalPlayerManager.Add(player3);
 
 
-            List<HomogeneousDice<int>> monopolyDice = new();
-            List<NumberDie> dndDice = new();
+            List<Die> monopolyDice = new();
+            List<Die> dndDice = new();
 
             string monopolyName = "Monopoly", dndName = "DnD";
 
-            NumberDieFace[] d6Faces = new NumberDieFace[] { new(1), new(2), new(3), new(4), new(5), new(6) };
+            NumberFace[] d6Faces = new NumberFace[] { new(1), new(2), new(3), new(4), new(5), new(6) };
 
-            monopolyDice.Add(new NumberDie(new NumberDieFace(1), new NumberDieFace(1), new NumberDieFace(1), new NumberDieFace(1)));
+            monopolyDice.Add(new NumberDie(new NumberFace(1), new NumberFace(1), new NumberFace(1), new NumberFace(1)));
             monopolyDice.Add(new NumberDie(d6Faces));
-            //monopolyDice.Add(new ColorDie(new("#ff0000"), new("#00ff00"), new("#0000ff"), new("#ffff00"), new("#000000"), new("#ffffff")));
+            monopolyDice.Add(new NumberDie(d6Faces));
+
+            ColorFace[] colorFaces = new ColorFace[]
+            {
+                new(Color.FromName("blue")),
+                new(Color.FromName("red")),
+                new(Color.FromName("yellow")),
+                new(Color.FromName("green")),
+                new(Color.FromName("black")),
+                new(Color.FromName("white"))
+            };
+
+            monopolyDice.Add(new ColorDie(colorFaces));
+
+            string rootPath = "https://unsplash.com/photos/";
+
+            ImageFace[] imageFaces = new ImageFace[]
+            {
+                new(new Uri(rootPath + "TLD6iCOlyb0")),
+                new(new Uri(rootPath + "rTZW4f02zY8")),
+                new(new Uri(rootPath + "Hyu76loQLdk")),
+                new(new Uri(rootPath + "A_Ncbi-RH6s")),
+            };
+
+            monopolyDice.Add(new ImageDie(imageFaces));
 
-            NumberDieFace[] d20Faces = new NumberDieFace[] {
+            NumberFace[] d20Faces = new NumberFace[] {
                 new(1), new(2), new(3), new(4), new(5),
                 new(6), new(7), new(8), new(9), new(10),
                 new(11), new(12), new(13), new(14), new(15),
@@ -40,8 +65,8 @@ namespace Data
 
             dndDice.Add(new NumberDie(d20Faces));
 
-            gr.GlobalDieManager.Add(new KeyValuePair<string, IEnumerable<AbstractDie<AbstractDieFace<object>>>>(dndName, dndDice.AsEnumerable()));
-            gr.GlobalDieManager.Add(new KeyValuePair<string, IEnumerable<AbstractDie<AbstractDieFace<object>>>>(monopolyName, monopolyDice.AsEnumerable()));
+            gr.GlobalDieManager.Add(new KeyValuePair<string, IEnumerable<Die>>(dndName, dndDice.AsEnumerable()));
+            gr.GlobalDieManager.Add(new KeyValuePair<string, IEnumerable<Die>>(monopolyName, monopolyDice.AsEnumerable()));
 
             string game1 = "Forgotten Realms", game2 = "4e", game3 = "The Coopers";
 

Sources/Model/Dice/AbstractDie.cs

@@ -1,25 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using Model.Dice.Faces;
-
-namespace Model.Dice
-{
-    public abstract class AbstractDie<T> : RandomnessHaver 
-    {
-        public IEnumerable<AbstractDieFace<T>> ListFaces => listFaces;
-
-        private readonly List<AbstractDieFace<T>> listFaces = new();
-
-        protected AbstractDie(params AbstractDieFace<T>[] faces)
-        {
-            listFaces.AddRange(faces);
-        }
-
-        public AbstractDieFace<T> GetRandomFace()
-        {
-            int faceIndex = rnd.Next(0, ListFaces.Count());
-            return ListFaces.ElementAt(faceIndex);
-        }
-    }
-}

Sources/Model/Dice/ColorDie.cs

@@ -1,18 +1,11 @@
 using Model.Dice.Faces;
-using System;
-using System.Collections;
-using System.Collections.Generic;
-using System.Collections.ObjectModel;
 using System.Drawing;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
 
 namespace Model.Dice
 {
-    public class ColorDie : AbstractDie<Color>
+    public class ColorDie : HomogeneousDie<Color>
     {
-        public ColorDie(params ColorDieFace[] faces) : base(faces)
+        public ColorDie(params ColorFace[] faces) : base(faces)
         {
 
         }

Sources/Model/Dice/Die.cs

@@ -0,0 +1,27 @@
+using Model.Dice.Faces;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Model.Dice
+{
+    public abstract class Die
+    {
+        public IEnumerable<Face> Faces => faces;
+
+        protected static readonly Random rnd = new();
+
+        private readonly List<Face> faces = new();
+
+        protected Die(params Face[] faces)
+        {
+            this.faces.AddRange(faces);
+        }
+
+        public virtual Face GetRandomFace()
+        {
+            int faceIndex = rnd.Next(0, Faces.Count());
+            return Faces.ElementAt(faceIndex);
+        }
+    }
+}

Sources/Model/Dice/DieManager.cs

@@ -1,63 +1,58 @@
-using Model.Dice.Faces;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-
-namespace Model.Dice
-{
-    public class DieManager : IManager<KeyValuePair<string, IEnumerable<AbstractDie<object>>>>
-    {
-        private readonly Dictionary<string, IEnumerable<AbstractDie<object>>> diceGroups = new();
-
-        public KeyValuePair<string, IEnumerable<AbstractDie<object>>> Add(KeyValuePair<string, IEnumerable<AbstractDie<object>>> toAdd)
-        {
-            // on trim la clé d'abord
-            diceGroups.Add(toAdd.Key.Trim(), toAdd.Value);
-            return toAdd;
+using Model.Dice.Faces;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Model.Dice
+{
+    public class DieManager : IManager<KeyValuePair<string, IEnumerable<Die>>>
+    {
+        private readonly Dictionary<string, IEnumerable<Die>> diceGroups = new();
+
+        public KeyValuePair<string, IEnumerable<Die>> Add(KeyValuePair<string, IEnumerable<Die>> toAdd)
+        {
+            // on trim la clé d'abord
+            diceGroups.Add(toAdd.Key.Trim(), toAdd.Value);
+            return toAdd;
         }
 
-        public IEnumerable<KeyValuePair<string, IEnumerable<AbstractDie<object>>>> GetAll()
-        {
-            return diceGroups.AsEnumerable();
-        }
-
-        public KeyValuePair<string, IEnumerable<AbstractDie<object>>> GetOneByName(string name)
-        {
-            // les groupes de dés nommés :
-            // ils sont case-sensistive, mais "mon jeu" == "mon jeu " == "  mon jeu"
-            return new KeyValuePair<string, IEnumerable<AbstractDie<object>>>(name, diceGroups[name]);
-        }
-
-        public void Remove(KeyValuePair<string, IEnumerable<AbstractDie<object>>> toRemove)
-        {
-            diceGroups.Remove(toRemove.Key);
+        public IEnumerable<KeyValuePair<string, IEnumerable<Die>>> GetAll()
+        {
+            return diceGroups.AsEnumerable();
         }
 
-        /*public void Remove(KeyValuePair<string, IEnumerable<AbstractDie<Faces.AbstractDieFace<object>, object>>> toRemove)
+        public KeyValuePair<string, IEnumerable<Die>> GetOneByID(Guid ID)
         {
             throw new NotImplementedException();
         }
 
-        public void Remove(KeyValuePair<string, IEnumerable<AbstractDie<AbstractDieFace<object>, object>>> toRemove)
+        public KeyValuePair<string, IEnumerable<Die>> GetOneByName(string name)
         {
-            throw new NotImplementedException();
-        }*/
+            // les groupes de dés nommés :
+            // ils sont case-sensistive, mais "mon jeu" == "mon jeu " == "  mon jeu"
+            return new KeyValuePair<string, IEnumerable<Die>>(name, diceGroups[name]);
+        }
+
+        public void Remove(KeyValuePair<string, IEnumerable<Die>> toRemove)
+        {
+            diceGroups.Remove(toRemove.Key);
+        }
+
+        public KeyValuePair<string, IEnumerable<Die>> Update(KeyValuePair<string, IEnumerable<Die>> before, KeyValuePair<string, IEnumerable<Die>> after)
+        {
+            // pas autorisé de changer les dés, juste le nom
+            if (!before.Value.Equals(after.Value))
+            {
+                if (string.IsNullOrWhiteSpace(before.Key) || string.IsNullOrWhiteSpace(after.Key))
+                {
+                    throw new ArgumentNullException(nameof(before), "dice group name should not be null or empty");
+                }
 
-        public KeyValuePair<string, IEnumerable<AbstractDie<object>>> Update(KeyValuePair<string, IEnumerable<AbstractDie<object>>> before, KeyValuePair<string, IEnumerable<AbstractDie<object>>> after)
-        {
-            // pas autorisé de changer les dés, juste le nom
-            if (!before.Value.Equals(after.Value))
-            {
-                if (string.IsNullOrWhiteSpace(before.Key) || string.IsNullOrWhiteSpace(after.Key))
-                {
-                    throw new ArgumentNullException(nameof(before), "dice group name should not be null or empty");
-                }
-
-                diceGroups.Remove(before.Key);
-                diceGroups.Add(after.Key, after.Value);
-                return after;
-            }
-            return before;
+                diceGroups.Remove(before.Key);
+                diceGroups.Add(after.Key, after.Value);
+                return after;
+            }
+            return before;
         }
 
 /*
@@ -72,5 +67,5 @@ namespace Model.Dice
             throw new NotImplementedException();
         }
 */
-    }
-}
+    }
+}

Sources/Model/Dice/Faces/ColorFace.cs

@@ -0,0 +1,11 @@
+using System.Drawing;
+
+namespace Model.Dice.Faces
+{
+    public class ColorFace : Face<Color>
+    {
+        public ColorFace(Color value) : base(value)
+        {
+        }
+    }
+}

Sources/Model/Dice/Faces/Face.cs

@@ -0,0 +1,28 @@
+namespace Model.Dice.Faces
+{
+    public abstract class Face
+    {
+        public string StringValue { get; protected set; }
+
+        public override string ToString()
+        {
+            return StringValue;
+        }
+    }
+    public abstract class Face<T> : Face
+    {
+        public T Value { get; protected set; }
+
+        protected Face(T value)
+        {
+            Value = value;
+            StringValue = value.ToString();
+        }
+
+        protected Face(T value, string stringValue)
+        {
+            Value = value;
+            StringValue = stringValue;
+        }
+    }
+}

Sources/Model/Dice/Faces/ImageFace.cs

@@ -0,0 +1,11 @@
+using System;
+
+namespace Model.Dice.Faces
+{
+    public class ImageFace : Face<Uri>
+    {
+        public ImageFace(Uri value) : base(value)
+        {
+        }
+    }
+}

Sources/Model/Dice/Faces/NumberFace.cs

@@ -0,0 +1,9 @@
+namespace Model.Dice.Faces
+{
+    public class NumberFace : Face<int>
+    {
+        public NumberFace(int value) : base(value)
+        {
+        }
+    }
+}

Sources/Model/Dice/HomogeneousDice.cs

@@ -7,9 +7,9 @@ using Model.Dice.Faces;
 
 namespace Model.Dice
 {
-    public class HomogeneousDice<T>: AbstractDie<T>
+    public class HomogeneousDice<T>: Die
     {
-        public HomogeneousDice(params AbstractDieFace<T>[] faces) : base(faces)
+        public HomogeneousDice(params Face[] faces) : base(faces)
         {
 
         }

Sources/Model/Dice/HomogeneousDie.cs

@@ -0,0 +1,16 @@
+using Model.Dice.Faces;
+
+namespace Model.Dice
+{
+    public abstract class HomogeneousDie<T> : Die
+    {
+        protected HomogeneousDie(params Face<T>[] faces) : base(faces)
+        {
+        }
+
+        public override Face<T> GetRandomFace()
+        {
+            return (Face<T>)base.GetRandomFace();
+        }
+    }
+}

Sources/Model/Dice/ImageDie.cs

@@ -1,15 +1,11 @@
 using Model.Dice.Faces;
 using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
 
 namespace Model.Dice
 {
-    public class ImageDie : HomogeneousDice<Uri>
+    public class ImageDie : HomogeneousDie<Uri>
     {
-        public ImageDie(params ImageDieFace[] faces) : base(faces)
+        public ImageDie(params ImageFace[] faces) : base(faces)
         {
         }
     }

Sources/Model/Dice/NumberDie.cs

@@ -7,9 +7,9 @@ using System.Threading.Tasks;
 
 namespace Model.Dice
 {
-    public class NumberDie : HomogeneousDice<int>
+    public class NumberDie : HomogeneousDie<int>
     {
-        public NumberDie(params NumberDieFace[] faces) : base(faces)
+        public NumberDie(params NumberFace[] faces) : base(faces)
         {
         }
     }

Sources/Model/Dice/RandomnessHaver.cs

@@ -1,16 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace Model.Dice
-{
-    public class RandomnessHaver
-    {
-        protected RandomnessHaver()
-        {
-        }
-        protected static readonly Random rnd = new();
-    }
-}

Sources/Model/Games/Game.cs

@@ -57,8 +57,8 @@ namespace Model.Games
         /// <summary>
         /// the group of dice used for this game
         /// </summary>
-        public IEnumerable<AbstractDie<object>> Dice => dice;
-        private readonly IEnumerable<AbstractDie<object>> dice;
+        public IEnumerable<Die> Dice => dice;
+        private readonly IEnumerable<Die> dice;
 
         /// <summary>
         /// constructs a Game with its own history of Turns. 
@@ -68,7 +68,7 @@ namespace Model.Games
         /// <param name="turns">the turns that have been done so far</param>
         /// <param name="playerManager">the game's player manager, doing CRUD on players and switching whose turn it is</param>
         /// <param name="favGroup">the group of dice used for this game</param>
-        public Game(string name, IManager<Player> playerManager, IEnumerable<AbstractDie<object>> dice, IEnumerable<Turn> turns)
+        public Game(string name, IManager<Player> playerManager, IEnumerable<Die> dice, IEnumerable<Turn> turns)
         {
             Name = name;
             PlayerManager = playerManager;
@@ -83,7 +83,7 @@ namespace Model.Games
         /// <param name="name">the name of the game 😎</param>
         /// <param name="playerManager">the game's player manager, doing CRUD on players and switching whose turn it is</param>
         /// <param name="favGroup">the group of dice used for this game</param>
-        public Game(string name, IManager<Player> playerManager, IEnumerable<AbstractDie<object>> dice)
+        public Game(string name, IManager<Player> playerManager, IEnumerable<Die> dice)
             : this(name, playerManager, dice, null)
         { }
 
@@ -161,10 +161,10 @@ namespace Model.Games
         /// throws all the Dice in FavGroup and returns a list of their Faces
         /// </summary>
         /// <returns>list of AbstractDieFaces after a throw</returns>
-        private Dictionary<AbstractDie<object>, AbstractDieFace<object>> ThrowAll()
+        private Dictionary<Die, Face> ThrowAll()
         {
-            Dictionary<AbstractDie<object>, AbstractDieFace<object>> faces = new();
-            foreach (AbstractDie<object> die in dice)
+            Dictionary<Die, Face> faces = new();
+            foreach (Die die in dice)
             {
                 faces.Add(die, die.GetRandomFace());
             }

Sources/Model/Games/GameRunner.cs

@@ -12,17 +12,17 @@ namespace Model.Games
     public class GameRunner : IManager<Game>
     {
         public IManager<Player> GlobalPlayerManager { get; private set; }
-        public IManager<KeyValuePair<string, IEnumerable<AbstractDie<object>>>> GlobalDieManager { get; private set; }
+        public IManager<KeyValuePair<string, IEnumerable<Die>>> GlobalDieManager { get; private set; }
         private readonly List<Game> games;
 
-        public GameRunner(IManager<Player> globalPlayerManager, IManager<KeyValuePair<string, IEnumerable<AbstractDie<object>>>> globalDieManager, List<Game> games)
+        public GameRunner(IManager<Player> globalPlayerManager, IManager<KeyValuePair<string, IEnumerable<Die>>> globalDieManager, List<Game> games)
         {
             GlobalPlayerManager = globalPlayerManager;
             GlobalDieManager = globalDieManager;
             this.games = games ?? new();
         }
 
-        public GameRunner(IManager<Player> globalPlayerManager, IManager<KeyValuePair<string, IEnumerable<AbstractDie<object>>>> globalDieManager)
+        public GameRunner(IManager<Player> globalPlayerManager, IManager<KeyValuePair<string, IEnumerable<Die>>> globalDieManager)
             : this(globalPlayerManager, globalDieManager, null){ }
 
 
@@ -65,7 +65,7 @@ namespace Model.Games
         /// <summary>
         /// creates a new game
         /// </summary>
-        public Game StartNewGame(string name, IManager<Player> playerManager, IEnumerable<AbstractDie<object>> dice)
+        public Game StartNewGame(string name, IManager<Player> playerManager, IEnumerable<Die> dice)
         {
             Game game = new(name, playerManager, dice);
             return Add(game);
@@ -108,5 +108,10 @@ namespace Model.Games
             game.PerformTurn(current);
             game.PrepareNextPlayer(current);
         }
+
+        public Game GetOneByID(Guid ID)
+        {
+            throw new NotImplementedException();
+        }
     }
 }

Sources/Model/Games/Turn.cs

@@ -1,7 +1,5 @@
 using System;
-using System.Collections;
 using System.Collections.Generic;
-using System.Collections.ObjectModel;
 using System.Linq;
 using System.Text;
 using Model.Dice;
@@ -33,8 +31,8 @@ namespace Model.Games
         /// <summary>
         /// the collection of Face that were rolled
         /// </summary>
-        public IEnumerable<KeyValuePair<AbstractDie<object>, AbstractDieFace<object>>> DiceNFaces => diceNFaces.AsEnumerable();
-        private readonly Dictionary<AbstractDie<object>, AbstractDieFace<object>> diceNFaces;
+        public IEnumerable<KeyValuePair<Die, Face>> DiceNFaces => diceNFaces.AsEnumerable();
+        private readonly Dictionary<Die, Face> diceNFaces;
 
         /// <summary>
         /// this private constructor is to be used only by factories
@@ -42,7 +40,7 @@ namespace Model.Games
         /// <param name="when">date and time of the turn</param>
         /// <param name="player">player who played the turn</param>
         /// <param name="faces">faces that were rolled</param>
-        private Turn(DateTime when, Player player, Dictionary<AbstractDie<object>, AbstractDieFace<object>> diceNFaces)
+        private Turn(DateTime when, Player player, Dictionary<Die, Face> diceNFaces)
         {
             When = when;
             Player = player;
@@ -59,7 +57,7 @@ namespace Model.Games
         /// <param name="player">player who played the turn</param>
         /// <param name="faces">faces that were rolled</param>
         /// <returns>a new Turn object</returns>
-        public static Turn CreateWithSpecifiedTime(DateTime when, Player player, Dictionary<AbstractDie<object>, AbstractDieFace<object>> diceNFaces)
+        public static Turn CreateWithSpecifiedTime(DateTime when, Player player, Dictionary<Die, Face> diceNFaces)
         {
             if (player is null)
             {
@@ -87,7 +85,7 @@ namespace Model.Games
         /// <param name="player">player who played the turn</param>
         /// <param name="faces">faces that were rolled</param>
         /// <returns>a new Turn object</returns>
-        public static Turn CreateWithDefaultTime(Player player, Dictionary<AbstractDie<object>, AbstractDieFace<object>> diceNFaces)
+        public static Turn CreateWithDefaultTime(Player player, Dictionary<Die, Face> diceNFaces)
         {
             return CreateWithSpecifiedTime(DateTime.UtcNow, player, diceNFaces);
         }
@@ -108,7 +106,7 @@ namespace Model.Games
                 date,
                 time,
                 Player.ToString());
-            foreach (AbstractDieFace<object> face in this.diceNFaces.Values)
+            foreach (Face face in this.diceNFaces.Values)
             {
                 sb.Append(" " + face.ToString());
             }

Sources/Model/IManager.cs

@@ -1,10 +1,12 @@
-using System.Collections.Generic;
+using System;
+using System.Collections.Generic;
 namespace Model
 {
     public interface IManager<T>
     {
         public T Add(T toAdd);
         public T GetOneByName(string name);
+        public T GetOneByID(Guid ID);
         public IEnumerable<T> GetAll();
         public T Update(T before, T after);
         public void Remove(T toRemove);

Sources/Model/Players/PlayerManager.cs

@@ -95,5 +95,10 @@ namespace Model.Players
             // the built-in Remove() method will use our redefined Equals(), using Name only
             players.Remove(toRemove);
         }
+
+        public Player GetOneByID(Guid ID)
+        {
+            throw new NotImplementedException();
+        }
     }
 }

Sources/Tests/Model_UTs/GameTest.cs

@@ -11,55 +11,32 @@ using System.Threading.Tasks;
 using Xunit;
 using static System.Collections.Specialized.BitVector32;
 using System.Diagnostics;
+using Data;
 
 namespace Tests.Model_UTs
 {
     public class GameTest
     {
-
+        private readonly GameRunner stubGameRunner = new Stub().LoadApp();
         private static readonly string GAME_NAME = "my game";
 
         private static readonly Player PLAYER_1 = new("Alice"), PLAYER_2 = new("Bob"), PLAYER_3 = new("Clyde");
-
-        private readonly static NumberDieFace FACE_NUM = new(1);
-        private readonly static ImageDieFace FACE_IMG = new(10);
-        private readonly static ColorDieFace FACE_CLR = new(1000);
-
-        private readonly static NumberDieFace[] FACES_1 = new NumberDieFace[]
-        {
-            FACE_NUM,
-            new(2),
-            new(3),
-            new(4)
-        };
-
-        private readonly static ImageDieFace[] FACES_2 = new ImageDieFace[]
+        private readonly IEnumerable<Die> DICE_1, DICE_2;
+        public GameTest()
         {
-            FACE_IMG,
-            new(20),
-            new(30),
-            new(40)
-        };
-
-        private readonly static ColorDieFace[] FACES_3 = new ColorDieFace[]
-        {
-            FACE_CLR,
-            new(2000),
-            new(3000),
-            new(4000)
-        };
+            DICE_1 = stubGameRunner.GlobalDieManager.GetAll().First().Value;
+            DICE_2 = stubGameRunner.GlobalDieManager.GetAll().Last().Value;
+        }
 
-        private static readonly AbstractDie<AbstractDieFace> NUM = new NumberDie(FACES_1), IMG = new ImageDie(FACES_2), CLR = new ColorDie(FACES_3);
 
-        private static readonly IEnumerable<AbstractDie<AbstractDieFace>> DICE =
-            new List<AbstractDie<AbstractDieFace>>() { NUM, IMG, CLR }
-            .AsEnumerable();
 
         [Fact]
         public void TestNamePropertyGet()
         {
             // Arrange
-            Game game = new(name: GAME_NAME, playerManager: new PlayerManager(), dice: DICE);
+            Game game = new(name: GAME_NAME,
+                playerManager: new PlayerManager(),
+                dice: DICE_1);
 
             // Act
             string actual = game.Name;
@@ -72,9 +49,11 @@ namespace Tests.Model_UTs
         public void TestNamePropertySetWhenValidThenCorrect()
         {
             // Arrange
-            Game game = new(name: GAME_NAME, playerManager: new PlayerManager(), dice: DICE);
-            string expected = "shitty marmot";
+            Game game = new(name: GAME_NAME,
+                playerManager: new PlayerManager(),
+                dice: DICE_1);
 
+            string expected = "shitty marmot";
 
             // Act
             game.Name = expected;
@@ -94,7 +73,9 @@ namespace Tests.Model_UTs
             Game game;
 
             // Act
-            void action() => game = new(name: name, playerManager: new PlayerManager(), dice: DICE);
+            void action() => game = new(name: name,
+                playerManager: new PlayerManager(),
+                dice: DICE_1);
 
             // Assert
             Assert.Throws<ArgumentException>(action);
@@ -104,12 +85,7 @@ namespace Tests.Model_UTs
         public void TestGetHistory()
         {
             // Arrange
-            Dictionary<AbstractDie<AbstractDieFace>, AbstractDieFace> diceNFaces = new()
-            {
-                { CLR, FACE_CLR },
-                { IMG, FACE_IMG },
-                { NUM, FACE_NUM }
-            };
+            Dictionary<Die, Face> diceNFaces = (Dictionary<Die, Face>)stubGameRunner.GetAll().First().GetHistory().First().DiceNFaces;
 
             Turn turn1 = Turn.CreateWithDefaultTime(PLAYER_1, diceNFaces);
             Turn turn2 = Turn.CreateWithDefaultTime(PLAYER_2, diceNFaces); // yeah they rolled the same
@@ -117,7 +93,11 @@ namespace Tests.Model_UTs
             IEnumerable<Turn> expected = new List<Turn>() { turn1, turn2 };
 
             // Act
-            Game game = new(name: GAME_NAME, playerManager: new PlayerManager(), dice: DICE, expected);
+            Game game = new(name: GAME_NAME,
+                playerManager: new PlayerManager(),
+                dice: DICE_1,
+                expected);
+
             IEnumerable<Turn> actual = game.GetHistory();
 
             // Assert
@@ -128,12 +108,14 @@ namespace Tests.Model_UTs
         public void TestDicePropertyGet()
         {
             // Arrange
-            Game game = new(name: GAME_NAME, playerManager: new PlayerManager(), dice: DICE);
+            Game game = new(name: GAME_NAME,
+                playerManager: new PlayerManager(),
+                dice: DICE_2);
 
 
             // Act
-            IEnumerable<AbstractDie<AbstractDieFace>> actual = game.Dice;
-            IEnumerable<AbstractDie<AbstractDieFace>> expected = DICE;
+            IEnumerable<Die> actual = game.Dice;
+            IEnumerable<Die> expected = DICE_2;
 
             // Assert
             Assert.Equal(expected, actual);
@@ -143,7 +125,10 @@ namespace Tests.Model_UTs
         public void TestPerformTurnDoesAddOneTurn()
         {
             // Arrange
-            Game game = new(name: GAME_NAME, playerManager: new PlayerManager(), dice: DICE);
+            Game game = new(name: GAME_NAME,
+                playerManager: new PlayerManager(),
+                dice: DICE_1);
+
             game.PlayerManager.Add(PLAYER_1);
             game.PlayerManager.Add(PLAYER_2);
 
@@ -171,7 +156,10 @@ namespace Tests.Model_UTs
         public void TestGetWhoPlaysNowWhenValidThenCorrect()
         {
             // Arrange
-            Game game = new(name: GAME_NAME, playerManager: new PlayerManager(), dice: DICE);
+            Game game = new(name: GAME_NAME,
+                playerManager: new PlayerManager(),
+                dice: DICE_1);
+
             game.PlayerManager.Add(PLAYER_1);
             game.PlayerManager.Add(PLAYER_2);
 
@@ -194,7 +182,9 @@ namespace Tests.Model_UTs
         public void TestGetWhoPlaysNowWhenInvalidThenException()
         {
             // Arrange
-            Game game = new(name: GAME_NAME, playerManager: new PlayerManager(), dice: DICE);
+            Game game = new(name: GAME_NAME,
+                playerManager: new PlayerManager(),
+                dice: DICE_1);
 
             // Act
             void action() => game.GetWhoPlaysNow(); // on an empty collection of players
@@ -207,8 +197,9 @@ namespace Tests.Model_UTs
         public void TestPrepareNextPlayerWhenEmptyThenException()
         {
             // Arrange
-            Game game = new(name: GAME_NAME, playerManager: new PlayerManager(), dice: DICE);
-
+            Game game = new(name: GAME_NAME,
+                playerManager: new PlayerManager(),
+                dice: DICE_1);
             // Act
             void action() => game.PrepareNextPlayer(PLAYER_1); // on an empty collection of players
 
@@ -220,7 +211,10 @@ namespace Tests.Model_UTs
         public void TestPrepareNextPlayerWhenNullThenException()
         {
             // Arrange
-            Game game = new(name: GAME_NAME, playerManager: new PlayerManager(), dice: DICE);
+            Game game = new(name: GAME_NAME,
+                playerManager: new PlayerManager(),
+                dice: DICE_2);
+
             game.PlayerManager.Add(PLAYER_1);
 
             // Act
@@ -234,7 +228,10 @@ namespace Tests.Model_UTs
         public void TestPrepareNextPlayerWhenNonExistentThenException()
         {
             // Arrange
-            Game game = new(name: GAME_NAME, playerManager: new PlayerManager(), dice: DICE);
+            Game game = new(name: GAME_NAME,
+                playerManager: new PlayerManager(),
+                dice: DICE_1);
+
             game.PlayerManager.Add(PLAYER_2);
 
             // Act
@@ -248,7 +245,10 @@ namespace Tests.Model_UTs
         public void TestPrepareNextPlayerWhenValidThenCorrectWithSeveralPlayers()
         {
             // Arrange
-            Game game = new(name: GAME_NAME, playerManager: new PlayerManager(), dice: DICE);
+            Game game = new(name: GAME_NAME,
+                playerManager: new PlayerManager(),
+                dice: DICE_2);
+
             game.PlayerManager.Add(PLAYER_1);
             game.PlayerManager.Add(PLAYER_2);
 
@@ -268,7 +268,10 @@ namespace Tests.Model_UTs
         public void TestPrepareNextPlayerWhenValidThenCorrectWithOnePlayer()
         {
             // Arrange
-            Game game = new(name: GAME_NAME, playerManager: new PlayerManager(), dice: DICE);
+            Game game = new(name: GAME_NAME,
+                playerManager: new PlayerManager(),
+                dice: DICE_1);
+
             game.PlayerManager.Add(PLAYER_1);
 
             // Act
@@ -287,7 +290,9 @@ namespace Tests.Model_UTs
         public void TestAddPlayerToGame()
         {
             // Arrange
-            Game game = new(name: GAME_NAME, playerManager: new PlayerManager(), dice: DICE);
+            Game game = new(name: GAME_NAME,
+                playerManager: new PlayerManager(),
+                dice: DICE_2);
 
             // Act
             Player expected = PLAYER_1;
@@ -301,7 +306,9 @@ namespace Tests.Model_UTs
         public void TestGetPlayersFromGame()
         {
             // Arrange
-            Game game = new(name: GAME_NAME, playerManager: new PlayerManager(), dice: DICE);
+            Game game = new(name: GAME_NAME,
+                playerManager: new PlayerManager(),
+                dice: DICE_1);
 
             // Act
             Assert.Empty(game.PlayerManager.GetAll());
@@ -315,7 +322,10 @@ namespace Tests.Model_UTs
         public void TestUpdatePlayerInGame()
         {
             // Arrange
-            Game game = new(name: GAME_NAME, playerManager: new PlayerManager(), dice: DICE);
+            Game game = new(name: GAME_NAME,
+                playerManager: new PlayerManager(),
+                dice: DICE_2);
+
             game.PlayerManager.Add(PLAYER_1);
 
             // Act
@@ -330,7 +340,10 @@ namespace Tests.Model_UTs
         public void TestRemovePlayerFromGame()
         {
             // Arrange
-            Game game = new(name: GAME_NAME, playerManager: new PlayerManager(), dice: DICE);
+            Game game = new(name: GAME_NAME,
+                playerManager: new PlayerManager(),
+                dice: DICE_1);
+
             game.PlayerManager.Add(PLAYER_1);
             game.PlayerManager.Add(PLAYER_2);
             game.PlayerManager.Remove(PLAYER_1);
@@ -342,54 +355,5 @@ namespace Tests.Model_UTs
             // Assert
             Assert.Equal(expected, actual);
         }
-
-        [Fact]
-        public void TestToString()
-        {
-            // Arrange
-            DateTime dateTime = DateTime.UtcNow;
-
-            List<Turn> turns = new()
-            {
-                Turn.CreateWithSpecifiedTime(dateTime, PLAYER_1, new()
-                {
-                    {NUM, new NumberDieFace(4)},
-                    {IMG, new ImageDieFace(40)},
-                    {CLR, new ColorDieFace("A00FA0")},
-                }),
-                Turn.CreateWithSpecifiedTime(dateTime, PLAYER_2, new()
-                {
-                    {NUM, new NumberDieFace(3)},
-                    {IMG, new ImageDieFace(20)},
-                    {CLR, new ColorDieFace("A00BB8")},
-                }),
-            };
-
-            Game game = new(name: GAME_NAME, playerManager: new PlayerManager(), dice: DICE, turns: turns);
-            game.PlayerManager.Add(PLAYER_1);
-            game.PlayerManager.Add(PLAYER_2);
-
-            // Act
-            string[] dateTimeString = dateTime.ToString("s", System.Globalization.CultureInfo.InvariantCulture).Split("T");
-
-            string date = dateTimeString[0];
-            string time = dateTimeString[1];
-
-            string expected =
-                "Game: my game" +
-                "\nPlayers: Alice Bob" +
-                "\nNext: Alice" +
-                "\nLog:" +
-                "\n\t" + date + " " + time + " -- Alice rolled: 4 Assets/images/40.png #A00FA0" +
-                "\n\t" + date + " " + time + " -- Bob rolled: 3 Assets/images/20.png #A00BB8" +
-                "\n";
-            string actual = game.ToString();
-
-            Debug.WriteLine("expected:\n" + expected);
-            Debug.WriteLine("actual:\n" + actual);
-
-            // Assert
-            Assert.Equal(expected, actual);
-        }
     }
 }

Sources/Tests/Model_UTs/TurnTest.cs

@@ -1,322 +1,245 @@
-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);
+using Data;
+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 GameRunner stubGameRunner = new Stub().LoadApp();
+
+        Dictionary<Die, Face> DICE_N_FACES_1, DICE_N_FACES_2;
+
+        public TurnTest()
+        {
+            DICE_N_FACES_1 = (Dictionary<Die, Face>)stubGameRunner.GetAll().First().GetHistory().First().DiceNFaces;
+            DICE_N_FACES_2 = (Dictionary<Die, Face>)stubGameRunner.GetAll().Last().GetHistory().Last().DiceNFaces;
+        }
+
+        [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 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 TestDiceNFacesProperty()
+        {
+            // Arrange
+            Player player = new("Erika");
+
+            // Act
+            Turn turn = Turn.CreateWithDefaultTime(player, DICE_N_FACES_1);
+            IEnumerable<KeyValuePair<Die, Face>> expected = DICE_N_FACES_1.AsEnumerable();
+
+            // Assert
+            Assert.Equal(expected, turn.DiceNFaces);
         }
 
-        [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 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 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()));
-        }
-    }
-}
+        [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()));
+        }
+    }
+}