public void ConvertShouldConvertToReversePolishNotation()
{
var input = new[] // 3 + 4 * 2 / (1 - 5)^2
{
InputCell.Number(3),
InputCell.Symbol("+"),
InputCell.Number(4),
InputCell.Symbol("*"),
InputCell.Number(2),
InputCell.Symbol("/"),
InputCell.Symbol("("),
InputCell.Number(1),
InputCell.Symbol("-"),
InputCell.Number(5),
InputCell.Symbol(")"),
InputCell.Symbol("^"),
InputCell.Number(2),
};
var result = new RpnConverter(new InputChecker()).Convert(input);
// 3 4 2 * 1 5 - 2 ^ / +
Assert.AreEqual(3, result[0].Value);
Assert.AreEqual(4, result[1].Value);
Assert.AreEqual(2, result[2].Value);
Assert.AreEqual("*", result[3].Value);
Assert.AreEqual(1, result[4].Value);
Assert.AreEqual(5, result[5].Value);
Assert.AreEqual("-", result[6].Value);
Assert.AreEqual(2, result[7].Value);
Assert.AreEqual("^", result[8].Value);
Assert.AreEqual("/", result[9].Value);
Assert.AreEqual("+", result[10].Value);
}
public void IsOperationShouldReturnTrue()
{
Assert.IsTrue(InputCell.Symbol("+").IsOperation());
Assert.IsTrue(InputCell.Symbol("-").IsOperation());
Assert.IsTrue(InputCell.Symbol("*").IsOperation());
Assert.IsTrue(InputCell.Symbol("/").IsOperation());
Assert.IsTrue(InputCell.Symbol("^").IsOperation());
}
public InputCell CreateInputCell(int value)
{
var cell = new InputCell(_cells.Count, value);
cell.Changed += OnCellChanged;
_cells[cell.Id] = cell;
return(cell);
}
public CalculationService(int row)
{
Row = row;
ResultValue = InputCell.CombineLatest(
GetPreviousResultValue(),
(i, r) => i + r
)
.Publish().RefCount();
}
public void SetActiveCell(InputCell _cell)
{
if(activeCell)
activeCell.DeactivateCell();
activeCell = _cell;
if(activeCell)
activeCell.ActivateCell();
}
public InputCell CreateInputCell(int value)
{
var inputCell = new InputCell(cells.Count, value);
inputCell.Changed += CellChanged;
cells[inputCell.Id] = inputCell;
return(inputCell);
}
public void WeightShouldReturnCorrectWeigth()
{
Assert.AreEqual(0, InputCell.Number(1).Weight);
Assert.AreEqual(1, InputCell.Symbol(")").Weight);
Assert.AreEqual(1, InputCell.Symbol("(").Weight);
Assert.AreEqual(2, InputCell.Symbol("+").Weight);
Assert.AreEqual(2, InputCell.Symbol("-").Weight);
Assert.AreEqual(3, InputCell.Symbol("*").Weight);
Assert.AreEqual(3, InputCell.Symbol("/").Weight);
Assert.AreEqual(4, InputCell.Symbol("^").Weight);
}
/// <summary>
/// Defines this cell as an input cell for a scenario
/// </summary>
/// <returns></returns>
public InputCell ToInputCell()
{
var cell = new InputCell()
{
Id = Id,
Content = Content,
Location = Location,
SifLocation = SifLocation
};
return(cell);
}
public void CheckShouldThrowExceptionIfThereIsOpeartionsInLastCell()
{
var input = new[]
{
InputCell.Number(2),
InputCell.Symbol("+"),
InputCell.Number(2),
InputCell.Symbol("+")
};
Assert.Throws <ArgumentException>(() =>
new InputChecker().Check(input));
}
public static void SetCellValue_object___Should_throw_ArgumentException___When_value_is_not_null_and_not_assignable_to_TValue()
{
// Arrange
var systemUnderTest = new InputCell <int>();
var timestampUtc = A.Dummy <UtcDateTime>();
var details = A.Dummy <string>();
// Act
var actual = Record.Exception(() => systemUnderTest.SetCellValue(A.Dummy <Version>(), timestampUtc, details));
// Assert
actual.AsTest().Must().BeOfType <ArgumentException>();
actual.Message.AsTest().Must().BeEqualTo("value is not of type int.");
}
private List <GridObject> SolveInput(InputCell _inputCell, List <GridObject> _checkedObjects)
{
_inputCell.CurrentValues = new int[] { _inputCell.InputValue };
GridObject exit = GetCell(_inputCell.Exit);
if (exit != null)
{
return(new List <GridObject> {
exit
});
}
else
{
return(null);
}
}
private void GenerateInput()
{
uint x = 0;
uint y = (uint)Random.Range(1, DimensionY);
int value = Random.Range(1, MaxInputValue + 1);
while (GetCell(new CellCoordinates(x, y)) != null)
{
y = (uint)Random.Range(1, DimensionY);
}
InputCell input = new InputCell(new CellCoordinates(x, y), ObjectOrientation.Or0, value);
m_inputs.Add(input);
InsertObject(input);
Debug.Log("GridManager: Input added - (" + x + "," + y + ") value " + value);
}
public void CountShouldReturn3Dot5()
{
// 3 + 4 * 2 / (1 - 5)^2 = 3.5
// 3 4 2 * 1 5 - 2 ^ / +
var input = new[]
{
InputCell.Number(3),
InputCell.Number(4),
InputCell.Number(2),
InputCell.Symbol("*"),
InputCell.Number(1),
InputCell.Number(5),
InputCell.Symbol("-"),
InputCell.Number(2),
InputCell.Symbol("^"),
InputCell.Symbol("/"),
InputCell.Symbol("+")
};
var result = new RpnCounter().Count(input);
Assert.AreEqual(3.5, result);
}
public void IsNumberShouldReturnTrue()
{
Assert.IsTrue(InputCell.Number(1).IsNumber());
}
public void TransferValue(InputCell _cell)
{
_cell.MyValue = MyValue;
MyValue = numberPool.GetNextNumber();
}
/// <summary>
/// Defines this cell as an input cell for a scenario
/// </summary>
/// <returns></returns>
public InputCell ToInputCell()
{
var cell = new InputCell()
{
Id = Id,
Content = Content,
Location = Location,
SifLocation = SifLocation
};
return cell;
}
private void PassThroughCell(CellCoordinates _cell)
{
if (m_passedThrough.Peek() != _cell)
{
CellCoordinates head = m_passedThrough.Pop();
if (_cell != head && IsAdjacentTo(_cell, head))
{
// Wait till we move, and only consider if it is adjacent
if (m_passedThrough.Count >= 1)
{
CellCoordinates prev = m_passedThrough.Pop();
if (_cell == prev)
{
// Early out if we went backwards
Log("WireManager: Going backwards to " + _cell.ToString());
m_passedThrough.Push(prev);
return;
}
m_passedThrough.Push(prev);
}
else
{
// This is the first move, assert that we head onto a valid OUTPUT of our starting gate
GridObject gridObject = m_gridManager.GetCell(head);
switch (gridObject.ObjectType)
{
case GridObjectType.Input:
{
InputCell input = (InputCell)gridObject;
if (input.Exit != _cell)
{
m_passedThrough.Push(head); // Put the head back on and early out, this is not the exit cell
return;
}
break;
}
case GridObjectType.Gate:
{
Gate gate = (Gate)gridObject;
bool isValid = false;
foreach (CellCoordinates output in gate.Outputs)
{
if (output == _cell)
{
isValid = true;
}
}
if (!isValid)
{
m_passedThrough.Push(head); // We are not over any valid output cell, put the head back on and early out
return;
}
break;
}
default:
{
Debug.LogError("WireManager: PassThrough found starting position that wasn't a Gate or Input.");
m_passedThrough.Push(head); // Put the head back on and early out
return;
}
}
}
m_passedThrough.Push(head); // Put the head back on, moving forwards
GridObject headObject = m_gridManager.GetCell(head);
if ((m_passedThrough.Count == 1 || headObject == null || (headObject.ObjectType != GridObjectType.Gate && headObject.ObjectType != GridObjectType.Output)) &&
!m_passedThrough.Contains(_cell))
{
// Check we haven't been here before on this path, and that we haven't already arrived at a destination
GridObject cellObject = m_gridManager.GetCell(_cell);
if (cellObject == null)
{
// Cell is unoccupied, add it
Log("WireManager: Passing through " + _cell.ToString());
m_passedThrough.Push(_cell);
}
else
{
// Need to check it's a valid goal and we arrived in an acceptable way
switch (cellObject.ObjectType)
{
case GridObjectType.Gate:
{
Gate gate = (Gate)cellObject;
bool isValid = false;
foreach (CellCoordinates input in gate.Inputs)
{
if (input == head)
{
isValid = true;
break;
}
}
if (isValid)
{
// Head lines up with an input for this gate so add Gate as end point
Log("WireManager: Passing through " + _cell.ToString());
m_passedThrough.Push(_cell);
}
else
{
return;
}
break;
}
case GridObjectType.Output:
{
OutputCell output = (OutputCell)cellObject;
if (output.Entry == head)
{
// Entry of Output lines up with head, so add Output as end point
Log("WireManager: Passing through " + _cell.ToString());
m_passedThrough.Push(_cell);
}
else
{
;
return;
}
break;
}
default:
{
return;
}
}
}
}
return;
}
m_passedThrough.Push(head); // Put the head back on, no new additions
}
}
static InputCellTValueTest()
{
ConstructorArgumentValidationTestScenarios
.RemoveAllScenarios()
.AddScenario(() =>
new ConstructorArgumentValidationTestScenario <InputCell <Version> >
{
Name = "constructor should throw ArgumentOutOfRangeException when parameter 'columnsSpanned' is 0",
ConstructionFunc = () =>
{
var referenceObject = A.Dummy <InputCell <Version> >();
var result = new InputCell <Version>(
referenceObject.Id,
0,
referenceObject.Details,
referenceObject.Validation,
referenceObject.ValidationEvents,
referenceObject.DefaultAvailability,
referenceObject.AvailabilityCheck,
referenceObject.AvailabilityCheckEvents,
referenceObject.InputEvents,
referenceObject.ValueFormat,
referenceObject.Format,
referenceObject.HoverOver);
return(result);
},
ExpectedExceptionType = typeof(ArgumentOutOfRangeException),
ExpectedExceptionMessageContains = new[] { "columnsSpanned is 0; must be null or >= 1.", },
})
.AddScenario(() =>
new ConstructorArgumentValidationTestScenario <InputCell <Version> >
{
Name = "constructor should throw ArgumentOutOfRangeException when parameter 'columnsSpanned' is -1",
ConstructionFunc = () =>
{
var referenceObject = A.Dummy <InputCell <Version> >();
var result = new InputCell <Version>(
referenceObject.Id,
-1,
referenceObject.Details,
referenceObject.Validation,
referenceObject.ValidationEvents,
referenceObject.DefaultAvailability,
referenceObject.AvailabilityCheck,
referenceObject.AvailabilityCheckEvents,
referenceObject.InputEvents,
referenceObject.ValueFormat,
referenceObject.Format,
referenceObject.HoverOver);
return(result);
},
ExpectedExceptionType = typeof(ArgumentOutOfRangeException),
ExpectedExceptionMessageContains = new[] { "columnsSpanned is -1; must be null or >= 1.", },
})
.AddScenario(() =>
new ConstructorArgumentValidationTestScenario <InputCell <Version> >
{
Name = "constructor should throw ArgumentOutOfRangeException when parameter 'columnsSpanned' is negative number",
ConstructionFunc = () =>
{
var referenceObject = A.Dummy <InputCell <Version> >();
var result = new InputCell <Version>(
referenceObject.Id,
A.Dummy <NegativeInteger>(),
referenceObject.Details,
referenceObject.Validation,
referenceObject.ValidationEvents,
referenceObject.DefaultAvailability,
referenceObject.AvailabilityCheck,
referenceObject.AvailabilityCheckEvents,
referenceObject.InputEvents,
referenceObject.ValueFormat,
referenceObject.Format,
referenceObject.HoverOver);
return(result);
},
ExpectedExceptionType = typeof(ArgumentOutOfRangeException),
ExpectedExceptionMessageContains = new[] { "columnsSpanned", "must be null or >= 1.", },
})
.AddScenario(() =>
new ConstructorArgumentValidationTestScenario <InputCell <Version> >
{
Name = "constructor should throw ArgumentException when parameter 'validationEvents' contains a null element",
ConstructionFunc = () =>
{
var referenceObject = A.Dummy <InputCell <Version> >();
var result = new InputCell <Version>(
referenceObject.Id,
referenceObject.ColumnsSpanned,
referenceObject.Details,
referenceObject.Validation,
new[] { A.Dummy <CellValidationEventBase>(), null, A.Dummy <CellValidationEventBase>() },
referenceObject.DefaultAvailability,
referenceObject.AvailabilityCheck,
referenceObject.AvailabilityCheckEvents,
referenceObject.InputEvents,
referenceObject.ValueFormat,
referenceObject.Format,
referenceObject.HoverOver);
return(result);
},
ExpectedExceptionType = typeof(ArgumentException),
ExpectedExceptionMessageContains = new[] { "validationEvents contains a null element", },
})
.AddScenario(() =>
new ConstructorArgumentValidationTestScenario <InputCell <Version> >
{
Name = "constructor should throw ArgumentException when parameter 'validation' is is null but parameter 'validationEvents' is not null nor empty.",
ConstructionFunc = () =>
{
var referenceObject = A.Dummy <InputCell <Version> >();
var result = new InputCell <Version>(
referenceObject.Id,
referenceObject.ColumnsSpanned,
referenceObject.Details,
null,
Some.ReadOnlyDummies <CellValidationEventBase>().ToList(),
referenceObject.DefaultAvailability,
referenceObject.AvailabilityCheck,
referenceObject.AvailabilityCheckEvents,
referenceObject.InputEvents,
referenceObject.ValueFormat,
referenceObject.Format,
referenceObject.HoverOver);
return(result);
},
ExpectedExceptionType = typeof(ArgumentException),
ExpectedExceptionMessageContains = new[] { "There is no validation specified, however one or more validationEvents exists.", },
})
.AddScenario(() =>
new ConstructorArgumentValidationTestScenario <InputCell <Version> >
{
Name = "constructor should throw ArgumentOutOfRangeException when parameter 'defaultAvailability' is neither Availability.Enabled nor Availabilty.Disabled",
ConstructionFunc = () =>
{
var referenceObject = A.Dummy <InputCell <Version> >();
var result = new InputCell <Version>(
referenceObject.Id,
referenceObject.ColumnsSpanned,
referenceObject.Details,
referenceObject.Validation,
referenceObject.ValidationEvents,
Availability.Unknown,
referenceObject.AvailabilityCheck,
referenceObject.AvailabilityCheckEvents,
referenceObject.InputEvents,
referenceObject.ValueFormat,
referenceObject.Format,
referenceObject.HoverOver);
return(result);
},
ExpectedExceptionType = typeof(ArgumentOutOfRangeException),
ExpectedExceptionMessageContains = new[] { "defaultAvailability is neither Availability.Enabled nor Availability.Disabled", },
})
.AddScenario(() =>
new ConstructorArgumentValidationTestScenario <InputCell <Version> >
{
Name = "constructor should throw ArgumentException when parameter 'availabilityCheckEvents' contains a null element",
ConstructionFunc = () =>
{
var referenceObject = A.Dummy <InputCell <Version> >();
var result = new InputCell <Version>(
referenceObject.Id,
referenceObject.ColumnsSpanned,
referenceObject.Details,
referenceObject.Validation,
referenceObject.ValidationEvents,
referenceObject.DefaultAvailability,
referenceObject.AvailabilityCheck,
new[] { A.Dummy <CellAvailabilityCheckEventBase>(), null, A.Dummy <CellAvailabilityCheckEventBase>() },
referenceObject.InputEvents,
referenceObject.ValueFormat,
referenceObject.Format,
referenceObject.HoverOver);
return(result);
},
ExpectedExceptionType = typeof(ArgumentException),
ExpectedExceptionMessageContains = new[] { "availabilityCheckEvents contains a null element", },
})
.AddScenario(() =>
new ConstructorArgumentValidationTestScenario <InputCell <Version> >
{
Name = "constructor should throw ArgumentException when parameter 'availabilityCheck' is is null but parameter 'availabilityCheckEvents' is not null nor empty.",
ConstructionFunc = () =>
{
var referenceObject = A.Dummy <InputCell <Version> >();
var result = new InputCell <Version>(
referenceObject.Id,
referenceObject.ColumnsSpanned,
referenceObject.Details,
referenceObject.Validation,
referenceObject.ValidationEvents,
referenceObject.DefaultAvailability,
null,
Some.ReadOnlyDummies <CellAvailabilityCheckEventBase>().ToList(),
referenceObject.InputEvents,
referenceObject.ValueFormat,
referenceObject.Format,
referenceObject.HoverOver);
return(result);
},
ExpectedExceptionType = typeof(ArgumentException),
ExpectedExceptionMessageContains = new[] { "There is no availabilityCheck specified, however one or more availabilityCheckEvents exists", },
})
.AddScenario(() =>
new ConstructorArgumentValidationTestScenario <InputCell <Version> >
{
Name = "constructor should throw ArgumentException when parameter 'inputEvents' contains a null element",
ConstructionFunc = () =>
{
var referenceObject = A.Dummy <InputCell <Version> >();
var result = new InputCell <Version>(
referenceObject.Id,
referenceObject.ColumnsSpanned,
referenceObject.Details,
referenceObject.Validation,
referenceObject.ValidationEvents,
referenceObject.DefaultAvailability,
referenceObject.AvailabilityCheck,
referenceObject.AvailabilityCheckEvents,
new[] { A.Dummy <CellInputEventBase>(), null, A.Dummy <CellInputEventBase>() },
referenceObject.ValueFormat,
referenceObject.Format,
referenceObject.HoverOver);
return(result);
},
ExpectedExceptionType = typeof(ArgumentException),
ExpectedExceptionMessageContains = new[] { "inputEvents contains a null element", },
});
}
private bool IsConnected(bool _isOutput, CellCoordinates _coords, GridObject _startObject)
{
//Check Us
GridObject gridObject = gridManager.GetCell(_coords);
if (gridObject != null)
{
switch (gridObject.ObjectType)
{
case GridObjectType.Wire:
{
Wire wire = (Wire)gridObject;
for (uint i = 0; i < _startObject.Coordinates.Length; ++i)
{
CellCoordinates toCompare = _isOutput ? wire.Entry : wire.Exit;
if (_startObject.Coordinates[i] == toCompare)
{
return(true);
}
}
break;
}
case GridObjectType.Input:
{
InputCell cell = (InputCell)gridObject;
for (uint i = 0; i < _startObject.Coordinates.Length; ++i)
{
if (_startObject.Coordinates[i] == cell.Exit)
{
if (_startObject.ObjectType == GridObjectType.Gate)
{
Gate usAsGate = (Gate)gridManager.GetCell(_startObject.Coordinates[i]);
foreach (CellCoordinates input in usAsGate.Inputs)
{
if (input == _coords)
{
return(true);
}
}
}
else
{
return(true);
}
}
}
break;
}
case GridObjectType.Output:
{
OutputCell cell = (OutputCell)gridObject;
for (uint i = 0; i < _startObject.Coordinates.Length; ++i)
{
if (_startObject.Coordinates[i] == cell.Entry)
{
if (_startObject.ObjectType == GridObjectType.Gate)
{
Gate usAsGate = (Gate)gridManager.GetCell(_startObject.Coordinates[i]);
foreach (CellCoordinates output in usAsGate.Outputs)
{
if (output == _coords)
{
return(true);
}
}
}
else
{
return(true);
}
}
}
break;
}
case GridObjectType.Gate:
{
Gate gateCell = (Gate)gridObject;
for (uint i = 0; i < _startObject.Coordinates.Length; ++i)
{
for (uint j = 0; j < (_isOutput? gateCell.Inputs.Length : gateCell.Outputs.Length); ++j)
{
CellCoordinates[] toCompare = _isOutput ? gateCell.Inputs : gateCell.Outputs;
if (_startObject.Coordinates[i] == toCompare[j])
{
return(true);
}
}
}
break;
}
}
}
return(false);
}
public DataStructureDummyFactory()
{
// <------------------- ENUMS ------------------------>
AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(Availability.Unknown);
AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(AvailabilityCheckStatus.Unknown);
AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(AvailabilityCheckStepAction.Unknown);
AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(BorderStyle.Unknown);
AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(BorderWeight.Unknown);
AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(BytesPayloadLinkedResourceKind.Unknown);
AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(CellOpExecutionOutcome.Unknown);
AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(CellOpExecutionStatus.Unknown);
AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(CompareOperator.Unknown);
AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(FillPatternStyle.Unknown);
AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(HorizontalAlignment.Unknown);
AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(InnerBorderEdges.None);
AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(LinkTarget.Unknown);
AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(MediaReferenceKind.Unknown);
AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(MessageFormatKind.Unknown);
AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(NumberFormatDigitGroupKind.Unknown);
AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(NumberFormatNegativeDisplayKind.Unknown);
AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(NumberFormatPercentDisplayKind.Unknown);
AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(OuterBorderSides.None);
AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(SlotSelectionStrategy.Unknown);
AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(StringPayloadLinkedResourceKind.Unknown);
AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(UrlLinkedResourceKind.Unknown);
AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(ValidationStatus.Unknown);
AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(ValidationStepAction.Unknown);
AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(Validity.Unknown);
AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(VerticalAlignment.Unknown);
// <------------------- INTERFACES ------------------------>
AutoFixtureBackedDummyFactory.AddDummyCreator <IAvailabilityCheckCell>(A.Dummy <NotSlottedCellBase>);
AutoFixtureBackedDummyFactory.AddDummyCreator <ICell>(A.Dummy <CellBase>);
AutoFixtureBackedDummyFactory.AddDummyCreator <INotSlottedCell>(A.Dummy <NotSlottedCellBase>);
AutoFixtureBackedDummyFactory.AddDummyCreator <IValidationCell>(A.Dummy <NotSlottedCellBase>);
AutoFixtureBackedDummyFactory.AddDummyCreator <ICellValueFormat <Version> >(A.Dummy <CellValueFormatBase <Version> >);
AutoFixtureBackedDummyFactory.AddDummyCreator <IHoverOver>(A.Dummy <HoverOverBase>);
AutoFixtureBackedDummyFactory.AddDummyCreator <ILink>(A.Dummy <SimpleLink>);
AutoFixtureBackedDummyFactory.AddDummyCreator <ILinkedResource>(A.Dummy <LinkedResourceBase>);
AutoFixtureBackedDummyFactory.AddDummyCreator <IOperationOutputCell <Version> >(A.Dummy <OperationCell <Version> >);
// <------------------- OPERATIONS ------------------------>
RegisterReturningOperation <bool>();
RegisterReturningOperation <decimal>();
RegisterReturningOperation <string>();
RegisterReturningOperation <ValidationResult>();
RegisterReturningOperation <AvailabilityCheckResult>();
RegisterReturningOperation <Availability>();
RegisterReturningOperation <Validity>();
RegisterReturningOperation <CellLocatorBase>();
RegisterReturningOperation <CompareOperator>();
// <------------------- MODELS ------------------------>
// Report
AutoFixtureBackedDummyFactory.AddDummyCreator(() =>
{
var numberOfSections = ThreadSafeRandom.Next(1, 4);
var result = new Report(A.Dummy <string>(), Some.ReadOnlyDummies <Section>(numberOfSections).ToList(), A.Dummy <string>(), A.Dummy <UtcDateTime>(), Some.ReadOnlyDummies <SimpleLink>().ToList(), A.Dummy <AdditionalReportInfo>(), A.Dummy <ReportFormat>());
return(result);
});
// TreeTable
AutoFixtureBackedDummyFactory.AddDummyCreator(() =>
{
var numberOfColumns = GetRandomNumberOfColumns();
var columns = Some.ReadOnlyDummies <Column>(numberOfColumns).ToList();
var tableColumns = new TableColumns(columns, A.Dummy <ColumnFormat>());
var tableRows = BuildTableRows(columns.Count);
var result = new TreeTable(tableColumns, tableRows, A.Dummy <TableFormat>());
return(result);
});
// TableRows
AutoFixtureBackedDummyFactory.AddDummyCreator(() =>
{
var result = BuildTableRows(GetRandomNumberOfColumns());
return(result);
});
// HeaderRows
AutoFixtureBackedDummyFactory.AddDummyCreator(() =>
{
var headerRows = BuildFlatRows(GetRandomNumberOfColumns());
var result = new HeaderRows(headerRows, A.Dummy <HeaderRowsFormat>());
return(result);
});
// DataRows
AutoFixtureBackedDummyFactory.AddDummyCreator(() =>
{
var allDataRows = BuildDataRows(GetRandomNumberOfColumns());
var result = new DataRows(allDataRows, A.Dummy <DataRowsFormat>());
return(result);
});
// FooterRows
AutoFixtureBackedDummyFactory.AddDummyCreator(() =>
{
var footerRows = BuildFlatRows(GetRandomNumberOfColumns());
var result = new FooterRows(footerRows, A.Dummy <FooterRowsFormat>());
return(result);
});
// Row
AutoFixtureBackedDummyFactory.AddDummyCreator(() =>
{
var result = BuildDataRow(GetRandomNumberOfColumns());
return(result);
});
// FlatRow
AutoFixtureBackedDummyFactory.AddDummyCreator(() =>
{
var result = BuildFlatRow(GetRandomNumberOfColumns(), allowSpanningCells: true);
return(result);
});
// SlottedCell
AutoFixtureBackedDummyFactory.AddDummyCreator(() =>
{
var columnsSpanned = GetRandomColumnsSpannedByCell();
var cells = Some.ReadOnlyDummies <NotSlottedCellBase>().Select(_ => _.DeepCloneWithColumnsSpanned(columnsSpanned)).Cast <NotSlottedCellBase>().ToList();
var slotIdToCellMap = cells.ToDictionary(_ => A.Dummy <string>(), _ => (INotSlottedCell)_);
var defaultSlotId = slotIdToCellMap.ElementAt(ThreadSafeRandom.Next(0, slotIdToCellMap.Count)).Key;
var result = new SlottedCell(slotIdToCellMap, defaultSlotId, A.Dummy <string>(), columnsSpanned, A.Dummy <string>());
return(result);
});
// InputCell<Version>
AutoFixtureBackedDummyFactory.AddDummyCreator(() =>
{
var result = new InputCell <Version>(
A.Dummy <string>(),
GetRandomColumnsSpannedByCell(),
A.Dummy <string>(),
A.Dummy <Validation>(),
Some.ReadOnlyDummies <CellValidationEventBase>().ToList(),
A.Dummy <Availability>(),
A.Dummy <AvailabilityCheck>(),
Some.ReadOnlyDummies <CellAvailabilityCheckEventBase>().ToList(),
Some.ReadOnlyDummies <CellInputEventBase>().ToList(),
A.Dummy <ICellValueFormat <Version> >(),
A.Dummy <CellFormat>(), A.Dummy <IHoverOver>());
return(result);
});
// NullCell
AutoFixtureBackedDummyFactory.AddDummyCreator(() =>
{
var result = new NullCell(
A.Dummy <string>(),
GetRandomColumnsSpannedByCell(),
A.Dummy <string>(),
A.Dummy <Validation>(),
Some.ReadOnlyDummies <CellValidationEventBase>().ToList(),
A.Dummy <Availability>(),
A.Dummy <AvailabilityCheck>(),
Some.ReadOnlyDummies <CellAvailabilityCheckEventBase>().ToList(),
A.Dummy <CellFormat>(),
A.Dummy <IHoverOver>(),
A.Dummy <ILink>());
return(result);
});
// ConstCell<Version>
AutoFixtureBackedDummyFactory.AddDummyCreator(() =>
{
var result = new ConstCell <Version>(
A.Dummy <Version>(),
A.Dummy <string>(),
GetRandomColumnsSpannedByCell(),
A.Dummy <string>(),
A.Dummy <Validation>(),
Some.ReadOnlyDummies <CellValidationEventBase>().ToList(),
A.Dummy <Availability>(),
A.Dummy <AvailabilityCheck>(),
Some.ReadOnlyDummies <CellAvailabilityCheckEventBase>().ToList(),
A.Dummy <ICellValueFormat <Version> >(),
A.Dummy <CellFormat>(),
A.Dummy <IHoverOver>(),
A.Dummy <ILink>());
return(result);
});
// OperationOutputCell<Version>
AutoFixtureBackedDummyFactory.AddDummyCreator(() =>
{
var result = new OperationCell <Version>(
A.Dummy <IReturningOperation <Version> >(),
A.Dummy <string>(),
GetRandomColumnsSpannedByCell(),
A.Dummy <string>(),
A.Dummy <Validation>(),
Some.ReadOnlyDummies <CellValidationEventBase>().ToList(),
A.Dummy <Availability>(),
A.Dummy <AvailabilityCheck>(),
Some.ReadOnlyDummies <CellAvailabilityCheckEventBase>().ToList(),
Some.ReadOnlyDummies <CellOpExecutionEventBase>().ToList(),
A.Dummy <ICellValueFormat <Version> >(),
A.Dummy <CellFormat>(),
A.Dummy <IHoverOver>(),
A.Dummy <ILink>());
return(result);
});
// DateTimeFormat
AutoFixtureBackedDummyFactory.AddDummyCreator(() =>
{
var localize = A.Dummy <bool>();
var result = new DateTimeFormat(A.Dummy <DateTimeFormatKind>(), A.Dummy <CultureKind>(), localize, localize ? A.Dummy <StandardTimeZone>() : (StandardTimeZone?)null);
return(result);
});
// ReportFormat
AutoFixtureBackedDummyFactory.AddDummyCreator(() =>
{
var displayTimestamp = A.Dummy <bool>();
var result = new ReportFormat(displayTimestamp, displayTimestamp ? A.Dummy <DateTimeFormat>() : null, A.Dummy <ReportFormatOptions>());
return(result);
});
// Color
AutoFixtureBackedDummyFactory.AddDummyCreator(() =>
{
var result = Color.FromArgb(A.Dummy <byte>(), A.Dummy <byte>(), A.Dummy <byte>());
return(result);
});
// Events
AutoFixtureBackedDummyFactory.AddDummyCreator(() =>
{
var result = new CellAvailabilityCheckClearedEvent(A.Dummy <UtcDateTime>(), A.Dummy <string>());
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(() =>
{
var result = new CellAvailabilityCheckDeterminedCellDisabledEvent(A.Dummy <UtcDateTime>(), A.Dummy <string>(), A.Dummy <string>());
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(() =>
{
var result = new CellAvailabilityCheckDeterminedCellEnabledEvent(A.Dummy <UtcDateTime>(), A.Dummy <string>(), A.Dummy <string>());
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(() =>
{
var result = new CellAvailabilityCheckFailedEvent(A.Dummy <UtcDateTime>(), A.Dummy <string>());
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(() =>
{
var result = new CellInputAppliedEvent <Version>(A.Dummy <UtcDateTime>(), A.Dummy <Version>(), A.Dummy <string>());
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(() =>
{
var result = new CellInputClearedEvent(A.Dummy <UtcDateTime>(), A.Dummy <string>());
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(() =>
{
var result = new CellOpExecutionAbortedEvent(A.Dummy <UtcDateTime>(), A.Dummy <string>());
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(() =>
{
var result = new CellOpExecutionClearedEvent(A.Dummy <UtcDateTime>(), A.Dummy <string>());
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(() =>
{
var result = new CellOpExecutionCompletedEvent <Version>(A.Dummy <UtcDateTime>(), A.Dummy <string>(), A.Dummy <Version>());
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(() =>
{
var result = new CellOpExecutionDeemedNotApplicableEvent(A.Dummy <UtcDateTime>(), A.Dummy <string>());
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(() =>
{
var result = new CellOpExecutionFailedEvent(A.Dummy <UtcDateTime>(), A.Dummy <string>());
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(() =>
{
var result = new CellValidationAbortedEvent(A.Dummy <UtcDateTime>(), A.Dummy <string>(), A.Dummy <string>());
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(() =>
{
var result = new CellValidationClearedEvent(A.Dummy <UtcDateTime>(), A.Dummy <string>());
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(() =>
{
var result = new CellValidationDeemedNotApplicableEvent(A.Dummy <UtcDateTime>(), A.Dummy <string>(), A.Dummy <string>());
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(() =>
{
var result = new CellValidationDeterminedCellInvalidEvent(A.Dummy <UtcDateTime>(), A.Dummy <string>(), A.Dummy <string>());
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(() =>
{
var result = new CellValidationDeterminedCellValidEvent(A.Dummy <UtcDateTime>(), A.Dummy <string>(), A.Dummy <string>());
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(() =>
{
var result = new CellValidationFailedEvent(A.Dummy <UtcDateTime>(), A.Dummy <string>());
return(result);
});
}
public void SymbolShouldTrowExceptionInputContainsInvalidSymbols()
{
Assert.Throws <ArgumentException>(() => InputCell.Symbol("$"));
Assert.Throws <ArgumentException>(() => InputCell.Symbol("1"));
Assert.Throws <ArgumentException>(() => InputCell.Symbol("a"));
}
public void IsOperationShouldReturnFalse()
{
Assert.IsFalse(InputCell.Symbol("(").IsOperation());
Assert.IsFalse(InputCell.Symbol(")").IsOperation());
}
public void IsNumberShouldReturnFalse()
{
Assert.IsFalse(InputCell.Symbol(")").IsNumber());
}
private List <GridObject> SolveGate(Gate _gate, List <GridObject> _checkedObjects)
{
List <GridObject> ret = new List <GridObject> {
_gate
};
GridObject[] inputs = new GridObject[_gate.Inputs.Length];
bool ready = true;
int numReadyInputs = inputs.Length;
bool[] readyInputs = new bool[_gate.Inputs.Length];
for (uint i = 0; i < inputs.Length; ++i)
{
// Check if all inputs have been solved
inputs[i] = GetCell(_gate.Inputs[i]);
if (!_checkedObjects.Contains(inputs[i]))
{
ready = false;
readyInputs[i] = false;
numReadyInputs--;
continue;
}
// Check if the output of this input actually aligns with us...
switch (inputs[i].ObjectType)
{
case GridObjectType.Gate:
{
Gate gate = (Gate)inputs[i];
ready = false;
for (uint j = 0; j < gate.Outputs.Length; ++j)
{
if (gate.Outputs[j] == _gate.GetCoordinateForInput(i))
{
ready = true;
break;
}
}
break;
}
case GridObjectType.Input:
{
InputCell input = (InputCell)inputs[i];
ready = input.Exit == _gate.GetCoordinateForInput(i);
break;
}
case GridObjectType.Wire:
{
Wire wire = (Wire)inputs[i];
ready = wire.Exit == _gate.GetCoordinateForInput(i);
break;
}
default:
{
Debug.LogError("GridManager: SolveOutput encountered an invalid GridObjectType at " + _gate.Inputs[i] + " !");
ready = false;
break;
}
}
if (!ready)
{
numReadyInputs--;
readyInputs[i] = false;
continue;
}
readyInputs[i] = true;
}
if (numReadyInputs == inputs.Length || (_gate.Type == GateType.Cross && numReadyInputs > 0))
{
int[] inputValues = new int[inputs.Length];
for (uint i = 0; i < inputs.Length; ++i)
{
// Get value for coordinate which depepnds on which input we are getting
if (readyInputs[i])
{
inputValues[i] = inputs[i].GetValueForCoordinate(_gate.GetCoordinateForInput(i));
}
}
// Actually perform the operation
_gate.DoOperation(inputValues, readyInputs, numReadyInputs);
ret = new List <GridObject>();
for (uint i = 0; i < _gate.Outputs.Length; ++i)
{
if (_gate.Type != GateType.Cross || readyInputs[i])
{
// Need to solve all outputs next (cross can only solve outputs it has readyInputs for!)
GridObject output = GetCell(_gate.Outputs[i]);
if (output != null)
{
ret.Add(output);
}
}
}
}
return(ret.Count != 0 ? ret : null);
}
