avpon/StructureHelper
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Change value diagram calculator

Browse Source
This commit is contained in:
Evgeny Redikultsev
2025-11-16 21:03:57 +05:00
parent f7e60e0bb3
commit 215f631bb0
170 changed files with 2108 additions and 387 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
StructureHelperTests/FunctionalTests/Ndms/Calculators/ForceCalculatorTests/RCSectionsTest.cs
View File

@@ -11,7 +11,7 @@ namespace StructureHelperTests.FunctionalTests.Ndms.Calculators.ForceCalculatorT
{
public class RCSectionsTest
{
[TestCase(0.4d, 0.6d, 0.012d, 0.025d, 2, 2, false, -0.00068471024318306586d, -0.0030411189808055242d, 0.00034289928716916179d)]
[TestCase(0.4d, 0.6d, 0.012d, 0.025d, 2, 2, false, -0.00068593466107645337d, -0.0030411189808055242d, 0.00034289928716916179d)]
public void Run_ShouldPass(double width, double height, double topDiametr, double bottomDiametr, int widthCount, int heightCount, bool isBuckling, double expectedKx, double expectedKy, double expectedEpsZ)
{
//Arrange

8
StructureHelperTests/UnitTests/MaterialTests/MaterialStrengthTest.cs
View File

@@ -14,10 +14,10 @@ namespace StructureHelperTests.UnitTests.MaterialTests
[TestCase(HeadmaterialType.Reinforcement500, CodeTypes.SP63_2018, LimitStates.ULS, CalcTerms.LongTerm, 434782608.69565225d, 434782608.69565225d)]
[TestCase(HeadmaterialType.Reinforcement500, CodeTypes.SP63_2018, LimitStates.SLS, CalcTerms.ShortTerm, 5e8d, 5e8d)]
[TestCase(HeadmaterialType.Reinforcement500, CodeTypes.SP63_2018, LimitStates.SLS, CalcTerms.ShortTerm, 5e8d, 5e8d)]
[TestCase(HeadmaterialType.Concrete40, CodeTypes.SP63_2018, LimitStates.ULS, CalcTerms.ShortTerm, 22461538.46153846d, 1395297.0017909051d)]
[TestCase(HeadmaterialType.Concrete40, CodeTypes.SP63_2018, LimitStates.ULS, CalcTerms.LongTerm, 20215384.615384616d, 1255767.3016118146d)]
[TestCase(HeadmaterialType.Concrete40, CodeTypes.SP63_2018, LimitStates.SLS, CalcTerms.ShortTerm, 29200000.0d, 2092945.5026863578d)]
[TestCase(HeadmaterialType.Concrete40, CodeTypes.SP63_2018, LimitStates.SLS, CalcTerms.LongTerm, 29200000.0d, 2092945.5026863578d)]
[TestCase(HeadmaterialType.Concrete40, CodeTypes.SP63_2018, LimitStates.ULS, CalcTerms.ShortTerm, 22199999.999999996d, 1395297.0017909051d)]
[TestCase(HeadmaterialType.Concrete40, CodeTypes.SP63_2018, LimitStates.ULS, CalcTerms.LongTerm, 19980000.0d, 1255767.3016118146d)]
[TestCase(HeadmaterialType.Concrete40, CodeTypes.SP63_2018, LimitStates.SLS, CalcTerms.ShortTerm, 28860000.0d, 2092945.5026863578d)]
[TestCase(HeadmaterialType.Concrete40, CodeTypes.SP63_2018, LimitStates.SLS, CalcTerms.LongTerm, 28860000.0d, 2092945.5026863578d)]
public void Run_ShouldPass(HeadmaterialType headmaterialType, CodeTypes code, LimitStates limitState, CalcTerms calcTerm, double expectedCompressive, double expectedTensile)
{
//Arrange

16
StructureHelperTests/UnitTests/Ndms/CheckPrimitiveCollectionLogicTests.cs
View File

@@ -6,6 +6,7 @@ using StructureHelperLogics.Models.Primitives;
using StructureHelperLogics.NdmCalculations.Primitives.Logics;
using StructureHelperLogics.NdmCalculations.Primitives;
using StructureHelperCommon.Infrastructures.Interfaces;
using StructureHelper.Models.Materials;
namespace StructureHelperTests.UnitTests.Ndms
@@ -53,9 +54,14 @@ namespace StructureHelperTests.UnitTests.Ndms
{
// Arrange
var rebarMock = new Mock<IRebarNdmPrimitive>();
var ndmElementMoq = new Mock<INdmElement>();
var headMaterialMoq = new Mock<IHeadMaterial>();
_mockHasPrimitives.Setup(x => x.Primitives).Returns(new List<INdmPrimitive> { rebarMock.Object });
_mockCheckRebarPrimitiveLogic.Setup(x => x.Check()).Returns(false);
_mockCheckRebarPrimitiveLogic.Setup(x => x.CheckResult).Returns("Rebar check failed\n");
rebarMock.Setup(x => x.NdmElement).Returns(ndmElementMoq.Object);
ndmElementMoq.Setup(x => x.HeadMaterial).Returns(headMaterialMoq.Object);
// Act
var result = _mockCheckPrimitiveCollectionLogic.Object.Check();
@@ -71,10 +77,14 @@ namespace StructureHelperTests.UnitTests.Ndms
// Arrange
var rebarMock = new Mock<IRebarNdmPrimitive>();
var hostPrimitiveMock = new Mock<INdmPrimitive>();
var ndmElementMoq = new Mock<INdmElement>();
var headMaterialMoq = new Mock<IHeadMaterial>();
rebarMock.Setup(x => x.HostPrimitive).Returns(hostPrimitiveMock.Object);
rebarMock.Setup(x => x.Name).Returns("RebarName");
hostPrimitiveMock.Setup(x => x.Name).Returns("HostPrimitiveName");
rebarMock.Setup(x => x.NdmElement).Returns(ndmElementMoq.Object);
ndmElementMoq.Setup(x => x.HeadMaterial).Returns(headMaterialMoq.Object);
_mockHasPrimitives.Setup(x => x.Primitives).Returns(new List<INdmPrimitive> { rebarMock.Object });
_mockCheckRebarPrimitiveLogic.Setup(x => x.Check()).Returns(true); // Assume rebar check passes
@@ -93,10 +103,16 @@ namespace StructureHelperTests.UnitTests.Ndms
{
// Arrange
var rebarMock = new Mock<IRebarNdmPrimitive>();
var ndmElementMoq = new Mock<INdmElement>();
var headMaterialMoq = new Mock<IHeadMaterial>();
var hostPrimitiveMock = new Mock<INdmPrimitive>();
rebarMock.Setup(x => x.HostPrimitive).Returns(hostPrimitiveMock.Object);
rebarMock.Setup(x => x.Name).Returns("RebarName");
rebarMock.Setup(x => x.NdmElement).Returns(ndmElementMoq.Object);
ndmElementMoq.Setup(x => x.HeadMaterial).Returns(headMaterialMoq.Object);
hostPrimitiveMock.Setup(x => x.NdmElement).Returns(ndmElementMoq.Object);
_mockHasPrimitives.Setup(x => x.Primitives).Returns(new List<INdmPrimitive> { rebarMock.Object, hostPrimitiveMock.Object });
_mockCheckRebarPrimitiveLogic.Setup(x => x.Check()).Returns(true);

14
StructureHelperTests/UnitTests/UpdateStrategiesTests/HasCalculatorsUpdateCloningStrategyTests.cs
View File

@@ -4,6 +4,7 @@ using StructureHelperCommon.Infrastructures.Exceptions;
using StructureHelperCommon.Infrastructures.Interfaces;
using StructureHelperCommon.Models.Calculators;
using StructureHelperLogics.NdmCalculations.Analyses.ByForces;
using StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams;
using StructureHelperLogics.NdmCalculations.Cracking;
using System;
using System.Collections.Generic;
@@ -15,26 +16,31 @@ namespace StructureHelperTests.UnitTests.UpdateStrategiesTests
[TestFixture]
public class HasCalculatorsUpdateCloningStrategyTests
{
private Mock<ICalculatorCloningStrategyContainer> _cloningStrategyContainerMoq;
private Mock<ICloningStrategy> _cloningStrategyMock;
private Mock<IUpdateStrategy<IForceCalculator>> _forceCalculatorUpdateStrategyMock;
private Mock<IUpdateStrategy<ICrackCalculator>> _crackCalculatorUpdateStrategyMock;
private Mock<IUpdateStrategy<ILimitCurvesCalculator>> _limitCurvesCalculatorUpdateStrategyMock;
private Mock<IUpdateStrategy<IValueDiagramCalculator>> _valueDiagramCalculatorUpdateStrategyMock;
private HasCalculatorsUpdateCloningStrategy _strategy;
[SetUp]
public void SetUp()
{
_cloningStrategyContainerMoq = new Mock<ICalculatorCloningStrategyContainer>();
_cloningStrategyMock = new Mock<ICloningStrategy>();
_forceCalculatorUpdateStrategyMock = new Mock<IUpdateStrategy<IForceCalculator>>();
_crackCalculatorUpdateStrategyMock = new Mock<IUpdateStrategy<ICrackCalculator>>();
_limitCurvesCalculatorUpdateStrategyMock = new Mock<IUpdateStrategy<ILimitCurvesCalculator>>();
_valueDiagramCalculatorUpdateStrategyMock = new Mock<IUpdateStrategy<IValueDiagramCalculator>>();
_cloningStrategyContainerMoq.Setup(m => m.ForceCalculatorStrategy).Returns(_forceCalculatorUpdateStrategyMock.Object);
_cloningStrategyContainerMoq.Setup(m => m.CrackCalculatorStrategy).Returns(_crackCalculatorUpdateStrategyMock.Object);
_cloningStrategyContainerMoq.Setup(m => m.LimitCurvesCalculatorStrategy).Returns(_limitCurvesCalculatorUpdateStrategyMock.Object);
_cloningStrategyContainerMoq.Setup(m => m.ValueDiagramCalculatorStrategy).Returns(_valueDiagramCalculatorUpdateStrategyMock.Object);
_strategy = new HasCalculatorsUpdateCloningStrategy(
_cloningStrategyMock.Object,
_forceCalculatorUpdateStrategyMock.Object,
_crackCalculatorUpdateStrategyMock.Object,
_limitCurvesCalculatorUpdateStrategyMock.Object
);
_cloningStrategyContainerMoq.Object);
}
[Test]

89
StructureHelperTests/UnitTests/ValueDiagramsTests/ValueDiagramCalculatorUpdateCloningStrategyTests.cs Normal file
View File

@@ -0,0 +1,89 @@
using Moq;
using NUnit.Framework;
using StructureHelperCommon.Infrastructures.Interfaces;
using StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams;
using StructureHelperLogics.NdmCalculations.Primitives;
using System;
using System.Collections.Generic;
using System.Text;
namespace StructureHelperTests.UnitTests.ValueDiagramsTests
{
using Moq;
using NUnit.Framework;
using StructureHelperCommon.Infrastructures.Exceptions;
[TestFixture]
public class ValueDiagramCalculatorUpdateCloningStrategyTests
{
private Mock<ICloningStrategy> _cloningStrategyMock;
private Mock<IUpdateStrategy<IHasForceActions>> _forcesUpdateMock;
private Mock<IUpdateStrategy<IHasPrimitives>> _primitivesUpdateMock;
private ValueDiagramCalculatorUpdateCloningStrategy _strategy;
private Mock<IValueDiagramCalculator> _sourceMock;
private Mock<IValueDiagramCalculator> _targetMock;
private Mock<IValueDiagramCalculatorInputData> _inputDataMock;
[SetUp]
public void Setup()
{
_cloningStrategyMock = new Mock<ICloningStrategy>();
_forcesUpdateMock = new Mock<IUpdateStrategy<IHasForceActions>>();
_primitivesUpdateMock = new Mock<IUpdateStrategy<IHasPrimitives>>();
_strategy = new ValueDiagramCalculatorUpdateCloningStrategy(
_cloningStrategyMock.Object,
_forcesUpdateMock.Object,
_primitivesUpdateMock.Object
);
_sourceMock = new Mock<IValueDiagramCalculator>();
_targetMock = new Mock<IValueDiagramCalculator>();
_inputDataMock = new Mock<IValueDiagramCalculatorInputData>();
// Both source and target share the same interface object type
_sourceMock.Setup(s => s.InputData).Returns(_inputDataMock.Object);
_targetMock.Setup(t => t.InputData).Returns(_inputDataMock.Object);
}
[Test]
public void Update_SourceObjectIsNull_Throws()
{
Assert.That(
() => _strategy.Update(_targetMock.Object, null),
Throws.Exception.TypeOf<StructureHelperException>()
);
}
[Test]
public void Update_TargetObjectIsNull_Throws()
{
Assert.That(
() => _strategy.Update(null, _sourceMock.Object),
Throws.Exception.TypeOf<StructureHelperException>()
);
}
[Test]
public void Update_TargetAndSourceAreSame_DoesNothing()
{
_strategy.Update(_targetMock.Object, _targetMock.Object);
_primitivesUpdateMock.Verify(p => p.Update(It.IsAny<IHasPrimitives>(), It.IsAny<IHasPrimitives>()), Times.Never);
_forcesUpdateMock.Verify(f => f.Update(It.IsAny<IHasForceActions>(), It.IsAny<IHasForceActions>()), Times.Never);
}
[Test]
public void Update_CallsPrimitivesAndForcesStrategies()
{
// Act
_strategy.Update(_targetMock.Object, _sourceMock.Object);
// Assert: Both strategies are called with the same InputData object
_primitivesUpdateMock.Verify(p => p.Update(_inputDataMock.Object, _inputDataMock.Object), Times.Once);
_forcesUpdateMock.Verify(f => f.Update(_inputDataMock.Object, _inputDataMock.Object), Times.Once);
}
}
}

120
StructureHelperTests/UnitTests/ValueDiagramsTests/ValueDiagramEntityCheckLogicTests.cs Normal file
View File

@@ -0,0 +1,120 @@
using Moq;
using NUnit.Framework;
using StructureHelperCommon.Infrastructures.Exceptions;
using StructureHelperCommon.Infrastructures.Interfaces;
using StructureHelperCommon.Models;
using StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams;
namespace StructureHelperTests.UnitTests.ValueDiagramsTests
{
[TestFixture]
public class ValueDiagramEntityCheckLogicTests
{
private Mock<ICheckEntityLogic<IValueDiagram>> _diagramCheckMock;
private Mock<IShiftTraceLogger> _loggerMock;
private ValueDiagramEntityCheckLogic _logic;
[SetUp]
public void Setup()
{
_diagramCheckMock = new Mock<ICheckEntityLogic<IValueDiagram>>();
_loggerMock = new Mock<IShiftTraceLogger>();
_logic = new ValueDiagramEntityCheckLogic(_diagramCheckMock.Object, _loggerMock.Object);
}
[Test]
public void Check_EntityIsNull_ThrowsStructureHelperException()
{
// Arrange
_logic.Entity = null;
// Act + Assert
Assert.That(
() => _logic.Check(),
Throws.Exception.TypeOf<StructureHelperException>()
);
}
[Test]
public void Check_DiagramCheckPasses_ReturnsTrue()
{
// Arrange
var entity = new Mock<IValueDiagramEntity>();
var diagram = new Mock<IValueDiagram>().Object;
entity.Setup(e => e.ValueDiagram).Returns(diagram);
entity.Setup(e => e.Name).Returns("TestDiagram");
_logic.Entity = entity.Object;
_diagramCheckMock.Setup(c => c.Check()).Returns(true);
// Act
var result = _logic.Check();
// Assert
Assert.That(result, Is.True);
_diagramCheckMock.VerifySet(c => c.Entity = diagram, Times.Once);
_diagramCheckMock.Verify(c => c.Check(), Times.Once);
_loggerMock.Verify(l => l.AddMessage(It.IsAny<string>()), Times.Never);
}
[Test]
public void Check_DiagramCheckFails_ReturnsFalse_AndLogsError()
{
// Arrange
var entity = new Mock<IValueDiagramEntity>();
var diagram = new Mock<IValueDiagram>().Object;
entity.Setup(e => e.ValueDiagram).Returns(diagram);
entity.Setup(e => e.Name).Returns("MyDiagram");
_logic.Entity = entity.Object;
_diagramCheckMock.Setup(c => c.Check()).Returns(false);
_diagramCheckMock.Setup(c => c.CheckResult).Returns("child error message");
// Act
var result = _logic.Check();
// Assert
Assert.That(result, Is.False);
_diagramCheckMock.Verify(c => c.Check(), Times.Once);
_loggerMock.Verify(
l => l.AddMessage(It.Is<string>(s => s.Contains("Diagram: MyDiagram has error: child error message"))),
Times.Once
);
}
[Test]
public void Check_EntityNameIsNull_UsesUnnamedInMessage()
{
// Arrange
var entity = new Mock<IValueDiagramEntity>();
var diagram = new Mock<IValueDiagram>().Object;
entity.Setup(e => e.ValueDiagram).Returns(diagram);
entity.Setup(e => e.Name).Returns((string)null);
_logic.Entity = entity.Object;
_diagramCheckMock.Setup(c => c.Check()).Returns(false);
_diagramCheckMock.Setup(c => c.CheckResult).Returns("xyz");
// Act
var result = _logic.Check();
// Assert
Assert.That(result, Is.False);
_loggerMock.Verify(
l => l.AddMessage(It.Is<string>(s => s.Contains("<unnamed>"))),
Times.Once
);
}
}
}

110
StructureHelperTests/UnitTests/ValueDiagramsTests/ValueDiagramUpdateStrategyTests.cs Normal file
View File

@@ -0,0 +1,110 @@
using Moq;
using NUnit.Framework;
using StructureHelperCommon.Infrastructures.Exceptions;
using StructureHelperCommon.Infrastructures.Interfaces;
using StructureHelperCommon.Models.Shapes;
using StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams;
namespace StructureHelperTests.UnitTests.ValueDiagramsTests
{
[TestFixture]
public class ValueDiagramUpdateStrategyTests
{
private Mock<IUpdateStrategy<IPoint2DRange>> _rangeUpdateMock;
private ValueDiagramUpdateStrategy _strategy;
private Mock<IValueDiagram> _targetMock;
private Mock<IValueDiagram> _sourceMock;
private Mock<IPoint2DRange> _targetRangeMock;
private Mock<IPoint2DRange> _sourceRangeMock;
[SetUp]
public void Setup()
{
_rangeUpdateMock = new Mock<IUpdateStrategy<IPoint2DRange>>();
_strategy = new ValueDiagramUpdateStrategy(_rangeUpdateMock.Object);
_targetMock = new Mock<IValueDiagram>();
_sourceMock = new Mock<IValueDiagram>();
_targetRangeMock = new Mock<IPoint2DRange>();
_sourceRangeMock = new Mock<IPoint2DRange>();
_targetMock.Setup(t => t.Point2DRange).Returns(_targetRangeMock.Object);
_sourceMock.Setup(s => s.Point2DRange).Returns(_sourceRangeMock.Object);
}
[Test]
public void Update_TargetIsNull_Throws()
{
Assert.That(
() => _strategy.Update(null, _sourceMock.Object),
Throws.Exception.TypeOf<StructureHelperException>()
);
}
[Test]
public void Update_SourceIsNull_Throws()
{
Assert.That(
() => _strategy.Update(_targetMock.Object, null),
Throws.Exception.TypeOf<StructureHelperException>()
);
}
[Test]
public void Update_TargetEqualsSource_DoesNothing()
{
_strategy.Update(_targetMock.Object, _targetMock.Object);
_rangeUpdateMock.Verify(r => r.Update(It.IsAny<IPoint2DRange>(), It.IsAny<IPoint2DRange>()), Times.Never);
}
[Test]
public void Update_CopiesStepNumber_AndCallsRangeUpdate()
{
_sourceMock.Setup(s => s.StepNumber).Returns(5);
_strategy.Update(_targetMock.Object, _sourceMock.Object);
_targetMock.VerifySet(t => t.StepNumber = 5, Times.Once);
_rangeUpdateMock.Verify(r => r.Update(_targetRangeMock.Object, _sourceRangeMock.Object), Times.Once);
}
[Test]
public void Update_LazyInitializesRangeUpdateStrategy_WhenNotProvided()
{
// Use parameterless constructor
var strategy = new ValueDiagramUpdateStrategy();
var targetMock = new Mock<IValueDiagram>();
var sourceMock = new Mock<IValueDiagram>();
var targetRangeMock = new Mock<IPoint2DRange>();
var sourceRangeMock = new Mock<IPoint2DRange>();
var pointMoq = new Mock<IPoint2D>();
targetMock.Setup(t => t.Point2DRange).Returns(targetRangeMock.Object);
sourceMock.Setup(s => s.Point2DRange).Returns(sourceRangeMock.Object);
sourceRangeMock.Setup(s => s.StartPoint).Returns(pointMoq.Object);
sourceRangeMock.Setup(s => s.EndPoint).Returns(pointMoq.Object);
targetRangeMock.Setup(s => s.StartPoint).Returns(pointMoq.Object);
targetRangeMock.Setup(s => s.EndPoint).Returns(pointMoq.Object);
// This should create Point2DRangeUpdateStrategy lazily
Assert.DoesNotThrow(() => strategy.Update(targetMock.Object, sourceMock.Object));
// No exception means lazy initialization worked
// Cannot directly mock the default Point2DRangeUpdateStrategy, but at least this ensures no null reference
}
[Test]
public void Update_DoesNotCallRangeUpdate_WhenUpdateChildrenIsFalse()
{
_strategy.UpdateChildren = false;
_strategy.Update(_targetMock.Object, _sourceMock.Object);
_rangeUpdateMock.Verify(r => r.Update(It.IsAny<IPoint2DRange>(), It.IsAny<IPoint2DRange>()), Times.Never);
}
}
}