Add test_puzzle

Author: DenHvideDvaerg

snake_mip_solver/puzzle.py

@@ -55,7 +55,7 @@ def __init__(self,
         self.end_cell = end_cell
 
         # Offset patterns for different types of tile relationships
-        self._adjacent_offsets = [(-1, 0), (1, 0), (0, -1), (0, 1)]
+        self._orthogonal_offsets = [(-1, 0), (1, 0), (0, -1), (0, 1)]
         self._diagonal_offsets = [(-1, -1), (-1, 1), (1, -1), (1, 1)]
 
         # Validate puzzle configuration
@@ -178,18 +178,17 @@ def _check_no_diagonal_touching(self, solution: Set[Tuple[int, int]]) -> bool:
 
             for diagonal_pos in diagonal_neighbors:
                 if diagonal_pos in solution:
-                    dr, dc = diagonal_pos
                     # Check if they are connected by orthogonal cells
                     # If there are orthogonal connections, diagonal touching is allowed
-                    orthogonal_connections = [
-                        (row - 1, col) in solution and (dr, col) in solution,  # vertical connection
-                        (row + 1, col) in solution and (dr, col) in solution,  # vertical connection
-                        (row, col - 1) in solution and (row, dc) in solution,  # horizontal connection
-                        (row, col + 1) in solution and (row, dc) in solution   # horizontal connection
-                    ]
+                    orthogonal_neighbors = self.get_tiles_by_offsets(position, self._orthogonal_offsets)
+                    diagonal_orthogonal_neighbors = self.get_tiles_by_offsets(diagonal_pos, self._orthogonal_offsets)
+                    
+                    # Check if there's an orthogonal path connecting the two diagonal cells
+                    shared_orthogonal = orthogonal_neighbors.intersection(diagonal_orthogonal_neighbors)
+                    orthogonal_connections = shared_orthogonal.intersection(solution)
 
                     # If diagonal cells touch but no orthogonal connection exists, it's invalid
-                    if not any(orthogonal_connections):
+                    if not orthogonal_connections:
                         return False
 
         return True
@@ -215,8 +214,8 @@ def _check_snake_path(self, solution: Set[Tuple[int, int]]) -> bool:
         # Count neighbors for each cell
         neighbor_count = {}
         for position in solution:
-            adjacent_neighbors = self.get_tiles_by_offsets(position, self._adjacent_offsets)
-            count = len(adjacent_neighbors.intersection(solution))
+            orthogonal_neighbors = self.get_tiles_by_offsets(position, self._orthogonal_offsets)
+            count = len(orthogonal_neighbors.intersection(solution))
             neighbor_count[position] = count
 
         # Check start and end cells have exactly 1 neighbor
@@ -239,15 +238,15 @@ def dfs(current):
                 return
             visited.add(current)
 
-            adjacent_neighbors = self.get_tiles_by_offsets(current, self._adjacent_offsets)
-            for neighbor in adjacent_neighbors:
+            orthogonal_neighbors = self.get_tiles_by_offsets(current, self._orthogonal_offsets)
+            for neighbor in orthogonal_neighbors:
                 if neighbor in solution and neighbor not in visited:
                     dfs(neighbor)
 
         # Start DFS from start_cell
         dfs(self.start_cell)
 
-        # All cells should be reachable from start, and end should be reachable
+        # All cells should be reachable from start
         return len(visited) == len(solution) and self.end_cell in visited
 
     def get_grid_size(self) -> Tuple[int, int]:

tests/test_puzzle.py

@@ -7,13 +7,133 @@ class TestSnakePuzzle:
 
     def test_basic_puzzle_creation(self):
         """Test creating a basic puzzle."""
-        # Example: Replace with your puzzle parameters
-        # puzzle = SnakePuzzle(size=5, constraints=[1, 2, 3])
+        # Test basic 3x3 puzzle with some constraints
+        row_sums = [2, None, 1]  # Row 0 needs 2 cells, row 1 unconstrained, row 2 needs 1 cell
+        col_sums = [1, 2, None]  # Col 0 needs 1 cell, col 1 needs 2 cells, col 2 unconstrained
+        start_cell = (0, 0)
+        end_cell = (2, 2)
 
-        # Basic instantiation should work with default template
-        puzzle = SnakePuzzle()
+        puzzle = SnakePuzzle(row_sums=row_sums, col_sums=col_sums, 
+                           start_cell=start_cell, end_cell=end_cell)
         assert puzzle is not None
 
-        # Once implemented, test basic properties:
-        # assert puzzle.size == 5
-        # assert len(puzzle.constraints) == 3
+        # Test basic properties
+        assert puzzle.rows == 3
+        assert puzzle.cols == 3
+        assert puzzle.row_sums == [2, None, 1]
+        assert puzzle.col_sums == [1, 2, None]
+        assert puzzle.get_grid_size() == (3, 3)
+        assert puzzle.get_start_cell() == (0, 0)
+        assert puzzle.get_end_cell() == (2, 2)
+        
+    def test_puzzle_validation(self):
+        """Test puzzle input validation."""
+        start_cell = (0, 0)
+        end_cell = (2, 2)
+        
+        # Test invalid dimensions (empty lists)
+        with pytest.raises(ValueError, match="Number of rows must be positive"):
+            SnakePuzzle([], [1, 2, 3], start_cell, end_cell)
+            
+        with pytest.raises(ValueError, match="Number of columns must be positive"):
+            SnakePuzzle([1, 2, 3], [], start_cell, end_cell)
+            
+        # Test invalid sum values
+        with pytest.raises(ValueError, match="Row 0 sum 5 must be between 0 and 3"):
+            SnakePuzzle([5, 1, 1], [1, 1, 1], start_cell, end_cell)
+            
+        with pytest.raises(ValueError, match="Column 1 sum -1 must be between 0 and 3"):
+            SnakePuzzle([1, 1, 1], [1, -1, 1], start_cell, end_cell)
+            
+        # Test invalid start/end cells
+        with pytest.raises(ValueError, match="Start cell .* is out of bounds"):
+            SnakePuzzle([1, 1, 1], [1, 1, 1], (3, 0), end_cell)
+            
+        with pytest.raises(ValueError, match="End cell .* is out of bounds"):
+            SnakePuzzle([1, 1, 1], [1, 1, 1], start_cell, (0, 3))
+            
+        with pytest.raises(ValueError, match="Start cell and end cell cannot be the same"):
+            SnakePuzzle([1, 1, 1], [1, 1, 1], (0, 0), (0, 0))
+            
+    def test_solution_validation(self):
+        """Test solution validation."""
+        puzzle = SnakePuzzle([2, 1, 2], [1, 3, 1], start_cell=(0, 0), end_cell=(2, 2))
+        
+        # Actual solution is (0,0), (0,1), (1,1), (2,1), (2,2)
+
+        # Test empty solution
+        assert not puzzle.is_valid_solution(set())
+        
+        # Test solution missing start or end cell
+        assert not puzzle.is_valid_solution({(0, 1), (1, 1), (2, 1)})  # Missing start (0,0) and end (2,2)
+        
+        # Test out of bounds solution
+        assert not puzzle.is_valid_solution({(0, 0), (3, 0), (2, 2)})  # row 3 is out of bounds
+        assert not puzzle.is_valid_solution({(0, 0), (0, 3), (2, 2)})  # col 3 is out of bounds
+        
+        # Test the actual valid solution
+        valid_solution = {(0, 0), (0, 1), (1, 1), (2, 1), (2, 2)}
+        assert puzzle.is_valid_solution(valid_solution)
+        
+        # Test solution that violates row constraints
+        invalid_row_solution = {(0, 0), (1, 1), (2, 2)}  # Row 0 has only 1 cell but needs 2
+        assert not puzzle.is_valid_solution(invalid_row_solution)
+        
+        # Test solution that violates column constraints  
+        invalid_col_solution = {(0, 0), (0, 1), (0, 2), (2, 2)}  # Col 1 has only 1 cell but needs 3
+        assert not puzzle.is_valid_solution(invalid_col_solution)
+        
+        # Test disconnected path
+        disconnected_solution = {(0, 0), (0, 1), (2, 1), (2, 2)}  # Missing (1,1) - creates gap
+        assert not puzzle.is_valid_solution(disconnected_solution)
+        
+    def test_utility_methods(self):
+        """Test utility methods."""
+        puzzle = SnakePuzzle([2, None, 1], [1, 2, None], start_cell=(0, 0), end_cell=(2, 2))
+        
+        # Test get_row_sum
+        assert puzzle.get_row_sum(0) == 2
+        assert puzzle.get_row_sum(1) is None
+        assert puzzle.get_row_sum(2) == 1
+        
+        with pytest.raises(IndexError):
+            puzzle.get_row_sum(3)
+            
+        # Test get_col_sum
+        assert puzzle.get_col_sum(0) == 1
+        assert puzzle.get_col_sum(1) == 2
+        assert puzzle.get_col_sum(2) is None
+        
+        with pytest.raises(IndexError):
+            puzzle.get_col_sum(3)
+            
+        # Test start/end cell getters
+        assert puzzle.get_start_cell() == (0, 0)
+        assert puzzle.get_end_cell() == (2, 2)
+        
+        # Test helper methods
+        assert puzzle.is_within_bounds(0, 0)
+        assert puzzle.is_within_bounds(2, 2)
+        assert not puzzle.is_within_bounds(-1, 0)
+        assert not puzzle.is_within_bounds(3, 0)
+        assert not puzzle.is_within_bounds(0, 3)
+        
+        # Test get_tile_by_offset
+        assert puzzle.get_tile_by_offset((1, 1), (-1, 0)) == (0, 1)
+        assert puzzle.get_tile_by_offset((0, 0), (-1, 0)) is None  # out of bounds
+        
+        # Test get_tiles_by_offsets
+        adjacent_tiles = puzzle.get_tiles_by_offsets((1, 1), puzzle._orthogonal_offsets)
+        expected_adjacent = {(0, 1), (2, 1), (1, 0), (1, 2)}
+        assert adjacent_tiles == expected_adjacent
+            
+    def test_repr(self):
+        """Test string representation."""
+        puzzle = SnakePuzzle([1, None], [2, 1, None], start_cell=(0, 0), end_cell=(1, 2))
+        repr_str = repr(puzzle)
+        assert "SnakePuzzle" in repr_str
+        assert "rows=2" in repr_str
+        assert "cols=3" in repr_str
+        assert "start=(0, 0)" in repr_str
+        assert "end=(1, 2)" in repr_str
+