public void AdjudicatorOnDataReceivedTest()
{
var injector = new Mock <ISimpleInjectorWrapper>();
var processFactory = new Mock <IProcessManagerFactory>();
var fakeProcess = new FakeProcessManager(new Mock <IProcessManager>().Object);
processFactory.Setup(s => s.Create(It.IsAny <string>(), It.IsAny <string>())).Returns(() => fakeProcess);
injector.Setup(s => s.GetInstance <IProcessManagerFactory>()).Returns(() => processFactory.Object);
var confService = new Mock <IConfigurationService>();
injector.Setup(s => s.GetInstance <IConfigurationService>()).Returns(() => confService.Object);
var fileService = new Mock <IFileService>();
fileService.Setup(s => s.FileExists(It.IsAny <string>())).Returns(() => true);
injector.Setup(s => s.GetInstance <IFileService>()).Returns(() => fileService.Object);
var adjudicator = new Adjudicator(injector.Object, new Duel());
GameResult gameResult = null;
adjudicator.Resigned = result => gameResult = result;
adjudicator.BlackMoves(Move.Parse("Z99"));
Task.Run(
() =>
{
Thread.Sleep(1000);
fakeProcess.DataReceived("= W+9.0");
});
fakeProcess.DataReceived("? illegal move");
Assert.NotNull(gameResult);
Assert.Equal(EndGameReason.InvalidMove, gameResult.EndReason);
Assert.Equal(9, gameResult.FinalScore);
injector.VerifyAll();
processFactory.VerifyAll();
fileService.VerifyAll();
}
public void OnMoveMade(Player sender, List <Movement> moves)
{
// Q_ASSERT(m_gameInProgress);
// Q_ASSERT(m_board->isLegalMove(move));
if (sender != PlayerToMove)
{
//qDebug("%s tried to make a move on the opponent's turn", qPrintable(sender->name()));
return;
}
Moves.AddRange(moves);
addPGNMove(moves, evalString(sender.Evaluation));
// Get the result before sending the move to the opponent
foreach (Movement move in moves)
{
Game.MakeMove(move, true);
}
if (Result.IsNone)
{
Adjudicator.AddEval(Game, sender.Evaluation);
if (Adjudicator.Result != null)
{
Result = Adjudicator.Result;
}
}
else
{
int q = 0;
}
for (int x = 0; x < moves.Count; x++)
{
Game.UndoMove();
}
Player player = PlayerToWait;
player.MakeMove(moves);
foreach (Movement move in moves)
{
Game.MakeMove(move, true);
}
if (Result.IsNone)
{
startTurn();
}
else
{
Stop();
}
emitLastMove();
}
public void BotRunnerCtorTest()
{
var injector = new Mock <ISimpleInjectorWrapper>();
var confService = new Mock <IConfigurationService>();
injector.Setup(s => s.GetInstance <IConfigurationService>()).Returns(() => confService.Object);
var fileService = new Mock <IFileService>();
fileService.Setup(s => s.FileExists(It.IsAny <string>())).Returns(() => true);
injector.Setup(s => s.GetInstance <IFileService>()).Returns(() => fileService.Object);
var processFactory = new Mock <IProcessManagerFactory>();
processFactory.Setup(s => s.Create(It.IsAny <string>(), It.IsAny <string>())).Returns(() => new Mock <IProcessManager>().Object);
injector.Setup(s => s.GetInstance <IProcessManagerFactory>()).Returns(() => processFactory.Object);
var adjudicator = new Adjudicator(injector.Object, new Duel());
var blackBot = new Mock <IGoBot>();
var whiteBot = new Mock <IGoBot>();
blackBot.Setup(s => s.Name).Returns(() => "Alice");
whiteBot.Setup(s => s.Name).Returns(() => "Jack");
bool?whiteStarted = null;
bool?blackStarted = null;
whiteBot.Setup(s => s.StartGame(It.IsAny <bool>())).Callback <bool>(c => whiteStarted = c);
blackBot.Setup(s => s.StartGame(It.IsAny <bool>())).Callback <bool>(c => blackStarted = c);
IBotRunner botRunner = new BotRunner(adjudicator, blackBot.Object, whiteBot.Object);
Assert.Equal(false, whiteStarted);
Assert.Equal(true, blackStarted);
Assert.False(botRunner.IsFinished);
GameResult gameResult = null;
botRunner.EndGame = result => gameResult = result;
Assert.Null(gameResult);
adjudicator.Resigned(new GameResult {
EndReason = EndGameReason.Resign
});
Assert.True(botRunner.IsFinished);
Assert.NotNull(gameResult);
Assert.Equal(EndGameReason.Resign, gameResult.EndReason);
Assert.NotNull(botRunner);
Assert.NotNull(botRunner.EndGame);
blackBot.VerifyAll();
whiteBot.VerifyAll();
}
private static async Task DoTest(BenchmarkSettings settings)
{
Console.WriteLine("____________________________________");
Console.WriteLine("Board size: {0}, bot #1 strength : {1}, bot #2 strength: {2}", settings.BoardSize, settings.FirstBotLevel, settings.SecondBotLevel);
tcs = new TaskCompletionSource <bool>();
Watch.Restart();
var botWhite = botFactory.CreateBotInstance(botKind, "WhiteBot");
botWhite.BoardSize = settings.BoardSize;
botWhite.Level = settings.FirstBotLevel;
var botBlack = botFactory.CreateBotInstance(new BotKind {
BinaryPath = botKind.BinaryPath, FullClassName = botKind.FullClassName
}, "BlackBot");
botBlack.BoardSize = settings.BoardSize;
botBlack.Level = settings.SecondBotLevel;
var judge = new Adjudicator(
Bootstrap(),
new Duel
{
BoardSize = settings.BoardSize,
BlackBot = "BlackBot",
WhiteBot = "WhiteBot",
Name = "Benchmarking"
})
{
SaveGameResults = true, GenerateLastBoard = true
};
var runner = new BotRunner(judge, botBlack, botWhite)
{
EndGame = OnTestFinised
};
await tcs.Task;
runner.Cancel();
}
public void AdjudicatorGenerateLastBoardTest()
{
var injector = new Mock <ISimpleInjectorWrapper>();
var processFactory = new Mock <IProcessManagerFactory>();
var processManager = new Mock <IProcessManager>();
var fakeProcess = new FakeProcessManager(processManager.Object);
List <string> processWrittenData = new List <string>();
processManager.Setup(s => s.WriteData(It.IsAny <string>(), It.IsAny <object[]>()))
.Callback <string, object[]>(
(s, o) => processWrittenData.Add(s));
processFactory.Setup(s => s.Create(It.IsAny <string>(), It.IsAny <string>())).Returns(() => fakeProcess);
injector.Setup(s => s.GetInstance <IProcessManagerFactory>()).Returns(() => processFactory.Object);
var confService = new Mock <IConfigurationService>();
injector.Setup(s => s.GetInstance <IConfigurationService>()).Returns(() => confService.Object);
var fileService = new Mock <IFileService>();
fileService.Setup(s => s.FileExists(It.IsAny <string>())).Returns(() => true);
injector.Setup(s => s.GetInstance <IFileService>()).Returns(() => fileService.Object);
var adjudicator = new Adjudicator(injector.Object, new Duel()
{
BoardSize = 2, WhiteBot = "weiss", BlackBot = "schwarz"
});
GameResult gameResult = null;
adjudicator.Resigned = result => gameResult = result;
adjudicator.GenerateLastBoard = true;
adjudicator.BoardUpdated = delegate { };
adjudicator.BlackMoves(Move.Parse("a1"));
fakeProcess.DataReceived("= ");
fakeProcess.DataReceived(" A B");
fakeProcess.DataReceived(" 2 O O 2 WHITE (O) has captured 2 stones");
fakeProcess.DataReceived(" 1 . . 1 BLACK (X) has captured 0 stones");
fakeProcess.DataReceived(" A B");
adjudicator.WhiteMoves(Move.Parse("b1"));
fakeProcess.DataReceived("= ");
fakeProcess.DataReceived(" A B");
fakeProcess.DataReceived(" 2 O O 2 WHITE (O) has captured 2 stones");
fakeProcess.DataReceived(" 1 . . 1 BLACK (X) has captured 0 stones");
fakeProcess.DataReceived(" A B");
Task.Run(
() =>
{
Thread.Sleep(2000);
fakeProcess.DataReceived(" A B");
fakeProcess.DataReceived(" A B");
fakeProcess.DataReceived(" 2 O O 2 WHITE (O) has captured 2 stones");
fakeProcess.DataReceived(" 1 . . 1 BLACK (X) has captured 0 stones");
fakeProcess.DataReceived(" A B");
});
adjudicator.BlackMoves(Move.Parse("resign"));
Assert.Equal(EndGameReason.Resign, gameResult.EndReason);
Assert.True(gameResult.FinalBoard.StartsWith(" A B\n 2 O O 2 WHITE (O) has captured 2 stones\n 1 . . 1 BLACK (X) has captured 0 stones"));
Assert.Equal(6, processWrittenData.Count);
Assert.Equal("boardsize {0}", processWrittenData.ElementAt(0));
Assert.Equal("black a1", processWrittenData.ElementAt(1));
Assert.Equal("showboard", processWrittenData.ElementAt(2));
Assert.Equal("white b1", processWrittenData.ElementAt(3));
Assert.Equal("showboard", processWrittenData.ElementAt(4));
Assert.Equal("showboard", processWrittenData.ElementAt(5));
injector.VerifyAll();
processFactory.VerifyAll();
fileService.VerifyAll();
}
public void AdjudicatorBlackWhiteMovesTest()
{
var injector = new Mock <ISimpleInjectorWrapper>();
var confService = new Mock <IConfigurationService>();
injector.Setup(s => s.GetInstance <IConfigurationService>()).Returns(() => confService.Object);
var fileService = new Mock <IFileService>();
fileService.Setup(s => s.FileExists(It.IsAny <string>())).Returns(() => true);
injector.Setup(s => s.GetInstance <IFileService>()).Returns(() => fileService.Object);
var processFactory = new Mock <IProcessManagerFactory>();
var fakeProcess = new FakeProcessManager(new Mock <IProcessManager>().Object);
processFactory.Setup(s => s.Create(It.IsAny <string>(), It.IsAny <string>())).Returns(() => fakeProcess);
injector.Setup(s => s.GetInstance <IProcessManagerFactory>()).Returns(() => processFactory.Object);
var logger = new Mock <ILogger>();
var logs = new List <string>();
injector.Setup(s => s.GetInstance <ILogger>()).Returns(() => logger.Object);
logger.Setup(s => s.WriteWarning(It.IsAny <string>(), It.IsAny <object[]>()))
.Callback <string, object[]>(
(s, o) =>
{
logs.Add(string.Format(s, o));
});
var adjudicator = new Adjudicator(injector.Object, new Duel());
try
{
adjudicator.BlackMoves(null);
Assert.True(false, "Should fail on previous statement");
}
catch (Exception ex)
{
Assert.IsType(typeof(ArgumentNullException), ex);
Assert.Equal("Value cannot be null.\r\nParameter name: move", ex.Message);
}
Assert.True(!logs.Any());
adjudicator.WhiteMoves(null);
Assert.True(logs.Any());
Assert.Equal("White bot makes move when it is not its turn", logs[0]);
GameResult gameResult = null;
adjudicator.Resigned = result => gameResult = result;
adjudicator.BlackMoves(Move.Parse("resign"));
Assert.Equal(EndGameReason.Resign, gameResult.EndReason);
adjudicator = new Adjudicator(injector.Object, new Duel());
adjudicator.BlackMoves(Move.Parse("a6"));
fakeProcess.DataReceived("= ");
adjudicator.BlackMoves(null);
adjudicator.WhiteMoves(Move.Parse("f3"));
adjudicator.WhiteMoves(Move.Parse("f3"));
Assert.Equal("Previous move was not yet validated. Ignoring f3 from white ", logs.Last());
fakeProcess.DataReceived("= ");
adjudicator.BlackMoves(Move.Parse("pass"));
fakeProcess.DataReceived("= ");
gameResult = null;
adjudicator.Resigned = result => gameResult = result;
Task.Run(
() =>
{
Thread.Sleep(1000);
fakeProcess.DataReceived("= B+8.0");
});
adjudicator.WhiteMoves(Move.Parse("pass"));
Assert.NotNull(gameResult);
Assert.Equal(EndGameReason.ConsecutivePass, gameResult.EndReason);
Assert.Equal(8, gameResult.FinalScore);
}
public void AdjudicatorSaveGameResultsTest()
{
var injector = new Mock <ISimpleInjectorWrapper>();
var processFactory = new Mock <IProcessManagerFactory>();
var processManager = new Mock <IProcessManager>();
bool disposed = false;
processManager.Setup(s => s.Dispose()).Callback(() => disposed = true);
var fakeProcess = new FakeProcessManager(processManager.Object);
List <string> processWrittenData = new List <string>();
processManager.Setup(s => s.WriteData(It.IsAny <string>(), It.IsAny <object[]>()))
.Callback <string, object[]>(
(s, o) => processWrittenData.Add(s));
processFactory.Setup(s => s.Create(It.IsAny <string>(), It.IsAny <string>())).Returns(() => fakeProcess);
injector.Setup(s => s.GetInstance <IProcessManagerFactory>()).Returns(() => processFactory.Object);
var confService = new Mock <IConfigurationService>();
GameResult saveGameResult = null;
string savedFileName = null;
confService.Setup(s => s.SerializeGameResult(It.IsAny <GameResult>(), It.IsAny <string>()))
.Callback <GameResult, string>(
(r, f) =>
{
saveGameResult = r;
savedFileName = f;
});
injector.Setup(s => s.GetInstance <IConfigurationService>()).Returns(() => confService.Object);
var fileService = new Mock <IFileService>();
fileService.Setup(s => s.FileExists(It.IsAny <string>())).Returns(() => true);
injector.Setup(s => s.GetInstance <IFileService>()).Returns(() => fileService.Object);
var logger = new Mock <ILogger>();
var logs = new List <string>();
injector.Setup(s => s.GetInstance <ILogger>()).Returns(() => logger.Object);
logger.Setup(s => s.WriteWarning(It.IsAny <string>(), It.IsAny <object[]>()))
.Callback <string, object[]>(
(s, o) =>
{
logs.Add(string.Format(s, o));
});
var adjudicator = new Adjudicator(injector.Object, new Duel());
GameResult gameResult = null;
adjudicator.Resigned = result => gameResult = result;
adjudicator.SaveGameResults = true;
adjudicator.BlackMoves(Move.Parse("&99"));
Task.Run(
() =>
{
Thread.Sleep(1000);
fakeProcess.DataReceived("= W+aaa");
});
fakeProcess.DataReceived("? invalid coordinate");
Assert.NotNull(gameResult);
Assert.Equal(EndGameReason.InvalidMove, gameResult.EndReason);
Assert.Equal(0, gameResult.FinalScore);
Assert.Equal(saveGameResult, gameResult);
Assert.True(logs.Count == 1);
Assert.Equal("Could not parse final score: W+aaa", logs.First());
Assert.Equal(4, processWrittenData.Count);
Assert.Equal("boardsize {0}", processWrittenData.ElementAt(0));
Assert.Equal("black &99", processWrittenData.ElementAt(1));
Assert.Equal("final_score", processWrittenData.ElementAt(2));
Assert.True(processWrittenData.ElementAt(3).StartsWith("printsgf 2"));
Assert.False(disposed);
adjudicator.Dispose();
Assert.True(disposed);
Assert.Equal("quit", processWrittenData.ElementAt(4));
injector.VerifyAll();
processFactory.VerifyAll();
fileService.VerifyAll();
}
