11 Commits

  1. 2
      BlazorSolution/MiniGames/Client/ViewModel/ITicTacToe.cs
  2. 31
      BlazorSolution/MiniGames/Client/ViewModel/TicTacToe.cs
  3. 4
      BlazorSolution/MiniGames/Shared/Models/TicTacToeBrett.cs
  4. 2
      BlazorSolution/MiniGames/Shared/Models/TicTacToeModel.cs
  5. 140
      BlazorSolution/MiniGamesTests/TicTacToeBrettTest.cs
  6. 107
      BlazorSolution/MiniGamesTests/TicTacToeTest.cs

2
BlazorSolution/MiniGames/Client/ViewModel/ITicTacToe.cs

@ -2,6 +2,6 @@
{
public interface ITicTacToe
{
bool SpielerInput(int spielerIndex, int posIndex);
void SpielerInput(int posIndex);
}
}

31
BlazorSolution/MiniGames/Client/ViewModel/TicTacToe.cs

@ -17,9 +17,36 @@ namespace MiniGames.Client.ViewModel
set { Model.Brett = value; }
}
public bool SpielerInput(int spielerIndex, int posIndex)
public int AktiverSpielerIndex
{
return true;
get { return Model.AktiverSpielerIndex; }
set { Model.AktiverSpielerIndex = value; }
}
public int GewinnerIndex
{
get { return Model.GewinnerIndex; }
set {
if (Model.GewinnerIndex < 0)
{
Model.GewinnerIndex = value;
}
}
}
public void SpielerInput(int posIndex)
{
if (Brett.Set(posIndex, AktiverSpielerIndex))
{
SpielerWechsel();
}
GewinnerIndex = Brett.Gewinner();
}
public void SpielerWechsel()
{
AktiverSpielerIndex = 1 - AktiverSpielerIndex;
}
}
}

4
BlazorSolution/MiniGames/Shared/Models/TicTacToeBrett.cs

@ -65,8 +65,8 @@ namespace MiniGames.Shared.Models
public bool Set(int pos, int wert)
{
int x = pos / 3;
int y = pos % 3;
int x = pos % 3;
int y = pos / 3;
try
{

2
BlazorSolution/MiniGames/Shared/Models/TicTacToeModel.cs

@ -9,6 +9,8 @@ namespace MiniGames.Shared.Models
public class TicTacToeModel
{
public SpielerModel[] Spieler { get; set; }
public int AktiverSpielerIndex { get; set; } = 0;
public int GewinnerIndex { get; set; } = -1;
public TicTacToeBrett Brett { get; set; }
}
}

140
BlazorSolution/MiniGamesTests/TicTacToeBrettTest.cs

@ -5,36 +5,56 @@ namespace MiniGamesTests
{
public class TicTacToeBrettTest
{
const int LEER = TicTacToeBrett.LEER;
public TicTacToeBrett TestBrett(
int a = TicTacToeBrett.LEER, int b = TicTacToeBrett.LEER, int c = TicTacToeBrett.LEER,
int d = TicTacToeBrett.LEER, int e = TicTacToeBrett.LEER, int f = TicTacToeBrett.LEER,
int g = TicTacToeBrett.LEER, int h = TicTacToeBrett.LEER, int i = TicTacToeBrett.LEER
int f00 = LEER, int f10 = LEER, int f20 = LEER,
int f01 = LEER, int f11 = LEER, int f21 = LEER,
int f02 = LEER, int f12 = LEER, int f22 = LEER
)
{
return new(
new int[,]
{
{ a, b, c, },
{ d, e, f, },
{ g, h, i, },
{ f00, f01, f02, },
{ f10, f11, f12, },
{ f20, f21, f22, },
}
);
}
[Fact]
public void Set_FreiesFeldBelegenTest()
[Theory]
[InlineData(4, 0,
LEER, LEER, LEER,
LEER, 0
)]
[InlineData(0, 1,
1
)]
[InlineData(8, 2,
LEER, LEER, LEER,
LEER, LEER, LEER,
LEER, LEER, 2
)]
[InlineData(6, 3,
LEER, LEER, LEER,
LEER, LEER, LEER,
3, LEER, LEER
)]
[InlineData(3, 4,
LEER, LEER, LEER,
4, LEER, LEER,
LEER, LEER, LEER
)]
public void Set_FreiesFeldBelegenTest(int pos, int wert,
int a = LEER, int b = LEER, int c = LEER,
int d = LEER, int e = LEER, int f = LEER,
int g = LEER, int h = LEER, int i = LEER
)
{
// arrange
TicTacToeBrett brett = new();
TicTacToeBrett erwartetesBrett = TestBrett(
TicTacToeBrett.LEER,
TicTacToeBrett.LEER,
TicTacToeBrett.LEER,
TicTacToeBrett.LEER,
0
);
int pos = 4;
int wert = 0;
TicTacToeBrett erwartetesBrett = TestBrett(a, b, c, d, e, f, g, h, i);
bool erwartetGesetzt = true;
// act
@ -189,7 +209,7 @@ namespace MiniGamesTests
{
// arrange
TicTacToeBrett brett = TestBrett();
int erwarteterGewinner = TicTacToeBrett.LEER;
int erwarteterGewinner = LEER;
// act
int erhaltenerGewinner = brett.Gewinner();
@ -201,56 +221,56 @@ namespace MiniGamesTests
[Theory]
// Vertikale Reihe 1
[InlineData(0,
0, 0, 0,
TicTacToeBrett.LEER, TicTacToeBrett.LEER, TicTacToeBrett.LEER,
TicTacToeBrett.LEER, TicTacToeBrett.LEER, TicTacToeBrett.LEER
0, LEER, LEER,
0, LEER, LEER,
0, LEER, LEER
)]
// Vertikale Reihe 2
[InlineData(1,
TicTacToeBrett.LEER, TicTacToeBrett.LEER, TicTacToeBrett.LEER,
1, 1, 1,
TicTacToeBrett.LEER, TicTacToeBrett.LEER, TicTacToeBrett.LEER
LEER, 1, LEER,
LEER, 1, LEER,
LEER, 1, LEER
)]
// Vertikale Reihe 3
[InlineData(2,
TicTacToeBrett.LEER, TicTacToeBrett.LEER, TicTacToeBrett.LEER,
TicTacToeBrett.LEER, TicTacToeBrett.LEER, TicTacToeBrett.LEER,
2, 2, 2
LEER, LEER, 2,
LEER, LEER, 2,
LEER, LEER, 2
)]
// Horizontale Reihe 1
[InlineData(3,
3, TicTacToeBrett.LEER, TicTacToeBrett.LEER,
3, TicTacToeBrett.LEER, TicTacToeBrett.LEER,
3, TicTacToeBrett.LEER, TicTacToeBrett.LEER
3, 3, 3,
LEER, LEER, LEER,
LEER, LEER, LEER
)]
// Horizontale Reihe 2
[InlineData(4,
TicTacToeBrett.LEER, 4, TicTacToeBrett.LEER,
TicTacToeBrett.LEER, 4, TicTacToeBrett.LEER,
TicTacToeBrett.LEER, 4, TicTacToeBrett.LEER
LEER, LEER, LEER,
4, 4, 4,
LEER, LEER, LEER
)]
// Horizontale Reihe 3
[InlineData(5,
TicTacToeBrett.LEER, TicTacToeBrett.LEER, 5,
TicTacToeBrett.LEER, TicTacToeBrett.LEER, 5,
TicTacToeBrett.LEER, TicTacToeBrett.LEER, 5
LEER, LEER, LEER,
LEER, LEER, LEER,
5, 5, 5
)]
// Diagonale Reihe links oben nach rechts unten
[InlineData(6,
6, TicTacToeBrett.LEER, TicTacToeBrett.LEER,
TicTacToeBrett.LEER, 6, TicTacToeBrett.LEER,
TicTacToeBrett.LEER, TicTacToeBrett.LEER, 6
6, LEER, LEER,
LEER, 6, LEER,
LEER, LEER, 6
)]
// Diagonale Reihe rechts oben nach links unten
[InlineData(7,
TicTacToeBrett.LEER, TicTacToeBrett.LEER, 7,
TicTacToeBrett.LEER, 7, TicTacToeBrett.LEER,
7, TicTacToeBrett.LEER, TicTacToeBrett.LEER
LEER, LEER, 7,
LEER, 7, LEER,
7, LEER, LEER
)]
public void Gewinner_VolleReihenTest(int gewinner,
int a = TicTacToeBrett.LEER, int b = TicTacToeBrett.LEER, int c = TicTacToeBrett.LEER,
int d = TicTacToeBrett.LEER, int e = TicTacToeBrett.LEER, int f = TicTacToeBrett.LEER,
int g = TicTacToeBrett.LEER, int h = TicTacToeBrett.LEER, int i = TicTacToeBrett.LEER
int a = LEER, int b = LEER, int c = LEER,
int d = LEER, int e = LEER, int f = LEER,
int g = LEER, int h = LEER, int i = LEER
)
{
// arrange
@ -266,34 +286,34 @@ namespace MiniGamesTests
[Theory]
[InlineData(
0, TicTacToeBrett.LEER, 0,
TicTacToeBrett.LEER, TicTacToeBrett.LEER, TicTacToeBrett.LEER,
0, TicTacToeBrett.LEER, 0
0, LEER, 0,
LEER, LEER, LEER,
0, LEER, 0
)]
[InlineData(
1, 1, TicTacToeBrett.LEER,
1, 1, TicTacToeBrett.LEER,
TicTacToeBrett.LEER, TicTacToeBrett.LEER, TicTacToeBrett.LEER
1, 1, LEER,
1, 1, LEER,
LEER, LEER, LEER
)]
[InlineData(
2, TicTacToeBrett.LEER, TicTacToeBrett.LEER,
2, TicTacToeBrett.LEER, 2,
TicTacToeBrett.LEER, 2, 2
2, 2, LEER,
LEER, LEER, 2,
LEER, 2, 2
)]
[InlineData(
1, 1, 2,
1, 3, 2,
2, 3, 3
1, 3, 3,
2, 2, 3
)]
public void Gewinner_NichtVolleReihenTest(
int a = TicTacToeBrett.LEER, int b = TicTacToeBrett.LEER, int c = TicTacToeBrett.LEER,
int d = TicTacToeBrett.LEER, int e = TicTacToeBrett.LEER, int f = TicTacToeBrett.LEER,
int g = TicTacToeBrett.LEER, int h = TicTacToeBrett.LEER, int i = TicTacToeBrett.LEER
int a = LEER, int b = LEER, int c = LEER,
int d = LEER, int e = LEER, int f = LEER,
int g = LEER, int h = LEER, int i = LEER
)
{
// arrange
TicTacToeBrett brett = TestBrett(a, b, c, d, e, f, g, h, i);
int erwarteterGewinner = TicTacToeBrett.LEER;
int erwarteterGewinner = LEER;
// act
int erhaltenerGewinner = brett.Gewinner();

107
BlazorSolution/MiniGamesTests/TicTacToeTest.cs

@ -1,4 +1,5 @@
using MiniGames.Shared.Models;
using MiniGames.Client.ViewModel;
using MiniGames.Shared.Models;
using Xunit;
namespace MiniGamesTests
@ -35,5 +36,109 @@ namespace MiniGamesTests
Brett = StandardBrett(),
};
}
TicTacToe StandardSpiel()
{
return new(StandardModel());
}
[Theory]
[InlineData(0, 1)]
[InlineData(1, 0)]
public void SpielerWechselTest(int vorher, int nachher)
{
// arrange
TicTacToe spiel = StandardSpiel();
spiel.AktiverSpielerIndex = vorher;
int erwarteterIndex = nachher;
// act
spiel.SpielerWechsel();
// assert
Assert.Equal(erwarteterIndex, spiel.AktiverSpielerIndex);
}
[Fact]
public void SpielerInput_ValidesInputTest()
{
// arrange
TicTacToe spiel = StandardSpiel();
spiel.AktiverSpielerIndex = 0;
int erwarteterSpielerIndex = 1;
int pos = 2;
TicTacToeBrett erwartetesBrett = new(new int[,]
{
{ TicTacToeBrett.LEER, TicTacToeBrett.LEER, TicTacToeBrett.LEER, },
{ TicTacToeBrett.LEER, TicTacToeBrett.LEER, TicTacToeBrett.LEER, },
{ spiel.AktiverSpielerIndex, TicTacToeBrett.LEER, TicTacToeBrett.LEER, },
});
// act
spiel.SpielerInput(pos);
// assert
Assert.True(spiel.Brett.Gleich(erwartetesBrett));
Assert.Equal(erwarteterSpielerIndex, spiel.AktiverSpielerIndex);
}
[Fact]
public void SpielerInput_InvalidesInputTest()
{
// arrange
TicTacToe spiel = StandardSpiel();
spiel.AktiverSpielerIndex = 0;
int erwarteterSpielerIndex = 0;
int pos = -1;
TicTacToeBrett erwartetesBrett = StandardBrett();
// act
spiel.SpielerInput(pos);
// assert
Assert.True(spiel.Brett.Gleich(erwartetesBrett));
Assert.Equal(erwarteterSpielerIndex, spiel.AktiverSpielerIndex);
}
[Theory]
[InlineData(0, 0, 3, 1, 4, 2)]
[InlineData(0, 3, 0, 4, 1, 5, 2)]
public void SpielerInput_GewinnerTest(int gewinnerIndex, params int[] inputs)
{
// arrange
TicTacToe spiel = StandardSpiel();
int erwarteterGewinnerIndex = gewinnerIndex;
// act
foreach (int input in inputs)
{
spiel.SpielerInput(input);
}
// assert
Assert.Equal(spiel.GewinnerIndex, erwarteterGewinnerIndex);
}
[Fact]
public void SpielerInput_KeinGewinnerTest()
{
// arrange
TicTacToe spiel = StandardSpiel();
spiel.AktiverSpielerIndex = 0;
int erwarteterGewinnerIndex = -1;
// act
spiel.SpielerInput(0);
spiel.SpielerInput(3);
spiel.SpielerInput(1);
spiel.SpielerInput(4);
spiel.SpielerInput(5);
spiel.SpielerInput(2);
// assert
Assert.Equal(spiel.GewinnerIndex, erwarteterGewinnerIndex);
}
}
}
Loading…
Cancel
Save