src/main/java/model/CellularAutomataSimulation.java

-package model;
-
-import controller.Simulation;
-import datastruct.Coordinate;
-import javafx.beans.property.ReadOnlyLongProperty;
-import javafx.beans.property.ReadOnlyLongWrapper;
-import javafx.scene.paint.Color;
-
-import java.util.Iterator;
-import java.util.function.Supplier;
-
-import static java.util.Objects.requireNonNull;
-
-/**
- * {@link CellularAutomataSimulation} instances run <i>The Game of Life</i>.
- */
-public class CellularAutomataSimulation<S extends State<S>>
-        implements Simulation {
-
-    private final CellGrid<S> grid;
-    private final Supplier<S> supplier;
-    private final S defaultState;
-    private final ReadOnlyLongWrapper generationNumber = new ReadOnlyLongWrapper();
-
-    /**
-     * Creates a new {@code GameOfLife} instance given the underlying {@link CellGrid}.
-     *
-     * @param grid     the underlying {@link CellGrid}
-     * @param defaultState   the state value to use when clearing the grid
-     * @param supplier  a {@Link Supplier} to produce values to initialize or reset the grid
-     * @throws NullPointerException if {@code grid} is {@code null}
-     */
-    public CellularAutomataSimulation(CellGrid<S> grid, S defaultState, Supplier<S> supplier) {
-        this.grid = requireNonNull(grid, "grid is null");
-        this.supplier = requireNonNull(supplier, "supplier is null");
-        this.defaultState = requireNonNull(defaultState, "defaultState is null");
-        grid.fillRandomly(this.supplier);
-    }
-
-
-
-    @Override
-    public int numberOfColumns() {
-        return this.grid.getNumberOfColumns();
-    }
-
-    @Override
-    public int numberOfRows() {
-        return this.grid.getNumberOfRows();
-    }
-
-    /**
-     * Transitions into the next generationNumber.
-     */
-    @Override
-    public void updateToNextGeneration() {
-        grid.updateToNextGeneration();
-        generationNumber.set(getGenerationNumber() + 1);
-    }
-
-    @Override
-    public void next(Coordinate coordinate) {
-        this.grid.cellAt(coordinate).toggleState();
-    }
-
-    @Override
-    public void copy(Coordinate source, Coordinate destination) {
-        S state = this.grid.at(source).get();
-        this.grid.at(destination).set(state);
-    }
-
-    @Override
-    public Color getColor(Coordinate coordinate) {
-        return this.grid.at(coordinate).get().getColor();
-    }
-
-    @Override
-    public void setChangeListener(Coordinate coordinate, Runnable runnable) {
-        this.grid.cellAt(coordinate).getStateProperty().addListener(
-                (obs,oldV,newV) -> runnable.run()
-        );
-    }
-
-
-    /**
-     * 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();
-    }
-
-
-    /**
-     * Clears the current game.
-     */
-    public void clear() {
-        grid.clear(defaultState);
-        generationNumber.set(0);
-    }
-
-    /**
-     * Clears the current game and randomly generates a new one.
-     */
-    public void reset() {
-        clear();
-        grid.fillRandomly(supplier);
-    }
-
-    @Override
-    public Iterator<Coordinate> iterator() {
-        return this.grid.coordinates().iterator();
-    }
-}

src/main/java/model/CellularAutomaton.java

+package model;
+
+import java.util.Random;
+
+/**
+ * Represents a cellular automaton, which defines the main parameters of a cellular automaton.
+ * The rules for updating states are defined in the class used as {@code S}.
+ *
+ * @param <S> The type of state used in the cellular automaton.
+ */
+public interface CellularAutomaton<S extends State<S>> {
+
+    /**
+     * Returns the number of columns in the grid of the cellular automaton.
+     *
+     * @return The number of columns in the grid.
+     */
+    int numberOfColumns();
+
+    /**
+     * Returns the number of rows in the grid of the cellular automaton.
+     *
+     * @return The number of rows in the grid.
+     */
+    int numberOfRows();
+
+    /**
+     * Returns the default state that is used to initialize cells in the automaton.
+     *
+     * @return The default state for cells in the automaton.
+     */
+    S defaultState();
+
+
+    /**
+     * Generates a random state using the specified random number generator.
+     *
+     * @param generator The random number generator to use.
+     * @return A randomly generated state.
+     */
+    S randomState(Random generator);
+}
\ No newline at end of file

src/main/java/model/CellularAutomatonSimulation.java

+package model;
+
+import controller.Simulation;
+import matrix.Coordinate;
+import matrix.ListMatrix;
+import javafx.scene.paint.Color;
+
+import java.util.Iterator;
+import java.util.Random;
+
+
+
+/**
+ * {@link CellularAutomatonSimulation} instances run <i>The Game of Life</i>.
+ *
+ *  @param <S> The type of state used in the simulation.
+ */
+public class CellularAutomatonSimulation<S extends State<S>>
+        implements Simulation {
+
+    private final ListMatrix<Cell<S>> grid;
+    private final Cell<Integer> generationNumber = new Cell<>(0);
+    private final CellularAutomaton<S> automaton;
+    private final Random generator;
+
+    /**
+     * Creates a new {@link CellularAutomatonSimulation} instance for a given automaton.
+     *
+     * @param automaton  A description of the {@link CellularAutomaton}.
+     * @param generator  The {@link Random} instance used for random state generation.
+     */
+    public CellularAutomatonSimulation(CellularAutomaton<S> automaton, Random generator) {
+        this.automaton = automaton;
+        this.grid = new ListMatrix<>(
+                automaton.numberOfColumns(),
+                automaton.numberOfRows(),
+                new ConstantCellInitializer<>(automaton.defaultState())
+        );
+        this.generator = generator;
+    }
+
+
+    @Override
+    public int numberOfColumns() {
+        //TODO: à compléter
+        return 0;
+    }
+
+    @Override
+    public int numberOfRows() {
+        //TODO: à compléter
+        return 0;
+    }
+
+    /**
+     * Returns the {@link Cell} at the specified coordinate.
+     *
+     * @param coordinate The coordinate of the cell to retrieve.
+     * @return The cell at the specified coordinate.
+     */
+    public Cell<S> at(Coordinate coordinate) {
+        //TODO: à compléter
+        return null;
+    }
+
+    @Override
+    public void updateToNextGeneration() {
+        //TODO: à compléter, en utilisant nextGenerationMatrix()
+    }
+
+    /** Computes the {@link ListMatrix} of states obtained after a single step of updates
+     * of the simulation.
+     *
+     * @return the states of each cell after one generation
+     */
+    private ListMatrix<S> nextGenerationMatrix() {
+        //TODO: à compléter
+        return null;
+    }
+    @Override
+    public void next(Coordinate coordinate) {
+        //TODO: à compléter
+    }
+
+    @Override
+    public void copy(Coordinate source, Coordinate destination) {
+        //TODO: à compléter
+    }
+
+    @Override
+    public Color getColor(Coordinate coordinate) {
+        //TODO: à compléter
+        return null;
+    }
+
+    @Override
+    public void setChangeListener(Coordinate coordinate, Runnable listener) {
+        this.at(coordinate).addOnChangeListener(
+                (oldValue, newValue) -> listener.run()
+        );
+    }
+
+    @Override
+    public void setGenerationNumberChangeListener(OnChangeListener<Integer> listener){
+        this.generationNumber.addOnChangeListener(listener);
+    }
+
+
+    @Override
+    public void clear() {
+        //TODO: à compléter (penser à remettre le nombre de génération à 0)
+    }
+
+
+    @Override
+    public void reset() {
+        //TODO: à compléter (penser à remettre le nombre de génération à 0)
+    }
+
+    @Override
+    public Iterator<Coordinate> iterator() {
+        return this.grid.coordinates().iterator();
+    }
+}

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/GameOfLifeState.java

-package model;
-
-import javafx.scene.paint.Color;
-
-import java.util.List;
-import java.util.Random;
-
-/**
- * {@link GameOfLifeState} instances represent the possible states of a {@link GameOfLifeState}.
- */
-public enum GameOfLifeState implements State<GameOfLifeState> {
-    ALIVE(Color.RED),
-    DEAD(Color.WHITE);
-
-    public final Color color;
-
-    GameOfLifeState(Color color) {
-        this.color = color;
-    }
-
-    @Override
-    public Color getColor() {
-        return this.color;
-    }
-
-    @Override
-    public GameOfLifeState next() {
-        return GameOfLifeState.values()[1 - this.ordinal()];
-    }
-
-    @Override
-    public GameOfLifeState update(List<State<GameOfLifeState>> neighbours) {
-        int countAlive = 0;
-        for (State<GameOfLifeState> state : neighbours) {
-            if (state.equals(ALIVE)) {
-                countAlive++;
-            }
-        }
-        boolean isAlive =
-                (this == DEAD && 3 == countAlive)
-                || (this == ALIVE && 2 <= countAlive && countAlive <= 3);
-        return isAlive ? ALIVE : DEAD;
-    }
-
-    private static final Random randomGen = new Random();
-    public static GameOfLifeState random() {
-        return randomGen.nextBoolean() ? ALIVE : DEAD;
-    }
-}

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/OneStepMatrixInitializer.java

-package model;
-
-import datastruct.Coordinate;
-import datastruct.MatrixInitializer;
-
-import java.util.ArrayList;
-import java.util.List;
-
-public class OneStepMatrixInitializer<S extends State<S>> implements MatrixInitializer<S> {
-
-    private final CellGrid<S> grid;
-
-    public OneStepMatrixInitializer(CellGrid<S> grid) {
-        this.grid = grid;
-    }
-
-    @Override
-    public S initialValueAt(Coordinate coordinate) {
-        List<State<S>> neighbours = new ArrayList<>();
-        for (Coordinate neighbourCoord : coordinate.orthodiagonalNeighbours()) {
-            neighbours.add(this.grid.cellAtWrapped(neighbourCoord).getState());
-        }
-        S state = this.grid.cellAt(coordinate).getState();
-        return state.update(neighbours);
-    }
-}

src/main/java/model/State.java

@@ -4,12 +4,47 @@ 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();
 
-    S update(List<State<S>> neighbours);
+    /**
+     * 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 datastruct.Coordinate;
+import matrix.Coordinate;
 import javafx.scene.input.MouseEvent;
 
 public class FillingMouseListener implements MouseListener {
@@ -14,7 +14,7 @@ public class FillingMouseListener implements MouseListener {
     }
 
     @Override
-    public void onMouseReleased(MouseEvent event, Coordinate coord) {
+    public void onMouseReleased(MouseEvent event, Coordinate coordinate) {
         this.matrix.resetWaitingListener();
     }
 
@@ -34,4 +34,5 @@ public class FillingMouseListener implements MouseListener {
                 new FillingMouseListener(this.matrix, coordinate)
         );
     }
+
 }

src/main/java/view/MatrixPane.java

 package view;
 
 import controller.Controller;
-import datastruct.Coordinate;
+import matrix.Coordinate;
 import javafx.scene.input.MouseDragEvent;
 import javafx.scene.input.MouseEvent;
 import javafx.scene.layout.GridPane;
@@ -52,6 +52,7 @@ public class MatrixPane extends GridPane {
     }
 
     private void addEventHandler(Rectangle cellRectangle, Coordinate coord) {
+
         cellRectangle.addEventHandler(
                 MouseEvent.MOUSE_PRESSED,
                 event -> mouseListener.onMousePressed(event, coord)

src/main/java/view/MouseListener.java

 package view;
 
-import datastruct.Coordinate;
+import matrix.Coordinate;
 import javafx.scene.input.MouseEvent;
 
 interface MouseListener {
@@ -9,4 +9,5 @@ interface MouseListener {
     default void onMouseReleased(MouseEvent event, Coordinate coordinate) {}
     default void onMouseEntered(MouseEvent event, Coordinate coordinate) {};
 
+
 }

src/main/java/view/WaitingMouseListener.java

 package view;
 
-import datastruct.Coordinate;
+import matrix.Coordinate;
 import javafx.scene.input.MouseEvent;
 
 class WaitingMouseListener implements MouseListener {
@@ -13,8 +13,10 @@ class WaitingMouseListener implements MouseListener {
     }
 
     @Override
-    public void onMousePressed(MouseEvent event, Coordinate coord) {
-       this.matrix.getController().getSimulation().next(coord);
-        matrix.setMouseListener(new FillingMouseListener(this.matrix, coord));
+    public void onMousePressed(MouseEvent event, Coordinate coordinate) {
+        this.matrix.getController().getSimulation().next(coordinate);
+        this.matrix.setMouseListener(new FillingMouseListener(this.matrix, coordinate));
     }
+
+
 }

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));
+        }
+      }
+    }
+
+
+}