You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
567 lines
18 KiB
567 lines
18 KiB
using MiniGames.Client.ViewModel;
|
|
using MiniGames.Shared.Enums;
|
|
using MiniGames.Shared.Models;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using Xunit;
|
|
|
|
namespace MiniGamesTests
|
|
{
|
|
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, 1)]
|
|
[InlineData(3, 1)]
|
|
[InlineData(4, 1)]
|
|
[InlineData(5, 1)]
|
|
[InlineData(6, 1)]
|
|
[InlineData(7, 1)]
|
|
[InlineData(8, 1)]
|
|
private void MehrereSpielerErstellenTest(int anzahlSpieler, int id)
|
|
{
|
|
//arrange
|
|
var _anzahlSpieler = anzahlSpieler;
|
|
string[] _spielerName = new string[anzahlSpieler];
|
|
var _id = id;
|
|
|
|
//act
|
|
for (int i = 0; i < _anzahlSpieler; i++)
|
|
{
|
|
_spielerName[i] = "Spieler" + i;
|
|
UnoRegeln.SpielerErstellen(_spielerName[i]);
|
|
}
|
|
var ergebnis = UnoRegeln.Spieler;
|
|
|
|
//assert
|
|
for (int i = 0; i < _anzahlSpieler; i++)
|
|
{
|
|
Assert.Equal(_spielerName[i], ergebnis[i].SpielerModel.SpielerName);
|
|
Assert.Equal(_id++, ergebnis[i].SpielerModel.Id);
|
|
Assert.NotNull(ergebnis[i].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
|
|
}
|
|
}
|