text:
using System;
using System.Collections.Generic;
using System.Linq;
using Scacchi.Modello.Pezzi;
using Xunit;

namespace Scacchi.Modello
{
    public class PezziTest
    {

        [Fact]
        public void IlPedoneBiancoPuoMuovereAvantiDiUnaCasa()
        {
            //Given
            Pedone pedone = new Pedone(Colore.Bianco);
            //When
            bool esito = pedone.PuòMuovere(
                    colonnaPartenza: Colonna.A,
                    traversaPartenza: Traversa.Seconda,
                    colonnaArrivo: Colonna.A,
                    traversaArrivo: Traversa.Terza);

            //Then
            Assert.True(esito);
        }

        [Fact]
        public void IlPedoneNonPuòRestareFermo()
        {
            //Given
            Pedone pedone = new Pedone(Colore.Bianco);
            //When
            bool esito = pedone.PuòMuovere(
                colonnaPartenza: Colonna.A,
                traversaPartenza: Traversa.Prima,
                colonnaArrivo: Colonna.A,
                traversaArrivo: Traversa.Prima
            );
            Assert.False(esito);
        }
        [Theory]
        [InlineData(Colore.Bianco)]
        [InlineData(Colore.Nero)]
        public void LAlfiereNonPuòRestareFermo(Colore c)
        {
            //Given
            Alfiere alfiere = new Alfiere(c);
            //When
            bool esito = alfiere.PuòMuovere(
                colonnaPartenza: Colonna.A,
                traversaPartenza: Traversa.Prima,
                colonnaArrivo: Colonna.A,
                traversaArrivo: Traversa.Prima
            );
            Assert.False(esito);
        }
        [Theory]
        [InlineData(Colore.Bianco)]
        [InlineData(Colore.Nero)]
        public void IlCavalloNonPuòRestareFermo(Colore c)
        {
            //Given
            Cavallo cavallo = new Cavallo(c);
            //When
            bool esito = cavallo.PuòMuovere(
                colonnaPartenza: Colonna.A,
                traversaPartenza: Traversa.Prima,
                colonnaArrivo: Colonna.A,
                traversaArrivo: Traversa.Prima
            );
            Assert.False(esito);
        }
        [Theory]
        [InlineData(Colore.Bianco)]
        [InlineData(Colore.Nero)]
        public void LaDonnaNonPuòRestareFerma(Colore c)
        {
            //Given
            Donna donna = new Donna(c);
            //When
            bool esito = donna.PuòMuovere(
                colonnaPartenza: Colonna.A,
                traversaPartenza: Traversa.Prima,
                colonnaArrivo: Colonna.A,
                traversaArrivo: Traversa.Prima
            );
            Assert.False(esito);
        }
        [Theory]
        [InlineData(Colore.Bianco)]
        [InlineData(Colore.Nero)]
        public void IlReNonPuòRestareFermo(Colore c)
        {
            //Given
            Re re = new Re(c);
            //When
            bool esito = re.PuòMuovere(
                colonnaPartenza: Colonna.A,
                traversaPartenza: Traversa.Prima,
                colonnaArrivo: Colonna.A,
                traversaArrivo: Traversa.Prima
            );
            Assert.False(esito);
        }
        [Theory]
        [InlineData(Colore.Bianco)]
        [InlineData(Colore.Nero)]
        public void LaTorreNonPuòRestareFerma(Colore c)
        {
            //Given
            var torre = new Torre(c);
            //When
            bool esito = torre.PuòMuovere(
                colonnaPartenza: Colonna.A,
                traversaPartenza: Traversa.Prima,
                colonnaArrivo: Colonna.A,
                traversaArrivo: Traversa.Prima
            );
            Assert.False(esito);
        }

        [Fact]
        public void IlCavalloPuòMuovereAvantiASinistraDiDueCase()
        {
            //Given
            Cavallo cavallo = new Cavallo(Colore.Nero);
            //When
            bool esito = cavallo.PuòMuovere(
                colonnaPartenza: Colonna.D,
                traversaPartenza: Traversa.Quarta,
                colonnaArrivo: Colonna.C,
                traversaArrivo: Traversa.Sesta);
            //Then
            Assert.True(esito);
        }

        [Fact]
        public void IlCavalloPuòMuovereAvantiADestraDiDueCase()
        {
            //Given
            Cavallo cavallo = new Cavallo(Colore.Nero);
            //When
            bool esito = cavallo.PuòMuovere(
                colonnaPartenza: Colonna.D,
                traversaPartenza: Traversa.Quarta,
                colonnaArrivo: Colonna.E,
                traversaArrivo: Traversa.Sesta);
            //Then
            Assert.True(esito);
        }

        [Fact]
        public void IlCavalloPuòMuovereIndietroASinistraDiDueCase()
        {
            //Given
            Cavallo cavallo = new Cavallo(Colore.Nero);
            //When
            bool esito = cavallo.PuòMuovere(
                colonnaPartenza: Colonna.D,
                traversaPartenza: Traversa.Quarta,
                colonnaArrivo: Colonna.C,
                traversaArrivo: Traversa.Seconda);
            //Then
            Assert.True(esito);
        }

        [Fact]
        public void IlCavalloPuòMuovereIndietroADestraDiDueCase()
        {
            //Given
            Cavallo cavallo = new Cavallo(Colore.Nero);
            //When
            bool esito = cavallo.PuòMuovere(
                colonnaPartenza: Colonna.D,
                traversaPartenza: Traversa.Quarta,
                colonnaArrivo: Colonna.E,
                traversaArrivo: Traversa.Seconda);
            //Then
            Assert.True(esito);
        }

        [Fact]
        public void IlCavalloPuòMuovereADestraAvantiDiUnaCasa()
        {
            //Given
            Cavallo cavallo = new Cavallo(Colore.Nero);
            //When
            bool esito = cavallo.PuòMuovere(
                colonnaPartenza: Colonna.D,
                traversaPartenza: Traversa.Quarta,
                colonnaArrivo: Colonna.F,
                traversaArrivo: Traversa.Quinta);
            //Then
            Assert.True(esito);
        }

        [Fact]
        public void IlCavalloPuòMuovereADestraIndietroDiUnaCasa()
        {
            //Given
            Cavallo cavallo = new Cavallo(Colore.Nero);
            //When
            bool esito = cavallo.PuòMuovere(
                colonnaPartenza: Colonna.D,
                traversaPartenza: Traversa.Quarta,
                colonnaArrivo: Colonna.F,
                traversaArrivo: Traversa.Terza);
            //Then
            Assert.True(esito);
        }

        [Fact]
        public void IlCavalloPuòMuovereASinistraAvantiDiUnaCasa()
        {
            //Given
            Cavallo cavallo = new Cavallo(Colore.Nero);
            //When
            bool esito = cavallo.PuòMuovere(
                colonnaPartenza: Colonna.D,
                traversaPartenza: Traversa.Quarta,
                colonnaArrivo: Colonna.B,
                traversaArrivo: Traversa.Quinta);
            //Then
            Assert.True(esito);
        }

        [Fact]
        public void IlCavalloPuòMuovereASinistraIndietroDiUnaCasa()
        {
            //Given
            Cavallo cavallo = new Cavallo(Colore.Nero);
            //When
            bool esito = cavallo.PuòMuovere(
                colonnaPartenza: Colonna.D,
                traversaPartenza: Traversa.Quarta,
                colonnaArrivo: Colonna.B,
                traversaArrivo: Traversa.Terza);
            //Then
            Assert.True(esito);
        }

        [Fact]
        public void LaTorreMuoveAvantiDiUnaCasa()
        {
            //Given
            Torre torre = new Torre(Colore.Bianco);
            //When
            bool esito = torre.PuòMuovere(
            colonnaPartenza: Colonna.F,
            traversaPartenza: Traversa.Quarta,
            colonnaArrivo: Colonna.F,
            traversaArrivo: Traversa.Quinta);
            //Then
            Assert.True(esito);
        }

        [Fact]
        public void LaTorreMuoveIndietroDiUnaCasa()
        {
            //Given
            Torre torre = new Torre(Colore.Bianco);
            //When
            bool esito = torre.PuòMuovere(
            colonnaPartenza: Colonna.F,
            traversaPartenza: Traversa.Quarta,
            colonnaArrivo: Colonna.F,
            traversaArrivo: Traversa.Terza);
            //Then
            Assert.True(esito);
        }

        [Fact]
        public void LaTorreMuoveAvantiDiDueCase()
        {
            //Given
            Torre torre = new Torre(Colore.Bianco);
            //When
            bool esito = torre.PuòMuovere(
            colonnaPartenza: Colonna.F,
            traversaPartenza: Traversa.Quarta,
            colonnaArrivo: Colonna.F,
            traversaArrivo: Traversa.Sesta);
            //Then
            Assert.True(esito);
        }

        [Fact]
        public void LaTorreMuoveIndietroDiDueCase()
        {
            //Given
            Torre torre = new Torre(Colore.Bianco);
            //When
            bool esito = torre.PuòMuovere(
            colonnaPartenza: Colonna.F,
            traversaPartenza: Traversa.Quarta,
            colonnaArrivo: Colonna.F,
            traversaArrivo: Traversa.Seconda);
            //Then
            Assert.True(esito);
        }

        [Fact]
        public void LaTorreMuoveAvantiDiQuattroCase()
        {
            //Given
            Torre torre = new Torre(Colore.Bianco);
            //When
            bool esito = torre.PuòMuovere(
            colonnaPartenza: Colonna.F,
            traversaPartenza: Traversa.Quarta,
            colonnaArrivo: Colonna.F,
            traversaArrivo: Traversa.Ottava);
            //Then
            Assert.True(esito);
        }

        [Fact]
        public void LaTorreMuoveIndietroDiTreCase()
        {
            //Given
            Torre torre = new Torre(Colore.Bianco);
            //When
            bool esito = torre.PuòMuovere(
            colonnaPartenza: Colonna.F,
            traversaPartenza: Traversa.Quarta,
            colonnaArrivo: Colonna.F,
            traversaArrivo: Traversa.Prima);
            //Then
            Assert.True(esito);
        }

        [Fact]
        public void LaTorreMuoveASinistraDiUnaCasa()
        {
            //Given
            Torre torre = new Torre(Colore.Bianco);
            //When
            bool esito = torre.PuòMuovere(
            colonnaPartenza: Colonna.F,
            traversaPartenza: Traversa.Quinta,
            colonnaArrivo: Colonna.E,
            traversaArrivo: Traversa.Quinta);
            //Then
            Assert.True(esito);
        }

        [Fact]
        public void LaTorreMuoveADestraDiUnaCasa()
        {
            //Given
            Torre torre = new Torre(Colore.Bianco);
            //When
            bool esito = torre.PuòMuovere(
            colonnaPartenza: Colonna.F,
            traversaPartenza: Traversa.Quinta,
            colonnaArrivo: Colonna.G,
            traversaArrivo: Traversa.Quinta);
            //Then
            Assert.True(esito);
        }

        [Fact]
        public void LaTorreMuoveASinistraDiDueCase()
        {
            //Given
            Torre torre = new Torre(Colore.Bianco);
            //When
            bool esito = torre.PuòMuovere(
            colonnaPartenza: Colonna.F,
            traversaPartenza: Traversa.Quinta,
            colonnaArrivo: Colonna.D,
            traversaArrivo: Traversa.Quinta);
            //Then
            Assert.True(esito);
        }

        [Fact]
        public void LaTorreMuoveADestraDiDueCase()
        {
            //Given
            Torre torre = new Torre(Colore.Bianco);
            //When
            bool esito = torre.PuòMuovere(
            colonnaPartenza: Colonna.F,
            traversaPartenza: Traversa.Quinta,
            colonnaArrivo: Colonna.H,
            traversaArrivo: Traversa.Quinta);
            //Then
            Assert.True(esito);
        }

        [Fact]
        public void LaTorreMuoveASinistraDiQuattroCase()
        {
            //Given
            Torre torre = new Torre(Colore.Bianco);
            //When
            bool esito = torre.PuòMuovere(
            colonnaPartenza: Colonna.F,
            traversaPartenza: Traversa.Quinta,
            colonnaArrivo: Colonna.B,
            traversaArrivo: Traversa.Quinta);
            //Then
            Assert.True(esito);
        }

        [Fact]
        public void LaTorreMuoveASinistraDiCinqueCase()
        {
            //Given
            Torre torre = new Torre(Colore.Bianco);
            //When
            bool esito = torre.PuòMuovere(
            colonnaPartenza: Colonna.F,
            traversaPartenza: Traversa.Quinta,
            colonnaArrivo: Colonna.A,
            traversaArrivo: Traversa.Quinta);
            //Then
            Assert.True(esito);
        }

        public void LaTorreNonPuòRimanereFermaUnaVoltaScelta()
        {
            //Given
            Torre torre = new Torre(Colore.Bianco);
            //When
            bool esito = torre.PuòMuovere(
            colonnaPartenza: Colonna.F,
            traversaPartenza: Traversa.Quinta,
            colonnaArrivo: Colonna.F,
            traversaArrivo: Traversa.Quinta);
            //Then
            Assert.False(esito);
        }

        [Fact]
        public void LAlfiereMuoveAvantiADestradiUnaCasa()
        {
            //Given
            Alfiere alfiere = new Alfiere(Colore.Nero);
            //When
            bool esito = alfiere.PuòMuovere(
            colonnaPartenza: Colonna.D,
            traversaPartenza: Traversa.Quinta,
            colonnaArrivo: Colonna.E,
            traversaArrivo: Traversa.Sesta);
            //Then
            Assert.True(esito);
        }

        [Fact]
        public void LAlfiereMuoveAvantiADestradiDueCase()
        {
            //Given
            Alfiere alfiere = new Alfiere(Colore.Nero);
            //When
            bool esito = alfiere.PuòMuovere(
            colonnaPartenza: Colonna.D,
            traversaPartenza: Traversa.Quinta,
            colonnaArrivo: Colonna.F,
            traversaArrivo: Traversa.Settima);
            //Then
            Assert.True(esito);
        }

        [Fact]
        public void LAlfiereMuoveAvantiADestradiTreCase()
        {
            //Given
            Alfiere alfiere = new Alfiere(Colore.Nero);
            //When
            bool esito = alfiere.PuòMuovere(
            colonnaPartenza: Colonna.D,
            traversaPartenza: Traversa.Quinta,
            colonnaArrivo: Colonna.G,
            traversaArrivo: Traversa.Ottava);
            //Then
            Assert.True(esito);
        }

        [Fact]
        public void LAlfiereMuoveAvantiASinistradiUnaCasa()
        {
            //Given
            Alfiere alfiere = new Alfiere(Colore.Nero);
            //When
            bool esito = alfiere.PuòMuovere(
            colonnaPartenza: Colonna.D,
            traversaPartenza: Traversa.Quinta,
            colonnaArrivo: Colonna.C,
            traversaArrivo: Traversa.Sesta);
            //Then
            Assert.True(esito);
        }

        [Fact]
        public void LAlfiereMuoveAvantiASinistradiDueCase()
        {
            //Given
            Alfiere alfiere = new Alfiere(Colore.Nero);
            //When
            bool esito = alfiere.PuòMuovere(
            colonnaPartenza: Colonna.D,
            traversaPartenza: Traversa.Quinta,
            colonnaArrivo: Colonna.B,
            traversaArrivo: Traversa.Settima);
            //Then
            Assert.True(esito);
        }

        [Fact]
        public void LAlfiereMuoveAvantiASinistradiTreCase()
        {
            //Given
            Alfiere alfiere = new Alfiere(Colore.Nero);
            //When
            bool esito = alfiere.PuòMuovere(
            colonnaPartenza: Colonna.D,
            traversaPartenza: Traversa.Quinta,
            colonnaArrivo: Colonna.A,
            traversaArrivo: Traversa.Ottava);
            //Then
            Assert.True(esito);
        }

        [Fact]
        public void LAlfiereMuoveIndietroADestradiUnaCasa()
        {
            //Given
            Alfiere alfiere = new Alfiere(Colore.Nero);
            //When
            bool esito = alfiere.PuòMuovere(
            colonnaPartenza: Colonna.D,
            traversaPartenza: Traversa.Quinta,
            colonnaArrivo: Colonna.E,
            traversaArrivo: Traversa.Quarta);
            //Then
            Assert.True(esito);
        }

        [Fact]
        public void LAlfiereMuoveIndietroADestradiDueCase()
        {
            //Given
            Alfiere alfiere = new Alfiere(Colore.Nero);
            //When
            bool esito = alfiere.PuòMuovere(
            colonnaPartenza: Colonna.D,
            traversaPartenza: Traversa.Quinta,
            colonnaArrivo: Colonna.F,
            traversaArrivo: Traversa.Terza);
            //Then
            Assert.True(esito);
        }

        [Fact]
        public void LAlfiereMuoveIndietroADestradiTreCase()
        {
            //Given
            Alfiere alfiere = new Alfiere(Colore.Nero);
            //When
            bool esito = alfiere.PuòMuovere(
            colonnaPartenza: Colonna.D,
            traversaPartenza: Traversa.Quinta,
            colonnaArrivo: Colonna.G,
            traversaArrivo: Traversa.Seconda);
            //Then
            Assert.True(esito);
        }

        [Fact]
        public void LAlfiereMuoveIndietroADestradiQuattroCase()
        {
            //Given
            Alfiere alfiere = new Alfiere(Colore.Nero);
            //When
            bool esito = alfiere.PuòMuovere(
            colonnaPartenza: Colonna.D,
            traversaPartenza: Traversa.Quinta,
            colonnaArrivo: Colonna.H,
            traversaArrivo: Traversa.Prima);
            //Then
            Assert.True(esito);
        }

        [Fact]
        public void LAlfiereMuoveIndietroASinistradiUnaCasa()
        {
            //Given
            Alfiere alfiere = new Alfiere(Colore.Nero);
            //When
            bool esito = alfiere.PuòMuovere(
            colonnaPartenza: Colonna.D,
            traversaPartenza: Traversa.Quinta,
            colonnaArrivo: Colonna.C,
            traversaArrivo: Traversa.Quarta);
            //Then
            Assert.True(esito);
        }

        [Fact]
        public void LAlfiereMuoveIndietroASinstradiDueCase()
        {
            //Given
            Alfiere alfiere = new Alfiere(Colore.Nero);
            //When
            bool esito = alfiere.PuòMuovere(
            colonnaPartenza: Colonna.D,
            traversaPartenza: Traversa.Quinta,
            colonnaArrivo: Colonna.B,
            traversaArrivo: Traversa.Terza);
            //Then
            Assert.True(esito);
        }

        [Fact]
        public void LAlfiereMuoveIndietroASinistradiTreCase()
        {
            //Given
            Alfiere alfiere = new Alfiere(Colore.Nero);
            //When
            bool esito = alfiere.PuòMuovere(
            colonnaPartenza: Colonna.D,
            traversaPartenza: Traversa.Quinta,
            colonnaArrivo: Colonna.A,
            traversaArrivo: Traversa.Seconda);
            //Then
            Assert.True(esito);
        }

        [Fact]
        public void IlReMuoveAvantidiUnaCasa()
        {
            //Given
            Re re = new Re(Colore.Bianco);
            //When
            bool esito = re.PuòMuovere(
            colonnaPartenza: Colonna.C,
            traversaPartenza: Traversa.Quarta,
            colonnaArrivo: Colonna.C,
            traversaArrivo: Traversa.Quinta);
            //Then
            Assert.True(esito);
        }
        [Fact]
        public void IlReMuoveAvantiADestradiUnaCasa()
        {
            //Given
            Re re = new Re(Colore.Bianco);
            //When
            bool esito = re.PuòMuovere(
            colonnaPartenza: Colonna.C,
            traversaPartenza: Traversa.Quarta,
            colonnaArrivo: Colonna.D,
            traversaArrivo: Traversa.Quinta);
            //Then
            Assert.True(esito);
        }
        [Fact]
        public void IlReMuoveAvantiASinistradiUnaCasa()
        {
            //Given
            Re re = new Re(Colore.Bianco);
            //When
            bool esito = re.PuòMuovere(
            colonnaPartenza: Colonna.C,
            traversaPartenza: Traversa.Quarta,
            colonnaArrivo: Colonna.B,
            traversaArrivo: Traversa.Quinta);
            //Then
            Assert.True(esito);
        }
        [Fact]
        public void IlReMuoveASinistradiUnaCasa()
        {
            //Given
            Re re = new Re(Colore.Bianco);
            //When
            bool esito = re.PuòMuovere(
            colonnaPartenza: Colonna.C,
            traversaPartenza: Traversa.Quarta,
            colonnaArrivo: Colonna.B,
            traversaArrivo: Traversa.Quarta);
            //Then
            Assert.True(esito);
        }

        [Fact]
        public void IlReMuoveADestradiUnaCasa()
        {
            //Given
            Re re = new Re(Colore.Bianco);
            //When
            bool esito = re.PuòMuovere(
            colonnaPartenza: Colonna.C,
            traversaPartenza: Traversa.Quarta,
            colonnaArrivo: Colonna.D,
            traversaArrivo: Traversa.Quarta);
            //Then
            Assert.True(esito);
        }

        [Fact]
        public void IlReMuoveIndietrodiUnaCasa()
        {
            //Given
            Re re = new Re(Colore.Bianco);
            //When
            bool esito = re.PuòMuovere(
            colonnaPartenza: Colonna.C,
            traversaPartenza: Traversa.Quarta,
            colonnaArrivo: Colonna.C,
            traversaArrivo: Traversa.Terza);
            //Then
            Assert.True(esito);
        }
        [Fact]
        public void IlReMuoveIndietroADestradiUnaCasa()
        {
            //Given
            Re re = new Re(Colore.Bianco);
            //When
            bool esito = re.PuòMuovere(
            colonnaPartenza: Colonna.C,
            traversaPartenza: Traversa.Quarta,
            colonnaArrivo: Colonna.D,
            traversaArrivo: Traversa.Terza);
            //Then
            Assert.True(esito);
        }
        [Fact]
        public void IlReMuoveIndieitroASinistradiUnaCasa()
        {
            //Given
            Re re = new Re(Colore.Bianco);
            //When
            bool esito = re.PuòMuovere(
            colonnaPartenza: Colonna.C,
            traversaPartenza: Traversa.Quarta,
            colonnaArrivo: Colonna.B,
            traversaArrivo: Traversa.Terza);
            //Then
            Assert.True(esito);
        }
        [Fact]
        public void IlReNonMuovediDueCasa()
        {
            //Given
            Re re = new Re(Colore.Bianco);
            //When
            bool esito = re.PuòMuovere(
            colonnaPartenza: Colonna.C,
            traversaPartenza: Traversa.Quarta,
            colonnaArrivo: Colonna.C,
            traversaArrivo: Traversa.Sesta);
            //Then
            Assert.False(esito);
        }

        [Fact]
        public void LaDonnaMuoveAvantidiUnaCasa()
        {
            //Given
            Donna donna = new Donna(Colore.Bianco);
            //When
            bool esito = donna.PuòMuovere(
            colonnaPartenza: Colonna.C,
            traversaPartenza: Traversa.Quarta,
            colonnaArrivo: Colonna.C,
            traversaArrivo: Traversa.Quinta);
            //Then
            Assert.True(esito);
        }
        [Fact]
        public void LaDonnaMuoveAvantiADestradiUnaCasa()
        {
            //Given
            Donna donna = new Donna(Colore.Bianco);
            //When
            bool esito = donna.PuòMuovere(
            colonnaPartenza: Colonna.C,
            traversaPartenza: Traversa.Quarta,
            colonnaArrivo: Colonna.D,
            traversaArrivo: Traversa.Quinta);
            //Then
            Assert.True(esito);
        }
        [Fact]
        public void LaDonnaMuoveAvantiASinistradiUnaCasa()
        {
            //Given
            Donna donna = new Donna(Colore.Bianco);
            //When
            bool esito = donna.PuòMuovere(
            colonnaPartenza: Colonna.C,
            traversaPartenza: Traversa.Quarta,
            colonnaArrivo: Colonna.B,
            traversaArrivo: Traversa.Quinta);
            //Then
            Assert.True(esito);
        }
        [Fact]
        public void LaDonnaMuoveASinistradiUnaCasa()
        {
            //Given
            Donna donna = new Donna(Colore.Bianco);
            //When
            bool esito = donna.PuòMuovere(
            colonnaPartenza: Colonna.C,
            traversaPartenza: Traversa.Quarta,
            colonnaArrivo: Colonna.B,
            traversaArrivo: Traversa.Quarta);
            //Then
            Assert.True(esito);
        }

        [Fact]
        public void LaDonnaMuoveADestradiUnaCasa()
        {
            //Given
            Donna donna = new Donna(Colore.Bianco);
            //When
            bool esito = donna.PuòMuovere(
            colonnaPartenza: Colonna.C,
            traversaPartenza: Traversa.Quarta,
            colonnaArrivo: Colonna.D,
            traversaArrivo: Traversa.Quarta);
            //Then
            Assert.True(esito);
        }

        [Fact]
        public void LaDonnaMuoveIndietrodiUnaCasa()
        {
            //Given
            Donna donna = new Donna(Colore.Bianco);
            //When
            bool esito = donna.PuòMuovere(
            colonnaPartenza: Colonna.C,
            traversaPartenza: Traversa.Quarta,
            colonnaArrivo: Colonna.C,
            traversaArrivo: Traversa.Terza);
            //Then
            Assert.True(esito);
        }
        [Fact]
        public void LaDonnaMuoveIndietroADestradiUnaCasa()
        {
            //Given
            Donna donna = new Donna(Colore.Bianco);
            //When
            bool esito = donna.PuòMuovere(
            colonnaPartenza: Colonna.C,
            traversaPartenza: Traversa.Quarta,
            colonnaArrivo: Colonna.D,
            traversaArrivo: Traversa.Terza);
            //Then
            Assert.True(esito);
        }
        [Fact]
        public void LaDonnaMuoveIndieitroASinistradiUnaCasa()
        {
            //Given
            Donna donna = new Donna(Colore.Bianco);
            //When
            bool esito = donna.PuòMuovere(
            colonnaPartenza: Colonna.C,
            traversaPartenza: Traversa.Quarta,
            colonnaArrivo: Colonna.B,
            traversaArrivo: Traversa.Terza);
            //Then
            Assert.True(esito);
        }

        [Fact]
        public void LaDonnaMuoveAvantiDiUnaCasa()
        {
            //Given
            Donna donna = new Donna(Colore.Bianco);
            //When
            bool esito = donna.PuòMuovere(
            colonnaPartenza: Colonna.F,
            traversaPartenza: Traversa.Quarta,
            colonnaArrivo: Colonna.F,
            traversaArrivo: Traversa.Quinta);
            //Then
            Assert.True(esito);
        }

        [Fact]
        public void LaDonnaMuoveIndietroDiUnaCasa()
        {
            //Given
            Donna donna = new Donna(Colore.Bianco);
            //When
            bool esito = donna.PuòMuovere(
            colonnaPartenza: Colonna.F,
            traversaPartenza: Traversa.Quarta,
            colonnaArrivo: Colonna.F,
            traversaArrivo: Traversa.Terza);
            //Then
            Assert.True(esito);
        }

        [Fact]
        public void LaDonnaMuoveAvantiDiDueCase()
        {
            //Given
            Donna donna = new Donna(Colore.Bianco);
            //When
            bool esito = donna.PuòMuovere(
            colonnaPartenza: Colonna.F,
            traversaPartenza: Traversa.Quarta,
            colonnaArrivo: Colonna.F,
            traversaArrivo: Traversa.Sesta);
            //Then
            Assert.True(esito);
        }

        [Fact]
        public void LaDonnaMuoveIndietroDiDueCase()
        {
            //Given
            Donna donna = new Donna(Colore.Bianco);
            //When
            bool esito = donna.PuòMuovere(
            colonnaPartenza: Colonna.F,
            traversaPartenza: Traversa.Quarta,
            colonnaArrivo: Colonna.F,
            traversaArrivo: Traversa.Seconda);
            //Then
            Assert.True(esito);
        }

        [Fact]
        public void LaDonnaMuoveAvantiDiQuattroCase()
        {
            //Given
            Donna donna = new Donna(Colore.Bianco);
            //When
            bool esito = donna.PuòMuovere(
            colonnaPartenza: Colonna.F,
            traversaPartenza: Traversa.Quarta,
            colonnaArrivo: Colonna.F,
            traversaArrivo: Traversa.Ottava);
            //Then
            Assert.True(esito);
        }

        [Fact]
        public void LaDonnaMuoveIndietroDiTreCase()
        {
            //Given
            Donna donna = new Donna(Colore.Bianco);
            //When
            bool esito = donna.PuòMuovere(
            colonnaPartenza: Colonna.F,
            traversaPartenza: Traversa.Quarta,
            colonnaArrivo: Colonna.F,
            traversaArrivo: Traversa.Prima);
            //Then
            Assert.True(esito);
        }

        [Fact]
        public void LaDonnaMuoveASinistraDiUnaCasa()
        {
            //Given
            Donna donna = new Donna(Colore.Bianco);
            //When
            bool esito = donna.PuòMuovere(
            colonnaPartenza: Colonna.F,
            traversaPartenza: Traversa.Quinta,
            colonnaArrivo: Colonna.E,
            traversaArrivo: Traversa.Quinta);
            //Then
            Assert.True(esito);
        }

        [Fact]
        public void LaDonnaMuoveADestraDiUnaCasa()
        {
            //Given
            Donna donna = new Donna(Colore.Bianco);
            //When
            bool esito = donna.PuòMuovere(
            colonnaPartenza: Colonna.F,
            traversaPartenza: Traversa.Quinta,
            colonnaArrivo: Colonna.G,
            traversaArrivo: Traversa.Quinta);
            //Then
            Assert.True(esito);
        }

        [Fact]
        public void LaDonnaMuoveASinistraDiDueCase()
        {
            //Given
            Donna donna = new Donna(Colore.Bianco);
            //When
            bool esito = donna.PuòMuovere(
            colonnaPartenza: Colonna.F,
            traversaPartenza: Traversa.Quinta,
            colonnaArrivo: Colonna.D,
            traversaArrivo: Traversa.Quinta);
            //Then
            Assert.True(esito);
        }

        [Fact]
        public void LaDonnaMuoveADestraDiDueCase()
        {
            //Given
            Donna donna = new Donna(Colore.Bianco);
            //When
            bool esito = donna.PuòMuovere(
            colonnaPartenza: Colonna.F,
            traversaPartenza: Traversa.Quinta,
            colonnaArrivo: Colonna.H,
            traversaArrivo: Traversa.Quinta);
            //Then
            Assert.True(esito);
        }

        [Fact]
        public void LaDonnaMuoveASinistraDiQuattroCase()
        {
            //Given
            Donna donna = new Donna(Colore.Bianco);
            //When
            bool esito = donna.PuòMuovere(
            colonnaPartenza: Colonna.F,
            traversaPartenza: Traversa.Quinta,
            colonnaArrivo: Colonna.B,
            traversaArrivo: Traversa.Quinta);
            //Then
            Assert.True(esito);
        }

        [Fact]
        public void LaDonnaMuoveASinistraDiCinqueCase()
        {
            //Given
            Donna donna = new Donna(Colore.Bianco);
            //When
            bool esito = donna.PuòMuovere(
            colonnaPartenza: Colonna.F,
            traversaPartenza: Traversa.Quinta,
            colonnaArrivo: Colonna.A,
            traversaArrivo: Traversa.Quinta);
            //Then
            Assert.True(esito);
        }

        public void LaDonnaNonPuòRimanereFermaUnaVoltaScelta()
        {
            //Given
            Donna donna = new Donna(Colore.Bianco);
            //When
            bool esito = donna.PuòMuovere(
            colonnaPartenza: Colonna.F,
            traversaPartenza: Traversa.Quinta,
            colonnaArrivo: Colonna.F,
            traversaArrivo: Traversa.Quinta);
            //Then
            Assert.False(esito);
        }

        [Fact]
        public void LaDonnaMuoveAvantiADestradiDueCase()
        {
            //Given
            Donna donna = new Donna(Colore.Nero);
            //When
            bool esito = donna.PuòMuovere(
            colonnaPartenza: Colonna.D,
            traversaPartenza: Traversa.Quinta,
            colonnaArrivo: Colonna.F,
            traversaArrivo: Traversa.Settima);
            //Then
            Assert.True(esito);
        }

        [Fact]
        public void LaDonnaMuoveAvantiADestradiTreCase()
        {
            //Given
            Donna donna = new Donna(Colore.Nero);
            //When
            bool esito = donna.PuòMuovere(
            colonnaPartenza: Colonna.D,
            traversaPartenza: Traversa.Quinta,
            colonnaArrivo: Colonna.G,
            traversaArrivo: Traversa.Ottava);
            //Then
            Assert.True(esito);
        }

        [Fact]
        public void LaDonnaMuoveAvantiASinistradiDueCase()
        {
            //Given
            Donna donna = new Donna(Colore.Nero);
            //When
            bool esito = donna.PuòMuovere(
            colonnaPartenza: Colonna.D,
            traversaPartenza: Traversa.Quinta,
            colonnaArrivo: Colonna.B,
            traversaArrivo: Traversa.Settima);
            //Then
            Assert.True(esito);
        }

        [Fact]
        public void LaDonnaMuoveAvantiASinistradiTreCase()
        {
            //Given
            Donna donna = new Donna(Colore.Nero);
            //When
            bool esito = donna.PuòMuovere(
            colonnaPartenza: Colonna.D,
            traversaPartenza: Traversa.Quinta,
            colonnaArrivo: Colonna.A,
            traversaArrivo: Traversa.Ottava);
            //Then
            Assert.True(esito);
        }

        [Fact]
        public void LaDonnaMuoveIndietroADestradiDueCase()
        {
            //Given
            Donna donna = new Donna(Colore.Nero);
            //When
            bool esito = donna.PuòMuovere(
            colonnaPartenza: Colonna.D,
            traversaPartenza: Traversa.Quinta,
            colonnaArrivo: Colonna.F,
            traversaArrivo: Traversa.Terza);
            //Then
            Assert.True(esito);
        }

        [Fact]
        public void LaDonnaMuoveIndietroADestradiTreCase()
        {
            //Given
            Donna donna = new Donna(Colore.Nero);
            //When
            bool esito = donna.PuòMuovere(
            colonnaPartenza: Colonna.D,
            traversaPartenza: Traversa.Quinta,
            colonnaArrivo: Colonna.G,
            traversaArrivo: Traversa.Seconda);
            //Then
            Assert.True(esito);
        }

        [Fact]
        public void LaDonnaMuoveIndietroADestradiQuattroCase()
        {
            //Given
            Donna donna = new Donna(Colore.Nero);
            //When
            bool esito = donna.PuòMuovere(
            colonnaPartenza: Colonna.D,
            traversaPartenza: Traversa.Quinta,
            colonnaArrivo: Colonna.H,
            traversaArrivo: Traversa.Prima);
            //Then
            Assert.True(esito);
        }

        [Fact]
        public void LaDonnaMuoveIndietroASinstradiDueCase()
        {
            //Given
            Donna donna = new Donna(Colore.Nero);
            //When
            bool esito = donna.PuòMuovere(
            colonnaPartenza: Colonna.D,
            traversaPartenza: Traversa.Quinta,
            colonnaArrivo: Colonna.B,
            traversaArrivo: Traversa.Terza);
            //Then
            Assert.True(esito);
        }

        [Fact]
        public void LaDonnaMuoveIndietroASinistradiTreCase()
        {
            //Given
            Donna donna = new Donna(Colore.Nero);
            //When
            bool esito = donna.PuòMuovere(
            colonnaPartenza: Colonna.D,
            traversaPartenza: Traversa.Quinta,
            colonnaArrivo: Colonna.A,
            traversaArrivo: Traversa.Seconda);
            //Then
            Assert.True(esito);
        }

        [Theory]
        [InlineData(Colore.Bianco)]
        [InlineData(Colore.Nero)]
        public void IlPedonePuoMuovereDiagonalmenteSeCatturaUnPezzo(Colore colore)
        {
            //Given
            var pedone = new Pedone(colore);
            Pedone pedoneNemico;
            Traversa traversaInizio;
            Traversa traversaArrivo;
            if(colore == Colore.Bianco) {
                traversaInizio = Traversa.Prima;
                traversaArrivo = Traversa.Seconda;
                pedoneNemico = new Pedone(Colore.Nero);
            } else {
                traversaInizio = Traversa.Settima;
                traversaArrivo = Traversa.Sesta;
                pedoneNemico = new Pedone(Colore.Bianco);
            }
            IEnumerable<ICasa> listaCase = new List<Casa>{
            new Casa(Colonna.A,traversaInizio){
                PezzoPresente = pedone
            },
            new Casa(Colonna.B,traversaArrivo){
                PezzoPresente = pedoneNemico
            }
        };

            //When

            bool esito = pedone.PuòMuovere(
                colonnaPartenza: Colonna.A,
                traversaPartenza: traversaInizio,
                colonnaArrivo: Colonna.B,
                traversaArrivo: traversaArrivo,
                listaCase: listaCase
            );
            //Then
            Assert.True(esito);

        }
        [Fact]
        public void IlPedoneNonPuoMuovereSeHaQualcunoDavanti()
        {
            //Given
            var pedone = new Pedone(Colore.Bianco);
            IEnumerable<ICasa> listaCase = new List<Casa> {
            new Casa(Colonna.A,Traversa.Prima){
                PezzoPresente = pedone
            },
            new Casa(Colonna.A,Traversa.Seconda){
                PezzoPresente = new Pedone(Colore.Bianco)
            }
        };
            //When
            bool esito = pedone.PuòMuovere(
                colonnaPartenza: Colonna.A,
                traversaPartenza: Traversa.Prima,
                colonnaArrivo: Colonna.A,
                traversaArrivo: Traversa.Seconda,
                listaCase: listaCase
            );
            //Then
            Assert.False(esito);
        }

        [Theory]
        [InlineData(Colore.Bianco)]
        [InlineData(Colore.Nero)]
        public void IlPedonePuòMuovereAvantiDiDueCase(Colore colore)
        {
        //Given
        var pedone = new Pedone(colore);
        //When
        Traversa traversaInizio;
        Traversa traversaFine;
        if(colore == Colore.Nero) {
            traversaInizio = Traversa.Settima;
            traversaFine = Traversa.Quinta;
        } else {
            traversaInizio = Traversa.Seconda;
            traversaFine = Traversa.Quarta;
        }
        bool result = pedone.PuòMuovere(
            Colonna.A,
            traversaInizio,
            Colonna.A,
            traversaFine
        );
        //Then
        Assert.True(result);

        }

        [Theory]
        [InlineData(Colore.Bianco)]
        [InlineData(Colore.Nero)]
        public void ilPedoneNonSiPuoMuovereInDiagonaleSeNonMangiaUnPezzo(Colore colore)
        {
        //Given
        var pedone = new Pedone(colore);
        //When
        Traversa traversaInizio;
        Traversa traversaFine;
        if(colore == Colore.Nero) {
            traversaInizio = Traversa.Settima;
            traversaFine = Traversa.Sesta;
        } else {
            traversaInizio = Traversa.Seconda;
            traversaFine = Traversa.Terza;
        }
        bool result = pedone.PuòMuovere(
            Colonna.A,
            traversaInizio,
            Colonna.B,
            traversaFine
        );
        //Then
        Assert.False(result);
        }

        [Fact]
        public void AlfiereSiPuoMuovereInDiagonaleDiQuantoVuole()
        {
        //Given
        var alfiere = new Alfiere(Colore.Bianco);
        Scacchiera scacchiera = new Scacchiera();
        //When
        Traversa traversaInizio = Traversa.Seconda;
        Traversa traversaFine = Traversa.Quarta;
        scacchiera[Colonna.A, traversaInizio].PezzoPresente = alfiere;
        bool result = alfiere.PuòMuovere(
            Colonna.A,
            traversaInizio,
            Colonna.C,
            traversaFine,
            scacchiera.Case
        );
        //Then
        Assert.True(result);

        }

        [Fact]
        public void DonnaSiPuoMuovereInDiagonaleDiQuantoVuole()
        {
        //Given
        var donna = new Donna(Colore.Bianco);
        Scacchiera scacchiera = new Scacchiera();
        //When
        Traversa traversaInizio = Traversa.Seconda;
        Traversa traversaFine = Traversa.Quarta;
        scacchiera[Colonna.A, traversaInizio].PezzoPresente = donna;
        bool result = donna.PuòMuovere(
            Colonna.A,
            traversaInizio,
            Colonna.C,
            traversaFine,
            scacchiera.Case
        );
        //Then
        Assert.True(result);
        }

        [Fact]
        public void IlPedoneNonPuoMuovereDiDueCaseInAvantiSeCaseNelPercorsoSonoOccupate()
        {
            //Given
            var pedone = new Pedone(Colore.Bianco);
            IEnumerable<ICasa> listaCase = new List<Casa> {
            new Casa(Colonna.A,Traversa.Seconda){
                PezzoPresente = pedone
            },
            new Casa(Colonna.A,Traversa.Terza){
                PezzoPresente = new Pedone(Colore.Bianco)
            },
            new Casa(Colonna.A, Traversa.Quarta)
        };
            //When
            bool esito = pedone.PuòMuovere(
                colonnaPartenza: Colonna.A,
                traversaPartenza: Traversa.Seconda,
                colonnaArrivo: Colonna.A,
                traversaArrivo: Traversa.Quarta,
                listaCase: listaCase
            );
            //Then
            Assert.False(esito);
        }

        [Fact]
        public void LaDonnaBiancaNonPuòScavalcareAltriPezziColSuoMovimentoObliquo()
        {
            //Given
            var donna = new Donna(Colore.Bianco);
            //When
            IEnumerable<ICasa> listaCase = new List<Casa> {
            new Casa(Colonna.E,Traversa.Prima){
                PezzoPresente = donna
            },
            new Casa(Colonna.F,Traversa.Seconda){
                //metto il pedone bianco simulando l'inizio della partita
                PezzoPresente = new Pedone(Colore.Bianco)
            },
            new Casa(Colonna.G, Traversa.Terza)
        };
            //Then
            //When
            bool esito = donna.PuòMuovere(
                colonnaPartenza: Colonna.E,
                traversaPartenza: Traversa.Prima,
                colonnaArrivo: Colonna.G,
                traversaArrivo: Traversa.Terza,
                listaCase: listaCase
            );
             //Then
            Assert.False(esito);
        }
        [Fact]
        public void LaDonnaBiancaNonPuòSpostarsiInObliquoUnaCasaConUnPezzoBianco()
        {
        var donna = new Donna(Colore.Bianco);
            //When
            IEnumerable<ICasa> listaCase = new List<Casa> {
            new Casa(Colonna.E,Traversa.Prima){
                PezzoPresente = donna
            },
            new Casa(Colonna.F,Traversa.Seconda),
            new Casa(Colonna.G, Traversa.Terza){
                //metto il pedone bianco in un posto obliquo alla posizione della regina
                PezzoPresente = new Pedone(Colore.Bianco)
            }
        };
            //Then
            //When
            bool esito = donna.PuòMuovere(
                colonnaPartenza: Colonna.E,
                traversaPartenza: Traversa.Prima,
                colonnaArrivo: Colonna.G,
                traversaArrivo: Traversa.Terza,
                listaCase: listaCase
            );
             //Then
            Assert.False(esito);
        }
        [Fact]
        public void LaDonnaBiancaPuòSposarsiInObliquoInUnaCasellaConUnPezzoNero()
        {
          var donna = new Donna(Colore.Bianco);
            //When
            IEnumerable<ICasa> listaCase = new List<Casa> {
            new Casa(Colonna.E,Traversa.Prima){
                PezzoPresente = donna
            },
            new Casa(Colonna.F,Traversa.Seconda),
            new Casa(Colonna.G, Traversa.Terza){
                //metto il pedone nero in un posto obliquo alla posizione della regina
                PezzoPresente = new Pedone(Colore.Nero)
            }
        };
            //Then
            //When
            bool esito = donna.PuòMuovere(
                colonnaPartenza: Colonna.E,
                traversaPartenza: Traversa.Prima,
                colonnaArrivo: Colonna.G,
                traversaArrivo: Traversa.Terza,
                listaCase: listaCase
            );
             //Then
            Assert.True(esito);
        }

         [Fact]
        public void LaDonnaBiancaNonPuòScavalcareAltriPezziColSuoMovimentoOrizzontale()
        {
            //Given
            var donna = new Donna(Colore.Bianco);
            //When
            IEnumerable<ICasa> listaCase = new List<Casa> {
            new Casa(Colonna.E,Traversa.Prima){
                PezzoPresente = donna
            },
            new Casa(Colonna.F,Traversa.Prima){
                //metto il pedone bianco simulando l'inizio della partita
                PezzoPresente = new Pedone(Colore.Bianco)
            },
            new Casa(Colonna.G, Traversa.Prima)
        };
            //Then
            //When
            bool esito = donna.PuòMuovere(
                colonnaPartenza: Colonna.E,
                traversaPartenza: Traversa.Prima,
                colonnaArrivo: Colonna.G,
                traversaArrivo: Traversa.Prima,
                listaCase: listaCase
            );
             //Then
            Assert.False(esito);
        }
        [Fact]
        public void LaDonnaBiancaNonPuòSpostarsiInOrizzontaleInUnaCasaConUnPezzoBianco()
        {
        var donna = new Donna(Colore.Bianco);
            //When
            IEnumerable<ICasa> listaCase = new List<Casa> {
            new Casa(Colonna.E,Traversa.Prima){
                PezzoPresente = donna
            },
            new Casa(Colonna.F,Traversa.Prima),
            new Casa(Colonna.G, Traversa.Prima){
                //metto il pedone bianco in un posto obliquo alla posizione della regina
                PezzoPresente = new Pedone(Colore.Bianco)
            }
        };
            //Then
            //When
            bool esito = donna.PuòMuovere(
                colonnaPartenza: Colonna.E,
                traversaPartenza: Traversa.Prima,
                colonnaArrivo: Colonna.G,
                traversaArrivo: Traversa.Prima,
                listaCase: listaCase
            );
             //Then
            Assert.False(esito);
        }
        [Fact]
        public void LaDonnaBiancaPuòSposarsiInOrizzontaleInUnaCasellaConUnPezzoNero()
        {
          var donna = new Donna(Colore.Bianco);
            //When
            IEnumerable<ICasa> listaCase = new List<Casa> {
            new Casa(Colonna.E,Traversa.Prima){
                PezzoPresente = donna
            },
            new Casa(Colonna.F,Traversa.Prima),
            new Casa(Colonna.G, Traversa.Prima){
                //metto il pedone nero in un posto obliquo alla posizione della regina
                PezzoPresente = new Pedone(Colore.Nero)
            }
        };
            //Then
            //When
            bool esito = donna.PuòMuovere(
                colonnaPartenza: Colonna.E,
                traversaPartenza: Traversa.Prima,
                colonnaArrivo: Colonna.G,
                traversaArrivo: Traversa.Prima,
                listaCase: listaCase
            );
             //Then
            Assert.True(esito);
        }

        public void LAlfiereNonPuoMuovereInAvantiADestraSeCaseNelPercorsoSonoOccupate()
        {
        //Given
        var alfiere = new Alfiere(Colore.Bianco);
        IEnumerable<ICasa> listaCase = new List<Casa> {
            new Casa(Colonna.D,Traversa.Quarta){
                PezzoPresente = alfiere
            },
            new Casa(Colonna.F,Traversa.Sesta){
                PezzoPresente = new Pedone(Colore.Nero)
            },
            new Casa(Colonna.H, Traversa.Ottava)
        };
        //When
        bool esito = alfiere.PuòMuovere(
            colonnaPartenza: Colonna.D,
            traversaPartenza: Traversa.Quarta,
            colonnaArrivo: Colonna.H,
            traversaArrivo: Traversa.Ottava,
            listaCase: listaCase
        );
        //Then
        Assert.False(esito);
        }

        [Fact]
        public void LAlfiereNonPuoMuovereInAvantiASinistraSeCaseNelPercorsoSonoOccupate()
        {
        //Given
        var alfiere = new Alfiere(Colore.Bianco);
        IEnumerable<ICasa> listaCase = new List<Casa> {
            new Casa(Colonna.D,Traversa.Quarta){
                PezzoPresente = alfiere
            },
            new Casa(Colonna.C,Traversa.Quinta){
                PezzoPresente = new Pedone(Colore.Nero)
            },
            new Casa(Colonna.A, Traversa.Settima)
        };
        //When
        bool esito = alfiere.PuòMuovere(
            colonnaPartenza: Colonna.D,
            traversaPartenza: Traversa.Quarta,
            colonnaArrivo: Colonna.A,
            traversaArrivo: Traversa.Settima,
            listaCase: listaCase
        );
        //Then
        Assert.False(esito);
        }

        [Fact]
        public void LAlfiereNonPuoMuovereIndietroADestraSeCaseNelPercorsoSonoOccupate()
        {
        //Given
        var alfiere = new Alfiere(Colore.Bianco);
        IEnumerable<ICasa> listaCase = new List<Casa> {
            new Casa(Colonna.D,Traversa.Quarta){
                PezzoPresente = alfiere
            },
            new Casa(Colonna.F,Traversa.Seconda){
                PezzoPresente = new Pedone(Colore.Nero)
            },
            new Casa(Colonna.G, Traversa.Prima)
        };
        //When
        bool esito = alfiere.PuòMuovere(
            colonnaPartenza: Colonna.D,
            traversaPartenza: Traversa.Quarta,
            colonnaArrivo: Colonna.G,
            traversaArrivo: Traversa.Prima,
            listaCase: listaCase
        );
        //Then
        Assert.False(esito);
        }

        [Fact]
        public void LAlfiereNonPuoMuovereIndietroASinistraSeCaseNelPercorsoSonoOccupate()
        {
        //Given
        var alfiere = new Alfiere(Colore.Bianco);
        IEnumerable<ICasa> listaCase = new List<Casa> {
            new Casa(Colonna.D,Traversa.Quarta){
                PezzoPresente = alfiere
            },
            new Casa(Colonna.C,Traversa.Terza){
                PezzoPresente = new Pedone(Colore.Nero)
            },
            new Casa(Colonna.A, Traversa.Prima)
        };
        //When
        bool esito = alfiere.PuòMuovere(
            colonnaPartenza: Colonna.D,
            traversaPartenza: Traversa.Quarta,
            colonnaArrivo: Colonna.A,
            traversaArrivo: Traversa.Prima,
            listaCase: listaCase
        );
        //Then
        Assert.False(esito);
        }

        [Fact]
        public void LAlfierePuòMuovereIndietroASinistraSeCaseNonNelPercorsoSonoOccupate()
        {
        //Given
        var alfiere = new Alfiere(Colore.Bianco);
        IEnumerable<ICasa> listaCase = new List<Casa> {
            new Casa(Colonna.D,Traversa.Quarta){
                PezzoPresente = alfiere
            },
            new Casa(Colonna.E,Traversa.Quinta){
                PezzoPresente = new Pedone(Colore.Nero)
            },
            new Casa(Colonna.A, Traversa.Prima)
        };
        //When
        bool esito = alfiere.PuòMuovere(
            colonnaPartenza: Colonna.D,
            traversaPartenza: Traversa.Quarta,
            colonnaArrivo: Colonna.A,
            traversaArrivo: Traversa.Prima,
            listaCase: listaCase
        );
        //Then
        Assert.True(esito);
        }

        [Fact]
        public void LAlfierePuoMuovereInAvantiADestraSeCaseNonNelPercorsoSonoOccupate()
        {
        //Given
        var alfiere = new Alfiere(Colore.Bianco);
        IEnumerable<ICasa> listaCase = new List<Casa> {
            new Casa(Colonna.D,Traversa.Quarta){
                PezzoPresente = alfiere
            },
            new Casa(Colonna.H,Traversa.Ottava){
                PezzoPresente = new Pedone(Colore.Nero)
            },
            new Casa(Colonna.G, Traversa.Settima)
        };
        //When
        bool esito = alfiere.PuòMuovere(
            colonnaPartenza: Colonna.D,
            traversaPartenza: Traversa.Quarta,
            colonnaArrivo: Colonna.G,
            traversaArrivo: Traversa.Settima,
            listaCase: listaCase
        );
        //Then
        Assert.True(esito);
        }

        [Fact]
        public void LAlfiereNonPuoMuovereInAvantiASinistraSeLaCasaÈOccupataDaUnPezzoDelloStessoColore()
        {
        //Given
        var alfiere = new Alfiere(Colore.Bianco);
        IEnumerable<ICasa> listaCase = new List<Casa> {
            new Casa(Colonna.D,Traversa.Quarta){
                PezzoPresente = alfiere
            },
            new Casa(Colonna.A,Traversa.Settima){
                PezzoPresente = new Pedone(Colore.Bianco)
            }
        };
        //When
        bool esito = alfiere.PuòMuovere(
            colonnaPartenza: Colonna.D,
            traversaPartenza: Traversa.Quarta,
            colonnaArrivo: Colonna.A,
            traversaArrivo: Traversa.Settima,
            listaCase: listaCase
        );
        //Then
        Assert.False(esito);
        }

        [Fact]
        public void LAlfierePuoMuovereInAvantiASinistraSeLaCasaÈOccupataDaUnPezzoDiDiversoColore()
        {
        //Given
        var alfiere = new Alfiere(Colore.Bianco);
        IEnumerable<ICasa> listaCase = new List<Casa> {
            new Casa(Colonna.D,Traversa.Quarta){
                PezzoPresente = alfiere
            },
            new Casa(Colonna.A,Traversa.Settima){
                PezzoPresente = new Pedone(Colore.Nero)
            }
        };
        //When
        bool esito = alfiere.PuòMuovere(
            colonnaPartenza: Colonna.D,
            traversaPartenza: Traversa.Quarta,
            colonnaArrivo: Colonna.A,
            traversaArrivo: Traversa.Settima,
            listaCase: listaCase
        );
        }

        public void IlCavalloPuòScavalcareIPezziNelMovimentoAL()
        {
        //Given
        Cavallo cavallo = new Cavallo(Colore.Bianco);
         IEnumerable<ICasa> listaCase = new List<Casa> {
            new Casa(Colonna.A,Traversa.Seconda){
                PezzoPresente = cavallo
            },
            new Casa(Colonna.B,Traversa.Terza){
                PezzoPresente = new Pedone(Colore.Bianco)
            },
            new Casa(Colonna.C, Traversa.Terza)
        };
        //When
         bool esito = cavallo.PuòMuovere(
            colonnaPartenza: Colonna.A,
            traversaPartenza: Traversa.Seconda,
            colonnaArrivo: Colonna.C,
            traversaArrivo: Traversa.Terza,
            listaCase: listaCase
        );
        //Then
        Assert.True(esito);
        }

        [Theory]
        [InlineData(Colore.Bianco)]
        [InlineData(Colore.Nero)]
        public void ilCavalloNonPuòMuoversiInCaseConPezziDelloStessoColoreSeDiversoLoCattura(Colore colore)
        {
            //Given
            Cavallo cavallo = new Cavallo(Colore.Bianco);
            IEnumerable<ICasa> listaCase = new List<Casa> {
                new Casa(Colonna.A,Traversa.Seconda){
                    PezzoPresente = cavallo
                },
                new Casa(Colonna.B,Traversa.Terza){
                    PezzoPresente = new Pedone(Colore.Bianco)
                },
                new Casa(Colonna.C, Traversa.Terza) {
                    PezzoPresente = new Pedone(colore)
                }
            };
            //When
            bool esito = cavallo.PuòMuovere(
                colonnaPartenza: Colonna.A,
                traversaPartenza: Traversa.Seconda,
                colonnaArrivo: Colonna.C,
                traversaArrivo: Traversa.Terza,
                listaCase: listaCase
            );
            //Then
            if(colore == cavallo.Colore)
                Assert.False(esito);
            else
                Assert.True(esito);
        }

        [Fact]
        public void LaTorreNonPuòScavalcareNelMovimentoOrizzontale()
        {
            //Given
            var torre =  new Torre(Colore.Bianco);
            IEnumerable<ICasa> listaCase = new List<Casa> {
                new Casa(Colonna.A, Traversa.Terza){
                    PezzoPresente = torre
                },
                new Casa(Colonna.B, Traversa.Terza){
                    PezzoPresente = new Pedone(Colore.Nero)
                },
                new Casa(Colonna.C, Traversa.Terza)
            };
            //When
            bool esito = torre.PuòMuovere(
                colonnaPartenza: Colonna.A,
                traversaPartenza: Traversa.Terza,
                colonnaArrivo: Colonna.C,
                traversaArrivo: Traversa.Terza,
                listaCase: listaCase
            );
            //Then
            Assert.False(esito);
        }

        [Fact]
        public void LaTorreNonPuòScavalcareNelMovimentoVerticale()
        {
            //Given
            var torre =  new Torre(Colore.Bianco);
                IEnumerable<ICasa> listaCase = new List<Casa> {
                    new Casa(Colonna.A, Traversa.Terza){
                        PezzoPresente = torre
                    },
                    new Casa(Colonna.A, Traversa.Quarta){
                        PezzoPresente = new Pedone(Colore.Nero)
                    },
                    new Casa(Colonna.A, Traversa.Quinta)
                };
            //When
            bool esito = torre.PuòMuovere(
                    colonnaPartenza: Colonna.A,
                    traversaPartenza: Traversa.Terza,
                    colonnaArrivo: Colonna.A,
                    traversaArrivo: Traversa.Quinta,
                    listaCase: listaCase
                );
            //Then
            Assert.False(esito);
        }

        [Fact]
        public void LaTorrePuoMuovereInVerticaleSuUnaScacchieraEMangiare()
        {
        //Given
        var torre =  new Torre(Colore.Bianco);
                IEnumerable<ICasa> listaCase = new List<Casa> {
                    new Casa(Colonna.A, Traversa.Terza){
                        PezzoPresente = torre
                    },
                    new Casa(Colonna.A, Traversa.Quarta),
                    new Casa(Colonna.A, Traversa.Quinta){
                        PezzoPresente = new Pedone(Colore.Nero)
                    }
                };
        //When
        bool esito = torre.PuòMuovere(
                    colonnaPartenza: Colonna.A,
                    traversaPartenza: Traversa.Terza,
                    colonnaArrivo: Colonna.A,
                    traversaArrivo: Traversa.Quinta,
                    listaCase: listaCase
                );
        //Then
        Assert.True(esito);
        }

        [Fact]
        public void LaTorrePuoMuovereInOrizzontaleSuUnaScacchieraEMangiare()
        {
            //Given
            var torre =  new Torre(Colore.Bianco);
            IEnumerable<ICasa> listaCase = new List<Casa> {
                new Casa(Colonna.A, Traversa.Terza){
                    PezzoPresente = torre
                },
                new Casa(Colonna.B, Traversa.Terza),
                new Casa(Colonna.C, Traversa.Terza){
                    PezzoPresente = new Pedone(Colore.Nero)
                }
            };
            //When
            bool esito = torre.PuòMuovere(
                colonnaPartenza: Colonna.A,
                traversaPartenza: Traversa.Terza,
                colonnaArrivo: Colonna.C,
                traversaArrivo: Traversa.Terza,
                listaCase: listaCase
            );
            //Then
            Assert.True(esito);
        }

        [Theory]
        [InlineData(Colore.Bianco)]
        [InlineData(Colore.Nero)]
        public void LaTorreNonPuoMangiareUnPezzoDelloStessoColoreInVerticale(Colore c)
        {
        //Given
        var torre =  new Torre(c);
                IEnumerable<ICasa> listaCase = new List<Casa> {
                    new Casa(Colonna.A, Traversa.Terza){
                        PezzoPresente = torre
                    },
                    new Casa(Colonna.A, Traversa.Quarta),
                    new Casa(Colonna.A, Traversa.Quinta){
                        PezzoPresente = new Pedone(c)
                    }
                };
        //When
        bool esito = torre.PuòMuovere(
                    colonnaPartenza: Colonna.A,
                    traversaPartenza: Traversa.Terza,
                    colonnaArrivo: Colonna.A,
                    traversaArrivo: Traversa.Quinta,
                    listaCase: listaCase
                );
        //Then
        Assert.False(esito);
        }

        [Theory]
        [InlineData(Colore.Bianco)]
        [InlineData(Colore.Nero)]
        public void LaTorreNonPuoMangiareUnPezzoDelloStessoColoreInOrizzontale(Colore c)
        {
            //Given
            var torre =  new Torre(c);
            IEnumerable<ICasa> listaCase = new List<Casa> {
                new Casa(Colonna.A, Traversa.Terza){
                    PezzoPresente = torre
                },
                new Casa(Colonna.B, Traversa.Terza),
                new Casa(Colonna.C, Traversa.Terza){
                    PezzoPresente = new Pedone(c)
                }
            };
            //When
            bool esito = torre.PuòMuovere(
                colonnaPartenza: Colonna.A,
                traversaPartenza: Traversa.Terza,
                colonnaArrivo: Colonna.C,
                traversaArrivo: Traversa.Terza,
                listaCase: listaCase
            );
            //Then
            Assert.False(esito);
        }

         [Fact]
        public void LaDonnaBiancaNonPuòScavalcareAltriPezziColSuoMovimentoVerticale()
        {
            //Given
            var donna = new Donna(Colore.Bianco);
            //When
            IEnumerable<ICasa> listaCase = new List<Casa> {
            new Casa(Colonna.E,Traversa.Prima){
                PezzoPresente = donna
            },
            new Casa(Colonna.E,Traversa.Seconda){
                //metto il pedone bianco simulando l'inizio della partita
                PezzoPresente = new Pedone(Colore.Bianco)
            },
            new Casa(Colonna.E, Traversa.Terza)
        };
            //Then
            //When
            bool esito = donna.PuòMuovere(
                colonnaPartenza: Colonna.E,
                traversaPartenza: Traversa.Prima,
                colonnaArrivo: Colonna.E,
                traversaArrivo: Traversa.Terza,
                listaCase: listaCase
            );
             //Then
            Assert.False(esito);
        }
        [Fact]
        public void LaDonnaBiancaNonPuòSpostarsiInVerticaleInUnaCasaConUnPezzoBianco()
        {
        var donna = new Donna(Colore.Bianco);
            //When
            IEnumerable<ICasa> listaCase = new List<Casa> {
            new Casa(Colonna.E,Traversa.Prima){
                PezzoPresente = donna
            },
            new Casa(Colonna.E,Traversa.Seconda),
            new Casa(Colonna.E, Traversa.Terza){
                //metto il pedone bianco in un posto obliquo alla posizione della regina
                PezzoPresente = new Pedone(Colore.Bianco)
            }
        };
            //Then
            //When
            bool esito = donna.PuòMuovere(
                colonnaPartenza: Colonna.E,
                traversaPartenza: Traversa.Prima,
                colonnaArrivo: Colonna.E,
                traversaArrivo: Traversa.Terza,
                listaCase: listaCase
            );
             //Then
            Assert.False(esito);
        }
        [Fact]
        public void LaDonnaBiancaPuòSposarsiInVerticaleInUnaCasellaConUnPezzoNero()
        {
          var donna = new Donna(Colore.Bianco);
            //When
            IEnumerable<ICasa> listaCase = new List<Casa> {
            new Casa(Colonna.E,Traversa.Prima){
                PezzoPresente = donna
            },
            new Casa(Colonna.E,Traversa.Seconda),
            new Casa(Colonna.E, Traversa.Terza){
                //metto il pedone nero in un posto obliquo alla posizione della regina
                PezzoPresente = new Pedone(Colore.Nero)
            }
        };
            //Then
            //When
            bool esito = donna.PuòMuovere(
                colonnaPartenza: Colonna.E,
                traversaPartenza: Traversa.Prima,
                colonnaArrivo: Colonna.G,
                traversaArrivo: Traversa.Prima,
                listaCase: listaCase
            );
             //Then
            Assert.True(esito);
        }
    }
}


text:
package shiver.me.timbers.plugins.invoker.multi;

import org.apache.maven.plugin.logging.Log;
import org.junit.Test;

import static org.junit.Assert.assertThat;
import static shiver.me.timbers.data.random.RandomEnums.someEnum;
import static shiver.me.timbers.matchers.Matchers.hasProperty;

public class DefaultLogFactoryTest {

    @Test
    public void Can_create_a_default_log() {

        // Given
        final LogLevel logLevel = someEnum(LogLevel.class);

        // When
        final Log actual = new DefaultLogFactory().create(logLevel);

        // Then
        assertThat(actual, hasProperty("logger.threshold", logLevel.getThreshold()));
    }
}

redpajama_set_name: RedPajamaGithub


text:
/** \author Wojciech Terepeta <wojciech.terepeta@gmail.com>
  */
#include <iostream>
#include <string>

#include "ide_listener.h"
#include "cute_runner.h"

#include "Logger.h"
#include "LogLevel.h"
#include "LoggerTest.h"

namespace wt
{
namespace test
{

using utility::Logger;
using utility::LogLevel;

void
LoggerTest::RunSuite()
{
    cute::suite s;

    s.push_back(CUTE_SMEMFUN(Tests, GetInstance));
    s.push_back(CUTE_SMEMFUN(Tests, DefaultLoggerEngine));
    s.push_back(CUTE_SMEMFUN(Tests, LogLevelToString));
    s.push_back(CUTE_SMEMFUN(Tests, StringToLogLevel));
    s.push_back(CUTE_SMEMFUN(Tests, AddLoggerEngine01));
    s.push_back(CUTE_SMEMFUN(Tests, AddLoggerEngine02));
    s.push_back(CUTE_SMEMFUN(Tests, RemoveLoggerEngine));
    s.push_back(CUTE_SMEMFUN(Tests, RemoveAllLoggerEngines));
    s.push_back(CUTE_SMEMFUN(Tests, Log));
    s.push_back(CUTE_SMEMFUN(Tests, LogStream));
    s.push_back(CUTE_SMEMFUN(Tests, LogVariadic));
    s.push_back(CUTE_SMEMFUN(Tests, DisableLogging));
    s.push_back(CUTE_SMEMFUN(Tests, DisableLogLevel));
    s.push_back(CUTE_SMEMFUN(Tests, GetTotalEngines));

    cute::ide_listener<> lis;
    cute::makeRunner(lis)(s, "Logger tests");
}

void
LoggerTest::Tests::GetInstance()
{
    ASSERTM("The static instance of Logger should not be null!", WtLog != nullptr);
}

void
LoggerTest::Tests::DefaultLoggerEngine()
{
    ASSERTM("No default logger engine!", WtLog->IsLoggerEngine("__default__"));
    WtLog->Debug() << "Using the default logger engine";
}

void
LoggerTest::Tests::LogLevelToString()
{
    ASSERT_EQUAL(utility::LogLevelNoneName, utility::LogLevelToString(LogLevel::None));
    ASSERT_EQUAL(utility::LogLevelTraceName, utility::LogLevelToString(LogLevel::Trace));
    ASSERT_EQUAL(utility::LogLevelDebugName, utility::LogLevelToString(LogLevel::Debug));
    ASSERT_EQUAL(utility::LogLevelInfoName, utility::LogLevelToString(LogLevel::Info));
    ASSERT_EQUAL(utility::LogLevelWarningName, utility::LogLevelToString(LogLevel::Warning));
    ASSERT_EQUAL(utility::LogLevelErrorName, utility::LogLevelToString(LogLevel::Error));
    ASSERT_EQUAL(utility::LogLevelCriticalName, utility::LogLevelToString(LogLevel::Critical));
    ASSERT_EQUAL(utility::LogLevelFatalName, utility::LogLevelToString(LogLevel::Fatal));
    ASSERT_EQUAL(utility::LogLevelWtfName, utility::LogLevelToString(LogLevel::Wtf));
    ASSERT_EQUAL(utility::LogLevelAllName, utility::LogLevelToString(LogLevel::All));
}

void
LoggerTest::Tests::StringToLogLevel()
{
    ASSERT_EQUAL(LogLevel::None, utility::StringToLogLevel(utility::LogLevelNoneName));
    ASSERT_EQUAL(LogLevel::Trace, utility::StringToLogLevel(utility::LogLevelTraceName));
    ASSERT_EQUAL(LogLevel::Debug, utility::StringToLogLevel(utility::LogLevelDebugName));
    ASSERT_EQUAL(LogLevel::Info, utility::StringToLogLevel(utility::LogLevelInfoName));
    ASSERT_EQUAL(LogLevel::Warning, utility::StringToLogLevel(utility::LogLevelWarningName));
    ASSERT_EQUAL(LogLevel::Error, utility::StringToLogLevel(utility::LogLevelErrorName));
    ASSERT_EQUAL(LogLevel::Critical, utility::StringToLogLevel(utility::LogLevelCriticalName));
    ASSERT_EQUAL(LogLevel::Fatal, utility::StringToLogLevel(utility::LogLevelFatalName));
    ASSERT_EQUAL(LogLevel::Wtf, utility::StringToLogLevel(utility::LogLevelWtfName));
    ASSERT_EQUAL(LogLevel::All, utility::StringToLogLevel(utility::LogLevelAllName));
}

void
LoggerTest::Tests::AddLoggerEngine01()
{
    constexpr auto engine_name = "test01";
    Logger logger;

    logger.AddLoggerEngine(engine_name, new LoggerTest::MockLoggerEngine());

    ASSERT_EQUALM("No logger engine after adding!", true, logger.IsLoggerEngine(engine_name));
}

void
LoggerTest::Tests::AddLoggerEngine02()
{
    constexpr auto engine_name01 = "test01";
    constexpr auto engine_name02 = "test02";
    auto engine(std::make_unique<LoggerTest::MockLoggerEngine>());
    Logger logger;

    logger.AddLoggerEngine(engine_name01, engine);

    ASSERT_EQUALM("No logger engine after adding (01)!", true, logger.IsLoggerEngine(engine_name01));

    logger.AddLoggerEngine(engine_name02, std::make_unique<LoggerTest::MockLoggerEngine>());

    ASSERT_EQUALM("No logger engine after adding (02)!", true, logger.IsLoggerEngine(engine_name02));
}

void
LoggerTest::Tests::RemoveLoggerEngine()
{
    constexpr auto engine_name = "test01";
    Logger logger;

    logger.AddLoggerEngine(engine_name, new LoggerTest::MockLoggerEngine());

    ASSERT_EQUALM("No logger engine!", true, logger.IsLoggerEngine(engine_name));

    logger.RemoveLoggerEngine(engine_name);

    ASSERT_EQUALM("Logger engine present after removal!", false, logger.IsLoggerEngine(engine_name));
}

void
LoggerTest::Tests::RemoveAllLoggerEngines()
{
    Logger logger;

    logger.AddLoggerEngine("test01", new LoggerTest::MockLoggerEngine());
    logger.AddLoggerEngine("test02", new LoggerTest::MockLoggerEngine());

    ASSERT_GREATERM("No logging engines!", logger.GetTotalLoggerEngines(), 0);

    logger.RemoveAllLoggerEngines();

    ASSERT_EQUALM("Logging engines present after removal!", 0, logger.GetTotalLoggerEngines());
}

void
LoggerTest::Tests::Log()
{
    constexpr int n = 10;
    std::vector<std::string> log_strings(n);
    Logger logger;

    for(int i = 0 ; i < n ; ++i)
    {
        logger.AddLoggerEngine("test" + std::to_string(i), new LoggerTest::MockLoggerEngine(&log_strings[i]));
    }

    logger.Warning("MockLoggerEngine");

    for(int i = 0 ; i < n ; ++i)
    {
        std::cout << i << " ";
        ASSERT_EQUAL("[warning] MockLoggerEngine\n", log_strings[i]);
    }
    std::cout << std::endl;
}

void
LoggerTest::Tests::LogStream()
{
    std::string log_string = "";
    Logger logger;

    logger.AddLoggerEngine("test", new LoggerTest::MockLoggerEngine(&log_string));

    logger.Warning() << "Mock" << "Logger" << 2015 << "Engine";
    logger.Warning() << 2.5 << "Testing!";
    ASSERT_EQUAL("[warning] MockLogger2015Engine\n[warning] 2.5Testing!\n", log_string);
}

void
LoggerTest::Tests::LogVariadic()
{
    Logger logger;
    std::string log_string = "";

    logger.AddLoggerEngine("test", new LoggerTest::MockLoggerEngine(&log_string));
    logger.Warning("Mock", "Logger", 2015, "Engine ", 2.5, "Testing!");

    ASSERT_EQUAL("[warning] MockLogger2015Engine 2.5Testing!\n", log_string);
}

void
LoggerTest::Tests::DisableLogging()
{
    const std::string engine_name = "test02";
    std::string log_string01 = "";
    std::string log_string02 = "";
    Logger logger;

    logger.AddLoggerEngine("test01", new LoggerTest::MockLoggerEngine(&log_string01));
    logger.AddLoggerEngine(engine_name, new LoggerTest::MockLoggerEngine(&log_string02));

    logger.DisableLoggerEngine(engine_name);
    logger.Warning("MockLoggerEngine");

    std::cout << "test01" << std::endl;
    ASSERT_EQUAL("[warning] MockLoggerEngine\n", log_string01);
    std::cout << engine_name << std::endl;
    ASSERT_EQUAL("", log_string02);
}

void
LoggerTest::Tests::DisableLogLevel()
{
    const std::string engine_name = "test02";
    std::string log_string01 = "";
    std::string log_string02 = "";
    Logger logger;

    logger.AddLoggerEngine("test01", new LoggerTest::MockLoggerEngine(&log_string01));
    logger.AddLoggerEngine(engine_name, new LoggerTest::MockLoggerEngine(&log_string02));

    logger.DisableLogLevels(engine_name, LogLevel::Warning);
    logger.Warning("MockLoggerEngine");

    std::cout << "test01" << std::endl;
    ASSERT_EQUAL("[warning] MockLoggerEngine\n", log_string01);
    std::cout << engine_name << std::endl;
    ASSERT_EQUAL("", log_string02);
}

void
LoggerTest::Tests::GetTotalEngines()
{
    constexpr int n = 10;
    Logger logger;

    logger.RemoveAllLoggerEngines();

    for(int i = 0 ; i < n ; ++i)
    {
        logger.AddLoggerEngine("test" + std::to_string(i), new LoggerTest::MockLoggerEngine());
    }

    ASSERT_EQUAL(n, logger.GetTotalLoggerEngines());
    ASSERT_EQUAL(n, logger.GetTotalEnabledLoggerEngines());

    logger.DisableLoggerEngine("test6");
    logger.DisableLoggerEngine("test9");

    ASSERT_EQUAL(n - 2, logger.GetTotalEnabledLoggerEngines());

    logger.RemoveAllLoggerEngines();
}

} // namespace test
} // namespace wt


text:
package com.mossle.internal.sendmail.persistence.manager;

import com.mossle.core.hibernate.HibernateEntityDao;

import com.mossle.internal.sendmail.persistence.domain.SendmailTemplate;

import org.springframework.stereotype.Service;

@Service
public class SendmailTemplateManager extends
        HibernateEntityDao<SendmailTemplate> {
}


text:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Mere.Files.Attributes
{
    public class MereDelimitedFileTableAttribute : MereFileTableAttribute
    {
        public MereDelimitedFileTableAttribute(string delimiter = ",", string lineDelimiter = "\r\n", string recKey = null)
            : base(delimiter, lineDelimiter, recKey) { }
    }
}


text:
{% extends "admin_arkisto/base.html" %}
{% load crispy_forms_tags %}

{% block title %}{{ block.super }} - Videot - Muokkaa{% endblock %}

{% block head %}
{{ block.super }}
{% endblock %}

{% block crumbs %}
{{ block.super }}

Videot

Muokkaa

{% endblock %}

{% block jquery %}
{{ block.super }}
{% endblock %}

{% block content %}
{{ block.super }}

Muokkaa videota {{ vid.name }}

{% crispy vidform vidform.helper %}
{% endblock %}


text:
package net.categoricaldata.category.functor.withSmallSource
import net.categoricaldata.category._

trait withLocallyFinitelyGeneratedTarget extends functor.withSmallSource.withSmallTarget with Functor.withLocallyFinitelyGeneratedTarget


text:
#include "config/stm32plus.h"

#if defined(STM32PLUS_F1)

#include "config/exti.h"

using namespace stm32plus;

// static initialiser for the hack that forces the IRQ handlers to be linked

template<> ExtiPeripheral<EXTI_Line0> *ExtiPeripheral<EXTI_Line0>::_extiInstance=nullptr;

#if defined(USE_EXTI0_INTERRUPT)

extern "C" {

  void __attribute__ ((interrupt("IRQ"))) EXTI0_IRQHandler(void) {

    if(EXTI_GetITStatus(EXTI_Line0)!=RESET) {
        Exti0::_extiInstance->ExtiInterruptEventSender.raiseEvent(0);
        EXTI_ClearITPendingBit(EXTI_Line0);
    }
    __DSB();      // prevent erroneous recall of this handler due to delayed memory write
  }
}

#endif
#endif


text:
import {
    Component,
    ChangeDetectorRef,
    ChangeDetectionStrategy
} from '@angular/core';
import {CORE_DIRECTIVES} from '@angular/common';
import {Todo} from './todo.model';
import {CompletedFilterPipe} from './completed-filter.pipe';

@Component({
    selector: 'as-todolist',
    templateUrl: 'app/todolist/todolist.html',
    directives: [CORE_DIRECTIVES],
    pipes: [CompletedFilterPipe],
    changeDetection: ChangeDetectionStrategy.OnPush
})
export class TodolistComponent {
    public todo: Todo;
    private list: Todo[];
    private showCompleted: Boolean;

    constructor(private _ref: ChangeDetectorRef) {
        this.showCompleted = true;
        this.todo = new Todo('Add me to list!', false);
        this.list = [
            new Todo('Its cool'),
            new Todo('Hello', true)
        ];
    }

    addTodo() {
        this.list = this.list.concat(Todo.clone(this.todo));
        this.todo.clear();
        this._ref.markForCheck();
    }

    delTodo(index: number) {
        this.list = [].concat(
            this.list.slice(0, index),
            this.list.slice(index + 1, this.list.length)
        );
        this._ref.markForCheck();
    }
}


text:
@class CALayer, DVTTabbedWindowTabViewItem, NSColor, ViewActionForwardingLayerDelegate;

@interface DVTScrollableTabBarViewButton : NSButton
{
    ViewActionForwardingLayerDelegate *_layerDelegate;
    NSColor *_backgroundColor;
    CALayer *_backgroundLayer;
    CALayer *_centerLayer;
    CALayer *_leftBorderLayer;
    CALayer *_rightBorderLayer;
    CALayer *_topBorderLayer;
    CALayer *_bottomBorderLayer;
    BOOL _active;
    BOOL _showsLeftSeparator;
    BOOL _showsRightSeparator;
    BOOL _hasMouseOverHighlight;
    BOOL _mouseOverHighlightShouldIncludeRightBorderFrameWidth;
    BOOL _forceRepaintWithActiveWindowAppearance;
    DVTTabbedWindowTabViewItem *_tabViewItem;
}

+ (double)contentBoundsWidthForButtonWidth:(double)arg1;
+ (Class)cellClass;
@property(nonatomic) BOOL forceRepaintWithActiveWindowAppearance; // @synthesize forceRepaintWithActiveWindowAppearance=_forceRepaintWithActiveWindowAppearance;
@property(retain, nonatomic) DVTTabbedWindowTabViewItem *tabViewItem; // @synthesize tabViewItem=_tabViewItem;
@property(nonatomic) BOOL mouseOverHighlightShouldIncludeRightBorderFrameWidth; // @synthesize mouseOverHighlightShouldIncludeRightBorderFrameWidth=_mouseOverHighlightShouldIncludeRightBorderFrameWidth;
@property(nonatomic) BOOL hasMouseOverHighlight; // @synthesize hasMouseOverHighlight=_hasMouseOverHighlight;
@property(nonatomic) BOOL showsRightSeparator; // @synthesize showsRightSeparator=_showsRightSeparator;
@property(nonatomic) BOOL showsLeftSeparator; // @synthesize showsLeftSeparator=_showsLeftSeparator;
@property(nonatomic, getter=isActive) BOOL active; // @synthesize active=_active;
- (void)_setBackgroundColor:(id)arg1 withAnimation:(id)arg2;
- (BOOL)_isAnimatingBackgroundColor;
- (void)setHasMouseOverHighlight:(BOOL)arg1 animated:(BOOL)arg2;
- (void)_updateBackgroundLayerImagesForActiveTab:(BOOL)arg1 inActiveWindow:(BOOL)arg2;
- (void)layout;
- (void)updateLayer;
- (BOOL)wantsUpdateLayer;
- (void)_windowChangedKeyState;
- (double)rightCapWidth;
- (double)leftCapWidth;
- (struct CGRect)contentBounds;
- (void)_setUpBackgroundLayer;
- (id)initWithFrame:(struct CGRect)arg1;

@end


text:
{-# LANGUAGE NoImplicitPrelude #-}

module GHC.IO.Handle.Lock.NoOp where

import GHC.Base
import GHC.IO (throwIO)
import GHC.IO.Handle.Lock.Common
import GHC.IO.Handle.Types (Handle)

-- | No-op implementation.
lockImpl :: Handle -> String -> LockMode -> Bool -> IO Bool
lockImpl _ _ _ _ = throwIO FileLockingNotSupported

-- | No-op implementation.
unlockImpl :: Handle -> IO ()
unlockImpl _ = throwIO FileLockingNotSupported


text:
const commonRun = require('./commonRun')

commonRun('Worker/App', 'worker', '172.18.0.5:3003')