Merge pull request 'chore(sonar): clean up test-file INFO code smells (NUnit2045/2046/2011, CA1866/1861/1869)' (#14) from fix/sonarqube-test-cases-code-smells into main

Reviewed-on: #14

tests/Strata.SqlTools.EFCore.Tests/QueryBreakdownMapperTests.cs

@@ -27,9 +27,12 @@ public class QueryBreakdownMapperTests
 
         // Assert
         Assert.That(entity, Is.Not.Null);
-        Assert.That(entity.SelectClause, Is.EqualTo("ID, Name"));
-        Assert.That(entity.FromClause, Is.EqualTo("Users"));
-        Assert.That(entity.CreatedAt, Is.LessThanOrEqualTo(DateTime.UtcNow));
+        Assert.Multiple(() =>
+        {
+            Assert.That(entity.SelectClause, Is.EqualTo("ID, Name"));
+            Assert.That(entity.FromClause, Is.EqualTo("Users"));
+            Assert.That(entity.CreatedAt, Is.LessThanOrEqualTo(DateTime.UtcNow));
+        });
     }
 
     [Test]
@@ -46,11 +49,14 @@ public class QueryBreakdownMapperTests
         // Act
         var entity = _mapper.MapToEntity(queryBreakdown);
 
-        // Assert
-        Assert.That(entity.SelectClause, Is.EqualTo("ID, Name"));
-        Assert.That(entity.FromClause, Is.EqualTo("Users"));
-        Assert.That(entity.WhereClause, Is.EqualTo("Active = 1"));
-        Assert.That(entity.OrderByClause, Is.EqualTo("Name ASC"));
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(entity.SelectClause, Is.EqualTo("ID, Name"));
+            Assert.That(entity.FromClause, Is.EqualTo("Users"));
+            Assert.That(entity.WhereClause, Is.EqualTo("Active = 1"));
+            Assert.That(entity.OrderByClause, Is.EqualTo("Name ASC"));
+        });
     }
 
     [Test]
@@ -72,9 +78,12 @@ public class QueryBreakdownMapperTests
 
         // Assert
         Assert.That(queryBreakdown, Is.Not.Null);
-        Assert.That(queryBreakdown.SelectClause?.Clause, Is.EqualTo("ID, Name"));
-        Assert.That(queryBreakdown.FromClause?.Clause, Is.EqualTo("Users"));
-        Assert.That(queryBreakdown.WhereClause?.Clause, Is.EqualTo("Active = 1"));
+        Assert.Multiple(() =>
+        {
+            Assert.That(queryBreakdown.SelectClause?.Clause, Is.EqualTo("ID, Name"));
+            Assert.That(queryBreakdown.FromClause?.Clause, Is.EqualTo("Users"));
+            Assert.That(queryBreakdown.WhereClause?.Clause, Is.EqualTo("Active = 1"));
+        });
     }
 
     [Test]
@@ -110,11 +119,14 @@ public class QueryBreakdownMapperTests
         var entity = _mapper.MapToEntity(originalQuery);
         var restoredQuery = _mapper.MapToDomainModel(entity);
 
-        // Assert
-        Assert.That(restoredQuery.SelectClause?.Clause, Is.EqualTo(originalQuery.SelectClause?.Clause));
-        Assert.That(restoredQuery.FromClause?.Clause, Is.EqualTo(originalQuery.FromClause?.Clause));
-        Assert.That(restoredQuery.WhereClause?.Clause, Is.EqualTo(originalQuery.WhereClause?.Clause));
-        Assert.That(restoredQuery.OrderByClause?.Clause, Is.EqualTo(originalQuery.OrderByClause?.Clause));
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(restoredQuery.SelectClause?.Clause, Is.EqualTo(originalQuery.SelectClause?.Clause));
+            Assert.That(restoredQuery.FromClause?.Clause, Is.EqualTo(originalQuery.FromClause?.Clause));
+            Assert.That(restoredQuery.WhereClause?.Clause, Is.EqualTo(originalQuery.WhereClause?.Clause));
+            Assert.That(restoredQuery.OrderByClause?.Clause, Is.EqualTo(originalQuery.OrderByClause?.Clause));
+        });
     }
 
     [Test]
@@ -127,10 +139,16 @@ public class QueryBreakdownMapperTests
         // Act
         var (entity, parameters, withClauses) = _mapper.MapToEntityWithRelations(queryBreakdown);
 
-        // Assert
-        Assert.That(entity, Is.Not.Null);
-        Assert.That(parameters, Is.Not.Empty);
-        Assert.That(parameters.First().ParameterName, Is.EqualTo("UserId"));
-        Assert.That(withClauses, Is.Empty);
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(entity, Is.Not.Null);
+            Assert.That(parameters, Is.Not.Empty);
+        });
+        Assert.Multiple(() =>
+        {
+            Assert.That(parameters.First().ParameterName, Is.EqualTo("UserId"));
+            Assert.That(withClauses, Is.Empty);
+        });
     }
 }

tests/Strata.SqlTools.EFCore.Tests/QueryBreakdownRepositoryTests.cs

@@ -58,8 +58,11 @@ public class QueryBreakdownRepositoryTests
 
         // Assert
         Assert.That(retrieved, Is.Not.Null);
-        Assert.That(retrieved?.SelectClause?.Clause, Is.EqualTo("ID, Name"));
-        Assert.That(retrieved?.FromClause?.Clause, Is.EqualTo("Users"));
+        Assert.Multiple(() =>
+        {
+            Assert.That(retrieved?.SelectClause?.Clause, Is.EqualTo("ID, Name"));
+            Assert.That(retrieved?.FromClause?.Clause, Is.EqualTo("Users"));
+        });
     }
 
     [Test]
@@ -117,9 +120,12 @@ public class QueryBreakdownRepositoryTests
         bool deleted = await _repository.DeleteAsync(id);
         var retrieved = await _repository.GetByIdAsync(id);
 
-        // Assert
-        Assert.That(deleted, Is.True);
-        Assert.That(retrieved, Is.Null);
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(deleted, Is.True);
+            Assert.That(retrieved, Is.Null);
+        });
     }
 
     [Test]

tests/Strata.SqlTools.LinqToSql.Tests/LinqQueryBreakdownBuilderTests.cs

@@ -23,9 +23,12 @@ public class LinqQueryBreakdownBuilderTests
 
         // Assert
         Assert.That(breakdown, Is.Not.Null);
-        Assert.That(breakdown.SelectClause.Clause, Contains.Substring("Id"));
-        Assert.That(breakdown.FromClause.Clause, Is.EqualTo("Users"));
-        Assert.That(breakdown.WhereClause.Clause, Is.EqualTo("Age > 18"));
+        Assert.Multiple(() =>
+        {
+            Assert.That(breakdown.SelectClause.Clause, Contains.Substring("Id"));
+            Assert.That(breakdown.FromClause.Clause, Is.EqualTo("Users"));
+            Assert.That(breakdown.WhereClause.Clause, Is.EqualTo("Age > 18"));
+        });
     }
 
     [Test]
@@ -375,13 +378,16 @@ public class LinqQueryBreakdownBuilderTests
             .OrderByDescending("AvgSalary")
             .Build();
 
-        // Assert
-        Assert.That(breakdown.SelectClause.Clause, Contains.Substring("Department"));
-        Assert.That(breakdown.FromClause.Clause, Is.EqualTo("Employees"));
-        Assert.That(breakdown.WhereClause.Clause, Is.EqualTo("IsActive = true"));
-        Assert.That(breakdown.GroupByClause.Clause, Is.EqualTo("Department, Position"));
-        Assert.That(breakdown.HavingClause.Clause, Is.EqualTo("COUNT(*) >= 3"));
-        Assert.That(breakdown.OrderByClause.Clause, Is.EqualTo("AvgSalary DESC"));
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(breakdown.SelectClause.Clause, Contains.Substring("Department"));
+            Assert.That(breakdown.FromClause.Clause, Is.EqualTo("Employees"));
+            Assert.That(breakdown.WhereClause.Clause, Is.EqualTo("IsActive = true"));
+            Assert.That(breakdown.GroupByClause.Clause, Is.EqualTo("Department, Position"));
+            Assert.That(breakdown.HavingClause.Clause, Is.EqualTo("COUNT(*) >= 3"));
+            Assert.That(breakdown.OrderByClause.Clause, Is.EqualTo("AvgSalary DESC"));
+        });
     }
 
     [Test]
@@ -396,10 +402,13 @@ public class LinqQueryBreakdownBuilderTests
             .OrderByAscending("Id")
             .Build();
 
-        // Assert
-        Assert.That(breakdown.SelectClause.Clause, Contains.Substring("Id"));
-        Assert.That(breakdown.WhereClause.Clause, Is.EqualTo("IsActive = true"));
-        Assert.That(breakdown.OrderByClause.Clause, Is.EqualTo("Id ASC"));
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(breakdown.SelectClause.Clause, Contains.Substring("Id"));
+            Assert.That(breakdown.WhereClause.Clause, Is.EqualTo("IsActive = true"));
+            Assert.That(breakdown.OrderByClause.Clause, Is.EqualTo("Id ASC"));
+        });
     }
 
     #endregion
@@ -503,9 +512,12 @@ public class LinqQueryBreakdownBuilderTests
             .FromTable("Orders");
         var breakdown2 = builder2.Build();
 
-        // Assert
-        Assert.That(breakdown1.FromClause.Clause, Is.EqualTo("Users"));
-        Assert.That(breakdown2.FromClause.Clause, Is.EqualTo("Orders"));
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(breakdown1.FromClause.Clause, Is.EqualTo("Users"));
+            Assert.That(breakdown2.FromClause.Clause, Is.EqualTo("Orders"));
+        });
     }
 
     #endregion

tests/Strata.SqlTools.LinqToSql.Tests/LinqQueryBreakdownTests.cs

@@ -27,8 +27,11 @@ public class LinqQueryBreakdownTests
 
         // Assert
         Assert.That(breakdown, Is.Not.Null);
-        Assert.That(breakdown.EntityType, Is.EqualTo(typeof(User)));
-        Assert.That(breakdown.FromClause?.Clause, Does.Contain("User"));
+        Assert.Multiple(() =>
+        {
+            Assert.That(breakdown.EntityType, Is.EqualTo(typeof(User)));
+            Assert.That(breakdown.FromClause?.Clause, Does.Contain("User"));
+        });
     }
 
     [Test]
@@ -92,10 +95,13 @@ public class LinqQueryBreakdownTests
         // Act
         var breakdown = LinqQueryBreakdown.Analyze(query);
 
-        // Assert
-        Assert.That(breakdown.WhereClause?.Clause, Is.Not.Null);
-        Assert.That(breakdown.OrderByClause?.Clause, Is.Not.Null);
-        Assert.That(breakdown.SelectClause?.Clause, Is.Not.Null);
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(breakdown.WhereClause?.Clause, Is.Not.Null);
+            Assert.That(breakdown.OrderByClause?.Clause, Is.Not.Null);
+            Assert.That(breakdown.SelectClause?.Clause, Is.Not.Null);
+        });
     }
 
     [Test]
@@ -159,10 +165,13 @@ public class LinqQueryBreakdownTests
         // Act
         var success = LinqQueryBreakdown.TryAnalyze(query, out var breakdown, out var error);
 
-        // Assert
-        Assert.That(success, Is.True);
-        Assert.That(breakdown, Is.Not.Null);
-        Assert.That(error, Is.Empty);
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(success, Is.True);
+            Assert.That(breakdown, Is.Not.Null);
+            Assert.That(error, Is.Empty);
+        });
     }
 
     [Test]
@@ -174,9 +183,12 @@ public class LinqQueryBreakdownTests
         // Act
         var success = LinqQueryBreakdown.TryAnalyze(query!, out var breakdown, out var error);
 
-        // Assert
-        Assert.That(success, Is.False);
-        Assert.That(error, Is.Not.Empty);
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(success, Is.False);
+            Assert.That(error, Is.Not.Empty);
+        });
     }
 
     [Test]
@@ -194,10 +206,16 @@ public class LinqQueryBreakdownTests
         // Assert
         Assert.That(breakdown.SelectClause?.Clause, Does.Contain("Id"));
         Assert.That(breakdown.SelectClause?.Clause, Does.Contain("Name"));
-        Assert.That(breakdown.SelectClause?.Clause, Does.Contain("Email"));
-        Assert.That(breakdown.WhereClause?.Clause, Does.Contain("Age"));
-        Assert.That(breakdown.WhereClause?.Clause, Does.Contain("IsActive"));
-        Assert.That(breakdown.OrderByClause?.Clause, Does.Contain("Name"));
+        Assert.Multiple(() =>
+        {
+            Assert.That(breakdown.SelectClause?.Clause, Does.Contain("Email"));
+            Assert.That(breakdown.WhereClause?.Clause, Does.Contain("Age"));
+        });
+        Assert.Multiple(() =>
+        {
+            Assert.That(breakdown.WhereClause?.Clause, Does.Contain("IsActive"));
+            Assert.That(breakdown.OrderByClause?.Clause, Does.Contain("Name"));
+        });
     }
 
     #region Round-Trip and Query Modification Tests
@@ -278,9 +296,12 @@ public class LinqQueryBreakdownTests
         var activeSql = activeBreakdown.GetSql();
         var recentSql = recentBreakdown.GetSql();
 
-        // Assert - Both queries are valid and different
-        Assert.That(activeSql, Does.Contain("IsActive"));
-        Assert.That(recentSql, Does.Contain("Age"));
+        Assert.Multiple(() =>
+        {
+            // Assert - Both queries are valid and different
+            Assert.That(activeSql, Does.Contain("IsActive"));
+            Assert.That(recentSql, Does.Contain("Age"));
+        });
         Assert.That(activeSql, Is.Not.EqualTo(recentSql));
     }
 
@@ -328,8 +349,11 @@ public class LinqQueryBreakdownTests
 
         // Assert
         Assert.That(paginatedSql, Does.Contain("ORDER BY"));
-        Assert.That(paginatedSql, Does.Contain("Id ASC"));
-        Assert.That(breakdown.SetupClauses, Has.Count.EqualTo(1));
+        Assert.Multiple(() =>
+        {
+            Assert.That(paginatedSql, Does.Contain("Id ASC"));
+            Assert.That(breakdown.SetupClauses, Has.Count.EqualTo(1));
+        });
     }
 
     [Test]
@@ -351,12 +375,15 @@ public class LinqQueryBreakdownTests
         var hasOrdering = !string.IsNullOrEmpty(breakdown.OrderByClause?.Clause);
         var summary = breakdown.GetQuerySummary();
 
-        // Assert - Verify analytics
-        Assert.That(methodCount, Is.GreaterThan(0));
-        Assert.That(hasProjection, Is.True);
-        Assert.That(hasFilters, Is.True);
-        Assert.That(hasOrdering, Is.True);
-        Assert.That(summary, Does.Contain("SELECT"));
+        Assert.Multiple(() =>
+        {
+            // Assert - Verify analytics
+            Assert.That(methodCount, Is.GreaterThan(0));
+            Assert.That(hasProjection, Is.True);
+            Assert.That(hasFilters, Is.True);
+            Assert.That(hasOrdering, Is.True);
+            Assert.That(summary, Does.Contain("SELECT"));
+        });
         Assert.That(summary, Does.Contain("WHERE"));
         Assert.That(summary, Does.Contain("ORDER BY"));
     }
@@ -523,9 +550,12 @@ public class GetQueryTests
         var linqResult = linqBreakdown.GetQuery<User>();
         var sqlResult = sqlBreakdown.GetQuery<User>();
 
-        // Assert
-        Assert.That(linqResult, Is.Null);
-        Assert.That(sqlResult, Is.Null);
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(linqResult, Is.Null);
+            Assert.That(sqlResult, Is.Null);
+        });
     }
 
     #endregion
@@ -543,9 +573,12 @@ public class GetQueryTests
 
         // Assert
         Assert.That(breakdown, Is.Not.Null);
-        Assert.That(breakdown.TableName.Clause, Is.EqualTo("User"));
-        Assert.That(breakdown.InsertIntoClause.Clause, Is.Not.Empty);
-        Assert.That(breakdown.ValuesClause.Clause, Is.Not.Empty);
+        Assert.Multiple(() =>
+        {
+            Assert.That(breakdown.TableName.Clause, Is.EqualTo("User"));
+            Assert.That(breakdown.InsertIntoClause.Clause, Is.Not.Empty);
+            Assert.That(breakdown.ValuesClause.Clause, Is.Not.Empty);
+        });
         Assert.That(breakdown.InsertIntoClause.Clause, Does.Contain("Id"));
         Assert.That(breakdown.InsertIntoClause.Clause, Does.Contain("Name"));
     }
@@ -565,9 +598,12 @@ public class GetQueryTests
 
         // Assert
         Assert.That(breakdown, Is.Not.Null);
-        Assert.That(breakdown.TableName.Clause, Is.EqualTo("User"));
-        Assert.That(breakdown.InsertIntoClause.Clause, Is.Not.Empty);
-        Assert.That(breakdown.ValuesClause.Clause, Does.Contain("("));
+        Assert.Multiple(() =>
+        {
+            Assert.That(breakdown.TableName.Clause, Is.EqualTo("User"));
+            Assert.That(breakdown.InsertIntoClause.Clause, Is.Not.Empty);
+            Assert.That(breakdown.ValuesClause.Clause, Does.Contain("("));
+        });
     }
 
     [Test]
@@ -690,9 +726,12 @@ public class GetQueryTests
 
         // Assert
         Assert.That(breakdown, Is.Not.Null);
-        Assert.That(breakdown.ProcedureName.Clause, Is.EqualTo(procName));
-        Assert.That(breakdown.Parameters, Is.Not.Empty);
-        Assert.That(breakdown.Parameters.Count, Is.EqualTo(2));
+        Assert.Multiple(() =>
+        {
+            Assert.That(breakdown.ProcedureName.Clause, Is.EqualTo(procName));
+            Assert.That(breakdown.Parameters, Is.Not.Empty);
+        });
+        Assert.That(breakdown.Parameters, Has.Count.EqualTo(2));
     }
 
     [Test]
@@ -763,10 +802,13 @@ public class GetQueryTests
 
         // Assert
         Assert.That(sqlServerBreakdown, Is.Not.Null);
-        Assert.That(sqlServerBreakdown.SelectClause?.Clause, Is.EqualTo(breakdown.SelectClause?.Clause));
-        Assert.That(sqlServerBreakdown.FromClause?.Clause, Is.EqualTo(breakdown.FromClause?.Clause));
-        Assert.That(sqlServerBreakdown.WhereClause?.Clause, Is.EqualTo(breakdown.WhereClause?.Clause));
-        Assert.That(sqlServerBreakdown.OrderByClause?.Clause, Is.EqualTo(breakdown.OrderByClause?.Clause));
+        Assert.Multiple(() =>
+        {
+            Assert.That(sqlServerBreakdown.SelectClause?.Clause, Is.EqualTo(breakdown.SelectClause?.Clause));
+            Assert.That(sqlServerBreakdown.FromClause?.Clause, Is.EqualTo(breakdown.FromClause?.Clause));
+            Assert.That(sqlServerBreakdown.WhereClause?.Clause, Is.EqualTo(breakdown.WhereClause?.Clause));
+            Assert.That(sqlServerBreakdown.OrderByClause?.Clause, Is.EqualTo(breakdown.OrderByClause?.Clause));
+        });
     }
 
     [Test]
@@ -784,10 +826,13 @@ public class GetQueryTests
 
         // Assert
         Assert.That(postgresBreakdown, Is.Not.Null);
-        Assert.That(postgresBreakdown.SelectClause?.Clause, Is.EqualTo(breakdown.SelectClause?.Clause));
-        Assert.That(postgresBreakdown.FromClause?.Clause, Is.EqualTo(breakdown.FromClause?.Clause));
-        Assert.That(postgresBreakdown.WhereClause?.Clause, Is.EqualTo(breakdown.WhereClause?.Clause));
-        Assert.That(postgresBreakdown.OrderByClause?.Clause, Is.EqualTo(breakdown.OrderByClause?.Clause));
+        Assert.Multiple(() =>
+        {
+            Assert.That(postgresBreakdown.SelectClause?.Clause, Is.EqualTo(breakdown.SelectClause?.Clause));
+            Assert.That(postgresBreakdown.FromClause?.Clause, Is.EqualTo(breakdown.FromClause?.Clause));
+            Assert.That(postgresBreakdown.WhereClause?.Clause, Is.EqualTo(breakdown.WhereClause?.Clause));
+            Assert.That(postgresBreakdown.OrderByClause?.Clause, Is.EqualTo(breakdown.OrderByClause?.Clause));
+        });
     }
 
     [Test]
@@ -802,10 +847,13 @@ public class GetQueryTests
 
         // Assert
         Assert.That(snowflakeBreakdown, Is.Not.Null);
-        Assert.That(snowflakeBreakdown.SelectClause?.Clause, Is.EqualTo(breakdown.SelectClause?.Clause));
-        Assert.That(snowflakeBreakdown.FromClause?.Clause, Is.EqualTo(breakdown.FromClause?.Clause));
-        Assert.That(snowflakeBreakdown.WhereClause?.Clause, Is.EqualTo(breakdown.WhereClause?.Clause));
-        Assert.That(snowflakeBreakdown.OrderByClause?.Clause, Is.EqualTo(breakdown.OrderByClause?.Clause));
+        Assert.Multiple(() =>
+        {
+            Assert.That(snowflakeBreakdown.SelectClause?.Clause, Is.EqualTo(breakdown.SelectClause?.Clause));
+            Assert.That(snowflakeBreakdown.FromClause?.Clause, Is.EqualTo(breakdown.FromClause?.Clause));
+            Assert.That(snowflakeBreakdown.WhereClause?.Clause, Is.EqualTo(breakdown.WhereClause?.Clause));
+            Assert.That(snowflakeBreakdown.OrderByClause?.Clause, Is.EqualTo(breakdown.OrderByClause?.Clause));
+        });
     }
 
     [Test]
@@ -819,9 +867,12 @@ public class GetQueryTests
         // Act
         var sqlServerBreakdown = breakdown.ConvertToSqlServerBreakdown();
 
-        // Assert
-        Assert.That(sqlServerBreakdown.SelectClause?.Comment, Is.EqualTo("Select user columns"));
-        Assert.That(sqlServerBreakdown.WhereClause?.Comment, Is.EqualTo("Filter adult users"));
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(sqlServerBreakdown.SelectClause?.Comment, Is.EqualTo("Select user columns"));
+            Assert.That(sqlServerBreakdown.WhereClause?.Comment, Is.EqualTo("Filter adult users"));
+        });
     }
 
     [Test]
@@ -837,12 +888,15 @@ public class GetQueryTests
         // Act
         var postgresBreakdown = breakdown.ConvertToPostgreSqlBreakdown();
 
-        // Assert
-        Assert.That(postgresBreakdown.SelectClause?.Clause, Is.Not.Null);
-        Assert.That(postgresBreakdown.FromClause?.Clause, Is.Not.Null);
-        Assert.That(postgresBreakdown.WhereClause?.Clause, Is.Not.Null);
-        Assert.That(postgresBreakdown.GroupByClause?.Clause, Is.Not.Null);
-        Assert.That(postgresBreakdown.OrderByClause?.Clause, Is.Not.Null);
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(postgresBreakdown.SelectClause?.Clause, Is.Not.Null);
+            Assert.That(postgresBreakdown.FromClause?.Clause, Is.Not.Null);
+            Assert.That(postgresBreakdown.WhereClause?.Clause, Is.Not.Null);
+            Assert.That(postgresBreakdown.GroupByClause?.Clause, Is.Not.Null);
+            Assert.That(postgresBreakdown.OrderByClause?.Clause, Is.Not.Null);
+        });
     }
 
     [Test]
@@ -854,9 +908,12 @@ public class GetQueryTests
         // Act
         var snowflakeBreakdown = breakdown.ConvertToSnowflakeBreakdown();
 
-        // Assert
-        Assert.That(snowflakeBreakdown.FromClause?.Clause, Is.EqualTo(breakdown.FromClause?.Clause));
-        Assert.That(snowflakeBreakdown.OrderByClause?.Clause, Is.EqualTo(breakdown.OrderByClause?.Clause));
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(snowflakeBreakdown.FromClause?.Clause, Is.EqualTo(breakdown.FromClause?.Clause));
+            Assert.That(snowflakeBreakdown.OrderByClause?.Clause, Is.EqualTo(breakdown.OrderByClause?.Clause));
+        });
     }
 
     [Test]

tests/Strata.SqlTools.LinqToSql.Tests/LinqQueryBreakdownWithClauseTests.cs

@@ -21,8 +21,11 @@ public class LinqQueryBreakdownWithClauseTests
 
         // Assert
         Assert.That(mainQuery.WithClauses, Has.Count.EqualTo(1));
-        Assert.That(mainQuery.WithClauses[0].TableName, Is.EqualTo("active_users"));
-        Assert.That(mainQuery.WithClauses[0].Query, Is.EqualTo(cte));
+        Assert.Multiple(() =>
+        {
+            Assert.That(mainQuery.WithClauses[0].TableName, Is.EqualTo("active_users"));
+            Assert.That(mainQuery.WithClauses[0].Query, Is.EqualTo(cte));
+        });
     }
 
     [Test]
@@ -81,8 +84,11 @@ public class LinqQueryBreakdownWithClauseTests
 
         // Assert
         var keys = merged.Keys.ToList();
-        Assert.That(keys.Any(k => k.Contains("Status")), "Should include CTE parameters");
-        Assert.That(keys.Any(k => k.Contains("Limit")), "Should include main query parameters");
+        Assert.Multiple(() =>
+        {
+            Assert.That(keys.Any(k => k.Contains("Status")), "Should include CTE parameters");
+            Assert.That(keys.Any(k => k.Contains("Limit")), "Should include main query parameters");
+        });
     }
 
     [Test]
@@ -101,8 +107,11 @@ public class LinqQueryBreakdownWithClauseTests
 
         // Assert
         var valueKey = merged.Keys.FirstOrDefault(k => k.Contains("Value"));
-        Assert.That(valueKey, Is.Not.Null, "Should have a Value parameter");
-        Assert.That(merged[valueKey], Is.EqualTo("main_value"), "Main query parameter should take precedence");
+        Assert.Multiple(() =>
+        {
+            Assert.That(valueKey, Is.Not.Null, "Should have a Value parameter");
+            Assert.That(merged[valueKey], Is.EqualTo("main_value"), "Main query parameter should take precedence");
+        });
     }
 
     #endregion
@@ -152,8 +161,11 @@ public class LinqQueryBreakdownWithClauseTests
         // Assert
         Assert.That(query.WithClauses, Has.Count.EqualTo(2));
         var keys = merged.Keys.ToList();
-        Assert.That(keys.Any(k => k.Contains("MinDate")));
-        Assert.That(keys.Any(k => k.Contains("Status")));
+        Assert.Multiple(() =>
+        {
+            Assert.That(keys.Any(k => k.Contains("MinDate")));
+            Assert.That(keys.Any(k => k.Contains("Status")));
+        });
     }
 
     #endregion
@@ -213,9 +225,12 @@ public class LinqQueryBreakdownWithClauseTests
 
         // Assert
         var keys = merged.Keys.ToList();
-        Assert.That(keys.Any(k => k.Contains("AnchorLevel")), "Should include anchor parameters");
-        Assert.That(keys.Any(k => k.Contains("MaxLevel")), "Should include recursive parameters");
-        Assert.That(keys.Any(k => k.Contains("QueryLimit")), "Should include main query parameters");
+        Assert.Multiple(() =>
+        {
+            Assert.That(keys.Any(k => k.Contains("AnchorLevel")), "Should include anchor parameters");
+            Assert.That(keys.Any(k => k.Contains("MaxLevel")), "Should include recursive parameters");
+            Assert.That(keys.Any(k => k.Contains("QueryLimit")), "Should include main query parameters");
+        });
     }
 
     #endregion
@@ -279,10 +294,13 @@ public class LinqQueryBreakdownWithClauseTests
 
         // Assert
         var keys = merged.Keys.ToList();
-        Assert.That(keys.Any(k => k.Contains("InnerParam")));
-        Assert.That(keys.Any(k => k.Contains("OuterParam")));
-        Assert.That(keys.Any(k => k.Contains("MainParam")));
-        Assert.That(sql, Contains.Substring("WITH"));
+        Assert.Multiple(() =>
+        {
+            Assert.That(keys.Any(k => k.Contains("InnerParam")));
+            Assert.That(keys.Any(k => k.Contains("OuterParam")));
+            Assert.That(keys.Any(k => k.Contains("MainParam")));
+            Assert.That(sql, Contains.Substring("WITH"));
+        });
     }
 
     #endregion

tests/Strata.SqlTools.LinqToSql.Tests/QueryCollectionAnalyzerTests.cs

@@ -19,10 +19,13 @@ public class QueryCollectionAnalyzerTests
         // Act
         var stats = analyzer.Analyze();
 
-        // Assert
-        Assert.That(stats.TotalQueries, Is.EqualTo(0));
-        Assert.That(stats.UniqueQueries, Is.EqualTo(0));
-        Assert.That(stats.DuplicateQueries.Count, Is.EqualTo(0));
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(stats.TotalQueries, Is.EqualTo(0));
+            Assert.That(stats.UniqueQueries, Is.EqualTo(0));
+            Assert.That(stats.DuplicateQueries, Is.Empty);
+        });
     }
 
     [Test]
@@ -43,10 +46,13 @@ public class QueryCollectionAnalyzerTests
         // Act
         var stats = analyzer.Analyze();
 
-        // Assert
-        Assert.That(stats.TotalQueries, Is.EqualTo(1));
-        Assert.That(stats.UniqueQueries, Is.EqualTo(1));
-        Assert.That(stats.DuplicateQueries.Count, Is.EqualTo(0));
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(stats.TotalQueries, Is.EqualTo(1));
+            Assert.That(stats.UniqueQueries, Is.EqualTo(1));
+            Assert.That(stats.DuplicateQueries, Is.Empty);
+        });
     }
 
     [Test]
@@ -77,10 +83,13 @@ public class QueryCollectionAnalyzerTests
         // Act
         var stats = analyzer.Analyze();
 
-        // Assert
-        Assert.That(stats.TotalQueries, Is.EqualTo(3));
-        Assert.That(stats.UniqueQueries, Is.EqualTo(1));
-        Assert.That(stats.DuplicateQueries.Count, Is.EqualTo(2));
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(stats.TotalQueries, Is.EqualTo(3));
+            Assert.That(stats.UniqueQueries, Is.EqualTo(1));
+            Assert.That(stats.DuplicateQueries, Has.Count.EqualTo(2));
+        });
     }
 
     #endregion
@@ -207,9 +216,12 @@ public class QueryCollectionAnalyzerTests
         // Act
         var stats = analyzer.Analyze();
 
-        // Assert
-        Assert.That(stats.TableUsageFrequency["Users"], Is.EqualTo(3));
-        Assert.That(stats.TableUsageFrequency["Orders"], Is.EqualTo(1));
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(stats.TableUsageFrequency["Users"], Is.EqualTo(3));
+            Assert.That(stats.TableUsageFrequency["Orders"], Is.EqualTo(1));
+        });
     }
 
     [Test]
@@ -246,11 +258,14 @@ public class QueryCollectionAnalyzerTests
         // Act
         var stats = analyzer.Analyze();
 
-        // Assert
-        Assert.That(stats.ColumnSelectionFrequency.ContainsKey("Id"), Is.True);
-        Assert.That(stats.ColumnSelectionFrequency["Id"], Is.EqualTo(3));
-        Assert.That(stats.ColumnSelectionFrequency["Name"], Is.EqualTo(2));
-        Assert.That(stats.ColumnSelectionFrequency["Email"], Is.EqualTo(1));
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(stats.ColumnSelectionFrequency.ContainsKey("Id"), Is.True);
+            Assert.That(stats.ColumnSelectionFrequency["Id"], Is.EqualTo(3));
+            Assert.That(stats.ColumnSelectionFrequency["Name"], Is.EqualTo(2));
+            Assert.That(stats.ColumnSelectionFrequency["Email"], Is.EqualTo(1));
+        });
     }
 
     [Test]
@@ -267,9 +282,12 @@ public class QueryCollectionAnalyzerTests
         // Act
         var stats = analyzer.Analyze();
 
-        // Assert
-        Assert.That(stats.ColumnSelectionFrequency.ContainsKey("*"), Is.False);
-        Assert.That(stats.ColumnSelectionFrequency["Id"], Is.EqualTo(1));
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(stats.ColumnSelectionFrequency.ContainsKey("*"), Is.False);
+            Assert.That(stats.ColumnSelectionFrequency["Id"], Is.EqualTo(1));
+        });
     }
 
     #endregion
@@ -345,7 +363,7 @@ public class QueryCollectionAnalyzerTests
         var duplicates = analyzer.FindDuplicates();
 
         // Assert
-        Assert.That(duplicates.Count, Is.EqualTo(0));
+        Assert.That(duplicates, Is.Empty);
     }
 
     [Test]
@@ -365,7 +383,7 @@ public class QueryCollectionAnalyzerTests
         var duplicates = analyzer.FindDuplicates();
 
         // Assert
-        Assert.That(duplicates.Count, Is.EqualTo(2));
+        Assert.That(duplicates, Has.Count.EqualTo(2));
     }
 
     #endregion
@@ -388,7 +406,7 @@ public class QueryCollectionAnalyzerTests
         var similar = analyzer.FindSimilarQueries(0.5); // Lower threshold for testing
 
         // Assert
-        Assert.That(similar.Count, Is.GreaterThan(0));
+        Assert.That(similar, Is.Not.Empty);
     }
 
     [Test]
@@ -488,9 +506,12 @@ public class QueryCollectionAnalyzerTests
         // Act
         var stats = analyzer.Analyze();
 
-        // Assert
-        Assert.That(stats.TotalQueries, Is.EqualTo(100));
-        Assert.That(stats.UniqueQueries, Is.EqualTo(1));
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(stats.TotalQueries, Is.EqualTo(100));
+            Assert.That(stats.UniqueQueries, Is.EqualTo(1));
+        });
     }
 
     #endregion

tests/Strata.SqlTools.LinqToSql.Tests/QueryValidatorTests.cs

@@ -62,9 +62,12 @@ public class QueryValidatorTests
         validator.Validate(breakdown2);
         var count2 = validator.Issues.Count;
 
-        // Assert
-        Assert.That(count1, Is.GreaterThan(0));
-        Assert.That(count2, Is.GreaterThan(0));
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(count1, Is.GreaterThan(0));
+            Assert.That(count2, Is.GreaterThan(0));
+        });
     }
 
     #endregion
@@ -324,10 +327,13 @@ public class QueryValidatorTests
         var infos = validator.GetIssuesBySeverity(ValidationSeverity.Info);
         var errors = validator.GetIssuesBySeverity(ValidationSeverity.Error);
 
-        // Assert
-        Assert.That(warnings, Is.Not.Empty);
-        Assert.That(infos, Is.Not.Empty);
-        Assert.That(errors, Is.Empty);
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(warnings, Is.Not.Empty);
+            Assert.That(infos, Is.Not.Empty);
+            Assert.That(errors, Is.Empty);
+        });
     }
 
     #endregion
@@ -348,9 +354,12 @@ public class QueryValidatorTests
             "This is a custom issue");
 
         // Assert
-        Assert.That(validator.Issues.Count, Is.EqualTo(1));
-        Assert.That(validator.Issues[0].Code, Is.EqualTo("CUSTOM_001"));
-        Assert.That(validator.HasErrors, Is.True);
+        Assert.That(validator.Issues, Has.Count.EqualTo(1));
+        Assert.Multiple(() =>
+        {
+            Assert.That(validator.Issues[0].Code, Is.EqualTo("CUSTOM_001"));
+            Assert.That(validator.HasErrors, Is.True);
+        });
     }
 
     [Test]
@@ -365,9 +374,12 @@ public class QueryValidatorTests
             .AddIssue(ValidationSeverity.Warning, "WARN_001", "Warning 1")
             .AddIssue(ValidationSeverity.Info, "INFO_001", "Info 1");
 
-        // Assert
-        Assert.That(result, Is.SameAs(validator));
-        Assert.That(validator.Issues.Count, Is.EqualTo(3));
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(result, Is.SameAs(validator));
+            Assert.That(validator.Issues, Has.Count.EqualTo(3));
+        });
     }
 
     #endregion
@@ -386,7 +398,7 @@ public class QueryValidatorTests
         validator.Clear();
 
         // Assert
-        Assert.That(validator.Issues.Count, Is.EqualTo(0));
+        Assert.That(validator.Issues, Is.Empty);
     }
 
     [Test]
@@ -480,9 +492,12 @@ public class QueryValidatorTests
         // Act
         var validator = QueryValidator.ValidateQuery(breakdown);
 
-        // Assert
-        Assert.That(validator.Issues.Count, Is.GreaterThan(1));
-        Assert.That(validator.HasWarnings, Is.True);
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(validator.Issues.Count, Is.GreaterThan(1));
+            Assert.That(validator.HasWarnings, Is.True);
+        });
     }
 
     [Test]
@@ -535,7 +550,7 @@ public class QueryValidatorTests
 
         // Assert
         Assert.That(validator, Is.Not.Null);
-        Assert.That(validator.Issues.Count, Is.GreaterThan(0));
+        Assert.That(validator.Issues, Is.Not.Empty);
     }
 
     #endregion

tests/Strata.SqlTools.LinqToSql.Tests/ReverseConverterTests.cs

@@ -27,10 +27,13 @@ public class ReverseConverterTests
 
         // Assert
         Assert.That(linqBreakdown, Is.Not.Null);
-        Assert.That(linqBreakdown.SelectClause.Clause, Contains.Substring("Id"));
-        Assert.That(linqBreakdown.FromClause.Clause, Is.EqualTo("Users"));
-        Assert.That(linqBreakdown.WhereClause.Clause, Is.EqualTo("IsActive = 1"));
-        Assert.That(linqBreakdown.OrderByClause.Clause, Is.EqualTo("Name ASC"));
+        Assert.Multiple(() =>
+        {
+            Assert.That(linqBreakdown.SelectClause.Clause, Contains.Substring("Id"));
+            Assert.That(linqBreakdown.FromClause.Clause, Is.EqualTo("Users"));
+            Assert.That(linqBreakdown.WhereClause.Clause, Is.EqualTo("IsActive = 1"));
+            Assert.That(linqBreakdown.OrderByClause.Clause, Is.EqualTo("Name ASC"));
+        });
     }
 
     [Test]
@@ -46,9 +49,12 @@ public class ReverseConverterTests
         // Act
         var linqBreakdown = sqlServerBreakdown.ToLinqQueryBreakdown();
 
-        // Assert
-        Assert.That(linqBreakdown.GroupByClause.Clause, Is.EqualTo("Department"));
-        Assert.That(linqBreakdown.HavingClause.Clause, Is.EqualTo("COUNT(*) > 5"));
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(linqBreakdown.GroupByClause.Clause, Is.EqualTo("Department"));
+            Assert.That(linqBreakdown.HavingClause.Clause, Is.EqualTo("COUNT(*) > 5"));
+        });
     }
 
     [Test]
@@ -81,9 +87,12 @@ public class ReverseConverterTests
 
         // Assert
         Assert.That(linqBreakdown, Is.Not.Null);
-        Assert.That(linqBreakdown.SelectClause.Clause, Contains.Substring("user_id"));
-        Assert.That(linqBreakdown.FromClause.Clause, Is.EqualTo("users"));
-        Assert.That(linqBreakdown.WhereClause.Clause, Is.EqualTo("is_active = true"));
+        Assert.Multiple(() =>
+        {
+            Assert.That(linqBreakdown.SelectClause.Clause, Contains.Substring("user_id"));
+            Assert.That(linqBreakdown.FromClause.Clause, Is.EqualTo("users"));
+            Assert.That(linqBreakdown.WhereClause.Clause, Is.EqualTo("is_active = true"));
+        });
     }
 
     [Test]
@@ -116,9 +125,12 @@ public class ReverseConverterTests
 
         // Assert
         Assert.That(linqBreakdown, Is.Not.Null);
-        Assert.That(linqBreakdown.SelectClause.Clause, Contains.Substring("USER_ID"));
-        Assert.That(linqBreakdown.FromClause.Clause, Is.EqualTo("USERS"));
-        Assert.That(linqBreakdown.WhereClause.Clause, Is.EqualTo("IS_ACTIVE = TRUE"));
+        Assert.Multiple(() =>
+        {
+            Assert.That(linqBreakdown.SelectClause.Clause, Contains.Substring("USER_ID"));
+            Assert.That(linqBreakdown.FromClause.Clause, Is.EqualTo("USERS"));
+            Assert.That(linqBreakdown.WhereClause.Clause, Is.EqualTo("IS_ACTIVE = TRUE"));
+        });
     }
 
     [Test]
@@ -252,10 +264,13 @@ public class ReverseConverterTests
         var result2 = sqlServerBreakdown.ConvertToDialect("POSTGRESQL");
         var result3 = sqlServerBreakdown.ConvertToDialect("postgresql");
 
-        // Assert
-        Assert.That(result1, Is.TypeOf<PostgreSqlBreakdown>());
-        Assert.That(result2, Is.TypeOf<PostgreSqlBreakdown>());
-        Assert.That(result3, Is.TypeOf<PostgreSqlBreakdown>());
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(result1, Is.TypeOf<PostgreSqlBreakdown>());
+            Assert.That(result2, Is.TypeOf<PostgreSqlBreakdown>());
+            Assert.That(result3, Is.TypeOf<PostgreSqlBreakdown>());
+        });
     }
 
     #endregion
@@ -281,10 +296,13 @@ public class ReverseConverterTests
         var backToLinq2 = toPostgres!.ToLinqQueryBreakdown();
         var finalToSqlServer = backToLinq2.ConvertToSqlServerBreakdown();
 
-        // Assert - Check that clauses are preserved
-        Assert.That(backToLinq.SelectClause.Clause, Contains.Substring("Id"));
-        Assert.That(backToLinq.FromClause.Clause, Is.EqualTo("Users"));
-        Assert.That(backToLinq.WhereClause.Clause, Is.EqualTo("IsActive = true"));
+        Assert.Multiple(() =>
+        {
+            // Assert - Check that clauses are preserved
+            Assert.That(backToLinq.SelectClause.Clause, Contains.Substring("Id"));
+            Assert.That(backToLinq.FromClause.Clause, Is.EqualTo("Users"));
+            Assert.That(backToLinq.WhereClause.Clause, Is.EqualTo("IsActive = true"));
+        });
     }
 
     #endregion
@@ -333,11 +351,14 @@ public class ReverseConverterTests
         var resultSqlServer1 = sqlServerBreakdown.ConvertToDialect("sqlserver");
         var resultSqlServer2 = sqlServerBreakdown.ConvertToDialect("sql_server");
 
-        // Assert
-        Assert.That(resultPostgres1, Is.TypeOf<PostgreSqlBreakdown>());
-        Assert.That(resultPostgres2, Is.TypeOf<PostgreSqlBreakdown>());
-        Assert.That(resultSqlServer1, Is.SameAs(sqlServerBreakdown));
-        Assert.That(resultSqlServer2, Is.SameAs(sqlServerBreakdown));
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(resultPostgres1, Is.TypeOf<PostgreSqlBreakdown>());
+            Assert.That(resultPostgres2, Is.TypeOf<PostgreSqlBreakdown>());
+            Assert.That(resultSqlServer1, Is.SameAs(sqlServerBreakdown));
+            Assert.That(resultSqlServer2, Is.SameAs(sqlServerBreakdown));
+        });
     }
 
     #endregion

tests/Strata.SqlTools.PostgreSql.Tests/PostgreSql/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]
@@ -269,8 +272,11 @@ public class CTEColumnListTests
         // Assert
         Assert.That(sql, Contains.Substring("customer_transactions (trans_date, prod_id, cust_id, trans_amount, transaction_rank)"));
         var paramKeys = params_all.Keys.ToList();
-        Assert.That(paramKeys.Any(k => k.Contains("StartDate")));
-        Assert.That(paramKeys.Any(k => k.Contains("MinAmount")));
+        Assert.Multiple(() =>
+        {
+            Assert.That(paramKeys.Any(k => k.Contains("StartDate")));
+            Assert.That(paramKeys.Any(k => k.Contains("MinAmount")));
+        });
     }
 
     #endregion

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

@@ -22,7 +22,7 @@ public class QueryBreakdownCollectionTests
         var collection = new QueryBreakdownCollection();
 
         // Assert
-        Assert.That(collection.Count, Is.EqualTo(0));
+        Assert.That(collection, Is.Empty);
     }
 
     #endregion
@@ -39,7 +39,7 @@ public class QueryBreakdownCollectionTests
         _collection.Add(query);
 
         // Assert
-        Assert.That(_collection.Count, Is.GreaterThan(0));
+        Assert.That(_collection, Is.Not.Empty);
     }
 
     [Test]
@@ -56,7 +56,7 @@ public class QueryBreakdownCollectionTests
         _collection.Add(query3);
 
         // Assert
-        Assert.That(_collection.Count, Is.EqualTo(3));
+        Assert.That(_collection, Has.Count.EqualTo(3));
     }
 
     #endregion
@@ -182,9 +182,12 @@ public class QueryBreakdownCollectionTests
         // Act
         var result = _collection.ParseBatch(batchSql);
 
-        // Assert
-        Assert.That(result, Is.True);
-        Assert.That(_collection.Count, Is.GreaterThan(0));
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(result, Is.True);
+            Assert.That(_collection, Is.Not.Empty);
+        });
     }
 
     [Test]
@@ -199,9 +202,12 @@ public class QueryBreakdownCollectionTests
         // Act
         var result = _collection.ParseBatch(batchSql);
 
-        // Assert
-        Assert.That(result, Is.True);
-        Assert.That(_collection.Count, Is.GreaterThan(0));
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(result, Is.True);
+            Assert.That(_collection, Is.Not.Empty);
+        });
     }
 
     [Test]
@@ -284,8 +290,11 @@ public class QueryBreakdownCollectionTests
 
         // Assert
         Assert.That(sql, Does.Contain("SELECT"));
-        Assert.That(sql, Does.Contain(";"));
-        Assert.That(_collection.Count, Is.EqualTo(3));
+        Assert.Multiple(() =>
+        {
+            Assert.That(sql, Does.Contain(";"));
+            Assert.That(_collection, Has.Count.EqualTo(3));
+        });
     }
 
     #endregion

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

@@ -13,11 +13,14 @@ public class QueryBreakdownTests
         // Arrange & Act
         var queryBreakdown = new QueryBreakdown();
 
-        // Assert
-        Assert.That(queryBreakdown.SelectClause.Clause, Is.EqualTo(string.Empty));
-        Assert.That(queryBreakdown.FromClause.Clause, Is.EqualTo(string.Empty));
-        Assert.That(queryBreakdown.WhereClause.Clause, Is.EqualTo(string.Empty));
-        Assert.That(queryBreakdown.OrderByClause.Clause, Is.EqualTo(string.Empty));
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(queryBreakdown.SelectClause.Clause, Is.EqualTo(string.Empty));
+            Assert.That(queryBreakdown.FromClause.Clause, Is.EqualTo(string.Empty));
+            Assert.That(queryBreakdown.WhereClause.Clause, Is.EqualTo(string.Empty));
+            Assert.That(queryBreakdown.OrderByClause.Clause, Is.EqualTo(string.Empty));
+        });
     }
 
     [Test]
@@ -30,9 +33,12 @@ public class QueryBreakdownTests
         // Act
         var queryBreakdown = new QueryBreakdown(selectClause, fromClause);
 
-        // Assert
-        Assert.That(queryBreakdown.SelectClause.Clause, Is.EqualTo(selectClause));
-        Assert.That(queryBreakdown.FromClause.Clause, Is.EqualTo(fromClause));
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(queryBreakdown.SelectClause.Clause, Is.EqualTo(selectClause));
+            Assert.That(queryBreakdown.FromClause.Clause, Is.EqualTo(fromClause));
+        });
     }
 
     [Test]
@@ -46,10 +52,13 @@ public class QueryBreakdownTests
         // Act
         var queryBreakdown = new QueryBreakdown(selectClause, fromClause, whereClause);
 
-        // Assert
-        Assert.That(queryBreakdown.SelectClause.Clause, Is.EqualTo(selectClause));
-        Assert.That(queryBreakdown.FromClause.Clause, Is.EqualTo(fromClause));
-        Assert.That(queryBreakdown.WhereClause.Clause, Is.EqualTo(whereClause));
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(queryBreakdown.SelectClause.Clause, Is.EqualTo(selectClause));
+            Assert.That(queryBreakdown.FromClause.Clause, Is.EqualTo(fromClause));
+            Assert.That(queryBreakdown.WhereClause.Clause, Is.EqualTo(whereClause));
+        });
     }
 
     [Test]
@@ -64,11 +73,14 @@ public class QueryBreakdownTests
         // Act
         var queryBreakdown = new QueryBreakdown(selectClause, fromClause, whereClause, orderByClause);
 
-        // Assert
-        Assert.That(queryBreakdown.SelectClause.Clause, Is.EqualTo(selectClause));
-        Assert.That(queryBreakdown.FromClause.Clause, Is.EqualTo(fromClause));
-        Assert.That(queryBreakdown.WhereClause.Clause, Is.EqualTo(whereClause));
-        Assert.That(queryBreakdown.OrderByClause.Clause, Is.EqualTo(orderByClause));
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(queryBreakdown.SelectClause.Clause, Is.EqualTo(selectClause));
+            Assert.That(queryBreakdown.FromClause.Clause, Is.EqualTo(fromClause));
+            Assert.That(queryBreakdown.WhereClause.Clause, Is.EqualTo(whereClause));
+            Assert.That(queryBreakdown.OrderByClause.Clause, Is.EqualTo(orderByClause));
+        });
     }
 
     #endregion
@@ -130,9 +142,12 @@ public class QueryBreakdownTests
         // Act
         queryBreakdown.AddParameter("userId", 123);
 
-        // Assert
-        Assert.That(queryBreakdown.Parameters.ContainsKey("userId"), Is.True);
-        Assert.That(queryBreakdown.Parameters["userId"], Is.EqualTo(123));
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(queryBreakdown.Parameters.ContainsKey("userId"), Is.True);
+            Assert.That(queryBreakdown.Parameters["userId"], Is.EqualTo(123));
+        });
     }
 
     [Test]
@@ -148,9 +163,12 @@ public class QueryBreakdownTests
 
         // Assert
         Assert.That(queryBreakdown.Parameters.Count, Is.GreaterThanOrEqualTo(3));
-        Assert.That(queryBreakdown.Parameters.ContainsKey("param1"), Is.True);
-        Assert.That(queryBreakdown.Parameters.ContainsKey("param2"), Is.True);
-        Assert.That(queryBreakdown.Parameters.ContainsKey("param3"), Is.True);
+        Assert.Multiple(() =>
+        {
+            Assert.That(queryBreakdown.Parameters.ContainsKey("param1"), Is.True);
+            Assert.That(queryBreakdown.Parameters.ContainsKey("param2"), Is.True);
+            Assert.That(queryBreakdown.Parameters.ContainsKey("param3"), Is.True);
+        });
     }
 
     [Test]
@@ -164,7 +182,7 @@ public class QueryBreakdownTests
 
         // Assert
         // The @ prefix is stripped
-        Assert.That(queryBreakdown.Parameters.Count, Is.GreaterThan(0));
+        Assert.That(queryBreakdown.Parameters, Is.Not.Empty);
     }
 
     #endregion
@@ -182,8 +200,11 @@ public class QueryBreakdownTests
 
         // Assert
         Assert.That(queryBreakdown, Is.Not.Null);
-        Assert.That(queryBreakdown.SelectClause.Clause, Is.Not.Empty);
-        Assert.That(queryBreakdown.FromClause.Clause, Is.Not.Empty);
+        Assert.Multiple(() =>
+        {
+            Assert.That(queryBreakdown.SelectClause.Clause, Is.Not.Empty);
+            Assert.That(queryBreakdown.FromClause.Clause, Is.Not.Empty);
+        });
     }
 
     [Test]
@@ -195,9 +216,12 @@ public class QueryBreakdownTests
         // Act
         var queryBreakdown = QueryBreakdown.Parse(sql);
 
-        // Assert
-        Assert.That(queryBreakdown.WhereClause.Clause, Is.Not.Empty);
-        Assert.That(queryBreakdown.FromClause.Clause, Does.Contain("users"));
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(queryBreakdown.WhereClause.Clause, Is.Not.Empty);
+            Assert.That(queryBreakdown.FromClause.Clause, Does.Contain("users"));
+        });
     }
 
     [Test]
@@ -244,13 +268,16 @@ public class QueryBreakdownTests
         // Act
         var queryBreakdown = QueryBreakdown.Parse(sql);
 
-        // Assert
-        Assert.That(queryBreakdown.SelectClause.Clause, Is.Not.Empty);
-        Assert.That(queryBreakdown.FromClause.Clause, Is.Not.Empty);
-        Assert.That(queryBreakdown.WhereClause.Clause, Is.Not.Empty);
-        Assert.That(queryBreakdown.GroupByClause.Clause, Is.Not.Empty);
-        Assert.That(queryBreakdown.HavingClause.Clause, Is.Not.Empty);
-        Assert.That(queryBreakdown.OrderByClause.Clause, Is.Not.Empty);
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(queryBreakdown.SelectClause.Clause, Is.Not.Empty);
+            Assert.That(queryBreakdown.FromClause.Clause, Is.Not.Empty);
+            Assert.That(queryBreakdown.WhereClause.Clause, Is.Not.Empty);
+            Assert.That(queryBreakdown.GroupByClause.Clause, Is.Not.Empty);
+            Assert.That(queryBreakdown.HavingClause.Clause, Is.Not.Empty);
+            Assert.That(queryBreakdown.OrderByClause.Clause, Is.Not.Empty);
+        });
     }
 
     [Test]
@@ -262,10 +289,13 @@ public class QueryBreakdownTests
         // Act
         var success = QueryBreakdown.TryParse(sql, out var queryBreakdown, out var errorMessage);
 
-        // Assert
-        Assert.That(success, Is.True);
-        Assert.That(queryBreakdown, Is.Not.Null);
-        Assert.That(errorMessage, Is.Empty);
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(success, Is.True);
+            Assert.That(queryBreakdown, Is.Not.Null);
+            Assert.That(errorMessage, Is.Empty);
+        });
     }
 
     [Test]
@@ -277,9 +307,12 @@ public class QueryBreakdownTests
         // Act
         var success = QueryBreakdown.TryParse(sql, out var queryBreakdown, out var errorMessage);
 
-        // Assert
-        Assert.That(success, Is.False);
-        Assert.That(errorMessage, Is.Not.Empty);
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(success, Is.False);
+            Assert.That(errorMessage, Is.Not.Empty);
+        });
     }
 
     #endregion
@@ -308,9 +341,12 @@ public class QueryBreakdownTests
         // Act
         var queryBreakdown = QueryBreakdown.Parse(sql);
 
-        // Assert
-        Assert.That(queryBreakdown.SelectClause.Clause, Is.Not.Empty);
-        Assert.That(queryBreakdown.FromClause.Clause, Is.Not.Empty);
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(queryBreakdown.SelectClause.Clause, Is.Not.Empty);
+            Assert.That(queryBreakdown.FromClause.Clause, Is.Not.Empty);
+        });
     }
 
     [Test]
@@ -353,9 +389,12 @@ public class QueryBreakdownTests
         queryBreakdown.SelectClause.Clause = "id, name";
         queryBreakdown.FromClause.Clause = "users";
 
-        // Assert
-        Assert.That(queryBreakdown.SelectClause.Clause, Is.EqualTo("id, name"));
-        Assert.That(queryBreakdown.FromClause.Clause, Is.EqualTo("users"));
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(queryBreakdown.SelectClause.Clause, Is.EqualTo("id, name"));
+            Assert.That(queryBreakdown.FromClause.Clause, Is.EqualTo("users"));
+        });
     }
 
     [Test]
@@ -387,8 +426,11 @@ public class QueryBreakdownTests
 
         // Assert
         Assert.That(mainQuery.WithClauses, Has.Count.EqualTo(1));
-        Assert.That(mainQuery.WithClauses[0].TableName, Is.EqualTo("active_users_cte"));
-        Assert.That(mainQuery.WithClauses[0].Query, Is.EqualTo(cte));
+        Assert.Multiple(() =>
+        {
+            Assert.That(mainQuery.WithClauses[0].TableName, Is.EqualTo("active_users_cte"));
+            Assert.That(mainQuery.WithClauses[0].Query, Is.EqualTo(cte));
+        });
     }
 
     [Test]
@@ -448,8 +490,11 @@ public class QueryBreakdownTests
         // PostgreSQL stores parameters with positional and name-based formats
         Assert.That(merged.Count, Is.GreaterThanOrEqualTo(2));
         var keys = merged.Keys.ToList();
-        Assert.That(keys.Any(k => k.Contains("UserId")));
-        Assert.That(keys.Any(k => k.Contains("ActiveStatus")));
+        Assert.Multiple(() =>
+        {
+            Assert.That(keys.Any(k => k.Contains("UserId")));
+            Assert.That(keys.Any(k => k.Contains("ActiveStatus")));
+        });
     }
 
     [Test]
@@ -468,8 +513,11 @@ public class QueryBreakdownTests
 
         // Assert
         var keys = merged.Keys.ToList();
-        Assert.That(keys.Any(k => k.Contains("MinDate")));
-        Assert.That(keys.Any(k => k.Contains("ResultLimit")));
+        Assert.Multiple(() =>
+        {
+            Assert.That(keys.Any(k => k.Contains("MinDate")));
+            Assert.That(keys.Any(k => k.Contains("ResultLimit")));
+        });
     }
 
     [Test]
@@ -492,9 +540,12 @@ public class QueryBreakdownTests
 
         // Assert
         var keys = merged.Keys.ToList();
-        Assert.That(keys.Any(k => k.Contains("Status1")));
-        Assert.That(keys.Any(k => k.Contains("MinDate")));
-        Assert.That(keys.Any(k => k.Contains("ResultLimit")));
+        Assert.Multiple(() =>
+        {
+            Assert.That(keys.Any(k => k.Contains("Status1")));
+            Assert.That(keys.Any(k => k.Contains("MinDate")));
+            Assert.That(keys.Any(k => k.Contains("ResultLimit")));
+        });
     }
 
     [Test]
@@ -514,8 +565,11 @@ public class QueryBreakdownTests
         // Assert
         // Find the UserId parameter value
         var userIdKey = merged.Keys.FirstOrDefault(k => k.Contains("UserId") && !k.Contains('$'));
-        Assert.That(userIdKey, Is.Not.Null);
-        Assert.That(merged[userIdKey], Is.EqualTo(123)); // Main query value, not CTE value
+        Assert.Multiple(() =>
+        {
+            Assert.That(userIdKey, Is.Not.Null);
+            Assert.That(merged[userIdKey], Is.EqualTo(123)); // Main query value, not CTE value
+        });
     }
 
     [Test]
@@ -538,9 +592,12 @@ public class QueryBreakdownTests
 
         // Assert
         var keys = merged.Keys.ToList();
-        Assert.That(keys.Any(k => k.Contains("Status")), "Should include Status from nested CTE");
-        Assert.That(keys.Any(k => k.Contains("Level")), "Should include Level from middle CTE");
-        Assert.That(keys.Any(k => k.Contains("Limit")), "Should include Limit from main query");
+        Assert.Multiple(() =>
+        {
+            Assert.That(keys.Any(k => k.Contains("Status")), "Should include Status from nested CTE");
+            Assert.That(keys.Any(k => k.Contains("Level")), "Should include Level from middle CTE");
+            Assert.That(keys.Any(k => k.Contains("Limit")), "Should include Limit from main query");
+        });
     }
 
     [Test]
@@ -563,14 +620,17 @@ public class QueryBreakdownTests
         var boolKey = merged.Keys.FirstOrDefault(k => k.Contains("IsActive") && !k.Contains('$'));
         var doubleKey = merged.Keys.FirstOrDefault(k => k.Contains("Threshold") && !k.Contains('$'));
 
-        Assert.That(dateKey, Is.Not.Null);
-        Assert.That(merged[dateKey], Is.TypeOf<DateTime>());
+        Assert.Multiple(() =>
+        {
+            Assert.That(dateKey, Is.Not.Null);
+            Assert.That(merged[dateKey], Is.TypeOf<DateTime>());
 
-        Assert.That(boolKey, Is.Not.Null);
-        Assert.That(merged[boolKey], Is.TypeOf<bool>());
+            Assert.That(boolKey, Is.Not.Null);
+            Assert.That(merged[boolKey], Is.TypeOf<bool>());
 
-        Assert.That(doubleKey, Is.Not.Null);
-        Assert.That(merged[doubleKey], Is.TypeOf<double>());
+            Assert.That(doubleKey, Is.Not.Null);
+            Assert.That(merged[doubleKey], Is.TypeOf<double>());
+        });
     }
 
     #endregion

tests/Strata.SqlTools.PostgreSql.Tests/PostgreSql/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,9 +181,12 @@ public class RecursiveCTETests
 
         // Assert
         // PostgreSQL stores parameters with positional syntax
-        var statusKey = merged.Keys.FirstOrDefault(k => k.Contains("Status") && !k.StartsWith("$"));
-        Assert.That(statusKey, Is.Not.Null);
-        Assert.That(merged[statusKey], Is.EqualTo("active"), "Main query parameter should take precedence");
+        var statusKey = merged.Keys.FirstOrDefault(k => k.Contains("Status") && !k.StartsWith('$'));
+        Assert.Multiple(() =>
+        {
+            Assert.That(statusKey, Is.Not.Null);
+            Assert.That(merged[statusKey], Is.EqualTo("active"), "Main query parameter should take precedence");
+        });
     }
 
     #endregion
@@ -247,8 +256,8 @@ public class RecursiveCTETests
 
         // Assert
         Assert.That(sql, Contains.Substring("WITH RECURSIVE"));
-        Assert.That(sql.Contains("base AS"), "Non-recursive CTE should be included");
-        Assert.That(sql.Contains("tree_hierarchy AS"), "Recursive CTE should be included");
+        Assert.That(sql, Does.Contain("base AS"), "Non-recursive CTE should be included");
+        Assert.That(sql, Does.Contain("tree_hierarchy AS"), "Recursive CTE should be included");
     }
 
     [Test]

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

@@ -23,9 +23,12 @@ 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"));
+        });
     }
 
     [Test]
@@ -44,10 +47,13 @@ public class StatementReaderTests
 
         // Assert
         Assert.That(tokens, Has.Count.EqualTo(5)); // "COLUMN_1" + "COLUMN_2" * 2
-        Assert.That(tokens[0].Type, Is.EqualTo(TokenType.ColumnIdentifier));
-        Assert.That(tokens[0].Value, Is.EqualTo("COLUMN_1"));
-        Assert.That(tokens[1].Type, Is.EqualTo(TokenType.Plus));
-        Assert.That(tokens[2].Type, Is.EqualTo(TokenType.ColumnIdentifier));
+        Assert.Multiple(() =>
+        {
+            Assert.That(tokens[0].Type, Is.EqualTo(TokenType.ColumnIdentifier));
+            Assert.That(tokens[0].Value, Is.EqualTo("COLUMN_1"));
+            Assert.That(tokens[1].Type, Is.EqualTo(TokenType.Plus));
+            Assert.That(tokens[2].Type, Is.EqualTo(TokenType.ColumnIdentifier));
+        });
     }
 
     [Test]
@@ -64,11 +70,14 @@ public class StatementReaderTests
             tokens.Add((sqlReader.TokenType, sqlReader.TokenValue));
         }
 
-        // Assert
-        Assert.That(tokens[0].Type, Is.EqualTo(TokenType.ColumnIdentifier));
-        Assert.That(tokens[0].Value, Is.EqualTo("MyColumn"));
-        Assert.That(tokens[2].Type, Is.EqualTo(TokenType.ColumnIdentifier));
-        Assert.That(tokens[2].Value, Is.EqualTo("AnotherColumn"));
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(tokens[0].Type, Is.EqualTo(TokenType.ColumnIdentifier));
+            Assert.That(tokens[0].Value, Is.EqualTo("MyColumn"));
+            Assert.That(tokens[2].Type, Is.EqualTo(TokenType.ColumnIdentifier));
+            Assert.That(tokens[2].Value, Is.EqualTo("AnotherColumn"));
+        });
     }
 
     [Test]
@@ -86,11 +95,14 @@ public class StatementReaderTests
         }
 
         // Assert
-        Assert.That(tokens.Count, Is.GreaterThan(0));
+        Assert.That(tokens, Is.Not.Empty);
         var paramTokens = tokens.Where(t => t.Type == TokenType.Parameter).ToList();
-        Assert.That(paramTokens.Count, Is.EqualTo(2));
-        Assert.That(paramTokens[0].Value, Is.EqualTo("$1"));
-        Assert.That(paramTokens[1].Value, Is.EqualTo("$2"));
+        Assert.That(paramTokens, Has.Count.EqualTo(2));
+        Assert.Multiple(() =>
+        {
+            Assert.That(paramTokens[0].Value, Is.EqualTo("$1"));
+            Assert.That(paramTokens[1].Value, Is.EqualTo("$2"));
+        });
     }
 
     [Test]
@@ -161,7 +173,7 @@ public class StatementReaderTests
         }
 
         // Assert
-        Assert.That(tokens.Count, Is.GreaterThan(0));
+        Assert.That(tokens, Is.Not.Empty);
     }
 
     [Test]
@@ -179,7 +191,7 @@ public class StatementReaderTests
         }
 
         // Assert
-        Assert.That(tokens.Count, Is.GreaterThan(0));
+        Assert.That(tokens, Is.Not.Empty);
     }
 
     [Test]
@@ -217,6 +229,6 @@ public class StatementReaderTests
 
         // Assert
         var numberTokens = tokens.Where(t => t.Type == TokenType.Number).ToList();
-        Assert.That(numberTokens.Count, Is.GreaterThan(0));
+        Assert.That(numberTokens, Is.Not.Empty);
     }
 }

tests/Strata.SqlTools.Rules.Tests/MarkdownParserTests.cs

@@ -12,8 +12,11 @@ public class MarkdownParserTests
     {
         var result = Markdown.Parse("42");
 
-        Assert.That(result, Is.InstanceOf<NumberLiteral>());
-        Assert.That(((NumberLiteral)result).Value, Is.EqualTo(42m));
+        Assert.Multiple(() =>
+        {
+            Assert.That(result, Is.InstanceOf<NumberLiteral>());
+            Assert.That(((NumberLiteral)result).Value, Is.EqualTo(42m));
+        });
     }
 
     [Test]
@@ -21,8 +24,11 @@ public class MarkdownParserTests
     {
         var result = Markdown.Parse("3.14");
 
-        Assert.That(result, Is.InstanceOf<NumberLiteral>());
-        Assert.That(((NumberLiteral)result).Value, Is.EqualTo(3.14m));
+        Assert.Multiple(() =>
+        {
+            Assert.That(result, Is.InstanceOf<NumberLiteral>());
+            Assert.That(((NumberLiteral)result).Value, Is.EqualTo(3.14m));
+        });
     }
 
     [Test]
@@ -30,8 +36,11 @@ public class MarkdownParserTests
     {
         var result = Markdown.Parse("\"hello world\"");
 
-        Assert.That(result, Is.InstanceOf<StringLiteral>());
-        Assert.That(((StringLiteral)result).Value, Is.EqualTo("hello world"));
+        Assert.Multiple(() =>
+        {
+            Assert.That(result, Is.InstanceOf<StringLiteral>());
+            Assert.That(((StringLiteral)result).Value, Is.EqualTo("hello world"));
+        });
     }
 
     [Test]
@@ -39,8 +48,11 @@ public class MarkdownParserTests
     {
         var result = Markdown.Parse("'test string'");
 
-        Assert.That(result, Is.InstanceOf<StringLiteral>());
-        Assert.That(((StringLiteral)result).Value, Is.EqualTo("test string"));
+        Assert.Multiple(() =>
+        {
+            Assert.That(result, Is.InstanceOf<StringLiteral>());
+            Assert.That(((StringLiteral)result).Value, Is.EqualTo("test string"));
+        });
     }
 
     [Test]
@@ -48,8 +60,11 @@ public class MarkdownParserTests
     {
         var result = Markdown.Parse("true");
 
-        Assert.That(result, Is.InstanceOf<Literal>());
-        Assert.That(((Literal)result).Value, Is.EqualTo(true));
+        Assert.Multiple(() =>
+        {
+            Assert.That(result, Is.InstanceOf<Literal>());
+            Assert.That(((Literal)result).Value, Is.EqualTo(true));
+        });
     }
 
     [Test]
@@ -57,8 +72,11 @@ public class MarkdownParserTests
     {
         var result = Markdown.Parse("false");
 
-        Assert.That(result, Is.InstanceOf<Literal>());
-        Assert.That(((Literal)result).Value, Is.EqualTo(false));
+        Assert.Multiple(() =>
+        {
+            Assert.That(result, Is.InstanceOf<Literal>());
+            Assert.That(((Literal)result).Value, Is.EqualTo(false));
+        });
     }
 
     #endregion
@@ -72,8 +90,11 @@ public class MarkdownParserTests
 
         Assert.That(result, Is.InstanceOf<Property>());
         var prop = (Property)result;
-        Assert.That(prop.PropertyName, Is.EqualTo("PropertyName"));
-        Assert.That(prop.Expression, Is.Null);
+        Assert.Multiple(() =>
+        {
+            Assert.That(prop.PropertyName, Is.EqualTo("PropertyName"));
+            Assert.That(prop.Expression, Is.Null);
+        });
     }
 
     [Test]
@@ -83,8 +104,11 @@ public class MarkdownParserTests
 
         Assert.That(result, Is.InstanceOf<Property>());
         var prop = (Property)result;
-        Assert.That(prop.PropertyName, Is.EqualTo("Age"));
-        Assert.That(prop.Expression, Is.InstanceOf<Parameter>());
+        Assert.Multiple(() =>
+        {
+            Assert.That(prop.PropertyName, Is.EqualTo("Age"));
+            Assert.That(prop.Expression, Is.InstanceOf<Parameter>());
+        });
     }
 
     [Test]
@@ -94,8 +118,11 @@ public class MarkdownParserTests
 
         Assert.That(result, Is.InstanceOf<Property>());
         var prop = (Property)result;
-        Assert.That(prop.PropertyName, Is.EqualTo("Department"));
-        Assert.That(prop.Expression, Is.InstanceOf<Parameter>());
+        Assert.Multiple(() =>
+        {
+            Assert.That(prop.PropertyName, Is.EqualTo("Department"));
+            Assert.That(prop.Expression, Is.InstanceOf<Parameter>());
+        });
     }
 
     [Test]
@@ -103,8 +130,11 @@ public class MarkdownParserTests
     {
         var result = Markdown.Parse("\\text{some text}");
 
-        Assert.That(result, Is.InstanceOf<StringLiteral>());
-        Assert.That(((StringLiteral)result).Value, Is.EqualTo("some text"));
+        Assert.Multiple(() =>
+        {
+            Assert.That(result, Is.InstanceOf<StringLiteral>());
+            Assert.That(((StringLiteral)result).Value, Is.EqualTo("some text"));
+        });
     }
 
     #endregion
@@ -118,8 +148,11 @@ public class MarkdownParserTests
 
         Assert.That(result, Is.InstanceOf<Equal>());
         var equal = (Equal)result;
-        Assert.That(equal.Left, Is.InstanceOf<Property>());
-        Assert.That(equal.Right, Is.InstanceOf<NumberLiteral>());
+        Assert.Multiple(() =>
+        {
+            Assert.That(equal.Left, Is.InstanceOf<Property>());
+            Assert.That(equal.Right, Is.InstanceOf<NumberLiteral>());
+        });
     }
 
     [Test]
@@ -129,8 +162,11 @@ public class MarkdownParserTests
 
         Assert.That(result, Is.InstanceOf<NotEqual>());
         var notEqual = (NotEqual)result;
-        Assert.That(notEqual.Left, Is.InstanceOf<Property>());
-        Assert.That(notEqual.Right, Is.InstanceOf<StringLiteral>());
+        Assert.Multiple(() =>
+        {
+            Assert.That(notEqual.Left, Is.InstanceOf<Property>());
+            Assert.That(notEqual.Right, Is.InstanceOf<StringLiteral>());
+        });
     }
 
     [Test]
@@ -140,8 +176,11 @@ public class MarkdownParserTests
 
         Assert.That(result, Is.InstanceOf<NotEqual>());
         var notEqual = (NotEqual)result;
-        Assert.That(notEqual.Left, Is.InstanceOf<Property>());
-        Assert.That(notEqual.Right, Is.InstanceOf<NumberLiteral>());
+        Assert.Multiple(() =>
+        {
+            Assert.That(notEqual.Left, Is.InstanceOf<Property>());
+            Assert.That(notEqual.Right, Is.InstanceOf<NumberLiteral>());
+        });
     }
 
     [Test]
@@ -151,8 +190,11 @@ public class MarkdownParserTests
 
         Assert.That(result, Is.InstanceOf<GreaterThan>());
         var greaterThan = (GreaterThan)result;
-        Assert.That(greaterThan.Left, Is.InstanceOf<Property>());
-        Assert.That(greaterThan.Right, Is.InstanceOf<NumberLiteral>());
+        Assert.Multiple(() =>
+        {
+            Assert.That(greaterThan.Left, Is.InstanceOf<Property>());
+            Assert.That(greaterThan.Right, Is.InstanceOf<NumberLiteral>());
+        });
     }
 
     [Test]
@@ -162,8 +204,11 @@ public class MarkdownParserTests
 
         Assert.That(result, Is.InstanceOf<GreaterThan>());
         var greaterThan = (GreaterThan)result;
-        Assert.That(greaterThan.Left, Is.InstanceOf<Property>());
-        Assert.That(greaterThan.Right, Is.InstanceOf<NumberLiteral>());
+        Assert.Multiple(() =>
+        {
+            Assert.That(greaterThan.Left, Is.InstanceOf<Property>());
+            Assert.That(greaterThan.Right, Is.InstanceOf<NumberLiteral>());
+        });
     }
 
     #endregion
@@ -177,8 +222,11 @@ public class MarkdownParserTests
 
         Assert.That(result, Is.InstanceOf<And>());
         var and = (And)result;
-        Assert.That(and.Left, Is.InstanceOf<GreaterThan>());
-        Assert.That(and.Right, Is.InstanceOf<Equal>());
+        Assert.Multiple(() =>
+        {
+            Assert.That(and.Left, Is.InstanceOf<GreaterThan>());
+            Assert.That(and.Right, Is.InstanceOf<Equal>());
+        });
     }
 
     [Test]
@@ -188,8 +236,11 @@ public class MarkdownParserTests
 
         Assert.That(result, Is.InstanceOf<Or>());
         var or = (Or)result;
-        Assert.That(or.Left, Is.InstanceOf<Equal>());
-        Assert.That(or.Right, Is.InstanceOf<Equal>());
+        Assert.Multiple(() =>
+        {
+            Assert.That(or.Left, Is.InstanceOf<Equal>());
+            Assert.That(or.Right, Is.InstanceOf<Equal>());
+        });
     }
 
     [Test]
@@ -199,8 +250,11 @@ public class MarkdownParserTests
 
         Assert.That(result, Is.InstanceOf<And>());
         var and = (And)result;
-        Assert.That(and.Left, Is.InstanceOf<Equal>());
-        Assert.That(and.Right, Is.InstanceOf<GreaterThan>());
+        Assert.Multiple(() =>
+        {
+            Assert.That(and.Left, Is.InstanceOf<Equal>());
+            Assert.That(and.Right, Is.InstanceOf<GreaterThan>());
+        });
     }
 
     [Test]
@@ -210,8 +264,11 @@ public class MarkdownParserTests
 
         Assert.That(result, Is.InstanceOf<Or>());
         var or = (Or)result;
-        Assert.That(or.Left, Is.InstanceOf<Equal>());
-        Assert.That(or.Right, Is.InstanceOf<Equal>());
+        Assert.Multiple(() =>
+        {
+            Assert.That(or.Left, Is.InstanceOf<Equal>());
+            Assert.That(or.Right, Is.InstanceOf<Equal>());
+        });
     }
 
     [Test]
@@ -241,8 +298,11 @@ public class MarkdownParserTests
 
         Assert.That(result, Is.InstanceOf<Or>());
         var or = (Or)result;
-        Assert.That(or.Left, Is.InstanceOf<And>());
-        Assert.That(or.Right, Is.InstanceOf<Equal>());
+        Assert.Multiple(() =>
+        {
+            Assert.That(or.Left, Is.InstanceOf<And>());
+            Assert.That(or.Right, Is.InstanceOf<Equal>());
+        });
     }
 
     [Test]
@@ -252,8 +312,11 @@ public class MarkdownParserTests
 
         Assert.That(result, Is.InstanceOf<And>());
         var and = (And)result;
-        Assert.That(and.Left, Is.InstanceOf<Equal>());
-        Assert.That(and.Right, Is.InstanceOf<Equal>());
+        Assert.Multiple(() =>
+        {
+            Assert.That(and.Left, Is.InstanceOf<Equal>());
+            Assert.That(and.Right, Is.InstanceOf<Equal>());
+        });
     }
 
     [Test]
@@ -263,12 +326,18 @@ public class MarkdownParserTests
 
         Assert.That(result, Is.InstanceOf<And>());
         var and = (And)result;
-        Assert.That(and.Left, Is.InstanceOf<GreaterThan>());
-        Assert.That(and.Right, Is.InstanceOf<Or>());
+        Assert.Multiple(() =>
+        {
+            Assert.That(and.Left, Is.InstanceOf<GreaterThan>());
+            Assert.That(and.Right, Is.InstanceOf<Or>());
+        });
 
         var or = (Or)and.Right;
-        Assert.That(or.Left, Is.InstanceOf<Equal>());
-        Assert.That(or.Right, Is.InstanceOf<Equal>());
+        Assert.Multiple(() =>
+        {
+            Assert.That(or.Left, Is.InstanceOf<Equal>());
+            Assert.That(or.Right, Is.InstanceOf<Equal>());
+        });
     }
 
     #endregion
@@ -332,8 +401,11 @@ public class MarkdownParserTests
     {
         var success = Markdown.TryParse("x.Age = 25", out var expression);
 
-        Assert.That(success, Is.True);
-        Assert.That(expression, Is.Not.Null);
+        Assert.Multiple(() =>
+        {
+            Assert.That(success, Is.True);
+            Assert.That(expression, Is.Not.Null);
+        });
         Assert.That(expression, Is.InstanceOf<Equal>());
     }
 
@@ -342,8 +414,11 @@ public class MarkdownParserTests
     {
         var success = Markdown.TryParse("@#$%", out var expression);
 
-        Assert.That(success, Is.False);
-        Assert.That(expression, Is.Null);
+        Assert.Multiple(() =>
+        {
+            Assert.That(success, Is.False);
+            Assert.That(expression, Is.Null);
+        });
     }
 
     #endregion
@@ -364,10 +439,13 @@ public class MarkdownParserTests
         var greaterThan = (GreaterThan)and.Left;
         Assert.That(greaterThan.Left, Is.InstanceOf<Property>());
         var userAge = (Property)greaterThan.Left;
-        Assert.That(userAge.PropertyName, Is.EqualTo("Age"));
+        Assert.Multiple(() =>
+        {
+            Assert.That(userAge.PropertyName, Is.EqualTo("Age"));
 
-        // Right side: user.Status = "active"
-        Assert.That(and.Right, Is.InstanceOf<Equal>());
+            // Right side: user.Status = "active"
+            Assert.That(and.Right, Is.InstanceOf<Equal>());
+        });
         var equal = (Equal)and.Right;
         Assert.That(equal.Left, Is.InstanceOf<Property>());
         var userStatus = (Property)equal.Left;
@@ -387,18 +465,27 @@ public class MarkdownParserTests
 
         Assert.That(result, Is.InstanceOf<Or>());
         var or = (Or)result;
-        Assert.That(or.Left, Is.InstanceOf<And>());
-        Assert.That(or.Right, Is.InstanceOf<And>());
+        Assert.Multiple(() =>
+        {
+            Assert.That(or.Left, Is.InstanceOf<And>());
+            Assert.That(or.Right, Is.InstanceOf<And>());
+        });
 
         // Left AND: TotalCharges > 1000 AND Status = 'pending'
         var leftAnd = (And)or.Left;
-        Assert.That(leftAnd.Left, Is.InstanceOf<GreaterThan>());
-        Assert.That(leftAnd.Right, Is.InstanceOf<Equal>());
+        Assert.Multiple(() =>
+        {
+            Assert.That(leftAnd.Left, Is.InstanceOf<GreaterThan>());
+            Assert.That(leftAnd.Right, Is.InstanceOf<Equal>());
+        });
 
         // Right AND: Priority = 'urgent' AND ApprovedBy != ''
         var rightAnd = (And)or.Right;
-        Assert.That(rightAnd.Left, Is.InstanceOf<Equal>());
-        Assert.That(rightAnd.Right, Is.InstanceOf<NotEqual>());
+        Assert.Multiple(() =>
+        {
+            Assert.That(rightAnd.Left, Is.InstanceOf<Equal>());
+            Assert.That(rightAnd.Right, Is.InstanceOf<NotEqual>());
+        });
     }
 
     #endregion

tests/Strata.SqlTools.Rules.Tests/RuleEngineTests.cs

@@ -609,9 +609,12 @@ public class RuleEngineTests
         var result1 = await engine.RunRules(ruleSet1, input);
         var result2 = await engine.RunRules(ruleSet2, input);
 
-        // Assert
-        Assert.That(result1, Is.False, "First rule set should fail");
-        Assert.That(result2, Is.True, "Second rule set should pass");
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(result1, Is.False, "First rule set should fail");
+            Assert.That(result2, Is.True, "Second rule set should pass");
+        });
     }
 
     #endregion

tests/Strata.SqlTools.Rules.Tests/UnitTest1.cs

@@ -11,20 +11,22 @@ public class Tests
     private static readonly Guid _pesDataTableGUID = new Guid("41639c8f-fecf-4449-b6e6-53f796c0c3e4");
     private const string EncounterIDKey = "DimPatientEnEncounterID";
 
+    private static readonly JsonSerializerOptions _jsonOptions = new()
+    {
+        Converters =
+        {
+            new HierarchicalDataConverter(),
+            new FlatDataConverter(),
+            new ObjectToInferredTypesConverter()
+        }
+    };
+
     public Dictionary<long, IHierarchicalData>? _encounterLookup;
 
     [OneTimeSetUp]
     public void OneTimeSetup()
     {
-        var allData = JsonSerializer.Deserialize<List<IHierarchicalData>>(File.ReadAllText(@"Data.json"), new JsonSerializerOptions
-        {
-            Converters =
-            {
-                new HierarchicalDataConverter(),
-                new FlatDataConverter(),
-                new ObjectToInferredTypesConverter()
-            }
-        });
+        var allData = JsonSerializer.Deserialize<List<IHierarchicalData>>(File.ReadAllText(@"Data.json"), _jsonOptions);
 
         if (allData == null || allData.Count == 0)
         {

tests/Strata.SqlTools.Snowflake.Tests/Snowflake/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]
@@ -274,8 +277,11 @@ public class CTEColumnListTests
         // Assert
         Assert.That(sql, Contains.Substring("high_value_sales (sale_date_key, product_key, customer_key, units_sold, total_revenue)"));
         var paramKeys = params_all.Keys.ToList();
-        Assert.That(paramKeys.Any(k => k.Contains("StartDateSk")));
-        Assert.That(paramKeys.Any(k => k.Contains("MinRevenue")));
+        Assert.Multiple(() =>
+        {
+            Assert.That(paramKeys.Any(k => k.Contains("StartDateSk")));
+            Assert.That(paramKeys.Any(k => k.Contains("MinRevenue")));
+        });
     }
 
     #endregion

tests/Strata.SqlTools.Snowflake.Tests/Snowflake/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();
@@ -325,8 +352,11 @@ public class CommentTests
 
         // Assert
         Assert.That(query.WhereClause.Comment, Does.Contain("-- Filter by status parameter"));
-        Assert.That(query.WhereClause.Comment, Does.Contain("-- Additional condition"));
-        Assert.That(query.Parameters, Contains.Key(":status"));
+        Assert.Multiple(() =>
+        {
+            Assert.That(query.WhereClause.Comment, Does.Contain("-- Additional condition"));
+            Assert.That(query.Parameters, Contains.Key(":status"));
+        });
         Assert.That(query.Parameters, Contains.Key(":start_date"));
     }
 

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

@@ -17,7 +17,7 @@ public class QueryBreakdownCollectionTests
     public void Constructor_Empty_CreatesEmptyCollection()
     {
         // Act & Assert
-        Assert.That(_collection.Count, Is.EqualTo(0));
+        Assert.That(_collection, Is.Empty);
         Assert.That(_collection.QueryBreakdowns, Is.Empty);
     }
 
@@ -35,8 +35,8 @@ public class QueryBreakdownCollectionTests
         var collection = new QueryBreakdownCollection(queries);
 
         // Assert
-        Assert.That(collection.Count, Is.EqualTo(2));
-        Assert.That(collection.QueryBreakdowns.Count, Is.EqualTo(2));
+        Assert.That(collection, Has.Count.EqualTo(2));
+        Assert.That(collection.QueryBreakdowns, Has.Count.EqualTo(2));
     }
 
     [Test]
@@ -49,7 +49,7 @@ public class QueryBreakdownCollectionTests
         _collection.Add(query);
 
         // Assert
-        Assert.That(_collection.Count, Is.EqualTo(1));
+        Assert.That(_collection, Has.Count.EqualTo(1));
         Assert.That(_collection.QueryBreakdowns[0], Is.EqualTo(query));
     }
 
@@ -103,7 +103,7 @@ public class QueryBreakdownCollectionTests
         var results = _collection.WhereUseStageReference().ToList();
 
         // Assert
-        Assert.That(results.Count, Is.EqualTo(1));
+        Assert.That(results, Has.Count.EqualTo(1));
     }
 
     [Test]
@@ -121,7 +121,7 @@ public class QueryBreakdownCollectionTests
 
         // Assert
         // Only the stage reference query should be returned, not the parameter query
-        Assert.That(results.Count, Is.EqualTo(1));
+        Assert.That(results, Has.Count.EqualTo(1));
         Assert.That(results[0], Is.EqualTo(queryWithStage));
     }
 
@@ -139,7 +139,7 @@ public class QueryBreakdownCollectionTests
         var results = _collection.WhereUseSemiStructuredData().ToList();
 
         // Assert
-        Assert.That(results.Count, Is.EqualTo(1));
+        Assert.That(results, Has.Count.EqualTo(1));
     }
 
     [Test]
@@ -168,7 +168,7 @@ public class QueryBreakdownCollectionTests
         var tables = _collection.GetUniqueTableReferences().ToList();
 
         // Assert
-        Assert.That(tables.Count, Is.EqualTo(2));
+        Assert.That(tables, Has.Count.EqualTo(2));
         Assert.That(tables, Does.Contain("Users"));
         Assert.That(tables, Does.Contain("Orders"));
     }
@@ -187,9 +187,12 @@ public class QueryBreakdownCollectionTests
         var summaries = _collection.GetQuerySummaries().ToList();
 
         // Assert
-        Assert.That(summaries.Count, Is.EqualTo(2));
-        Assert.That(summaries[0].UsesSemiStructuredData, Is.True);
-        Assert.That(summaries[1].UsesStageReference, Is.True);
+        Assert.That(summaries, Has.Count.EqualTo(2));
+        Assert.Multiple(() =>
+        {
+            Assert.That(summaries[0].UsesSemiStructuredData, Is.True);
+            Assert.That(summaries[1].UsesStageReference, Is.True);
+        });
     }
 
     [Test]
@@ -220,9 +223,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]
@@ -241,7 +247,7 @@ public class QueryBreakdownCollectionTests
         var report = _collection.GetParameterUsageReport().ToList();
 
         // Assert
-        Assert.That(report.Count, Is.GreaterThan(0));
+        Assert.That(report, Is.Not.Empty);
         var userIdReport = report.FirstOrDefault(r => r.ParameterName == "UserId");
         Assert.That(userIdReport, Is.Not.Null);
         Assert.That(userIdReport?.UsedInQueryCount, Is.EqualTo(2));
@@ -273,6 +279,6 @@ public class QueryBreakdownCollectionTests
         _collection.Clear();
 
         // Assert
-        Assert.That(_collection.Count, Is.EqualTo(0));
+        Assert.That(_collection, Is.Empty);
     }
 }

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

@@ -13,13 +13,16 @@ public class QueryBreakdownTests
         // Arrange & Act
         var queryBreakdown = new QueryBreakdown();
 
-        // Assert
-        Assert.That(queryBreakdown.SelectClause.Clause, Is.EqualTo(string.Empty));
-        Assert.That(queryBreakdown.FromClause.Clause, Is.EqualTo(string.Empty));
-        Assert.That(queryBreakdown.WhereClause.Clause, Is.EqualTo(string.Empty));
-        Assert.That(queryBreakdown.OrderByClause.Clause, Is.EqualTo(string.Empty));
-        Assert.That(queryBreakdown.GroupByClause.Clause, Is.EqualTo(string.Empty));
-        Assert.That(queryBreakdown.HavingClause.Clause, Is.EqualTo(string.Empty));
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(queryBreakdown.SelectClause.Clause, Is.EqualTo(string.Empty));
+            Assert.That(queryBreakdown.FromClause.Clause, Is.EqualTo(string.Empty));
+            Assert.That(queryBreakdown.WhereClause.Clause, Is.EqualTo(string.Empty));
+            Assert.That(queryBreakdown.OrderByClause.Clause, Is.EqualTo(string.Empty));
+            Assert.That(queryBreakdown.GroupByClause.Clause, Is.EqualTo(string.Empty));
+            Assert.That(queryBreakdown.HavingClause.Clause, Is.EqualTo(string.Empty));
+        });
     }
 
     [Test]
@@ -32,9 +35,12 @@ public class QueryBreakdownTests
         // Act
         var queryBreakdown = new QueryBreakdown(selectClause, fromClause);
 
-        // Assert
-        Assert.That(queryBreakdown.SelectClause.Clause, Is.EqualTo(selectClause));
-        Assert.That(queryBreakdown.FromClause.Clause, Is.EqualTo(fromClause));
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(queryBreakdown.SelectClause.Clause, Is.EqualTo(selectClause));
+            Assert.That(queryBreakdown.FromClause.Clause, Is.EqualTo(fromClause));
+        });
     }
 
     [Test]
@@ -48,10 +54,13 @@ public class QueryBreakdownTests
         // Act
         var queryBreakdown = new QueryBreakdown(selectClause, fromClause, whereClause);
 
-        // Assert
-        Assert.That(queryBreakdown.SelectClause.Clause, Is.EqualTo(selectClause));
-        Assert.That(queryBreakdown.FromClause.Clause, Is.EqualTo(fromClause));
-        Assert.That(queryBreakdown.WhereClause.Clause, Is.EqualTo(whereClause));
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(queryBreakdown.SelectClause.Clause, Is.EqualTo(selectClause));
+            Assert.That(queryBreakdown.FromClause.Clause, Is.EqualTo(fromClause));
+            Assert.That(queryBreakdown.WhereClause.Clause, Is.EqualTo(whereClause));
+        });
     }
 
     #endregion
@@ -118,7 +127,7 @@ public class QueryBreakdownTests
         // Verify 4-space Snowflake indentation
         var lines = sql.Split(separator, StringSplitOptions.RemoveEmptyEntries);
         var indentedLines = lines.Where(l => l.StartsWith("    ")).ToList();
-        Assert.That(indentedLines.Count, Is.GreaterThan(0));
+        Assert.That(indentedLines, Is.Not.Empty);
     }
 
     [Test]
@@ -171,7 +180,7 @@ public class QueryBreakdownTests
         mainQueryBreakdown.AddWithClause("PRODUCT_ORDERS", cteSql);
 
         // Assert
-        Assert.That(mainQueryBreakdown.WithClauses.Count, Is.EqualTo(1));
+        Assert.That(mainQueryBreakdown.WithClauses, Has.Count.EqualTo(1));
         Assert.That(mainQueryBreakdown.WithClauses[0].TableName, Is.EqualTo("PRODUCT_ORDERS"));
     }
 
@@ -186,7 +195,7 @@ public class QueryBreakdownTests
         mainQueryBreakdown.AddWithClause("ProductOrders", cteSql, isMicrosoftSql: true);
 
         // Assert
-        Assert.That(mainQueryBreakdown.WithClauses.Count, Is.EqualTo(1));
+        Assert.That(mainQueryBreakdown.WithClauses, Has.Count.EqualTo(1));
         Assert.That(mainQueryBreakdown.WithClauses[0].TableName, Is.EqualTo("ProductOrders"));
     }
 
@@ -202,7 +211,7 @@ public class QueryBreakdownTests
         mainQueryBreakdown.AddWithClause("PRODUCT_ORDERS", cteQuery);
 
         // Assert
-        Assert.That(mainQueryBreakdown.WithClauses.Count, Is.EqualTo(1));
+        Assert.That(mainQueryBreakdown.WithClauses, Has.Count.EqualTo(1));
         Assert.That(mainQueryBreakdown.WithClauses[0].Query, Is.EqualTo(cteQuery));
     }
 
@@ -231,11 +240,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"));
     }
@@ -289,12 +301,18 @@ 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.That(withIndex, Is.LessThan(mainSelectIndex));
+        Assert.Multiple(() =>
+        {
+            Assert.That(withIndex, Is.GreaterThan(-1));
+            Assert.That(mainSelectIndex, Is.GreaterThan(-1));
+        });
+        Assert.Multiple(() =>
+        {
+            Assert.That(withIndex, Is.LessThan(mainSelectIndex));
 
-        // Assert - Verify CTE definition
-        Assert.That(sql, Does.Contain("PRODUCT_TOTALS"));
+            // Assert - Verify CTE definition
+            Assert.That(sql, Does.Contain("PRODUCT_TOTALS"));
+        });
         Assert.That(sql, Does.Contain("AS"));
         Assert.That(sql, Does.Contain("PRODUCT_ID"));
         Assert.That(sql, Does.Contain("TOTAL_QUANTITY"));
@@ -312,13 +330,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]
@@ -334,9 +358,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.Count, Is.EqualTo(1));
+        Assert.Multiple(() =>
+        {
+            // Assert - Now using WITH clause
+            Assert.That(query.IsUsingWithClause, Is.True);
+            Assert.That(query.WithClauses, Has.Count.EqualTo(1));
+        });
     }
 
     #endregion
@@ -357,8 +384,11 @@ public class QueryBreakdownTests
         // Assert
         // Snowflake stores parameters in both @ and : formats, so count is doubled
         Assert.That(merged.Count, Is.GreaterThanOrEqualTo(2));
-        Assert.That(merged.ContainsKey("@UserId") || merged.ContainsKey(":UserId"), Is.True);
-        Assert.That(merged.ContainsKey("@ActiveStatus") || merged.ContainsKey(":ActiveStatus"), Is.True);
+        Assert.Multiple(() =>
+        {
+            Assert.That(merged.ContainsKey("@UserId") || merged.ContainsKey(":UserId"), Is.True);
+            Assert.That(merged.ContainsKey("@ActiveStatus") || merged.ContainsKey(":ActiveStatus"), Is.True);
+        });
     }
 
     [Test]
@@ -378,8 +408,11 @@ public class QueryBreakdownTests
         // Assert
         // Should have parameters from both CTE and main query
         var keys = merged.Keys.ToList();
-        Assert.That(keys.Any(k => k.Contains("MinDate")));
-        Assert.That(keys.Any(k => k.Contains("ResultLimit")));
+        Assert.Multiple(() =>
+        {
+            Assert.That(keys.Any(k => k.Contains("MinDate")));
+            Assert.That(keys.Any(k => k.Contains("ResultLimit")));
+        });
     }
 
     [Test]
@@ -402,9 +435,12 @@ public class QueryBreakdownTests
 
         // Assert
         var keys = merged.Keys.ToList();
-        Assert.That(keys.Any(k => k.Contains("Status1")));
-        Assert.That(keys.Any(k => k.Contains("MinDate")));
-        Assert.That(keys.Any(k => k.Contains("ResultLimit")));
+        Assert.Multiple(() =>
+        {
+            Assert.That(keys.Any(k => k.Contains("Status1")));
+            Assert.That(keys.Any(k => k.Contains("MinDate")));
+            Assert.That(keys.Any(k => k.Contains("ResultLimit")));
+        });
     }
 
     [Test]
@@ -424,7 +460,7 @@ public class QueryBreakdownTests
         // Assert
         // Main query value should win
         var keys = merged.Keys.Where(k => k.Contains("QueryLimit")).ToList();
-        Assert.That(keys.Count, Is.GreaterThan(0));
+        Assert.That(keys, Is.Not.Empty);
         // All QueryLimit entries should be 100 (main query's value)
         foreach (var key in keys)
         {
@@ -452,9 +488,12 @@ public class QueryBreakdownTests
 
         // Assert - All parameters from all levels should be present
         var keys = merged.Keys.ToList();
-        Assert.That(keys.Any(k => k.Contains("InnerParam")));
-        Assert.That(keys.Any(k => k.Contains("MiddleParam")));
-        Assert.That(keys.Any(k => k.Contains("MainParam")));
+        Assert.Multiple(() =>
+        {
+            Assert.That(keys.Any(k => k.Contains("InnerParam")));
+            Assert.That(keys.Any(k => k.Contains("MiddleParam")));
+            Assert.That(keys.Any(k => k.Contains("MainParam")));
+        });
     }
 
     [Test]
@@ -480,10 +519,13 @@ public class QueryBreakdownTests
         var dateValues = merged.Values.OfType<DateTime>().Count();
         var decimalValues = merged.Values.OfType<decimal>().Count();
 
-        Assert.That(intValues, Is.GreaterThan(0), "Should have at least one int value");
-        Assert.That(stringValues, Is.GreaterThan(0), "Should have at least one string value");
-        Assert.That(dateValues, Is.GreaterThan(0), "Should have at least one DateTime value");
-        Assert.That(decimalValues, Is.GreaterThan(0), "Should have at least one decimal value");
+        Assert.Multiple(() =>
+        {
+            Assert.That(intValues, Is.GreaterThan(0), "Should have at least one int value");
+            Assert.That(stringValues, Is.GreaterThan(0), "Should have at least one string value");
+            Assert.That(dateValues, Is.GreaterThan(0), "Should have at least one DateTime value");
+            Assert.That(decimalValues, Is.GreaterThan(0), "Should have at least one decimal value");
+        });
     }
 
     #endregion
@@ -499,9 +541,12 @@ public class QueryBreakdownTests
         // Act
         var queryBreakdown = QueryBreakdown.Parse(sql, false);
 
-        // Assert
-        Assert.That(queryBreakdown.SelectClause.Clause?.Trim(), Does.Contain("ID, NAME"));
-        Assert.That(queryBreakdown.FromClause.Clause?.Trim(), Does.Contain("USERS"));
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(queryBreakdown.SelectClause.Clause?.Trim(), Does.Contain("ID, NAME"));
+            Assert.That(queryBreakdown.FromClause.Clause?.Trim(), Does.Contain("USERS"));
+        });
     }
 
     [Test]
@@ -572,7 +617,7 @@ public class QueryBreakdownTests
         var queryBreakdown = QueryBreakdown.Parse(sql, false);
 
         // Assert
-        Assert.That(queryBreakdown.Parameters.Count, Is.GreaterThan(0));
+        Assert.That(queryBreakdown.Parameters, Is.Not.Empty);
     }
 
     [Test]
@@ -606,9 +651,12 @@ public class QueryBreakdownTests
         // Act
         var queryBreakdown = QueryBreakdown.Parse(sql, false);
 
-        // Assert
-        Assert.That(queryBreakdown.IsUsingWithClause, Is.True);
-        Assert.That(queryBreakdown.SelectClause.Clause?.Trim(), Does.Contain("P.*, PS.TOTAL_QTY"));
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(queryBreakdown.IsUsingWithClause, Is.True);
+            Assert.That(queryBreakdown.SelectClause.Clause?.Trim(), Does.Contain("P.*, PS.TOTAL_QTY"));
+        });
     }
 
     [Test]
@@ -637,9 +685,12 @@ public class QueryBreakdownTests
         // Act
         var success = QueryBreakdown.TryParse(sql, out var queryBreakdown, false);
 
-        // Assert
-        Assert.That(success, Is.True);
-        Assert.That(queryBreakdown, Is.Not.Null);
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(success, Is.True);
+            Assert.That(queryBreakdown, Is.Not.Null);
+        });
         Assert.That(queryBreakdown, Is.InstanceOf<QueryBreakdown>());
     }
 
@@ -652,10 +703,13 @@ public class QueryBreakdownTests
         // Act
         var success = QueryBreakdown.TryParse(sql, out var queryBreakdown, out var error, false);
 
-        // Assert
-        Assert.That(success, Is.False);
-        Assert.That(queryBreakdown, Is.Null);
-        Assert.That(error, Is.Not.Null);
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(success, Is.False);
+            Assert.That(queryBreakdown, Is.Null);
+            Assert.That(error, Is.Not.Null);
+        });
     }
 
     #endregion
@@ -672,9 +726,12 @@ public class QueryBreakdownTests
         queryBreakdown.AddParameter("UserId", 123);
         queryBreakdown.AddWhereClause("ACTIVE = 1");
 
-        // Assert
-        Assert.That(queryBreakdown.Parameters, Does.ContainKey("@UserId"));
-        Assert.That(queryBreakdown.WhereClause.Clause, Does.Contain("ACTIVE = 1"));
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(queryBreakdown.Parameters, Does.ContainKey("@UserId"));
+            Assert.That(queryBreakdown.WhereClause.Clause, Does.Contain("ACTIVE = 1"));
+        });
     }
 
     [Test]
@@ -687,9 +744,12 @@ public class QueryBreakdownTests
         // Act
         queryBreakdown.AddWithClause("ORDER_CTE", cte);
 
-        // Assert
-        Assert.That(queryBreakdown.WithClauses.Count, Is.EqualTo(1));
-        Assert.That(queryBreakdown.IsUsingWithClause, Is.True);
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(queryBreakdown.WithClauses, Has.Count.EqualTo(1));
+            Assert.That(queryBreakdown.IsUsingWithClause, Is.True);
+        });
     }
 
     [Test]
@@ -740,8 +800,11 @@ public class QueryBreakdownTests
         Assert.That(sql, Does.Contain("WITH"));
         Assert.That(sql, Does.Contain("SALES_SUMMARY AS ("));
         Assert.That(sql, Does.Contain("ACTIVE_PRODUCTS AS ("));
-        Assert.That(sql, Does.Contain("LIMIT 100"));
-        Assert.That(mainQueryBreakdown.Parameters, Does.ContainKey(":minSales"));
+        Assert.Multiple(() =>
+        {
+            Assert.That(sql, Does.Contain("LIMIT 100"));
+            Assert.That(mainQueryBreakdown.Parameters, Does.ContainKey(":minSales"));
+        });
         Assert.That(mainQueryBreakdown.Parameters, Does.ContainKey(":startDate"));
     }
 
@@ -762,8 +825,11 @@ public class QueryBreakdownTests
 
         // Assert
         Assert.That(sql, Does.Contain("WITH"));
-        Assert.That(sql, Does.Contain("MIDDLE_CTE AS ("));
-        Assert.That(mainQueryBreakdown.WithClauses.Count, Is.EqualTo(1));
+        Assert.Multiple(() =>
+        {
+            Assert.That(sql, Does.Contain("MIDDLE_CTE AS ("));
+            Assert.That(mainQueryBreakdown.WithClauses, Has.Count.EqualTo(1));
+        });
     }
 
     [Test]
@@ -887,9 +953,12 @@ public class QueryBreakdownTests
         // Act
         var queryBreakdown = QueryBreakdown.Parse(sql, false);
 
-        // Assert
-        Assert.That(queryBreakdown.SelectClause.Clause, Does.Contain("F.VALUE"));
-        Assert.That(queryBreakdown.FromClause.Clause, Does.Contain("FLATTEN"));
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(queryBreakdown.SelectClause.Clause, Does.Contain("F.VALUE"));
+            Assert.That(queryBreakdown.FromClause.Clause, Does.Contain("FLATTEN"));
+        });
     }
 
     [Test]
@@ -1004,7 +1073,7 @@ public class QueryBreakdownTests
 
         // Assert
         // Base class normalizes to @, but Snowflake might handle differently
-        Assert.That(queryBreakdown.Parameters.Count, Is.GreaterThan(0));
+        Assert.That(queryBreakdown.Parameters, Is.Not.Empty);
     }
 
     #endregion
@@ -1122,7 +1191,7 @@ public class QueryBreakdownTests
         // Assert - Snowflake should use 4-space indent, base uses 5-space
         var snowflakeLines = snowflakeSql.Split(separator, StringSplitOptions.RemoveEmptyEntries);
         var snowflakeIndentedLines = snowflakeLines.Where(l => l.StartsWith("    ") && !l.StartsWith("     ")).ToList();
-        Assert.That(snowflakeIndentedLines.Count, Is.GreaterThan(0), "Snowflake should use 4-space indentation");
+        Assert.That(snowflakeIndentedLines, Is.Not.Empty, "Snowflake should use 4-space indentation");
     }
 
     #endregion
@@ -1148,9 +1217,12 @@ public class QueryBreakdownTests
         // Act
         var success = QueryBreakdown.TryParse(sql, out _, out var error, false);
 
-        // Assert
-        Assert.That(success, Is.False);
-        Assert.That(error, Is.Not.Null.And.Not.Empty);
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(success, Is.False);
+            Assert.That(error, Is.Not.Null.And.Not.Empty);
+        });
     }
 
     [Test]
@@ -1196,9 +1268,12 @@ public class QueryBreakdownTests
         // Act
         var queryBreakdown = QueryBreakdown.Parse(sql, false);
 
-        // Assert
-        Assert.That(queryBreakdown.SelectClause.Clause, Does.Contain("$1"));
-        Assert.That(queryBreakdown.FromClause.Clause, Does.Contain("@MY_STAGE"));
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(queryBreakdown.SelectClause.Clause, Does.Contain("$1"));
+            Assert.That(queryBreakdown.FromClause.Clause, Does.Contain("@MY_STAGE"));
+        });
     }
 
     [Test]
@@ -1245,8 +1320,11 @@ public class QueryBreakdownTests
         Assert.That(sql, Does.Contain("SALES_SUMMARY AS ("));
         Assert.That(sql, Does.Contain("TOP_PRODUCTS AS ("));
         Assert.That(sql, Does.Contain("ROW_NUMBER()"));
-        Assert.That(sql, Does.Contain("LIMIT 100"));
-        Assert.That(mainQueryBreakdown.Parameters.Count, Is.GreaterThanOrEqualTo(2));
+        Assert.Multiple(() =>
+        {
+            Assert.That(sql, Does.Contain("LIMIT 100"));
+            Assert.That(mainQueryBreakdown.Parameters.Count, Is.GreaterThanOrEqualTo(2));
+        });
     }
 
     #endregion
@@ -1265,9 +1343,12 @@ public class QueryBreakdownTests
         // Assert
         Assert.That(result, Is.Not.Null);
         Assert.That(result, Is.InstanceOf<QueryBreakdown>(), "Should return Snowflake QueryBreakdown instance");
-        Assert.That(result.SelectClause.Clause?.Trim(), Does.Contain("Id, Name"));
-        Assert.That(result.FromClause.Clause?.Trim(), Does.Contain("Users"));
-        Assert.That(result.WhereClause.Clause?.Trim(), Does.Contain("Active = 1"));
+        Assert.Multiple(() =>
+        {
+            Assert.That(result.SelectClause.Clause?.Trim(), Does.Contain("Id, Name"));
+            Assert.That(result.FromClause.Clause?.Trim(), Does.Contain("Users"));
+            Assert.That(result.WhereClause.Clause?.Trim(), Does.Contain("Active = 1"));
+        });
     }
 
     [Test]
@@ -1300,12 +1381,15 @@ public class QueryBreakdownTests
 
         // Assert
         Assert.That(result.SelectClause.Clause?.Trim(), Does.Contain("DepartmentId"));
-        Assert.That(result.SelectClause.Clause?.Trim(), Does.Contain("COUNT(*)"));
-        Assert.That(result.FromClause.Clause?.Trim(), Does.Contain("Employees"));
-        Assert.That(result.WhereClause.Clause?.Trim(), Does.Contain("Active = 1"));
-        Assert.That(result.GroupByClause.Clause?.Trim(), Does.Contain("DepartmentId"));
-        Assert.That(result.HavingClause.Clause?.Trim(), Does.Contain("COUNT(*) > 5"));
-        Assert.That(result.OrderByClause.Clause?.Trim(), Does.Contain("EmployeeCount DESC"));
+        Assert.Multiple(() =>
+        {
+            Assert.That(result.SelectClause.Clause?.Trim(), Does.Contain("COUNT(*)"));
+            Assert.That(result.FromClause.Clause?.Trim(), Does.Contain("Employees"));
+            Assert.That(result.WhereClause.Clause?.Trim(), Does.Contain("Active = 1"));
+            Assert.That(result.GroupByClause.Clause?.Trim(), Does.Contain("DepartmentId"));
+            Assert.That(result.HavingClause.Clause?.Trim(), Does.Contain("COUNT(*) > 5"));
+            Assert.That(result.OrderByClause.Clause?.Trim(), Does.Contain("EmployeeCount DESC"));
+        });
     }
 
     [Test]
@@ -1326,7 +1410,7 @@ public class QueryBreakdownTests
         // Verify Snowflake-style formatting (4-space indentation)
         var lines = snowflakeSql.Split(separator, StringSplitOptions.RemoveEmptyEntries);
         var indentedLines = lines.Where(l => l.StartsWith("    ")).ToList();
-        Assert.That(indentedLines.Count, Is.GreaterThan(0), "Should have Snowflake-style indentation");
+        Assert.That(indentedLines, Is.Not.Empty, "Should have Snowflake-style indentation");
     }
 
     [Test]
@@ -1343,11 +1427,17 @@ public class QueryBreakdownTests
         // Act
         var result = QueryBreakdown.Parse(tsqlQuery, isMicrosoftSql: true);
 
-        // Assert
-        Assert.That(result.SelectClause.Clause?.Trim(), Does.Contain("o.OrderId"));
-        Assert.That(result.FromClause.Clause?.Trim(), Does.Contain("INNER JOIN"));
-        Assert.That(result.FromClause.Clause?.Trim(), Does.Contain("LEFT JOIN"));
-        Assert.That(result.WhereClause.Clause?.Trim(), Does.Contain("OrderDate"));
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(result.SelectClause.Clause?.Trim(), Does.Contain("o.OrderId"));
+            Assert.That(result.FromClause.Clause?.Trim(), Does.Contain("INNER JOIN"));
+        });
+        Assert.Multiple(() =>
+        {
+            Assert.That(result.FromClause.Clause?.Trim(), Does.Contain("LEFT JOIN"));
+            Assert.That(result.WhereClause.Clause?.Trim(), Does.Contain("OrderDate"));
+        });
     }
 
     [Test]
@@ -1361,9 +1451,12 @@ public class QueryBreakdownTests
         // Act
         var result = QueryBreakdown.Parse(tsqlQuery, isMicrosoftSql: true);
 
-        // Assert
-        Assert.That(result.SelectClause.Clause?.Trim(), Does.Contain("CustomerId, CustomerName"));
-        Assert.That(result.WhereClause.Clause?.Trim(), Does.Contain("IN"));
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(result.SelectClause.Clause?.Trim(), Does.Contain("CustomerId, CustomerName"));
+            Assert.That(result.WhereClause.Clause?.Trim(), Does.Contain("IN"));
+        });
         Assert.That(result.WhereClause.Clause?.Trim(), Does.Contain("SELECT"));
     }
 
@@ -1376,9 +1469,12 @@ public class QueryBreakdownTests
         // Act
         var success = QueryBreakdown.TryParse(tsqlQuery, out var result, isMicrosoftSql: true);
 
-        // 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<QueryBreakdown>());
     }
 
@@ -1391,10 +1487,13 @@ public class QueryBreakdownTests
         // Act
         var success = QueryBreakdown.TryParse(invalidQuery, out var result, out var errorMessage, isMicrosoftSql: true);
 
-        // Assert
-        Assert.That(success, Is.False);
-        Assert.That(result, Is.Null);
-        Assert.That(errorMessage, Is.Not.Null.And.Not.Empty);
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(success, Is.False);
+            Assert.That(result, Is.Null);
+            Assert.That(errorMessage, Is.Not.Null.And.Not.Empty);
+        });
     }
 
     [Test]
@@ -1406,10 +1505,13 @@ public class QueryBreakdownTests
         // Act
         var result = QueryBreakdown.Parse(tsqlQuery, isMicrosoftSql: true);
 
-        // Assert
-        Assert.That(result.SelectClause.Clause?.Trim(), Does.Contain("[Order Id]"));
-        Assert.That(result.FromClause.Clause?.Trim(), Does.Contain("[Order Details]"));
-        Assert.That(result.WhereClause.Clause?.Trim(), Does.Contain("[Active]"));
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(result.SelectClause.Clause?.Trim(), Does.Contain("[Order Id]"));
+            Assert.That(result.FromClause.Clause?.Trim(), Does.Contain("[Order Details]"));
+            Assert.That(result.WhereClause.Clause?.Trim(), Does.Contain("[Active]"));
+        });
     }
 
     [Test]
@@ -1428,9 +1530,12 @@ public class QueryBreakdownTests
         // Act
         var result = QueryBreakdown.Parse(tsqlQuery, isMicrosoftSql: true);
 
-        // Assert
-        Assert.That(result.IsUsingWithClause, Is.True);
-        Assert.That(result.SelectClause.Clause?.Trim(), Does.Contain("DepartmentName"));
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(result.IsUsingWithClause, Is.True);
+            Assert.That(result.SelectClause.Clause?.Trim(), Does.Contain("DepartmentName"));
+        });
     }
 
     [Test]
@@ -1452,8 +1557,11 @@ public class QueryBreakdownTests
 
         // Assert
         Assert.That(snowflakeSql, Does.Contain("WITH"));
-        Assert.That(snowflakeSql, Does.Contain("SELECT"));
-        Assert.That(result.IsUsingWithClause, Is.True, "Should have WITH clause parsed");
+        Assert.Multiple(() =>
+        {
+            Assert.That(snowflakeSql, Does.Contain("SELECT"));
+            Assert.That(result.IsUsingWithClause, Is.True, "Should have WITH clause parsed");
+        });
         // Note: WITH clause content is stored in WithClause property when parsed via isMicrosoftSql
         // The GetSql() will output it if WithClauses collection is populated or if we manually add it
     }
@@ -1482,14 +1590,20 @@ public class QueryBreakdownTests
 
         // Assert - Verify parsing
         Assert.That(result, Is.InstanceOf<QueryBreakdown>());
-        Assert.That(result.SelectClause.Clause?.Trim(), Does.Contain("YEAR"));
-        Assert.That(result.GroupByClause.Clause?.Trim(), Does.Contain("YEAR"));
-        Assert.That(result.HavingClause.Clause?.Trim(), Does.Contain("COUNT"));
-        Assert.That(result.Parameters, Does.ContainKey("@startDate"));
-        Assert.That(result.Parameters, Does.ContainKey("@endDate"));
+        Assert.Multiple(() =>
+        {
+            Assert.That(result.SelectClause.Clause?.Trim(), Does.Contain("YEAR"));
+            Assert.That(result.GroupByClause.Clause?.Trim(), Does.Contain("YEAR"));
+            Assert.That(result.HavingClause.Clause?.Trim(), Does.Contain("COUNT"));
+            Assert.That(result.Parameters, Does.ContainKey("@startDate"));
+        });
+        Assert.Multiple(() =>
+        {
+            Assert.That(result.Parameters, Does.ContainKey("@endDate"));
 
-        // Assert - Verify Snowflake SQL generation
-        Assert.That(snowflakeSql, Does.Contain("SELECT"));
+            // Assert - Verify Snowflake SQL generation
+            Assert.That(snowflakeSql, Does.Contain("SELECT"));
+        });
         Assert.That(snowflakeSql, Does.Contain("FROM"));
         Assert.That(snowflakeSql, Does.Contain("WHERE"));
         Assert.That(snowflakeSql, Does.Contain("GROUP BY"));
@@ -1510,9 +1624,12 @@ public class QueryBreakdownTests
         result.AddWithClause("ProductSummary", cteQuery);
         var snowflakeSql = result.GetSql();
 
-        // Assert
-        Assert.That(result.WithClauses.Count, Is.EqualTo(1));
-        Assert.That(snowflakeSql, Does.Contain("WITH"));
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(result.WithClauses, Has.Count.EqualTo(1));
+            Assert.That(snowflakeSql, Does.Contain("WITH"));
+        });
         Assert.That(snowflakeSql, Does.Contain("ProductSummary AS ("));
     }
 
@@ -1528,9 +1645,12 @@ public class QueryBreakdownTests
 
         // Assert
         Assert.That(clone, Is.InstanceOf<QueryBreakdown>());
-        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.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));
+        });
     }
 
     #endregion
@@ -1608,9 +1728,12 @@ public class QueryBreakdownTests
         // Act
         query.AddSelectExpression(expr, "/* Primary key */");
 
-        // Assert
-        Assert.That(query.SelectClause.Clause, Is.EqualTo("CUSTOMERS.CUSTOMER_ID"));
-        Assert.That(query.SelectClause.Comment, Is.EqualTo("/* Primary key */"));
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(query.SelectClause.Clause, Is.EqualTo("CUSTOMERS.CUSTOMER_ID"));
+            Assert.That(query.SelectClause.Comment, Is.EqualTo("/* Primary key */"));
+        });
     }
 
     [Test]
@@ -1888,12 +2011,18 @@ public class QueryBreakdownTests
         // Act - Use Snowflake :param syntax
         query.AddWhereClause("USER_ID = :UserId AND STATUS = :Status", false);
 
-        // Assert
-        Assert.That(query.WhereClause.Clause, Is.EqualTo("USER_ID = :UserId AND STATUS = :Status"));
-        Assert.That(query.Parameters, Does.ContainKey(":UserId"));
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(query.WhereClause.Clause, Is.EqualTo("USER_ID = :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]
@@ -1905,9 +2034,12 @@ public class QueryBreakdownTests
         // Act - Use Microsoft @param syntax with isMicrosoftSql=true
         query.AddWhereClause("USER_ID = @UserId AND STATUS = @Status", "and", true);
 
-        // Assert
-        Assert.That(query.WhereClause.Clause, Is.EqualTo("USER_ID = @UserId AND STATUS = @Status"));
-        Assert.That(query.Parameters, Does.ContainKey("@UserId"));
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(query.WhereClause.Clause, Is.EqualTo("USER_ID = @UserId AND STATUS = @Status"));
+            Assert.That(query.Parameters, Does.ContainKey("@UserId"));
+        });
         Assert.That(query.Parameters, Does.ContainKey("@Status"));
     }
 

tests/Strata.SqlTools.Snowflake.Tests/Snowflake/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,9 +181,12 @@ public class RecursiveCTETests
 
         // Assert
         // Snowflake stores parameters with both @ and : formats
-        var statusKey = merged.Keys.FirstOrDefault(k => k.Contains("Status") && (k.StartsWith("@") || k.StartsWith(":")));
-        Assert.That(statusKey, Is.Not.Null);
-        Assert.That(merged[statusKey], Is.EqualTo("active"), "Main query parameter should take precedence");
+        var statusKey = merged.Keys.FirstOrDefault(k => k.Contains("Status") && (k.StartsWith('@') || k.StartsWith(':')));
+        Assert.Multiple(() =>
+        {
+            Assert.That(statusKey, Is.Not.Null);
+            Assert.That(merged[statusKey], Is.EqualTo("active"), "Main query parameter should take precedence");
+        });
     }
 
     #endregion
@@ -247,8 +256,8 @@ public class RecursiveCTETests
 
         // Assert
         Assert.That(sql, Contains.Substring("WITH RECURSIVE"));
-        Assert.That(sql.Contains("base AS"), "Non-recursive CTE should be included");
-        Assert.That(sql.Contains("tree_hierarchy AS"), "Recursive CTE should be included");
+        Assert.That(sql, Does.Contain("base AS"), "Non-recursive CTE should be included");
+        Assert.That(sql, Does.Contain("tree_hierarchy AS"), "Recursive CTE should be included");
     }
 
     [Test]

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

@@ -34,8 +34,11 @@ public class StatementExpressionParserTests
 
         // Assert
         Assert.That(result, Is.Not.Null);
-        Assert.That(result, Is.InstanceOf<NumberLiteralExpression>());
-        Assert.That(((NumberLiteralExpression)result).Value, Is.EqualTo(42));
+        Assert.Multiple(() =>
+        {
+            Assert.That(result, Is.InstanceOf<NumberLiteralExpression>());
+            Assert.That(((NumberLiteralExpression)result).Value, Is.EqualTo(42));
+        });
     }
 
     [Test]
@@ -49,8 +52,11 @@ public class StatementExpressionParserTests
 
         // Assert
         Assert.That(result, Is.Not.Null);
-        Assert.That(result, Is.InstanceOf<NumberLiteralExpression>());
-        Assert.That(((NumberLiteralExpression)result).Value, Is.EqualTo(3.14m));
+        Assert.Multiple(() =>
+        {
+            Assert.That(result, Is.InstanceOf<NumberLiteralExpression>());
+            Assert.That(((NumberLiteralExpression)result).Value, Is.EqualTo(3.14m));
+        });
     }
 
     [Test]
@@ -64,8 +70,11 @@ public class StatementExpressionParserTests
 
         // Assert
         Assert.That(result, Is.Not.Null);
-        Assert.That(result, Is.InstanceOf<ColumnExpression>());
-        Assert.That(((ColumnExpression)result).ColumnName, Is.EqualTo("CUSTOMER_ID"));
+        Assert.Multiple(() =>
+        {
+            Assert.That(result, Is.InstanceOf<ColumnExpression>());
+            Assert.That(((ColumnExpression)result).ColumnName, Is.EqualTo("CUSTOMER_ID"));
+        });
     }
 
     [Test]
@@ -79,8 +88,11 @@ public class StatementExpressionParserTests
 
         // Assert
         Assert.That(result, Is.Not.Null);
-        Assert.That(result, Is.InstanceOf<ColumnExpression>());
-        Assert.That(((ColumnExpression)result).ColumnName, Is.EqualTo("CUSTOMER_ID"));
+        Assert.Multiple(() =>
+        {
+            Assert.That(result, Is.InstanceOf<ColumnExpression>());
+            Assert.That(((ColumnExpression)result).ColumnName, Is.EqualTo("CUSTOMER_ID"));
+        });
     }
 
     #endregion
@@ -232,8 +244,11 @@ public class StatementExpressionParserTests
 
         // Assert
         Assert.That(result, Is.Not.Null);
-        Assert.That(result, Is.InstanceOf<ColumnExpression>());
-        Assert.That(((ColumnExpression)result).ColumnName, Is.EqualTo("ORDER_TOTAL"));
+        Assert.Multiple(() =>
+        {
+            Assert.That(result, Is.InstanceOf<ColumnExpression>());
+            Assert.That(((ColumnExpression)result).ColumnName, Is.EqualTo("ORDER_TOTAL"));
+        });
     }
 
     [Test]
@@ -247,8 +262,11 @@ public class StatementExpressionParserTests
 
         // Assert
         Assert.That(result, Is.Not.Null);
-        Assert.That(result, Is.InstanceOf<ColumnExpression>());
-        Assert.That(((ColumnExpression)result).ColumnName, Is.EqualTo("NET_REVENUE_USD_2024"));
+        Assert.Multiple(() =>
+        {
+            Assert.That(result, Is.InstanceOf<ColumnExpression>());
+            Assert.That(((ColumnExpression)result).ColumnName, Is.EqualTo("NET_REVENUE_USD_2024"));
+        });
     }
 
     [Test]
@@ -368,9 +386,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);
+        });
     }
 
     #endregion

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

@@ -23,9 +23,12 @@ 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"));
+        });
     }
 
     [Test]
@@ -44,14 +47,17 @@ public class StatementReaderTests
 
         // Assert
         Assert.That(tokens, Has.Count.EqualTo(5)); // "COLUMN_1" + "COLUMN_2" * 2
-        Assert.That(tokens[0].Type, Is.EqualTo(TokenType.ColumnIdentifier));
-        Assert.That(tokens[0].Value, Is.EqualTo("COLUMN_1"));
-        Assert.That(tokens[1].Type, Is.EqualTo(TokenType.Plus));
-        Assert.That(tokens[2].Type, Is.EqualTo(TokenType.ColumnIdentifier));
-        Assert.That(tokens[2].Value, Is.EqualTo("COLUMN_2"));
-        Assert.That(tokens[3].Type, Is.EqualTo(TokenType.Multiply));
-        Assert.That(tokens[4].Type, Is.EqualTo(TokenType.Number));
-        Assert.That(tokens[4].Value, Is.EqualTo("2"));
+        Assert.Multiple(() =>
+        {
+            Assert.That(tokens[0].Type, Is.EqualTo(TokenType.ColumnIdentifier));
+            Assert.That(tokens[0].Value, Is.EqualTo("COLUMN_1"));
+            Assert.That(tokens[1].Type, Is.EqualTo(TokenType.Plus));
+            Assert.That(tokens[2].Type, Is.EqualTo(TokenType.ColumnIdentifier));
+            Assert.That(tokens[2].Value, Is.EqualTo("COLUMN_2"));
+            Assert.That(tokens[3].Type, Is.EqualTo(TokenType.Multiply));
+            Assert.That(tokens[4].Type, Is.EqualTo(TokenType.Number));
+            Assert.That(tokens[4].Value, Is.EqualTo("2"));
+        });
     }
 
     [Test]
@@ -70,14 +76,17 @@ public class StatementReaderTests
 
         // Assert
         Assert.That(tokens, Has.Count.EqualTo(5));
-        Assert.That(tokens[0].Type, Is.EqualTo(TokenType.ColumnIdentifier));
-        Assert.That(tokens[0].Value, Is.EqualTo("REVENUE"));
-        Assert.That(tokens[1].Type, Is.EqualTo(TokenType.Plus));
-        Assert.That(tokens[2].Type, Is.EqualTo(TokenType.ColumnIdentifier));
-        Assert.That(tokens[2].Value, Is.EqualTo("COST"));
-        Assert.That(tokens[3].Type, Is.EqualTo(TokenType.Minus));
-        Assert.That(tokens[4].Type, Is.EqualTo(TokenType.String));
-        Assert.That(tokens[4].Value, Is.EqualTo("PROFIT"));
+        Assert.Multiple(() =>
+        {
+            Assert.That(tokens[0].Type, Is.EqualTo(TokenType.ColumnIdentifier));
+            Assert.That(tokens[0].Value, Is.EqualTo("REVENUE"));
+            Assert.That(tokens[1].Type, Is.EqualTo(TokenType.Plus));
+            Assert.That(tokens[2].Type, Is.EqualTo(TokenType.ColumnIdentifier));
+            Assert.That(tokens[2].Value, Is.EqualTo("COST"));
+            Assert.That(tokens[3].Type, Is.EqualTo(TokenType.Minus));
+            Assert.That(tokens[4].Type, Is.EqualTo(TokenType.String));
+            Assert.That(tokens[4].Value, Is.EqualTo("PROFIT"));
+        });
     }
 
     [Test]
@@ -96,11 +105,14 @@ public class StatementReaderTests
 
         // Assert
         Assert.That(tokens, Is.Not.Empty);
-        Assert.That(tokens[0].Type, Is.EqualTo(TokenType.FunctionStart));
-        Assert.That(tokens[0].Value, Is.EqualTo("SUM"));
-        Assert.That(tokens[1].Type, Is.EqualTo(TokenType.ColumnIdentifier));
-        Assert.That(tokens[1].Value, Is.EqualTo("TOTAL_AMOUNT"));
-        Assert.That(tokens[2].Type, Is.EqualTo(TokenType.FunctionEnd));
+        Assert.Multiple(() =>
+        {
+            Assert.That(tokens[0].Type, Is.EqualTo(TokenType.FunctionStart));
+            Assert.That(tokens[0].Value, Is.EqualTo("SUM"));
+            Assert.That(tokens[1].Type, Is.EqualTo(TokenType.ColumnIdentifier));
+            Assert.That(tokens[1].Value, Is.EqualTo("TOTAL_AMOUNT"));
+            Assert.That(tokens[2].Type, Is.EqualTo(TokenType.FunctionEnd));
+        });
     }
 
     [Test]
@@ -119,14 +131,17 @@ public class StatementReaderTests
 
         // Assert
         Assert.That(tokens, Has.Count.EqualTo(5));
-        Assert.That(tokens[0].Type, Is.EqualTo(TokenType.ColumnIdentifier));
-        Assert.That(tokens[0].Value, Is.EqualTo("3_REVENUE"));
-        Assert.That(tokens[1].Type, Is.EqualTo(TokenType.Plus));
-        Assert.That(tokens[2].Type, Is.EqualTo(TokenType.ColumnIdentifier));
-        Assert.That(tokens[2].Value, Is.EqualTo("4_COST"));
-        Assert.That(tokens[3].Type, Is.EqualTo(TokenType.Minus));
-        Assert.That(tokens[4].Type, Is.EqualTo(TokenType.ColumnIdentifier));
-        Assert.That(tokens[4].Value, Is.EqualTo("5_PROFIT"));
+        Assert.Multiple(() =>
+        {
+            Assert.That(tokens[0].Type, Is.EqualTo(TokenType.ColumnIdentifier));
+            Assert.That(tokens[0].Value, Is.EqualTo("3_REVENUE"));
+            Assert.That(tokens[1].Type, Is.EqualTo(TokenType.Plus));
+            Assert.That(tokens[2].Type, Is.EqualTo(TokenType.ColumnIdentifier));
+            Assert.That(tokens[2].Value, Is.EqualTo("4_COST"));
+            Assert.That(tokens[3].Type, Is.EqualTo(TokenType.Minus));
+            Assert.That(tokens[4].Type, Is.EqualTo(TokenType.ColumnIdentifier));
+            Assert.That(tokens[4].Value, Is.EqualTo("5_PROFIT"));
+        });
     }
 
     [Test]
@@ -145,11 +160,14 @@ public class StatementReaderTests
 
         // Assert
         Assert.That(tokens, Has.Count.EqualTo(3));
-        Assert.That(tokens[0].Type, Is.EqualTo(TokenType.Number));
-        Assert.That(tokens[0].Value, Is.EqualTo("123.45"));
-        Assert.That(tokens[1].Type, Is.EqualTo(TokenType.Plus));
-        Assert.That(tokens[2].Type, Is.EqualTo(TokenType.Number));
-        Assert.That(tokens[2].Value, Is.EqualTo("67.89"));
+        Assert.Multiple(() =>
+        {
+            Assert.That(tokens[0].Type, Is.EqualTo(TokenType.Number));
+            Assert.That(tokens[0].Value, Is.EqualTo("123.45"));
+            Assert.That(tokens[1].Type, Is.EqualTo(TokenType.Plus));
+            Assert.That(tokens[2].Type, Is.EqualTo(TokenType.Number));
+            Assert.That(tokens[2].Value, Is.EqualTo("67.89"));
+        });
     }
 
     [Test]
@@ -168,11 +186,14 @@ public class StatementReaderTests
 
         // Assert
         Assert.That(tokens, Has.Count.EqualTo(3));
-        Assert.That(tokens[0].Type, Is.EqualTo(TokenType.String));
-        Assert.That(tokens[0].Value, Is.EqualTo("REVENUE"));
-        Assert.That(tokens[1].Type, Is.EqualTo(TokenType.Plus));
-        Assert.That(tokens[2].Type, Is.EqualTo(TokenType.String));
-        Assert.That(tokens[2].Value, Is.EqualTo("COST"));
+        Assert.Multiple(() =>
+        {
+            Assert.That(tokens[0].Type, Is.EqualTo(TokenType.String));
+            Assert.That(tokens[0].Value, Is.EqualTo("REVENUE"));
+            Assert.That(tokens[1].Type, Is.EqualTo(TokenType.Plus));
+            Assert.That(tokens[2].Type, Is.EqualTo(TokenType.String));
+            Assert.That(tokens[2].Value, Is.EqualTo("COST"));
+        });
     }
 
     [Test]
@@ -217,11 +238,14 @@ public class StatementReaderTests
 
         // Assert
         Assert.That(tokens, Is.Not.Empty);
-        Assert.That(tokens[0].Type, Is.EqualTo(TokenType.FunctionStart));
-        Assert.That(tokens[0].Value, Is.EqualTo("SUM"));
-        Assert.That(tokens[1].Type, Is.EqualTo(TokenType.FunctionStart));
-        Assert.That(tokens[1].Value, Is.EqualTo("AVG"));
-        Assert.That(tokens[2].Type, Is.EqualTo(TokenType.ColumnIdentifier));
-        Assert.That(tokens[2].Value, Is.EqualTo("REVENUE"));
+        Assert.Multiple(() =>
+        {
+            Assert.That(tokens[0].Type, Is.EqualTo(TokenType.FunctionStart));
+            Assert.That(tokens[0].Value, Is.EqualTo("SUM"));
+            Assert.That(tokens[1].Type, Is.EqualTo(TokenType.FunctionStart));
+            Assert.That(tokens[1].Value, Is.EqualTo("AVG"));
+            Assert.That(tokens[2].Type, Is.EqualTo(TokenType.ColumnIdentifier));
+            Assert.That(tokens[2].Value, Is.EqualTo("REVENUE"));
+        });
     }
 }

tests/Strata.SqlTools.Snowflake.Tests/Snowflake/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 >= :start_date"));
+        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 >= :start_date"));
 
-        // 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

tests/Strata.SqlTools.SqlBreakdown.Tests/Exceptions/ExceptionHandlingTests.cs

@@ -22,11 +22,14 @@ public class ExceptionHandlingTests
         // Act
         var exception = new SqlParseException(message, sql, position);
 
-        // Assert
-        Assert.That(exception.Message, Does.Contain(message));
-        Assert.That(exception.Sql, Is.EqualTo(sql));
-        Assert.That(exception.Position, Is.EqualTo(position));
-        Assert.That(exception.NearText, Is.Not.Empty);
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(exception.Message, Does.Contain(message));
+            Assert.That(exception.Sql, Is.EqualTo(sql));
+            Assert.That(exception.Position, Is.EqualTo(position));
+            Assert.That(exception.NearText, Is.Not.Empty);
+        });
     }
 
     [Test]
@@ -57,10 +60,13 @@ public class ExceptionHandlingTests
         // Act
         var exception = new SqlParseException(message, sql!, position);
 
-        // Assert
-        Assert.That(exception.Message, Does.Contain("SQL is null"));
-        Assert.That(exception.Sql, Is.EqualTo(string.Empty));
-        Assert.That(exception.NearText, Is.EqualTo(string.Empty));
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(exception.Message, Does.Contain("SQL is null"));
+            Assert.That(exception.Sql, Is.EqualTo(string.Empty));
+            Assert.That(exception.NearText, Is.EqualTo(string.Empty));
+        });
     }
 
     [Test]
@@ -90,9 +96,12 @@ public class ExceptionHandlingTests
         // Act
         var exception = new SqlParseException(message, sql, position, innerException);
 
-        // Assert
-        Assert.That(exception.InnerException, Is.EqualTo(innerException));
-        Assert.That(exception.Message, Does.Contain("Parse failed"));
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(exception.InnerException, Is.EqualTo(innerException));
+            Assert.That(exception.Message, Does.Contain("Parse failed"));
+        });
     }
 
     #endregion
@@ -110,10 +119,13 @@ public class ExceptionHandlingTests
         // Act
         var exception = new CteValidationException(message, cteName, validationRule);
 
-        // Assert
-        Assert.That(exception.Message, Does.Contain(message));
-        Assert.That(exception.CteName, Is.EqualTo(cteName));
-        Assert.That(exception.ValidationRule, Is.EqualTo(validationRule));
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(exception.Message, Does.Contain(message));
+            Assert.That(exception.CteName, Is.EqualTo(cteName));
+            Assert.That(exception.ValidationRule, Is.EqualTo(validationRule));
+        });
     }
 
     [Test]
@@ -141,9 +153,12 @@ public class ExceptionHandlingTests
         // Act
         var exception = new CteValidationException(message, "my_cte", validationRule);
 
-        // Assert
-        Assert.That(exception.ValidationRule, Is.EqualTo(validationRule));
-        Assert.That(exception.Message, Does.Contain("Validation failed"));
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(exception.ValidationRule, Is.EqualTo(validationRule));
+            Assert.That(exception.Message, Does.Contain("Validation failed"));
+        });
     }
 
     [Test]
@@ -204,8 +219,11 @@ public class ExceptionHandlingTests
 
         // Act & Assert
         var exception = Assert.Throws<SqlParseException>(() => QueryBreakdown.Parse(sql));
-        Assert.That(exception!.Sql, Is.EqualTo(sql));
-        Assert.That(exception.Message, Does.Contain("Failed to parse"));
+        Assert.Multiple(() =>
+        {
+            Assert.That(exception!.Sql, Is.EqualTo(sql));
+            Assert.That(exception.Message, Does.Contain("Failed to parse"));
+        });
     }
 
     [Test]
@@ -274,8 +292,11 @@ public class ExceptionHandlingTests
         // Act & Assert
         var exception = Assert.Throws<CteValidationException>(() =>
             query.AddWithClause("test_cte", (QueryBreakdown)null!));
-        Assert.That(exception!.ValidationRule, Is.EqualTo("QueryRequired"));
-        Assert.That(exception.CteName, Is.EqualTo("test_cte"));
+        Assert.Multiple(() =>
+        {
+            Assert.That(exception!.ValidationRule, Is.EqualTo("QueryRequired"));
+            Assert.That(exception.CteName, Is.EqualTo("test_cte"));
+        });
     }
 
     [Test]
@@ -291,8 +312,11 @@ public class ExceptionHandlingTests
         // Act & Assert
         var exception = Assert.Throws<CteValidationException>(() =>
             query.AddWithClause("my_cte", cte2));
-        Assert.That(exception!.ValidationRule, Is.EqualTo("DuplicateCteName"));
-        Assert.That(exception.Message, Does.Contain("already exists"));
+        Assert.Multiple(() =>
+        {
+            Assert.That(exception!.ValidationRule, Is.EqualTo("DuplicateCteName"));
+            Assert.That(exception.Message, Does.Contain("already exists"));
+        });
     }
 
     [Test]
@@ -344,8 +368,11 @@ public class ExceptionHandlingTests
         // Act & Assert
         var exception = Assert.Throws<SqlParseException>(() =>
             query.AddWithClause("my_cte", "INVALID SQL"));
-        Assert.That(exception!.Message, Does.Contain("my_cte"));
-        Assert.That(exception.Sql, Is.EqualTo("INVALID SQL"));
+        Assert.Multiple(() =>
+        {
+            Assert.That(exception!.Message, Does.Contain("my_cte"));
+            Assert.That(exception.Sql, Is.EqualTo("INVALID SQL"));
+        });
     }
 
     [Test]
@@ -374,8 +401,11 @@ public class ExceptionHandlingTests
         // Act & Assert
         var exception = Assert.Throws<CteValidationException>(() =>
             query.AddWithClause(withClause));
-        Assert.That(exception!.ValidationRule, Is.EqualTo("QueryRequired"));
-        Assert.That(exception.Message, Does.Contain("Query or Sql"));
+        Assert.Multiple(() =>
+        {
+            Assert.That(exception!.ValidationRule, Is.EqualTo("QueryRequired"));
+            Assert.That(exception.Message, Does.Contain("Query or Sql"));
+        });
     }
 
     [Test]
@@ -389,7 +419,7 @@ public class ExceptionHandlingTests
         query.AddWithClause("active_users", cteQuery);
 
         // Assert
-        Assert.That(query.WithClauses.Count, Is.EqualTo(1));
+        Assert.That(query.WithClauses, Has.Count.EqualTo(1));
         Assert.That(query.WithClauses[0].TableName, Is.EqualTo("active_users"));
     }
 
@@ -435,9 +465,12 @@ public class ExceptionHandlingTests
         // Act
         var exception = new SqlParseException("Syntax error", sql, position);
 
-        // Assert
-        Assert.That(exception.NearText, Does.Contain("status"));
-        Assert.That(exception.Message, Does.Contain("Near:"));
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(exception.NearText, Does.Contain("status"));
+            Assert.That(exception.Message, Does.Contain("Near:"));
+        });
     }
 
     #endregion

tests/Strata.SqlTools.SqlBreakdown.Tests/ExpressionTests/BooleanExpressionTests.cs

@@ -24,8 +24,11 @@ public class BooleanExpressionTests : ExpressionTestsBase
 
         // Assert
         Assert.That(firstResult, Is.Not.SameAs(BooleanExpression.False));
-        Assert.That(firstResult, Is.AssignableTo<BooleanExpression>());
-        Assert.That(secondResult, Is.Not.SameAs(BooleanExpression.False));
+        Assert.Multiple(() =>
+        {
+            Assert.That(firstResult, Is.AssignableTo<BooleanExpression>());
+            Assert.That(secondResult, Is.Not.SameAs(BooleanExpression.False));
+        });
         Assert.That(secondResult, Is.TypeOf<AndExpression>());
     }
 

tests/Strata.SqlTools.SqlBreakdown.Tests/ExpressionTests/DateFunctionTests.cs

@@ -27,7 +27,7 @@ public class DateFunctionTests : ExpressionTestsBase
                 {
                     var sql = (string)result;
                     Assert.That(sql, Is.Not.Null);
-                    Assert.That(sql.Length, Is.GreaterThan(0));
+                    Assert.That(sql, Is.Not.Empty);
                     Assert.That(sql, Is.EqualTo("DATE_TRUNC('month', DATEADD('month', 6, PES.DISCHARGE_DATE))"));
                     return true;
                 }

tests/Strata.SqlTools.SqlBreakdown.Tests/ExpressionTests/ExpressionFactoryFilterTests.cs

@@ -6,6 +6,8 @@ namespace Strata.SqlTools.SqlBreakdown.Tests.ExpressionTests;
 public class ExpressionFactoryFilterTests : ExpressionTestsBase
 {
     private static readonly string[] values = new[] { "FY2019", "FY2020", "FY2021", "FY2022" };
+    private static readonly string[] monthListValues = new[] { "01-2020" };
+    private static readonly string[] calendarRange = new[] { "01/01/2019", "01/01/2023" };
 
     private static IEnumerable<TestCaseData> FilterTestCases()
     {
@@ -23,12 +25,12 @@ public class ExpressionFactoryFilterTests : ExpressionTestsBase
         ).SetName("DateListFilterFiscalYear_{m}");
 
         yield return new TestCaseData(
-            new Filter(4, FilterType.List, new[] { "01-2020" }, Array.Empty<FilterCondition>(), DatePart.Month, false, 0, 0),
+            new Filter(4, FilterType.List, monthListValues, Array.Empty<FilterCondition>(), DatePart.Month, false, 0, 0),
             "DEPT.DISCHARGE_DATE >= '2020-01-01' AND DEPT.DISCHARGE_DATE < '2020-02-01'"
         ).SetName("MonthListFilter_{m}");
 
         yield return new TestCaseData(
-            new Filter(4, FilterType.Calendar, new[] { "01/01/2019", "01/01/2023" }, Array.Empty<FilterCondition>(), DatePart.Month, false, 0, 0),
+            new Filter(4, FilterType.Calendar, calendarRange, Array.Empty<FilterCondition>(), DatePart.Month, false, 0, 0),
             "DEPT.DISCHARGE_DATE >= '2019-01-01' AND DEPT.DISCHARGE_DATE < '2023-01-01'"
         ).SetName("CalendarFilter_{m}");
 
@@ -50,7 +52,7 @@ public class ExpressionFactoryFilterTests : ExpressionTestsBase
 
         // Assert
         Assert.That(result, Is.Not.Null);
-        Assert.That(result.Length, Is.GreaterThan(0));
+        Assert.That(result, Is.Not.Empty);
         Assert.That(result, Is.EqualTo(expectedSql));
     }
 }

tests/Strata.SqlTools.SqlBreakdown.Tests/ExpressionTests/GenericColumnExpressionTests.cs

@@ -35,11 +35,9 @@ public class GenericColumnExpressionTests : ExpressionTestsBase
                 Assertions = result =>
                 {
                     var results = (Dictionary<string, string>)result;
-                    Assert.That(results["priceWithTax"], Does.Contain("Price"));
-                    Assert.That(results["priceWithTax"], Does.Contain("1.1"));
-                    Assert.That(results["priceWithFee"], Does.Contain("Price"));
-                    Assert.That(results["priceWithFee"], Does.Contain("10"));
-                    Assert.That(results["revenue"], Does.Contain("Quantity"));
+                    Assert.That(results["priceWithTax"], Does.Contain("Price")); Assert.Multiple(() => { Assert.That(results["priceWithTax"], Does.Contain("1.1"));
+                    Assert.That(results["priceWithFee"], Does.Contain("Price")); }); Assert.Multiple(() => { Assert.That(results["priceWithFee"], Does.Contain("10"));
+                    Assert.That(results["revenue"], Does.Contain("Quantity")); });
                     Assert.That(results["revenue"], Does.Contain("Price"));
                     return true;
                 }
@@ -67,9 +65,8 @@ public class GenericColumnExpressionTests : ExpressionTestsBase
                 Assertions = result =>
                 {
                     var results = (Dictionary<string, string>)result;
-                    Assert.That(results["priceCondition"], Does.Contain("Price"));
-                    Assert.That(results["priceCondition"], Does.Contain("100"));
-                    Assert.That(results["categoryCondition"], Does.Contain("Category"));
+                    Assert.That(results["priceCondition"], Does.Contain("Price")); Assert.Multiple(() => { Assert.That(results["priceCondition"], Does.Contain("100"));
+                    Assert.That(results["categoryCondition"], Does.Contain("Category")); });
                     Assert.That(results["categoryCondition"], Does.Contain("Electronics"));
                     return true;
                 }
@@ -151,9 +148,8 @@ public class GenericColumnExpressionTests : ExpressionTestsBase
                 },
                 Assertions = result =>
                 {
-                    var results = (Dictionary<string, string>)result;
-                    Assert.That(results["customerResult"], Does.Contain("CustomerID"));
-                    Assert.That(results["orderResult"], Does.Contain("OrderDate"));
+                    var results = (Dictionary<string, string>)result; Assert.Multiple(() => { Assert.That(results["customerResult"], Does.Contain("CustomerID"));
+                    Assert.That(results["orderResult"], Does.Contain("OrderDate")); });
                     return true;
                 }
             },
@@ -182,9 +178,8 @@ public class GenericColumnExpressionTests : ExpressionTestsBase
                 Assertions = result =>
                 {
                     var results = (Dictionary<string, string>)result;
-                    Assert.That(results["lowerBound"], Does.Contain("UnitPrice"));
-                    Assert.That(results["lowerBound"], Does.Contain("MinPrice"));
-                    Assert.That(results["upperBound"], Does.Contain("UnitPrice"));
+                    Assert.That(results["lowerBound"], Does.Contain("UnitPrice")); Assert.Multiple(() => { Assert.That(results["lowerBound"], Does.Contain("MinPrice"));
+                    Assert.That(results["upperBound"], Does.Contain("UnitPrice")); });
                     Assert.That(results["upperBound"], Does.Contain("MaxPrice"));
                     return true;
                 }

tests/Strata.SqlTools.SqlBreakdown.Tests/Extensions/QueryBreakdownExtensionsTests.cs

@@ -17,9 +17,12 @@ public class QueryBreakdownExtensionsTests
         // Act
         var result = query.Select("id, name");
 
-        // Assert
-        Assert.That(result, Is.SameAs(query));
-        Assert.That(query.SelectClause.Clause, Is.EqualTo("id, name"));
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(result, Is.SameAs(query));
+            Assert.That(query.SelectClause.Clause, Is.EqualTo("id, name"));
+        });
     }
 
     [Test]
@@ -31,9 +34,12 @@ public class QueryBreakdownExtensionsTests
         // Act
         var result = query.From("users");
 
-        // Assert
-        Assert.That(result, Is.SameAs(query));
-        Assert.That(query.FromClause.Clause, Is.EqualTo("users"));
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(result, Is.SameAs(query));
+            Assert.That(query.FromClause.Clause, Is.EqualTo("users"));
+        });
     }
 
     [Test]
@@ -45,9 +51,12 @@ public class QueryBreakdownExtensionsTests
         // Act
         var result = query.Where("active = 1");
 
-        // Assert
-        Assert.That(result, Is.SameAs(query));
-        Assert.That(query.WhereClause.Clause, Is.EqualTo("active = 1"));
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(result, Is.SameAs(query));
+            Assert.That(query.WhereClause.Clause, Is.EqualTo("active = 1"));
+        });
     }
 
     [Test]
@@ -59,9 +68,12 @@ public class QueryBreakdownExtensionsTests
         // Act
         var result = query.GroupBy("department");
 
-        // Assert
-        Assert.That(result, Is.SameAs(query));
-        Assert.That(query.GroupByClause.Clause, Is.EqualTo("department"));
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(result, Is.SameAs(query));
+            Assert.That(query.GroupByClause.Clause, Is.EqualTo("department"));
+        });
     }
 
     [Test]
@@ -73,9 +85,12 @@ public class QueryBreakdownExtensionsTests
         // Act
         var result = query.Having("COUNT(*) > 5");
 
-        // Assert
-        Assert.That(result, Is.SameAs(query));
-        Assert.That(query.HavingClause.Clause, Is.EqualTo("COUNT(*) > 5"));
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(result, Is.SameAs(query));
+            Assert.That(query.HavingClause.Clause, Is.EqualTo("COUNT(*) > 5"));
+        });
     }
 
     [Test]
@@ -87,9 +102,12 @@ public class QueryBreakdownExtensionsTests
         // Act
         var result = query.OrderBy("name ASC");
 
-        // Assert
-        Assert.That(result, Is.SameAs(query));
-        Assert.That(query.OrderByClause.Clause, Is.EqualTo("name ASC"));
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(result, Is.SameAs(query));
+            Assert.That(query.OrderByClause.Clause, Is.EqualTo("name ASC"));
+        });
     }
 
     [Test]
@@ -101,9 +119,12 @@ public class QueryBreakdownExtensionsTests
         // Act
         var result = query.AddWhere("AND age > 18");
 
-        // Assert
-        Assert.That(result, Is.SameAs(query));
-        Assert.That(query.WhereClause.Clause, Does.Contain("active = 1"));
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(result, Is.SameAs(query));
+            Assert.That(query.WhereClause.Clause, Does.Contain("active = 1"));
+        });
         Assert.That(query.WhereClause.Clause, Does.Contain("AND age > 18"));
     }
 
@@ -120,10 +141,13 @@ public class QueryBreakdownExtensionsTests
             .From("users")
             .Where("active = 1");
 
-        // 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.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"));
+        });
     }
 
     [Test]
@@ -138,13 +162,16 @@ public class QueryBreakdownExtensionsTests
             .Having("COUNT(*) > 5")
             .OrderBy("employee_count DESC");
 
-        // Assert
-        Assert.That(query.SelectClause.Clause, Is.EqualTo("department, COUNT(*) as employee_count"));
-        Assert.That(query.FromClause.Clause, Is.EqualTo("employees"));
-        Assert.That(query.WhereClause.Clause, Is.EqualTo("salary > 50000"));
-        Assert.That(query.GroupByClause.Clause, Is.EqualTo("department"));
-        Assert.That(query.HavingClause.Clause, Is.EqualTo("COUNT(*) > 5"));
-        Assert.That(query.OrderByClause.Clause, Is.EqualTo("employee_count DESC"));
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(query.SelectClause.Clause, Is.EqualTo("department, COUNT(*) as employee_count"));
+            Assert.That(query.FromClause.Clause, Is.EqualTo("employees"));
+            Assert.That(query.WhereClause.Clause, Is.EqualTo("salary > 50000"));
+            Assert.That(query.GroupByClause.Clause, Is.EqualTo("department"));
+            Assert.That(query.HavingClause.Clause, Is.EqualTo("COUNT(*) > 5"));
+            Assert.That(query.OrderByClause.Clause, Is.EqualTo("employee_count DESC"));
+        });
     }
 
     [Test]
@@ -186,12 +213,18 @@ public class QueryBreakdownExtensionsTests
             .Select("*")
             .From("active_users");
 
-        // Assert
-        Assert.That(query.IsUsingWithClause, Is.True);
-        Assert.That(query.WithClauses.Count, Is.EqualTo(1));
-        Assert.That(query.WithClauses[0].TableName, Is.EqualTo("active_users"));
-        Assert.That(query.SelectClause.Clause, Is.EqualTo("*"));
-        Assert.That(query.FromClause.Clause, Is.EqualTo("active_users"));
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(query.IsUsingWithClause, Is.True);
+            Assert.That(query.WithClauses, Has.Count.EqualTo(1));
+        });
+        Assert.Multiple(() =>
+        {
+            Assert.That(query.WithClauses[0].TableName, Is.EqualTo("active_users"));
+            Assert.That(query.SelectClause.Clause, Is.EqualTo("*"));
+            Assert.That(query.FromClause.Clause, Is.EqualTo("active_users"));
+        });
     }
 
     [Test]
@@ -236,11 +269,17 @@ public class QueryBreakdownExtensionsTests
             .From("active_users u LEFT JOIN recent_orders o ON u.id = o.user_id")
             .GroupBy("u.id, u.name");
 
-        // Assert
-        Assert.That(query.IsUsingWithClause, Is.True);
-        Assert.That(query.WithClauses.Count, Is.EqualTo(2));
-        Assert.That(query.WithClauses[0].TableName, Is.EqualTo("active_users"));
-        Assert.That(query.WithClauses[1].TableName, Is.EqualTo("recent_orders"));
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(query.IsUsingWithClause, Is.True);
+            Assert.That(query.WithClauses, Has.Count.EqualTo(2));
+        });
+        Assert.Multiple(() =>
+        {
+            Assert.That(query.WithClauses[0].TableName, Is.EqualTo("active_users"));
+            Assert.That(query.WithClauses[1].TableName, Is.EqualTo("recent_orders"));
+        });
     }
 
     private static readonly string[] columns = new[] { "id", "name", "email" };
@@ -259,10 +298,13 @@ public class QueryBreakdownExtensionsTests
 
         var sql = query.GetSql();
 
-        // Assert
-        Assert.That(query.IsUsingWithClause, Is.True);
-        Assert.That(query.WithClauses.Count, Is.EqualTo(1));
-        Assert.That(sql, Does.Contain("active_users (id, name, email)"));
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(query.IsUsingWithClause, Is.True);
+            Assert.That(query.WithClauses, Has.Count.EqualTo(1));
+            Assert.That(sql, Does.Contain("active_users (id, name, email)"));
+        });
     }
 
     [Test]
@@ -280,9 +322,12 @@ public class QueryBreakdownExtensionsTests
             .Select("*")
             .From("active_users");
 
-        // Assert
-        Assert.That(query.IsUsingWithClause, Is.True);
-        Assert.That(query.WithClauses.Count, Is.EqualTo(1));
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(query.IsUsingWithClause, Is.True);
+            Assert.That(query.WithClauses, Has.Count.EqualTo(1));
+        });
         Assert.That(query.WithClauses[0].TableName, Is.EqualTo("active_users"));
     }
 
@@ -331,8 +376,11 @@ public class QueryBreakdownExtensionsTests
         // Assert
         Assert.That(sql, Does.Contain("WITH"));
         Assert.That(sql, Does.Contain("monthly_sales AS"));
-        Assert.That(sql, Does.Contain("LAG(total_sales)"));
-        Assert.That(query.IsUsingWithClause, Is.True);
+        Assert.Multiple(() =>
+        {
+            Assert.That(sql, Does.Contain("LAG(total_sales)"));
+            Assert.That(query.IsUsingWithClause, Is.True);
+        });
     }
 
     [Test]
@@ -355,9 +403,12 @@ public class QueryBreakdownExtensionsTests
 
         var sql = query.GetSql();
 
-        // Assert
-        Assert.That(query.WithClauses.Count, Is.EqualTo(2));
-        Assert.That(sql, Does.Contain("active_users AS"));
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(query.WithClauses, Has.Count.EqualTo(2));
+            Assert.That(sql, Does.Contain("active_users AS"));
+        });
         Assert.That(sql, Does.Contain("user_orders AS"));
         Assert.That(sql, Does.Contain("customer_tier"));
     }
@@ -467,9 +518,12 @@ public class QueryBreakdownExtensionsTests
         // Act - Overwrite clauses
         query.Select("id, name").Where("active = 0");
 
-        // Assert
-        Assert.That(query.SelectClause.Clause, Is.EqualTo("id, name"));
-        Assert.That(query.WhereClause.Clause, Is.EqualTo("active = 0"));
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(query.SelectClause.Clause, Is.EqualTo("id, name"));
+            Assert.That(query.WhereClause.Clause, Is.EqualTo("active = 0"));
+        });
     }
 
     [Test]
@@ -481,10 +535,13 @@ public class QueryBreakdownExtensionsTests
             .From("")
             .Where("");
 
-        // Assert
-        Assert.That(query.SelectClause.Clause, Is.EqualTo(""));
-        Assert.That(query.FromClause.Clause, Is.EqualTo(""));
-        Assert.That(query.WhereClause.Clause, Is.EqualTo(""));
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(query.SelectClause.Clause, Is.EqualTo(""));
+            Assert.That(query.FromClause.Clause, Is.EqualTo(""));
+            Assert.That(query.WhereClause.Clause, Is.EqualTo(""));
+        });
     }
 
     [Test]
@@ -495,9 +552,12 @@ public class QueryBreakdownExtensionsTests
             .Select("  id,  name  ")
             .From("  users  ");
 
-        // Assert
-        Assert.That(query.SelectClause.Clause, Is.EqualTo("  id,  name  "));
-        Assert.That(query.FromClause.Clause, Is.EqualTo("  users  "));
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(query.SelectClause.Clause, Is.EqualTo("  id,  name  "));
+            Assert.That(query.FromClause.Clause, Is.EqualTo("  users  "));
+        });
     }
 
     #endregion

tests/Strata.SqlTools.SqlBreakdown.Tests/JsonTokenReaderTests.cs

@@ -33,26 +33,35 @@ public class JsonTokenReaderTests
 
         // Validate JSON starts with StartObject and ends with EndObject
         Assert.That(tokens.Count, Is.GreaterThan(2));
-        Assert.That(tokens[0].Type, Is.EqualTo(JsonTokenType.StartObject));
-        Assert.That(tokens[^1].Type, Is.EqualTo(JsonTokenType.EndObject));
-        Assert.That(tokens.Count(t => t.Type == JsonTokenType.PropertyName && t.Value == "foo"), Is.EqualTo(1));
-        Assert.That(tokens.Count(t => t.Type == JsonTokenType.String && t.Value == "bar"), Is.EqualTo(1));
-        Assert.That(tokens.Count(t => t.Type == JsonTokenType.PropertyName && t.Value == "myList"), Is.EqualTo(1));
-        Assert.That(tokens.Count(t => t.Type == JsonTokenType.StartArray), Is.EqualTo(1));
-        Assert.That(tokens.Count(t => t.Type == JsonTokenType.PropertyName && t.Value == "another"), Is.EqualTo(1));
-        Assert.That(tokens.Count(t => t.Type == JsonTokenType.Number && t.Value == "12"), Is.EqualTo(1));
+        Assert.Multiple(() =>
+        {
+            Assert.That(tokens[0].Type, Is.EqualTo(JsonTokenType.StartObject));
+            Assert.That(tokens[^1].Type, Is.EqualTo(JsonTokenType.EndObject));
+            Assert.That(tokens.Count(t => t.Type == JsonTokenType.PropertyName && t.Value == "foo"), Is.EqualTo(1));
+            Assert.That(tokens.Count(t => t.Type == JsonTokenType.String && t.Value == "bar"), Is.EqualTo(1));
+            Assert.That(tokens.Count(t => t.Type == JsonTokenType.PropertyName && t.Value == "myList"), Is.EqualTo(1));
+            Assert.That(tokens.Count(t => t.Type == JsonTokenType.StartArray), Is.EqualTo(1));
+            Assert.That(tokens.Count(t => t.Type == JsonTokenType.PropertyName && t.Value == "another"), Is.EqualTo(1));
+            Assert.That(tokens.Count(t => t.Type == JsonTokenType.Number && t.Value == "12"), Is.EqualTo(1));
+        });
 
         // Deep validation of JSON content structure
         var tokenIndex = 4;
 
-        // Token 4: [
-        Assert.That(tokens[tokenIndex++].Type, Is.EqualTo(JsonTokenType.StartArray));
+        Assert.Multiple(() =>
+        {
+            // Token 4: [
+            Assert.That(tokens[tokenIndex++].Type, Is.EqualTo(JsonTokenType.StartArray));
 
-        // Token 5-8: Array elements [1,2,3,4]
-        Assert.That(tokens[tokenIndex].Type, Is.EqualTo(JsonTokenType.Number));
-        Assert.That(tokens[tokenIndex++].Value, Is.EqualTo("1"));
-        Assert.That(tokens[tokenIndex].Type, Is.EqualTo(JsonTokenType.Number));
-        Assert.That(tokens[tokenIndex++].Value, Is.EqualTo("2"));
+            // Token 5-8: Array elements [1,2,3,4]
+            Assert.That(tokens[tokenIndex].Type, Is.EqualTo(JsonTokenType.Number));
+            Assert.That(tokens[tokenIndex++].Value, Is.EqualTo("1"));
+        });
+        Assert.Multiple(() =>
+        {
+            Assert.That(tokens[tokenIndex].Type, Is.EqualTo(JsonTokenType.Number));
+            Assert.That(tokens[tokenIndex++].Value, Is.EqualTo("2"));
+        });
         Assert.That(tokens[tokenIndex].Type, Is.EqualTo(JsonTokenType.Number));
         Assert.That(tokens[tokenIndex++].Value, Is.EqualTo("3"));
         Assert.That(tokens[tokenIndex].Type, Is.EqualTo(JsonTokenType.Number));

tests/Strata.SqlTools.SqlBreakdown.Tests/SqlBreakdownCollectionTests/SqlBreakdownCollectionCoreTests.cs

@@ -16,10 +16,13 @@ public class SqlBreakdownCollectionCoreTests : SqlBreakdownCollectionTestBase
         var collection = new SqlBreakdownCollection();
 
         // Assert
-        Assert.That(collection.Count, Is.EqualTo(0));
-        Assert.That(collection.IsEmpty, Is.True);
-        Assert.That(collection.Breakdowns, Is.Empty);
-        Assert.That(collection.RawStatements, Is.Empty);
+        Assert.That(collection, Is.Empty);
+        Assert.Multiple(() =>
+        {
+            Assert.That(collection.IsEmpty, Is.True);
+            Assert.That(collection.Breakdowns, Is.Empty);
+            Assert.That(collection.RawStatements, Is.Empty);
+        });
     }
 
     [Test]
@@ -36,7 +39,7 @@ public class SqlBreakdownCollectionCoreTests : SqlBreakdownCollectionTestBase
         var collection = new SqlBreakdownCollection(mockBreakdowns);
 
         // Assert
-        Assert.That(collection.Count, Is.EqualTo(2));
+        Assert.That(collection, Has.Count.EqualTo(2));
         Assert.That(collection.IsEmpty, Is.False);
     }
 
@@ -51,7 +54,7 @@ public class SqlBreakdownCollectionCoreTests : SqlBreakdownCollectionTestBase
         collection.Add(breakdown);
 
         // Assert
-        Assert.That(collection.Count, Is.EqualTo(1));
+        Assert.That(collection, Has.Count.EqualTo(1));
         Assert.That(collection.GetAt(0), Is.EqualTo(breakdown));
     }
 
@@ -81,7 +84,7 @@ public class SqlBreakdownCollectionCoreTests : SqlBreakdownCollectionTestBase
         collection.AddRange(breakdowns);
 
         // Assert
-        Assert.That(collection.Count, Is.EqualTo(3));
+        Assert.That(collection, Has.Count.EqualTo(3));
     }
 
     [Test]
@@ -104,9 +107,12 @@ public class SqlBreakdownCollectionCoreTests : SqlBreakdownCollectionTestBase
         // Act
         var result = collection.Remove(breakdown);
 
-        // Assert
-        Assert.That(result, Is.True);
-        Assert.That(collection.Count, Is.EqualTo(0));
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(result, Is.True);
+            Assert.That(collection, Is.Empty);
+        });
     }
 
     [Test]
@@ -119,9 +125,12 @@ public class SqlBreakdownCollectionCoreTests : SqlBreakdownCollectionTestBase
         // Act
         var result = collection.Remove(otherBreakdown);
 
-        // Assert
-        Assert.That(result, Is.False);
-        Assert.That(collection.Count, Is.EqualTo(1));
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(result, Is.False);
+            Assert.That(collection, Has.Count.EqualTo(1));
+        });
     }
 
     [Test]
@@ -138,7 +147,7 @@ public class SqlBreakdownCollectionCoreTests : SqlBreakdownCollectionTestBase
         collection.Clear();
 
         // Assert
-        Assert.That(collection.Count, Is.EqualTo(0));
+        Assert.That(collection, Is.Empty);
         Assert.That(collection.IsEmpty, Is.True);
     }
 
@@ -159,10 +168,13 @@ public class SqlBreakdownCollectionCoreTests : SqlBreakdownCollectionTestBase
         collection.ParseBatch(batchSql);
 
         // Assert
-        Assert.That(collection.RawStatements.Count, Is.EqualTo(3));
-        Assert.That(collection.RawStatements[0], Does.Contain("Table1"));
-        Assert.That(collection.RawStatements[1], Does.Contain("Table2"));
-        Assert.That(collection.RawStatements[2], Does.Contain("Table3"));
+        Assert.That(collection.RawStatements, Has.Count.EqualTo(3));
+        Assert.Multiple(() =>
+        {
+            Assert.That(collection.RawStatements[0], Does.Contain("Table1"));
+            Assert.That(collection.RawStatements[1], Does.Contain("Table2"));
+            Assert.That(collection.RawStatements[2], Does.Contain("Table3"));
+        });
     }
 
     [Test]
@@ -182,7 +194,7 @@ public class SqlBreakdownCollectionCoreTests : SqlBreakdownCollectionTestBase
         collection.ParseBatch(batchSql);
 
         // Assert
-        Assert.That(collection.RawStatements.Count, Is.EqualTo(3));
+        Assert.That(collection.RawStatements, Has.Count.EqualTo(3));
     }
 
     [Test]
@@ -202,7 +214,7 @@ public class SqlBreakdownCollectionCoreTests : SqlBreakdownCollectionTestBase
         collection.ParseBatch(batchSql);
 
         // Assert
-        Assert.That(collection.RawStatements.Count, Is.EqualTo(3));
+        Assert.That(collection.RawStatements, Has.Count.EqualTo(3));
     }
 
     [Test]
@@ -222,9 +234,12 @@ public class SqlBreakdownCollectionCoreTests : SqlBreakdownCollectionTestBase
         collection.ParseBatch(batchSql);
 
         // Assert
-        Assert.That(collection.RawStatements.Count, Is.EqualTo(2));
-        Assert.That(collection.RawStatements[0], Does.Contain("Table1"));
-        Assert.That(collection.RawStatements[1], Does.Contain("Table2"));
+        Assert.That(collection.RawStatements, Has.Count.EqualTo(2));
+        Assert.Multiple(() =>
+        {
+            Assert.That(collection.RawStatements[0], Does.Contain("Table1"));
+            Assert.That(collection.RawStatements[1], Does.Contain("Table2"));
+        });
     }
 
     [Test]
@@ -338,7 +353,7 @@ public class SqlBreakdownCollectionCoreTests : SqlBreakdownCollectionTestBase
         var filtered = collection.Where(b => b.ToString()!.Contains("Table2")).ToList();
 
         // Assert
-        Assert.That(filtered.Count, Is.EqualTo(1));
+        Assert.That(filtered, Has.Count.EqualTo(1));
         Assert.That(filtered[0].ToString()!, Does.Contain("Table2"));
     }
 
@@ -357,7 +372,7 @@ public class SqlBreakdownCollectionCoreTests : SqlBreakdownCollectionTestBase
         var projected = collection.Select(b => b.ToString()!.Length).ToList();
 
         // Assert
-        Assert.That(projected.Count, Is.EqualTo(2));
+        Assert.That(projected, Has.Count.EqualTo(2));
         Assert.That(projected[0], Is.GreaterThan(0));
     }
 

tests/Strata.SqlTools.SqlBreakdown.Tests/SqlBreakdownCollectionTests/SqlBreakdownCollectionCreateTests.cs

@@ -31,9 +31,12 @@ public class SqlBreakdownCollectionCreateTests : SqlBreakdownCollectionTestBase
         collection.ParseBatch(batchSql);
 
         // Assert
-        Assert.That(collection.Count, Is.EqualTo(2));
-        Assert.That(collection.GetRawStatementAt(0), Does.Contain("CREATE TABLE Users"));
-        Assert.That(collection.GetRawStatementAt(1), Does.Contain("CREATE TABLE Orders"));
+        Assert.That(collection, Has.Count.EqualTo(2));
+        Assert.Multiple(() =>
+        {
+            Assert.That(collection.GetRawStatementAt(0), Does.Contain("CREATE TABLE Users"));
+            Assert.That(collection.GetRawStatementAt(1), Does.Contain("CREATE TABLE Orders"));
+        });
     }
 
     [Test]
@@ -51,9 +54,12 @@ public class SqlBreakdownCollectionCreateTests : SqlBreakdownCollectionTestBase
         collection.ParseBatch(batchSql);
 
         // Assert
-        Assert.That(collection.Count, Is.EqualTo(2));
-        Assert.That(collection.GetRawStatementAt(0), Does.Contain("CREATE INDEX"));
-        Assert.That(collection.GetRawStatementAt(1), Does.Contain("UNIQUE"));
+        Assert.That(collection, Has.Count.EqualTo(2));
+        Assert.Multiple(() =>
+        {
+            Assert.That(collection.GetRawStatementAt(0), Does.Contain("CREATE INDEX"));
+            Assert.That(collection.GetRawStatementAt(1), Does.Contain("UNIQUE"));
+        });
     }
 
     [Test]
@@ -74,7 +80,7 @@ public class SqlBreakdownCollectionCreateTests : SqlBreakdownCollectionTestBase
         collection.ParseBatch(batchSql);
 
         // Assert
-        Assert.That(collection.Count, Is.GreaterThanOrEqualTo(1));
+        Assert.That(collection, Is.Not.Empty);
         Assert.That(collection.GetRawStatementAt(0), Does.Contain("CREATE PROCEDURE"));
     }
 }

tests/Strata.SqlTools.SqlBreakdown.Tests/SqlBreakdownCollectionTests/SqlBreakdownCollectionDeleteTests.cs

@@ -25,10 +25,13 @@ public class SqlBreakdownCollectionDeleteTests : SqlBreakdownCollectionTestBase
         collection.ParseBatch(batchSql);
 
         // Assert
-        Assert.That(collection.Count, Is.EqualTo(3));
-        Assert.That(collection.GetRawStatementAt(0), Does.Contain("DELETE FROM Orders"));
-        Assert.That(collection.GetRawStatementAt(1), Does.Contain("NOT IN"));
-        Assert.That(collection.GetRawStatementAt(2), Does.Contain("DATEADD"));
+        Assert.That(collection, Has.Count.EqualTo(3));
+        Assert.Multiple(() =>
+        {
+            Assert.That(collection.GetRawStatementAt(0), Does.Contain("DELETE FROM Orders"));
+            Assert.That(collection.GetRawStatementAt(1), Does.Contain("NOT IN"));
+            Assert.That(collection.GetRawStatementAt(2), Does.Contain("DATEADD"));
+        });
     }
 
     [Test]
@@ -48,7 +51,7 @@ public class SqlBreakdownCollectionDeleteTests : SqlBreakdownCollectionTestBase
         collection.ParseBatch(batchSql);
 
         // Assert
-        Assert.That(collection.Count, Is.EqualTo(2));
+        Assert.That(collection, Has.Count.EqualTo(2));
         Assert.That(collection.GetRawStatementAt(0), Does.Contain("EXISTS"));
     }
 
@@ -68,7 +71,7 @@ public class SqlBreakdownCollectionDeleteTests : SqlBreakdownCollectionTestBase
         collection.ParseBatch(batchSql);
 
         // Assert
-        Assert.That(collection.Count, Is.GreaterThanOrEqualTo(1));
+        Assert.That(collection, Is.Not.Empty);
         Assert.That(collection.GetRawStatementAt(0), Does.Contain("DELETE Orders"));
         Assert.That(collection.GetRawStatementAt(0), Does.Contain("INNER JOIN"));
     }

tests/Strata.SqlTools.SqlBreakdown.Tests/SqlBreakdownCollectionTests/SqlBreakdownCollectionDropTests.cs

@@ -25,9 +25,12 @@ public class SqlBreakdownCollectionDropTests : SqlBreakdownCollectionTestBase
         collection.ParseBatch(batchSql);
 
         // Assert
-        Assert.That(collection.Count, Is.EqualTo(3));
-        Assert.That(collection.GetRawStatementAt(0), Does.Contain("DROP TABLE"));
-        Assert.That(collection.GetRawStatementAt(1), Does.Contain("DROP TABLE"));
+        Assert.That(collection, Has.Count.EqualTo(3));
+        Assert.Multiple(() =>
+        {
+            Assert.That(collection.GetRawStatementAt(0), Does.Contain("DROP TABLE"));
+            Assert.That(collection.GetRawStatementAt(1), Does.Contain("DROP TABLE"));
+        });
     }
 
     [Test]
@@ -47,9 +50,12 @@ public class SqlBreakdownCollectionDropTests : SqlBreakdownCollectionTestBase
         collection.ParseBatch(batchSql);
 
         // Assert
-        Assert.That(collection.Count, Is.EqualTo(3));
-        Assert.That(collection.GetRawStatementAt(0), Does.Contain("DROP INDEX"));
-        Assert.That(collection.GetRawStatementAt(1), Does.Contain("PROCEDURE"));
-        Assert.That(collection.GetRawStatementAt(2), Does.Contain("VIEW"));
+        Assert.That(collection, Has.Count.EqualTo(3));
+        Assert.Multiple(() =>
+        {
+            Assert.That(collection.GetRawStatementAt(0), Does.Contain("DROP INDEX"));
+            Assert.That(collection.GetRawStatementAt(1), Does.Contain("PROCEDURE"));
+            Assert.That(collection.GetRawStatementAt(2), Does.Contain("VIEW"));
+        });
     }
 }

tests/Strata.SqlTools.SqlBreakdown.Tests/SqlBreakdownCollectionTests/SqlBreakdownCollectionInsertTests.cs

@@ -25,10 +25,13 @@ public class SqlBreakdownCollectionInsertTests : SqlBreakdownCollectionTestBase
         collection.ParseBatch(batchSql);
 
         // Assert
-        Assert.That(collection.Count, Is.EqualTo(3));
-        Assert.That(collection.GetRawStatementAt(0), Does.Contain("INSERT INTO Users"));
-        Assert.That(collection.GetRawStatementAt(1), Does.Contain("Jane Smith"));
-        Assert.That(collection.GetRawStatementAt(2), Does.Contain("Bob Johnson"));
+        Assert.That(collection, Has.Count.EqualTo(3));
+        Assert.Multiple(() =>
+        {
+            Assert.That(collection.GetRawStatementAt(0), Does.Contain("INSERT INTO Users"));
+            Assert.That(collection.GetRawStatementAt(1), Does.Contain("Jane Smith"));
+            Assert.That(collection.GetRawStatementAt(2), Does.Contain("Bob Johnson"));
+        });
     }
 
     [Test]
@@ -48,7 +51,7 @@ public class SqlBreakdownCollectionInsertTests : SqlBreakdownCollectionTestBase
         collection.ParseBatch(batchSql);
 
         // Assert
-        Assert.That(collection.Count, Is.EqualTo(2));
+        Assert.That(collection, Has.Count.EqualTo(2));
         Assert.That(collection.GetRawStatementAt(0), Does.Contain("INSERT INTO UsersArchive"));
         Assert.That(collection.GetRawStatementAt(0), Does.Contain("SELECT"));
     }
@@ -70,7 +73,7 @@ public class SqlBreakdownCollectionInsertTests : SqlBreakdownCollectionTestBase
         collection.ParseBatch(batchSql);
 
         // Assert
-        Assert.That(collection.Count, Is.EqualTo(2));
+        Assert.That(collection, Has.Count.EqualTo(2));
         Assert.That(collection.GetRawStatementAt(0), Does.Contain("BULK INSERT"));
     }
 }

tests/Strata.SqlTools.SqlBreakdown.Tests/SqlBreakdownCollectionTests/SqlBreakdownCollectionMixedCrudTests.cs

@@ -37,13 +37,16 @@ public class SqlBreakdownCollectionMixedCrudTests : SqlBreakdownCollectionTestBa
         collection.ParseBatch(batchSql);
 
         // Assert
-        Assert.That(collection.Count, Is.EqualTo(7));
-        Assert.That(collection.GetRawStatementAt(0), Does.Contain("CREATE TABLE"));
-        Assert.That(collection.GetRawStatementAt(1), Does.Contain("INSERT"));
-        Assert.That(collection.GetRawStatementAt(3), Does.Contain("SELECT"));
-        Assert.That(collection.GetRawStatementAt(4), Does.Contain("UPDATE"));
-        Assert.That(collection.GetRawStatementAt(5), Does.Contain("DELETE"));
-        Assert.That(collection.GetRawStatementAt(6), Does.Contain("DROP"));
+        Assert.That(collection, Has.Count.EqualTo(7));
+        Assert.Multiple(() =>
+        {
+            Assert.That(collection.GetRawStatementAt(0), Does.Contain("CREATE TABLE"));
+            Assert.That(collection.GetRawStatementAt(1), Does.Contain("INSERT"));
+            Assert.That(collection.GetRawStatementAt(3), Does.Contain("SELECT"));
+            Assert.That(collection.GetRawStatementAt(4), Does.Contain("UPDATE"));
+            Assert.That(collection.GetRawStatementAt(5), Does.Contain("DELETE"));
+            Assert.That(collection.GetRawStatementAt(6), Does.Contain("DROP"));
+        });
     }
 
     [Test]
@@ -81,8 +84,8 @@ public class SqlBreakdownCollectionMixedCrudTests : SqlBreakdownCollectionTestBa
         collection.ParseBatch(batchSql);
 
         // Assert
-        Assert.That(collection.Count, Is.EqualTo(5));
-        Assert.That(collection.RawStatements.Count, Is.EqualTo(5));
+        Assert.That(collection, Has.Count.EqualTo(5));
+        Assert.That(collection.RawStatements, Has.Count.EqualTo(5));
         foreach (var statement in collection.RawStatements)
         {
             Assert.That(statement, Is.Not.Empty);

tests/Strata.SqlTools.SqlBreakdown.Tests/SqlBreakdownCollectionTests/SqlBreakdownCollectionParameterTests.cs

@@ -23,7 +23,7 @@ public class SqlBreakdownCollectionParameterTests : SqlBreakdownCollectionTestBa
         collection.ParseBatch(batchSql);
 
         // Assert
-        Assert.That(collection.Count, Is.EqualTo(2));
+        Assert.That(collection, Has.Count.EqualTo(2));
         Assert.That(collection.GetRawStatementAt(0), Does.Contain("@UserId"));
         Assert.That(collection.GetRawStatementAt(0), Does.Contain("@UserEmail"));
     }
@@ -43,9 +43,12 @@ public class SqlBreakdownCollectionParameterTests : SqlBreakdownCollectionTestBa
         collection.ParseBatch(batchSql);
 
         // Assert
-        Assert.That(collection.Count, Is.EqualTo(2));
-        Assert.That(collection.GetRawStatementAt(0), Does.Contain("@Name"));
-        Assert.That(collection.GetRawStatementAt(1), Does.Contain("@Status"));
+        Assert.That(collection, Has.Count.EqualTo(2));
+        Assert.Multiple(() =>
+        {
+            Assert.That(collection.GetRawStatementAt(0), Does.Contain("@Name"));
+            Assert.That(collection.GetRawStatementAt(1), Does.Contain("@Status"));
+        });
     }
 
     [Test]

tests/Strata.SqlTools.SqlBreakdown.Tests/SqlBreakdownCollectionTests/SqlBreakdownCollectionSelectTests.cs

@@ -29,10 +29,13 @@ public class SqlBreakdownCollectionSelectTests : SqlBreakdownCollectionTestBase
         collection.ParseBatch(batchSql);
 
         // Assert
-        Assert.That(collection.Count, Is.EqualTo(2));
+        Assert.That(collection, Has.Count.EqualTo(2));
         Assert.That(collection.GetRawStatementAt(0), Does.Contain("LEFT JOIN"));
-        Assert.That(collection.GetRawStatementAt(0), Does.Contain("GROUP BY"));
-        Assert.That(collection.GetRawStatementAt(1), Does.Contain("BETWEEN"));
+        Assert.Multiple(() =>
+        {
+            Assert.That(collection.GetRawStatementAt(0), Does.Contain("GROUP BY"));
+            Assert.That(collection.GetRawStatementAt(1), Does.Contain("BETWEEN"));
+        });
     }
 
     [Test]
@@ -55,7 +58,7 @@ public class SqlBreakdownCollectionSelectTests : SqlBreakdownCollectionTestBase
         collection.ParseBatch(batchSql);
 
         // Assert
-        Assert.That(collection.Count, Is.GreaterThanOrEqualTo(1));
+        Assert.That(collection, Is.Not.Empty);
         Assert.That(collection.GetRawStatementAt(0), Does.Contain("WITH UserOrders AS"));
     }
 
@@ -79,8 +82,11 @@ public class SqlBreakdownCollectionSelectTests : SqlBreakdownCollectionTestBase
         collection.ParseBatch(batchSql);
 
         // Assert
-        Assert.That(collection.Count, Is.EqualTo(2));
-        Assert.That(collection.GetRawStatementAt(0), Does.Contain("JOIN"));
-        Assert.That(collection.GetRawStatementAt(1), Does.Contain("IN"));
+        Assert.That(collection, Has.Count.EqualTo(2));
+        Assert.Multiple(() =>
+        {
+            Assert.That(collection.GetRawStatementAt(0), Does.Contain("JOIN"));
+            Assert.That(collection.GetRawStatementAt(1), Does.Contain("IN"));
+        });
     }
 }

tests/Strata.SqlTools.SqlBreakdown.Tests/SqlBreakdownCollectionTests/SqlBreakdownCollectionSeparatorTests.cs

@@ -25,10 +25,13 @@ public class SqlBreakdownCollectionSeparatorTests : SqlBreakdownCollectionTestBa
         collection.ParseBatch(batchSql, ";");
 
         // Assert
-        Assert.That(collection.Count, Is.EqualTo(3));
-        Assert.That(collection.GetRawStatementAt(0), Does.Contain("Users"));
-        Assert.That(collection.GetRawStatementAt(1), Does.Contain("Orders"));
-        Assert.That(collection.GetRawStatementAt(2), Does.Contain("Products"));
+        Assert.That(collection, Has.Count.EqualTo(3));
+        Assert.Multiple(() =>
+        {
+            Assert.That(collection.GetRawStatementAt(0), Does.Contain("Users"));
+            Assert.That(collection.GetRawStatementAt(1), Does.Contain("Orders"));
+            Assert.That(collection.GetRawStatementAt(2), Does.Contain("Products"));
+        });
     }
 
     [Test]
@@ -48,7 +51,7 @@ public class SqlBreakdownCollectionSeparatorTests : SqlBreakdownCollectionTestBa
         collection.ParseBatch(batchSql, "~~~");
 
         // Assert
-        Assert.That(collection.Count, Is.EqualTo(3));
-        Assert.That(collection.RawStatements.Count, Is.EqualTo(3));
+        Assert.That(collection, Has.Count.EqualTo(3));
+        Assert.That(collection.RawStatements, Has.Count.EqualTo(3));
     }
 }

tests/Strata.SqlTools.SqlBreakdown.Tests/SqlBreakdownCollectionTests/SqlBreakdownCollectionTransactionTests.cs

@@ -29,7 +29,7 @@ public class SqlBreakdownCollectionTransactionTests : SqlBreakdownCollectionTest
         collection.ParseBatch(batchSql);
 
         // Assert
-        Assert.That(collection.Count, Is.GreaterThanOrEqualTo(1));
+        Assert.That(collection, Is.Not.Empty);
         var statement = collection.GetRawStatementAt(0);
         Assert.That(statement, Does.Contain("BEGIN TRANSACTION"));
         Assert.That(statement, Does.Contain("COMMIT"));

tests/Strata.SqlTools.SqlBreakdown.Tests/SqlBreakdownCollectionTests/SqlBreakdownCollectionUpdateTests.cs

@@ -25,10 +25,13 @@ public class SqlBreakdownCollectionUpdateTests : SqlBreakdownCollectionTestBase
         collection.ParseBatch(batchSql);
 
         // Assert
-        Assert.That(collection.Count, Is.EqualTo(3));
-        Assert.That(collection.GetRawStatementAt(0), Does.Contain("UPDATE Users"));
-        Assert.That(collection.GetRawStatementAt(1), Does.Contain("Status"));
-        Assert.That(collection.GetRawStatementAt(2), Does.Contain("Price * 1.1"));
+        Assert.That(collection, Has.Count.EqualTo(3));
+        Assert.Multiple(() =>
+        {
+            Assert.That(collection.GetRawStatementAt(0), Does.Contain("UPDATE Users"));
+            Assert.That(collection.GetRawStatementAt(1), Does.Contain("Status"));
+            Assert.That(collection.GetRawStatementAt(2), Does.Contain("Price * 1.1"));
+        });
     }
 
     [Test]
@@ -52,9 +55,12 @@ public class SqlBreakdownCollectionUpdateTests : SqlBreakdownCollectionTestBase
         collection.ParseBatch(batchSql);
 
         // Assert
-        Assert.That(collection.Count, Is.EqualTo(2));
-        Assert.That(collection.GetRawStatementAt(0), Does.Contain("UPDATE u"));
-        Assert.That(collection.GetRawStatementAt(1), Does.Contain("Quantity - 1"));
+        Assert.That(collection, Has.Count.EqualTo(2));
+        Assert.Multiple(() =>
+        {
+            Assert.That(collection.GetRawStatementAt(0), Does.Contain("UPDATE u"));
+            Assert.That(collection.GetRawStatementAt(1), Does.Contain("Quantity - 1"));
+        });
     }
 
     [Test]
@@ -74,7 +80,7 @@ public class SqlBreakdownCollectionUpdateTests : SqlBreakdownCollectionTestBase
         collection.ParseBatch(batchSql);
 
         // Assert
-        Assert.That(collection.Count, Is.GreaterThanOrEqualTo(1));
+        Assert.That(collection, Is.Not.Empty);
         Assert.That(collection.GetRawStatementAt(0), Does.Contain("UPDATE Orders"));
         Assert.That(collection.GetRawStatementAt(0), Does.Contain("JOIN"));
     }

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

@@ -17,7 +17,7 @@ public class QueryBreakdownCollectionTests
     public void Constructor_Empty_CreatesEmptyCollection()
     {
         // Act & Assert
-        Assert.That(_collection.Count, Is.EqualTo(0));
+        Assert.That(_collection, Is.Empty);
         Assert.That(_collection.QueryBreakdowns, Is.Empty);
     }
 
@@ -35,8 +35,8 @@ public class QueryBreakdownCollectionTests
         var collection = new QueryBreakdownCollection(queries);
 
         // Assert
-        Assert.That(collection.Count, Is.EqualTo(2));
-        Assert.That(collection.QueryBreakdowns.Count, Is.EqualTo(2));
+        Assert.That(collection, Has.Count.EqualTo(2));
+        Assert.That(collection.QueryBreakdowns, Has.Count.EqualTo(2));
     }
 
     [Test]
@@ -49,7 +49,7 @@ public class QueryBreakdownCollectionTests
         _collection.Add(query);
 
         // Assert
-        Assert.That(_collection.Count, Is.EqualTo(1));
+        Assert.That(_collection, Has.Count.EqualTo(1));
         Assert.That(_collection.QueryBreakdowns[0], Is.EqualTo(query));
     }
 
@@ -74,7 +74,7 @@ public class QueryBreakdownCollectionTests
         _collection.AddRange(queries);
 
         // Assert
-        Assert.That(_collection.Count, Is.EqualTo(2));
+        Assert.That(_collection, Has.Count.EqualTo(2));
     }
 
     [Test]
@@ -87,9 +87,12 @@ public class QueryBreakdownCollectionTests
         // Act
         var removed = _collection.Remove(query);
 
-        // Assert
-        Assert.That(removed, Is.True);
-        Assert.That(_collection.Count, Is.EqualTo(0));
+        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.Count, Is.EqualTo(1));
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(removed, Is.False);
+            Assert.That(_collection, Has.Count.EqualTo(1));
+        });
     }
 
     [Test]
@@ -119,7 +125,7 @@ public class QueryBreakdownCollectionTests
         _collection.Clear();
 
         // Assert
-        Assert.That(_collection.Count, Is.EqualTo(0));
+        Assert.That(_collection, Is.Empty);
     }
 
     [Test]
@@ -164,7 +170,7 @@ public class QueryBreakdownCollectionTests
         var results = _collection.WhereSelectContains("Email").ToList();
 
         // Assert
-        Assert.That(results.Count, Is.EqualTo(1));
+        Assert.That(results, Has.Count.EqualTo(1));
         Assert.That(results[0], Is.EqualTo(query1));
     }
 
@@ -179,7 +185,7 @@ public class QueryBreakdownCollectionTests
         var results = _collection.WhereSelectContains("email").ToList();
 
         // Assert
-        Assert.That(results.Count, Is.EqualTo(1));
+        Assert.That(results, Has.Count.EqualTo(1));
     }
 
     [Test]
@@ -195,7 +201,7 @@ public class QueryBreakdownCollectionTests
         var results = _collection.WhereTableContains("Users").ToList();
 
         // Assert
-        Assert.That(results.Count, Is.EqualTo(1));
+        Assert.That(results, Has.Count.EqualTo(1));
         Assert.That(results[0], Is.EqualTo(query1));
     }
 
@@ -212,7 +218,7 @@ public class QueryBreakdownCollectionTests
         var results = _collection.WhereHaveWhereClause().ToList();
 
         // Assert
-        Assert.That(results.Count, Is.EqualTo(1));
+        Assert.That(results, Has.Count.EqualTo(1));
         Assert.That(results[0], Is.EqualTo(query1));
     }
 
@@ -229,7 +235,7 @@ public class QueryBreakdownCollectionTests
         var results = _collection.WhereHaveNoWhereClause().ToList();
 
         // Assert
-        Assert.That(results.Count, Is.EqualTo(1));
+        Assert.That(results, Has.Count.EqualTo(1));
         Assert.That(results[0], Is.EqualTo(query2));
     }
 
@@ -259,7 +265,7 @@ public class QueryBreakdownCollectionTests
         var tables = _collection.GetUniqueTableReferences().ToList();
 
         // Assert
-        Assert.That(tables.Count, Is.EqualTo(2));
+        Assert.That(tables, Has.Count.EqualTo(2));
         Assert.That(tables, Does.Contain("Users"));
         Assert.That(tables, Does.Contain("Orders"));
     }
@@ -275,9 +281,12 @@ public class QueryBreakdownCollectionTests
         var summaries = _collection.GetQuerySummaries().ToList();
 
         // Assert
-        Assert.That(summaries.Count, Is.EqualTo(2));
-        Assert.That(summaries[0].HasSelectClause, Is.True);
-        Assert.That(summaries[1].HasWhereClause, Is.True);
+        Assert.That(summaries, Has.Count.EqualTo(2));
+        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]
@@ -348,7 +360,7 @@ public class QueryBreakdownCollectionTests
         var report = _collection.GetParameterUsageReport().ToList();
 
         // Assert
-        Assert.That(report.Count, Is.GreaterThan(0));
+        Assert.That(report, Is.Not.Empty);
         var userIdReport = report.FirstOrDefault(r => r.ParameterName == "UserId");
         Assert.That(userIdReport, Is.Not.Null);
         Assert.That(userIdReport?.UsedInQueryCount, Is.EqualTo(2));

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

@@ -16,19 +16,25 @@ 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.That(query.WithClauses.Count, Is.EqualTo(0));
-        Assert.That(query.Parameters, Is.Not.Null);
-        Assert.That(query.ParameterList, 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.Multiple(() =>
+        {
+            Assert.That(query.WithClauses, Is.Empty);
+            Assert.That(query.Parameters, Is.Not.Null);
+            Assert.That(query.ParameterList, Is.Not.Null);
+        });
     }
 
     [Test]
@@ -41,10 +47,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 +67,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 +89,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 +162,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]
@@ -208,9 +226,12 @@ public class QueryBreakdownTests
         var merged = query.GetMergedParameters();
 
         // Assert
-        Assert.That(merged.Count, Is.EqualTo(2));
-        Assert.That(merged["@UserId"], Is.EqualTo(123));
-        Assert.That(merged["@ActiveStatus"], Is.EqualTo(true));
+        Assert.That(merged, Has.Count.EqualTo(2));
+        Assert.Multiple(() =>
+        {
+            Assert.That(merged["@UserId"], Is.EqualTo(123));
+            Assert.That(merged["@ActiveStatus"], Is.EqualTo(true));
+        });
     }
 
     [Test]
@@ -228,9 +249,12 @@ public class QueryBreakdownTests
         var merged = mainQuery.GetMergedParameters();
 
         // Assert
-        Assert.That(merged.Count, Is.EqualTo(2));
-        Assert.That(merged["@MinDate"], Is.EqualTo(DateTime.Today.AddDays(-30)));
-        Assert.That(merged["@Limit"], Is.EqualTo(100));
+        Assert.That(merged, Has.Count.EqualTo(2));
+        Assert.Multiple(() =>
+        {
+            Assert.That(merged["@MinDate"], Is.EqualTo(DateTime.Today.AddDays(-30)));
+            Assert.That(merged["@Limit"], Is.EqualTo(100));
+        });
     }
 
     [Test]
@@ -252,10 +276,13 @@ public class QueryBreakdownTests
         var merged = mainQuery.GetMergedParameters();
 
         // Assert
-        Assert.That(merged.Count, Is.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.That(merged, Has.Count.EqualTo(3));
+        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]
@@ -273,7 +300,7 @@ public class QueryBreakdownTests
         var merged = mainQuery.GetMergedParameters();
 
         // Assert
-        Assert.That(merged.Count, Is.EqualTo(1));
+        Assert.That(merged, Has.Count.EqualTo(1));
         Assert.That(merged["@Limit"], Is.EqualTo(100)); // Main query value wins
     }
 
@@ -296,10 +323,13 @@ public class QueryBreakdownTests
         var merged = mainQuery.GetMergedParameters();
 
         // Assert - All parameters from all levels should be present
-        Assert.That(merged.Count, Is.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.That(merged, Has.Count.EqualTo(3));
+        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]
@@ -317,7 +347,7 @@ public class QueryBreakdownTests
         var merged = mainQuery.GetMergedParameters();
 
         // Assert
-        Assert.That(merged.Count, Is.EqualTo(0));
+        Assert.That(merged, Is.Empty);
     }
 
     [Test]
@@ -336,11 +366,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 +446,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]
@@ -464,7 +503,7 @@ public class QueryBreakdownTests
         query.AddWhereClause("CreatedDate > @StartDate", "and");
 
         // Assert
-        Assert.That(query.Parameters.Count, Is.EqualTo(3));
+        Assert.That(query.Parameters, Has.Count.EqualTo(3));
         Assert.That(query.Parameters, Does.ContainKey("@UserId"));
         Assert.That(query.Parameters, Does.ContainKey("@Status"));
         Assert.That(query.Parameters, Does.ContainKey("@StartDate"));
@@ -481,9 +520,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
@@ -566,9 +608,12 @@ public class QueryBreakdownTests
         mainQuery.AddWithClause("ProductOrders", cteQuery);
 
         // Assert
-        Assert.That(mainQuery.WithClauses.Count, Is.EqualTo(1));
-        Assert.That(mainQuery.WithClauses[0].TableName, Is.EqualTo("ProductOrders"));
-        Assert.That(mainQuery.WithClauses[0].Query, Is.EqualTo(cteQuery));
+        Assert.That(mainQuery.WithClauses, Has.Count.EqualTo(1));
+        Assert.Multiple(() =>
+        {
+            Assert.That(mainQuery.WithClauses[0].TableName, Is.EqualTo("ProductOrders"));
+            Assert.That(mainQuery.WithClauses[0].Query, Is.EqualTo(cteQuery));
+        });
     }
 
     [Test]
@@ -586,10 +631,13 @@ public class QueryBreakdownTests
         mainQuery.AddWithClause("CTE3", cte3);
 
         // Assert
-        Assert.That(mainQuery.WithClauses.Count, Is.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.That(mainQuery.WithClauses, Has.Count.EqualTo(3));
+        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]
@@ -603,10 +651,13 @@ public class QueryBreakdownTests
         mainQuery.AddWithClause("ProductOrders", cteSql, isMicrosoftSql: true);
 
         // Assert
-        Assert.That(mainQuery.WithClauses.Count, Is.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.That(mainQuery.WithClauses, Has.Count.EqualTo(1));
+        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 +716,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,12 +776,18 @@ 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.That(withIndex, Is.LessThan(mainSelectIndex));
+        Assert.Multiple(() =>
+        {
+            Assert.That(withIndex, Is.GreaterThan(-1));
+            Assert.That(mainSelectIndex, Is.GreaterThan(-1));
+        });
+        Assert.Multiple(() =>
+        {
+            Assert.That(withIndex, Is.LessThan(mainSelectIndex));
 
-        // Assert - Verify CTE definition
-        Assert.That(sql, Does.Contain("ProductTotals"));
+            // Assert - Verify CTE definition
+            Assert.That(sql, Does.Contain("ProductTotals"));
+        });
         Assert.That(sql, Does.Contain("AS"));
         Assert.That(sql, Does.Contain("ProductID"));
         Assert.That(sql, Does.Contain("TotalQuantity"));
@@ -745,13 +805,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 +833,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.Count, Is.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 +994,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 +1011,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 +1029,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 +1081,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 +1123,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 +1140,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 +1221,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 +1240,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 +1295,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 +1565,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 +1962,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
@@ -246,8 +255,8 @@ public class RecursiveCTETests
 
         // Assert
         Assert.That(sql, Contains.Substring("WITH RECURSIVE"));
-        Assert.That(sql.Contains("base AS"), "Non-recursive CTE should be included");
-        Assert.That(sql.Contains("tree_hierarchy AS"), "Recursive CTE should be included");
+        Assert.That(sql, Does.Contain("base AS"), "Non-recursive CTE should be included");
+        Assert.That(sql, Does.Contain("tree_hierarchy AS"), "Recursive CTE should be included");
     }
 
     [Test]

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