sokoban-elements 0.2.1

//! [`Sokoban`](crate::Tessellation::Sokoban) geometry: the raw coordinate maps that
//! [`Tessellation`](crate::Tessellation) dispatches to.

use super::{Tessellation, TessellationError, validate_and_apply_delta};
use crate::game_board::BoardTransform;
use crate::{Direction, TileShape};

pub static KNOWN_DIRECTIONS: [Direction; 4] = [
    Direction::Left,
    Direction::Up,
    Direction::Right,
    Direction::Down,
];
pub static TILE_SHAPES: [TileShape; 1] = [TileShape::Square];
pub const ROTATION_STEP_DEGREES: u16 = 90;

pub const fn tile_shape_from_pos() -> TileShape { TileShape::Square }

pub const fn is_rigid_translation(_dx: i64, _dy: i64) -> bool { true }

pub fn transformed_raw(transform: BoardTransform, x: i64, y: i64) -> (i64, i64) {
    match transform {
        BoardTransform::MirrorHorizontal => (x, -y),
        BoardTransform::MirrorVertical => (-x, y),
        BoardTransform::RotateClockwise => (-y, x),
        BoardTransform::RotateCounterClockwise => (y, -x),
    }
}

pub fn neighbor_checked(
    x: usize, y: usize, to: Direction, width: usize, height: usize,
) -> Result<(usize, usize), TessellationError> {
    let dx: i8;
    let dy: i8;

    match to {
        Direction::Left => {
            dx = -1;
            dy = 0;
        }
        Direction::Up => {
            dx = 0;
            dy = -1;
        }
        Direction::Right => {
            dx = 1;
            dy = 0;
        }
        Direction::Down => {
            dx = 0;
            dy = 1;
        }
        _ => {
            return Err(TessellationError::IllegalDirection(Tessellation::Sokoban, to));
        }
    }

    validate_and_apply_delta(x, y, to, dx, dy, width, height)
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::Size2D;

    /// The raw transform maps of section 4 of
    /// `doc/dev-notes/board-geometry-and-transformations.md`.
    ///
    /// Every expectation here is derived from the formulas in that document and cross-checked
    /// against its own hand-worked examples - not read back out of [`transformed_raw()`]. Sokoban's
    /// map is `MH (x, -y)`, `MV (-x, y)`, `CW (-y, x)`, `CCW (y, -x)`, and `is_rigid_translation`
    /// is unconditionally `true` because the square lattice has period one on both axes.
    ///
    /// `octoban.rs` has a byte-identical [`transformed_raw()`]; the two differ *only* in
    /// [`is_rigid_translation()`], where Octoban imposes `(dx + dy)` even. Do not deduplicate them.
    mod test_transforms {
        use super::*;

        /// A source position and its image under each of `TRANSFORMS`, in that order.
        type Expectation = ((i64, i64), [(i64, i64); 4]);

        const TRANSFORMS: [BoardTransform; 4] = [
            BoardTransform::MirrorHorizontal,
            BoardTransform::MirrorVertical,
            BoardTransform::RotateClockwise,
            BoardTransform::RotateCounterClockwise,
        ];

        /// Both row parities and both column parities, in `TRANSFORMS` order.
        #[rustfmt::skip]
        #[test]
        fn it_maps_the_first_two_rows_under_every_transform() {
            let expectations: [Expectation; 8] = [
                ((0, 0), [(0,  0), ( 0, 0), ( 0, 0), ( 0,  0)]),
                ((1, 0), [(1,  0), (-1, 0), ( 0, 1), ( 0, -1)]),
                ((2, 0), [(2,  0), (-2, 0), ( 0, 2), ( 0, -2)]),
                ((3, 0), [(3,  0), (-3, 0), ( 0, 3), ( 0, -3)]),
                ((0, 1), [(0, -1), ( 0, 1), (-1, 0), ( 1,  0)]),
                ((1, 1), [(1, -1), (-1, 1), (-1, 1), ( 1, -1)]),
                ((2, 1), [(2, -1), (-2, 1), (-1, 2), ( 1, -2)]),
                ((3, 1), [(3, -1), (-3, 1), (-1, 3), ( 1, -3)]),
            ];

            for ((x, y), wanted) in expectations {
                for (transform, want) in TRANSFORMS.iter().zip(wanted) {
                    assert_eq!(
                        transformed_raw(*transform, x, y), want,
                        "{transform:?} at ({x}, {y})"
                    );
                }
            }
        }

        /// Negative coordinates are not hypothetical: `RotateCounterClockwise` is
        /// `mirror . rotate . mirror` on the parity-sensitive tessellations, so intermediates go
        /// negative on every call. Sokoban's own map is sign-agnostic, and this pins that.
        #[rustfmt::skip]
        #[test]
        fn it_maps_negative_coordinates() {
            let expectations: [Expectation; 8] = [
                (( 0, -1), [( 0,  1), ( 0, -1), ( 1,  0), (-1,  0)]),
                (( 1, -1), [( 1,  1), (-1, -1), ( 1,  1), (-1, -1)]),
                ((-1,  0), [(-1,  0), ( 1,  0), ( 0, -1), ( 0,  1)]),
                ((-1, -1), [(-1,  1), ( 1, -1), ( 1, -1), (-1,  1)]),
                ((-2, -1), [(-2,  1), ( 2, -1), ( 1, -2), (-1,  2)]),
                ((-1, -2), [(-1,  2), ( 1, -2), ( 2, -1), (-2,  1)]),
                ((-2, -2), [(-2,  2), ( 2, -2), ( 2, -2), (-2,  2)]),
                ((-3, -2), [(-3,  2), ( 3, -2), ( 2, -3), (-2,  3)]),
            ];

            for ((x, y), wanted) in expectations {
                for (transform, want) in TRANSFORMS.iter().zip(wanted) {
                    assert_eq!(
                        transformed_raw(*transform, x, y), want,
                        "{transform:?} at ({x}, {y})"
                    );
                }
            }
        }

        /// `CW` composed `360 / ROTATION_STEP_DEGREES` times is the identity, and no fewer.
        ///
        /// The early-return half is what pins the *angle*: a 180 degree map would satisfy
        /// `CW^4 == id` too. It needs a witness away from the origin, which is this tiling's only
        /// fixed point under rotation.
        #[test]
        fn it_returns_to_the_start_only_after_a_full_turn() {
            let steps = 360 / usize::from(ROTATION_STEP_DEGREES);
            assert_eq!(steps, 4);

            // Away from the origin, which rotation fixes and which therefore cannot witness a
            // partial turn.
            let witness = (2_i64, 1_i64);
            let mut point = witness;
            for step in 1..steps {
                point = transformed_raw(BoardTransform::RotateClockwise, point.0, point.1);
                assert_ne!(point, witness, "home again after {step} of {steps} steps");
            }

            for y in -6_i64..=6 {
                for x in -6_i64..=6 {
                    let mut point = (x, y);
                    for _ in 0..steps {
                        point = transformed_raw(BoardTransform::RotateClockwise, point.0, point.1);
                    }
                    assert_eq!(point, (x, y), "({x}, {y}) after a full turn");
                }
            }
        }

        #[test]
        fn counter_clockwise_inverts_clockwise_and_mirrors_are_involutions() {
            for y in -6_i64..=6 {
                for x in -6_i64..=6 {
                    let clockwise = transformed_raw(BoardTransform::RotateClockwise, x, y);
                    assert_eq!(
                        transformed_raw(
                            BoardTransform::RotateCounterClockwise,
                            clockwise.0,
                            clockwise.1
                        ),
                        (x, y),
                        "CCW . CW at ({x}, {y})"
                    );

                    for mirror in [
                        BoardTransform::MirrorHorizontal,
                        BoardTransform::MirrorVertical,
                    ] {
                        let once = transformed_raw(mirror, x, y);
                        assert_eq!(
                            transformed_raw(mirror, once.0, once.1),
                            (x, y),
                            "{mirror:?} twice at ({x}, {y})"
                        );
                    }
                }
            }
        }

        /// Every translation is rigid on a square lattice - all 49 pairs in `-3..=3`.
        #[test]
        fn it_reports_every_translation_as_rigid() {
            let rigid = (-3_i64..=3)
                .flat_map(|dy| (-3_i64..=3).map(move |dx| (dx, dy)))
                .filter(|(dx, dy)| is_rigid_translation(*dx, *dy))
                .count();

            assert_eq!(rigid, 49);
        }

        /// A clockwise turn relabels directions by one step of the rotation, and *which* step is
        /// what distinguishes a correct rotation from any other adjacency-preserving bijection.
        ///
        /// The permutation is section 11 part E of the dev notes, measured there but asserted
        /// nowhere until now. Coordinates are offset into the middle of a large virtual board so
        /// that no neighbour is clipped by an edge and no intermediate goes negative.
        #[test]
        fn it_rotates_every_direction_by_one_step() {
            let relabelled = [
                (Direction::Up, Direction::Right),
                (Direction::Right, Direction::Down),
                (Direction::Down, Direction::Left),
                (Direction::Left, Direction::Up),
            ];

            for y in 0_usize..4 {
                for x in 0_usize..4 {
                    for (direction, rotated) in relabelled {
                        assert_rotated_direction(x, y, direction, rotated);
                    }
                }
            }
        }
    }

    /// Asserts that a clockwise turn carries `direction` onto `rotated`: the image of the
    /// `direction` neighbour of a cell is the `rotated` neighbour of that cell's image.
    ///
    /// Everything happens in the middle of a large board so no neighbour is clipped by an edge,
    /// and images are shifted back on-board by an **even** offset on both axes - which leaves both
    /// `y` parity (Hexoban) and `x + y` parity (Trioban, Octoban) untouched, so the shift cannot
    /// change what the geometry does.
    #[cfg(test)]
    fn assert_rotated_direction(x: usize, y: usize, direction: Direction, rotated: Direction) {
        const ORIGIN: usize = 64;
        const SHIFT: i64 = 128;
        const SIZE: usize = 256;

        let turned = |(cx, cy): (usize, usize)| {
            let (tx, ty) = transformed_raw(
                BoardTransform::RotateClockwise,
                i64::try_from(cx).unwrap(),
                i64::try_from(cy).unwrap(),
            );
            (
                usize::try_from(tx + SHIFT).unwrap(),
                usize::try_from(ty + SHIFT).unwrap(),
            )
        };

        let (column, row) = (x + ORIGIN, y + ORIGIN);
        let neighbor = neighbor_checked(column, row, direction, SIZE, SIZE)
            .expect("the source neighbour is on board");

        let source = turned((column, row));
        assert_eq!(
            neighbor_checked(source.0, source.1, rotated, SIZE, SIZE),
            Ok(turned(neighbor)),
            "a clockwise turn should carry {direction:?} onto {rotated:?}, at ({column}, {row})"
        );
    }

    // type Expectation = (Direction, Result<(usize, usize), TessellationError>);

    #[rustfmt::skip]
    #[test]
    fn test_top_left() {
        let size = Size2D::new(10, 10);
        let width = size.width;
        let height = size.height;
        let row: usize = 0;
        let column: usize = 0;
        let expectations = [
            (Direction::Left     , Err(TessellationError::OffBoard(column, row, Direction::Left))),
            (Direction::Right    , Ok((1, 0))),
            (Direction::Up       , Err(TessellationError::OffBoard(column, row, Direction::Up))),
            (Direction::Down     , Ok((0, 1))),
            (Direction::NorthWest, Err(TessellationError::IllegalDirection(Tessellation::Sokoban, Direction::NorthWest))),
            (Direction::NorthEast, Err(TessellationError::IllegalDirection(Tessellation::Sokoban, Direction::NorthEast))),
            (Direction::SouthWest, Err(TessellationError::IllegalDirection(Tessellation::Sokoban, Direction::SouthWest))),
            (Direction::SouthEast, Err(TessellationError::IllegalDirection(Tessellation::Sokoban, Direction::SouthEast))),
        ];

        for (direction, result) in &expectations {
            assert_eq!(
                neighbor_checked(column, row, *direction, width, height),
                *result
            );
        }
    }

    #[rustfmt::skip]
    #[test]
    fn test_top_right() {
        let size = Size2D::new(10, 10);
        let width = size.width;
        let height = size.height;
        let row: usize = 0;
        let column: usize = 9;

        let expectations = [
            (Direction::Left     , Ok((8, 0))),
            (Direction::Right    , Err(TessellationError::OffBoard(column, row, Direction::Right))),
            (Direction::Up       , Err(TessellationError::OffBoard(column, row, Direction::Up))),
            (Direction::Down     , Ok((9, 1))),
            (Direction::NorthWest, Err(TessellationError::IllegalDirection(Tessellation::Sokoban, Direction::NorthWest))),
            (Direction::NorthEast, Err(TessellationError::IllegalDirection(Tessellation::Sokoban, Direction::NorthEast))),
            (Direction::SouthWest, Err(TessellationError::IllegalDirection(Tessellation::Sokoban, Direction::SouthWest))),
            (Direction::SouthEast, Err(TessellationError::IllegalDirection(Tessellation::Sokoban, Direction::SouthEast))),
        ];

        for (direction, result) in &expectations {
            assert_eq!(
                neighbor_checked(column, row, *direction, width, height),
                *result
            );
        }
    }

    #[rustfmt::skip]
    #[test]
    fn test_bottom_left() {
        let size = Size2D::new(10, 10);
        let width = size.width;
        let height = size.height;
        let row: usize = 9;
        let column: usize = 0;

        let expectations = [
            (Direction::Left     , Err(TessellationError::OffBoard(column, row, Direction::Left))),
            (Direction::Right    , Ok((1, 9))),
            (Direction::Up       , Ok((0, 8))),
            (Direction::Down     , Err(TessellationError::OffBoard(column, row, Direction::Down))),
            (Direction::NorthWest, Err(TessellationError::IllegalDirection(Tessellation::Sokoban, Direction::NorthWest))),
            (Direction::NorthEast, Err(TessellationError::IllegalDirection(Tessellation::Sokoban, Direction::NorthEast))),
            (Direction::SouthWest, Err(TessellationError::IllegalDirection(Tessellation::Sokoban, Direction::SouthWest))),
            (Direction::SouthEast, Err(TessellationError::IllegalDirection(Tessellation::Sokoban, Direction::SouthEast))),
        ];

        for (direction, result) in &expectations {
            assert_eq!(
                neighbor_checked(column, row, *direction, width, height),
                *result
            );
        }
    }

    #[rustfmt::skip]
    #[test]
    fn test_bottom_right() {
        let size = Size2D::new(10, 10);
        let width = size.width;
        let height = size.height;
        let row: usize = 9;
        let column: usize = 9;

        let expectations = [
            (Direction::Left     , Ok((8, 9))),
            (Direction::Right    , Err(TessellationError::OffBoard(column, row, Direction::Right))),
            (Direction::Up       , Ok((9, 8))),
            (Direction::Down     , Err(TessellationError::OffBoard(column, row, Direction::Down))),
            (Direction::NorthWest, Err(TessellationError::IllegalDirection(Tessellation::Sokoban, Direction::NorthWest))),
            (Direction::NorthEast, Err(TessellationError::IllegalDirection(Tessellation::Sokoban, Direction::NorthEast))),
            (Direction::SouthWest, Err(TessellationError::IllegalDirection(Tessellation::Sokoban, Direction::SouthWest))),
            (Direction::SouthEast, Err(TessellationError::IllegalDirection(Tessellation::Sokoban, Direction::SouthEast))),
        ];

        for (direction, result) in &expectations {
            assert_eq!(
                neighbor_checked(column, row, *direction, width, height),
                *result
            );
        }
    }

    #[rustfmt::skip]
    #[test]
    fn test_middle_top() {
        let size = Size2D::new(10, 10);
        let width = size.width;
        let height = size.height;
        let row: usize = 0;
        let column: usize = 5;

        let expectations = [
            (Direction::Left     , Ok((4, 0))),
            (Direction::Right    , Ok((6, 0))),
            (Direction::Up       , Err(TessellationError::OffBoard(column, row, Direction::Up))),
            (Direction::Down     , Ok((5, 1))),
            (Direction::NorthWest, Err(TessellationError::IllegalDirection(Tessellation::Sokoban, Direction::NorthWest))),
            (Direction::NorthEast, Err(TessellationError::IllegalDirection(Tessellation::Sokoban, Direction::NorthEast))),
            (Direction::SouthWest, Err(TessellationError::IllegalDirection(Tessellation::Sokoban, Direction::SouthWest))),
            (Direction::SouthEast, Err(TessellationError::IllegalDirection(Tessellation::Sokoban, Direction::SouthEast))),
        ];

        for (direction, result) in &expectations {
            assert_eq!(
                neighbor_checked(column, row, *direction, width, height),
                *result
            );
        }
    }

    #[rustfmt::skip]
    #[test]
    fn test_middle_bottom() {
        let size = Size2D::new(10, 10);
        let width = size.width;
        let height = size.height;
        let row: usize = 9;
        let column: usize = 5;

        let expectations = [
            (Direction::Left     , Ok((4, 9))),
            (Direction::Right    , Ok((6, 9))),
            (Direction::Up       , Ok((5, 8))),
            (Direction::Down     , Err(TessellationError::OffBoard(column, row, Direction::Down))),
            (Direction::NorthWest, Err(TessellationError::IllegalDirection(Tessellation::Sokoban, Direction::NorthWest))),
            (Direction::NorthEast, Err(TessellationError::IllegalDirection(Tessellation::Sokoban, Direction::NorthEast))),
            (Direction::SouthWest, Err(TessellationError::IllegalDirection(Tessellation::Sokoban, Direction::SouthWest))),
            (Direction::SouthEast, Err(TessellationError::IllegalDirection(Tessellation::Sokoban, Direction::SouthEast))),
        ];

        for (direction, result) in &expectations {
            assert_eq!(
                neighbor_checked(column, row, *direction, width, height),
                *result
            );
        }
    }

    #[rustfmt::skip]
    #[test]
    fn test_middle_left() {
        let size = Size2D::new(10, 10);
        let width = size.width;
        let height = size.height;
        let row: usize = 5;
        let column: usize = 0;

        let expectations = [
            (Direction::Left     , Err(TessellationError::OffBoard(column, row, Direction::Left))),
            (Direction::Right    , Ok((1, 5))),
            (Direction::Up       , Ok((0, 4))),
            (Direction::Down     , Ok((0, 6))),
            (Direction::NorthWest, Err(TessellationError::IllegalDirection(Tessellation::Sokoban, Direction::NorthWest))),
            (Direction::NorthEast, Err(TessellationError::IllegalDirection(Tessellation::Sokoban, Direction::NorthEast))),
            (Direction::SouthWest, Err(TessellationError::IllegalDirection(Tessellation::Sokoban, Direction::SouthWest))),
            (Direction::SouthEast, Err(TessellationError::IllegalDirection(Tessellation::Sokoban, Direction::SouthEast))),
        ];

        for (direction, result) in &expectations {
            assert_eq!(
                neighbor_checked(column, row, *direction, width, height),
                *result
            );
        }
    }

    #[rustfmt::skip]
    #[test]
    fn test_middle_right() {
        let size = Size2D::new(10, 10);
        let width = size.width;
        let height = size.height;
        let row: usize = 5;
        let column: usize = 9;

        let expectations = [
            (Direction::Left     , Ok((8, 5))),
            (Direction::Right    , Err(TessellationError::OffBoard(column, row, Direction::Right))),
            (Direction::Up       , Ok((9, 4))),
            (Direction::Down     , Ok((9, 6))),
            (Direction::NorthWest, Err(TessellationError::IllegalDirection(Tessellation::Sokoban, Direction::NorthWest))),
            (Direction::NorthEast, Err(TessellationError::IllegalDirection(Tessellation::Sokoban, Direction::NorthEast))),
            (Direction::SouthWest, Err(TessellationError::IllegalDirection(Tessellation::Sokoban, Direction::SouthWest))),
            (Direction::SouthEast, Err(TessellationError::IllegalDirection(Tessellation::Sokoban, Direction::SouthEast))),
        ];

        for (direction, result) in &expectations {
            assert_eq!(
                neighbor_checked(column, row, *direction, width, height),
                *result
            );
        }
    }

    #[rustfmt::skip]
    #[test]
    fn test_board1x1() {
        let size = Size2D::new(1, 1);
        let width = size.width;
        let height = size.height;
        let row: usize = 0;
        let column: usize = 0;

        let expectations = [
            (Direction::Left     , Err(TessellationError::OffBoard(column, row, Direction::Left))),
            (Direction::Right    , Err(TessellationError::OffBoard(column, row, Direction::Right))),
            (Direction::Up       , Err(TessellationError::OffBoard(column, row, Direction::Up))),
            (Direction::Down     , Err(TessellationError::OffBoard(column, row, Direction::Down))),
            (Direction::NorthWest, Err(TessellationError::IllegalDirection(Tessellation::Sokoban, Direction::NorthWest))),
            (Direction::NorthEast, Err(TessellationError::IllegalDirection(Tessellation::Sokoban, Direction::NorthEast))),
            (Direction::SouthWest, Err(TessellationError::IllegalDirection(Tessellation::Sokoban, Direction::SouthWest))),
            (Direction::SouthEast, Err(TessellationError::IllegalDirection(Tessellation::Sokoban, Direction::SouthEast))),
        ];

        for (direction, result) in &expectations {
            assert_eq!(
                neighbor_checked(column, row, *direction, width, height),
                *result
            );
        }
    }

    #[rustfmt::skip]
    #[test]
    fn test_board2x1_left() {
        let size = Size2D::new(2, 1);
        let width = size.width;
        let height = size.height;
        let row: usize = 0;
        let column: usize = 0;

        let expectations = [
            (Direction::Left     , Err(TessellationError::OffBoard(column, row, Direction::Left))),
            (Direction::Right    , Ok((1, 0))),
            (Direction::Up       , Err(TessellationError::OffBoard(column, row, Direction::Up))),
            (Direction::Down     , Err(TessellationError::OffBoard(column, row, Direction::Down))),
            (Direction::NorthWest, Err(TessellationError::IllegalDirection(Tessellation::Sokoban, Direction::NorthWest))),
            (Direction::NorthEast, Err(TessellationError::IllegalDirection(Tessellation::Sokoban, Direction::NorthEast))),
            (Direction::SouthWest, Err(TessellationError::IllegalDirection(Tessellation::Sokoban, Direction::SouthWest))),
            (Direction::SouthEast, Err(TessellationError::IllegalDirection(Tessellation::Sokoban, Direction::SouthEast))),
        ];

        for (direction, result) in &expectations {
            assert_eq!(
                neighbor_checked(column, row, *direction, width, height),
                *result
            );
        }
    }

    #[rustfmt::skip]
    #[test]
    fn test_boar_d2x1_right() {
        let size = Size2D::new(2, 1);
        let width = size.width;
        let height = size.height;
        let row: usize = 0;
        let column: usize = 1;

        let expectations = [
            (Direction::Left     , Ok((0, 0))),
            (Direction::Right    , Err(TessellationError::OffBoard(column, row, Direction::Right))),
            (Direction::Up       , Err(TessellationError::OffBoard(column, row, Direction::Up))),
            (Direction::Down     , Err(TessellationError::OffBoard(column, row, Direction::Down))),
            (Direction::NorthWest, Err(TessellationError::IllegalDirection(Tessellation::Sokoban, Direction::NorthWest))),
            (Direction::NorthEast, Err(TessellationError::IllegalDirection(Tessellation::Sokoban, Direction::NorthEast))),
            (Direction::SouthWest, Err(TessellationError::IllegalDirection(Tessellation::Sokoban, Direction::SouthWest))),
            (Direction::SouthEast, Err(TessellationError::IllegalDirection(Tessellation::Sokoban, Direction::SouthEast))),
        ];

        for (direction, result) in &expectations {
            assert_eq!(
                neighbor_checked(column, row, *direction, width, height),
                *result
            );
        }
    }

    #[rustfmt::skip]
    #[test]
    fn test_1x2_top() {
        let size = Size2D::new(1, 2);
        let width = size.width;
        let height = size.height;
        let row: usize = 0;
        let column: usize = 0;

        let expectations = [
            (Direction::Left     , Err(TessellationError::OffBoard(column, row, Direction::Left))),
            (Direction::Right    , Err(TessellationError::OffBoard(column, row, Direction::Right))),
            (Direction::Up       , Err(TessellationError::OffBoard(column, row, Direction::Up))),
            (Direction::Down     , Ok((0, 1))),
            (Direction::NorthWest, Err(TessellationError::IllegalDirection(Tessellation::Sokoban, Direction::NorthWest))),
            (Direction::NorthEast, Err(TessellationError::IllegalDirection(Tessellation::Sokoban, Direction::NorthEast))),
            (Direction::SouthWest, Err(TessellationError::IllegalDirection(Tessellation::Sokoban, Direction::SouthWest))),
            (Direction::SouthEast, Err(TessellationError::IllegalDirection(Tessellation::Sokoban, Direction::SouthEast))),
        ];

        for (direction, result) in &expectations {
            assert_eq!(
                neighbor_checked(column, row, *direction, width, height),
                *result
            );
        }
    }

    #[rustfmt::skip]
    #[test]
    fn test_1x2_bottom() {
        let size = Size2D::new(1, 2);
        let width = size.width;
        let height = size.height;
        let row: usize = 1;
        let column: usize = 0;

        let expectations = [
            (Direction::Left     , Err(TessellationError::OffBoard(column, row, Direction::Left))),
            (Direction::Right    , Err(TessellationError::OffBoard(column, row, Direction::Right))),
            (Direction::Up       , Ok((0, 0))),
            (Direction::Down     , Err(TessellationError::OffBoard(column, row, Direction::Down))),
            (Direction::NorthWest, Err(TessellationError::IllegalDirection(Tessellation::Sokoban, Direction::NorthWest))),
            (Direction::NorthEast, Err(TessellationError::IllegalDirection(Tessellation::Sokoban, Direction::NorthEast))),
            (Direction::SouthWest, Err(TessellationError::IllegalDirection(Tessellation::Sokoban, Direction::SouthWest))),
            (Direction::SouthEast, Err(TessellationError::IllegalDirection(Tessellation::Sokoban, Direction::SouthEast))),
        ];

        for (direction, result) in &expectations {
            assert_eq!(
                neighbor_checked(column, row, *direction, width, height),
                *result
            );
        }
    }
}