refactoring vom AussetzenKarteAufStapelLegenTest Code

Code in eine Methode extrahiert

BlazorSolution/MiniGames/Client/ViewModel/Uno.cs

@@ -1,210 +1,272 @@
 using MiniGames.Shared.Enums;
 using MiniGames.Shared.Models;
-using System;
 using System.Collections.Generic;
 using System.Linq;
 
 namespace MiniGames.Client.ViewModel
-{
-    public class Uno : IUno
-    {
-        public StapelModel KartenAblageStapel { get; set; } = new();
-        public StapelModel ZiehKartenStapel { get; set; } = new();
-        public List<HandKartenModel> Spieler { get; set; } = new();
-        public int NaechsterSpielerId { get; set; }
-
-        public bool IstAblageStapelFarbeGleichZuLegendeKarte(string neueKarteFarbe)
-        {
-            bool ergebnis;
-
-            _ = KartenAblageStapel.KartenModels.LastOrDefault().Farbe.Equals(neueKarteFarbe) ? ergebnis = true : ergebnis = false;
-
-            return ergebnis;
-        }
-
-        public bool IstAblageStapelZahlGleichZuLegendeKarte(string handStapelKarteBezeichnung)
-        {
-            bool ergebnis;
+{
+	public class Uno : IUno
+	{
+		public StapelModel AblageKartenStapel { get; set; } = new();
+		public StapelModel ZiehKartenStapel { get; set; } = new();
+		public List<HandKartenModel> Spieler { get; set; } = new();
+		public int NaechsterSpielerId { get; set; }
+		public bool Uhrzeigersinn { get; set; } = true;
 
-            _ = KartenAblageStapel.KartenModels.LastOrDefault().Name.Equals(handStapelKarteBezeichnung) ? ergebnis = true : ergebnis = false;
+		public bool IstAblageStapelFarbeGleichZuLegendeKarte(string neueKarteFarbe)
+		{
+			bool ergebnis;
 
-            return ergebnis;
-        }
-
-        public void ZiehEineKarte(int id)
-        {
-            int _id = id;
-            int index = Spieler.FindIndex(x => x.SpielerModel.Id == _id);
-
-            Spieler[index].KartenModels.Add(ZiehKartenStapel.KartenModels.FirstOrDefault());
-            ZiehKartenStapel.KartenModels.RemoveAt(0);
-        }
-
-        public void KarteAufStapelLegen(int id, KartenModel zuLegendeKarte)
-        {
-            int _id = id;
-            StapelModel _stapelModel = new();
-            _stapelModel.KartenModels = new();
-            const string _plusZweiKarte = "PlusZweiKarte";
-            const string _retoureKarte = "RetoureKarte";
-            const string _aussetzenKarte = "AussetzenKarte";
-
-            if (KartenAblageStapel.KartenModels is null)
-            {
-                KartenAblageStapel.KartenModels = new();
-            }
-
-            switch (zuLegendeKarte.Name)
-            {
-                case _plusZweiKarte:
-                    for (int i = 0; i < 2; i++)
-                    {
-                        ZiehEineKarte(_id);
-                    }
-                    break;
-                case _retoureKarte:
-                    break;
-                case _aussetzenKarte:
-                    break;
-                default:
-                    break;
-
-            }
-
-        }
-
-        public void SpielerErstellen(string spielerName)
-        {
-            string _spielerName = spielerName;
-            Spieler.Add(
-                new HandKartenModel
-                {
-                    SpielerModel = new()
-                    {
-                        Id = Spieler.Count() + 1,
-                        SpielerName = _spielerName,
-                    },
-                    KartenModels = new()
-                });
-        }
-
-        public void SpielerWahl(int aktuellerSpielerId, bool uhrZeigerSinn)
-        {
-            var aktuellerSpielerIndex = Spieler.FindIndex(x => x.SpielerModel.Id == aktuellerSpielerId);
-            if (uhrZeigerSinn)
-            {
-                if (aktuellerSpielerIndex == Spieler.Count() - 1)
-                {
-                    NaechsterSpielerId = 1;
-                }
-                else
-                {
-                    NaechsterSpielerId = Spieler[aktuellerSpielerIndex + 1].SpielerModel.Id;
-                }
-            }
-            else
-            {
-                if (aktuellerSpielerIndex != 0)
-                {
-                    NaechsterSpielerId = Spieler[aktuellerSpielerIndex - 1].SpielerModel.Id;
-                }
-                else
-                {
-                    NaechsterSpielerId = Spieler.LastOrDefault().SpielerModel.Id;
-                }
-            }
-        }
-
-        #region Stapel Erstellen
-        public static StapelModel ErstelleStandardKarten()
-        {
-            StapelModel stapelModel = new();
-            stapelModel.KartenModels = new();
-            for (int f = 1; f <= 4; f++)
-            {
-                for (int k = 1; k <= 19; k++)
-                {
-                    var kartenbezeichnung = (Kartenbezeichnung)k;
-                    var kartenfarbe = (Farbe)f;
-                    stapelModel.KartenModels.Add(
-                        new KartenModel
-                        {
-                            Name = kartenbezeichnung.ToString(),
-                            Farbe = kartenfarbe.ToString(),
-                            Spezial = false
-                        }
-                        );
-                }
-            }
-
-            return stapelModel;
-        }
-
-        public static StapelModel ErstelleFarbigeSpezialKarten()
-        {
-            StapelModel stapelModel = new();
-            stapelModel.KartenModels = new();
-            for (int k = 10; k <= 12; k++)
-            {
-                for (int f = 1; f <= 4; f++)
-                {
-                    for (int i = 0; i < 2; i++)
-                    {
-                        var _kartenbezeichnung = (Kartenbezeichnung)k;
-                        var kartenfarbe = (Farbe)f;
-                        stapelModel.KartenModels.Add(
-                            new KartenModel
-                            {
-                                Name = _kartenbezeichnung.ToString(),
-                                Farbe = kartenfarbe.ToString(),
-                                Spezial = true
-                            }
-                            );
-                    }
-                }
-            }
-
-            return stapelModel;
-        }
-
-        public static StapelModel ErstelleJokerKarten()
-        {
-            StapelModel stapelModel = new();
-            stapelModel.KartenModels = new();
-
-            for (int k = 13; k <= 14; k++)
-            {
-                for (int a = 0; a < 4; a++)
-                {
-                    var kartenbezeichnung = (Kartenbezeichnung)k;
-                    stapelModel.KartenModels.Add(
-                        new KartenModel
-                        {
-                            Name = kartenbezeichnung.ToString(),
-                            Farbe = Farbe.Keine.ToString(),
-                            Spezial = true
-                        }
-                        );
-                }
-
-            }
-
-            return stapelModel;
-        }
-
-        public void ZiehKartenStapelZusammenstellen()
-        {
-            var standardKarten = Uno.ErstelleStandardKarten();
-            var spezialKarten = Uno.ErstelleFarbigeSpezialKarten();
-            var jokerKarten = Uno.ErstelleJokerKarten();
-
-            ZiehKartenStapel.KartenModels = new();
-            ZiehKartenStapel.KartenModels.AddRange(standardKarten.KartenModels);
-            ZiehKartenStapel.KartenModels.AddRange(spezialKarten.KartenModels);
-            ZiehKartenStapel.KartenModels.AddRange(jokerKarten.KartenModels);
-        }
+			_ = AblageKartenStapel.KartenModels.LastOrDefault().Farbe.Equals(neueKarteFarbe) ? ergebnis = true : ergebnis = false;
+
+			return ergebnis;
+		}
+
+		public bool IstAblageStapelZahlGleichZuLegendeKarte(string handStapelKarteBezeichnung)
+		{
+			bool ergebnis;
+
+			_ = AblageKartenStapel.KartenModels.LastOrDefault().Name.Equals(handStapelKarteBezeichnung) ? ergebnis = true : ergebnis = false;
+
+			return ergebnis;
+		}
+
+		public void ZiehEineKarte(int id)
+		{
+			int _id = id;
+			int index = Spieler.FindIndex(x => x.SpielerModel.Id == _id);
+
+			Spieler[index].KartenModels.Add(ZiehKartenStapel.KartenModels.FirstOrDefault());
+			ZiehKartenStapel.KartenModels.RemoveAt(0);
+		}
+
+		public void KarteAufStapelLegen(int id, KartenModel zuLegendeKarte)
+		{
+			NaechsterSpielerWahl(id, Uhrzeigersinn);
+			int _naechstenId = NaechsterSpielerId;
+
+			StapelModel _stapelModel = new();
+			_stapelModel.KartenModels = new();
+			const string _plusZweiKarte = "PlusZweiKarte";
+			const string _retoureKarte = "RetoureKarte";
+			const string _aussetzenKarte = "AussetzenKarte";
+
+			if (AblageKartenStapel.KartenModels is null)
+			{
+				AblageKartenStapel.KartenModels = new();
+			}
+
+			switch (zuLegendeKarte.Name)
+			{
+				case _plusZweiKarte:
+					for (int i = 0; i < 2; i++)
+					{
+						ZiehEineKarte(_naechstenId);
+					}
+					break;
+
+				case _retoureKarte:
+					_naechstenId = RetoureKarte(id);
+					break;
+
+				case _aussetzenKarte:
+					AussetzenKarteSpielerWahl(id, Uhrzeigersinn);
+					break;
+
+				default:
+					break;
+
+			}
+
+		}
+
+		private int RetoureKarte(int id)
+		{
+			Uhrzeigersinn = !Uhrzeigersinn;
+			NaechsterSpielerWahl(id, Uhrzeigersinn);
+			return NaechsterSpielerId;
+		}
+
+		public void SpielerErstellen(string spielerName)
+		{
+			string _spielerName = spielerName;
+			Spieler.Add(
+				new HandKartenModel
+				{
+					SpielerModel = new()
+					{
+						Id = Spieler.Count() + 1,
+						SpielerName = _spielerName,
+					},
+					KartenModels = new()
+				});
+		}
+
+		public void NaechsterSpielerWahl(int aktuellerSpielerId, bool uhrZeigerSinn)
+		{
+			var aktuellerSpielerIndex = Spieler.FindIndex(x => x.SpielerModel.Id == aktuellerSpielerId);
+			if (uhrZeigerSinn)
+			{
+				if (aktuellerSpielerIndex == Spieler.Count() - 1)
+				{
+					NaechsterSpielerId = 1;
+				}
+				else
+				{
+					NaechsterSpielerId = Spieler[aktuellerSpielerIndex + 1].SpielerModel.Id;
+				}
+			}
+			else
+			{
+				if (aktuellerSpielerIndex != 0)
+				{
+					NaechsterSpielerId = Spieler[aktuellerSpielerIndex - 1].SpielerModel.Id;
+				}
+				else
+				{
+					NaechsterSpielerId = Spieler.LastOrDefault().SpielerModel.Id;
+				}
+			}
+		}
+
+		private void AussetzenKarteSpielerWahl(int aktuellerSpielerId, bool uhrZeigerSinn)
+		{
+			if (uhrZeigerSinn)
+			{
+				if (aktuellerSpielerId == Spieler.LastOrDefault().SpielerModel.Id)
+				{
+					NaechsterSpielerId = 2;
+				}
+				else if (aktuellerSpielerId == Spieler.LastOrDefault().SpielerModel.Id - 1)
+				{
+					NaechsterSpielerId = 1;
+				}
+				else
+				{
+					NaechsterSpielerId = aktuellerSpielerId + 2;
+				}
+			}
+			else
+			{
+				if (aktuellerSpielerId > 2)
+				{
+					NaechsterSpielerId = aktuellerSpielerId - 2;
+				}
+				else if (aktuellerSpielerId == 2)
+				{
+					NaechsterSpielerId = Spieler.LastOrDefault().SpielerModel.Id;
+				}
+				else
+				{
+					NaechsterSpielerId = Spieler.LastOrDefault().SpielerModel.Id - 1;
+				}
+			}
+		}
+
+		#region Stapel Erstellen
+		public static StapelModel ErstelleStandardKarten()
+		{
+			StapelModel stapelModel = new();
+			stapelModel.KartenModels = new();
+			for (int f = 1; f <= 4; f++)
+			{
+				EinzelneKarteErstellen(stapelModel, f, 0, false);
+
+				for (int k = 1; k <= 9; k++)
+				{
+					for (int a = 0; a < 2; a++)
+					{
+						EinzelneKarteErstellen(stapelModel, f, k, false);
+					}
+				}
+
+			}
+
+			return stapelModel;
+		}
+
+		private static void EinzelneKarteErstellen(StapelModel stapelModel, int farbenIndex, int kartenbezeichungIndex, bool spezial)
+		{
+			var kartenbezeichnung = (Kartenbezeichnung)kartenbezeichungIndex;
+			var kartenfarbe = (Farbe)farbenIndex;
+			stapelModel.KartenModels.Add(
+				new KartenModel
+				{
+					Name = kartenbezeichnung.ToString(),
+					Farbe = kartenfarbe.ToString(),
+					Spezial = spezial
+				}
+				);
+		}
+
+		public static StapelModel ErstelleFarbigeSpezialKarten()
+		{
+			StapelModel stapelModel = new();
+			stapelModel.KartenModels = new();
+			for (int k = 10; k <= 12; k++)
+			{
+				for (int f = 1; f <= 4; f++)
+				{
+					for (int i = 0; i < 2; i++)
+					{
+						EinzelneKarteErstellen(stapelModel, f, k, true);
+					}
+				}
+			}
+
+			return stapelModel;
+		}
+
+		public void InitialeKartenVerteilung()
+		{
+			for (int i = 0; i < 7; i++)
+			{
+				foreach (var spieler in Spieler)
+				{
+					spieler.KartenModels.Add(ZiehKartenStapel.KartenModels.FirstOrDefault());
+					ZiehKartenStapel.KartenModels.RemoveAt(0);
+				}
+			}
+		}
+
+		public static StapelModel ErstelleJokerKarten()
+		{
+			StapelModel stapelModel = new();
+			stapelModel.KartenModels = new();
+
+			for (int k = 13; k <= 14; k++)
+			{
+				for (int a = 0; a < 4; a++)
+				{
+					var kartenbezeichnung = (Kartenbezeichnung)k;
+					stapelModel.KartenModels.Add(
+						new KartenModel
+						{
+							Name = kartenbezeichnung.ToString(),
+							Farbe = Farbe.Keine.ToString(),
+							Spezial = true
+						}
+						);
+				}
+
+			}
+
+			return stapelModel;
+		}
+
+		public void ZiehKartenStapelZusammenstellen()
+		{
+			var standardKarten = Uno.ErstelleStandardKarten();
+			var spezialKarten = Uno.ErstelleFarbigeSpezialKarten();
+			var jokerKarten = Uno.ErstelleJokerKarten();
+
+			ZiehKartenStapel.KartenModels = new();
+			ZiehKartenStapel.KartenModels.AddRange(standardKarten.KartenModels);
+			ZiehKartenStapel.KartenModels.AddRange(spezialKarten.KartenModels);
+			ZiehKartenStapel.KartenModels.AddRange(jokerKarten.KartenModels);
+		}
 
 
-        #endregion
-    }
+		#endregion
+	}
 }

BlazorSolution/MiniGames/Shared/Enums/Enums.cs

@@ -9,6 +9,7 @@ namespace MiniGames.Shared.Enums
     [Flags]
     public enum Kartenbezeichnung
     {
+        Null = 0,
         Eins = 1,
         Zwei = 2,
         Drei = 3,

BlazorSolution/MiniGamesTests/UnoTest.cs

@@ -7,358 +7,528 @@ using Xunit;
 
 namespace MiniGamesTests
 {
-    public class UnoTest
-    {
-        public Uno UnoRegeln = new();
-
-        private KartenModel BeispielKarte(string name, string farbe, bool spezial)
-        {
-            var _name = name;
-            var _farbe = farbe;
-            var _spezial = spezial;
-
-            KartenModel kartenModel = new()
-            {
-                Name = _name,
-                Farbe = _farbe,
-                Spezial = _spezial
-            };
-
-            return kartenModel;
-        }
-
-        private HandKartenModel BeispielHand()
-        {
-            HandKartenModel HandStapel = new()
-            {
-                SpielerModel = new()
-                {
-                    Id = 1,
-                    SpielerName = "Andrej",
-                },
-
-                KartenModels = new()
-                {
-                    new KartenModel
-                    {
-                        Name = Kartenbezeichnung.PlusZweiKarte.ToString(),
-                        Farbe = Farbe.Gelb.ToString(),
-                        Spezial = true
-                    }
-                }
-            };
-
-            return HandStapel;
-        }
-
-        private StapelModel BeispielStapelModelKarten(string name, string farbe, bool spezial)
-        {
-            var _name = name;
-            var _farbe = farbe;
-            var _spezial = spezial;
-
-            StapelModel TestStapel = new();
-            TestStapel.KartenModels = new()
-            {
-                new KartenModel
-                {
-                    Name = _name,
-                    Farbe = _farbe,
-                    Spezial = _spezial
-                },
-            };
-            return TestStapel;
-        }
-
-        #region UserManagement
-        [Theory]
-        [InlineData("Andrej", 1)]
-        private void SpielerErstellenTest(string spielerName, int id)
-        {
-            //arrange
-            var _spielerName = spielerName;
-            var _id = id;
-
-            //act
-            UnoRegeln.SpielerErstellen(_spielerName);
-            var ergebnis = UnoRegeln.Spieler;
-
-            //assert
-            Assert.Equal(_spielerName, ergebnis[0].SpielerModel.SpielerName);
-            Assert.Equal(_id, ergebnis[0].SpielerModel.Id);
-        }
-
-        [Theory]
-        [InlineData("Andrej", 1, "Paul", 2, "Erhard", 3)]
-        [InlineData("Sabine", 1, "Erich", 2, "Anna", 3)]
-        [InlineData("Thomas", 1, "Mike", 2, "Robin", 3)]
-        private void MehrereSpielerErstellenTest(string spielerEinsName, int spielerEinsId, string spielerZweiName, int spielerZweiId, string spielerDreiName, int spielerDreiId)
-        {
-            //arrange
-            var _spielerEinsName = spielerEinsName;
-            var _spielerEinsId = spielerEinsId;
-            var _spielerZweiName = spielerZweiName;
-            var _spielerZweiId = spielerZweiId;
-            var _spielerDreiName = spielerDreiName;
-            var _spielerDreiId = spielerDreiId;
-
-            //act
-            UnoRegeln.SpielerErstellen(_spielerEinsName);
-            UnoRegeln.SpielerErstellen(_spielerZweiName);
-            UnoRegeln.SpielerErstellen(_spielerDreiName);
-            var ergebnis = UnoRegeln.Spieler;
-
-            //assert
-            Assert.Equal(_spielerEinsName, ergebnis[0].SpielerModel.SpielerName);
-            Assert.Equal(_spielerEinsId, ergebnis[0].SpielerModel.Id);
-            Assert.NotNull(ergebnis[0].KartenModels);
-
-            Assert.Equal(_spielerZweiName, ergebnis[1].SpielerModel.SpielerName);
-            Assert.Equal(_spielerZweiId, ergebnis[1].SpielerModel.Id);
-            Assert.NotNull(ergebnis[1].KartenModels);
-
-            Assert.Equal(_spielerDreiName, ergebnis[2].SpielerModel.SpielerName);
-            Assert.Equal(_spielerDreiId, ergebnis[2].SpielerModel.Id);
-            Assert.NotNull(ergebnis[2].KartenModels);
-        }
-
-        [Theory]
-        [InlineData("Andrej", 1, "Paul", 2, "Erhard", 3, true, 2, 3)]
-        [InlineData("Sabine", 1, "Erich", 2, "Anna", 3, false, 3, 2)]
-        [InlineData("Thomas", 1, "Mike", 2, "Robin", 3, true, 2, 3)]
-        [InlineData("Andrej", 1, "Paul", 2, "Erhard", 3, true, 3, 1)]
-        [InlineData("Sabine", 1, "Erich", 2, "Anna", 3, false, 1, 3)]
-        private void NaechsterSpielerTest(string spielerEinsName, int spielerEinsId, string spielerZweiName, int spielerZweiId, string spielerDreiName, int spielerDreiId, bool uhrZeigerSinn, int aktuellerSpieler, int naechsterErwartung)
-        {
-            //arrange
-            var _spielerEinsName = spielerEinsName;
-            var _spielerEinsId = spielerEinsId;
-            var _spielerZweiName = spielerZweiName;
-            var _spielerZweiId = spielerZweiId;
-            var _spielerDreiName = spielerDreiName;
-            var _spielerDreiId = spielerDreiId;
-            var _uhrZeigerSinn = uhrZeigerSinn;
-            var _aktuellerSpieler = aktuellerSpieler;
-            var _naechsterErwartung = naechsterErwartung;
-
-            //act
-            UnoRegeln.SpielerErstellen(_spielerEinsName);
-            UnoRegeln.SpielerErstellen(_spielerZweiName);
-            UnoRegeln.SpielerErstellen(_spielerDreiName);
-            UnoRegeln.SpielerWahl(_aktuellerSpieler, _uhrZeigerSinn);
-
-            //assert
-            Assert.Equal(_naechsterErwartung, UnoRegeln.NaechsterSpielerId);
-
-        }
-
-        #endregion
-
-        [Theory]
-        [InlineData(Farbe.Rot, Farbe.Rot, true)]
-        [InlineData(Farbe.Blau, Farbe.Rot, false)]
-        [InlineData(Farbe.Rot, Farbe.Blau, false)]
-        [InlineData(Farbe.Blau, Farbe.Blau, true)]
-        [InlineData(Farbe.Gelb, Farbe.Rot, false)]
-        [InlineData(Farbe.Gruen, Farbe.Gruen, true)]
-        private void IstAblageStapelFarbeGleichZuLegendeKarteTest(Farbe ablegeStapelKarteFarbe, Farbe neueKarteFarbe, bool erwartet)
-        {
-            //arrange
-            var _ablegeStabelKarteFarbe = ablegeStapelKarteFarbe.ToString();
-            var _neueKarteFarbe = neueKarteFarbe.ToString();
-            var _erwartet = erwartet;
-
-
-            //act
-            UnoRegeln.KartenAblageStapel.KartenModels = new();
-            UnoRegeln.KartenAblageStapel.KartenModels.Add(
-                BeispielKarte("Testkarten Name", _ablegeStabelKarteFarbe, false)
-                );
-            var erhalten = UnoRegeln.IstAblageStapelFarbeGleichZuLegendeKarte(_neueKarteFarbe);
-
-            //assert
-            Assert.Equal(_erwartet, erhalten);
-        }
-
-        [Theory]
-        [InlineData(Kartenbezeichnung.Acht, Kartenbezeichnung.Acht, true)]
-        [InlineData(Kartenbezeichnung.Eins, Kartenbezeichnung.Acht, false)]
-        [InlineData(Kartenbezeichnung.Fuenf, Kartenbezeichnung.Vier, false)]
-        [InlineData(Kartenbezeichnung.Sechs, Kartenbezeichnung.Sechs, true)]
-        [InlineData(Kartenbezeichnung.Zwei, Kartenbezeichnung.Drei, false)]
-        [InlineData(Kartenbezeichnung.Neun, Kartenbezeichnung.Acht, false)]
-        private void IstAblageStapelZahlGleichZuLegendeKarteTest(Kartenbezeichnung ablegeStapelKarteBezeichnung, Kartenbezeichnung handStapelKarteBezeichnung, bool erwartet)
-        {
-            //arrange
-            var _ablegeStapelKarteBezeichnung = ablegeStapelKarteBezeichnung.ToString();
-            var _handStapelKarteBezeichnung = handStapelKarteBezeichnung.ToString();
-            var _erwartet = erwartet;
-
-            //act
-            UnoRegeln.KartenAblageStapel.KartenModels = new();
-            UnoRegeln.KartenAblageStapel.KartenModels.Add(
-                BeispielKarte(_ablegeStapelKarteBezeichnung, Farbe.Blau.ToString(), false)
-                );
-            var erhalten = UnoRegeln.IstAblageStapelZahlGleichZuLegendeKarte(_handStapelKarteBezeichnung);
-
-            //assert
-            Assert.Equal(_erwartet, erhalten);
-
-        }
-
-        [Fact]
-        private void ZiehEineKarteTest()
-        {
-            //arrange
-            UnoRegeln.ZiehKartenStapelZusammenstellen();
-            UnoRegeln.SpielerErstellen("Andrej");
-
-            var erwartet = UnoRegeln.ZiehKartenStapel.KartenModels.FirstOrDefault();
-
-            //act
-            UnoRegeln.ZiehEineKarte(1);
-
-            var erhalten = UnoRegeln.Spieler[0].KartenModels.LastOrDefault();
-
-            //assert
-            Assert.Equal(erwartet, erhalten);
-        }
-
-        [Theory]
-        [InlineData(Kartenbezeichnung.PlusZweiKarte, Farbe.Gelb, true)]
-        private void PlusZweiKarteAufStapelLegenTest(Kartenbezeichnung kartenbezeichnung, Farbe farbe, bool spezial)
-        {
-            //arrange
-            UnoRegeln.ZiehKartenStapelZusammenstellen();
-            var kartenAblageStapel = UnoRegeln.KartenAblageStapel;
-            var ziehKartenStapel = UnoRegeln.ZiehKartenStapel;
-
-            var _kartenbezeichnung = kartenbezeichnung.ToString();
-            var _farbe = farbe.ToString();
-            var _spezial = spezial;
-            var naechstenHand = BeispielHand();
-            var beispielZuLegendeKarte = BeispielKarte(_kartenbezeichnung, _farbe, _spezial);
-
-
-            //act
-            //naechstenHand.KartenModels = UnoRegeln.KarteAufStapelLegen(naechstenHand.KartenModels, beispielZuLegendeKarte);
-
-            //assert
-        }
-
-        #region Stapel erstellen
-        [Theory]
-        [InlineData((Kartenbezeichnung)2, Farbe.Gelb, false, 19)]
-        [InlineData((Kartenbezeichnung)7, Farbe.Blau, false, 19)]
-        [InlineData((Kartenbezeichnung)9, Farbe.Gruen, false, 19)]
-        [InlineData((Kartenbezeichnung)4, Farbe.Rot, false, 19)]
-        [InlineData((Kartenbezeichnung)5, Farbe.Blau, false, 19)]
-        [InlineData((Kartenbezeichnung)9, Farbe.Gelb, false, 19)]
-        [InlineData((Kartenbezeichnung)6, Farbe.Gruen, false, 19)]
-        private void ErstelleStandardKartenTest(Kartenbezeichnung kartenbezeichnung, Farbe farbe, bool spezial, int anzahl)
-        {
-            //arrange
-            var _kartenbezeichnung = kartenbezeichnung.ToString();
-            var _farbe = farbe.ToString();
-            var _spezial = spezial;
-            var _anzahl = anzahl;
-            var erwartet = BeispielKarte(_kartenbezeichnung, _farbe, _spezial);
-
-            //act
-            var neuesDeck = Uno.ErstelleStandardKarten();
-            var anzahlBlau = neuesDeck.KartenModels.Where(x => x.Farbe.Equals(Farbe.Blau.ToString())).Count();
-            var anzahlRot = neuesDeck.KartenModels.Where(x => x.Farbe.Equals(Farbe.Rot.ToString())).Count();
-            var anzahlGruen = neuesDeck.KartenModels.Where(x => x.Farbe.Equals(Farbe.Gruen.ToString())).Count();
-            var anzahlGelb = neuesDeck.KartenModels.Where(x => x.Farbe.Equals(Farbe.Gelb.ToString())).Count();
-
-            //assert           
-            Assert.Equal(_anzahl, anzahlBlau);
-            Assert.Equal(_anzahl, anzahlRot);
-            Assert.Equal(_anzahl, anzahlGruen);
-            Assert.Equal(_anzahl, anzahlGelb);
-
-            Assert.Contains(neuesDeck.KartenModels, n =>
-                n.Name.Equals(erwartet.Name) &&
-                n.Farbe.Equals(erwartet.Farbe) &&
-                n.Spezial == erwartet.Spezial
-            );
-        }
-
-        [Theory]
-        [InlineData(Kartenbezeichnung.PlusZweiKarte, Farbe.Gelb, true, 6)]
-        [InlineData(Kartenbezeichnung.RetoureKarte, Farbe.Rot, true, 6)]
-        [InlineData(Kartenbezeichnung.AussetzenKarte, Farbe.Gelb, true, 6)]
-        [InlineData(Kartenbezeichnung.PlusZweiKarte, Farbe.Blau, true, 6)]
-        [InlineData(Kartenbezeichnung.PlusZweiKarte, Farbe.Gruen, true, 6)]
-        [InlineData(Kartenbezeichnung.RetoureKarte, Farbe.Gelb, true, 6)]
-        [InlineData(Kartenbezeichnung.AussetzenKarte, Farbe.Gruen, true, 6)]
-        [InlineData(Kartenbezeichnung.PlusZweiKarte, Farbe.Rot, true, 6)]
-        private void ErstelleFarbigeSpezialKartenTest(Kartenbezeichnung kartenbezeichnung, Farbe farbe, bool spezial, int anzahl)
-        {
-            //arrange
-            var _kartenbezeichnung = kartenbezeichnung.ToString();
-            var _farbe = farbe.ToString();
-            var _spezial = spezial;
-            var _anzahl = anzahl;
-            var erwartet = BeispielKarte(_kartenbezeichnung, _farbe, _spezial);
-
-            //act
-            var neuesDeck = Uno.ErstelleFarbigeSpezialKarten();
-            var anzahlBlau = neuesDeck.KartenModels.Where(x => x.Farbe.Equals(Farbe.Blau.ToString())).Count();
-            var anzahlRot = neuesDeck.KartenModels.Where(x => x.Farbe.Equals(Farbe.Rot.ToString())).Count();
-            var anzahlGruen = neuesDeck.KartenModels.Where(x => x.Farbe.Equals(Farbe.Gruen.ToString())).Count();
-            var anzahlGelb = neuesDeck.KartenModels.Where(x => x.Farbe.Equals(Farbe.Gelb.ToString())).Count();
-
-
-            //assert
-            Assert.Equal(_anzahl, anzahlBlau);
-            Assert.Equal(_anzahl, anzahlRot);
-            Assert.Equal(_anzahl, anzahlGruen);
-            Assert.Equal(_anzahl, anzahlGelb);
-
-            Assert.Contains(neuesDeck.KartenModels, n =>
-                n.Name.Equals(erwartet.Name) &&
-                n.Farbe.Equals(erwartet.Farbe) &&
-                n.Spezial == erwartet.Spezial
-            );
-        }
-
-        [Theory]
-        [InlineData(Kartenbezeichnung.FarbwahlKarte, Farbe.Keine, true, 4)]
-        [InlineData(Kartenbezeichnung.ZiehVierFarbenwahlkarte, Farbe.Keine, true, 4)]
-        private void ErstelleJokerKartenTest(Kartenbezeichnung kartenbezeichnung, Farbe farbe, bool spezial, int anzahl)
-        {
-            //arrange
-            var _kartenbezeichnung = kartenbezeichnung.ToString();
-            var _farbe = farbe.ToString();
-            var _spezial = spezial;
-            var _anzahl = anzahl;
-            var erwartet = BeispielKarte(_kartenbezeichnung, _farbe, _spezial);
-
-            //act
-            var neuesDeck = Uno.ErstelleJokerKarten();
-            var ergebnisAnzahl = neuesDeck.KartenModels.Where(x => x.Name.Equals(kartenbezeichnung.ToString())).Count();
-
-            //assert
-            Assert.Equal(_anzahl, ergebnisAnzahl);
-            Assert.Contains(neuesDeck.KartenModels, n =>
-                n.Name.Equals(erwartet.Name) &&
-                n.Farbe.Equals(erwartet.Farbe) &&
-                n.Spezial == erwartet.Spezial
-            );
-        }
-
-        [Fact]
-        private void AblagestapelZusammenstellenTest()
-        {
-
-            UnoRegeln.ZiehKartenStapelZusammenstellen();
-
-            var ergebnis = UnoRegeln.ZiehKartenStapel;
-
-            Assert.Equal(108, ergebnis.KartenModels.Count());
-        }
-
-        #endregion
-    }
+	public class UnoTest
+	{
+		public Uno UnoRegeln = new();
+		public List<SpielerModel> SpielerModels = new();
+
+		private KartenModel BeispielKarte(string name, string farbe, bool spezial)
+		{
+			var _name = name;
+			var _farbe = farbe;
+			var _spezial = spezial;
+
+			KartenModel kartenModel = new()
+			{
+				Name = _name,
+				Farbe = _farbe,
+				Spezial = _spezial
+			};
+
+			return kartenModel;
+		}
+
+		private HandKartenModel BeispielHand()
+		{
+			HandKartenModel HandStapel = new()
+			{
+				SpielerModel = new()
+				{
+					Id = 1,
+					SpielerName = "Andrej",
+				},
+
+				KartenModels = new()
+				{
+					new KartenModel
+					{
+						Name = Kartenbezeichnung.PlusZweiKarte.ToString(),
+						Farbe = Farbe.Gelb.ToString(),
+						Spezial = true
+					}
+				}
+			};
+
+			return HandStapel;
+		}
+
+		private void BeispielSpielerModelsFüllen(int id, string spielerName)
+		{
+			int _id = id;
+			string _spielerName = spielerName;
+
+			SpielerModels.Add(new SpielerModel()
+			{
+				Id = _id,
+				SpielerName = _spielerName,
+				Punkte = 0
+			});
+		}
+
+		private void BeispielMultipleSpielerModelsFüllen(int anzahlSpieler)
+		{
+			switch (anzahlSpieler)
+			{
+				case 2:
+					BeispielSpielerModelsFüllen(1, "Hans");
+					BeispielSpielerModelsFüllen(2, "Peter");
+					break;
+				case 3:
+					BeispielSpielerModelsFüllen(1, "Hans");
+					BeispielSpielerModelsFüllen(2, "Peter");
+					BeispielSpielerModelsFüllen(3, "Anna");
+					break;
+				case 4:
+					BeispielSpielerModelsFüllen(1, "Hans");
+					BeispielSpielerModelsFüllen(2, "Peter");
+					BeispielSpielerModelsFüllen(3, "Anna");
+					BeispielSpielerModelsFüllen(4, "Klaus");
+					break;
+				case 5:
+					BeispielSpielerModelsFüllen(1, "Hans");
+					BeispielSpielerModelsFüllen(2, "Peter");
+					BeispielSpielerModelsFüllen(3, "Anna");
+					BeispielSpielerModelsFüllen(4, "Klaus");
+					BeispielSpielerModelsFüllen(5, "Brigitte");
+					break;
+				case 6:
+					BeispielSpielerModelsFüllen(1, "Hans");
+					BeispielSpielerModelsFüllen(2, "Peter");
+					BeispielSpielerModelsFüllen(3, "Anna");
+					BeispielSpielerModelsFüllen(4, "Klaus");
+					BeispielSpielerModelsFüllen(5, "Brigitte");
+					BeispielSpielerModelsFüllen(6, "Morty");
+					break;
+				default:
+					break;
+			}
+		}
+
+		private StapelModel BeispielStapelModelKarten(string name, string farbe, bool spezial)
+		{
+			var _name = name;
+			var _farbe = farbe;
+			var _spezial = spezial;
+
+			StapelModel TestStapel = new();
+			TestStapel.KartenModels = new()
+			{
+				new KartenModel
+				{
+					Name = _name,
+					Farbe = _farbe,
+					Spezial = _spezial
+				},
+			};
+			return TestStapel;
+		}
+
+		#region UserManagement
+		[Theory]
+		[InlineData("Andrej", 1)]
+		private void SpielerErstellenTest(string spielerName, int id)
+		{
+			//arrange
+			var _spielerName = spielerName;
+			var _id = id;
+
+			//act
+			UnoRegeln.SpielerErstellen(_spielerName);
+			var ergebnis = UnoRegeln.Spieler;
+
+			//assert
+			Assert.Equal(_spielerName, ergebnis[0].SpielerModel.SpielerName);
+			Assert.Equal(_id, ergebnis[0].SpielerModel.Id);
+		}
+
+		[Theory]
+		[InlineData("Andrej", 1, "Paul", 2, "Erhard", 3)]
+		[InlineData("Sabine", 1, "Erich", 2, "Anna", 3)]
+		[InlineData("Thomas", 1, "Mike", 2, "Robin", 3)]
+		private void MehrereSpielerErstellenTest(string spielerEinsName, int spielerEinsId, string spielerZweiName, int spielerZweiId, string spielerDreiName, int spielerDreiId)
+		{
+			//arrange
+			var _spielerEinsName = spielerEinsName;
+			var _spielerEinsId = spielerEinsId;
+			var _spielerZweiName = spielerZweiName;
+			var _spielerZweiId = spielerZweiId;
+			var _spielerDreiName = spielerDreiName;
+			var _spielerDreiId = spielerDreiId;
+
+			//act
+			UnoRegeln.SpielerErstellen(_spielerEinsName);
+			UnoRegeln.SpielerErstellen(_spielerZweiName);
+			UnoRegeln.SpielerErstellen(_spielerDreiName);
+			var ergebnis = UnoRegeln.Spieler;
+
+			//assert
+			Assert.Equal(_spielerEinsName, ergebnis[0].SpielerModel.SpielerName);
+			Assert.Equal(_spielerEinsId, ergebnis[0].SpielerModel.Id);
+			Assert.NotNull(ergebnis[0].KartenModels);
+
+			Assert.Equal(_spielerZweiName, ergebnis[1].SpielerModel.SpielerName);
+			Assert.Equal(_spielerZweiId, ergebnis[1].SpielerModel.Id);
+			Assert.NotNull(ergebnis[1].KartenModels);
+
+			Assert.Equal(_spielerDreiName, ergebnis[2].SpielerModel.SpielerName);
+			Assert.Equal(_spielerDreiId, ergebnis[2].SpielerModel.Id);
+			Assert.NotNull(ergebnis[2].KartenModels);
+		}
+
+		[Theory]
+		[InlineData(2)]
+		[InlineData(3)]
+		[InlineData(4)]
+		[InlineData(5)]
+		private void InitialeKartenVerteilungTest(int anzahlSpieler)
+		{
+			//arrange
+			var _anzahlSpieler = anzahlSpieler;
+
+			BeispielMultipleSpielerModelsFüllen(_anzahlSpieler);
+
+			foreach (var spieler in SpielerModels)
+			{
+				UnoRegeln.SpielerErstellen(spieler.SpielerName);
+			}
+
+			UnoRegeln.ZiehKartenStapelZusammenstellen();
+
+			//act
+			UnoRegeln.InitialeKartenVerteilung();
+
+			//assert
+			foreach (var spieler in UnoRegeln.Spieler)
+			{
+				Assert.Equal(7, spieler.KartenModels.Count());
+			}
+		}
+
+		[Theory]
+		[InlineData("Andrej", 1, "Paul", 2, "Erhard", 3, true, 2, 3)]
+		[InlineData("Sabine", 1, "Erich", 2, "Anna", 3, false, 3, 2)]
+		[InlineData("Thomas", 1, "Mike", 2, "Robin", 3, true, 2, 3)]
+		[InlineData("Andrej", 1, "Paul", 2, "Erhard", 3, true, 3, 1)]
+		[InlineData("Sabine", 1, "Erich", 2, "Anna", 3, false, 1, 3)]
+		private void NaechsterSpielerTest(string spielerEinsName, int spielerEinsId, string spielerZweiName, int spielerZweiId, string spielerDreiName, int spielerDreiId, bool uhrZeigerSinn, int aktuellerSpieler, int naechsterErwartung)
+		{
+			//arrange
+			var _spielerEinsName = spielerEinsName;
+			var _spielerEinsId = spielerEinsId;
+			var _spielerZweiName = spielerZweiName;
+			var _spielerZweiId = spielerZweiId;
+			var _spielerDreiName = spielerDreiName;
+			var _spielerDreiId = spielerDreiId;
+			var _uhrZeigerSinn = uhrZeigerSinn;
+			var _aktuellerSpieler = aktuellerSpieler;
+			var _naechsterErwartung = naechsterErwartung;
+
+			//act
+			UnoRegeln.SpielerErstellen(_spielerEinsName);
+			UnoRegeln.SpielerErstellen(_spielerZweiName);
+			UnoRegeln.SpielerErstellen(_spielerDreiName);
+			UnoRegeln.NaechsterSpielerWahl(_aktuellerSpieler, _uhrZeigerSinn);
+
+			//assert
+			Assert.Equal(_naechsterErwartung, UnoRegeln.NaechsterSpielerId);
+
+		}
+
+		#endregion
+
+		[Theory]
+		[InlineData(Farbe.Rot, Farbe.Rot, true)]
+		[InlineData(Farbe.Blau, Farbe.Rot, false)]
+		[InlineData(Farbe.Rot, Farbe.Blau, false)]
+		[InlineData(Farbe.Blau, Farbe.Blau, true)]
+		[InlineData(Farbe.Gelb, Farbe.Rot, false)]
+		[InlineData(Farbe.Gruen, Farbe.Gruen, true)]
+		private void IstAblageStapelFarbeGleichZuLegendeKarteTest(Farbe ablegeStapelKarteFarbe, Farbe neueKarteFarbe, bool erwartet)
+		{
+			//arrange
+			var _ablegeStabelKarteFarbe = ablegeStapelKarteFarbe.ToString();
+			var _neueKarteFarbe = neueKarteFarbe.ToString();
+			var _erwartet = erwartet;
+
+
+			//act
+			UnoRegeln.AblageKartenStapel.KartenModels = new();
+			UnoRegeln.AblageKartenStapel.KartenModels.Add(
+				BeispielKarte("Testkarten Name", _ablegeStabelKarteFarbe, false)
+				);
+			var erhalten = UnoRegeln.IstAblageStapelFarbeGleichZuLegendeKarte(_neueKarteFarbe);
+
+			//assert
+			Assert.Equal(_erwartet, erhalten);
+		}
+
+		[Theory]
+		[InlineData(Kartenbezeichnung.Acht, Kartenbezeichnung.Acht, true)]
+		[InlineData(Kartenbezeichnung.Eins, Kartenbezeichnung.Acht, false)]
+		[InlineData(Kartenbezeichnung.Fuenf, Kartenbezeichnung.Vier, false)]
+		[InlineData(Kartenbezeichnung.Sechs, Kartenbezeichnung.Sechs, true)]
+		[InlineData(Kartenbezeichnung.Zwei, Kartenbezeichnung.Drei, false)]
+		[InlineData(Kartenbezeichnung.Neun, Kartenbezeichnung.Acht, false)]
+		private void IstAblageStapelZahlGleichZuLegendeKarteTest(Kartenbezeichnung ablegeStapelKarteBezeichnung, Kartenbezeichnung handStapelKarteBezeichnung, bool erwartet)
+		{
+			//arrange
+			var _ablegeStapelKarteBezeichnung = ablegeStapelKarteBezeichnung.ToString();
+			var _handStapelKarteBezeichnung = handStapelKarteBezeichnung.ToString();
+			var _erwartet = erwartet;
+
+			//act
+			UnoRegeln.AblageKartenStapel.KartenModels = new();
+			UnoRegeln.AblageKartenStapel.KartenModels.Add(
+				BeispielKarte(_ablegeStapelKarteBezeichnung, Farbe.Blau.ToString(), false)
+				);
+			var erhalten = UnoRegeln.IstAblageStapelZahlGleichZuLegendeKarte(_handStapelKarteBezeichnung);
+
+			//assert
+			Assert.Equal(_erwartet, erhalten);
+
+		}
+
+		[Fact]
+		private void ZiehEineKarteTest()
+		{
+			//arrange
+			UnoRegeln.ZiehKartenStapelZusammenstellen();
+			UnoRegeln.SpielerErstellen("Andrej");
+
+			var erwartet = UnoRegeln.ZiehKartenStapel.KartenModels.FirstOrDefault();
+
+			//act
+			UnoRegeln.ZiehEineKarte(1);
+
+			var erhalten = UnoRegeln.Spieler[0].KartenModels.LastOrDefault();
+
+			//assert
+			Assert.Equal(erwartet, erhalten);
+		}
+
+		[Theory]
+		[InlineData(2, 0, 1)]
+		[InlineData(3, 2, 0)]
+		[InlineData(4, 2, 3)]
+		[InlineData(5, 0, 1)]
+		private void PlusZweiKarteAufStapelLegenTest(int anzahlSpieler, int aktuellerSpielerIndex, int naechsterSpielerIndex)
+		{
+			//arrange
+			UnoRegeln.ZiehKartenStapelZusammenstellen();
+			BeispielMultipleSpielerModelsFüllen(anzahlSpieler);
+
+			foreach (var spieler in SpielerModels)
+			{
+				UnoRegeln.SpielerErstellen(spieler.SpielerName);
+			}
+
+			var _aktuellerSpielerIndex = aktuellerSpielerIndex;
+			var _naechsterSpielerIndex = naechsterSpielerIndex;
+			var nachstenSpielerKartenAnzahlErwartet = UnoRegeln.Spieler[_naechsterSpielerIndex].KartenModels.Count + 2;
+
+			var beispielZuLegendeKarte = BeispielKarte(Kartenbezeichnung.PlusZweiKarte.ToString(), Farbe.Gelb.ToString(), true);
+
+			//act
+			UnoRegeln.KarteAufStapelLegen(UnoRegeln.Spieler[_aktuellerSpielerIndex].SpielerModel.Id, beispielZuLegendeKarte);
+
+			//assert
+			Assert.Equal(nachstenSpielerKartenAnzahlErwartet, UnoRegeln.Spieler[_naechsterSpielerIndex].KartenModels.Count);
+			Assert.DoesNotContain(UnoRegeln.Spieler[_naechsterSpielerIndex].KartenModels[0], UnoRegeln.ZiehKartenStapel.KartenModels);
+			Assert.DoesNotContain(UnoRegeln.Spieler[_naechsterSpielerIndex].KartenModels[1], UnoRegeln.ZiehKartenStapel.KartenModels);
+		}
+
+
+		[Theory]
+		[InlineData(4, 0, 3, true)]
+		[InlineData(4, 0, 1, false)]
+		[InlineData(4, 2, 3, false)]
+		[InlineData(4, 3, 2, true)]
+		[InlineData(3, 1, 2, false)]
+		private void RetoureKarteAufStapelLegenTest(int anzahlSpieler, int aktuellerSpielerIndex, int naechsterSpielerIndex, bool uhrzeigerSinn)
+		{
+			//arrange
+			UnoRegeln.ZiehKartenStapelZusammenstellen();
+			BeispielMultipleSpielerModelsFüllen(anzahlSpieler);
+
+			foreach (var spieler in SpielerModels)
+			{
+				UnoRegeln.SpielerErstellen(spieler.SpielerName);
+			}
+
+			var erwartet = !uhrzeigerSinn;
+			var _aktuellerSpielerIndex = aktuellerSpielerIndex;
+			var beispielZuLegendeKarte = BeispielKarte(Kartenbezeichnung.RetoureKarte.ToString(), Farbe.Gelb.ToString(), true);
+
+			//act
+			UnoRegeln.Uhrzeigersinn = uhrzeigerSinn;
+			UnoRegeln.KarteAufStapelLegen(UnoRegeln.Spieler[_aktuellerSpielerIndex].SpielerModel.Id, beispielZuLegendeKarte);
+
+			//assert
+			Assert.Equal(naechsterSpielerIndex, UnoRegeln.Spieler.FindIndex(x => x.SpielerModel.Id == UnoRegeln.NaechsterSpielerId));
+		}
+
+		[Theory]
+		[InlineData(4, 1, 3, true)]
+		[InlineData(4, 1, 3, false)]
+		[InlineData(4, 2, 4, true)]
+		[InlineData(4, 2, 4, false)]
+		[InlineData(4, 3, 1, true)]
+		[InlineData(4, 3, 1, false)]
+		[InlineData(6, 1, 3, true)]
+		[InlineData(6, 1, 5, false)]
+		[InlineData(6, 2, 4, true)]
+		[InlineData(6, 2, 6, false)]
+		[InlineData(6, 3, 5, true)]
+		[InlineData(6, 3, 1, false)]
+		[InlineData(6, 4, 6, true)]
+		[InlineData(6, 4, 2, false)]
+		[InlineData(6, 5, 1, true)]
+		[InlineData(6, 5, 3, false)]
+		[InlineData(6, 6, 2, true)]
+		[InlineData(6, 6, 4, false)]
+		private void AussetzenKarteAufStapelLegenTest(int anzahlSpieler, int aktuellerSpielerId, int naechsterSpielerId, bool uhrzeigerSinn)
+		{
+			//arrange
+			UnoRegeln.ZiehKartenStapelZusammenstellen();
+			BeispielMultipleSpielerModelsFüllen(anzahlSpieler);
+
+			foreach (var spieler in SpielerModels)
+			{
+				UnoRegeln.SpielerErstellen(spieler.SpielerName);
+			}
+
+			var erwartetNaechsterSpielerId = naechsterSpielerId;
+			var _aktuellerSpielerId = aktuellerSpielerId;
+			var beispielZuLegendeKarte = BeispielKarte(Kartenbezeichnung.AussetzenKarte.ToString(), Farbe.Rot.ToString(), true);
+			UnoRegeln.Uhrzeigersinn = uhrzeigerSinn;
+
+			//act
+			UnoRegeln.KarteAufStapelLegen(_aktuellerSpielerId, beispielZuLegendeKarte);
+
+			//assert
+			Assert.Equal(erwartetNaechsterSpielerId, UnoRegeln.NaechsterSpielerId);
+		}
+
+		#region Stapel erstellen
+		[Theory]
+		[InlineData((Kartenbezeichnung)0, Farbe.Rot, false, 19)]
+		[InlineData((Kartenbezeichnung)1, Farbe.Rot, false, 19)]
+		[InlineData((Kartenbezeichnung)2, Farbe.Gelb, false, 19)]
+		[InlineData((Kartenbezeichnung)3, Farbe.Gruen, false, 19)]
+		[InlineData((Kartenbezeichnung)4, Farbe.Rot, false, 19)]
+		[InlineData((Kartenbezeichnung)5, Farbe.Blau, false, 19)]
+		[InlineData((Kartenbezeichnung)6, Farbe.Gruen, false, 19)]
+		[InlineData((Kartenbezeichnung)7, Farbe.Blau, false, 19)]
+		[InlineData((Kartenbezeichnung)8, Farbe.Gruen, false, 19)]
+		[InlineData((Kartenbezeichnung)9, Farbe.Gelb, false, 19)]
+		private void ErstelleStandardKartenTest(Kartenbezeichnung kartenbezeichnung, Farbe farbe, bool spezial, int anzahl)
+		{
+			//arrange
+			var _kartenbezeichnung = kartenbezeichnung.ToString();
+			var _farbe = farbe.ToString();
+			var _spezial = spezial;
+			var _anzahl = anzahl;
+			var erwartet = BeispielKarte(_kartenbezeichnung, _farbe, _spezial);
+
+			//act
+			var neuesDeck = Uno.ErstelleStandardKarten();
+			var anzahlBlau = neuesDeck.KartenModels.Where(x => x.Farbe.Equals(Farbe.Blau.ToString())).Count();
+			var anzahlRot = neuesDeck.KartenModels.Where(x => x.Farbe.Equals(Farbe.Rot.ToString())).Count();
+			var anzahlGruen = neuesDeck.KartenModels.Where(x => x.Farbe.Equals(Farbe.Gruen.ToString())).Count();
+			var anzahlGelb = neuesDeck.KartenModels.Where(x => x.Farbe.Equals(Farbe.Gelb.ToString())).Count();
+
+			//assert           
+			Assert.Equal(_anzahl, anzahlBlau);
+			Assert.Equal(_anzahl, anzahlRot);
+			Assert.Equal(_anzahl, anzahlGruen);
+			Assert.Equal(_anzahl, anzahlGelb);
+
+			Assert.Contains(neuesDeck.KartenModels, n =>
+				n.Name.Equals(erwartet.Name) &&
+				n.Farbe.Equals(erwartet.Farbe) &&
+				n.Spezial == erwartet.Spezial
+			);
+		}
+
+		[Theory]
+		[InlineData(Kartenbezeichnung.PlusZweiKarte, Farbe.Gelb, true, 6)]
+		[InlineData(Kartenbezeichnung.PlusZweiKarte, Farbe.Blau, true, 6)]
+		[InlineData(Kartenbezeichnung.PlusZweiKarte, Farbe.Gruen, true, 6)]
+		[InlineData(Kartenbezeichnung.PlusZweiKarte, Farbe.Rot, true, 6)]
+		[InlineData(Kartenbezeichnung.RetoureKarte, Farbe.Gelb, true, 6)]
+		[InlineData(Kartenbezeichnung.RetoureKarte, Farbe.Blau, true, 6)]
+		[InlineData(Kartenbezeichnung.RetoureKarte, Farbe.Gruen, true, 6)]
+		[InlineData(Kartenbezeichnung.RetoureKarte, Farbe.Rot, true, 6)]
+		[InlineData(Kartenbezeichnung.AussetzenKarte, Farbe.Gelb, true, 6)]
+		[InlineData(Kartenbezeichnung.AussetzenKarte, Farbe.Blau, true, 6)]
+		[InlineData(Kartenbezeichnung.AussetzenKarte, Farbe.Gruen, true, 6)]
+		[InlineData(Kartenbezeichnung.AussetzenKarte, Farbe.Rot, true, 6)]
+		private void ErstelleFarbigeSpezialKartenTest(Kartenbezeichnung kartenbezeichnung, Farbe farbe, bool spezial, int anzahl)
+		{
+			//arrange
+			var _kartenbezeichnung = kartenbezeichnung.ToString();
+			var _farbe = farbe.ToString();
+			var _spezial = spezial;
+			var _anzahl = anzahl;
+			var erwartet = BeispielKarte(_kartenbezeichnung, _farbe, _spezial);
+
+			//act
+			var neuesDeck = Uno.ErstelleFarbigeSpezialKarten();
+			var anzahlBlau = neuesDeck.KartenModels.Where(x => x.Farbe.Equals(Farbe.Blau.ToString())).Count();
+			var anzahlRot = neuesDeck.KartenModels.Where(x => x.Farbe.Equals(Farbe.Rot.ToString())).Count();
+			var anzahlGruen = neuesDeck.KartenModels.Where(x => x.Farbe.Equals(Farbe.Gruen.ToString())).Count();
+			var anzahlGelb = neuesDeck.KartenModels.Where(x => x.Farbe.Equals(Farbe.Gelb.ToString())).Count();
+
+
+			//assert
+			Assert.Equal(_anzahl, anzahlBlau);
+			Assert.Equal(_anzahl, anzahlRot);
+			Assert.Equal(_anzahl, anzahlGruen);
+			Assert.Equal(_anzahl, anzahlGelb);
+
+			Assert.Contains(neuesDeck.KartenModels, n =>
+				n.Name.Equals(erwartet.Name) &&
+				n.Farbe.Equals(erwartet.Farbe) &&
+				n.Spezial == erwartet.Spezial
+			);
+		}
+
+		[Theory]
+		[InlineData(Kartenbezeichnung.FarbwahlKarte, Farbe.Keine, true, 4)]
+		[InlineData(Kartenbezeichnung.ZiehVierFarbenwahlkarte, Farbe.Keine, true, 4)]
+		private void ErstelleJokerKartenTest(Kartenbezeichnung kartenbezeichnung, Farbe farbe, bool spezial, int anzahl)
+		{
+			//arrange
+			var _kartenbezeichnung = kartenbezeichnung.ToString();
+			var _farbe = farbe.ToString();
+			var _spezial = spezial;
+			var _anzahl = anzahl;
+			var erwartet = BeispielKarte(_kartenbezeichnung, _farbe, _spezial);
+
+			//act
+			var neuesDeck = Uno.ErstelleJokerKarten();
+			var ergebnisAnzahl = neuesDeck.KartenModels.Where(x => x.Name.Equals(kartenbezeichnung.ToString())).Count();
+
+			//assert
+			Assert.Equal(_anzahl, ergebnisAnzahl);
+			Assert.Contains(neuesDeck.KartenModels, n =>
+				n.Name.Equals(erwartet.Name) &&
+				n.Farbe.Equals(erwartet.Farbe) &&
+				n.Spezial == erwartet.Spezial
+			);
+		}
+
+		[Fact]
+		private void AblagestapelZusammenstellenTest()
+		{
+
+			UnoRegeln.ZiehKartenStapelZusammenstellen();
+
+			var ergebnis = UnoRegeln.ZiehKartenStapel;
+
+			Assert.Equal(108, ergebnis.KartenModels.Count());
+		}
+
+		#endregion
+	}
 }