diff --git a/Hitori/src/main/java/PR2/HitoriSpiel/Fassade/GameBoard.java b/Hitori/src/main/java/PR2/HitoriSpiel/Fassade/GameBoard.java index de25f02..f7403ab 100644 --- a/Hitori/src/main/java/PR2/HitoriSpiel/Fassade/GameBoard.java +++ b/Hitori/src/main/java/PR2/HitoriSpiel/Fassade/GameBoard.java @@ -197,7 +197,7 @@ public class GameBoard extends JPanel { return button; } - private void toggleCellState(HitoriCell cell, int row, int col) { + public void toggleCellState(HitoriCell cell, int row, int col) { if (cell == null) { System.err.println("Ungültige Zelle! Der Zustand kann nicht geändert werden."); return; diff --git a/Hitori/src/test/java/Domain/ActionTest.java b/Hitori/src/test/java/Domain/ActionTest.java new file mode 100644 index 0000000..ec2a16a --- /dev/null +++ b/Hitori/src/test/java/Domain/ActionTest.java @@ -0,0 +1,31 @@ +package Domain; + +import PR2.HitoriSpiel.Domain.Action; +import org.junit.jupiter.api.Test; +import static org.junit.jupiter.api.Assertions.*; + +public class ActionTest { + + @Test + public void testConstructorAndGetters() { + Action action = new Action(2, 3, "WHITE", "BLACK"); + assertEquals(2, action.getRow()); + assertEquals(3, action.getCol()); + assertEquals("WHITE", action.getOldState()); + assertEquals("BLACK", action.getNewState()); + } + + @Test + public void testEqualsAndHashCode() { + Action action1 = new Action(1, 2, "GRAY", "WHITE"); + Action action2 = new Action(1, 2, "GRAY", "WHITE"); + assertEquals(action1, action2); + assertEquals(action1.hashCode(), action2.hashCode()); + } + + @Test + public void testToString() { + Action action = new Action(4, 5, "GRAY", "BLACK"); + assertEquals("4,5,GRAY,BLACK", action.toString()); + } +} diff --git a/Hitori/src/test/java/Domain/HitoriBoardTest.java b/Hitori/src/test/java/Domain/HitoriBoardTest.java new file mode 100644 index 0000000..ac4b2de --- /dev/null +++ b/Hitori/src/test/java/Domain/HitoriBoardTest.java @@ -0,0 +1,36 @@ +package Domain; + +import PR2.HitoriSpiel.Domain.HitoriBoard; +import PR2.HitoriSpiel.Domain.HitoriCell; +import org.junit.jupiter.api.Test; +import java.util.Arrays; +import static org.junit.jupiter.api.Assertions.*; + +public class HitoriBoardTest { + + @Test + public void testBoardInitialization() { + int[][] numbers = {{1, 2}, {3, 4}}; + HitoriBoard board = new HitoriBoard(numbers, Arrays.asList("1,1", "2,2"), "TestBoard"); + assertEquals(2, board.getSize()); + assertEquals("TestBoard", board.getBoardName()); + assertEquals(1, board.getCell(0, 0).getNumber()); + } + + @Test + public void testResetBoard() { + int[][] numbers = {{5, 6}, {7, 8}}; + HitoriBoard board = new HitoriBoard(numbers, Arrays.asList("1,1", "2,2"), "ResetTest"); + board.resetBoard(); + assertEquals(HitoriCell.CellState.GRAY, board.getCell(0, 0).getState()); + } + + @Test + public void testSetAndGetNumbers() { + int[][] initialNumbers = {{9, 10}, {11, 12}}; + HitoriBoard board = new HitoriBoard(initialNumbers, Arrays.asList(), "SetNumbersTest"); + int[][] newNumbers = {{1, 2}, {3, 4}}; + board.setNumbers(newNumbers); + assertArrayEquals(newNumbers, board.getNumbers()); + } +} diff --git a/Hitori/src/test/java/Domain/HitoriCellTest.java b/Hitori/src/test/java/Domain/HitoriCellTest.java new file mode 100644 index 0000000..dc4a457 --- /dev/null +++ b/Hitori/src/test/java/Domain/HitoriCellTest.java @@ -0,0 +1,23 @@ +package Domain; + +import PR2.HitoriSpiel.Domain.HitoriCell; +import org.junit.jupiter.api.Test; +import static org.junit.jupiter.api.Assertions.*; + +public class HitoriCellTest { + + @Test + public void testCellInitialization() { + HitoriCell cell = new HitoriCell(7); + assertEquals(7, cell.getNumber()); + assertEquals(HitoriCell.CellState.GRAY, cell.getState()); + } + + @Test + public void testSetState() { + HitoriCell cell = new HitoriCell(8); + cell.setState(HitoriCell.CellState.BLACK); + assertEquals(HitoriCell.CellState.BLACK, cell.getState()); + } +} + diff --git a/Hitori/src/test/java/Domain/HitoriValidatorTest.java b/Hitori/src/test/java/Domain/HitoriValidatorTest.java new file mode 100644 index 0000000..0385e57 --- /dev/null +++ b/Hitori/src/test/java/Domain/HitoriValidatorTest.java @@ -0,0 +1,89 @@ +package Domain; + +import PR2.HitoriSpiel.Domain.HitoriBoard; +import PR2.HitoriSpiel.Domain.HitoriValidator; +import PR2.HitoriSpiel.Domain.HitoriCell; +import org.junit.jupiter.api.Test; +import java.util.Arrays; +import static org.junit.jupiter.api.Assertions.*; + +public class HitoriValidatorTest { + + @Test + public void testValidateBoardValidSolution() { + // Spielfeld-Setup + int[][] numbers = {{1, 2, 3}, {4, 1, 6}, {7, 8, 1}}; + HitoriBoard board = new HitoriBoard(numbers, Arrays.asList("1,1", "2,2", "3,3"), "ValidSolutionTest"); + + // Lösung manuell setzen (alle Zellen aus der Lösungsliste auf BLACK setzen) + board.getCell(0, 0).setState(HitoriCell.CellState.BLACK); // Koordinaten 1,1 + board.getCell(1, 1).setState(HitoriCell.CellState.BLACK); // Koordinaten 2,2 + board.getCell(2, 2).setState(HitoriCell.CellState.BLACK); // Koordinaten 3,3 + + // Alle anderen Zellen auf WHITE setzen + for (int i = 0; i < board.getSize(); i++) { + for (int j = 0; j < board.getSize(); j++) { + if (!Arrays.asList("1,1", "2,2", "3,3").contains((i + 1) + "," + (j + 1))) { + board.getCell(i, j).setState(HitoriCell.CellState.WHITE); + } + } + } + + // Validator initialisieren und prüfen + HitoriValidator validator = new HitoriValidator(board); + assertTrue(validator.validateBoard(Arrays.asList("1,1", "2,2", "3,3"))); + } + + @Test + public void testValidateBoardInvalidSolution() { + // Spielfeld-Setup + int[][] numbers = {{1, 2, 3}, {4, 1, 6}, {7, 8, 1}}; + HitoriBoard board = new HitoriBoard(numbers, Arrays.asList("1,1", "2,2", "3,3"), "InvalidSolutionTest"); + + // Ungültige Lösung setzen (eine Zelle aus der Lösungsliste bleibt nicht BLACK) + board.getCell(0, 0).setState(HitoriCell.CellState.BLACK); // Koordinaten 1,1 + board.getCell(1, 1).setState(HitoriCell.CellState.WHITE); // Koordinaten 2,2 (falsch) + board.getCell(2, 2).setState(HitoriCell.CellState.BLACK); // Koordinaten 3,3 + + // Alle anderen Zellen auf WHITE setzen + for (int i = 0; i < board.getSize(); i++) { + for (int j = 0; j < board.getSize(); j++) { + if (!Arrays.asList("1,1", "2,2", "3,3").contains((i + 1) + "," + (j + 1))) { + board.getCell(i, j).setState(HitoriCell.CellState.WHITE); + } + } + } + + // Validator initialisieren und prüfen + HitoriValidator validator = new HitoriValidator(board); + assertFalse(validator.validateBoard(Arrays.asList("1,1", "2,2", "3,3"))); + } + + @Test + public void testValidateBoardExtraBlackCells() { + // Spielfeld-Setup + int[][] numbers = {{1, 2, 3}, {4, 1, 6}, {7, 8, 1}}; + HitoriBoard board = new HitoriBoard(numbers, Arrays.asList("1,1", "2,2", "3,3"), "ExtraBlackCellsTest"); + + // Lösung setzen + board.getCell(0, 0).setState(HitoriCell.CellState.BLACK); // Koordinaten 1,1 + board.getCell(1, 1).setState(HitoriCell.CellState.BLACK); // Koordinaten 2,2 + board.getCell(2, 2).setState(HitoriCell.CellState.BLACK); // Koordinaten 3,3 + + // Zusätzliche schwarze Zelle setzen (ungültig) + board.getCell(0, 1).setState(HitoriCell.CellState.BLACK); // Koordinaten 1,2 (nicht Teil der Lösung) + + // Alle anderen Zellen auf WHITE setzen + for (int i = 0; i < board.getSize(); i++) { + for (int j = 0; j < board.getSize(); j++) { + if (!Arrays.asList("1,1", "2,2", "3,3", "1,2").contains((i + 1) + "," + (j + 1))) { + board.getCell(i, j).setState(HitoriCell.CellState.WHITE); + } + } + } + + // Validator initialisieren und prüfen + HitoriValidator validator = new HitoriValidator(board); + assertFalse(validator.validateBoard(Arrays.asList("1,1", "2,2", "3,3"))); + } +} diff --git a/Hitori/src/test/java/Domain/StateFileManagerTest.java b/Hitori/src/test/java/Domain/StateFileManagerTest.java new file mode 100644 index 0000000..63c2937 --- /dev/null +++ b/Hitori/src/test/java/Domain/StateFileManagerTest.java @@ -0,0 +1,29 @@ +package Domain; + +import PR2.HitoriSpiel.Domain.StateFileManager; +import PR2.HitoriSpiel.Domain.Action; +import org.junit.jupiter.api.Test; +import java.util.Stack; +import static org.junit.jupiter.api.Assertions.*; + +public class StateFileManagerTest { + + @Test + public void testSaveAndLoadState() { + Stack undoStack = new Stack<>(); + Stack redoStack = new Stack<>(); + + undoStack.push(new Action(1, 1, "GRAY", "BLACK")); + redoStack.push(new Action(2, 2, "WHITE", "GRAY")); + + StateFileManager.saveState(undoStack, redoStack); + + Stack loadedUndo = new Stack<>(); + Stack loadedRedo = new Stack<>(); + StateFileManager.loadState(loadedUndo, loadedRedo); + + assertEquals(undoStack, loadedUndo); + assertEquals(redoStack, loadedRedo); + } +} + diff --git a/Hitori/src/test/java/Fassade/GameBoardTest.java b/Hitori/src/test/java/Fassade/GameBoardTest.java new file mode 100644 index 0000000..f98a01a --- /dev/null +++ b/Hitori/src/test/java/Fassade/GameBoardTest.java @@ -0,0 +1,95 @@ +package Fassade; + +import PR2.HitoriSpiel.Domain.HitoriBoard; +import PR2.HitoriSpiel.Domain.HitoriCell; +import PR2.HitoriSpiel.Fassade.GameBoard; +import org.junit.jupiter.api.Test; + +import javax.swing.*; +import java.util.Arrays; + +import static org.junit.jupiter.api.Assertions.*; + +public class GameBoardTest { + + @Test + public void testGameBoardInitialization() { + int[][] numbers = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}}; + HitoriBoard board = new HitoriBoard(numbers, Arrays.asList("1,1", "2,2", "3,3"), "TestBoard"); + GameBoard gameBoard = new GameBoard(board); + + assertNotNull(gameBoard, "GameBoard sollte erfolgreich initialisiert werden."); + assertNotNull(gameBoard.validateCurrentBoard(), "Das Spielfeld sollte validierbar sein."); + } + + @Test + public void testResetBoard() { + int[][] numbers = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}}; + HitoriBoard board = new HitoriBoard(numbers, Arrays.asList("1,1", "2,2", "3,3"), "TestBoard"); + GameBoard gameBoard = new GameBoard(board); + + // Setze einige Zellen auf unterschiedliche Zustände + board.getCell(0, 0).setState(HitoriCell.CellState.BLACK); + board.getCell(1, 1).setState(HitoriCell.CellState.WHITE); + + // Führe das Zurücksetzen durch + gameBoard.resetBoard(); + + // Verifiziere, dass alle Zellen zurückgesetzt wurden + for (int i = 0; i < numbers.length; i++) { + for (int j = 0; j < numbers[i].length; j++) { + assertEquals(HitoriCell.CellState.GRAY, board.getCell(i, j).getState(), + "Alle Zellen sollten nach dem Zurücksetzen grau sein."); + } + } + } + + + @Test + public void testValidateCurrentBoard() { + int[][] numbers = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}}; + HitoriBoard board = new HitoriBoard(numbers, Arrays.asList("1,1", "2,2", "3,3"), "TestBoard"); + GameBoard gameBoard = new GameBoard(board); + + // Setze Zellen auf die Lösung + board.getCell(0, 0).setState(HitoriCell.CellState.BLACK); + board.getCell(1, 1).setState(HitoriCell.CellState.BLACK); + board.getCell(2, 2).setState(HitoriCell.CellState.BLACK); + + // Alle anderen Zellen auf weiß setzen + for (int i = 0; i < numbers.length; i++) { + for (int j = 0; j < numbers[i].length; j++) { + if (!Arrays.asList("1,1", "2,2", "3,3").contains((i + 1) + "," + (j + 1))) { + board.getCell(i, j).setState(HitoriCell.CellState.WHITE); + } + } + } + + assertTrue(gameBoard.validateCurrentBoard(), "Das Board sollte als gültig erkannt werden."); + } + + @Test + public void testToggleCellState() { + int[][] numbers = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}}; + HitoriBoard board = new HitoriBoard(numbers, Arrays.asList("1,1", "2,2", "3,3"), "TestBoard"); + GameBoard gameBoard = new GameBoard(board); + + HitoriCell cell = board.getCell(0, 0); + + // Initialer Zustand: GRAY + assertEquals(HitoriCell.CellState.GRAY, cell.getState(), "Die Zelle sollte initial grau sein."); + + // Zustand wechseln: BLACK + gameBoard.toggleCellState(cell, 0, 0); + assertEquals(HitoriCell.CellState.BLACK, cell.getState(), "Die Zelle sollte schwarz sein."); + + // Zustand wechseln: WHITE + gameBoard.toggleCellState(cell, 0, 0); + assertEquals(HitoriCell.CellState.WHITE, cell.getState(), "Die Zelle sollte weiß sein."); + + // Zustand wechseln: GRAY + gameBoard.toggleCellState(cell, 0, 0); + assertEquals(HitoriCell.CellState.GRAY, cell.getState(), "Die Zelle sollte wieder grau sein."); + } + +} diff --git a/Hitori/src/test/java/Fassade/HighscoreManagerTest.java b/Hitori/src/test/java/Fassade/HighscoreManagerTest.java new file mode 100644 index 0000000..18ef420 --- /dev/null +++ b/Hitori/src/test/java/Fassade/HighscoreManagerTest.java @@ -0,0 +1,44 @@ +package Fassade; + +import PR2.HitoriSpiel.Fassade.HighscoreManager; +import org.junit.jupiter.api.Test; + +import java.util.List; + +import static org.junit.jupiter.api.Assertions.*; + +public class HighscoreManagerTest { + + @Test + public void testAddHighscore() { + HighscoreManager manager = new HighscoreManager(); + manager.addHighscore("Alice", 120, "TestBoard", 0); + List highscores = manager.getHighscoresForBoard("TestBoard"); + + assertEquals(1, highscores.size()); + assertEquals("Alice", highscores.get(0).getPlayerName()); + assertEquals(120, highscores.get(0).getTime()); + assertEquals("TestBoard", highscores.get(0).getBoardName()); + } + + @Test + public void testIsNewHighscore() { + HighscoreManager manager = new HighscoreManager(); + manager.addHighscore("Bob", 150, "TestBoard", 0); + + assertTrue(manager.isNewHighscore(140, "TestBoard")); + assertFalse(manager.isNewHighscore(160, "TestBoard")); + } + + @Test + public void testClearHighscores() { + HighscoreManager manager = new HighscoreManager(); + manager.addHighscore("Alice", 100, "TestBoard", 0); + + manager.clearHighscores(); + List highscores = manager.getHighscores(); + + assertTrue(highscores.isEmpty(), "Alle Highscores sollten gelöscht sein."); + } +} + diff --git a/Hitori/src/test/java/Fassade/HitoriSolutionLoaderTest.java b/Hitori/src/test/java/Fassade/HitoriSolutionLoaderTest.java new file mode 100644 index 0000000..b27e187 --- /dev/null +++ b/Hitori/src/test/java/Fassade/HitoriSolutionLoaderTest.java @@ -0,0 +1,102 @@ +package Fassade; + +import PR2.HitoriSpiel.Fassade.HitoriSolutionLoader; +import org.junit.jupiter.api.Test; + +import java.io.*; +import java.util.ArrayList; +import java.util.List; + +import static org.junit.jupiter.api.Assertions.*; + +public class HitoriSolutionLoaderTest { + + @Test + public void testLoadSolutionValidFile() throws IOException { + // Simuliere eine valide Lösung im InputStream + String solutionContent = """ + //Lösung + 1,1 + 2,2 + 3,3 + """; + + InputStream inputStream = new ByteArrayInputStream(solutionContent.getBytes()); + + // Mock den Aufruf von getResourceAsStream + List solution = loadSolutionFromStream(inputStream); + assertNotNull(solution, "Die Lösungsliste sollte nicht null sein."); + assertFalse(solution.isEmpty(), "Die Lösungsliste sollte nicht leer sein."); + assertEquals("1,1", solution.get(0), "Die erste Koordinate sollte korrekt geladen werden."); + assertEquals("3,3", solution.get(2), "Die letzte Koordinate sollte korrekt geladen werden."); + } + + @Test + public void testLoadSolutionNoSolutionSection() throws IOException { + // Simuliere eine Datei ohne "//Lösung" + String solutionContent = """ + 1,1 + 2,2 + 3,3 + """; + + InputStream inputStream = new ByteArrayInputStream(solutionContent.getBytes()); + + // Mock den Aufruf von getResourceAsStream + List solution = loadSolutionFromStream(inputStream); + assertNotNull(solution, "Die Lösungsliste sollte nicht null sein."); + assertTrue(solution.isEmpty(), "Die Lösungsliste sollte leer sein, wenn kein Lösungsteil gefunden wird."); + } + + @Test + public void testLoadSolutionWithEmptyLines() throws IOException { + // Simuliere eine Datei mit leeren Zeilen + String solutionContent = """ + //Lösung + + 1,1 + + 2,2 + 3,3 + """; + + InputStream inputStream = new ByteArrayInputStream(solutionContent.getBytes()); + + // Mock den Aufruf von getResourceAsStream + List solution = loadSolutionFromStream(inputStream); + assertNotNull(solution, "Die Lösungsliste sollte nicht null sein."); + assertFalse(solution.isEmpty(), "Die Lösungsliste sollte nicht leer sein."); + assertEquals(3, solution.size(), "Die Lösungsliste sollte nur 3 gültige Einträge enthalten."); + assertEquals("1,1", solution.get(0), "Die erste Koordinate sollte korrekt geladen werden."); + } + + + // Hilfsmethode: Simuliert die Verarbeitung des InputStreams + private List loadSolutionFromStream(InputStream inputStream) throws IOException { + BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream)); + List solutionCoordinates = new ArrayList<>(); + boolean solutionSectionFound = false; + + String line; + while ((line = reader.readLine()) != null) { + line = line.trim(); + + if (line.startsWith("//Lösung")) { + solutionSectionFound = true; + continue; + } + + if (solutionSectionFound) { + if (!line.isEmpty()) { + solutionCoordinates.add(line); + } + } + } + + if (!solutionSectionFound) { + System.err.println("Warnung: Lösungsteil wurde in der Datei nicht gefunden."); + } + + return solutionCoordinates; + } +} diff --git a/Hitori/src/test/java/Fassade/SetupTest.java b/Hitori/src/test/java/Fassade/SetupTest.java new file mode 100644 index 0000000..75d7aac --- /dev/null +++ b/Hitori/src/test/java/Fassade/SetupTest.java @@ -0,0 +1,35 @@ +package Fassade; + +import PR2.HitoriSpiel.Fassade.Setup; +import org.junit.jupiter.api.Test; + +import javax.swing.*; +import java.awt.*; + +import static org.junit.jupiter.api.Assertions.*; + +public class SetupTest { + + @Test + public void testCreateButton() { + JButton button = Setup.createButton("TestButton", 100, 50); + + assertNotNull(button); + assertEquals("TestButton", button.getText()); + assertEquals(new Dimension(100, 50), button.getPreferredSize()); + assertEquals(Setup.BUTTON_COLOR, button.getBackground()); + assertEquals(Setup.BUTTON_TEXT_COLOR, button.getForeground()); + } + + @Test + public void testCreateGameBoardButton() { + JButton button = Setup.createGameBoardButton("GameButton", 150, 60); + + assertNotNull(button); + assertEquals("GameButton", button.getText()); + assertEquals(new Dimension(150, 60), button.getPreferredSize()); + assertEquals(Setup.GAME_BUTTON_COLOR, button.getBackground()); + assertEquals(Setup.GAME_BUTTON_TEXT_COLOR, button.getForeground()); + } +} + diff --git a/Hitori/src/test/java/Fassade/StateManagerTest.java b/Hitori/src/test/java/Fassade/StateManagerTest.java new file mode 100644 index 0000000..d68512f --- /dev/null +++ b/Hitori/src/test/java/Fassade/StateManagerTest.java @@ -0,0 +1,50 @@ +package Fassade; + +import PR2.HitoriSpiel.Fassade.StateManager; +import PR2.HitoriSpiel.Domain.Action; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.*; + +public class StateManagerTest { + + @Test + public void testSaveActionAndUndo() { + StateManager stateManager = new StateManager(); + stateManager.saveAction(0, 0, "GRAY", "BLACK"); + + Action undoAction = stateManager.undo(); + assertNotNull(undoAction); + assertEquals(0, undoAction.getRow()); + assertEquals(0, undoAction.getCol()); + assertEquals("GRAY", undoAction.getOldState()); + assertEquals("BLACK", undoAction.getNewState()); + } + + @Test + public void testRedo() { + StateManager stateManager = new StateManager(); + stateManager.saveAction(1, 1, "WHITE", "BLACK"); + + stateManager.undo(); + Action redoAction = stateManager.redo(); + assertNotNull(redoAction); + assertEquals(1, redoAction.getRow()); + assertEquals(1, redoAction.getCol()); + assertEquals("WHITE", redoAction.getOldState()); + assertEquals("BLACK", redoAction.getNewState()); + } + + @Test + public void testLoadStateFromFile() { + StateManager stateManager = new StateManager(); + stateManager.saveAction(0, 0, "GRAY", "BLACK"); + stateManager.saveAction(1, 1, "WHITE", "BLACK"); + + stateManager.loadStateFromFile(); + + assertNotNull(stateManager.undo(), "Der Undo-Stack sollte geladen werden."); + assertNotNull(stateManager.redo(), "Der Redo-Stack sollte geladen werden."); + } +} +