src/main/java/dotsandboxes/DotsAndBoxesGrid.java

 package dotsandboxes;
 
-
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.function.Consumer;
@@ -25,11 +24,13 @@ import java.util.function.Consumer;
  * - for each column, there are as many horizontals as there are corner dots.
  * - for each column, there is one less box than the number of corner dots
  *
- * For example, in this (4, 3) grid, there are (3, 3) horizontal lines, and (4, 2) vertical lines, and (3, 2) boxes.
+ * For example, in this (4, 3) grid, there are (3, 3) horizontal lines, and (4,
+ * 2) vertical lines, and (3, 2) boxes.
  *
  * We number all lines and boxes by their top-left coordinate.
  *
- * In Java 14+, we might use a Record class for this, but we're using 11+ as an LTS version, so we don't have that yet.
+ * In Java 14+, we might use a Record class for this, but we're using 11+ as an
+ * LTS version, so we don't have that yet.
  */
 public class DotsAndBoxesGrid {
 
@@ -50,6 +51,7 @@ public class DotsAndBoxesGrid {
 
     final int players;
     private int player = 1;
+
     public int getPlayer() {
         return player;
     }
@@ -98,9 +100,9 @@ public class DotsAndBoxesGrid {
         return boxOwners[x][y];
     }
 
-
     /**
      * Checks whether a box has been fully drawn (all four sides)
+     * 
      * @param x coordinate of the left side of the box
      * @param y coordinate of the top of the box
      * @return true if all four sides have been drawn.
@@ -110,12 +112,20 @@ public class DotsAndBoxesGrid {
             return false;
         }
 
-        // A box is complete if the north and south horizontals and the east and west verticals have all been drawn.
+        // A box is complete if the north and south horizontals and the east and west
+        // verticals have all been drawn.
         // FIXME: You'll need to fix this code (after writing a test first).
-        return true;
+        // Check if all four sides are drawn
+        return horizontals[x][y] && // North
+                horizontals[x][y + 1] && // South
+                verticals[x][y] && // West
+                verticals[x + 1][y]; // East
     }
 
-    /** Tries to claim a box for a player. If the box is complete, sets the ownership and returns true. */
+    /**
+     * Tries to claim a box for a player. If the box is complete, sets the ownership
+     * and returns true.
+     */
     private boolean claimBox(int x, int y, int p) {
         if (boxComplete(x, y)) {
             boxOwners[x][y] = player;
@@ -126,20 +136,28 @@ public class DotsAndBoxesGrid {
     }
 
     /**
-     * "Draws" a horizontal line, from grid point (x, y) to (x + 1, y). (i.e. sets that line to true)
+     * "Draws" a horizontal line, from grid point (x, y) to (x + 1, y). (i.e. sets
+     * that line to true)
+     * 
      * @param x
      * @param y
      * @return true if it completes a box
      */
     public boolean drawHorizontal(int x, int y, int player) {
         if (x >= width - 1 || x < 0) {
-            throw new IndexOutOfBoundsException(String.format("x was %d, which is out of range. Range is 0 to %d", x, width - 1));
+            throw new IndexOutOfBoundsException(
+                    String.format("x was %d, which is out of range. Range is 0 to %d", x, width - 1));
         }
         if (y >= height || y < 0) {
-            throw new IndexOutOfBoundsException(String.format("y was %d, which is out of range. Range is 0 to %d", y, height));
+            throw new IndexOutOfBoundsException(
+                    String.format("y was %d, which is out of range. Range is 0 to %d", y, height));
         }
 
         // FIXME: You need to throw an exception if the line was already drawn.
+        // Check if the line was already drawn
+        if (this.horizontals[x][y]) {
+            throw new IllegalStateException("Line already drawn");
+        }
 
         this.horizontals[x][y] = true;
 
@@ -157,20 +175,28 @@ public class DotsAndBoxesGrid {
     }
 
     /**
-     * "Draws" a vertical line, from grid point (x, y) to (x, y + 1). (i.e. sets that line to true)
+     * "Draws" a vertical line, from grid point (x, y) to (x, y + 1). (i.e. sets
+     * that line to true)
+     * 
      * @param x
      * @param y
      * @return true if it completes a box
      */
     public boolean drawVertical(int x, int y, int player) {
         if (x >= width || x < 0) {
-            throw new IndexOutOfBoundsException(String.format("x was %d, which is out of range. Range is 0 to %d", x, width));
+            throw new IndexOutOfBoundsException(
+                    String.format("x was %d, which is out of range. Range is 0 to %d", x, width));
         }
         if (y >= height - 1 || y < 0) {
-            throw new IndexOutOfBoundsException(String.format("y was %d, which is out of range. Range is 0 to %d", y, height - 1));
+            throw new IndexOutOfBoundsException(
+                    String.format("y was %d, which is out of range. Range is 0 to %d", y, height - 1));
         }
 
         // You need to throw an exception if the line was already drawn.
+        // Check if the line was already drawn
+        if (this.verticals[x][y]) {
+            throw new IllegalStateException("Line already drawn");
+        }
 
         this.verticals[x][y] = true;
         // Try to claim the north or south boxes
@@ -188,10 +214,11 @@ public class DotsAndBoxesGrid {
     }
 
     public boolean gameComplete() {
-        // Students who took COSC250 might recognise this style of code. This is Java's version of higher order functions.
-        // The grid is complete if "for all rows, all the boxes in that row have a non-zero owner"
+        // Students who took COSC250 might recognise this style of code. This is Java's
+        // version of higher order functions.
+        // The grid is complete if "for all rows, all the boxes in that row have a
+        // non-zero owner"
         return Arrays.stream(boxOwners).allMatch((row) -> Arrays.stream(row).allMatch((owner) -> owner > 0));
     }
 
-
 }

src/test/java/dotsandboxes/DotsAndBoxesGridTest.java

@@ -9,14 +9,17 @@ import org.apache.logging.log4j.Logger;
 
 public class DotsAndBoxesGridTest {
     /*
-     * Because Test classes are classes, they can have fields, and can have static fields.
-     * This field is a logger. Loggers are like a more advanced println, for writing messages out to the console or a log file.
+     * Because Test classes are classes, they can have fields, and can have static
+     * fields.
+     * This field is a logger. Loggers are like a more advanced println, for writing
+     * messages out to the console or a log file.
      */
     private static final Logger logger = LogManager.getLogger(DotsAndBoxesGridTest.class);
 
     /*
      * Tests are functions that have an @Test annotation before them.
-     * The typical format of a test is that it contains some code that does something, and then one
+     * The typical format of a test is that it contains some code that does
+     * something, and then one
      * or more assertions to check that a condition holds.
      *
      * This is a dummy test just to show that the test suite itself runs
@@ -28,4 +31,42 @@ public class DotsAndBoxesGridTest {
     }
 
     // FIXME: You need to write tests for the two known bugs in the code.
+    @Test
+    public void testBoxComplete() {
+        DotsAndBoxesGrid grid = new DotsAndBoxesGrid(4, 3, 2);
+
+        // Draw lines around a single box
+        grid.drawHorizontal(0, 0, 1);
+        grid.drawHorizontal(0, 1, 1);
+        grid.drawVertical(0, 0, 1);
+        grid.drawVertical(1, 0, 1);
+
+        // Check if the box is complete
+        assertTrue(grid.boxComplete(0, 0));
+    }
+
+    @Test
+    public void testDrawHorizontalLineAlreadyDrawn() {
+        DotsAndBoxesGrid grid = new DotsAndBoxesGrid(4, 3, 2);
+
+        grid.drawHorizontal(0, 0, 1);
+
+        // Attempt to draw the same line again and expect an exception
+        assertThrows(IllegalStateException.class, () -> {
+            grid.drawHorizontal(0, 0, 1);
+        });
+    }
+
+    @Test
+    public void testDrawVerticalLineAlreadyDrawn() {
+        DotsAndBoxesGrid grid = new DotsAndBoxesGrid(4, 3, 2);
+
+        grid.drawVertical(0, 0, 1);
+
+        // Attempt to draw the same line again and expect an exception
+        assertThrows(IllegalStateException.class, () -> {
+            grid.drawVertical(0, 0, 1);
+        });
+    }
+
 }