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

Analisys manager window was added

Browse Source
This commit is contained in:
RedikultsevEvg
2024-08-20 20:38:01 +05:00
parent 45dbd7a1ca
commit c1b9f80a96
50 changed files with 1036 additions and 281 deletions
Download Patch File Download Diff File Expand all files Collapse all files

93
StructureHelperTests/UnitTests/Ndms/Cracks/CrackWidthCalculationLogicTests.cs
View File

@@ -10,98 +10,7 @@ namespace StructureHelperTests.UnitTests.Ndms.Cracks
[TestFixture]
public class CrackWidthCalculationLogicTests
{
private Mock<IRebarStressCalculator> _calculator;
private Mock<ICrackWidthLogic> _mockCrackWidthLogic;
private Mock<IShiftTraceLogger> _mockTraceLogger;
private CrackWidthCalculationLogic _logic;
private IRebarCrackCalculatorInputData _inputData;
[SetUp]
public void SetUp()
{
_calculator = new Mock<IRebarStressCalculator>();
_mockCrackWidthLogic = new Mock<ICrackWidthLogic>();
_mockTraceLogger = new Mock<IShiftTraceLogger>();
_inputData = new RebarCrackCalculatorInputData
{
};
_inputData.UserCrackInputData = new UserCrackInputData();
_logic = new CrackWidthCalculationLogic(_calculator.Object, _mockCrackWidthLogic.Object, _mockTraceLogger.Object)
{
InputData = _inputData
};
}
[Test]
public void Run_ShouldPrepareNewResultAndProcessCalculations()
{
// Arrange
_mockCrackWidthLogic.Setup(m => m.GetCrackWidth())
.Returns(0.5); // Mock the GetCrackWidth method
// Act
_logic.Run();
// Assert
Assert.NotNull(_logic.Result);
Assert.IsTrue(_logic.Result.IsValid);
_mockTraceLogger.Verify(x => x.AddMessage(It.IsAny<string>()), Times.AtLeastOnce);
}
[Test]
public void ProcessLongTermCalculation_ShouldReturnExpectedResult()
{
// Arrange
_mockCrackWidthLogic.SetupSequence(m => m.GetCrackWidth())
.Returns(0.5) // longTermLoadLongTermConcreteCrackWidth
.Returns(0.2); // longTermLoadShortConcreteWidth
// Act
var result = _logic.ProcessLongTermCalculations();
// Assert
Assert.NotNull(result);
Assert.AreEqual(0.5, result.CrackWidth);
_mockTraceLogger.Verify(x => x.AddMessage(It.IsAny<string>()), Times.AtLeastOnce);
}
[Test]
public void ProcessShortTermCalculations_ShouldReturnExpectedResult()
{
// Arrange
_mockCrackWidthLogic.SetupSequence(m => m.GetCrackWidth())
.Returns(0.2) // longTermLoadShortConcreteWidth
.Returns(0.3); // fullLoadShortConcreteCrackWidth
// Act
var result = _logic.ProcessShortTermCalculations();
// Assert
Assert.NotNull(result);
Assert.AreEqual(0.0, result.CrackWidth); // Assuming acrcShort would be 0 in this scenario
_mockTraceLogger.Verify(x => x.AddMessage(It.IsAny<string>()), Times.AtLeastOnce);
}
[Test]
public void GetRebarStressResult_ShouldReturnValidResult()
{
// Arrange
var mockRebarStressCalculator = new Mock<IRebarStressCalculator>();
var expectedResult = new RebarStressResult { IsValid = true };
mockRebarStressCalculator.Setup(c => c.Run());
mockRebarStressCalculator.Setup(c => c.Result).Returns(expectedResult);
// Act
var result = _logic.GetRebarStressResult(_inputData.ShortRebarData);
// Assert
Assert.NotNull(result);
Assert.IsTrue(result.IsValid);
_mockTraceLogger.Verify(x => x.AddMessage(It.IsAny<string>(), TraceLogStatuses.Error), Times.Never);
}
}
}

88
StructureHelperTests/UnitTests/Ndms/Cracks/InputDataTests/CheckCrackWidthSP63InputDataLogicTests.cs
View File

@@ -4,6 +4,10 @@ using StructureHelperCommon.Models;
using StructureHelperLogics.NdmCalculations.Cracking;
using StructureHelperLogics.NdmCalculations.Primitives;
using StructureHelperCommon.Models.Forces;
using StructureHelperCommon.Models.Calculators;
using Autofac.Features.ResolveAnything;
using StructureHelperLogics.NdmCalculations.Triangulations;
using LoaderCalculator.Data.Ndms;
namespace StructureHelperTests.UnitTests.Ndms.Cracks.InputDataTests
{
@@ -11,89 +15,7 @@ namespace StructureHelperTests.UnitTests.Ndms.Cracks.InputDataTests
[TestFixture]
public class CrackWidthCalculationLogicTests
{
private Mock<IRebarStressCalculator> _calculator;
private Mock<ICrackWidthLogic> mockCrackWidthLogic;
private Mock<IShiftTraceLogger> mockTraceLogger;
private Mock<IRebarCrackCalculatorInputData> mockInputData;
private Mock<IUserCrackInputData> mockUserCrackInputData;
private Mock<IRebarPrimitive> mockRebarPrimitive;
private Mock<IRebarStressCalculator> mockRebarStressCalculator;
private CrackWidthCalculationLogic crackWidthCalculationLogic;
private Mock<IRebarCrackInputData> mockRebarCrackInputData;
[SetUp]
public void SetUp()
{
_calculator = new Mock<IRebarStressCalculator>();
mockCrackWidthLogic = new Mock<ICrackWidthLogic>();
mockTraceLogger = new Mock<IShiftTraceLogger>();
mockInputData = new Mock<IRebarCrackCalculatorInputData>();
mockUserCrackInputData = new Mock<IUserCrackInputData>();
mockRebarPrimitive = new Mock<IRebarPrimitive>();
mockRebarStressCalculator = new Mock<IRebarStressCalculator>();
mockRebarCrackInputData = new Mock<IRebarCrackInputData>();
mockInputData.Setup(x => x.UserCrackInputData).Returns(mockUserCrackInputData.Object);
mockInputData.Setup(x => x.LongRebarData).Returns(mockRebarCrackInputData.Object);
mockInputData.Setup(x => x.ShortRebarData).Returns(mockRebarCrackInputData.Object);
mockInputData.Setup(x => x.RebarPrimitive).Returns(mockRebarPrimitive.Object);
mockRebarCrackInputData.Setup(x => x.ForceTuple).Returns(new ForceTuple());
crackWidthCalculationLogic = new CrackWidthCalculationLogic(_calculator.Object, mockCrackWidthLogic.Object, mockTraceLogger.Object)
{
InputData = mockInputData.Object
};
}
[Test]
public void Run_ShouldPrepareNewResultAndProcessCalculations()
{
// Arrange
mockCrackWidthLogic.Setup(x => x.GetCrackWidth()).Returns(0.5);
// Act
crackWidthCalculationLogic.Run();
// Assert
mockCrackWidthLogic.Verify(x => x.GetCrackWidth(), Times.AtLeastOnce);
Assert.IsNotNull(crackWidthCalculationLogic.Result);
Assert.IsTrue(crackWidthCalculationLogic.Result.IsValid);
}
[Test]
public void ProcessShortTermCalculations_ShouldCalculateCorrectShortTermCrackWidth()
{
// Arrange
mockUserCrackInputData.Setup(x => x.UltimateShortCrackWidth).Returns(1.0);
mockCrackWidthLogic.SetupSequence(x => x.GetCrackWidth())
.Returns(0.6) // longTermLoadShortConcreteWidth
.Returns(0.8); // fullLoadShortConcreteCrackWidth
crackWidthCalculationLogic.InputData = mockInputData.Object;
// Act
var shortTermResult = crackWidthCalculationLogic.ProcessShortTermCalculations();
// Assert
Assert.AreEqual(1.2, shortTermResult.CrackWidth);
Assert.AreEqual(1.0, shortTermResult.UltimateCrackWidth);
}
[Test]
public void ProcessLongTermCalculations_ShouldCalculateCorrectLongTermCrackWidth()
{
// Arrange
mockUserCrackInputData.Setup(x => x.UltimateLongCrackWidth).Returns(1.2);
mockCrackWidthLogic.Setup(x => x.GetCrackWidth()).Returns(0.9);
// Act
var longTermResult = crackWidthCalculationLogic.ProcessLongTermCalculations();
// Assert
Assert.AreEqual(0.9, longTermResult.CrackWidth);
Assert.AreEqual(1.2, longTermResult.UltimateCrackWidth);
}
}

80
StructureHelperTests/UnitTests/Ndms/Cracks/RebarStressResultLogicTests.cs Normal file
View File

@@ -0,0 +1,80 @@
using Moq;
using NUnit.Framework;
using StructureHelperCommon.Infrastructures.Exceptions;
using StructureHelperCommon.Models.Loggers;
using StructureHelperCommon.Models;
using StructureHelperLogics.NdmCalculations.Cracking;
using StructureHelperLogics.NdmCalculations.Primitives;
namespace StructureHelperTests.UnitTests.Ndms.Cracks
{
[TestFixture]
public class RebarStressResultLogicTests
{
private Mock<IRebarStressCalculator> _mockRebarStressCalculator;
private Mock<IShiftTraceLogger> _mockTraceLogger;
private RebarStressResultLogic _rebarStressResultLogic;
[SetUp]
public void Setup()
{
_mockRebarStressCalculator = new Mock<IRebarStressCalculator>();
_mockTraceLogger = new Mock<IShiftTraceLogger>();
_rebarStressResultLogic = new RebarStressResultLogic(_mockRebarStressCalculator.Object, _mockTraceLogger.Object);
}
[Test]
public void GetRebarStressResult_WhenCalculationIsValid_ReturnsRebarStressResult()
{
// Arrange
var mockRebarStressResult = new RebarStressResult
{
IsValid = true
};
_mockRebarStressCalculator.Setup(x => x.Run());
_mockRebarStressCalculator.Setup(x => x.Result).Returns(mockRebarStressResult);
var mockRebarPrimitive = new Mock<IRebarPrimitive>();
var mockRebarCrackInputData = new Mock<IRebarCrackInputData>();
_rebarStressResultLogic.RebarPrimitive = mockRebarPrimitive.Object;
_rebarStressResultLogic.RebarCrackInputData = mockRebarCrackInputData.Object;
// Act
var result = _rebarStressResultLogic.GetRebarStressResult();
// Assert
Assert.AreEqual(mockRebarStressResult, result);
_mockRebarStressCalculator.Verify(x => x.Run(), Times.Once);
}
[Test]
public void GetRebarStressResult_WhenCalculationIsInvalid_ThrowsStructureHelperException()
{
// Arrange
var mockRebarStressResult = new RebarStressResult
{
IsValid = false,
Description = "Error in calculation"
};
_mockRebarStressCalculator.Setup(x => x.Run());
_mockRebarStressCalculator.Setup(x => x.Result).Returns(mockRebarStressResult);
var mockRebarPrimitive = new Mock<IRebarPrimitive>();
var mockRebarCrackInputData = new Mock<IRebarCrackInputData>();
_rebarStressResultLogic.RebarPrimitive = mockRebarPrimitive.Object;
_rebarStressResultLogic.RebarCrackInputData = mockRebarCrackInputData.Object;
// Act & Assert
var ex = Assert.Throws<StructureHelperException>(() => _rebarStressResultLogic.GetRebarStressResult());
Assert.That(ex.Message, Is.EqualTo(LoggerStrings.CalculationError + mockRebarStressResult.Description));
_mockTraceLogger.Verify(x => x.AddMessage(It.IsAny<string>(), TraceLogStatuses.Error), Times.Once);
}
}
}