update README

README.MD

@@ -1,3 +1,12 @@
+# Notes au correcteur : 
+Ce dépot contient le projet Java avec des tests unitaires et tests Cucumber. 
+Nous avons chacun mis au point notre propre méthode de résolution du problème. Les deux méthodes sont exécutées à la suite et sont distinctivement nommées. 
+
+Afin de comparer les performances de nos méthodes, nous avons créé une classe supplémentaire "Etude.java" faisant des tests de plus en plus lourds à nos méthodes pour comparer les temps d'exécution sur différentes tailles d'echiquiers. N'étant pas un ajout initialement prévu, la classe n'est pas proprement intégrée au projet ni testée. Il vous faudra apporter de légères modifications au code en suivant les indications des commentaires si vous voulez l'essayer par vous même.
+
+
+
+
 # Problème des Huit Dames
 
 ## Préambule

pom.xml

@@ -51,6 +51,11 @@
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-surefire-plugin</artifactId>
                 <version>${maven-surefire-plugin.version}</version>
+                <configuration>
+                    <includes>
+                        <include>**/*Test.java</include>
+                    </includes>
+                </configuration>
             </plugin>
         </plugins>
     </build>

src/main/java/fr/iut_fbleau/but3/dev6_2/Chessboard.java

@@ -5,13 +5,25 @@ import java.util.List;
 
 public class Chessboard {
     public static final int SIZE = 8;
-    private final int[][] gameBoard = new int[SIZE][SIZE];
+    public static int currentSize;
+    private final int[][] gameBoard;
     private final List<Position> queensPosition = new ArrayList<>();
     private static final String ANSI_RED = "\u001B[31m";
     private static final String ANSI_RESET = "\u001B[0m";
 
     public Chessboard() {
-        // Constructeur vide
+        this.gameBoard = new int[SIZE][SIZE];
+        currentSize = SIZE;
+    }
+
+    public Chessboard(int size) {
+        this.gameBoard = new int[size][size];
+        currentSize = size;
+    }
+
+    public Position[] getQueensPositions(){
+        Position[] a = new Position[queensPosition.size()];
+        return queensPosition.toArray(a);
     }
 
     public int getTile(int x,int y){
@@ -31,7 +43,7 @@ public class Chessboard {
     }
 
     public Boolean VerifAccessible(int x, int y) {
-        for (int i = 0; i < SIZE; i++) {
+        for (int i = 0; i < currentSize; i++) {
             int diagonaleAscendante = y - (x - i);
             int diagonaleDescendante = y + (x - i);
             if (gameBoard[i][y] != 0) {
@@ -40,10 +52,10 @@ public class Chessboard {
             if (gameBoard[x][i] != 0) {
                 return false;
             }
-            if (diagonaleAscendante >= 0 && diagonaleAscendante < SIZE && gameBoard[i][diagonaleAscendante] == 1) {
+            if (diagonaleAscendante >= 0 && diagonaleAscendante < currentSize && gameBoard[i][diagonaleAscendante] == 1) {
                 return false;
             }
-            if (diagonaleDescendante >= 0 && diagonaleDescendante < SIZE && gameBoard[i][diagonaleDescendante] == 1) {
+            if (diagonaleDescendante >= 0 && diagonaleDescendante < currentSize && gameBoard[i][diagonaleDescendante] == 1) {
                 return false;
             }
         }
@@ -54,8 +66,8 @@ public class Chessboard {
         return queensPosition.size();
     }
     public void printChessboard() {
-        for (int i = 0; i < SIZE; i++) {
-            for (int j = 0; j < SIZE; j++) {
+        for (int i = 0; i < currentSize; i++) {
+            for (int j = 0; j < currentSize; j++) {
                 if (gameBoard[j][i] == 1) {
                     System.out.print(ANSI_RED+"|♕|"+ANSI_RESET);
                 } else{

src/main/java/fr/iut_fbleau/but3/dev6_2/EightQueensSolver.java

@@ -3,44 +3,67 @@ package fr.iut_fbleau.but3.dev6_2;
 public class EightQueensSolver {
     public Chessboard chessboard = new Chessboard();
 
+    public Chessboard chessboard(){
+        return chessboard;
+    }
+
     public EightQueensSolver() {
         
+    }
+    public void setChessboard(Chessboard theChessboard) {
+        this.chessboard = theChessboard;
     }
 
     
 
      public static void main(String[] args){
         EightQueensSolver solver = new EightQueensSolver();
+        System.out.println("Taille de l'echiquier : " + Chessboard.currentSize);  
         
-        long startTimeSimSim = System.currentTimeMillis();
-        System.out.println("Début SimSim");
-        System.out.println(solver.SolverSim(0));
-        System.out.println("Fin SimSim");
-        long endTimeSimSim = System.currentTimeMillis();
-        System.out.println("Temps d'exécution SimSim: " + (endTimeSimSim - startTimeSimSim) + " ms");
-        solver.chessboard.printChessboard();
-
-
+        //Chronometrage de la méthode à Victor
+        long time = 0;
+        for (int i = 0; i < 10; i++) {
             solver.chessboard = new Chessboard();
+            long startTime = System.currentTimeMillis();
+            solver.SolverVic(0); 
+            long endTime = System.currentTimeMillis();
             
+            time += endTime - startTime;
+        }
+        time /= 10;
 
-        long startTimeVictor = System.currentTimeMillis();
-        System.out.println("Début Victor");
-        System.out.println(solver.SolverVic(0));
-        System.out.println("Fin Victor");
-        long endTimeVictor = System.currentTimeMillis();
-        System.out.println("Temps d'exécution Victor: " + (endTimeVictor - startTimeVictor) + " ms");
+        System.out.println("Temps moyen d'exécution Victor: " + (time) + " ms");
         solver.chessboard.printChessboard();
         
+        // Chronometrage de la méthode à Simon
+        time = 0;
+        System.out.println("Début SimSim");
+        for (int i = 0; i < 10; i++) {
+            solver.chessboard = new Chessboard();
+            long startTime = System.currentTimeMillis();
+            solver.SolverSim(0); 
+            long endTime = System.currentTimeMillis();
+            
+            time += endTime - startTime;
+        }
+        time /= 10;
+        System.out.println("Fin SimSim");
+        System.out.println("Temps moyen d'exécution SimSim: " + (time) + " ms");
+        solver.chessboard.printChessboard();
+
+
+        //Spoiler : c'est simsim qu'a la meilleure méthode :)
     }
     
+
+    // Méthode de résolution de victor
     public Boolean SolverVic(int level) {
-        if (chessboard.getNumberOfQueen() == Chessboard.SIZE) {
+        if (chessboard.getNumberOfQueen() == Chessboard.currentSize) {
             return true;
         }
-        for (int i = level*Chessboard.SIZE; i < Chessboard.SIZE * Chessboard.SIZE; i++) {
-            int x = i % Chessboard.SIZE;
-            int y = i / Chessboard.SIZE;
+        for (int i = level*Chessboard.currentSize; i < Chessboard.currentSize * Chessboard.currentSize; i++) {
+            int x = i % Chessboard.currentSize;
+            int y = i / Chessboard.currentSize;
             if (chessboard.VerifAccessible(x, y)) {
                 chessboard.placeQueen(x, y);
                 if (!SolverVic(y)) {
@@ -53,18 +76,19 @@ public class EightQueensSolver {
         return false;
     }
 
-    public boolean SolverSim(int line){
-        if(chessboard.getNumberOfQueen() == Chessboard.SIZE){
+    // Méthode de résolution de Simon
+    public boolean SolverSim(int yPos){
+        if(chessboard.getNumberOfQueen() == Chessboard.currentSize){
             return true;
         }
-        for(int collumn = 0 ; collumn < Chessboard.SIZE ; collumn++){
-            if(chessboard.VerifAccessible(collumn, line)){
-                chessboard.placeQueen(collumn, line);
-                if(SolverSim(line+1)){
+        for(int xPos = 0 ; xPos < Chessboard.currentSize ; xPos++){
+            if(chessboard.VerifAccessible(xPos, yPos)){
+                chessboard.placeQueen(xPos, yPos);
+                if(SolverSim(yPos+1)){
                     return true;
                 }
                 else{
-                    chessboard.removeQueen(collumn, line);
+                    chessboard.removeQueen(xPos, yPos);
                 }
             }
         }

src/main/java/fr/iut_fbleau/but3/dev6_2/Etude.java

@@ -0,0 +1,63 @@
+package fr.iut_fbleau.but3.dev6_2;
+
+public class Etude {
+    public static final int MAX_TIME = 1000;
+
+    private Chessboard chessboard;
+    private int currentSize;
+    private EightQueensSolver solver;
+    public Etude() {
+        this.currentSize = 5;
+        this.solver = new EightQueensSolver();
+
+    }
+
+    private void resetChessboard(){
+        this.chessboard = new Chessboard(currentSize);
+        this.solver.setChessboard(this.chessboard);
+    }
+
+    /**
+     * Etude de performance des différents solveurs sur des tailles croissantes de chessboards. 
+     * Chaque taille est testée 10 fois et la moyenne du temps passé dessus par chaque solveur est indiquée en ms.
+     * La boucle de l'étude s'arrête lorsque le temps de résolution moyen dépasse les 1000ms. 
+     *
+     *  Un seul solveur est testé à la fois. Il suffit de commenter et décommenter une ligne au milieu de la méthode main pour qu'un autre solveur soit testé. 
+     *  Il vous reviens de noter les résultats de chaque solveur, aucune comparaison n'est faite dans ce code. 
+     *
+     * Les chessboards de taille impaire sont bien plus rapides à résoudre que ceux de taille paire.
+     * Pour faire l'étude uniquement sur des tailles paires, une ligne est à décommenter à la fin de la méthode main.
+     */
+    public static void _main(String[] args){
+        Etude etude = new Etude();
+
+        int passedTime = 0;
+        while(passedTime < MAX_TIME){
+            passedTime = 0;
+            
+            System.out.println("Taille de l'echiquier : " + etude.currentSize);
+            System.out.println("Début solveur");
+            
+            for (int i = 0; i < 10; i++) {
+                long startTimeSimSim = System.currentTimeMillis();
+                etude.resetChessboard();
+                etude.solver.SolverSim(0);
+                //etude.solver.Solver(0);   // décommenter cette ligne et commenter celle du dessus pour étudier l'autre solveur
+                long endTimeSimSim = System.currentTimeMillis();
+
+                passedTime += endTimeSimSim - startTimeSimSim;
+            }
+            passedTime /= 10;
+            
+            System.out.println("Fin solveur");
+            System.out.println("Temps d'exécution moyen solveur: " + (passedTime) + " ms");
+            
+            etude.chessboard.printChessboard(); 
+            
+
+            etude.currentSize ++;
+            // etude.currentSize ++;   // décommenter cette ligne pour que seules les tailles de chessboard impaires soient testées
+        }
+    }
+
+}

src/test/java/fr/iut_fbleau/but3/dev6_2/ChessboardTest.java

@@ -41,8 +41,8 @@ class ChessboardTest {
         assertEquals(3, this.chessboard.getNumberOfQueen());
         int cpt=0;
         //double test to assure getNumberOfQueen works
-        for(int i = 0; i< Chessboard.SIZE ;i++){
-            for(int j = 0; j< Chessboard.SIZE ;j++){
+        for(int i = 0; i< Chessboard.currentSize ;i++){
+            for(int j = 0; j< Chessboard.currentSize ;j++){
                 if(this.chessboard.getTile(i, j) == 1){
                     cpt += 1;
 ;               }
@@ -86,8 +86,8 @@ class ChessboardTest {
         return x >= 0 && x < Chessboard.SIZE && y >= 0 && y < Chessboard.SIZE;
     }
     
-    
-    void testWinningSolution(Chessboard chessboard) {
+    // méthode appelée par d'autres tests
+    private void testWinningSolution(Chessboard chessboard) {
         assertEquals(Chessboard.SIZE, chessboard.getNumberOfQueen(),"Devrait etre egal a "+Chessboard.SIZE);
         for(int i = 0; i< Chessboard.SIZE ;i++){
             for(int j = 0; j< Chessboard.SIZE ;j++){

src/test/java/fr/iut_fbleau/but3/dev6_2/steps/EightQueensSolverSteps.java

@@ -1,27 +1,142 @@
 package fr.iut_fbleau.but3.dev6_2.steps;
 
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import fr.iut_fbleau.but3.dev6_2.Chessboard;
 import fr.iut_fbleau.but3.dev6_2.EightQueensSolver;
+import fr.iut_fbleau.but3.dev6_2.Position;
 import io.cucumber.java.en.Given;
 import io.cucumber.java.en.Then;
 import io.cucumber.java.en.When;
 
-import static org.junit.jupiter.api.Assertions.assertEquals;
-
 public class EightQueensSolverSteps {
-    private EightQueensSolver eightQueensSolver;
+    private EightQueensSolver solver;
 
-    @Given("un echiquier")
-    public void unEchiquier() {
-        this.eightQueensSolver = new EightQueensSolver();
+    private Position lastRemovedQueen;
+
+    @Given("un echiquier vide")
+    public void unEchiquierVide() {
+        this.solver = new EightQueensSolver();
+        this.solver.setChessboard(new Chessboard());
+    }
+
+    @Given("un echiquier avec {int} reines valides")
+    public void unEchiquierAvecXReinesValides(int nbReines) {
+        
+        Position[] positions = {new Position(3, 0), new Position(1, 1), new Position(6, 2), new Position(2, 3), new Position(5, 4), new Position(7, 5), new Position(4, 6), new Position(0, 7)};
+
+        this.solver = new EightQueensSolver();
+        this.solver.setChessboard(new Chessboard());
+        nbReines = (nbReines > Chessboard.SIZE)
+                ? Chessboard.SIZE 
+                : nbReines;
+        for(int i=0 ; i<nbReines ; i++){
+            Position position = positions[i];
+            this.solver.getChessboard().placeQueen(position.x(), position.y());
+        }
     }
 
     @When("placer une reine en {int}, {int}")
-    public void placerUnReineEn(int x, int y) {
-        this.eightQueensSolver.getChessboard().placeQueen(x,y);
+    public void placerUneReineEn(int x, int y) {
+        this.solver.getChessboard().placeQueen(x, y);
     }
     
-    @Then("{int} reine sur l'échiquier")
+    @When("retirer une reine en {int}, {int}")
+    public void retirerUneReineEn(int x, int y) {
+        this.solver.getChessboard().removeQueen(x, y);
+        lastRemovedQueen = new Position(x, y);
+    }
+
+    @Then("{int} reine\\(s) sur l'échiquier")
     public void reineSurLEchiquier(int queensOnChessboard) {
-        assertEquals(1, this.eightQueensSolver.getChessboard().getNumberOfQueen());
+        assertEquals(queensOnChessboard, this.solver.getChessboard().getNumberOfQueen());
+    }
+
+    @Then("la colonne {int} est capturée")
+    public void colonneCapturee(int x){
+        for(int y=0; y<Chessboard.SIZE ; y++){
+            assertFalse(this.solver.getChessboard().VerifAccessible(x, y), "La case (" + x + ", " + y + ") est accessible mais ne devrait pas l'être.");
         }
     }
+
+    @Then("la ligne {int} est capturée")
+    public void ligneCapturee(int y){
+        for(int x=0; x<Chessboard.SIZE ; x++){
+            assertFalse(this.solver.getChessboard().VerifAccessible(x, y), "La case (" + x + ", " + y + ") est accessible mais ne devrait pas l'être.");
+        }
+    }
+
+    @Then("Then la diagonnale montante {int}, {int} est capturée")
+    public void diagonaleAscendanteCapturee(int startX, int startY){
+        int limit = Math.min(Chessboard.SIZE - startX, Chessboard.SIZE - startY);
+               for (int i = 0; i < limit; i++) {
+            int x = startX + i;
+            int y = startY + i;
+            assertFalse(this.solver.getChessboard().VerifAccessible(x, y), "La case (" + x + ", " + y + ") est accessible mais ne devrait pas l'être.");
+        }
+    }
+
+    @Then("Then la diagonnale descendante {int}, {int} est capturée")
+    public void diagonaleDescendanteCapturee(int startX, int startY){
+        int limit = Math.min(Chessboard.SIZE - startX, startY + 1);
+        for (int i = 0; i < limit; i++) {
+            int x = startX + i;
+            int y = startY - i;
+            assertFalse(this.solver.getChessboard().VerifAccessible(x, y), "La case (" + x + ", " + y + ") est accessible mais ne devrait pas l'être.");
+        }
+    }
+
+    @Then("la case {int}, {int} est libre")
+    public void caseReineRetireeEstLibre(int x, int y){
+            assertTrue(this.solver.getChessboard().VerifAccessible(x, y), "La case (" + x + ", " +y + ") est capturée mais ne devrait pas l'être.");
+    }
+
+    @When("le solveur Sim termine de résoudre le problème")
+    public void le_solveurSim_termine_de_résoudre_le_problème() {
+        this.solver.SolverSim(0);
+    }
+
+    @When("le solveur Vic termine de résoudre le problème")
+    public void le_solveurVic_termine_de_résoudre_le_problème() {
+        this.solver.SolverVic(0);
+    }
+
+    @Then("toutes les lignes doivent avoir une reine")
+    public void toutes_les_lignes_doivent_avoir_une_reine() {
+        for (int row = 0; row < Chessboard.SIZE; row++) {
+            int queenCount = 0;
+            for (int col = 0; col < Chessboard.SIZE; col++) {
+                if (solver.getChessboard().getTile(row, col) == 1) {
+                    queenCount++;
+                }
+            }
+            assertTrue(1 == queenCount, "La ligne " + row + " n'a pas exactement une reine");
+        }
+    }
+
+    @Then("toutes les colonnes doivent avoir une reine")
+    public void toutes_les_colonnes_doivent_avoir_une_reine() {
+        for (int col = 0; col < Chessboard.SIZE; col++) {
+            int queenCount = 0;
+            for (int row = 0; row < Chessboard.SIZE; row++) {
+                if (solver.getChessboard().getTile(row, col) == 1) {
+                    queenCount++;
+                }
+            }
+            assertTrue(1 == queenCount, "La colonne " + col + " n'a pas exactement une reine");
+        }
+    }
+
+    @Then("aucune reine ne doit être menacée par une autre")
+    public void aucune_reine_ne_doit_être_menacée_par_une_autre() {
+        for(Position pos : this.solver.getChessboard().getQueensPositions()){
+            this.solver.getChessboard().removeQueen(pos.x(), pos.y());
+            assertTrue(this.solver.getChessboard().VerifAccessible(pos.x(), pos.y()), "La case (" + pos.x() + ", " + pos.y() + ") est capturée mais ne devrait pas l'être.");
+            this.solver.getChessboard().placeQueen(pos.x(), pos.y());
+        }
+    }
+
+
+}

src/test/java/fr/iut_fbleau/but3/dev6_2/steps/EightQueensSolverStepsTest.java

@@ -1,24 +0,0 @@
-package fr.iut_fbleau.but3.dev6_2.steps;
-
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.Test;
-
-import fr.iut_fbleau.but3.dev6_2.Chessboard;
-
-class ChessboardTest {
-
-    private Chessboard chessboard;
-
-    @BeforeEach
-    public void beforeEach(){
-        this.chessboard = new Chessboard();
-    }
-
-    @Test
-    void placeAQueen(){
-        this.chessboard.placeQueen(0,0);
-        assertEquals(1, this.chessboard.getNumberOfQueen());
-    }
-
-}

src/test/resources/features/placeAQueen.feature

@@ -2,6 +2,7 @@ Feature: Placer une reine
   Placer une reine sur l'échiquier
 
   Scenario: Placer une reine en 0, 0
-    Given un echiquier
+    Given un echiquier vide
     When placer une reine en 0, 0
-    Then 1 reine sur l'échiquier
+    Then 1 reine(s) sur l'échiquier
+

src/test/resources/features/removeAQueen.feature

@@ -0,0 +1,8 @@
+Feature: Retirer une reine
+  Retirer une reine de l'échiquier
+
+  Scenario: Retirer une reine en 0, 0
+    Given un echiquier avec 5 reines valides
+    When retirer une reine en 2, 3
+    Then 4 reine(s) sur l'échiquier
+    And la case 2, 3 est libre

src/test/resources/features/solveProblem.feature

@@ -0,0 +1,15 @@
+Feature: Résoudre le problème
+  
+   Scenario: Vérification de la résolution du problème par le solveur de Simon
+    Given un echiquier vide
+    When le solveur Sim termine de résoudre le problème
+    Then aucune reine ne doit être menacée par une autre
+    And toutes les lignes doivent avoir une reine
+    And toutes les colonnes doivent avoir une reine
+
+   Scenario: Vérification de la résolution du problème par le solveur de Victor
+    Given un echiquier vide
+    When le solveur Vic termine de résoudre le problème
+    Then aucune reine ne doit être menacée par une autre
+    And toutes les lignes doivent avoir une reine
+    And toutes les colonnes doivent avoir une reine