BlazorCICD/BlazorSolution/MiniGamesTests/TicTacToeBrettTest.cs

using MiniGames.Shared.Models;
using Xunit;

namespace MiniGamesTests
{
    public class TicTacToeBrettTest
    {
        const int LEER = TicTacToeBrett.LEER;

        public TicTacToeBrett TestBrett(
            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[,]
                {
                    { f00, f01, f02, },
                    { f10, f11, f12, },
                    { f20, f21, f22, },
                }
            );
        }

        [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(a, b, c, d, e, f, g, h, i);
            bool erwartetGesetzt = true;

            // act
            bool erhaltenGesetzt = brett.Set(pos, wert);

            // assert
            Assert.Equal(erwartetGesetzt, erhaltenGesetzt);
            Assert.True(brett.Gleich(erwartetesBrett));
        }

        [Fact]
        public void Set_BelegtesFeldBelegenTest()
        {
            // arrange
            TicTacToeBrett brett = TestBrett(1);
            TicTacToeBrett erwartetesBrett = TestBrett(1);
            int pos = 0;
            int wert = 1;
            bool erwartetGesetzt = false;

            // act
            bool erhaltenGesetzt = brett.Set(pos, wert);

            // assert
            Assert.Equal(erwartetGesetzt, erhaltenGesetzt);
            Assert.True(brett.Gleich(erwartetesBrett));
        }

        [Theory]
        [InlineData(-1)]
        [InlineData(9)]
        public void Set_OutOfBoundsTest(int pos)
        {
            // arrange
            TicTacToeBrett brett = new();
            TicTacToeBrett erwartetesBrett = new();
            int wert = 0;
            bool erwartetGesetzt = false;

            // act
            bool erhaltenGesetzt = brett.Set(pos, wert);

            // assert
            Assert.Equal(erwartetGesetzt, erhaltenGesetzt);
            Assert.True(brett.Gleich(erwartetesBrett));
        }

        [Fact]
        public void Gleich_LeereBretterGleichTest()
        {
            // arrange
            TicTacToeBrett b1 = new();
            TicTacToeBrett b2 = new();
            bool erwartetGleich = true;

            // act
            bool erhaltenGleich = b1.Gleich(b2);

            // assert
            Assert.Equal(erwartetGleich, erhaltenGleich);
        }

        [Fact]
        public void Gleich_NichtLeereBretterGleichTest()
        {
            // arrange
            TicTacToeBrett b1 = TestBrett(1, 2, 3, 4, 5, 6, 7, 8, 9);
            TicTacToeBrett b2 = TestBrett(1, 2, 3, 4, 5, 6, 7, 8, 9);
            bool erwartetGleich = true;

            // act
            bool erhaltenGleich = b1.Gleich(b2);

            // assert
            Assert.Equal(erwartetGleich, erhaltenGleich);
        }

        [Fact]
        public void Gleich_ErsteUngleichTest()
        {
            // arrange
            TicTacToeBrett b1 = TestBrett(1);
            TicTacToeBrett b2 = TestBrett(2);
            bool erwartetGleich = false;

            // act
            bool erhaltenGleich = b1.Gleich(b2);

            // assert
            Assert.Equal(erwartetGleich, erhaltenGleich);
        }

        [Fact]
        public void Gleich_LetzteUngleichTest()
        {
            // arrange
            TicTacToeBrett b1 = TestBrett(1, 2, 3, 4, 5, 6, 7, 8, 9);
            TicTacToeBrett b2 = TestBrett(1, 2, 3, 4, 5, 6, 7, 8, 10);
            bool erwartetGleich = false;

            // act
            bool erhaltenGleich = b1.Gleich(b2);

            // assert
            Assert.Equal(erwartetGleich, erhaltenGleich);
        }

        [Fact]
        public void Voll_LeeresBrettTest()
        {
            // arrange
            TicTacToeBrett brett = TestBrett();
            bool erwartetVoll = false;

            // act
            bool erhaltenVoll = brett.Voll();

            // assert
            Assert.Equal(erwartetVoll, erhaltenVoll);
        }

        [Fact]
        public void Voll_VollesBrettTest()
        {
            // arrange
            TicTacToeBrett brett = TestBrett(1, 2, 3, 4, 5, 6, 7, 8, 9);
            bool erwartetVoll = true;

            // act
            bool erhaltenVoll = brett.Voll();

            // assert
            Assert.Equal(erwartetVoll, erhaltenVoll);
        }

        [Fact]
        public void Voll_FastVollesBrettTest()
        {
            // arrange
            TicTacToeBrett brett = TestBrett(1, 2, 3, 4, 5, 6, 7, 8);
            bool erwartetVoll = false;

            // act
            bool erhaltenVoll = brett.Voll();

            // assert
            Assert.Equal(erwartetVoll, erhaltenVoll);
        }

        [Fact]
        public void Gewinner_LeeresFeldTest()
        {
            // arrange
            TicTacToeBrett brett = TestBrett();
            int erwarteterGewinner = LEER;

            // act
            int erhaltenerGewinner = brett.Gewinner();

            // assert
            Assert.Equal(erwarteterGewinner, erhaltenerGewinner);
        }

        [Theory]
        // Vertikale Reihe 1
        [InlineData(0,
            0, LEER, LEER,
            0, LEER, LEER,
            0, LEER, LEER
        )]
        // Vertikale Reihe 2
        [InlineData(1,
            LEER, 1, LEER,
            LEER, 1, LEER,
            LEER, 1, LEER
        )]
        // Vertikale Reihe 3
        [InlineData(2,
            LEER, LEER, 2,
            LEER, LEER, 2,
            LEER, LEER, 2
        )]
        // Horizontale Reihe 1
        [InlineData(3,
            3, 3, 3,
            LEER, LEER, LEER,
            LEER, LEER, LEER
        )]
        // Horizontale Reihe 2
        [InlineData(4,
            LEER, LEER, LEER,
            4, 4, 4,
            LEER, LEER, LEER
        )]
        // Horizontale Reihe 3
        [InlineData(5,
            LEER, LEER, LEER,
            LEER, LEER, LEER,
            5, 5, 5
        )]
        // Diagonale Reihe links oben nach rechts unten
        [InlineData(6,
            6, LEER, LEER,
            LEER, 6, LEER,
            LEER, LEER, 6
        )]
        // Diagonale Reihe rechts oben nach links unten
        [InlineData(7,
            LEER, LEER, 7,
            LEER, 7, LEER,
            7, LEER, LEER
        )]
        public void Gewinner_VolleReihenTest(int gewinner,
            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 = gewinner;

            // act
            int erhaltenerGewinner = brett.Gewinner();

            // assert
            Assert.Equal(erwarteterGewinner, erhaltenerGewinner);
        }

        [Theory]
        [InlineData(
            0, LEER, 0,
            LEER, LEER, LEER,
            0, LEER, 0
        )]
        [InlineData(
            1, 1, LEER,
            1, 1, LEER,
            LEER, LEER, LEER
        )]
        [InlineData(
            2, 2, LEER,
            LEER, LEER, 2,
            LEER, 2, 2
        )]
        [InlineData(
            1, 1, 2,
            1, 3, 3,
            2, 2, 3
        )]
        public void Gewinner_NichtVolleReihenTest(
            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 = LEER;

            // act
            int erhaltenerGewinner = brett.Gewinner();

            // assert
            Assert.Equal(erwarteterGewinner, erhaltenerGewinner);
        }
    }
}