public void NewGameShouldCreateNewGameFromMoves()
{
//arrange
ServiceProviderMock
.Setup(a => a.GetService(typeof(IGame)))
.Returns(GameMock.Object);
var movesToMake = new[] {
Move.Center,
Move.Western,
Move.Eastern
};
GameMock
.Setup(a => a.IsMoveValid(It.Is <Move>(b => movesToMake.Contains(b))))
.Returns(true);
//act
var newGame = TicTacToeFactory.NewGame(movesToMake);
//assert
newGame.Should().BeSameAs(GameMock.Object);
GameMock
.Verify(a => a.Move(Move.Center), Times.Once());
GameMock
.Verify(a => a.Move(Move.Western), Times.Once());
GameMock
.Verify(a => a.Move(Move.Eastern), Times.Once());
}
public static IBaseRepository <Game> GetGetByIdAsync(this IBaseRepository <Game> repository)
{
repository.GetByIdAsync(Arg.Is(GameMock.ValidGameId), Arg.Any <CancellationToken>())
.Returns(GameMock.GetDefaultValidInstance());
return(repository);
}
public static IBaseRepository <Game> GetInsertOneAsync(this IBaseRepository <Game> repository)
{
repository.InsertOneAsync(Arg.Is <Game>(GameMock.GetDefaultValidInstance()), Arg.Any <CancellationToken>())
.Returns(Task.CompletedTask);
return(repository);
}
public void ElapsedTimeIsCorrect()
{
GameMock mock = new GameMock();
mock.Update(122d);
Assert.AreEqual(122d, mock.ElapsedTime, 0.01d);
}
public static IMapper CreateGameCommandMapper(this IMapper mapper)
{
mapper
.Map <Game>(Arg.Any <CreateGameCommand>())
.Returns(GameMock.GetDefaultValidInstance());
return(mapper);
}
public void MakeMoveShouldMakeWinningMoveForX()
{
//arrange
GameMock
.Setup(a => a.GameIsOver)
.Returns(false);
GameMock
.Setup(a => a.GameBoardString)
.Returns(AGameBoardString);
GameMock
.Setup(a => a.CurrentPlayer)
.Returns(Player.X);
var moveResponses = new MoveResponse[]
{
new MoveResponse()
{
Response = Move.Northern,
Outcome = GameState.XWin,
Board = "_________",
Player = Player.X
},
new MoveResponse()
{
Response = Move.Center,
Outcome = GameState.OWin,
Board = "_________",
Player = Player.X
},
new MoveResponse()
{
Response = Move.Southern,
Outcome = GameState.Tie,
Board = "_________",
Player = Player.X
}
};
MoveDataAccessMock
.Setup(a => a.FindMoveResponses(AGameBoardString, Player.X))
.Returns(moveResponses);
RandomMock
.Setup(a => a.Next(It.IsAny <int>()))
.Returns(0);
//act
OmniscientGod.MakeMove(GameMock.Object);
//assert
GameMock
.Verify(a => a.Move(Move.Northern), Times.Once());
}
public void ShouldFindMoveResults()
{
//arrange
GameMock
.Setup(a => a.GameBoardString)
.Returns(AGameBoardString);
GameMock
.Setup(a => a.CurrentPlayer)
.Returns(Player.X);
var moveResponses = new MoveResponse[]
{
new MoveResponse()
{
Response = Move.Northern,
Outcome = GameState.XWin,
Board = "_________",
Player = Player.X
},
new MoveResponse()
{
Response = Move.Center,
Outcome = GameState.OWin,
Board = "_________",
Player = Player.X
},
new MoveResponse()
{
Response = Move.Southern,
Outcome = GameState.Tie,
Board = "_________",
Player = Player.X
}
};
MoveDataAccessMock
.Setup(a => a.FindMoveResponses(AGameBoardString, Player.X))
.Returns(moveResponses);
//act
var results = OmniscientGod.FindMoveResults(GameMock.Object);
//assert
var expectedMoveResults = new MoveResult[]
{
new MoveResult(Move.Northern, GameState.XWin),
new MoveResult(Move.Center, GameState.OWin),
new MoveResult(Move.Southern, GameState.Tie)
};
results.ShouldAllBeEquivalentTo(expectedMoveResults);
}
public void MakeMoveShouldThrowExceptionWhenGameIsOver()
{
//arrange
GameMock
.Setup(a => a.GameIsOver)
.Returns(true);
//act
Action act = () => BruteForce.MakeMove(GameMock.Object);
//assert
act
.ShouldThrow <GameException>()
.WithMessage($"Unable to make a move because the game is over.");
}
static void RunCustomFieldEditor()
{
var dummyGames = new GameMock[]
{
new GameMock
{
Title = "Death and Return of Superman, The",
Genres = new BlockingCollection <string> {
"Beat' Em Up"
},
PlayModes = new string[] { "Single Player" }
},
new GameMock
{
Title = "Aladdin",
Genres = new BlockingCollection <string> {
"Action", "Adventure"
},
PlayModes = new string[] { "Single Player" }
},
new GameMock
{
Title = "The Ghoul Patrol",
Genres = new BlockingCollection <string>(),
PlayModes = new string[] { "Cooperative", "Multiplayer" }
},
new GameMock
{
Title = "Dragon View",
Genres = new BlockingCollection <string> {
"Action", "RPG"
},
PlayModes = new string[] { "Single Player" }
}
};
for (var i = 1; i <= 20; i++)
{
dummyGames.First().Genres.Add($"Test {i:00}");
}
var form = new BulkGenreEditor.FormGenreEditor(PluginHelper.DataManager, dummyGames);
Application.Run(form);
}
public void ShouldCallGameEvaluationResultWhenEvaluationSucceeds()
{
//ARRANGE
var gameMock = new GameMock();
var result = new SuccessGameEvaluationResult(GameCategory.ROYAL_FLUSH, null);
var evaluation = new EvaluationMock();
evaluation.EvaluateReturns(result);
var subject = new GameEvaluationCommand(evaluation);
//ACT
var actual = subject.Evaluate(gameMock);
//ASSERT
Assert.AreSame(result, gameMock.ReceivedEvaluationResult);
}
public void ShouldCallGameEvaluationResultWhenEvaluationSucceeds()
{
//ARRANGE
var gameMock = new GameMock();
var result = new SuccessGameEvaluationResult(GameCategory.ROYAL_FLUSH, null);
var evaluation = new EvaluationMock();
evaluation.EvaluateReturns(result);
var subject = new GameEvaluationCommand(evaluation);
//ACT
var actual = subject.Evaluate(gameMock);
//ASSERT
Assert.AreSame(result, gameMock.ReceivedEvaluationResult);
}
public void NewGameShouldThrowWhenMoveIsInvalid()
{
//arrange
ServiceProviderMock
.Setup(a => a.GetService(typeof(IGame)))
.Returns(GameMock.Object);
var movesToMake = new[] {
Move.Center
};
GameMock
.Setup(a => a.IsMoveValid(Move.Center))
.Returns(false);
//act
Action act = () => TicTacToeFactory.NewGame(movesToMake);
//assert
act
.ShouldThrow <GameException>()
.WithMessage("Invalid move passed in. Cannot create game from moves.");
}
public void FindMoveResultsShouldMakeCopyOfGame()
{
//arrange
//setup a mock for the initial object..
Move[] initialGameMoveArray = new Move[1];
Mock <IGame> initialGame = new Mock <IGame>(MockBehavior.Strict);
initialGame
.Setup(a => a.MoveHistory)
.Returns(initialGameMoveArray);
TicTacToeFactoryMock
.Setup(a => a.NewGame(initialGameMoveArray))
.Returns(GameMock.Object);
//store the last move made...
//we need this to test correctly
Move?lastMoveMade = null;
GameMock
.Setup(a => a.Move(It.IsAny <Move>()))
.Callback <Move>(a => lastMoveMade = a);
var firstLegalMoves = new Move[]
{
Move.Northern,
Move.Southern
};
var secondLegalMoves = new Move[]
{
Move.NorthEast,
Move.NorthWest,
Move.Western,
Move.Center
};
var thirdLegalMoves = new Move[]
{
Move.Eastern,
Move.SouthEast,
Move.SouthWest
};
//setup the game mock that will drive the rest of our choices
GameMock
.Setup(a => a.GetLegalMoves())
.Returns(() =>
{
if (lastMoveMade.HasValue == false)
{
return(firstLegalMoves);
}
else if (lastMoveMade.Value == Move.Northern)
{
return(secondLegalMoves);
}
else if (lastMoveMade.Value == Move.Southern)
{
return(thirdLegalMoves);
}
throw new Exception("test borked");
});
//the game is in play for the first two moves...
GameMock
.Setup(a => a.GameIsOver)
.Returns(() =>
{
switch (lastMoveMade)
{
case Move.Northern:
case Move.Southern:
return(false);
default:
return(true);
}
});
GameMock
.Setup(a => a.CurrentPlayer)
.Returns(() =>
{
return(Player.X);
});
GameMock
.Setup(a => a.GameState)
.Returns(() =>
{
switch (lastMoveMade)
{
case Move.NorthEast:
return(GameState.Tie);
case Move.NorthWest:
return(GameState.OWin);
case Move.Western:
return(GameState.Tie);
case Move.Center:
return(GameState.OWin);
case Move.Eastern:
return(GameState.XWin);
case Move.SouthEast:
return(GameState.OWin);
case Move.SouthWest:
return(GameState.Tie);
}
throw new Exception();
});
//act
var moveResults = BruteForce.FindMoveResults(initialGame.Object);
//assert
//at this point, this is all we need...
}
public void MakeMoveShouldMakeWinningMoveForXRandomly()
{
//arrange
//setup a mock for the initial object..
Move[] initialGameMoveArray = new Move[1];
Mock <IGame> initialGame = new Mock <IGame>();
initialGame
.Setup(a => a.MoveHistory)
.Returns(initialGameMoveArray);
TicTacToeFactoryMock
.Setup(a => a.NewGame(initialGameMoveArray))
.Returns(GameMock.Object);
//setup the game mock that will drive the rest of our choices
List <Move> legalMoves = new List <Move>()
{
Move.Northern,
Move.Center,
Move.Southern
};
GameMock
.Setup(a => a.GetLegalMoves())
.Returns(legalMoves);
GameMock
.Setup(a => a.GameIsOver)
.Returns(true);
GameMock
.Setup(a => a.CurrentPlayer)
.Returns(Player.X);
var callCount = 0;
GameMock
.Setup(a => a.GameState)
.Returns(() =>
{
callCount++;
switch (callCount - 1)
{
case 0:
return(GameState.OWin);
case 1:
return(GameState.XWin);
default:
return(GameState.Tie);
}
});
//setup up our random mock
RandomMock
.Setup(a => a.Next(1))
.Returns(0);
//act
BruteForce.MakeMove(initialGame.Object);
//assert
//random was called
RandomMock.Verify(a => a.Next(1), Times.Once());
//the center move was made
GameMock
.Verify(a => a.Move(Move.Center));
}
public void MakeMoveShouldMakeCopyOfGame()
{
//arrange
//setup a mock for the initial object..
Move[] initialGameMoveArray = new Move[1];
Mock <IGame> initialGame = new Mock <IGame>(MockBehavior.Strict);
initialGame
.Setup(a => a.MoveHistory)
.Returns(initialGameMoveArray);
initialGame
.Setup(a => a.GameIsOver)
.Returns(false);
initialGame
.Setup(a => a.Move(It.IsAny <Move>()));
TicTacToeFactoryMock
.Setup(a => a.NewGame(initialGameMoveArray))
.Returns(GameMock.Object);
//setup the game mock that will drive the rest of our choices
List <Move> legalMoves = new List <Move>()
{
Move.Northern,
Move.Center,
Move.Southern
};
GameMock
.Setup(a => a.GetLegalMoves())
.Returns(legalMoves);
GameMock
.Setup(a => a.GameIsOver)
.Returns(true);
GameMock
.Setup(a => a.CurrentPlayer)
.Returns(Player.O);
var callCount = 0;
GameMock
.Setup(a => a.GameState)
.Returns(() =>
{
callCount++;
switch (callCount - 1)
{
case 0:
return(GameState.XWin);
case 1:
return(GameState.XWin);
default:
return(GameState.XWin);
}
});
//setup up our random mock
RandomMock
.Setup(a => a.Next(3))
.Returns(0);
//act
BruteForce.MakeMove(initialGame.Object);
//assert
TicTacToeFactoryMock.Verify(a => a.NewGame(initialGameMoveArray), Times.Once());
}
public void ComputerPlayerTest_1()
{
var computerPlayer = new ComputerPlayer("P1", _wrapper, _treeManager);
var anotherPlayer = new PlayerMock("P2");
var board1Str = new[]
{
"_____",
"_b___",
"_____",
"_b___",
"w____"
};
var board1 = new BoardMock(board1Str, 5, false);
board1.ActivePlayer.Figures
.First(f => f.X == 0 && f.Y == 4)
.AvailableMoves = new List <Cell> {
new Cell(1, 3)
};
var board2Str = new[]
{
"_____",
"_b___",
"__w__",
"_____",
"_____"
};
var board2 = new BoardMock(board2Str, 5, false);
board2.ActivePlayer.Figures
.First(f => f.X == 2 && f.Y == 2)
.AvailableMoves = new List <Cell> {
new Cell(0, 0)
};
var board3Str = new[]
{
"W____",
"_____",
"_____",
"_____",
"_____"
};
var board3 = new BoardMock(board3Str, 5, false);
board3.SwitchPlayers();
var gameMock = new GameMock(
new[] { board1, board2, board3 },
new IPlayer[] { computerPlayer, computerPlayer, anotherPlayer });
var cts = new CancellationTokenSource();
computerPlayer.MakeMove(gameMock, cts.Token).Wait();
gameMock.Moves
.Should()
.BeEquivalentTo(new[]
{
new Move(0, 4, 1, 3),
new Move(2, 2, 0, 0)
});
}
public void StartThrowsApplicationExceptionWhenNoPhases()
{
GameMock mock = new GameMock();
mock.TriggerStart();
}
