diff --git a/src/DemaConsulting.ReqStream/TraceMatrix.cs b/src/DemaConsulting.ReqStream/TraceMatrix.cs
index 0d5efb3..362f860 100644
--- a/src/DemaConsulting.ReqStream/TraceMatrix.cs
+++ b/src/DemaConsulting.ReqStream/TraceMatrix.cs
@@ -475,7 +475,7 @@ private void ExportRequirementSection(TextWriter writer, Section section, int de
     /// <param name="section">The section to check.</param>
     /// <param name="filterTags">The set of filter tags.</param>
     /// <returns>True if the section has filtered content, false otherwise.</returns>
-    private bool SectionHasFilteredContent(Section section, HashSet<string>? filterTags)
+    private static bool SectionHasFilteredContent(Section section, HashSet<string>? filterTags)
     {
         // Check if section has any matching requirements
         if (filterTags == null || filterTags.Count == 0)
diff --git a/test/DemaConsulting.ReqStream.Tests/ContextTests.cs b/test/DemaConsulting.ReqStream.Tests/ContextTests.cs
index 36dfd24..cdcad5a 100644
--- a/test/DemaConsulting.ReqStream.Tests/ContextTests.cs
+++ b/test/DemaConsulting.ReqStream.Tests/ContextTests.cs
@@ -148,15 +148,8 @@ public void Context_Create_ResultsFlag_SetsResultsFileProperty()
     [TestMethod]
     public void Context_Create_MissingResultsFilename_ThrowsException()
     {
-        try
-        {
-            Context.Create(["--results"]);
-            Assert.Fail("Expected ArgumentException was not thrown");
-        }
-        catch (ArgumentException ex)
-        {
-            Assert.Contains("--results requires a filename argument", ex.Message);
-        }
+        var ex = Assert.ThrowsExactly<ArgumentException>(() => Context.Create(["--results"]));
+        Assert.Contains("--results requires a filename argument", ex.Message);
     }
 
     /// <summary>
@@ -225,15 +218,8 @@ public void Context_Create_MatrixFile_SetsMatrixProperty()
     [TestMethod]
     public void Context_Create_UnsupportedArgument_ThrowsException()
     {
-        try
-        {
-            Context.Create(["--unsupported"]);
-            Assert.Fail("Expected ArgumentException was not thrown");
-        }
-        catch (ArgumentException ex)
-        {
-            Assert.Contains("Unsupported argument '--unsupported'", ex.Message);
-        }
+        var ex = Assert.ThrowsExactly<ArgumentException>(() => Context.Create(["--unsupported"]));
+        Assert.Contains("Unsupported argument '--unsupported'", ex.Message);
     }
 
     /// <summary>
@@ -242,15 +228,8 @@ public void Context_Create_UnsupportedArgument_ThrowsException()
     [TestMethod]
     public void Context_Create_MissingLogFilename_ThrowsException()
     {
-        try
-        {
-            Context.Create(["--log"]);
-            Assert.Fail("Expected ArgumentException was not thrown");
-        }
-        catch (ArgumentException ex)
-        {
-            Assert.Contains("--log requires a filename argument", ex.Message);
-        }
+        var ex = Assert.ThrowsExactly<ArgumentException>(() => Context.Create(["--log"]));
+        Assert.Contains("--log requires a filename argument", ex.Message);
     }
 
     /// <summary>
@@ -259,15 +238,8 @@ public void Context_Create_MissingLogFilename_ThrowsException()
     [TestMethod]
     public void Context_Create_MissingReportFilename_ThrowsException()
     {
-        try
-        {
-            Context.Create(["--report"]);
-            Assert.Fail("Expected ArgumentException was not thrown");
-        }
-        catch (ArgumentException ex)
-        {
-            Assert.Contains("--report requires a filename argument", ex.Message);
-        }
+        var ex = Assert.ThrowsExactly<ArgumentException>(() => Context.Create(["--report"]));
+        Assert.Contains("--report requires a filename argument", ex.Message);
     }
 
     /// <summary>
@@ -276,15 +248,8 @@ public void Context_Create_MissingReportFilename_ThrowsException()
     [TestMethod]
     public void Context_Create_MissingMatrixFilename_ThrowsException()
     {
-        try
-        {
-            Context.Create(["--matrix"]);
-            Assert.Fail("Expected ArgumentException was not thrown");
-        }
-        catch (ArgumentException ex)
-        {
-            Assert.Contains("--matrix requires a filename argument", ex.Message);
-        }
+        var ex = Assert.ThrowsExactly<ArgumentException>(() => Context.Create(["--matrix"]));
+        Assert.Contains("--matrix requires a filename argument", ex.Message);
     }
 
     /// <summary>
@@ -293,15 +258,8 @@ public void Context_Create_MissingMatrixFilename_ThrowsException()
     [TestMethod]
     public void Context_Create_MissingReportDepth_ThrowsException()
     {
-        try
-        {
-            Context.Create(["--report-depth"]);
-            Assert.Fail("Expected ArgumentException was not thrown");
-        }
-        catch (ArgumentException ex)
-        {
-            Assert.Contains("--report-depth requires a depth argument", ex.Message);
-        }
+        var ex = Assert.ThrowsExactly<ArgumentException>(() => Context.Create(["--report-depth"]));
+        Assert.Contains("--report-depth requires a depth argument", ex.Message);
     }
 
     /// <summary>
@@ -310,15 +268,8 @@ public void Context_Create_MissingReportDepth_ThrowsException()
     [TestMethod]
     public void Context_Create_MissingMatrixDepth_ThrowsException()
     {
-        try
-        {
-            Context.Create(["--matrix-depth"]);
-            Assert.Fail("Expected ArgumentException was not thrown");
-        }
-        catch (ArgumentException ex)
-        {
-            Assert.Contains("--matrix-depth requires a depth argument", ex.Message);
-        }
+        var ex = Assert.ThrowsExactly<ArgumentException>(() => Context.Create(["--matrix-depth"]));
+        Assert.Contains("--matrix-depth requires a depth argument", ex.Message);
     }
 
     /// <summary>
@@ -327,35 +278,14 @@ public void Context_Create_MissingMatrixDepth_ThrowsException()
     [TestMethod]
     public void Context_Create_InvalidReportDepth_ThrowsException()
     {
-        try
-        {
-            Context.Create(["--report-depth", "invalid"]);
-            Assert.Fail("Expected ArgumentException was not thrown");
-        }
-        catch (ArgumentException ex)
-        {
-            Assert.Contains("--report-depth requires a positive integer", ex.Message);
-        }
+        var ex1 = Assert.ThrowsExactly<ArgumentException>(() => Context.Create(["--report-depth", "invalid"]));
+        Assert.Contains("--report-depth requires a positive integer", ex1.Message);
 
-        try
-        {
-            Context.Create(["--report-depth", "0"]);
-            Assert.Fail("Expected ArgumentException was not thrown");
-        }
-        catch (ArgumentException ex)
-        {
-            Assert.Contains("--report-depth requires a positive integer", ex.Message);
-        }
+        var ex2 = Assert.ThrowsExactly<ArgumentException>(() => Context.Create(["--report-depth", "0"]));
+        Assert.Contains("--report-depth requires a positive integer", ex2.Message);
 
-        try
-        {
-            Context.Create(["--report-depth", "-1"]);
-            Assert.Fail("Expected ArgumentException was not thrown");
-        }
-        catch (ArgumentException ex)
-        {
-            Assert.Contains("--report-depth requires a positive integer", ex.Message);
-        }
+        var ex3 = Assert.ThrowsExactly<ArgumentException>(() => Context.Create(["--report-depth", "-1"]));
+        Assert.Contains("--report-depth requires a positive integer", ex3.Message);
     }
 
     /// <summary>
@@ -364,25 +294,11 @@ public void Context_Create_InvalidReportDepth_ThrowsException()
     [TestMethod]
     public void Context_Create_InvalidMatrixDepth_ThrowsException()
     {
-        try
-        {
-            Context.Create(["--matrix-depth", "invalid"]);
-            Assert.Fail("Expected ArgumentException was not thrown");
-        }
-        catch (ArgumentException ex)
-        {
-            Assert.Contains("--matrix-depth requires a positive integer", ex.Message);
-        }
+        var ex1 = Assert.ThrowsExactly<ArgumentException>(() => Context.Create(["--matrix-depth", "invalid"]));
+        Assert.Contains("--matrix-depth requires a positive integer", ex1.Message);
 
-        try
-        {
-            Context.Create(["--matrix-depth", "0"]);
-            Assert.Fail("Expected ArgumentException was not thrown");
-        }
-        catch (ArgumentException ex)
-        {
-            Assert.Contains("--matrix-depth requires a positive integer", ex.Message);
-        }
+        var ex2 = Assert.ThrowsExactly<ArgumentException>(() => Context.Create(["--matrix-depth", "0"]));
+        Assert.Contains("--matrix-depth requires a positive integer", ex2.Message);
     }
 
     /// <summary>
@@ -600,15 +516,8 @@ public void Context_Create_WithTestsPattern_ExpandsGlobPattern()
     [TestMethod]
     public void Context_Create_MissingRequirementsPattern_ThrowsException()
     {
-        try
-        {
-            Context.Create(["--requirements"]);
-            Assert.Fail("Expected ArgumentException was not thrown");
-        }
-        catch (ArgumentException ex)
-        {
-            Assert.Contains("--requirements requires a pattern argument", ex.Message);
-        }
+        var ex = Assert.ThrowsExactly<ArgumentException>(() => Context.Create(["--requirements"]));
+        Assert.Contains("--requirements requires a pattern argument", ex.Message);
     }
 
     /// <summary>
@@ -617,15 +526,8 @@ public void Context_Create_MissingRequirementsPattern_ThrowsException()
     [TestMethod]
     public void Context_Create_MissingTestsPattern_ThrowsException()
     {
-        try
-        {
-            Context.Create(["--tests"]);
-            Assert.Fail("Expected ArgumentException was not thrown");
-        }
-        catch (ArgumentException ex)
-        {
-            Assert.Contains("--tests requires a pattern argument", ex.Message);
-        }
+        var ex = Assert.ThrowsExactly<ArgumentException>(() => Context.Create(["--tests"]));
+        Assert.Contains("--tests requires a pattern argument", ex.Message);
     }
 
     /// <summary>
@@ -672,15 +574,8 @@ public void Context_Create_InvalidLogPath_ThrowsException()
     {
         var invalidPath = Path.Combine(_testDirectory, "nonexistent", "test.log");
 
-        try
-        {
-            Context.Create(["--log", invalidPath]);
-            Assert.Fail("Expected ArgumentException was not thrown");
-        }
-        catch (ArgumentException ex)
-        {
-            Assert.Contains("Failed to open log file", ex.Message);
-        }
+        var ex = Assert.ThrowsExactly<ArgumentException>(() => Context.Create(["--log", invalidPath]));
+        Assert.Contains("Failed to open log file", ex.Message);
     }
 
     /// <summary>
@@ -720,15 +615,8 @@ public void Context_Create_FilterArgumentWithSpaces_TrimsAndParsesTagsCorrectly(
     [TestMethod]
     public void Context_Create_FilterArgumentMissingValue_ThrowsArgumentException()
     {
-        try
-        {
-            Context.Create(["--filter"]);
-            Assert.Fail("Expected ArgumentException was not thrown");
-        }
-        catch (ArgumentException ex)
-        {
-            Assert.Contains("--filter requires a comma-separated list of tags", ex.Message);
-        }
+        var ex = Assert.ThrowsExactly<ArgumentException>(() => Context.Create(["--filter"]));
+        Assert.Contains("--filter requires a comma-separated list of tags", ex.Message);
     }
 
     /// <summary>
diff --git a/test/DemaConsulting.ReqStream.Tests/RequirementsExportTests.cs b/test/DemaConsulting.ReqStream.Tests/RequirementsExportTests.cs
index 150af66..6f2eebe 100644
--- a/test/DemaConsulting.ReqStream.Tests/RequirementsExportTests.cs
+++ b/test/DemaConsulting.ReqStream.Tests/RequirementsExportTests.cs
@@ -183,15 +183,8 @@ public void Requirements_Export_NullFilePath_ThrowsArgumentException()
         File.WriteAllText(reqPath, yamlContent);
         var requirements = Requirements.Read(reqPath);
 
-        try
-        {
-            requirements.Export(null!);
-            Assert.Fail("Expected ArgumentException was not thrown");
-        }
-        catch (ArgumentException ex)
-        {
-            Assert.Contains("File path cannot be null or empty", ex.Message);
-        }
+        var ex = Assert.ThrowsExactly<ArgumentException>(() => requirements.Export(null!));
+        Assert.Contains("File path cannot be null or empty", ex.Message);
     }
 
     /// <summary>
@@ -211,15 +204,8 @@ public void Requirements_Export_EmptyFilePath_ThrowsArgumentException()
         File.WriteAllText(reqPath, yamlContent);
         var requirements = Requirements.Read(reqPath);
 
-        try
-        {
-            requirements.Export(string.Empty);
-            Assert.Fail("Expected ArgumentException was not thrown");
-        }
-        catch (ArgumentException ex)
-        {
-            Assert.Contains("File path cannot be null or empty", ex.Message);
-        }
+        var ex = Assert.ThrowsExactly<ArgumentException>(() => requirements.Export(string.Empty));
+        Assert.Contains("File path cannot be null or empty", ex.Message);
     }
 
     /// <summary>
diff --git a/test/DemaConsulting.ReqStream.Tests/RequirementsReadTests.cs b/test/DemaConsulting.ReqStream.Tests/RequirementsReadTests.cs
index 3fb4ae6..a89b731 100644
--- a/test/DemaConsulting.ReqStream.Tests/RequirementsReadTests.cs
+++ b/test/DemaConsulting.ReqStream.Tests/RequirementsReadTests.cs
@@ -326,16 +326,9 @@ public void Requirements_Read_DuplicateRequirementId_ThrowsException()
         var filePath = Path.Combine(_testDirectory, "requirements.yaml");
         File.WriteAllText(filePath, yamlContent);
 
-        try
-        {
-            Requirements.Read(filePath);
-            Assert.Fail("Expected InvalidOperationException was not thrown");
-        }
-        catch (InvalidOperationException ex)
-        {
-            Assert.Contains("SYS-SEC-001", ex.Message);
-            Assert.Contains("Duplicate requirement ID", ex.Message);
-        }
+        var ex = Assert.ThrowsExactly<InvalidOperationException>(() => Requirements.Read(filePath));
+        Assert.Contains("SYS-SEC-001", ex.Message);
+        Assert.Contains("Duplicate requirement ID", ex.Message);
     }
 
     /// <summary>
@@ -383,15 +376,8 @@ public void Requirements_Read_FileNotFound_ThrowsException()
     {
         var nonExistentPath = Path.Combine(_testDirectory, "nonexistent.yaml");
 
-        try
-        {
-            Requirements.Read(nonExistentPath);
-            Assert.Fail("Expected FileNotFoundException was not thrown");
-        }
-        catch (FileNotFoundException ex)
-        {
-            Assert.Contains("Requirements file not found", ex.Message);
-        }
+        var ex = Assert.ThrowsExactly<FileNotFoundException>(() => Requirements.Read(nonExistentPath));
+        Assert.Contains("Requirements file not found", ex.Message);
     }
 
     /// <summary>
@@ -496,17 +482,10 @@ public void Requirements_Read_BlankRequirementId_ThrowsExceptionWithFileLocation
         var filePath = Path.Combine(_testDirectory, "requirements.yaml");
         File.WriteAllText(filePath, yamlContent);
 
-        try
-        {
-            Requirements.Read(filePath);
-            Assert.Fail("Expected InvalidOperationException was not thrown");
-        }
-        catch (InvalidOperationException ex)
-        {
-            Assert.Contains("Requirement ID cannot be blank", ex.Message);
-            Assert.Contains("System Security", ex.Message);
-            Assert.Contains(filePath, ex.Message);
-        }
+        var ex = Assert.ThrowsExactly<InvalidOperationException>(() => Requirements.Read(filePath));
+        Assert.Contains("Requirement ID cannot be blank", ex.Message);
+        Assert.Contains("System Security", ex.Message);
+        Assert.Contains(filePath, ex.Message);
     }
 
     /// <summary>
@@ -525,17 +504,10 @@ public void Requirements_Read_BlankRequirementTitle_ThrowsExceptionWithFileLocat
         var filePath = Path.Combine(_testDirectory, "requirements.yaml");
         File.WriteAllText(filePath, yamlContent);
 
-        try
-        {
-            Requirements.Read(filePath);
-            Assert.Fail("Expected InvalidOperationException was not thrown");
-        }
-        catch (InvalidOperationException ex)
-        {
-            Assert.Contains("Requirement title cannot be blank", ex.Message);
-            Assert.Contains("SYS-SEC-001", ex.Message);
-            Assert.Contains(filePath, ex.Message);
-        }
+        var ex = Assert.ThrowsExactly<InvalidOperationException>(() => Requirements.Read(filePath));
+        Assert.Contains("Requirement title cannot be blank", ex.Message);
+        Assert.Contains("SYS-SEC-001", ex.Message);
+        Assert.Contains(filePath, ex.Message);
     }
 
     /// <summary>
@@ -554,16 +526,9 @@ public void Requirements_Read_BlankSectionTitle_ThrowsExceptionWithFileLocation(
         var filePath = Path.Combine(_testDirectory, "requirements.yaml");
         File.WriteAllText(filePath, yamlContent);
 
-        try
-        {
-            Requirements.Read(filePath);
-            Assert.Fail("Expected InvalidOperationException was not thrown");
-        }
-        catch (InvalidOperationException ex)
-        {
-            Assert.Contains("Section title cannot be blank", ex.Message);
-            Assert.Contains(filePath, ex.Message);
-        }
+        var ex = Assert.ThrowsExactly<InvalidOperationException>(() => Requirements.Read(filePath));
+        Assert.Contains("Section title cannot be blank", ex.Message);
+        Assert.Contains(filePath, ex.Message);
     }
 
     /// <summary>
@@ -586,17 +551,10 @@ public void Requirements_Read_BlankTestNameInRequirement_ThrowsExceptionWithFile
         var filePath = Path.Combine(_testDirectory, "requirements.yaml");
         File.WriteAllText(filePath, yamlContent);
 
-        try
-        {
-            Requirements.Read(filePath);
-            Assert.Fail("Expected InvalidOperationException was not thrown");
-        }
-        catch (InvalidOperationException ex)
-        {
-            Assert.Contains("Test name cannot be blank", ex.Message);
-            Assert.Contains("SYS-SEC-001", ex.Message);
-            Assert.Contains(filePath, ex.Message);
-        }
+        var ex = Assert.ThrowsExactly<InvalidOperationException>(() => Requirements.Read(filePath));
+        Assert.Contains("Test name cannot be blank", ex.Message);
+        Assert.Contains("SYS-SEC-001", ex.Message);
+        Assert.Contains(filePath, ex.Message);
     }
 
     /// <summary>
@@ -621,17 +579,10 @@ public void Requirements_Read_BlankTestNameInMapping_ThrowsExceptionWithFileLoca
         var filePath = Path.Combine(_testDirectory, "requirements.yaml");
         File.WriteAllText(filePath, yamlContent);
 
-        try
-        {
-            Requirements.Read(filePath);
-            Assert.Fail("Expected InvalidOperationException was not thrown");
-        }
-        catch (InvalidOperationException ex)
-        {
-            Assert.Contains("Test name cannot be blank", ex.Message);
-            Assert.Contains("SYS-SEC-001", ex.Message);
-            Assert.Contains(filePath, ex.Message);
-        }
+        var ex = Assert.ThrowsExactly<InvalidOperationException>(() => Requirements.Read(filePath));
+        Assert.Contains("Test name cannot be blank", ex.Message);
+        Assert.Contains("SYS-SEC-001", ex.Message);
+        Assert.Contains(filePath, ex.Message);
     }
 
     /// <summary>
@@ -655,16 +606,9 @@ public void Requirements_Read_BlankMappingId_ThrowsExceptionWithFileLocation()
         var filePath = Path.Combine(_testDirectory, "requirements.yaml");
         File.WriteAllText(filePath, yamlContent);
 
-        try
-        {
-            Requirements.Read(filePath);
-            Assert.Fail("Expected InvalidOperationException was not thrown");
-        }
-        catch (InvalidOperationException ex)
-        {
-            Assert.Contains("Mapping requirement ID cannot be blank", ex.Message);
-            Assert.Contains(filePath, ex.Message);
-        }
+        var ex = Assert.ThrowsExactly<InvalidOperationException>(() => Requirements.Read(filePath));
+        Assert.Contains("Mapping requirement ID cannot be blank", ex.Message);
+        Assert.Contains(filePath, ex.Message);
     }
 
     /// <summary>
@@ -685,17 +629,10 @@ public void Requirements_Read_DuplicateRequirementId_ExceptionIncludesFileLocati
         var filePath = Path.Combine(_testDirectory, "requirements.yaml");
         File.WriteAllText(filePath, yamlContent);
 
-        try
-        {
-            Requirements.Read(filePath);
-            Assert.Fail("Expected InvalidOperationException was not thrown");
-        }
-        catch (InvalidOperationException ex)
-        {
-            Assert.Contains("SYS-SEC-001", ex.Message);
-            Assert.Contains("Duplicate requirement ID", ex.Message);
-            Assert.Contains(filePath, ex.Message);
-        }
+        var ex = Assert.ThrowsExactly<InvalidOperationException>(() => Requirements.Read(filePath));
+        Assert.Contains("SYS-SEC-001", ex.Message);
+        Assert.Contains("Duplicate requirement ID", ex.Message);
+        Assert.Contains(filePath, ex.Message);
     }
 
     /// <summary>
@@ -810,15 +747,8 @@ public void Requirements_Read_SingleFileWithParamsArray_WorksCorrectly()
     [TestMethod]
     public void Requirements_Read_NoArguments_ThrowsArgumentException()
     {
-        try
-        {
-            Requirements.Read();
-            Assert.Fail("Expected ArgumentException was not thrown");
-        }
-        catch (ArgumentException ex)
-        {
-            Assert.Contains("At least one file path must be provided", ex.Message);
-        }
+        var ex = Assert.ThrowsExactly<ArgumentException>(() => Requirements.Read());
+        Assert.Contains("At least one file path must be provided", ex.Message);
     }
 
     /// <summary>
@@ -827,15 +757,8 @@ public void Requirements_Read_NoArguments_ThrowsArgumentException()
     [TestMethod]
     public void Requirements_Read_NullArgument_ThrowsArgumentException()
     {
-        try
-        {
-            Requirements.Read(null!);
-            Assert.Fail("Expected ArgumentException was not thrown");
-        }
-        catch (ArgumentException ex)
-        {
-            Assert.Contains("At least one file path must be provided", ex.Message);
-        }
+        var ex = Assert.ThrowsExactly<ArgumentException>(() => Requirements.Read(null!));
+        Assert.Contains("At least one file path must be provided", ex.Message);
     }
 
     /// <summary>
@@ -925,16 +848,9 @@ public void Requirements_Read_BlankTagName_ThrowsExceptionWithFileLocation()
         var filePath = Path.Combine(_testDirectory, "requirements.yaml");
         File.WriteAllText(filePath, yamlContent);
 
-        try
-        {
-            Requirements.Read(filePath);
-            Assert.Fail("Expected InvalidOperationException was not thrown");
-        }
-        catch (InvalidOperationException ex)
-        {
-            Assert.Contains("Tag name cannot be blank", ex.Message);
-            Assert.Contains("SYS-SEC-001", ex.Message);
-            Assert.Contains(filePath, ex.Message);
-        }
+        var ex = Assert.ThrowsExactly<InvalidOperationException>(() => Requirements.Read(filePath));
+        Assert.Contains("Tag name cannot be blank", ex.Message);
+        Assert.Contains("SYS-SEC-001", ex.Message);
+        Assert.Contains(filePath, ex.Message);
     }
 }
diff --git a/test/DemaConsulting.ReqStream.Tests/TraceMatrixExportTests.cs b/test/DemaConsulting.ReqStream.Tests/TraceMatrixExportTests.cs
index 5770e82..de1faa1 100644
--- a/test/DemaConsulting.ReqStream.Tests/TraceMatrixExportTests.cs
+++ b/test/DemaConsulting.ReqStream.Tests/TraceMatrixExportTests.cs
@@ -358,15 +358,8 @@ public void TraceMatrix_Export_NullFilePath_ThrowsArgumentException()
         // Create TraceMatrix
         var matrix = new TraceMatrix(requirements);
 
-        try
-        {
-            matrix.Export(null!);
-            Assert.Fail("Expected ArgumentException was not thrown");
-        }
-        catch (ArgumentException ex)
-        {
-            Assert.Contains("File path cannot be null or empty", ex.Message);
-        }
+        var ex = Assert.ThrowsExactly<ArgumentException>(() => matrix.Export(null!));
+        Assert.Contains("File path cannot be null or empty", ex.Message);
     }
 
     /// <summary>
@@ -392,15 +385,8 @@ public void TraceMatrix_Export_EmptyFilePath_ThrowsArgumentException()
         // Create TraceMatrix
         var matrix = new TraceMatrix(requirements);
 
-        try
-        {
-            matrix.Export(string.Empty);
-            Assert.Fail("Expected ArgumentException was not thrown");
-        }
-        catch (ArgumentException ex)
-        {
-            Assert.Contains("File path cannot be null or empty", ex.Message);
-        }
+        var ex = Assert.ThrowsExactly<ArgumentException>(() => matrix.Export(string.Empty));
+        Assert.Contains("File path cannot be null or empty", ex.Message);
     }
 
     /// <summary>
diff --git a/test/DemaConsulting.ReqStream.Tests/TraceMatrixReadTests.cs b/test/DemaConsulting.ReqStream.Tests/TraceMatrixReadTests.cs
index 45040da..1bdf865 100644
--- a/test/DemaConsulting.ReqStream.Tests/TraceMatrixReadTests.cs
+++ b/test/DemaConsulting.ReqStream.Tests/TraceMatrixReadTests.cs
@@ -266,15 +266,8 @@ public void TraceMatrix_WithExtraTests_IgnoresUnreferencedTests()
     [TestMethod]
     public void TraceMatrix_NullRequirements_ThrowsArgumentNullException()
     {
-        try
-        {
-            _ = new TraceMatrix(null!, Array.Empty<string>());
-            Assert.Fail("Expected ArgumentNullException was not thrown");
-        }
-        catch (ArgumentNullException ex)
-        {
-            Assert.Contains("requirements", ex.Message);
-        }
+        var ex = Assert.ThrowsExactly<ArgumentNullException>(() => _ = new TraceMatrix(null!, Array.Empty<string>()));
+        Assert.Contains("requirements", ex.Message);
     }
 
     /// <summary>
@@ -299,15 +292,8 @@ public void TraceMatrix_MissingFile_ThrowsFileNotFoundException()
 
         var nonExistentPath = Path.Combine(_testDirectory, "nonexistent.trx");
 
-        try
-        {
-            _ = new TraceMatrix(requirements, nonExistentPath);
-            Assert.Fail("Expected FileNotFoundException was not thrown");
-        }
-        catch (FileNotFoundException ex)
-        {
-            Assert.Contains("Test result file not found", ex.Message);
-        }
+        var ex = Assert.ThrowsExactly<FileNotFoundException>(() => _ = new TraceMatrix(requirements, nonExistentPath));
+        Assert.Contains("Test result file not found", ex.Message);
     }
 
     /// <summary>