示例#1
0
        public void Constructor_WithAssemblyGroupSet_ExpectedColumnStates(FailureMechanismSectionAssemblyGroup assemblyGroup,
                                                                          Color expectedBackgroundColor)
        {
            // Setup
            var mocks         = new MockRepository();
            var errorProvider = mocks.Stub <IFailureMechanismSectionResultRowWithCalculatedProbabilityErrorProvider>();

            mocks.ReplayAll();

            FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
            var result = new AdoptableFailureMechanismSectionResult(section);

            Func <FailureMechanismSectionAssemblyResultWrapper> performAssemblyFunc = () =>
                                                                                      new FailureMechanismSectionAssemblyResultWrapper(
                FailureMechanismSectionAssemblyResultTestFactory.CreateFailureMechanismSectionAssemblyResult(assemblyGroup),
                AssemblyMethod.BOI0A1, AssemblyMethod.BOI0B1);

            // Call
            var row = new AdoptableFailureMechanismSectionResultRow(result, () => double.NaN, errorProvider,
                                                                    performAssemblyFunc, ConstructionProperties);

            // Assert
            IDictionary <int, DataGridViewColumnStateDefinition> columnStateDefinitions = row.ColumnStateDefinitions;

            DataGridViewControlColumnStateDefinitionTestHelper.AssertColumnWithColorState(
                columnStateDefinitions[ConstructionProperties.AssemblyGroupIndex], expectedBackgroundColor);

            mocks.VerifyAll();
        }
示例#2
0
        public void Constructor_AssemblyRan_ReturnsAssemblyResult()
        {
            // Setup
            var mocks         = new MockRepository();
            var errorProvider = mocks.Stub <IFailureMechanismSectionResultRowWithCalculatedProbabilityErrorProvider>();

            mocks.ReplayAll();

            FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
            var result = new AdoptableFailureMechanismSectionResult(section);

            FailureMechanismSectionAssemblyResultWrapper        assemblyResultWrapper = FailureMechanismSectionAssemblyResultWrapperTestFactory.Create();
            Func <FailureMechanismSectionAssemblyResultWrapper> performAssemblyFunc   = () => assemblyResultWrapper;

            // Call
            var row = new AdoptableFailureMechanismSectionResultRow(result, () => double.NaN, errorProvider,
                                                                    performAssemblyFunc, ConstructionProperties);

            // Assert
            var assemblyResult = assemblyResultWrapper.AssemblyResult;

            Assert.AreEqual(assemblyResult.SectionProbability, row.SectionProbability);
            Assert.AreEqual(EnumDisplayNameHelper.GetDisplayName(assemblyResult.FailureMechanismSectionAssemblyGroup),
                            row.AssemblyGroup);

            mocks.VerifyAll();
        }
示例#3
0
        public void Constructor_WithFurtherAnalysisType_ExpectedColumnStates(FailureMechanismSectionResultFurtherAnalysisType furtherAnalysisType,
                                                                             bool expectedEnabled)
        {
            // Setup
            var mocks         = new MockRepository();
            var errorProvider = mocks.Stub <IFailureMechanismSectionResultRowWithCalculatedProbabilityErrorProvider>();

            errorProvider.Stub(ep => ep.GetCalculatedProbabilityValidationError(null))
            .IgnoreArguments()
            .Return(string.Empty);
            errorProvider.Stub(ep => ep.GetManualProbabilityValidationError(double.NaN))
            .IgnoreArguments()
            .Return(string.Empty);
            mocks.ReplayAll();

            FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
            var result = new AdoptableFailureMechanismSectionResult(section)
            {
                FurtherAnalysisType = furtherAnalysisType
            };

            Func <FailureMechanismSectionAssemblyResultWrapper> performAssemblyFunc = FailureMechanismSectionAssemblyResultWrapperTestFactory.Create;

            // Call
            var row = new AdoptableFailureMechanismSectionResultRow(result, () => double.NaN, errorProvider,
                                                                    performAssemblyFunc, ConstructionProperties);

            // Assert
            IDictionary <int, DataGridViewColumnStateDefinition> columnStateDefinitions = row.ColumnStateDefinitions;

            DataGridViewControlColumnStateDefinitionTestHelper.AssertColumnState(
                columnStateDefinitions[ConstructionProperties.RefinedSectionProbabilityIndex], expectedEnabled);

            mocks.VerifyAll();
        }
示例#4
0
        public void Constructor_Always_ExpectedColumnStates()
        {
            // Setup
            var mocks         = new MockRepository();
            var errorProvider = mocks.Stub <IFailureMechanismSectionResultRowWithCalculatedProbabilityErrorProvider>();

            mocks.ReplayAll();

            FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
            var result = new AdoptableFailureMechanismSectionResult(section);

            Func <FailureMechanismSectionAssemblyResultWrapper> performAssemblyFunc = FailureMechanismSectionAssemblyResultWrapperTestFactory.Create;

            // Call
            var row = new AdoptableFailureMechanismSectionResultRow(result, () => double.NaN, errorProvider,
                                                                    performAssemblyFunc, ConstructionProperties);

            // Assert
            IDictionary <int, DataGridViewColumnStateDefinition> columnStateDefinitions = row.ColumnStateDefinitions;

            DataGridViewControlColumnStateDefinitionTestHelper.AssertColumnState(
                columnStateDefinitions[ConstructionProperties.SectionProbabilityIndex], true, true);

            mocks.VerifyAll();
        }
示例#5
0
        private static void Property_SetNewValue_NotifyObserversAndPropertyChanged <T>(
            Action <AdoptableFailureMechanismSectionResultRow> setPropertyAction,
            Func <AdoptableFailureMechanismSectionResult, T> assertPropertyFunc,
            T newValue)
        {
            // Setup
            var mocks         = new MockRepository();
            var errorProvider = mocks.Stub <IFailureMechanismSectionResultRowWithCalculatedProbabilityErrorProvider>();
            var observer      = mocks.StrictMock <IObserver>();

            observer.Expect(o => o.UpdateObserver());
            mocks.ReplayAll();

            FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
            var result = new AdoptableFailureMechanismSectionResult(section);

            result.Attach(observer);

            Func <FailureMechanismSectionAssemblyResultWrapper> performAssemblyFunc = FailureMechanismSectionAssemblyResultWrapperTestFactory.Create;
            var row = new AdoptableFailureMechanismSectionResultRow(result, () => double.NaN, errorProvider,
                                                                    performAssemblyFunc, ConstructionProperties);

            // Call
            setPropertyAction(row);

            // Assert
            Assert.AreEqual(newValue, assertPropertyFunc(result));

            mocks.VerifyAll();
        }
示例#6
0
        private static void ProbabilityProperty_SetInvalidValue_ThrowsArgumentOutOfRangeException(
            Action <AdoptableFailureMechanismSectionResultRow> setPropertyAction)
        {
            // Setup
            var mocks         = new MockRepository();
            var errorProvider = mocks.Stub <IFailureMechanismSectionResultRowWithCalculatedProbabilityErrorProvider>();

            mocks.ReplayAll();

            FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
            var result = new AdoptableFailureMechanismSectionResult(section);

            Func <FailureMechanismSectionAssemblyResultWrapper> performAssemblyFunc = FailureMechanismSectionAssemblyResultWrapperTestFactory.Create;

            var row = new AdoptableFailureMechanismSectionResultRow(result, () => double.NaN, errorProvider,
                                                                    performAssemblyFunc, ConstructionProperties);

            // Call
            void Call() => setPropertyAction(row);

            // Assert
            const string expectedMessage = "De waarde voor de faalkans moet in het bereik [0,0, 1,0] liggen.";

            TestHelper.AssertThrowsArgumentExceptionAndTestMessage <ArgumentOutOfRangeException>(Call, expectedMessage);

            mocks.VerifyAll();
        }
示例#7
0
        public void GivenRowWithFurtherAnalysisTypeNotExecuted_WhenErrorProviderReturnsError_ThenShowsNoError(FailureMechanismSectionResultFurtherAnalysisType furtherAnalysisType)
        {
            // Given
            var mocks         = new MockRepository();
            var errorProvider = mocks.StrictMock <IFailureMechanismSectionResultRowWithCalculatedProbabilityErrorProvider>();

            errorProvider.Stub(ep => ep.GetCalculatedProbabilityValidationError(null))
            .IgnoreArguments()
            .Return(string.Empty);
            errorProvider.Stub(ep => ep.GetManualProbabilityValidationError(double.NaN))
            .IgnoreArguments()
            .Return("error message");
            mocks.ReplayAll();

            FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
            var result = new AdoptableFailureMechanismSectionResult(section)
            {
                FurtherAnalysisType = furtherAnalysisType
            };

            Func <FailureMechanismSectionAssemblyResultWrapper> performAssemblyFunc = FailureMechanismSectionAssemblyResultWrapperTestFactory.Create;

            // When
            var row = new AdoptableFailureMechanismSectionResultRow(result, () => double.NaN, errorProvider,
                                                                    performAssemblyFunc, ConstructionProperties);

            // Then
            IDictionary <int, DataGridViewColumnStateDefinition> columnStateDefinitions = row.ColumnStateDefinitions;

            Assert.IsEmpty(columnStateDefinitions[ConstructionProperties.RefinedSectionProbabilityIndex].ErrorText);

            mocks.VerifyAll();
        }
示例#8
0
        public void GivenRowWithIsRelevantAndInitialFailureMechanismResultType_WhenErrorProviderReturnsError_ThenShowNoError(
            bool isRelevant, AdoptableInitialFailureMechanismResultType initialFailureMechanismResultType)
        {
            // Given
            var mocks         = new MockRepository();
            var errorProvider = mocks.StrictMock <IFailureMechanismSectionResultRowWithCalculatedProbabilityErrorProvider>();

            errorProvider.Stub(ep => ep.GetCalculatedProbabilityValidationError(null))
            .IgnoreArguments()
            .Return("error message");
            mocks.ReplayAll();

            FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
            var result = new AdoptableFailureMechanismSectionResult(section)
            {
                IsRelevant = isRelevant,
                InitialFailureMechanismResultType = initialFailureMechanismResultType
            };

            Func <FailureMechanismSectionAssemblyResultWrapper> performAssemblyFunc = FailureMechanismSectionAssemblyResultWrapperTestFactory.Create;

            // When
            var row = new AdoptableFailureMechanismSectionResultRow(result, () => double.NaN, errorProvider,
                                                                    performAssemblyFunc, ConstructionProperties);

            // Then
            IDictionary <int, DataGridViewColumnStateDefinition> columnStateDefinitions = row.ColumnStateDefinitions;

            Assert.AreEqual(string.Empty, columnStateDefinitions[ConstructionProperties.InitialFailureMechanismResultSectionProbabilityIndex].ErrorText);

            mocks.VerifyAll();
        }
示例#9
0
        public void GivenRowWithIsRelevantTrueAndInitialFailureMechanismResultTypeManual_WhenErrorProviderReturnsError_ThenShowError()
        {
            // Given
            var    random             = new Random(21);
            double sectionProbability = random.NextDouble();

            const string errorText     = "error";
            var          mocks         = new MockRepository();
            var          errorProvider = mocks.StrictMock <IFailureMechanismSectionResultRowWithCalculatedProbabilityErrorProvider>();

            errorProvider.Expect(ep => ep.GetManualProbabilityValidationError(sectionProbability))
            .Return(errorText);
            mocks.ReplayAll();

            FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
            var result = new AdoptableFailureMechanismSectionResult(section)
            {
                InitialFailureMechanismResultType = AdoptableInitialFailureMechanismResultType.Manual,
                ManualInitialFailureMechanismResultSectionProbability = sectionProbability
            };

            Func <FailureMechanismSectionAssemblyResultWrapper> performAssemblyFunc = FailureMechanismSectionAssemblyResultWrapperTestFactory.Create;

            // When
            var row = new AdoptableFailureMechanismSectionResultRow(result, () => double.NaN, errorProvider,
                                                                    performAssemblyFunc, ConstructionProperties);

            // Then
            IDictionary <int, DataGridViewColumnStateDefinition> columnStateDefinitions = row.ColumnStateDefinitions;

            Assert.AreEqual(errorText, columnStateDefinitions[ConstructionProperties.InitialFailureMechanismResultSectionProbabilityIndex].ErrorText);

            mocks.VerifyAll();
        }
示例#10
0
        public void GivenRowWithInitialFailureMechanismResultTypeAdopt_WhenValueChanged_ThenInitialProbabilitiesChanged(AdoptableInitialFailureMechanismResultType newValue)
        {
            // Given
            var mocks         = new MockRepository();
            var errorProvider = mocks.Stub <IFailureMechanismSectionResultRowWithCalculatedProbabilityErrorProvider>();

            mocks.ReplayAll();

            FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
            var result = new AdoptableFailureMechanismSectionResult(section);

            double sectionProbability = new Random(21).NextDouble();
            Func <FailureMechanismSectionAssemblyResultWrapper> performAssemblyFunc = FailureMechanismSectionAssemblyResultWrapperTestFactory.Create;
            var row = new AdoptableFailureMechanismSectionResultRow(result, () => sectionProbability, errorProvider,
                                                                    performAssemblyFunc, ConstructionProperties);

            // Precondition
            Assert.AreEqual(sectionProbability, row.InitialFailureMechanismResultSectionProbability);

            // When
            row.InitialFailureMechanismResultType = newValue;

            // Then
            Assert.AreEqual(result.ManualInitialFailureMechanismResultSectionProbability, row.InitialFailureMechanismResultSectionProbability);

            mocks.VerifyAll();
        }
示例#11
0
        public void GivenRowWithoutAssemblyErrors_WhenUpdatingAndAssemblyThrowsException_ThenAssemblyPropertiesSetToDefault()
        {
            // Given
            var mocks         = new MockRepository();
            var errorProvider = mocks.Stub <IFailureMechanismSectionResultRowWithCalculatedProbabilityErrorProvider>();

            mocks.ReplayAll();

            FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
            var result = new AdoptableFailureMechanismSectionResult(section);

            var nrOfCalls = 0;
            FailureMechanismSectionAssemblyResultWrapper assemblyResultWrapper = FailureMechanismSectionAssemblyResultWrapperTestFactory.Create();

            Func <FailureMechanismSectionAssemblyResultWrapper> performAssemblyFunc = () =>
            {
                if (nrOfCalls == 1)
                {
                    throw new AssemblyException();
                }

                nrOfCalls++;
                return(assemblyResultWrapper);
            };

            var row = new AdoptableFailureMechanismSectionResultRow(result, () => double.NaN, errorProvider,
                                                                    performAssemblyFunc, ConstructionProperties);

            // Precondition
            FailureMechanismSectionAssemblyResult assemblyResult = assemblyResultWrapper.AssemblyResult;

            Assert.AreEqual(assemblyResult.SectionProbability, row.SectionProbability);
            Assert.AreEqual(EnumDisplayNameHelper.GetDisplayName(assemblyResult.FailureMechanismSectionAssemblyGroup),
                            row.AssemblyGroup);

            // When
            row.InitialFailureMechanismResultType = AdoptableInitialFailureMechanismResultType.Manual;

            // Then
            var expectedAssemblyResult = new DefaultFailureMechanismSectionAssemblyResult();

            Assert.AreEqual(expectedAssemblyResult.SectionProbability, row.SectionProbability);
            Assert.AreEqual(EnumDisplayNameHelper.GetDisplayName(expectedAssemblyResult.FailureMechanismSectionAssemblyGroup),
                            row.AssemblyGroup);

            mocks.VerifyAll();
        }
示例#12
0
        public void Constructor_ExpectedValues()
        {
            // Setup
            var mocks         = new MockRepository();
            var errorProvider = mocks.Stub <IFailureMechanismSectionResultRowWithCalculatedProbabilityErrorProvider>();

            mocks.ReplayAll();

            Func <FailureMechanismSectionAssemblyResultWrapper> performAssemblyFunc = FailureMechanismSectionAssemblyResultWrapperTestFactory.Create;

            FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
            var result = new AdoptableFailureMechanismSectionResult(section);

            double initialFailureMechanismResultProbability = new Random(21).NextDouble();

            // Call
            var row = new AdoptableFailureMechanismSectionResultRow(result, () => initialFailureMechanismResultProbability, errorProvider,
                                                                    performAssemblyFunc, ConstructionProperties);

            // Assert
            Assert.IsInstanceOf <FailureMechanismSectionResultRow <AdoptableFailureMechanismSectionResult> >(row);
            Assert.AreEqual(result.IsRelevant, row.IsRelevant);
            Assert.AreEqual(result.InitialFailureMechanismResultType, row.InitialFailureMechanismResultType);
            Assert.AreEqual(initialFailureMechanismResultProbability, row.InitialFailureMechanismResultSectionProbability);
            Assert.AreEqual(result.FurtherAnalysisType, row.FurtherAnalysisType);
            Assert.AreEqual(result.RefinedSectionProbability, row.RefinedSectionProbability);

            TestHelper.AssertTypeConverter <AdoptableFailureMechanismSectionResultRow, NoProbabilityValueDoubleConverter>(
                nameof(AdoptableFailureMechanismSectionResultRow.InitialFailureMechanismResultSectionProbability));
            TestHelper.AssertTypeConverter <AdoptableFailureMechanismSectionResultRow, NoProbabilityValueDoubleConverter>(
                nameof(AdoptableFailureMechanismSectionResultRow.RefinedSectionProbability));
            TestHelper.AssertTypeConverter <AdoptableFailureMechanismSectionResultRow, NoProbabilityValueDoubleConverter>(
                nameof(AdoptableFailureMechanismSectionResultRow.SectionProbability));

            IDictionary <int, DataGridViewColumnStateDefinition> columnStateDefinitions = row.ColumnStateDefinitions;

            Assert.AreEqual(6, columnStateDefinitions.Count);

            DataGridViewControlColumnStateDefinitionTestHelper.AssertColumnStateDefinition(columnStateDefinitions, ConstructionProperties.InitialFailureMechanismResultTypeIndex);
            DataGridViewControlColumnStateDefinitionTestHelper.AssertColumnStateDefinition(columnStateDefinitions, ConstructionProperties.InitialFailureMechanismResultSectionProbabilityIndex);
            DataGridViewControlColumnStateDefinitionTestHelper.AssertColumnStateDefinition(columnStateDefinitions, ConstructionProperties.FurtherAnalysisTypeIndex);
            DataGridViewControlColumnStateDefinitionTestHelper.AssertColumnStateDefinition(columnStateDefinitions, ConstructionProperties.RefinedSectionProbabilityIndex);
            DataGridViewControlColumnStateDefinitionTestHelper.AssertColumnStateDefinition(columnStateDefinitions, ConstructionProperties.SectionProbabilityIndex);
            DataGridViewControlColumnStateDefinitionTestHelper.AssertColumnStateDefinition(columnStateDefinitions, ConstructionProperties.AssemblyGroupIndex);

            mocks.VerifyAll();
        }
示例#13
0
        public void GivenRowWithAssemblyErrors_WhenUpdatingAndAssemblyDoesNotThrowException_ThenNoErrorShown()
        {
            // Given
            var mocks         = new MockRepository();
            var errorProvider = mocks.Stub <IFailureMechanismSectionResultRowWithCalculatedProbabilityErrorProvider>();

            mocks.ReplayAll();

            FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
            var result = new AdoptableFailureMechanismSectionResult(section);

            const string errorText = "Message";
            int          nrOfCalls = 0;
            Func <FailureMechanismSectionAssemblyResultWrapper> performAssemblyFunc = () =>
            {
                if (nrOfCalls == 0)
                {
                    nrOfCalls++;
                    throw new AssemblyException(errorText);
                }

                return(FailureMechanismSectionAssemblyResultWrapperTestFactory.Create());
            };

            var row = new AdoptableFailureMechanismSectionResultRow(result, () => double.NaN, errorProvider,
                                                                    performAssemblyFunc, ConstructionProperties);

            // Precondition
            IDictionary <int, DataGridViewColumnStateDefinition> columnStateDefinitions = row.ColumnStateDefinitions;
            const string expectedErrorText = "Message";

            Assert.AreEqual(expectedErrorText, columnStateDefinitions[ConstructionProperties.SectionProbabilityIndex].ErrorText);
            Assert.AreEqual(expectedErrorText, columnStateDefinitions[ConstructionProperties.AssemblyGroupIndex].ErrorText);

            // When
            row.InitialFailureMechanismResultType = AdoptableInitialFailureMechanismResultType.Manual;

            // Then
            Assert.AreEqual(string.Empty, columnStateDefinitions[ConstructionProperties.SectionProbabilityIndex].ErrorText);
            Assert.AreEqual(string.Empty, columnStateDefinitions[ConstructionProperties.AssemblyGroupIndex].ErrorText);

            mocks.VerifyAll();
        }
示例#14
0
        public void Constructor_WithIsRelevant_ExpectedColumnStates(bool isRelevant)
        {
            // Setup
            var mocks         = new MockRepository();
            var errorProvider = mocks.Stub <IFailureMechanismSectionResultRowWithCalculatedProbabilityErrorProvider>();

            errorProvider.Stub(ep => ep.GetManualProbabilityValidationError(double.NaN))
            .Return(string.Empty);
            mocks.ReplayAll();

            FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
            var result = new AdoptableFailureMechanismSectionResult(section)
            {
                IsRelevant          = isRelevant,
                FurtherAnalysisType = FailureMechanismSectionResultFurtherAnalysisType.Executed,
                InitialFailureMechanismResultType = AdoptableInitialFailureMechanismResultType.Manual
            };

            Func <FailureMechanismSectionAssemblyResultWrapper> performAssemblyFunc = FailureMechanismSectionAssemblyResultWrapperTestFactory.Create;

            // Call
            var row = new AdoptableFailureMechanismSectionResultRow(result, () => double.NaN, errorProvider,
                                                                    performAssemblyFunc, ConstructionProperties);

            // Assert
            IDictionary <int, DataGridViewColumnStateDefinition> columnStateDefinitions = row.ColumnStateDefinitions;

            DataGridViewControlColumnStateDefinitionTestHelper.AssertColumnState(
                columnStateDefinitions[ConstructionProperties.InitialFailureMechanismResultTypeIndex], isRelevant);
            DataGridViewControlColumnStateDefinitionTestHelper.AssertColumnState(
                columnStateDefinitions[ConstructionProperties.InitialFailureMechanismResultSectionProbabilityIndex], isRelevant);
            DataGridViewControlColumnStateDefinitionTestHelper.AssertColumnState(
                columnStateDefinitions[ConstructionProperties.FurtherAnalysisTypeIndex], isRelevant);
            DataGridViewControlColumnStateDefinitionTestHelper.AssertColumnState(
                columnStateDefinitions[ConstructionProperties.RefinedSectionProbabilityIndex], isRelevant);

            mocks.VerifyAll();
        }