AttackMap _map; // = new AttackMap(new List<Move>(), board);
#endregion Fields
#region Constructors
public ClassForTest(Figure figure, string cell)
{
Board = new Board();
ValidCells = new List<string>();
Figure = figure;
Board[cell] = Figure;
_map = new AttackMap(new List<Move>(), Board);
}
public void SimpleIsPromotionWhiteTest()
{
//a - arange
var board = new Board();
board["d7"] = new FigurePawn(Side.WHITE);
//a - act
AttackMap map = new AttackMap(new List<Move>(), board);
board.DoMove("d7", "d8", FigureQueen.SYMBOL.ToString(CultureInfo.InvariantCulture));
//a - assert
Assert.AreEqual(typeof(FigureQueen), board["d8"].GetType());
}
public override Response DoWork(string request)
{
var moveVariantsRequest = JsonConvert.DeserializeObject<MoveVariantsRequest>(request);
var moveVariantsResponse = new MoveVariantsResponse();
var game = Server.Games[moveVariantsRequest.GameID];
var map = new AttackMap(game.Moves);
if (map.SourceBoard[moveVariantsRequest.Cell].Side == game.Turn)
{
moveVariantsResponse.Cells = map.MoveVariants(moveVariantsRequest.Cell);
}
else
{
moveVariantsResponse.Cells = new List<string>();
}
moveVariantsResponse.Status = Statuses.Ok;
return moveVariantsResponse;
}
public void BlackBishopTest()
{
//a - arange
var board = new Board();
var bishop = new FigureBishop(Side.BLACK);
var knight = new FigureKnight(Side.WHITE);
var rook = new FigureRook(Side.WHITE);
var queen = new FigureQueen(Side.WHITE);
var pawn = new FigurePawn(Side.WHITE);
board["e5"] = bishop;
board["c3"] = knight;
board["c7"] = rook;
board["g3"] = pawn;
board["g7"] = queen;
//a - act
var map = new AttackMap(new List<Move>(), board);
//a - assert
var validCells = new List<string>
{
"f6","g7",
"d4","c3",
"d6","c7",
"f4","g3"
};
for (var j = 1; j <= Board.BoardSize; j++)
{
for (var i = 'a'; i <= 'h'; i++)
{
var cell = i.ToString(CultureInfo.InvariantCulture) + j;
if (validCells.Contains(cell))
{
Assert.IsTrue(map[cell].Contains(bishop));
}
else
{
Assert.IsFalse(map[cell].Contains(bishop));
}
}
}
}
public void AfterIsCheckTest()
{
//a - arange
var board = new Board();
var pawn = new FigurePawn(Side.WHITE);
var king = new FigureKing(Side.WHITE);
board["h3"] = king;
board["g2"] = pawn;
board["f3"] = new FigureQueen(Side.BLACK);
//a - act
var map = new AttackMap(new List<Move>(), board);
//a - assert
Assert.IsTrue(map.IsCheck);
Assert.IsTrue(map["f3"].Contains(pawn));
Assert.IsTrue(map["g3"].Contains(pawn));
Assert.IsFalse(map["g4"].Contains(pawn));
Assert.IsFalse(map["g3"].Contains(king));
Assert.IsFalse(map["g4"].Contains(king));
Assert.IsTrue(map["h2"].Contains(king));
Assert.IsTrue(map["h4"].Contains(king));
}
public void WhiteKnightTest()
{
//a - arange
var board = new Board();
var knight = new FigureKnight(Side.WHITE);
var rook = new FigureRook(Side.BLACK);
var bishop = new FigureBishop(Side.BLACK);
var queen = new FigureQueen(Side.BLACK);
var queen1 = new FigureQueen(Side.WHITE);
var bishop1 = new FigureBishop(Side.BLACK);
board["e4"] = knight;
board["f6"] = queen1;
board["g5"] = bishop1;
board["g3"] = bishop;
board["f3"] = rook;
board["d2"] = queen;
//a - act
var map = new AttackMap(new List<Move>(), board);
//a - assert
Assert.IsTrue(!map["f6"].Contains(knight));
Assert.IsTrue(map["g5"].Contains(knight));
Assert.IsTrue(map["g3"].Contains(knight));
Assert.IsTrue(map["f2"].Contains(knight));
Assert.IsTrue(map["d2"].Contains(knight));
Assert.IsTrue(map["c3"].Contains(knight));
Assert.IsTrue(map["c5"].Contains(knight));
Assert.IsTrue(map["d6"].Contains(knight));
Assert.IsTrue(!map["h6"].Contains(knight));
}
public void SimpleQueenTest()
{
//a - arange
var board = new Board();
var queen = new FigureQueen(Side.WHITE);
board["d4"] = queen;
//a - act
var map = new AttackMap(new List<Move>(), board);
//a - assert
var validCells = new List<string>
{
"e3","f2",
"g1","c5",
"b6","a7",
"c3","b2",
"a1","e5",
"f6","g7",
"h8",
"d3","d2","d1",
"d5","d6","d7","d8",
"e4","f4","g4","h4",
"c4","b4","a4"
};
for (var j = 1; j <= Board.BoardSize; j++)
{
for (var i = 'a'; i <= 'h'; i++)
{
var cell = i.ToString(CultureInfo.InvariantCulture) + j;
if (validCells.Contains(cell))
{
Assert.IsTrue(map[cell].Contains(queen));
}
else
{
Assert.IsFalse(map[cell].Contains(queen));
}
}
}
}
public void SimpleKingTest()
{
//a - arange
var board = new Board();
var king = new FigureKing(Side.WHITE);
board["e4"] = king;
//a - act
var map = new AttackMap(new List<Move>(), board);
//a - assert
Assert.IsTrue(map["e5"].Contains(king));
Assert.IsTrue(map["f5"].Contains(king));
Assert.IsTrue(map["f4"].Contains(king));
Assert.IsTrue(map["f3"].Contains(king));
Assert.IsTrue(map["e3"].Contains(king));
Assert.IsTrue(map["d3"].Contains(king));
Assert.IsTrue(map["d4"].Contains(king));
Assert.IsTrue(map["d5"].Contains(king));
Assert.IsTrue(!map["h6"].Contains(king));
}
public void ShortCastlingWhiteTest2()
{
//a - arange
var board = new Board();
var king = new FigureKing(Side.WHITE);
var rook = new FigureRook(Side.WHITE);
var pawn = new FigurePawn(Side.WHITE);
board["e1"] = king;
board["h1"] = rook;
board["f1"] = pawn;
//a - act
var map = new AttackMap(new List<Move>(), board);
//a - assert
Assert.IsFalse(map["g1"].Contains(king));
}
public void OneWhitePawnTest()
{
//a - arange
var board = new Board();
var pawn = new FigurePawn(Side.WHITE);
board["e2"] = pawn;
//a - act
var map = new AttackMap(new List<Move>(), board);
//a - assert
Assert.IsTrue(map["e3"].Contains(pawn));
Assert.IsTrue(map["e4"].Contains(pawn));
}
public void LongCastlingBlackTest4()
{
//a - arange
var board = new Board();
var king = new FigureKing(Side.BLACK);
var rook = new FigureRook(Side.BLACK);
var knight = new FigureKnight(Side.WHITE);
board["e8"] = king;
board["a8"] = rook;
board["d6"] = knight;
//a - act
var moves = new List<Move>{
new Move { From = "c8", To = "d6" }};
var map = new AttackMap(moves, board);
//a - assert
Assert.IsFalse(map["c8"].Contains(king));
}
public void BlackQueenVsWhiteTest()
{
//a - arange
var board = new Board();
var knight = new FigureKnight(Side.WHITE);
var rook = new FigureRook(Side.WHITE);
var queen2 = new FigureQueen(Side.WHITE);
var pawn = new FigurePawn(Side.WHITE);
var queen = new FigureQueen(Side.BLACK);
board["d1"] = rook;
board["d8"] = rook;
board["h4"] = knight;
board["a4"] = queen2;
//Диагональ
board["d4"] = queen;
board["a1"] = knight;
board["a7"] = rook;
board["g1"] = pawn;
board["h8"] = queen2;
//a - act
var map = new AttackMap(new List<Move>(), board);
//a - assert
var validCells = new List<string>
{
"e3","f2",
"g1","c5",
"b6","a7",
"c3","b2",
"a1","e5",
"f6","g7",
"h8",
"d3","d2","d1",
"d5","d6","d7","d8",
"e4","f4","g4","h4",
"c4","b4","a4"
};
for (var j = 1; j <= Board.BoardSize; j++)
{
for (var i = 'a'; i <= 'h'; i++)
{
var cell = i.ToString(CultureInfo.InvariantCulture) + j;
if (validCells.Contains(cell))
{
Assert.IsTrue(map[cell].Contains(queen));
}
else
{
Assert.IsFalse(map[cell].Contains(queen));
}
}
}
}
public void BlackPawnSimpleTest()
{
//a - arange
var board = new Board();
var pawn = new FigurePawn(Side.BLACK);
board["e7"] = pawn;
//a - act
var map = new AttackMap(new List<Move>(), board);
//a - assert
var validCells = new List<string>
{
"e6","e5"
};
for (var j = 1; j <= Board.BoardSize; j++)
{
for (var i = 'a'; i <= 'h'; i++)
{
var cell = i.ToString(CultureInfo.InvariantCulture) + j;
if (validCells.Contains(cell))
{
Assert.IsTrue(map[cell].Contains(pawn));
}
else
{
Assert.IsFalse(map[cell].Contains(pawn));
}
}
}
}
public void BlackPassedPawnTest2()
{
//a - arange
var board = new Board();
var pawnWhite = new FigurePawn(Side.WHITE);
var pawnBlack = new FigurePawn(Side.BLACK);
board["f5"] = pawnWhite;
board["g5"] = pawnBlack;
var moves = new List<Move>{
new Move { From = "g7", To = "g6" },
new Move { From = "g6", To = "g5" }};
//a - act
var map = new AttackMap(moves, board);
//a - assert
Assert.IsFalse(map["g6"].Contains(pawnWhite));
}
public void WhitePassedPawnTest2()
{
//a - arange
var board = new Board();
var pawnBlack = new FigurePawn(Side.BLACK);
//board["c4"] = pawnWhite;
//board["b4"] = pawnBlack;
//board["d4"] = rookBlack;
var moves = new List<Move>{
new Move { From = "c2", To = "c4" },
new Move { From = "f6", To = "d4" },
new Move { From = "b5", To = "b4" }};
//a - act
var map = new AttackMap(moves, new Board());
//a - assert
Assert.IsTrue(!map["c3"].Contains(pawnBlack));
}
public void WhitePassedPawnTest()
{
//a - arange
var board = new Board();
var pawnWhite = new FigurePawn(Side.WHITE);
var pawnBlack = new FigurePawn(Side.BLACK);
board["c4"] = pawnWhite;
board["b4"] = pawnBlack;
var moves = new List<Move>{
new Move { From = "c2", To = "c4" }};
//a - act
var map = new AttackMap(moves, board);
//a - assert
Assert.IsTrue(map["c3"].Contains(pawnBlack));
}
public void IsStalemateWhiteTest()
{
//a - arange
var board = new Board();
var pawn = new FigurePawn(Side.WHITE);
var pawn2 = new FigurePawn(Side.BLACK);
var king = new FigureKing(Side.WHITE);
board["h8"] = king;
board["f7"] = new FigureQueen(Side.BLACK);
board["b4"] = pawn;
board["b5"] = pawn2;
//a - act
var map = new AttackMap(new List<Move>(), board);
//a - assert
Assert.IsTrue(map.IsStalemateWhite);
}
public void BlackRookTest()
{
//a - arange
var board = new Board();
var rook = new FigureRook(Side.BLACK);
var knight = new FigureKnight(Side.WHITE);
var bishop = new FigureBishop(Side.WHITE);
var pawn = new FigurePawn(Side.WHITE);
var queen = new FigureQueen(Side.WHITE);
board["e4"] = rook;
board["e3"] = knight;
board["e5"] = bishop;
board["d4"] = pawn;
board["f4"] = queen;
//a - act
var map = new AttackMap(new List<Move>(), board);
for (var i = 'a'; i <= 'h'; i++)
{
for (var j = 1; j <= Board.BoardSize; j++)
{
if (j == 4)
{
if (i == 'f' || i == 'd')
Assert.IsTrue(map[i.ToString(CultureInfo.InvariantCulture) + j].Contains(rook));
if (i == 'e')
Assert.IsTrue(!map[i.ToString(CultureInfo.InvariantCulture) + j].Contains(rook));
}
else if (j == 3 || j == 5)
{
if (i == 'e')
Assert.IsTrue(map[i.ToString(CultureInfo.InvariantCulture) + j].Contains(rook));
}
else
Assert.IsTrue(!map[i.ToString(CultureInfo.InvariantCulture) + j].Contains(rook));
}
}
}
public void LongCastlingBlackTest2()
{
//a - arange
var board = new Board();
var king = new FigureKing(Side.BLACK);
var rook = new FigureRook(Side.BLACK);
var pawn = new FigurePawn(Side.BLACK);
board["e8"] = king;
board["a8"] = rook;
board["b8"] = pawn;
//a - act
var map = new AttackMap(new List<Move>(), board);
//a - assert
Assert.IsFalse(map["c8"].Contains(king));
}
public void BlackRookVsBlackTest()
{
//a - arange
var board = new Board();
var rook = new FigureRook(Side.BLACK);
var knight = new FigureKnight(Side.BLACK);
var queen = new FigureQueen(Side.BLACK);
var bishop = new FigureBishop(Side.BLACK);
var rook2 = new FigureRook(Side.BLACK);
board["e4"] = rook;
board["e2"] = rook2;
board["e6"] = knight;
board["f4"] = queen;
board["b4"] = bishop;
//a - act
var map = new AttackMap(new List<Move>(), board);
//a - assert
for (var j = 1; j <= Board.BoardSize; j++)
{
if (j != 4 && j < 6 && j > 2)
Assert.IsTrue(map["e" + j].Contains(rook));
if (j >= 6 && j < 2)
Assert.IsTrue(!map["e" + j].Contains(rook));
}
for (var i = 'a'; i <= 'h'; i++)
{
if (i != 'e' && i < 'f' && i > 'b')
Assert.IsTrue(map[i.ToString(CultureInfo.InvariantCulture) + 4].Contains(rook));
}
}
public void LongCastlingWhiteTest()
{
//a - arange
var board = new Board();
var king = new FigureKing(Side.WHITE);
var rook = new FigureRook(Side.WHITE);
board["e1"] = king;
board["a1"] = rook;
//a - act
var map = new AttackMap(new List<Move>(), board);
//a - assert
Assert.IsTrue(map["c1"].Contains(king));
}
public void InitialPositionTest()
{
//a - act
var map = new AttackMap(new List<Move>());
}
public void ShortCastlingBlackTest()
{
//a - arange
var board = new Board();
var king = new FigureKing(Side.BLACK);
var rook = new FigureRook(Side.BLACK);
board["e8"] = king;
board["h8"] = rook;
//a - act
var map = new AttackMap(new List<Move>(), board);
//a - assert
Assert.IsTrue(map["g8"].Contains(king));
}
public void IsCheckTest()
{
//a - arange
var board = new Board();
var rook = new FigureRook(Side.BLACK);
var king = new FigureKing(Side.WHITE);
board["e3"] = king;
board["h3"] = rook;
//a - act
var map = new AttackMap(new List<Move>(), board);
Assert.IsTrue(map.IsCheck);
}
public void SimpleBishopTest()
{
//a - arange
var board = new Board();
var bishop = new FigureBishop(Side.WHITE);
board["e4"] = bishop;
//a - act
var map = new AttackMap(new List<Move>(), board);
//a - assert
for (var j = 1; j <= Board.BoardSize; j++)
{
for (var i = 'a'; i <= 'h'; i++)
{
if (Math.Abs('e' - i) == Math.Abs(4 - j) && j != 4)
{
Assert.IsTrue(map[i.ToString(CultureInfo.InvariantCulture) + j].Contains(bishop));
}
else
{
Assert.IsFalse(map[i.ToString(CultureInfo.InvariantCulture) + j].Contains(bishop));
}
}
}
}
public void SimpleRookTest()
{
//a - arange
var board = new Board();
var rook = new FigureRook(Side.WHITE);
board["e4"] = rook;
//a - act
var map = new AttackMap(new List<Move>(), board);
//a - assert
for (var j = 1; j <= Board.BoardSize; j++)
{
if (j != 4)
Assert.IsTrue(map["e" + j].Contains(rook));
}
for (var i = 'a'; i <= 'h'; i++)
{
if (i != 'e')
Assert.IsTrue(map[i.ToString(CultureInfo.InvariantCulture) + 4].Contains(rook));
}
}
public void SimpleKnightTest()
{
//a - arange
var board = new Board();
var knight = new FigureKnight(Side.WHITE);
board["e4"] = knight;
//a - act
var map = new AttackMap(new List<Move>(), board);
//a - assert
Assert.IsTrue(map["f6"].Contains(knight));
Assert.IsTrue(map["g5"].Contains(knight));
Assert.IsTrue(map["g3"].Contains(knight));
Assert.IsTrue(map["f2"].Contains(knight));
Assert.IsTrue(map["d2"].Contains(knight));
Assert.IsTrue(map["c3"].Contains(knight));
Assert.IsTrue(map["c5"].Contains(knight));
Assert.IsTrue(map["d6"].Contains(knight));
}
public void IsMateWhiteTest()
{
//a - arange
var board = new Board();
board["a1"] = new FigureKing(Side.WHITE);
board["a2"] = new FigurePawn(Side.WHITE);
board["b1"] = new FigureRook(Side.WHITE);
board["b2"] = new FigureBishop(Side.WHITE);
board["c2"] = new FigureKnight(Side.BLACK);
//a - act
var map = new AttackMap(new List<Move>(), board);
//a - assert
Assert.IsTrue(map.IsMateWhite);
}
public void IsMateBlackTest()
{
//a - arange
var board = new Board();
var king = new FigureKing(Side.BLACK);
board["e8"] = king;
board["g8"] = new FigureQueen(Side.WHITE);
board["c8"] = new FigureRook(Side.WHITE);
board["b7"] = new FigureRook(Side.WHITE);
board["e7"] = new FigureBishop(Side.WHITE);
//a - act
var map = new AttackMap(new List<Move>(), board);
//a - assert
Assert.IsTrue(map.IsMateBlack);
}
public void WhiteKingTest()
{
//a - arange
var board = new Board();
var king = new FigureKing(Side.WHITE);
var pawn = new FigurePawn(Side.WHITE);
var rook = new FigureRook(Side.BLACK);
var pawn1 = new FigurePawn(Side.BLACK);
var bishop = new FigureBishop(Side.BLACK);
var queen = new FigureQueen(Side.BLACK);
board["e4"] = king;
board["f5"] = pawn;
board["f4"] = pawn1;
board["f3"] = bishop;
board["e3"] = rook;
board["d3"] = queen;
//a - act
var map = new AttackMap(new List<Move>(), board);
//a - assert
Assert.IsFalse(map["e5"].Contains(king));
Assert.IsFalse(map["f5"].Contains(king));
Assert.IsTrue(map["f4"].Contains(king));
Assert.IsFalse(map["f3"].Contains(king));
Assert.IsFalse(map["e3"].Contains(king));
Assert.IsFalse(map["d3"].Contains(king));
Assert.IsFalse(map["d4"].Contains(king));
Assert.IsFalse(map["d5"].Contains(king));
Assert.IsFalse(map["g4"].Contains(king));
}
