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

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

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

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

tests/Strata.SqlTools.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]
@@ -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/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;
                 }
@@ -151,9 +149,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 +179,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, Has.Count.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, Has.Count.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, Has.Count.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, Has.Count.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, Has.Count.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,24 +33,30 @@ 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"));
+            // 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"));
         Assert.That(tokens[tokenIndex].Type, Is.EqualTo(JsonTokenType.Number));

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

@@ -17,9 +17,12 @@ public class SqlBreakdownCollectionCoreTests : SqlBreakdownCollectionTestBase
 
         // Assert
         Assert.That(collection, Is.Empty);
-        Assert.That(collection.IsEmpty, Is.True);
-        Assert.That(collection.Breakdowns, Is.Empty);
-        Assert.That(collection.RawStatements, Is.Empty);
+        Assert.Multiple(() =>
+        {
+            Assert.That(collection.IsEmpty, Is.True);
+            Assert.That(collection.Breakdowns, Is.Empty);
+            Assert.That(collection.RawStatements, Is.Empty);
+        });
     }
 
     [Test]
@@ -104,9 +107,12 @@ public class SqlBreakdownCollectionCoreTests : SqlBreakdownCollectionTestBase
         // Act
         var result = collection.Remove(breakdown);
 
-        // Assert
-        Assert.That(result, Is.True);
-        Assert.That(collection, Is.Empty);
+        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, Has.Count.EqualTo(1));
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(result, Is.False);
+            Assert.That(collection, Has.Count.EqualTo(1));
+        });
     }
 
     [Test]
@@ -160,9 +169,12 @@ public class SqlBreakdownCollectionCoreTests : SqlBreakdownCollectionTestBase
 
         // Assert
         Assert.That(collection.RawStatements, Has.Count.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.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]
@@ -223,8 +235,11 @@ public class SqlBreakdownCollectionCoreTests : SqlBreakdownCollectionTestBase
 
         // Assert
         Assert.That(collection.RawStatements, Has.Count.EqualTo(2));
-        Assert.That(collection.RawStatements[0], Does.Contain("Table1"));
-        Assert.That(collection.RawStatements[1], Does.Contain("Table2"));
+        Assert.Multiple(() =>
+        {
+            Assert.That(collection.RawStatements[0], Does.Contain("Table1"));
+            Assert.That(collection.RawStatements[1], Does.Contain("Table2"));
+        });
     }
 
     [Test]

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

@@ -32,8 +32,11 @@ public class SqlBreakdownCollectionCreateTests : SqlBreakdownCollectionTestBase
 
         // Assert
         Assert.That(collection, Has.Count.EqualTo(2));
-        Assert.That(collection.GetRawStatementAt(0), Does.Contain("CREATE TABLE Users"));
-        Assert.That(collection.GetRawStatementAt(1), Does.Contain("CREATE TABLE Orders"));
+        Assert.Multiple(() =>
+        {
+            Assert.That(collection.GetRawStatementAt(0), Does.Contain("CREATE TABLE Users"));
+            Assert.That(collection.GetRawStatementAt(1), Does.Contain("CREATE TABLE Orders"));
+        });
     }
 
     [Test]
@@ -52,8 +55,11 @@ public class SqlBreakdownCollectionCreateTests : SqlBreakdownCollectionTestBase
 
         // Assert
         Assert.That(collection, Has.Count.EqualTo(2));
-        Assert.That(collection.GetRawStatementAt(0), Does.Contain("CREATE INDEX"));
-        Assert.That(collection.GetRawStatementAt(1), Does.Contain("UNIQUE"));
+        Assert.Multiple(() =>
+        {
+            Assert.That(collection.GetRawStatementAt(0), Does.Contain("CREATE INDEX"));
+            Assert.That(collection.GetRawStatementAt(1), Does.Contain("UNIQUE"));
+        });
     }
 
     [Test]

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

@@ -26,9 +26,12 @@ public class SqlBreakdownCollectionDeleteTests : SqlBreakdownCollectionTestBase
 
         // Assert
         Assert.That(collection, Has.Count.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.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]

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

@@ -26,8 +26,11 @@ public class SqlBreakdownCollectionDropTests : SqlBreakdownCollectionTestBase
 
         // Assert
         Assert.That(collection, Has.Count.EqualTo(3));
-        Assert.That(collection.GetRawStatementAt(0), Does.Contain("DROP TABLE"));
-        Assert.That(collection.GetRawStatementAt(1), Does.Contain("DROP TABLE"));
+        Assert.Multiple(() =>
+        {
+            Assert.That(collection.GetRawStatementAt(0), Does.Contain("DROP TABLE"));
+            Assert.That(collection.GetRawStatementAt(1), Does.Contain("DROP TABLE"));
+        });
     }
 
     [Test]
@@ -48,8 +51,11 @@ public class SqlBreakdownCollectionDropTests : SqlBreakdownCollectionTestBase
 
         // Assert
         Assert.That(collection, Has.Count.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.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

@@ -26,9 +26,12 @@ public class SqlBreakdownCollectionInsertTests : SqlBreakdownCollectionTestBase
 
         // Assert
         Assert.That(collection, Has.Count.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.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]

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

@@ -38,12 +38,15 @@ public class SqlBreakdownCollectionMixedCrudTests : SqlBreakdownCollectionTestBa
 
         // Assert
         Assert.That(collection, Has.Count.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.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]

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

@@ -44,8 +44,11 @@ public class SqlBreakdownCollectionParameterTests : SqlBreakdownCollectionTestBa
 
         // Assert
         Assert.That(collection, Has.Count.EqualTo(2));
-        Assert.That(collection.GetRawStatementAt(0), Does.Contain("@Name"));
-        Assert.That(collection.GetRawStatementAt(1), Does.Contain("@Status"));
+        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

@@ -31,8 +31,11 @@ public class SqlBreakdownCollectionSelectTests : SqlBreakdownCollectionTestBase
         // Assert
         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]
@@ -80,7 +83,10 @@ public class SqlBreakdownCollectionSelectTests : SqlBreakdownCollectionTestBase
 
         // Assert
         Assert.That(collection, Has.Count.EqualTo(2));
-        Assert.That(collection.GetRawStatementAt(0), Does.Contain("JOIN"));
-        Assert.That(collection.GetRawStatementAt(1), Does.Contain("IN"));
+        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

@@ -26,9 +26,12 @@ public class SqlBreakdownCollectionSeparatorTests : SqlBreakdownCollectionTestBa
 
         // Assert
         Assert.That(collection, Has.Count.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.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]

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

@@ -26,9 +26,12 @@ public class SqlBreakdownCollectionUpdateTests : SqlBreakdownCollectionTestBase
 
         // Assert
         Assert.That(collection, Has.Count.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.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]
@@ -53,8 +56,11 @@ public class SqlBreakdownCollectionUpdateTests : SqlBreakdownCollectionTestBase
 
         // Assert
         Assert.That(collection, Has.Count.EqualTo(2));
-        Assert.That(collection.GetRawStatementAt(0), Does.Contain("UPDATE u"));
-        Assert.That(collection.GetRawStatementAt(1), Does.Contain("Quantity - 1"));
+        Assert.Multiple(() =>
+        {
+            Assert.That(collection.GetRawStatementAt(0), Does.Contain("UPDATE u"));
+            Assert.That(collection.GetRawStatementAt(1), Does.Contain("Quantity - 1"));
+        });
     }
 
     [Test]