BDD

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

@@ -12,4 +12,6 @@ import static io.cucumber.junit.platform.engine.Constants.GLUE_PROPERTY_NAME;
 @SelectClasspathResource("features")
 @ConfigurationParameter(key = GLUE_PROPERTY_NAME, value = "fr.iut_fbleau.but3.dev6_2.steps")
 public class CucumberTest {
+
+    
 }

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

@@ -1,27 +1,104 @@
 package fr.iut_fbleau.but3.dev6_2.steps;
 
-import fr.iut_fbleau.but3.dev6_2.*;
+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 static org.junit.jupiter.api.Assertions.fail;
+
+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")
+    private Position lastRemovedQueen;
-    public void unEchiquier() {
+
-        this.eightQueensSolver = new EightQueensSolver();
+    @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) {
+    public void placerUneReineEn(int x, int y) {
-        this.eightQueensSolver.getChessboard().placeQueen(x,y);
+        this.solver.getChessboard().placeQueen(x, y);
     }
     
-    @Then("{int} reine sur l'échiquier")
+    @When("retirer une reine en {int}, {int}")
-    public void reineSurLEchiquier(int queensOnChessboard) {
+    public void retirerUneReineEn(int x, int y) {
-        assertEquals(1, this.eightQueensSolver.getChessboard().getNumberOfQueen());
+        this.solver.getChessboard().removeQueen(x, y);
+        lastRemovedQueen = new Position(x, y);
     }
+
+    @Then("{int} reine(s) sur l'échiquier")
+    public void reineSurLEchiquier(int queensOnChessboard) {
+        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 de la reine retirée est libre")
+    public void caseReineRetireeEstLibre(){
+        if(lastRemovedQueen != null){
+            assertTrue(this.solver.getChessboard().VerifAccessible(lastRemovedQueen.x(), lastRemovedQueen.y()), "La case (" + lastRemovedQueen.x() + ", " + lastRemovedQueen.y() + ") est capturée mais ne devrait pas l'être.");
+            lastRemovedQueen = null;
+        }
+        else{
+            fail("Aucune reine n'a été retirée, ce test ne peut avoir lieu");
+        }
+    }
+
+
 }

src/test/resources/features/placeAQueen.feature

@@ -4,24 +4,20 @@ Feature: Placer une reine
   Scenario: Placer une reine en 0, 0
     Given un echiquier vide
     When placer une reine en 0, 0
-    Then 1 reine sur l'échiquier
+    Then 1 reine(s) sur l'échiquier
 
-  Scenario: Placer une reine sur une case libre
+  Scenario: Capturer toutes les cases de la colonne d'une reine
-    Given un echiquier avec une reine sur la ligne 0
-    When placer une reine sur la ligne 1
-    Then la reine est posée sur une case libre
-    And 2 reines sur l'échiquier
-
-Feature: Résoudre le problème
-
-  Scenario: Résoudre le problème à l'aide du solveur SolverVic
     Given un echiquier vide
-    When le solveur termine de résoudre le problème
+    When placer une reine en 4, 4
-    Then la solution doit être valide
+    Then la colonne 4 est capturée
-    And le nombre de reines doit être égal à 8
 
-  Scenario: Résoudre le problème à l'aide du solveur SolverSim
+  Scenario: Capturer toutes les cases de la ligne d'une reine
     Given un echiquier vide
-    When le solveur termine de résoudre le problème
+    When placer une reine en 4, 4
-    Then la solution doit être valide
+    Then toutes les cases de la ligne 4 sont prises
-    And le nombre de reines doit être égal à 8
+
+  Scenario : Capturer toutes les cases en diagonales d'une reine
+    Given un echiquier vide
+    When placer une reine en 4, 4
+    Then la diagonnale montante 0, 0 est capturée
+    And la diagonale descendante 8, 0 est capturée

src/test/resources/features/removeAQueen copy.feature

@@ -0,0 +1,15 @@
+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 la 4e reine
+    Then 4 reine(s) sur l'échiquier
+    And la case de la reine retirée est libre
+
+
+
+5, 4
+7, 5
+4, 6
+0, 7

src/test/resources/features/solveProblem.feature

@@ -0,0 +1,14 @@
+Feature: Résoudre le problème
+  
+   Scenario: Vérification des positions des reines
+    Given un echiquier vide
+    When le solveur termine de résoudre le problème
+    Then chaque reine est placée sur une case différente
+    And aucune reine ne doit être menacée par une autre
+  
+  Scenario: Vérification de la complétude de la solution
+    Given un echiquier vide
+    When le solveur termine de résoudre le problème
+    Then toutes les lignes doivent avoir une reine
+    And toutes les colonnes doivent avoir une reine
+    And chaque diagonale au maximum 1 reine