Code coverage boost: fixed two latent bugs (Modulus precedence; NANOSECOND keyword bucket), implemented DbParameterCollection (was NotImplementedException stubs), refactored unreachable Encode/Decode/ConvertParameter overrides to virtual-throw tripwires on the SqlType base, and added ~64 tests filling real surface gaps and reducing noise in the coverage report.

Author: RyanLamansky

SqlServerSimulator.Tests/AggregateTests.cs

@@ -96,6 +96,20 @@ public void Sum_IntOverflow_RaisesMsg8115()
         AreEqual("8115", ex.Data["HelpLink.EvtID"]);
     }
 
+    [TestMethod]
+    public void Sum_Float_AccumulatesViaDouble()
+    {
+        using var connection = Seeded("a float", "(1.5), (2.25), (0.25)");
+        AreEqual(4.0, connection.CreateCommand("select sum(a) from t").ExecuteScalar());
+    }
+
+    [TestMethod]
+    public void Sum_Real_AccumulatesViaDoubleAndNarrowsBack()
+    {
+        using var connection = Seeded("a real", "(1.5), (2.25), (0.25)");
+        AreEqual(4.0f, connection.CreateCommand("select sum(a) from t").ExecuteScalar());
+    }
+
     [TestMethod]
     public void Avg_Int_TruncatesByIntegerDivision()
     {

SqlServerSimulator.Tests/CreateTableTests.cs

@@ -377,4 +377,14 @@ public void ContextualKeywordsAsColumnNames_RoundTrip(string columnName)
         Assert.IsTrue(reader.Read());
         Assert.AreEqual(42, reader.GetInt32(0));
     }
+
+    [TestMethod]
+    public void CreateTable_DuplicateName_RaisesMsg2714()
+    {
+        var simulation = new Simulation();
+        _ = simulation.ExecuteNonQuery("create table dup (a int)");
+        var ex = Assert.Throws<DbException>(() => simulation.ExecuteNonQuery("create table dup (a int)"));
+        Assert.AreEqual("There is already an object named 'dup' in the database.", ex.Message);
+        Assert.AreEqual("2714", ex.Data["HelpLink.EvtID"]);
+    }
 }

SqlServerSimulator.Tests/DataReaderTests.cs

@@ -203,12 +203,55 @@ public void GetDataTypeName_ReturnsBareSqlServerName(string expression, string e
     [DataRow("cast('12:00' as time(3))", typeof(TimeSpan))]
     [DataRow("cast('2024-01-01T12:00:00+00:00' as datetimeoffset(3))", typeof(DateTimeOffset))]
     [DataRow("cast('00000000-0000-0000-0000-000000000000' as uniqueidentifier)", typeof(Guid))]
+    [DataRow("cast(1 as smallmoney)", typeof(decimal))]
+    [DataRow("cast('2024-01-01' as smalldatetime)", typeof(DateTime))]
+    [DataRow("cast('abc' as char(5))", typeof(string))]
+    [DataRow("cast('abc' as nchar(5))", typeof(string))]
+    [DataRow("cast(0x1234 as binary(4))", typeof(byte[]))]
     public void GetFieldType_ReturnsClrType(string expression, Type expected)
     {
         using var reader = OpenReader($"select {expression}");
         AreEqual(expected, reader.GetFieldType(0));
     }
 
+    [TestMethod]
+    [DataRow("text", "text", typeof(string))]
+    [DataRow("ntext", "ntext", typeof(string))]
+    [DataRow("image", "image", typeof(byte[]))]
+    public void LobTypes_FieldTypeAndDataTypeName_ViaColumnRoundTrip(string columnType, string expectedSqlName, Type expectedClr)
+    {
+        // text / ntext / image can't appear as a CAST target; reach their
+        // type-metadata paths by declaring a column and reading it back.
+        var sim = new Simulation();
+        _ = sim.ExecuteNonQuery($"create table t (id int, c {columnType})");
+        _ = sim.ExecuteNonQuery("insert t (id) values (1)");
+        using var reader = sim.ExecuteReader("select c from t");
+        AreEqual(expectedSqlName, reader.GetDataTypeName(0));
+        AreEqual(expectedClr, reader.GetFieldType(0));
+    }
+
+    [TestMethod]
+    public void RowVersion_FieldTypeAndDataTypeName_ViaColumnRoundTrip()
+    {
+        // rowversion stores 8 bytes, surfaces under the legacy "timestamp" name.
+        var sim = new Simulation();
+        _ = sim.ExecuteNonQuery("create table t (id int, rv rowversion)");
+        _ = sim.ExecuteNonQuery("insert t (id) values (1)");
+        using var reader = sim.ExecuteReader("select rv from t");
+        AreEqual("timestamp", reader.GetDataTypeName(0));
+        AreEqual(typeof(byte[]), reader.GetFieldType(0));
+    }
+
+    [TestMethod]
+    public void SysName_FieldTypeAndDataTypeName_ViaSystemTable()
+    {
+        // sysname can't be declared in user CREATE TABLE; the systypes
+        // catalog table exposes it via the "name" column.
+        using var reader = new Simulation().ExecuteReader("select name from systypes");
+        AreEqual("sysname", reader.GetDataTypeName(0));
+        AreEqual(typeof(string), reader.GetFieldType(0));
+    }
+
     [TestMethod]
     public void GetOrdinal_CaseSensitiveThenCaseInsensitive()
     {
@@ -299,4 +342,20 @@ public void GetChar_AlwaysThrowsInvalidCast()
         IsTrue(reader.Read());
         _ = ThrowsExactly<InvalidCastException>(() => reader.GetChar(0));
     }
+
+    [TestMethod]
+    public void GetFloat_ReadsRealColumn()
+    {
+        using var reader = OpenReader("select cast(3.5 as real)");
+        IsTrue(reader.Read());
+        AreEqual(3.5f, reader.GetFloat(0));
+    }
+
+    [TestMethod]
+    public void GetFloat_OnNull_ThrowsSqlNullValueException()
+    {
+        using var reader = OpenReader("select cast(null as real)");
+        IsTrue(reader.Read());
+        _ = Throws<SqlNullValueException>(() => reader.GetFloat(0));
+    }
 }

SqlServerSimulator.Tests/DatePartTests.cs

@@ -51,6 +51,15 @@ public void DatePart_OnTime_AcceptsTimeParts() =>
     public void DatePart_OnDateTimeOffset_AcceptsTzOffset() =>
         AreEqual(-420, ExecuteScalar("select datepart(tzoffset, cast('2024-06-15 13:45:30 -07:00' as datetimeoffset))"));
 
+    [TestMethod]
+    [DataRow("2024-01-01", 1)]   // Jan 1 is always week 1.
+    [DataRow("2024-01-06", 1)]   // Saturday before first Sunday roll → still week 1.
+    [DataRow("2024-01-07", 2)]   // Sunday → week 2 begins.
+    [DataRow("2024-06-15", 24)]  // Mid-year, default us_english Sunday-anchored.
+    [DataRow("2024-12-31", 53)]  // Last day of year — straddles into week 53.
+    public void DatePart_Week_DefaultUsEnglishSundayAnchored(string dateStr, int expectedWeek) =>
+        AreEqual(expectedWeek, ExecuteScalar($"select datepart(week, cast('{dateStr}' as date))"));
+
     [TestMethod]
     public void DatePart_NullInput_ReturnsNullInt() =>
         IsInstanceOfType<DBNull>(ExecuteScalar("select datepart(year, cast(null as datetime2))"));

SqlServerSimulator.Tests/DbParameterCollectionTests.cs

@@ -0,0 +1,215 @@
+using System.Data.Common;
+using static Microsoft.VisualStudio.TestTools.UnitTesting.Assert;
+
+namespace SqlServerSimulator;
+
+/// <summary>
+/// Behavioral tests for the <see cref="DbParameterCollection"/> contract
+/// surfaced through <c>DbCommand.Parameters</c>. SqlClient-style consumers
+/// reach these methods directly (Add, Contains, IndexOf, RemoveAt by name,
+/// etc.) when manipulating parameter collections; the simulator's
+/// implementation is exercised by frameworks like Dapper / EF Core's
+/// command interception layer.
+/// </summary>
+[TestClass]
+public sealed class DbParameterCollectionTests
+{
+    private static (DbConnection conn, DbCommand cmd) Open()
+    {
+        var conn = new Simulation().CreateOpenConnection();
+        return (conn, conn.CreateCommand());
+    }
+
+    private static DbParameter MakeParam(DbCommand cmd, string name, object value)
+    {
+        var p = cmd.CreateParameter();
+        p.ParameterName = name;
+        p.Value = value;
+        return p;
+    }
+
+    [TestMethod]
+    public void Add_ReturnsIndex_ParametersAccessibleByPosition()
+    {
+        var (conn, cmd) = Open();
+        using (conn)
+        using (cmd)
+        {
+            var p1 = MakeParam(cmd, "@a", 1);
+            var p2 = MakeParam(cmd, "@b", 2);
+            AreEqual(0, cmd.Parameters.Add(p1));
+            AreEqual(1, cmd.Parameters.Add(p2));
+            HasCount(2, cmd.Parameters);
+            AreSame(p1, cmd.Parameters[0]);
+            AreSame(p2, cmd.Parameters[1]);
+        }
+    }
+
+    [TestMethod]
+    public void IndexOf_ByName_IsCaseInsensitive()
+    {
+        var (conn, cmd) = Open();
+        using (conn)
+        using (cmd)
+        {
+            _ = cmd.Parameters.Add(MakeParam(cmd, "@Foo", 1));
+            AreEqual(0, cmd.Parameters.IndexOf("@foo"));
+            AreEqual(0, cmd.Parameters.IndexOf("@FOO"));
+            AreEqual(-1, cmd.Parameters.IndexOf("@bar"));
+        }
+    }
+
+    [TestMethod]
+    public void Contains_ByName_AndByObject()
+    {
+        var (conn, cmd) = Open();
+        using (conn)
+        using (cmd)
+        {
+            var p = MakeParam(cmd, "@x", 1);
+            _ = cmd.Parameters.Add(p);
+            var hasX = cmd.Parameters.Contains("@x");
+            var hasY = cmd.Parameters.Contains("@y");
+            var hasP = cmd.Parameters.Contains(p);
+            IsTrue(hasX);
+            IsFalse(hasY);
+            IsTrue(hasP);
+        }
+    }
+
+    [TestMethod]
+    public void IndexerByName_GetAndSet()
+    {
+        var (conn, cmd) = Open();
+        using (conn)
+        using (cmd)
+        {
+            var p = MakeParam(cmd, "@x", 1);
+            _ = cmd.Parameters.Add(p);
+            AreSame(p, cmd.Parameters["@x"]);
+            var replacement = MakeParam(cmd, "@x", 99);
+            cmd.Parameters["@x"] = replacement;
+            AreSame(replacement, cmd.Parameters["@x"]);
+        }
+    }
+
+    [TestMethod]
+    public void IndexerByName_MissingNameThrows()
+    {
+        var (conn, cmd) = Open();
+        using (conn)
+        using (cmd)
+            _ = Throws<ArgumentException>(() => _ = cmd.Parameters["@missing"]);
+    }
+
+    [TestMethod]
+    public void RemoveAt_ByIndex_AndByName()
+    {
+        var (conn, cmd) = Open();
+        using (conn)
+        using (cmd)
+        {
+            _ = cmd.Parameters.Add(MakeParam(cmd, "@a", 1));
+            _ = cmd.Parameters.Add(MakeParam(cmd, "@b", 2));
+            _ = cmd.Parameters.Add(MakeParam(cmd, "@c", 3));
+            cmd.Parameters.RemoveAt(0);
+            HasCount(2, cmd.Parameters);
+            cmd.Parameters.RemoveAt("@c");
+            HasCount(1, cmd.Parameters);
+            AreEqual("@b", cmd.Parameters[0].ParameterName);
+        }
+    }
+
+    [TestMethod]
+    public void Remove_ByObject()
+    {
+        var (conn, cmd) = Open();
+        using (conn)
+        using (cmd)
+        {
+            var p = MakeParam(cmd, "@x", 1);
+            _ = cmd.Parameters.Add(p);
+            cmd.Parameters.Remove(p);
+            IsEmpty(cmd.Parameters);
+        }
+    }
+
+    [TestMethod]
+    public void Insert_PutsParameterAtSpecificIndex()
+    {
+        var (conn, cmd) = Open();
+        using (conn)
+        using (cmd)
+        {
+            _ = cmd.Parameters.Add(MakeParam(cmd, "@a", 1));
+            _ = cmd.Parameters.Add(MakeParam(cmd, "@c", 3));
+            cmd.Parameters.Insert(1, MakeParam(cmd, "@b", 2));
+            AreEqual("@a", cmd.Parameters[0].ParameterName);
+            AreEqual("@b", cmd.Parameters[1].ParameterName);
+            AreEqual("@c", cmd.Parameters[2].ParameterName);
+        }
+    }
+
+    [TestMethod]
+    public void AddRange_AddsAllElements()
+    {
+        var (conn, cmd) = Open();
+        using (conn)
+        using (cmd)
+        {
+            var batch = new[] { MakeParam(cmd, "@a", 1), MakeParam(cmd, "@b", 2) };
+            cmd.Parameters.AddRange(batch);
+            HasCount(2, cmd.Parameters);
+        }
+    }
+
+    [TestMethod]
+    public void Clear_EmptiesCollection()
+    {
+        var (conn, cmd) = Open();
+        using (conn)
+        using (cmd)
+        {
+            _ = cmd.Parameters.Add(MakeParam(cmd, "@a", 1));
+            _ = cmd.Parameters.Add(MakeParam(cmd, "@b", 2));
+            cmd.Parameters.Clear();
+            IsEmpty(cmd.Parameters);
+        }
+    }
+
+    [TestMethod]
+    public void CopyTo_CopiesIntoArray()
+    {
+        var (conn, cmd) = Open();
+        using (conn)
+        using (cmd)
+        {
+            _ = cmd.Parameters.Add(MakeParam(cmd, "@a", 1));
+            _ = cmd.Parameters.Add(MakeParam(cmd, "@b", 2));
+            var dest = new DbParameter[2];
+            cmd.Parameters.CopyTo(dest, 0);
+            AreEqual("@a", dest[0].ParameterName);
+            AreEqual("@b", dest[1].ParameterName);
+        }
+    }
+
+    [TestMethod]
+    public void Enumerator_YieldsParametersInOrder()
+    {
+        var (conn, cmd) = Open();
+        using (conn)
+        using (cmd)
+        {
+            _ = cmd.Parameters.Add(MakeParam(cmd, "@a", 1));
+            _ = cmd.Parameters.Add(MakeParam(cmd, "@b", 2));
+            var names = new List<string>();
+            foreach (DbParameter p in cmd.Parameters)
+                names.Add(p.ParameterName);
+            CollectionAssert.AreEqual(new[] { "@a", "@b" }, names);
+        }
+    }
+
+    [TestMethod]
+    public void SyncRoot_NotNull() =>
+        IsNotNull(new Simulation().CreateOpenConnection().CreateCommand().Parameters.SyncRoot);
+}

SqlServerSimulator.Tests/OperatorPrecedenceTests.cs

@@ -0,0 +1,29 @@
+using static Microsoft.VisualStudio.TestTools.UnitTesting.Assert;
+using static SqlServerSimulator.TestHelpers;
+
+namespace SqlServerSimulator;
+
+/// <summary>
+/// Parser-tree-balancing tests for binary operator precedence. Each row
+/// places a specific operator on the right of another two-sided
+/// expression — that's the path that reads the right-side child's
+/// <c>Precedence</c> property in <c>TwoSidedExpression.AdjustForPrecedence</c>.
+/// Without these chains, the per-subclass <c>Precedence</c> overrides on
+/// Bitwise* / Divide / Modulus / Subtract sit at 0% because the simpler
+/// <c>a OP b</c> shape doesn't require precedence comparison.
+/// </summary>
+[TestClass]
+public sealed class OperatorPrecedenceTests
+{
+    [TestMethod]
+    [DataRow("1 + 2 - 3", 0)]   // Subtract on the right of Add (same precedence, left-assoc swap).
+    [DataRow("8 - 4 + 2", 6)]   // Add on the right of Subtract.
+    [DataRow("1 + 2 & 3", 3)]   // BitwiseAnd on the right of Add.
+    [DataRow("1 + 2 | 4", 7)]   // BitwiseOr on the right of Add.
+    [DataRow("1 + 2 ^ 5", 6)]   // BitwiseExclusiveOr on the right of Add: (1+2)^5 = 3^5 = 6.
+    [DataRow("10 + 8 / 4", 12)] // Divide on the right of Add (Divide is higher precedence; doesn't swap).
+    [DataRow("1 + 5 % 3", 3)]   // Modulus on the right of Add (same precedence): (1+5)%3 = 6%3 = 0... wait, swap means Modulus parent: 1+(5%3) = 1+2 = 3.
+    [DataRow("2 * 3 + 4", 10)]  // Add on the right of Multiply (Add lower precedence; swap).
+    public void OperatorChainProducesExpected(string expr, int expected) =>
+        AreEqual(expected, ExecuteScalar($"select {expr}"));
+}