Test de isLegal (à debug) [wip]

Makefile

@@ -1,3 +1,6 @@
+# === Environnements ===
+TEST_ENV = "bin:/usr/share/java/junit.jar:/usr/share/java/hamcrest-core.jar"
+
 # === Répertoires ===
 SRC_DIR = fr
 BIN_DIR = bin
@@ -12,12 +15,16 @@ SOURCES := $(shell find $(SRC_DIR) -name "*.java")
 # === Classe principale ===
 MAIN_CLASS = fr.iut_fbleau.Avalam.Main
 
+# === Classe de test ===
+TEST_CLASS = fr.iut_fbleau.Tests.AvalamBoardTest
+
 # === Commandes Java ===
 JC = javac
-JCFLAGS = -d $(BIN_DIR)
+JCFLAGS = -d $(BIN_DIR) -cp $(TEST_ENV)
 
 JAVA = java
 JAVAFLAGS = -cp $(BIN_DIR)
+JAVAFLAGS_TESTS = -cp $(TEST_ENV)
 
 # === Règle par défaut ===
 all: build
@@ -43,6 +50,12 @@ run:
 	@echo "===> Lancement du jeu Avalam..."
 	@$(JAVA) $(JAVAFLAGS) $(MAIN_CLASS)
 
+# === Tests ===
+test:
+	@echo "===> Lancement des tests..."
+	@$(JAVA) $(JAVAFLAGS_TESTS) org.junit.runner.JUnitCore $(TEST_CLASS)
+	@echo "... Fin des tests."
+
 # === Nettoyage ===
 clean:
 	@echo "===> Suppression des fichiers compilés..."

fr/iut_fbleau/Tests/AvalamBoardTest.java

@@ -0,0 +1,122 @@
+package fr.iut_fbleau.Tests;
+
+import fr.iut_fbleau.GameAPI.AbstractPly;
+import fr.iut_fbleau.GameAPI.Player;
+
+import fr.iut_fbleau.Avalam.AvalamBoard;
+import fr.iut_fbleau.Avalam.AvalamPly;
+import fr.iut_fbleau.Avalam.Tower;
+import fr.iut_fbleau.Avalam.Color;
+
+import org.junit.Before;
+import org.junit.Test;
+//import org.mockito.Mockito;  //À retirer si Mockito absent
+
+import static org.junit.Assert.*;
+
+/**
+* La classe <code>AvalamBoardTest</code> test si la méthode isLegal() fonctionne comme prévu.
+*/
+public class AvalamBoardTest {
+
+    private Tower[][] grid;
+    private AvalamBoard board;
+
+    @Before
+    public void setUp() {
+        grid = new Tower[AvalamBoard.SIZE][AvalamBoard.SIZE];
+        // Par défaut, current player sera PLAYER1 via constructeur sans joueur
+        board = new AvalamBoard(grid);
+    }
+
+    /*
+    @Test  //À retirer si Mockito absent
+    public void nonAvalamPly_returnsFalse() {
+        AbstractPly fake = Mockito.mock(AbstractPly.class); // instance non-AvalamPly
+        assertFalse(board.isLegal(fake));
+    }*/
+
+    @Test
+    public void outOfBounds_returnsFalse() {
+        grid[2][2] = new Tower(1, Color.YELLOW);
+        grid[2][3] = new Tower(1, Color.RED);
+        AvalamPly p = new AvalamPly(Player.PLAYER1, -1, 2, 2, 3);
+        assertFalse(board.isLegal(p));
+
+        AvalamPly p2 = new AvalamPly(Player.PLAYER1, 2, 2, 9, 3);
+        assertFalse(board.isLegal(p2));
+    }
+
+    @Test
+    public void sameCell_returnsFalse() {
+        grid[4][4] = new Tower(1, Color.YELLOW);
+        AvalamPly p = new AvalamPly(Player.PLAYER1, 4, 4, 4, 4);
+        assertFalse(board.isLegal(p));
+    }
+
+    @Test
+    public void emptySourceOrDest_returnsFalse() {
+        // source null
+        grid[3][3] = null;
+        grid[3][4] = new Tower(1, Color.RED);
+        AvalamPly p1 = new AvalamPly(Player.PLAYER1, 3, 3, 3, 4);
+        assertFalse(board.isLegal(p1));
+
+        // dest null
+        grid[5][5] = new Tower(1, Color.YELLOW);
+        grid[5][6] = null;
+        AvalamPly p2 = new AvalamPly(Player.PLAYER1, 5, 5, 5, 6);
+        assertFalse(board.isLegal(p2));
+    }
+
+    @Test
+    public void sourceNotOwned_returnsFalse() {
+        // current player = PLAYER1 -> color must be YELLOW
+        grid[2][2] = new Tower(1, Color.RED); // not owned
+        grid[2][3] = new Tower(1, Color.YELLOW);
+        AvalamPly p = new AvalamPly(Player.PLAYER1, 2, 2, 2, 3);
+        assertFalse(board.isLegal(p));
+    }
+
+    @Test
+    public void notAdjacent_returnsFalse() {
+        grid[0][0] = new Tower(1, Color.YELLOW);
+        grid[0][2] = new Tower(1, Color.RED);
+        AvalamPly p = new AvalamPly(Player.PLAYER1, 0, 0, 0, 2);
+        assertFalse(board.isLegal(p));
+    }
+
+    @Test
+    public void sameColor_returnsFalse() {
+        grid[6][6] = new Tower(1, Color.YELLOW);
+        grid[6][7] = new Tower(1, Color.YELLOW); // same color as source
+        AvalamPly p = new AvalamPly(Player.PLAYER1, 6, 6, 6, 7);
+        assertFalse(board.isLegal(p));
+    }
+
+    @Test
+    public void tooTallAfterMerge_returnsFalse() {
+        grid[1][1] = new Tower(3, Color.YELLOW);
+        grid[1][2] = new Tower(3, Color.RED); // 3+3 = 6 > MAX_HEIGHT (5)
+        AvalamPly p = new AvalamPly(Player.PLAYER1, 1, 1, 1, 2);
+        assertFalse(board.isLegal(p));
+    }
+
+    @Test
+    public void validMove_returnsTrue() {
+        grid[4][4] = new Tower(2, Color.YELLOW); // owned by PLAYER1
+        grid[4][5] = new Tower(2, Color.RED);    // opposite color
+        AvalamPly p = new AvalamPly(Player.PLAYER1, 4, 4, 4, 5);
+        assertTrue(board.isLegal(p));
+    }
+
+    @Test
+    public void currentPlayerMismatchInPlyDoesNotAffectOwnershipCheck() {
+        // Even if AvalamPly is constructed with a player value, isLegal uses board.getCurrentPlayer()
+        grid[7][7] = new Tower(1, Color.YELLOW); // owned by PLAYER1 (board default)
+        grid[7][8] = new Tower(1, Color.RED);
+        // Construct ply with PLAYER2 explicitly — ownership check should still compare to board.getCurrentPlayer()
+        AvalamPly p = new AvalamPly(Player.PLAYER2, 7, 7, 7, 8);
+        assertFalse(board.isLegal(p));
+    }
+}