src/main/java/model/ConstantCellInitializer.java

 package model;
 
-import datastruct.Coordinate;
-import datastruct.MatrixInitializer;
+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>> {
-    private final T defaultValue;
+    //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) {
-        this.defaultValue = defaultValue;
+        //TODO: à compléter
     }
 
     @Override
     public Cell<T> initialValueAt(Coordinate coordinate) {
-        return new Cell<>(defaultValue);
+        //TODO: à compléter
+        return null;
     }
 }

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 datastruct.Coordinate;
-import datastruct.Matrix;
-import datastruct.MatrixInitializer;
-
-import java.util.ArrayList;
-import java.util.List;
-
+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> {
 
-    private final CellularAutomatonSimulation<S> simulation;
+    //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) {
-        this.simulation = simulation;
+        //TODO: à compléter
     }
 
     @Override
     public S initialValueAt(Coordinate coordinate) {
-        List<State<S>> neighbours = new ArrayList<>();
-        for (Coordinate neighbourCoord : coordinate.orthodiagonalNeighbours()) {
-            Coordinate wrapped = wrap(neighbourCoord);
-            neighbours.add(this.simulation.at(wrapped).get());
-        }
-        S state = this.simulation.at(coordinate).get();
-        return state.update(neighbours);
+        //TODO: à compléter
+        return null;
     }
 
-    private Coordinate wrap(Coordinate coordinate) {
-        return new Coordinate(
-                modulo(coordinate.x(),this.simulation.numberOfColumns()),
-                modulo(coordinate.y(),this.simulation.numberOfRows())
-        );
+    /** 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.
@@ -39,7 +51,7 @@ public class NextGenerationInitializer<S extends State<S>> implements MatrixInit
      * @param d a non-zero integer.
      * @return the remainder of {@code n/d}, between {@code 0} and {@code n-1}.
      */
-    private static int modulo(int n, int d) {
+    static int modulo(int n, int d) {
         int result = n % d;
         return n < 0 ? result + d : result;
     }

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

-package model.automata;
-
-import model.CellularAutomaton;
-import model.State;
-
-public abstract class AbstractAutomaton<S extends State<S>> implements CellularAutomaton<S> {
-
-    private final int numberOfColumns;
-    private final int numberOfRows;
-
-
-    protected AbstractAutomaton(int numberOfColumns, int numberOfRows) {
-        this.numberOfColumns = numberOfColumns;
-        this.numberOfRows = numberOfRows;
-    }
-
-    public int numberOfColumns() {
-        return numberOfColumns;
-    }
-
-    public int numberOfRows() {
-        return numberOfRows;
-    }
-}

src/main/java/model/automata/BiColorAutomaton.java

-package model.automata;
-
-import model.CellularAutomaton;
-
-import java.util.Random;
-
-public class BiColorAutomaton extends AbstractAutomaton<BiColorState> {
-
-    public BiColorAutomaton(int numberOfColumns, int numberOfRows) {
-        super(numberOfColumns, numberOfRows);
-    }
-
-    @Override
-    public BiColorState defaultState() {
-        return BiColorState.DEAD;
-    }
-
-    @Override
-    public BiColorState randomState(Random generator) {
-        return generator.nextBoolean()? BiColorState.DEAD:
-                generator.nextBoolean()? BiColorState.RED:
-                        BiColorState.BLUE;
-    }
-
-}

src/main/java/model/automata/BiColorState.java

-package model.automata;
-
-import javafx.scene.paint.Color;
-import model.State;
-
-import java.util.List;
-import java.util.Random;
-
-public enum BiColorState implements State<BiColorState> {
-    BLUE, RED, DEAD;
-
-
-
-    @Override
-    public Color getColor() {
-        return switch (this) {
-            case BLUE -> Color.BLUE;
-            case RED -> Color.RED;
-            case DEAD -> Color.WHITE;
-        };
-    }
-
-    @Override
-    public BiColorState next() {
-        return switch (this) {
-            case BLUE -> RED;
-            case RED -> DEAD;
-            case DEAD -> BLUE;
-        };
-    }
-
-    @Override
-    public BiColorState update(List<State<BiColorState>> neighbours) {
-        int countBlue = 0;
-        int countRed = 0;
-        for (State<BiColorState> neighbour : neighbours) {
-            if (neighbour == RED) {
-                countRed++;
-            }
-            if (neighbour == BLUE) {
-                countBlue++;
-            }
-        }
-        if (this == DEAD) {
-            return (countBlue + countRed != 3)? DEAD:
-                    countBlue > countRed? BLUE:
-                            RED;
-        }
-        return 2 <= countBlue + countRed && countBlue + countRed <= 3? this:
-                DEAD;
-    }
-
-}

src/main/java/model/automata/BriansBrainAutomaton.java

-package model.automata;
-
-import java.util.Random;
-
-public class BriansBrainAutomaton extends AbstractAutomaton<BriansBrainState> {
-
-    public BriansBrainAutomaton(int numberOfColumns, int numberOfRows) {
-        super(numberOfColumns, numberOfRows);
-    }
-
-    @Override
-    public BriansBrainState defaultState() {
-        return BriansBrainState.OFF;
-    }
-
-    @Override
-    public BriansBrainState randomState(Random generator) {
-        return generator.nextInt(10) == 0 ?
-                 BriansBrainState.ON:
-                 BriansBrainState.OFF;
-    }
-}

src/main/java/model/automata/BriansBrainState.java

-package model.automata;
-
-import javafx.scene.paint.Color;
-import model.State;
-
-import java.util.List;
-import java.util.Random;
-
-public enum BriansBrainState implements State<BriansBrainState> {
-    ON, OFF, DYING;
-
-    @Override
-    public Color getColor() {
-        return switch (this) {
-            case ON -> Color.WHITE;
-            case OFF -> Color.BLACK;
-            case DYING -> Color.BLUE;
-        };
-    }
-
-    @Override
-    public BriansBrainState next() {
-        return switch (this) {
-            case ON -> DYING;
-            case OFF -> ON;
-            case DYING -> OFF;
-        };
-    }
-
-    @Override
-    public BriansBrainState update(List<State<BriansBrainState>> neighbours) {
-        return switch (this) {
-            case ON -> DYING;
-            case DYING -> OFF;
-            case OFF -> {
-                int count = countList(ON, neighbours);
-                yield count==2 ? ON : OFF;
-            }
-        };
-    }
-
-    static <T>  int countList(T value, List<T> elements) {
-        int count = 0;
-        for (T v : elements) {
-            if (v.equals(value)) {
-                count++;
-            }
-        }
-        return count;
-    }
-}

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

@@ -4,21 +4,33 @@ import model.CellularAutomaton;
 
 import java.util.Random;
 
-public class GameOfLifeAutomaton extends AbstractAutomaton<GameOfLifeState> {
+public class GameOfLifeAutomaton implements CellularAutomaton<GameOfLifeState> {
 
-    protected GameOfLifeAutomaton(int numberOfColumns, int numberOfRows) {
-        super(numberOfColumns, numberOfRows);
+    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() {
-        return GameOfLifeState.DEAD;
+        //TODO: à compléter
+        return null;
     }
 
     @Override
     public GameOfLifeState randomState(Random generator) {
-        return generator.nextBoolean()?
-                 GameOfLifeState.ALIVE:
-                 GameOfLifeState.DEAD;
+        //TODO: à compléter
+        return null;
     }
 }

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

@@ -4,43 +4,30 @@ import javafx.scene.paint.Color;
 import model.State;
 
 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);
+    ALIVE, DEAD;
 
-    public final Color color;
-
-    GameOfLifeState(Color color) {
-        this.color = color;
-    }
 
     @Override
     public Color getColor() {
-        return this.color;
+        //TODO: à compléter
+        return Color.BLACK;
     }
 
     @Override
     public GameOfLifeState next() {
-        return GameOfLifeState.values()[1 - this.ordinal()];
+        //TODO: à compléter
+        return null;
     }
 
     @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;
+    public GameOfLifeState update(List<GameOfLifeState> neighbours) {
+        //TODO: à compléter
+        return null;
     }
 
 }

src/main/java/model/automata/SeedsAutomaton.java

-package model.automata;
-
-import java.util.Random;
-
-public class SeedsAutomaton extends AbstractAutomaton<SeedsState> {
-    public SeedsAutomaton(int numberOfColumns, int numberOfRows) {
-        super(numberOfColumns, numberOfRows);
-    }
-
-    @Override
-    public SeedsState defaultState() {
-        return SeedsState.OFF;
-    }
-
-    @Override
-    public SeedsState randomState(Random generator) {
-        return generator.nextInt() == 0?
-                SeedsState.ON:
-                SeedsState.OFF;
-    }
-}

src/main/java/model/automata/SeedsState.java

-package model.automata;
-
-import javafx.scene.paint.Color;
-import model.State;
-
-import java.util.List;
-
-import static model.automata.BriansBrainState.countList;
-
-public enum SeedsState implements State<SeedsState> {
-    ON, OFF;
-    @Override
-    public Color getColor() {
-        return switch (this) {
-            case ON -> Color.WHITE;
-            case OFF -> Color.BLACK;
-        };
-    }
-
-    @Override
-    public SeedsState next() {
-        return switch (this) {
-            case ON -> OFF;
-            case OFF -> ON;
-        };
-    }
-
-    @Override
-    public SeedsState update(List<State<SeedsState>> neighbours) {
-        return switch (this) {
-            case ON -> OFF;
-            case OFF -> countList(ON,neighbours) == 2 ? ON: OFF;
-        };
-    }
-
-}

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