Content of file TicTacToeGameImplTest.java

package de.fhdw.gaming.ipspiel23.tictactoe.core.domain.impl;

import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.equalTo;
import static org.hamcrest.Matchers.is;
import static org.hamcrest.Matchers.sameInstance;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertTrue;

import java.util.Optional;
import java.util.ServiceLoader;

import org.junit.jupiter.api.Test;

import de.fhdw.gaming.core.domain.DefaultObserverFactoryProvider;
import de.fhdw.gaming.core.domain.GameBuilder;
import de.fhdw.gaming.core.domain.util.GameBuilderFacade;
import de.fhdw.gaming.ipspiel23.tictactoe.core.domain.TicTacToeBoard;
import de.fhdw.gaming.ipspiel23.tictactoe.core.domain.TicTacToeFieldState;
import de.fhdw.gaming.ipspiel23.tictactoe.core.domain.TicTacToeGame;
import de.fhdw.gaming.ipspiel23.tictactoe.core.domain.TicTacToeGameBuilder;
import de.fhdw.gaming.ipspiel23.tictactoe.core.domain.TicTacToeGameBuilderFactory;
import de.fhdw.gaming.ipspiel23.tictactoe.core.domain.TicTacToePosition;
import de.fhdw.gaming.ipspiel23.tictactoe.core.domain.TicTacToeState;
import de.fhdw.gaming.ipspiel23.tictactoe.core.moves.impl.AbstractTicTacToeMove;
import de.fhdw.gaming.ipspiel23.tictactoe.core.moves.impl.TicTacToeDefaultMoveFactory;

/**
 * Tests {@link TicTacToeGameImpl}.
 */
class TicTacToeGameImplTest {

    /**
     * Tests that the game comes to an end. Due to the strategy chosen (TicTacToeFirstMoveStrategy), the result is as
     * follows:
     *
     * <pre>
     * X O X
     * O X O
     * X _ _
     * </pre>
     */
    @Test
    void testGame() throws Exception {
        final TicTacToeGameBuilder gameBuilder = GameBuilderFacade.createGameBuilder(
                TicTacToeGameBuilder.class,
                ServiceLoader.load(TicTacToeGameBuilderFactory.class),
                Optional.of(new TicTacToeFirstMoveStrategy(new TicTacToeDefaultMoveFactory())),
                GameBuilder.DEFAULT_MAX_COMPUTATION_TIME_PER_MOVE).orElseThrow();

        try (TicTacToeGame game = gameBuilder.build(1)) {
            game.start();

            int moveNumber = 0;
            while (!game.isFinished()) {
                game.makeMove();
                ++moveNumber;
            }

            assertEquals(0, game.getState().computeNextPlayers().size());

            assertEquals(3, game.getBoardSize());

            final String expected = "TicTacToeGame[id=1, boardSize=3, state=TicTacToeState[board=\n"
            + "X O X \n"
            + "O X O \n"
            + "X _ _ \n"
            + ", crossesPlayer=TicTacToePlayer[name=1, type=X, state=WON, outcome=Optional[1.0]], "
            + "noughtsPlayer=TicTacToePlayer[name=2, type=O, state=LOST, outcome=Optional[-1.0]], currentPlayer=O], " 
            + "strategies={1=TicTacToeFirstMoveStrategy, 2=TicTacToeFirstMoveStrategy}]";

            assertEquals(expected, game.toString());

            assertThat(moveNumber, is(equalTo(7)));

            final TicTacToeState state = game.getState();
            // next player would be the one using noughts (but he already lost the game)
            assertThat(state.getCurrentPlayer(), is(sameInstance(state.getNoughtsPlayer())));

            final TicTacToeBoard board = state.getBoard();
            assertThat(board.getFieldAt(TicTacToePosition.of(0, 0)).getState(), is(equalTo(TicTacToeFieldState.CROSS)));
            assertThat(
                    board.getFieldAt(TicTacToePosition.of(0, 1)).getState(),
                    is(equalTo(TicTacToeFieldState.NOUGHT)));
            assertThat(board.getFieldAt(TicTacToePosition.of(0, 2)).getState(), is(equalTo(TicTacToeFieldState.CROSS)));
            assertThat(
                    board.getFieldAt(TicTacToePosition.of(1, 0)).getState(),
                    is(equalTo(TicTacToeFieldState.NOUGHT)));
            assertThat(board.getFieldAt(TicTacToePosition.of(1, 1)).getState(), is(equalTo(TicTacToeFieldState.CROSS)));
            assertThat(
                    board.getFieldAt(TicTacToePosition.of(1, 2)).getState(),
                    is(equalTo(TicTacToeFieldState.NOUGHT)));
            assertThat(board.getFieldAt(TicTacToePosition.of(2, 0)).getState(), is(equalTo(TicTacToeFieldState.CROSS)));
            assertThat(board.getFieldAt(TicTacToePosition.of(2, 1)).getState(), is(equalTo(TicTacToeFieldState.EMPTY)));
            assertThat(board.getFieldAt(TicTacToePosition.of(2, 2)).getState(), is(equalTo(TicTacToeFieldState.EMPTY)));
        }
    }

    @Test
Missing a Javadoc comment.
    void testChoseRandomMove() throws Exception {
        final TicTacToeGameBuilder gameBuilder = GameBuilderFacade.createGameBuilder(
            TicTacToeGameBuilder.class,
            ServiceLoader.load(TicTacToeGameBuilderFactory.class),
            Optional.of(new TicTacToeFirstMoveStrategy(new TicTacToeDefaultMoveFactory())),
            GameBuilder.DEFAULT_MAX_COMPUTATION_TIME_PER_MOVE).orElseThrow();

        try (TicTacToeGame game = gameBuilder.build(1)) {
            final var move = game.chooseRandomMove(game.getPlayers().get("1"), game.getState());
            assertTrue(move.isPresent());
            final var state = game.getState();
            final var board = state.getBoard();
            board.getFieldAt(TicTacToePosition.of(0, 0)).changeState(TicTacToeFieldState.CROSS);
            board.getFieldAt(TicTacToePosition.of(0, 1)).changeState(TicTacToeFieldState.NOUGHT);
            board.getFieldAt(TicTacToePosition.of(0, 2)).changeState(TicTacToeFieldState.CROSS);
            board.getFieldAt(TicTacToePosition.of(1, 0)).changeState(TicTacToeFieldState.NOUGHT);
            board.getFieldAt(TicTacToePosition.of(1, 1)).changeState(TicTacToeFieldState.CROSS);
            board.getFieldAt(TicTacToePosition.of(1, 2)).changeState(TicTacToeFieldState.NOUGHT);
            board.getFieldAt(TicTacToePosition.of(2, 0)).changeState(TicTacToeFieldState.CROSS);
            board.getFieldAt(TicTacToePosition.of(2, 1)).changeState(TicTacToeFieldState.NOUGHT);
            board.getFieldAt(TicTacToePosition.of(2, 2)).changeState(TicTacToeFieldState.CROSS);

            try (TicTacToeGame game2 = new TicTacToeGameImpl(3, state, game.getStrategies(), 
                    GameBuilder.DEFAULT_MAX_COMPUTATION_TIME_PER_MOVE, 
                    AbstractTicTacToeMove.class::isInstance, new DefaultObserverFactoryProvider())) {

                final var move2 = game2.chooseRandomMove(game2.getPlayers().get("1"), game2.getState());
                assertFalse(move2.isPresent());
            }
        }
    }
}