Content of file SSPGameBuilderImplTest.java

package de.schereSteinPapier.domain.impl;

import de.fhdw.gaming.core.domain.DefaultObserverFactoryProvider;
import de.fhdw.gaming.core.domain.GameException;
import de.fhdw.gaming.core.domain.ObserverFactoryProvider;
import de.schereSteinPapier.domain.*;

//import static org.junit.jupiter.api.Assertions.assertThrows;

//import org.junit.jupiter.api.Test;

//import de.fhdw.gaming.core.domain.GameException;
//import de.schereSteinPapier.domain.SSPGameBuilder;

import de.schereSteinPapier.domain.factory.SSPStrategyFactory;
import de.schereSteinPapier.moves.factory.SSPMoveFactory;
import de.schereSteinPapier.moves.impl.SSPDefaultMoveFactory;

import static de.schereSteinPapier.SSPConstants.AuswahlConstants.PAPIER;
import static de.schereSteinPapier.SSPConstants.AuswahlConstants.SCHERE;
import static de.schereSteinPapier.SSPConstants.AuswahlConstants.STEIN;

import de.schereSteinPapier.strategy.SSPSayEquilibriumStrategyFactory;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;

import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.containsInAnyOrder;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;

import java.util.LinkedHashMap;
import java.util.Map;

/**
 * Tests {@link class SSPGameBuilderImpl}.
 */
class SSPGameBuilderImplTest {

    /**
     * GameBuilder
     */
    private SSPGameBuilderImpl sspGameBuilder;

    /**
     * Setup
     */
    @BeforeEach
    void setUp() {
        this.sspGameBuilder = new SSPGameBuilderImpl();
    }

    /**
     * Tries to create an SSP game with as much defaults as possible.
     */
    @Test
    void testCreateGameWithDefaults() throws GameException, InterruptedException {
        final SSPGameBuilder builder = new SSPGameBuilderImpl();

        final Map<String, Map<String, Double>> possibleOutcomes = new LinkedHashMap<>();
        final Map<String, Double> possibleOutcomesPapier = new LinkedHashMap<>();
        final Map<String, Double> possibleOutcomesStein = new LinkedHashMap<>();
        final Map<String, Double> possibleOutcomesSchere = new LinkedHashMap<>();

        possibleOutcomesSchere.put(SCHERE, 0.0);
        possibleOutcomesSchere.put(STEIN, -1.0);
        possibleOutcomesSchere.put(PAPIER, 1.0);

        possibleOutcomesStein.put(SCHERE, 1.0);
        possibleOutcomesStein.put(STEIN, 0.0);
        possibleOutcomesStein.put(PAPIER, -1.0);

        possibleOutcomesPapier.put(SCHERE, 1.0);
        possibleOutcomesPapier.put(STEIN, -1.0);
        possibleOutcomesPapier.put(PAPIER, 0.0);

        possibleOutcomes.put(SCHERE, possibleOutcomesSchere);
        possibleOutcomes.put(STEIN, possibleOutcomesStein);
        possibleOutcomes.put(PAPIER, possibleOutcomesPapier);

        final SSPPlayerBuilder playerBuilderA = builder.createPlayerBuilder().changeName("A")
                .changePossibleOutcomes(possibleOutcomes);
        final SSPPlayerBuilder playerBuilderB = builder.createPlayerBuilder().changeName("B")
                .changePossibleOutcomes(possibleOutcomes);
        try (SSPGame game = builder.addPlayer(playerBuilderA.build(),
                        new SSPStrategyStub(new SSPDefaultMoveFactory()))
                .addPlayer(playerBuilderB.build(), new SSPStrategyStub(new SSPDefaultMoveFactory()))
                .build(1)) {

            assertThat(game.getPlayers().keySet(), containsInAnyOrder("A", "B"));
        }
    }

    /**
     * Test for method addPlayer.
     */
    @Test
    void addPlayer() throws GameException {
        final Map<String, Map<String, Double>> possibleOutcomes = createPossibleOutcomes();

        SSPPlayer firstPlayer = createPlayer("A", possibleOutcomes);
        SSPPlayer secondPlayer = createPlayer("B", possibleOutcomes);

        sspGameBuilder.addPlayer(firstPlayer, createEquilibriumStrategy());
        sspGameBuilder.addPlayer(secondPlayer, createEquilibriumStrategy());

        try {
            SSPGame game = sspGameBuilder.build(1);
            assertTrue(game.getPlayers().containsKey("A") && game.getPlayers().containsKey("B"));
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }

    Map<String, Map<String, Double>> createPossibleOutcomes() {
        final Map<String, Map<String, Double>> possibleOutcomes = new LinkedHashMap<>();
        Map<String, Double> possibleOutcomesSchere = new LinkedHashMap<>();
        Map<String, Double> possibleOutcomesStein = new LinkedHashMap<>();
        Map<String, Double> possibleOutcomesPapier = new LinkedHashMap<>();

        possibleOutcomesSchere.put(SCHERE, 0.0);
        possibleOutcomesSchere.put(STEIN, 1.0);
        possibleOutcomesSchere.put(PAPIER, -1.0);

        possibleOutcomesStein.put(STEIN, 0.0);
        possibleOutcomesStein.put(SCHERE, -1.0);
        possibleOutcomesStein.put(PAPIER, 1.0);

        possibleOutcomesPapier.put(PAPIER, 0.0);
        possibleOutcomesPapier.put(SCHERE, 1.0);
        possibleOutcomesPapier.put(STEIN, -1.0);

        possibleOutcomes.put(SCHERE, possibleOutcomesSchere);
        possibleOutcomes.put(STEIN, possibleOutcomesStein);
        possibleOutcomes.put(PAPIER, possibleOutcomesPapier);

        return possibleOutcomes;
    }

    /**
First sentence should end with a period.
Since Checkstyle 3.2

          Validates Javadoc comments to help ensure they are well
          formed.  The following checks are performed:
        

            Ensures the first sentence ends with proper punctuation
            (That is a period, question mark, or exclamation mark, by default).
            Javadoc automatically places the first sentence in the
            method summary table and index.  Without proper punctuation
            the Javadoc may be malformed.  All items eligible for the
            {@inheritDoc} tag are exempt from this
            requirement.
          

            Check text for Javadoc statements that do not have any
            description.  This includes both completely empty Javadoc,
            and Javadoc with only tags such as @param and @return.
          

            Check text for incomplete HTML tags.  Verifies that HTML
            tags have corresponding end tags and issues an "Unclosed
            HTML tag found:" error if not.  An "Extra HTML tag found:"
            error is issued if an end tag is found without a previous
            open tag.
          

           Check that a package Javadoc comment is well-formed (as
           described above) and NOT missing from any package-info.java files.
          

            Check for allowed HTML tags. The list of allowed HTML tags
            is "a", "abbr", "acronym", "address", "area", "b", "bdo",
            "big", "blockquote", "br", "caption", "cite", "code",
            "colgroup", "dd", "del", "div", "dfn", "dl", "dt", "em",
            "fieldset", "font", "h1" to "h6", "hr", "i", "img", "ins",
            "kbd", "li", "ol", "p", "pre", "q", "samp", "small", "span",
            "strong", "sub", "sup", "table", "tbody", "td", "tfoot", "th",
            "thread", "tr", "tt", "u", "ul".
          

          These checks were patterned after the checks made by the DocCheck
          doclet available from Sun. Note: Original Sun's DocCheck tool does not exist anymore.
        
     * Creates a player
     *
     * @param playerName       name of the player
     * @param possibleOutcomes Map with all possible outcomes
     * @return SSPPlayer
     */
    SSPPlayer createPlayer(String playerName, Map<String, Map<String, Double>> possibleOutcomes) {
        try {
            return sspGameBuilder.createPlayerBuilder().changeName(playerName).changePossibleOutcomes(possibleOutcomes).build();
        } catch (GameException e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * Test for method changeMaximumComputationTimePerMove.
     */
    @Test
    void changeMaximumComputationTimePerMove() {
        sspGameBuilder.changeMaximumComputationTimePerMove(7);
        assertEquals(7, sspGameBuilder.getMaxComputationTimePerMove());
    }

    /**
     * Test for method changeObserverFactoryProvider.
     */
    @Test
    void changeObserverFactoryProvider() {
        ObserverFactoryProvider provider = new DefaultObserverFactoryProvider();
        sspGameBuilder.changeObserverFactoryProvider(provider);
        assertEquals(provider, sspGameBuilder.getObserverFactoryProvider());
    }

    /**
     * Test for method, that builds a game.
     */
    @Test
    void build() throws InterruptedException, GameException {
        sspGameBuilder.addPlayer(createPlayer("A", createPossibleOutcomes()), createEquilibriumStrategy());
        sspGameBuilder.addPlayer(createPlayer("B", createPossibleOutcomes()), createEquilibriumStrategy());

        SSPGame game = sspGameBuilder.build(1);
        assertEquals(1, game.getId());
    }

    /**
     * @return an EquilibriumStrategy
     */
    SSPStrategy createEquilibriumStrategy() {
        final SSPMoveFactory moveFactory = new SSPDefaultMoveFactory();
        SSPStrategyFactory equilibriumStrategyFactory = new SSPSayEquilibriumStrategyFactory();
        return equilibriumStrategyFactory.create(moveFactory);
    }

}