Miscellaneous quality improvements.

RyanLamansky · RyanLamansky · commit d7622c522af7 · 2026-05-20T14:37:37.000-05:00
diff --git a/SqlServerSimulator.Tests/MergeViewTests.cs b/SqlServerSimulator.Tests/MergeViewTests.cs
@@ -261,7 +261,7 @@ public void OutputThroughView_RaisesNotSupported()
         sim.ExecuteBatches(
             "create table base_t (id int primary key, v int)",
             "create view v_base as select id, v from base_t");
-        _ = Throws<System.NotSupportedException>(() => sim.ExecuteNonQuery("""
+        _ = Throws<NotSupportedException>(() => sim.ExecuteNonQuery("""
             merge into v_base using (values(1, 10)) src(id, v) on v_base.id = src.id
             when not matched then insert (id, v) values (src.id, src.v) output inserted.id;
             """));
diff --git a/SqlServerSimulator.Tests/QualityTests.cs b/SqlServerSimulator.Tests/QualityTests.cs
@@ -1,4 +1,5 @@
-﻿using SqlServerSimulator.Storage.Bacpac;
+using System.Reflection;
+using SqlServerSimulator.Storage.Bacpac;
 
 namespace SqlServerSimulator;
 
@@ -9,45 +10,111 @@ public class QualityTests
     [Description("Prevents unintentional expansion of the public API.")]
     public void PublicApiWhitelist()
     {
-        var simulation = typeof(Simulation);
-
-        var types = simulation
+        var publicTypes = typeof(Simulation)
             .Assembly
             .GetTypes()
             .Where(type => type.IsPublic)
             .ToArray();
 
-        HashSet<Type> allowedTypes = [
-            simulation,
-            typeof(TableValuedParameterExtensions),
-            typeof(BacpacImportOptions),
-            typeof(BacpacImportResult),
-            typeof(BacpacSkipped),
-            typeof(SimulatedDbConnection),
-            typeof(SimulatedError),
-            typeof(SimulatedErrorCollection),
-            typeof(SimulatedInfoMessageEventArgs),
-        ];
-        Assert.HasCount(allowedTypes.Count, types);
-        foreach (var type in types)
-            Assert.Contains(type, allowedTypes);
-
-        var memberNames = simulation
-            .GetMembers()
-            .Where(member => member.DeclaringType == simulation)
-            .Select(member => member.Name)
-            .ToHashSet();
+        // Per-type whitelist of member names declared directly on the type.
+        // Property / event / operator accessors and compiler-generated members
+        // (record <Clone>$, the C# 14 extension's <G>$... nested type) are
+        // filtered before comparison, so the entries below read as the
+        // human-meaningful API surface.
+        Dictionary<Type, HashSet<string>> allowedMembers = new()
+        {
+            [typeof(Simulation)] = [
+                ".ctor",
+                nameof(Simulation.CreateDbConnection),
+                nameof(Simulation.ImportBacpac),
+                nameof(Simulation.AddRemoteSimulation),
+            ],
+            [typeof(SimulatedDbConnection)] = [
+                nameof(SimulatedDbConnection.InfoMessage),
+                nameof(SimulatedDbConnection.ConnectionString),
+                nameof(SimulatedDbConnection.Database),
+                nameof(SimulatedDbConnection.DataSource),
+                nameof(SimulatedDbConnection.ServerVersion),
+                nameof(SimulatedDbConnection.State),
+                nameof(SimulatedDbConnection.ChangeDatabase),
+                nameof(SimulatedDbConnection.Close),
+                nameof(SimulatedDbConnection.Open),
+            ],
+            [typeof(SimulatedError)] = [
+                nameof(SimulatedError.Class),
+                nameof(SimulatedError.LineNumber),
+                nameof(SimulatedError.Message),
+                nameof(SimulatedError.Number),
+                nameof(SimulatedError.Procedure),
+                nameof(SimulatedError.Server),
+                nameof(SimulatedError.Source),
+                nameof(SimulatedError.State),
+                nameof(SimulatedError.ToString),
+            ],
+            [typeof(SimulatedErrorCollection)] = [
+                "Item",
+                nameof(SimulatedErrorCollection.Count),
+                nameof(SimulatedErrorCollection.CopyTo),
+                nameof(SimulatedErrorCollection.GetEnumerator),
+            ],
+            [typeof(SimulatedInfoMessageEventArgs)] = [
+                nameof(SimulatedInfoMessageEventArgs.Errors),
+                nameof(SimulatedInfoMessageEventArgs.LineNumber),
+                nameof(SimulatedInfoMessageEventArgs.Message),
+                nameof(SimulatedInfoMessageEventArgs.Source),
+            ],
+            // C# 14 lowers the extension(DbParameter) block to static
+            // accessor methods on the host class plus a compiler-generated
+            // <G>$... nested type carrying the cross-assembly metadata. The
+            // nested type is filtered as compiler-generated; the accessors
+            // surface as regular (non-special-name) methods here.
+            [typeof(TableValuedParameterExtensions)] = [
+                "get_TypeName",
+                "set_TypeName",
+            ],
+            [typeof(BacpacImportOptions)] = [
+                ".ctor",
+                nameof(BacpacImportOptions.DatabaseName),
+                nameof(BacpacImportOptions.MaxDegreeOfParallelism),
+                nameof(Equals),
+                nameof(GetHashCode),
+                nameof(ToString),
+            ],
+            [typeof(BacpacImportResult)] = [
+                ".ctor",
+                nameof(BacpacImportResult.ElementCounts),
+                nameof(BacpacImportResult.Skipped),
+                nameof(BacpacImportResult.Warnings),
+            ],
+            [typeof(BacpacSkipped)] = [
+                ".ctor",
+                "Deconstruct",
+                nameof(BacpacSkipped.ElementName),
+                nameof(BacpacSkipped.ElementType),
+                nameof(BacpacSkipped.Reason),
+                nameof(Equals),
+                nameof(GetHashCode),
+                nameof(ToString),
+            ],
+        };
 
-        HashSet<string> allowedMemberNames = [
-            ".ctor",
-            nameof(Simulation.CreateDbConnection),
-            nameof(Simulation.ImportBacpac),
-            nameof(Simulation.AddRemoteSimulation),
-        ];
+        Assert.HasCount(allowedMembers.Count, publicTypes);
+        foreach (var type in publicTypes)
+            Assert.Contains(type, allowedMembers.Keys);
 
-        Assert.HasCount(allowedMemberNames.Count, memberNames);
+        foreach (var (type, allowedNames) in allowedMembers)
+        {
+            var memberNames = type
+                .GetMembers()
+                .Where(member => member.DeclaringType == type)
+                .Where(member => member.Name[0] != '<')
+                .Where(member => member is not MethodInfo mi || !mi.IsSpecialName)
+                .Select(member => member.Name)
+                .ToHashSet();
 
-        foreach (var name in memberNames)
-            Assert.Contains(name, allowedMemberNames);
+            Assert.HasCount(allowedNames.Count, memberNames, $"Member count mismatch on {type.FullName}");
+            foreach (var name in memberNames)
+                Assert.Contains(name, allowedNames, $"Unexpected public member '{name}' on {type.FullName}");
+        }
     }
 }
diff --git a/SqlServerSimulator/Errors/SimulatedSqlException.TypeErrors.cs b/SqlServerSimulator/Errors/SimulatedSqlException.TypeErrors.cs
@@ -439,7 +439,7 @@ internal static SimulatedSqlException InvalidHierarchyIdInput(string detail) =>
     /// attached to a non-string expression (probe-confirmed wording:
     /// <c>"Expression type int is invalid for COLLATE clause."</c>).
     /// Real SQL Server raises this at bind time; the simulator raises at
-    /// runtime because <see cref="Storage.SqlType"/> isn't fully bound
+    /// runtime because <see cref="SqlType"/> isn't fully bound
     /// during the parse pass (column refs without a resolver are typed
     /// lazily). Same Msg + same wording; only the firing point differs.
     /// </summary>
diff --git a/SqlServerSimulator/LinkedServer.cs b/SqlServerSimulator/LinkedServer.cs
@@ -21,7 +21,7 @@ namespace SqlServerSimulator;
 /// <para>
 /// Writes through a four-part name (<c>INSERT</c>, <c>UPDATE</c>,
 /// <c>DELETE</c>, <c>MERGE</c> targeting <c>linkedserver.db.schema.t</c>)
-/// raise <see cref="System.NotSupportedException"/> at parse time. Lock-
+/// raise <see cref="NotSupportedException"/> at parse time. Lock-
 /// manager and undo-log coordination across <see cref="Simulation"/>
 /// boundaries isn't modeled; this mirrors the existing
 /// <see cref="System.Data.IsolationLevel"/>-related deferral for
diff --git a/SqlServerSimulator/Schemas/SchemaObject.cs b/SqlServerSimulator/Schemas/SchemaObject.cs
@@ -4,7 +4,7 @@ namespace SqlServerSimulator.Schemas;
 
 /// <summary>
 /// Common metadata base for every named, schema-resident database object —
-/// <see cref="Storage.HeapTable"/>, <see cref="View"/>,
+/// <see cref="HeapTable"/>, <see cref="View"/>,
 /// <see cref="Procedure"/>, <see cref="UserDefinedFunction"/>,
 /// <see cref="Sequence"/>, <see cref="TableType"/>, <see cref="Trigger"/>.
 /// The base unifies the fields every concrete type was previously
@@ -17,13 +17,13 @@ namespace SqlServerSimulator.Schemas;
 /// <remarks>
 /// <para>
 /// <see cref="Trigger.Parent"/> is typed as <c>SchemaObject</c> so a trigger
-/// can be attached to a <see cref="Storage.HeapTable"/> or a <see cref="View"/>
+/// can be attached to a <see cref="HeapTable"/> or a <see cref="View"/>
 /// without falling through <c>object</c>. DML hooks that need to dispatch on
 /// the trigger's parent take a <c>SchemaObject</c> parameter directly.
 /// </para>
 /// <para>
 /// <see cref="SchemaId"/> is stored as the integer ID for both the
-/// <c>SchemaId</c>-only types (<see cref="Storage.HeapTable"/>) and the
+/// <c>SchemaId</c>-only types (<see cref="HeapTable"/>) and the
 /// types that also carry a <see cref="Schema"/> reference (every other
 /// schema-object kind); those derived types continue to expose their
 /// <see cref="Schema"/> field independently — the base just keeps the
diff --git a/SqlServerSimulator/Simulation/Simulation.cs b/SqlServerSimulator/Simulation/Simulation.cs
@@ -95,7 +95,7 @@ public void AddRemoteSimulation(string name, Simulation target)
     /// lazily seeds <see cref="DefaultDatabaseName"/> on first connection
     /// to a Simulation that has no databases (so the all-T-SQL use case
     /// keeps working without an explicit import / CREATE DATABASE).
-    /// <see cref="ImportBacpac(System.IO.Stream, out Storage.Bacpac.BacpacImportResult, Storage.Bacpac.BacpacImportOptions?)"/>
+    /// <see cref="ImportBacpac(Stream, out Storage.Bacpac.BacpacImportResult, Storage.Bacpac.BacpacImportOptions?)"/>
     /// adds further entries; <c>USE &lt;db&gt;</c> switches a session's
     /// <see cref="SimulatedDbConnection.CurrentDatabase"/> across entries
     /// (Msg 911 on miss). Fresh connections pick the lazy seed when present,
diff --git a/SqlServerSimulator/Storage/Bacpac/BacpacImportOptions.cs b/SqlServerSimulator/Storage/Bacpac/BacpacImportOptions.cs
@@ -2,7 +2,7 @@ namespace SqlServerSimulator.Storage.Bacpac;
 
 /// <summary>
 /// Options passed to <see cref="Simulation.ImportBacpac(string, out BacpacImportResult, BacpacImportOptions?)"/>
-/// and its <see cref="System.IO.Stream"/> overload. Defaulted-everything: the
+/// and its <see cref="Stream"/> overload. Defaulted-everything: the
 /// parameterless constructor (and a <see langword="null"/>-defaulted
 /// <c>options</c> argument) produce the simulator's standard import behavior.
 /// </summary>
@@ -31,7 +31,7 @@ public sealed record class BacpacImportOptions
     /// <summary>
     /// Worker-thread cap for the per-table parallel data-load phase. <c>-1</c>
     /// (the default) uses <see cref="Environment.ProcessorCount"/>, matching
-    /// the convention on <see cref="System.Threading.Tasks.ParallelOptions"/>.
+    /// the convention on <see cref="ParallelOptions"/>.
     /// Positive values cap at that many workers; the loader still won't spin
     /// up more workers than there are work items.
     /// </summary>
diff --git a/SqlServerSimulator/Storage/Bacpac/BacpacImportResult.cs b/SqlServerSimulator/Storage/Bacpac/BacpacImportResult.cs
@@ -2,7 +2,7 @@ namespace SqlServerSimulator.Storage.Bacpac;
 
 /// <summary>
 /// Diagnostics carrier returned from <see cref="Simulation.ImportBacpac(string, out BacpacImportResult, BacpacImportOptions?)"/>
-/// and its <see cref="System.IO.Stream"/> overload. Tracks model.xml elements
+/// and its <see cref="Stream"/> overload. Tracks model.xml elements
 /// the loader recognized but couldn't fully apply (e.g. a feature the
 /// simulator doesn't model end-to-end) so the caller has a feature-gap report
 /// rather than a single throw.
diff --git a/SqlServerSimulator/Storage/LockResource.cs b/SqlServerSimulator/Storage/LockResource.cs
@@ -39,7 +39,7 @@ internal enum LockMode
 /// (each a <see cref="Hold"/> entry with owner / mode / re-entrance
 /// count). Every <see cref="SchemaObject"/> carries one via the inherited
 /// <see cref="SchemaObject.SchemaLock"/>; row-level locks live in
-/// <see cref="Storage.HeapTable.RowLocks"/>, lazily-interned per
+/// <see cref="HeapTable.RowLocks"/>, lazily-interned per
 /// <c>(pageIndex, slotIndex)</c>. All mutations to <see cref="Holders"/>
 /// happen under <see cref="LockManager"/>'s gate; the class itself has no
 /// logic.
