Release prep: tightened NuGet package set, fixed some low-difficulty fidelity issues.

Author: RyanLamansky

Example/Example.csproj

@@ -6,6 +6,8 @@
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>
     <DebugType>embedded</DebugType>
+    <!-- Demonstration project; not a shippable package. -->
+    <IsPackable>false</IsPackable>
   </PropertyGroup>
 
   <ItemGroup>

README.md

@@ -57,11 +57,13 @@ sealed class SimulatedContext(Simulation simulation) : DbContext
 }
 ```
 
+<!-- Not shipping this until someone asks for it.
 The companion `SqlServerSimulator.EFCore` package adds `UseSqlServerSimulator(...)` for entities that use CLR/store-type pairs whose EF default mappings downcast to `SqlParameter` (`DateOnly`/`DateTime`→`date`/`smalldatetime`, `TimeOnly`/`TimeSpan`→`time(N)`, `decimal`→`money`/`smallmoney`). Without it, those mappings throw at SaveChanges. The base-ADO.NET types in the example above don't need it.
+-->
 
 ## Fidelity
 
-Behavior was probed against a live SQL Server reference instance before being modeled. SQL Server's quirks, inconsistencies, and suprises are mostly preserved. Error messages usually match.
+Behavior was probed against a live SQL Server reference instance before being modeled. SQL Server's quirks, inconsistencies, and surprises are mostly preserved. Error messages usually match.
 
 Entity Framework Core trusts the simulator end-to-end: LINQ queries, migrations, change tracking, and the SaveChanges pipeline all flow through unchanged.
 

SqlServerSimulator.EFCore/SqlServerSimulator.EFCore.csproj

@@ -26,6 +26,9 @@
     <EnforceCodeStyleInBuild>true</EnforceCodeStyleInBuild>
     <RootNamespace>SqlServerSimulator.EFCore</RootNamespace>
     <PackageReadmeFile>README.md</PackageReadmeFile>
+    <!-- The simulator package ships on its own; the EF Core adapter is not
+         published separately. Excluded from `dotnet pack` output. -->
+    <IsPackable>false</IsPackable>
   </PropertyGroup>
 
   <ItemGroup>

SqlServerSimulator.Tests/BuiltInFunctionTests.cs

@@ -108,12 +108,68 @@ public void MultiArgStringFunction_NullPropagates(string expression) =>
     [DataRow("left('abc', -1)")]
     [DataRow("right('abc', -1)")]
     [DataRow("substring('abc', 1, -1)")]
-    public void NegativeLength_RaisesMsg537(string expression)
+    public void NegativeLength_RaisesMsg536(string expression)
     {
-        var ex = Throws<DbException>(() => ExecuteScalar($"select {expression}"));
+        var ex = Throws<SimulatedSqlException>(() => ExecuteScalar($"select {expression}"));
+        AreEqual(536, ex.Number);
         Assert.Contains("Invalid length parameter", ex.Message);
     }
 
+    [TestMethod]
+    [DataRow("1/0")]
+    [DataRow("1%0")]
+    [DataRow("cast(1 as bigint) / 0")]
+    [DataRow("10 % cast(0 as bigint)")]
+    [DataRow("isnull(1/0, 0)")]
+    public void IntegerDivideByZero_RaisesMsg8134(string expression)
+    {
+        var ex = Throws<SimulatedSqlException>(() => ExecuteScalar($"select {expression}"));
+        AreEqual(8134, ex.Number);
+        Assert.Contains("Divide by zero", ex.Message);
+    }
+
+    [TestMethod]
+    [DataRow("left('abc', 2147483648)")]
+    [DataRow("right('abc', 2147483648)")]
+    public void IntArgumentOverflow_RaisesMsg8115(string expression)
+    {
+        var ex = Throws<SimulatedSqlException>(() => ExecuteScalar($"select {expression}"));
+        AreEqual(8115, ex.Number);
+        Assert.Contains("Arithmetic overflow", ex.Message);
+    }
+
+    [TestMethod]
+    [DataRow("substring('abc', -2147483648, 2147483647)", "")]
+    [DataRow("substring('abc', 2147483647, 2147483647)", "")]
+    [DataRow("substring('abcdef', 0, 3)", "ab")]
+    [DataRow("substring('abcdef', -2, 5)", "ab")]
+    public void Substring_ClampsExtremesInsteadOfThrowing(string expression, string expected)
+        => AreEqual(expected, ExecuteScalar($"select {expression}"));
+
+    [TestMethod]
+    [DataRow("switchoffset(sysdatetimeoffset(), 9999)")]
+    [DataRow("switchoffset(sysdatetimeoffset(), '+20:00')")]
+    [DataRow("todatetimeoffset(getdate(), 9999)")]
+    [DataRow("todatetimeoffset(getdate(), -2000)")]
+    public void OffsetOutOfRange_RaisesMsg9812(string expression)
+    {
+        var ex = Throws<SimulatedSqlException>(() => ExecuteScalar($"select {expression}"));
+        AreEqual(9812, ex.Number);
+        Assert.Contains("timezone provided to builtin function", ex.Message);
+    }
+
+    [TestMethod]
+    public void DecimalLiteralBeyondMaxPrecision_RaisesMsg1007()
+    {
+        var ex = Throws<SimulatedSqlException>(() => ExecuteScalar("select 1.23456789012345678901234567890123456789012"));
+        AreEqual(1007, ex.Number);
+        Assert.Contains("out of the range for numeric representation", ex.Message);
+    }
+
+    [TestMethod]
+    public void ReplaceWithEmptySearch_ReturnsInputUnchanged()
+        => AreEqual("abc", ExecuteScalar("select replace('abc', '', 'X')"));
+
     [TestMethod]
     public void FunctionOfColumn_FromTable()
     {

SqlServerSimulator.Tests/CommandTests.cs

@@ -61,6 +61,17 @@ public void DesignTimeVisibleBehavior()
         IsTrue(command.DesignTimeVisible);
     }
 
+    [TestMethod]
+    public void CancelAndPrepareAreNoOps()
+    {
+        using var connection = CreateOpenConnection();
+        using var command = connection.CreateCommand();
+        command.CommandText = "select 1";
+        command.Cancel();
+        command.Prepare();
+        AreEqual(1, command.ExecuteScalar());
+    }
+
     [TestMethod]
     public void TransactionPassThrough()
     {

SqlServerSimulator.Tests/ConnectionTests.cs

@@ -40,4 +40,37 @@ public async Task OpenAsyncCancellable()
         await connection.OpenAsync(this.TestContext.CancellationToken);
         Assert.AreEqual(ConnectionState.Open, connection.State);
     }
+
+    [TestMethod]
+    public void DatabaseReflectsCurrentDatabaseAndRoundTripsThroughChangeDatabase()
+    {
+        using var connection = new Simulation().CreateDbConnection();
+        var current = connection.Database;
+        Assert.IsFalse(string.IsNullOrEmpty(current));
+
+        connection.ChangeDatabase(current);
+        Assert.AreEqual(current, connection.Database);
+    }
+
+    [TestMethod]
+    public void ChangeDatabaseToMissingRaisesMsg911()
+    {
+        using var connection = new Simulation().CreateDbConnection();
+        var exception = Assert.ThrowsExactly<SimulatedSqlException>(() => connection.ChangeDatabase("no_such_database"));
+        Assert.AreEqual(911, exception.Number);
+    }
+
+    [TestMethod]
+    public void ChangeDatabaseToWhitespaceRaisesArgumentException()
+    {
+        using var connection = new Simulation().CreateDbConnection();
+        _ = Assert.ThrowsExactly<ArgumentException>(() => connection.ChangeDatabase("   "));
+    }
+
+    [TestMethod]
+    public void ConnectionStringSetterIsNotSupported()
+    {
+        using var connection = new Simulation().CreateDbConnection();
+        _ = Assert.ThrowsExactly<NotSupportedException>(() => connection.ConnectionString = "anything");
+    }
 }

SqlServerSimulator.Tests/IfBlockTests.cs

@@ -366,15 +366,16 @@ select 1
             """));
 
     /// <summary>
-    /// Cond eval errors propagate when the IF is reached. Real SQL Server
-    /// surfaces divide-by-zero in a cond as Msg 8134; the simulator's runtime
-    /// surfaces a raw <see cref="DivideByZeroException"/> (pre-existing
-    /// fidelity gap — same as the gap documented for TRY_CAST).
+    /// Cond eval errors propagate when the IF is reached. Divide-by-zero in a
+    /// cond surfaces as Msg 8134, matching SQL Server.
     /// </summary>
     [TestMethod]
     public void CondEvalError_PropagatesAsRuntimeError()
-        => Throws<DivideByZeroException>(() => new Simulation().ExecuteNonQuery(
+    {
+        var ex = Throws<SimulatedSqlException>(() => new Simulation().ExecuteNonQuery(
             "if 1/0 = 0 select 'ran'"));
+        AreEqual(8134, ex.Number);
+    }
 
     /// <summary>
     /// A taken branch propagates errors normally — a CHECK violation in the

SqlServerSimulator/Errors/SimulatedSqlException.TypeErrors.cs

@@ -245,10 +245,8 @@ internal static SimulatedSqlException CannotConvertCharToMoney() =>
         new("Cannot convert a char value to money. The char value has incorrect syntax.", 235, 16, 1);
 
     /// <summary>
-    /// Mimics SQL Server error 8134: division by zero in decimal / float /
-    /// money arithmetic. Integer division currently falls through .NET's
-    /// <see cref="DivideByZeroException"/> path; future integer-division
-    /// alignment can reuse this factory.
+    /// Mimics SQL Server error 8134: division by zero in integer, decimal,
+    /// float, or money arithmetic.
     /// </summary>
     internal static SimulatedSqlException DivideByZero() =>
         new("Divide by zero error encountered.", 8134, 16, 1);
@@ -415,11 +413,29 @@ internal static SimulatedSqlException IncompatibleDataTypesInOperator(SqlType a,
         new($"The data types {FamilyRootName(a)} and {FamilyRootName(b)} are incompatible in the {operatorName} operator.", 402, 16, 1);
 
     /// <summary>
-    /// Mimics SQL Server error 537: a length / count argument to a string
-    /// function (LEFT, RIGHT, SUBSTRING) was negative.
+    /// Mimics SQL Server error 536: a length / count argument to a string
+    /// function (left, right, substring) was negative. The function name is
+    /// lowercase in the message and the state varies by function (6 for
+    /// left / right, 8 for substring), verified against SQL Server 2025.
     /// </summary>
-    internal static SimulatedSqlException NegativeLengthNotAllowed(string function) =>
-        new($"Invalid length parameter passed to the {function} function.", 537, 16, 3);
+    internal static SimulatedSqlException NegativeLengthNotAllowed(string function, byte state) =>
+        new($"Invalid length parameter passed to the {function} function.", 536, 16, state);
+
+    /// <summary>
+    /// Mimics SQL Server error 1007: a numeric literal carries more than 38
+    /// significant digits, exceeding the maximum precision of the numeric
+    /// representation. Class 15 — raised while reading the literal.
+    /// </summary>
+    internal static SimulatedSqlException NumberOutOfRangeForNumeric(string literal) =>
+        new($"The number '{literal}' is out of the range for numeric representation (maximum precision 38).", 1007, 15, 1);
+
+    /// <summary>
+    /// Mimics SQL Server error 9812: the offset passed to SWITCHOFFSET /
+    /// TODATETIMEOFFSET falls outside the legal ±14:00 range. The builtin
+    /// function name appears lowercase in the message.
+    /// </summary>
+    internal static SimulatedSqlException InvalidTimeZone(string function) =>
+        new($"The timezone provided to builtin function {function} is invalid.", 9812, 16, 1);
 
     /// <summary>
     /// Mimics SQL Server error 6522: an input to a hierarchyid method

SqlServerSimulator/Parser/Expressions/DateTimeAdjustments.cs

@@ -117,7 +117,7 @@ public override SqlValue Run(RuntimeContext runtime)
         var off = this.offsetArg.Run(runtime);
         if (off.IsNull)
             return SqlValue.Null(v.Type);
-        var offsetMinutes = ParseOffsetMinutes(off);
+        var offsetMinutes = ParseOffsetMinutes(off, "switchoffset");
         var adjusted = v.AsDateTimeOffset.ToOffset(TimeSpan.FromMinutes(offsetMinutes));
         return SqlValue.FromDateTimeOffset(v.Type, adjusted);
     }
@@ -146,6 +146,20 @@ internal static int ParseOffsetMinutes(SqlValue v)
         return v.CoerceTo(SqlType.Int32).AsInt32;
     }
 
+    /// <summary>
+    /// Parses the offset and enforces SQL Server's legal ±14:00 range,
+    /// raising Msg 9812 (named for <paramref name="functionName"/>) when it
+    /// is exceeded — instead of letting <see cref="DateTimeOffset"/> throw an
+    /// internal <see cref="ArgumentOutOfRangeException"/>.
+    /// </summary>
+    internal static int ParseOffsetMinutes(SqlValue v, string functionName)
+    {
+        var minutes = ParseOffsetMinutes(v);
+        return minutes is < -840 or > 840
+            ? throw SimulatedSqlException.InvalidTimeZone(functionName)
+            : minutes;
+    }
+
     public override SqlType GetSqlType(BatchContext batch, Func<MultiPartName, SqlType> resolveColumnType) =>
         this.dtoArg.GetSqlType(batch, resolveColumnType) is DateTimeOffsetSqlType t ? t : SqlType.GetDateTimeOffset(7);
 
@@ -184,7 +198,7 @@ public override SqlValue Run(RuntimeContext runtime)
         var off = this.offsetArg.Run(runtime);
         if (off.IsNull)
             return SqlValue.Null(ResultType);
-        var offsetMinutes = SwitchOffset.ParseOffsetMinutes(off);
+        var offsetMinutes = SwitchOffset.ParseOffsetMinutes(off, "todatetimeoffset");
         var dt = v.Type == SqlType.DateTime ? v.AsDateTime
             : v.Type == SqlType.SmallDateTime ? v.AsSmallDateTime
             : v.Type is DateTime2SqlType ? v.AsDateTime2

SqlServerSimulator/Parser/Expressions/Left.cs

@@ -28,9 +28,9 @@ public override SqlValue Run(RuntimeContext runtime)
             return SqlValue.Null(StringScalars.ResolveResultType(rawSource.Type, runtime.Batch));
         var s = StringScalars.CoerceToVarchar(rawSource, runtime.Batch, "left");
 
-        var len = n.CoerceTo(SqlType.Int32).AsInt32;
+        var len = StringScalars.CoerceLengthArgument(n);
         if (len < 0)
-            throw SimulatedSqlException.NegativeLengthNotAllowed("LEFT");
+            throw SimulatedSqlException.NegativeLengthNotAllowed("left", 6);
 
         var input = s.AsString;
         var result = s.Type.Collation?.IsSupplementaryCharacterAware == true