chore(sonar): wrap independent assertions in Assert.Multiple (NUnit2045)

Driven by `dotnet format analyzers --diagnostics NUnit2045`. The fixer
groups consecutive independent `Assert.That(...)` calls into
`Assert.Multiple(() => { ... })`, so a failing assertion no longer
short-circuits the block — every failure inside the group is reported,
which gives much better diagnostics on multi-property tests.

Audit confirmed no Assert.Throws / Assert.Fail / Assert.Catch / Assert.Pass
/ Assert.DoesNotThrow got pulled inside a Multiple block (those need to
short-circuit). All 1180 tests pass.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

tests/Strata.SqlTools.SqlServer.Tests/Performance/GetClausesCachingTests.cs

@@ -181,8 +181,11 @@ public class GetClausesCachingTests
 
         // Assert
         Assert.That(clauses2, Is.Not.SameAs(clauses1), "GetClauses should return a new instance after ApplyClauses");
-        Assert.That(clauses2.SelectClause?.Clause, Is.EqualTo("id, name"));
-        Assert.That(clauses2.FromClause?.Clause, Is.EqualTo("customers"));
+        Assert.Multiple(() =>
+        {
+            Assert.That(clauses2.SelectClause?.Clause, Is.EqualTo("id, name"));
+            Assert.That(clauses2.FromClause?.Clause, Is.EqualTo("customers"));
+        });
     }
 
     [Test]
@@ -197,10 +200,13 @@ public class GetClausesCachingTests
 
         // Assert
         Assert.That(clauses, Is.Not.Null);
-        Assert.That(clauses.SelectClause?.Clause, Is.EqualTo("id, name"));
-        Assert.That(clauses.FromClause?.Clause, Is.EqualTo("users"));
-        Assert.That(clauses.WhereClause?.Clause, Is.EqualTo("active = 1"));
-        Assert.That(clauses.OrderByClause?.Clause, Is.EqualTo("name ASC"));
+        Assert.Multiple(() =>
+        {
+            Assert.That(clauses.SelectClause?.Clause, Is.EqualTo("id, name"));
+            Assert.That(clauses.FromClause?.Clause, Is.EqualTo("users"));
+            Assert.That(clauses.WhereClause?.Clause, Is.EqualTo("active = 1"));
+            Assert.That(clauses.OrderByClause?.Clause, Is.EqualTo("name ASC"));
+        });
     }
 
     [Test]
@@ -214,8 +220,11 @@ public class GetClausesCachingTests
         var clauses2 = query.GetClauses();
         var clauses3 = query.GetClauses();
 
-        // Assert - All should be the same instance
-        Assert.That(clauses2, Is.SameAs(clauses1));
-        Assert.That(clauses3, Is.SameAs(clauses1));
+        Assert.Multiple(() =>
+        {
+            // Assert - All should be the same instance
+            Assert.That(clauses2, Is.SameAs(clauses1));
+            Assert.That(clauses3, Is.SameAs(clauses1));
+        });
     }
 }

tests/Strata.SqlTools.SqlServer.Tests/SqlServer/CTEColumnListTests.cs

@@ -20,9 +20,12 @@ public class CTEColumnListTests
 
         // Act & Assert
         Assert.That(withClause.ColumnList, Has.Count.EqualTo(3));
-        Assert.That(withClause.ColumnList[0], Is.EqualTo("user_id"));
-        Assert.That(withClause.ColumnList[1], Is.EqualTo("user_name"));
-        Assert.That(withClause.ColumnList[2], Is.EqualTo("user_email"));
+        Assert.Multiple(() =>
+        {
+            Assert.That(withClause.ColumnList[0], Is.EqualTo("user_id"));
+            Assert.That(withClause.ColumnList[1], Is.EqualTo("user_name"));
+            Assert.That(withClause.ColumnList[2], Is.EqualTo("user_email"));
+        });
     }
 
     [Test]
@@ -362,9 +365,12 @@ public class CTEColumnListTests
         // Assert
         Assert.That(sql, Contains.Substring("recent_sales (cust_id, order_id, sale_date, amount)"));
         var paramKeys = params_all.Keys.ToList();
-        Assert.That(paramKeys.Any(k => k.Contains("StartDate")));
-        Assert.That(paramKeys.Any(k => k.Contains("MinAmount")));
-        Assert.That(paramKeys.Any(k => k.Contains("CurrencyConversion")));
+        Assert.Multiple(() =>
+        {
+            Assert.That(paramKeys.Any(k => k.Contains("StartDate")));
+            Assert.That(paramKeys.Any(k => k.Contains("MinAmount")));
+            Assert.That(paramKeys.Any(k => k.Contains("CurrencyConversion")));
+        });
     }
 
     #endregion

tests/Strata.SqlTools.SqlServer.Tests/SqlServer/CommentTests.cs

@@ -21,8 +21,11 @@ public class CommentTests
         // Assert
         Assert.That(query.SelectClause.Clause, Does.Contain("ID"));
         Assert.That(query.SelectClause.Clause, Does.Contain("Name"));
-        Assert.That(query.SelectClause.Clause, Does.Contain("Email"));
-        Assert.That(query.SelectClause.Comment, Does.Contain("-- This is a customer name"));
+        Assert.Multiple(() =>
+        {
+            Assert.That(query.SelectClause.Clause, Does.Contain("Email"));
+            Assert.That(query.SelectClause.Comment, Does.Contain("-- This is a customer name"));
+        });
     }
 
     [Test]
@@ -42,8 +45,11 @@ public class CommentTests
 
         // Assert
         Assert.That(query.SelectClause.Clause, Does.Contain("ID"));
-        Assert.That(query.SelectClause.Clause, Does.Contain("Name"));
-        Assert.That(query.SelectClause.Comment, Does.Contain("/* Multi-line comment"));
+        Assert.Multiple(() =>
+        {
+            Assert.That(query.SelectClause.Clause, Does.Contain("Name"));
+            Assert.That(query.SelectClause.Comment, Does.Contain("/* Multi-line comment"));
+        });
         Assert.That(query.SelectClause.Comment, Does.Contain("explaining the query */"));
     }
 
@@ -64,11 +70,14 @@ public class CommentTests
         // Act
         var query = QueryBreakdown.Parse(sql);
 
-        // Assert
-        Assert.That(query.SelectClause.Comment, Does.Contain("-- Select specific columns"));
-        Assert.That(query.FromClause.Comment, Does.Contain("-- Main user table"));
-        Assert.That(query.WhereClause.Comment, Does.Contain("/* Active users only */"));
-        Assert.That(query.OrderByClause.Comment, Does.Contain("-- Sort by name"));
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(query.SelectClause.Comment, Does.Contain("-- Select specific columns"));
+            Assert.That(query.FromClause.Comment, Does.Contain("-- Main user table"));
+            Assert.That(query.WhereClause.Comment, Does.Contain("/* Active users only */"));
+            Assert.That(query.OrderByClause.Comment, Does.Contain("-- Sort by name"));
+        });
     }
 
     [Test]
@@ -100,10 +109,13 @@ public class CommentTests
         // Act
         var query = QueryBreakdown.Parse(sql);
 
-        // Assert
-        Assert.That(query.SelectClause.Comment, Is.Null.Or.Empty);
-        Assert.That(query.FromClause.Comment, Is.Null.Or.Empty);
-        Assert.That(query.WhereClause.Comment, Is.Null.Or.Empty);
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(query.SelectClause.Comment, Is.Null.Or.Empty);
+            Assert.That(query.FromClause.Comment, Is.Null.Or.Empty);
+            Assert.That(query.WhereClause.Comment, Is.Null.Or.Empty);
+        });
     }
 
     [Test]
@@ -121,10 +133,13 @@ public class CommentTests
         // Act
         var cloned = (QueryBreakdown)original.Clone();
 
-        // Assert
-        Assert.That(cloned.SelectClause.Comment, Is.EqualTo(original.SelectClause.Comment));
-        Assert.That(cloned.FromClause.Comment, Is.EqualTo(original.FromClause.Comment));
-        Assert.That(cloned.WhereClause.Comment, Is.EqualTo(original.WhereClause.Comment));
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(cloned.SelectClause.Comment, Is.EqualTo(original.SelectClause.Comment));
+            Assert.That(cloned.FromClause.Comment, Is.EqualTo(original.FromClause.Comment));
+            Assert.That(cloned.WhereClause.Comment, Is.EqualTo(original.WhereClause.Comment));
+        });
     }
 
     [Test]
@@ -221,10 +236,16 @@ public class CommentTests
 
         // Assert
         Assert.That(comments, Has.Count.EqualTo(2));
-        Assert.That(comments[0], Does.Contain("-- Single line"));
-        Assert.That(comments[1], Does.Contain("/* Multi"));
-        Assert.That(comments[1], Does.Contain("line */"));
-        Assert.That(cleanSql, Does.Not.Contain("-- Single line"));
+        Assert.Multiple(() =>
+        {
+            Assert.That(comments[0], Does.Contain("-- Single line"));
+            Assert.That(comments[1], Does.Contain("/* Multi"));
+        });
+        Assert.Multiple(() =>
+        {
+            Assert.That(comments[1], Does.Contain("line */"));
+            Assert.That(cleanSql, Does.Not.Contain("-- Single line"));
+        });
         Assert.That(cleanSql, Does.Not.Contain("/*"));
     }
 
@@ -257,15 +278,21 @@ public class CommentTests
         Assert.That(query.SelectClause.Clause, Does.Contain("Name"));
         Assert.That(query.SelectClause.Clause, Does.Contain("Email"));
         Assert.That(query.SelectClause.Clause, Does.Not.Contain("--"));
-        Assert.That(query.SelectClause.Clause, Does.Not.Contain("/*"));
+        Assert.Multiple(() =>
+        {
+            Assert.That(query.SelectClause.Clause, Does.Not.Contain("/*"));
 
-        Assert.That(query.SelectClause.Comment, Does.Contain("-- Primary key"));
+            Assert.That(query.SelectClause.Comment, Does.Contain("-- Primary key"));
+        });
         Assert.That(query.SelectClause.Comment, Does.Contain("-- Customer name field"));
-        Assert.That(query.SelectClause.Comment, Does.Contain("/* Email address for notifications */"));
+        Assert.Multiple(() =>
+        {
+            Assert.That(query.SelectClause.Comment, Does.Contain("/* Email address for notifications */"));
 
-        Assert.That(query.FromClause.Comment, Does.Contain("-- Main user table"));
-        Assert.That(query.WhereClause.Comment, Does.Contain("/* Filter for active users only */"));
-        Assert.That(query.OrderByClause.Comment, Does.Contain("-- Sort alphabetically"));
+            Assert.That(query.FromClause.Comment, Does.Contain("-- Main user table"));
+            Assert.That(query.WhereClause.Comment, Does.Contain("/* Filter for active users only */"));
+            Assert.That(query.OrderByClause.Comment, Does.Contain("-- Sort alphabetically"));
+        });
 
         // Act - Generate SQL
         var regeneratedSql = query.GetSql();

tests/Strata.SqlTools.SqlServer.Tests/SqlServer/QueryBreakdownCollectionTests.cs

@@ -87,9 +87,12 @@ public class QueryBreakdownCollectionTests
         // Act
         var removed = _collection.Remove(query);
 
-        // Assert
-        Assert.That(removed, Is.True);
-        Assert.That(_collection, Is.Empty);
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(removed, Is.True);
+            Assert.That(_collection, Is.Empty);
+        });
     }
 
     [Test]
@@ -103,9 +106,12 @@ public class QueryBreakdownCollectionTests
         // Act
         var removed = _collection.Remove(query2);
 
-        // Assert
-        Assert.That(removed, Is.False);
-        Assert.That(_collection, Has.Count.EqualTo(1));
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(removed, Is.False);
+            Assert.That(_collection, Has.Count.EqualTo(1));
+        });
     }
 
     [Test]
@@ -276,8 +282,11 @@ public class QueryBreakdownCollectionTests
 
         // Assert
         Assert.That(summaries, Has.Count.EqualTo(2));
-        Assert.That(summaries[0].HasSelectClause, Is.True);
-        Assert.That(summaries[1].HasWhereClause, Is.True);
+        Assert.Multiple(() =>
+        {
+            Assert.That(summaries[0].HasSelectClause, Is.True);
+            Assert.That(summaries[1].HasWhereClause, Is.True);
+        });
     }
 
     [Test]
@@ -327,9 +336,12 @@ public class QueryBreakdownCollectionTests
         // Act
         _collection.AddParameterToAll("CompanyId", 99);
 
-        // Assert
-        Assert.That(_collection.QueryBreakdowns[0].Parameters["CompanyId"], Is.EqualTo(99));
-        Assert.That(_collection.QueryBreakdowns[1].Parameters["CompanyId"], Is.EqualTo(99));
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(_collection.QueryBreakdowns[0].Parameters["CompanyId"], Is.EqualTo(99));
+            Assert.That(_collection.QueryBreakdowns[1].Parameters["CompanyId"], Is.EqualTo(99));
+        });
     }
 
     [Test]

tests/Strata.SqlTools.SqlServer.Tests/SqlServer/QueryBreakdownTests.cs

@@ -16,16 +16,19 @@ public class QueryBreakdownTests
         // Arrange & Act
         var query = new QueryBreakdown();
 
-        // Assert
-        Assert.That(query.SelectClause.Clause, Is.EqualTo(string.Empty));
-        Assert.That(query.FromClause.Clause, Is.EqualTo(string.Empty));
-        Assert.That(query.WhereClause.Clause, Is.EqualTo(string.Empty));
-        Assert.That(query.OrderByClause.Clause, Is.EqualTo(string.Empty));
-        Assert.That(query.GroupByClause.Clause, Is.EqualTo(string.Empty));
-        Assert.That(query.HavingClause.Clause, Is.EqualTo(string.Empty));
-        Assert.That(query.SetupClauses, Is.Not.Null);
-        Assert.That(query.FinishClauses, Is.Not.Null);
-        Assert.That(query.WithClauses, Is.Not.Null);
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(query.SelectClause.Clause, Is.EqualTo(string.Empty));
+            Assert.That(query.FromClause.Clause, Is.EqualTo(string.Empty));
+            Assert.That(query.WhereClause.Clause, Is.EqualTo(string.Empty));
+            Assert.That(query.OrderByClause.Clause, Is.EqualTo(string.Empty));
+            Assert.That(query.GroupByClause.Clause, Is.EqualTo(string.Empty));
+            Assert.That(query.HavingClause.Clause, Is.EqualTo(string.Empty));
+            Assert.That(query.SetupClauses, Is.Not.Null);
+            Assert.That(query.FinishClauses, Is.Not.Null);
+            Assert.That(query.WithClauses, Is.Not.Null);
+        });
         Assert.That(query.WithClauses, Is.Empty);
         Assert.That(query.Parameters, Is.Not.Null);
         Assert.That(query.ParameterList, Is.Not.Null);
@@ -41,10 +44,13 @@ public class QueryBreakdownTests
         // Act
         var query = new QueryBreakdown(selectClause, fromClause);
 
-        // Assert
-        Assert.That(query.SelectClause.Clause, Is.EqualTo(selectClause));
-        Assert.That(query.FromClause.Clause, Is.EqualTo(fromClause));
-        Assert.That(query.WhereClause.Clause, Is.EqualTo(string.Empty));
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(query.SelectClause.Clause, Is.EqualTo(selectClause));
+            Assert.That(query.FromClause.Clause, Is.EqualTo(fromClause));
+            Assert.That(query.WhereClause.Clause, Is.EqualTo(string.Empty));
+        });
     }
 
     [Test]
@@ -58,11 +64,14 @@ public class QueryBreakdownTests
         // Act
         var query = new QueryBreakdown(selectClause, fromClause, whereClause);
 
-        // Assert
-        Assert.That(query.SelectClause.Clause, Is.EqualTo(selectClause));
-        Assert.That(query.FromClause.Clause, Is.EqualTo(fromClause));
-        Assert.That(query.WhereClause.Clause, Is.EqualTo(whereClause));
-        Assert.That(query.OrderByClause.Clause, Is.EqualTo(string.Empty));
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(query.SelectClause.Clause, Is.EqualTo(selectClause));
+            Assert.That(query.FromClause.Clause, Is.EqualTo(fromClause));
+            Assert.That(query.WhereClause.Clause, Is.EqualTo(whereClause));
+            Assert.That(query.OrderByClause.Clause, Is.EqualTo(string.Empty));
+        });
     }
 
     [Test]
@@ -77,11 +86,14 @@ public class QueryBreakdownTests
         // Act
         var query = new QueryBreakdown(selectClause, fromClause, whereClause, orderByClause);
 
-        // Assert
-        Assert.That(query.SelectClause.Clause, Is.EqualTo(selectClause));
-        Assert.That(query.FromClause.Clause, Is.EqualTo(fromClause));
-        Assert.That(query.WhereClause.Clause, Is.EqualTo(whereClause));
-        Assert.That(query.OrderByClause.Clause, Is.EqualTo(orderByClause));
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(query.SelectClause.Clause, Is.EqualTo(selectClause));
+            Assert.That(query.FromClause.Clause, Is.EqualTo(fromClause));
+            Assert.That(query.WhereClause.Clause, Is.EqualTo(whereClause));
+            Assert.That(query.OrderByClause.Clause, Is.EqualTo(orderByClause));
+        });
     }
 
     #endregion
@@ -147,9 +159,12 @@ public class QueryBreakdownTests
         // Act
         query.AddParameter("UserId", 123);
 
-        // Assert
-        Assert.That(query.ParameterList.Count(), Is.EqualTo(1));
-        Assert.That(query.Parameters["@UserId"], Is.EqualTo(123));
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(query.ParameterList.Count(), Is.EqualTo(1));
+            Assert.That(query.Parameters["@UserId"], Is.EqualTo(123));
+        });
     }
 
     [Test]
@@ -209,8 +224,11 @@ public class QueryBreakdownTests
 
         // Assert
         Assert.That(merged, Has.Count.EqualTo(2));
-        Assert.That(merged["@UserId"], Is.EqualTo(123));
-        Assert.That(merged["@ActiveStatus"], Is.EqualTo(true));
+        Assert.Multiple(() =>
+        {
+            Assert.That(merged["@UserId"], Is.EqualTo(123));
+            Assert.That(merged["@ActiveStatus"], Is.EqualTo(true));
+        });
     }
 
     [Test]
@@ -229,8 +247,11 @@ public class QueryBreakdownTests
 
         // Assert
         Assert.That(merged, Has.Count.EqualTo(2));
-        Assert.That(merged["@MinDate"], Is.EqualTo(DateTime.Today.AddDays(-30)));
-        Assert.That(merged["@Limit"], Is.EqualTo(100));
+        Assert.Multiple(() =>
+        {
+            Assert.That(merged["@MinDate"], Is.EqualTo(DateTime.Today.AddDays(-30)));
+            Assert.That(merged["@Limit"], Is.EqualTo(100));
+        });
     }
 
     [Test]
@@ -253,9 +274,12 @@ public class QueryBreakdownTests
 
         // Assert
         Assert.That(merged, Has.Count.EqualTo(3));
-        Assert.That(merged["@Status1"], Is.EqualTo("active"));
-        Assert.That(merged["@MinDate"], Is.EqualTo(DateTime.Today.AddDays(-30)));
-        Assert.That(merged["@ResultLimit"], Is.EqualTo(50));
+        Assert.Multiple(() =>
+        {
+            Assert.That(merged["@Status1"], Is.EqualTo("active"));
+            Assert.That(merged["@MinDate"], Is.EqualTo(DateTime.Today.AddDays(-30)));
+            Assert.That(merged["@ResultLimit"], Is.EqualTo(50));
+        });
     }
 
     [Test]
@@ -297,9 +321,12 @@ public class QueryBreakdownTests
 
         // Assert - All parameters from all levels should be present
         Assert.That(merged, Has.Count.EqualTo(3));
-        Assert.That(merged["@InnerParam"], Is.EqualTo("inner_value"));
-        Assert.That(merged["@MiddleParam"], Is.EqualTo("middle_value"));
-        Assert.That(merged["@MainParam"], Is.EqualTo("main_value"));
+        Assert.Multiple(() =>
+        {
+            Assert.That(merged["@InnerParam"], Is.EqualTo("inner_value"));
+            Assert.That(merged["@MiddleParam"], Is.EqualTo("middle_value"));
+            Assert.That(merged["@MainParam"], Is.EqualTo("main_value"));
+        });
     }
 
     [Test]
@@ -336,11 +363,14 @@ public class QueryBreakdownTests
         // Act
         var merged = mainQuery.GetMergedParameters();
 
-        // Assert
-        Assert.That(merged["@IntValue"], Is.TypeOf<int>());
-        Assert.That(merged["@StringValue"], Is.TypeOf<string>());
-        Assert.That(merged["@DateValue"], Is.TypeOf<DateTime>());
-        Assert.That(merged["@DecimalValue"], Is.TypeOf<decimal>());
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(merged["@IntValue"], Is.TypeOf<int>());
+            Assert.That(merged["@StringValue"], Is.TypeOf<string>());
+            Assert.That(merged["@DateValue"], Is.TypeOf<DateTime>());
+            Assert.That(merged["@DecimalValue"], Is.TypeOf<decimal>());
+        });
     }
 
     #endregion
@@ -413,12 +443,18 @@ public class QueryBreakdownTests
         // Act
         query.AddWhereClause("UserID = @UserId AND Status = @Status");
 
-        // Assert
-        Assert.That(query.WhereClause.Clause, Is.EqualTo("UserID = @UserId AND Status = @Status"));
-        Assert.That(query.Parameters, Does.ContainKey("@UserId"));
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(query.WhereClause.Clause, Is.EqualTo("UserID = @UserId AND Status = @Status"));
+            Assert.That(query.Parameters, Does.ContainKey("@UserId"));
+        });
         Assert.That(query.Parameters, Does.ContainKey("@Status"));
-        Assert.That(query.Parameters["@UserId"], Is.Null);
-        Assert.That(query.Parameters["@Status"], Is.Null);
+        Assert.Multiple(() =>
+        {
+            Assert.That(query.Parameters["@UserId"], Is.Null);
+            Assert.That(query.Parameters["@Status"], Is.Null);
+        });
     }
 
     [Test]
@@ -481,9 +517,12 @@ public class QueryBreakdownTests
         // Act - AddWhereClause should not overwrite existing non-null values
         query.AddWhereClause("UserID = @UserId AND Status = @Status");
 
-        // Assert - Values should be preserved
-        Assert.That(query.Parameters["@UserId"], Is.EqualTo(123));
-        Assert.That(query.Parameters["@Status"], Is.EqualTo("Active"));
+        Assert.Multiple(() =>
+        {
+            // Assert - Values should be preserved
+            Assert.That(query.Parameters["@UserId"], Is.EqualTo(123));
+            Assert.That(query.Parameters["@Status"], Is.EqualTo("Active"));
+        });
     }
 
     #endregion
@@ -567,8 +606,11 @@ public class QueryBreakdownTests
 
         // Assert
         Assert.That(mainQuery.WithClauses, Has.Count.EqualTo(1));
-        Assert.That(mainQuery.WithClauses[0].TableName, Is.EqualTo("ProductOrders"));
-        Assert.That(mainQuery.WithClauses[0].Query, Is.EqualTo(cteQuery));
+        Assert.Multiple(() =>
+        {
+            Assert.That(mainQuery.WithClauses[0].TableName, Is.EqualTo("ProductOrders"));
+            Assert.That(mainQuery.WithClauses[0].Query, Is.EqualTo(cteQuery));
+        });
     }
 
     [Test]
@@ -587,9 +629,12 @@ public class QueryBreakdownTests
 
         // Assert
         Assert.That(mainQuery.WithClauses, Has.Count.EqualTo(3));
-        Assert.That(mainQuery.WithClauses[0].TableName, Is.EqualTo("CTE1"));
-        Assert.That(mainQuery.WithClauses[1].TableName, Is.EqualTo("CTE2"));
-        Assert.That(mainQuery.WithClauses[2].TableName, Is.EqualTo("CTE3"));
+        Assert.Multiple(() =>
+        {
+            Assert.That(mainQuery.WithClauses[0].TableName, Is.EqualTo("CTE1"));
+            Assert.That(mainQuery.WithClauses[1].TableName, Is.EqualTo("CTE2"));
+            Assert.That(mainQuery.WithClauses[2].TableName, Is.EqualTo("CTE3"));
+        });
     }
 
     [Test]
@@ -604,9 +649,12 @@ public class QueryBreakdownTests
 
         // Assert
         Assert.That(mainQuery.WithClauses, Has.Count.EqualTo(1));
-        Assert.That(mainQuery.WithClauses[0].TableName, Is.EqualTo("ProductOrders"));
-        Assert.That(mainQuery.WithClauses[0].Query!.SelectClause.Clause, Does.Contain("ProductID"));
-        Assert.That(mainQuery.WithClauses[0].Query!.GroupByClause.Clause, Does.Contain("ProductID"));
+        Assert.Multiple(() =>
+        {
+            Assert.That(mainQuery.WithClauses[0].TableName, Is.EqualTo("ProductOrders"));
+            Assert.That(mainQuery.WithClauses[0].Query!.SelectClause.Clause, Does.Contain("ProductID"));
+            Assert.That(mainQuery.WithClauses[0].Query!.GroupByClause.Clause, Does.Contain("ProductID"));
+        });
     }
 
     [Test]
@@ -665,11 +713,14 @@ public class QueryBreakdownTests
         var innerParams = innerCte.ParameterList.Count();
         var middleParams = middleCte.ParameterList.Count();
 
-        // Assert - Each CTE maintains its own parameters
-        Assert.That(innerParams, Is.EqualTo(1));
-        Assert.That(middleParams, Is.EqualTo(1));
-        // SQL should contain both WITH clauses
-        Assert.That(sql, Does.Contain("WITH"));
+        Assert.Multiple(() =>
+        {
+            // Assert - Each CTE maintains its own parameters
+            Assert.That(innerParams, Is.EqualTo(1));
+            Assert.That(middleParams, Is.EqualTo(1));
+            // SQL should contain both WITH clauses
+            Assert.That(sql, Does.Contain("WITH"));
+        });
         Assert.That(sql, Does.Contain("recent_users"));
         Assert.That(sql, Does.Contain("filtered_users"));
     }
@@ -722,8 +773,11 @@ public class QueryBreakdownTests
         // Assert - Verify WITH clause appears before main SELECT
         var withIndex = sql.IndexOf("WITH");
         var mainSelectIndex = sql.LastIndexOf("SELECT");
-        Assert.That(withIndex, Is.GreaterThan(-1));
-        Assert.That(mainSelectIndex, Is.GreaterThan(-1));
+        Assert.Multiple(() =>
+        {
+            Assert.That(withIndex, Is.GreaterThan(-1));
+            Assert.That(mainSelectIndex, Is.GreaterThan(-1));
+        });
         Assert.That(withIndex, Is.LessThan(mainSelectIndex));
 
         // Assert - Verify CTE definition
@@ -745,13 +799,19 @@ public class QueryBreakdownTests
         var sql = mainQuery.GetSql();
         var withClause = mainQuery.WithClauses[0];
 
-        // Assert: Verify WithClause properties
-        Assert.That(withClause.TableName, Is.EqualTo("sales_team"));
-        Assert.That(withClause.Query, Is.Not.Null);
-        Assert.That(withClause.Sql, Is.Not.Null);
-        Assert.That(withClause.Sql?.SelectClause?.Clause, Contains.Substring("id, name"));
-        Assert.That(withClause.Sql?.FromClause?.Clause, Contains.Substring("employees"));
-        Assert.That(withClause.Sql?.WhereClause?.Clause, Contains.Substring("department = 'Sales'"));
+        Assert.Multiple(() =>
+        {
+            // Assert: Verify WithClause properties
+            Assert.That(withClause.TableName, Is.EqualTo("sales_team"));
+            Assert.That(withClause.Query, Is.Not.Null);
+            Assert.That(withClause.Sql, Is.Not.Null);
+        });
+        Assert.Multiple(() =>
+        {
+            Assert.That(withClause.Sql?.SelectClause?.Clause, Contains.Substring("id, name"));
+            Assert.That(withClause.Sql?.FromClause?.Clause, Contains.Substring("employees"));
+            Assert.That(withClause.Sql?.WhereClause?.Clause, Contains.Substring("department = 'Sales'"));
+        });
     }
 
     [Test]
@@ -767,9 +827,12 @@ public class QueryBreakdownTests
         var cte = new QueryBreakdown("id, name", "source_table");
         query.AddWithClause("source_cte", cte);
 
-        // Assert - Now using WITH clause
-        Assert.That(query.IsUsingWithClause, Is.True);
-        Assert.That(query.WithClauses, Has.Count.EqualTo(1));
+        Assert.Multiple(() =>
+        {
+            // Assert - Now using WITH clause
+            Assert.That(query.IsUsingWithClause, Is.True);
+            Assert.That(query.WithClauses, Has.Count.EqualTo(1));
+        });
     }
 
     #endregion
@@ -925,9 +988,12 @@ public class QueryBreakdownTests
         // Act
         var query = QueryBreakdown.Parse(sql);
 
-        // Assert
-        Assert.That(query.SelectClause.Clause?.Trim(), Does.Contain("ID, Name"));
-        Assert.That(query.FromClause.Clause?.Trim(), Does.Contain("Users"));
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(query.SelectClause.Clause?.Trim(), Does.Contain("ID, Name"));
+            Assert.That(query.FromClause.Clause?.Trim(), Does.Contain("Users"));
+        });
     }
 
     [Test]
@@ -939,10 +1005,13 @@ public class QueryBreakdownTests
         // Act
         var query = QueryBreakdown.Parse(sql);
 
-        // Assert
-        Assert.That(query.SelectClause.Clause?.Trim(), Does.Contain("ID, Name"));
-        Assert.That(query.FromClause.Clause?.Trim(), Does.Contain("Users"));
-        Assert.That(query.WhereClause.Clause?.Trim(), Does.Contain("Active = 1"));
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(query.SelectClause.Clause?.Trim(), Does.Contain("ID, Name"));
+            Assert.That(query.FromClause.Clause?.Trim(), Does.Contain("Users"));
+            Assert.That(query.WhereClause.Clause?.Trim(), Does.Contain("Active = 1"));
+        });
     }
 
     [Test]
@@ -954,10 +1023,13 @@ public class QueryBreakdownTests
         // Act
         var query = QueryBreakdown.Parse(sql);
 
-        // Assert
-        Assert.That(query.SelectClause.Clause?.Trim(), Does.Contain("Department"));
-        Assert.That(query.GroupByClause.Clause?.Trim(), Does.Contain("Department"));
-        Assert.That(query.HavingClause.Clause?.Trim(), Does.Contain("COUNT(*) > 5"));
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(query.SelectClause.Clause?.Trim(), Does.Contain("Department"));
+            Assert.That(query.GroupByClause.Clause?.Trim(), Does.Contain("Department"));
+            Assert.That(query.HavingClause.Clause?.Trim(), Does.Contain("COUNT(*) > 5"));
+        });
     }
 
     [Test]
@@ -1003,10 +1075,13 @@ public class QueryBreakdownTests
         // Act
         var query = QueryBreakdown.Parse(sql);
 
-        // Assert
-        Assert.That(query.IsUsingWithClause, Is.True);
-        Assert.That(query.SelectClause.Clause?.Trim(), Does.Contain("p.*, ps.TotalQty"));
-        Assert.That(query.FromClause.Clause?.Trim(), Does.Contain("Products p"));
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(query.IsUsingWithClause, Is.True);
+            Assert.That(query.SelectClause.Clause?.Trim(), Does.Contain("p.*, ps.TotalQty"));
+            Assert.That(query.FromClause.Clause?.Trim(), Does.Contain("Products p"));
+        });
     }
 
     [Test]
@@ -1042,9 +1117,12 @@ public class QueryBreakdownTests
         // Act
         var success = QueryBreakdown.TryParse(sql, out var query);
 
-        // Assert
-        Assert.That(success, Is.True);
-        Assert.That(query, Is.Not.Null);
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(success, Is.True);
+            Assert.That(query, Is.Not.Null);
+        });
     }
 
     [Test]
@@ -1056,10 +1134,13 @@ public class QueryBreakdownTests
         // Act
         var success = QueryBreakdown.TryParse(sql, out var query, out var error);
 
-        // Assert
-        Assert.That(success, Is.False);
-        Assert.That(query, Is.Null);
-        Assert.That(error, Is.Not.Null);
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(success, Is.False);
+            Assert.That(query, Is.Null);
+            Assert.That(error, Is.Not.Null);
+        });
     }
 
     #endregion
@@ -1134,10 +1215,13 @@ public class QueryBreakdownTests
 
         // Assert
         Assert.That(clone, Is.Not.SameAs(original));
-        Assert.That(clone.SelectClause.Clause, Is.EqualTo(original.SelectClause.Clause));
-        Assert.That(clone.FromClause.Clause, Is.EqualTo(original.FromClause.Clause));
-        Assert.That(clone.WhereClause.Clause, Is.EqualTo(original.WhereClause.Clause));
-        Assert.That(clone.OrderByClause.Clause, Is.EqualTo(original.OrderByClause.Clause));
+        Assert.Multiple(() =>
+        {
+            Assert.That(clone.SelectClause.Clause, Is.EqualTo(original.SelectClause.Clause));
+            Assert.That(clone.FromClause.Clause, Is.EqualTo(original.FromClause.Clause));
+            Assert.That(clone.WhereClause.Clause, Is.EqualTo(original.WhereClause.Clause));
+            Assert.That(clone.OrderByClause.Clause, Is.EqualTo(original.OrderByClause.Clause));
+        });
     }
 
     [Test]
@@ -1150,9 +1234,12 @@ public class QueryBreakdownTests
         // Act
         clone.WhereClause.Clause = "Active = 1";
 
-        // Assert
-        Assert.That(original.WhereClause.Clause, Is.EqualTo(string.Empty));
-        Assert.That(clone.WhereClause.Clause, Is.EqualTo("Active = 1"));
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(original.WhereClause.Clause, Is.EqualTo(string.Empty));
+            Assert.That(clone.WhereClause.Clause, Is.EqualTo("Active = 1"));
+        });
     }
 
     #endregion
@@ -1202,9 +1289,12 @@ public class QueryBreakdownTests
         // Act
         var query = QueryBreakdown.Parse(sql);
 
-        // Assert
-        Assert.That(query.SelectClause.Clause, Does.Contain("\"User Name\""));
-        Assert.That(query.FromClause.Clause, Does.Contain("\"User Table\""));
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(query.SelectClause.Clause, Does.Contain("\"User Name\""));
+            Assert.That(query.FromClause.Clause, Does.Contain("\"User Table\""));
+        });
     }
 
     [Test]
@@ -1469,8 +1559,11 @@ public class QueryBreakdownTests
         // Assert
         Assert.That(query.SelectClause.Clause, Does.Contain("[Select]"));
         Assert.That(query.SelectClause.Clause, Does.Contain("[From]"));
-        Assert.That(query.SelectClause.Clause, Does.Contain("[Where]"));
-        Assert.That(query.FromClause.Clause, Does.Contain("[Order]"));
+        Assert.Multiple(() =>
+        {
+            Assert.That(query.SelectClause.Clause, Does.Contain("[Where]"));
+            Assert.That(query.FromClause.Clause, Does.Contain("[Order]"));
+        });
     }
 
     [Test]
@@ -1863,9 +1956,12 @@ public class QueryBreakdownTests
         // Act
         query.AddSelectExpression(expr, "/* Primary key */");
 
-        // Assert
-        Assert.That(query.SelectClause.Clause, Is.EqualTo("[Customers].[CustomerID]"));
-        Assert.That(query.SelectClause.Comment, Is.EqualTo("/* Primary key */"));
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(query.SelectClause.Clause, Is.EqualTo("[Customers].[CustomerID]"));
+            Assert.That(query.SelectClause.Comment, Is.EqualTo("/* Primary key */"));
+        });
     }
 
     [Test]

tests/Strata.SqlTools.SqlServer.Tests/SqlServer/RecursiveCTETests.cs

@@ -33,9 +33,12 @@ public class RecursiveCTETests
         var isRecursive = withClause.IsRecursive;
         var hasRecursiveQuery = withClause.RecursiveQuery != null;
 
-        // Assert
-        Assert.That(isRecursive, Is.True);
-        Assert.That(hasRecursiveQuery, Is.True);
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(isRecursive, Is.True);
+            Assert.That(hasRecursiveQuery, Is.True);
+        });
     }
 
     [Test]
@@ -143,10 +146,13 @@ public class RecursiveCTETests
 
         // Assert
         var keys = merged.Keys.ToList();
-        Assert.That(keys.Any(k => k.Contains("AnchorStatus")), "Should include anchor query parameters");
-        Assert.That(keys.Any(k => k.Contains("RecursiveLevel")), "Should include recursive query parameters");
-        Assert.That(keys.Any(k => k.Contains("RecursiveStatus")), "Should include recurring query parameters");
-        Assert.That(keys.Any(k => k.Contains("MainLimit")), "Should include main query parameters");
+        Assert.Multiple(() =>
+        {
+            Assert.That(keys.Any(k => k.Contains("AnchorStatus")), "Should include anchor query parameters");
+            Assert.That(keys.Any(k => k.Contains("RecursiveLevel")), "Should include recursive query parameters");
+            Assert.That(keys.Any(k => k.Contains("RecursiveStatus")), "Should include recurring query parameters");
+            Assert.That(keys.Any(k => k.Contains("MainLimit")), "Should include main query parameters");
+        });
     }
 
     [Test]
@@ -175,8 +181,11 @@ public class RecursiveCTETests
 
         // Assert
         var statusKey = merged.Keys.FirstOrDefault(k => k.Contains("Status") && !k.Contains('@') && !k.Contains('$'));
-        Assert.That(statusKey, Is.Not.Null);
-        Assert.That(merged[statusKey], Is.EqualTo("active"), "Main query parameter should take precedence");
+        Assert.Multiple(() =>
+        {
+            Assert.That(statusKey, Is.Not.Null);
+            Assert.That(merged[statusKey], Is.EqualTo("active"), "Main query parameter should take precedence");
+        });
     }
 
     #endregion

tests/Strata.SqlTools.SqlServer.Tests/SqlServer/StatementExpressionParserTests.cs

@@ -280,8 +280,11 @@ public class StatementExpressionParserTests
 
         // Act & Assert
         var ex = Assert.Throws<ArgumentNullException>(() => _parser.Parse(sql));
-        Assert.That(ex.ParamName, Is.EqualTo("sqlStatement"));
-        Assert.That(ex.Message, Does.Contain("SQL statement cannot be null or empty"));
+        Assert.Multiple(() =>
+        {
+            Assert.That(ex.ParamName, Is.EqualTo("sqlStatement"));
+            Assert.That(ex.Message, Does.Contain("SQL statement cannot be null or empty"));
+        });
     }
 
     [Test]
@@ -351,9 +354,12 @@ public class StatementExpressionParserTests
         // Act
         var success = _parser.TryParse(sql, out var result);
 
-        // Assert
-        Assert.That(success, Is.True);
-        Assert.That(result, Is.Not.Null);
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(success, Is.True);
+            Assert.That(result, Is.Not.Null);
+        });
         Assert.That(result, Is.InstanceOf<NumberLiteralExpression>());
     }
 
@@ -366,9 +372,12 @@ public class StatementExpressionParserTests
         // Act
         var success = _parser.TryParse(sql, out var result);
 
-        // Assert
-        Assert.That(success, Is.True);
-        Assert.That(result, Is.Not.Null);
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(success, Is.True);
+            Assert.That(result, Is.Not.Null);
+        });
     }
 
     [Test]
@@ -380,9 +389,12 @@ public class StatementExpressionParserTests
         // Act
         var success = _parser.TryParse(sql, out var result);
 
-        // Assert
-        Assert.That(success, Is.True);
-        Assert.That(result, Is.Not.Null);
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(success, Is.True);
+            Assert.That(result, Is.Not.Null);
+        });
         Assert.That(result, Is.InstanceOf<SumFunction>());
     }
 
@@ -395,9 +407,12 @@ public class StatementExpressionParserTests
         // Act
         var success = _parser.TryParse(sql, out var result);
 
-        // Assert
-        Assert.That(success, Is.False);
-        Assert.That(result, Is.Null);
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(success, Is.False);
+            Assert.That(result, Is.Null);
+        });
     }
 
     [Test]
@@ -409,9 +424,12 @@ public class StatementExpressionParserTests
         // Act
         var success = _parser.TryParse(sql, out var result);
 
-        // Assert
-        Assert.That(success, Is.False);
-        Assert.That(result, Is.Null);
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(success, Is.False);
+            Assert.That(result, Is.Null);
+        });
     }
 
     [Test]
@@ -423,9 +441,12 @@ public class StatementExpressionParserTests
         // Act
         var success = _parser.TryParse(sql, out var result);
 
-        // Assert
-        Assert.That(success, Is.False);
-        Assert.That(result, Is.Null);
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(success, Is.False);
+            Assert.That(result, Is.Null);
+        });
     }
 
     [Test]
@@ -437,9 +458,12 @@ public class StatementExpressionParserTests
         // Act
         var success = _parser.TryParse(sql, out var result);
 
-        // Assert
-        Assert.That(success, Is.False);
-        Assert.That(result, Is.Null);
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(success, Is.False);
+            Assert.That(result, Is.Null);
+        });
     }
 
     [Test]
@@ -451,10 +475,13 @@ public class StatementExpressionParserTests
         // Act
         var success = _parser.TryParse(sql, out var result, out var errorMessage);
 
-        // Assert
-        Assert.That(success, Is.True);
-        Assert.That(result, Is.Not.Null);
-        Assert.That(errorMessage, Is.Null);
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(success, Is.True);
+            Assert.That(result, Is.Not.Null);
+            Assert.That(errorMessage, Is.Null);
+        });
     }
 
     [Test]
@@ -466,10 +493,13 @@ public class StatementExpressionParserTests
         // Act
         var success = _parser.TryParse(sql, out var result, out var errorMessage);
 
-        // Assert
-        Assert.That(success, Is.False);
-        Assert.That(result, Is.Null);
-        Assert.That(errorMessage, Is.Not.Null);
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(success, Is.False);
+            Assert.That(result, Is.Null);
+            Assert.That(errorMessage, Is.Not.Null);
+        });
         Assert.That(errorMessage, Does.Contain("SQL statement cannot be null or empty"));
     }
 
@@ -482,10 +512,13 @@ public class StatementExpressionParserTests
         // Act
         var success = _parser.TryParse(sql, out var result, out var errorMessage);
 
-        // Assert
-        Assert.That(success, Is.False);
-        Assert.That(result, Is.Null);
-        Assert.That(errorMessage, Is.Not.Null);
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(success, Is.False);
+            Assert.That(result, Is.Null);
+            Assert.That(errorMessage, Is.Not.Null);
+        });
         Assert.That(errorMessage, Does.Contain("Invalid syntax"));
     }
 
@@ -498,10 +531,13 @@ public class StatementExpressionParserTests
         // Act
         var success = _parser.TryParse(sql, out var result, out var errorMessage);
 
-        // Assert
-        Assert.That(success, Is.False);
-        Assert.That(result, Is.Null);
-        Assert.That(errorMessage, Is.Not.Null);
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(success, Is.False);
+            Assert.That(result, Is.Null);
+            Assert.That(errorMessage, Is.Not.Null);
+        });
         Assert.That(errorMessage, Does.Contain("not recognized"));
     }
 

tests/Strata.SqlTools.SqlServer.Tests/SqlServer/StatementReaderTests.cs

@@ -22,8 +22,11 @@ public class StatementReaderTests
 
         // Assert
         Assert.That(tokens, Is.Not.Empty);
-        Assert.That(tokens[0].Type, Is.EqualTo(TokenType.LeftParenthesis));
-        Assert.That(tokens[1].Type, Is.EqualTo(TokenType.Number));
-        Assert.That(tokens[1].Value, Is.EqualTo("1"));
+        Assert.Multiple(() =>
+        {
+            Assert.That(tokens[0].Type, Is.EqualTo(TokenType.LeftParenthesis));
+            Assert.That(tokens[1].Type, Is.EqualTo(TokenType.Number));
+            Assert.That(tokens[1].Value, Is.EqualTo("1"));
+        });
     }
 }

tests/Strata.SqlTools.SqlServer.Tests/SqlServer/WithClauseTests.cs

@@ -15,11 +15,14 @@ public class WithClauseTests
         // Arrange & Act
         var withClause = new WithClause();
 
-        // Assert
-        Assert.That(withClause.TableName, Is.EqualTo(string.Empty));
-        Assert.That(withClause.Sql, Is.Null);
-        Assert.That(withClause.Query, Is.Null);
-        Assert.That(withClause.Clause, Is.Null.Or.Empty);
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(withClause.TableName, Is.EqualTo(string.Empty));
+            Assert.That(withClause.Sql, Is.Null);
+            Assert.That(withClause.Query, Is.Null);
+            Assert.That(withClause.Clause, Is.Null.Or.Empty);
+        });
     }
 
     [Test]
@@ -32,10 +35,13 @@ public class WithClauseTests
         // Act
         var withClause = new WithClause(tableName, query);
 
-        // Assert
-        Assert.That(withClause.TableName, Is.EqualTo(tableName));
-        Assert.That(withClause.Query, Is.EqualTo(query));
-        Assert.That(withClause.Sql, Is.Not.Null);
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(withClause.TableName, Is.EqualTo(tableName));
+            Assert.That(withClause.Query, Is.EqualTo(query));
+            Assert.That(withClause.Sql, Is.Not.Null);
+        });
     }
 
     [Test]
@@ -72,10 +78,13 @@ public class WithClauseTests
         // Act
         var withClause = new WithClause(tableName, sqlClauses);
 
-        // Assert
-        Assert.That(withClause.TableName, Is.EqualTo(tableName));
-        Assert.That(withClause.Sql, Is.EqualTo(sqlClauses));
-        Assert.That(withClause.Query, Is.Null);
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(withClause.TableName, Is.EqualTo(tableName));
+            Assert.That(withClause.Sql, Is.EqualTo(sqlClauses));
+            Assert.That(withClause.Query, Is.Null);
+        });
     }
 
     [Test]
@@ -117,8 +126,11 @@ public class WithClauseTests
 
         // Assert
         Assert.That(sql, Is.Not.Null);
-        Assert.That(sql!.SelectClause?.Clause, Is.EqualTo("user_id, name"));
-        Assert.That(sql.FromClause?.Clause, Is.EqualTo("users"));
+        Assert.Multiple(() =>
+        {
+            Assert.That(sql!.SelectClause?.Clause, Is.EqualTo("user_id, name"));
+            Assert.That(sql.FromClause?.Clause, Is.EqualTo("users"));
+        });
     }
 
     [Test]
@@ -153,9 +165,12 @@ public class WithClauseTests
         // Act
         withClause.Sql = sqlClauses;
 
-        // Assert
-        Assert.That(withClause.Sql, Is.EqualTo(sqlClauses));
-        Assert.That(withClause.Query, Is.Null);
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(withClause.Sql, Is.EqualTo(sqlClauses));
+            Assert.That(withClause.Query, Is.Null);
+        });
     }
 
     [Test]
@@ -173,12 +188,15 @@ public class WithClauseTests
         // Act
         withClause.Sql = sqlClauses;
 
-        // Assert - Clauses are applied to the Query
-        Assert.That(query.SelectClause.Clause, Is.EqualTo("column1"));
-        Assert.That(query.FromClause.Clause, Is.EqualTo("table1"));
-        // And Sql property returns the applied clauses (from Query, not stored)
-        Assert.That(withClause.Sql?.SelectClause?.Clause, Is.EqualTo("column1"));
-        Assert.That(withClause.Sql?.FromClause?.Clause, Is.EqualTo("table1"));
+        Assert.Multiple(() =>
+        {
+            // Assert - Clauses are applied to the Query
+            Assert.That(query.SelectClause.Clause, Is.EqualTo("column1"));
+            Assert.That(query.FromClause.Clause, Is.EqualTo("table1"));
+            // And Sql property returns the applied clauses (from Query, not stored)
+            Assert.That(withClause.Sql?.SelectClause?.Clause, Is.EqualTo("column1"));
+            Assert.That(withClause.Sql?.FromClause?.Clause, Is.EqualTo("table1"));
+        });
     }
 
     [Test]
@@ -197,9 +215,12 @@ public class WithClauseTests
         var query = new QueryBreakdown();
         withClause.Query = query;
 
-        // Assert - Stored SQL is applied to Query
-        Assert.That(query.SelectClause.Clause, Is.EqualTo("column1"));
-        Assert.That(query.FromClause.Clause, Is.EqualTo("table1"));
+        Assert.Multiple(() =>
+        {
+            // Assert - Stored SQL is applied to Query
+            Assert.That(query.SelectClause.Clause, Is.EqualTo("column1"));
+            Assert.That(query.FromClause.Clause, Is.EqualTo("table1"));
+        });
     }
 
     [Test]
@@ -237,10 +258,13 @@ public class WithClauseTests
         var query = new QueryBreakdown();
         withClause.Query = query;
 
-        // Assert
-        Assert.That(query.SelectClause.Clause, Is.EqualTo("old_column"));
-        Assert.That(query.FromClause.Clause, Is.EqualTo("old_table"));
-        Assert.That(withClause.Query, Is.EqualTo(query));
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(query.SelectClause.Clause, Is.EqualTo("old_column"));
+            Assert.That(query.FromClause.Clause, Is.EqualTo("old_table"));
+            Assert.That(withClause.Query, Is.EqualTo(query));
+        });
     }
 
     [Test]
@@ -258,9 +282,12 @@ public class WithClauseTests
         };
         withClause.Sql = sqlClauses;
 
-        // Assert
-        Assert.That(query.SelectClause.Clause, Is.EqualTo("new_column"));
-        Assert.That(query.FromClause.Clause, Is.EqualTo("new_table"));
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(query.SelectClause.Clause, Is.EqualTo("new_column"));
+            Assert.That(query.FromClause.Clause, Is.EqualTo("new_table"));
+        });
     }
 
     #endregion
@@ -283,12 +310,15 @@ public class WithClauseTests
 
         // Assert
         Assert.That(sql, Is.Not.Null);
-        Assert.That(sql!.SelectClause?.Clause, Is.EqualTo("id, name"));
-        Assert.That(sql.FromClause?.Clause, Is.EqualTo("users"));
-        Assert.That(sql.WhereClause?.Clause, Is.EqualTo("active = 1"));
-        Assert.That(sql.GroupByClause?.Clause, Is.EqualTo("department"));
-        Assert.That(sql.HavingClause?.Clause, Is.EqualTo("COUNT(*) > 5"));
-        Assert.That(sql.OrderByClause?.Clause, Is.EqualTo("name ASC"));
+        Assert.Multiple(() =>
+        {
+            Assert.That(sql!.SelectClause?.Clause, Is.EqualTo("id, name"));
+            Assert.That(sql.FromClause?.Clause, Is.EqualTo("users"));
+            Assert.That(sql.WhereClause?.Clause, Is.EqualTo("active = 1"));
+            Assert.That(sql.GroupByClause?.Clause, Is.EqualTo("department"));
+            Assert.That(sql.HavingClause?.Clause, Is.EqualTo("COUNT(*) > 5"));
+            Assert.That(sql.OrderByClause?.Clause, Is.EqualTo("name ASC"));
+        });
     }
 
     #endregion
@@ -315,13 +345,16 @@ public class WithClauseTests
         // Act
         withClause.Sql = sqlClauses;
 
-        // Assert
-        Assert.That(query.SelectClause.Clause, Is.EqualTo("id, name"));
-        Assert.That(query.FromClause.Clause, Is.EqualTo("users"));
-        Assert.That(query.WhereClause.Clause, Is.EqualTo("active = 1"));
-        Assert.That(query.GroupByClause.Clause, Is.EqualTo("department"));
-        Assert.That(query.HavingClause.Clause, Is.EqualTo("COUNT(*) > 5"));
-        Assert.That(query.OrderByClause.Clause, Is.EqualTo("name ASC"));
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(query.SelectClause.Clause, Is.EqualTo("id, name"));
+            Assert.That(query.FromClause.Clause, Is.EqualTo("users"));
+            Assert.That(query.WhereClause.Clause, Is.EqualTo("active = 1"));
+            Assert.That(query.GroupByClause.Clause, Is.EqualTo("department"));
+            Assert.That(query.HavingClause.Clause, Is.EqualTo("COUNT(*) > 5"));
+            Assert.That(query.OrderByClause.Clause, Is.EqualTo("name ASC"));
+        });
     }
 
     [Test]
@@ -340,9 +373,12 @@ public class WithClauseTests
         // Act
         withClause.Sql = sqlClauses;
 
-        // Assert
-        Assert.That(query.SelectClause.Clause, Is.EqualTo("new_select"));
-        Assert.That(query.FromClause.Clause, Is.EqualTo("original_from")); // Unchanged
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(query.SelectClause.Clause, Is.EqualTo("new_select"));
+            Assert.That(query.FromClause.Clause, Is.EqualTo("original_from")); // Unchanged
+        });
     }
 
     #endregion
@@ -448,14 +484,17 @@ public class WithClauseTests
         var innerSql = innerCte.Sql;
         var outerSql = outerCte.Sql;
 
-        // Assert - Inner CTE has parameter and correct clauses
-        Assert.That(innerQuery.ParameterList.Count(), Is.EqualTo(1));
-        Assert.That(innerSql?.SelectClause?.Clause, Is.EqualTo("id, name"));
-        Assert.That(innerSql?.WhereClause?.Clause, Is.EqualTo("created_date >= @StartDate"));
+        Assert.Multiple(() =>
+        {
+            // Assert - Inner CTE has parameter and correct clauses
+            Assert.That(innerQuery.ParameterList.Count(), Is.EqualTo(1));
+            Assert.That(innerSql?.SelectClause?.Clause, Is.EqualTo("id, name"));
+            Assert.That(innerSql?.WhereClause?.Clause, Is.EqualTo("created_date >= @StartDate"));
 
-        // Assert - Outer CTE references inner CTE
-        Assert.That(outerSql?.SelectClause?.Clause, Is.EqualTo("*"));
-        Assert.That(outerSql?.FromClause?.Clause, Is.EqualTo("recent_users"));
+            // Assert - Outer CTE references inner CTE
+            Assert.That(outerSql?.SelectClause?.Clause, Is.EqualTo("*"));
+            Assert.That(outerSql?.FromClause?.Clause, Is.EqualTo("recent_users"));
+        });
     }
 
     [Test]
@@ -495,9 +534,12 @@ public class WithClauseTests
         Assert.That(sql, Does.Contain("WITH"));
         Assert.That(sql, Does.Contain("active_users"));
         Assert.That(sql, Does.Contain("AS"));
-        // Check for keywords/content (allowing for formatting variations)
-        Assert.That(sql.ToUpper(), Does.Contain("SELECT"));
-        Assert.That(sql, Does.Contain("id, name"));
+        Assert.Multiple(() =>
+        {
+            // Check for keywords/content (allowing for formatting variations)
+            Assert.That(sql.ToUpper(), Does.Contain("SELECT"));
+            Assert.That(sql, Does.Contain("id, name"));
+        });
         Assert.That(sql, Does.Contain("users"));
         Assert.That(sql, Does.Contain("active = 1"));
     }
@@ -523,8 +565,11 @@ public class WithClauseTests
         // Verify order: first CTE comes before second CTE
         var pos1 = sql.IndexOf("active_users");
         var pos2 = sql.IndexOf("user_orders");
-        Assert.That(pos1, Is.GreaterThan(-1));
-        Assert.That(pos2, Is.GreaterThan(-1));
+        Assert.Multiple(() =>
+        {
+            Assert.That(pos1, Is.GreaterThan(-1));
+            Assert.That(pos2, Is.GreaterThan(-1));
+        });
         Assert.That(pos1, Is.LessThan(pos2));    }
 
     #endregion