hg/html~demo: chess/src/test/java/com/oracle/chess/client/htmljava/BoardModelTest.java@945fbfff28f3

     1 /**

     2  * The MIT License (MIT)

     3  *

     4  * Copyright (C) 2013 Jaroslav Tulach <jaroslav.tulach@apidesign.org>

     5  *

     6  * Permission is hereby granted, free of charge, to any person obtaining a copy

     7  * of this software and associated documentation files (the "Software"), to deal

     8  * in the Software without restriction, including without limitation the rights

     9  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

    10  * copies of the Software, and to permit persons to whom the Software is

    11  * furnished to do so, subject to the following conditions:

    12  *

    13  * The above copyright notice and this permission notice shall be included in

    14  * all copies or substantial portions of the Software.

    15  *

    16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

    17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

    18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

    19  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

    20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

    21  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

    22  * THE SOFTWARE.

    23  */

    24 package com.oracle.chess.client.htmljava;

    26 import com.oracle.chess.client.htmljava.BoardModel.PieceType;

    27 import java.util.Arrays;

    28 import java.util.Collections;

    29 import java.util.List;

    30 import static org.testng.Assert.*;

    31 import org.testng.annotations.Test;

    33 /**

    34  *

    35  * @author Jaroslav Tulach <jtulach@netbeans.org>

    36  */

    37 public class BoardModelTest {

    39     public BoardModelTest() {

    40     }

    42     @Test public void whiteRockLeftBottom() {

    43         Board b = Rules.createBoard();

    44         Row bottom = b.getRows().get(7);

    45         Square left = bottom.getColumns().get(0);

    46         assertEquals(left.getPiece(), PieceType.ROCK, "Rock is on bottom left square");

    47         assertEquals(left.getPieceColor(), Color.W, "It is white");

    48         assertEquals(left.getColor(), Color.B, "Square is black");

    49     }

    51     @Test public void e2e4e7e6() {

    52         Board b = Rules.createBoard();

    53         b.setGameId("myId");

    54         setPlayer(b, Color.W);

    55         assertEquals(b.getTurn(), Color.W);

    57         Square e2 = BoardModel.findSquare(b, 'E', 2);

    58         assertNotNull(e2);

    59         BoardModel.selected(b, e2);

    60         assertEquals(BoardModel.findSelectedSquare(b), e2, "E2 is selected");

    62         Square e4 = BoardModel.findSquare(b, 'E', 4);

    63         assertNotNull(e4);

    65         BoardModel.selected(b, e4);

    67         assertTrue(e4.isPending(), "e4 marked as pending move");

    68         assertNull(e2.getPiece(), "No pawn at e2");

    70         // ignore all other figures than the two pawns

    71         BoardModel.moveResponse(b, null, Collections.singletonList("Pe4"),

    72             Collections.singletonList("Pe7"), Color.B, null

    73         );

    75         assertFalse(e4.isPending(), "e4 now the move is real");

    76         assertNull(e2.getPiece(), "No pawn at e2");

    77         assertEquals(e4.getPiece(), BoardModel.PieceType.PAWN, "Pawn moved successfully");

    78         assertNull(BoardModel.findSelectedSquare(b), "No square selected");

    80         BoardModel.selected(b, e4);

    81         assertNull(BoardModel.findSelectedSquare(b), "No square selected, it is blacks turn");

    83         List<Move> mvs1 = b.getMoves();

    84         assertEquals(1, mvs1.size(), "First move was made: " + mvs1);

    85         Move firstMove = mvs1.get(0);

    86         assertEquals(firstMove.getPiece(), PieceType.PAWN, "Moving with pawn");

    87         assertEquals(firstMove.getRound(), 1, "First round of moves");

    88         assertEquals(firstMove.getTurn(), Color.W, "Moved by white");

    89         assertTrue(firstMove.isWhiteMove(), "Really moved by white");

    91         assertTrue(b.isBlackTurn(), "black's turn");

    94         Square e7 = BoardModel.findSquare(b, 'E', 7);

    95         BoardModel.selected(b, e7);

    96         assertNull(BoardModel.findSelectedSquare(b), "Can't select anything when I am white player");

    98         Move blackMv = BoardModel.MoveImpl.valueOf("E7E6");

    99         BoardModel.moveUpdate(b, blackMv,

   100             Collections.singletonList("PE4"),

   101             Collections.singletonList("PE6"),

   102             Color.W, null

   103         );

   105         assertNull(e7.getPiece(), "Piece has been moved");

   107         List<Move> mvs = b.getMoves();

   108         assertEquals(2, mvs.size(), "There are two moves now: " + mvs);

   109         Move secondMove = mvs.get(1);

   110         assertEquals(secondMove.getPiece(), PieceType.PAWN, "Moving with pawn");

   111         assertEquals(secondMove.getRound(), 1, "Still 1st round of moves");

   112         assertEquals(secondMove.getTurn(), Color.B, "Moved by black");

   113         assertFalse(secondMove.isWhiteMove(), "Really moved by black");

   114     }

   116     @Test public void unselect() {

   117         Board b = Rules.createBoard();

   118         b.setGameId("myId");

   119         setPlayer(b, Color.W);

   120         assertEquals(b.getTurn(), Color.W);

   122         Square e2 = BoardModel.findSquare(b, 'E', 2);

   123         assertNotNull(e2);

   124         BoardModel.selected(b, e2);

   125         assertEquals(BoardModel.findSelectedSquare(b), e2, "E2 is selected");

   127         BoardModel.selected(b, e2);

   128         assertNull(BoardModel.findSelectedSquare(b), "E2 is unselected");

   130         for (Row row : b.getRows()) {

   131             for (Square s : row.getColumns()) {

   132                 assertFalse(s.isAccessible(), "No square is accessible anymore: " + s);

   133             }

   134         }

   135     }

   137     @Test public void discaredMove() {

   138         Board b = Rules.createBoard();

   139         b.setGameId("myId");

   140         setPlayer(b, Color.W);

   141         assertEquals(b.getTurn(), Color.W);

   143         Square e2 = BoardModel.findSquare(b, 'E', 2);

   144         assertNotNull(e2);

   145         BoardModel.selected(b, e2);

   146         assertEquals(BoardModel.findSelectedSquare(b), e2, "E2 is selected");

   148         Square e4 = BoardModel.findSquare(b, 'E', 4);

   149         assertNotNull(e4);

   151         BoardModel.selected(b, e4);

   153         assertTrue(e4.isPending(), "e4 marked as pending move");

   154         assertNull(e2.getPiece(), "No pawn at e2");

   156         assertEquals(b.getMoves().size(), 1, "One move recorded");

   157         assertEquals(b.getMoves().get(0), b.getPendingMove(), "Pending move is waiting");

   159         // ignore all other figures than the two pawns

   160         BoardModel.moveResponse(b, "No way, can't play like this", Collections.singletonList("PE2"),

   161             Collections.singletonList("Pe7"), Color.W, null

   162         );

   164         assertEquals(b.getAlertMessage(), "No way, can't play like this");

   165         assertNull(e4.getPiece(), "No piece on e4");

   166         assertEquals(e2.getPiece(), PieceType.PAWN, "Pawn is back");

   168         assertEquals(b.getMoves().size(), 0, "Move was discarded");

   169         assertNull(b.getPendingMove(), "No pending moves");

   170     }

   172     @Test public void cantSelectEmptySquare() {

   173         Board b = Rules.createBoard();

   174         Square e3 = BoardModel.findSquare(b, 'E', 3);

   175         assertNotNull(e3);

   176         BoardModel.selected(b, e3);

   177         assertNull(BoardModel.findSelectedSquare(b), "No square is selected");

   178     }

   180     @Test public void cantTakeOwnPiece() {

   181         Board b = Rules.createBoard();

   182         setPlayer(b, Color.W);

   183         Square e1 = BoardModel.findSquare(b, 'E', 1);

   184         assertNotNull(e1);

   185         BoardModel.selected(b, e1);

   186         assertEquals(BoardModel.findSelectedSquare(b), e1, "E1 is selected");

   188         Square e2 = BoardModel.findSquare(b, 'E', 2);

   189         assertNotNull(e2);

   191         BoardModel.selected(b, e2);

   193         assertNotNull(e1.getPiece(), "King remains at e1");

   194         assertEquals(e2.getPiece(), BoardModel.PieceType.PAWN, "Pawn remains");

   195         assertEquals(BoardModel.findSelectedSquare(b), e2, "e2 now selected");

   197     }

   199     @Test public void knightMustMoveToF3() {

   200         Board b = Rules.createBoard();

   201         setPlayer(b, Color.W);

   202         Square g1 = BoardModel.findSquare(b, 'G', 1);

   203         BoardModel.selected(b, g1);

   205         Square f3 = BoardModel.findSquare(b, 'F', 3);

   206         assertTrue(f3.isAccessible(), "This is a field where knight can move");

   208         Square g3 = BoardModel.findSquare(b, 'G', 3);

   209         assertFalse(g3.isAccessible(), "Not a place for knight");

   211         Square e2 = BoardModel.findSquare(b, 'E', 2);

   212         assertFalse(e2.isAccessible(), "Not a place either, occupied");

   214         BoardModel.selected(b, g3);

   216         assertNull(g3.getPiece(), "No figure was moved");

   217         assertTrue(g1.isSelected(), "Original square still selected");

   219         BoardModel.selected(b, f3);

   221         assertEquals(f3.getPiece(), PieceType.KNIGHT, "Moved");

   222         assertFalse(g3.isSelected(), "No longer selected");

   223     }

   225     @Test public void pawnCanTakeToSide() {

   226         Board b = Rules.createBoard();

   227         Square e2 = BoardModel.findSquare(b, 'E', 2);

   228         Square e4 = BoardModel.findSquare(b, 'E', 4);

   229         Square d7 = BoardModel.findSquare(b, 'D', 7);

   230         Square d5 = BoardModel.findSquare(b, 'D', 5);

   232         BoardModel.selected(b, e2);

   233         BoardModel.selected(b, e4);

   235         // ignore all other figures than the two pawns

   236         BoardModel.moveResponse(b, null, Collections.singletonList("PE4"),

   237             Collections.singletonList("PD7"), Color.B, null

   238         );

   240         setPlayer(b, Color.B);

   242         BoardModel.selected(b, d7);

   243         BoardModel.selected(b, d5);

   245         // ignore all other figures than the two pawns

   246         BoardModel.moveResponse(b, null, Collections.singletonList("PE4"),

   247             Collections.singletonList("PD5"), Color.W, null

   248         );

   250         setPlayer(b, Color.W);

   252         BoardModel.selected(b, e4);

   253         assertTrue(d5.isAccessible(), "Can take on d5");

   254         BoardModel.selected(b, d5);

   255         assertNull(e4.getPiece(), "No pawn on e4");

   256         assertEquals(d5.getPieceColor(), Color.W, "White Pawn on d5");

   257     }

   259     @Test public void pawnCanJumpOnAnother() {

   260         Board b = Rules.createBoard();

   261         Square e2 = BoardModel.findSquare(b, 'E', 2);

   262         Square e4 = BoardModel.findSquare(b, 'E', 4);

   263         Square d7 = BoardModel.findSquare(b, 'D', 7);

   264         Square d5 = BoardModel.findSquare(b, 'D', 5);

   265         Square e7 = BoardModel.findSquare(b, 'E', 7);

   266         Square e6 = BoardModel.findSquare(b, 'E', 6);

   267         Square e5 = BoardModel.findSquare(b, 'E', 5);

   269         BoardModel.selected(b, e2);

   270         BoardModel.selected(b, e4);

   272         // ignore all other figures than the three pawns

   273         BoardModel.moveResponse(b, null, Collections.singletonList("PE4"),

   274             Arrays.asList("PD7", "PE7"), Color.B, null

   275         );

   277         setPlayer(b, Color.B);

   279         BoardModel.selected(b, d7);

   280         BoardModel.selected(b, d5);

   282         // ignore all other figures than the three pawns

   283         BoardModel.moveResponse(b, null, Collections.singletonList("PE4"),

   284             Arrays.asList("PD5", "PE7"), Color.W, null

   285         );

   287         setPlayer(b, Color.W);

   289         BoardModel.selected(b, e4);

   290         BoardModel.selected(b, e5);

   292         // ignore all other figures than the three pawns

   293         BoardModel.moveResponse(b, null, Collections.singletonList("PE5"),

   294             Arrays.asList("PD5", "PE7"), Color.B, null

   295         );

   297         setPlayer(b, Color.B);

   299         BoardModel.selected(b, e7);

   300         assertTrue(e6.isAccessible(), "Can move by one piece");

   301         assertFalse(e5.isAccessible(), "Can't move where other pawn is");

   302     }

   304     @Test public void showFirstMove() {

   305         Board b = Rules.createBoard();

   306         setPlayer(b, Color.W);

   307         Square e2 = BoardModel.findSquare(b, 'E', 2);

   308         Square e4 = BoardModel.findSquare(b, 'E', 4);

   309         Square d7 = BoardModel.findSquare(b, 'D', 7);

   310         Square d5 = BoardModel.findSquare(b, 'D', 5);

   312         BoardModel.selected(b, e2);

   313         BoardModel.selected(b, e4);

   315         // ignore all other figures than the two pawns

   316         BoardModel.moveResponse(b, null, Collections.singletonList("Pe4"),

   317             Collections.singletonList("PD7"), Color.B, null

   318         );

   320         Move blackMv = BoardModel.MoveImpl.valueOf("D7D5");

   321         BoardModel.moveUpdate(b, blackMv,

   322             Collections.singletonList("PE4"),

   323             Collections.singletonList("PD5"),

   324             Color.W, null

   325         );

   328         assertEquals(b.getMoves().size(), 2, "Two moves");

   329         BoardModel.showPosition(b, b.getMoves().get(0));

   331         assertEquals(b.getRows().size(), 8, "Still eight rows");

   332         assertEquals(b.getRows().get(0).getColumns().size(), 8, "Eight columns");

   334         assertNull(e2.getPiece(), "e2 is empty");

   335         assertEquals(e4.getPiece(), PieceType.PAWN, "e4 has pawn");

   336         assertEquals(d7.getPiece(), PieceType.PAWN, "d7 has pawn");

   337         assertNull(d5.getPiece(), "Second move is not made");

   338         assertNull(b.getTurn(), "Nobody to make a move");

   339     }

   341     @Test public void initialPositionReadFromAServer() {

   342         List<String> blacks = Arrays.asList(

   343             "Pa7",

   344             "Pb7",

   345             "Pc7",

   346             "Pd7",

   347             "Pe7",

   348             "Pf7",

   349             "Pg7",

   350             "Ph7",

   351             "Ra8",

   352             "Nb8",

   353             "Bc8",

   354             "Qd8",

   355             "Ke8",

   356             "Bf8",

   357             "Ng8",

   358             "Rh8"

   359         );

   360         List<String> whites = Arrays.asList(

   361             "Ra1",

   362             "Nb1",

   363             "Bc1",

   364             "Qd1",

   365             "Ke1",

   366             "Bf1",

   367             "Ng1",

   368             "Rh1",

   369             "Pa2",

   370             "Pb2",

   371             "Pc2",

   372             "Pd2",

   373             "Pe2",

   374             "Pf2",

   375             "Pg2",

   376             "Ph2"

   377         );

   379         Board b = Rules.createBoard();

   380         Rules.initBoard(b, whites, blacks, Color.W);

   382         Board b2 = Rules.createBoard();

   383         Rules.initBoard(b2);

   385         for (int i = 0; i < 7; i++) {

   386             for (int j = 0; j < 7; j++) {

   387                 Square s = b.getRows().get(i).getColumns().get(j);

   388                 Square s2 = b2.getRows().get(i).getColumns().get(j);

   390                 assertEquals(s.getPiece(), s2.getPiece(), "Same piece at " + i + "/" + j);

   391                 assertEquals(s.getPieceColor(), s2.getPieceColor(), "Same piece color at " + i + "/" + j);

   392             }

   393         }

   394     }

   396     @Test public void allowSmallRochade() {

   397         Board b = Rules.createBoard();

   398         setPlayer(b, Color.W);

   399         Square f1 = BoardModel.findSquare(b, 'F', 1);

   400         f1.setPiece(null);

   401         f1.setPieceColor(null);

   402         Square g1 = BoardModel.findSquare(b, 'G', 1);

   403         g1.setPiece(null);

   404         g1.setPieceColor(null);

   405         Square e1 = BoardModel.findSquare(b, 'E', 1);

   407         BoardModel.selected(b, e1);

   408         assertTrue(g1.isAccessible(), "Can do 0-0");

   409     }

   411     @Test public void allowSmallRochadeForBlack() {

   412         Board b = Rules.createBoard();

   413         setPlayer(b, Color.B);

   414         b.setTurn(Color.B);

   415         Square f8 = BoardModel.findSquare(b, 'F', 8);

   416         f8.setPiece(null);

   417         f8.setPieceColor(null);

   418         Square g8 = BoardModel.findSquare(b, 'G', 8);

   419         g8.setPiece(null);

   420         g8.setPieceColor(null);

   421         Square e8 = BoardModel.findSquare(b, 'E', 8);

   423         BoardModel.selected(b, e8);

   424         assertTrue(g8.isAccessible(), "Can do 0-0");

   425     }

   427     @Test public void disallowSmallRochadeWhenNoRock() {

   428         Board b = Rules.createBoard();

   429         setPlayer(b, Color.W);

   430         Square f1 = BoardModel.findSquare(b, 'F', 1);

   431         f1.setPiece(null);

   432         f1.setPieceColor(null);

   433         Square g1 = BoardModel.findSquare(b, 'G', 1);

   434         g1.setPiece(null);

   435         g1.setPieceColor(null);

   436         Square h1 = BoardModel.findSquare(b, 'H', 1);

   437         h1.setPiece(null);

   438         h1.setPieceColor(null);

   439         Square e1 = BoardModel.findSquare(b, 'E', 1);

   441         BoardModel.selected(b, e1);

   442         assertFalse(g1.isAccessible(), "Cannot do 0-0 when there is no rock");

   443     }

   445     @Test public void disallowSmallRochadeWhenBishop() {

   446         Board b = Rules.createBoard();

   447         setPlayer(b, Color.W);

   448         Square g1 = BoardModel.findSquare(b, 'G', 1);

   449         g1.setPiece(null);

   450         Square e1 = BoardModel.findSquare(b, 'E', 1);

   452         BoardModel.selected(b, e1);

   453         assertFalse(g1.isAccessible(), "Cannot do 0-0 when there is bishop");

   454     }

   456     @Test public void disallowSmallRochadeWhenKnight() {

   457         Board b = Rules.createBoard();

   458         setPlayer(b, Color.W);

   459         Square f1 = BoardModel.findSquare(b, 'F', 1);

   460         f1.setPiece(null);

   461         Square e1 = BoardModel.findSquare(b, 'E', 1);

   463         BoardModel.selected(b, e1);

   464         assertFalse(f1.isAccessible(), "Cannot do 0-0 when there is knight");

   465     }

   467     @Test public void allowBigRochadeForBlack() {

   468         Board b = Rules.createBoard();

   469         setPlayer(b, Color.B);

   470         b.setTurn(Color.B);

   471         Square b8 = BoardModel.findSquare(b, 'B', 8);

   472         b8.setPiece(null);

   473         b8.setPieceColor(null);

   474         Square c8 = BoardModel.findSquare(b, 'C', 8);

   475         c8.setPiece(null);

   476         c8.setPieceColor(null);

   477         Square d8 = BoardModel.findSquare(b, 'D', 8);

   478         d8.setPiece(null);

   479         d8.setPieceColor(null);

   480         Square e8 = BoardModel.findSquare(b, 'E', 8);

   482         BoardModel.selected(b, e8);

   483         assertTrue(c8.isAccessible(), "Can do 0-0-0");

   484     }

   486     @Test public void enPassant() {

   487         Board b = Rules.createBoard();

   488         setPlayer(b, Color.B);

   489         b.setTurn(Color.B);

   491         Square e7 = BoardModel.findSquare(b, 'E', 7);

   492         Square e4 = BoardModel.findSquare(b, 'E', 4);

   493         movePiece(e7, e4);

   495         Move move = new Move();

   496         move.setFrom(position('D', 2));

   497         move.setTo(position('D', 4));

   498         move.setPiece(PieceType.PAWN);

   499         b.getMoves().add(move);

   501         Square d2 = BoardModel.findSquare(b, 'D', 2);

   502         Square d4 = BoardModel.findSquare(b, 'D', 4);

   503         movePiece(d2, d4);

   505         BoardModel.selected(b, e4);

   507         Square e3 = BoardModel.findSquare(b, 'E', 3);

   508         assertTrue(e3.isAccessible(), "Obviously can move to e3");

   510         Square d3 = BoardModel.findSquare(b, 'D', 3);

   511         assertTrue(d3.isAccessible(), "Can also take on d3");

   512     }

   514     private void movePiece(Square from, Square to) {

   515         to.setPiece(from.getPiece());

   516         to.setPieceColor(from.getPieceColor());

   517         from.setPiece(null);

   518         from.setPieceColor(null);

   519     }

   521     private Position position(char c, int i) {

   522         Position p = new Position();

   523         p.setX(c);

   524         p.setY(i);

   525         return p;

   526     }

   528     private static void setPlayer(Board b, Color c) {

   529         b.setWhitePlayer("x");

   530         b.setBlackPlayer("y");

   531         if (c == Color.B) {

   532             b.setPlayer("y");

   533         } else {

   534             b.setPlayer("x");

   535         }

   536     }

   537 }

author	Jaroslav Tulach <jaroslav.tulach@apidesign.org>
	Tue, 24 Sep 2013 22:20:24 +0200
branch	chess
changeset 49	945fbfff28f3
permissions	-rw-r--r--