Continous_Integration_in_der_Praxis
/
CIiP-WS-2021-2022-Projektarbeit_BlazorCICD
forked from Andrej1988/BlazorCICD
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

Merge commit '2e56a1e0cba7b14252016ac4be857b8f35bc20ea' into HEAD

main
ADato88 3 years ago
parent
688cefbfc5 2e56a1e0cb
commit
3eb5acfc88
6 changed files with 220 additions and 66 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  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
View File

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

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

@ -17,9 +17,36 @@ namespace MiniGames.Client.ViewModel
set { Model.Brett = value; } 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
View File

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

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

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

140
BlazorSolution/MiniGamesTests/TicTacToeBrettTest.cs
View File

@ -5,36 +5,56 @@ namespace MiniGamesTests
{ {
public class TicTacToeBrettTest public class TicTacToeBrettTest
{ {
const int LEER = TicTacToeBrett.LEER;
public TicTacToeBrett TestBrett( 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( return new(
new int[,] 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 // arrange
TicTacToeBrett brett = new(); 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; bool erwartetGesetzt = true;
// act // act
@ -189,7 +209,7 @@ namespace MiniGamesTests
{ {
// arrange // arrange
TicTacToeBrett brett = TestBrett(); TicTacToeBrett brett = TestBrett();
int erwarteterGewinner = TicTacToeBrett.LEER;
int erwarteterGewinner = LEER;
// act // act
int erhaltenerGewinner = brett.Gewinner(); int erhaltenerGewinner = brett.Gewinner();
@ -201,56 +221,56 @@ namespace MiniGamesTests
[Theory] [Theory]
// Vertikale Reihe 1 // Vertikale Reihe 1
[InlineData(0, [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 // Vertikale Reihe 2
[InlineData(1, [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 // Vertikale Reihe 3
[InlineData(2, [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 // Horizontale Reihe 1
[InlineData(3, [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 // Horizontale Reihe 2
[InlineData(4, [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 // Horizontale Reihe 3
[InlineData(5, [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 // Diagonale Reihe links oben nach rechts unten
[InlineData(6, [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 // Diagonale Reihe rechts oben nach links unten
[InlineData(7, [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, 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 // arrange
@ -266,34 +286,34 @@ namespace MiniGamesTests
[Theory] [Theory]
[InlineData( [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( [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( [InlineData(
2, TicTacToeBrett.LEER, TicTacToeBrett.LEER,
2, TicTacToeBrett.LEER, 2,
TicTacToeBrett.LEER, 2, 2
2, 2, LEER,
LEER, LEER, 2,
LEER, 2, 2
)] )]
[InlineData( [InlineData(
1, 1, 2, 1, 1, 2,
1, 3, 2,
2, 3, 3
1, 3, 3,
2, 2, 3
)] )]
public void Gewinner_NichtVolleReihenTest( 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 // arrange
TicTacToeBrett brett = TestBrett(a, b, c, d, e, f, g, h, i); TicTacToeBrett brett = TestBrett(a, b, c, d, e, f, g, h, i);
int erwarteterGewinner = TicTacToeBrett.LEER;
int erwarteterGewinner = LEER;
// act // act
int erhaltenerGewinner = brett.Gewinner(); int erhaltenerGewinner = brett.Gewinner();

107
BlazorSolution/MiniGamesTests/TicTacToeTest.cs
View File

@ -1,4 +1,5 @@
using MiniGames.Shared.Models;
using MiniGames.Client.ViewModel;
using MiniGames.Shared.Models;
using Xunit; using Xunit;
namespace MiniGamesTests namespace MiniGamesTests
@ -35,5 +36,109 @@ namespace MiniGamesTests
Brett = StandardBrett(), 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);
}
} }
} }
Write Preview
Loading…
Cancel
Save