hg/html~demo: chess/src/test/java/org/apidesign/html/demo/chess/BoardModelTest.java@bc0094a5f88c

     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 org.apidesign.html.demo.chess;

    26 import org.apidesign.html.demo.chess.Color;

    27 import org.apidesign.html.demo.chess.Rules;

    28 import org.apidesign.html.demo.chess.BoardModel;

    29 import org.apidesign.html.demo.chess.BoardModel.PieceType;

    30 import java.util.Arrays;

    31 import java.util.Collections;

    32 import java.util.List;

    33 import static org.testng.Assert.*;

    34 import org.testng.annotations.Test;

    36 /**

    37  *

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

    39  */

    40 public class BoardModelTest {

    42     public BoardModelTest() {

    43     }

    45     @Test public void whiteRockLeftBottom() {

    46         Board b = Rules.createBoard();

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

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

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

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

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

    52     }

    54     @Test public void e2e4e7e6() {

    55         Board b = Rules.createBoard();

    56         b.setGameId("myId");

    57         setPlayer(b, Color.W);

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

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

    61         assertNotNull(e2);

    62         BoardModel.selected(b, e2);

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

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

    66         assertNotNull(e4);

    68         BoardModel.selected(b, e4);

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

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

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

    74         BoardModel.selected(b, e4);

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

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

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

    79         Move firstMove = mvs1.get(0);

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

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

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

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

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

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

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

    91         BoardModel.moveUpdate(b, blackMv,

    92             Collections.singletonList("PE4"),

    93             Collections.singletonList("PE6"),

    94             Color.W, null

    95         );

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

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

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

   101         Move secondMove = mvs.get(1);

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

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

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

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

   106     }

   108     @Test public void unselect() {

   109         Board b = Rules.createBoard();

   110         b.setGameId("myId");

   111         setPlayer(b, Color.W);

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

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

   115         assertNotNull(e2);

   116         BoardModel.selected(b, e2);

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

   119         BoardModel.selected(b, e2);

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

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

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

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

   125             }

   126         }

   127     }

   129     @Test public void discaredMove() {

   130         Board b = Rules.createBoard();

   131         b.setGameId("myId");

   132         setPlayer(b, Color.W);

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

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

   136         assertNotNull(e2);

   137         BoardModel.selected(b, e2);

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

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

   141         assertNotNull(e4);

   143         BoardModel.selected(b, e4);

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

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

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

   149     }

   151     @Test public void cantSelectEmptySquare() {

   152         Board b = Rules.createBoard();

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

   154         assertNotNull(e3);

   155         BoardModel.selected(b, e3);

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

   157     }

   159     @Test public void cantTakeOwnPiece() {

   160         Board b = Rules.createBoard();

   161         setPlayer(b, Color.W);

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

   163         assertNotNull(e1);

   164         BoardModel.selected(b, e1);

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

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

   168         assertNotNull(e2);

   170         BoardModel.selected(b, e2);

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

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

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

   176     }

   178     @Test public void knightMustMoveToF3() {

   179         Board b = Rules.createBoard();

   180         setPlayer(b, Color.W);

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

   182         BoardModel.selected(b, g1);

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

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

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

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

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

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

   193         BoardModel.selected(b, g3);

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

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

   198         BoardModel.selected(b, f3);

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

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

   202     }

   204     @Test public void pawnCanTakeToSide() {

   205         Board b = Rules.createBoard();

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

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

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

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

   211         BoardModel.selected(b, e2);

   212         BoardModel.selected(b, e4);

   214         setPlayer(b, Color.B);

   216         BoardModel.selected(b, d7);

   217         BoardModel.selected(b, d5);

   219         setPlayer(b, Color.W);

   221         BoardModel.selected(b, e4);

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

   223         BoardModel.selected(b, d5);

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

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

   226     }

   228     @Test public void pawnCanJumpOnAnother() {

   229         Board b = Rules.createBoard();

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

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

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

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

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

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

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

   238         BoardModel.selected(b, e2);

   239         BoardModel.selected(b, e4);

   241         setPlayer(b, Color.B);

   243         BoardModel.selected(b, d7);

   244         BoardModel.selected(b, d5);

   246         setPlayer(b, Color.W);

   248         BoardModel.selected(b, e4);

   249         BoardModel.selected(b, e5);

   251         setPlayer(b, Color.B);

   253         BoardModel.selected(b, e7);

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

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

   256     }

   258     @Test public void showFirstMove() {

   259         Board b = Rules.createBoard();

   260         setPlayer(b, Color.W);

   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);

   266         BoardModel.selected(b, e2);

   267         BoardModel.selected(b, e4);

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

   270         BoardModel.moveUpdate(b, blackMv,

   271             Collections.singletonList("PE4"),

   272             Collections.singletonList("PD5"),

   273             Color.W, null

   274         );

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

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

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

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

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

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

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

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

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

   288     }

   290     @Test public void initialPositionReadFromAServer() {

   291         List<String> blacks = Arrays.asList(

   292             "Pa7",

   293             "Pb7",

   294             "Pc7",

   295             "Pd7",

   296             "Pe7",

   297             "Pf7",

   298             "Pg7",

   299             "Ph7",

   300             "Ra8",

   301             "Nb8",

   302             "Bc8",

   303             "Qd8",

   304             "Ke8",

   305             "Bf8",

   306             "Ng8",

   307             "Rh8"

   308         );

   309         List<String> whites = Arrays.asList(

   310             "Ra1",

   311             "Nb1",

   312             "Bc1",

   313             "Qd1",

   314             "Ke1",

   315             "Bf1",

   316             "Ng1",

   317             "Rh1",

   318             "Pa2",

   319             "Pb2",

   320             "Pc2",

   321             "Pd2",

   322             "Pe2",

   323             "Pf2",

   324             "Pg2",

   325             "Ph2"

   326         );

   328         Board b = Rules.createBoard();

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

   331         Board b2 = Rules.createBoard();

   332         Rules.initBoard(b2);

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

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

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

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

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

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

   341             }

   342         }

   343     }

   345     @Test public void allowSmallRochade() {

   346         Board b = Rules.createBoard();

   347         setPlayer(b, Color.W);

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

   349         f1.setPiece(null);

   350         f1.setPieceColor(null);

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

   352         g1.setPiece(null);

   353         g1.setPieceColor(null);

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

   356         BoardModel.selected(b, e1);

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

   358     }

   360     @Test public void allowSmallRochadeForBlack() {

   361         Board b = Rules.createBoard();

   362         setPlayer(b, Color.B);

   363         b.setTurn(Color.B);

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

   365         f8.setPiece(null);

   366         f8.setPieceColor(null);

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

   368         g8.setPiece(null);

   369         g8.setPieceColor(null);

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

   372         BoardModel.selected(b, e8);

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

   374     }

   376     @Test public void disallowSmallRochadeWhenNoRock() {

   377         Board b = Rules.createBoard();

   378         setPlayer(b, Color.W);

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

   380         f1.setPiece(null);

   381         f1.setPieceColor(null);

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

   383         g1.setPiece(null);

   384         g1.setPieceColor(null);

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

   386         h1.setPiece(null);

   387         h1.setPieceColor(null);

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

   390         BoardModel.selected(b, e1);

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

   392     }

   394     @Test public void disallowSmallRochadeWhenBishop() {

   395         Board b = Rules.createBoard();

   396         setPlayer(b, Color.W);

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

   398         g1.setPiece(null);

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

   401         BoardModel.selected(b, e1);

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

   403     }

   405     @Test public void disallowSmallRochadeWhenKnight() {

   406         Board b = Rules.createBoard();

   407         setPlayer(b, Color.W);

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

   409         f1.setPiece(null);

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

   412         BoardModel.selected(b, e1);

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

   414     }

   416     @Test public void allowBigRochadeForBlack() {

   417         Board b = Rules.createBoard();

   418         setPlayer(b, Color.B);

   419         b.setTurn(Color.B);

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

   421         b8.setPiece(null);

   422         b8.setPieceColor(null);

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

   424         c8.setPiece(null);

   425         c8.setPieceColor(null);

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

   427         d8.setPiece(null);

   428         d8.setPieceColor(null);

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

   431         BoardModel.selected(b, e8);

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

   433     }

   435     @Test public void enPassant() {

   436         Board b = Rules.createBoard();

   437         setPlayer(b, Color.B);

   438         b.setTurn(Color.B);

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

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

   442         movePiece(e7, e4);

   444         Move move = new Move();

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

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

   447         move.setPiece(PieceType.PAWN);

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

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

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

   452         movePiece(d2, d4);

   454         BoardModel.selected(b, e4);

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

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

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

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

   461     }

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

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

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

   466         from.setPiece(null);

   467         from.setPieceColor(null);

   468     }

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

   471         Position p = new Position();

   472         p.setX(c);

   473         p.setY(i);

   474         return p;

   475     }

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

   478         b.setWhitePlayer("x");

   479         b.setBlackPlayer("y");

   480         if (c == Color.B) {

   481             b.setPlayer("y");

   482         } else {

   483             b.setPlayer("x");

   484         }

   485     }

   486 }

author	Jaroslav Tulach <jtulach@netbeans.org>
	Wed, 25 Sep 2013 04:18:47 +0200
branch	chess
changeset 53	bc0094a5f88c
parent 51	3f1866fdb2a1
child 244	cea2063fd0f9
permissions	-rw-r--r--