Implemented text/ntext/image. Minor test clean-up and quality improvement.

Author: RyanLamansky

.editorconfig

@@ -17,4 +17,15 @@ dotnet_diagnostic.IDE0040.severity = none # Add accessibility modifiers
 dotnet_diagnostic.IDE0061.severity = none # Use block body for local function
 dotnet_diagnostic.IDE0072.severity = none # Add missing cases
 
+dotnet_diagnostic.MSTEST0017.severity = error # Assertion arguments should be passed in the correct order (expected then actual)
+dotnet_diagnostic.MSTEST0024.severity = error # Do not store TestContext in a static or readonly field
+dotnet_diagnostic.MSTEST0025.severity = error # Use 'Assert.Fail' instead of always-failing constructs
+dotnet_diagnostic.MSTEST0026.severity = error # Avoid conditional access in assertions
+dotnet_diagnostic.MSTEST0032.severity = error # Review or remove the assertion as its condition is known to be always true
+dotnet_diagnostic.MSTEST0036.severity = error # Don't compare strings using '==' operator in tests
+dotnet_diagnostic.MSTEST0037.severity = error # Use proper Assert methods (avoid generic Assert.AreEqual on known types)
+dotnet_diagnostic.MSTEST0038.severity = error # Don't use 'Assert.AreSame' / 'Assert.AreNotSame' with value types
+dotnet_diagnostic.MSTEST0039.severity = error # Use 'Assert.Throws<T>' over the legacy 'Assert.ThrowsException<T>'
+dotnet_diagnostic.MSTEST0042.severity = error # Duplicate attribute
+dotnet_diagnostic.MSTEST0046.severity = error # Use 'Assert.Contains' instead of 'StringAssert.Contains'
 dotnet_diagnostic.MSTEST0049.severity = error # Flow TestContext.CancellationToken to async operations

CLAUDE.md

@@ -12,15 +12,15 @@ High-fidelity SQL Server simulation, eventually including transactions, locks, M
 
 When SQL Server's actual behavior is quirky or lossy (CP1252's silent `?` replacement for out-of-codepage characters, ANSI trailing-space padding for `=`, `LEN` excluding trailing spaces), mirror it rather than "fixing" it — authenticity over desirability is what makes the simulator a faithful stand-in.
 
-The overall plan is incremental and non-specific: pick the lowest-effort path that unlocks the most useful application compatibility next. Transactions / locks / MVCC, the `varchar(MAX)` family — both are eventual targets, but the order is opportunistic, driven by what's blocking the user's actual application stand-ins. Over time, this accretion gets the simulator to "most apps just work"; near term, work flows to the smallest unlock for the biggest cohort of pain points.
+The overall plan is incremental and non-specific: pick the lowest-effort path that unlocks the most useful application compatibility next. Transactions / locks / MVCC are the next obvious eventual target; order is opportunistic, driven by what's blocking the user's actual application stand-ins. Over time, this accretion gets the simulator to "most apps just work"; near term, work flows to the smallest unlock for the biggest cohort of pain points.
 
 ## Public API surface
 
 `Simulation` and `CreateDbConnection()`. That's it. `QualityTests.PublicApiWhitelist` fails the build if anything else becomes public. Resist expanding the surface.
 
 ## Architecture shape
 
-One backend: page-format storage. User tables hold a heap of 8KB pages; rows are encoded as bytes via a row encoder/decoder and navigated column-by-column without rehydrating whole rows. The type system has its own `SqlType`/`SqlValue` pair. Expression evaluation has separate paths for runtime evaluation and static type-of resolution (for projection planning).
+One backend: page-format storage. User tables hold a heap of 8KB pages; rows are encoded as bytes via a row encoder/decoder and navigated column-by-column without rehydrating whole rows. Oversize values for the LOB-eligible types (`varchar(MAX)` / `nvarchar(MAX)` / `varbinary(MAX)` / `text` / `ntext` / `image`) flow through a parallel chain of 8KB LOB pages on the same heap; the row stores an inline marker plus a chain-head pointer. The type system has its own `SqlType`/`SqlValue` pair. Expression evaluation has separate paths for runtime evaluation and static type-of resolution (for projection planning).
 
 Top-level subsystems (in `SqlServerSimulator/`):
 - `Storage/` — pages, row encoder/decoder, types, values
@@ -56,7 +56,7 @@ Each test project has an `AssemblyHooks.cs` with a `static [TestClass]` hosting
 Every test project uses `[assembly: Parallelize(Scope = ExecutionScope.MethodLevel)]`. New test projects should follow.
 
 ### Exception types
-`SimulatedSqlException` mirrors a real SQL Server error — its number, class, state, and message format. Use it when the simulator's behavior matches SQL Server's: invalid SQL, type mismatches, constraint violations, oversize column declarations, truncation. `NotSupportedException` is for valid SQL Server features the simulator hasn't built yet (row-overflow pages, `varchar(MAX)`, etc.); name the unmodeled feature in the message. The distinction matters to users debugging tests against the simulator: "this is invalid SQL" should look different from "this works against real SQL Server but not yet here."
+`SimulatedSqlException` mirrors a real SQL Server error — its number, class, state, and message format. Use it when the simulator's behavior matches SQL Server's: invalid SQL, type mismatches, constraint violations, oversize column declarations, truncation. `NotSupportedException` is for valid SQL Server features the simulator hasn't built yet; name the unmodeled feature in the message. The distinction matters to users debugging tests against the simulator: "this is invalid SQL" should look different from "this works against real SQL Server but not yet here."
 
 ### Commit messages
 Single sentence with period. Concrete artifacts named where useful. Squashes capture the intended end state, not the working steps.
@@ -72,13 +72,14 @@ Prefer public-API tests when the behavior is reachable from SQL — they exercis
 Heavy-hitters someone might assume work but don't. Source and `git log` are the truth for what's done; this list is for what isn't.
 
 - Transactions / locks / MVCC.
-- Row-overflow / LOB pages and the `varchar(MAX)` / `nvarchar(MAX)` / `varbinary(MAX)` types they enable.
+- Row-overflow pages for ordinary `varchar(N)`/`nvarchar(N)`/`varbinary(N)` columns aren't modeled — rows whose declared bounded var values together exceed 8060 bytes still fail at insert. The MAX siblings (`varchar(MAX)` / `nvarchar(MAX)` / `varbinary(MAX)`) and the always-LOB types (`text` / `ntext` / `image`) bypass the row-size limit through their own LOB-chain pages.
+- `text` / `ntext` / `image` operation restrictions: comparison (Msg 402) and ORDER BY / DISTINCT (Msg 306) are enforced; function-level restrictions (e.g. `LEN(ntext)` raising Msg 8116) and the legacy `READTEXT`/`WRITETEXT`/`UPDATETEXT` family aren't modeled.
 - `decimal` / `numeric` values are backed by .NET `decimal`, so values requiring more than 28 significant digits aren't modeled (the type declarations up through `decimal(38, *)` are accepted so storage byte-width still matches SQL Server). `float` text formatting uses .NET's `G15`/`G7` conventions rather than SQL Server's exact `1e+015`-style scientific layout.
 - `NEWSEQUENTIALID()` (deferred until `DEFAULT`-clause support exists in `CREATE TABLE`; the function is only valid in that context).
 - `CONVERT` / `TRY_CONVERT` style-code coverage. Only styles `0`, `120`, and `121` are wired up for date-like sources targeting a character string (the EF Core code-generation defaults). Other style numbers raise Msg 281; money / float / binary style codes and `CONVERT(date, str, 103)`-style date-parsing styles aren't modeled.
 - `LIKE` `COLLATE` override. The default collation (case-insensitive, Latin1_General-shaped) is what every `LIKE` runs under; explicit `COLLATE` clauses on the predicate aren't parsed yet.
 - Cross-category `Promote` for integer ↔ string. Only CAST works for that pair.
-- EF Core compatibility: the `SqlServerSimulator.EFCore` adapter (`UseSqlServerSimulator(...)`) covers the seven `SqlParameter`-downcast pairs — `DateOnly → date`, `DateTime → date`, `DateTime → smalldatetime`, `TimeOnly → time(N)`, `TimeSpan → time(N)`, `decimal → money`, `decimal → smallmoney`. Without the adapter (plain `UseSqlServer`), those mappings still throw at SaveChanges as before. Other type pairs the SqlServer provider supports but aren't modeled here (e.g. `hierarchyid`, `geography`, `geometry`, `rowversion`) are not bridged.
+- EF Core compatibility: the `SqlServerSimulator.EFCore` adapter (`UseSqlServerSimulator(...)`) covers the seven `SqlParameter`-downcast pairs — `DateOnly → date`, `DateTime → date`, `DateTime → smalldatetime`, `TimeOnly → time(N)`, `TimeSpan → time(N)`, `decimal → money`, `decimal → smallmoney`. Without the adapter (plain `UseSqlServer`), those mappings still throw at SaveChanges as before. The MAX-string family (default-mapped `string` → `nvarchar(max)`, `[Column(TypeName = "varchar(max)")]`, `[Column(TypeName = "varbinary(max)")]`) flows through plain `UseSqlServer` without needing the adapter. Other type pairs the SqlServer provider supports but aren't modeled here (e.g. `hierarchyid`, `geography`, `geometry`, `rowversion`) are not bridged.
 - `OUTPUT` and `MERGE` are scoped to the EF Core SaveChanges shape: `INSERT ... OUTPUT INSERTED.<col>` (single-row) and `MERGE INTO target USING (VALUES ...) AS alias (cols) ON predicate WHEN NOT MATCHED THEN INSERT ... [OUTPUT ...]` (multi-row batch). `OUTPUT INTO @table_var`, `OUTPUT DELETED.*`, OUTPUT on UPDATE/DELETE, `INSERTED.*` star expansion, MERGE source subqueries, MERGE target with column refs in `ON`, the `WHEN MATCHED` UPDATE/DELETE branches, and `$action` aren't supported. The `WHEN MATCHED` branch parses syntactically but throws `NotSupportedException` if the per-row predicate ever evaluates true.
 - Session-scoped state. `SCOPE_IDENTITY()` / `@@IDENTITY`, `SET IDENTITY_INSERT`'s active table, and `DBCC TRACEON(N)` flags all live on `Simulation` rather than per-connection. The simulator collapses session vs global scope until a real connection-scoped state model exists; revisit when transactions/locks/MVCC bring the per-session shape with them.
 - CAST to a smaller `varchar`/`nvarchar` than the value renders: SQL Server silently truncates; the simulator returns the full string.

SqlServerSimulator.Tests.EFCore/EFCoreDateTime.cs

@@ -107,7 +107,7 @@ public void MultipleRows_RoundTripBothColumns()
         _ = context.SaveChanges();
 
         var rows = context.Events.OrderBy(e => e.Id).Select(e => new { e.CreatedAt, e.Updated }).ToArray();
-        Assert.AreEqual(2, rows.Length);
+        Assert.HasCount(2, rows);
         Assert.AreEqual(a, rows[0].CreatedAt);
         Assert.AreEqual(b, rows[0].Updated);
         Assert.AreEqual(b, rows[1].CreatedAt);

SqlServerSimulator.Tests.EFCore/EFCoreMaxTypes.cs

@@ -0,0 +1,101 @@
+namespace SqlServerSimulator;
+
+/// <summary>
+/// Exercises the simulator's <c>varchar(MAX)</c> / <c>nvarchar(MAX)</c> /
+/// <c>varbinary(MAX)</c> support through EF Core. EF Core's default mapping
+/// for an unannotated <c>string</c> property is <c>nvarchar(max)</c>, so any
+/// model with such a property hits this path; the explicit MAX siblings
+/// behave identically.
+/// </summary>
+[TestClass]
+public class EFCoreMaxTypes
+{
+    public TestContext TestContext { get; set; } = null!;
+
+    [TestMethod]
+    public void Insert_NVarcharMax_DefaultStringMapping_RoundTrips()
+    {
+        // Body has no [Column] annotation; EF picks nvarchar(max) by default.
+        using var context = new TestDbContext(TestDbContext.CreateArticlesSimulation());
+        _ = context.Articles.Add(new Article { Id = 1, Body = "hello world" });
+        _ = context.SaveChanges();
+
+        Assert.AreEqual("hello world", context.Articles.Select(a => a.Body).First());
+    }
+
+    [TestMethod]
+    public void Insert_NVarcharMax_LargeValue_RoundTripsThroughLobChain()
+    {
+        using var context = new TestDbContext(TestDbContext.CreateArticlesSimulation());
+
+        var big = new string('§', 12_000); // > inline 8060-byte cap, forces off-row LOB
+        _ = context.Articles.Add(new Article { Id = 1, Body = big });
+        _ = context.SaveChanges();
+
+        Assert.AreEqual(big, context.Articles.Select(a => a.Body).First());
+    }
+
+    [TestMethod]
+    public void Insert_VarcharMax_RoundTrips()
+    {
+        using var context = new TestDbContext(TestDbContext.CreateArticlesSimulation());
+
+        var big = new string('A', 20_000);
+        _ = context.Articles.Add(new Article { Id = 1, Body = "irrelevant", Summary = big });
+        _ = context.SaveChanges();
+
+        Assert.AreEqual(big, context.Articles.Select(a => a.Summary).First());
+    }
+
+    [TestMethod]
+    public void Insert_VarbinaryMax_LargeValue_RoundTrips()
+    {
+        using var context = new TestDbContext(TestDbContext.CreateArticlesSimulation());
+
+        var bytes = new byte[18_000];
+        for (var i = 0; i < bytes.Length; i++)
+            bytes[i] = (byte)(i & 0xFF);
+
+        _ = context.Articles.Add(new Article { Id = 1, Body = "irrelevant", Attachment = bytes });
+        _ = context.SaveChanges();
+
+        var roundtrip = context.Articles.Select(a => a.Attachment).First();
+        Assert.IsNotNull(roundtrip);
+        CollectionAssert.AreEqual(bytes, roundtrip);
+    }
+
+    [TestMethod]
+    public async Task InsertAsync_NVarcharMax_RoundTrips()
+    {
+        await using var context = new TestDbContext(TestDbContext.CreateArticlesSimulation());
+        const string body = "async path through nvarchar(max)";
+        _ = context.Articles.Add(new Article { Id = 1, Body = body });
+        _ = await context.SaveChangesAsync(this.TestContext.CancellationToken);
+
+        Assert.AreEqual(body, context.Articles.Select(a => a.Body).First());
+    }
+
+    [TestMethod]
+    public void Where_FiltersByNVarcharMaxEquality()
+    {
+        using var context = new TestDbContext(TestDbContext.CreateArticlesSimulation());
+        context.Articles.AddRange(
+            new Article { Id = 1, Body = "first" },
+            new Article { Id = 2, Body = "second" },
+            new Article { Id = 3, Body = "third" });
+        _ = context.SaveChanges();
+
+        var match = context.Articles.Where(a => a.Body == "second").Select(a => a.Id).Single();
+        Assert.AreEqual(2, match);
+    }
+
+    [TestMethod]
+    public void Insert_NullableVarcharMax_AcceptsNull()
+    {
+        using var context = new TestDbContext(TestDbContext.CreateArticlesSimulation());
+        _ = context.Articles.Add(new Article { Id = 1, Body = "body" });
+        _ = context.SaveChanges();
+
+        Assert.IsNull(context.Articles.Select(a => a.Summary).First());
+    }
+}

SqlServerSimulator.Tests.EFCore/EFCoreStrings.cs

@@ -84,9 +84,9 @@ public void Insert_NameOverMaxLengthRaisesUpdateException()
 
         var ex = Assert.Throws<DbUpdateException>(() => context.SaveChanges());
         Assert.IsNotNull(ex.InnerException);
-        StringAssert.Contains(ex.InnerException.Message, "would be truncated");
-        StringAssert.Contains(ex.InnerException.Message, "People");
-        StringAssert.Contains(ex.InnerException.Message, "Name");
+        Assert.Contains("would be truncated", ex.InnerException.Message);
+        Assert.Contains("People", ex.InnerException.Message);
+        Assert.Contains("Name", ex.InnerException.Message);
     }
 
     [TestMethod]
@@ -143,9 +143,9 @@ public void Insert_VarbinaryAvatarOverMax_RaisesTruncationWithHexValue()
 
         var ex = Assert.Throws<DbUpdateException>(() => context.SaveChanges());
         Assert.IsNotNull(ex.InnerException);
-        StringAssert.Contains(ex.InnerException.Message, "would be truncated");
-        StringAssert.Contains(ex.InnerException.Message, "Avatar");
-        StringAssert.Contains(ex.InnerException.Message, "0x"); // hex prefix, not string
+        Assert.Contains("would be truncated", ex.InnerException.Message);
+        Assert.Contains("Avatar", ex.InnerException.Message);
+        Assert.Contains("0x", ex.InnerException.Message); // hex prefix, not string
     }
 
     [TestMethod]

SqlServerSimulator.Tests.EFCore/TestDbContext.cs

@@ -109,6 +109,28 @@ internal class Product
     public decimal? Discount { get; set; }
 }
 
+/// <summary>
+/// Exercises the simulator's <c>nvarchar(MAX)</c> / <c>varchar(MAX)</c> /
+/// <c>varbinary(MAX)</c> support through EF Core — the LOB-eligible MAX
+/// siblings of the bounded var types. EF Core's default mapping for an
+/// unannotated <c>string</c> property is <c>nvarchar(max)</c>, so this
+/// entity is also a regression check for the simulator handling that
+/// default without a length annotation.
+/// </summary>
+internal class Article
+{
+    public int Id { get; set; }
+
+    // Default EF mapping for string is nvarchar(max).
+    public string Body { get; set; } = null!;
+
+    [Column(TypeName = "varchar(max)")]
+    public string? Summary { get; set; }
+
+    [Column(TypeName = "varbinary(max)")]
+    public byte[]? Attachment { get; set; }
+}
+
 /// <summary>
 /// Exercises the simulator's <c>IDENTITY</c> column support through EF Core.
 /// EF Core defaults int primary keys to <c>ValueGeneratedOnAdd</c>; with the
@@ -163,6 +185,8 @@ protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
 
     public DbSet<Product> Products => Set<Product>();
 
+    public DbSet<Article> Articles => Set<Article>();
+
     public DbSet<Widget> Widgets => Set<Widget>();
 
     public DbSet<Sticker> Stickers => Set<Sticker>();
@@ -225,6 +249,23 @@ OptionalKey uniqueidentifier null
         return simulation;
     }
 
+    public static Simulation CreateArticlesSimulation()
+    {
+        var simulation = new Simulation();
+        _ = simulation
+            .CreateOpenConnection()
+            .CreateCommand("""
+                create table Articles (
+                    Id int,
+                    Body nvarchar(max) not null,
+                    Summary varchar(max) null,
+                    Attachment varbinary(max) null
+                )
+                """)
+            .ExecuteNonQuery();
+        return simulation;
+    }
+
     public static Simulation CreateProductsSimulation()
     {
         var simulation = new Simulation();

SqlServerSimulator.Tests.Internal/Storage/DecodeColumnTests.cs

@@ -8,8 +8,8 @@ namespace SqlServerSimulator.Storage;
 /// catch regressions the way users will.
 /// </summary>
 /// <remarks>
-/// Covers <see cref="RowDecoder.DecodeColumn"/>, which the data reader uses to
-/// navigate row bytes one column at a time without materializing the whole row.
+/// Covers <see cref="RowDecoder"/>, which the data reader uses to navigate
+/// row bytes one column at a time without materializing the whole row.
 /// </remarks>
 [TestClass]
 public sealed class DecodeColumnTests

SqlServerSimulator.Tests.Internal/Storage/HeapPageTests.cs

@@ -20,7 +20,7 @@ public void NewPage_HasHeapTypeAndEmptySlotDir()
         AreEqual((ushort)HeapPage.HeaderSize, page.FreeSpacePointer);
         AreEqual(-1, page.NextPageIndex);
         AreEqual(-1, page.PrevPageIndex);
-        AreEqual(HeapPage.PageSize, page.Bytes.Length);
+        HasCount(HeapPage.PageSize, page.Bytes);
     }
 
     [TestMethod]
@@ -37,7 +37,7 @@ public void TryInsert_SingleRow_AppendsRowAndSlot()
         AreEqual((ushort)HeapPage.HeaderSize, slot0);
 
         var rows = page.EnumerateRows().ToList();
-        AreEqual(1, rows.Count);
+        HasCount(1, rows);
         CollectionAssert.AreEqual(new byte[] { 0x80, 0x81, 0x82 }, rows[0]);
     }
 
@@ -52,7 +52,7 @@ public void TryInsert_MultipleRows_PreservesOrderAndPacksContiguously()
         AreEqual((ushort)3, page.SlotCount);
 
         var rows = page.EnumerateRows().ToList();
-        AreEqual(3, rows.Count);
+        HasCount(3, rows);
         CollectionAssert.AreEqual(new byte[] { 0x80 }, rows[0]);
         CollectionAssert.AreEqual(new byte[] { 0x90, 0x91 }, rows[1]);
         CollectionAssert.AreEqual(new byte[] { 0xA0, 0xA1, 0xA2 }, rows[2]);
@@ -83,7 +83,7 @@ public void TryInsert_RowPayloadAtMaximum_FitsExactly()
         AreEqual(0, page.FreeSpace);
 
         var rows = page.EnumerateRows().ToList();
-        AreEqual(1, rows.Count);
+        HasCount(1, rows);
         CollectionAssert.AreEqual(big, rows[0]);
     }