fours 0.1.0

Four in a row in your terminal, with three levels of opponent.
Documentation
//! Tests for the rules of the game.

mod support;

use fours::game::BoardDimensions;
use fours::game::Cell;
use fours::game::Game;
use fours::game::GameError;
use fours::game::GameState;
use fours::game::Player;
use fours::game::Status;
use support::Outcome;
use support::check_board;
use support::check_invariants;
use support::check_landing_cells;
use support::check_outcome;
use support::check_rejected;
use support::corpus;
use support::play;
use support::play_on;

#[test]
fn corpus_games_end_the_way_they_should() {
    for case in corpus() {
        let game = play_on(case.dimensions, &case.moves);
        let state = game.state();

        assert_eq!(
            state.to_string(),
            case.board,
            "unexpected board for case {:?}",
            case.name
        );
        check_outcome(state, case.outcome);
        check_invariants(state);
        assert_eq!(game.move_history(), case.moves);
        assert_eq!(state.disc_count(), case.moves.len());
        assert_eq!(state.dimensions(), case.dimensions);
    }
}

#[test]
fn corpus_games_can_be_replayed_move_by_move() {
    for case in corpus() {
        let mut state = GameState::with_dimensions(case.dimensions);
        let mut placed = 0;

        for column in &case.moves {
            let placement = state.apply_move(*column).expect("a corpus move is legal");
            placed += 1;

            assert_eq!(placement.cell.column, *column);
            assert_eq!(state.piece_at(placement.cell), Some(placement.player));
            assert_eq!(state.disc_count(), placed);
            check_invariants(&state);
        }

        assert_eq!(state.to_string(), case.board);
        assert_eq!(state, *play_on(case.dimensions, &case.moves).state());
    }
}

#[test]
fn an_empty_board_has_no_discs() {
    let game = play(&[]);

    check_board(
        game.state(),
        "
        .......
        .......
        .......
        .......
        .......
        .......",
    );
    check_outcome(game.state(), Outcome::InProgress);
    assert_eq!(game.state().current_player(), Player::Red);
    assert_eq!(game.state().disc_count(), 0);
}

#[test]
fn discs_stack_from_the_bottom_of_a_column() {
    let game = play(&[3, 3, 3]);

    check_board(
        game.state(),
        "
        .......
        .......
        .......
        ...R...
        ...Y...
        ...R...",
    );
}

#[test]
fn players_alternate() {
    let mut state = GameState::new();
    let mut expected = Player::Red;

    for column in [0, 1, 2, 4, 5, 6] {
        assert_eq!(state.current_player(), expected);
        let placement = state.apply_move(column).expect("the column is empty");
        assert_eq!(placement.player, expected);
        expected = expected.opponent();
    }
}

#[test]
fn a_vertical_line_wins() {
    let game = play(&[2, 3, 2, 3, 2, 3, 2]);

    check_outcome(game.state(), Outcome::Won(Player::Red));
    check_winning_line(game.state(), &[(2, 0), (2, 1), (2, 2), (2, 3)]);
}

#[test]
fn a_horizontal_line_wins() {
    let game = play(&[0, 0, 1, 1, 2, 2, 3]);

    check_outcome(game.state(), Outcome::Won(Player::Red));
    check_winning_line(game.state(), &[(0, 0), (1, 0), (2, 0), (3, 0)]);
}

#[test]
fn a_rising_diagonal_wins() {
    let game = play(&[0, 1, 1, 2, 2, 3, 2, 3, 3, 0, 3]);

    check_outcome(game.state(), Outcome::Won(Player::Red));
    check_winning_line(game.state(), &[(0, 0), (1, 1), (2, 2), (3, 3)]);
}

#[test]
fn a_falling_diagonal_wins() {
    let game = play(&[6, 5, 5, 4, 4, 3, 4, 3, 3, 0, 3]);

    check_outcome(game.state(), Outcome::Won(Player::Red));
    check_winning_line(game.state(), &[(3, 3), (4, 2), (5, 1), (6, 0)]);
}

#[test]
fn a_line_of_five_reports_every_disc() {
    let game = play(&[0, 0, 1, 1, 2, 2, 4, 4, 3]);

    check_winning_line(game.state(), &[(0, 0), (1, 0), (2, 0), (3, 0), (4, 0)]);
}

#[test]
fn three_in_a_row_does_not_win() {
    let game = play(&[0, 4, 1, 5, 2]);

    check_outcome(game.state(), Outcome::InProgress);
}

#[test]
fn a_full_board_without_a_line_is_a_draw() {
    let dimensions = BoardDimensions::new(2, 2).expect("a two by two board is playable");
    let game = play_on(dimensions, &[0, 0, 1, 1]);

    check_board(
        game.state(),
        "
        YY
        RR",
    );
    check_outcome(game.state(), Outcome::Draw);
    assert!(game.state().is_full());
}

#[test]
fn a_move_that_wins_and_fills_the_board_is_a_win() {
    let dimensions = BoardDimensions::new(4, 4).expect("a four by four board is playable");
    let game = play_on(
        dimensions,
        &[1, 2, 0, 3, 3, 1, 0, 0, 0, 2, 3, 2, 1, 1, 3, 2],
    );

    check_board(
        game.state(),
        "
        RYYR
        YRYR
        RYYR
        RRYY",
    );
    check_outcome(game.state(), Outcome::Won(Player::Yellow));
    assert!(game.state().is_full());
}

#[test]
fn playing_outside_the_board_is_rejected() {
    let mut game = Game::new();

    check_rejected(
        &mut game,
        7,
        &GameError::ColumnOutOfRange {
            column: 7,
            column_count: 7,
        },
    );
    check_rejected(
        &mut game,
        usize::MAX,
        &GameError::ColumnOutOfRange {
            column: usize::MAX,
            column_count: 7,
        },
    );
}

#[test]
fn playing_a_full_column_is_rejected() {
    let mut game = play(&[0, 0, 0, 0, 0, 0]);

    check_rejected(&mut game, 0, &GameError::ColumnFull { column: 0 });
    assert!(game.play(1).is_ok());
}

#[test]
fn playing_after_the_game_ended_is_rejected() {
    let mut game = play(&[3, 4, 3, 4, 3, 4, 3]);

    check_rejected(&mut game, 0, &GameError::GameOver);
    check_rejected(&mut game, 3, &GameError::GameOver);
}

#[test]
fn landing_cells_follow_the_discs() {
    let mut game = Game::new();
    check_landing_cells(game.state(), &[Some(0); 7]);

    game.play(0).expect("the column is empty");
    check_landing_cells(
        game.state(),
        &[
            Some(1),
            Some(0),
            Some(0),
            Some(0),
            Some(0),
            Some(0),
            Some(0),
        ],
    );

    let mut game = play(&[0, 0, 0, 0, 0, 0]);
    check_landing_cells(
        game.state(),
        &[None, Some(0), Some(0), Some(0), Some(0), Some(0), Some(0)],
    );

    game.play(1).expect("the column is empty");
    assert_eq!(game.state().landing_cell(7), None);
}

#[test]
fn a_finished_game_has_no_landing_cells() {
    let game = play(&[3, 4, 3, 4, 3, 4, 3]);

    check_landing_cells(game.state(), &[None; 7]);
    assert!(game.state().legal_moves().is_empty());
}

#[test]
fn a_restarted_game_forgets_everything() {
    let mut game = play(&[3, 4, 3, 4, 3, 4, 3]);
    game.restart();

    assert_eq!(game, Game::new());
    assert!(game.move_history().is_empty());
    check_outcome(game.state(), Outcome::InProgress);
}

#[test]
fn a_restarted_game_keeps_its_size() {
    let dimensions = BoardDimensions::new(5, 9).expect("a five by nine board is playable");
    let mut game = play_on(dimensions, &[0, 1, 2]);
    game.restart();

    assert_eq!(game.state().dimensions(), dimensions);
    assert_eq!(game, Game::with_dimensions(dimensions));
}

#[test]
fn a_rejected_move_is_not_recorded() {
    let mut game = play(&[0, 0, 0, 0, 0, 0]);
    let history_before = game.move_history().to_vec();

    assert!(game.play(0).is_err());
    assert_eq!(game.move_history(), history_before);
}

#[test]
fn boards_have_a_sensible_size() {
    assert_eq!(BoardDimensions::STANDARD.column_count(), 7);
    assert_eq!(BoardDimensions::STANDARD.row_count(), 6);
    assert_eq!(BoardDimensions::STANDARD.cell_count(), 42);
    assert_eq!(BoardDimensions::default(), BoardDimensions::STANDARD);

    for (columns, rows) in [(0, 6), (7, 0), (0, 0), (65, 6), (7, 65)] {
        assert_eq!(
            BoardDimensions::new(columns, rows),
            Err(GameError::InvalidDimensions {
                column_count: columns,
                row_count: rows,
            })
        );
    }

    for (columns, rows) in [(1, 1), (4, 4), (7, 6), (64, 64)] {
        let dimensions = BoardDimensions::new(columns, rows).expect("the size is playable");
        assert_eq!(dimensions.cell_count(), columns * rows);
        check_invariants(&GameState::with_dimensions(dimensions));
    }
}

#[test]
fn cells_outside_the_board_are_empty() {
    let game = play(&[0]);

    assert_eq!(game.state().piece_at(Cell::new(0, 0)), Some(Player::Red));
    assert_eq!(game.state().piece_at(Cell::new(7, 0)), None);
    assert_eq!(game.state().piece_at(Cell::new(0, 6)), None);
    assert_eq!(
        game.state().piece_at(Cell::new(usize::MAX, usize::MAX)),
        None
    );
}

#[test]
fn every_column_can_be_filled() {
    let dimensions = BoardDimensions::STANDARD;
    let mut game = Game::with_dimensions(dimensions);
    let mut columns = (0..dimensions.column_count()).cycle();

    while !game.state().is_over() {
        let column = columns.next().expect("the cycle never ends");
        if game.state().is_playable(column) {
            game.play(column).expect("a playable column accepts a disc");
        }
        check_invariants(game.state());
    }
}

#[test]
fn a_game_of_one_cell_ends_immediately() {
    let dimensions = BoardDimensions::new(1, 1).expect("a one by one board is playable");
    let game = play_on(dimensions, &[0]);

    check_board(game.state(), "R");
    check_outcome(game.state(), Outcome::Draw);
}

#[track_caller]
fn check_winning_line(state: &GameState, expected: &[(usize, usize)]) {
    let Status::Won(victory) = state.status() else {
        panic!("the game was expected to be won");
    };

    let actual: Vec<(usize, usize)> = victory
        .line()
        .iter()
        .map(|cell| (cell.column, cell.row))
        .collect();

    assert_eq!(actual, expected);
}