src/main/java/model/ConstantCellInitializer.java

+package model;
+
+import matrix.Coordinate;
+import matrix.ListMatrix;
+import matrix.MatrixInitializer;
+
+/**
+ *  An initializer for {@link ListMatrix} of {@link Cell}s, where each cell is initialized to the
+ *  same value.
+ *
+ * @param <T> the type of content of each cell
+ */
+public class ConstantCellInitializer<T>  implements MatrixInitializer<Cell<T>> {
+    //TODO: ajouter la/les propriétes nécessaires
+
+    /** Make a new {@link MatrixInitializer} with cells containing a {@link Cell} with the same
+     * value.
+     *
+     * @param defaultValue the value stored in each cell.
+     */
+    public ConstantCellInitializer(T defaultValue) {
+        //TODO: à compléter
+    }
+
+    @Override
+    public Cell<T> initialValueAt(Coordinate coordinate) {
+        //TODO: à compléter
+        return null;
+    }
+}

src/main/java/model/GameOfLife.java

-package model;
-
-import javafx.animation.Animation;
-import javafx.animation.KeyFrame;
-import javafx.animation.Timeline;
-import javafx.beans.property.ReadOnlyLongProperty;
-import javafx.beans.property.ReadOnlyLongWrapper;
-import javafx.event.ActionEvent;
-import javafx.event.EventHandler;
-import javafx.util.Duration;
-
-import java.util.Random;
-
-import static java.util.Objects.requireNonNull;
-
-/**
- * {@link GameOfLife} instances run <i>The Game of Life</i>.
- */
-public class GameOfLife {
-
-    private final Random random = new Random();
-    private static final int PERIOD_IN_MILLISECONDS = 100;
-
-    private final Grid grid;
-    private final ReadOnlyLongWrapper generationNumber = new ReadOnlyLongWrapper();
-    private Timeline timeline;
-
-    /**
-     * Creates a new {@code GameOfLife} instance given the underlying {@link Grid}.
-     *
-     * @param grid the underlying {@link Grid}
-     * @throws NullPointerException if {@code grid} is {@code null}
-     */
-    public GameOfLife(Grid grid) {
-        this.grid = requireNonNull(grid, "grid is null");
-        updateTimeline();
-        grid.randomGeneration(random);
-    }
-
-    private void updateTimeline() {
-        Duration duration = new Duration(PERIOD_IN_MILLISECONDS);
-        EventHandler<ActionEvent> eventHandler = event -> next();
-        KeyFrame keyFrame = new KeyFrame(duration, eventHandler);
-        timeline = new Timeline(keyFrame);
-        timeline.setCycleCount(Animation.INDEFINITE);
-    }
-
-    /**
-     * Transitions into the next generationNumber.
-     */
-    private void next() {
-        grid.updateToNextGeneration();
-        generationNumber.set(getGenerationNumber() + 1);
-    }
-
-
-    /**
-     * Returns the current generationNumber.
-     *
-     * @return the current generationNumber
-     */
-    private long getGenerationNumber() {
-        return generationNumber.get();
-    }
-
-    /**
-     * Returns the generationNumber {@link ReadOnlyLongProperty}.
-     *
-     * @return the generationNumber {@link ReadOnlyLongProperty}
-     */
-    public ReadOnlyLongProperty generationNumberProperty() {
-        return generationNumber.getReadOnlyProperty();
-    }
-
-    /**
-     * Returns the {@link Grid}.
-     *
-     * @return the {@link Grid}
-     */
-    public Grid getGrid() {
-        return grid;
-    }
-
-    /**
-     * Plays the game.
-     */
-    public void play() {
-        timeline.play();
-    }
-
-    /**
-     * Pauses the game.
-     */
-    public void pause() {
-        timeline.pause();
-    }
-
-    /**
-     * Clears the current game.
-     */
-    public void clear() {
-        pause();
-        grid.clear();
-        generationNumber.set(0);
-    }
-
-    /**
-     * Clears the current game and randomly generates a new one.
-     */
-    public void reset() {
-        clear();
-        grid.randomGeneration(random);
-    }
-
-}

src/main/java/model/Grid.java

-package model;
-
-import java.util.Iterator;
-import java.util.List;
-import java.util.Random;
-
-
-/**
- * {@link Grid} instances represent the grid in <i>The Game of Life</i>.
- */
-public class Grid implements Iterable<Cell> {
-
-    private final int numberOfRows;
-    private final int numberOfColumns;
-    private final Cell[][] cells;
-
-    /**
-     * Creates a new {@code Grid} instance given the number of rows and columns.
-     *
-     * @param numberOfRows    the number of rows
-     * @param numberOfColumns the number of columns
-     * @throws IllegalArgumentException if {@code numberOfRows} or {@code numberOfColumns} are
-     *                                  less than or equal to 0
-     */
-    public Grid(int numberOfRows, int numberOfColumns) {
-        this.numberOfRows = numberOfRows;
-        this.numberOfColumns = numberOfColumns;
-        this.cells = createCells();
-    }
-
-    /**
-     * Returns an iterator over the cells in this {@code Grid}.
-     *
-     * @return an iterator over the cells in this {@code Grid}
-     */
-
-    @Override
-    public Iterator<Cell> iterator() {
-        return new GridIterator(this);
-    }
-
-    private Cell[][] createCells() {
-        Cell[][] cells = new Cell[getNumberOfRows()][getNumberOfColumns()];
-        for (int rowIndex = 0; rowIndex < getNumberOfRows(); rowIndex++) {
-            for (int columnIndex = 0; columnIndex < getNumberOfColumns(); columnIndex++) {
-                cells[rowIndex][columnIndex] = new Cell();
-            }
-        }
-        return cells;
-    }
-
-    /**
-     * Returns the {@link Cell} at the given index.
-     *
-     * <p>Note that the index is wrapped around so that a {@link Cell} is always returned.
-     *
-     * @param rowIndex    the row index of the {@link Cell}
-     * @param columnIndex the column index of the {@link Cell}
-     * @return the {@link Cell} at the given row and column index
-     */
-    public Cell getCell(int rowIndex, int columnIndex) {
-        return cells[getWrappedRowIndex(rowIndex)][getWrappedColumnIndex(columnIndex)];
-    }
-
-    private int getWrappedRowIndex(int rowIndex) {
-        return (rowIndex + getNumberOfRows()) % getNumberOfRows();
-    }
-
-    private int getWrappedColumnIndex(int columnIndex) {
-        return (columnIndex + getNumberOfColumns()) % getNumberOfColumns();
-    }
-
-    /**
-     * Returns the number of rows in this {@code Grid}.
-     *
-     * @return the number of rows in this {@code Grid}
-     */
-    public int getNumberOfRows() {
-        return numberOfRows;
-    }
-
-    /**
-     * Returns the number of columns in this {@code Grid}.
-     *
-     * @return the number of columns in this {@code Grid}
-     */
-    public int getNumberOfColumns() {
-        return numberOfColumns;
-    }
-
-
-    // TODO: Écrire une version correcte de cette méthode.
-    public List<Cell> getNeighbors(int rowIndex, int columnIndex) {
-        return null;
-    }
-
-    // TODO: Écrire une version correcte de cette méthode.
-    public int countAliveNeighbors(int rowIndex, int columnIndex) {
-        return 0;
-    }
-
-    // TODO: Écrire une version correcte de cette méthode.
-    public CellState calculateNextState(int rowIndex, int columnIndex) {
-        return null;
-    }
-
-
-
-    // TODO: Écrire une version correcte de cette méthode.
-    public CellState[][] calculateNextStates() {
-        CellState[][] nextCellState = new CellState[getNumberOfRows()][getNumberOfColumns()];
-        return nextCellState;
-    }
-
-    // TODO: Écrire une version correcte de cette méthode.
-    public void updateStates(CellState[][] nextState) {
-
-    }
-
-    /**
-     * Transitions all {@link Cell}s in this {@code Grid} to the next generation.
-     *
-     * <p>The following rules are applied:
-     * <ul>
-     * <li>Any live {@link Cell} with fewer than two live neighbours dies, i.e. underpopulation.</li>
-     * <li>Any live {@link Cell} with two or three live neighbours lives on to the next
-     * generation.</li>
-     * <li>Any live {@link Cell} with more than three live neighbours dies, i.e. overpopulation.</li>
-     * <li>Any dead {@link Cell} with exactly three live neighbours becomes a live cell, i.e.
-     * reproduction.</li>
-     * </ul>
-     */
-    // TODO: Écrire une version correcte de cette méthode.
-    public void updateToNextGeneration() {
-
-    }
-
-    /**
-     * Sets all {@link Cell}s in this {@code Grid} as dead.
-     */
-    // TODO: Écrire une version correcte de cette méthode.
-    public void clear() {
-
-    }
-
-    /**
-     * Goes through each {@link Cell} in this {@code Grid} and randomly sets its state as ALIVE or DEAD.
-     *
-     * @param random {@link Random} instance used to decide if each {@link Cell} is ALIVE or DEAD.
-     * @throws NullPointerException if {@code random} is {@code null}.
-     */
-    // TODO: Écrire une version correcte de cette méthode.
-    public void randomGeneration(Random random) {
-
-    }
-}

src/main/java/model/GridIterator.java

-package model;
-
-import java.util.Iterator;
-
-/**
- * {@link GridIterator} instances are used to iterate over the cells of a grid.
- */
-public class GridIterator implements Iterator<Cell> {
-    private int rowIndex;
-    private int columnIndex;
-    private final Grid grid;
-
-    GridIterator(Grid grid) {
-        this.rowIndex = 0;
-        this.columnIndex = 0;
-        this.grid = grid;
-    }
-
-    @Override
-    public boolean hasNext() {
-        return columnIndex < grid.getNumberOfColumns() && rowIndex < grid.getNumberOfRows();
-    }
-
-    @Override
-    public Cell next() {
-        final Cell result = grid.getCell(rowIndex, columnIndex);
-        columnIndex = (columnIndex +1) % grid.getNumberOfColumns();
-        if(columnIndex == 0){
-            rowIndex++;
-        }
-        return result;
-    }
-}

src/main/java/model/Lens.java

+package model;
+
+/**
+ * A lens interface representing a view into a mutable state.
+ *
+ * @param <S> The type of the value stored in the lens.
+ */
+public interface Lens<S> {
+    /**
+     * Gets the value from the {@link Lens}.
+     *
+     * @return The value stored in the place designated by {@link Lens}.
+     */
+    S get();
+
+    /**
+     * Sets a new value into the {@link Lens}.
+     *
+     * @param value The new value to set in the place designated by the {@link Lens}.
+     */
+    void set(S value);
+}

src/main/java/model/NextGenerationInitializer.java

+package model;
+
+import matrix.Coordinate;
+import matrix.MatrixInitializer;
+import matrix.ListMatrix;
+import controller.Simulation;
+
+/**
+ * An initializer for a {@link ListMatrix} of states, where each state is computed based on the value
+ * of its neighbours in a {@link Simulation} of a cellular automaton.
+ *
+ * @param <S> the type of states in the simulation.
+ */
+public class NextGenerationInitializer<S extends State<S>> implements MatrixInitializer<S> {
+
+    //TODO: ajouter les propriétés nécessaires
+
+    /** Create a {@link MatrixInitializer} to compute the next generation in
+     * a 2D cellular automaton.
+     *
+     * @param simulation the {@link Simulation} representing the cellular automaton.
+     */
+    public NextGenerationInitializer(CellularAutomatonSimulation<S> simulation) {
+        //TODO: à compléter
+    }
+
+    @Override
+    public S initialValueAt(Coordinate coordinate) {
+        //TODO: à compléter
+        return null;
+    }
+
+    /** Computes the grid {@link Coordinate} for an arbitrary {@link Coordinate}, even outside
+     * the grid. This is done by considering that the grid wraps over its edges, connecting the left side to the right
+     * side, and the top side to the bottom side. This way, every cell has 4 orthogonal
+     * neighbours and 4 diagonal neighbours.
+     *
+     * @param coordinate a {@link Coordinate} that may be outside the grid.
+     * @return a corresponding {@link Coordinate}, that is inside the grid.
+     */
+    Coordinate wrap(Coordinate coordinate) {
+        //TODO: à compléter
+        //Il faut recalculer les coordonnées x et y modulo les dimensions de la grille.
+        //Pour le modulo, utiliser la fonction ci-dessous, qui s'assure que le résultat est positif.
+        return null;
+    }
+
+    /** The non-negative remainder of n divided by d.
+     *
+     * @param n an arbitrary integer.
+     * @param d a non-zero integer.
+     * @return the remainder of {@code n/d}, between {@code 0} and {@code n-1}.
+     */
+    static int modulo(int n, int d) {
+        int result = n % d;
+        return n < 0 ? result + d : result;
+    }
+}

src/main/java/model/OnChangeListener.java

+package model;
+
+public interface OnChangeListener<T> {
+    void valueChanged(T oldValue, T newValue);
+}

src/main/java/model/State.java

+package model;
+
+import javafx.scene.paint.Color;
+
+import java.util.List;
+
+/**
+ * Represents a state of a cell in a cellular automaton, and the update rules for the cellular
+ * automaton.
+ *
+ * @param <S> The type of the state itself, used for reflexivity: if a class {@code SomeState}
+ *          wants to implement this interface, it should implement {@code State<SomeState>}.
+ */
+public interface State<S> {
+
+    /**
+     * Returns the color associated with this state.
+     *
+     * @return The color representing this state.
+     */
+    Color getColor();
+
+    /**
+     * Computes and returns the next state based on the rules of the cellular automaton.
+     *
+     * @return The next state.
+     */
+    S next();
+
+    /**
+     * Updates the state based on the states of its neighboring cells.
+     *
+     * @param neighbours A list of neighboring cell states.
+     * @return The updated state based on the neighbors.
+     */
+    S update(List<S> neighbours);
+
+    /**
+     * Counts the occurrences of a specific state within a list of neighboring states.
+     *
+     * @param <T>       The type of state to count.
+     * @param state     The state to count occurrences of.
+     * @param neighbours A list of neighboring states to search within.
+     * @return The number of times the specified state appears in the list of neighbors.
+     */
+    static <T> int count(T state, List<T> neighbours) {
+        //TODO: à compléter
+        return 0;
+    }
+}
\ No newline at end of file

src/main/java/model/automata/GameOfLifeAutomaton.java

+package model.automata;
+
+import model.CellularAutomaton;
+
+import java.util.Random;
+
+public class GameOfLifeAutomaton implements CellularAutomaton<GameOfLifeState> {
+
+    public GameOfLifeAutomaton(int numberOfColumns, int numberOfRows) {
+        //TODO: à compléter
+    }
+
+    @Override
+    public int numberOfColumns() {
+        //TODO: à compléter
+        return 0;
+    }
+
+    @Override
+    public int numberOfRows() {
+        //TODO: à compléter
+        return 0;
+    }
+
+    @Override
+    public GameOfLifeState defaultState() {
+        //TODO: à compléter
+        return null;
+    }
+
+    @Override
+    public GameOfLifeState randomState(Random generator) {
+        //TODO: à compléter
+        return null;
+    }
+}

src/main/java/model/automata/GameOfLifeState.java

+package model.automata;
+
+import javafx.scene.paint.Color;
+import model.State;
+
+import java.util.List;
+
+/**
+ * {@link GameOfLifeState} instances represent the possible states of a {@link GameOfLifeState}.
+ */
+public enum GameOfLifeState implements State<GameOfLifeState> {
+    ALIVE, DEAD;
+
+
+    @Override
+    public Color getColor() {
+        //TODO: à compléter
+        return Color.BLACK;
+    }
+
+    @Override
+    public GameOfLifeState next() {
+        //TODO: à compléter
+        return null;
+    }
+
+    @Override
+    public GameOfLifeState update(List<GameOfLifeState> neighbours) {
+        //TODO: à compléter
+        return null;
+    }
+
+}

src/main/java/view/FillingMouseListener.java

+package view;
+
+import matrix.Coordinate;
+import javafx.scene.input.MouseEvent;
+
+public class FillingMouseListener implements MouseListener {
+    private final MatrixPane matrix;
+    private final Coordinate source;
+
+
+    public FillingMouseListener(MatrixPane matrix, Coordinate source) {
+        this.matrix = matrix;
+        this.source = source;
+    }
+
+    @Override
+    public void onMouseReleased(MouseEvent event, Coordinate coordinate) {
+        this.matrix.resetWaitingListener();
+    }
+
+    @Override
+    public void onMouseEntered(MouseEvent event, Coordinate destination) {
+        if (!event.isPrimaryButtonDown()) {
+            this.matrix.resetWaitingListener();
+            return;
+        }
+        this.matrix.getController().getSimulation().copy(source, destination);
+    }
+
+    @Override
+    public void onMousePressed(MouseEvent event, Coordinate coordinate) {
+        this.matrix.getController().getSimulation().next(coordinate);
+        this.matrix.setMouseListener(
+                new FillingMouseListener(this.matrix, coordinate)
+        );
+    }
+
+}

src/main/java/view/MatrixPane.java

 package view;
 
+import controller.Controller;
+import matrix.Coordinate;
+import javafx.scene.input.MouseDragEvent;
 import javafx.scene.input.MouseEvent;
 import javafx.scene.layout.GridPane;
+import javafx.scene.paint.Color;
 import javafx.scene.shape.Rectangle;
-import model.Cell;
-import model.CellState;
-import model.Grid;
 
 /**
  * Created by Arnaud Labourel on 22/11/2018.
@@ -13,32 +14,70 @@ import model.Grid;
 public class MatrixPane extends GridPane {
     private static final double CELL_SIZE = 14;
 
-    public void initialize(Grid grid) {
-        for (int rowIndex = 0; rowIndex < grid.getNumberOfRows(); rowIndex++) {
-            for (int columnIndex = 0; columnIndex < grid.getNumberOfColumns(); columnIndex++) {
-                addCellRectangle(grid.getCell(rowIndex,columnIndex), rowIndex, columnIndex);
+    public Controller getController() {
+        return controller;
     }
+
+    private Controller controller;
+
+    public void initialize(Controller controller) {
+        this.controller = controller;
+        for (Coordinate coordinate : controller.coordinates()) {
+            addCellRectangle(coordinate);
         }
     }
 
-    private void addCellRectangle(Cell cell, int rowIndex, int columnIndex) {
+    private void addCellRectangle(Coordinate coord) {
         Rectangle rectangleCell = new Rectangle(CELL_SIZE, CELL_SIZE);
-        addStatePropertyListener(cell, rectangleCell);
-        updateFill(rectangleCell, cell.getState());
-        addClickEventHandler(cell, rectangleCell);
-        add(rectangleCell, columnIndex, rowIndex);
+        addStatePropertyListener(rectangleCell, coord);
+        updateFill(rectangleCell, coord);
+        addEventHandler(rectangleCell, coord);
+        add(rectangleCell, coord);
+    }
+
+    private void add(Rectangle rectangleCell, Coordinate coord) {
+        this.add(rectangleCell, coord.x(), coord.y());
+    }
+
+    private void addStatePropertyListener(Rectangle cellRectangle, Coordinate coord) {
+        controller.getSimulation().setChangeListener(
+                coord,
+                () -> updateFill(cellRectangle, coord)
+        );
     }
 
-    private void addStatePropertyListener(Cell cell, Rectangle cellRectangle) {
-        cell.getStateProperty().addListener((observable, oldValue, newValue) ->
-                updateFill(cellRectangle, newValue));
+    private void updateFill(Rectangle cellRectangle, Coordinate coord) {
+        Color color = this.controller.getSimulation().getColor(coord);
+        cellRectangle.setFill(color);
     }
 
-    private void updateFill(Rectangle cellRectangle, CellState newCellState) {
-        cellRectangle.setFill(newCellState.color);
+    private void addEventHandler(Rectangle cellRectangle, Coordinate coord) {
+
+        cellRectangle.addEventHandler(
+                MouseEvent.MOUSE_PRESSED,
+                event -> mouseListener.onMousePressed(event, coord)
+        );
+        cellRectangle.addEventHandler(
+                MouseEvent.DRAG_DETECTED,
+                event -> this.startFullDrag()
+        );
+        cellRectangle.addEventHandler(
+                MouseDragEvent.MOUSE_DRAG_RELEASED,
+                event -> mouseListener.onMouseReleased(event, coord)
+        );
+        cellRectangle.addEventHandler(
+                MouseDragEvent.MOUSE_DRAG_ENTERED,
+                event -> mouseListener.onMouseEntered(event, coord)
+        );
+    }
+
+    private MouseListener mouseListener = new WaitingMouseListener(this);
+
+    void setMouseListener(MouseListener mouseListener) {
+        this.mouseListener = mouseListener;
     }
 
-    private void addClickEventHandler(Cell cell, Rectangle cellRectangle) {
-        cellRectangle.addEventHandler(MouseEvent.MOUSE_CLICKED, event -> cell.toggleState());
+    void resetWaitingListener() {
+        this.mouseListener = new WaitingMouseListener(this);
     }
 }

src/main/java/view/MouseListener.java

+package view;
+
+import matrix.Coordinate;
+import javafx.scene.input.MouseEvent;
+
+interface MouseListener {
+
+    default void onMousePressed(MouseEvent event, Coordinate coordinate) {}
+    default void onMouseReleased(MouseEvent event, Coordinate coordinate) {}
+    default void onMouseEntered(MouseEvent event, Coordinate coordinate) {};
+
+
+}

src/main/java/view/WaitingMouseListener.java

+package view;
+
+import matrix.Coordinate;
+import javafx.scene.input.MouseEvent;
+
+class WaitingMouseListener implements MouseListener {
+
+
+    private final MatrixPane matrix;
+
+    WaitingMouseListener(MatrixPane matrix) {
+        this.matrix = matrix;
+    }
+
+    @Override
+    public void onMousePressed(MouseEvent event, Coordinate coordinate) {
+        this.matrix.getController().getSimulation().next(coordinate);
+        this.matrix.setMouseListener(new FillingMouseListener(this.matrix, coordinate));
+    }
+
+
+}

src/main/resources/view/view.fxml

 <?xml version="1.0" encoding="UTF-8"?>
 
 <?import javafx.geometry.Insets?>
-<?import javafx.scene.control.Button?>
-<?import javafx.scene.control.Label?>
-<?import javafx.scene.control.Separator?>
-<?import javafx.scene.control.ToggleButton?>
-<?import javafx.scene.layout.AnchorPane?>
-<?import javafx.scene.layout.GridPane?>
-<?import javafx.scene.layout.HBox?>
-
+<?import javafx.scene.control.*?>
+<?import javafx.scene.layout.*?>
 <?import view.MatrixPane?>
 <AnchorPane maxHeight="1.7976931348623157E308" maxWidth="1.7976931348623157E308"
             styleClass="background" stylesheets="@style.css"

src/test/java/matrix/ConstantMatrixInitializerTest.java

+package matrix;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class ConstantMatrixInitializerTest {
+    @Test
+    public void testMatrixInitializationWithConstantValue() {
+        ListMatrix<String> matrix = new ListMatrix<>(3, 3, new ConstantMatrixInitializer<>("X"));
+
+        // Test that all cells have the constant value.
+        for (int x = 0; x < 3; x++) {
+            for (int y = 0; y < 3; y++) {
+                assertEquals("X", matrix.get(x, y));
+            }
+        }
+    }
+
+    @Test
+    public void testMatrixInitializationWithConstantValue2() {
+        ListMatrix<Integer> matrix = new ListMatrix<>(3, 5, new ConstantMatrixInitializer<>(12));
+
+        // Test that all cells have the constant value.
+        for (int x = 0; x < 3; x++) {
+            for (int y = 0; y < 5; y++) {
+                assertEquals(12, matrix.get(x, y));
+            }
+        }
+    }
+}
\ No newline at end of file

src/test/java/matrix/CoordinateIteratorTest.java

+package matrix;
+
+import org.junit.jupiter.api.Test;
+
+import java.util.NoSuchElementException;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class CoordinateIteratorTest {
+
+    @Test
+    public void testIteratorWithZeroDimensions() {
+        CoordinateIterator iterator = new CoordinateIterator(0, 0);
+        assertFalse(iterator.hasNext());
+    }
+
+    @Test
+    public void testIteratorWithOneDimension() {
+        CoordinateIterator iterator = new CoordinateIterator(5, 1);
+        assertTrue(iterator.hasNext());
+        assertEquals(Coordinate.of(0, 0), iterator.next());
+        assertTrue(iterator.hasNext());
+        assertEquals(Coordinate.of(1, 0), iterator.next());
+        assertTrue(iterator.hasNext());
+        assertEquals(Coordinate.of(2, 0), iterator.next());
+        assertTrue(iterator.hasNext());
+        assertEquals(Coordinate.of(3, 0), iterator.next());
+        assertTrue(iterator.hasNext());
+        assertEquals(Coordinate.of(4, 0), iterator.next());
+        assertFalse(iterator.hasNext());
+        assertThrows(NoSuchElementException.class, iterator::next);
+    }
+
+    @Test
+    public void testIteratorWithTwoDimensions() {
+        CoordinateIterator iterator = new CoordinateIterator(3, 2);
+        assertTrue(iterator.hasNext());
+        assertEquals(Coordinate.of(0, 0), iterator.next());
+        assertTrue(iterator.hasNext());
+        assertEquals(Coordinate.of(1, 0), iterator.next());
+        assertTrue(iterator.hasNext());
+        assertEquals(Coordinate.of(2, 0), iterator.next());
+        assertTrue(iterator.hasNext());
+        assertEquals(Coordinate.of(0, 1), iterator.next());
+        assertTrue(iterator.hasNext());
+        assertEquals(Coordinate.of(1, 1), iterator.next());
+        assertTrue(iterator.hasNext());
+        assertEquals(Coordinate.of(2, 1), iterator.next());
+        assertFalse(iterator.hasNext());
+        assertThrows(NoSuchElementException.class, iterator::next);
+    }
+
+}
\ No newline at end of file

src/test/java/matrix/CoordinateTest.java

+package matrix;
+
+import org.junit.jupiter.api.Test;
+
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+public class CoordinateTest {
+    @Test
+    public void testCoordinateCreation() {
+        Coordinate coordinate = Coordinate.of(3, 4);
+        assertEquals(3, coordinate.x());
+        assertEquals(4, coordinate.y());
+    }
+
+    @Test
+    public void testLeft() {
+        Coordinate coordinate = Coordinate.of(3, 4);
+        Coordinate left = coordinate.left();
+        assertEquals(2, left.x());
+        assertEquals(4, left.y());
+    }
+
+    @Test
+    public void testRight() {
+        Coordinate coordinate = Coordinate.of(3, 4);
+        Coordinate right = coordinate.right();
+        assertEquals(4, right.x());
+        assertEquals(4, right.y());
+    }
+
+    @Test
+    public void testAbove() {
+        Coordinate coordinate = Coordinate.of(3, 4);
+        Coordinate above = coordinate.above();
+        assertEquals(3, above.x());
+        assertEquals(5, above.y());
+    }
+
+    @Test
+    public void testBelow() {
+        Coordinate coordinate = Coordinate.of(3, 4);
+        Coordinate below = coordinate.below();
+        assertEquals(3, below.x());
+        assertEquals(3, below.y());
+    }
+
+    @Test
+    public void testOrthogonalNeighbours() {
+        Coordinate coordinate = Coordinate.of(3, 4);
+        List<Coordinate> neighbours = coordinate.orthogonalNeighbours();
+        assertEquals(4, neighbours.size());
+        assertTrue(neighbours.contains(Coordinate.of(2, 4)));
+        assertTrue(neighbours.contains(Coordinate.of(4, 4)));
+        assertTrue(neighbours.contains(Coordinate.of(3, 3)));
+        assertTrue(neighbours.contains(Coordinate.of(3, 5)));
+        assertFalse(neighbours.contains(coordinate));
+        assertFalse(neighbours.contains(Coordinate.of(1, 4)));
+        assertFalse(neighbours.contains(Coordinate.of(5, 4)));
+        assertFalse(neighbours.contains(Coordinate.of(3, 6)));
+        assertFalse(neighbours.contains(Coordinate.of(3, 1)));
+    }
+
+    @Test
+    public void testDiagonalNeighbours() {
+        Coordinate coordinate = Coordinate.of(3, 4);
+        List<Coordinate> neighbours = coordinate.diagonalNeighbours();
+        assertEquals(4, neighbours.size());
+        assertTrue(neighbours.contains(Coordinate.of(2, 3)));
+        assertTrue(neighbours.contains(Coordinate.of(4, 3)));
+        assertTrue(neighbours.contains(Coordinate.of(2, 5)));
+        assertTrue(neighbours.contains(Coordinate.of(4, 5)));
+        assertFalse(neighbours.contains(coordinate));
+        assertFalse(neighbours.contains(Coordinate.of(1, 4)));
+        assertFalse(neighbours.contains(Coordinate.of(5, 4)));
+        assertFalse(neighbours.contains(Coordinate.of(3, 6)));
+        assertFalse(neighbours.contains(Coordinate.of(3, 1)));
+    }
+
+    @Test
+    public void testOrthodiagonalNeighbours() {
+        Coordinate coordinate = Coordinate.of(3, 4);
+        List<Coordinate> neighbours = coordinate.orthodiagonalNeighbours();
+        assertEquals(8, neighbours.size());
+        assertTrue(neighbours.contains(Coordinate.of(2, 4)));
+        assertTrue(neighbours.contains(Coordinate.of(4, 4)));
+        assertTrue(neighbours.contains(Coordinate.of(3, 3)));
+        assertTrue(neighbours.contains(Coordinate.of(3, 5)));
+        assertTrue(neighbours.contains(Coordinate.of(2, 3)));
+        assertTrue(neighbours.contains(Coordinate.of(4, 3)));
+        assertTrue(neighbours.contains(Coordinate.of(2, 5)));
+        assertTrue(neighbours.contains(Coordinate.of(4, 5)));
+        assertFalse(neighbours.contains(coordinate));
+        assertFalse(neighbours.contains(Coordinate.of(1, 4)));
+        assertFalse(neighbours.contains(Coordinate.of(5, 4)));
+        assertFalse(neighbours.contains(Coordinate.of(3, 6)));
+        assertFalse(neighbours.contains(Coordinate.of(3, 1)));
+    }
+}
\ No newline at end of file

src/test/java/matrix/ListMatrixTest.java

+package matrix;
+
+import org.junit.jupiter.api.Test;
+
+import java.util.Iterator;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class ListMatrixTest {
+
+    private final MatrixInitializer<Integer> sumInitializer =
+            coord -> coord.x() + coord.y();
+
+    @Test
+    public void testMatrixCreationWithInitializer() {
+        ListMatrix<Integer> matrix = new ListMatrix<>(3, 4, sumInitializer);
+        assertEquals(3, matrix.width());
+        assertEquals(4, matrix.height());
+        assertEquals(4, matrix.get(2, 2));
+        assertEquals(3, matrix.get(1, 2));
+        assertEquals(3, matrix.get(2, 1));
+        assertEquals(2, matrix.get(1, 1));
+    }
+
+    @Test
+    public void testMatrixCreationWithInitialValue() {
+        ListMatrix<String> matrix = new ListMatrix<>(2, 2, "Foo");
+        assertEquals(2, matrix.width());
+        assertEquals(2, matrix.height());
+        assertEquals("Foo", matrix.get(1, 1)); // Test a specific cell value.
+    }
+
+    @Test
+    public void testMatrixSetAndGet() {
+        ListMatrix<Integer> matrix = new ListMatrix<>(3, 3, 0);
+        matrix.set(1, 1,42);
+        assertEquals(42, matrix.get(1, 1));
+        matrix.set(0, 2,10);
+        assertEquals(10, matrix.get(0, 2));
+        matrix.set(Coordinate.of(2, 2),99);
+        assertEquals(99, matrix.get(Coordinate.of(2, 2)));
+    }
+
+    @Test
+    public void testMatrixWidthAndHeight() {
+        ListMatrix<String> matrix = new ListMatrix<>(4, 2, "A");
+        assertEquals(4, matrix.width());
+        assertEquals(2, matrix.height());
+        matrix.set(3, 1,"B");
+        assertEquals(4, matrix.width());
+        assertEquals(2, matrix.height());
+    }
+
+    @Test
+    public void testMatrixIterator() {
+        ListMatrix<Integer> matrix = new ListMatrix<>(2, 2, sumInitializer);
+        Iterator<Integer> iterator = matrix.iterator();
+        assertTrue(iterator.hasNext());
+        assertEquals(0, iterator.next());
+        assertTrue(iterator.hasNext());
+        assertEquals(1, iterator.next());
+        assertTrue(iterator.hasNext());
+        assertEquals(1, iterator.next());
+        assertTrue(iterator.hasNext());
+        assertEquals(2, iterator.next());
+        assertFalse(iterator.hasNext());
+    }
+
+    @Test
+    public void testMatrixCoordinates() {
+        ListMatrix<Integer> matrix = new ListMatrix<>(2, 2, 0);
+        Iterable<Coordinate> coordinates = matrix.coordinates();
+        int count = 0;
+        for (Coordinate coord : coordinates) {
+            count++;
+        }
+        assertEquals(4, count);
+    }
+
+
+    @Test
+    public void testSubMatrix() {
+      Matrix<Integer> matrix = new ListMatrix<>(5, 5, 0);
+      for (int x = 0; x < 5; x++) {
+        for (int y = 0; y < 5; y++) {
+          matrix.set(x,y,x + y * 5);
+        }
+      }
+      Matrix<Integer> sub = matrix.subMatrix(Coordinate.of(2,1),2,3);
+      assertEquals(2, sub.width());
+      assertEquals(3, sub.height());
+      for (int x = 2; x < 4; x++) {
+        for (int y = 1; y < 4; y++) {
+          assertEquals(x + y * 5, sub.get(x-2,y-1));
+        }
+      }
+    }
+
+
+}

src/test/java/model/CellTest.java

+package model;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class CellTest {
+
+    private record Change<T>(T oldValue, T newValue) {}
+    private static class MockListener<T> implements OnChangeListener<T> {
+        private Change<T> lastChange = null;
+
+        public boolean checksLastChange(T oldValue, T newValue) {
+            return this.lastChange != null
+                    && this.lastChange.oldValue.equals(oldValue)
+                    && this.lastChange.newValue.equals(newValue);
+        }
+
+        @Override
+        public void valueChanged(T oldValue, T newValue) {
+            lastChange = new Change<>(oldValue, newValue);
+        }
+    }
+    @Test
+    public void testCellValueChangeWithListener() {
+        Cell<Integer> cell = new Cell<>(42);
+        MockListener<Integer> mockListener = new MockListener<>();
+        cell.addOnChangeListener(mockListener);
+        cell.set(99);
+        assertTrue(mockListener.checksLastChange(42, 99));
+        assertEquals(99, cell.get());
+    }
+
+    @Test
+    public void testCellWithoutListener() {
+        Cell<String> cell = new Cell<>("Foo");
+        cell.set("Bar");
+        assertEquals("Bar", cell.get());
+    }
+}
\ No newline at end of file