introduce bitloops

src/test/java/puzzle/MaskerCluesTest.java

@@ -0,0 +1,117 @@
+package puzzle;
+
+import module java.base;
+import org.junit.jupiter.api.Test;
+import static org.junit.jupiter.api.Assertions.*;
+import static puzzle.Masker.Clues;
+import static puzzle.SwedishGenerator.*;
+import static puzzle.Masker.Slot;
+
+public class MaskerCluesTest {
+
+    @Test
+    void testSimilarity() {
+        Clues a = Clues.createEmpty();
+        a.setClueLo(1L << 0, (byte) 1);
+        a.setClueLo(1L << 10, (byte) 0);
+        
+        Clues b = Clues.createEmpty();
+        b.setClueLo(1L << 0, (byte) 1);
+        b.setClueLo(1L << 10, (byte) 0);
+        
+        // Identity
+        assertEquals(1.0, a.similarity(b), 0.001);
+        
+        // Different direction
+        Clues c = Clues.createEmpty();
+        c.setClueLo(1L << 0, (byte) 0);
+        c.setClueLo(1L << 10, (byte) 0);
+        assertTrue(a.similarity(c) < 1.0);
+        
+        // Completely different
+        Clues d = Clues.createEmpty();
+        // Matching empty cells count towards similarity. 
+        // a has 2 clues, d has 0. They match on 70 empty cells.
+        assertEquals(70.0 / 72.0, a.similarity(d), 0.001);
+    }
+
+    @Test
+    void testIsValid() {
+        Clues g = Clues.createEmpty();
+        assertTrue(g.isValid(MIN_LEN));
+        
+        // Valid clue: Right from (0,0) in 9x8 grid. Length is 8.
+        g.setClueLo(1L << Masker.offset(0, 0), (byte) 1);
+        assertTrue(g.isValid(MIN_LEN));
+        
+        // Invalid clue: Right from (0,7) in 9x8 grid. Length is 1 (too short if MIN_LEN >= 2).
+        Clues g2 = Clues.createEmpty();
+        g2.setClueLo(1L << Masker.offset(0, 7), (byte) 1);
+        assertFalse(g2.isValid(MIN_LEN));
+    }
+
+    @Test
+    void testHasRoomForClue() {
+        Clues g = Clues.createEmpty();
+        
+        // Room for Right clue at (0,0) (length 8)
+        assertTrue(g.hasRoomForClue(Slot.packSlotKey(Masker.offset(0, 0), 1)));
+        
+        // No room for Right clue at (0,8) (length 0 < MIN_LEN)
+        assertFalse(g.hasRoomForClue(Slot.packSlotKey(Masker.offset(0, 8), 1)));
+        
+        // Blocked room
+        // Let's place a clue that leaves only 1 cell for another clue.
+        g.setClueLo(1L << Masker.offset(0, 2), (byte) 1);
+        // Now Right at (0,0) only has (0,1) available -> length 1 < MIN_LEN (which is 2)
+        assertFalse(g.hasRoomForClue(Slot.packSlotKey(Masker.offset(0, 0), 1)));
+        
+        // But enough room
+        g.clearClueLo(0L);
+        g.setClueLo(1L << Masker.offset(0, 3), (byte) 1);
+        // Now Right at (0,0) has (0,1), (0,2) -> length 2 == MIN_LEN
+        assertTrue(g.hasRoomForClue(Slot.packSlotKey(Masker.offset(0, 0), 1)));
+    }
+
+    @Test
+    void testIntersectionConstraint() {
+        Clues g = Clues.createEmpty();
+        
+        // Clue 1: (0,0) Right. Slot cells: (0,1), (0,2), (0,3), (0,4), (0,5), (0,6), (0,7), (0,8)
+        g.setClueLo(1L << Masker.offset(0, 0), (byte) 1);
+        
+        // Clue 2: (1,2) Up. Slot cells: (0,2)
+        // Intersection is exactly 1 cell (0,2). Valid.
+        g.setClueLo(1L << Masker.offset(2, 2), (byte) 2); 
+        assertTrue(g.isValid(MIN_LEN));
+        
+        // Clue 3: (1,1) Right. Slot cells: (1,2), (1,3), ...
+        // No intersection with Clue 1 or 2. Valid.
+        g.setClueLo(1L << Masker.offset(1, 1), (byte) 1);
+        assertTrue(g.isValid(MIN_LEN));
+        
+        // Now create a violation: two slots sharing 2 cells.
+        // We can do this with Corner Down and another clue.
+        // Clue A: (0,0) Corner Down. Starts at (0,1) goes down: (0,1), (1,1), (2,1), (3,1), ...
+        // Clue B: (0,2) Corner Down Left. Starts at (0,1) goes down: (0,1), (1,1), (2,1), ...
+        // They share MANY cells starting from (0,1).
+        
+        Clues g3 = Clues.createEmpty();
+        g3.setClueLo(1L << Masker.offset(0, 0), (byte) 4); // Corner Down
+        g3.setClueLo(1L << Masker.offset(0, 2), (byte) 5); // Corner Down Left
+        assertFalse(g3.isValid(MIN_LEN));
+    }
+
+    @Test
+    void testInvalidDirectionBits() {
+        Clues g = Clues.createEmpty();
+        // Dir 6 (x=1, r=1, v=0) is invalid
+        g.setClueLo(1L << 0, (byte) 6);
+        assertFalse(g.isValid(MIN_LEN));
+        
+        // Dir 7 (x=1, r=1, v=1) is invalid
+        Clues g2 = Clues.createEmpty();
+        g2.setClueLo(1L << 0, (byte) 7);
+        assertFalse(g2.isValid(MIN_LEN));
+    }
+}