public void EgalPlusValeurCTest_DoitReussir()
{
int[] TabRef = { 1, 0, 0, 0, 0, 1, 0, 0, 0 };
int[,] GrilleTest =
{
{ 1, 2, 3, 4, 5, 6, 7, 8, 0 },
{ 4, 5, 6, 0, 8, 0, 5, 4, 1 },
{ 7, 8, 0, 4, 0, 0, 6, 3, 2 },
{ 4, 9, 0, 6, 2, 1, 0, 0, 3 },
{ 5, 2, 7, 0, 0, 0, 1, 6, 4 },
{ 6, 0, 0, 5, 7, 4, 0, 9, 5 },
{ 7, 4, 5, 0, 0, 9, 7, 0, 6 },
{ 8, 3, 2, 0, 5, 0, 8, 4, 7 },
{ 0, 6, 1, 6, 5, 4, 3, 2, 1 }
}; // A noter que la grille n'est pas une réelle grille de sudoku mais peut être utilisée pour un test unitaire.
Sudoku.Sudoku GrilleDeSudoku = new Sudoku.Sudoku(GrilleTest);
Sudoku.Cellule Case = new Sudoku.Cellule(0, 0, 0);
for (int i = 1; i < Case.PropValPossibles.Length; i++)
{
Case.PropValPossibles[i] = 0;
}
Case.PropValPossibles[0] = 1;
Case.PropValPossibles[5] = 1;
Case.PropValPossibles[6] = 1; // Toutes les valeurs du champs de de la case sont nulles sauf 3, dont deux qui correspond à celles non nulles dans le tableau de reférence.
Assert.IsTrue(GrilleDeSudoku.EgalPlusValeurC(Case, TabRef)); // Donc le test réussi, il n'y a qu'une seule valeur C en plus de A et B.
}
private Cellule[][] GetAutresCelluleDeRegion(int indiceRegion, int posX, int posY)
{
Cellule[][] mesCellules = new Cellule[9][];
int posXMini, posXMaxi, posYMini, posYMaxi;
posXMini = (indiceRegion % 3) * 3;
posXMaxi = posXMini + 2;
posYMini = (int)(Math.Floor(indiceRegion / 3.0)) * 3;
posYMaxi = posYMini + 2;
//int xCompteur = 0;
for (int ligne = posXMini; ligne <= posXMaxi; ligne++)
{
mesCellules[ligne] = new Cellule[9];
//int yCompteur = 0;
for (int colonne = posYMini; colonne <= posYMaxi; colonne++)
{
if (ligne != posX || colonne != posY)
{
mesCellules[ligne][colonne] = TabCellules[ligne][colonne];
}
}
//xCompteur++;
}
return(mesCellules);
}
public Sudoku()
{
TabCellules = new Cellule[9][];
TabCellules[0] = new Cellule[] { new Cellule(), new Cellule(), new Cellule(6), new Cellule(2), new Cellule(), new Cellule(), new Cellule(), new Cellule(8), new Cellule() };
TabCellules[1] = new Cellule[] { new Cellule(), new Cellule(), new Cellule(8), new Cellule(9), new Cellule(7), new Cellule(), new Cellule(), new Cellule(), new Cellule() };
TabCellules[2] = new Cellule[] { new Cellule(), new Cellule(), new Cellule(4), new Cellule(8), new Cellule(1), new Cellule(), new Cellule(5), new Cellule(), new Cellule() };
TabCellules[3] = new Cellule[] { new Cellule(), new Cellule(), new Cellule(), new Cellule(), new Cellule(6), new Cellule(), new Cellule(), new Cellule(), new Cellule(2) };
TabCellules[4] = new Cellule[] { new Cellule(), new Cellule(7), new Cellule(), new Cellule(), new Cellule(), new Cellule(), new Cellule(), new Cellule(3), new Cellule() };
TabCellules[5] = new Cellule[] { new Cellule(6), new Cellule(), new Cellule(), new Cellule(), new Cellule(5), new Cellule(), new Cellule(), new Cellule(), new Cellule() };
TabCellules[6] = new Cellule[] { new Cellule(), new Cellule(), new Cellule(2), new Cellule(), new Cellule(4), new Cellule(7), new Cellule(1), new Cellule(), new Cellule() };
TabCellules[7] = new Cellule[] { new Cellule(), new Cellule(), new Cellule(3), new Cellule(), new Cellule(2), new Cellule(8), new Cellule(4), new Cellule(), new Cellule() };
TabCellules[8] = new Cellule[] { new Cellule(), new Cellule(5), new Cellule(), new Cellule(), new Cellule(), new Cellule(1), new Cellule(2), new Cellule(), new Cellule() };
/* for (int x = 0; x <= 8; x++)
* {
* TabCellules[x] = new Cellule[9];
* for (int y = 0; y <= 8; y++)
* {
* TabCellules[x][y] = new Cellule
* {
* EstTrouve = false,
* EstValeurInitiale = false,
* Valeur = x * 10 + (y + 1)
* };
*
* }
* }*/
}
public void RestaurerGrille()
{
for (int ligne = 0; ligne < TabCellules.Length; ligne++)
{
for (int colonne = 0; colonne < TabCellules[ligne].Length; colonne++)
{
if (TabCellules[ligne][colonne].EstValeurInitiale == false)
{
TabCellules[ligne][colonne] = new Cellule(0);
}
}
}
}
public void Egal_DoitEchouer()
{
Sudoku.Cellule Case1 = new Sudoku.Cellule(0, 0, 0);
Sudoku.Cellule Case2 = new Sudoku.Cellule(0, 0, 1); // On crée deux cellules.
for (int i = 0; i < Case1.PropValPossibles.Length; i++) // On initialise les champs avec des 0.
{
Case1.PropValPossibles[i] = 0;
Case2.PropValPossibles[i] = 0;
}
Case1.PropValPossibles[0] = 1;
Case1.PropValPossibles[2] = 0; // Champs des possibles de Case1 : {1,0,0,0,0,0,0,0,0}
Case2.PropValPossibles[0] = 1;
Case2.PropValPossibles[2] = 1; // Champs des possibles de Case1 : {1,0,1,0,0,0,0,0,0}
Assert.IsTrue(Case1.Egal(Case2)); // Les cases ont un champs des possibles différent, le test est un échec.
}
public void Egal_DoitReussir()
{
Sudoku.Cellule Case1 = new Sudoku.Cellule(0, 0, 0);
Sudoku.Cellule Case2 = new Sudoku.Cellule(0, 0, 1); // On crée deux cellules.
for (int i = 0; i < Case1.PropValPossibles.Length; i++) // On initialise les champs avec des 0.
{
Case1.PropValPossibles[i] = 0;
Case2.PropValPossibles[i] = 0;
}
Case1.PropValPossibles[0] = 1;
Case1.PropValPossibles[2] = 1; // Champs des possibles de Case1 : {1,0,1,0,0,0,0,0,0}
Case2.PropValPossibles[0] = 1;
Case2.PropValPossibles[2] = 1; // Champs des possibles de Case2 : {1,0,1,0,0,0,0,0,0}
Assert.IsTrue(Case1.Egal(Case2)); // Les cases ont le même champs de possibles, le test est réussi.
}
public bool Egal(Cellule c) // On compare le champs des possibles de deux cellules, elle retourne true si il y a deux valeur A et B au même endroit dans le champs des possibles des deux cellules.
{
bool egal = false;
bool CaseDifferentes = false;
int compteur = 0;
for (int i = 0; i < ValPossibles.Length; i++)
{
if (c.PropValPossibles[i] == ValPossibles[i] && c.PropValPossibles[i] != 0) // Si les deux valeurs des champs sont égales et différentes de 0.
{
compteur++;
}
if (c.PropValPossibles[i] != ValPossibles[i]) // Si il y une valeur différente alors le champs des possibles est forcément différent.
{
CaseDifferentes = true;
}
if (compteur == 2 && i == ValPossibles.Length - 1 && !CaseDifferentes) // S'il y a deux valeurs possibles et que l'on a fini le parcours alors leurs champs sont considérés égaux.
{
egal = true;
}
}
return(egal);
}
} // Si il y a une cellule dont le champs des possibles contient A et B + une valeur C dans la même région, la méthode retourne un tableau dont la première valeur est l'index (ligne) de la case, la deuxième valeur l'index (colonne) de la case et la troisième la valeur C à changer.
public bool EgalPlusValeurC(Cellule a, int[] tabref) // On compare le champs de possible d'une cellule avec un champs de possibles de référence contentant deux valeurs A et B, en espérant trouver une valeur C.
{
bool egal = false;
int compteur = 0;
int compteur2 = 0;
for (int i = 0; i < tabref.Length; i++)
{
if (a.PropValPossibles[i] == tabref[i] && tabref[i] != 0)
{
compteur++;
}
if (a.PropValPossibles[i] != tabref[i] && tabref[i] == 0)
{
compteur2++;
}
if (compteur == 2 && i == tabref.Length - 1 && compteur2 == 1)
{
egal = true;
}
}
return(egal);
}
public void EgalPlusValeurCTest_DoitEchouer()
{
int[] TabRef = { 1, 0, 0, 0, 0, 1, 0, 0, 0 };
int[,] GrilleTest =
{
{ 1, 2, 3, 4, 5, 6, 7, 8, 0 },
{ 4, 5, 6, 0, 8, 0, 5, 4, 1 },
{ 7, 8, 0, 4, 0, 0, 6, 3, 2 },
{ 4, 9, 0, 6, 2, 1, 0, 0, 3 },
{ 5, 2, 7, 0, 0, 0, 1, 6, 4 },
{ 6, 0, 0, 5, 7, 4, 0, 9, 5 },
{ 7, 4, 5, 0, 0, 9, 7, 0, 6 },
{ 8, 3, 2, 0, 5, 0, 8, 4, 7 },
{ 0, 6, 1, 6, 5, 4, 3, 2, 1 }
}; // A noter que la grille n'est pas une réelle grille de sudoku mais peut être utilisée pour un test unitaire.
Sudoku.Sudoku GrilleDeSudoku = new Sudoku.Sudoku(GrilleTest);
Sudoku.Cellule Case = new Sudoku.Cellule(0, 0, 0);
for (int i = 0; i < Case.PropValPossibles.Length; i++)
{
Case.PropValPossibles[i] = 1;
}
// Toutes les valeurs du champs de de la case sont vallent 1.
Assert.IsTrue(GrilleDeSudoku.EgalPlusValeurC(Case, TabRef)); // Donc le champs contient A et B mais aussi pleins d'autres valeurs, le test échoue.
}
