src/test/java/model/CellularAutomatonSimulationTest.java

+package model;
+
+import matrix.Coordinate;
+import javafx.scene.paint.Color;
+import model.automata.GameOfLifeAutomaton;
+import static model.automata.GameOfLifeState.*;
+import model.automata.GameOfLifeState;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Random;
+import static org.junit.jupiter.api.Assertions.*;
+
+
+class CellularAutomatonSimulationTest {
+
+    private final CellularAutomatonSimulation<GameOfLifeState> simulation;
+    private final CellularAutomaton<GameOfLifeState> automaton;
+    private final Random randomGenerator;
+
+    CellularAutomatonSimulationTest() {
+        this.randomGenerator = new Random();
+        this.automaton = new GameOfLifeAutomaton(4,3);
+        this.simulation = new CellularAutomatonSimulation<>(automaton, randomGenerator);
+    }
+    @BeforeEach
+    public void setUp() {
+        this.simulation.clear();
+    }
+
+    @Test
+    public void testNumberOfColumns() {
+        assertEquals(4, simulation.numberOfColumns());
+    }
+
+    @Test
+    public void testNumberOfRows() {
+        assertEquals(3, simulation.numberOfRows());
+    }
+
+    @Test
+    public void testAt() {
+        Coordinate coordinate = Coordinate.of(1, 2);
+        Cell<GameOfLifeState> cell = simulation.at(coordinate);
+        assertEquals(DEAD,cell.get());
+    }
+
+    @Test
+    public void testUpdateToNextGeneration() {
+        GameOfLifeState[][] input =
+                { {ALIVE, ALIVE, ALIVE, DEAD},
+                  {ALIVE, DEAD, DEAD, DEAD},
+                  {DEAD, ALIVE, DEAD, DEAD}
+                };
+        GameOfLifeState[][] output =
+                { {ALIVE, DEAD, ALIVE, ALIVE},
+                  {ALIVE, DEAD, ALIVE, ALIVE},
+                  {DEAD, DEAD, ALIVE, ALIVE}
+                };
+        for (Coordinate coordinate : this.simulation) {
+            this.simulation.at(coordinate).set(input[coordinate.y()][coordinate.x()]);
+        }
+        simulation.updateToNextGeneration();
+        for (Coordinate coordinate : this.simulation) {
+            assertEquals(
+                    output[coordinate.y()][coordinate.x()],
+                    this.simulation.at(coordinate).get(),
+                    "Generation at " + coordinate
+            );
+        }
+    }
+
+    @Test
+    public void testNext() {
+        Coordinate coordinate = Coordinate.of(1, 1);
+        Cell<GameOfLifeState> cell = simulation.at(coordinate);
+        GameOfLifeState oldState = cell.get();
+        simulation.next(coordinate);
+        assertNotEquals(oldState, cell.get());
+    }
+
+    @Test
+    public void testCopy() {
+        Coordinate source = Coordinate.of(1, 1);
+        Coordinate destination = Coordinate.of(2, 2);
+        this.simulation.at(source).set(ALIVE);
+        simulation.copy(source, destination);
+        assertEquals(
+                ALIVE,
+                this.simulation.at(destination).get()
+        );
+    }
+
+    @Test
+    public void testColor() {
+        Coordinate coordinate = Coordinate.of(1, 1);
+        assertEquals(Color.WHITE, this.simulation.getColor(coordinate));
+        this.simulation.at(coordinate).set(ALIVE);
+        assertEquals(Color.RED, this.simulation.getColor(coordinate));
+    }
+
+    @Test
+    public void testSetChangeListener() {
+        Coordinate coordinate = Coordinate.of(1, 1);
+        Coordinate otherCoordinate = Coordinate.of(0,2);
+        Cell<GameOfLifeState> cell = simulation.at(coordinate);
+        List<GameOfLifeState> states = new ArrayList<>();
+        Runnable listener = () -> states.add(this.simulation.at(coordinate).get());
+        simulation.setChangeListener(coordinate, listener);
+        this.simulation.at(otherCoordinate).set(ALIVE);
+        assertEquals(Collections.emptyList(), states);
+        this.simulation.at(coordinate).set(ALIVE);
+        this.simulation.at(otherCoordinate).set(DEAD);
+        assertEquals(List.of(ALIVE), states);
+        this.simulation.at(coordinate).set(ALIVE);
+        this.simulation.at(otherCoordinate).set(ALIVE);
+        this.simulation.at(coordinate).set(DEAD);
+        assertEquals(List.of(ALIVE, ALIVE, DEAD), states);
+    }
+
+    @Test
+    public void testSetGenerationNumberChangeListener() {
+        List<Integer> values = new ArrayList<>();
+        OnChangeListener<Integer> listener = (oldValue, newValue) -> values.add(newValue);
+        simulation.setGenerationNumberChangeListener(listener);
+        assertEquals(Collections.emptyList(), values);
+        simulation.clear();
+        assertEquals(List.of(0), values);
+        simulation.updateToNextGeneration();
+        assertEquals(List.of(0,1), values);
+        simulation.updateToNextGeneration();
+        simulation.updateToNextGeneration();
+        assertEquals(List.of(0,1,2,3), values);
+    }
+
+    @Test
+    public void testClear() {
+        for (Coordinate coordinate : this.simulation) {
+            this.simulation.at(coordinate).set(ALIVE);
+        }
+        this.simulation.clear();
+        for (Coordinate coordinate : this.simulation) {
+            assertEquals(DEAD, this.simulation.at(coordinate).get());
+        }
+    }
+
+    @Test
+    public void testReset() {
+        randomGenerator.setSeed(321);
+        this.simulation.reset();
+        int count = 0;
+        for (Coordinate coordinate : this.simulation) {
+            if (this.simulation.at(coordinate).get().equals(ALIVE)) {
+                count = count + 1;
+            }
+        }
+        assertEquals(7, count);
+    }
+}
\ No newline at end of file

src/test/java/model/GridTest.java

-package model;
-
-import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.Test;
-import static org.hamcrest.MatcherAssert.assertThat;
-import static org.hamcrest.Matchers.*;
-
-public class GridTest {
-  private Grid grid;
-
-  @BeforeEach
-  public void initializeGrid(){
-    grid = new Grid(3,3);
-  }
-
-  @Test
-  public void testGetNeighbours(){
-    assertThat(grid.getNeighbours(1,1), is(notNullValue()));
-    assertThat(grid.getNeighbours(1,1), hasSize(equalTo(8)));
-    assertThat(grid.getNeighbours(1,1),
-            containsInAnyOrder(grid.getCell(0,0),
-                    grid.getCell(0,1),
-                    grid.getCell(0,2),
-                    grid.getCell(1,0),
-                    grid.getCell(1,2),
-                    grid.getCell(2,0),
-                    grid.getCell(2,1),
-                    grid.getCell(2,2)));
-  }
-
-  @Test
-  public void testCountAliveNeighbours(){
-    assertThat(grid.countAliveNeighbours(1,1), is(equalTo(0)));
-    grid.getCell(2,2).setState(CellState.ALIVE);
-    grid.getCell(0,0).setState(CellState.ALIVE);
-    assertThat(grid.countAliveNeighbours(1,1), is(equalTo(2)));
-  }
-
-
-}

src/test/java/model/NextGenerationInitializerTest.java

+package model;
+
+import matrix.Coordinate;
+import model.automata.GameOfLifeAutomaton;
+import model.automata.GameOfLifeState;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.util.Random;
+
+import static model.automata.GameOfLifeState.ALIVE;
+import static model.automata.GameOfLifeState.DEAD;
+import static org.junit.jupiter.api.Assertions.*;
+
+class NextGenerationInitializerTest {
+
+    private final CellularAutomatonSimulation<GameOfLifeState> simulation =
+            new CellularAutomatonSimulation<>(
+                    new GameOfLifeAutomaton(4,3),
+                    new Random()
+                    );
+    private final NextGenerationInitializer<GameOfLifeState> initializer =
+            new NextGenerationInitializer<>(this.simulation);
+
+    @BeforeEach
+    public void prepareSimulation() {
+        GameOfLifeState[][] state =
+                { { DEAD, DEAD, DEAD, DEAD }
+                , { ALIVE, ALIVE, DEAD, DEAD }
+                , { DEAD, DEAD, ALIVE, DEAD }
+                };
+        for (Coordinate coordinate : this.simulation) {
+            this.simulation.at(coordinate).set(state[coordinate.y()][coordinate.x()]);
+        }
+    }
+
+    @Test
+    void initialValueAt() {
+        assertEquals(DEAD, initializer.initialValueAt(Coordinate.of(0,1)));
+        assertEquals(ALIVE, initializer.initialValueAt(Coordinate.of(1,0)));
+        assertEquals(ALIVE, initializer.initialValueAt(Coordinate.of(1,1)));
+        assertEquals(ALIVE, initializer.initialValueAt(Coordinate.of(1,2)));
+        assertEquals(DEAD, initializer.initialValueAt(Coordinate.of(2,2)));
+    }
+
+    @Test
+    public void testWrapCoordinateInsideGrid() {
+        Coordinate coordinate = Coordinate.of(1, 1);
+        Coordinate wrapped = initializer.wrap(coordinate);
+        assertEquals(coordinate, wrapped);
+    }
+
+    @Test
+    public void testWrapCoordinateOutsideGrid() {
+        assertEquals(
+                Coordinate.of(0, 1),
+                initializer.wrap(Coordinate.of(4, 4))
+        );
+        assertEquals(
+                Coordinate.of(3, 2),
+                initializer.wrap(Coordinate.of(-1, 2))
+        );
+         assertEquals(
+                Coordinate.of(3, 2),
+                initializer.wrap(Coordinate.of(-1, -1))
+        );   }
+
+    @Test
+    public void testModuloPositive() {
+        int result = NextGenerationInitializer.modulo(7, 4);
+        assertEquals(3, result);
+    }
+
+    @Test
+    public void testModuloNegative() {
+        int result = NextGenerationInitializer.modulo(-7, 4);
+        assertEquals(1, result);
+    }
+
+
+}
\ No newline at end of file

src/test/java/model/StateTest.java

+package model;
+
+import org.junit.jupiter.api.Test;
+
+import java.util.List;
+
+import static model.State.count;
+import static org.junit.jupiter.api.Assertions.*;
+
+class StateTest {
+    @Test
+    public void testCountMethodWithInteger() {
+        List<Integer> neighbours = List.of(1, 2, 1, 3, 1);
+        int result = count(1, neighbours);
+        assertEquals(3, result);
+    }
+
+    @Test
+    public void testCountMethodWithString() {
+        List<String> neighbours = List.of("apple", "banana", "apple", "cherry", "apple");
+        int result = count("apple", neighbours);
+        assertEquals(3, result);
+    }
+
+    @Test
+    public void testCountMethodWithEmptyList() {
+        List<Double> neighbours = List.of();
+        int result = count(5.0, neighbours);
+        assertEquals(0, result);
+    }
+
+    @Test
+    public void testCountMethodWithNoMatchingElements() {
+        List<Character> neighbours = List.of('a', 'b', 'c');
+        int result = count('x', neighbours);
+        assertEquals(0, result);
+    }
+
+}
\ No newline at end of file

src/test/java/model/automata/GameOfLifeStateTest.java

+package model.automata;
+
+import javafx.scene.paint.Color;
+import model.State;
+import org.junit.jupiter.api.Test;
+
+import java.util.List;
+
+import static model.automata.GameOfLifeState.*;
+import static org.junit.jupiter.api.Assertions.*;
+
+class GameOfLifeStateTest {
+    @Test
+    public void testGetColor() {
+        assertEquals(Color.WHITE, DEAD.getColor());
+        assertEquals(Color.RED, ALIVE.getColor());
+    }
+
+    @Test
+    public void testNext() {
+        assertEquals(ALIVE.next(), DEAD);
+        assertEquals(DEAD.next(), ALIVE);
+    }
+
+    @Test
+    public void testAliveUpdate() {
+        // Test with three alive neighbors, should be ALIVE
+        List<GameOfLifeState> aliveNeighbors =
+                List.of(ALIVE, DEAD, ALIVE, DEAD, ALIVE);
+        assertEquals(ALIVE, ALIVE.update(aliveNeighbors));
+
+        // Test with two alive neighbors, should be ALIVE
+        List<GameOfLifeState> twoAliveNeighbors =
+                List.of(ALIVE, DEAD, ALIVE, DEAD, DEAD);
+        assertEquals(ALIVE, ALIVE.update(twoAliveNeighbors));
+
+        // Test with four alive neighbors, should be DEAD
+        List<GameOfLifeState> fourAliveNeighbors =
+                List.of(ALIVE, ALIVE, DEAD, ALIVE, ALIVE);
+        assertEquals(DEAD, ALIVE.update(fourAliveNeighbors));
+
+        // Test with zero alive neighbors, should be DEAD
+        List<GameOfLifeState> zeroAliveNeighbors =
+                List.of(DEAD, DEAD, DEAD, DEAD);
+        assertEquals(DEAD, ALIVE.update(zeroAliveNeighbors));
+    }
+
+    @Test
+    public void testDeadUpdate() {
+        // Test with three alive neighbors, should be ALIVE
+        List<GameOfLifeState> aliveNeighbors =
+                List.of(ALIVE, DEAD, ALIVE, DEAD, ALIVE);
+        assertEquals(ALIVE, DEAD.update(aliveNeighbors));
+
+        // Test with two alive neighbors, should be DEAD
+        List<GameOfLifeState> twoAliveNeighbors =
+                List.of(ALIVE, DEAD, ALIVE, DEAD, DEAD);
+        assertEquals(DEAD, DEAD.update(twoAliveNeighbors));
+
+        // Test with four alive neighbors, should be DEAD
+        List<GameOfLifeState> fourAliveNeighbors =
+                List.of(ALIVE, ALIVE, DEAD, ALIVE, ALIVE);
+        assertEquals(DEAD, DEAD.update(fourAliveNeighbors));
+
+        // Test with zero alive neighbors, should be DEAD
+        List<GameOfLifeState> zeroAliveNeighbors =
+                List.of(DEAD, DEAD, DEAD, DEAD);
+        assertEquals(DEAD, DEAD.update(zeroAliveNeighbors));
+    }
+}
\ No newline at end of file