The RPC-parameter and bulk/TVP-column value decoders now unify on a shared TdsWireValue core with TdsColumnDecoder as the single COLMETADATA-shaped decode home.

Author: RyanLamansky

SqlServerSimulator.Tests.Internal/TokenBoundaryTests.cs

@@ -0,0 +1,65 @@
+using SqlServerSimulator.Network;
+using SqlServerSimulator.Storage;
+using static Microsoft.VisualStudio.TestTools.UnitTesting.Assert;
+
+namespace SqlServerSimulator;
+
+/// <summary>
+/// Pins the <see cref="TdsTokenWriter.AtTokenBoundary"/> invariant the terminal
+/// crash boundary relies on: the flag is true whenever the buffer ends at a
+/// complete-token boundary and false only while a composite token
+/// (COLMETADATA / ROW / RETURNVALUE — the writers that interleave a
+/// throw-capable per-column sub-write) is mid-write. A crash that struck
+/// mid-composite therefore leaves the flag false, and the backstop declines to
+/// append an ERROR token that would desync the stream.
+/// </summary>
+[TestClass]
+public sealed class TokenBoundaryTests
+{
+    private static TdsTokenWriter NewWriter() => new(new TdsPacketTransport(new MemoryStream()));
+
+    [TestMethod]
+    public void FreshWriter_IsAtTokenBoundary()
+    {
+        IsTrue(NewWriter().AtTokenBoundary);
+    }
+
+    [TestMethod]
+    public void SelfContainedToken_LeavesBoundaryTrue()
+    {
+        var writer = NewWriter();
+        writer.WriteDone(Tds.DoneFinal, 0);
+        IsTrue(writer.AtTokenBoundary);
+    }
+
+    [TestMethod]
+    public void Composite_IsNotAtBoundary_WhileOpen_TrueWhenClosed()
+    {
+        var writer = NewWriter();
+        writer.EnterComposite();
+        IsFalse(writer.AtTokenBoundary);
+        writer.LeaveComposite();
+        IsTrue(writer.AtTokenBoundary);
+    }
+
+    [TestMethod]
+    public void WriteColMetadata_LeavesBoundaryTrue()
+    {
+        var writer = NewWriter();
+        TdsTypeCodec.WriteColMetadata(writer, [SqlType.Int32], ["a"], null);
+        IsTrue(writer.AtTokenBoundary);
+    }
+
+    [TestMethod]
+    public void CompositeAbandonedMidWrite_LeavesBoundaryFalse()
+    {
+        // Simulates a throw between the token's first byte and its completion —
+        // WriteColMetadata's EnterComposite ran but a per-column WriteTypeInfo
+        // would have thrown before LeaveComposite. The flag stays false, so the
+        // backstop must NOT append another token here.
+        var writer = NewWriter();
+        writer.EnterComposite();
+        writer.WriteByte(Tds.TokenColMetadata);
+        IsFalse(writer.AtTokenBoundary);
+    }
+}

SqlServerSimulator.Tests.SqlClient/BulkCopyTests.cs

@@ -415,6 +415,59 @@ public async Task EmptySource_WritesNoRows()
         AreEqual(0, Scalar(connection, "select count(*) from t"));
     }
 
+    [TestMethod]
+    public async Task LegacyLobColumns_TextNtextImage_InsertAndRoundTrip()
+    {
+        // SqlClient sends legacy text / ntext / image destination columns in the
+        // BCP stream with their LONGLEN TYPE_INFO (a 4-byte max size, the 5-byte
+        // collation for the string pair, and a zero-part TableName field) and the
+        // in-band text-pointer ROW value form — the same value form results carry,
+        // now decoded by the shared column decoder. Probe-captured against
+        // SqlClient 7.0.2 (2026-07-19).
+        var (_, listener, connection) = await SetUpAsync(
+            "create table t (id int, t_col text null, n_col ntext null, i_col image null)",
+            TestContext.CancellationToken);
+        await using var listenerScope = listener;
+        await using var connectionScope = connection;
+
+        var big = new string('Z', 20000);
+        var image = new byte[300];
+        for (var i = 0; i < image.Length; i++)
+            image[i] = (byte)(i & 0xFF);
+
+        var data = Table(("id", typeof(int)), ("t_col", typeof(string)), ("n_col", typeof(string)), ("i_col", typeof(byte[])));
+        _ = data.Rows.Add(1, "hello text", "wörld ntext", new byte[] { 1, 2, 3, 254 });
+        _ = data.Rows.Add(2, DBNull.Value, DBNull.Value, DBNull.Value);
+        _ = data.Rows.Add(3, big, big, image);
+        using (var bulk = new SqlBulkCopy(connection) { DestinationTableName = "t" })
+        {
+            Map(bulk, "id", "id");
+            Map(bulk, "t_col", "t_col");
+            Map(bulk, "n_col", "n_col");
+            Map(bulk, "i_col", "i_col");
+            await bulk.WriteToServerAsync(data, TestContext.CancellationToken);
+        }
+
+        await using var read = new SqlCommand("select t_col, n_col, i_col from t order by id", connection);
+        await using var reader = await read.ExecuteReaderAsync(TestContext.CancellationToken);
+
+        IsTrue(await reader.ReadAsync(TestContext.CancellationToken));
+        AreEqual("hello text", reader.GetString(0));
+        AreEqual("wörld ntext", reader.GetString(1));
+        CollectionAssert.AreEqual(new byte[] { 1, 2, 3, 254 }, (byte[])reader.GetValue(2));
+
+        IsTrue(await reader.ReadAsync(TestContext.CancellationToken));
+        IsTrue(reader.IsDBNull(0));
+        IsTrue(reader.IsDBNull(1));
+        IsTrue(reader.IsDBNull(2));
+
+        IsTrue(await reader.ReadAsync(TestContext.CancellationToken));
+        AreEqual(big, reader.GetString(0));
+        AreEqual(big, reader.GetString(1));
+        CollectionAssert.AreEqual(image, (byte[])reader.GetValue(2));
+        IsFalse(await reader.ReadAsync(TestContext.CancellationToken));
+    }
+
     [TestMethod]
     public async Task MixedScalarTypes_RoundTripOverTheWire()
     {

SqlServerSimulator.Tests.SqlClient/CrashBoundaryTests.cs

@@ -0,0 +1,59 @@
+using Microsoft.Data.SqlClient;
+using static Microsoft.VisualStudio.TestTools.UnitTesting.Assert;
+
+namespace SqlServerSimulator;
+
+/// <summary>
+/// The TDS session's terminal crash boundary: an exception the typed catch list
+/// does not anticipate (and no handler converted to an ERROR token) used to kill
+/// the session silently, leaving the client with a bare transport reset. The
+/// backstop now emits a best-effort Msg 0 / severity 20 ERROR — the shape real
+/// SQL Server sends for an internal failure — so SqlClient surfaces a
+/// <c>SqlException</c> and marks the connection dead, the same way it treats a
+/// severity ≥ 20 error from a real server.
+/// </summary>
+[TestClass]
+public sealed class CrashBoundaryTests
+{
+    public TestContext TestContext { get; set; } = null!;
+
+    [TestMethod]
+    public async Task UnexpectedSessionException_SurfacesSevereError_NotTransportReset()
+    {
+        var simulation = new Simulation
+        {
+            // A type absent from RunAsync's typed catch list, so it escapes to the
+            // terminal backstop rather than a per-statement ERROR conversion.
+            NetworkBatchCrashHookForTesting = () => throw new InvalidOperationException("forced internal failure"),
+        };
+        await using var listener = await simulation.ListenAsync(0, TestContext.CancellationToken);
+        await using var connection = await Wire.OpenAsync(listener, TestContext.CancellationToken);
+        await using var command = new SqlCommand("select 1", connection);
+
+        var exception = await Assert.ThrowsExactlyAsync<SqlException>(
+            async () => await command.ExecuteScalarAsync(TestContext.CancellationToken));
+
+        // Msg 0, severity 20 — a SqlException, not a transport-layer exception.
+        AreEqual(0, exception.Number);
+        AreEqual((byte)20, exception.Class);
+        Contains("A severe error occurred on the current command", exception.Message);
+    }
+
+    [TestMethod]
+    public async Task SevereError_LeavesConnectionUnusable()
+    {
+        var simulation = new Simulation
+        {
+            NetworkBatchCrashHookForTesting = () => throw new InvalidOperationException("forced internal failure"),
+        };
+        await using var listener = await simulation.ListenAsync(0, TestContext.CancellationToken);
+        await using var connection = await Wire.OpenAsync(listener, TestContext.CancellationToken);
+        await using var command = new SqlCommand("select 1", connection);
+
+        _ = await Assert.ThrowsExactlyAsync<SqlException>(
+            async () => await command.ExecuteScalarAsync(TestContext.CancellationToken));
+
+        // Severity 20 is fatal client-side: the connection is no longer open.
+        AreNotEqual(System.Data.ConnectionState.Open, connection.State);
+    }
+}

SqlServerSimulator.Tests.SqlClient/TvpVariantUdtColumnTests.cs

@@ -0,0 +1,149 @@
+using System.Data;
+using System.Data.SqlTypes;
+using Microsoft.Data.SqlClient;
+using Microsoft.Data.SqlClient.Server;
+using Microsoft.SqlServer.Types;
+using static Microsoft.VisualStudio.TestTools.UnitTesting.Assert;
+
+namespace SqlServerSimulator;
+
+/// <summary>
+/// <c>sql_variant</c> and CLR-UDT (<c>hierarchyid</c> / <c>geography</c> /
+/// <c>geometry</c>) columns inside a table-valued parameter. Once the RPC value
+/// decoders and the COLMETADATA-shaped column decoder share one implementation
+/// (<c>TdsWireValue</c>), a TVP column carrying a self-describing
+/// <c>sql_variant</c> body or a PLP-carried UDT value decodes through the same
+/// path an RPC <c>sql_variant</c> / UDT parameter uses. Wire shapes probe-captured
+/// against SQL Server 2025 + SqlClient 7.0.2 through a cleartext tee proxy
+/// (2026-07-19): the <c>sql_variant</c> column TYPE_INFO is <c>0x62</c> + a 4-byte
+/// max length with a 4-byte-total-length (0 = NULL) body value; the UDT column
+/// TYPE_INFO is <c>0xF0</c> + three B_VARCHARs (db / schema / type) with a PLP
+/// value — both the same forms as the matching RPC parameters.
+/// </summary>
+/// <remarks>
+/// These drive the TVP through the <c>sp_executesql</c> text path (the parameter
+/// binds as its own <c>@rows</c> table variable). Routing a LOB-backed TVP column
+/// (<c>geography</c> / <c>geometry</c>, like <c>nvarchar(max)</c>) through a
+/// stored-procedure READONLY parameter hits a pre-existing table-variable LOB-copy
+/// gap in proc-parameter binding, unrelated to the wire decode; see
+/// docs/claude/tds-endpoint.md.
+/// </remarks>
+[TestClass]
+public sealed class TvpVariantUdtColumnTests
+{
+    public TestContext TestContext { get; set; } = null!;
+
+    // geometry POINT(3 4): the 22-byte single-point MS spatial binary
+    // (SqlGeometry.STGeomFromText is unavailable on managed Types under Linux, so
+    // geometry rides raw WKB bytes — the shape DacFx / bulk-import consumers send).
+    private const string GeometryPointWkbHex = "00000000010C00000000000008400000000000001040";
+
+    private static async Task InsertViaTvp(SqlConnection connection, string typeName, IEnumerable<SqlDataRecord> rows, CancellationToken token)
+    {
+        await using var command = new SqlCommand("insert into dbo.sink select * from @rows", connection);
+        var parameter = command.Parameters.AddWithValue("@rows", rows);
+        parameter.SqlDbType = SqlDbType.Structured;
+        parameter.TypeName = typeName;
+        _ = await command.ExecuteNonQueryAsync(token);
+    }
+
+    [TestMethod]
+    public async Task SqlVariantColumn_PerBaseType_RoundTripsWithBaseType()
+    {
+        var simulation = new Simulation();
+        Wire.ExecInProc(simulation, "create type dbo.VarRows as table (id int, v sql_variant)");
+        Wire.ExecInProc(simulation, "create table dbo.sink (id int, v sql_variant)");
+        await using var listener = await simulation.ListenAsync(0, TestContext.CancellationToken);
+        await using var connection = await Wire.OpenAsync(listener, TestContext.CancellationToken);
+
+        var metadata = new[] { new SqlMetaData("id", SqlDbType.Int), new SqlMetaData("v", SqlDbType.Variant) };
+        var rows = new List<SqlDataRecord>();
+        foreach (var (id, value) in new (int, object?)[] { (1, 4242), (2, "hello"), (3, 3.5d), (4, null) })
+        {
+            var record = new SqlDataRecord(metadata);
+            record.SetInt32(0, id);
+            if (value is null)
+                record.SetDBNull(1);
+            else
+                record.SetValue(1, value);
+            rows.Add(record);
+        }
+
+        await InsertViaTvp(connection, "dbo.VarRows", rows, TestContext.CancellationToken);
+
+        var read = Wire.Drain(await new SqlCommand(
+            "select id, v, sql_variant_property(v, 'BaseType') from dbo.sink order by id",
+            connection).ExecuteReaderAsync(TestContext.CancellationToken));
+        HasCount(4, read);
+        AreEqual(4242, read[0][1]);
+        AreEqual("int", read[0][2]);
+        AreEqual("hello", read[1][1]);
+        AreEqual("nvarchar", read[1][2]);
+        AreEqual(3.5d, read[2][1]);
+        AreEqual("float", read[2][2]);
+        IsNull(read[3][1]);
+    }
+
+    [TestMethod]
+    public async Task HierarchyIdColumn_RoundTripsToPathAndDataLength()
+    {
+        var simulation = new Simulation();
+        Wire.ExecInProc(simulation, "create type dbo.HierRows as table (id int, h hierarchyid)");
+        Wire.ExecInProc(simulation, "create table dbo.sink (id int, h hierarchyid)");
+        await using var listener = await simulation.ListenAsync(0, TestContext.CancellationToken);
+        await using var connection = await Wire.OpenAsync(listener, TestContext.CancellationToken);
+
+        var metadata = new[] { new SqlMetaData("id", SqlDbType.Int), new SqlMetaData("h", SqlDbType.Udt, typeof(SqlHierarchyId), "hierarchyid") };
+        var record = new SqlDataRecord(metadata);
+        record.SetInt32(0, 1);
+        record.SetValue(1, SqlHierarchyId.Parse(new SqlString("/1/2/")));
+
+        await InsertViaTvp(connection, "dbo.HierRows", [record], TestContext.CancellationToken);
+
+        await using var reader = await new SqlCommand("select h.ToString(), datalength(h) from dbo.sink", connection)
+            .ExecuteReaderAsync(TestContext.CancellationToken);
+        IsTrue(await reader.ReadAsync(TestContext.CancellationToken));
+        AreEqual("/1/2/", reader.GetString(0));
+        AreEqual(2, reader.GetInt32(1));
+    }
+
+    [TestMethod]
+    public async Task GeographyColumn_RoundTripsToWkt()
+    {
+        var simulation = new Simulation();
+        Wire.ExecInProc(simulation, "create type dbo.GeoRows as table (id int, g geography)");
+        Wire.ExecInProc(simulation, "create table dbo.sink (id int, g geography)");
+        await using var listener = await simulation.ListenAsync(0, TestContext.CancellationToken);
+        await using var connection = await Wire.OpenAsync(listener, TestContext.CancellationToken);
+
+        var metadata = new[] { new SqlMetaData("id", SqlDbType.Int), new SqlMetaData("g", SqlDbType.Udt, typeof(SqlGeography), "geography") };
+        var record = new SqlDataRecord(metadata);
+        record.SetInt32(0, 1);
+        record.SetValue(1, SqlGeography.STGeomFromText(new SqlChars("POINT(-122.3 47.6)"), 4326));
+
+        await InsertViaTvp(connection, "dbo.GeoRows", [record], TestContext.CancellationToken);
+
+        AreEqual("POINT (-122.3 47.6)", await new SqlCommand("select g.ToString() from dbo.sink", connection)
+            .ExecuteScalarAsync(TestContext.CancellationToken));
+    }
+
+    [TestMethod]
+    public async Task GeometryColumn_RoundTripsToWkt()
+    {
+        var simulation = new Simulation();
+        Wire.ExecInProc(simulation, "create type dbo.GeomRows as table (id int, g geometry)");
+        Wire.ExecInProc(simulation, "create table dbo.sink (id int, g geometry)");
+        await using var listener = await simulation.ListenAsync(0, TestContext.CancellationToken);
+        await using var connection = await Wire.OpenAsync(listener, TestContext.CancellationToken);
+
+        var metadata = new[] { new SqlMetaData("id", SqlDbType.Int), new SqlMetaData("g", SqlDbType.Udt, typeof(SqlGeometry), "geometry") };
+        var record = new SqlDataRecord(metadata);
+        record.SetInt32(0, 1);
+        record.SetSqlBytes(1, new SqlBytes(Convert.FromHexString(GeometryPointWkbHex)));
+
+        await InsertViaTvp(connection, "dbo.GeomRows", [record], TestContext.CancellationToken);
+
+        AreEqual("POINT (3 4)", await new SqlCommand("select g.ToString() from dbo.sink", connection)
+            .ExecuteScalarAsync(TestContext.CancellationToken));
+    }
+}