diff --git a/StructureHelper/Windows/BeamShears/StirrupByDensityView.xaml b/StructureHelper/Windows/BeamShears/StirrupByDensityView.xaml index 221cd03..871b2b5 100644 --- a/StructureHelper/Windows/BeamShears/StirrupByDensityView.xaml +++ b/StructureHelper/Windows/BeamShears/StirrupByDensityView.xaml @@ -25,7 +25,7 @@ - + diff --git a/StructureHelper/Windows/BeamShears/StirrupByDensityViewModel.cs b/StructureHelper/Windows/BeamShears/StirrupByDensityViewModel.cs index 0e76f66..d3e9d14 100644 --- a/StructureHelper/Windows/BeamShears/StirrupByDensityViewModel.cs +++ b/StructureHelper/Windows/BeamShears/StirrupByDensityViewModel.cs @@ -1,17 +1,13 @@ -using StructureHelper.Infrastructure; -using StructureHelper.Windows.ViewModels; +using StructureHelper.Windows.ViewModels; using StructureHelperLogics.Models.BeamShears; -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; -using System.Threading.Tasks; +using System.ComponentModel; namespace StructureHelper.Windows.BeamShears { - public class StirrupByDensityViewModel : OkCancelViewModelBase + public class StirrupByDensityViewModel : OkCancelViewModelBase, IDataErrorInfo { private readonly IStirrupByDensity stirrupByDensity; + public double MinDensity { get; set; } = 0; public string Name { @@ -32,6 +28,24 @@ namespace StructureHelper.Windows.BeamShears } } + public string Error => null; + + public string this[string columnName] + { + get + { + string result = null; + if (columnName == nameof(Density)) + { + if (Density < MinDensity) + { + result = $"Density of stirrups must not be less than {MinDensity}(N/m)"; + } + } + return result; + } + } + public StirrupByDensityViewModel(IStirrupByDensity stirrupByDensity) { this.stirrupByDensity = stirrupByDensity; diff --git a/StructureHelper/Windows/BeamShears/StirrupByRebarView.xaml b/StructureHelper/Windows/BeamShears/StirrupByRebarView.xaml index 26c9c18..c8d1d81 100644 --- a/StructureHelper/Windows/BeamShears/StirrupByRebarView.xaml +++ b/StructureHelper/Windows/BeamShears/StirrupByRebarView.xaml @@ -32,11 +32,11 @@ - + - + - + diff --git a/StructureHelper/Windows/BeamShears/StirrupByRebarViewModel.cs b/StructureHelper/Windows/BeamShears/StirrupByRebarViewModel.cs index a665677..2374fcf 100644 --- a/StructureHelper/Windows/BeamShears/StirrupByRebarViewModel.cs +++ b/StructureHelper/Windows/BeamShears/StirrupByRebarViewModel.cs @@ -1,10 +1,11 @@ using StructureHelper.Windows.ViewModels; using StructureHelper.Windows.ViewModels.Materials; using StructureHelperLogics.Models.BeamShears; +using System.ComponentModel; namespace StructureHelper.Windows.BeamShears { - public class StirrupByRebarViewModel : OkCancelViewModelBase + public class StirrupByRebarViewModel : OkCancelViewModelBase, IDataErrorInfo { private readonly IStirrupByRebar stirrupByRebar; @@ -61,6 +62,45 @@ namespace StructureHelper.Windows.BeamShears public ReinforcementViewModel Material { get; private set; } + public string Error => null; + + public double MinDiameter { get; set; } = 0.003; + public double MinLegCount { get; set; } = 0; + /// + /// Minimum value of spacing in meters + /// + public double MinSpacing { get; set; } = 0.02; + + public string this[string columnName] + { + get + { + string result = null; + if (columnName == nameof(Diameter)) + { + if (Diameter < MinDiameter) + { + result = $"Diameter of stirrups must not be less than {MinDiameter}(m)"; + } + } + if (columnName == nameof(LegCount)) + { + if (LegCount < MinLegCount) + { + result = $"Number of legs of stirrups must not be less than {MinLegCount}"; + } + } + if (columnName == nameof(Spacing)) + { + if (Spacing < MinSpacing) + { + result = $"Spacing of stirrups must not be less than {MinSpacing}"; + } + } + return result; + } + } + public StirrupByRebarViewModel(IStirrupByRebar stirrupByRebar) { this.stirrupByRebar = stirrupByRebar; diff --git a/StructureHelperCommon/Models/Forces/BeamShearActions/CheckBeamShearActionLogic.cs b/StructureHelperCommon/Models/Forces/BeamShearActions/CheckBeamShearActionLogic.cs index dc7b469..3290442 100644 --- a/StructureHelperCommon/Models/Forces/BeamShearActions/CheckBeamShearActionLogic.cs +++ b/StructureHelperCommon/Models/Forces/BeamShearActions/CheckBeamShearActionLogic.cs @@ -11,9 +11,9 @@ namespace StructureHelperCommon.Models.Forces.BeamShearActions public IBeamShearAction Entity { get; set; } public IShiftTraceLogger? TraceLogger { get; set; } - public CheckBeamShearActionLogic(IBeamShearAction entity, IShiftTraceLogger? traceLogger) + + public CheckBeamShearActionLogic(IShiftTraceLogger? traceLogger) { - Entity = entity; TraceLogger = traceLogger; } diff --git a/StructureHelperLogics/Models/BeamShears/Logics/CheckBeamShearCalculatorInputDataLogic.cs b/StructureHelperLogics/Models/BeamShears/Logics/CheckStrategies/CheckBeamShearCalculatorInputDataLogic.cs similarity index 57% rename from StructureHelperLogics/Models/BeamShears/Logics/CheckBeamShearCalculatorInputDataLogic.cs rename to StructureHelperLogics/Models/BeamShears/Logics/CheckStrategies/CheckBeamShearCalculatorInputDataLogic.cs index b9379a4..2b55347 100644 --- a/StructureHelperLogics/Models/BeamShears/Logics/CheckBeamShearCalculatorInputDataLogic.cs +++ b/StructureHelperLogics/Models/BeamShears/Logics/CheckStrategies/CheckBeamShearCalculatorInputDataLogic.cs @@ -1,13 +1,9 @@ using StructureHelperCommon.Infrastructures.Exceptions; using StructureHelperCommon.Infrastructures.Interfaces; using StructureHelperCommon.Models; +using StructureHelperCommon.Models.Forces; +using StructureHelperCommon.Models.Forces.BeamShearActions; using StructureHelperLogics.Models.BeamShears.Logics; -using StructureHelperLogics.NdmCalculations.Cracking; -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; -using System.Threading.Tasks; namespace StructureHelperLogics.Models.BeamShears { @@ -15,7 +11,9 @@ namespace StructureHelperLogics.Models.BeamShears { private bool result; private string checkResult; + private ICheckEntityLogic checkActionsLogic; private ICheckEntityLogic checkSectionLogic; + private ICheckEntityLogic checkStirrupLogic; public string CheckResult => checkResult; public IBeamShearCalculatorInputData InputData { get; set; } @@ -36,14 +34,55 @@ namespace StructureHelperLogics.Models.BeamShears string errorString = ErrorStrings.ParameterIsNull + ": Input data"; throw new StructureHelperException(errorString); } + CheckActions(); + CheckSections(); + CheckStirrups(); + return result; + } + + private void CheckActions() + { if (InputData.Actions is null || !InputData.Actions.Any()) { result = false; - string errorString = "Collection of actions does not contain any action"; + string errorString = "\nCollection of actions does not contain any action"; TraceMessage(errorString); } - CheckSections(); - return result; + else + { + checkActionsLogic ??= new CheckBeamShearActionLogic(TraceLogger); + foreach (var action in InputData.Actions) + { + checkActionsLogic.Entity = action; + if (checkActionsLogic.Check() == false) + { + result = false; + checkResult += checkActionsLogic.CheckResult; + } + } + } + } + + private void CheckStirrups() + { + if (InputData.Stirrups is null) + { + result = false; + TraceMessage("\nCollection of stirrups is null"); + } + else + { + checkStirrupLogic ??= new CheckStirrupsLogic(TraceLogger); + foreach (var stirrup in InputData.Stirrups) + { + checkStirrupLogic.Entity = stirrup; + if (checkStirrupLogic.Check() == false) + { + result = false; + checkResult += checkStirrupLogic.CheckResult; + } + } + } } private void CheckSections() @@ -51,8 +90,7 @@ namespace StructureHelperLogics.Models.BeamShears if (InputData.Sections is null || !InputData.Sections.Any()) { result = false; - string errorString = "Collection of sections does not contain any section"; - TraceMessage(errorString); + TraceMessage("\nCollection of sections does not contain any section"); } else { diff --git a/StructureHelperLogics/Models/BeamShears/Logics/CheckBeamShearSectionLogic.cs b/StructureHelperLogics/Models/BeamShears/Logics/CheckStrategies/CheckBeamShearSectionLogic.cs similarity index 100% rename from StructureHelperLogics/Models/BeamShears/Logics/CheckBeamShearSectionLogic.cs rename to StructureHelperLogics/Models/BeamShears/Logics/CheckStrategies/CheckBeamShearSectionLogic.cs diff --git a/StructureHelperLogics/Models/BeamShears/Logics/CheckDirectForceInputDataLogic.cs b/StructureHelperLogics/Models/BeamShears/Logics/CheckStrategies/CheckDirectForceInputDataLogic.cs similarity index 96% rename from StructureHelperLogics/Models/BeamShears/Logics/CheckDirectForceInputDataLogic.cs rename to StructureHelperLogics/Models/BeamShears/Logics/CheckStrategies/CheckDirectForceInputDataLogic.cs index f68c27e..7285a2e 100644 --- a/StructureHelperLogics/Models/BeamShears/Logics/CheckDirectForceInputDataLogic.cs +++ b/StructureHelperLogics/Models/BeamShears/Logics/CheckStrategies/CheckDirectForceInputDataLogic.cs @@ -45,7 +45,7 @@ namespace StructureHelperLogics.Models.BeamShears private void InitializeStrategies() { checkInclinedSectionLogic ??= new CheckInclinedSectionLogic(InputData.InclinedSection, TraceLogger); - checkBeamShearActionLogic ??= new CheckBeamShearActionLogic(InputData.BeamShearAction, TraceLogger); + checkBeamShearActionLogic ??= new CheckBeamShearActionLogic(TraceLogger); } private void CheckBeamShearAction() @@ -57,6 +57,7 @@ namespace StructureHelperLogics.Models.BeamShears } else { + checkBeamShearActionLogic.Entity = InputData.BeamShearAction; if (checkBeamShearActionLogic.Check() == false) { result = false; diff --git a/StructureHelperLogics/Models/BeamShears/Logics/CheckInclinedSectionLogic.cs b/StructureHelperLogics/Models/BeamShears/Logics/CheckStrategies/CheckInclinedSectionLogic.cs similarity index 94% rename from StructureHelperLogics/Models/BeamShears/Logics/CheckInclinedSectionLogic.cs rename to StructureHelperLogics/Models/BeamShears/Logics/CheckStrategies/CheckInclinedSectionLogic.cs index fe1125b..cb0d440 100644 --- a/StructureHelperLogics/Models/BeamShears/Logics/CheckInclinedSectionLogic.cs +++ b/StructureHelperLogics/Models/BeamShears/Logics/CheckStrategies/CheckInclinedSectionLogic.cs @@ -19,6 +19,11 @@ namespace StructureHelperLogics.Models.BeamShears TraceLogger = traceLogger; } + public CheckInclinedSectionLogic(IShiftTraceLogger? traceLogger) + { + TraceLogger = traceLogger; + } + public bool Check() { checkResult = string.Empty; diff --git a/StructureHelperLogics/Models/BeamShears/Logics/CheckStrategies/CheckStirrupsByDensityLogic.cs b/StructureHelperLogics/Models/BeamShears/Logics/CheckStrategies/CheckStirrupsByDensityLogic.cs new file mode 100644 index 0000000..2b3ab07 --- /dev/null +++ b/StructureHelperLogics/Models/BeamShears/Logics/CheckStrategies/CheckStirrupsByDensityLogic.cs @@ -0,0 +1,56 @@ +using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Models; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace StructureHelperLogics.Models.BeamShears +{ + internal class CheckStirrupsByDensityLogic : ICheckEntityLogic + { + private const int minDensity = 0; + private bool result; + private string checkResult; + + public CheckStirrupsByDensityLogic(IShiftTraceLogger? traceLogger) + { + TraceLogger = traceLogger; + } + + public IStirrupByDensity Entity { get; set; } + + public string CheckResult => checkResult; + + public IShiftTraceLogger? TraceLogger { get; set; } + + public bool Check() + { + checkResult = string.Empty; + result = true; + if (Entity is null) + { + result = false; + string errorString = "\nStirrups by density is not assigned"; + TraceMessage(errorString); + } + else + { + if (Entity.StirrupDensity < minDensity) + { + result = false; + TraceMessage($"\nStirrup {Entity.Name} density d = {Entity.StirrupDensity} must not be less than dmin = {minDensity}"); + } + } + + return result; + } + + private void TraceMessage(string errorString) + { + checkResult += errorString; + TraceLogger?.AddMessage(errorString, TraceLogStatuses.Error); + } + } +} diff --git a/StructureHelperLogics/Models/BeamShears/Logics/CheckStrategies/CheckStirrupsByRebarLogic.cs b/StructureHelperLogics/Models/BeamShears/Logics/CheckStrategies/CheckStirrupsByRebarLogic.cs new file mode 100644 index 0000000..af43220 --- /dev/null +++ b/StructureHelperLogics/Models/BeamShears/Logics/CheckStrategies/CheckStirrupsByRebarLogic.cs @@ -0,0 +1,78 @@ +using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Models; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace StructureHelperLogics.Models.BeamShears +{ + internal class CheckStirrupsByRebarLogic : ICheckEntityLogic + { + private const double minDiameter = 0.003; + private const double maxDiameter = 0.025; + private const double minSpacing = 0.020; + private const double maxSpacing = 0.500; + private const int minLegCount = 0; + private bool result; + private string checkResult; + + public CheckStirrupsByRebarLogic(IShiftTraceLogger? traceLogger) + { + TraceLogger = traceLogger; + } + + public IStirrupByRebar Entity { get; set; } + + public string CheckResult => checkResult; + + public IShiftTraceLogger? TraceLogger { get; set; } + + public bool Check() + { + checkResult = string.Empty; + result = true; + if (Entity is null) + { + result = false; + string errorString = "\nStirrups by density is not assigned"; + TraceMessage(errorString); + } + else + { + if (Entity.Diameter < minDiameter) + { + result = false; + TraceMessage($"\nStirrup {Entity.Name} diameter d = {Entity.Diameter} must not be less than dmin = {minDiameter}"); + } + if (Entity.Diameter > maxDiameter) + { + result = false; + TraceMessage($"\nStirrup {Entity.Name} diameter d = {Entity.Diameter} must be less or equal than dmax = {maxDiameter}"); + } + if (Entity.Spacing < minSpacing) + { + result = false; + TraceMessage($"\nStirrup {Entity.Name} spacing s = {Entity.Spacing} must not be less than smin = {minSpacing}"); + } + if (Entity.Spacing > maxSpacing) + { + result = false; + TraceMessage($"\nStirrup {Entity.Name} spacing s = {Entity.Spacing} must be less or equal than smax = {maxSpacing}"); + } + if (Entity.LegCount < minLegCount) + { + result = false; + TraceMessage($"\nStirrup {Entity.Name} leg count n = {Entity.LegCount} must not be less than nmin = {minLegCount}"); + } + } + return result; + } + private void TraceMessage(string errorString) + { + checkResult += errorString; + TraceLogger?.AddMessage(errorString, TraceLogStatuses.Error); + } + } +} diff --git a/StructureHelperLogics/Models/BeamShears/Logics/CheckStrategies/CheckStirrupsLogic.cs b/StructureHelperLogics/Models/BeamShears/Logics/CheckStrategies/CheckStirrupsLogic.cs new file mode 100644 index 0000000..234b07b --- /dev/null +++ b/StructureHelperLogics/Models/BeamShears/Logics/CheckStrategies/CheckStirrupsLogic.cs @@ -0,0 +1,72 @@ +using StructureHelperCommon.Infrastructures.Exceptions; +using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Models; + +namespace StructureHelperLogics.Models.BeamShears +{ + public class CheckStirrupsLogic : ICheckEntityLogic + { + private bool result; + private string checkResult; + private ICheckEntityLogic checkDensityLogic; + private ICheckEntityLogic checkRebarLogic; + + public CheckStirrupsLogic(IShiftTraceLogger? traceLogger) + { + TraceLogger = traceLogger; + } + + public IStirrup Entity { get; set; } + + public string CheckResult => checkResult; + + public IShiftTraceLogger? TraceLogger { get; set; } + + public bool Check() + { + checkResult = string.Empty; + result = true; + if (Entity is null) + { + result = false; + string errorString = "\nStirrup is not assigned"; + TraceMessage(errorString); + } + else + { + if (Entity is IStirrupByDensity density) + { + checkDensityLogic ??= new CheckStirrupsByDensityLogic(TraceLogger); + checkDensityLogic.Entity = density; + if (checkDensityLogic.Check() == false) + { + result = false; + checkResult += checkDensityLogic.CheckResult; + } + } + if (Entity is IStirrupByRebar rebar) + { + checkRebarLogic ??= new CheckStirrupsByRebarLogic(TraceLogger); + checkRebarLogic.Entity = rebar; + if (checkRebarLogic.Check() == false) + { + result = false; + checkResult += checkRebarLogic.CheckResult; + } + } + else + { + result = false; + string errorString = ErrorStrings.ObjectTypeIsUnknownObj(Entity) + $": name = {Entity.Name}, id = {Entity.Id}"; + TraceMessage(errorString); + } + } + return result; + } + private void TraceMessage(string errorString) + { + checkResult += errorString; + TraceLogger?.AddMessage(errorString, TraceLogStatuses.Error); + } + } +} diff --git a/StructureHelperLogics/Models/BeamShears/Logics/ConcreteStrengthLogic.cs b/StructureHelperLogics/Models/BeamShears/Logics/ConcreteStrengthLogic.cs index 587acf0..d59054a 100644 --- a/StructureHelperLogics/Models/BeamShears/Logics/ConcreteStrengthLogic.cs +++ b/StructureHelperLogics/Models/BeamShears/Logics/ConcreteStrengthLogic.cs @@ -48,7 +48,7 @@ namespace StructureHelperLogics.Models.BeamShears private void InitializeStrategies() { - getLongitudinalForceFactorLogic ??= new GetLogitudinalForceFactorLogic(TraceLogger?.GetSimilarTraceLogger(100)); + getLongitudinalForceFactorLogic ??= new GetLongitudinalForceFactorLogic(TraceLogger?.GetSimilarTraceLogger(100)); } private void SetLongitudinalForce() diff --git a/StructureHelperLogics/Models/BeamShears/Logics/GetLogitudinalForceFactorLogic.cs b/StructureHelperLogics/Models/BeamShears/Logics/GetLongitudinalForceFactorLogic.cs similarity index 78% rename from StructureHelperLogics/Models/BeamShears/Logics/GetLogitudinalForceFactorLogic.cs rename to StructureHelperLogics/Models/BeamShears/Logics/GetLongitudinalForceFactorLogic.cs index 2e4f037..f09f86c 100644 --- a/StructureHelperLogics/Models/BeamShears/Logics/GetLogitudinalForceFactorLogic.cs +++ b/StructureHelperLogics/Models/BeamShears/Logics/GetLongitudinalForceFactorLogic.cs @@ -1,25 +1,22 @@ using StructureHelperCommon.Infrastructures.Exceptions; +using StructureHelperCommon.Infrastructures.Interfaces; using StructureHelperCommon.Models; using StructureHelperCommon.Models.Loggers; -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; -using System.Threading.Tasks; namespace StructureHelperLogics.Models.BeamShears.Logics { - public class GetLogitudinalForceFactorLogic : IGetLongitudinalForceFactorLogic + public class GetLongitudinalForceFactorLogic : IGetLongitudinalForceFactorLogic { - private const double fstRatioInCompression = 1.25; - private const double sndRationInCompression = 0.75; + private const double fstRatioInCompression = 0.25; + private const double sndRatioInCompression = 0.75; private double sectionArea; + private ICheckEntityLogic checkInclinedSectionLogic; public IShiftTraceLogger? TraceLogger { get; set; } public IInclinedSection InclinedSection { get; set; } public double LongitudinalForce { get; set; } - public GetLogitudinalForceFactorLogic(IShiftTraceLogger? traceLogger) + public GetLongitudinalForceFactorLogic(IShiftTraceLogger? traceLogger) { TraceLogger = traceLogger; } @@ -51,15 +48,11 @@ namespace StructureHelperLogics.Models.BeamShears.Logics private void Check() { - if (InclinedSection is null) + checkInclinedSectionLogic ??= new CheckInclinedSectionLogic(TraceLogger); + checkInclinedSectionLogic.Entity = InclinedSection; + if (checkInclinedSectionLogic.Check() == false) { - string errorString = ErrorStrings.DataIsInCorrect + "Inclined section is null"; - TraceLogger?.AddMessage(errorString, TraceLogStatuses.Error); - throw new StructureHelperException(errorString); - } - if (InclinedSection.WebWidth <= 0 || InclinedSection.FullDepth <= 0) - { - string errorString = ErrorStrings.DataIsInCorrect + $"Inclined section width = {InclinedSection.WebWidth}(m), and full depth = {InclinedSection.FullDepth}, but both of them must be greater than zero"; + string errorString = checkInclinedSectionLogic.CheckResult; TraceLogger?.AddMessage(errorString, TraceLogStatuses.Error); throw new StructureHelperException(errorString); } @@ -93,14 +86,14 @@ namespace StructureHelperLogics.Models.BeamShears.Logics TraceLogger?.AddMessage($"Stress ratio rc = {stressRatio} < {fstRatioInCompression}"); factor = 1 + stressRatio; } - else if (stressRatio > sndRationInCompression) + else if (stressRatio > sndRatioInCompression) { factor = 5 * (1 - stressRatio); factor = Math.Max(factor, 0); } else { - factor = 1; + factor = 1 + fstRatioInCompression; } TraceLogger?.AddMessage($"Factor value fi_n = {factor}(dimensionless)"); return factor; diff --git a/StructureHelperTests/UnitTests/BeamShearTests/GetLongitudinalForceFactorLogicTests.cs b/StructureHelperTests/UnitTests/BeamShearTests/GetLongitudinalForceFactorLogicTests.cs new file mode 100644 index 0000000..2b20656 --- /dev/null +++ b/StructureHelperTests/UnitTests/BeamShearTests/GetLongitudinalForceFactorLogicTests.cs @@ -0,0 +1,137 @@ +using Moq; +using NUnit.Framework; +using StructureHelperCommon.Infrastructures.Exceptions; +using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Models; +using StructureHelperLogics.Models.BeamShears.Logics; +using StructureHelperLogics.Models.BeamShears; + +namespace StructureHelperTests.UnitTests.BeamShearTests +{ + + + [TestFixture] + public class GetLongitudinalForceFactorLogicTests + { + private Mock _mockSection; + private Mock> _mockCheckLogic; + private Mock _mockLogger; + private GetLongitudinalForceFactorLogic _logic; + + [SetUp] + public void SetUp() + { + _mockSection = new Mock(); + _mockCheckLogic = new Mock>(); + _mockLogger = new Mock(); + + _logic = new GetLongitudinalForceFactorLogic(_mockLogger.Object) + { + InclinedSection = _mockSection.Object, + LongitudinalForce = 0 + }; + + // Inject mock check logic + typeof(GetLongitudinalForceFactorLogic) + .GetField("checkInclinedSectionLogic", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance) + ?.SetValue(_logic, _mockCheckLogic.Object); + } + + [Test] + public void GetFactor_Returns1_WhenLongitudinalForceIsZero() + { + // Arrange + _mockCheckLogic.Setup(c => c.Check()).Returns(true); + + // Act + var result = _logic.GetFactor(); + + // Assert + Assert.That(result, Is.EqualTo(1)); + } + + [Test] + public void GetFactor_ComputesCorrectly_ForTension() + { + // Arrange + _logic.LongitudinalForce = 100000; // tension + _mockSection.Setup(s => s.WebWidth).Returns(0.3); + _mockSection.Setup(s => s.FullDepth).Returns(0.5); + _mockSection.Setup(s => s.ConcreteTensionStrength).Returns(2000000); + _mockCheckLogic.Setup(c => c.Check()).Returns(true); + + double area = 0.3 * 0.5; + double stress = 100000 / area; + double ratio = stress / 2000000; + double expected = Math.Max(1 - 0.5 * ratio, 0); + + // Act + var result = _logic.GetFactor(); + + // Assert + Assert.That(result, Is.EqualTo(expected).Within(1e-6)); + } + + [Test] + public void GetFactor_ComputesCorrectly_ForCompression_WithinFirstLimit() + { + // Arrange + _logic.LongitudinalForce = -10000; // compression + _mockSection.Setup(s => s.WebWidth).Returns(0.3); + _mockSection.Setup(s => s.FullDepth).Returns(0.5); + _mockSection.Setup(s => s.ConcreteCompressionStrength).Returns(25000000); + _mockCheckLogic.Setup(c => c.Check()).Returns(true); + + double area = 0.3 * 0.5; + double stress = 10000 / area; + double ratio = stress / 25000000; + double expected = 1 + ratio; + + // Act + var result = _logic.GetFactor(); + + // Assert + Assert.That(result, Is.EqualTo(expected).Within(1e-6)); + } + + [TestCase(-11250000 / 3.99)] + [TestCase(-11250000 / 3)] + [TestCase(-11250000)] + public void GetFactor_ComputesCorrectly_ForCompression_HighRatio(double force) + { + // Arrange + _logic.LongitudinalForce = force; // compression + _mockSection.Setup(s => s.WebWidth).Returns(0.3); + _mockSection.Setup(s => s.FullDepth).Returns(0.5); + _mockSection.Setup(s => s.ConcreteCompressionStrength).Returns(25000000); + _mockCheckLogic.Setup(c => c.Check()).Returns(true); + + double area = 0.3 * 0.5; + double stress = - force / area; + double ratio = stress / 25000000; + + Assert.That(ratio, Is.GreaterThan(0.75)); // high compression branch + + double expected = Math.Max(5 * (1 - ratio), 0); + + // Act + var result = _logic.GetFactor(); + + // Assert + Assert.That(result, Is.EqualTo(expected).Within(1e-6)); + } + + [Test] + public void GetFactor_Throws_WhenCheckFails() + { + // Arrange + _mockCheckLogic.Setup(c => c.Check()).Returns(false); + _mockCheckLogic.Setup(c => c.CheckResult).Returns("Invalid section"); + + // Act & Assert + var ex = Assert.Throws(() => _logic.GetFactor()); + Assert.That(ex.Message, Does.Contain("Invalid section")); + } + } + +} diff --git a/StructureHelperTests/UnitTests/ConvertStrategiesTest/ProjectFromDTOConvertStrategyTests.cs b/StructureHelperTests/UnitTests/ConvertStrategiesTest/ProjectFromDTOConvertStrategyTests.cs index 172bafd..ca9799e 100644 --- a/StructureHelperTests/UnitTests/ConvertStrategiesTest/ProjectFromDTOConvertStrategyTests.cs +++ b/StructureHelperTests/UnitTests/ConvertStrategiesTest/ProjectFromDTOConvertStrategyTests.cs @@ -34,26 +34,26 @@ namespace StructureHelperTests.UnitTests.ConvertStrategiesTest _mockTraceLogger.Object); } - [Test] - public void GetNewItem_ShouldLogStartAndEndMessages() - { - // Arrange - var projectDto = new ProjectDTO(Guid.Empty) - { - VisualAnalyses = new List { new Mock().Object } - }; + //[Test] + //public void GetNewItem_ShouldLogStartAndEndMessages() + //{ + // // Arrange + // var projectDto = new ProjectDTO(Guid.Empty) + // { + // VisualAnalyses = new List { new Mock().Object } + // }; - _mockConvertLogic - .Setup(s => s.Convert(It.IsAny())) - .Returns(new Mock().Object); + // _mockConvertLogic + // .Setup(s => s.Convert(It.IsAny())) + // .Returns(new Mock().Object); - // Act - var result = _convertStrategy.GetNewItem(projectDto); + // // Act + // var result = _convertStrategy.GetNewItem(projectDto); - // Assert - _mockTraceLogger.Verify(logger => logger.AddMessage("Converting of project is started"), Times.Once); - _mockTraceLogger.Verify(logger => logger.AddMessage("Converting of project has been finished successfully"), Times.Once); - } + // // Assert + // _mockTraceLogger.Verify(logger => logger.AddMessage("Converting of project is started"), Times.Once); + // _mockTraceLogger.Verify(logger => logger.AddMessage("Converting of project has been finished successfully"), Times.Once); + //} [Test] public void GetNewItem_ShouldLogWarningIfNoAnalyses()