public void TestGetGameBoard()
{
TicTacToe game = new TicTacToe("Player1", "Player2");
//GameBoard á ekki að vera tómt
CollectionAssert.AreNotEqual(game.GameBoard, null);
}
public void TestTicTacToeConstructor()
{
TicTacToe game = new TicTacToe("Testguy", "Testgal");
Assert.IsNotNull(game);
//TicTacToe g2;
//Assert.IsNull(g2 = new TicTacToe("ble",null),"villa");
// Bera saman upphafsborð, ath hvort smiður búi til rétt borð í upphafi leiks
int i = 0;
Play[] pArr = {0,0,0,0,0,0,0,0,0};
foreach (var item in pArr)
{
Assert.AreEqual(game.GameBoard[i], pArr[i]);
i++;
}
// Ath fjölda reita í borði i verður 9 = 10 reitir, einum of mikið. Lykkjan bætir einum við en hættir keyrslu á réttum stað
Assert.AreEqual(i, 9);
// Ath hvort að vinningsstöður séu réttar í _winningCombinations
CollectionAssert.AreEqual(new int[,] { { 0, 1, 2 }, { 3, 4, 5 },
{ 6, 7, 8 }, { 0, 3, 6 },
{ 1, 4, 7 }, { 2, 5, 8 },
{ 0, 4, 8 }, { 2, 4, 6 }
},
game._winningCombinations);
}
public void CurrentPlayerPlaceOOnBoard()
{
TicTacToe controller = new TicTacToe();
int[,] boardArray = controller.CreateBoard();
controller.MakeMove("x", "o", "o", boardArray, 0);
Assert.AreEqual(2, boardArray[0, 1]);
}
public void NotThrowPlayerNotPlayingGameException_WhenPlayerWhoPlaysIsInTheGame()
{
var fakeFirstPlayer = new Mock <IPlayer>();
var fakeSecondPlayer = new Mock <IPlayer>();
var game = new TicTacToe(fakeFirstPlayer.Object, fakeSecondPlayer.Object);
Assert.DoesNotThrow(() => game.PlayTurn(fakeFirstPlayer.Object, 1));
}
public void MoveOFail()
{
var game = new TicTacToe(state);
var move = new TicTacToeMove(TicTacToePlayer.O, new TicTacToeCell(0, 1));
var newState = game.MakeMove(move);
Assert.IsNull(newState);
}
public void ShouldNotMarkTheSameStep()
{
var game = new TicTacToe();
game.Mark(1, 1);
Assert.IsFalse(game.CanMark(1, 1));
game.Mark(1, 1);
}
public void testMovingBumpsLevelByOne() {
TicTacToe t1 = new TicTacToe();
int level = t1.getLevel(t1.getState());
Assert.assertEquals(0, level);
t1.makeMove(0, 0);
level = t1.getLevel(t1.getState());
Assert.assertEquals(1, level);
}
public void T3NeitherPlayerHasThreeInARow()
{
TicTacToe ticTacToe = new TicTacToe();
const char expectet = ' ';
char actual = ticTacToe.Validate();
Assert.AreEqual(expectet, actual);
}
public void TokenAlreadyExists()
{
state.Cells[1, 1] = TicTacToePlayer.X;
var game = new TicTacToe(state);
Assert.IsNull(game.State.Winner);
Assert.IsNull(game.MakeMove(new TicTacToeMove(TicTacToePlayer.O, new TicTacToeCell(1, 1))));
}
public void playerOMarker()
{
TicTacToe board = new TicTacToe();
board.CreateBoard();
board.switchPlayer();
board.MakeMove(0);
Assert.AreEqual(2, board.newBoard[0]);
}
public void SetSecondPlayer()
{
var fakeFirstPlayer = new Mock <IPlayer>();
var fakeSecondPlayer = new Mock <IPlayer>();
var game = new TicTacToe(fakeFirstPlayer.Object, fakeSecondPlayer.Object);
Assert.AreEqual(game.SecondtPlayer, fakeSecondPlayer.Object);
}
static void Main(string[] args)
{
// Diese Variante des TicTacToe-Spiels nutz Polymporphie mit Hilfe der Schnittstelle ISpieler
TicTacToe ttt = new TicTacToe();
ttt.Spieler1 = WaehleSpieler('X');
ttt.Spieler2 = WaehleSpieler('O');
ttt.StarteSpiel();
}
public void CreateGameWhichIsNotOver()
{
var fakeFirstPlayer = new Mock <IPlayer>();
var fakeSecondPlayer = new Mock <IPlayer>();
var game = new TicTacToe(fakeFirstPlayer.Object, fakeSecondPlayer.Object);
Assert.IsFalse(game.IsOver);
}
public void ReturnFalse_WhenAPostionIsAlreadyMarked()
{
var fakeFirstPlayer = new Mock <IPlayer>();
var fakeSecondPlayer = new Mock <IPlayer>();
var game = new TicTacToe(fakeFirstPlayer.Object, fakeSecondPlayer.Object);
game.PlayTurn(fakeFirstPlayer.Object, 1);
Assert.IsFalse(game.PlayTurn(fakeFirstPlayer.Object, 1));
}
public void Test_TicTacToe_3x3_P1Win_Diagonal()
{
gameboard_3x3 = new TicTacToe(3);
gameboard_3x3.PlacePiece(0, 0, 1);
gameboard_3x3.PlacePiece(1, 1, 1);
var result = gameboard_3x3.PlacePiece(2, 2, 1);
Assert.AreEqual(1, result);
}
public void board_size_is_3x3()
{
TicTacToe game = new TicTacToe();
int expectedWIDTH = 3;
int expectedHEIGHT = 3;
Assert.That(TicTacToe.WIDTH, Is.EqualTo(expectedWIDTH));
Assert.That(TicTacToe.HEIGHT, Is.EqualTo(expectedHEIGHT));
}
public void Should_Next_Next_Player()
{
TicTacToe t = new TicTacToe();
t.Next();
t.Next();
Assert.AreEqual(t.GetCurrentPlayer(), 1);
}
static void Main(string[] args)
{
// Diese Variante des TicTacToe nutzt Polymporhie mit Hilfe der abstrakten Klasse Spieler
TicTacToe ttt = new TicTacToe();
ttt.Spieler1 = WaehleSpieler('X');
ttt.Spieler2 = WaehleSpieler('O');
ttt.StarteSpiel();
}
// Use this for initialization
void Awake()
{
audioSrc = GetComponent <AudioSource>();
manager = FindObjectOfType <TicTacToe>();
myRenderer = GetComponent <SpriteRenderer>();
empty = Resources.Load("box", typeof(Sprite)) as Sprite;
circled = Resources.Load("boxCircled", typeof(Sprite)) as Sprite;
crossed = Resources.Load("boxCrossed", typeof(Sprite)) as Sprite;
}
public void Deveria_criar_inteligencia()
{
return;
using (TicTacToe ticTacToe = new TicTacToe('O', 'X'))
{
ticTacToe.AutomaticPlay();
}
}
public void GivenThisNextFullBoard(Table table)
{
_game = new TicTacToe(_gameManager.Object, null, _fileWriter.Object);
var board = new Board();
board.SetFromTable(table);
_game.setBoard(board);
}
// This is only called when the game is first started
public void OnGet()
{
// We need a game object, becausde the Razor page always
// displays what's in the game object's game grid
game = new TicTacToe();
// We need to clear out the game grid when we start a new game
HttpContext.Session.Clear();
}
public void Test_TicTacToe_3x3_P2Win_Horizontal()
{
gameboard_3x3 = new TicTacToe(3);
gameboard_3x3.PlacePiece(0, 0, 2);
gameboard_3x3.PlacePiece(0, 1, 2);
var result = gameboard_3x3.PlacePiece(0, 2, 2);
Assert.AreEqual(2, result);
}
public void WillThrowExceptionIfWinCheckerReturnsNULL()
{
Mock <IWinChecker> mockChecker = new Mock <IWinChecker>(MockBehavior.Strict);
CompositeGame game = new TicTacToe(mockChecker.Object);
game.setBoard(new List <List <BoardGame> >());
mockChecker.Setup(x => x.checkForWin(game)).Returns((PlayerColour?)null);
game.getWinner();
}
static void Main(string[] args)
{
var memory = new MemoryRepository();
var output = new ConsoleDisplay();
var input = new ConsoleController();
var game = new TicTacToe(memory, output, input);
game.Start();
}
public void TestVerticalWin()
{
Char[,] board = { { '.', '.', 'O' },
{ '.', '.', 'O' },
{ '.', '.', 'O' } };
TicTacToe game = new TicTacToe(board);
Assert.AreEqual(game.checkWinVertical(), true);
}
public void TestHorizontalWin()
{
Char[,] board = { { 'X', 'X', 'X' },
{ '.', '.', '.' },
{ '.', '.', '.' } };
TicTacToe game = new TicTacToe(board);
Assert.AreEqual(game.checkWinHorizontal(), true);
}
public void TestDraw()
{
Char[,] board = { { 'O', 'X', 'O' },
{ 'X', 'X', 'O' },
{ 'O', 'O', 'X' } };
TicTacToe game = new TicTacToe(board);
Assert.AreEqual(game.checkDraw(), true);
}
public void TestDiagonalWinBottomLeftToTopRight()
{
Char[,] board = { { '.', '.', 'O' },
{ '.', 'O', '.' },
{ 'O', '.', '.' } };
TicTacToe game = new TicTacToe(board);
Assert.AreEqual(game.checkWinDiagonal(), true);
}
public void TestValidMove()
{
Char[,] board = { { '.', 'X', 'O' },
{ 'X', 'X', 'O' },
{ 'O', 'O', 'X' } };
TicTacToe game = new TicTacToe(board);
Assert.AreEqual(game.takeTurn(1, 1, 'X'), true);
}
public void spieler_test()
{
var spieler = TicTacToe.Spieler_festlegen("neu", "A");
Assert.AreEqual(spieler, "X");
spieler = TicTacToe.Spieler_festlegen("A1", "X");
Assert.AreEqual(spieler, "O");
}
public void ValidInputTest()
{
TicTacToe ticTacToe = new TicTacToe();
Assert.AreEqual(ticTacToe.ValidInput("0"), true);
Assert.AreEqual(ticTacToe.ValidInput("1"), true);
Assert.AreEqual(ticTacToe.ValidInput("2"), true);
Assert.AreEqual(ticTacToe.ValidInput("something else"), false);
}
public override void AcademyStep()
{
TicTacToe game = TicTacToe.Instance;
if (game.getWinner() != TicTacToe.DefVal || !game.isPlayable())
{
done = true;
}
}
public void WillReturnEmptyListIfGameIsWon()
{
TicTacToe game = new TicTacToe(null);
game.owner = 0;
List <Move> result = game.getAvailableMoves();
Assert.IsTrue(result.Count == 0);
}
public static void Main( string [] args )
{
TicTacToe T = new TicTacToe();
if( args.Length != 1 ) {
T.usage();
}
if ((args[0] != "1") & (args[0] != "2")) {
T.usage();
}
T.turn( args[0] );
}
public void TestSetPlayedSquare()
{
TicTacToe game = new TicTacToe("Player1", "Player2");
game.SetPlayedSquare(0, "Player1");
game.SetPlayedSquare(8, "Player2");
Play[] temp = new Play[9] { Play.Player1, 0, 0, 0, 0, 0, 0, 0, Play.Player2 };
CollectionAssert.AreEqual(game.GameBoard, temp);
}
public void TestCheckIfAvailable()
{
TicTacToe game = new TicTacToe("Player1", "Player2");
//Kannað hvort gildi sem sett var á ákveðinn stað í myllu sé rétt og á réttum stað
game.GameBoard[3] = Play.Player1;
game.GameBoard[3] = Play.Player2;
//Ath hvort nokkuð hafi verið breytt á reitnum
Assert.AreEqual(game.GameBoard[3], Play.Player2);
}
public void TestCheckForWinner()
{
TicTacToe game = new TicTacToe("Player1", "Player2");
// Ath vinningsstöðuna [0, 1, 2]
game.PlayAction(game.Player1, 0);
Assert.AreEqual(game.CheckForWinner(), null);
game.PlayAction(game.Player1, 1);
game.PlayAction(game.Player1, 2);
Assert.AreEqual(game.Player1.Name, game.CheckForWinner().Name);
}
public void ShouldStartNew()
{
var game = new TicTacToe();
Assert.IsTrue(game.IsNew);
game.Mark(1,1);
Assert.IsFalse(game.IsNew);
game.StartNew();
Assert.IsTrue(game.IsNew);
}
public void ShouldPrintGame()
{
var printMessage = MockRepository.GenerateStub<IPrintMessage>();
var game = new TicTacToe(printMessage);
game.Mark(1, 1);
game.Mark(2, 2);
game.Mark(3, 3);
game.Print("|");
printMessage.AssertWasCalled(x => x.Print("X| | \n |O| \n | |X"));
}
public void TestPlayAction()
{
TicTacToe game = new TicTacToe("Player1", "Player2");
//Player1 setur sitt merki á nokkra reiti
game.PlayAction(game.Player1, 0);
game.PlayAction(game.Player1, 5);
game.PlayAction(game.Player1, 6);
//Kannað hvort reitirnir sem player1 valdi hafi skilað sér á borðið
Assert.AreEqual(game.GameBoard[0], Play.Player1);
Assert.AreEqual(game.GameBoard[5], Play.Player1);
Assert.AreEqual(game.GameBoard[6], Play.Player1);
}
public void testGivenABoardNUmberOfPossibleMovesCalculatedCorrectly() {
TicTacToe t3 = new TicTacToe();
Assert.assertEquals(9, t3.getMoves(t3.getState()).size());
Assert.assertEquals("X", t3.getPlayerToMove(t3.getState()));
t3.makeMove(t3.getState(), 0, 0);
Assert.assertEquals(8, t3.getMoves(t3.getState()).size());
Assert.assertEquals("O", t3.getPlayerToMove(t3.getState()));
// try illegal move
t3.makeMove(t3.getState(), 0, 0);
Assert.assertEquals(8, t3.getMoves(t3.getState()).size());
Assert.assertEquals("O", t3.getPlayerToMove(t3.getState()));
t3.makeMove(t3.getState(), 1, 1);
Assert.assertEquals(7, t3.getMoves(t3.getState()).size());
Assert.assertEquals("X", t3.getPlayerToMove(t3.getState()));
}
public void ShouldCheckIsWinner()
{
{
var game = new TicTacToe();
game.Mark(1, 1); //X
game.Mark(2, 1); //O
game.Mark(1, 2); //X
game.Mark(2, 2); //O
game.Mark(1, 3); //X
Assert.IsTrue(game.IsWinner("X"));
}
{
var game = new TicTacToe();
game.Mark(1, 1); //X
game.Mark(1, 2); //O
game.Mark(2, 2); //X
game.Mark(2, 3); //O
game.Mark(3, 3); //X
Assert.IsTrue(game.IsWinner("X"));
}
{
var game = new TicTacToe();
game.Mark(1, 1); //X
game.Mark(1, 2); //O
game.Mark(2, 3); //X
game.Mark(2, 2); //O
game.Mark(3, 3); //X
game.Mark(3, 2); //O
Assert.IsTrue(game.IsWinner("O"));
}
}
public void testGenerateSuccessors() {
TicTacToe t3 = new TicTacToe();
ArrayList successors = t3.getSuccessorStates(t3.getState());
Assert.assertEquals(9, successors.size());
checkSuccessorList(successors, "O", 8);
ArrayList successors2 = t3.getSuccessorStates((GameState) successors
.get(0));
checkSuccessorList(successors2, "X", 7);
ArrayList successors3 = t3.getSuccessorStates((GameState) successors2
.get(0));
checkSuccessorList(successors3, "O", 6);
}
public void testMiniMax15() {
TicTacToe t1 = new TicTacToe();
t1.makeMove(0, 0);
int minimax1 = t1.getMiniMaxValue(t1.getState());
TicTacToe t2 = new TicTacToe();
t2.makeMove(0, 2);
int minimax2 = t2.getMiniMaxValue(t2.getState());
TicTacToe t3 = new TicTacToe();
t3.makeMove(2, 0);
int minimax3 = t3.getMiniMaxValue(t3.getState());
TicTacToe t4 = new TicTacToe();
int minimax4 = t4.getMiniMaxValue(t4.getState());
t4.makeMove(2, 2);
Assert.assertEquals(minimax1, minimax2);
}
public void testTerminalStateDetection() {
TicTacToe t3 = new TicTacToe();
t3.makeMove(0, 0);
t3.makeMove(0, 1);
t3.makeMove(0, 2);
t3.makeMove(1, 0);
t3.makeMove(1, 1);
t3.makeMove(1, 2);
Assert.assertEquals(1, t3.getMiniMaxValue(t3.getState()));
}
public void Mark_ShouldWitnIn3X3()
{
var game = new TicTacToe();
Assert.IsFalse(game.CanMark(4, 0));
game.Mark(4, 0);
}
static void Main()
{
TicTacToe field = new TicTacToe();
field.InitializeField();
field.Solve(0, 0);
Console.WriteLine(TicTacToe.playerXWins);
Console.WriteLine(TicTacToe.draws);
Console.WriteLine(TicTacToe.playerOWins);
}
//
// PRIVATE METHODS
//
private void checkSuccessorList(ArrayList successorList,
String playerToMove, int sizeOfSuccessors) {
for (int i = 0; i < successorList.size(); i++) {
GameState h = (GameState) successorList.get(i);
ArrayList successors2 = new TicTacToe().getSuccessorStates(h);
Assert.assertEquals(sizeOfSuccessors, successors2.size());
Assert.assertEquals(playerToMove, new TicTacToe()
.getPlayerToMove(h));
}
}
public void tesMiniMax4() {
TicTacToe t3 = new TicTacToe();
Assert.assertEquals(0, t3.getMiniMaxValue(t3.getState()));
}
public void Mark_ShouldNotAllowedWithTheGameIsOver()
{
{
var game = new TicTacToe();
game.Mark(1, 1); //X
game.Mark(1, 2); //O
game.Mark(2, 2); //X
game.Mark(2, 3); //O
game.Mark(3, 3); //X
game.Mark(3, 1); //O
Assert.IsTrue(game.IsGameOver());
Assert.IsFalse(game.CanMark(3, 2));
game.Mark(3, 2);
}
}
public void testCreation() {
TicTacToe t3 = new TicTacToe();
Assert.assertEquals(9, t3.getMoves(t3.getState()).size());
Assert.assertEquals("X", t3.getPlayerToMove(t3.getState()));
}
public void testAlphaBeta() {
TicTacToe t1 = new TicTacToe();
int alphabeta0 = t1.getAlphaBetaValue(t1.getState());
Assert.assertEquals(0, alphabeta0);
t1.makeMove(0, 0);
int alphabeta1 = t1.getAlphaBetaValue(t1.getState());
Assert.assertEquals(0, alphabeta1);
TicTacToe t2 = new TicTacToe();
t2.makeMove(0, 2);
int alphabeta2 = t2.getAlphaBetaValue(t2.getState());
Assert.assertEquals(0, alphabeta2);
TicTacToe t3 = new TicTacToe();
t3.makeMove(2, 0);
int alphabeta3 = t3.getAlphaBetaValue(t3.getState());
Assert.assertEquals(0, alphabeta3);
TicTacToe t4 = new TicTacToe();
int alphabeta4 = t4.getAlphaBetaValue(t4.getState());
t4.makeMove(2, 2);
Assert.assertEquals(0, alphabeta4);
}
/// <summary>
/// Plays the game, create new board, asks the user for input
/// </summary>
private void playGame()
{
ITicTacToe Ittt = new TicTacToe(user1, user2);
Play[] board = Ittt.GetGameBoard();
for (int i = 0; i < board.Length; i++)
{
DrawGameBoard(board);
if (player1ToDo)
{
GetPlayerInput(user1, Ittt);
player1ToDo = false;
// koma í veg fyrir að hægt sé að velja sama reit oftar en 1 sinni (player1)
player1Move: // goto playerMove
if(board[selectedSquare - 1].Equals(Play.NotPlayed))
{
board[selectedSquare - 1] = Play.Player1;
}
else
{
Console.WriteLine("This square is already selected, please choose another one");
GetPlayerInput(user1, Ittt);
goto player1Move;
}
}
else
{
GetPlayerInput(user2, Ittt);
player1ToDo = true;
// koma í veg fyrir að hægt sé að velja sama reit oftar en 1 sinni (player2)
player2Move: // goto playerMove
if (board[selectedSquare - 1].Equals(Play.NotPlayed))
{
board[selectedSquare - 1] = Play.Player2;
}
else
{
Console.WriteLine("This square is already selected, please choose another one");
GetPlayerInput(user2, Ittt);
goto player2Move;
}
}
// Check for a winner or if nobody has yet won at the end of the game
var check = Ittt.CheckForWinner();
if (i >= 4 && check != null)
{
DrawGameBoard(board);
Console.WriteLine("Player: {0} won the game! woohoo", check.Name);
break;
}
else if (i == 8)
{
DrawGameBoard(board);
Console.WriteLine("Nobody won the game, booo");
break;
}
}
Console.WriteLine("Do you want to play again? Press N to quit or any other key to continue");
playAgain = Console.ReadKey().KeyChar;
}
public void testMiniMax6() {
TicTacToe t3 = new TicTacToe();
t3.makeMove(0, 0);
t3.makeMove(0, 1);
t3.makeMove(0, 2);
t3.makeMove(2, 2);
t3.makeMove(1, 2);
t3.makeMove(2, 1);
t3.makeMove(1, 1);
Assert.assertEquals(-1, t3.getMiniMaxValue(t3.getState()));
}
public void testCalculateUtilityOfABoard() {
// game 1
TicTacToe t3 = new TicTacToe();
t3.makeMove(t3.getState(), 0, 0);
Assert.assertEquals(0, t3.getUtility(t3.getState()));
t3.makeMove(t3.getState(), 2, 2);
Assert.assertEquals(0, t3.getUtility(t3.getState()));
t3.makeMove(t3.getState(), 2, 0);
Assert.assertEquals(0, t3.getUtility(t3.getState()));
t3.makeMove(t3.getState(), 1, 0);
Assert.assertEquals(0, t3.getUtility(t3.getState()));
t3.makeMove(t3.getState(), 0, 2);
Assert.assertEquals(0, t3.getUtility(t3.getState()));
t3.makeMove(t3.getState(), 0, 1);
Assert.assertEquals(0, t3.getUtility(t3.getState()));
t3.makeMove(t3.getState(), 1, 1);
Assert.assertEquals(1, t3.computeUtility((t3.getState())));
// game 2
TicTacToe t4 = new TicTacToe();
t4.makeMove(t4.getState(), 0, 0);
Assert.assertEquals(0, t4.getUtility(t4.getState()));
t4.makeMove(t4.getState(), 0, 1);
Assert.assertEquals(0, t4.getUtility(t4.getState()));
t4.makeMove(t4.getState(), 0, 2);
Assert.assertEquals(0, t4.getUtility(t4.getState()));
t4.makeMove(t4.getState(), 1, 0);
Assert.assertEquals(0, t4.getUtility(t4.getState()));
t4.makeMove(t4.getState(), 1, 1);
Assert.assertEquals(0, t4.getUtility(t4.getState()));
t4.makeMove(t4.getState(), 1, 2);
Assert.assertEquals(0, t4.getUtility(t4.getState()));
t4.makeMove(t4.getState(), 2, 0);
Assert.assertEquals(1, t4.computeUtility(t4.getState()));
}
// Use this for initialization
void Start () {
gm = GameObject.Find ("_GameManager").GetComponent<TicTacToe>();
buttonAnim = this.GetComponentInChildren<Animator> ();
}
public void testAlphaBetaMinValueCalculation() {
// board x o x , o o x,- x -
TicTacToe t = new TicTacToe();
t.makeMove(0, 0); // x
t.makeMove(0, 1); // o
t.makeMove(0, 2); // x
t.makeMove(1, 0); // o
t.makeMove(1, 2); // x
t.makeMove(1, 1); // o
t.makeMove(2, 1); // x
int minValue = t.minValue(t.getState(), new AlphaBeta(
Integer.MIN_VALUE, Integer.MAX_VALUE));
Assert.assertEquals(0, minValue);
}
public void ShouldCheckIfTheGameIsOver()
{
{
var game = new TicTacToe();
game.Mark(1, 1); //X
game.Mark(1, 2); //O
game.Mark(2, 2); //X
game.Mark(2, 3); //O
game.Mark(3, 3); //X
Assert.IsTrue(game.IsGameOver());
}
{
var game = new TicTacToe();
game.Mark(1, 1); //X
game.Mark(2, 1); //O
game.Mark(3, 1); //X
game.Mark(2, 2); //O
game.Mark(1, 2); //X
game.Mark(3, 2); //O
game.Mark(2, 3); //X
game.Mark(1, 3); //O
game.Mark(3, 3); //O
Assert.IsTrue(game.IsGameOver());
Assert.IsTrue(game.IsGameDraw());
}
}
