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

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

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

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

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

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