public override void TestDefaults()
{
var builder = new GameDefinitionBuilder();
var definition = builder.Build();
Assert.Empty(definition.Boards);
}
public void TestValid(string sentence, string[] colors)
{
var parser = CreateParser();
var builder = new GameDefinitionBuilder();
(new BoardGrid()).Parse(builder, "The board is an 8x8 grid", out _);
var didMatch = parser.Parse(builder, sentence, out ParserError[] errors);
Assert.True(didMatch);
Assert.Empty(errors);
var definition = builder.Build();
Assert.Single(definition.Boards);
var board = definition.Boards[0];
int iColor = 0;
foreach (var cell in board.Cells)
{
Assert.Equal(cell.Color, colors[iColor++]);
if (iColor >= colors.Length)
{
iColor = 0;
}
}
}
public override void TestDefaults()
{
var builder = new GameDefinitionBuilder();
var definition = builder.Build();
Assert.Equal(2, definition.Players.Count(player => player.Required));
Assert.Equal(2, definition.Players.Length);
}
public override void TestDefaults()
{
var builder = new GameDefinitionBuilder();
var definition = builder.Build();
Assert.Equal(2, definition.Players.Length);
Assert.Equal("red", definition.Players[0].Color);
Assert.Equal("blue", definition.Players[1].Color);
}
public override void TestNotMatching(string sentence)
{
var parser = CreateParser();
var builder = new GameDefinitionBuilder();
var didMatch = parser.Parse(builder, sentence, out ParserError[] errors);
Assert.False(didMatch);
}
public override void TestDefaults()
{
var builder = new GameDefinitionBuilder();
var definition = builder.Build();
Assert.Equal(2, definition.Players.Length);
Assert.Equal("Player 1", definition.Players[0].Name);
Assert.Equal("Player 2", definition.Players[1].Name);
}
public override void TestMissingRequirement(string sentence)
{
var parser = CreateParser();
var builder = new GameDefinitionBuilder();
var didMatch = parser.Parse(builder, sentence, out ParserError[] errors);
Assert.True(didMatch);
Assert.NotEmpty(errors);
}
public override void TestInvalid(string sentence)
{
var parser = CreateParser();
var builder = new GameDefinitionBuilder();
(new PlayerCount()).Parse(builder, $"There are 2 players", out _);
var didMatch = parser.Parse(builder, sentence, out ParserError[] errors);
Assert.True(didMatch);
Assert.NotEmpty(errors);
}
public override void TestDefaults()
{
var builder = new GameDefinitionBuilder();
(new BoardGrid()).Parse(builder, "The board is a 2x2 grid", out _);
var definition = builder.Build();
Assert.Single(definition.Boards);
var board = definition.Boards[0];
Assert.True(board.AllowMultipleOccupancy);
}
public override void TestDefaults()
{
var builder = new GameDefinitionBuilder();
(new BoardGrid()).Parse(builder, "The board is a 2x2 grid", out _);
var definition = builder.Build();
Assert.Single(definition.Boards);
var board = definition.Boards[0];
Assert.Equal(0, board.BorderWidth);
Assert.Null(board.BorderColor);
}
public void TestValid(string sentence, int min, int max)
{
var parser = CreateParser();
var builder = new GameDefinitionBuilder();
var didMatch = parser.Parse(builder, sentence, out ParserError[] errors);
Assert.True(didMatch);
Assert.Empty(errors);
var definition = builder.Build();
Assert.Equal(min, definition.Players.Count(player => player.Required));
Assert.Equal(max, definition.Players.Length);
}
public IEnumerable <ParserError> Parse([FromBody] ParserData data)
{
var parser = new GameDefinitionParser();
var builder = new GameDefinitionBuilder();
var errors = parser.Parse(builder, data.Text);
if (errors.Count == 0)
{
var definition = builder.Build();
// TODO: use definition somehow
}
return(errors);
}
public void TestAllExamples()
{
var parsers = new GameDefinitionParser().SentenceParsers;
foreach (var sentenceParser in parsers)
{
foreach (var example in sentenceParser.Examples)
{
var builder = new GameDefinitionBuilder();
var didMatch = sentenceParser.Parse(builder, example, out _);
Assert.True(didMatch); // all sentence parser examples should match their sentence
// ... but they might be dependent on others having run first, so we can't be sure that running in isolution produces no errors
}
}
}
public void TestCombo()
{
var text = @"
There are 3 players.
Player names are attacker, neutral and defender.
Player colors are red, #cccccc and blue.
The board is an 8x8 grid. Only one piece can occupy a cell on the board.
Cells on the board are referenced using a letter for their row and a number for their column, starting with A1 at the southwest corner.
Cells on the board are alternately colored black and white.
Cells on the board have a thin grey border.
";
var parser = new GameDefinitionParser();
var builder = new GameDefinitionBuilder();
var errors = parser.Parse(builder, text);
Assert.Empty(errors);
var definition = builder.Build();
Assert.Equal(3, definition.Players.Count(player => player.Required));
Assert.Equal(3, definition.Players.Length);
Assert.Equal("attacker", definition.Players[0].Name);
Assert.Equal("red", definition.Players[0].Color);
Assert.Equal("neutral", definition.Players[1].Name);
Assert.Equal("#cccccc", definition.Players[1].Color);
Assert.Equal("defender", definition.Players[2].Name);
Assert.Equal("blue", definition.Players[2].Color);
Assert.Single(definition.Boards);
var board = definition.Boards[0];
Assert.Equal(64, board.Cells.Length);
Assert.Equal("grey", board.BorderColor);
Assert.Equal(1, board.BorderWidth);
for (int iCell = 0; iCell < board.Cells.Length; iCell++)
{
Assert.Equal(board.Cells[iCell].Color, iCell % 2 == 0 ? "black" : "white");
}
}
public override void TestDefaults()
{
var builder = new GameDefinitionBuilder();
(new BoardGrid()).Parse(builder, "The board is a 2x2 grid", out _);
var definition = builder.Build();
Assert.Single(definition.Boards);
var board = definition.Boards[0];
foreach (var cell in board.Cells)
{
Assert.Equal("grey", cell.Color);
}
}
public void TestValid(string sentence, int width, int height)
{
var parser = CreateParser();
var builder = new GameDefinitionBuilder();
var didMatch = parser.Parse(builder, sentence, out ParserError[] errors);
Assert.True(didMatch);
Assert.Empty(errors);
var definition = builder.Build();
Assert.Single(definition.Boards);
var board = definition.Boards[0];
Assert.Equal(width * height, board.Cells.Length);
// TODO: need separate width and height checks
}
public void TestValid(string sentence, string[] names)
{
var parser = CreateParser();
var builder = new GameDefinitionBuilder();
(new PlayerCount()).Parse(builder, $"There are {names.Length} players", out _);
var didMatch = parser.Parse(builder, sentence, out ParserError[] errors);
Assert.True(didMatch);
Assert.Empty(errors);
var definition = builder.Build();
for (int i = 0; i < definition.Players.Length && i < names.Length; i++)
{
Assert.Equal(names[i], definition.Players[i].Name);
}
}
public void TestValid(string sentence, bool allowMultiple)
{
var parser = CreateParser();
var builder = new GameDefinitionBuilder();
(new BoardGrid()).Parse(builder, "The board is a 2x2 grid", out _);
var didMatch = parser.Parse(builder, sentence, out ParserError[] errors);
Assert.True(didMatch);
Assert.Empty(errors);
var definition = builder.Build();
Assert.Single(definition.Boards);
var board = definition.Boards[0];
Assert.Equal(board.AllowMultipleOccupancy, allowMultiple);
}
public void TestValid(string sentence, string color, int thickness)
{
var parser = CreateParser();
var builder = new GameDefinitionBuilder();
(new BoardGrid()).Parse(builder, "The board is an 8x8 grid", out _);
var didMatch = parser.Parse(builder, sentence, out ParserError[] errors);
Assert.True(didMatch);
Assert.Empty(errors);
var definition = builder.Build();
Assert.Single(definition.Boards);
var board = definition.Boards[0];
Assert.Equal(board.BorderColor, color);
Assert.Equal(board.BorderWidth, thickness);
}
