public void Calculate_CalculatorWithCompleteInput_InputCorrectlySetToKernel()
{
// Setup
WaternetCalculatorInput input = WaternetCalculatorInputTestFactory.CreateCompleteCalculatorInput();
using (new MacroStabilityInwardsKernelFactoryConfig())
{
var factory = (TestMacroStabilityInwardsKernelFactory)MacroStabilityInwardsKernelWrapperFactory.Instance;
WaternetKernelStub waternetKernel = factory.LastCreatedWaternetExtremeKernel;
waternetKernel.Waternet = new CSharpWrapperWaternet
{
HeadLines = new List <HeadLine>(),
ReferenceLines = new List <ReferenceLine>(),
PhreaticLine = new HeadLine
{
Name = string.Empty
}
};
// Call
new WaternetExtremeCalculator(input, factory).Calculate();
// Assert
WaternetKernelInputAssert.AssertMacroStabilityInput(MacroStabilityInputCreator.CreateWaternet(input), waternetKernel.KernelInput);
}
}
public void Calculate_KernelWithCompleteOutput_OutputCorrectlyReturnedByCalculator()
{
// Setup
WaternetCalculatorInput input = WaternetCalculatorInputTestFactory.CreateValidCalculatorInput();
using (new MacroStabilityInwardsKernelFactoryConfig())
{
var factory = (TestMacroStabilityInwardsKernelFactory)MacroStabilityInwardsKernelWrapperFactory.Instance;
WaternetKernelStub kernel = factory.LastCreatedWaternetExtremeKernel;
SetCompleteKernelOutput(kernel);
// Call
WaternetCalculatorResult result = new TestWaternetCalculator(input, factory).Calculate();
// Assert
Assert.IsNotNull(result);
var expectedPhreaticLines = new List <HeadLine>
{
kernel.Waternet.PhreaticLine
};
expectedPhreaticLines.AddRange(kernel.Waternet.HeadLines);
WaternetCalculatorOutputAssert.AssertPhreaticLines(expectedPhreaticLines.ToArray(), result.PhreaticLines.ToArray());
WaternetCalculatorOutputAssert.AssertReferenceLines(kernel.Waternet.ReferenceLines.ToArray(), result.WaternetLines.ToArray());
}
}
public void Validate_KernelReturnsValidationResults_ReturnsEnumerableWithOnlyErrorsAndWarnings()
{
// Setup
using (new MacroStabilityInwardsKernelFactoryConfig())
{
var factory = (TestMacroStabilityInwardsKernelFactory)MacroStabilityInwardsKernelWrapperFactory.Instance;
WaternetKernelStub waternetKernel = factory.LastCreatedWaternetExtremeKernel;
waternetKernel.ReturnValidationResults = true;
WaternetCalculatorInput input = WaternetCalculatorInputTestFactory.CreateValidCalculatorInput();
var calculator = new TestWaternetCalculator(input, factory);
// Call
IEnumerable <MacroStabilityInwardsKernelMessage> kernelMessages = calculator.Validate();
// Assert
Assert.AreEqual(2, kernelMessages.Count());
MacroStabilityInwardsKernelMessage firstMessage = kernelMessages.ElementAt(0);
Assert.AreEqual("Validation Warning", firstMessage.Message);
Assert.AreEqual(MacroStabilityInwardsKernelMessageType.Warning, firstMessage.Type);
MacroStabilityInwardsKernelMessage secondMessage = kernelMessages.ElementAt(1);
Assert.AreEqual("Validation Error", secondMessage.Message);
Assert.AreEqual(MacroStabilityInwardsKernelMessageType.Error, secondMessage.Type);
}
}
public void Constructor_FactoryNull_ArgumentNullException()
{
// Setup
WaternetCalculatorInput input = WaternetCalculatorInputTestFactory.CreateValidCalculatorInput();
// Call
void Call() => new TestWaternetCalculator(input, null);
// Assert
var exception = Assert.Throws <ArgumentNullException>(Call);
Assert.AreEqual("factory", exception.ParamName);
}
public void Constructor_ExpectedValues()
{
// Setup
var mocks = new MockRepository();
var factory = mocks.Stub <IMacroStabilityInwardsKernelFactory>();
mocks.ReplayAll();
WaternetCalculatorInput input = WaternetCalculatorInputTestFactory.CreateValidCalculatorInput();
// Call
var calculator = new WaternetExtremeCalculator(input, factory);
// Assert
Assert.IsInstanceOf <WaternetCalculator>(calculator);
mocks.VerifyAll();
}
public void Validate_CalculatorWithValidInput_ReturnEmptyEnumerable()
{
// Setup
using (new MacroStabilityInwardsKernelFactoryConfig())
{
var factory = (TestMacroStabilityInwardsKernelFactory)MacroStabilityInwardsKernelWrapperFactory.Instance;
WaternetCalculatorInput input = WaternetCalculatorInputTestFactory.CreateValidCalculatorInput();
var calculator = new TestWaternetCalculator(input, factory);
// Call
IEnumerable <MacroStabilityInwardsKernelMessage> kernelMessages = calculator.Validate();
// Assert
CollectionAssert.IsEmpty(kernelMessages);
}
}
public void Validate_CalculatorWithValidInput_KernelValidateMethodCalled()
{
// Setup
using (new MacroStabilityInwardsKernelFactoryConfig())
{
var factory = (TestMacroStabilityInwardsKernelFactory)MacroStabilityInwardsKernelWrapperFactory.Instance;
WaternetCalculatorInput input = WaternetCalculatorInputTestFactory.CreateValidCalculatorInput();
var calculator = new TestWaternetCalculator(input, factory);
// Call
calculator.Validate();
// Assert
Assert.IsTrue(factory.LastCreatedWaternetExtremeKernel.Validated);
}
}
public void Calculate_CalculatorWithValidInput_KernelCalculateMethodCalled()
{
// Setup
WaternetCalculatorInput input = WaternetCalculatorInputTestFactory.CreateValidCalculatorInput();
using (new MacroStabilityInwardsKernelFactoryConfig())
{
var factory = (TestMacroStabilityInwardsKernelFactory)MacroStabilityInwardsKernelWrapperFactory.Instance;
WaternetKernelStub waternetKernel = factory.LastCreatedWaternetExtremeKernel;
SetCompleteKernelOutput(waternetKernel);
// Call
new TestWaternetCalculator(input, factory).Calculate();
// Assert
Assert.IsTrue(waternetKernel.Calculated);
}
}
public void Calculate_KernelThrowsWaternetKernelWrapperException_ThrowWaternetCalculatorException()
{
// Setup
WaternetCalculatorInput input = WaternetCalculatorInputTestFactory.CreateValidCalculatorInput();
using (new MacroStabilityInwardsKernelFactoryConfig())
{
var factory = (TestMacroStabilityInwardsKernelFactory)MacroStabilityInwardsKernelWrapperFactory.Instance;
WaternetKernelStub waternetKernel = factory.LastCreatedWaternetExtremeKernel;
waternetKernel.ThrowExceptionOnCalculate = true;
// Call
void Call() => new TestWaternetCalculator(input, factory).Calculate();
// Assert
var exception = Assert.Throws <WaternetCalculatorException>(Call);
Assert.IsInstanceOf <WaternetKernelWrapperException>(exception.InnerException);
Assert.AreEqual(exception.InnerException.Message, exception.Message);
}
}
public void CreateWaternet_ValidData_ReturnMacroStabilityInput()
{
// Setup
WaternetCalculatorInput input = WaternetCalculatorInputTestFactory.CreateValidCalculatorInput();
// Call
MacroStabilityInput macroStabilityInput = MacroStabilityInputCreator.CreateWaternet(input);
// Assert
LayerWithSoil[] layersWithSoil = LayerWithSoilCreator.Create(input.SoilProfile, out IDictionary <SoilLayer, LayerWithSoil> _);
CollectionAssert.AreEqual(layersWithSoil.Select(lws => lws.Soil).ToList(), macroStabilityInput.StabilityModel.Soils, new SoilComparer());
KernelInputAssert.AssertSoilProfile(SoilProfileCreator.Create(layersWithSoil),
macroStabilityInput.StabilityModel.ConstructionStages.Single().SoilProfile);
PreConstructionStage preConstructionStage = macroStabilityInput.PreprocessingInput.PreConstructionStages.Single();
KernelInputAssert.AssertSurfaceLine(SurfaceLineCreator.Create(input.SurfaceLine), preConstructionStage.SurfaceLine);
Assert.IsTrue(preConstructionStage.CreateWaternet);
KernelInputAssert.AssertWaternetCreatorInput(WaternetCreatorInputCreator.Create(input), preConstructionStage.WaternetCreatorInput);
}
