public void Constructor_ExpectedValues()
{
// Setup
var mockRepository = new MockRepository();
var handler = mockRepository.Stub <IObservablePropertyChangeHandler>();
var assessmentSection = mockRepository.Stub <IAssessmentSection>();
mockRepository.ReplayAll();
var calculation = new GrassCoverErosionOutwardsWaveConditionsCalculation();
var context = new GrassCoverErosionOutwardsWaveConditionsInputContext(
calculation.InputParameters,
calculation,
assessmentSection,
Enumerable.Empty <ForeshoreProfile>());
// Call
var properties = new GrassCoverErosionOutwardsWaveConditionsInputContextProperties(
context, AssessmentSectionTestHelper.GetTestAssessmentLevel, handler);
// Assert
Assert.IsInstanceOf <WaveConditionsInputContextProperties <
GrassCoverErosionOutwardsWaveConditionsInputContext,
GrassCoverErosionOutwardsWaveConditionsInput,
GrassCoverErosionOutwardsWaveConditionsCalculationType> >(properties);
Assert.AreSame(context, properties.Data);
Assert.AreEqual(calculation.InputParameters.CalculationType, properties.RevetmentType);
mockRepository.VerifyAll();
}
public void Read_EntityWithNullValues_ReturnCalculationWithNaNValues()
{
// Setup
var entity = new GrassCoverErosionOutwardsWaveConditionsCalculationEntity();
var collector = new ReadConversionCollector();
// Call
GrassCoverErosionOutwardsWaveConditionsCalculation calculation = entity.Read(collector);
// Assert
Assert.IsNull(calculation.Name);
Assert.IsNull(calculation.Comments.Body);
GrassCoverErosionOutwardsWaveConditionsInput calculationInput = calculation.InputParameters;
Assert.IsNaN(calculationInput.BreakWater.Height);
Assert.IsNaN(calculationInput.Orientation);
Assert.IsNaN(calculationInput.UpperBoundaryRevetment);
Assert.IsNaN(calculationInput.LowerBoundaryRevetment);
Assert.IsNaN(calculationInput.UpperBoundaryWaterLevels);
Assert.IsNaN(calculationInput.LowerBoundaryWaterLevels);
Assert.IsNull(calculationInput.HydraulicBoundaryLocation);
Assert.IsNull(calculationInput.ForeshoreProfile);
Assert.IsNull(calculation.Output);
}
public DerivedGrassCoverErosionOutwardsWaveConditionsCalculationContext(GrassCoverErosionOutwardsWaveConditionsCalculation calculation,
CalculationGroup parent,
GrassCoverErosionOutwardsFailureMechanism failureMechanism,
IAssessmentSection assessmentSection)
: base(calculation, parent, failureMechanism, assessmentSection)
{
}
public void Create_HasCalculationOutputWithWaveImpactWithWaveDirection_EntityHasCalculationOutputEntity()
{
// Setup
var registry = new PersistenceRegistry();
var calculation = new GrassCoverErosionOutwardsWaveConditionsCalculation
{
Output = GrassCoverErosionOutwardsWaveConditionsOutputFactory.CreateOutputWithWaveImpactWithWaveDirection(
new[]
{
new TestWaveConditionsOutput(),
new TestWaveConditionsOutput()
})
};
// Call
GrassCoverErosionOutwardsWaveConditionsCalculationEntity entity = calculation.Create(registry, 0);
// Assert
ICollection <GrassCoverErosionOutwardsWaveConditionsOutputEntity> outputEntities = entity.GrassCoverErosionOutwardsWaveConditionsOutputEntities;
Assert.AreEqual(2, outputEntities.Count);
CollectionAssert.AreEqual(new[]
{
0,
1
}, outputEntities.Select(oe => oe.Order));
Assert.IsTrue(outputEntities.All(oe => oe.OutputType == Convert.ToByte(GrassCoverErosionOutwardsWaveConditionsOutputType.WaveImpactWithWaveDirection)));
}
public void Cancel_WhenPerformingCalculation_CurrentCalculationForWaterLevelCompletesAndSubsequentCalculationsDidNotRun()
{
// Setup
AssessmentSectionStub assessmentSection = CreateAssessmentSection();
ConfigureAssessmentSectionWithHydraulicBoundaryOutput(assessmentSection);
GrassCoverErosionOutwardsWaveConditionsCalculation calculation = CreateValidCalculation(assessmentSection.HydraulicBoundaryDatabase.Locations.First());
var failureMechanism = new GrassCoverErosionOutwardsFailureMechanism();
CalculatableActivity activity = GrassCoverErosionOutwardsCalculationActivityFactory.CreateWaveConditionsCalculationActivity(calculation,
failureMechanism,
assessmentSection);
var mockRepository = new MockRepository();
var calculatorFactory = mockRepository.StrictMock <IHydraRingCalculatorFactory>();
calculatorFactory.Expect(cf => cf.CreateWaveConditionsCosineCalculator(null))
.IgnoreArguments()
.Return(new TestWaveConditionsCosineCalculator());
mockRepository.ReplayAll();
using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
{
activity.ProgressChanged += (sender, args) =>
{
if (activity.State != ActivityState.Canceled)
{
// Call
activity.Cancel();
}
};
// Assert
TestHelper.AssertLogMessages(() => activity.Run(), messages =>
{
string[] msgs = messages.ToArray();
RoundedDouble firstWaterLevel = GetWaterLevels(calculation, assessmentSection).First();
Assert.AreEqual(10, msgs.Length);
Assert.AreEqual($"Golfcondities berekenen voor '{calculation.Name}' is gestart.", msgs[0]);
CalculationServiceTestHelper.AssertValidationStartMessage(msgs[1]);
CalculationServiceTestHelper.AssertValidationEndMessage(msgs[2]);
CalculationServiceTestHelper.AssertCalculationStartMessage(msgs[3]);
Assert.AreEqual("Berekening voor golfoploop is gestart.", msgs[4]);
Assert.AreEqual($"Berekening voor waterstand '{firstWaterLevel}' is gestart.", msgs[5]);
StringAssert.StartsWith("Golfcondities berekening is uitgevoerd op de tijdelijke locatie", msgs[6]);
Assert.AreEqual($"Berekening voor waterstand '{firstWaterLevel}' is beëindigd.", msgs[7]);
Assert.AreEqual("Berekening voor golfoploop is beëindigd.", msgs[8]);
CalculationServiceTestHelper.AssertCalculationEndMessage(msgs[9]);
});
Assert.AreEqual(ActivityState.Canceled, activity.State);
Assert.IsNull(calculation.Output);
}
mockRepository.VerifyAll();
}
/// <summary>
/// Reads the <see cref="GrassCoverErosionInwardsCalculationEntity"/> and use the
/// information to update a <see cref="GrassCoverErosionOutwardsWaveConditionsCalculation"/>.
/// </summary>
/// <param name="entity">The <see cref="GrassCoverErosionInwardsCalculationEntity"/>
/// to create <see cref="GrassCoverErosionOutwardsWaveConditionsCalculation"/> for.</param>
/// <param name="collector">The object keeping track of read operations.</param>
/// <returns>A new <see cref="GrassCoverErosionOutwardsWaveConditionsCalculation"/>.</returns>
/// <exception cref="ArgumentNullException">Thrown when any parameter is <c>null</c>.</exception>
internal static GrassCoverErosionOutwardsWaveConditionsCalculation Read(this GrassCoverErosionOutwardsWaveConditionsCalculationEntity entity,
ReadConversionCollector collector)
{
if (entity == null)
{
throw new ArgumentNullException(nameof(entity));
}
if (collector == null)
{
throw new ArgumentNullException(nameof(collector));
}
var calculation = new GrassCoverErosionOutwardsWaveConditionsCalculation
{
Name = entity.Name,
Comments =
{
Body = entity.Comments
}
};
ReadCalculationInputs(calculation.InputParameters, entity, collector);
ReadCalculationOutputs(calculation, entity);
return(calculation);
}
public void Constructor_Always_PropertiesHaveExpectedAttributesValues()
{
// Setup
var mocks = new MockRepository();
var assessmentSection = mocks.Stub <IAssessmentSection>();
var handler = mocks.Stub <IObservablePropertyChangeHandler>();
mocks.ReplayAll();
var calculation = new GrassCoverErosionOutwardsWaveConditionsCalculation();
var context = new GrassCoverErosionOutwardsWaveConditionsInputContext(
calculation.InputParameters,
calculation,
assessmentSection,
Enumerable.Empty <ForeshoreProfile>());
// Call
var properties = new GrassCoverErosionOutwardsWaveConditionsInputContextProperties(
context, AssessmentSectionTestHelper.GetTestAssessmentLevel, handler);
// Assert
PropertyDescriptorCollection dynamicProperties = PropertiesTestHelper.GetAllVisiblePropertyDescriptors(properties);
Assert.AreEqual(16, dynamicProperties.Count);
PropertyDescriptor revetmentTypeProperty = dynamicProperties[10];
Assert.IsInstanceOf <EnumTypeConverter>(revetmentTypeProperty.Converter);
PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(revetmentTypeProperty,
"Modelinstellingen",
"Type bekleding",
"Het type van de bekleding waarvoor berekend wordt.");
mocks.VerifyAll();
}
public void CreateCalculationActivity_WithValidCalculation_ReturnsGrassCoverErosionOutwardsWaveConditionsCalculationActivityWithParametersSet()
{
// Setup
GrassCoverErosionOutwardsFailureMechanism failureMechanism = new GrassCoverErosionOutwardsFailureMechanism();
var assessmentSection = new AssessmentSectionStub();
HydraulicBoundaryDatabase hydraulicBoundaryDatabase = assessmentSection.HydraulicBoundaryDatabase;
hydraulicBoundaryDatabase.FilePath = validFilePath;
var hydraulicBoundaryLocation = new TestHydraulicBoundaryLocation("locationName 1");
assessmentSection.SetHydraulicBoundaryLocationCalculations(new[]
{
hydraulicBoundaryLocation
}, true);
GrassCoverErosionOutwardsWaveConditionsCalculation calculation = CreateValidCalculation(hydraulicBoundaryLocation);
// Call
CalculatableActivity activity = GrassCoverErosionOutwardsCalculationActivityFactory.CreateWaveConditionsCalculationActivity(calculation,
failureMechanism,
assessmentSection);
// Assert
Assert.IsInstanceOf <GrassCoverErosionOutwardsWaveConditionsCalculationActivity>(activity);
AssertGrassCoverErosionOutwardsWaveConditionsCalculationActivity(
activity,
calculation,
assessmentSection.WaterLevelCalculationsForSignalFloodingProbability.Single().Output.Result,
hydraulicBoundaryDatabase);
}
private static void ReadCalculationOutputs(GrassCoverErosionOutwardsWaveConditionsCalculation calculation,
GrassCoverErosionOutwardsWaveConditionsCalculationEntity entity)
{
if (!entity.GrassCoverErosionOutwardsWaveConditionsOutputEntities.Any())
{
return;
}
var waveRunUpOutput = new List <WaveConditionsOutput>();
var waveImpactOutput = new List <WaveConditionsOutput>();
var waveImpactWithWaveDirectionOutput = new List <WaveConditionsOutput>();
foreach (GrassCoverErosionOutwardsWaveConditionsOutputEntity outputEntity in
entity.GrassCoverErosionOutwardsWaveConditionsOutputEntities.OrderBy(e => e.Order))
{
if (outputEntity.OutputType == Convert.ToByte(GrassCoverErosionOutwardsWaveConditionsOutputType.WaveRunUp))
{
waveRunUpOutput.Add(outputEntity.Read());
}
if (outputEntity.OutputType == Convert.ToByte(GrassCoverErosionOutwardsWaveConditionsOutputType.WaveImpact))
{
waveImpactOutput.Add(outputEntity.Read());
}
if (outputEntity.OutputType == Convert.ToByte(GrassCoverErosionOutwardsWaveConditionsOutputType.WaveImpactWithWaveDirection))
{
waveImpactWithWaveDirectionOutput.Add(outputEntity.Read());
}
}
calculation.Output = CreateGrassCoverErosionOutwardsWaveConditionsOutput(waveRunUpOutput, waveImpactOutput, waveImpactWithWaveDirectionOutput);
}
public void RevetmentType_SetNewValue_InputChangedAndObservablesNotified()
{
// Setup
var random = new Random(21);
var mocks = new MockRepository();
var assessmentSection = mocks.Stub <IAssessmentSection>();
var observable = mocks.StrictMock <IObservable>();
observable.Expect(o => o.NotifyObservers());
mocks.ReplayAll();
var customHandler = new SetPropertyValueAfterConfirmationParameterTester(new[]
{
observable
});
var calculation = new GrassCoverErosionOutwardsWaveConditionsCalculation();
var context = new GrassCoverErosionOutwardsWaveConditionsInputContext(
calculation.InputParameters,
calculation,
assessmentSection,
Enumerable.Empty <ForeshoreProfile>());
var properties = new GrassCoverErosionOutwardsWaveConditionsInputContextProperties(
context, AssessmentSectionTestHelper.GetTestAssessmentLevel, customHandler);
// Call
properties.RevetmentType = random.NextEnumValue <GrassCoverErosionOutwardsWaveConditionsCalculationType>();
// Assert
Assert.IsTrue(customHandler.Called);
mocks.VerifyAll();
}
public void CreateInstance_WithContextThatHasInputWithSpecificWaterLevelType_ExpectedProperties(
IAssessmentSection assessmentSection,
Action <WaveConditionsInput> configureInputAction,
RoundedDouble expectedAssessmentLevel)
{
// Setup
var calculation = new GrassCoverErosionOutwardsWaveConditionsCalculation();
configureInputAction(calculation.InputParameters);
var context = new GrassCoverErosionOutwardsWaveConditionsInputContext(calculation.InputParameters,
calculation,
assessmentSection,
Enumerable.Empty <ForeshoreProfile>());
using (var plugin = new GrassCoverErosionOutwardsPlugin())
{
PropertyInfo info = GetInfo(plugin);
// Call
IObjectProperties objectProperties = info.CreateInstance(context);
// Assert
Assert.IsInstanceOf <GrassCoverErosionOutwardsWaveConditionsInputContextProperties>(objectProperties);
Assert.AreSame(context, objectProperties.Data);
Assert.AreEqual(expectedAssessmentLevel, ((GrassCoverErosionOutwardsWaveConditionsInputContextProperties)objectProperties).AssessmentLevel);
}
}
public void IsEnabled_CalculationWithOrWithoutOutput_ReturnExpectedEnabledState(bool hasOutput)
{
// Setup
var assessmentSection = mocks.Stub <IAssessmentSection>();
mocks.ReplayAll();
var failureMechanism = new GrassCoverErosionOutwardsFailureMechanism();
var calculationGroup = new CalculationGroup();
var calculation = new GrassCoverErosionOutwardsWaveConditionsCalculation();
if (hasOutput)
{
calculation.Output = GrassCoverErosionOutwardsWaveConditionsOutputTestFactory.Create();
}
calculationGroup.Children.Add(calculation);
var context = new GrassCoverErosionOutwardsCalculationGroupContext(calculationGroup, null, failureMechanism, assessmentSection);
// Call
bool isEnabled = info.IsEnabled(context);
// Assert
Assert.AreEqual(hasOutput, isEnabled);
}
public void Create_HasHydraulicLocationCalculationsForTargetProbability_EntityHasHydraulicLocationCalculationForTargetProbabilityCollectionEntity()
{
// Setup
var random = new Random(21);
var hydraulicCalculations = new HydraulicBoundaryLocationCalculationsForTargetProbability(random.NextDouble(0, 0.1));
var hydraulicCalculationsEntity = new HydraulicLocationCalculationForTargetProbabilityCollectionEntity();
var registry = new PersistenceRegistry();
registry.Register(hydraulicCalculationsEntity, hydraulicCalculations);
var calculation = new GrassCoverErosionOutwardsWaveConditionsCalculation
{
InputParameters =
{
CalculationsTargetProbability = hydraulicCalculations
}
};
// Call
GrassCoverErosionOutwardsWaveConditionsCalculationEntity entity = calculation.Create(registry, 0);
// Assert
Assert.AreSame(hydraulicCalculationsEntity, entity.HydraulicLocationCalculationForTargetProbabilityCollectionEntity);
}
public void CreateCalculationFeatures_GivenCalculations_ReturnsCalculationFeaturesCollection()
{
// Setup
var calculationA = new GrassCoverErosionOutwardsWaveConditionsCalculation();
var calculationB = new GrassCoverErosionOutwardsWaveConditionsCalculation();
calculationA.InputParameters.ForeshoreProfile = new TestForeshoreProfile(new Point2D(1.0, 3.0));
calculationB.InputParameters.ForeshoreProfile = new TestForeshoreProfile(new Point2D(1.0, 4.0));
calculationA.InputParameters.HydraulicBoundaryLocation = new HydraulicBoundaryLocation(1, string.Empty, 5.0, 4.0);
calculationB.InputParameters.HydraulicBoundaryLocation = new HydraulicBoundaryLocation(1, string.Empty, 2.2, 3.8);
// Call
IEnumerable <MapFeature> features = GrassCoverErosionOutwardsMapDataFeaturesFactory.CreateCalculationFeatures(new[]
{
calculationA,
calculationB
});
// Assert
Assert.AreEqual(2, features.Count());
Assert.AreEqual(1, features.ElementAt(0).MapGeometries.Count());
Assert.AreEqual(1, features.ElementAt(1).MapGeometries.Count());
AssertEqualPointCollections(new[]
{
new Point2D(1.0, 3.0),
new Point2D(5.0, 4.0)
}, features.ElementAt(0).MapGeometries.ElementAt(0));
AssertEqualPointCollections(new[]
{
new Point2D(1.0, 4.0),
new Point2D(2.2, 3.8)
}, features.ElementAt(1).MapGeometries.ElementAt(0));
}
public void Create_CalculationWithNaNProperties_ReturnCalculationEntity()
{
// Setup
var calculation = new GrassCoverErosionOutwardsWaveConditionsCalculation
{
InputParameters =
{
Orientation = RoundedDouble.NaN,
UpperBoundaryRevetment = RoundedDouble.NaN,
LowerBoundaryRevetment = RoundedDouble.NaN,
UpperBoundaryWaterLevels = RoundedDouble.NaN,
LowerBoundaryWaterLevels = RoundedDouble.NaN,
BreakWater =
{
Height = RoundedDouble.NaN
}
}
};
var registry = new PersistenceRegistry();
// Call
GrassCoverErosionOutwardsWaveConditionsCalculationEntity entity = calculation.Create(registry, 1234);
// Assert
Assert.IsNull(entity.Orientation);
Assert.IsNull(entity.UpperBoundaryRevetment);
Assert.IsNull(entity.LowerBoundaryRevetment);
Assert.IsNull(entity.UpperBoundaryWaterLevels);
Assert.IsNull(entity.LowerBoundaryWaterLevels);
Assert.IsNull(entity.BreakWaterHeight);
}
/// <summary>
/// Method that asserts whether <paramref name="original"/> and <paramref name="clone"/>
/// are clones.
/// </summary>
/// <param name="original">The original object.</param>
/// <param name="clone">The cloned object.</param>
/// <exception cref="AssertionException">Thrown when <paramref name="original"/> and
/// <paramref name="clone"/> are not clones.</exception>
public static void AreClones(GrassCoverErosionOutwardsWaveConditionsCalculation original, GrassCoverErosionOutwardsWaveConditionsCalculation clone)
{
Assert.AreEqual(original.Name, clone.Name);
CoreCloneAssert.AreObjectClones(original.Comments, clone.Comments, CommonCloneAssert.AreClones);
CoreCloneAssert.AreObjectClones(original.InputParameters, clone.InputParameters, AreClones);
CoreCloneAssert.AreObjectClones(original.Output, clone.Output, AreClones);
}
public void CreateInstance_GrassCoverErosionOutwardsWaveConditionsInputContext_ReturnViewWithStylingApplied()
{
// Setup
var calculation = new GrassCoverErosionOutwardsWaveConditionsCalculation();
var context = new GrassCoverErosionOutwardsWaveConditionsInputContext(
new GrassCoverErosionOutwardsWaveConditionsInput(),
calculation,
new AssessmentSectionStub(),
Enumerable.Empty <ForeshoreProfile>());
// Call
var view = (WaveConditionsInputView)info.CreateInstance(context);
// Assert
ChartDataCollection chartData = view.Chart.Data;
var lowerBoundaryRevetmentChartData = (ChartLineData)chartData.Collection.ElementAt(lowerBoundaryRevetmentChartDataIndex);
var upperBoundaryRevetmentChartData = (ChartLineData)chartData.Collection.ElementAt(upperBoundaryRevetmentChartDataIndex);
var revetmentBaseChartData = (ChartLineData)chartData.Collection.ElementAt(revetmentBaseChartDataIndex);
var revetmentChartData = (ChartLineData)chartData.Collection.ElementAt(revetmentChartDataIndex);
Color revetmentLineColor = Color.Green;
Assert.AreEqual(revetmentLineColor, lowerBoundaryRevetmentChartData.Style.Color);
Assert.AreEqual(revetmentLineColor, upperBoundaryRevetmentChartData.Style.Color);
Assert.AreEqual(Color.FromArgb(120, revetmentLineColor), revetmentBaseChartData.Style.Color);
Assert.AreEqual(revetmentLineColor, revetmentChartData.Style.Color);
}
public void CreateInstance_WithContextThatHasInputWithSpecificWaterLevelType_ReturnViewWithCorrespondingAssessmentLevel(
IAssessmentSection assessmentSection,
Action <WaveConditionsInput> configureInputAction,
RoundedDouble expectedAssessmentLevel)
{
// Setup
var calculation = new GrassCoverErosionOutwardsWaveConditionsCalculation();
configureInputAction(calculation.InputParameters);
var context = new GrassCoverErosionOutwardsWaveConditionsInputContext(
calculation.InputParameters,
calculation,
assessmentSection,
Enumerable.Empty <ForeshoreProfile>());
// Call
var view = (WaveConditionsInputView)info.CreateInstance(context);
// Assert
ChartDataCollection chartData = view.Chart.Data;
var designWaterLevelChartData = (ChartLineData)chartData.Collection.ElementAt(designWaterLevelChartDataIndex);
if (expectedAssessmentLevel != RoundedDouble.NaN)
{
Assert.AreEqual(expectedAssessmentLevel, designWaterLevelChartData.Points.First().Y);
}
else
{
Assert.IsEmpty(designWaterLevelChartData.Points);
}
}
private static void Validate(GrassCoverErosionOutwardsWaveConditionsCalculationContext context)
{
IAssessmentSection assessmentSection = context.AssessmentSection;
GrassCoverErosionOutwardsWaveConditionsCalculation calculation = context.WrappedData;
WaveConditionsCalculationServiceBase.Validate(calculation.InputParameters,
WaveConditionsInputHelper.GetAssessmentLevel(calculation.InputParameters, assessmentSection),
assessmentSection.HydraulicBoundaryDatabase);
}
private IEnumerable <WaveConditionsOutput> CalculateWaveImpact(GrassCoverErosionOutwardsWaveConditionsCalculation calculation,
GrassCoverErosionOutwardsFailureMechanism failureMechanism,
HydraulicBoundaryDatabase hydraulicBoundaryDatabase,
RoundedDouble assessmentLevel,
double targetProbability)
{
return(Calculate(calculation, hydraulicBoundaryDatabase, targetProbability, assessmentLevel,
failureMechanism.GeneralInput.GeneralWaveImpactWaveConditionsInput,
Resources.GrassCoverErosionOutwardsWaveConditions_WaveImpact_DisplayName));
}
private static void SetOutputEntities(GrassCoverErosionOutwardsWaveConditionsCalculationEntity entity,
GrassCoverErosionOutwardsWaveConditionsCalculation calculation)
{
if (calculation.HasOutput)
{
var i = 0;
SetOutputEntities(entity, calculation.Output.WaveRunUpOutput, GrassCoverErosionOutwardsWaveConditionsOutputType.WaveRunUp, ref i);
SetOutputEntities(entity, calculation.Output.WaveImpactOutput, GrassCoverErosionOutwardsWaveConditionsOutputType.WaveImpact, ref i);
SetOutputEntities(entity, calculation.Output.WaveImpactWithWaveDirectionOutput, GrassCoverErosionOutwardsWaveConditionsOutputType.WaveImpactWithWaveDirection, ref i);
}
}
public void Clone_NotAllPropertiesSet_ReturnNewInstanceWithCopiedValues()
{
// Setup
var original = new GrassCoverErosionOutwardsWaveConditionsCalculation();
// Call
object clone = original.Clone();
// Assert
CoreCloneAssert.AreObjectClones(original, clone, GrassCoverErosionOutwardsCloneAssert.AreClones);
}
public void Create_PersistenceRegistryNull_ThrowArgumentNullException()
{
// Setup
var calculation = new GrassCoverErosionOutwardsWaveConditionsCalculation();
// Call
TestDelegate call = () => calculation.Create(null, 0);
// Assert
string paramName = Assert.Throws <ArgumentNullException>(call).ParamName;
Assert.AreEqual(paramName, "registry");
}
public void Clone_AllPropertiesSet_ReturnNewInstanceWithCopiedValues()
{
// Setup
GrassCoverErosionOutwardsWaveConditionsCalculation original = GrassCoverErosionOutwardsTestDataGenerator.GetRandomGrassCoverErosionOutwardsWaveConditionsCalculation();
original.Output = GrassCoverErosionOutwardsTestDataGenerator.GetRandomGrassCoverErosionOutwardsWaveConditionsOutput();
// Call
object clone = original.Clone();
// Assert
CoreCloneAssert.AreObjectClones(original, clone, GrassCoverErosionOutwardsCloneAssert.AreClones);
}
public void Constructor_AssessmentSectionNull_ThrowsArgumentNullException()
{
// Setup
var calculation = new GrassCoverErosionOutwardsWaveConditionsCalculation();
var failureMechanism = new GrassCoverErosionOutwardsFailureMechanism();
// Call
TestDelegate test = () => new GrassCoverErosionOutwardsWaveConditionsCalculationActivity(calculation, failureMechanism, null);
// Assert
var exception = Assert.Throws <ArgumentNullException>(test);
Assert.AreEqual("assessmentSection", exception.ParamName);
}
public void CreateCalculationActivity_AssessmentSectionNull_ThrowsArgumentNullException()
{
// Setup
var calculation = new GrassCoverErosionOutwardsWaveConditionsCalculation();
var failureMechanism = new GrassCoverErosionOutwardsFailureMechanism();
// Call
void Call() => GrassCoverErosionOutwardsCalculationActivityFactory.CreateWaveConditionsCalculationActivity(calculation, failureMechanism, null);
// Assert
var exception = Assert.Throws <ArgumentNullException>(Call);
Assert.AreEqual("assessmentSection", exception.ParamName);
}
public void HasOutput_OutputSet_ReturnsTrue()
{
// Setup
var calculation = new GrassCoverErosionOutwardsWaveConditionsCalculation
{
Output = GrassCoverErosionOutwardsTestDataGenerator.GetRandomGrassCoverErosionOutwardsWaveConditionsOutput()
};
// Call
bool hasOutput = calculation.HasOutput;
// Assert
Assert.IsTrue(hasOutput);
}
public void HasOutput_OutputNull_ReturnsFalse()
{
// Setup
var calculation = new GrassCoverErosionOutwardsWaveConditionsCalculation
{
Output = null
};
// Call
bool hasOutput = calculation.HasOutput;
// Assert
Assert.IsFalse(hasOutput);
}
public void ShouldCalculate_OutputSet_ReturnsFalse()
{
// Setup
var calculation = new GrassCoverErosionOutwardsWaveConditionsCalculation
{
Output = GrassCoverErosionOutwardsTestDataGenerator.GetRandomGrassCoverErosionOutwardsWaveConditionsOutput()
};
// Call
bool shouldCalculate = calculation.ShouldCalculate;
// Assert
Assert.IsFalse(shouldCalculate);
}
public void ShouldCalculate_OutputNull_ReturnsTrue()
{
// Setup
var calculation = new GrassCoverErosionOutwardsWaveConditionsCalculation
{
Output = null
};
// Call
bool shouldCalculate = calculation.ShouldCalculate;
// Assert
Assert.IsTrue(shouldCalculate);
}
