From 7ebfecc6c48d0c5986a624633572a3c9b594868c Mon Sep 17 00:00:00 2001
From: valen <valen@Höllenmaschine>
Date: Sun, 22 Jun 2025 15:19:08 +0200
Subject: [PATCH] =?UTF-8?q?ModelTests=20wurden=20hinzugef=C3=BCgt?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../informatik/chess/test/ModelTest.java      | 146 ++++++++++++++++++
 1 file changed, 146 insertions(+)
 create mode 100644 schach/src/test/java/de/hs_mannheim/informatik/chess/test/ModelTest.java

diff --git a/schach/src/test/java/de/hs_mannheim/informatik/chess/test/ModelTest.java b/schach/src/test/java/de/hs_mannheim/informatik/chess/test/ModelTest.java
new file mode 100644
index 0000000..6c7d620
--- /dev/null
+++ b/schach/src/test/java/de/hs_mannheim/informatik/chess/test/ModelTest.java
@@ -0,0 +1,146 @@
+package de.hs_mannheim.informatik.chess.test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import java.util.ArrayList;
+import java.util.List;
+
+
+import de.hs_mannheim.informatik.chess.model.*;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+
+
+
+
+class ModelTest {
+
+	private ChessEngine engine;
+	
+	@BeforeEach
+	public void setUp() {
+	    engine = new ChessEngine(); // Echte Instanz!
+	}
+	
+	@Test
+	public void ErkenntObZugLegalOderIllegal()
+	{
+		assertTrue(engine.move(new MoveDTO(6, 4, 4, 4)));
+		
+		assertFalse(engine.move(new MoveDTO(7, 0, 5, 1)));
+	}
+	
+	
+	@Test
+	public void GibtLegaleMovesAn() {
+		List<MoveDTO> mvs = new ArrayList<>();
+		mvs.add(new MoveDTO(6,4,5,4));
+		mvs.add(new MoveDTO(6,4,4,4));
+		List<MoveDTO> moves = engine.getLegalDestinations("E2");
+
+		assertEquals(2, moves.size());
+		assertTrue(moves.stream().anyMatch(m -> m.getToRow() == 5 && m.getToCol() == 4));
+		assertTrue(moves.stream().anyMatch(m -> m.getToRow() == 4 && m.getToCol() == 4));
+	}
+	
+	@Test //Stichprobenartige Kontrolle ob richtige Figur an richtiger Stelle
+	public void BoardWirdRichtigAufgebaut() {
+		BoardDTO board = engine.getBoardAsDTO();
+		PieceDTO a1 = board.getBoard()[7][0];
+		assertEquals("ROOK", a1.getType());
+		assertEquals("WHITE", a1.getColor());
+		
+		PieceDTO e1 = 	board.getBoard()[7][4];
+		assertEquals("KING", e1.getType());
+		assertEquals("WHITE", e1.getColor());
+		
+		PieceDTO a8 = 	board.getBoard()[0][0];
+		assertEquals("ROOK", a8.getType());
+		assertEquals("BLACK", a8.getColor());
+		
+		PieceDTO e8 = 	board.getBoard()[0][4];
+		assertEquals("KING", e8.getType());
+		assertEquals("BLACK", e8.getColor());
+		
+		PieceDTO e2 = 	board.getBoard()[6][4];
+		assertEquals("PAWN", e2.getType());
+		assertEquals("WHITE", e2.getColor());
+		
+		PieceDTO d7 = 	board.getBoard()[1][3];
+		assertEquals("PAWN", d7.getType());
+		assertEquals("BLACK", d7.getColor());
+		
+		PieceDTO e4 = 	board.getBoard()[4][4];
+		assertNull(e4);
+		
+		PieceDTO d5 = 	board.getBoard()[3][3];
+		assertNull(d5);
+		
+
+	}
+	
+	
+	@Test
+	public void speichertMovesRichtigGruppiert() {
+		engine.move(new MoveDTO(6, 6, 4, 6));
+		engine.move(new MoveDTO(1, 4, 3, 4));
+		engine.move(new MoveDTO(7, 6, 5, 5)); //Züge um das speichern zu testen
+		engine.move(new MoveDTO(0, 1, 2, 2));
+		engine.move(new MoveDTO(7, 1, 5, 2));
+		
+		
+		List<String> gruppiertGespeichert = engine.getMoveListStringsGrouped(); //Moves in Liste gespeichert um zu testen
+		assertTrue(gruppiertGespeichert.size() >= 3, "Zu wenige gespeicherte Gruppen");
+		assertTrue(gruppiertGespeichert.get(0).startsWith("1."));
+		assertTrue(gruppiertGespeichert.get(1).startsWith("2."));
+		assertTrue(gruppiertGespeichert.get(2).startsWith("3."));
+		
+		for (int i = 0; i < gruppiertGespeichert.size(); i++) {
+	        String[] parts = gruppiertGespeichert.get(i).split(" ");
+	        if (i == gruppiertGespeichert.size() - 1) {
+	            assertTrue(parts.length == 2 || parts.length == 3); 
+	        } else {
+	            assertEquals(3, parts.length);
+	        }
+	    }
+
+	}
+	
+	
+	@Test
+	public void erkenntMattKorrekt() {
+	    
+		assertFalse(engine.isMated()); //<--Test, dass nicht immer alles einfach Matt ist
+	    engine.setPositionFromFEN("7k/6Q1/5K2/8/8/8/8/8 b - - 0 1"); //<--Matt position vorbereiten
+
+	    System.out.println("Aktueller Spieler: " + engine.getCurrentPlayer());
+	    System.out.println("isMated(): " + engine.isMated());
+
+	    assertEquals("BLACK", engine.getCurrentPlayer());
+	    assertTrue(engine.isMated()); //<Test ob nun spieler Matt ist
+	}
+
+
+	@Test
+	public void erkenntPattKorrekt() {
+	    
+		assertFalse(engine.isStalemate()); 
+	    engine.setPositionFromFEN("7k/5Q2/6K1/8/8/8/8/8 b - - 0 1");
+
+	    System.out.println("Aktueller Spieler: " + engine.getCurrentPlayer());
+	    System.out.println("isStalemate(): " + engine.isStalemate());
+
+	    assertEquals("BLACK", engine.getCurrentPlayer());
+	    assertTrue(engine.isStalemate()); 
+	}
+	
+	@Test
+	public void erkenntUnentschieden() {
+		assertFalse(engine.isDraw());
+		engine.setPositionFromFEN("8/8/8/8/8/8/8/4K2k w - - 0 1"); // nur zwei Könige
+		assertTrue(engine.isDraw());
+	}
+	
+
+}
\ No newline at end of file