diff --git a/StructureHelper/Infrastructure/UI/Resources/ButtonStyles.xaml b/StructureHelper/Infrastructure/UI/Resources/ButtonStyles.xaml
index ce36911..5ac6f7a 100644
--- a/StructureHelper/Infrastructure/UI/Resources/ButtonStyles.xaml
+++ b/StructureHelper/Infrastructure/UI/Resources/ButtonStyles.xaml
@@ -1,5 +1,6 @@
 <ResourceDictionary xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
-                    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
+                    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+                    xmlns:uc="clr-namespace:StructureHelper.Windows.UserControls">
 
     <Style TargetType="Button" x:Key="ButtonBase">
 
@@ -142,15 +143,15 @@
         </StackPanel>
     </DataTemplate>
 
-    <DataTemplate x:Key="ButtonCalculatorRectangle">              
-    <Rectangle Style="{DynamicResource ButtonRect}" Stroke="{DynamicResource CalculatorFrame}">
-        <Rectangle.Fill>
-            <LinearGradientBrush EndPoint="0.5,1" StartPoint="0.5,0">
-                <GradientStop Color="{DynamicResource ButtonLight}" Offset="0.2"/>
-                <GradientStop Color="{DynamicResource CalculatorColor}" Offset="1"/>
-            </LinearGradientBrush>
-        </Rectangle.Fill>
-    </Rectangle>
+    <DataTemplate x:Key="ButtonCalculatorRectangle">
+        <Rectangle Style="{DynamicResource ButtonRect}" Stroke="{DynamicResource CalculatorFrame}">
+            <Rectangle.Fill>
+                <LinearGradientBrush EndPoint="0.5,1" StartPoint="0.5,0">
+                    <GradientStop Color="{DynamicResource ButtonLight}" Offset="0.2"/>
+                    <GradientStop Color="{DynamicResource CalculatorColor}" Offset="1"/>
+                </LinearGradientBrush>
+            </Rectangle.Fill>
+        </Rectangle>
     </DataTemplate>
 
     <DataTemplate x:Key="ButtonResultRectangle">
@@ -605,4 +606,17 @@
         </Canvas>
     </DataTemplate>
 
+    <DataTemplate x:Key="ExportToExcelButton">
+        <Button Style="{DynamicResource ToolButton}" Command="{Binding ExportToCSVCommand}">
+            <Button.ToolTip>
+                <uc:ButtonToolTipEh HeaderText="Export to *.csv"
+                                                IconContent="{StaticResource ExportToXLS}"
+                                                DescriptionText="Export all valid results to *.csv file"/>
+            </Button.ToolTip>
+            <Viewbox>
+                <ContentControl ContentTemplate="{DynamicResource ExportToXLS}"/>
+            </Viewbox>
+        </Button>
+    </DataTemplate>
+
 </ResourceDictionary>
\ No newline at end of file
diff --git a/StructureHelper/Libraries/LoaderCalculator.dll b/StructureHelper/Libraries/LoaderCalculator.dll
index 2fc401e..bb9395f 100644
Binary files a/StructureHelper/Libraries/LoaderCalculator.dll and b/StructureHelper/Libraries/LoaderCalculator.dll differ
diff --git a/StructureHelper/StructureHelper.csproj b/StructureHelper/StructureHelper.csproj
index 9e178b0..dbf8900 100644
--- a/StructureHelper/StructureHelper.csproj
+++ b/StructureHelper/StructureHelper.csproj
@@ -59,11 +59,11 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="Autofac" Version="8.1.0" />
+    <PackageReference Include="Autofac" Version="8.2.0" />
     <PackageReference Include="LiveCharts.Wpf" Version="0.9.7" />
     <PackageReference Include="LiveCharts.Wpf.Core" Version="0.9.8" />
     <PackageReference Include="LiveCharts.Wpf.NetCore3" Version="0.9.8" />
-    <PackageReference Include="Microsoft.Xaml.Behaviors.Wpf" Version="1.1.122" />
+    <PackageReference Include="Microsoft.Xaml.Behaviors.Wpf" Version="1.1.135" />
     <PackageReference Include="Newtonsoft.Json" Version="13.0.3" />
     <PackageReference Include="System.Windows.Interactivity.WPF" Version="2.0.20525" />
   </ItemGroup>
diff --git a/StructureHelper/Windows/Graphs/GraphView.xaml b/StructureHelper/Windows/Graphs/GraphView.xaml
index ad233fa..47b4c2d 100644
--- a/StructureHelper/Windows/Graphs/GraphView.xaml
+++ b/StructureHelper/Windows/Graphs/GraphView.xaml
@@ -5,17 +5,36 @@
         xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
         xmlns:local="clr-namespace:StructureHelper.Windows.Graphs"
         xmlns:lvc="clr-namespace:LiveCharts.Wpf;assembly=LiveCharts.Wpf"
+        xmlns:uc="clr-namespace:StructureHelper.Windows.UserControls"
         d:DataContext="{d:DesignInstance local:GraphViewModel}"
         mc:Ignorable="d"
-        Title="Graph" Height="550" Width="800" MinHeight="500" MinWidth="600" WindowStartupLocation="CenterScreen">
+        Title="Graph" Height="650" Width="1000" MinHeight="500" MinWidth="600" MaxHeight="1100" MaxWidth="1800" WindowStartupLocation="CenterScreen">
     <DockPanel>
-        <!--<ToolBarTray DockPanel.Dock="Top">
+        <ToolBarTray DockPanel.Dock="Top">
             <ToolBar>
-                <Button Command="{Binding SaveAsImage}">
-                    <Image Style="{StaticResource ButtonImage32}" Source="/Windows/MainWindow/ConMaterial32.png"/>
+                <Button Style="{StaticResource ToolButton}" 
+                        Command="{Binding RedrawLinesCommand}">
+                    <Button.ToolTip>
+                        <uc:ButtonToolTipEh HeaderText="Redraw lines"
+                                                IconContent="{StaticResource Renew}"
+                                                DescriptionText="Redraw all lines of chart which have been selected"/>
+                    </Button.ToolTip>
+                    <Viewbox>
+                        <ContentControl ContentTemplate="{StaticResource Renew}"/>
+                    </Viewbox>
+                </Button>
+                <Button Style="{DynamicResource ToolButton}" Command="{Binding ExportToCSVCommand}">
+                    <Button.ToolTip>
+                        <uc:ButtonToolTipEh HeaderText="Export to *.csv"
+                                                IconContent="{StaticResource ExportToXLS}"
+                                                DescriptionText="Export all valid results to *.csv file"/>
+                    </Button.ToolTip>
+                    <Viewbox>
+                        <ContentControl ContentTemplate="{DynamicResource ExportToXLS}"/>
+                    </Viewbox>
                 </Button>
             </ToolBar>
-        </ToolBarTray>-->
+        </ToolBarTray>
         <Grid>
             <Grid.ColumnDefinitions>
                 <ColumnDefinition MinWidth="250"/>
@@ -26,7 +45,6 @@
                 <Grid.RowDefinitions>
                     <RowDefinition/>
                     <RowDefinition Height="170"/>
-                    <RowDefinition Height="40"/>
                 </Grid.RowDefinitions>
                 <ListBox ItemsSource="{Binding Series}">
                     <ListBox.ItemTemplate>
@@ -77,10 +95,6 @@
                     </ListBox.ItemTemplate>
                 </ListBox>
                 <ContentControl Grid.Row="1" ContentTemplate="{StaticResource ResourceKey=LineVisualProperties}" Content="{Binding VisualProps}"/>
-                
-                <StackPanel Grid.Row="2">
-                    <Button Margin="3" Content="Draw Lines" ToolTip="Draw Lines" Command="{Binding RedrawLinesCommand}"/>
-                </StackPanel>
             </Grid>
             <GridSplitter Grid.Column="1" Width="3" VerticalAlignment="Stretch" HorizontalAlignment="Center" ShowsPreview="False"/>
             <lvc:CartesianChart Name="MainChart" Grid.Column="2" Series="{Binding SeriesCollection}" LegendLocation="Bottom" Zoom="Xy">
diff --git a/StructureHelper/Windows/Graphs/GraphViewModel.cs b/StructureHelper/Windows/Graphs/GraphViewModel.cs
index acc89a6..0e60751 100644
--- a/StructureHelper/Windows/Graphs/GraphViewModel.cs
+++ b/StructureHelper/Windows/Graphs/GraphViewModel.cs
@@ -17,6 +17,7 @@ using System.Windows.Input;
 using System.Windows.Media;
 using System.Windows.Media.Imaging;
 
+
 //Copyright (c) 2023 Redikultsev Evgeny, Ekaterinburg, Russia
 //All rights reserved.
 
diff --git a/StructureHelperCommon/StructureHelperCommon.csproj b/StructureHelperCommon/StructureHelperCommon.csproj
index fa91557..64f85c9 100644
--- a/StructureHelperCommon/StructureHelperCommon.csproj
+++ b/StructureHelperCommon/StructureHelperCommon.csproj
@@ -10,7 +10,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="NLog" Version="5.3.3" />
+    <PackageReference Include="NLog" Version="5.3.4" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/StructureHelperTests/FieldsVisualizerTests/ColorOperationTests/GetColorByValueTest.cs b/StructureHelperTests/FieldsVisualizerTests/ColorOperationTests/GetColorByValueTest.cs
index a3e5ef9..8dc1779 100644
--- a/StructureHelperTests/FieldsVisualizerTests/ColorOperationTests/GetColorByValueTest.cs
+++ b/StructureHelperTests/FieldsVisualizerTests/ColorOperationTests/GetColorByValueTest.cs
@@ -3,6 +3,7 @@ using FieldVisualizer.Entities.ColorMaps.Factories;
 using FieldVisualizer.Entities.Values;
 using FieldVisualizer.Services.ColorServices;
 using NUnit.Framework;
+using NUnit.Framework.Legacy;
 
 namespace StructureHelperTests.FieldsVisualizerTests.ColorOperationTests
 {
@@ -37,11 +38,11 @@ namespace StructureHelperTests.FieldsVisualizerTests.ColorOperationTests
             var actualG = result.G;
             var actualB = result.B;
             //Assert
-            Assert.NotNull(result);
-            Assert.AreEqual(expectedA, actualA);
-            Assert.AreEqual(expectedR, actualR);
-            Assert.AreEqual(expectedG, actualG);
-            Assert.AreEqual(expectedB, actualB);
+            Assert.That(result, Is.Not.Null);
+            Assert.That(actualA, Is.EqualTo(expectedA));
+            Assert.That(actualR, Is.EqualTo(expectedR));
+            Assert.That(actualG, Is.EqualTo(expectedG));
+            Assert.That(actualB, Is.EqualTo(expectedB));
         }
     }
 }
diff --git a/StructureHelperTests/FieldsVisualizerTests/WindowTests/ViewerTest.cs b/StructureHelperTests/FieldsVisualizerTests/WindowTests/ViewerTest.cs
index 79002d6..4b53bd1 100644
--- a/StructureHelperTests/FieldsVisualizerTests/WindowTests/ViewerTest.cs
+++ b/StructureHelperTests/FieldsVisualizerTests/WindowTests/ViewerTest.cs
@@ -20,7 +20,7 @@ namespace StructureHelperTests.FieldsVisualizerTests.WindowTests
             //Act
             WndFieldViewer viewer = new WndFieldViewer(primitiveSets);
             //Assert
-            Assert.NotNull(viewer);
+            Assert.That(viewer, Is.Not.Null);
         }
 
     }
diff --git a/StructureHelperTests/FunctionalTests/Ndms/Calculators/AnchorageCalculatorTest/AnchorageCalculatorTest.cs b/StructureHelperTests/FunctionalTests/Ndms/Calculators/AnchorageCalculatorTest/AnchorageCalculatorTest.cs
index d9bbe58..f8c6bfe 100644
--- a/StructureHelperTests/FunctionalTests/Ndms/Calculators/AnchorageCalculatorTest/AnchorageCalculatorTest.cs
+++ b/StructureHelperTests/FunctionalTests/Ndms/Calculators/AnchorageCalculatorTest/AnchorageCalculatorTest.cs
@@ -29,7 +29,7 @@ namespace StructureHelperTests.FunctionalTests.Ndms.Calculators.AnchorageCalcula
             //Act
             var baseLength = calculator.GetBaseDevLength();
             //Assert
-            Assert.AreEqual(expectedBaseDevLength, baseLength, 0.001d);
+            Assert.That(baseLength, Is.EqualTo(expectedBaseDevLength).Within(0.001d));
         }
     }
 }
diff --git a/StructureHelperTests/FunctionalTests/Ndms/Calculators/CrackCalculatorTests/CrackCalculatorTest.cs b/StructureHelperTests/FunctionalTests/Ndms/Calculators/CrackCalculatorTests/CrackCalculatorTest.cs
index 1caa1e3..1529371 100644
--- a/StructureHelperTests/FunctionalTests/Ndms/Calculators/CrackCalculatorTests/CrackCalculatorTest.cs
+++ b/StructureHelperTests/FunctionalTests/Ndms/Calculators/CrackCalculatorTests/CrackCalculatorTest.cs
@@ -41,9 +41,9 @@ namespace StructureHelperTests.FunctionalTests.Ndms.Calculators.CrackCalculatorT
             calculator.Run();
             var result = (CrackForceResult)calculator.Result;
             //Assert
-            Assert.NotNull(result);
-            Assert.IsTrue(result.IsValid);
-            Assert.AreEqual(expectedFactor, result.FactorOfCrackAppearance, 0.01d);
+            Assert.That(result, Is.Not.Null);
+            Assert.That(result.IsValid, Is.True);
+            Assert.That(result.FactorOfCrackAppearance, Is.EqualTo(expectedFactor).Within(0.01d));
         }
     }
 }
diff --git a/StructureHelperTests/FunctionalTests/Ndms/Calculators/ForceCalculatorTests/RCSectionsTest.cs b/StructureHelperTests/FunctionalTests/Ndms/Calculators/ForceCalculatorTests/RCSectionsTest.cs
index 3433514..9354298 100644
--- a/StructureHelperTests/FunctionalTests/Ndms/Calculators/ForceCalculatorTests/RCSectionsTest.cs
+++ b/StructureHelperTests/FunctionalTests/Ndms/Calculators/ForceCalculatorTests/RCSectionsTest.cs
@@ -29,15 +29,15 @@ namespace StructureHelperTests.FunctionalTests.Ndms.Calculators.ForceCalculatorT
             calculator.Run();
             var result = calculator.Result as IForcesResults;
             //Assert
-            Assert.IsNotNull(result);
-            Assert.IsTrue(result.IsValid);
+            Assert.That(result, Is.Not.Null);
+            Assert.That(result.IsValid, Is.True);
             var strainMatrix = result.ForcesResultList[0].LoaderResults.StrainMatrix;
             var kx = strainMatrix.Kx;
             var ky = strainMatrix.Ky;
             var epsz = strainMatrix.EpsZ;
-            Assert.AreEqual(expectedKx, kx, ExpectedProcessor.GetAccuracyForExpectedValue(expectedKx));
-            Assert.AreEqual(expectedKy, ky, ExpectedProcessor.GetAccuracyForExpectedValue(expectedKy));
-            Assert.AreEqual(expectedEpsZ, epsz, ExpectedProcessor.GetAccuracyForExpectedValue(expectedEpsZ));
+            Assert.That(kx, Is.EqualTo(expectedKx).Within(ExpectedProcessor.GetAccuracyForExpectedValue(expectedKx)));
+            Assert.That(ky, Is.EqualTo(expectedKy).Within(ExpectedProcessor.GetAccuracyForExpectedValue(expectedKy)));
+            Assert.That(epsz, Is.EqualTo(expectedEpsZ).Within(ExpectedProcessor.GetAccuracyForExpectedValue(expectedEpsZ)));
         }
 
         [TestCase(0.4d, 0.6d, 0.012d, 0.025d, 2, 2, false, true, true)]
@@ -54,9 +54,9 @@ namespace StructureHelperTests.FunctionalTests.Ndms.Calculators.ForceCalculatorT
             calculator.Run();
             var result = calculator.Result as IForcesResults;
             //Assert
-            Assert.IsNotNull(result);
-            Assert.True(calcResult == result.IsValid);
-            Assert.True(firstForceResult == result.ForcesResultList[0].IsValid);
+            Assert.That(result, Is.Not.Null);
+            Assert.That(calcResult == result.IsValid, Is.True);
+            Assert.That(firstForceResult == result.ForcesResultList[0].IsValid, Is.True);
         }
 
         [TestCase(0.4d, 0.6d, 0.012d, 0.025d, 2, 2, 0d, 0d, 0d)]
@@ -80,15 +80,15 @@ namespace StructureHelperTests.FunctionalTests.Ndms.Calculators.ForceCalculatorT
             calculator.Run();
             var result2 = calculator.Result as IForcesResults;
             //Assert
-            Assert.IsNotNull(result2);
-            Assert.IsTrue(result2.IsValid);
+            Assert.That(result2, Is.Not.Null);
+            Assert.That(result2.IsValid, Is.True);
             var strainMatrix2 = result2.ForcesResultList[0].LoaderResults.StrainMatrix;
             var kx = strainMatrix2.Kx;
             var ky = strainMatrix2.Ky;
             var epsz = strainMatrix2.EpsZ;
-            Assert.AreEqual(expectedKx, kx, 1e-10);
-            Assert.AreEqual(expectedKy, ky, 1e-10);
-            Assert.AreEqual(expectedEpsZ, epsz, 1e-10);
+            Assert.That(kx, Is.EqualTo(expectedKx).Within(1e-10));
+            Assert.That(ky, Is.EqualTo(expectedKy).Within(1e-10));
+            Assert.That(epsz, Is.EqualTo(expectedEpsZ).Within(1e-10));
         }
     }
 }
diff --git a/StructureHelperTests/FunctionalTests/Ndms/RCSections/BucklingLogicTest.cs b/StructureHelperTests/FunctionalTests/Ndms/RCSections/BucklingLogicTest.cs
index 56abd72..aebff5d 100644
--- a/StructureHelperTests/FunctionalTests/Ndms/RCSections/BucklingLogicTest.cs
+++ b/StructureHelperTests/FunctionalTests/Ndms/RCSections/BucklingLogicTest.cs
@@ -31,7 +31,7 @@ namespace StructureHelperTests.FunctionalTests.Ndms.RCSections
             var phiLogic = new PhiLogicSP63(fullTuple, longTuple, point);
             var phiL = phiLogic.GetPhil();
             //Assert
-            Assert.AreEqual(expectedPhi, phiL, 0.01d);
+            Assert.That(phiL, Is.EqualTo(expectedPhi).Within(0.01d));
         }
 
         [TestCase(0d, 0.5d, 0.15d)]
@@ -44,7 +44,7 @@ namespace StructureHelperTests.FunctionalTests.Ndms.RCSections
             var deltaELogic = new DeltaELogicSP63(eccentricity, size);
             var deltaE = deltaELogic.GetDeltaE();
             //Assert
-            Assert.AreEqual(expectedDeltaE, deltaE, 0.01d);
+            Assert.That(deltaE, Is.EqualTo(expectedDeltaE).Within(0.01d));
         }
     }
 }
diff --git a/StructureHelperTests/FunctionalTests/RCs/Eccentricitis/RcAccEccentricityAxisTest.cs b/StructureHelperTests/FunctionalTests/RCs/Eccentricitis/RcAccEccentricityAxisTest.cs
index 1691ca2..4361bc9 100644
--- a/StructureHelperTests/FunctionalTests/RCs/Eccentricitis/RcAccEccentricityAxisTest.cs
+++ b/StructureHelperTests/FunctionalTests/RCs/Eccentricitis/RcAccEccentricityAxisTest.cs
@@ -32,7 +32,7 @@ namespace StructureHelperTests.FunctionalTests.RCs.Eccentricitis
 
             // Assert
             //loggerMock.Verify(logger => logger.AddMessage(It.IsAny<string>(), It.IsAny<TraceLogStatuses>()), Times.Exactly(7)); // Adjust based on your actual calls
-            Assert.AreEqual(expectedEccentricity, result, 0.0001); // Adjust based on your expected result
+            Assert.That(result, Is.EqualTo(expectedEccentricity).Within(0.0001)); // Adjust based on your expected result
                                                            // Add more assertions based on your expected behavior
         }
     }
diff --git a/StructureHelperTests/FunctionalTests/RCs/Eccentricitis/RcAccEccentricityTest.cs b/StructureHelperTests/FunctionalTests/RCs/Eccentricitis/RcAccEccentricityTest.cs
index 673a002..7f2e277 100644
--- a/StructureHelperTests/FunctionalTests/RCs/Eccentricitis/RcAccEccentricityTest.cs
+++ b/StructureHelperTests/FunctionalTests/RCs/Eccentricitis/RcAccEccentricityTest.cs
@@ -35,8 +35,8 @@ namespace StructureHelperTests.FunctionalTests.RCs.Eccentricitis
             // Assert
             eccentricityAxisLogicMock.Verify(el => el.GetValue(), Times.Exactly(2));
             //loggerMock.Verify(logger => logger.AddMessage(It.IsAny<string>(), It.IsAny<TraceLogStatuses>()), Times.Exactly(3)); // Adjust based on your actual calls
-            Assert.AreEqual(3.0, result.ex, 0.001); // Adjust based on your expected result
-            Assert.AreEqual(3.0, result.ey, 0.001); // Adjust based on your expected result
+            Assert.That(result.ex, Is.EqualTo(3.0).Within(0.001)); // Adjust based on your expected result
+            Assert.That(result.ey, Is.EqualTo(3.0).Within(0.001)); // Adjust based on your expected result
                                                     // Add more assertions based on your expected behavior
         }
     }
diff --git a/StructureHelperTests/FunctionalTests/RCs/Eccentricitis/RcEccentricityLogicTest.cs b/StructureHelperTests/FunctionalTests/RCs/Eccentricitis/RcEccentricityLogicTest.cs
index bef8dcd..c56768e 100644
--- a/StructureHelperTests/FunctionalTests/RCs/Eccentricitis/RcEccentricityLogicTest.cs
+++ b/StructureHelperTests/FunctionalTests/RCs/Eccentricitis/RcEccentricityLogicTest.cs
@@ -50,8 +50,8 @@ namespace StructureHelperTests.FunctionalTests.RCs.Eccentricitis
             eccentricityLogicMock.Verify(el => el.GetValue(), Times.Once);
             //loggerMock.Verify(logger => logger.AddMessage(It.IsAny<string>(), It.IsAny<TraceLogStatuses>()), Times.Exactly(6)); // Adjust based on your actual calls
             //loggerMock.Verify(logger => logger.AddEntry(It.IsAny<string>()), Times.Once); // Adjust based on your actual calls
-            Assert.AreEqual(expectedMx, result.Mx, 0.001); // Adjust based on your expected result
-            Assert.AreEqual(expectedMy, result.My, 0.001); // Adjust based on your expected result
+            Assert.That(result.Mx, Is.EqualTo(expectedMx).Within(0.001d)); // Adjust based on your expected result
+            Assert.That(result.My, Is.EqualTo(expectedMy).Within(0.001d)); // Adjust based on your expected result
                                                         // Add more assertions based on your expected behavior
         }
     }
diff --git a/StructureHelperTests/Infrastructures/ShTables/TraceTablesFactoryTests.cs b/StructureHelperTests/Infrastructures/ShTables/TraceTablesFactoryTests.cs
index 859074c..8cc4e72 100644
--- a/StructureHelperTests/Infrastructures/ShTables/TraceTablesFactoryTests.cs
+++ b/StructureHelperTests/Infrastructures/ShTables/TraceTablesFactoryTests.cs
@@ -20,12 +20,12 @@ namespace StructureHelperTests.Infrastructures.ShTables
             var result = factory.GetByPoint2D(mockPoint);
 
             // Assert
-            Assert.IsNotNull(result);
-            Assert.AreEqual(2, result.Table.RowCount);
-            Assert.AreEqual("X", (result.Table.GetCell(0, 0).Value as StringLogEntry).Message);
-            Assert.AreEqual("Y", (result.Table.GetCell(0, 1).Value as StringLogEntry).Message);
-            Assert.AreEqual("1", (result.Table.GetCell(1, 0).Value as StringLogEntry).Message);
-            Assert.AreEqual("2", (result.Table.GetCell(1, 1).Value as StringLogEntry).Message);
+            Assert.That(result, Is.Not.Null);
+            Assert.That(2, Is.EqualTo(result.Table.RowCount));
+            Assert.That((result.Table.GetCell(0, 0).Value as StringLogEntry).Message, Is.EqualTo("X"));
+            Assert.That((result.Table.GetCell(0, 1).Value as StringLogEntry).Message, Is.EqualTo("Y"));
+            Assert.That((result.Table.GetCell(1, 0).Value as StringLogEntry).Message, Is.EqualTo("1"));
+            Assert.That((result.Table.GetCell(1, 1).Value as StringLogEntry).Message, Is.EqualTo("2"));
         }
 
         [Test]
@@ -44,16 +44,16 @@ namespace StructureHelperTests.Infrastructures.ShTables
             var result = factory.GetByPoint2D(mockPoints);
 
             // Assert
-            Assert.IsNotNull(result);
-            Assert.AreEqual(4, result.Table.RowCount); // Header + 3 Point rows
-            Assert.AreEqual("X", (result.Table.GetCell(0, 0).Value as StringLogEntry).Message);
-            Assert.AreEqual("Y", (result.Table.GetCell(0, 1).Value as StringLogEntry).Message);
-            Assert.AreEqual("1", (result.Table.GetCell(1, 0).Value as StringLogEntry).Message);
-            Assert.AreEqual("2", (result.Table.GetCell(1, 1).Value as StringLogEntry).Message);
-            Assert.AreEqual("3", (result.Table.GetCell(2, 0).Value as StringLogEntry).Message);
-            Assert.AreEqual("4", (result.Table.GetCell(2, 1).Value as StringLogEntry).Message);
-            Assert.AreEqual("5", (result.Table.GetCell(3, 0).Value as StringLogEntry).Message);
-            Assert.AreEqual("6", (result.Table.GetCell(3, 1).Value as StringLogEntry).Message);
+            Assert.That(result, Is.Not.Null);
+            Assert.That(result.Table.RowCount, Is.EqualTo(4));// Header + 3 Point rows
+            Assert.That((result.Table.GetCell(0, 0).Value as StringLogEntry).Message, Is.EqualTo("X"));
+            Assert.That((result.Table.GetCell(0, 1).Value as StringLogEntry).Message, Is.EqualTo("Y"));
+            Assert.That((result.Table.GetCell(1, 0).Value as StringLogEntry).Message, Is.EqualTo("1"));
+            Assert.That((result.Table.GetCell(1, 1).Value as StringLogEntry).Message, Is.EqualTo("2"));
+            Assert.That((result.Table.GetCell(2, 0).Value as StringLogEntry).Message, Is.EqualTo("3"));
+            Assert.That((result.Table.GetCell(2, 1).Value as StringLogEntry).Message, Is.EqualTo("4"));
+            Assert.That((result.Table.GetCell(3, 0).Value as StringLogEntry).Message, Is.EqualTo("5"));
+            Assert.That((result.Table.GetCell(3, 1).Value as StringLogEntry).Message, Is.EqualTo("6"));
         }
 
         [Test]
@@ -67,10 +67,10 @@ namespace StructureHelperTests.Infrastructures.ShTables
             var result = factory.GetByPoint2D(emptyPoints);
 
             // Assert
-            Assert.IsNotNull(result);
-            Assert.AreEqual(1, result.Table.RowCount); // Only Header row
-            Assert.AreEqual("X", (result.Table.GetCell(0, 0).Value as StringLogEntry).Message);
-            Assert.AreEqual("Y", (result.Table.GetCell(0, 1).Value as StringLogEntry).Message);
+            Assert.That(result, Is.Not.Null);
+            Assert.That(result.Table.RowCount, Is.EqualTo(1));// Only Header row
+            Assert.That((result.Table.GetCell(0, 0).Value as StringLogEntry).Message, Is.EqualTo("X"));
+            Assert.That((result.Table.GetCell(0, 1).Value as StringLogEntry).Message, Is.EqualTo("Y"));
         }
 
         // Add more test cases for different scenarios and edge cases
diff --git a/StructureHelperTests/LibrariesTests/Ndms/RCSections/RCSectionTest.cs b/StructureHelperTests/LibrariesTests/Ndms/RCSections/RCSectionTest.cs
index 381e806..ff0a7b5 100644
--- a/StructureHelperTests/LibrariesTests/Ndms/RCSections/RCSectionTest.cs
+++ b/StructureHelperTests/LibrariesTests/Ndms/RCSections/RCSectionTest.cs
@@ -58,12 +58,12 @@ namespace LoaderCalculator.Tests.FunctionalTests.SectionTests
             calculator.Run(loaderData, new CancellationToken());
             var results = calculator.Result;
             //Assert
-            Assert.NotNull(results);
+            Assert.That(results, Is.Not.Null);
             var strainMatrix = results.StrainMatrix;
-            Assert.NotNull(strainMatrix);
-            Assert.AreEqual(expectedKx, strainMatrix.Kx, ExpectedProcessor.GetAccuracyForExpectedValue(expectedKx));
-            Assert.AreEqual(expectedKy, strainMatrix.Ky, ExpectedProcessor.GetAccuracyForExpectedValue(expectedKy));
-            Assert.AreEqual(expectedEpsilonZ, strainMatrix.EpsZ, ExpectedProcessor.GetAccuracyForExpectedValue(expectedEpsilonZ));
+            Assert.That(strainMatrix, Is.Not.Null);
+            Assert.That(strainMatrix.Kx, Is.EqualTo(expectedKx).Within(ExpectedProcessor.GetAccuracyForExpectedValue(expectedKx)));
+            Assert.That(strainMatrix.Ky, Is.EqualTo(expectedKy).Within(ExpectedProcessor.GetAccuracyForExpectedValue(expectedKy)));
+            Assert.That(strainMatrix.EpsZ, Is.EqualTo(expectedEpsilonZ).Within(ExpectedProcessor.GetAccuracyForExpectedValue(expectedEpsilonZ)));
         }
         //Longitudenal prestrain only
         [TestCase(0.000494, 0.000494, 0d, 0d, 0d, 0d, 0d, 0d, 0d, 0.0d, 0d)]
@@ -98,12 +98,12 @@ namespace LoaderCalculator.Tests.FunctionalTests.SectionTests
             calculator.Run(loaderData, new CancellationToken());
             var results = calculator.Result;
             //Assert
-            Assert.NotNull(results);
+            Assert.That(results, Is.Not.Null);
             var strainMatrix = results.StrainMatrix;
-            Assert.NotNull(strainMatrix);
-            Assert.AreEqual(expectedKx, strainMatrix.Kx, ExpectedProcessor.GetAccuracyForExpectedValue(expectedKx));
-            Assert.AreEqual(expectedKy, strainMatrix.Ky, ExpectedProcessor.GetAccuracyForExpectedValue(expectedKy));
-            Assert.AreEqual(expectedEpsilonZ, strainMatrix.EpsZ, ExpectedProcessor.GetAccuracyForExpectedValue(expectedEpsilonZ));
+            Assert.That(strainMatrix, Is.Not.Null);
+            Assert.That(strainMatrix.Kx, Is.EqualTo(expectedKx).Within(ExpectedProcessor.GetAccuracyForExpectedValue(expectedKx)));
+            Assert.That(strainMatrix.Ky, Is.EqualTo(expectedKy).Within(ExpectedProcessor.GetAccuracyForExpectedValue(expectedKy)));
+            Assert.That(strainMatrix.EpsZ, Is.EqualTo(expectedEpsilonZ).Within(ExpectedProcessor.GetAccuracyForExpectedValue(expectedEpsilonZ)));
         }
 
         private void ArrangeMaterial(LimitStates limitStates, bool isShortTerm)
diff --git a/StructureHelperTests/StructureHelperTests.csproj b/StructureHelperTests/StructureHelperTests.csproj
index fc3f661..5db161e 100644
--- a/StructureHelperTests/StructureHelperTests.csproj
+++ b/StructureHelperTests/StructureHelperTests.csproj
@@ -10,10 +10,10 @@
 
   <ItemGroup>
     <PackageReference Include="Castle.Core" Version="5.1.1" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.5.0" />
-    <PackageReference Include="Moq" Version="4.18.4" />
-    <PackageReference Include="NUnit" Version="3.13.3" />
-    <PackageReference Include="NUnit3TestAdapter" Version="4.3.1" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.12.0" />
+    <PackageReference Include="Moq" Version="4.20.72" />
+    <PackageReference Include="NUnit" Version="4.3.0" />
+    <PackageReference Include="NUnit3TestAdapter" Version="4.6.0" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/StructureHelperTests/UnitTests/Calcuators/CheckForceTupleInputDataLogicTests.cs b/StructureHelperTests/UnitTests/Calcuators/CheckForceTupleInputDataLogicTests.cs
index a993eb5..6073ae7 100644
--- a/StructureHelperTests/UnitTests/Calcuators/CheckForceTupleInputDataLogicTests.cs
+++ b/StructureHelperTests/UnitTests/Calcuators/CheckForceTupleInputDataLogicTests.cs
@@ -52,7 +52,7 @@ namespace StructureHelperTests.UnitTests.Calcuators
             var result = _checkLogic.Check();
 
             // Assert
-            Assert.IsFalse(result);
+            Assert.That(result, Is.False);
             //Assert.That(_checkLogic.CheckResult, Is.EqualTo("Ndm collection is null or empty"));
             _mockTraceLogger.Verify(x => x.AddMessage("\nNdm collection is null or empty"), Times.Once);
         }
@@ -68,7 +68,7 @@ namespace StructureHelperTests.UnitTests.Calcuators
             var result = _checkLogic.Check();
 
             // Assert
-            Assert.IsFalse(result);
+            Assert.That(result, Is.False);
             //Assert.That(_checkLogic.CheckResult, Is.EqualTo("Force tuple is null"));
             _mockTraceLogger.Verify(x => x.AddMessage("\nForce tuple is null"), Times.Once);
         }
@@ -85,7 +85,7 @@ namespace StructureHelperTests.UnitTests.Calcuators
             var result = _checkLogic.Check();
 
             // Assert
-            Assert.IsFalse(result);
+            Assert.That(result, Is.False);
             //Assert.That(_checkLogic.CheckResult, Is.EqualTo("Accuracy requirements is not assigned"));
             _mockTraceLogger.Verify(x => x.AddMessage("\nAccuracy requirements is not assigned"), Times.Once);
         }
@@ -106,7 +106,7 @@ namespace StructureHelperTests.UnitTests.Calcuators
             var result = _checkLogic.Check();
 
             // Assert
-            Assert.IsFalse(result);
+            Assert.That(result, Is.False);
             //Assert.That(_checkLogic.CheckResult, Is.EqualTo("Value of accuracy 0 must be grater than zeroMax number of iteration 0 must be grater than zero"));
             _mockTraceLogger.Verify(x => x.AddMessage("\nValue of accuracy 0 must be grater than zero"), Times.Once);
             _mockTraceLogger.Verify(x => x.AddMessage("\nMax number of iteration 0 must be grater than zero"), Times.Once);
@@ -128,7 +128,7 @@ namespace StructureHelperTests.UnitTests.Calcuators
             var result = _checkLogic.Check();
 
             // Assert
-            Assert.IsTrue(result);
+            Assert.That(result, Is.True);
             Assert.That(_checkLogic.CheckResult, Is.EqualTo(string.Empty));
         }
     }
diff --git a/StructureHelperTests/UnitTests/Calcuators/FindParameterTest.cs b/StructureHelperTests/UnitTests/Calcuators/FindParameterTest.cs
index e9a3313..1e58480 100644
--- a/StructureHelperTests/UnitTests/Calcuators/FindParameterTest.cs
+++ b/StructureHelperTests/UnitTests/Calcuators/FindParameterTest.cs
@@ -19,9 +19,9 @@ namespace StructureHelperTests.UnitTests.Calcuators
             calculator.Run();
             var result = calculator.Result as FindParameterResult;
             //Assert
-            Assert.NotNull(result);
-            Assert.IsTrue(result.IsValid);
-            Assert.AreEqual(predicateValue, expectedValue, 0.001d);
+            Assert.That(result, Is.Not.Null);
+            Assert.That(result.IsValid, Is.True);
+            Assert.That(expectedValue, Is.EqualTo(predicateValue).Within(0.001d));
         }
         [TestCase(0d, 1d, 5d, 5d, false)]
         [TestCase(0d, 10d, 15d, 15d, false)]
@@ -36,8 +36,8 @@ namespace StructureHelperTests.UnitTests.Calcuators
             calculator.Run();
             var result = calculator.Result as FindParameterResult;
             //Assert
-            Assert.NotNull(result);
-            Assert.IsTrue(result.IsValid == isValid);
+            Assert.That(result, Is.Not.Null);
+            Assert.That(result.IsValid == isValid, Is.True);
         }
     }
 }
diff --git a/StructureHelperTests/UnitTests/Calcuators/LimitCurveCalculatorTest.cs b/StructureHelperTests/UnitTests/Calcuators/LimitCurveCalculatorTest.cs
index 7ce50d8..ed8d515 100644
--- a/StructureHelperTests/UnitTests/Calcuators/LimitCurveCalculatorTest.cs
+++ b/StructureHelperTests/UnitTests/Calcuators/LimitCurveCalculatorTest.cs
@@ -25,7 +25,7 @@ namespace StructureHelperTests.UnitTests.Calcuators
             calculator.Run();
             var result = calculator.Result;
             //Assert
-            Assert.IsNotNull(result);
+            Assert.That(result, Is.Not.Null);
         }
     }
 }
diff --git a/StructureHelperTests/UnitTests/Calcuators/LimitCurveLogicTest.cs b/StructureHelperTests/UnitTests/Calcuators/LimitCurveLogicTest.cs
index 13d0ede..f68a575 100644
--- a/StructureHelperTests/UnitTests/Calcuators/LimitCurveLogicTest.cs
+++ b/StructureHelperTests/UnitTests/Calcuators/LimitCurveLogicTest.cs
@@ -31,13 +31,12 @@ namespace StructureHelperTests.UnitTests.Calcuators
             var result = limitCurveLogic.GetPoints(inputPoints);
 
             // Assert
-            Assert.IsNotNull(result);
-            Assert.AreEqual(inputPoints.Count, result.Count);
-
+            Assert.That(result, Is.Not.Null);
+            Assert.That(result.Count, Is.EqualTo(inputPoints.Count));
             for (int i = 0; i < inputPoints.Count; i++)
             {
-                Assert.AreEqual(0.5d, result[i].X, 0.01d);
-                Assert.AreEqual(inputPoints[i].Y / inputPoints[i].X * 0.5d, result[i].Y, 0.01d);
+                Assert.That(result[i].X, Is.EqualTo(0.5d).Within(0.01d));
+                Assert.That(result[i].Y, Is.EqualTo(inputPoints[i].Y / inputPoints[i].X * 0.5d).Within(0.01d));
             }
         }
     }
diff --git a/StructureHelperTests/UnitTests/Calcuators/SoilAnchorCalculatorTest.cs b/StructureHelperTests/UnitTests/Calcuators/SoilAnchorCalculatorTest.cs
index eca8f6f..3846efe 100644
--- a/StructureHelperTests/UnitTests/Calcuators/SoilAnchorCalculatorTest.cs
+++ b/StructureHelperTests/UnitTests/Calcuators/SoilAnchorCalculatorTest.cs
@@ -34,9 +34,9 @@ namespace StructureHelperTests.UnitTests.Calcuators
             calculator.Run();
             var result = calculator.Result as AnchorResult;
             //Assert
-            Assert.IsNotNull(result);
-            Assert.AreEqual(expectedCharBearingCapacity, result.CharBearingCapacity, expectedCharBearingCapacity * 1e-6d);
-            Assert.AreEqual(expectedDesignBearingCapacity, result.DesignBearingCapacity, expectedDesignBearingCapacity * 1e-6d);
+            Assert.That(result, Is.Not.Null);
+            Assert.That(result.CharBearingCapacity, Is.EqualTo(expectedCharBearingCapacity).Within(expectedCharBearingCapacity * 1e-6d));
+            Assert.That(result.DesignBearingCapacity, Is.EqualTo(expectedDesignBearingCapacity).Within(expectedDesignBearingCapacity * 1e-6d));
         }
 
         [TestCase(6d, 0.2d, 7d, 0.145d, 0.28290937500000002d, 0.13633537500000006d)]
@@ -57,9 +57,9 @@ namespace StructureHelperTests.UnitTests.Calcuators
             calculator.Run();
             var result = calculator.Result as AnchorResult;
             //Assert
-            Assert.IsNotNull(result);
-            Assert.AreEqual(expectedVolume1, result.MortarVolumeFstStady, expectedVolume1 * 1e-6d);
-            Assert.AreEqual(expectedVolume2, result.MortarVolumeSndStady, expectedVolume2 * 1e-6d);
+            Assert.That(result, Is.Not.Null);
+            Assert.That(result.MortarVolumeFstStady, Is.EqualTo(expectedVolume1).Within(expectedVolume1 * 1e-6d));
+            Assert.That(result.MortarVolumeSndStady, Is.EqualTo(expectedVolume2).Within(expectedVolume2 * 1e-6d));
         }
     }
 }
diff --git a/StructureHelperTests/UnitTests/ConvertStrategiesTest/ProjectFromDTOConvertStrategyTests.cs b/StructureHelperTests/UnitTests/ConvertStrategiesTest/ProjectFromDTOConvertStrategyTests.cs
index 006924a..3f34d8f 100644
--- a/StructureHelperTests/UnitTests/ConvertStrategiesTest/ProjectFromDTOConvertStrategyTests.cs
+++ b/StructureHelperTests/UnitTests/ConvertStrategiesTest/ProjectFromDTOConvertStrategyTests.cs
@@ -89,7 +89,7 @@ namespace StructureHelperTests.UnitTests.ConvertStrategiesTest
             var analyses = _convertStrategy.GetAnalyses(projectDto, newItem);
 
             // Assert
-            Assert.AreEqual(projectDto.VisualAnalyses.Count, analyses.Count);
+            Assert.That(analyses.Count, Is.EqualTo(projectDto.VisualAnalyses.Count));
             _mockConvertLogic.Verify(s => s.Convert(It.IsAny<IVisualAnalysis>()), Times.Exactly(projectDto.VisualAnalyses.Count));
             _mockTraceLogger.Verify(logger => logger.AddMessage($"Source project has {projectDto.VisualAnalyses.Count} analyses"), Times.Once);
         }
diff --git a/StructureHelperTests/UnitTests/MaterialTests/MaterialStrengthTest.cs b/StructureHelperTests/UnitTests/MaterialTests/MaterialStrengthTest.cs
index 86b8db4..c86744f 100644
--- a/StructureHelperTests/UnitTests/MaterialTests/MaterialStrengthTest.cs
+++ b/StructureHelperTests/UnitTests/MaterialTests/MaterialStrengthTest.cs
@@ -27,8 +27,8 @@ namespace StructureHelperTests.UnitTests.MaterialTests
             var compressive = libMaterial.GetStrength(limitState, calcTerm).Compressive;
             var tensile = libMaterial.GetStrength(limitState, calcTerm).Tensile;
             //Assert
-            Assert.AreEqual(expectedCompressive, compressive, 1d);
-            Assert.AreEqual(expectedTensile, tensile, 1d);
+            Assert.That(compressive, Is.EqualTo(expectedCompressive).Within(1d));
+            Assert.That(tensile, Is.EqualTo(expectedTensile).Within(1d));
         }
     }
 }
diff --git a/StructureHelperTests/UnitTests/Ndms/CheckPrimitiveCollectionLogicTests.cs b/StructureHelperTests/UnitTests/Ndms/CheckPrimitiveCollectionLogicTests.cs
index b58b9dd..7ad0681 100644
--- a/StructureHelperTests/UnitTests/Ndms/CheckPrimitiveCollectionLogicTests.cs
+++ b/StructureHelperTests/UnitTests/Ndms/CheckPrimitiveCollectionLogicTests.cs
@@ -42,7 +42,7 @@ namespace StructureHelperTests.UnitTests.Ndms
             var result = _mockCheckPrimitiveCollectionLogic.Object.Check();
 
             // Assert
-            Assert.IsFalse(result);
+            Assert.That(result, Is.False);
             Assert.That(_mockCheckPrimitiveCollectionLogic.Object.CheckResult, Is.EqualTo("Calculator does not contain any primitives\n"));
             //_mockTraceLogger.Verify(x => x.AddMessage("Calculator does not contain any primitives\n", TraceLogStatuses.Error), Times.Once);
         }
@@ -60,7 +60,7 @@ namespace StructureHelperTests.UnitTests.Ndms
             var result = _mockCheckPrimitiveCollectionLogic.Object.Check();
 
             // Assert
-            Assert.IsFalse(result);
+            Assert.That(result, Is.False);
             Assert.That(_mockCheckPrimitiveCollectionLogic.Object.CheckResult, Is.EqualTo("Rebar check failed\n"));
         }
 
@@ -82,7 +82,7 @@ namespace StructureHelperTests.UnitTests.Ndms
             var result = _mockCheckPrimitiveCollectionLogic.Object.Check();
 
             // Assert
-            Assert.IsFalse(result);
+            Assert.That(result, Is.False);
             Assert.That(_mockCheckPrimitiveCollectionLogic.Object.CheckResult, Is.EqualTo("Host RebarName (HostPrimitiveName) is not included in primitives\n"));
             //_mockTraceLogger.Verify(x => x.AddMessage("Host RebarName (HostPrimitiveName) is not included in primitives\n", TraceLogStatuses.Error), Times.Once);
         }
@@ -104,7 +104,7 @@ namespace StructureHelperTests.UnitTests.Ndms
             var result = _mockCheckPrimitiveCollectionLogic.Object.Check();
 
             // Assert
-            Assert.IsTrue(result);
+            Assert.That(result, Is.True);
             Assert.That(_mockCheckPrimitiveCollectionLogic.Object.CheckResult, Is.EqualTo(string.Empty));
         }
     }
diff --git a/StructureHelperTests/UnitTests/Ndms/CheckRebarPrimitiveLogicTests.cs b/StructureHelperTests/UnitTests/Ndms/CheckRebarPrimitiveLogicTests.cs
index a21b310..99c7983 100644
--- a/StructureHelperTests/UnitTests/Ndms/CheckRebarPrimitiveLogicTests.cs
+++ b/StructureHelperTests/UnitTests/Ndms/CheckRebarPrimitiveLogicTests.cs
@@ -46,7 +46,7 @@ namespace StructureHelperTests.UnitTests.Ndms
             var result = _checkRebarPrimitiveLogic.Check();
 
             // Assert
-            Assert.IsFalse(result);
+            Assert.That(result, Is.False);
             Assert.That(_checkRebarPrimitiveLogic.CheckResult, Is.EqualTo("Primitive RebarName does not have a host\n"));
             //_mockTraceLogger.Verify(x => x.AddMessage("Primitive RebarName does not have a host\n", TraceLogStatuses.Error), Times.Once);
         }
@@ -84,7 +84,7 @@ namespace StructureHelperTests.UnitTests.Ndms
             var result = _checkRebarPrimitiveLogic.Check();
 
             // Assert
-            Assert.IsFalse(result);
+            Assert.That(result, Is.False);
             Assert.That(_checkRebarPrimitiveLogic.CheckResult, Is.EqualTo("Material of host of RebarName ()  does not support cracking\n"));
             //_mockTraceLogger.Verify(x => x.AddMessage("Material of host of RebarName ()  does not support cracking\n", TraceLogStatuses.Error), Times.Once);
         }
diff --git a/StructureHelperTests/UnitTests/Ndms/Cracks/CrackWidthLogicSP63Test.cs b/StructureHelperTests/UnitTests/Ndms/Cracks/CrackWidthLogicSP63Test.cs
index 4f3d32f..8784098 100644
--- a/StructureHelperTests/UnitTests/Ndms/Cracks/CrackWidthLogicSP63Test.cs
+++ b/StructureHelperTests/UnitTests/Ndms/Cracks/CrackWidthLogicSP63Test.cs
@@ -30,7 +30,7 @@ namespace StructureHelperTests.UnitTests.Ndms.Cracks
             //Act
             var width = logic.GetCrackWidth();
             //Assert
-            Assert.AreEqual(expectedWidth, width, 0.000001d);
+            Assert.That(width, Is.EqualTo(expectedWidth).Within(0.000001d));
         }
 
     }
diff --git a/StructureHelperTests/UnitTests/Ndms/Cracks/EquivalentDiameterLogicTest.cs b/StructureHelperTests/UnitTests/Ndms/Cracks/EquivalentDiameterLogicTest.cs
index f710f8b..8efed31 100644
--- a/StructureHelperTests/UnitTests/Ndms/Cracks/EquivalentDiameterLogicTest.cs
+++ b/StructureHelperTests/UnitTests/Ndms/Cracks/EquivalentDiameterLogicTest.cs
@@ -30,7 +30,7 @@ namespace StructureHelperTests.UnitTests.Ndms.Cracks
             //Act
             var eqDiametr = logic.GetAverageDiameter();
             //Assert
-            Assert.AreEqual(expectedDiameter, eqDiametr, 0.0001d);
+            Assert.That(eqDiametr, Is.EqualTo(expectedDiameter).Within(0.0001d));
         }
     }
 }
diff --git a/StructureHelperTests/UnitTests/Ndms/Cracks/InputDataTests/CheckTupleCalculatorInputDataTests.cs b/StructureHelperTests/UnitTests/Ndms/Cracks/InputDataTests/CheckTupleCalculatorInputDataTests.cs
index ddfb11d..c90d69e 100644
--- a/StructureHelperTests/UnitTests/Ndms/Cracks/InputDataTests/CheckTupleCalculatorInputDataTests.cs
+++ b/StructureHelperTests/UnitTests/Ndms/Cracks/InputDataTests/CheckTupleCalculatorInputDataTests.cs
@@ -28,7 +28,7 @@ public class CheckTupleCalculatorInputDataTests
         var result = _checkTupleCalculatorInputData.Check();
 
         // Assert
-        Assert.IsFalse(result);
+        Assert.That(result, Is.False);
         Assert.That(_checkTupleCalculatorInputData.CheckResult, Is.EqualTo(ErrorStrings.ParameterIsNull + ": InputData"));
     }
 
@@ -46,7 +46,7 @@ public class CheckTupleCalculatorInputDataTests
         var result = _checkTupleCalculatorInputData.Check();
 
         // Assert
-        Assert.IsFalse(result);
+        Assert.That(result, Is.False);
         Assert.That(_checkTupleCalculatorInputData.CheckResult, Is.EqualTo("Collection does not have any primitives"));
     }
 
@@ -64,7 +64,7 @@ public class CheckTupleCalculatorInputDataTests
         var result = _checkTupleCalculatorInputData.Check();
 
         // Assert
-        Assert.IsFalse(result);
+        Assert.That(result, Is.False);
         Assert.That(_checkTupleCalculatorInputData.CheckResult, Is.EqualTo("User crack input data is null"));
     }
 
@@ -82,7 +82,7 @@ public class CheckTupleCalculatorInputDataTests
         var result = _checkTupleCalculatorInputData.Check();
 
         // Assert
-        Assert.IsTrue(result);
+        Assert.That(result, Is.True);
         Assert.That(_checkTupleCalculatorInputData.CheckResult, Is.EqualTo(string.Empty));
     }
 };
diff --git a/StructureHelperTests/UnitTests/Ndms/Cracks/RebarCalulatorsFactoryTests.cs b/StructureHelperTests/UnitTests/Ndms/Cracks/RebarCalulatorsFactoryTests.cs
index 396427b..f1352d1 100644
--- a/StructureHelperTests/UnitTests/Ndms/Cracks/RebarCalulatorsFactoryTests.cs
+++ b/StructureHelperTests/UnitTests/Ndms/Cracks/RebarCalulatorsFactoryTests.cs
@@ -38,9 +38,9 @@ namespace StructureHelperTests.UnitTests.Ndms.Cracks
 
             // Assert
             var calculator = calculators[0];
-            Assert.NotNull(calculator);
-            Assert.AreEqual(rebarCrackInputData, calculator.InputData);
-            Assert.Null(calculator.TraceLogger);
+            Assert.That(calculator, Is.Not.Null);
+            Assert.That(calculator.InputData, Is.EqualTo(rebarCrackInputData));
+            Assert.That(calculator.TraceLogger, Is.Null);
         }
 
         [Test]
@@ -75,8 +75,8 @@ namespace StructureHelperTests.UnitTests.Ndms.Cracks
             var calculators = factory.GetCalculators();
 
             // Assert
-            Assert.AreEqual(2, calculators.Count);
-            Assert.AreEqual(rebarInputData1, calculators[0].InputData);
+            Assert.That(calculators.Count, Is.EqualTo(2));
+            Assert.That(calculators[0].InputData, Is.EqualTo(rebarInputData1));
             //Assert.AreEqual(rebarInputData2, calculators[1].InputData);
             //Assert.AreEqual(mockLogger.Object, calculators[0].TraceLogger);
             //Assert.AreEqual(mockLogger.Object, calculators[1].TraceLogger);
diff --git a/StructureHelperTests/UnitTests/Ndms/Cracks/RebarStressResultLogicTests.cs b/StructureHelperTests/UnitTests/Ndms/Cracks/RebarStressResultLogicTests.cs
index 8c99ea4..c728d25 100644
--- a/StructureHelperTests/UnitTests/Ndms/Cracks/RebarStressResultLogicTests.cs
+++ b/StructureHelperTests/UnitTests/Ndms/Cracks/RebarStressResultLogicTests.cs
@@ -46,8 +46,8 @@ namespace StructureHelperTests.UnitTests.Ndms.Cracks
             // Act
             var result = _rebarStressResultLogic.GetRebarStressResult();
 
-            // Assert
-            Assert.AreEqual(mockRebarStressResult, result);
+            // Assert;
+            Assert.That(result, Is.EqualTo(mockRebarStressResult));
             _mockRebarStressCalculator.Verify(x => x.Run(), Times.Once);
         }
 
diff --git a/StructureHelperTests/UnitTests/Ndms/Cracks/TensionREbarAreaSumLogicTest.cs b/StructureHelperTests/UnitTests/Ndms/Cracks/TensionREbarAreaSumLogicTest.cs
index 8b41179..c62fdf1 100644
--- a/StructureHelperTests/UnitTests/Ndms/Cracks/TensionREbarAreaSumLogicTest.cs
+++ b/StructureHelperTests/UnitTests/Ndms/Cracks/TensionREbarAreaSumLogicTest.cs
@@ -46,7 +46,7 @@ namespace StructureHelperTests.UnitTests.Ndms.Cracks
             // Assert
             // Expected result calculation:
             // rebarArea = 1.0 * 1.0 + 2.0 * 1.0 + 3.0 * 1.0 = 6.0
-            Assert.AreEqual(6.0, result);
+            Assert.That(result, Is.EqualTo(6.0));
 
         }
 
@@ -76,7 +76,7 @@ namespace StructureHelperTests.UnitTests.Ndms.Cracks
 
             // Act & Assert
             var ex = Assert.Throws<StructureHelperException>(() => logic.GetTensionRebarArea());
-            StringAssert.Contains("Collection of rebars does not contain any tensile rebars", ex.Message);
+            Assert.That(ex.Message, Does.Contain("Collection of rebars does not contain any tensile rebars"));
         }
     }
 }
diff --git a/StructureHelperTests/UnitTests/Ndms/Cracks/TensionRebarAreaByStrainLogicTest.cs b/StructureHelperTests/UnitTests/Ndms/Cracks/TensionRebarAreaByStrainLogicTest.cs
index ea12e1d..a0de39f 100644
--- a/StructureHelperTests/UnitTests/Ndms/Cracks/TensionRebarAreaByStrainLogicTest.cs
+++ b/StructureHelperTests/UnitTests/Ndms/Cracks/TensionRebarAreaByStrainLogicTest.cs
@@ -53,7 +53,7 @@ namespace StructureHelperTests.UnitTests.Ndms.Cracks
             // reducedArea for rebar 2 = 2.0 * 1.0 / 1.5 = 1.333...
             // reducedArea for rebar 3 = 3.0 * 1.5 / 1.5 = 3.0
             // sumArea = 0.333... + 1.333... + 3.0 = 4.666...
-            Assert.AreEqual(4.666666666666667, result, 9);
+            Assert.That(result, Is.EqualTo(4.666666666666667).Within(9));
         }
         [Test]
         public void GetTensionRebarArea_ShouldThrowException_WhenNoRebarsInTension()
@@ -81,7 +81,8 @@ namespace StructureHelperTests.UnitTests.Ndms.Cracks
 
             // Act & Assert
             var ex = Assert.Throws<StructureHelperException>(() => logic.GetTensionRebarArea());
-            StringAssert.Contains("Collection of rebars does not contain any tensile rebars", ex.Message);
+            Assert.That(ex.Message, Does.Contain("Collection of rebars does not contain any tensile rebars"));
+
 
         }
     }
diff --git a/StructureHelperTests/UnitTests/Ndms/Cracks/TupleRebarCrackSolverTest.cs b/StructureHelperTests/UnitTests/Ndms/Cracks/TupleRebarCrackSolverTest.cs
index b055e93..70fa076 100644
--- a/StructureHelperTests/UnitTests/Ndms/Cracks/TupleRebarCrackSolverTest.cs
+++ b/StructureHelperTests/UnitTests/Ndms/Cracks/TupleRebarCrackSolverTest.cs
@@ -4,6 +4,7 @@ using System.Linq;
 using System.Threading.Tasks;
 using Moq;
 using NUnit.Framework;
+using StructureHelperCommon.Models.Calculators;
 using StructureHelperLogics.NdmCalculations.Cracking;
 using StructureHelperLogics.NdmCalculations.Primitives;
 
@@ -37,9 +38,9 @@ namespace StructureHelperTests.UnitTests.Ndms.Cracks
 
             // Assert
             mockCalculator.Verify(c => c.Run(), Times.Once);
-            Assert.True(solver.IsResultValid);
-            Assert.NotNull(solver.Result);
-            Assert.True(solver.Result.All(r => r.IsValid));
+            Assert.That(solver.IsResultValid, Is.True);
+            Assert.That(solver.Result, Is.Not.Null);
+            Assert.That(solver.Result.All(r => r.IsValid), Is.True);
         }
 
         [Test]
@@ -73,7 +74,7 @@ namespace StructureHelperTests.UnitTests.Ndms.Cracks
             // Assert
             mockCalculator1.Verify(c => c.Run(), Times.Once);
             mockCalculator2.Verify(c => c.Run(), Times.Once);
-            Assert.False(solver.IsResultValid);
+            Assert.That(solver.IsResultValid, Is.False);
         }
     }
 }
\ No newline at end of file
diff --git a/StructureHelperTests/UnitTests/Ndms/Triangulations/RectangleTriangulationTest.cs b/StructureHelperTests/UnitTests/Ndms/Triangulations/RectangleTriangulationTest.cs
index 5b196b5..d366ccf 100644
--- a/StructureHelperTests/UnitTests/Ndms/Triangulations/RectangleTriangulationTest.cs
+++ b/StructureHelperTests/UnitTests/Ndms/Triangulations/RectangleTriangulationTest.cs
@@ -52,11 +52,11 @@ namespace StructureHelperTests.UnitTests.Ndms.Triangulations
             //Act
             var result = logic.GetNdmCollection();
             //Assert
-            Assert.NotNull(result);
-            Assert.AreEqual(expectedCount, result.Count());
+            Assert.That(result, Is.Not.Null);
+            Assert.That(result.Count(), Is.EqualTo(expectedCount));
             var firstNdm = result.First();
-            Assert.AreEqual(expectedFirstCenterX, firstNdm.CenterX);
-            Assert.AreEqual(expectedFirstCenterY, firstNdm.CenterY);
+            Assert.That(firstNdm.CenterX, Is.EqualTo(expectedFirstCenterX));
+            Assert.That(firstNdm.CenterY, Is.EqualTo(expectedFirstCenterY));
         }
         [TestCase(0d, 0d, 1.0d, 1.0d, true, 1d, 3020418448.8512335d, 3020418448.8512335d)]
         [TestCase(0d, 0d, 1.0d, 1.0d, false, 0.94d, 3013186843.9241991d, 3004124682.3615651d)]
@@ -97,9 +97,9 @@ namespace StructureHelperTests.UnitTests.Ndms.Triangulations
             //Assert
             var area = ndms.Sum(x => x.Area);
             var moments = GeometryOperations.GetReducedMomentsOfInertia(ndms);
-            Assert.AreEqual(expectedArea, area, 0.001d);
-            Assert.AreEqual(expectedMomX, moments.EIx, 0.001d);
-            Assert.AreEqual(expectedMomY, moments.EIy, 1d);
+            Assert.That(area, Is.EqualTo(expectedArea).Within(0.001d));
+            Assert.That(moments.EIx, Is.EqualTo(expectedMomX).Within(0.001d));
+            Assert.That(moments.EIy, Is.EqualTo(expectedMomY).Within(1d));
         }
         [TestCase(0d, 0d, 1.0d, 1.0d, true, 1d, 3020017308.3574591d, 3020017308.3574591d)]
         [TestCase(0d, 0d, 1.0d, 1.0d, false, 0.92839999999991407d, 3005633713.5049105d, 3005633713.5049105d)]
@@ -143,9 +143,9 @@ namespace StructureHelperTests.UnitTests.Ndms.Triangulations
             //Assert
             var area = ndms.Sum(x => x.Area);
             var moments = GeometryOperations.GetReducedMomentsOfInertia(ndms);
-            Assert.AreEqual(expectedArea, area, 0.001d);
-            Assert.AreEqual(expectedMomX, moments.EIx, 0.001d);
-            Assert.AreEqual(expectedMomY, moments.EIy, 1d);
+            Assert.That(area, Is.EqualTo(expectedArea).Within(0.001d));
+            Assert.That(moments.EIx, Is.EqualTo(expectedMomX).Within(0.001d));
+            Assert.That(moments.EIy, Is.EqualTo(expectedMomY).Within(1d));
         }
         [TestCase(0d, 0d, 1.0d, true, 0.78079430967489682d, 1777730450.3666615d, 1776732530.5957441d)]
         [TestCase(0d, 0d, 1.0d, false, 0.72079430967490343d, 1770498845.4396176d, 1760438764.1059904d)]
@@ -182,9 +182,9 @@ namespace StructureHelperTests.UnitTests.Ndms.Triangulations
             //Assert
             var area = ndms.Sum(x => x.Area);
             var moments = GeometryOperations.GetReducedMomentsOfInertia(ndms);
-            Assert.AreEqual(expectedArea, area, 0.001d);
-            Assert.AreEqual(expectedMomX, moments.EIx, 0.001d);
-            Assert.AreEqual(expectedMomY, moments.EIy, 1d);
+            Assert.That(area, Is.EqualTo(expectedArea).Within(0.001d));
+            Assert.That(moments.EIx, Is.EqualTo(expectedMomX).Within(0.001d));
+            Assert.That(moments.EIy, Is.EqualTo(expectedMomY).Within(1d));
         }
     }
 }
diff --git a/StructureHelperTests/UnitTests/ParamTests/ProcessDoublePairTest.cs b/StructureHelperTests/UnitTests/ParamTests/ProcessDoublePairTest.cs
index 8ce7ab0..c67a716 100644
--- a/StructureHelperTests/UnitTests/ParamTests/ProcessDoublePairTest.cs
+++ b/StructureHelperTests/UnitTests/ParamTests/ProcessDoublePairTest.cs
@@ -20,8 +20,8 @@ namespace StructureHelperTests.UnitTests.ParamTests
             //Act
             var result = logic.GetValuePairByString(inputString);
             //Assert
-            Assert.AreEqual(expectedText, result.Text);
-            Assert.AreEqual(expectedValue, result.Value, 0.001d);
+            Assert.That(result.Text, Is.EqualTo(expectedText));
+            Assert.That(result.Value, Is.EqualTo(expectedValue).Within(0.001d));
         }
     }
 }
diff --git a/StructureHelperTests/UnitTests/UpdateStrategiesTests/CrackCalculatorUpdateStrategyTests.cs b/StructureHelperTests/UnitTests/UpdateStrategiesTests/CrackCalculatorUpdateStrategyTests.cs
index fe4f899..e7f2b23 100644
--- a/StructureHelperTests/UnitTests/UpdateStrategiesTests/CrackCalculatorUpdateStrategyTests.cs
+++ b/StructureHelperTests/UnitTests/UpdateStrategiesTests/CrackCalculatorUpdateStrategyTests.cs
@@ -74,7 +74,7 @@ namespace StructureHelperTests.UnitTests.UpdateStrategiesTests
             _crackCalculatorUpdateStrategy.Update(targetObject.Object, sourceObject.Object);
 
             // Assert
-            Assert.AreEqual("Source Name", targetObject.Object.Name);
+            Assert.That(targetObject.Object.Name, Is.EqualTo("Source Name"));
             _inputDataUpdateStrategyMock.Verify(s => s.Update(targetInputData, sourceInputData), Times.Once);
         }
 
@@ -96,7 +96,7 @@ namespace StructureHelperTests.UnitTests.UpdateStrategiesTests
             _crackCalculatorUpdateStrategy.Update(targetObject.Object, sourceObject.Object);
 
             // Assert
-            Assert.IsNotNull(targetObject.Object.InputData);
+            Assert.That(targetObject.Object.InputData, Is.Not.Null);
             _inputDataUpdateStrategyMock.Verify(s => s.Update(targetObject.Object.InputData, sourceInputData), Times.Once);
         }
     }
diff --git a/StructureHelperTests/UnitTests/UpdateStrategiesTests/CrackInputDataUpdateStrategyTests.cs b/StructureHelperTests/UnitTests/UpdateStrategiesTests/CrackInputDataUpdateStrategyTests.cs
index af45c91..856d078 100644
--- a/StructureHelperTests/UnitTests/UpdateStrategiesTests/CrackInputDataUpdateStrategyTests.cs
+++ b/StructureHelperTests/UnitTests/UpdateStrategiesTests/CrackInputDataUpdateStrategyTests.cs
@@ -38,8 +38,8 @@ namespace StructureHelperTests.UnitTests.UpdateStrategiesTests
             strategy.Update(targetObject.Object, sourceObject.Object);
 
             // Assert
-            Assert.AreEqual(forceActions, targetObject.Object.ForceActions);
-            Assert.AreEqual(primitives, targetObject.Object.Primitives);
+            Assert.That(targetObject.Object.ForceActions, Is.EqualTo(forceActions));
+            Assert.That(targetObject.Object.Primitives, Is.EqualTo(primitives));
             mockUserCrackInputDataUpdateStrategy.Verify(s => s.Update(It.IsAny<IUserCrackInputData>(), It.IsAny<IUserCrackInputData>()), Times.Once);
         }
 
diff --git a/StructureHelperTests/UnitTests/UpdateStrategiesTests/DeepCloningStrategyTests.cs b/StructureHelperTests/UnitTests/UpdateStrategiesTests/DeepCloningStrategyTests.cs
index fadce7b..b7d782c 100644
--- a/StructureHelperTests/UnitTests/UpdateStrategiesTests/DeepCloningStrategyTests.cs
+++ b/StructureHelperTests/UnitTests/UpdateStrategiesTests/DeepCloningStrategyTests.cs
@@ -25,7 +25,7 @@ namespace StructureHelperTests.UnitTests.UpdateStrategiesTests
             var result = _strategy.Clone<object>(null);
 
             // Assert
-            Assert.IsNull(result);
+            Assert.That(result, Is.Null);
         }
 
         [Test]
@@ -44,7 +44,7 @@ namespace StructureHelperTests.UnitTests.UpdateStrategiesTests
             var result = _strategy.Clone(original);
 
             // Assert
-            Assert.AreSame(expectedClone, result);
+            Assert.That(result, Is.SameAs(expectedClone));
         }
 
         [Test]
@@ -61,7 +61,7 @@ namespace StructureHelperTests.UnitTests.UpdateStrategiesTests
             var result = _strategy.Clone(original, cloneStrategyMock.Object);
 
             // Assert
-            Assert.AreSame(expectedClone, result);
+            Assert.That(result, Is.SameAs(expectedClone));
             cloneStrategyMock.Verify(cs => cs.GetClone(original), Times.Once);
         }
 
@@ -78,7 +78,7 @@ namespace StructureHelperTests.UnitTests.UpdateStrategiesTests
             var result = _strategy.Clone(originalMock.Object);
 
             // Assert
-            Assert.AreSame(expectedClone, result);
+            Assert.That(result, Is.SameAs(expectedClone));
             originalMock.Verify(o => o.Clone(), Times.Once);
         }
 
@@ -110,7 +110,7 @@ namespace StructureHelperTests.UnitTests.UpdateStrategiesTests
             var clonedObjects = (Dictionary<object, object>)internalField.GetValue(_strategy);
 
             // Assert
-            Assert.AreSame(expectedClone, clonedObjects[originalMock.Object]);
+            Assert.That(clonedObjects[originalMock.Object], Is.SameAs(expectedClone));
         }
     }
 
diff --git a/StructureHelperTests/UnitTests/UpdateStrategiesTests/HeadMaterialUpdateStrategyTests.cs b/StructureHelperTests/UnitTests/UpdateStrategiesTests/HeadMaterialUpdateStrategyTests.cs
index 874320e..f34727d 100644
--- a/StructureHelperTests/UnitTests/UpdateStrategiesTests/HeadMaterialUpdateStrategyTests.cs
+++ b/StructureHelperTests/UnitTests/UpdateStrategiesTests/HeadMaterialUpdateStrategyTests.cs
@@ -62,8 +62,8 @@ namespace StructureHelperTests.UnitTests.UpdateStrategiesTests
             _strategy.Update(targetObject, sourceObject);
 
             // Assert
-            Assert.AreEqual("Updated", targetObject.Name, "Name should be updated");
-            Assert.AreEqual(Color.FromRgb(255, 0, 0), targetObject.Color, "Color should be updated");
+            Assert.That(targetObject.Name, Is.EqualTo("Updated"), "Name should be updated");
+            Assert.That(targetObject.Color, Is.EqualTo(Color.FromRgb(255, 0, 0)), "Color should be updated");
         }
 
         [Test]
@@ -77,8 +77,8 @@ namespace StructureHelperTests.UnitTests.UpdateStrategiesTests
             _strategy.Update(targetObject, sourceObject);
 
             // Assert
-            Assert.AreEqual("Updated", (targetObject.HelperMaterial as MockHelperMaterial).Property, "HelperMaterial property should be updated");
-            Assert.AreNotSame(sourceObject.HelperMaterial, targetObject.HelperMaterial,
+            Assert.That((targetObject.HelperMaterial as MockHelperMaterial).Property, Is.EqualTo("Updated"), "HelperMaterial property should be updated");
+            Assert.That(targetObject.HelperMaterial, Is.Not.SameAs(sourceObject.HelperMaterial),
                 "HelperMaterial should be cloned, not directly assigned");
         }
 
diff --git a/StructureHelperTests/ViewModelTests/GraphViewModelTest.cs b/StructureHelperTests/ViewModelTests/GraphViewModelTest.cs
index 858a9c0..5e50338 100644
--- a/StructureHelperTests/ViewModelTests/GraphViewModelTest.cs
+++ b/StructureHelperTests/ViewModelTests/GraphViewModelTest.cs
@@ -1,5 +1,6 @@
 using NUnit.Framework;
 using StructureHelper.Windows.Graphs;
+using StructureHelperCommon.Models.Calculators;
 using StructureHelperCommon.Models.Parameters;
 
 namespace StructureHelperTests.ViewModelTests
@@ -28,9 +29,9 @@ namespace StructureHelperTests.ViewModelTests
             //Act
             var vm = new GraphViewModel(array);
             //Assert
-            Assert.IsNotNull(vm);
-            Assert.AreEqual(columnCount, vm.Series[0].XItems.Collection.Count());
-            Assert.AreEqual(columnCount, vm.Series[0].YItems.CollectionItems.Count());
+            Assert.That(vm, Is.Not.Null);
+            Assert.That(vm.Series[0].XItems.Collection.Count(), Is.EqualTo(columnCount));
+            Assert.That(vm.Series[0].YItems.CollectionItems.Count(), Is.EqualTo(columnCount));
         }
     }
 }
diff --git a/StructureHelperTests/ViewModelTests/NdmPrimitiveTests.cs b/StructureHelperTests/ViewModelTests/NdmPrimitiveTests.cs
index 51f39f5..05ceea7 100644
--- a/StructureHelperTests/ViewModelTests/NdmPrimitiveTests.cs
+++ b/StructureHelperTests/ViewModelTests/NdmPrimitiveTests.cs
@@ -32,7 +32,7 @@ namespace StructureHelperTests.ViewModelTests
             //Act
             var vm = new PrimitivePropertiesViewModel(primitiveBase, new CrossSectionRepository());
             //Assert
-            Assert.NotNull(vm);
+            Assert.That(vm, Is.Not.Null);
         }
 
         public void Circle_Run_ShouldPass()
@@ -46,7 +46,7 @@ namespace StructureHelperTests.ViewModelTests
             //Act
             var vm = new PrimitivePropertiesViewModel(primitiveBase, new CrossSectionRepository());
             //Assert
-            Assert.NotNull(vm);
+            Assert.That(vm, Is.Not.Null);
         }
 
         [Test]
@@ -61,7 +61,7 @@ namespace StructureHelperTests.ViewModelTests
             //Act
             var vm = new PrimitivePropertiesViewModel(primitiveBase, new CrossSectionRepository());
             //Assert
-            Assert.NotNull(vm);
+            Assert.That(vm, Is.Not.Null);
         }
 
         public void Reinforcement_Run_ShouldPass()
@@ -75,7 +75,7 @@ namespace StructureHelperTests.ViewModelTests
             //Act
             var vm = new PrimitivePropertiesViewModel(primitiveBase, new CrossSectionRepository());
             //Assert
-            Assert.NotNull(vm);
+            Assert.That(vm, Is.Not.Null);
         }
     }
 }