nachsterSpielerTest erstellt

BlazorSolution/MiniGames/Client/ViewModel/IUno.cs

@@ -9,6 +9,6 @@ namespace MiniGames.Client.ViewModel
 
         void ZiehKartenStapelZusammenstellen();
         bool IstAblageStapelFarbeGleichZuLegendeKarte(string neueKarteFarbe);
-        List<KartenModel> ZiehEineKarte(List<KartenModel> zuZiehendeHand);
+        void ZiehEineKarte(int id);
     }
 }

BlazorSolution/MiniGames/Client/ViewModel/Uno.cs

@@ -1,5 +1,6 @@
 using MiniGames.Shared.Enums;
 using MiniGames.Shared.Models;
+using System;
 using System.Collections.Generic;
 using System.Linq;
 
@@ -9,32 +10,39 @@ namespace MiniGames.Client.ViewModel
     {
         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)
         {
-            if (KartenAblageStapel.KartenModels.LastOrDefault().Farbe.Equals(neueKarteFarbe))
-            {
-                return true;
-            }
-            else
-            {
-                return false;
-            }
+            bool ergebnis;
+
+            _ = KartenAblageStapel.KartenModels.LastOrDefault().Farbe.Equals(neueKarteFarbe) ? ergebnis = true : ergebnis = false;
+
+            return ergebnis;
+        }
+
+        public bool IstAblageStapelZahlGleichZuLegendeKarte(string handStapelKarteBezeichnung)
+        {
+            bool ergebnis;
+
+            _ = KartenAblageStapel.KartenModels.LastOrDefault().Name.Equals(handStapelKarteBezeichnung) ? ergebnis = true : ergebnis = false;
+
+            return ergebnis;
         }
 
-        public List<KartenModel> ZiehEineKarte(List<KartenModel> zuZiehendeHand)
+        public void ZiehEineKarte(int id)
         {
-            List<KartenModel> _zuZiehendeHand = zuZiehendeHand;
+            int _id = id;
+            int index = Spieler.FindIndex(x => x.SpielerModel.Id == _id);
 
-            _zuZiehendeHand.Add(ZiehKartenStapel.KartenModels.FirstOrDefault());
+            Spieler[index].KartenModels.Add(ZiehKartenStapel.KartenModels.FirstOrDefault());
             ZiehKartenStapel.KartenModels.RemoveAt(0);
-
-            return _zuZiehendeHand;
         }
 
-        public List<KartenModel> KarteAufStapelLegen(List<KartenModel> naechstenHand, KartenModel zuLegendeKarte)
-        {
-            List<KartenModel> _naechstenHand = naechstenHand;
+        public void KarteAufStapelLegen(int id, KartenModel zuLegendeKarte)
+        {
+            int _id = id;
             StapelModel _stapelModel = new();
             _stapelModel.KartenModels = new();
             const string _plusZweiKarte = "PlusZweiKarte";
@@ -50,8 +58,8 @@ namespace MiniGames.Client.ViewModel
             {
                 case _plusZweiKarte:
                     for (int i = 0; i < 2; i++)
-                    {
-                        _naechstenHand = ZiehEineKarte(_naechstenHand);
+                    {
+                        ZiehEineKarte(_id);
                     }
                     break;
                 case _retoureKarte:
@@ -63,10 +71,50 @@ namespace MiniGames.Client.ViewModel
 
             }
 
-            return _naechstenHand;
-        }
-
-
+        }
+
+        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()
         {
@@ -142,8 +190,8 @@ namespace MiniGames.Client.ViewModel
             }
 
             return stapelModel;
-        }
-
+        }
+
         public void ZiehKartenStapelZusammenstellen()
         {
             var standardKarten = Uno.ErstelleStandardKarten();
@@ -154,9 +202,9 @@ namespace MiniGames.Client.ViewModel
             ZiehKartenStapel.KartenModels.AddRange(standardKarten.KartenModels);
             ZiehKartenStapel.KartenModels.AddRange(spezialKarten.KartenModels);
             ZiehKartenStapel.KartenModels.AddRange(jokerKarten.KartenModels);
-        }
-
-
+        }
+
+
         #endregion
     }
 }

BlazorSolution/MiniGames/Shared/Models/HandKartenModel.cs

@@ -8,8 +8,7 @@ namespace MiniGames.Shared.Models
 {
     public class HandKartenModel
     {
-        public int Id { get; set; }
-        public string Name { get; set; }
+        public SpielerModel SpielerModel { get; set; }
 
         public List<KartenModel> KartenModels { get; set; }
     }

BlazorSolution/MiniGames/Shared/Models/SpielerModel.cs

@@ -8,6 +8,7 @@ namespace MiniGames.Shared.Models
 {
     public class SpielerModel
     {
+        public int Id { get; set; }
         public string SpielerName { get; set; }
         public int Punkte { get; set; }
     }

BlazorSolution/MiniGamesTests/UnoTest.cs

@@ -6,246 +6,359 @@ using System.Linq;
 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()
-            {
-                Id = 1,
-                Name = "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;
-        }
-
-
-        [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
-            UnoRegeln.ZiehKartenStapelZusammenstellen();
-            var _ablegeStabelKarteFarbe = ablegeStapelKarteFarbe.ToString();
-            var _neueKarteFarbe = neueKarteFarbe.ToString();
-            var _erwartet = erwartet;
-
-            UnoRegeln.KartenAblageStapel.KartenModels = new();
-            UnoRegeln.KartenAblageStapel.KartenModels.Add(BeispielKarte("Testkarten Name", _ablegeStabelKarteFarbe, false));
-
-            //act
-            var erhalten = UnoRegeln.IstAblageStapelFarbeGleichZuLegendeKarte(_neueKarteFarbe);
-
-            //assert
-            Assert.Equal(_erwartet, erhalten);
-        }
-
-        [Fact]
-        private void ZiehEineKarteTest()
-        {
-            //arrange
-            UnoRegeln.ZiehKartenStapelZusammenstellen();
-            List<KartenModel> KartenListe = new();
-
-            var beispielHand = BeispielHand();
-            var erwartet = UnoRegeln.ZiehKartenStapel.KartenModels.FirstOrDefault();
-
-            //act
-            KartenListe = UnoRegeln.ZiehEineKarte(beispielHand.KartenModels);
-
-            var erhalten = KartenListe.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
-        }
-
+{
+    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());
-        }
-
+        [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
     }
 }