public void CreateInput_AssessmentSectionNull_ThrowsArgumentNullException()
        {
            // Call
            void Call() => CombinedAssemblyFailureMechanismSectionFactory.CreateInput(null, Enumerable.Empty <IFailureMechanism>());

            // Assert
            var exception = Assert.Throws <ArgumentNullException>(Call);

            Assert.AreEqual("assessmentSection", exception.ParamName);
        }
        public void CreateInput_FailureMechanismsNull_ThrowsArgumentNullException()
        {
            // Setup
            var assessmentSection = new AssessmentSection(new Random(21).NextEnumValue <AssessmentSectionComposition>());

            // Call
            void Call() => CombinedAssemblyFailureMechanismSectionFactory.CreateInput(assessmentSection, null);

            // Assert
            var exception = Assert.Throws <ArgumentNullException>(Call);

            Assert.AreEqual("failureMechanisms", exception.ParamName);
        }
        public void CreateInput_WithAllFailureMechanisms_ReturnsInputCollection()
        {
            // Setup
            var random = new Random(21);
            AssessmentSection assessmentSection = TestDataGenerator.GetAssessmentSectionWithAllFailureMechanismSectionsAndResults(
                random.NextEnumValue <AssessmentSectionComposition>());

            using (new AssemblyToolCalculatorFactoryConfig())
            {
                var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance;
                FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator;

                // Call
                IEnumerable <IEnumerable <CombinedAssemblyFailureMechanismSection> > inputs = CombinedAssemblyFailureMechanismSectionFactory.CreateInput(
                    assessmentSection, assessmentSection.GetFailureMechanisms().Concat(assessmentSection.SpecificFailureMechanisms));

                // Assert
                int expectedNrOfGeneralSectionResults  = assessmentSection.GetFailureMechanisms().Count();
                int expectedNrOfSpecificSectionResults = assessmentSection.SpecificFailureMechanisms.Count;
                Assert.AreEqual(expectedNrOfGeneralSectionResults + expectedNrOfSpecificSectionResults, inputs.Count());

                FailureMechanismSectionAssemblyResult assemblyResult = calculator.FailureMechanismSectionAssemblyResultOutput.AssemblyResult;
                AssertSectionsWithResult(assessmentSection.Piping.SectionResults, assemblyResult.FailureMechanismSectionAssemblyGroup, inputs.ElementAt(0));
                AssertSectionsWithResult(assessmentSection.GrassCoverErosionInwards.SectionResults, assemblyResult.FailureMechanismSectionAssemblyGroup, inputs.ElementAt(1));
                AssertSectionsWithResult(assessmentSection.MacroStabilityInwards.SectionResults, assemblyResult.FailureMechanismSectionAssemblyGroup, inputs.ElementAt(2));
                AssertSectionsWithResult(assessmentSection.Microstability.SectionResults, assemblyResult.FailureMechanismSectionAssemblyGroup, inputs.ElementAt(3));
                AssertSectionsWithResult(assessmentSection.StabilityStoneCover.SectionResults, assemblyResult.FailureMechanismSectionAssemblyGroup, inputs.ElementAt(4));
                AssertSectionsWithResult(assessmentSection.WaveImpactAsphaltCover.SectionResults, assemblyResult.FailureMechanismSectionAssemblyGroup, inputs.ElementAt(5));
                AssertSectionsWithResult(assessmentSection.WaterPressureAsphaltCover.SectionResults, assemblyResult.FailureMechanismSectionAssemblyGroup, inputs.ElementAt(6));
                AssertSectionsWithResult(assessmentSection.GrassCoverErosionOutwards.SectionResults, assemblyResult.FailureMechanismSectionAssemblyGroup, inputs.ElementAt(7));
                AssertSectionsWithResult(assessmentSection.GrassCoverSlipOffOutwards.SectionResults, assemblyResult.FailureMechanismSectionAssemblyGroup, inputs.ElementAt(8));
                AssertSectionsWithResult(assessmentSection.GrassCoverSlipOffInwards.SectionResults, assemblyResult.FailureMechanismSectionAssemblyGroup, inputs.ElementAt(9));
                AssertSectionsWithResult(assessmentSection.HeightStructures.SectionResults, assemblyResult.FailureMechanismSectionAssemblyGroup, inputs.ElementAt(10));
                AssertSectionsWithResult(assessmentSection.ClosingStructures.SectionResults, assemblyResult.FailureMechanismSectionAssemblyGroup, inputs.ElementAt(11));
                AssertSectionsWithResult(assessmentSection.PipingStructure.SectionResults, assemblyResult.FailureMechanismSectionAssemblyGroup, inputs.ElementAt(12));
                AssertSectionsWithResult(assessmentSection.StabilityPointStructures.SectionResults, assemblyResult.FailureMechanismSectionAssemblyGroup, inputs.ElementAt(13));
                AssertSectionsWithResult(assessmentSection.DuneErosion.SectionResults, assemblyResult.FailureMechanismSectionAssemblyGroup, inputs.ElementAt(14));
                for (var i = 0; i < expectedNrOfSpecificSectionResults; i++)
                {
                    AssertSectionsWithResult(assessmentSection.SpecificFailureMechanisms[i].SectionResults, assemblyResult.FailureMechanismSectionAssemblyGroup,
                                             inputs.ElementAt(expectedNrOfGeneralSectionResults + i));
                }
            }
        }
        public void CreateInput_WithOneFailureMechanism_ReturnsInputCollection(AssessmentSection assessmentSection, IFailureMechanism failureMechanismInAssembly)
        {
            // Setup
            assessmentSection.GetFailureMechanisms()
            .ForEachElementDo(failureMechanism => failureMechanism.InAssembly = failureMechanism == failureMechanismInAssembly);

            using (new AssemblyToolCalculatorFactoryConfig())
            {
                // Call
                IEnumerable <IEnumerable <CombinedAssemblyFailureMechanismSection> > inputs = CombinedAssemblyFailureMechanismSectionFactory.CreateInput(
                    assessmentSection, new[]
                {
                    failureMechanismInAssembly
                });

                // Assert
                IObservableEnumerable <FailureMechanismSectionResult> failureMechanismSectionResults = ((IFailureMechanism <FailureMechanismSectionResult>)failureMechanismInAssembly).SectionResults;
                AssertSections(failureMechanismSectionResults, inputs.Single());
            }
        }
Exemplo n.º 5
0
        public void AssembleCombinedPerFailureMechanismSection_WithAssessmentSection_SetsInputOnCalculator(bool failureMechanismSectionAssemblyThrowsException)
        {
            var random = new Random(21);
            AssessmentSection assessmentSection = TestDataGenerator.GetAssessmentSectionWithAllFailureMechanismSectionsAndResults(
                random.NextEnumValue <AssessmentSectionComposition>());

            using (new AssemblyToolCalculatorFactoryConfig())
            {
                var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance;
                FailureMechanismSectionAssemblyCalculatorStub failureMechanismSectionAssemblyCalculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator;
                failureMechanismSectionAssemblyCalculator.ThrowExceptionOnCalculate = failureMechanismSectionAssemblyThrowsException;

                // Call
                AssessmentSectionAssemblyFactory.AssembleCombinedPerFailureMechanismSection(assessmentSection);

                // Assert
                AssessmentSectionAssemblyCalculatorStub assessmentSectionAssemblyCalculator = calculatorFactory.LastCreatedAssessmentSectionAssemblyCalculator;
                IEnumerable <CombinedAssemblyFailureMechanismSection>[] actualInput         = assessmentSectionAssemblyCalculator.CombinedFailureMechanismSectionsInput.ToArray();
                IEnumerable <CombinedAssemblyFailureMechanismSection>[] expectedInput       = CombinedAssemblyFailureMechanismSectionFactory.CreateInput(
                    assessmentSection, assessmentSection.GetFailureMechanisms().Concat(assessmentSection.SpecificFailureMechanisms)).ToArray();
                Assert.AreEqual(expectedInput.Length, actualInput.Length);

                for (var i = 0; i < expectedInput.Length; i++)
                {
                    CombinedAssemblyFailureMechanismSection[] actualSections   = actualInput[i].ToArray();
                    CombinedAssemblyFailureMechanismSection[] expectedSections = expectedInput[i].ToArray();
                    Assert.AreEqual(expectedSections.Length, actualSections.Length);

                    for (var j = 0; j < expectedSections.Length; j++)
                    {
                        Assert.AreEqual(expectedSections[j].SectionStart, actualSections[j].SectionStart);
                        Assert.AreEqual(expectedSections[j].SectionEnd, actualSections[j].SectionEnd);
                        Assert.AreEqual(expectedSections[j].FailureMechanismSectionAssemblyGroup, actualSections[j].FailureMechanismSectionAssemblyGroup);
                    }
                }
            }
        }