Пример #1
0
        public void Constructor_ExpectedValues()
        {
            // Setup
            var    failureMechanism = new TestFailureMechanism();
            string sourcePath       = TestHelper.GetScratchPadPath();

            var random = new Random(39);
            var probabilityAssessmentInput = new TestProbabilityAssessmentInput(random.NextDouble(), random.NextDouble());

            IEnumerable <FailureMechanismSection> sections = new[]
            {
                FailureMechanismSectionTestFactory.CreateFailureMechanismSection()
            };

            failureMechanism.SetSections(sections, sourcePath);

            // Call
            using (var properties = new FailureMechanismSectionsProbabilityAssessmentProperties(
                       failureMechanism, probabilityAssessmentInput))
            {
                // Assert
                Assert.IsInstanceOf <ObjectProperties <IFailureMechanism> >(properties);
                Assert.IsInstanceOf <IDisposable>(properties);
                Assert.AreSame(failureMechanism, properties.Data);

                TestHelper.AssertTypeConverter <FailureMechanismSectionsProperties, ExpandableArrayConverter>(
                    nameof(FailureMechanismSectionsProperties.Sections));
                Assert.AreEqual(sections.Count(), properties.Sections.Length);

                double sectionStart = 0;
                for (var i = 0; i < sections.Count(); i++)
                {
                    FailureMechanismSection section = sections.ElementAt(i);
                    FailureMechanismSectionProbabilityAssessmentProperties property = properties.Sections[i];

                    Assert.AreSame(section, property.Data);
                    Assert.AreEqual(1 + probabilityAssessmentInput.A * section.Length / probabilityAssessmentInput.B,
                                    property.N,
                                    property.N.GetAccuracy());

                    double sectionEnd = sectionStart + section.Length;
                    Assert.AreEqual(sectionStart, property.SectionStart, property.SectionStart.GetAccuracy());
                    Assert.AreEqual(sectionEnd, property.SectionEnd, property.SectionEnd.GetAccuracy());
                    sectionStart = sectionEnd;
                }

                Assert.AreEqual(sourcePath, properties.SourcePath);
            }
        }
Пример #2
0
        public void Constructor_ExpectedValues()
        {
            // Setup
            var    random       = new Random(21);
            double sectionStart = random.NextDouble();
            double sectionEnd   = random.NextDouble();

            var probabilityAssessmentInput  = new TestProbabilityAssessmentInput(0.5, 100);
            FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();

            // Call
            var properties = new FailureMechanismSectionProbabilityAssessmentProperties(section, sectionStart, sectionEnd, probabilityAssessmentInput);

            // Assert
            Assert.IsInstanceOf <FailureMechanismSectionProperties>(properties);
            Assert.AreSame(section, properties.Data);
            TestHelper.AssertTypeConverter <FailureMechanismSectionProbabilityAssessmentProperties, ExpandableObjectConverter>();

            Assert.AreEqual(2, properties.N.NumberOfDecimalPlaces);
            Assert.AreEqual(1.0, properties.N, properties.N.GetAccuracy());

            Assert.AreEqual(sectionStart, properties.SectionStart, properties.SectionStart.GetAccuracy());
            Assert.AreEqual(sectionEnd, properties.SectionEnd, properties.SectionEnd.GetAccuracy());
        }
Пример #3
0
        public void Constructor_Always_PropertiesHaveExpectedAttributesValues()
        {
            // Setup
            var probabilityAssessmentInput  = new TestProbabilityAssessmentInput(0.5, 100);
            FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();

            // Call
            var properties = new FailureMechanismSectionProbabilityAssessmentProperties(section, double.NaN, double.NaN, probabilityAssessmentInput);

            // Assert
            PropertyDescriptorCollection dynamicProperties = PropertiesTestHelper.GetAllVisiblePropertyDescriptors(properties);

            Assert.AreEqual(7, dynamicProperties.Count);

            PropertyDescriptor nameProperty = dynamicProperties[0];

            PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(nameProperty,
                                                                            "Algemeen",
                                                                            "Vaknaam",
                                                                            "De naam van het vak.",
                                                                            true);
            PropertyDescriptor sectionStartDistanceProperty = dynamicProperties[1];

            PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(sectionStartDistanceProperty,
                                                                            "Algemeen",
                                                                            "Metrering van* [m]",
                                                                            "De afstand tussen het beginpunt van het vak en het begin van het traject, gemeten langs het traject in meters (afgerond).",
                                                                            true);
            PropertyDescriptor sectionEndDistanceProperty = dynamicProperties[2];

            PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(sectionEndDistanceProperty,
                                                                            "Algemeen",
                                                                            "Metrering tot* [m]",
                                                                            "De afstand tussen het eindpunt van het vak en het begin van het traject, gemeten langs het traject in meters (afgerond).",
                                                                            true);
            PropertyDescriptor lengthProperty = dynamicProperties[3];

            PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(lengthProperty,
                                                                            "Algemeen",
                                                                            "Lengte* [m]",
                                                                            "De totale lengte van het vak in meters (afgerond).",
                                                                            true);
            PropertyDescriptor startPointProperty = dynamicProperties[4];

            PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(startPointProperty,
                                                                            "Algemeen",
                                                                            "Beginpunt",
                                                                            "Beginpunt van het vak (X-coördinaat, Y-coördinaat).",
                                                                            true);
            PropertyDescriptor endPointProperty = dynamicProperties[5];

            PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(endPointProperty,
                                                                            "Algemeen",
                                                                            "Eindpunt",
                                                                            "Eindpunt van het vak (X-coördinaat, Y-coördinaat).",
                                                                            true);

            PropertyDescriptor nProperty = dynamicProperties[6];

            PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(nProperty,
                                                                            "Algemeen",
                                                                            "Nvak* [-]",
                                                                            "Vakspecifieke waarde voor het in rekening brengen van " +
                                                                            "het lengte-effect tijdens assemblage (afgerond).",
                                                                            true);
        }