/// <summary>
/// Creates a new instance of <see cref="DistanceCalculator"/>.
/// </summary>
/// <param name="normalTakeOffDynamicsCalculator">The <see cref="INormalTakeOffDynamicsCalculator"/>
/// to calculate the aircraft dynamics without failure.</param>
/// <param name="failureTakeOffDynamicsCalculator">The <see cref="IFailureTakeOffDynamicsCalculator"/>
/// to calculate the aircraft dynamics after failure.</param>
/// <param name="integrator">The <see cref="IIntegrator"/> to integrate the first order
/// dynamic system.</param>
/// <param name="calculationSettings">The <see cref="CalculationSettings"/>
/// to configure the calculator.</param>
/// <exception cref="ArgumentNullException">Thrown when:
/// <list type="bullet">
/// <item><paramref name="normalTakeOffDynamicsCalculator"/></item>
/// <item><paramref name="failureTakeOffDynamicsCalculator"/></item>
/// <item><paramref name="integrator"/></item>
/// <item><paramref name="calculationSettings"/></item>
/// </list>
/// is <c>null</c>.</exception>
public DistanceCalculator(INormalTakeOffDynamicsCalculator normalTakeOffDynamicsCalculator,
IFailureTakeOffDynamicsCalculator failureTakeOffDynamicsCalculator,
IIntegrator integrator,
CalculationSettings calculationSettings)
{
if (normalTakeOffDynamicsCalculator == null)
{
throw new ArgumentNullException(nameof(normalTakeOffDynamicsCalculator));
}
if (failureTakeOffDynamicsCalculator == null)
{
throw new ArgumentNullException(nameof(failureTakeOffDynamicsCalculator));
}
if (integrator == null)
{
throw new ArgumentNullException(nameof(integrator));
}
if (calculationSettings == null)
{
throw new ArgumentNullException(nameof(calculationSettings));
}
this.normalTakeOffDynamicsCalculator = normalTakeOffDynamicsCalculator;
this.failureTakeOffDynamicsCalculator = failureTakeOffDynamicsCalculator;
this.integrator = integrator;
this.calculationSettings = calculationSettings;
}
public static void Calculate_ContinuedTakeOffDistanceCalculatorThrowsCalculatorException_ThrowsCalculatorException()
{
// Setup
var random = new Random(21);
AircraftData aircraftData = AircraftDataTestFactory.CreateRandomAircraftData();
var integrator = Substitute.For <IIntegrator>();
int nrOfFailedEngines = random.Next();
double density = random.NextDouble();
double gravitationalAcceleration = random.NextDouble();
CalculationSettings calculationSettings = CalculationSettingsTestFactory.CreateDistanceCalculatorSettings();
var calculatorException = new CalculatorException();
var continuedTakeOffDistanceCalculator = Substitute.For <IDistanceCalculator>();
continuedTakeOffDistanceCalculator.Calculate().Throws(calculatorException);
var distanceCalculatorFactory = Substitute.For <IDistanceCalculatorFactory>();
distanceCalculatorFactory.CreateAbortedTakeOffDistanceCalculator(null, null, 0, 0, null).ReturnsForAnyArgs(continuedTakeOffDistanceCalculator);
var aggregatedCalculator = new Calculator.AggregatedDistanceCalculator.AggregatedDistanceCalculator(distanceCalculatorFactory);
// Call
TestDelegate call = () => aggregatedCalculator.Calculate(aircraftData, integrator, nrOfFailedEngines, density, gravitationalAcceleration, calculationSettings);
// Assert
var exception = Assert.Throws <CalculatorException>(call);
Assert.AreSame(calculatorException, exception);
}
public void GivenCalculator_WhenCalculatingAndSolutionConvergesWithHeightAboveScreenHeightDuringNormalTakeOff_ThenCallsInExpectedOrderAndThrowsCalculatorException()
{
// Given
var random = new Random(21);
const double screenHeight = 10.7;
int nrOfTimeSteps = random.Next(2, int.MaxValue);
double timeStep = random.NextDouble();
int failureSpeed = random.Next();
AircraftState[] states =
{
CreateAircraftStateWithHeight(screenHeight - 0.1),
CreateAircraftStateWithHeight(screenHeight + 0.1),
CreateAircraftStateWithHeight(screenHeight + 0.2)
};
AircraftAccelerations[] accelerations =
{
CreateAircraftAccelerations(),
CreateAircraftAccelerations()
};
var normalTakeOffDynamicsCalculator = Substitute.For <INormalTakeOffDynamicsCalculator>();
normalTakeOffDynamicsCalculator.Calculate(Arg.Any <AircraftState>())
.Returns(accelerations[0], accelerations[1]);
var failureTakeOffDynamicsCalculator = Substitute.For <IFailureTakeOffDynamicsCalculator>();
var integrator = Substitute.For <IIntegrator>();
integrator.Integrate(Arg.Any <AircraftState>(), Arg.Any <AircraftAccelerations>(), timeStep)
.Returns(states[0], states[1], states[2]);
var calculatorSettings = new CalculationSettings(failureSpeed, nrOfTimeSteps, timeStep);
var calculator = new DistanceCalculator(normalTakeOffDynamicsCalculator, failureTakeOffDynamicsCalculator,
integrator, calculatorSettings);
// When
TestDelegate call = () => calculator.Calculate();
// Then
var exception = Assert.Throws <CalculatorException>(call);
Assert.AreEqual("Calculation converged before failure occurred.", exception.Message);
failureTakeOffDynamicsCalculator.DidNotReceiveWithAnyArgs().Calculate(Arg.Any <AircraftState>());
normalTakeOffDynamicsCalculator.Received(2).Calculate(Arg.Any <AircraftState>());
integrator.Received(2).Integrate(Arg.Any <AircraftState>(), Arg.Any <AircraftAccelerations>(), timeStep);
Received.InOrder(() =>
{
normalTakeOffDynamicsCalculator.Calculate(Arg.Is <AircraftState>(state => IsZeroAircraftState(state)));
integrator.Integrate(Arg.Is <AircraftState>(state => IsZeroAircraftState(state)), accelerations[0], timeStep);
normalTakeOffDynamicsCalculator.Calculate(states[0]);
integrator.Integrate(states[0], accelerations[1], timeStep);
// Do not expect additional calls after the second state was returned
});
}
/// <summary>
/// Asserts whether the <paramref name="calculationSettings"/> contain the correct information based on
/// <paramref name="simulationSettings"/>.
/// </summary>
/// <param name="simulationSettings">The <see cref="GeneralSimulationSettingsData"/> to use as a reference.</param>
/// <param name="failureSpeed">The failure speed to use as reference.</param>
/// <param name="calculationSettings">The <see cref="CalculationSettings"/> to assert.</param>
public static void AssertCalculationSettings(GeneralSimulationSettingsData simulationSettings,
int failureSpeed,
CalculationSettings calculationSettings)
{
Assert.That(calculationSettings.TimeStep, Is.EqualTo(simulationSettings.TimeStep));
Assert.That(calculationSettings.MaximumNrOfTimeSteps, Is.EqualTo(simulationSettings.MaximumNrOfIterations));
Assert.That(calculationSettings.FailureSpeed, Is.EqualTo(failureSpeed));
}
public AggregatedDistanceOutput Calculate(AircraftData aircraftData,
IIntegrator integrator,
int nrOfFailedEngines,
double density,
double gravitationalAcceleration,
CalculationSettings calculationSettings)
{
return(aggregatedDistanceCalculator.Calculate(aircraftData, integrator, nrOfFailedEngines, density, gravitationalAcceleration, calculationSettings));
}
public void CreateDistanceCalculatorSettings_Always_ReturnsExpectedValues()
{
// Call
CalculationSettings settings = CalculationSettingsTestFactory.CreateDistanceCalculatorSettings();
// Assert
Assert.IsNotNull(settings);
Assert.Greater(settings.FailureSpeed, 0);
Assert.Greater(settings.MaximumNrOfTimeSteps, 0);
Assert.IsTrue(IsConcreteNumber(settings.TimeStep));
}
public IDistanceCalculator CreateAbortedTakeOffDistanceCalculator(AircraftData data,
IIntegrator integrator,
double density,
double gravitationalAcceleration,
CalculationSettings calculationSettings)
{
INormalTakeOffDynamicsCalculator normalTakeOffDynamicsCalculator =
takeOffDynamicsCalculatorFactory.CreateNormalTakeOffDynamics(data, density, gravitationalAcceleration);
IFailureTakeOffDynamicsCalculator failureTakeOffDynamicsCalculator =
takeOffDynamicsCalculatorFactory.CreateAbortedTakeOffDynamics(data, density, gravitationalAcceleration);
return(new DistanceCalculator(normalTakeOffDynamicsCalculator, failureTakeOffDynamicsCalculator, integrator, calculationSettings));
}
public static void Calculate_WithArguments_ExecutesDistanceCalculatorsAndReturnsExpectedOutput()
{
// Setup
var random = new Random(21);
AircraftData aircraftData = AircraftDataTestFactory.CreateRandomAircraftData();
var integrator = Substitute.For <IIntegrator>();
int nrOfFailedEngines = random.Next();
double density = random.NextDouble();
double gravitationalAcceleration = random.NextDouble();
CalculationSettings calculationSettings = CalculationSettingsTestFactory.CreateDistanceCalculatorSettings();
var abortedTakeOffDistanceCalculator = Substitute.For <IDistanceCalculator>();
var abortedTakeOffDistanceOutput = new DistanceCalculatorOutput(calculationSettings.FailureSpeed, random.NextDouble());
abortedTakeOffDistanceCalculator.Calculate().Returns(abortedTakeOffDistanceOutput);
var continuedTakeOffDistanceCalculator = Substitute.For <IDistanceCalculator>();
var continuedTakeOffDistanceOutput = new DistanceCalculatorOutput(calculationSettings.FailureSpeed, random.NextDouble());
continuedTakeOffDistanceCalculator.Calculate().Returns(continuedTakeOffDistanceOutput);
var distanceCalculatorFactory = Substitute.For <IDistanceCalculatorFactory>();
distanceCalculatorFactory.CreateAbortedTakeOffDistanceCalculator(Arg.Is(aircraftData),
Arg.Is(integrator),
Arg.Is(density),
Arg.Is(gravitationalAcceleration),
Arg.Is(calculationSettings))
.Returns(abortedTakeOffDistanceCalculator);
distanceCalculatorFactory.CreateContinuedTakeOffDistanceCalculator(Arg.Is(aircraftData),
Arg.Is(integrator),
Arg.Is(nrOfFailedEngines),
Arg.Is(density),
Arg.Is(gravitationalAcceleration),
Arg.Is(calculationSettings))
.Returns(continuedTakeOffDistanceCalculator);
var aggregatedCalculator = new Calculator.AggregatedDistanceCalculator.AggregatedDistanceCalculator(distanceCalculatorFactory);
// Call
AggregatedDistanceOutput output = aggregatedCalculator.Calculate(aircraftData, integrator, nrOfFailedEngines, density, gravitationalAcceleration, calculationSettings);
// Assert
Assert.AreEqual(calculationSettings.FailureSpeed, output.FailureSpeed);
Assert.AreEqual(abortedTakeOffDistanceOutput.Distance, output.AbortedTakeOffDistance);
Assert.AreEqual(continuedTakeOffDistanceOutput.Distance, output.ContinuedTakeOffDistance);
}
public void Constructor_WithValidArguments_ExpectedValues()
{
// Setup
var random = new Random(21);
int failureSpeed = random.Next();
int maximumNrOfTimeSteps = random.Next();
double timeStep = random.NextDouble();
// Call
var settings = new CalculationSettings(failureSpeed, maximumNrOfTimeSteps, timeStep);
// Assert
Assert.AreEqual(failureSpeed, settings.FailureSpeed);
Assert.AreEqual(maximumNrOfTimeSteps, settings.MaximumNrOfTimeSteps);
Assert.AreEqual(timeStep, settings.TimeStep);
}
public static void Constructor_ExpectedValues()
{
// Setup
var normalTakeOffDynamicsCalculator = Substitute.For <INormalTakeOffDynamicsCalculator>();
var failureTakeOffDynamicsCalculator = Substitute.For <IFailureTakeOffDynamicsCalculator>();
var integrator = Substitute.For <IIntegrator>();
CalculationSettings calculationSettings = CalculationSettingsTestFactory.CreateDistanceCalculatorSettings();
// Call
var calculator = new DistanceCalculator(normalTakeOffDynamicsCalculator,
failureTakeOffDynamicsCalculator,
integrator,
calculationSettings);
// Assert
Assert.IsInstanceOf <IDistanceCalculator>(calculator);
}
public void Create_WithValidGeneralSimulationSettingsData_ReturnsExpectedCalculationSettings()
{
// Setup
var random = new Random(21);
int failureSpeed = random.Next();
var settings = new GeneralSimulationSettingsData
{
TimeStep = random.NextDouble(),
MaximumNrOfIterations = random.Next()
};
// Call
CalculationSettings calculationSettings = CalculationSettingsFactory.Create(settings, failureSpeed);
// Assert
CalculationSettingsTestHelper.AssertCalculationSettings(settings, failureSpeed, calculationSettings);
}
/// <summary>
/// Calculates the <see cref="AggregatedDistanceOutput"/> based on the calculation input.
/// </summary>
/// <param name="calculationInput">The calculation input to calculate for.</param>
/// <returns>A <see cref="AggregatedDistanceOutput"/>.</returns>
/// <exception cref="CreateKernelDataException">Thrown when the calculation input
/// could not be created for the kernel.</exception>
/// <exception cref="KernelCalculationException">Thrown when <see cref="AggregatedDistanceOutput"/>
/// could not be calculated.</exception>
private AggregatedDistanceOutput CalculateDistances(CalculationInput calculationInput)
{
try
{
CalculationSettings simulationSettings = CalculationSettingsFactory.Create(calculationInput.GeneralSimulationSettings,
calculationInput.FailureVelocity);
return(kernel.Calculate(calculationInput.AircraftData,
calculationInput.Integrator,
calculationInput.NrOfFailedEngines,
calculationInput.Density,
calculationInput.GravitationalAcceleration,
simulationSettings));
}
catch (CalculatorException e)
{
throw new KernelCalculationException(e.Message, e);
}
}
public void GivenKernel_WhenCalculationsAreMadeForVelocityRange_ThenReturnsExpectedOutputsAndBalancedFieldLength(AircraftData aircraftData,
IntegrationReferenceData integrationReferenceData)
{
// Given
var integrator = new EulerIntegrator();
var calculationKernel = new AggregatedDistanceCalculatorKernel();
// When
var outputs = new List <AggregatedDistanceOutput>();
for (int i = 0; i < 90; i++)
{
var calculationSettings = new CalculationSettings(i, maximumTimeSteps, timeStep);
AggregatedDistanceOutput result = calculationKernel.Calculate(aircraftData,
integrator,
1,
density,
gravitationalAcceleration,
calculationSettings);
outputs.Add(result);
}
BalancedFieldLength balancedFieldLength = BalancedFieldLengthCalculator.CalculateBalancedFieldLength(outputs);
// Then
IEnumerable <ReferenceOutput> referenceOutputs = GetReferenceOutputs(integrationReferenceData.FileName);
int expectedLength = referenceOutputs.Count();
Assert.AreEqual(expectedLength, outputs.Count, "Number of reference data entries do not match with actual number of entries");
int velocity = 0;
foreach (ReferenceOutput referenceOutput in referenceOutputs)
{
Assert.AreEqual(referenceOutput.Velocity, outputs[velocity].FailureSpeed);
Assert.AreEqual(referenceOutput.ContinuedTakeOffDistance, outputs[velocity].ContinuedTakeOffDistance, tolerance);
Assert.AreEqual(referenceOutput.AbortedTakeOffDistance, outputs[velocity].AbortedTakeOffDistance, tolerance);
velocity++;
}
Assert.AreEqual(integrationReferenceData.Velocity, balancedFieldLength.Velocity, tolerance);
Assert.AreEqual(integrationReferenceData.Distance, balancedFieldLength.Distance, tolerance);
}
public AggregatedDistanceOutput Calculate(AircraftData aircraftData,
IIntegrator integrator,
int nrOfFailedEngines,
double density,
double gravitationalAcceleration,
CalculationSettings calculationSettings)
{
if (aircraftData == null)
{
throw new ArgumentNullException(nameof(aircraftData));
}
if (integrator == null)
{
throw new ArgumentNullException(nameof(integrator));
}
if (calculationSettings == null)
{
throw new ArgumentNullException(nameof(calculationSettings));
}
IDistanceCalculator abortedTakeOffCalculator = distanceCalculatorFactory.CreateAbortedTakeOffDistanceCalculator(aircraftData,
integrator,
density,
gravitationalAcceleration,
calculationSettings);
IDistanceCalculator continuedTakeOffCalculator = distanceCalculatorFactory.CreateContinuedTakeOffDistanceCalculator(aircraftData,
integrator,
nrOfFailedEngines,
density,
gravitationalAcceleration,
calculationSettings);
DistanceCalculatorOutput abortedTakeOffOutput = abortedTakeOffCalculator.Calculate();
DistanceCalculatorOutput continuedTakeOffOutput = continuedTakeOffCalculator.Calculate();
return(new AggregatedDistanceOutput(calculationSettings.FailureSpeed,
abortedTakeOffOutput.Distance,
continuedTakeOffOutput.Distance));
}
public void Calculate_IntegratorNull_ThrowsArgumentNullException()
{
// Setup
var random = new Random(21);
AircraftData aircraftData = AircraftDataTestFactory.CreateRandomAircraftData();
int nrOfFailedEngines = random.Next();
double density = random.NextDouble();
double gravitationalAcceleration = random.NextDouble();
CalculationSettings calculationSettings = CalculationSettingsTestFactory.CreateDistanceCalculatorSettings();
var distanceCalculatorFactory = Substitute.For <IDistanceCalculatorFactory>();
var aggregatedCalculator = new Calculator.AggregatedDistanceCalculator.AggregatedDistanceCalculator(distanceCalculatorFactory);
// Call
TestDelegate call = () => aggregatedCalculator.Calculate(aircraftData, null, nrOfFailedEngines, density, gravitationalAcceleration, calculationSettings);
// Assert
var exception = Assert.Throws <ArgumentNullException>(call);
Assert.AreEqual("integrator", exception.ParamName);
}
public void Calculate_FailureDynamicsCalculatorThrowsException_ThenExceptionRethrown()
{
// Setup
var random = new Random(21);
double timeStep = random.NextDouble();
int failureSpeed = random.Next();
var normalTakeOffDynamicsCalculator = Substitute.For <INormalTakeOffDynamicsCalculator>();
var calculatorException = new CalculatorException();
var failureTakeOffDynamicsCalculator = Substitute.For <IFailureTakeOffDynamicsCalculator>();
failureTakeOffDynamicsCalculator.Calculate(Arg.Any <AircraftState>())
.Throws(calculatorException);
var integrator = Substitute.For <IIntegrator>();
integrator.Integrate(Arg.Any <AircraftState>(), Arg.Any <AircraftAccelerations>(), timeStep)
.Returns(CreateAircraftStateWithVelocity(failureSpeed + 0.1));
var calculatorSettings = new CalculationSettings(failureSpeed,
random.Next(),
timeStep);
var calculator = new DistanceCalculator(normalTakeOffDynamicsCalculator,
failureTakeOffDynamicsCalculator,
integrator,
calculatorSettings);
// Call
TestDelegate call = () => calculator.Calculate();
// Assert
var exception = Assert.Throws <CalculatorException>(call);
Assert.AreSame(calculatorException, exception);
}
public void Calculate_MaximumIterationsHit_ThrowsCalculatorException()
{
// Setup
var random = new Random(21);
int nrOfTimeSteps = random.Next(1, 10);
double timeStep = random.NextDouble();
int failureSpeed = random.Next();
var normalTakeOffDynamicsCalculator = Substitute.For <INormalTakeOffDynamicsCalculator>();
var calculatorException = new CalculatorException();
var failureTakeOffDynamicsCalculator = Substitute.For <IFailureTakeOffDynamicsCalculator>();
failureTakeOffDynamicsCalculator.Calculate(Arg.Any <AircraftState>())
.Throws(calculatorException);
var integrator = Substitute.For <IIntegrator>();
integrator.Integrate(Arg.Any <AircraftState>(), Arg.Any <AircraftAccelerations>(), timeStep)
.Returns(CreateAircraftStateWithVelocity(failureSpeed));
var calculatorSettings = new CalculationSettings(failureSpeed, nrOfTimeSteps, timeStep);
var calculator = new DistanceCalculator(normalTakeOffDynamicsCalculator, failureTakeOffDynamicsCalculator,
integrator, calculatorSettings);
// Call
TestDelegate call = () => calculator.Calculate();
// Assert
var exception = Assert.Throws <CalculatorException>(call);
Assert.AreEqual("Calculation did not converge.", exception.Message);
integrator.ReceivedWithAnyArgs(nrOfTimeSteps)
.Integrate(Arg.Any <AircraftState>(), Arg.Any <AircraftAccelerations>(), timeStep);
}
private void trvExtensions_AfterSelect(object sender, TreeViewEventArgs e)
{
if (_edSvc.IsNew)
{
return;
}
var ext = e.Node.Tag as IFeatureSourceExtension;
var join = e.Node.Tag as IAttributeRelation;
var calc = e.Node.Tag as ICalculatedProperty;
if (ext != null)
{
var ctl = new ExtendedClassSettings(_fs, GetAllClassNames(), ext);
ctl.Dock = DockStyle.Fill;
//If editing to something valid, update the toolbar
ctl.ResourceChanged += (s, evt) =>
{
btnNewJoin.Enabled = btnNewCalculation.Enabled = IsValidExtension(ext);
};
splitContainer1.Panel2.Controls.Clear();
splitContainer1.Panel2.Controls.Add(ctl);
btnDelete.Enabled = true;
btnNewCalculation.Enabled = btnNewJoin.Enabled = IsValidExtension(ext);
}
else if (join != null)
{
ext = e.Node.Parent.Tag as IFeatureSourceExtension;
if (ext != null)
{
if (ext.FeatureClass != null)
{
//NOTE: The feature source id here may be session based, but this is still okay
//as we're only giving context (the primary class to join on) for the secondary join UI.
//This feature source id is never written into the actual document
var ctl = new JoinSettings(_fs.ResourceID, ext.FeatureClass, join);
ctl.Bind(_edSvc);
ctl.Dock = DockStyle.Fill;
splitContainer1.Panel2.Controls.Clear();
splitContainer1.Panel2.Controls.Add(ctl);
btnDelete.Enabled = true;
}
}
}
else if (calc != null)
{
ext = e.Node.Parent.Tag as IFeatureSourceExtension;
if (ext != null)
{
ClassDefinition cls = _edSvc.CurrentConnection.FeatureService.GetClassDefinition(_fs.ResourceID, ext.FeatureClass); //TODO: Cache?
if (cls != null)
{
var ctl = new CalculationSettings(_edSvc, cls, _fs, calc);
ctl.Dock = DockStyle.Fill;
splitContainer1.Panel2.Controls.Clear();
splitContainer1.Panel2.Controls.Add(ctl);
btnDelete.Enabled = true;
}
}
}
else
{
splitContainer1.Panel2.Controls.Clear();
}
}
public SettingsController(CalculationSettings calcSettings)
{
_calcSettings = calcSettings ?? throw new ArgumentNullException(nameof(calcSettings));
}
public void GivenCalculator_WhenCalculatingAndSolutionConvergesWithScreenHeightAfterFailureDynamics_ThenCallsInExpectedOrderAndOutputReturned()
{
// Given
var random = new Random(21);
const double screenHeight = 10.7;
int nrOfTimeSteps = random.Next(3, int.MaxValue);
double timeStep = random.NextDouble();
int failureSpeed = random.Next();
var failureState = new AircraftState(random.NextAngle(),
random.NextAngle(),
failureSpeed + 0.1,
random.NextDouble(),
random.NextDouble());
AircraftState[] states =
{
failureState,
CreateAircraftStateWithHeight(screenHeight - 0.2),
CreateAircraftStateWithHeight(screenHeight)
};
AircraftAccelerations[] accelerations =
{
CreateAircraftAccelerations(),
CreateAircraftAccelerations(),
CreateAircraftAccelerations()
};
var normalTakeOffDynamicsCalculator = Substitute.For <INormalTakeOffDynamicsCalculator>();
normalTakeOffDynamicsCalculator.Calculate(Arg.Any <AircraftState>())
.Returns(accelerations[0]);
var failureTakeOffDynamicsCalculator = Substitute.For <IFailureTakeOffDynamicsCalculator>();
failureTakeOffDynamicsCalculator.Calculate(Arg.Any <AircraftState>())
.Returns(accelerations[1], accelerations[2]);
var integrator = Substitute.For <IIntegrator>();
integrator.Integrate(Arg.Any <AircraftState>(), Arg.Any <AircraftAccelerations>(), timeStep)
.Returns(states[0], states[1], states[2]);
var calculatorSettings = new CalculationSettings(failureSpeed, nrOfTimeSteps, timeStep);
var calculator = new DistanceCalculator(normalTakeOffDynamicsCalculator, failureTakeOffDynamicsCalculator,
integrator, calculatorSettings);
// Call
DistanceCalculatorOutput output = calculator.Calculate();
// Assert
normalTakeOffDynamicsCalculator.Received(1).Calculate(Arg.Any <AircraftState>());
failureTakeOffDynamicsCalculator.Received(2).Calculate(Arg.Any <AircraftState>());
integrator.Received(3).Integrate(Arg.Any <AircraftState>(), Arg.Any <AircraftAccelerations>(), timeStep);
Received.InOrder(() =>
{
normalTakeOffDynamicsCalculator.Calculate(Arg.Is <AircraftState>(state => IsZeroAircraftState(state)));
integrator.Integrate(Arg.Is <AircraftState>(state => IsZeroAircraftState(state)), accelerations[0], timeStep);
failureTakeOffDynamicsCalculator.Calculate(states[0]);
integrator.Integrate(states[0], accelerations[1], timeStep);
failureTakeOffDynamicsCalculator.Calculate(states[1]);
integrator.Integrate(states[1], accelerations[2], timeStep);
});
Assert.AreEqual(states.Last().Distance, output.Distance);
Assert.AreEqual(failureSpeed, output.FailureSpeed);
}
// ----------------------------------------------------------------------------------------
#region Constructors
public CalculationArguments(CalculationSettings settings, ProgressReporter reporter, CancellationTokenSource tokenSource)
{
this.settings = settings;
this.reporter = reporter;
this.tokenSource = tokenSource;
}
