/*

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

     }

 }