/*

 * Quoridor server and related libraries

 * Copyright (C) 2009-2010 Jaroslav Tulach <jaroslav.tulach@apidesign.org>

 *

 * This program is free software: you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation, either version 3 of the License.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program. Look for COPYING file in the top folder.

 * If not, see http://www.gnu.org/licenses/.

 */

package cz.xelfi.quoridor;

import cz.xelfi.quoridor.Fence.Orientation;

import cz.xelfi.quoridor.Player.Direction;

import java.io.IOException;

import java.io.StringReader;

import java.io.StringWriter;

import java.util.List;

import junit.framework.TestCase;

/**

 *

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

 */

public abstract class BoardCase extends TestCase {

    protected Board board;

    protected BoardCase(String n) {

        super(n);

        board = Board.empty();

    }

    protected abstract Board move(Board b, int player, Player.Direction... where)

    throws IllegalPositionException;

    protected abstract Board fence(Board b, int player, char x, int y, Fence.Orientation orie)

    throws IllegalPositionException;

    protected abstract Board apply(Board b, Move move) throws IllegalPositionException;

    public void testResignWhite() throws IllegalPositionException {

        List<Player> list = board.getPlayers();

        assertEquals ("Two", 2, list.size ());

        Board b = board.apply(Move.RESIGN);

        assertEquals(b.getPlayers().get(1), b.getWinner());

        try {

            b.apply(Move.EAST);

            fail("No more moves allowed, the player resigned");

        } catch (IllegalPositionException ex) {

            // OK

        }

        assertNull("No player", b.getCurrentPlayer());

    }

    public void testResignBlack() throws IllegalPositionException {

        List<Player> list = board.getPlayers();

        assertEquals ("Two", 2, list.size ());

        Board b = board.apply(Move.NORTH).apply(Move.RESIGN);

        assertEquals(b.getPlayers().get(0), b.getWinner());

        try {

            b.apply(Move.EAST);

            fail("No more moves allowed, the player resigned");

        } catch (IllegalPositionException ex) {

            // OK

        }

        assertNull("No player", b.getCurrentPlayer());

    }

    public void testTwoPlayers () {

        List<Player> list = board.getPlayers();

        assertEquals ("Two", 2, list.size ());

        assertFalse ("Both are non-null", list.contains (null));

        try {

            list.add (null);

            fail ("Modifications are not allowed");

        } catch (UnsupportedOperationException ex) {

            // ok

        }

        try {

            list.remove (0);

            fail ("Modifications are not allowed");

        } catch (UnsupportedOperationException ex) {

            // ok

        }

        assertEquals (8, list.get (0).getXInternal());

        assertEquals (0, list.get (0).getYInternal());

        assertEquals (10, list.get (0).getFences ());

        assertEquals (8, list.get (1).getXInternal());

        assertEquals (16, list.get (1).getYInternal());

        assertEquals (10, list.get (1).getFences ());

    }

    public void testFences () throws IllegalPositionException {

        assertEquals ("No on board", 0, board.getFences ().size ());

        try {

            board.getFences ().add (null);

            fail ("Should be unmodifiable");

        } catch (java.lang.UnsupportedOperationException ex) {

            // ok

        }

        {

            Board b = board.apply(Move.fence('A', 1, Orientation.HORIZONTAL));

            assertEquals("One fence placed: ", 1, b.getFences().size());

            Fence f = b.getFences().iterator().next();

            assertEquals("Row", 1, f.getRow());

            assertEquals("Column", 'A', f.getColumn());

        }

        {

            Board b = board.apply(Move.fence('A', 1, Orientation.VERTICAL));

            assertEquals("One fence placed: ", 1, b.getFences().size());

            Fence f = b.getFences().iterator().next();

            assertEquals("Row", 1, f.getRow());

            assertEquals("Column", 'A', f.getColumn());

        }

        {

            Board b = board.apply(Move.fence('H', 8, Orientation.HORIZONTAL));

            assertEquals("One fence placed: ", 1, b.getFences().size());

            Fence f = b.getFences().iterator().next();

            assertEquals("Row", 8, f.getRow());

            assertEquals("Column", 'H', f.getColumn());

        }

        {

            Board b = board.apply(Move.fence('H', 8, Orientation.VERTICAL));

            assertEquals("One fence placed: ", 1, b.getFences().size());

            Fence f = b.getFences().iterator().next();

            assertEquals("Row", 8, f.getRow());

            assertEquals("Column", 'H', f.getColumn());

        }

    }

    public void testTwoFencesInTheSamePosition() throws IllegalPositionException {

        assertEquals ("No on board", 0, board.getFences ().size ());

        Board one = board.apply(Move.fence('A', 1, Orientation.HORIZONTAL));

        try {

            Board snd = one.apply(Move.fence('A', 1, Orientation.HORIZONTAL));

            fail("Cannot place fence twice to the same place");

        } catch (IllegalPositionException ex) {

            // OK

        }

    }

    public void testSelfDestructionForbidden() throws Exception {

        Board b = board;

        b = fence(b, 0, 'D', 1, Orientation.VERTICAL);

        b = move(b, 1, Player.Direction.SOUTH);

        b = fence(b, 0, 'E', 1, Orientation.VERTICAL);

        b = move(b, 1, Player.Direction.SOUTH);

        try {

            b = fence(b, 0, 'E', 2, Orientation.HORIZONTAL);

            fail ("Forbidden. Player 0 has no way to reach the end");

        } catch (IllegalPositionException ex) {

            // ok

        }

    }

    public void testRealSelfDestructionForbidden() throws Exception {

        String b = "" +

            "                         [N]    \n" +

            "\n" +

"            A   B   C   D   E   F   G   H\n" +

"            |   |   |   |   |   |   |   |\n" +

"        +*----------------------------------+\n" +

"        |                                   |\n" +

"     8--|-------+-------+-------+-------+   |--8\n" +

"        |               |           |       |\n" +

"     7--|   +   +   +   |-------+   |   +   |--7\n" +

"        |               |       |   |       |\n" +

"     6--|   +   +   +   +   +   |   +   +   |--6\n" +

"        |                   |   |           |\n" +

"     5--|   +   +   +   +   |-------+   +   |--5\n" +

"[W]     |                   |               |     [E]\n" +

"     4--|   +   +   +   +   +-------+   +   |--4\n" +

"        |                           |   |   |\n" +

"     3--|   +   +   +   +   +   +   |   |   |--3\n" +

"        |                         P | Q |   |\n" +

"     2--|   +   +   +   +   +   +   +   +   |--2\n" +

"        |                       |           |\n" +

"     1--|   +   +   +   +   +   |   +-------|--1\n" +

"        |                       |           |\n" +

"        +||||-------------------------------+\n" +

"            |   |   |   |   |   |   |   |\n" +

"            A   B   C   D   E   F   G   H\n" +

"\n" +

"                         [S]                 \n";

        b = picture2board(b).toString();

        Board begin = Board.valueOf(b);

        try {

            Board bad = fence(begin, 0, 'G', 2, Orientation.HORIZONTAL);

            fail("Not allowed move:\n" + bad.toString());

        } catch (IllegalPositionException ex) {

            // OK

        }

    }

    public void testFourTimesInAgainstEachOtherResultsInInvalidPosition () throws Exception {

        Board b = board;

        for (int i = 0; i < 3; i++) {

            b = move(b, 0, Player.Direction.NORTH);

            b = move(b, 1, Player.Direction.SOUTH);

        }

        b = move(b, 0, Player.Direction.NORTH);

        try {

            b = move(b, 1, Player.Direction.SOUTH);

            fail ("Now the positions of two players are supposed to be the same, this results in exception");

        } catch (IllegalPositionException ex) {

            // ok

        }

    }

    public void testCanNorth() {

        Move m = board.findMove(board.getCurrentPlayer(), 4, 1);

        assertEquals("Go north", Move.NORTH, m);

    }

    public void testCanEast() {

        Move m = board.findMove(board.getCurrentPlayer(), 5, 0);

        assertEquals("Go east", Move.EAST, m);

    }

    public void testCanWest() {

        Move m = board.findMove(board.getCurrentPlayer(), 3, 0);

        assertEquals("Go west", Move.WEST, m);

    }

    public void testCannotWestAndNorth() {

        Move m = board.findMove(board.getCurrentPlayer(), 3, 1);

        assertNull("No way", m);

    }

    public void testCanJumpStraight () throws Exception {

        Board b = board;

        for (int i = 0; i < 3; i++) {

            b = move(b, 0, Player.Direction.NORTH);

            b = move(b, 1, Player.Direction.SOUTH);

        }

        b = apply(b, Move.NORTH);

        Move m = b.findMove(b.getPlayers().get(0), 4, 6);

        assertEquals("N+N", Move.jump(Direction.NORTH, Direction.NORTH), m);

    }

    public void testCanJumSptraightAndTurn () throws Exception {

        Board b = board;

        for (int i = 0; i < 3; i++) {

            b = move(b, 0, Player.Direction.NORTH);

            b = move(b, 1, Player.Direction.SOUTH);

        }

        b = apply(b, Move.fence('A', 1, Orientation.HORIZONTAL));

        b = apply(b, Move.SOUTH);

        b = apply(b, Move.fence('D', 5, Orientation.HORIZONTAL));

        b = apply(b, Move.fence('A', 8, Orientation.HORIZONTAL));

        Move m = b.findMove(b.getCurrentPlayer(), 4, 5);

        assertNull("No N+N", m);

        m = b.findMove(b.getCurrentPlayer(), 5, 4);

        assertEquals("N+E is OK", Move.jump(Direction.NORTH, Direction.EAST), m);

    }

    public void testCrossFences () throws Exception {

        Board b1 = board.fence (board.getPlayers ().get(0), 'A', 1, Fence.Orientation.HORIZONTAL);

        try {

            b1.fence (b1.getPlayers ().get(1), 'A', 1, Fence.Orientation.VERTICAL);

            fail ("This must fail, as the fences overlap");

        } catch (IllegalPositionException ex) {

            // ok

        }

    }

    public void testPawnsCanJumpOverEachOther () throws Exception {

        Board b = board;

        for (int i = 0; i < 3; i++) {

            b = move(b, 0, Player.Direction.NORTH);

            b = move(b, 1, Player.Direction.SOUTH);

        }

        b = move(b, 0, Player.Direction.NORTH);

        // jump over

        b = move(b, 1, Player.Direction.SOUTH, Player.Direction.SOUTH);

    }

    public void testJumpBackForbidden() throws Exception {

        Board b = board;

        for (int i = 0; i < 3; i++) {

            b = move(b, 0, Player.Direction.NORTH);

            b = move(b, 1, Player.Direction.SOUTH);

        }

        b = move(b, 0, Player.Direction.NORTH);

        b = fence(b, 1, 'D', 6, Orientation.HORIZONTAL);

        try {

            b = move(b, 0, Player.Direction.NORTH, Player.Direction.NORTH);

            fail("Can't jump over a pawn when there is a fence");

        } catch (IllegalPositionException ex) {

            // OK

        }

        try {

            b = move(b, 0, Player.Direction.NORTH, Player.Direction.SOUTH);

            fail("Can't bounce from the fence back neither");

        } catch (IllegalPositionException ex) {

            // OK

        }

    }

    public void testCannotJumpOverFence () throws Exception {

        Board b = fence (board, 0, 'D', 8, Fence.Orientation.HORIZONTAL);

        assertEquals("One fence is present", 1, b.getFences().size());

        final Fence f = b.getFences().iterator().next();

        assertEquals("Row is 8", 8, f.getRow());

        assertEquals("Column is D", 'D', f.getColumn());

        try {

            move(b, 1, Player.Direction.SOUTH);

            fail ("This shall not be allowed, as there is the fence");

        } catch (IllegalPositionException ex) {

            // ok

        }

    }

    public void testSideJumpsNotAllowedWhenThereIsNoFence () throws Exception {

        Board b = board;

        for (int i = 0; i < 3; i++) {

            b = move(b, 0, Player.Direction.NORTH);

            b = move(b, 1, Player.Direction.SOUTH);

        }

        b = move(b, 0, Player.Direction.NORTH);

        try {

            b = move(b, 1, Player.Direction.SOUTH, Player.Direction.WEST);

            fail ("Cannot just jump aside");

        } catch (IllegalPositionException ex) {

            // ok

        }

    }

    public void testSideJumpsAllowedWhenThereAFence () throws Exception {

        Board b = board;

        for (int i = 0; i < 3; i++) {

            b = move(b, 0, Player.Direction.NORTH);

            b = move(b, 1, Player.Direction.SOUTH);

        }

        b = move(b, 0, Player.Direction.NORTH);

        assertEquals (8, b.getPlayers ().get (0).getXInternal());

        assertEquals (8, b.getPlayers ().get (0).getYInternal());

        b = fence(b, 0, 'D', 4, Fence.Orientation.HORIZONTAL);

        // we can over jump to west

        move(b, 1, Player.Direction.SOUTH, Player.Direction.WEST);

        // as well as east

        move(b, 1, Player.Direction.SOUTH, Player.Direction.EAST);

    }

    public void testPlaceAllFences() throws Exception {

        doPlaceAllFences(0);

    }

    public void testPlaceAllFences2() throws Exception {

        doPlaceAllFences(1);

    }

    private void doPlaceAllFences(int player) throws Exception {

        Board b = board;

        int cnt = 10;

        for (int i = 1; i <= 5; i++) {

            b = fence(b, player, 'A', i, Fence.Orientation.HORIZONTAL);

            b = fence(b, player, 'D', i, Fence.Orientation.HORIZONTAL);

            cnt -= 2;

            assertEquals("Two less" + i, cnt, b.getPlayers().get(player).getFences());

        }

        try {

            fence(b, player, 'F', 7, Fence.Orientation.VERTICAL);

            fail("We shall run out of fences");

        } catch (IllegalPositionException ex) {

            // OK

        }

    }

    public void testAlwaysHasToHaveAccessToEndLine () throws Exception {

        Board b = board;

        b = b.fence (b.getPlayers ().get (0), 'E', 1, Fence.Orientation.HORIZONTAL);

        b = b.fence (b.getPlayers ().get (0), 'F', 1, Fence.Orientation.VERTICAL);

        try {

            b = b.fence (b.getPlayers ().get (0), 'D', 1, Fence.Orientation.VERTICAL);

            fail ("This is not allowed as player 0 cannot now reach the final line");

        } catch (IllegalPositionException ex) {

            // ok

        }

    }

    public void testEqualsOfPlayers () throws Exception {

        Player p1 = new Player (1, 1, 10, Player.Direction.EAST);

        Player p2 = new Player (1, 1, 10, Player.Direction.EAST);

        Player p3 = new Player (2, 1, 10, Player.Direction.EAST);

        Player p4 = new Player (1, 1, 10, Player.Direction.WEST);

        Player p5 = new Player (1, 2, 10, Player.Direction.EAST);

        Player p6 = new Player (1, 1, 5, Player.Direction.EAST);

        assertEquals ("p1 == p2", p1, p2);

        if (p2.equals (p3)) fail ();

        if (p2.equals (p4)) fail ();

        if (p2.equals (p5)) fail ();

        if (p2.equals (p6)) fail ();

        if (p3.equals (p6)) fail ();

        if (p4.equals (p3)) fail ();

        if (p6.equals (p3)) fail ();

        if (p5.equals (p3)) fail ();

        if (p5.equals (p3)) fail ();

        if (p4.equals (p3)) fail ();

        if (p3.equals (p4)) fail ();

        if (p3.equals (p5)) fail ();

        if (p4.equals (p5)) fail ();

        if (p5.equals (p4)) fail ();

    }

    public void testEqualsOfFences () throws Exception {

        Fence f1 = new Fence (1, 1, Fence.Orientation.HORIZONTAL);

        Fence f2 = new Fence (1, 1, Fence.Orientation.HORIZONTAL);

        Fence f3 = new Fence (3, 1, Fence.Orientation.HORIZONTAL);

        Fence f4 = new Fence (1, 3, Fence.Orientation.HORIZONTAL);

        Fence f5 = new Fence (1, 1, Fence.Orientation.VERTICAL);

        assertEquals ("f1 == f2", f1, f2);

        if (f1.equals (f3)) fail ();

        if (f3.equals (f1)) fail ();

        if (f5.equals (f1)) fail ();

        if (f1.equals (f5)) fail ();

        if (f4.equals (f1)) fail ();

        if (f1.equals (f4)) fail ();

    }

    public void testEqualsOfBoards1 () throws Exception {

        Board b1 = board.move (board.getPlayers ().get (0), Player.Direction.NORTH);

        Board b2 = board.move (board.getPlayers ().get (0), Player.Direction.NORTH);

        Board b3 = board.move (board.getPlayers ().get (0), Player.Direction.EAST);

        if (b1.equals (b3)) fail ();

        if (b3.equals (b1)) fail ();

        assertEquals ("b1 == b2", b1, b2);

    }

    public void testEqualsOfBoards2 () throws Exception {

        Board b1 = board.fence (board.getPlayers ().get (0), 'E', 3, Fence.Orientation.HORIZONTAL);

        Board b2 = board.fence (board.getPlayers ().get (0), 'E', 3, Fence.Orientation.HORIZONTAL);

        Board b3 = board.fence (board.getPlayers ().get (0), 'D', 3, Fence.Orientation.HORIZONTAL);

        Board b4 = board.fence (board.getPlayers ().get (0), 'E', 4, Fence.Orientation.HORIZONTAL);

        Board b5 = board.fence (board.getPlayers ().get (0), 'E', 3, Fence.Orientation.VERTICAL);

        if (b1.equals (b3)) fail ();

        if (b3.equals (b1)) fail ();

        if (b1.equals (b4)) fail ();

        if (b1.equals (b5)) fail ();

        if (b5.equals (b1)) fail ();

        if (b4.equals (b1)) fail ();

        assertEquals ("b1 == b2", b1, b2);

    }

    public void testEqualsOfBoardsWhenJumpOver () throws Exception {

        Board b = board;

        for (int i = 0; i < 3; i++) {

            b = move(b, 0, Player.Direction.NORTH);

            b = move(b, 1, Player.Direction.SOUTH);

        }

        Board b1 = move(b, 0, Player.Direction.NORTH);

        Board b2 = move(b, 1, Player.Direction.SOUTH);

        b2 = b2.move (b2.getPlayers ().get (0), Player.Direction.NORTH, Player.Direction.NORTH);

        if (b1.equals (b2)) fail ("Not the same, pawns are reverted");

        if (b2.equals (b1)) fail ("Not the same, pawns are reverted");

    }

    public void testMoveAltersCurrentPlayer() throws Exception {

        assertEquals("First player ready", board.getCurrentPlayer(), board.getPlayers().get(0));

        Board b = apply(board, Move.EAST);

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

            assertEquals("Snd player ready", b.getCurrentPlayer(), b.getPlayers().get(1));

            b = apply(b, Move.SOUTH);

            assertEquals("First player ready", b.getCurrentPlayer(), b.getPlayers().get(0));

            b = apply(b, Move.NORTH);

        }

        Board fin = b.apply(Move.NORTH).apply(Move.NORTH);

        assertNotNull("There is a winner", fin.getWinner());

        assertEquals("And the winner is", fin.getPlayers().get(0), fin.getWinner());

        assertFalse("No next move can be applied", fin.isApplicable(Move.fence('D', 3, Fence.Orientation.HORIZONTAL)));

        try {

            fin.apply(Move.EAST);

            fail("No moves allow when we are in final position");

        } catch (IllegalPositionException ex) {

            // OK

        }

    }

    public void testDetectInvalidFence() {

        try {

            Move m = Move.fence('D', 9, Orientation.HORIZONTAL);

            fail("Move shall not be allowed: " + m);

        } catch (IllegalPositionException ex) {

            // OK

        }

    }

    public void testEqualityOfMoves() throws Exception {

        for (Direction m1 : Direction.values()) {

            for (Direction m2 : Direction.values()) {

                Move both1 = Move.jump(m1, m2);

                Move both2 = Move.jump(m1, m2);

                Move opposite = Move.jump(m2, m1);

                assertTrue("Both boths are equal", both1.equals(both2));

                assertFalse("Not north", Move.NORTH.equals(both1));

                assertFalse("Not east", Move.EAST.equals(both1));

                assertFalse("Not west", Move.WEST.equals(both1));

                assertFalse("Not south", Move.SOUTH.equals(both1));

                if (m1 == m2) {

                    continue;

                }

                assertFalse("Not equal to opposite", both1.equals(opposite));

            }

        }

        Move f1 = Move.fence('D', 6, Orientation.HORIZONTAL);

        Move f2 = Move.fence('D', 6, Orientation.HORIZONTAL);

        Move f3 = Move.fence('D', 6, Orientation.VERTICAL);

        Move f4 = Move.fence('E', 6, Orientation.VERTICAL);

        Move f5 = Move.fence('E', 5, Orientation.VERTICAL);

        assertEquals(f1, f2);

        assertFalse(f1.equals(f3));

        assertFalse(f4.equals(f5));

        assertFalse(f3.equals(f5));

    }

    public void testBrokenWriteOfAGameDanVsJarda() throws Exception {

        Board b = board.apply(Move.NORTH).apply(Move.SOUTH).

            apply(Move.NORTH).apply(Move.SOUTH).

            apply(Move.NORTH).apply(Move.SOUTH).

            apply(Move.WEST).apply(Move.fence('C', 6, Orientation.HORIZONTAL)).

            apply(Move.EAST).apply(Move.SOUTH).

            apply(Move.fence('E', 2, Orientation.HORIZONTAL)).apply(Move.fence('E', 5, Orientation.HORIZONTAL)).

            apply(Move.fence('F', 3, Orientation.VERTICAL)).apply(Move.fence('D', 6, Orientation.VERTICAL)).

            apply(Move.jump(Direction.NORTH, Direction.EAST)).apply(Move.fence('F', 5, Orientation.VERTICAL)).

            apply(Move.fence('E', 1, Orientation.VERTICAL)).apply(Move.fence('E', 4, Orientation.VERTICAL)).

            apply(Move.fence('D', 8, Orientation.HORIZONTAL)).apply(Move.fence('D', 7, Orientation.HORIZONTAL)).

            apply(Move.fence('D', 4, Orientation.HORIZONTAL)).apply(Move.fence('E', 8, Orientation.VERTICAL)).

            apply(Move.fence('C', 3, Orientation.HORIZONTAL)).apply(Move.WEST).

            apply(Move.fence('D', 2, Orientation.VERTICAL)).apply(Move.fence('A', 4, Orientation.HORIZONTAL)).

            apply(Move.fence('B', 2, Orientation.HORIZONTAL)).apply(Move.WEST).

            apply(Move.SOUTH).apply(Move.SOUTH).

            apply(Move.SOUTH).apply(Move.WEST);

        Board m = move(b, 0, Direction.WEST);

        Board f = fence(m, 1, 'A', 1, Orientation.VERTICAL);

        Board l = fence(f, 0, 'A', 3, Orientation.VERTICAL);

    }

    public void testTomasHolyCannotJumpWS() throws Exception {

/*

N   S 

N   S 

N   S 

 */

        Board b = apply(board, Move.NORTH);

        b = apply(b, Move.SOUTH);

        b = apply(b, Move.NORTH);

        b = apply(b, Move.SOUTH);

        b = apply(b, Move.NORTH);

        b = apply(b, Move.SOUTH);

/*        

HD3   HE6 

HB6   HG3 

VE3   HD4 

HA4   VB5 

 */

        b = fence(b, 0, 'D', 3, Orientation.HORIZONTAL);

        b = fence(b, 1, 'E', 6, Orientation.HORIZONTAL);

        b = fence(b, 0, 'B', 6, Orientation.HORIZONTAL);

        b = fence(b, 1, 'G', 3, Orientation.HORIZONTAL);

        b = fence(b, 0, 'E', 3, Orientation.VERTICAL);

        b = fence(b, 1, 'D', 4, Orientation.HORIZONTAL);

        b = fence(b, 0, 'A', 4, Orientation.HORIZONTAL);

        b = fence(b, 1, 'B', 5, Orientation.VERTICAL);

/*        

VE1   HC5 

VE5   HF2 

VH2   HH1 

HB3   HF1 

HA1   S 

 */

        b = fence(b, 0, 'E', 1, Orientation.VERTICAL);

        b = fence(b, 1, 'C', 5, Orientation.HORIZONTAL);

        b = fence(b, 0, 'E', 5, Orientation.VERTICAL);

        b = fence(b, 1, 'F', 2, Orientation.HORIZONTAL);

        b = fence(b, 0, 'H', 2, Orientation.VERTICAL);

        b = fence(b, 1, 'H', 1, Orientation.HORIZONTAL);

        b = fence(b, 0, 'B', 3, Orientation.HORIZONTAL);

        b = fence(b, 1, 'F', 1, Orientation.HORIZONTAL);

        b = fence(b, 0, 'A', 1, Orientation.HORIZONTAL);

        b = apply(b, Move.SOUTH);

/*

W   W 

W   HC8 

HC1   HE8 

N                

*/

        b = apply(b, Move.WEST);

        b = apply(b, Move.WEST);

        b = apply(b, Move.WEST);

        b = fence(b, 1, 'C', 8, Orientation.HORIZONTAL);

        b = fence(b, 0, 'C', 1, Orientation.HORIZONTAL);

        b = fence(b, 1, 'E', 8, Orientation.HORIZONTAL);

        b = apply(b, Move.NORTH);

/* and now try WS */

        b = move(b, 1, Direction.WEST, Direction.SOUTH);

        assertNotNull("Board is OK", b);

    }

    static String toPicture(Board b) throws IOException {

        StringWriter sw = new StringWriter();

        b.write(sw);

        return sw.toString();

    }

    static Board picture2board(String text) throws IOException, IllegalPositionException {

        StringReader sr = new StringReader(text);

        return Board.read(sr);

    }

}