add some tests

Author: h908714124

src/main/java/com/bernd/game/PointQueue.java

@@ -10,6 +10,7 @@ final class PointQueue {
   private final int capacity;
   private final int dim;
 
+  private boolean empty = true;
   private int write;
   private int read;
   private final int[] buffer;
@@ -24,24 +25,33 @@ private PointQueue(
   }
 
   static PointQueue create(int dim) {
-    // Assumption 1: All algorithms proceed from the starting point outward in a diamond shape.
-    // Assumption 2: The circumference of the diamond shape is not greater than 2 * dim + 1.
-    int capacity = 2 * dim + 1;
+    // Assumption:
+    // All algorithms proceed from the starting point outward in a diamond shape.
+    // The diamond contains at most two points per row, see testDiamond().
+    return byCapacity(dim, 2 * dim);
+  }
+
+  // visible for testing
+  static PointQueue byCapacity(int dim, int capacity) {
     return new PointQueue(capacity, dim, new int[divideUp(capacity, 2)]);
   }
 
   void offer(int x, int y) {
+    if (!empty && write == read) {
+      throw new RuntimeException("buffer overflow");
+    }
+    empty = false;
     int ptId = dim * y + x;
     set(ptId);
     write = (write + 1) % capacity;
-    if (write == read) {
-      throw new RuntimeException("buffer overflow");
-    }
   }
 
   int poll() {
     int ptId = get();
     read = (read + 1) % capacity;
+    if (read == write) {
+      empty = true;
+    }
     return ptId;
   }
 
@@ -60,6 +70,10 @@ private void set(int ptId) {
   }
 
   boolean isEmpty() {
-    return write == read;
+    return empty;
+  }
+
+  int dim() {
+    return dim;
   }
 }

src/main/java/com/bernd/game/PointSet.java

@@ -13,7 +13,7 @@ private PointSet(int dim, int[] points) {
   }
 
   static PointSet create(int dim) {
-    return new PointSet(dim, new int[divideUp(dim * dim, 0x11)]);
+    return new PointSet(dim, new int[divideUp(dim * dim, 0x20)]);
   }
 
   void add(int x, int y) {

src/test/java/com/bernd/game/CountTest.java

@@ -1,5 +1,6 @@
 package com.bernd.game;
 
+import java.util.concurrent.ThreadLocalRandom;
 import org.junit.jupiter.api.Test;
 
 import static com.bernd.game.Board.B;
@@ -160,15 +161,24 @@ void testCountLargeArea() {
 
   @Test
   void testNoBufferOverflow() {
-    // fails if the assumption in PointQueue is incorrect
+    // fails if the capacity assumption in PointQueue is wrong
     for (int dim = 1; dim < 40; dim++) {
-      int[][] board = createEmptyBoard(dim);
-      int result = Count.getImpliedColor(board, dim / 2, dim / 2);
-      assertEquals(0, result);
+      assertEquals(0, Count.getImpliedColor(
+          createEmptyBoard(dim),
+          dim / 2,
+          dim / 2));
+      assertEquals(0, Count.getImpliedColor(
+          createEmptyBoard(dim),
+          0,
+          0));
+      assertEquals(0, Count.getImpliedColor(
+          createEmptyBoard(dim),
+          ThreadLocalRandom.current().nextInt(dim),
+          ThreadLocalRandom.current().nextInt(dim)));
     }
   }
 
-  private static int[][] createEmptyBoard(int dim) {
+  static int[][] createEmptyBoard(int dim) {
     int[][] board = new int[dim][];
     for (int i = 0; i < board.length; i++) {
       board[i] = new int[dim];

src/test/java/com/bernd/game/PointQueueTest.java

@@ -1,38 +1,97 @@
 package com.bernd.game;
 
+import com.bernd.util.Util;
 import org.junit.jupiter.api.Test;
 
+import static com.bernd.game.CountTest.createEmptyBoard;
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
 class PointQueueTest {
 
   @Test
-  void testOffer() {
+  void testOfferAndPoll() {
     int dim = 4;
     PointQueue queue = PointQueue.create(dim);
-    assertTrue(queue.isEmpty());
     queue.offer(0, 1);
     queue.offer(1, 2);
-    int pid = queue.poll();
-    assertFalse(queue.isEmpty());
-    int x = pid % dim;
-    int y = pid / dim;
-    assertEquals(0, x);
-    assertEquals(1, y);
+    poll(queue, 0, 1);
     queue.offer(2, 3);
-    pid = queue.poll();
-    assertFalse(queue.isEmpty());
-    x = pid % dim;
-    y = pid / dim;
-    assertEquals(1, x);
-    assertEquals(2, y);
-    pid = queue.poll();
-    x = pid % dim;
-    y = pid / dim;
-    assertEquals(2, x);
-    assertEquals(3, y);
+    poll(queue, 1, 2);
+    poll(queue, 2, 3);
     assertTrue(queue.isEmpty());
   }
+
+  @Test
+  void testFullCapacity() {
+    PointQueue queue = PointQueue.byCapacity(2, 4);
+    queue.offer(0, 0);
+    queue.offer(0, 1);
+    queue.offer(1, 0);
+    queue.offer(1, 1);
+    poll(queue, 0, 0);
+    poll(queue, 0, 1);
+    poll(queue, 1, 0);
+    poll(queue, 1, 1);
+    assertTrue(queue.isEmpty());
+  }
+
+  @Test
+  void testCapacityExceeded() {
+    PointQueue queue = PointQueue.byCapacity(2, 3);
+    queue.offer(0, 0);
+    queue.offer(0, 1);
+    queue.offer(1, 0);
+    assertThrows(RuntimeException.class, () -> queue.offer(1, 1));
+  }
+
+  @Test
+  void testDiamond() {
+    int dim = 5;
+    int[][] board = createEmptyBoard(dim);
+    PointQueue pointsToCheck = PointQueue.create(dim);
+    pointsToCheck.offer(2, 2);
+    for (int i = 0; i < 9; i++) {
+      int ptId = pointsToCheck.poll();
+      int y = ptId / dim;
+      int x = ptId % dim;
+      board[y][x] = 2;
+      if (y > 0 && board[y - 1][x] == 0) {
+        board[y - 1][x] = 1;
+        pointsToCheck.offer(x, y - 1);
+      }
+      if (y < dim - 1 && board[y + 1][x] == 0) {
+        board[y + 1][x] = 1;
+        pointsToCheck.offer(x, y + 1);
+      }
+      if (x > 0 && board[y][x - 1] == 0) {
+        board[y][x - 1] = 1;
+        pointsToCheck.offer(x - 1, y);
+      }
+      if (x < dim - 1 && board[y][x + 1] == 0) {
+        board[y][x + 1] = 1;
+        pointsToCheck.offer(x + 1, y);
+      }
+    }
+    // After 9 iterations, the diamond contains exactly two points per row.
+    assertArrayEquals(new int[][]{
+        new int[]{0, 1, 2, 1, 0},
+        new int[]{1, 2, 2, 2, 1},
+        new int[]{1, 2, 2, 2, 1},
+        new int[]{0, 1, 2, 1, 0},
+        new int[]{0, 1, 2, 1, 0},
+    }, board, () -> Util.boardToString(board));
+  }
+
+  private void poll(PointQueue queue, int expect_x, int expect_y) {
+    assertFalse(queue.isEmpty());
+    int ptId = queue.poll();
+    int x = ptId % queue.dim();
+    int y = ptId / queue.dim();
+    assertEquals(expect_x, x);
+    assertEquals(expect_y, y);
+  }
 }

src/test/java/com/bernd/game/PointSetTest.java

@@ -28,4 +28,17 @@ void testBig() {
     assertFalse(pointSet.has(10, 11));
     assertFalse(pointSet.has(11, 10));
   }
+
+  @Test
+  void testFullCapacity() {
+    int dim = 64;
+    PointSet pointSet = PointSet.create(dim);
+    for (int x = 0; x < dim; x++) {
+      for (int y = 0; y < dim; y++) {
+        assertFalse(pointSet.has(x, y));
+        pointSet.add(x, y);
+        assertTrue(pointSet.has(x, y));
+      }
+    }
+  }
 }