public async Task Spreadsheet_AddRow_CellWithVeryLongStringValue(int length, Type type)
{
// Arrange
var value = new string('a', length);
using var stream = new MemoryStream();
var options = new SpreadCheetahOptions {
BufferSize = SpreadCheetahOptions.MinimumBufferSize
};
await using (var spreadsheet = await Spreadsheet.CreateNewAsync(stream, options))
{
await spreadsheet.StartWorksheetAsync("Sheet");
var cell = CellFactory.Create(type, value);
// Act
await spreadsheet.AddRowAsync(cell);
await spreadsheet.FinishAsync();
}
// Assert
SpreadsheetAssert.Valid(stream);
using var actual = SpreadsheetDocument.Open(stream, true);
var sheetPart = actual.WorkbookPart !.WorksheetParts.Single();
var actualCell = sheetPart.Worksheet.Descendants <OpenXmlCell>().Single();
Assert.Equal(CellValues.InlineString, actualCell.DataType?.Value);
Assert.Equal(value, actualCell.InnerText);
}
public async Task Spreadsheet_AddRow_FontNameCellWithStringValue(string? fontName, Type type)
{
// Arrange
const string cellValue = "Font name test";
using var stream = new MemoryStream();
await using (var spreadsheet = await Spreadsheet.CreateNewAsync(stream))
{
await spreadsheet.StartWorksheetAsync("Sheet");
var style = new Style();
style.Font.Name = fontName;
var styleId = spreadsheet.AddStyle(style);
var styledCell = CellFactory.Create(type, cellValue, styleId);
// Act
await spreadsheet.AddRowAsync(styledCell);
await spreadsheet.FinishAsync();
}
// Assert
SpreadsheetAssert.Valid(stream);
using var workbook = new XLWorkbook(stream);
var worksheet = workbook.Worksheets.Single();
var actualCell = worksheet.Cell(1, 1);
Assert.Equal(cellValue, actualCell.Value);
Assert.Equal(fontName ?? "Calibri", actualCell.Style.Font.FontName);
}
public async Task Spreadsheet_AddRow_MixedBoldStyleCells(bool firstCellBold, Type type)
{
// Arrange
const string firstCellValue = "First";
const string secondCellValue = "Second";
using var stream = new MemoryStream();
await using (var spreadsheet = await Spreadsheet.CreateNewAsync(stream))
{
await spreadsheet.StartWorksheetAsync("Sheet");
var style = new Style();
style.Font.Bold = true;
var styleId = spreadsheet.AddStyle(style);
var firstCell = CellFactory.Create(type, firstCellValue, firstCellBold ? styleId : null);
var secondCell = CellFactory.Create(type, secondCellValue, firstCellBold ? null : styleId);
// Act
await spreadsheet.AddRowAsync(new[] { firstCell, secondCell });
await spreadsheet.FinishAsync();
}
// Assert
SpreadsheetAssert.Valid(stream);
using var workbook = new XLWorkbook(stream);
var worksheet = workbook.Worksheets.Single();
var actualFirstCell = worksheet.Cell(1, 1);
var actualSecondCell = worksheet.Cell(1, 2);
Assert.Equal(firstCellValue, actualFirstCell.Value);
Assert.Equal(secondCellValue, actualSecondCell.Value);
Assert.Equal(firstCellBold, actualFirstCell.Style.Font.Bold);
Assert.Equal(!firstCellBold, actualSecondCell.Style.Font.Bold);
}
public async Task Spreadsheet_AddRow_FillColorCellWithStringValue(Type type)
{
// Arrange
const string cellValue = "Color test";
var color = Color.Brown;
using var stream = new MemoryStream();
await using (var spreadsheet = await Spreadsheet.CreateNewAsync(stream))
{
await spreadsheet.StartWorksheetAsync("Sheet");
var style = new Style();
style.Fill.Color = color;
var styleId = spreadsheet.AddStyle(style);
var styledCell = CellFactory.Create(type, cellValue, styleId);
// Act
await spreadsheet.AddRowAsync(styledCell);
await spreadsheet.FinishAsync();
}
// Assert
SpreadsheetAssert.Valid(stream);
using var workbook = new XLWorkbook(stream);
var worksheet = workbook.Worksheets.Single();
var actualCell = worksheet.Cell(1, 1);
Assert.Equal(cellValue, actualCell.Value);
Assert.Equal(color, actualCell.Style.Fill.BackgroundColor.Color);
}
public async Task Spreadsheet_AddRow_CellWithIntegerValue(int?value, Type type)
{
// Arrange
using var stream = new MemoryStream();
await using (var spreadsheet = await Spreadsheet.CreateNewAsync(stream))
{
await spreadsheet.StartWorksheetAsync("Sheet");
var cell = CellFactory.Create(type, value);
// Act
await spreadsheet.AddRowAsync(cell);
await spreadsheet.FinishAsync();
}
// Assert
SpreadsheetAssert.Valid(stream);
using var actual = SpreadsheetDocument.Open(stream, true);
var sheetPart = actual.WorkbookPart !.WorksheetParts.Single();
var actualCell = sheetPart.Worksheet.Descendants <OpenXmlCell>().Single();
Assert.Equal(CellValues.Number, actualCell.GetDataType());
Assert.Equal(value?.ToString() ?? string.Empty, actualCell.InnerText);
}
public async Task Spreadsheet_AddRow_CellWithStringValue(string?value, Type type)
{
// Arrange
using var stream = new MemoryStream();
await using (var spreadsheet = await Spreadsheet.CreateNewAsync(stream))
{
await spreadsheet.StartWorksheetAsync("Sheet");
var cell = CellFactory.Create(type, value);
// Act
await spreadsheet.AddRowAsync(cell);
await spreadsheet.FinishAsync();
}
// Assert
SpreadsheetAssert.Valid(stream);
using var actual = SpreadsheetDocument.Open(stream, true);
var sheetPart = actual.WorkbookPart !.WorksheetParts.Single();
var actualCell = sheetPart.Worksheet.Descendants <OpenXmlCell>().Single();
CellValues?expectedDataType = value is null ? null : CellValues.InlineString;
Assert.Equal(expectedDataType, actualCell.DataType?.Value);
Assert.Equal(value ?? string.Empty, actualCell.InnerText);
}
/// <summary>
/// Generates the output
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
public string GenerateOutput(string input)
{
List <Minefield> minefields = new List <Minefield>();
Minefield minefield = null;
StringBuilder output = new StringBuilder();
string[] delimiter = { Environment.NewLine };
string[] words = input.Split(delimiter, StringSplitOptions.None);
foreach (string s in words)
{
if (MinefieldValidator.IsHeader(s))
{
minefield = MinefieldFactory.Create(minefields.Count + 1, s);
minefields.Add(minefield);
}
else if (MinefieldValidator.isFooter(s))
{
break;
}
else
{
foreach (char c in s.ToCharArray())
{
if (CellValidator.isMineOrSafe(c.ToString()))
{
minefield.Cells.Add(CellFactory.Create(c));
}
else
{
ErroMessage = "Your input data is not valid.";
return(output.ToString());
}
}
}
}
try
{
foreach (Minefield field in minefields)
{
MinesweeperConverter converter = new MinesweeperConverter();
converter.ConvertMinefield(field);
//header
output.Append(String.Format(MinefieldValidator.headerOutput, field.Id));
output.Append(Environment.NewLine);
//result
output.Append(converter.output);
output.Append(Environment.NewLine);
}
}
catch
{
ErroMessage = "Your input data is not valid.";
return(output.ToString());
}
return(output.ToString());
}
internal void GenerateSea()
{
for (var i = 0; i < size; i++)
{
for (var j = 0; j < size; j++)
{
field[i].Add(CellFactory.Create(CellType.Water, i, j));
}
}
}
public void Generate(CellType cellType, int times)
{
times = times > playableArea.Count
? playableArea.Count
: times;
for (var i = 0; i < times; i++)
{
var cell = GetPlayableCell();
var newType = CellFactory.Create(cellType, cell.Position.Column, cell.Position.Row);
newType.Field = this;
Draw(newType);
}
}
public Board()
{
Matrix = new CellState[SIZE, SIZE];
for (int x = 0; x < SIZE; x++)
{
for (int y = 0; y < SIZE; y++)
{
var position = new Vector3(x - (SIZE / 2), y - (SIZE / 2), 0);
Matrix[x, y] = CellFactory.Create(position, Random.Range(1, 3) == 1);
}
}
}
/// <summary>
/// Filling the minefield with cells.
/// </summary>
/// <param name="minefield">The minefield.</param>
/// <param name="input">The input.</param>
private void CreateCells(Minefield minefield, string input)
{
foreach (char c in input.ToCharArray())
{
if (CellValidator.isMineOrSafe(c.ToString()))
{
minefield.Cells.Add(CellFactory.Create(c));
}
else
{
//invalid input
this.Renderer.ClearCurrentLine();
break;
}
}
}
public void CanCreateAllTypes()
{
var missedCellTypes = new List <CellType>();
var values = (IList)Enum.GetValues(typeof(CellType));
for (var i = 0; i < values.Count; i++)
{
var cellType = (CellType)values[i];
try {
CellFactory.Create(cellType, 1, 1);
}
catch (Exception) {
missedCellTypes.Add(cellType);
Console.WriteLine(cellType.ToString());
}
}
missedCellTypes.ShouldBeEmpty();
}
public async Task Spreadsheet_AddRow_MultiFormatCellWithStringValue(bool formatting, Type type)
{
// Arrange
const string cellValue = "Formatting test";
var fontName = formatting ? "Arial" : null;
var fillColor = formatting ? Color.Green as Color? : null;
var fontColor = formatting ? Color.Red as Color? : null;
using var stream = new MemoryStream();
await using (var spreadsheet = await Spreadsheet.CreateNewAsync(stream))
{
await spreadsheet.StartWorksheetAsync("Sheet");
var style = new Style();
style.Fill.Color = fillColor;
style.Font.Bold = formatting;
style.Font.Color = fontColor;
style.Font.Italic = formatting;
style.Font.Name = fontName;
style.Font.Strikethrough = formatting;
var styleId = spreadsheet.AddStyle(style);
var styledCell = CellFactory.Create(type, cellValue, styleId);
// Act
await spreadsheet.AddRowAsync(styledCell);
await spreadsheet.FinishAsync();
}
// Assert
SpreadsheetAssert.Valid(stream);
using var workbook = new XLWorkbook(stream);
var worksheet = workbook.Worksheets.Single();
var actualCell = worksheet.Cell(1, 1);
Assert.Equal(cellValue, actualCell.Value);
Assert.Equal(formatting, actualCell.Style.Fill.BackgroundColor.Color == fillColor);
Assert.Equal(formatting, actualCell.Style.Font.Bold);
Assert.Equal(formatting, actualCell.Style.Font.FontColor.Color == fontColor);
Assert.Equal(formatting, string.Equals(actualCell.Style.Font.FontName, fontName, StringComparison.Ordinal));
Assert.Equal(formatting, actualCell.Style.Font.Italic);
Assert.Equal(formatting, actualCell.Style.Font.Strikethrough);
}
internal void GenerateGrass()
{
for (var i = 1; i < size - 1; i++)
{
for (var j = 1; j < size - 1; j++)
{
var cell = CellFactory.Create(CellType.Grass, i, j);
field[i][j] = cell;
playableArea.Add(cell);
}
}
playableArea.Remove(field[1][1]);
playableArea.Remove(field[1][size - 2]);
playableArea.Remove(field[size - 2][size - 2]);
playableArea.Remove(field[size - 2][1]);
field[1][1] = CellFactory.Create(CellType.Water, 1, 1);
field[1][size - 2] = CellFactory.Create(CellType.Water, 1, size - 2);
field[size - 2][size - 2] = CellFactory.Create(CellType.Water, size - 2, size - 2);
field[size - 2][1] = CellFactory.Create(CellType.Water, size - 2, 1);
}
public Cell GetCellOrCreate(Vector2 point)
{
// cellIndex is the index of the cell
var cellIndex = point;
cellIndex.x = Util.RoundTo(cellIndex.x + 0.5f, NumberOfTiles);
cellIndex.y = Util.RoundTo(cellIndex.y + 0.5f, NumberOfTiles);
cellIndex = cellIndex / NumberOfTiles;
var groupName = "(" + cellIndex.x + "," + cellIndex.y + ")";
var cell = Cells.Find(element => element.name == groupName);
// If it doesn't exist time to create it
if (cell == null)
{
cell = CellFactory.Create(cellIndex, this);
Cells.Add(cell);
}
return(cell);
}
Vector3 pointPos; //position to place each prefab along the given circle/eliptoid
public BoardCircle()
{
Matrix = new CellState[SIZE_X, SIZE_Y];
for (int x = 0; x < SIZE_X; x++)
{
for (int y = 0; y < SIZE_Y; y++)
{
//multiply 'i' by '1.0f' to ensure the result is a fraction
float pointNum = (x * 1.0f) / SIZE_X;
//angle along the unit circle for placing points
float angle = pointNum * Mathf.PI * 2;
float X = Mathf.Sin(angle) * radiusX; // for radial placement and simple height
float Y = Mathf.Cos(angle) * radiusY; // for radial placement and simple height
//float X = Mathf.Sin (angle)*(radiusX + radiusOffset* y); // for placement in a ring like fasion on the ground
//float Y = Mathf.Cos (angle)*(radiusY + radiusOffset* y); // for placement in a ring like fasion on the ground
//position for the point prefab
if (vertical)
{
pointPos = new Vector3(X, Y) + centerPos;
}
else if (!vertical)
{
pointPos = new Vector3(X, y * SCALE - (SIZE_Y / 2) * SCALE, Y) + centerPos; // for centered pivot of the entire group
pointPos = new Vector3(X, y * SCALE, Y) + centerPos; // for placement from bottom to top
//pointPos = new Vector3(X, centerPos.y, Y)+centerPos; // for placement in a ring like fasion on the ground
}
//var position = new Vector3(x - (SIZE_X / 2), y - (SIZE_Y / 2), 0);
//var position = new Vector3(x*SCALE- (SIZE_X / 2)*SCALE,y*SCALE- (SIZE_Y / 2)*SCALE,0);
var position = pointPos;
Matrix[x, y] = CellFactory.Create(position, Random.Range(1, 3) == 1);
}
}
}
public Entity RequestCell(Cell cell, float verticalOffset, Transform parent)
{
Entity?cellEntity = data.Find(e => !e.Value.IsEnabled() && e.Value.Get <Cell>().Color == cell.Color);
if (!cellEntity.HasValue)
{
cellEntity = _cellFactory.Create(cell, parent);
data.Add(cellEntity.Value);
}
else
{
Reset(cellEntity, cell);
}
var localPosition = GetLocalPosition(cell);
PlaceCell(cellEntity, localPosition, verticalOffset);
if (verticalOffset != 0)
{
cellEntity.Value.Set(new TargetPosition {
Position = localPosition, UseLocalPosition = true
});
}
return(cellEntity.Value);
}
public void TestInit()
{
ship = new Ship(new Team(TeamType.Black, new TestEmptyRules()), (WaterCell)CellFactory.Create(CellType.Water, 1, 1));
}
public IPropertyGirdCell Create(PropertyEditorAttribute attribute)
{
return(_factory.Create(attribute));
}