source: class MovePlayingTest extends Move {
  
    @Test
    public void applyOnGame() {
  
target:     /*
       * NEW TEST CASE
       */
      String testCaseName = "New phase - card not owned is illegal";
      Contract contract = ContractFactory.createContract(100, Suit.HEARTS);
      CoincheGame game = initialGamePlayingPhase(1, contract, 1);
      contract = contract.withPlayer(p1);
      assignCards(
          Map.of(
              1, List.of("Jh", "As", "Td", "Jc", "Ah", "8h", "Js", "9h"),
              2, List.of("Ks", "Jd", "8d", "7s", "Qd", "9s", "Ac", "Th"),
              3, List.of("Kc", "9c", "Tc", "Kh", "7d", "Ts", "Kd", "7h"),
              4, List.of("7c", "9d", "Qc", "Qs", "8c", "8s", "Ad", "Qh")));
      assertThatExceptionOfType(IllegalMoveException.class)
          .as(testCaseName)
          .isThrownBy(() -> MovePlaying.cardMove(stringToCard("Kh")).applyOnGame(game))
          .withNoCause();
  
      /*
       * NEW TEST CASE
       */
      testCaseName = "New phase - Jh(T)";
      CoincheGameRound preMoveRound = game.getCurrentRound();
      try {
        GameResult<Team> result = MovePlaying.cardMove(stringToCard("Jh")).applyOnGame(game);
        assertThat(result.isFinished())
            .as(String.format("%s: check game hasn't finished", testCaseName))
            .isFalse();
      } catch (IllegalMoveException e) {
        throw new RuntimeException(String.format("%s: Illegal move wasn't expected", testCaseName));
      }
      assertThat(p1.getCards().contains(stringToCard("Jh")))
          .as(String.format("%s: check card has disappeared from hand", testCaseName))
          .isFalse();
      CoincheGameRound round = game.getCurrentRound();
      assertThat(round)
          .as(String.format("%s: check round hasn't changed", testCaseName))
          .isEqualTo(preMoveRound);
      assertThat(round.getCurrentPlayer())
          .as(String.format("%s: check current player index is 2", testCaseName))
          .isEqualTo(p2);
      GameState state = round.getState();
      assertThat(state)
          .as(String.format("%s: check state is playing state", testCaseName))
          .isInstanceOf(GameStatePlaying.class);
      GameStatePlaying playingState = (GameStatePlaying) state;
      assertThat(playingState.getTrickPointsForPlayer(p1))
          .as(String.format("%s: check p1 has 0 pts (trick)", testCaseName))
          .isEqualTo(0);
      assertThat(playingState.getTrickPointsForPlayer(p2))
          .as(String.format("%s: check p2 has 0 pts (trick)", testCaseName))
          .isEqualTo(0);
      assertThat(playingState.getTrickPointsForPlayer(p3))
          .as(String.format("%s: check p3 has 0 pts (trick)", testCaseName))
          .isEqualTo(0);
      assertThat(playingState.getTrickPointsForPlayer(p4))
          .as(String.format("%s: check p4 has 0 pts (trick)", testCaseName))
          .isEqualTo(0);
      assertThat(playingState.getCurrentTrickNumber())
          .as(String.format("%s: check current trick # is 1", testCaseName))
          .isEqualTo(1);
      Trick currentTrick = playingState.getCurrentTrick();
      assertThat(currentTrick.isEmpty())
          .as(String.format("%s: check current trick isn't empty", testCaseName))
          .isFalse();
      assertThat(currentTrick.getDesiredSuit())
          .as(String.format("%s: checktrick's desired suit is h", testCaseName))
          .isEqualTo(Suit.HEARTS);
      assertThat(currentTrick.getValue())
          .as(String.format("%s: check trick's value is 20", testCaseName))
          .isEqualTo(20);
      assertThat(currentTrick.getMaster())
          .as(String.format("%s: check trick's master is p1", testCaseName))
          .isEqualTo(p1);
      assertThat(currentTrick.getHighestTrump())
          .as(String.format("%s: check trick's highest trump is Jh", testCaseName))
          .isEqualTo(ValuedCard.fromCard(stringToCard("Jh"), Suit.HEARTS));
  
      /*
       * NEW TEST CASE
       */
      testCaseName = "Jh(T) - 7s is illegal";
      assertThatExceptionOfType(IllegalMoveException.class)
          .as(testCaseName)
          .isThrownBy(() -> MovePlaying.cardMove(stringToCard("7s")).applyOnGame(game))
          .withNoCause();
  
      /*
       * NEW TEST CASE
       */
      testCaseName = "Jh(T) - Th";
      preMoveRound = game.getCurrentRound();
      try {
        GameResult<Team> result = MovePlaying.cardMove(stringToCard("Th")).applyOnGame(game);
        assertThat(result.isFinished())
            .as(String.format("%s: check game hasn't finished", testCaseName))
            .isFalse();
      } catch (IllegalMoveException e) {
        throw new RuntimeException(String.format("%s: Illegal move wasn't expected", testCaseName));
      }
      assertThat(p2.getCards().contains(stringToCard("Th")))
          .as(String.format("%s: check card has disappeared from hand", testCaseName))
          .isFalse();
      round = game.getCurrentRound();
      assertThat(round)
          .as(String.format("%s: check round hasn't changed", testCaseName))
          .isEqualTo(preMoveRound);
      assertThat(round.getCurrentPlayer())
          .as(String.format("%s: check current player index is 3", testCaseName))
          .isEqualTo(p3);
      state = round.getState();
      assertThat(state)
          .as(String.format("%s: check state is playing state", testCaseName))
          .isInstanceOf(GameStatePlaying.class);
      playingState = (GameStatePlaying) state;
      assertThat(playingState.getTrickPointsForPlayer(p1))
          .as(String.format("%s: check p1 has 0 pts (trick)", testCaseName))
          .isEqualTo(0);
      assertThat(playingState.getTrickPointsForPlayer(p2))
          .as(String.format("%s: check p2 has 0 pts (trick)", testCaseName))
          .isEqualTo(0);
      assertThat(playingState.getTrickPointsForPlayer(p3))
          .as(String.format("%s: check p3 has 0 pts (trick)", testCaseName))
          .isEqualTo(0);
      assertThat(playingState.getTrickPointsForPlayer(p4))
          .as(String.format("%s: check p4 has 0 pts (trick)", testCaseName))
          .isEqualTo(0);
      assertThat(playingState.getCurrentTrickNumber())
          .as(String.format("%s: check current trick # is 1", testCaseName))
          .isEqualTo(1);
      currentTrick = playingState.getCurrentTrick();
      assertThat(currentTrick.isEmpty())
          .as(String.format("%s: check current trick isn't empty", testCaseName))
          .isFalse();
      assertThat(currentTrick.getDesiredSuit())
          .as(String.format("%s: checktrick's desired suit is h", testCaseName))
          .isEqualTo(Suit.HEARTS);
      assertThat(currentTrick.getValue())
          .as(String.format("%s: check trick's value is 30", testCaseName))
          .isEqualTo(30);
      assertThat(currentTrick.getMaster())
          .as(String.format("%s: check trick's master is p1", testCaseName))
          .isEqualTo(p1);
      assertThat(currentTrick.getHighestTrump())
          .as(String.format("%s: check trick's highest trump is Jh", testCaseName))
          .isEqualTo(ValuedCard.fromCard(stringToCard("Jh"), Suit.HEARTS));
  
      /*
       * NEW TEST CASE
       */
      testCaseName = "Jh(T), Th - Kh";
      preMoveRound = game.getCurrentRound();
      try {
        GameResult<Team> result = MovePlaying.cardMove(stringToCard("Kh")).applyOnGame(game);
        assertThat(result.isFinished())
            .as(String.format("%s: check game hasn't finished", testCaseName))
            .isFalse();
      } catch (IllegalMoveException e) {
        throw new RuntimeException(String.format("%s: Illegal move wasn't expected", testCaseName));
      }
      assertThat(p3.getCards().contains(stringToCard("Kh")))
          .as(String.format("%s: check card has disappeared from hand", testCaseName))
          .isFalse();
      round = game.getCurrentRound();
      assertThat(round)
          .as(String.format("%s: check round hasn't changed", testCaseName))
          .isEqualTo(preMoveRound);
      assertThat(round.getCurrentPlayer())
          .as(String.format("%s: check current player index is 4", testCaseName))
          .isEqualTo(p4);
      state = round.getState();
      assertThat(state)
          .as(String.format("%s: check state is playing state", testCaseName))
          .isInstanceOf(GameStatePlaying.class);
      playingState = (GameStatePlaying) state;
      assertThat(playingState.getTrickPointsForPlayer(p1))
          .as(String.format("%s: check p1 has 0 pts (trick)", testCaseName))
          .isEqualTo(0);
      assertThat(playingState.getTrickPointsForPlayer(p2))
          .as(String.format("%s: check p2 has 0 pts (trick)", testCaseName))
          .isEqualTo(0);
      assertThat(playingState.getTrickPointsForPlayer(p3))
          .as(String.format("%s: check p3 has 0 pts (trick)", testCaseName))
          .isEqualTo(0);
      assertThat(playingState.getTrickPointsForPlayer(p4))
          .as(String.format("%s: check p4 has 0 pts (trick)", testCaseName))
          .isEqualTo(0);
      assertThat(playingState.getCurrentTrickNumber())
          .as(String.format("%s: check current trick # is 1", testCaseName))
          .isEqualTo(1);
      currentTrick = playingState.getCurrentTrick();
      assertThat(currentTrick.isEmpty())
          .as(String.format("%s: check current trick isn't empty", testCaseName))
          .isFalse();
      assertThat(currentTrick.getDesiredSuit())
          .as(String.format("%s: checktrick's desired suit is h", testCaseName))
          .isEqualTo(Suit.HEARTS);
      assertThat(currentTrick.getValue())
          .as(String.format("%s: check trick's value is 34", testCaseName))
          .isEqualTo(34);
      assertThat(currentTrick.getMaster())
          .as(String.format("%s: check trick's master is p1", testCaseName))
          .isEqualTo(p1);
      assertThat(currentTrick.getHighestTrump())
          .as(String.format("%s: check trick's highest trump is Jh", testCaseName))
          .isEqualTo(ValuedCard.fromCard(stringToCard("Jh"), Suit.HEARTS));
  
      /*
       * NEW TEST CASE
       */
      testCaseName = "Jh(T), Th, Kh - Qh";
      preMoveRound = game.getCurrentRound();
      try {
        GameResult<Team> result = MovePlaying.cardMove(stringToCard("Qh")).applyOnGame(game);
        assertThat(result.isFinished())
            .as(String.format("%s: check game hasn't finished", testCaseName))
            .isFalse();
      } catch (IllegalMoveException e) {
        throw new RuntimeException(String.format("%s: Illegal move wasn't expected", testCaseName));
      }
      assertThat(p4.getCards().contains(stringToCard("Qh")))
          .as(String.format("%s: check card has disappeared from hand", testCaseName))
          .isFalse();
      round = game.getCurrentRound();
      assertThat(round)
          .as(String.format("%s: check round hasn't changed", testCaseName))
          .isEqualTo(preMoveRound);
      assertThat(round.getCurrentPlayer())
          .as(String.format("%s: check current player index is 1", testCaseName))
          .isEqualTo(p1);
      state = round.getState();
      assertThat(state)
          .as(String.format("%s: check state is playing state", testCaseName))
          .isInstanceOf(GameStatePlaying.class);
      playingState = (GameStatePlaying) state;
      assertThat(playingState.getTrickPointsForPlayer(p1))
          .as(String.format("%s: check p1 has 37 pts (trick)", testCaseName))
          .isEqualTo(37);
      assertThat(playingState.getTrickPointsForPlayer(p2))
          .as(String.format("%s: check p2 has 0 pts (trick)", testCaseName))
          .isEqualTo(0);
      assertThat(playingState.getTrickPointsForPlayer(p3))
          .as(String.format("%s: check p3 has 0 pts (trick)", testCaseName))
          .isEqualTo(0);
      assertThat(playingState.getTrickPointsForPlayer(p4))
          .as(String.format("%s: check p4 has 0 pts (trick)", testCaseName))
          .isEqualTo(0);
      assertThat(playingState.getCurrentTrickNumber())
          .as(String.format("%s: check current trick # is 2", testCaseName))
          .isEqualTo(2);
      currentTrick = playingState.getCurrentTrick();
      assertThat(currentTrick.isEmpty())
          .as(String.format("%s: check current trick is empty", testCaseName))
          .isTrue();
  
      /*
       * NEW TEST CASE
       */
      testCaseName = "Jh is no longer legal";
      assertThatExceptionOfType(IllegalMoveException.class)
          .as(testCaseName)
          .isThrownBy(() -> MovePlaying.cardMove(stringToCard("Jh")).applyOnGame(game))
          .withNoCause();
  
      /*
       * NEW TEST CASE
       */
      testCaseName = "Jc";
      preMoveRound = game.getCurrentRound();
      try {
        GameResult<Team> result = MovePlaying.cardMove(stringToCard("Jc")).applyOnGame(game);
        assertThat(result.isFinished())
            .as(String.format("%s: check game hasn't finished", testCaseName))
            .isFalse();
      } catch (IllegalMoveException e) {
        throw new RuntimeException(String.format("%s: Illegal move wasn't expected", testCaseName));
      }
      assertThat(p1.getCards().contains(stringToCard("Jc")))
          .as(String.format("%s: check card has disappeared from hand", testCaseName))
          .isFalse();
      round = game.getCurrentRound();
      assertThat(round)
          .as(String.format("%s: check round hasn't changed", testCaseName))
          .isEqualTo(preMoveRound);
      assertThat(round.getCurrentPlayer())
          .as(String.format("%s: check current player index is 2", testCaseName))
          .isEqualTo(p2);
      state = round.getState();
      assertThat(state)
          .as(String.format("%s: check state is playing state", testCaseName))
          .isInstanceOf(GameStatePlaying.class);
      playingState = (GameStatePlaying) state;
      assertThat(playingState.getTrickPointsForPlayer(p1))
          .as(String.format("%s: check p1 has 37 pts (trick)", testCaseName))
          .isEqualTo(37);
      assertThat(playingState.getTrickPointsForPlayer(p2))
          .as(String.format("%s: check p2 has 0 pts (trick)", testCaseName))
          .isEqualTo(0);
      assertThat(playingState.getTrickPointsForPlayer(p3))
          .as(String.format("%s: check p3 has 0 pts (trick)", testCaseName))
          .isEqualTo(0);
      assertThat(playingState.getTrickPointsForPlayer(p4))
          .as(String.format("%s: check p4 has 0 pts (trick)", testCaseName))
          .isEqualTo(0);
      assertThat(playingState.getCurrentTrickNumber())
          .as(String.format("%s: check current trick # is 2", testCaseName))
          .isEqualTo(2);
      currentTrick = playingState.getCurrentTrick();
      assertThat(currentTrick.isEmpty())
          .as(String.format("%s: check current trick isn't empty", testCaseName))
          .isFalse();
      assertThat(currentTrick.getDesiredSuit())
          .as(String.format("%s: checktrick's desired suit is c", testCaseName))
          .isEqualTo(Suit.CLUBS);
      assertThat(currentTrick.getValue())
          .as(String.format("%s: check trick's value is 2", testCaseName))
          .isEqualTo(2);
      assertThat(currentTrick.getMaster())
          .as(String.format("%s: check trick's master is p1", testCaseName))
          .isEqualTo(p1);
      assertThat(currentTrick.getHighestTrump())
          .as(String.format("%s: check trick's highest trump is null", testCaseName))
          .isNull();
  
      /*
       * NEW TEST CASE
       */
      testCaseName = "Jc - Ac";
      preMoveRound = game.getCurrentRound();
      try {
        GameResult<Team> result = MovePlaying.cardMove(stringToCard("Ac")).applyOnGame(game);
        assertThat(result.isFinished())
            .as(String.format("%s: check game hasn't finished", testCaseName))
            .isFalse();
      } catch (IllegalMoveException e) {
        throw new RuntimeException(String.format("%s: Illegal move wasn't expected", testCaseName));
      }
      assertThat(p2.getCards().contains(stringToCard("Ac")))
          .as(String.format("%s: check card has disappeared from hand", testCaseName))
          .isFalse();
      round = game.getCurrentRound();
      assertThat(round)
          .as(String.format("%s: check round hasn't changed", testCaseName))
          .isEqualTo(preMoveRound);
      assertThat(round.getCurrentPlayer())
          .as(String.format("%s: check current player index is 3", testCaseName))
          .isEqualTo(p3);
      state = round.getState();
      assertThat(state)
          .as(String.format("%s: check state is playing state", testCaseName))
          .isInstanceOf(GameStatePlaying.class);
      playingState = (GameStatePlaying) state;
      assertThat(playingState.getTrickPointsForPlayer(p1))
          .as(String.format("%s: check p1 has 37 pts (trick)", testCaseName))
          .isEqualTo(37);
      assertThat(playingState.getTrickPointsForPlayer(p2))
          .as(String.format("%s: check p2 has 0 pts (trick)", testCaseName))
          .isEqualTo(0);
      assertThat(playingState.getTrickPointsForPlayer(p3))
          .as(String.format("%s: check p3 has 0 pts (trick)", testCaseName))
          .isEqualTo(0);
      assertThat(playingState.getTrickPointsForPlayer(p4))
          .as(String.format("%s: check p4 has 0 pts (trick)", testCaseName))
          .isEqualTo(0);
      assertThat(playingState.getCurrentTrickNumber())
          .as(String.format("%s: check current trick # is 2", testCaseName))
          .isEqualTo(2);
      currentTrick = playingState.getCurrentTrick();
      assertThat(currentTrick.isEmpty())
          .as(String.format("%s: check current trick isn't empty", testCaseName))
          .isFalse();
      assertThat(currentTrick.getDesiredSuit())
          .as(String.format("%s: checktrick's desired suit is c", testCaseName))
          .isEqualTo(Suit.CLUBS);
      assertThat(currentTrick.getValue())
          .as(String.format("%s: check trick's value is 13", testCaseName))
          .isEqualTo(13);
      assertThat(currentTrick.getMaster())
          .as(String.format("%s: check trick's master is p2", testCaseName))
          .isEqualTo(p2);
      assertThat(currentTrick.getHighestTrump())
          .as(String.format("%s: check trick's highest trump is null", testCaseName))
          .isNull();
  
      /*
       * NEW TEST CASE
       */
      testCaseName = "Jc, Ac - 9c";
      preMoveRound = game.getCurrentRound();
      try {
        GameResult<Team> result = MovePlaying.cardMove(stringToCard("9c")).applyOnGame(game);
        assertThat(result.isFinished())
            .as(String.format("%s: check game hasn't finished", testCaseName))
            .isFalse();
      } catch (IllegalMoveException e) {
        throw new RuntimeException(String.format("%s: Illegal move wasn't expected", testCaseName));
      }
      assertThat(p3.getCards().contains(stringToCard("9c")))
          .as(String.format("%s: check card has disappeared from hand", testCaseName))
          .isFalse();
      round = game.getCurrentRound();
      assertThat(round)
          .as(String.format("%s: check round hasn't changed", testCaseName))
          .isEqualTo(preMoveRound);
      assertThat(round.getCurrentPlayer())
          .as(String.format("%s: check current player index is 4", testCaseName))
          .isEqualTo(p4);
      state = round.getState();
      assertThat(state)
          .as(String.format("%s: check state is playing state", testCaseName))
          .isInstanceOf(GameStatePlaying.class);
      playingState = (GameStatePlaying) state;
      assertThat(playingState.getTrickPointsForPlayer(p1))
          .as(String.format("%s: check p1 has 37 pts (trick)", testCaseName))
          .isEqualTo(37);
      assertThat(playingState.getTrickPointsForPlayer(p2))
          .as(String.format("%s: check p2 has 0 pts (trick)", testCaseName))
          .isEqualTo(0);
      assertThat(playingState.getTrickPointsForPlayer(p3))
          .as(String.format("%s: check p3 has 0 pts (trick)", testCaseName))
          .isEqualTo(0);
      assertThat(playingState.getTrickPointsForPlayer(p4))
          .as(String.format("%s: check p4 has 0 pts (trick)", testCaseName))
          .isEqualTo(0);
      assertThat(playingState.getCurrentTrickNumber())
          .as(String.format("%s: check current trick # is 2", testCaseName))
          .isEqualTo(2);
      currentTrick = playingState.getCurrentTrick();
      assertThat(currentTrick.isEmpty())
          .as(String.format("%s: check current trick isn't empty", testCaseName))
          .isFalse();
      assertThat(currentTrick.getDesiredSuit())
          .as(String.format("%s: checktrick's desired suit is c", testCaseName))
          .isEqualTo(Suit.CLUBS);
      assertThat(currentTrick.getValue())
          .as(String.format("%s: check trick's value is 13", testCaseName))
          .isEqualTo(13);
      assertThat(currentTrick.getMaster())
          .as(String.format("%s: check trick's master is p2", testCaseName))
          .isEqualTo(p2);
      assertThat(currentTrick.getHighestTrump())
          .as(String.format("%s: check trick's highest trump is null", testCaseName))
          .isNull();
  
      /*
       * NEW TEST CASE
       */
      testCaseName = "Jc, Ac, 9c - Qc";
      preMoveRound = game.getCurrentRound();
      try {
        GameResult<Team> result = MovePlaying.cardMove(stringToCard("Qc")).applyOnGame(game);
        assertThat(result.isFinished())
            .as(String.format("%s: check game hasn't finished", testCaseName))
            .isFalse();
      } catch (IllegalMoveException e) {
        throw new RuntimeException(String.format("%s: Illegal move wasn't expected", testCaseName));
      }
      assertThat(p4.getCards().contains(stringToCard("Qc")))
          .as(String.format("%s: check card has disappeared from hand", testCaseName))
          .isFalse();
      round = game.getCurrentRound();
      assertThat(round)
          .as(String.format("%s: check round hasn't changed", testCaseName))
          .isEqualTo(preMoveRound);
      assertThat(round.getCurrentPlayer())
          .as(String.format("%s: check current player index is 2", testCaseName))
          .isEqualTo(p2);
      state = round.getState();
      assertThat(state)
          .as(String.format("%s: check state is playing state", testCaseName))
          .isInstanceOf(GameStatePlaying.class);
      playingState = (GameStatePlaying) state;
      assertThat(playingState.getTrickPointsForPlayer(p1))
          .as(String.format("%s: check p1 has 37 pts (trick)", testCaseName))
          .isEqualTo(37);
      assertThat(playingState.getTrickPointsForPlayer(p2))
          .as(String.format("%s: check p2 has 16 pts (trick)", testCaseName))
          .isEqualTo(16);
      assertThat(playingState.getTrickPointsForPlayer(p3))
          .as(String.format("%s: check p3 has 0 pts (trick)", testCaseName))
          .isEqualTo(0);
      assertThat(playingState.getTrickPointsForPlayer(p4))
          .as(String.format("%s: check p4 has 0 pts (trick)", testCaseName))
          .isEqualTo(0);
      assertThat(playingState.getCurrentTrickNumber())
          .as(String.format("%s: check current trick # is 3", testCaseName))
          .isEqualTo(3);
      currentTrick = playingState.getCurrentTrick();
      assertThat(currentTrick.isEmpty())
          .as(String.format("%s: check current trick is empty", testCaseName))
          .isTrue();
  
      /*
       * NEW TEST CASE
       */
      testCaseName = "Qd";
      preMoveRound = game.getCurrentRound();
      try {
        GameResult<Team> result = MovePlaying.cardMove(stringToCard("Qd")).applyOnGame(game);
        assertThat(result.isFinished())
            .as(String.format("%s: check game hasn't finished", testCaseName))
            .isFalse();
      } catch (IllegalMoveException e) {
        throw new RuntimeException(String.format("%s: Illegal move wasn't expected", testCaseName));
      }
      assertThat(p2.getCards().contains(stringToCard("Qd")))
          .as(String.format("%s: check card has disappeared from hand", testCaseName))
          .isFalse();
      round = game.getCurrentRound();
      assertThat(round)
          .as(String.format("%s: check round hasn't changed", testCaseName))
          .isEqualTo(preMoveRound);
      assertThat(round.getCurrentPlayer())
          .as(String.format("%s: check current player index is 3", testCaseName))
          .isEqualTo(p3);
      state = round.getState();
      assertThat(state)
          .as(String.format("%s: check state is playing state", testCaseName))
          .isInstanceOf(GameStatePlaying.class);
      playingState = (GameStatePlaying) state;
      assertThat(playingState.getTrickPointsForPlayer(p1))
          .as(String.format("%s: check p1 has 37 pts (trick)", testCaseName))
          .isEqualTo(37);
      assertThat(playingState.getTrickPointsForPlayer(p2))
          .as(String.format("%s: check p2 has 16 pts (trick)", testCaseName))
          .isEqualTo(16);
      assertThat(playingState.getTrickPointsForPlayer(p3))
          .as(String.format("%s: check p3 has 0 pts (trick)", testCaseName))
          .isEqualTo(0);
      assertThat(playingState.getTrickPointsForPlayer(p4))
          .as(String.format("%s: check p4 has 0 pts (trick)", testCaseName))
          .isEqualTo(0);
      assertThat(playingState.getCurrentTrickNumber())
          .as(String.format("%s: check current trick # is 3", testCaseName))
          .isEqualTo(3);
      currentTrick = playingState.getCurrentTrick();
      assertThat(currentTrick.isEmpty())
          .as(String.format("%s: check current trick isn't empty", testCaseName))
          .isFalse();
      assertThat(currentTrick.getDesiredSuit())
          .as(String.format("%s: checktrick's desired suit is d", testCaseName))
          .isEqualTo(Suit.DIAMONDS);
      assertThat(currentTrick.getValue())
          .as(String.format("%s: check trick's value is 3", testCaseName))
          .isEqualTo(3);
      assertThat(currentTrick.getMaster())
          .as(String.format("%s: check trick's master is p2", testCaseName))
          .isEqualTo(p2);
      assertThat(currentTrick.getHighestTrump())
          .as(String.format("%s: check trick's highest trump is null", testCaseName))
          .isNull();
  
      /*
       * NEW TEST CASE
       */
      testCaseName = "Qd - Kd";
      preMoveRound = game.getCurrentRound();
      try {
        GameResult<Team> result = MovePlaying.cardMove(stringToCard("Kd")).applyOnGame(game);
        assertThat(result.isFinished())
            .as(String.format("%s: check game hasn't finished", testCaseName))
            .isFalse();
      } catch (IllegalMoveException e) {
        throw new RuntimeException(String.format("%s: Illegal move wasn't expected", testCaseName));
      }
      assertThat(p3.getCards().contains(stringToCard("Kd")))
          .as(String.format("%s: check card has disappeared from hand", testCaseName))
          .isFalse();
      round = game.getCurrentRound();
      assertThat(round)
          .as(String.format("%s: check round hasn't changed", testCaseName))
          .isEqualTo(preMoveRound);
      assertThat(round.getCurrentPlayer())
          .as(String.format("%s: check current player index is 4", testCaseName))
          .isEqualTo(p4);
      state = round.getState();
      assertThat(state)
          .as(String.format("%s: check state is playing state", testCaseName))
          .isInstanceOf(GameStatePlaying.class);
      playingState = (GameStatePlaying) state;
      assertThat(playingState.getTrickPointsForPlayer(p1))
          .as(String.format("%s: check p1 has 37 pts (trick)", testCaseName))
          .isEqualTo(37);
      assertThat(playingState.getTrickPointsForPlayer(p2))
          .as(String.format("%s: check p2 has 16 pts (trick)", testCaseName))
          .isEqualTo(16);
      assertThat(playingState.getTrickPointsForPlayer(p3))
          .as(String.format("%s: check p3 has 0 pts (trick)", testCaseName))
          .isEqualTo(0);
      assertThat(playingState.getTrickPointsForPlayer(p4))
          .as(String.format("%s: check p4 has 0 pts (trick)", testCaseName))
          .isEqualTo(0);
      assertThat(playingState.getCurrentTrickNumber())
          .as(String.format("%s: check current trick # is 3", testCaseName))
          .isEqualTo(3);
      currentTrick = playingState.getCurrentTrick();
      assertThat(currentTrick.isEmpty())
          .as(String.format("%s: check current trick isn't empty", testCaseName))
          .isFalse();
      assertThat(currentTrick.getDesiredSuit())
          .as(String.format("%s: checktrick's desired suit is d", testCaseName))
          .isEqualTo(Suit.DIAMONDS);
      assertThat(currentTrick.getValue())
          .as(String.format("%s: check trick's value is 7", testCaseName))
          .isEqualTo(7);
      assertThat(currentTrick.getMaster())
          .as(String.format("%s: check trick's master is p3", testCaseName))
          .isEqualTo(p3);
      assertThat(currentTrick.getHighestTrump())
          .as(String.format("%s: check trick's highest trump is null", testCaseName))
          .isNull();
  
      /*
       * NEW TEST CASE
       */
      testCaseName = "Qd, Kd - Ad";
      preMoveRound = game.getCurrentRound();
      try {
        GameResult<Team> result = MovePlaying.cardMove(stringToCard("Ad")).applyOnGame(game);
        assertThat(result.isFinished())
            .as(String.format("%s: check game hasn't finished", testCaseName))
            .isFalse();
      } catch (IllegalMoveException e) {
        throw new RuntimeException(String.format("%s: Illegal move wasn't expected", testCaseName));
      }
      assertThat(p4.getCards().contains(stringToCard("Ad")))
          .as(String.format("%s: check card has disappeared from hand", testCaseName))
          .isFalse();
      round = game.getCurrentRound();
      assertThat(round)
          .as(String.format("%s: check round hasn't changed", testCaseName))
          .isEqualTo(preMoveRound);
      assertThat(round.getCurrentPlayer())
          .as(String.format("%s: check current player index is 1", testCaseName))
          .isEqualTo(p1);
      state = round.getState();
      assertThat(state)
          .as(String.format("%s: check state is playing state", testCaseName))
          .isInstanceOf(GameStatePlaying.class);
      playingState = (GameStatePlaying) state;
      assertThat(playingState.getTrickPointsForPlayer(p1))
          .as(String.format("%s: check p1 has 37 pts (trick)", testCaseName))
          .isEqualTo(37);
      assertThat(playingState.getTrickPointsForPlayer(p2))
          .as(String.format("%s: check p2 has 16 pts (trick)", testCaseName))
          .isEqualTo(16);
      assertThat(playingState.getTrickPointsForPlayer(p3))
          .as(String.format("%s: check p3 has 0 pts (trick)", testCaseName))
          .isEqualTo(0);
      assertThat(playingState.getTrickPointsForPlayer(p4))
          .as(String.format("%s: check p4 has 0 pts (trick)", testCaseName))
          .isEqualTo(0);
      assertThat(playingState.getCurrentTrickNumber())
          .as(String.format("%s: check current trick # is 3", testCaseName))
          .isEqualTo(3);
      currentTrick = playingState.getCurrentTrick();
      assertThat(currentTrick.isEmpty())
          .as(String.format("%s: check current trick isn't empty", testCaseName))
          .isFalse();
      assertThat(currentTrick.getDesiredSuit())
          .as(String.format("%s: checktrick's desired suit is d", testCaseName))
          .isEqualTo(Suit.DIAMONDS);
      assertThat(currentTrick.getValue())
          .as(String.format("%s: check trick's value is 18", testCaseName))
          .isEqualTo(18);
      assertThat(currentTrick.getMaster())
          .as(String.format("%s: check trick's master is p4", testCaseName))
          .isEqualTo(p4);
      assertThat(currentTrick.getHighestTrump())
          .as(String.format("%s: check trick's highest trump is null", testCaseName))
          .isNull();
  
      /*
       * NEW TEST CASE
       */
      testCaseName = "Qd, Kd, Ad - Td";
      preMoveRound = game.getCurrentRound();
      try {
        GameResult<Team> result = MovePlaying.cardMove(stringToCard("Td")).applyOnGame(game);
        assertThat(result.isFinished())
            .as(String.format("%s: check game hasn't finished", testCaseName))
            .isFalse();
      } catch (IllegalMoveException e) {
        throw new RuntimeException(String.format("%s: Illegal move wasn't expected", testCaseName));
      }
      assertThat(p1.getCards().contains(stringToCard("Td")))
          .as(String.format("%s: check card has disappeared from hand", testCaseName))
          .isFalse();
      round = game.getCurrentRound();
      assertThat(round)
          .as(String.format("%s: check round hasn't changed", testCaseName))
          .isEqualTo(preMoveRound);
      assertThat(round.getCurrentPlayer())
          .as(String.format("%s: check current player index is 4", testCaseName))
          .isEqualTo(p4);
      state = round.getState();
      assertThat(state)
          .as(String.format("%s: check state is playing state", testCaseName))
          .isInstanceOf(GameStatePlaying.class);
      playingState = (GameStatePlaying) state;
      assertThat(playingState.getTrickPointsForPlayer(p1))
          .as(String.format("%s: check p1 has 37 pts (trick)", testCaseName))
          .isEqualTo(37);
      assertThat(playingState.getTrickPointsForPlayer(p2))
          .as(String.format("%s: check p2 has 16 pts (trick)", testCaseName))
          .isEqualTo(16);
      assertThat(playingState.getTrickPointsForPlayer(p3))
          .as(String.format("%s: check p3 has 0 pts (trick)", testCaseName))
          .isEqualTo(0);
      assertThat(playingState.getTrickPointsForPlayer(p4))
          .as(String.format("%s: check p4 has 28 pts (trick)", testCaseName))
          .isEqualTo(28);
      assertThat(playingState.getCurrentTrickNumber())
          .as(String.format("%s: check current trick # is 4", testCaseName))
          .isEqualTo(4);
      currentTrick = playingState.getCurrentTrick();
      assertThat(currentTrick.isEmpty())
          .as(String.format("%s: check current trick is empty", testCaseName))
          .isTrue();
  
      /*
       * NEW TEST CASE
       */
      testCaseName = "9d";
      preMoveRound = game.getCurrentRound();
      try {
        GameResult<Team> result = MovePlaying.cardMove(stringToCard("9d")).applyOnGame(game);
        assertThat(result.isFinished())
            .as(String.format("%s: check game hasn't finished", testCaseName))
            .isFalse();
      } catch (IllegalMoveException e) {
        throw new RuntimeException(String.format("%s: Illegal move wasn't expected", testCaseName));
      }
      assertThat(p4.getCards().contains(stringToCard("9d")))
          .as(String.format("%s: check card has disappeared from hand", testCaseName))
          .isFalse();
      round = game.getCurrentRound();
      assertThat(round)
          .as(String.format("%s: check round hasn't changed", testCaseName))
          .isEqualTo(preMoveRound);
      assertThat(round.getCurrentPlayer())
          .as(String.format("%s: check current player index is 1", testCaseName))
          .isEqualTo(p1);
      state = round.getState();
      assertThat(state)
          .as(String.format("%s: check state is playing state", testCaseName))
          .isInstanceOf(GameStatePlaying.class);
      playingState = (GameStatePlaying) state;
      assertThat(playingState.getTrickPointsForPlayer(p1))
          .as(String.format("%s: check p1 has 37 pts (trick)", testCaseName))
          .isEqualTo(37);
      assertThat(playingState.getTrickPointsForPlayer(p2))
          .as(String.format("%s: check p2 has 16 pts (trick)", testCaseName))
          .isEqualTo(16);
      assertThat(playingState.getTrickPointsForPlayer(p3))
          .as(String.format("%s: check p3 has 0 pts (trick)", testCaseName))
          .isEqualTo(0);
      assertThat(playingState.getTrickPointsForPlayer(p4))
          .as(String.format("%s: check p4 has 28 pts (trick)", testCaseName))
          .isEqualTo(28);
      assertThat(playingState.getCurrentTrickNumber())
          .as(String.format("%s: check current trick # is 4", testCaseName))
          .isEqualTo(4);
      currentTrick = playingState.getCurrentTrick();
      assertThat(currentTrick.isEmpty())
          .as(String.format("%s: check current trick isn't empty", testCaseName))
          .isFalse();
      assertThat(currentTrick.getDesiredSuit())
          .as(String.format("%s: checktrick's desired suit is d", testCaseName))
          .isEqualTo(Suit.DIAMONDS);
      assertThat(currentTrick.getValue())
          .as(String.format("%s: check trick's value is 0", testCaseName))
          .isEqualTo(0);
      assertThat(currentTrick.getMaster())
          .as(String.format("%s: check trick's master is p4", testCaseName))
          .isEqualTo(p4);
      assertThat(currentTrick.getHighestTrump())
          .as(String.format("%s: check trick's highest trump is null", testCaseName))
          .isNull();
  
      /*
       * NEW TEST CASE
       */
      testCaseName = "9d - 8h";
      preMoveRound = game.getCurrentRound();
      try {
        GameResult<Team> result = MovePlaying.cardMove(stringToCard("8h")).applyOnGame(game);
        assertThat(result.isFinished())
            .as(String.format("%s: check game hasn't finished", testCaseName))
            .isFalse();
      } catch (IllegalMoveException e) {
        throw new RuntimeException(String.format("%s: Illegal move wasn't expected", testCaseName));
      }
      assertThat(p1.getCards().contains(stringToCard("8h")))
          .as(String.format("%s: check card has disappeared from hand", testCaseName))
          .isFalse();
      round = game.getCurrentRound();
      assertThat(round)
          .as(String.format("%s: check round hasn't changed", testCaseName))
          .isEqualTo(preMoveRound);
      assertThat(round.getCurrentPlayer())
          .as(String.format("%s: check current player index is 2", testCaseName))
          .isEqualTo(p2);
      state = round.getState();
      assertThat(state)
          .as(String.format("%s: check state is playing state", testCaseName))
          .isInstanceOf(GameStatePlaying.class);
      playingState = (GameStatePlaying) state;
      assertThat(playingState.getTrickPointsForPlayer(p1))
          .as(String.format("%s: check p1 has 37 pts (trick)", testCaseName))
          .isEqualTo(37);
      assertThat(playingState.getTrickPointsForPlayer(p2))
          .as(String.format("%s: check p2 has 16 pts (trick)", testCaseName))
          .isEqualTo(16);
      assertThat(playingState.getTrickPointsForPlayer(p3))
          .as(String.format("%s: check p3 has 0 pts (trick)", testCaseName))
          .isEqualTo(0);
      assertThat(playingState.getTrickPointsForPlayer(p4))
          .as(String.format("%s: check p4 has 28 pts (trick)", testCaseName))
          .isEqualTo(28);
      assertThat(playingState.getCurrentTrickNumber())
          .as(String.format("%s: check current trick # is 4", testCaseName))
          .isEqualTo(4);
      currentTrick = playingState.getCurrentTrick();
      assertThat(currentTrick.isEmpty())
          .as(String.format("%s: check current trick isn't empty", testCaseName))
          .isFalse();
      assertThat(currentTrick.getDesiredSuit())
          .as(String.format("%s: checktrick's desired suit is d", testCaseName))
          .isEqualTo(Suit.DIAMONDS);
      assertThat(currentTrick.getValue())
          .as(String.format("%s: check trick's value is 0", testCaseName))
          .isEqualTo(0);
      assertThat(currentTrick.getMaster())
          .as(String.format("%s: check trick's master is p1", testCaseName))
          .isEqualTo(p1);
      assertThat(currentTrick.getHighestTrump())
          .as(String.format("%s: check trick's highest trump is 8h", testCaseName))
          .isEqualTo(ValuedCard.fromCard(stringToCard("8h"), Suit.HEARTS));
  
      /*
       * NEW TEST CASE
       */
      testCaseName = "9d, 8h - 8d";
      preMoveRound = game.getCurrentRound();
      try {
        GameResult<Team> result = MovePlaying.cardMove(stringToCard("8d")).applyOnGame(game);
        assertThat(result.isFinished())
            .as(String.format("%s: check game hasn't finished", testCaseName))
            .isFalse();
      } catch (IllegalMoveException e) {
        throw new RuntimeException(String.format("%s: Illegal move wasn't expected", testCaseName));
      }
      assertThat(p2.getCards().contains(stringToCard("8d")))
          .as(String.format("%s: check card has disappeared from hand", testCaseName))
          .isFalse();
      round = game.getCurrentRound();
      assertThat(round)
          .as(String.format("%s: check round hasn't changed", testCaseName))
          .isEqualTo(preMoveRound);
      assertThat(round.getCurrentPlayer())
          .as(String.format("%s: check current player index is 3", testCaseName))
          .isEqualTo(p3);
      state = round.getState();
      assertThat(state)
          .as(String.format("%s: check state is playing state", testCaseName))
          .isInstanceOf(GameStatePlaying.class);
      playingState = (GameStatePlaying) state;
      assertThat(playingState.getTrickPointsForPlayer(p1))
          .as(String.format("%s: check p1 has 37 pts (trick)", testCaseName))
          .isEqualTo(37);
      assertThat(playingState.getTrickPointsForPlayer(p2))
          .as(String.format("%s: check p2 has 16 pts (trick)", testCaseName))
          .isEqualTo(16);
      assertThat(playingState.getTrickPointsForPlayer(p3))
          .as(String.format("%s: check p3 has 0 pts (trick)", testCaseName))
          .isEqualTo(0);
      assertThat(playingState.getTrickPointsForPlayer(p4))
          .as(String.format("%s: check p4 has 28 pts (trick)", testCaseName))
          .isEqualTo(28);
      assertThat(playingState.getCurrentTrickNumber())
          .as(String.format("%s: check current trick # is 4", testCaseName))
          .isEqualTo(4);
      currentTrick = playingState.getCurrentTrick();
      assertThat(currentTrick.isEmpty())
          .as(String.format("%s: check current trick isn't empty", testCaseName))
          .isFalse();
      assertThat(currentTrick.getDesiredSuit())
          .as(String.format("%s: checktrick's desired suit is d", testCaseName))
          .isEqualTo(Suit.DIAMONDS);
      assertThat(currentTrick.getValue())
          .as(String.format("%s: check trick's value is 0", testCaseName))
          .isEqualTo(0);
      assertThat(currentTrick.getMaster())
          .as(String.format("%s: check trick's master is p1", testCaseName))
          .isEqualTo(p1);
      assertThat(currentTrick.getHighestTrump())
          .as(String.format("%s: check trick's highest trump is 8h", testCaseName))
          .isEqualTo(ValuedCard.fromCard(stringToCard("8h"), Suit.HEARTS));
  
      /*
       * NEW TEST CASE
       */
      testCaseName = "9d, 8h, 8d - 7d";
      preMoveRound = game.getCurrentRound();
      try {
        GameResult<Team> result = MovePlaying.cardMove(stringToCard("7d")).applyOnGame(game);
        assertThat(result.isFinished())
            .as(String.format("%s: check game hasn't finished", testCaseName))
            .isFalse();
      } catch (IllegalMoveException e) {
        throw new RuntimeException(String.format("%s: Illegal move wasn't expected", testCaseName));
      }
      assertThat(p2.getCards().contains(stringToCard("7d")))
          .as(String.format("%s: check card has disappeared from hand", testCaseName))
          .isFalse();
      round = game.getCurrentRound();
      assertThat(round)
          .as(String.format("%s: check round hasn't changed", testCaseName))
          .isEqualTo(preMoveRound);
      assertThat(round.getCurrentPlayer())
          .as(String.format("%s: check current player index is 1", testCaseName))
          .isEqualTo(p1);
      state = round.getState();
      assertThat(state)
          .as(String.format("%s: check state is playing state", testCaseName))
          .isInstanceOf(GameStatePlaying.class);
      playingState = (GameStatePlaying) state;
      assertThat(playingState.getTrickPointsForPlayer(p1))
          .as(String.format("%s: check p1 has 37 pts (trick)", testCaseName))
          .isEqualTo(37);
      assertThat(playingState.getTrickPointsForPlayer(p2))
          .as(String.format("%s: check p2 has 16 pts (trick)", testCaseName))
          .isEqualTo(16);
      assertThat(playingState.getTrickPointsForPlayer(p3))
          .as(String.format("%s: check p3 has 0 pts (trick)", testCaseName))
          .isEqualTo(0);
      assertThat(playingState.getTrickPointsForPlayer(p4))
          .as(String.format("%s: check p4 has 28 pts (trick)", testCaseName))
          .isEqualTo(28);
      assertThat(playingState.getCurrentTrickNumber())
          .as(String.format("%s: check current trick # is 5", testCaseName))
          .isEqualTo(5);
      currentTrick = playingState.getCurrentTrick();
      assertThat(currentTrick.isEmpty())
          .as(String.format("%s: check current trick is empty", testCaseName))
          .isTrue();
  
      /*
       * NEW TEST CASE
       */
      testCaseName = "As";
      preMoveRound = game.getCurrentRound();
      try {
        GameResult<Team> result = MovePlaying.cardMove(stringToCard("As")).applyOnGame(game);
        assertThat(result.isFinished())
            .as(String.format("%s: check game hasn't finished", testCaseName))
            .isFalse();
      } catch (IllegalMoveException e) {
        throw new RuntimeException(String.format("%s: Illegal move wasn't expected", testCaseName));
      }
      assertThat(p1.getCards().contains(stringToCard("As")))
          .as(String.format("%s: check card has disappeared from hand", testCaseName))
          .isFalse();
      round = game.getCurrentRound();
      assertThat(round)
          .as(String.format("%s: check round hasn't changed", testCaseName))
          .isEqualTo(preMoveRound);
      assertThat(round.getCurrentPlayer())
          .as(String.format("%s: check current player index is 2", testCaseName))
          .isEqualTo(p2);
      state = round.getState();
      assertThat(state)
          .as(String.format("%s: check state is playing state", testCaseName))
          .isInstanceOf(GameStatePlaying.class);
      playingState = (GameStatePlaying) state;
      assertThat(playingState.getTrickPointsForPlayer(p1))
          .as(String.format("%s: check p1 has 37 pts (trick)", testCaseName))
          .isEqualTo(37);
      assertThat(playingState.getTrickPointsForPlayer(p2))
          .as(String.format("%s: check p2 has 16 pts (trick)", testCaseName))
          .isEqualTo(16);
      assertThat(playingState.getTrickPointsForPlayer(p3))
          .as(String.format("%s: check p3 has 0 pts (trick)", testCaseName))
          .isEqualTo(0);
      assertThat(playingState.getTrickPointsForPlayer(p4))
          .as(String.format("%s: check p4 has 28 pts (trick)", testCaseName))
          .isEqualTo(28);
      assertThat(playingState.getCurrentTrickNumber())
          .as(String.format("%s: check current trick # is 5", testCaseName))
          .isEqualTo(5);
      currentTrick = playingState.getCurrentTrick();
      assertThat(currentTrick.isEmpty())
          .as(String.format("%s: check current trick isn't empty", testCaseName))
          .isFalse();
      assertThat(currentTrick.getDesiredSuit())
          .as(String.format("%s: checktrick's desired suit is s", testCaseName))
          .isEqualTo(Suit.SPADES);
      assertThat(currentTrick.getValue())
          .as(String.format("%s: check trick's value is 11", testCaseName))
          .isEqualTo(11);
      assertThat(currentTrick.getMaster())
          .as(String.format("%s: check trick's master is p1", testCaseName))
          .isEqualTo(p1);
      assertThat(currentTrick.getHighestTrump())
          .as(String.format("%s: check trick's highest trump is null", testCaseName))
          .isNull();
  
      /*
       * NEW TEST CASE
       */
      testCaseName = "As - 7s";
      preMoveRound = game.getCurrentRound();
      try {
        GameResult<Team> result = MovePlaying.cardMove(stringToCard("7s")).applyOnGame(game);
        assertThat(result.isFinished())
            .as(String.format("%s: check game hasn't finished", testCaseName))
            .isFalse();
      } catch (IllegalMoveException e) {
        throw new RuntimeException(String.format("%s: Illegal move wasn't expected", testCaseName));
      }
      assertThat(p2.getCards().contains(stringToCard("7s")))
          .as(String.format("%s: check card has disappeared from hand", testCaseName))
          .isFalse();
      round = game.getCurrentRound();
      assertThat(round)
          .as(String.format("%s: check round hasn't changed", testCaseName))
          .isEqualTo(preMoveRound);
      assertThat(round.getCurrentPlayer())
          .as(String.format("%s: check current player index is 3", testCaseName))
          .isEqualTo(p3);
      state = round.getState();
      assertThat(state)
          .as(String.format("%s: check state is playing state", testCaseName))
          .isInstanceOf(GameStatePlaying.class);
      playingState = (GameStatePlaying) state;
      assertThat(playingState.getTrickPointsForPlayer(p1))
          .as(String.format("%s: check p1 has 37 pts (trick)", testCaseName))
          .isEqualTo(37);
      assertThat(playingState.getTrickPointsForPlayer(p2))
          .as(String.format("%s: check p2 has 16 pts (trick)", testCaseName))
          .isEqualTo(16);
      assertThat(playingState.getTrickPointsForPlayer(p3))
          .as(String.format("%s: check p3 has 0 pts (trick)", testCaseName))
          .isEqualTo(0);
      assertThat(playingState.getTrickPointsForPlayer(p4))
          .as(String.format("%s: check p4 has 28 pts (trick)", testCaseName))
          .isEqualTo(28);
      assertThat(playingState.getCurrentTrickNumber())
          .as(String.format("%s: check current trick # is 5", testCaseName))
          .isEqualTo(5);
      currentTrick = playingState.getCurrentTrick();
      assertThat(currentTrick.isEmpty())
          .as(String.format("%s: check current trick isn't empty", testCaseName))
          .isFalse();
      assertThat(currentTrick.getDesiredSuit())
          .as(String.format("%s: checktrick's desired suit is s", testCaseName))
          .isEqualTo(Suit.SPADES);
      assertThat(currentTrick.getValue())
          .as(String.format("%s: check trick's value is 11", testCaseName))
          .isEqualTo(11);
      assertThat(currentTrick.getMaster())
          .as(String.format("%s: check trick's master is p1", testCaseName))
          .isEqualTo(p1);
      assertThat(currentTrick.getHighestTrump())
          .as(String.format("%s: check trick's highest trump is null", testCaseName))
          .isNull();
  
      /*
       * NEW TEST CASE
       */
      testCaseName = "As, 7s - Ts";
      preMoveRound = game.getCurrentRound();
      try {
        GameResult<Team> result = MovePlaying.cardMove(stringToCard("Ts")).applyOnGame(game);
        assertThat(result.isFinished())
            .as(String.format("%s: check game hasn't finished", testCaseName))
            .isFalse();
      } catch (IllegalMoveException e) {
        throw new RuntimeException(String.format("%s: Illegal move wasn't expected", testCaseName));
      }
      assertThat(p3.getCards().contains(stringToCard("Ts")))
          .as(String.format("%s: check card has disappeared from hand", testCaseName))
          .isFalse();
      round = game.getCurrentRound();
      assertThat(round)
          .as(String.format("%s: check round hasn't changed", testCaseName))
          .isEqualTo(preMoveRound);
      assertThat(round.getCurrentPlayer())
          .as(String.format("%s: check current player index is 4", testCaseName))
          .isEqualTo(p4);
      state = round.getState();
      assertThat(state)
          .as(String.format("%s: check state is playing state", testCaseName))
          .isInstanceOf(GameStatePlaying.class);
      playingState = (GameStatePlaying) state;
      assertThat(playingState.getTrickPointsForPlayer(p1))
          .as(String.format("%s: check p1 has 37 pts (trick)", testCaseName))
          .isEqualTo(37);
      assertThat(playingState.getTrickPointsForPlayer(p2))
          .as(String.format("%s: check p2 has 16 pts (trick)", testCaseName))
          .isEqualTo(16);
      assertThat(playingState.getTrickPointsForPlayer(p3))
          .as(String.format("%s: check p3 has 0 pts (trick)", testCaseName))
          .isEqualTo(0);
      assertThat(playingState.getTrickPointsForPlayer(p4))
          .as(String.format("%s: check p4 has 28 pts (trick)", testCaseName))
          .isEqualTo(28);
      assertThat(playingState.getCurrentTrickNumber())
          .as(String.format("%s: check current trick # is 5", testCaseName))
          .isEqualTo(5);
      currentTrick = playingState.getCurrentTrick();
      assertThat(currentTrick.isEmpty())
          .as(String.format("%s: check current trick isn't empty", testCaseName))
          .isFalse();
      assertThat(currentTrick.getDesiredSuit())
          .as(String.format("%s: checktrick's desired suit is s", testCaseName))
          .isEqualTo(Suit.SPADES);
      assertThat(currentTrick.getValue())
          .as(String.format("%s: check trick's value is 0", testCaseName))
          .isEqualTo(21);
      assertThat(currentTrick.getMaster())
          .as(String.format("%s: check trick's master is p1", testCaseName))
          .isEqualTo(p1);
      assertThat(currentTrick.getHighestTrump())
          .as(String.format("%s: check trick's highest trump is null", testCaseName))
          .isNull();
  
      /*
       * NEW TEST CASE
       */
      testCaseName = "As, 7s, Ts - 8s";
      preMoveRound = game.getCurrentRound();
      try {
        GameResult<Team> result = MovePlaying.cardMove(stringToCard("8s")).applyOnGame(game);
        assertThat(result.isFinished())
            .as(String.format("%s: check game hasn't finished", testCaseName))
            .isFalse();
      } catch (IllegalMoveException e) {
        throw new RuntimeException(String.format("%s: Illegal move wasn't expected", testCaseName));
      }
      assertThat(p4.getCards().contains(stringToCard("8s")))
          .as(String.format("%s: check card has disappeared from hand", testCaseName))
          .isFalse();
      round = game.getCurrentRound();
      assertThat(round)
          .as(String.format("%s: check round hasn't changed", testCaseName))
          .isEqualTo(preMoveRound);
      assertThat(round.getCurrentPlayer())
          .as(String.format("%s: check current player index is 1", testCaseName))
          .isEqualTo(p1);
      state = round.getState();
      assertThat(state)
          .as(String.format("%s: check state is playing state", testCaseName))
          .isInstanceOf(GameStatePlaying.class);
      playingState = (GameStatePlaying) state;
      assertThat(playingState.getTrickPointsForPlayer(p1))
          .as(String.format("%s: check p1 has 58 pts (trick)", testCaseName))
          .isEqualTo(58);
      assertThat(playingState.getTrickPointsForPlayer(p2))
          .as(String.format("%s: check p2 has 16 pts (trick)", testCaseName))
          .isEqualTo(16);
      assertThat(playingState.getTrickPointsForPlayer(p3))
          .as(String.format("%s: check p3 has 0 pts (trick)", testCaseName))
          .isEqualTo(0);
      assertThat(playingState.getTrickPointsForPlayer(p4))
          .as(String.format("%s: check p4 has 28 pts (trick)", testCaseName))
          .isEqualTo(28);
      assertThat(playingState.getCurrentTrickNumber())
          .as(String.format("%s: check current trick # is 6", testCaseName))
          .isEqualTo(6);
      currentTrick = playingState.getCurrentTrick();
      assertThat(currentTrick.isEmpty())
          .as(String.format("%s: check current trick is empty", testCaseName))
          .isTrue();
  
      /*
       * NEW TEST CASE
       */
      testCaseName = "Js";
      preMoveRound = game.getCurrentRound();
      try {
        GameResult<Team> result = MovePlaying.cardMove(stringToCard("Js")).applyOnGame(game);
        assertThat(result.isFinished())
            .as(String.format("%s: check game hasn't finished", testCaseName))
            .isFalse();
      } catch (IllegalMoveException e) {
        throw new RuntimeException(String.format("%s: Illegal move wasn't expected", testCaseName));
      }
      assertThat(p1.getCards().contains(stringToCard("Js")))
          .as(String.format("%s: check card has disappeared from hand", testCaseName))
          .isFalse();
      round = game.getCurrentRound();
      assertThat(round)
          .as(String.format("%s: check round hasn't changed", testCaseName))
          .isEqualTo(preMoveRound);
      assertThat(round.getCurrentPlayer())
          .as(String.format("%s: check current player index is 2", testCaseName))
          .isEqualTo(p2);
      state = round.getState();
      assertThat(state)
          .as(String.format("%s: check state is playing state", testCaseName))
          .isInstanceOf(GameStatePlaying.class);
      playingState = (GameStatePlaying) state;
      assertThat(playingState.getTrickPointsForPlayer(p1))
          .as(String.format("%s: check p1 has 58 pts (trick)", testCaseName))
          .isEqualTo(58);
      assertThat(playingState.getTrickPointsForPlayer(p2))
          .as(String.format("%s: check p2 has 16 pts (trick)", testCaseName))
          .isEqualTo(16);
      assertThat(playingState.getTrickPointsForPlayer(p3))
          .as(String.format("%s: check p3 has 0 pts (trick)", testCaseName))
          .isEqualTo(0);
      assertThat(playingState.getTrickPointsForPlayer(p4))
          .as(String.format("%s: check p4 has 28 pts (trick)", testCaseName))
          .isEqualTo(28);
      assertThat(playingState.getCurrentTrickNumber())
          .as(String.format("%s: check current trick # is 6", testCaseName))
          .isEqualTo(6);
      currentTrick = playingState.getCurrentTrick();
      assertThat(currentTrick.isEmpty())
          .as(String.format("%s: check current trick isn't empty", testCaseName))
          .isFalse();
      assertThat(currentTrick.getDesiredSuit())
          .as(String.format("%s: checktrick's desired suit is s", testCaseName))
          .isEqualTo(Suit.SPADES);
      assertThat(currentTrick.getValue())
          .as(String.format("%s: check trick's value is 2", testCaseName))
          .isEqualTo(2);
      assertThat(currentTrick.getMaster())
          .as(String.format("%s: check trick's master is p1", testCaseName))
          .isEqualTo(p1);
      assertThat(currentTrick.getHighestTrump())
          .as(String.format("%s: check trick's highest trump is null", testCaseName))
          .isNull();
  
      /*
       * NEW TEST CASE
       */
      testCaseName = "Js - Ks";
      preMoveRound = game.getCurrentRound();
      try {
        GameResult<Team> result = MovePlaying.cardMove(stringToCard("Ks")).applyOnGame(game);
        assertThat(result.isFinished())
            .as(String.format("%s: check game hasn't finished", testCaseName))
            .isFalse();
      } catch (IllegalMoveException e) {
        throw new RuntimeException(String.format("%s: Illegal move wasn't expected", testCaseName));
      }
      assertThat(p2.getCards().contains(stringToCard("Ks")))
          .as(String.format("%s: check card has disappeared from hand", testCaseName))
          .isFalse();
      round = game.getCurrentRound();
      assertThat(round)
          .as(String.format("%s: check round hasn't changed", testCaseName))
          .isEqualTo(preMoveRound);
      assertThat(round.getCurrentPlayer())
          .as(String.format("%s: check current player index is 3", testCaseName))
          .isEqualTo(p3);
      state = round.getState();
      assertThat(state)
          .as(String.format("%s: check state is playing state", testCaseName))
          .isInstanceOf(GameStatePlaying.class);
      playingState = (GameStatePlaying) state;
      assertThat(playingState.getTrickPointsForPlayer(p1))
          .as(String.format("%s: check p1 has 58 pts (trick)", testCaseName))
          .isEqualTo(58);
      assertThat(playingState.getTrickPointsForPlayer(p2))
          .as(String.format("%s: check p2 has 16 pts (trick)", testCaseName))
          .isEqualTo(16);
      assertThat(playingState.getTrickPointsForPlayer(p3))
          .as(String.format("%s: check p3 has 0 pts (trick)", testCaseName))
          .isEqualTo(0);
      assertThat(playingState.getTrickPointsForPlayer(p4))
          .as(String.format("%s: check p4 has 28 pts (trick)", testCaseName))
          .isEqualTo(28);
      assertThat(playingState.getCurrentTrickNumber())
          .as(String.format("%s: check current trick # is 6", testCaseName))
          .isEqualTo(6);
      currentTrick = playingState.getCurrentTrick();
      assertThat(currentTrick.isEmpty())
          .as(String.format("%s: check current trick isn't empty", testCaseName))
          .isFalse();
      assertThat(currentTrick.getDesiredSuit())
          .as(String.format("%s: checktrick's desired suit is s", testCaseName))
          .isEqualTo(Suit.SPADES);
      assertThat(currentTrick.getValue())
          .as(String.format("%s: check trick's value is 6", testCaseName))
          .isEqualTo(6);
      assertThat(currentTrick.getMaster())
          .as(String.format("%s: check trick's master is p2", testCaseName))
          .isEqualTo(p2);
      assertThat(currentTrick.getHighestTrump())
          .as(String.format("%s: check trick's highest trump is null", testCaseName))
          .isNull();
  
      /*
       * NEW TEST CASE
       */
      testCaseName = "Js, Ks - 7h";
      preMoveRound = game.getCurrentRound();
      try {
        GameResult<Team> result = MovePlaying.cardMove(stringToCard("7h")).applyOnGame(game);
        assertThat(result.isFinished())
            .as(String.format("%s: check game hasn't finished", testCaseName))
            .isFalse();
      } catch (IllegalMoveException e) {
        throw new RuntimeException(String.format("%s: Illegal move wasn't expected", testCaseName));
      }
      assertThat(p3.getCards().contains(stringToCard("7h")))
          .as(String.format("%s: check card has disappeared from hand", testCaseName))
          .isFalse();
      round = game.getCurrentRound();
      assertThat(round)
          .as(String.format("%s: check round hasn't changed", testCaseName))
          .isEqualTo(preMoveRound);
      assertThat(round.getCurrentPlayer())
          .as(String.format("%s: check current player index is 4", testCaseName))
          .isEqualTo(p4);
      state = round.getState();
      assertThat(state)
          .as(String.format("%s: check state is playing state", testCaseName))
          .isInstanceOf(GameStatePlaying.class);
      playingState = (GameStatePlaying) state;
      assertThat(playingState.getTrickPointsForPlayer(p1))
          .as(String.format("%s: check p1 has 58 pts (trick)", testCaseName))
          .isEqualTo(58);
      assertThat(playingState.getTrickPointsForPlayer(p2))
          .as(String.format("%s: check p2 has 16 pts (trick)", testCaseName))
          .isEqualTo(16);
      assertThat(playingState.getTrickPointsForPlayer(p3))
          .as(String.format("%s: check p3 has 0 pts (trick)", testCaseName))
          .isEqualTo(0);
      assertThat(playingState.getTrickPointsForPlayer(p4))
          .as(String.format("%s: check p4 has 28 pts (trick)", testCaseName))
          .isEqualTo(28);
      assertThat(playingState.getCurrentTrickNumber())
          .as(String.format("%s: check current trick # is 6", testCaseName))
          .isEqualTo(6);
      currentTrick = playingState.getCurrentTrick();
      assertThat(currentTrick.isEmpty())
          .as(String.format("%s: check current trick isn't empty", testCaseName))
          .isFalse();
      assertThat(currentTrick.getDesiredSuit())
          .as(String.format("%s: checktrick's desired suit is s", testCaseName))
          .isEqualTo(Suit.SPADES);
      assertThat(currentTrick.getValue())
          .as(String.format("%s: check trick's value is 6", testCaseName))
          .isEqualTo(6);
      assertThat(currentTrick.getMaster())
          .as(String.format("%s: check trick's master is p3", testCaseName))
          .isEqualTo(p3);
      assertThat(currentTrick.getHighestTrump())
          .as(String.format("%s: check trick's highest trump is 7h", testCaseName))
          .isEqualTo(ValuedCard.fromCard(stringToCard("7h"), Suit.HEARTS));
  
      /*
       * NEW TEST CASE
       */
      testCaseName = "Js, Ks, 7h - Qs";
      preMoveRound = game.getCurrentRound();
      try {
        GameResult<Team> result = MovePlaying.cardMove(stringToCard("Qs")).applyOnGame(game);
        assertThat(result.isFinished())
            .as(String.format("%s: check game hasn't finished", testCaseName))
            .isFalse();
      } catch (IllegalMoveException e) {
        throw new RuntimeException(String.format("%s: Illegal move wasn't expected", testCaseName));
      }
      assertThat(p4.getCards().contains(stringToCard("Qs")))
          .as(String.format("%s: check card has disappeared from hand", testCaseName))
          .isFalse();
      round = game.getCurrentRound();
      assertThat(round)
          .as(String.format("%s: check round hasn't changed", testCaseName))
          .isEqualTo(preMoveRound);
      assertThat(round.getCurrentPlayer())
          .as(String.format("%s: check current player index is 3", testCaseName))
          .isEqualTo(p3);
      state = round.getState();
      assertThat(state)
          .as(String.format("%s: check state is playing state", testCaseName))
          .isInstanceOf(GameStatePlaying.class);
      playingState = (GameStatePlaying) state;
      assertThat(playingState.getTrickPointsForPlayer(p1))
          .as(String.format("%s: check p1 has 58 pts (trick)", testCaseName))
          .isEqualTo(58);
      assertThat(playingState.getTrickPointsForPlayer(p2))
          .as(String.format("%s: check p2 has 16 pts (trick)", testCaseName))
          .isEqualTo(16);
      assertThat(playingState.getTrickPointsForPlayer(p3))
          .as(String.format("%s: check p3 has 9 pts (trick)", testCaseName))
          .isEqualTo(9);
      assertThat(playingState.getTrickPointsForPlayer(p4))
          .as(String.format("%s: check p4 has 28 pts (trick)", testCaseName))
          .isEqualTo(28);
      assertThat(playingState.getCurrentTrickNumber())
          .as(String.format("%s: check current trick # is 7", testCaseName))
          .isEqualTo(7);
      currentTrick = playingState.getCurrentTrick();
      assertThat(currentTrick.isEmpty())
          .as(String.format("%s: check current trick is empty", testCaseName))
          .isTrue();
  
      /*
       * NEW TEST CASE
       */
      testCaseName = "Tc";
      preMoveRound = game.getCurrentRound();
      try {
        GameResult<Team> result = MovePlaying.cardMove(stringToCard("Tc")).applyOnGame(game);
        assertThat(result.isFinished())
            .as(String.format("%s: check game hasn't finished", testCaseName))
            .isFalse();
      } catch (IllegalMoveException e) {
        throw new RuntimeException(String.format("%s: Illegal move wasn't expected", testCaseName));
      }
      assertThat(p3.getCards().contains(stringToCard("Tc")))
          .as(String.format("%s: check card has disappeared from hand", testCaseName))
          .isFalse();
      round = game.getCurrentRound();
      assertThat(round)
          .as(String.format("%s: check round hasn't changed", testCaseName))
          .isEqualTo(preMoveRound);
      assertThat(round.getCurrentPlayer())
          .as(String.format("%s: check current player index is 4", testCaseName))
          .isEqualTo(p4);
      state = round.getState();
      assertThat(state)
          .as(String.format("%s: check state is playing state", testCaseName))
          .isInstanceOf(GameStatePlaying.class);
      playingState = (GameStatePlaying) state;
      assertThat(playingState.getTrickPointsForPlayer(p1))
          .as(String.format("%s: check p1 has 58 pts (trick)", testCaseName))
          .isEqualTo(58);
      assertThat(playingState.getTrickPointsForPlayer(p2))
          .as(String.format("%s: check p2 has 16 pts (trick)", testCaseName))
          .isEqualTo(16);
      assertThat(playingState.getTrickPointsForPlayer(p3))
          .as(String.format("%s: check p3 has 9 pts (trick)", testCaseName))
          .isEqualTo(9);
      assertThat(playingState.getTrickPointsForPlayer(p4))
          .as(String.format("%s: check p4 has 28 pts (trick)", testCaseName))
          .isEqualTo(28);
      assertThat(playingState.getCurrentTrickNumber())
          .as(String.format("%s: check current trick # is 7", testCaseName))
          .isEqualTo(7);
      currentTrick = playingState.getCurrentTrick();
      assertThat(currentTrick.isEmpty())
          .as(String.format("%s: check current trick isn't empty", testCaseName))
          .isFalse();
      assertThat(currentTrick.getDesiredSuit())
          .as(String.format("%s: checktrick's desired suit is c", testCaseName))
          .isEqualTo(Suit.CLUBS);
      assertThat(currentTrick.getValue())
          .as(String.format("%s: check trick's value is 10", testCaseName))
          .isEqualTo(10);
      assertThat(currentTrick.getMaster())
          .as(String.format("%s: check trick's master is p3", testCaseName))
          .isEqualTo(p3);
      assertThat(currentTrick.getHighestTrump())
          .as(String.format("%s: check trick's highest trump is null", testCaseName))
          .isNull();
  
      /*
       * NEW TEST CASE
       */
      testCaseName = "Tc - 7c";
      preMoveRound = game.getCurrentRound();
      try {
        GameResult<Team> result = MovePlaying.cardMove(stringToCard("7c")).applyOnGame(game);
        assertThat(result.isFinished())
            .as(String.format("%s: check game hasn't finished", testCaseName))
            .isFalse();
      } catch (IllegalMoveException e) {
        throw new RuntimeException(String.format("%s: Illegal move wasn't expected", testCaseName));
      }
      assertThat(p4.getCards().contains(stringToCard("7c")))
          .as(String.format("%s: check card has disappeared from hand", testCaseName))
          .isFalse();
      round = game.getCurrentRound();
      assertThat(round)
          .as(String.format("%s: check round hasn't changed", testCaseName))
          .isEqualTo(preMoveRound);
      assertThat(round.getCurrentPlayer())
          .as(String.format("%s: check current player index is 1", testCaseName))
          .isEqualTo(p1);
      state = round.getState();
      assertThat(state)
          .as(String.format("%s: check state is playing state", testCaseName))
          .isInstanceOf(GameStatePlaying.class);
      playingState = (GameStatePlaying) state;
      assertThat(playingState.getTrickPointsForPlayer(p1))
          .as(String.format("%s: check p1 has 58 pts (trick)", testCaseName))
          .isEqualTo(58);
      assertThat(playingState.getTrickPointsForPlayer(p2))
          .as(String.format("%s: check p2 has 16 pts (trick)", testCaseName))
          .isEqualTo(16);
      assertThat(playingState.getTrickPointsForPlayer(p3))
          .as(String.format("%s: check p3 has 9 pts (trick)", testCaseName))
          .isEqualTo(9);
      assertThat(playingState.getTrickPointsForPlayer(p4))
          .as(String.format("%s: check p4 has 28 pts (trick)", testCaseName))
          .isEqualTo(28);
      assertThat(playingState.getCurrentTrickNumber())
          .as(String.format("%s: check current trick # is 7", testCaseName))
          .isEqualTo(7);
      currentTrick = playingState.getCurrentTrick();
      assertThat(currentTrick.isEmpty())
          .as(String.format("%s: check current trick isn't empty", testCaseName))
          .isFalse();
      assertThat(currentTrick.getDesiredSuit())
          .as(String.format("%s: checktrick's desired suit is c", testCaseName))
          .isEqualTo(Suit.CLUBS);
      assertThat(currentTrick.getValue())
          .as(String.format("%s: check trick's value is 10", testCaseName))
          .isEqualTo(10);
      assertThat(currentTrick.getMaster())
          .as(String.format("%s: check trick's master is p3", testCaseName))
          .isEqualTo(p3);
      assertThat(currentTrick.getHighestTrump())
          .as(String.format("%s: check trick's highest trump is null", testCaseName))
          .isNull();
  
      /*
       * NEW TEST CASE
       */
      testCaseName = "Tc, 7c - Ah";
      preMoveRound = game.getCurrentRound();
      try {
        GameResult<Team> result = MovePlaying.cardMove(stringToCard("Ah")).applyOnGame(game);
        assertThat(result.isFinished())
            .as(String.format("%s: check game hasn't finished", testCaseName))
            .isFalse();
      } catch (IllegalMoveException e) {
        throw new RuntimeException(String.format("%s: Illegal move wasn't expected", testCaseName));
      }
      assertThat(p1.getCards().contains(stringToCard("Ah")))
          .as(String.format("%s: check card has disappeared from hand", testCaseName))
          .isFalse();
      round = game.getCurrentRound();
      assertThat(round)
          .as(String.format("%s: check round hasn't changed", testCaseName))
          .isEqualTo(preMoveRound);
      assertThat(round.getCurrentPlayer())
          .as(String.format("%s: check current player index is 2", testCaseName))
          .isEqualTo(p2);
      state = round.getState();
      assertThat(state)
          .as(String.format("%s: check state is playing state", testCaseName))
          .isInstanceOf(GameStatePlaying.class);
      playingState = (GameStatePlaying) state;
      assertThat(playingState.getTrickPointsForPlayer(p1))
          .as(String.format("%s: check p1 has 58 pts (trick)", testCaseName))
          .isEqualTo(58);
      assertThat(playingState.getTrickPointsForPlayer(p2))
          .as(String.format("%s: check p2 has 16 pts (trick)", testCaseName))
          .isEqualTo(16);
      assertThat(playingState.getTrickPointsForPlayer(p3))
          .as(String.format("%s: check p3 has 9 pts (trick)", testCaseName))
          .isEqualTo(9);
      assertThat(playingState.getTrickPointsForPlayer(p4))
          .as(String.format("%s: check p4 has 28 pts (trick)", testCaseName))
          .isEqualTo(28);
      assertThat(playingState.getCurrentTrickNumber())
          .as(String.format("%s: check current trick # is 7", testCaseName))
          .isEqualTo(7);
      currentTrick = playingState.getCurrentTrick();
      assertThat(currentTrick.isEmpty())
          .as(String.format("%s: check current trick isn't empty", testCaseName))
          .isFalse();
      assertThat(currentTrick.getDesiredSuit())
          .as(String.format("%s: checktrick's desired suit is c", testCaseName))
          .isEqualTo(Suit.CLUBS);
      assertThat(currentTrick.getValue())
          .as(String.format("%s: check trick's value is 21", testCaseName))
          .isEqualTo(21);
      assertThat(currentTrick.getMaster())
          .as(String.format("%s: check trick's master is p1", testCaseName))
          .isEqualTo(p1);
      assertThat(currentTrick.getHighestTrump())
          .as(String.format("%s: check trick's highest trump is Ah", testCaseName))
          .isEqualTo(ValuedCard.fromCard(stringToCard("Ah"), Suit.HEARTS));
  
      /*
       * NEW TEST CASE
       */
      testCaseName = "Tc, 7c, Ah - 9s";
      preMoveRound = game.getCurrentRound();
      try {
        GameResult<Team> result = MovePlaying.cardMove(stringToCard("9s")).applyOnGame(game);
        assertThat(result.isFinished())
            .as(String.format("%s: check game hasn't finished", testCaseName))
            .isFalse();
      } catch (IllegalMoveException e) {
        throw new RuntimeException(String.format("%s: Illegal move wasn't expected", testCaseName));
      }
      assertThat(p2.getCards().contains(stringToCard("9s")))
          .as(String.format("%s: check card has disappeared from hand", testCaseName))
          .isFalse();
      round = game.getCurrentRound();
      assertThat(round)
          .as(String.format("%s: check round hasn't changed", testCaseName))
          .isEqualTo(preMoveRound);
      assertThat(round.getCurrentPlayer())
          .as(String.format("%s: check current player index is 1", testCaseName))
          .isEqualTo(p1);
      state = round.getState();
      assertThat(state)
          .as(String.format("%s: check state is playing state", testCaseName))
          .isInstanceOf(GameStatePlaying.class);
      playingState = (GameStatePlaying) state;
      assertThat(playingState.getTrickPointsForPlayer(p1))
          .as(String.format("%s: check p1 has 79 pts (trick)", testCaseName))
          .isEqualTo(79);
      assertThat(playingState.getTrickPointsForPlayer(p2))
          .as(String.format("%s: check p2 has 16 pts (trick)", testCaseName))
          .isEqualTo(16);
      assertThat(playingState.getTrickPointsForPlayer(p3))
          .as(String.format("%s: check p3 has 9 pts (trick)", testCaseName))
          .isEqualTo(9);
      assertThat(playingState.getTrickPointsForPlayer(p4))
          .as(String.format("%s: check p4 has 28 pts (trick)", testCaseName))
          .isEqualTo(28);
      assertThat(playingState.getCurrentTrickNumber())
          .as(String.format("%s: check current trick # is 8", testCaseName))
          .isEqualTo(8);
      currentTrick = playingState.getCurrentTrick();
      assertThat(currentTrick.isEmpty())
          .as(String.format("%s: check current trick is empty", testCaseName))
          .isTrue();
  
      /*
       * NEW TEST CASE
       */
      testCaseName = "9h";
      preMoveRound = game.getCurrentRound();
      try {
        GameResult<Team> result = MovePlaying.cardMove(stringToCard("9h")).applyOnGame(game);
        assertThat(result.isFinished())
            .as(String.format("%s: check game hasn't finished", testCaseName))
            .isFalse();
      } catch (IllegalMoveException e) {
        throw new RuntimeException(String.format("%s: Illegal move wasn't expected", testCaseName));
      }
      assertThat(p1.getCards().contains(stringToCard("9h")))
          .as(String.format("%s: check card has disappeared from hand", testCaseName))
          .isFalse();
      round = game.getCurrentRound();
      assertThat(round)
          .as(String.format("%s: check round hasn't changed", testCaseName))
          .isEqualTo(preMoveRound);
      assertThat(round.getCurrentPlayer())
          .as(String.format("%s: check current player index is 2", testCaseName))
          .isEqualTo(p2);
      state = round.getState();
      assertThat(state)
          .as(String.format("%s: check state is playing state", testCaseName))
          .isInstanceOf(GameStatePlaying.class);
      playingState = (GameStatePlaying) state;
      assertThat(playingState.getTrickPointsForPlayer(p1))
          .as(String.format("%s: check p1 has 79 pts (trick)", testCaseName))
          .isEqualTo(79);
      assertThat(playingState.getTrickPointsForPlayer(p2))
          .as(String.format("%s: check p2 has 16 pts (trick)", testCaseName))
          .isEqualTo(16);
      assertThat(playingState.getTrickPointsForPlayer(p3))
          .as(String.format("%s: check p3 has 9 pts (trick)", testCaseName))
          .isEqualTo(9);
      assertThat(playingState.getTrickPointsForPlayer(p4))
          .as(String.format("%s: check p4 has 28 pts (trick)", testCaseName))
          .isEqualTo(28);
      assertThat(playingState.getCurrentTrickNumber())
          .as(String.format("%s: check current trick # is 8", testCaseName))
          .isEqualTo(8);
      currentTrick = playingState.getCurrentTrick();
      assertThat(currentTrick.isEmpty())
          .as(String.format("%s: check current trick isn't empty", testCaseName))
          .isFalse();
      assertThat(currentTrick.getDesiredSuit())
          .as(String.format("%s: checktrick's desired suit is h", testCaseName))
          .isEqualTo(Suit.HEARTS);
      assertThat(currentTrick.getValue())
          .as(String.format("%s: check trick's value is 14", testCaseName))
          .isEqualTo(14);
      assertThat(currentTrick.getMaster())
          .as(String.format("%s: check trick's master is p1", testCaseName))
          .isEqualTo(p1);
      assertThat(currentTrick.getHighestTrump())
          .as(String.format("%s: check trick's highest trump is 9h", testCaseName))
          .isEqualTo(ValuedCard.fromCard(stringToCard("9h"), Suit.HEARTS));
  
      /*
       * NEW TEST CASE
       */
      testCaseName = "9h - Jd";
      preMoveRound = game.getCurrentRound();
      try {
        GameResult<Team> result = MovePlaying.cardMove(stringToCard("Jd")).applyOnGame(game);
        assertThat(result.isFinished())
            .as(String.format("%s: check game hasn't finished", testCaseName))
            .isFalse();
      } catch (IllegalMoveException e) {
        throw new RuntimeException(String.format("%s: Illegal move wasn't expected", testCaseName));
      }
      assertThat(p2.getCards().contains(stringToCard("Jd")))
          .as(String.format("%s: check card has disappeared from hand", testCaseName))
          .isFalse();
      round = game.getCurrentRound();
      assertThat(round)
          .as(String.format("%s: check round hasn't changed", testCaseName))
          .isEqualTo(preMoveRound);
      assertThat(round.getCurrentPlayer())
          .as(String.format("%s: check current player index is 3", testCaseName))
          .isEqualTo(p3);
      state = round.getState();
      assertThat(state)
          .as(String.format("%s: check state is playing state", testCaseName))
          .isInstanceOf(GameStatePlaying.class);
      playingState = (GameStatePlaying) state;
      assertThat(playingState.getTrickPointsForPlayer(p1))
          .as(String.format("%s: check p1 has 79 pts (trick)", testCaseName))
          .isEqualTo(79);
      assertThat(playingState.getTrickPointsForPlayer(p2))
          .as(String.format("%s: check p2 has 16 pts (trick)", testCaseName))
          .isEqualTo(16);
      assertThat(playingState.getTrickPointsForPlayer(p3))
          .as(String.format("%s: check p3 has 9 pts (trick)", testCaseName))
          .isEqualTo(9);
      assertThat(playingState.getTrickPointsForPlayer(p4))
          .as(String.format("%s: check p4 has 28 pts (trick)", testCaseName))
          .isEqualTo(28);
      assertThat(playingState.getCurrentTrickNumber())
          .as(String.format("%s: check current trick # is 8", testCaseName))
          .isEqualTo(8);
      currentTrick = playingState.getCurrentTrick();
      assertThat(currentTrick.isEmpty())
          .as(String.format("%s: check current trick isn't empty", testCaseName))
          .isFalse();
      assertThat(currentTrick.getDesiredSuit())
          .as(String.format("%s: checktrick's desired suit is h", testCaseName))
          .isEqualTo(Suit.HEARTS);
      assertThat(currentTrick.getValue())
          .as(String.format("%s: check trick's value is 16", testCaseName))
          .isEqualTo(16);
      assertThat(currentTrick.getMaster())
          .as(String.format("%s: check trick's master is p1", testCaseName))
          .isEqualTo(p1);
      assertThat(currentTrick.getHighestTrump())
          .as(String.format("%s: check trick's highest trump is 9h", testCaseName))
          .isEqualTo(ValuedCard.fromCard(stringToCard("9h"), Suit.HEARTS));
  
      /*
       * NEW TEST CASE
       */
      testCaseName = "9h, Jd - Kc";
      preMoveRound = game.getCurrentRound();
      try {
        GameResult<Team> result = MovePlaying.cardMove(stringToCard("Kc")).applyOnGame(game);
        assertThat(result.isFinished())
            .as(String.format("%s: check game hasn't finished", testCaseName))
            .isFalse();
      } catch (IllegalMoveException e) {
        throw new RuntimeException(String.format("%s: Illegal move wasn't expected", testCaseName));
      }
      assertThat(p3.getCards().contains(stringToCard("Kc")))
          .as(String.format("%s: check card has disappeared from hand", testCaseName))
          .isFalse();
      round = game.getCurrentRound();
      assertThat(round)
          .as(String.format("%s: check round hasn't changed", testCaseName))
          .isEqualTo(preMoveRound);
      assertThat(round.getCurrentPlayer())
          .as(String.format("%s: check current player index is 4", testCaseName))
          .isEqualTo(p4);
      state = round.getState();
      assertThat(state)
          .as(String.format("%s: check state is playing state", testCaseName))
          .isInstanceOf(GameStatePlaying.class);
      playingState = (GameStatePlaying) state;
      assertThat(playingState.getTrickPointsForPlayer(p1))
          .as(String.format("%s: check p1 has 79 pts (trick)", testCaseName))
          .isEqualTo(79);
      assertThat(playingState.getTrickPointsForPlayer(p2))
          .as(String.format("%s: check p2 has 16 pts (trick)", testCaseName))
          .isEqualTo(16);
      assertThat(playingState.getTrickPointsForPlayer(p3))
          .as(String.format("%s: check p3 has 9 pts (trick)", testCaseName))
          .isEqualTo(9);
      assertThat(playingState.getTrickPointsForPlayer(p4))
          .as(String.format("%s: check p4 has 28 pts (trick)", testCaseName))
          .isEqualTo(28);
      assertThat(playingState.getCurrentTrickNumber())
          .as(String.format("%s: check current trick # is 8", testCaseName))
          .isEqualTo(8);
      currentTrick = playingState.getCurrentTrick();
      assertThat(currentTrick.isEmpty())
          .as(String.format("%s: check current trick isn't empty", testCaseName))
          .isFalse();
      assertThat(currentTrick.getDesiredSuit())
          .as(String.format("%s: checktrick's desired suit is h", testCaseName))
          .isEqualTo(Suit.HEARTS);
      assertThat(currentTrick.getValue())
          .as(String.format("%s: check trick's value is 20", testCaseName))
          .isEqualTo(20);
      assertThat(currentTrick.getMaster())
          .as(String.format("%s: check trick's master is p1", testCaseName))
          .isEqualTo(p1);
      assertThat(currentTrick.getHighestTrump())
          .as(String.format("%s: check trick's highest trump is 9h", testCaseName))
          .isEqualTo(ValuedCard.fromCard(stringToCard("9h"), Suit.HEARTS));
  
      /*
       * NEW TEST CASE
       */
      testCaseName = "9h, Jd, Kc - 8c";
      preMoveRound = game.getCurrentRound();
      try {
        GameResult<Team> result = MovePlaying.cardMove(stringToCard("8c")).applyOnGame(game);
        assertThat(result.isFinished())
            .as(String.format("%s: check game hasn't finished", testCaseName))
            .isFalse();
      } catch (IllegalMoveException e) {
        throw new RuntimeException(String.format("%s: Illegal move wasn't expected", testCaseName));
      }
      round = game.getCurrentRound();
      round = game.getCurrentRound();
      assertThat(round)
          .as(String.format("%s: check round has changed", testCaseName))
          .isNotEqualTo(preMoveRound);
      assertThat(game.getRedTeam().getPoints())
          .as(String.format("%s: check red team's points have been updated", testCaseName))
          .isEqualTo(218);
      assertThat(game.getBlueTeam().getPoints())
          .as(String.format("%s: check blue team's points have been updated", testCaseName))
          .isEqualTo(44);
      assertThat(round.getCurrentPlayer())
          .as(String.format("%s: check current player index is 2", testCaseName))
          .isEqualTo(p2);
      state = round.getState();
      assertThat(state)
          .as(String.format("%s: check state is bidding state", testCaseName))
          .isInstanceOf(GameStateBidding.class);
      GameStateBidding biddingState = (GameStateBidding) state;
      assertThat(biddingState.isCoinched())
          .as(String.format("%s: check is not coinched", testCaseName))
          .isFalse();
      assertThat(biddingState.isSurcoinched())
          .as(String.format("%s: check is not surcoinched", testCaseName))
          .isFalse();
      Contract highestBidding = biddingState.getHighestBidding();
      assertThat(highestBidding)
          .as(String.format("%s: check highest bidding is null", testCaseName))
          .isNull();
    }
  
  }