Densified test files via DataRow consolidation, comment removal, and shared error-assertion helpers (AssertSqlError / AssertSqlMessage).

Author: RyanLamansky

SqlServerSimulator.Tests.EFCore/EFCoreApply.cs

@@ -4,10 +4,7 @@ namespace SqlServerSimulator;
 /// End-to-end tests for the LINQ shapes EF Core 10 translates to
 /// <c>CROSS APPLY</c> / <c>OUTER APPLY</c>: <c>SelectMany</c> over a filtered
 /// collection navigation, and the same shape with <c>DefaultIfEmpty</c> for
-/// the OUTER variant. EF Core 10's emission for top-N projections moved to
-/// <c>ROW_NUMBER() OVER</c> + <c>LEFT JOIN</c>, so APPLY only emerges
-/// here — when the inner correlates by something more than top-level
-/// equality.
+/// the OUTER variant.
 /// </summary>
 [TestClass]
 public class EFCoreApply
@@ -35,9 +32,6 @@ private static TestDbContext SeededContext()
     [TestMethod]
     public void SelectMany_FilteredNavigation_EmitsCrossApply()
     {
-        // EF Core 10 emits CROSS APPLY for SelectMany over a filtered
-        // collection navigation. Verifies end-to-end correctness against
-        // the shape probe-confirmed against real SQL Server 2025.
         using var context = SeededContext();
         var pairs = context.Authors
             .SelectMany(a => a.Books.Where(b => b.Score > 10),
@@ -52,8 +46,7 @@ public void SelectMany_FilteredNavigation_EmitsCrossApply()
     [TestMethod]
     public void SelectMany_FilterReferencesOuter_EmitsCrossApply()
     {
-        // Inner WHERE references both outer and inner columns —
-        // can't lift to a JOIN, must be APPLY.
+        // Inner WHERE references both outer and inner columns — can't lift to JOIN, must be APPLY.
         using var context = SeededContext();
         var pairs = context.Authors
             .SelectMany(a => a.Books.Where(b => b.Score >= a.Id * 5),

SqlServerSimulator.Tests.EFCore/EFCoreDateTime.cs

@@ -1,21 +1,11 @@
 namespace SqlServerSimulator;
 
 /// <summary>
-/// Exercises the simulator's <c>datetime2(N)</c> and <c>datetimeoffset(N)</c>
-/// column support through EF Core's idiomatic surface. Confirms full-precision
-/// (precision 7) round trips and lower-precision (precision 3 / 0) rounding-
-/// on-store behavior land correctly through EF's parameter binding and reader
-/// hydration. Datetimeoffset additionally pins offset preservation across the
-/// round trip and equality-by-UTC-instant in <c>WHERE</c>.
+/// Exercises <c>datetime2(N)</c> and <c>datetimeoffset(N)</c> column support
+/// through EF Core. Confirms full-precision (precision 7) round trips,
+/// lower-precision rounding-on-store, datetimeoffset offset preservation,
+/// equality-by-UTC-instant, and legacy datetime tick-quantization round-trip.
 /// </summary>
-/// <remarks>
-/// Only <see cref="DateTime"/> and <see cref="DateTimeOffset"/> properties are
-/// covered — see <see cref="SimulatedDbParameter"/> for the per-mapping
-/// compatibility table explaining why the other date/time configurations
-/// (<c>DateOnly → date</c>, <c>TimeOnly → time</c>, <c>TimeSpan → time</c>,
-/// <c>DateTime → date</c>) are unreachable through EF Core until a bridge
-/// adapter ships.
-/// </remarks>
 [TestClass]
 public class EFCoreDateTime
 {
@@ -69,7 +59,7 @@ public void Insert_NullableDateTime_AcceptsValue()
     [TestMethod]
     public void Insert_LowerPrecisionColumn_RoundsHalfUp()
     {
-        // Updated is datetime2(3); 0.5ms above a millisecond boundary rounds to next ms.
+        // Updated is datetime2(3); 0.5ms above ms boundary rounds to next ms.
         using var context = new TestDbContext(TestDbContext.CreateEventsSimulation());
         var updated = new DateTime(2026, 5, 4, 13, 45, 30, 100).AddTicks(5_000);
         _ = context.Events.Add(new Event { Id = 1, CreatedAt = new DateTime(2026, 5, 4), Updated = updated });
@@ -90,8 +80,7 @@ public void Where_FiltersByDateTimeEquality()
             new Event { Id = 3, CreatedAt = new DateTime(2026, 5, 4, 15, 0, 0) });
         _ = context.SaveChanges();
 
-        var match = context.Events.Where(e => e.CreatedAt == target).Select(e => e.Id).Single();
-        Assert.AreEqual(2, match);
+        Assert.AreEqual(2, context.Events.Where(e => e.CreatedAt == target).Select(e => e.Id).Single());
     }
 
     [TestMethod]
@@ -146,7 +135,7 @@ public void Insert_NullableDateTimeOffset_AcceptsNullAndValue()
     [TestMethod]
     public void Insert_DateTimeOffset_LowerPrecisionColumn_RoundsHalfUp()
     {
-        // Cancelled is datetimeoffset(3); 0.5ms above a millisecond boundary rounds to next ms.
+        // Cancelled is datetimeoffset(3); 0.5ms above ms boundary rounds to next ms.
         using var context = new TestDbContext(TestDbContext.CreateEventsSimulation());
         var cancelled = new DateTimeOffset(2026, 5, 4, 13, 45, 30, 100, TimeSpan.FromHours(-7)).AddTicks(5_000);
         _ = context.Events.Add(new Event { Id = 1, CreatedAt = new DateTime(2026, 5, 4), OccurredAt = DateTimeOffset.UnixEpoch, Cancelled = cancelled });
@@ -159,8 +148,7 @@ public void Insert_DateTimeOffset_LowerPrecisionColumn_RoundsHalfUp()
     [TestMethod]
     public void Where_FiltersByDateTimeOffsetEquality_CrossOffset()
     {
-        // The stored value and the parameter share a UTC instant but carry
-        // different offsets; equality should still match.
+        // Stored value and parameter share UTC instant but carry different offsets; equality should match.
         using var context = new TestDbContext(TestDbContext.CreateEventsSimulation());
         var east = new DateTimeOffset(2026, 5, 4, 20, 45, 30, TimeSpan.FromHours(7));
         context.Events.AddRange(
@@ -169,30 +157,25 @@ public void Where_FiltersByDateTimeOffsetEquality_CrossOffset()
         _ = context.SaveChanges();
 
         var west = new DateTimeOffset(2026, 5, 4, 6, 45, 30, TimeSpan.FromHours(-7));
-        var match = context.Events.Where(e => e.OccurredAt == west).Select(e => e.Id).Single();
-        Assert.AreEqual(1, match);
+        Assert.AreEqual(1, context.Events.Where(e => e.OccurredAt == west).Select(e => e.Id).Single());
     }
 
     [TestMethod]
     public void Insert_LegacyDateTime_RoundTripsAtTickGranularity()
     {
-        // Legacy datetime stores 1/300-second ticks. .997 input lands on
-        // tick 299 — preserved by EF Core's reader hydration since SqlClient
-        // reconstructs DateTime ticks deterministically from the stored unit.
+        // Legacy datetime stores 1/300-second ticks; .997 input → tick 299 = 9_966_666 100-ns ticks past second.
         using var context = new TestDbContext(TestDbContext.CreateEventsSimulation());
 
         var started = new DateTime(2026, 5, 4, 13, 45, 30, 997);
         _ = context.Events.Add(new Event { Id = 1, CreatedAt = new DateTime(2026, 5, 4), Started = started });
         _ = context.SaveChanges();
 
-        // Round-trip preserves the tick-quantized value, not the raw ms.
         var read = context.Events.Select(e => e.Started).First();
         Assert.IsNotNull(read);
         Assert.AreEqual(started.Date, read.Value.Date);
         Assert.AreEqual(started.Hour, read.Value.Hour);
         Assert.AreEqual(started.Minute, read.Value.Minute);
         Assert.AreEqual(started.Second, read.Value.Second);
-        // .997 ms input → tick 299 → stored at 9_966_666 100-ns ticks past the second.
         Assert.AreEqual(9_966_666, read.Value.Ticks % TimeSpan.TicksPerSecond);
     }
 
@@ -228,8 +211,7 @@ public void Where_FiltersByLegacyDateTimeEquality()
             new Event { Id = 3, CreatedAt = new DateTime(2026, 5, 4), Started = new DateTime(2026, 5, 4, 15, 0, 0) });
         _ = context.SaveChanges();
 
-        var match = context.Events.Where(e => e.Started == target).Select(e => e.Id).Single();
-        Assert.AreEqual(2, match);
+        Assert.AreEqual(2, context.Events.Where(e => e.Started == target).Select(e => e.Id).Single());
     }
 
     [TestMethod]
@@ -246,9 +228,7 @@ public void Insert_LegacyDateTime_AtMin_RoundTrips()
     [TestMethod]
     public void Where_DateTimeYearExtraction_TranslatesToDatepart()
     {
-        // EF Core translates .Year (and .Month / .Day / .Hour / etc.) to
-        // DATEPART(year, col). Common in real apps for "events this year"
-        // filters.
+        // EF Core translates .Year to DATEPART(year, col).
         var simulation = TestDbContext.CreateEventsSimulation();
         using (var seed = new TestDbContext(simulation))
         {
@@ -267,7 +247,6 @@ public void Where_DateTimeYearExtraction_TranslatesToDatepart()
     [TestMethod]
     public void Projection_DateTimeAddDays_TranslatesToDateadd()
     {
-        // EF Core translates .AddDays(N) to DATEADD(day, CAST(N AS int), col).
         var simulation = TestDbContext.CreateEventsSimulation();
         using (var seed = new TestDbContext(simulation))
         {
@@ -281,7 +260,6 @@ public void Projection_DateTimeAddDays_TranslatesToDateadd()
         }
 
         using var context = new TestDbContext(simulation);
-        var rolled = context.Events.Select(e => e.CreatedAt.AddDays(7)).Single();
-        Assert.AreEqual(new DateTime(2024, 6, 8), rolled);
+        Assert.AreEqual(new DateTime(2024, 6, 8), context.Events.Select(e => e.CreatedAt.AddDays(7)).Single());
     }
 }

SqlServerSimulator.Tests.EFCore/EFCoreDecimal.cs

@@ -90,8 +90,6 @@ public void OrderBy_DecimalAscending()
     [TestMethod]
     public void Cast_DecimalToDouble_ProjectsAsFloat()
     {
-        // (double)decimalCol — EF Core emits CAST(... AS float). Common when
-        // Math functions or aggregations need a wider numeric type.
         using var context = new TestDbContext(TestDbContext.CreateProductsSimulation());
         _ = context.Products.Add(new Product { Id = 1, Price = 19.99m });
         _ = context.SaveChanges();

SqlServerSimulator.Tests.EFCore/EFCoreMath.cs

@@ -2,12 +2,11 @@ namespace SqlServerSimulator;
 
 /// <summary>
 /// End-to-end coverage for EF Core 10's translation of <c>Math.X</c> LINQ
-/// methods. Probe-confirmed (2026-05-09): EF emits the SQL function
-/// directly for <c>Math.Round</c> / <c>Floor</c> / <c>Ceiling</c> /
-/// <c>Pow</c> / <c>Sqrt</c> / <c>Sign</c> / <c>Log</c> / <c>Exp</c> /
-/// <c>Log10</c>, and emits <c>ROUND(x, 0, 1)</c> for <c>Math.Truncate</c>
-/// (the truncate-mode third-arg form). <c>Math.Abs</c> already routes
-/// through the existing <c>AbsoluteValue</c> path.
+/// methods. EF emits the SQL function directly for <c>Math.Round</c> /
+/// <c>Floor</c> / <c>Ceiling</c> / <c>Pow</c> / <c>Sqrt</c> / <c>Sign</c> /
+/// <c>Log</c> / <c>Exp</c> / <c>Log10</c>, and emits <c>ROUND(x, 0, 1)</c>
+/// for <c>Math.Truncate</c>. <c>Math.Abs</c> routes through the existing
+/// <c>AbsoluteValue</c> path.
 /// </summary>
 [TestClass]
 public class EFCoreMath
@@ -28,7 +27,6 @@ private static TestDbContext SeededProductsContext()
     [TestMethod]
     public void Round_DecimalProperty()
     {
-        // Math.Round(p.Price, 2) → ROUND([p].[Price], 2) — half-away-from-zero.
         using var context = SeededProductsContext();
         var rounded = context.Products
             .OrderBy(p => p.Id)
@@ -40,7 +38,6 @@ public void Round_DecimalProperty()
     [TestMethod]
     public void RoundToInteger()
     {
-        // Math.Round(p.Price) → ROUND([p].[Price], 0) — half-away-from-zero.
         using var context = SeededProductsContext();
         var rounded = context.Products
             .OrderBy(p => p.Id)
@@ -52,7 +49,6 @@ public void RoundToInteger()
     [TestMethod]
     public void Floor_DecimalProperty()
     {
-        // Math.Floor(p.Price) → FLOOR([p].[Price]).
         using var context = SeededProductsContext();
         var floors = context.Products
             .OrderBy(p => p.Id)
@@ -75,10 +71,7 @@ public void Ceiling_DecimalProperty()
     [TestMethod]
     public void Sign_IntFromOrderBy()
     {
-        // EF Core emits SIGN([t].[Id]) for Math.Sign(int); the result is
-        // an int column. Math.Sign(decimal) → int has a server-side type
-        // mismatch (SQL Server's SIGN(decimal) returns decimal, but EF
-        // reads the column as int) — that route isn't exercised here.
+        // Math.Sign(decimal) → CAST mismatch end-to-end (CLAUDE.md); exercising the int route only.
         using var context = SeededProductsContext();
         var signs = context.Products
             .OrderBy(p => p.Id)
@@ -90,7 +83,6 @@ public void Sign_IntFromOrderBy()
     [TestMethod]
     public void Abs_DecimalProperty()
     {
-        // Math.Abs(p.Price) → ABS([p].[Price]) — preserves decimal(p,s).
         using var context = SeededProductsContext();
         var values = context.Products
             .OrderBy(p => p.Id)
@@ -102,7 +94,6 @@ public void Abs_DecimalProperty()
     [TestMethod]
     public void Truncate_DecimalProperty_EmitsRoundWithTruncateFlag()
     {
-        // Math.Truncate(p.Price) → ROUND([p].[Price], 0, 1) — truncate mode.
         using var context = SeededProductsContext();
         var truncated = context.Products
             .OrderBy(p => p.Id)
@@ -114,16 +105,14 @@ public void Truncate_DecimalProperty_EmitsRoundWithTruncateFlag()
     [TestMethod]
     public void Power_AndSqrt_OverFloatProjection()
     {
-        // Math.Pow / Math.Sqrt require float operands at the LINQ side
-        // (EF Core's translator doesn't widen decimal to double
-        // automatically), so route through a CAST to double.
+        // Math.Pow / Sqrt require float operands at the LINQ side (EF doesn't auto-widen decimal → double).
         using var context = SeededProductsContext();
         var values = context.Products
             .Where(p => p.Price > 0)
             .OrderBy(p => p.Id)
             .Select(p => new { Pow = Math.Pow((double)p.Price, 2), Root = Math.Sqrt((double)p.Price) })
             .ToArray();
-        // Price is decimal(10,2) so 12.345 stores as 12.35 → 12.35^2 = 152.5225.
+        // Price is decimal(10,2), so 12.345 stores as 12.35 → 12.35^2 = 152.5225.
         AreClose(152.5225m, (decimal)values[0].Pow, 0.001m);
         AreClose(3.5142m, (decimal)values[0].Root, 0.001m);
         AreClose(0.25m, (decimal)values[1].Pow, 0.001m);
@@ -139,8 +128,8 @@ public void LogAndExp_FloatProjection()
             .Select(p => new { Log = Math.Log((double)p.Price), Exp = Math.Exp(1.0) })
             .ToArray();
         Assert.HasCount(2, values);
-        AreClose(2.5133m, (decimal)values[0].Log, 0.001m); // log(12.345)
-        AreClose(2.7183m, (decimal)values[0].Exp, 0.001m); // e
+        AreClose(2.5133m, (decimal)values[0].Log, 0.001m);
+        AreClose(2.7183m, (decimal)values[0].Exp, 0.001m);
     }
 
     [TestMethod]
@@ -152,7 +141,7 @@ public void Log10_FloatProjection()
             .OrderBy(p => p.Id)
             .Select(p => Math.Log10((double)p.Price))
             .ToArray();
-        AreClose(1.0915m, (decimal)values[0], 0.001m); // log10(12.345)
+        AreClose(1.0915m, (decimal)values[0], 0.001m);
     }
 
     private static void AreClose(decimal expected, decimal actual, decimal tolerance)