[TestFixture]
    public class TestProgram
    {
        [Test]
        public void TestDescription()
        {
            Assert.That(Program.Description.Length, Is.GreaterThan(0));
        }
    }

Assert.Greater(Program.Description.Length,0) ;

using Nunit.Framework;
using Nunit.Framework.Constraints;
using Nunit.Framework.SyntaxHelpers;

static public string Description
{
   get { return ""; }
}

get { return "Pentaminos"; }

{
           { 1, 1,2,3,4 },         // This array represents everything the program
	   { 1, 10,20,30,40 },     // knows about the individual pentominos.  Each
	   { 2, 9,10,11,20 },      // row in the array represents a particular
	   { 3, 1,10,19,20 },      // pentomino in a particular orientation.  Different
	   { 3, 10,11,12,22 },     // orientations are obtained by rotating or flipping
	   { 3, 1,11,21,22 },      // the pentomino over.  Note that the program must
	   { 3, 8,9,10,18 },       // try each pentomino in each possible orientation,
	   { 4, 10,20,21,22 },     // but must be careful not to reuse a piece if
	   { 4, 1,2,10,20 },       // it has already been used on the board in a
	   { 4, 10,18,19,20 },     // different orientation.
	   { 4, 1,2,12,22 },       //     The pentominoes are numbered from 1 to 12.
	   { 5, 1,2,11,21 },    // The first number on each row here tells which pentomino
	   { 5, 8,9,10,20 },       // that line represents.  Note that there can be
	   { 5, 10,19,20,21 },     // up to 8 different rows for each pentomino.
	   { 5, 10,11,12,20 },     // some pentominos have fewer rows because they are
	   { 6, 10,11,21,22 },     // symmetric.  For example, the pentomino that looks
	   { 6, 9,10,18,19 },      // like:
	   { 6, 1,11,12,22 },      //           GGG
	   { 6, 1,9,10,19 },       //           G G
	   { 7, 1,2,10,12 },       //
	   { 7, 1,11,20,21 },      // can be rotated into three additional positions,
	   { 7, 2,10,11,12 },      // but flipping it over will give nothing new.
	   { 7, 1,10,20,21 },      // So, it has only 4 rows in the array.
	   { 8, 10,11,12,13 },     //     The four remaining entries in the array
	   { 8, 10,20,29,30 },     // describe the given piece in the given orientation,
	   { 8, 1,2,3,13 },        // in a way convenient for placing the piece into
	   { 8, 1,10,20,30 },      // the one-dimensional array that represents the
	   { 8, 1,11,21,31 },      // board.  As an example, consider the row
	   { 8, 1,2,3,10 },        //
	   { 8, 10,20,30,31 },     //           { 7, 1,2,10,19 }
	   { 8, 7,8,9,10 },        //
	   { 9, 1,8,9,10 },        // If this piece is placed on the board so that
	   { 9, 10,11,21,31 },     // its topmost/leftmost square fills position
	   { 9, 1,2,9,10 },        // p in the array, then the other four squares
	   { 9, 10,20,21,31 },     // will be at positions  p+1, p+2, p+10, and p+19.
	   { 9, 1,11,12,13 },      // To see whether the piece can be played at that
	   { 9, 10,19,20,29 },     // position, it suffices to check whether any of
	   { 9, 1,2,12,13 },       // these five squares are filled. 
	   { 9, 9,10,19,29 },      
	   { 10, 8,9,10,11 },      
	   { 10, 9,10,20,30 },    
	   { 10, 1,2,3,11 },
	   { 10, 10,20,21,30 },
	   { 10, 1,2,3,12 },
	   { 10, 10,11,20,30 },
	   { 10, 9,10,11,12 },  
	   { 10, 10,19,20,30 },
	   { 11, 9,10,11,21 },
	   { 11, 1,9,10,20 },   
	   { 11, 10,11,12,21 },
	   { 11, 10,11,19,20 }, 
	   { 11, 8,9,10,19},
	   { 11, 1,11,12,21 },
	   { 11, 9,10,11,19 },
	   { 11, 9,10,20,21 },
	   { 12, 1,10,11,21 },
	   { 12, 1,2,10,11 },
	   { 12, 10,11,20,21 },
	   { 12, 1,9,10,11 },  
	   { 12, 1,10,11,12 }, 
	   { 12, 9,10,19,20 },
	   { 12, 1,2,11,12 },
	   { 12, 1,10,11,20 }   
        };
//         by:  David J. Eck
//              Deparment of Mathematics and Computer Science
//              Hobart and William Smith Colleges
//              Geneva, NY   14456
//              Email:  eck@hws.edu
//

Assert.That(ListeDePentaminos().Count, Is.EqualTo(63));

Assert.That(FabriqueDePentaminos.ListeDePentaminos().Count, Is.EqualTo(63));

    [TestFixture]
    public class TestListePentaminos
    {
        [Test]
        public void TestTotalPentaminos()
        {
            Assert.That(FabriqueDePentaminos.ListeDePentaminos().Count, Is.EqualTo(63));
        }
    }

    class Pentamino
    {
    }

    class FabriqueDePentaminos
    {
        static public List<Pentamino> ListeDePentaminos()
        {
            return new List<Pentamino>();
        }
    }

static public List<Pentamino> ListeDePentaminos()
{
	List<Pentamino> liste = new List<Pentamino>();
	for (int i = 0; i < 63; i++)
	{
		liste.Add(new Pentamino());
	}
	return liste;
}

public const int NombreDeVariantes = 63;

[Test]
public void TestPositionDuPentominoX()
{
   Pentamino x =  FabriqueDePentaminos.ListeDePentaminos()[2] ;

   Assert.That(x.Decalage[0], Is.EqualTo(9),
	"le premier décalage de X est incorrect");
   Assert.That(x.Decalage[1], Is.EqualTo(10), 
	"le deuxième décalage de X est incorrect");
   Assert.That(x.Decalage[2], Is.EqualTo(11), 
	"le troisième décalage de X est incorrect");
   Assert.That(x.Decalage[3], Is.EqualTo(20), 
	"le quatrième décalage de X est incorrect");
   Assert.That(x.Variante, Is.EqualTo(2), 
	"la Variante de X est incorrecte");
}

        public int[] Decalage = new int[4];
        public int Variante;

        static public int NombreDeVariantes
        {
            get { return DescriptionsInternes.GetUpperBound(0) + 1; }
        }

Assert.That(plateau.Ajoute(I));

    class Plateau
    {
        public Boolean Ajoute(Pentamino pentamino)
        {
            return false;
        }
    }

    [TestFixture]
    public class TestPlateau
    {
        [Test]
        public void TestAjoutPentamino()
        {
            Plateau plateau = new Plateau();
            Pentamino I = FabriqueDePentaminos.ListeDePentaminos()[0] ;
            Assert.That(plateau.Ajoute(I));
        }
    }

[Test]
public void TestAjoutPentaminoSansRepetition()
{
	Plateau plateau = new Plateau();
	Pentamino I = FabriqueDePentaminos.ListeDePentaminos()[0];
	plateau.Ajoute(I);
	Assert.That(plateau.Ajoute(I), Is.False);
}

private Boolean[] VariantesDejaAjoutees = new Boolean[12] ;

public Boolean Ajoute(Pentamino pentamino)
{
	if (VariantesDejaAjoutees[pentamino.Variante])
	{
		return false;
	}
	else
	{
		VariantesDejaAjoutees[pentamino.Variante] = true;
		return true;
	}
}

        private Plateau plateau;
        private Pentamino I;

        [SetUp]
        public void SetUp()
        {
            plateau = new Plateau();
            I = FabriqueDePentaminos.ListeDePentaminos()[0];
         }

       [Test]
       public void TestSolutionTrouveePlateauVide()
       {
            Assert.That(plateau.SolutionTrouvee, Is.False);
       }

       public Boolean SolutionTrouvee
       {
            get { return true; }
       }

       public Boolean SolutionTrouvee
        {
            get { return (TotalVariantesDejaAjoutees == FabriqueDePentaminos.NombreDePentaminos) ; }
        }

    Assert.That(plateau.VerifierPlaceLibre(I, 1), Is.True);

	plateau.Ajoute(I, 1);
	Assert.That(plateau.VerifierPlaceLibre(X, 1), Is.False);

private Boolean[] Cases = new Boolean[60];

private void Pose(Pentamino pentamino, int position)
{
	VariantesDejaAjoutees[pentamino.Variante] = true;
	TotalVariantesDejaAjoutees++;

	Cases[position] = true;
	foreach (int decalage in pentamino.Decalage)
	{
		Cases[position + decalage] = true;
	}
}

public Boolean VerifierPlaceLibre(Pentamino pentamino, int position)
{
	if (Cases[position])
	{
		return false;
	}
	else
	{
		Boolean toutes_libres = true;
		foreach (int decalage in pentamino.Decalage)
		{
			toutes_libres = Cases[position + decalage];
			if (!toutes_libres)
			{
				break;
			}
		}
		return toutes_libres;
	}
}

toutes_libres = !Cases[position + decalage];

        public int[] Decalage = new int[5];
        public int Variante;

        public Pentamino(int variante, int decalage1, int decalage2, int decalage3, int decalage4)
        {
            Variante = variante;
            Decalage[0] = decalage1;
            Decalage[1] = decalage2;
            Decalage[2] = decalage3;
            Decalage[3] = decalage4;
            Decalage[4] = 0;
        }

public Boolean VerifierPlaceLibre(Pentamino pentamino, int position)
{
	Boolean toutes_libres = true;
	foreach (int decalage in pentamino.Decalage)
	{
		toutes_libres = !Cases[position + decalage];
		if (!toutes_libres)
		{
			break;
		}
	}
	return toutes_libres;
}

public Boolean VerifierPlaceLibre(Pentamino pentamino, int position)
{
	foreach (int decalage in pentamino.Decalage)
	{
		if (Cases[position + decalage])
		{
			return false;
		}
	}
	return true;
}

	Assert.That(plateau.VerifierPlaceLibre(I, 9), Is.False);

public Plateau()
{
	int position = 0;
	for (int index_ligne = 1; index_ligne <= 6; index_ligne++)
	{
		Cases[position++] = true;
		for (int index_colonne = 1; index_colonne <= 10; index_colonne++)
		{
			Cases[position++] = false;
		}
		Cases[position++] = true;
	}
	for (int index_colonne = 0; index_colonne <= 11; index_colonne++)
	{
		Cases[position++] = true;
	}
}

public