Tests and Javadox, thanks chatGPT

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

@@ -5,14 +5,13 @@ 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 ON -> Color.GOLD;
             case OFF -> Color.BLACK;
         };
     }
@@ -29,7 +28,7 @@ public enum SeedsState implements State<SeedsState> {
     public SeedsState update(List<State<SeedsState>> neighbours) {
         return switch (this) {
             case ON -> OFF;
-            case OFF -> countList(ON,neighbours) == 2 ? ON: OFF;
+            case OFF -> State.count(ON,neighbours) == 2 ? ON: OFF;
         };
     }
 

src/main/java/view/FillingMouseListener.java

@@ -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

@@ -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

@@ -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

@@ -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/datastruct/ConstantMatrixInitializerTest.java

+package datastruct;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class ConstantMatrixInitializerTest {
+    @Test
+    public void testMatrixInitializationWithConstantValue() {
+        Matrix<String> matrix = new Matrix<>(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() {
+        Matrix<Integer> matrix = new Matrix<>(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/datastruct/CoordinateIteratorTest.java

+package datastruct;
+
+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/datastruct/CoordinateTest.java

+package datastruct;
+
+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/datastruct/MatrixTest.java

+package datastruct;
+
+import org.junit.jupiter.api.Test;
+
+import java.util.Iterator;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class MatrixTest {
+
+    private final MatrixInitializer<Integer> sumInitializer =
+            coord -> coord.x() + coord.y();
+
+    @Test
+    public void testMatrixCreationWithInitializer() {
+        Matrix<Integer> matrix = new Matrix<>(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() {
+        Matrix<String> matrix = new Matrix<>(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() {
+        Matrix<Integer> matrix = new Matrix<>(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() {
+        Matrix<String> matrix = new Matrix<>(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() {
+        Matrix<Integer> matrix = new Matrix<>(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() {
+        Matrix<Integer> matrix = new Matrix<>(2, 2, 0);
+        Iterable<Coordinate> coordinates = matrix.coordinates();
+        int count = 0;
+        for (Coordinate coord : coordinates) {
+            count++;
+        }
+        assertEquals(4, count);
+    }
+
+    @Test
+    public void testMatrixLens() {
+        Matrix<Integer> matrix = new Matrix<>(2, 2, 0);
+        Lens<Integer> lens = matrix.at(1, 1);
+        assertEquals(0, lens.get());
+        lens.set(42);
+        assertEquals(42, matrix.get(1, 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

src/test/java/model/CellularAutomatonSimulationTest.java

+package model;
+
+import datastruct.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.assertj.core.api.Assertions.assertThat;
-
-public class GridTest {
-  private CellGrid grid;
-
-//  @BeforeEach
-//  public void initializeGrid() {
-//    grid = new CellGrid(6, 6);
-//  }
-//
-//  @Test
-//  public void testGetNeighbours() {
-//    assertThat(grid.getNeighbors(1, 1)).isNotNull();
-//    assertThat(grid.getNeighbors(1, 1)).hasSize(8);
-//    assertThat(grid.getNeighbors(1, 1))
-//            .containsExactlyInAnyOrder(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.countAliveNeighbors(1, 1)).isEqualTo(0);
-//    grid.getCell(2, 2).setState(CellState.ALIVE);
-//    grid.getCell(0, 0).setState(CellState.ALIVE);
-//    assertThat(grid.countAliveNeighbors(1, 1)).isEqualTo(2);
-//  }
-//
-//  @Test
-//  public void testCalculateNextState() {
-//    grid.getCell(1, 0).setState(CellState.ALIVE);
-//    grid.getCell(1, 1).setState(CellState.ALIVE);
-//    grid.getCell(1, 2).setState(CellState.ALIVE);
-//    assertThat(grid.calculateNextState(0, 0).isAlive).isFalse();
-//    assertThat(grid.calculateNextState(1, 0).isAlive).isFalse();
-//    assertThat(grid.calculateNextState(1, 1).isAlive).isTrue();
-//    assertThat(grid.calculateNextState(2, 1).isAlive).isTrue();
-//  }
-
-}
\ 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<State<GameOfLifeState>> aliveNeighbors =
+                List.of(ALIVE, DEAD, ALIVE, DEAD, ALIVE);
+        assertEquals(ALIVE, ALIVE.update(aliveNeighbors));
+
+        // Test with two alive neighbors, should be ALIVE
+        List<State<GameOfLifeState>> twoAliveNeighbors =
+                List.of(ALIVE, DEAD, ALIVE, DEAD, DEAD);
+        assertEquals(ALIVE, ALIVE.update(twoAliveNeighbors));
+
+        // Test with four alive neighbors, should be DEAD
+        List<State<GameOfLifeState>> fourAliveNeighbors =
+                List.of(ALIVE, ALIVE, DEAD, ALIVE, ALIVE);
+        assertEquals(DEAD, ALIVE.update(fourAliveNeighbors));
+
+        // Test with zero alive neighbors, should be DEAD
+        List<State<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<State<GameOfLifeState>> aliveNeighbors =
+                List.of(ALIVE, DEAD, ALIVE, DEAD, ALIVE);
+        assertEquals(ALIVE, DEAD.update(aliveNeighbors));
+
+        // Test with two alive neighbors, should be DEAD
+        List<State<GameOfLifeState>> twoAliveNeighbors =
+                List.of(ALIVE, DEAD, ALIVE, DEAD, DEAD);
+        assertEquals(DEAD, DEAD.update(twoAliveNeighbors));
+
+        // Test with four alive neighbors, should be DEAD
+        List<State<GameOfLifeState>> fourAliveNeighbors =
+                List.of(ALIVE, ALIVE, DEAD, ALIVE, ALIVE);
+        assertEquals(DEAD, DEAD.update(fourAliveNeighbors));
+
+        // Test with zero alive neighbors, should be DEAD
+        List<State<GameOfLifeState>> zeroAliveNeighbors =
+                List.of(DEAD, DEAD, DEAD, DEAD);
+        assertEquals(DEAD, DEAD.update(zeroAliveNeighbors));
+    }
+}
\ No newline at end of file