public HintField([NotNull] Func <IMineField, IHintCompass> factory,
[NotNull] IMineField mineField)
{
m_HintCompass = factory(mineField);
m_Field = ToHintField(mineField);
}
public HintField([NotNull] IHintCompassFactory factory,
[NotNull] IMineField mineField)
{
m_HintCompass = factory.Create(mineField);
m_Field = ToHintField(mineField);
}
private HintField CreateSut(IMineField mineField)
{
var hintCompass = new HintCompass(mineField);
var hintField = new HintField(HintCompassFactory,
mineField);
return(hintField);
}
private DisplayHintField CreateSut(IMineField mineField)
{
var factory = Container.Resolve <IHintFieldFactory>();
IHintField hintField = factory.Create(mineField);
var displayHintField = new DisplayHintField(hintField);
return(displayHintField);
}
public PlayingField([NotNull] IMineField mineField)
{
m_MineField = mineField;
m_FieldMask = new Field <bool>(mineField.RowsCount,
mineField.ColumnsCount);
Status = GameStatus.Player.SelectedFieldWithoutMine;
}
private IMineField CreateMineField([NotNull] string text)
{
var converter = new StringToMineFieldConverter();
IMineField minefield = converter.ToMineField(text);
return(minefield);
}
private IHintField CreateHintField([NotNull] IMineField mineField)
{
var factory = new HintCompassFactory();
var hintField = new HintField(factory,
mineField);
return(hintField);
}
private int AddOneIfDirectionIsSouth([NotNull] IMineField mineField,
int rowIndex,
int columnIndex)
{
return(AddOneIfMineIs(mineField,
IsMineSouth,
rowIndex,
columnIndex));
}
private int AddOneIfDirectionIsNorthWest([NotNull] IMineField mineField,
int rowIndex,
int columnIndex)
{
return(AddOneIfMineIs(mineField,
IsMineNorthWest,
rowIndex,
columnIndex));
}
public void ColumnsCount_ReturnsCount_ForMineField()
{
// Arrange
IMineField mineField = CreateMineField(m_MineFieldWithDifferentRowColumnCount);
PlayingField sut = CreateSut(mineField);
// Act
// Assert
Assert.AreEqual(2,
sut.ColumnsCount);
}
public void CreateMineField_SetStatus_WhenCalled()
{
// Arrange
IMineField mineField = CreateMineField(m_MineFieldWithTwoMines);
PlayingField sut = CreateSut(mineField);
// Act
// Assert
Assert.AreEqual(GameStatus.Player.SelectedFieldWithoutMine,
sut.Status);
}
public void ColumnsCount_ReturnsColumnsCount_ForHintField()
{
// Arrange
IMineField field = CreateMineField(m_MineFieldWithTwoMines);
HintField sut = CreateSut(field);
// Act
// Assert
Assert.AreEqual(4,
sut.RowsCount);
}
public void GetHintFor_Throws_ForInvalidRowAndColumn(int row,
int column)
{
// Arrange
IMineField mineField = CreateMineField(m_MineFieldWithTwoMines);
HintField sut = CreateSut(mineField);
// Act
// Assert
Assert.Throws <ArgumentException>(() => sut.GetHintFor(row,
column));
}
public void HasPlayerWon_ReturnsFalse_ForNoneSelected()
{
// Arrange
IMineField mineField = CreateMineField(m_SmallMineFieldWithTwoMines);
PlayingField sut = CreateSut(mineField);
// Act
bool actual = sut.HasPlayerWon();
// Assert
Assert.False(actual);
}
private static int AddOneIfMineIs([NotNull] IMineField mineField,
Func <IMineField, int, int, bool> isMineInDirection,
int rowIndex,
int columnIndex)
{
bool isThereMine = isMineInDirection(mineField,
rowIndex,
columnIndex);
return(isThereMine
? 1
: 0);
}
public void ToString_ReturnsString_ForMineField()
{
// Arrange
IMineField mineField = CreateMineField(m_MineFieldWithTwoMines);
DisplayHintField sut = CreateSut(mineField);
// Act
string actual = sut.ToString();
// Assert
Assert.AreEqual(m_HintFieldWithTwoMines,
actual);
}
private HintField CreateSut(IMineField mineField)
{
var hintCompass = new HintCompass(mineField); // todo replace with Substitute?
var factory = Substitute.For <IHintCompassFactory>();
factory.Create(Arg.Any <IMineField>())
.Returns(hintCompass);
var hintField = new HintField(factory,
mineField);
return(hintField);
}
public void CreateMineField(int numberOfRows,
int numberOfColumns,
int numberOfMines)
{
m_MineField = m_MineFieldFactory.Create(numberOfRows,
numberOfColumns);
IMineLayer mineLayer = m_MineLayerFactory.Create(m_MineField);
mineLayer.PutMinesAtRandomLocation(numberOfMines);
CreateCommon();
}
public void SelectedField_DoesNotUpdateStatusByDefault_WhenCalled()
{
// Arrange
IMineField mineField = CreateMineField(m_MineFieldWithTwoMines);
PlayingField sut = CreateSut(mineField);
// Act
sut.SelectField(1,
2);
// Assert
Assert.AreEqual(GameStatus.Player.SelectedFieldWithoutMine,
sut.Status);
}
public void UserSelectedField_SetsStatusToSelectedFieldWithMine_WhenSelectedFieldWithMine()
{
// Arrange
IMineField mineField = CreateMineField(m_SmallMineFieldWithTwoMines);
PlayingField sut = CreateSut(mineField);
// Act
sut.SelectField(1,
1);
// Assert
Assert.AreEqual(GameStatus.Player.SelectedFieldWithMine,
sut.Status);
}
public void GetHintFor_ReturnsHintNumber_ForRowAndColumn(int row,
int column,
int expected)
{
// Arrange
IMineField mineField = CreateMineField(m_MineFieldWithTwoMines);
HintField sut = CreateSut(mineField);
// Act
int actual = sut.GetHintFor(row,
column);
// Assert
Assert.AreEqual(expected,
actual);
}
public void ToString_ReturnsString_ForNoneSelected()
{
// Arrange
IMineField mineField = CreateMineField(m_SmallMineFieldWithTwoMines);
IHintField hintField = CreateHintField(mineField);
PlayingField playingField = CreatePlayingField(mineField);
DisplayPlayingField sut = CreateSut(hintField,
playingField);
// Act
string actual = sut.ToString();
// Assert
Assert.AreEqual("..\r\n..\r\n",
actual);
}
public void GetMineCountFor_ReturnsMineCount_For3x3AndMinesAroundCentre(int row,
int column,
int expected)
{
// Arrange
IMineField mineField = CreateMineFieldWith3x3AndMinesAroundCentre();
HintCompass sut = CreateSut(mineField);
// Act
int actual = sut.GetMineCountFor(row,
column);
// Assert
Assert.AreEqual(expected,
actual);
}
public HintCompass([NotNull] IMineField mineField)
{
m_MineField = mineField;
m_Functions = new Func <IMineField, int, int, int>[]
{
AddOneIfDirectionIsNorth,
AddOneIfDirectionIsNorthEast,
AddOneIfDirectionIsEast,
AddOneIfDirectionIsSouthEast,
AddOneIfDirectionIsSouth,
AddOneIfDirectionIsSouthWest,
AddOneIfDirectionIsWest,
AddOneIfDirectionIsNorthWest
};
}
public void ToString_ReturnsMineFieldAsString_ForEmptyMineField()
{
// Arrange
string expected = ".." +
m_NewLine +
".." +
m_NewLine;
IMineField mineField = CreateEmptyMineField();
DisplayMineField sut = CreateSut(mineField);
// Act
string actual = sut.ToString();
// Assert
Assert.AreEqual(expected,
actual);
}
private Field <int> ToHintField([NotNull] IMineField mineField)
{
var hints = new Field <int>(mineField.RowsCount,
mineField.ColumnsCount);
for (var rows = 0; rows < hints.RowsCount; rows++)
{
for (var columns = 0; columns < hints.ColumnsCount; columns++)
{
hints [rows,
columns] = m_HintCompass.GetMineCountFor(rows,
columns);
}
}
return(hints);
}
public void HasPlayerWon_ReturnsTrue_ForAllSelected()
{
// Arrange
IMineField mineField = CreateMineField(m_SmallMineFieldWithTwoMines);
PlayingField sut = CreateSut(mineField);
sut.SelectField(0,
1);
sut.SelectField(1,
0);
// Act
bool actual = sut.HasPlayerWon();
// Assert
Assert.True(actual);
}
public void SelectField_MarksFieldAsSelected_ForRowAndColumn(int row,
int column,
bool expected)
{
// Arrange
IMineField mineField = CreateMineField(m_MineFieldWithTwoMines);
PlayingField sut = CreateSut(mineField);
// Act
sut.SelectField(row,
column);
// Assert
Assert.AreEqual(expected,
sut.IsSelected(row,
column));
}
public void UserSelectedField_UpdatesStatus_WhenPlayerHasWon()
{
// Arrange
IMineField mineField = CreateMineField(m_SmallMineFieldWithTwoMines);
PlayingField sut = CreateSut(mineField);
sut.SelectField(0,
1);
// Act
sut.SelectField(1,
0);
// Assert
Assert.AreEqual(GameStatus.Player.HasWon,
sut.Status);
}
public IMineField ToMineField(string text)
{
string[] lines = text.Split('\n');
var noWhiteSpaces = new List <string>();
foreach (string line in lines)
{
string noWhiteSpace = line.TrimEnd('\r',
'\n');
noWhiteSpaces.Add(noWhiteSpace);
}
IMineField mineField = LinesToMineField(noWhiteSpaces.ToArray());
return(mineField);
}
