Tests: xUnit cleanup

This change:
- Removes the Assert shim
- Uses recommended xUnit methods (improving fail errors)
- Cleans up exception tests
- General test formatting fixes
- Removes the netcoerapp1.0 only testing (oops commit)

Dapper.Tests.Contrib/Dapper.Tests.Contrib.csproj

@@ -9,7 +9,7 @@
     <TargetFrameworks>netcoreapp1.0;netcoreapp2.0</TargetFrameworks>
   </PropertyGroup>
   <ItemGroup>
-    <Compile Include="..\Dapper.Tests\Helpers\Assert.cs;..\Dapper.Tests\Helpers\XunitSkippable.cs;..\Dapper\TypeExtensions.cs" />
+    <Compile Include="..\Dapper.Tests\Helpers\XunitSkippable.cs;..\Dapper\TypeExtensions.cs" />
     <None Remove="Test.DB.sdf" />
   </ItemGroup>
   <ItemGroup>

Dapper.Tests.Contrib/TestSuites.cs

@@ -18,6 +18,7 @@ namespace Dapper.Tests.Contrib
     // If we want to support a new provider, they need only be added here - not in multiple places
 
     [XunitTestCaseDiscoverer("Dapper.Tests.SkippableFactDiscoverer", "Dapper.Tests.Contrib")]
+    [AttributeUsage(AttributeTargets.Method, AllowMultiple = false)]
     public class SkippableFactAttribute : FactAttribute
     {
     }
@@ -36,31 +37,31 @@ static SqlServerTestSuite()
             using (var connection = new SqlConnection(ConnectionString))
             {
                 // ReSharper disable once AccessToDisposedClosure
-                Action<string> dropTable = name => connection.Execute($@"IF OBJECT_ID('{name}', 'U') IS NOT NULL DROP TABLE [{name}]; ");
+                Action<string> dropTable = name => connection.Execute($"IF OBJECT_ID('{name}', 'U') IS NOT NULL DROP TABLE [{name}]; ");
                 connection.Open();
                 dropTable("Stuff");
-                connection.Execute(@"CREATE TABLE Stuff (TheId int IDENTITY(1,1) not null, Name nvarchar(100) not null, Created DateTime null);");
+                connection.Execute("CREATE TABLE Stuff (TheId int IDENTITY(1,1) not null, Name nvarchar(100) not null, Created DateTime null);");
                 dropTable("People");
-                connection.Execute(@"CREATE TABLE People (Id int IDENTITY(1,1) not null, Name nvarchar(100) not null);");
+                connection.Execute("CREATE TABLE People (Id int IDENTITY(1,1) not null, Name nvarchar(100) not null);");
                 dropTable("Users");
-                connection.Execute(@"CREATE TABLE Users (Id int IDENTITY(1,1) not null, Name nvarchar(100) not null, Age int not null);");
+                connection.Execute("CREATE TABLE Users (Id int IDENTITY(1,1) not null, Name nvarchar(100) not null, Age int not null);");
                 dropTable("Automobiles");
-                connection.Execute(@"CREATE TABLE Automobiles (Id int IDENTITY(1,1) not null, Name nvarchar(100) not null);");
+                connection.Execute("CREATE TABLE Automobiles (Id int IDENTITY(1,1) not null, Name nvarchar(100) not null);");
                 dropTable("Results");
-                connection.Execute(@"CREATE TABLE Results (Id int IDENTITY(1,1) not null, Name nvarchar(100) not null, [Order] int not null);");
+                connection.Execute("CREATE TABLE Results (Id int IDENTITY(1,1) not null, Name nvarchar(100) not null, [Order] int not null);");
                 dropTable("ObjectX");
-                connection.Execute(@"CREATE TABLE ObjectX (ObjectXId nvarchar(100) not null, Name nvarchar(100) not null);");
+                connection.Execute("CREATE TABLE ObjectX (ObjectXId nvarchar(100) not null, Name nvarchar(100) not null);");
                 dropTable("ObjectY");
-                connection.Execute(@"CREATE TABLE ObjectY (ObjectYId int not null, Name nvarchar(100) not null);");
+                connection.Execute("CREATE TABLE ObjectY (ObjectYId int not null, Name nvarchar(100) not null);");
                 dropTable("ObjectZ");
-                connection.Execute(@"CREATE TABLE ObjectZ (Id int not null, Name nvarchar(100) not null);");
+                connection.Execute("CREATE TABLE ObjectZ (Id int not null, Name nvarchar(100) not null);");
             }
         }
     }
 
     public class MySqlServerTestSuite : TestSuite
     {
-        const string DbName = "DapperContribTests";
+        private const string DbName = "DapperContribTests";
 
         public static string ConnectionString { get; private set; } =
             IsAppVeyor
@@ -82,25 +83,25 @@ static MySqlServerTestSuite()
                 using (var connection = new MySqlConnection(ConnectionString))
                 {
                     // ReSharper disable once AccessToDisposedClosure
-                    Action<string> dropTable = name => connection.Execute($@"DROP TABLE IF EXISTS `{name}`;");
+                    Action<string> dropTable = name => connection.Execute($"DROP TABLE IF EXISTS `{name}`;");
                     connection.Open();
-                    connection.Execute($@"DROP DATABASE IF EXISTS {DbName}; CREATE DATABASE {DbName}; USE {DbName};");
+                    connection.Execute($"DROP DATABASE IF EXISTS {DbName}; CREATE DATABASE {DbName}; USE {DbName};");
                     dropTable("Stuff");
-                    connection.Execute(@"CREATE TABLE Stuff (TheId int not null AUTO_INCREMENT PRIMARY KEY, Name nvarchar(100) not null, Created DateTime null);");
+                    connection.Execute("CREATE TABLE Stuff (TheId int not null AUTO_INCREMENT PRIMARY KEY, Name nvarchar(100) not null, Created DateTime null);");
                     dropTable("People");
-                    connection.Execute(@"CREATE TABLE People (Id int not null AUTO_INCREMENT PRIMARY KEY, Name nvarchar(100) not null);");
+                    connection.Execute("CREATE TABLE People (Id int not null AUTO_INCREMENT PRIMARY KEY, Name nvarchar(100) not null);");
                     dropTable("Users");
-                    connection.Execute(@"CREATE TABLE Users (Id int not null AUTO_INCREMENT PRIMARY KEY, Name nvarchar(100) not null, Age int not null);");
+                    connection.Execute("CREATE TABLE Users (Id int not null AUTO_INCREMENT PRIMARY KEY, Name nvarchar(100) not null, Age int not null);");
                     dropTable("Automobiles");
-                    connection.Execute(@"CREATE TABLE Automobiles (Id int not null AUTO_INCREMENT PRIMARY KEY, Name nvarchar(100) not null);");
+                    connection.Execute("CREATE TABLE Automobiles (Id int not null AUTO_INCREMENT PRIMARY KEY, Name nvarchar(100) not null);");
                     dropTable("Results");
-                    connection.Execute(@"CREATE TABLE Results (Id int not null AUTO_INCREMENT PRIMARY KEY, Name nvarchar(100) not null, `Order` int not null);");
+                    connection.Execute("CREATE TABLE Results (Id int not null AUTO_INCREMENT PRIMARY KEY, Name nvarchar(100) not null, `Order` int not null);");
                     dropTable("ObjectX");
-                    connection.Execute(@"CREATE TABLE ObjectX (ObjectXId nvarchar(100) not null, Name nvarchar(100) not null);");
+                    connection.Execute("CREATE TABLE ObjectX (ObjectXId nvarchar(100) not null, Name nvarchar(100) not null);");
                     dropTable("ObjectY");
-                    connection.Execute(@"CREATE TABLE ObjectY (ObjectYId int not null, Name nvarchar(100) not null);");
+                    connection.Execute("CREATE TABLE ObjectY (ObjectYId int not null, Name nvarchar(100) not null);");
                     dropTable("ObjectZ");
-                    connection.Execute(@"CREATE TABLE ObjectZ (Id int not null, Name nvarchar(100) not null);");
+                    connection.Execute("CREATE TABLE ObjectZ (Id int not null, Name nvarchar(100) not null);");
                 }
             }
             catch (MySqlException e)
@@ -112,10 +113,10 @@ static MySqlServerTestSuite()
             }
         }
     }
-    
+
     public class SQLiteTestSuite : TestSuite
     {
-        const string FileName = "Test.DB.sqlite";
+        private const string FileName = "Test.DB.sqlite";
         public static string ConnectionString => $"Filename=./{FileName};Mode=ReadWriteCreate;";
         public override IDbConnection GetConnection() => new SqliteConnection(ConnectionString);
 
@@ -128,14 +129,14 @@ static SQLiteTestSuite()
             using (var connection = new SqliteConnection(ConnectionString))
             {
                 connection.Open();
-                connection.Execute(@"CREATE TABLE Stuff (TheId integer primary key autoincrement not null, Name nvarchar(100) not null, Created DateTime null) ");
-                connection.Execute(@"CREATE TABLE People (Id integer primary key autoincrement not null, Name nvarchar(100) not null) ");
-                connection.Execute(@"CREATE TABLE Users (Id integer primary key autoincrement not null, Name nvarchar(100) not null, Age int not null) ");
-                connection.Execute(@"CREATE TABLE Automobiles (Id integer primary key autoincrement not null, Name nvarchar(100) not null) ");
-                connection.Execute(@"CREATE TABLE Results (Id integer primary key autoincrement not null, Name nvarchar(100) not null, [Order] int not null) ");
-                connection.Execute(@"CREATE TABLE ObjectX (ObjectXId nvarchar(100) not null, Name nvarchar(100) not null) ");
-                connection.Execute(@"CREATE TABLE ObjectY (ObjectYId integer not null, Name nvarchar(100) not null) ");
-                connection.Execute(@"CREATE TABLE ObjectZ (Id integer not null, Name nvarchar(100) not null) ");
+                connection.Execute("CREATE TABLE Stuff (TheId integer primary key autoincrement not null, Name nvarchar(100) not null, Created DateTime null) ");
+                connection.Execute("CREATE TABLE People (Id integer primary key autoincrement not null, Name nvarchar(100) not null) ");
+                connection.Execute("CREATE TABLE Users (Id integer primary key autoincrement not null, Name nvarchar(100) not null, Age int not null) ");
+                connection.Execute("CREATE TABLE Automobiles (Id integer primary key autoincrement not null, Name nvarchar(100) not null) ");
+                connection.Execute("CREATE TABLE Results (Id integer primary key autoincrement not null, Name nvarchar(100) not null, [Order] int not null) ");
+                connection.Execute("CREATE TABLE ObjectX (ObjectXId nvarchar(100) not null, Name nvarchar(100) not null) ");
+                connection.Execute("CREATE TABLE ObjectY (ObjectYId integer not null, Name nvarchar(100) not null) ");
+                connection.Execute("CREATE TABLE ObjectZ (Id integer not null, Name nvarchar(100) not null) ");
             }
         }
     }

Dapper.Tests/ConstructorTests.cs

@@ -12,26 +12,26 @@ public void TestAbstractInheritance()
         {
             var order = connection.Query<AbstractInheritance.ConcreteOrder>("select 1 Internal,2 Protected,3 [Public],4 Concrete").First();
 
-            order.Internal.IsEqualTo(1);
-            order.ProtectedVal.IsEqualTo(2);
-            order.Public.IsEqualTo(3);
-            order.Concrete.IsEqualTo(4);
+            Assert.Equal(1, order.Internal);
+            Assert.Equal(2, order.ProtectedVal);
+            Assert.Equal(3, order.Public);
+            Assert.Equal(4, order.Concrete);
         }
 
         [Fact]
         public void TestMultipleConstructors()
         {
             MultipleConstructors mult = connection.Query<MultipleConstructors>("select 0 A, 'Dapper' b").First();
-            mult.A.IsEqualTo(0);
-            mult.B.IsEqualTo("Dapper");
+            Assert.Equal(0, mult.A);
+            Assert.Equal("Dapper", mult.B);
         }
 
         [Fact]
         public void TestConstructorsWithAccessModifiers()
         {
             ConstructorsWithAccessModifiers value = connection.Query<ConstructorsWithAccessModifiers>("select 0 A, 'Dapper' b").First();
-            value.A.IsEqualTo(1);
-            value.B.IsEqualTo("Dapper!");
+            Assert.Equal(1, value.A);
+            Assert.Equal("Dapper!", value.B);
         }
 
         [Fact]
@@ -39,11 +39,11 @@ public void TestNoDefaultConstructor()
         {
             var guid = Guid.NewGuid();
             NoDefaultConstructor nodef = connection.Query<NoDefaultConstructor>("select CAST(NULL AS integer) A1,  CAST(NULL AS integer) b1, CAST(NULL AS real) f1, 'Dapper' s1, G1 = @id", new { id = guid }).First();
-            nodef.A.IsEqualTo(0);
-            nodef.B.IsEqualTo(null);
-            nodef.F.IsEqualTo(0);
-            nodef.S.IsEqualTo("Dapper");
-            nodef.G.IsEqualTo(guid);
+            Assert.Equal(0, nodef.A);
+            Assert.Null(nodef.B);
+            Assert.Equal(0, nodef.F);
+            Assert.Equal("Dapper", nodef.S);
+            Assert.Equal(nodef.G, guid);
         }
 
         [Fact]
@@ -52,18 +52,18 @@ public void TestNoDefaultConstructorWithChar()
             const char c1 = 'ą';
             const char c3 = 'ó';
             NoDefaultConstructorWithChar nodef = connection.Query<NoDefaultConstructorWithChar>("select @c1 c1, @c2 c2, @c3 c3", new { c1 = c1, c2 = (char?)null, c3 = c3 }).First();
-            nodef.Char1.IsEqualTo(c1);
-            nodef.Char2.IsEqualTo(null);
-            nodef.Char3.IsEqualTo(c3);
+            Assert.Equal(nodef.Char1, c1);
+            Assert.Null(nodef.Char2);
+            Assert.Equal(nodef.Char3, c3);
         }
 
         [Fact]
         public void TestNoDefaultConstructorWithEnum()
         {
             NoDefaultConstructorWithEnum nodef = connection.Query<NoDefaultConstructorWithEnum>("select cast(2 as smallint) E1, cast(5 as smallint) n1, cast(null as smallint) n2").First();
-            nodef.E.IsEqualTo(ShortEnum.Two);
-            nodef.NE1.IsEqualTo(ShortEnum.Five);
-            nodef.NE2.IsEqualTo(null);
+            Assert.Equal(ShortEnum.Two, nodef.E);
+            Assert.Equal(ShortEnum.Five, nodef.NE1);
+            Assert.Null(nodef.NE2);
         }
 
         [Fact]
@@ -77,10 +77,10 @@ public void ExplicitConstructors()
 SELECT * FROM @ExplicitConstructors"
 ).ToList();
 
-            rows.Count.IsEqualTo(1);
-            rows[0].Field.IsEqualTo(1);
-            rows[0].Field_1.IsEqualTo(1);
-            rows[0].GetWentThroughProperConstructor().IsTrue();
+            Assert.Single(rows);
+            Assert.Equal(1, rows[0].Field);
+            Assert.Equal(1, rows[0].Field_1);
+            Assert.True(rows[0].GetWentThroughProperConstructor());
         }
 
         private class _ExplicitConstructors
@@ -211,7 +211,7 @@ private WithPrivateConstructor()
         public void TestWithNonPublicConstructor()
         {
             var output = connection.Query<WithPrivateConstructor>("select 1 as Foo").First();
-            output.Foo.IsEqualTo(1);
+            Assert.Equal(1, output.Foo);
         }
     }
 }

Dapper.Tests/Dapper.Tests.csproj

@@ -7,7 +7,6 @@
     <AutoGenerateBindingRedirects>true</AutoGenerateBindingRedirects>
     <GenerateBindingRedirectsOutputType>true</GenerateBindingRedirectsOutputType>
     <TargetFrameworks>net452;netcoreapp1.0;netcoreapp2.0</TargetFrameworks>
-    <TargetFrameworks>netcoreapp1.0</TargetFrameworks>
     <TreatWarningsAsErrors>false</TreatWarningsAsErrors>
   </PropertyGroup>
 

Dapper.Tests/DataReaderTests.cs

@@ -14,12 +14,12 @@ public void GetSameReaderForSameShape()
 
             var typedParser = origReader.GetRowParser<HazNameId>();
 
-            ReferenceEquals(origParser, typedParser).IsEqualTo(true);
+            Assert.True(ReferenceEquals(origParser, typedParser));
 
             var list = origReader.Parse<HazNameId>().ToList();
-            list.Count.IsEqualTo(1);
-            list[0].Name.IsEqualTo("abc");
-            list[0].Id.IsEqualTo(123);
+            Assert.Single(list);
+            Assert.Equal("abc", list[0].Name);
+            Assert.Equal(123, list[0].Id);
             origReader.Dispose();
 
             var secondReader = connection.ExecuteReader("select 'abc' as Name, 123 as Id");
@@ -27,15 +27,15 @@ public void GetSameReaderForSameShape()
             var thirdParser = secondReader.GetRowParser(typeof(HazNameId), 1);
 
             list = secondReader.Parse<HazNameId>().ToList();
-            list.Count.IsEqualTo(1);
-            list[0].Name.IsEqualTo("abc");
-            list[0].Id.IsEqualTo(123);
+            Assert.Single(list);
+            Assert.Equal("abc", list[0].Name);
+            Assert.Equal(123, list[0].Id);
             secondReader.Dispose();
 
             // now: should be different readers, but same parser
-            ReferenceEquals(origReader, secondReader).IsEqualTo(false);
-            ReferenceEquals(origParser, secondParser).IsEqualTo(true);
-            ReferenceEquals(secondParser, thirdParser).IsEqualTo(false);
+            Assert.False(ReferenceEquals(origReader, secondReader));
+            Assert.True(ReferenceEquals(origParser, secondParser));
+            Assert.False(ReferenceEquals(secondParser, thirdParser));
         }
 
         [Fact]
@@ -68,13 +68,13 @@ union all
                 }
             }
 
-            result.Count.IsEqualTo(2);
-            result[0].Type.IsEqualTo(1);
-            result[1].Type.IsEqualTo(2);
+            Assert.Equal(2, result.Count);
+            Assert.Equal(1, result[0].Type);
+            Assert.Equal(2, result[1].Type);
             var foo = (Discriminated_Foo)result[0];
-            foo.Name.IsEqualTo("abc");
+            Assert.Equal("abc", foo.Name);
             var bar = (Discriminated_Bar)result[1];
-            bar.Value.IsEqualTo((float)4.0);
+            Assert.Equal(bar.Value, (float)4.0);
         }
 
         [Fact]
@@ -108,7 +108,7 @@ union all
                             break;
                         }
 
-                        obj.IsNotNull();
+                        Assert.NotNull(obj);
                         obj.HazNameIdObject = toHaz(reader);
                         result.Add(obj);
 
@@ -116,17 +116,17 @@ union all
                 }
             }
 
-            result.Count.IsEqualTo(2);
-            result[0].Type.IsEqualTo(1);
-            result[1].Type.IsEqualTo(2);
+            Assert.Equal(2, result.Count);
+            Assert.Equal(1, result[0].Type);
+            Assert.Equal(2, result[1].Type);
             var foo = (DiscriminatedWithMultiMapping_Foo)result[0];
-            foo.Name.IsEqualTo("abc");
-            foo.HazNameIdObject.Id.IsEqualTo(1);
-            foo.HazNameIdObject.Name.IsEqualTo("zxc");
+            Assert.Equal("abc", foo.Name);
+            Assert.Equal(1, foo.HazNameIdObject.Id);
+            Assert.Equal("zxc", foo.HazNameIdObject.Name);
             var bar = (DiscriminatedWithMultiMapping_Bar)result[1];
-            bar.Value.IsEqualTo((float)4.0);
-            bar.HazNameIdObject.Id.IsEqualTo(2);
-            bar.HazNameIdObject.Name.IsEqualTo("qwe");
+            Assert.Equal(bar.Value, (float)4.0);
+            Assert.Equal(2, bar.HazNameIdObject.Id);
+            Assert.Equal("qwe", bar.HazNameIdObject.Name);
         }
 
         private abstract class Discriminated_BaseType

Dapper.Tests/DecimalTests.cs

@@ -15,7 +15,7 @@ public void Issue261_Decimals()
             connection.Execute("create proc #Issue261 @c decimal(10,5) OUTPUT as begin set @c=11.884 end");
             connection.Execute("#Issue261", parameters, commandType: CommandType.StoredProcedure);
             var c = parameters.Get<Decimal>("c");
-            c.IsEqualTo(11.884M);
+            Assert.Equal(11.884M, c);
         }
 
         [Fact]
@@ -61,7 +61,7 @@ private void Issue261_Decimals_ADONET(bool setPrecisionScaleViaAbstractApi)
                 cmd.Parameters.Add(c);
                 cmd.ExecuteNonQuery();
                 decimal value = (decimal)c.Value;
-                value.IsEqualTo(11.884M);
+                Assert.Equal(11.884M, value);
             }
         }
 
@@ -69,7 +69,7 @@ private void Issue261_Decimals_ADONET(bool setPrecisionScaleViaAbstractApi)
         public void BasicDecimals()
         {
             var c = connection.Query<decimal>("select @c", new { c = 11.884M }).Single();
-            c.IsEqualTo(11.884M);
+            Assert.Equal(11.884M, c);
         }
 
         [Fact]
@@ -100,9 +100,9 @@ public void TestDoubleDecimalConversions_SO18228523_Nulls()
             var row = connection.Query<HasDoubleDecimal>(
                 "select cast(null as decimal) as A, cast(null as decimal) as B, cast(null as float) as C, cast(null as float) as D").Single();
             row.A.Equals(0.0);
-            row.B.IsNull();
+            Assert.Null(row.B);
             row.C.Equals(0.0M);
-            row.D.IsNull();
+            Assert.Null(row.D);
         }
 
         private class HasDoubleDecimal

Dapper.Tests/EnumTests.cs

@@ -9,42 +9,42 @@ public class EnumTests : TestBase
         [Fact]
         public void TestEnumWeirdness()
         {
-            connection.Query<TestEnumClass>("select null as [EnumEnum]").First().EnumEnum.IsEqualTo(null);
-            connection.Query<TestEnumClass>("select cast(1 as tinyint) as [EnumEnum]").First().EnumEnum.IsEqualTo(TestEnum.Bla);
+            Assert.Null(connection.Query<TestEnumClass>("select null as [EnumEnum]").First().EnumEnum);
+            Assert.Equal(TestEnum.Bla, connection.Query<TestEnumClass>("select cast(1 as tinyint) as [EnumEnum]").First().EnumEnum);
         }
 
         [Fact]
         public void TestEnumStrings()
         {
-            connection.Query<TestEnumClassNoNull>("select 'BLA' as [EnumEnum]").First().EnumEnum.IsEqualTo(TestEnum.Bla);
-            connection.Query<TestEnumClassNoNull>("select 'bla' as [EnumEnum]").First().EnumEnum.IsEqualTo(TestEnum.Bla);
+            Assert.Equal(TestEnum.Bla, connection.Query<TestEnumClassNoNull>("select 'BLA' as [EnumEnum]").First().EnumEnum);
+            Assert.Equal(TestEnum.Bla, connection.Query<TestEnumClassNoNull>("select 'bla' as [EnumEnum]").First().EnumEnum);
 
-            connection.Query<TestEnumClass>("select 'BLA' as [EnumEnum]").First().EnumEnum.IsEqualTo(TestEnum.Bla);
-            connection.Query<TestEnumClass>("select 'bla' as [EnumEnum]").First().EnumEnum.IsEqualTo(TestEnum.Bla);
+            Assert.Equal(TestEnum.Bla, connection.Query<TestEnumClass>("select 'BLA' as [EnumEnum]").First().EnumEnum);
+            Assert.Equal(TestEnum.Bla, connection.Query<TestEnumClass>("select 'bla' as [EnumEnum]").First().EnumEnum);
         }
 
         [Fact]
         public void TestEnumParamsWithNullable()
         {
-            EnumParam a = EnumParam.A;
+            const EnumParam a = EnumParam.A;
             EnumParam? b = EnumParam.B, c = null;
             var obj = connection.Query<EnumParamObject>("select @a as A, @b as B, @c as C",
                 new { a, b, c }).Single();
-            obj.A.IsEqualTo(EnumParam.A);
-            obj.B.IsEqualTo(EnumParam.B);
-            obj.C.IsEqualTo(null);
+            Assert.Equal(EnumParam.A, obj.A);
+            Assert.Equal(EnumParam.B, obj.B);
+            Assert.Null(obj.C);
         }
 
         [Fact]
         public void TestEnumParamsWithoutNullable()
         {
-            EnumParam a = EnumParam.A;
-            EnumParam b = EnumParam.B, c = 0;
+            const EnumParam a = EnumParam.A;
+            const EnumParam b = EnumParam.B, c = 0;
             var obj = connection.Query<EnumParamObjectNonNullable>("select @a as A, @b as B, @c as C",
                 new { a, b, c }).Single();
-            obj.A.IsEqualTo(EnumParam.A);
-            obj.B.IsEqualTo(EnumParam.B);
-            obj.C.IsEqualTo((EnumParam)0);
+            Assert.Equal(EnumParam.A, obj.A);
+            Assert.Equal(EnumParam.B, obj.B);
+            Assert.Equal(obj.C, (EnumParam)0);
         }
 
         private enum EnumParam : short
@@ -96,7 +96,7 @@ public void AdoNetEnumValue()
                 cmd.Parameters.Add(p);
                 object value = cmd.ExecuteScalar();
                 AnEnum val = (AnEnum)value;
-                val.IsEqualTo(AnEnum.B);
+                Assert.Equal(AnEnum.B, val);
             }
         }
 
@@ -123,7 +123,7 @@ public SO27024806Class(SO27024806Enum myField)
         public void SO27024806_TestVarcharEnumMemberWithExplicitConstructor()
         {
             var foo = connection.Query<SO27024806Class>("SELECT 'Foo' AS myField").Single();
-            foo.MyField.IsEqualTo(SO27024806Enum.Foo);
+            Assert.Equal(SO27024806Enum.Foo, foo.MyField);
         }
     }
 }

Dapper.Tests/Helpers/Assert.cs

-using System.Collections.Generic;
-
-namespace Dapper.Tests
-{
-    public static class Assert
-    {
-        public static void IsEqualTo<T>(this T actual, T expected)
-        {
-            Xunit.Assert.Equal(expected, actual);
-        }
-
-        public static void IsSequenceEqualTo<T>(this IEnumerable<T> actual, IEnumerable<T> expected)
-        {
-            Xunit.Assert.Equal(expected, actual ?? new T[0]);
-        }
-
-        public static void IsMoreThan(this int a, int b)
-        {
-            Xunit.Assert.True(a > b, $"{a} should be larger than {b}");
-        }
-
-        public static void IsMoreThan(this long a, int b)
-        {
-            Xunit.Assert.True(a > b, $"{a} should be larger than {b}");
-        }
-
-        public static void Fail(string message = null)
-        {
-            Xunit.Assert.True(false, message ?? "Expectation failed");
-        }
-
-        public static void IsFalse(this bool b)
-        {
-            Xunit.Assert.False(b);
-        }
-
-        public static void IsTrue(this bool b)
-        {
-            Xunit.Assert.True(b);
-        }
-
-        public static void IsNull(this object obj)
-        {
-            Xunit.Assert.Null(obj);
-        }
-
-        public static void IsNotNull(this object obj)
-        {
-            Xunit.Assert.NotNull(obj);
-        }
-    }
-}

Dapper.Tests/Helpers/Attributes.cs

@@ -17,6 +17,7 @@ public FactLongRunningAttribute()
         public string Url { get; private set; }
     }
 
+    [AttributeUsage(AttributeTargets.Method, AllowMultiple = false)]
     public class FactRequiredCompatibilityLevelAttribute : FactAttribute
     {
         public FactRequiredCompatibilityLevelAttribute(int level) : base()
@@ -42,6 +43,7 @@ static FactRequiredCompatibilityLevelAttribute()
         }
     }
 
+    [AttributeUsage(AttributeTargets.Method, AllowMultiple = false)]
     public class FactUnlessCaseSensitiveDatabaseAttribute : FactAttribute
     {
         public FactUnlessCaseSensitiveDatabaseAttribute() : base()

Dapper.Tests/Helpers/Common.cs

 using System;
 using System.Data;
 using System.Data.Common;
+using Xunit;
 
 namespace Dapper.Tests
 {
@@ -12,48 +13,48 @@ public static void DapperEnumValue(IDbConnection connection)
         {
             // test passing as AsEnum, reading as int
             var v = (AnEnum)connection.QuerySingle<int>("select @v, @y, @z", new { v = AnEnum.B, y = (AnEnum?)AnEnum.B, z = (AnEnum?)null });
-            v.IsEqualTo(AnEnum.B);
+            Assert.Equal(AnEnum.B, v);
 
             var args = new DynamicParameters();
             args.Add("v", AnEnum.B);
             args.Add("y", AnEnum.B);
             args.Add("z", null);
             v = (AnEnum)connection.QuerySingle<int>("select @v, @y, @z", args);
-            v.IsEqualTo(AnEnum.B);
+            Assert.Equal(AnEnum.B, v);
 
             // test passing as int, reading as AnEnum
             var k = (int)connection.QuerySingle<AnEnum>("select @v, @y, @z", new { v = (int)AnEnum.B, y = (int?)(int)AnEnum.B, z = (int?)null });
-            k.IsEqualTo((int)AnEnum.B);
+            Assert.Equal(k, (int)AnEnum.B);
 
             args = new DynamicParameters();
             args.Add("v", (int)AnEnum.B);
             args.Add("y", (int)AnEnum.B);
             args.Add("z", null);
             k = (int)connection.QuerySingle<AnEnum>("select @v, @y, @z", args);
-            k.IsEqualTo((int)AnEnum.B);
+            Assert.Equal(k, (int)AnEnum.B);
         }
 
         public static void TestDateTime(DbConnection connection)
         {
             DateTime? now = DateTime.UtcNow;
             try { connection.Execute("DROP TABLE Persons"); } catch { /* don't care */ }
-            connection.Execute(@"CREATE TABLE Persons (id int not null, dob datetime null)");
-            connection.Execute(@"INSERT Persons (id, dob) values (@id, @dob)",
+            connection.Execute("CREATE TABLE Persons (id int not null, dob datetime null)");
+            connection.Execute("INSERT Persons (id, dob) values (@id, @dob)",
                  new { id = 7, dob = (DateTime?)null });
-            connection.Execute(@"INSERT Persons (id, dob) values (@id, @dob)",
+            connection.Execute("INSERT Persons (id, dob) values (@id, @dob)",
                  new { id = 42, dob = now });
 
             var row = connection.QueryFirstOrDefault<NullableDatePerson>(
                 "SELECT id, dob, dob as dob2 FROM Persons WHERE id=@id", new { id = 7 });
-            row.IsNotNull();
-            row.Id.IsEqualTo(7);
-            row.DoB.IsNull();
-            row.DoB2.IsNull();
+            Assert.NotNull(row);
+            Assert.Equal(7, row.Id);
+            Assert.Null(row.DoB);
+            Assert.Null(row.DoB2);
 
             row = connection.QueryFirstOrDefault<NullableDatePerson>(
                 "SELECT id, dob FROM Persons WHERE id=@id", new { id = 42 });
-            row.IsNotNull();
-            row.Id.IsEqualTo(42);
+            Assert.NotNull(row);
+            Assert.Equal(42, row.Id);
             row.DoB.Equals(now);
             row.DoB2.Equals(now);
         }

Dapper.Tests/LiteralTests.cs

@@ -38,10 +38,10 @@ public void LiteralReplacementDynamicEnumAndString()
         public void LiteralReplacementBoolean()
         {
             var row = connection.Query<int?>("select 42 where 1 = {=val}", new { val = true }).SingleOrDefault();
-            row.IsNotNull();
-            row.IsEqualTo(42);
+            Assert.NotNull(row);
+            Assert.Equal(42, row);
             row = connection.Query<int?>("select 42 where 1 = {=val}", new { val = false }).SingleOrDefault();
-            row.IsNull();
+            Assert.Null(row);
         }
 
         [Fact]
@@ -67,7 +67,7 @@ public void LiteralIn()
             });
             var count = connection.Query<int>("select count(1) from #literalin where id in {=ids}",
                 new { ids = new[] { 1, 3, 4 } }).Single();
-            count.IsEqualTo(2);
+            Assert.Equal(2, count);
         }
 
         [Fact]
@@ -78,9 +78,9 @@ public void LiteralReplacement()
             var rows = new[] { new { id = 1, foo = 2 }, new { id = 3, foo = 4 } };
             connection.Execute("insert #literal1 (id,foo) values ({=id}, @foo)", rows);
             var count = connection.Query<int>("select count(1) from #literal1 where id={=foo}", new { foo = 123 }).Single();
-            count.IsEqualTo(1);
+            Assert.Equal(1, count);
             int sum = connection.Query<int>("select sum(id) + sum(foo) from #literal1").Single();
-            sum.IsEqualTo(123 + 456 + 1 + 2 + 3 + 4);
+            Assert.Equal(sum, 123 + 456 + 1 + 2 + 3 + 4);
         }
 
         [Fact]
@@ -94,7 +94,7 @@ public void LiteralReplacementDynamic()
             args = new DynamicParameters();
             args.Add("foo", 123);
             var count = connection.Query<int>("select count(1) from #literal2 where id={=foo}", args).Single();
-            count.IsEqualTo(1);
+            Assert.Equal(1, count);
         }
     }
 }

Dapper.Tests/NullTests.cs

@@ -34,30 +34,30 @@ private void TestNullable(bool applyNulls)
 
                 var obj = data[2];
 
-                obj.Id.IsEqualTo(2);
-                obj.A.IsEqualTo(42);
-                obj.B.IsEqualTo(42);
-                obj.C.IsEqualTo("abc");
-                obj.D.IsEqualTo(AnEnum.A);
-                obj.E.IsEqualTo(AnEnum.A);
+                Assert.Equal(2, obj.Id);
+                Assert.Equal(42, obj.A);
+                Assert.Equal(42, obj.B);
+                Assert.Equal("abc", obj.C);
+                Assert.Equal(AnEnum.A, obj.D);
+                Assert.Equal(AnEnum.A, obj.E);
 
                 obj = data[1];
-                obj.Id.IsEqualTo(1);
+                Assert.Equal(1, obj.Id);
                 if (applyNulls)
                 {
-                    obj.A.IsEqualTo(2); // cannot be null
-                    obj.B.IsEqualTo(null);
-                    obj.C.IsEqualTo(null);
-                    obj.D.IsEqualTo(AnEnum.B);
-                    obj.E.IsEqualTo(null);
+                    Assert.Equal(2, obj.A); // cannot be null
+                    Assert.Null(obj.B);
+                    Assert.Null(obj.C);
+                    Assert.Equal(AnEnum.B, obj.D);
+                    Assert.Null(obj.E);
                 }
 				else
                 {
-                    obj.A.IsEqualTo(2);
-                    obj.B.IsEqualTo(2);
-                    obj.C.IsEqualTo("def");
-                    obj.D.IsEqualTo(AnEnum.B);
-                    obj.E.IsEqualTo(AnEnum.B);
+                    Assert.Equal(2, obj.A);
+                    Assert.Equal(2, obj.B);
+                    Assert.Equal("def", obj.C);
+                    Assert.Equal(AnEnum.B, obj.D);
+                    Assert.Equal(AnEnum.B, obj.E);
                 }
             } finally
             {

Dapper.Tests/ProcedureTests.cs

@@ -26,7 +26,7 @@ @Bar int
             var args = new DynamicParameters(obj);
             args.Add("ID", 0, direction: ParameterDirection.Output);
             connection.Execute("#TestProcWithOutParameter", args, commandType: CommandType.StoredProcedure);
-            args.Get<int>("ID").IsEqualTo(7);
+            Assert.Equal(7, args.Get<int>("ID"));
         }
 
         [Fact]
@@ -50,8 +50,8 @@ @Bar int
             args.Add("ID", 0, direction: ParameterDirection.Output);
             args.Add("result", 0, direction: ParameterDirection.ReturnValue);
             connection.Execute("#TestProcWithOutAndReturnParameter", args, commandType: CommandType.StoredProcedure);
-            args.Get<int>("ID").IsEqualTo(7);
-            args.Get<int>("result").IsEqualTo(42);
+            Assert.Equal(7, args.Get<int>("ID"));
+            Assert.Equal(42, args.Get<int>("result"));
         }
 
         [Fact]
@@ -78,12 +78,12 @@ public void TestIssue17648290()
         END");
             var result = connection.Query(sql: "#up_MessageProcessed_get", param: p, commandType: CommandType.StoredProcedure);
             var row = result.Single();
-            ((int)row.MessageProcessID).IsEqualTo(2);
-            ((int)row.StartNum).IsEqualTo(38349348);
-            ((int)row.EndNum).IsEqualTo(3874900);
+            Assert.Equal(2, (int)row.MessageProcessID);
+            Assert.Equal(38349348, (int)row.StartNum);
+            Assert.Equal(3874900, (int)row.EndNum);
             DateTime startDate = row.StartDate, endDate = row.EndDate;
-            p.Get<int>("SuccessCode").IsEqualTo(0);
-            p.Get<string>("ErrorDescription").IsEqualTo("Completed successfully");
+            Assert.Equal(0, p.Get<int>("SuccessCode"));
+            Assert.Equal("Completed successfully", p.Get<string>("ErrorDescription"));
         }
 
         [Fact]
@@ -97,7 +97,7 @@ public void SO24605346_ProcsAndStrings()
                 TaxInvoiceNumber = InvoiceNumber
             }, commandType: CommandType.StoredProcedure).FirstOrDefault();
 
-            result.TaxInvoiceNumber.IsEqualTo("INV0000000028PPN");
+            Assert.Equal("INV0000000028PPN", result.TaxInvoiceNumber);
         }
 
         private class PracticeRebateOrders
@@ -125,8 +125,8 @@ public void Issue327_ReadEmptyProcedureResults()
             var query = connection.QueryMultiple("#TestEmptyResults", commandType: CommandType.StoredProcedure);
             var result1 = query.Read<Issue327_Person>();
             var result2 = query.Read<Issue327_Magic>();
-            result1.Any().IsFalse();
-            result2.Any().IsFalse();
+            Assert.False(result1.Any());
+            Assert.False(result2.Any());
         }
 
         private class Issue327_Person
@@ -159,10 +159,10 @@ public void TestProcSupport()
 	select 1111
 	return @a
 end");
-            connection.Query<int>("#TestProc", p, commandType: CommandType.StoredProcedure).First().IsEqualTo(1111);
+            Assert.Equal(1111, connection.Query<int>("#TestProc", p, commandType: CommandType.StoredProcedure).First());
 
-            p.Get<int>("c").IsEqualTo(11);
-            p.Get<int>("b").IsEqualTo(999);
+            Assert.Equal(11, p.Get<int>("c"));
+            Assert.Equal(999, p.Get<int>("b"));
         }
 
         // https://stackoverflow.com/q/8593871
@@ -178,10 +178,10 @@ public void TestListOfAnsiStrings()
                 }
                 }).ToList();
 
-            results.Count.IsEqualTo(2);
+            Assert.Equal(2, results.Count);
             results.Sort();
-            results[0].IsEqualTo("a");
-            results[1].IsEqualTo("b");
+            Assert.Equal("a", results[0]);
+            Assert.Equal("b", results[1]);
         }
     }
 }

Dapper.Tests/Providers/EntityFrameworkTests.cs

@@ -24,8 +24,8 @@ public void Issue570_DbGeo_HasValues()
             var fromDb = connection.QuerySingle<DbGeography>("declare @geos table(geo geography); insert @geos(geo) values(@val); select * from @geos",
                 new { val = orig });
 
-            fromDb.Area.IsNotNull();
-            fromDb.Area.IsEqualTo(orig.Area);
+            Assert.NotNull(fromDb.Area);
+            Assert.Equal(orig.Area, fromDb.Area);
         }
 #endif
 
@@ -34,7 +34,7 @@ public void Issue22_ExecuteScalar_EntityFramework()
         {
             var geo = DbGeography.LineFromText("LINESTRING(-122.360 47.656, -122.343 47.656 )", 4326);
             var geo2 = connection.ExecuteScalar<DbGeography>("select @geo", new { geo });
-            geo2.IsNotNull();
+            Assert.NotNull(geo2);
         }
     }
 }

Dapper.Tests/Providers/FirebirdTests.cs

@@ -10,12 +10,12 @@ public class FirebirdTests : TestBase
         [Fact(Skip = "Bug in Firebird; a PR to fix it has been submitted")]
         public void Issue178_Firebird()
         {
-            const string cs = @"initial catalog=localhost:database;user id=SYSDBA;password=masterkey";
+            const string cs = "initial catalog=localhost:database;user id=SYSDBA;password=masterkey";
 
             using (var connection = new FbConnection(cs))
             {
                 connection.Open();
-                const string sql = @"select count(*) from Issue178";
+                const string sql = "select count(*) from Issue178";
                 try { connection.Execute("drop table Issue178"); }
                 catch { /* don't care */ }
                 connection.Execute("create table Issue178(id int not null)");
@@ -24,23 +24,23 @@ public void Issue178_Firebird()
                 using (var sqlCmd = new FbCommand(sql, connection))
                 using (IDataReader reader1 = sqlCmd.ExecuteReader())
                 {
-                    Assert.IsTrue(reader1.Read());
-                    reader1.GetInt32(0).IsEqualTo(1);
-                    Assert.IsFalse(reader1.Read());
-                    Assert.IsFalse(reader1.NextResult());
+                    Assert.True(reader1.Read());
+                    Assert.Equal(1, reader1.GetInt32(0));
+                    Assert.False(reader1.Read());
+                    Assert.False(reader1.NextResult());
                 }
 
                 // dapper
                 using (var reader2 = connection.ExecuteReader(sql))
                 {
-                    Assert.IsTrue(reader2.Read());
-                    reader2.GetInt32(0).IsEqualTo(1);
-                    Assert.IsFalse(reader2.Read());
-                    Assert.IsFalse(reader2.NextResult());
+                    Assert.True(reader2.Read());
+                    Assert.Equal(1, reader2.GetInt32(0));
+                    Assert.False(reader2.Read());
+                    Assert.False(reader2.NextResult());
                 }
 
                 var count = connection.Query<int>(sql).Single();
-                count.IsEqualTo(1);
+                Assert.Equal(1, count);
             }
         }
     }

Dapper.Tests/Providers/Linq2SqlTests.cs

@@ -19,7 +19,7 @@ public void TestLinqBinaryToClass()
 
             var output = connection.Query<WithBinary>("select @input as [Value]", new { input }).First().Value;
 
-            output.ToArray().IsSequenceEqualTo(orig);
+            Assert.Equal(orig, output.ToArray());
         }
 
         [Fact]
@@ -31,7 +31,7 @@ public void TestLinqBinaryRaw()
 
             var output = connection.Query<System.Data.Linq.Binary>("select @input as [Value]", new { input }).First();
 
-            output.ToArray().IsSequenceEqualTo(orig);
+            Assert.Equal(orig, output.ToArray());
         }
 
         private class WithBinary
@@ -39,7 +39,6 @@ private class WithBinary
             public System.Data.Linq.Binary Value { get; set; }
         }
 
-
         private class NoDefaultConstructorWithBinary
         {
             public System.Data.Linq.Binary Value { get; set; }
@@ -57,7 +56,7 @@ public void TestNoDefaultConstructorBinary()
             new Random(123456).NextBytes(orig);
             var input = new System.Data.Linq.Binary(orig);
             var output = connection.Query<NoDefaultConstructorWithBinary>("select @input as val", new { input }).First().Value;
-            output.ToArray().IsSequenceEqualTo(orig);
+            Assert.Equal(orig, output.ToArray());
         }
     }
 }

Dapper.Tests/Providers/MySQLTests.cs

@@ -54,14 +54,14 @@ public void Issue552_SignedUnsignedBooleans()
 
                 var rows = conn.Query<MySqlHasBool>("select * from bar;").ToDictionary(x => x.Id);
 
-                rows[1].Bool_Val.IsNull();
-                rows[2].Bool_Val.IsEqualTo(false);
-                rows[3].Bool_Val.IsEqualTo(true);
-                rows[4].Bool_Val.IsNull();
-                rows[5].Bool_Val.IsEqualTo(true);
-                rows[6].Bool_Val.IsEqualTo(false);
-                rows[7].Bool_Val.IsNull();
-                rows[8].Bool_Val.IsEqualTo(true);
+                Assert.Null(rows[1].Bool_Val);
+                Assert.False(rows[2].Bool_Val);
+                Assert.True(rows[3].Bool_Val);
+                Assert.Null(rows[4].Bool_Val);
+                Assert.True(rows[5].Bool_Val);
+                Assert.False(rows[6].Bool_Val);
+                Assert.Null(rows[7].Bool_Val);
+                Assert.True(rows[8].Bool_Val);
             }
         }
 
@@ -125,8 +125,8 @@ public void Issue426_SO34439033_DateTimeGainsTicks()
                 conn.Execute("replace into Issue426_Test values (@Id,@Time)", localObj);
 
                 var dbObj = conn.Query<Issue426_Test>("select * from Issue426_Test where Id = @id", new { id = Id }).Single();
-                dbObj.Id.IsEqualTo(Id);
-                dbObj.Time.Value.Ticks.IsEqualTo(ticks);
+                Assert.Equal(Id, dbObj.Id);
+                Assert.Equal(ticks, dbObj.Time.Value.Ticks);
             }
         }
 
@@ -142,10 +142,10 @@ public void SO36303462_Tinyint_Bools()
                 conn.Execute("insert SO36303462_Test (Id, IsBold) values (3,1);");
 
                 var rows = conn.Query<SO36303462>("select * from SO36303462_Test").ToDictionary(x => x.Id);
-                rows.Count.IsEqualTo(3);
-                rows[1].IsBold.IsTrue();
-                rows[2].IsBold.IsFalse();
-                rows[3].IsBold.IsTrue();
+                Assert.Equal(3, rows.Count);
+                Assert.True(rows[1].IsBold);
+                Assert.False(rows[2].IsBold);
+                Assert.True(rows[3].IsBold);
             }
         }
 
@@ -161,6 +161,7 @@ public class Issue426_Test
             public TimeSpan? Time { get; set; }
         }
 
+        [AttributeUsage(AttributeTargets.Method, AllowMultiple = false)]
         public class FactMySqlAttribute : FactAttribute
         {
             public override string Skip

Dapper.Tests/Providers/OLDEBTests.cs

@@ -31,8 +31,8 @@ public void TestOleDbParameters()
                 ).Single();
                 int age = row.Age;
                 int id = row.Id;
-                age.IsEqualTo(23);
-                id.IsEqualTo(12);
+                Assert.Equal(23, age);
+                Assert.Equal(12, id);
             }
         }
 
@@ -42,7 +42,7 @@ public void PseudoPositionalParameters_Simple()
             using (var connection = GetOleDbConnection())
             {
                 int value = connection.Query<int>("select ?x? + ?y_2? + ?z?", new { x = 1, y_2 = 3, z = 5, z2 = 24 }).Single();
-                value.IsEqualTo(9);
+                Assert.Equal(9, value);
             }
         }
 
@@ -67,7 +67,7 @@ public void PseudoPositionalParameters_Dynamic()
                 args.Add("z", 5);
                 args.Add("z2", 24);
                 int value = connection.Query<int>("select ?x? + ?y_2? + ?z?", args).Single();
-                value.IsEqualTo(9);
+                Assert.Equal(9, value);
             }
         }
 
@@ -76,15 +76,8 @@ public void PseudoPositionalParameters_ReusedParameter()
         {
             using (var connection = GetOleDbConnection())
             {
-                try
-                {
-                    int value = connection.Query<int>("select ?x? + ?y_2? + ?x?", new { x = 1, y_2 = 3 }).Single();
-                    Assert.Fail();
-                }
-                catch (InvalidOperationException ex)
-                {
-                    ex.Message.IsEqualTo("When passing parameters by position, each parameter can only be referenced once");
-                }
+                var ex = Assert.Throws<InvalidOperationException>(() => connection.Query<int>("select ?x? + ?y_2? + ?x?", new { x = 1, y_2 = 3 }).Single());
+                Assert.Equal("When passing parameters by position, each parameter can only be referenced once", ex.Message);
             }
         }
 
@@ -96,7 +89,7 @@ public void Issue569_SO38527197_PseudoPositionalParameters_In()
                 int[] ids = { 1, 2, 5, 7 };
                 var list = connection.Query<int>("select * from string_split('1,2,3,4,5',',') where value in ?ids?", new { ids }).AsList();
                 list.Sort();
-                string.Join(",", list).IsEqualTo("1,2,5");
+                Assert.Equal("1,2,5", string.Join(",", list));
             }
         }
 
@@ -109,8 +102,8 @@ public void PseudoPositional_CanUseVariable()
                 var row = connection.QuerySingle("declare @id int = ?id?; select @id as [A], @id as [B];", new { id });
                 int a = (int)row.A;
                 int b = (int)row.B;
-                a.IsEqualTo(42);
-                b.IsEqualTo(42);
+                Assert.Equal(42, a);
+                Assert.Equal(42, b);
             }
         }
 
@@ -119,16 +112,12 @@ public void PseudoPositional_CannotUseParameterMultipleTimes()
         {
             using (var connection = GetOleDbConnection())
             {
-                try
+                var ex = Assert.Throws<InvalidOperationException>(() =>
                 {
                     const int id = 42;
-                    var row = connection.QuerySingle("select ?id? as [A], ?id? as [B];", new { id });
-                    Assert.Fail();
-                }
-                catch (InvalidOperationException ex) when (ex.Message == "When passing parameters by position, each parameter can only be referenced once")
-                {
-                    // that's a win
-                }
+                    connection.QuerySingle("select ?id? as [A], ?id? as [B];", new { id });
+                });
+                Assert.Equal("When passing parameters by position, each parameter can only be referenced once", ex.Message);
             }
         }
 
@@ -141,8 +130,8 @@ public void PseudoPositionalParameters_ExecSingle()
                 connection.Execute("create table #named_single(val int not null)");
                 int count = connection.Execute("insert #named_single (val) values (?x?)", data);
                 int sum = (int)connection.ExecuteScalar("select sum(val) from #named_single");
-                count.IsEqualTo(1);
-                sum.IsEqualTo(6);
+                Assert.Equal(1, count);
+                Assert.Equal(6, sum);
             }
         }
 
@@ -160,8 +149,8 @@ public void PseudoPositionalParameters_ExecMulti()
                 connection.Execute("create table #named_multi(val int not null)");
                 int count = connection.Execute("insert #named_multi (val) values (?x?)", data);
                 int sum = (int)connection.ExecuteScalar("select sum(val) from #named_multi");
-                count.IsEqualTo(3);
-                sum.IsEqualTo(10);
+                Assert.Equal(3, count);
+                Assert.Equal(10, sum);
             }
         }
 
@@ -187,8 +176,8 @@ public void Issue457_NullParameterValues()
                 var a = (DateTime?)row.Since;
                 var b = (string)row.Code;
 
-                a.IsEqualTo(since);
-                b.IsEqualTo(code);
+                Assert.Equal(since, a);
+                Assert.Equal(code, b);
             }
         }
 
@@ -214,8 +203,8 @@ public void Issue457_NullParameterValues_Named()
                 var a = (DateTime?)row.Since;
                 var b = (string)row.Code;
 
-                a.IsEqualTo(since);
-                b.IsEqualTo(code);
+                Assert.Equal(since, a);
+                Assert.Equal(code, b);
             }
         }
 
@@ -243,8 +232,8 @@ public async void Issue457_NullParameterValues_MultiAsync()
                     var a = (DateTime?)row.Since;
                     var b = (string)row.Code;
 
-                    a.IsEqualTo(since);
-                    b.IsEqualTo(code);
+                    Assert.Equal(a, since);
+                    Assert.Equal(b, code);
                 }
             }
         }
@@ -273,8 +262,8 @@ public async void Issue457_NullParameterValues_MultiAsync_Named()
                     var a = (DateTime?)row.Since;
                     var b = (string)row.Code;
 
-                    a.IsEqualTo(since);
-                    b.IsEqualTo(code);
+                    Assert.Equal(a, since);
+                    Assert.Equal(b, code);
                 }
             }
         }

Dapper.Tests/Providers/PostgresqlTests.cs

@@ -48,14 +48,15 @@ public void TestPostgresqlArrayParameters()
                 conn.Execute("insert into tcat(breed, name) values(:breed, :name) ", Cats);
 
                 var r = conn.Query<Cat>("select * from tcat where id=any(:catids)", new { catids = new[] { 1, 3, 5 } });
-                r.Count().IsEqualTo(3);
-                r.Count(c => c.Id == 1).IsEqualTo(1);
-                r.Count(c => c.Id == 3).IsEqualTo(1);
-                r.Count(c => c.Id == 5).IsEqualTo(1);
+                Assert.Equal(3, r.Count());
+                Assert.Equal(1, r.Count(c => c.Id == 1));
+                Assert.Equal(1, r.Count(c => c.Id == 3));
+                Assert.Equal(1, r.Count(c => c.Id == 5));
                 transaction.Rollback();
             }
         }
 
+        [AttributeUsage(AttributeTargets.Method, AllowMultiple = false)]
         public class FactPostgresqlAttribute : FactAttribute
         {
             public override string Skip

Dapper.Tests/Providers/SQLCETests.cs

@@ -29,11 +29,11 @@ public void MultiRSSqlCE()
                 cnn.Execute("insert Posts values(2,'title2','body2',null)");
                 cnn.Execute("insert Authors values(1,'sam')");
 
-                var data = cnn.Query<PostCE, AuthorCE, PostCE>(@"select * from Posts p left join Authors a on a.ID = p.AuthorID", (post, author) => { post.Author = author; return post; }).ToList();
+                var data = cnn.Query<PostCE, AuthorCE, PostCE>("select * from Posts p left join Authors a on a.ID = p.AuthorID", (post, author) => { post.Author = author; return post; }).ToList();
                 var firstPost = data[0];
-                firstPost.Title.IsEqualTo("title");
-                firstPost.Author.Name.IsEqualTo("sam");
-                data[1].Author.IsNull();
+                Assert.Equal("title", firstPost.Title);
+                Assert.Equal("sam", firstPost.Author.Name);
+                Assert.Null(data[1].Author);
             }
         }
 

Dapper.Tests/Providers/SqliteTests.cs

@@ -34,15 +34,15 @@ public void Issue466_SqliteHatesOptimizations()
                 {
                     SqlMapper.ResetTypeHandlers();
                     var row = connection.Query<HazNameId>("select 42 as Id").First();
-                    row.Id.IsEqualTo(42);
+                    Assert.Equal(42, row.Id);
                     row = connection.Query<HazNameId>("select 42 as Id").First();
-                    row.Id.IsEqualTo(42);
+                    Assert.Equal(42, row.Id);
 
                     SqlMapper.ResetTypeHandlers();
                     row = connection.QueryFirst<HazNameId>("select 42 as Id");
-                    row.Id.IsEqualTo(42);
+                    Assert.Equal(42, row.Id);
                     row = connection.QueryFirst<HazNameId>("select 42 as Id");
-                    row.Id.IsEqualTo(42);
+                    Assert.Equal(42, row.Id);
                 }
             }
 
@@ -53,15 +53,15 @@ public async Task Issue466_SqliteHatesOptimizations_Async()
                 {
                     SqlMapper.ResetTypeHandlers();
                     var row = (await connection.QueryAsync<HazNameId>("select 42 as Id").ConfigureAwait(false)).First();
-                    row.Id.IsEqualTo(42);
+                    Assert.Equal(42, row.Id);
                     row = (await connection.QueryAsync<HazNameId>("select 42 as Id").ConfigureAwait(false)).First();
-                    row.Id.IsEqualTo(42);
+                    Assert.Equal(42, row.Id);
 
                     SqlMapper.ResetTypeHandlers();
                     row = await connection.QueryFirstAsync<HazNameId>("select 42 as Id").ConfigureAwait(false);
-                    row.Id.IsEqualTo(42);
+                    Assert.Equal(42, row.Id);
                     row = await connection.QueryFirstAsync<HazNameId>("select 42 as Id").ConfigureAwait(false);
-                    row.Id.IsEqualTo(42);
+                    Assert.Equal(42, row.Id);
                 }
             }
         }
@@ -87,10 +87,11 @@ private void Isse467_SqliteParameterNaming(bool prefix)
                 const SqliteType type = SqliteType.Integer;
                 cmd.Parameters.Add(prefix ? "@foo" : "foo", type).Value = 42;
                 var i = Convert.ToInt32(cmd.ExecuteScalar());
-                i.IsEqualTo(42);
+                Assert.Equal(42, i);
             }
         }
 
+        [AttributeUsage(AttributeTargets.Method, AllowMultiple = false)]
         public class FactSqliteAttribute : FactAttribute
         {
             public override string Skip

Dapper.Tests/QueryMultipleTests.cs

@@ -63,7 +63,7 @@ public void TestQueryMultipleNonBufferedCorrectOrder()
         [Fact]
         public void TestMultiReaderBasic()
         {
-            const string sql = @"select 1 as Id union all select 2 as Id     select 'abc' as name   select 1 as Id union all select 2 as Id";
+            const string sql = "select 1 as Id union all select 2 as Id     select 'abc' as name   select 1 as Id union all select 2 as Id";
             int i, j;
             string s;
             using (var multi = connection.QueryMultiple(sql))
@@ -72,9 +72,9 @@ public void TestMultiReaderBasic()
                 s = multi.Read<string>().Single();
                 j = multi.Read<int>().Sum();
             }
-            Assert.IsEqualTo(i, 1);
-            Assert.IsEqualTo(s, "abc");
-            Assert.IsEqualTo(j, 3);
+            Assert.Equal(1, i);
+            Assert.Equal("abc", s);
+            Assert.Equal(3, j);
         }
 
         [Fact]
@@ -102,11 +102,11 @@ public void TestReadDynamicWithGridReader()
                 var users = grid.Read().ToList();
                 var posts = grid.Read().ToList();
 
-                users.Count.IsEqualTo(2);
-                posts.Count.IsEqualTo(3);
+                Assert.Equal(2, users.Count);
+                Assert.Equal(3, posts.Count);
 
-                ((int)users[0].Id).IsEqualTo(2);
-                ((int)posts[0].Id).IsEqualTo(3);
+                Assert.Equal(2, (int)users[0].Id);
+                Assert.Equal(3, (int)posts[0].Id);
             }
             finally
             {
@@ -133,7 +133,7 @@ select @b
                 reader.Read();
             }
             var retVal = p.Get<int>("RetVal");
-            retVal.IsEqualTo(3);
+            Assert.Equal(3, retVal);
         }
 
         [Fact]
@@ -141,14 +141,14 @@ public void Issue524_QueryMultiple_Cast()
         {
             // aka: Read<int> should work even if the data is a <long>
             // using regular API
-            connection.Query<int>("select cast(42 as bigint)").Single().IsEqualTo(42);
-            connection.QuerySingle<int>("select cast(42 as bigint)").IsEqualTo(42);
+            Assert.Equal(42, connection.Query<int>("select cast(42 as bigint)").Single());
+            Assert.Equal(42, connection.QuerySingle<int>("select cast(42 as bigint)"));
 
             // using multi-reader API
             using(var reader = connection.QueryMultiple("select cast(42 as bigint); select cast(42 as bigint)"))
             {
-                reader.Read<int>().Single().IsEqualTo(42);
-                reader.ReadSingle<int>().IsEqualTo(42);
+                Assert.Equal(42, reader.Read<int>().Single());
+                Assert.Equal(42, reader.ReadSingle<int>());
             }
         }
 
@@ -159,10 +159,10 @@ public void QueryMultipleFromClosed()
             {
                 using (var multi = conn.QueryMultiple("select 1; select 'abc';"))
                 {
-                    multi.Read<int>().Single().IsEqualTo(1);
-                    multi.Read<string>().Single().IsEqualTo("abc");
+                    Assert.Equal(1, multi.Read<int>().Single());
+                    Assert.Equal("abc", multi.Read<string>().Single());
                 }
-                conn.State.IsEqualTo(ConnectionState.Closed);
+                Assert.Equal(ConnectionState.Closed, conn.State);
             }
         }
 
@@ -171,14 +171,14 @@ public void QueryMultiple2FromClosed()
         {
             using (var conn = GetClosedConnection())
             {
-                conn.State.IsEqualTo(ConnectionState.Closed);
+                Assert.Equal(ConnectionState.Closed, conn.State);
                 using (var multi = conn.QueryMultiple("select 1 select 2 select 3"))
                 {
-                    multi.Read<int>().Single().IsEqualTo(1);
-                    multi.Read<int>().Single().IsEqualTo(2);
+                    Assert.Equal(1, multi.Read<int>().Single());
+                    Assert.Equal(2, multi.Read<int>().Single());
                     // not reading 3 is intentional here
                 }
-                conn.State.IsEqualTo(ConnectionState.Closed);
+                Assert.Equal(ConnectionState.Closed, conn.State);
             }
         }
 
@@ -192,10 +192,10 @@ public void SO35554284_QueryMultipleUntilConsumed()
                 {
                     items.AddRange(reader.Read<HazNameId>());
                 }
-                items.Count.IsEqualTo(3);
-                items[0].Id.IsEqualTo(1);
-                items[1].Id.IsEqualTo(2);
-                items[2].Id.IsEqualTo(3);
+                Assert.Equal(3, items.Count);
+                Assert.Equal(1, items[0].Id);
+                Assert.Equal(2, items[1].Id);
+                Assert.Equal(3, items[2].Id);
             }
         }
 
@@ -204,15 +204,8 @@ public void QueryMultipleInvalidFromClosed()
         {
             using (var conn = GetClosedConnection())
             {
-                try
-                {
-                    conn.QueryMultiple("select gibberish");
-                    false.IsEqualTo(true); // shouldn't have got here
-                }
-                catch
-                {
-                    conn.State.IsEqualTo(ConnectionState.Closed);
-                }
+                Assert.ThrowsAny<Exception>(() => conn.QueryMultiple("select gibberish"));
+                Assert.Equal(ConnectionState.Closed, conn.State);
             }
         }
 
@@ -237,15 +230,15 @@ private void TestMultiSelectWithSomeEmptyGrids(bool buffered)
                 }
                 catch (ObjectDisposedException ex)
                 { // expected; success
-                    ex.Message.IsEqualTo("The reader has been disposed; this can happen after all data has been consumed\r\nObject name: 'Dapper.SqlMapper+GridReader'.");
+                    Assert.Equal("The reader has been disposed; this can happen after all data has been consumed\r\nObject name: 'Dapper.SqlMapper+GridReader'.", ex.Message);
                 }
 
-                one.Length.IsEqualTo(1);
-                one[0].IsEqualTo(1);
-                two.Length.IsEqualTo(0);
-                three.Length.IsEqualTo(0);
-                four.Length.IsEqualTo(1);
-                four[0].IsEqualTo(4);
+                Assert.Single(one);
+                Assert.Equal(1, one[0]);
+                Assert.Empty(two);
+                Assert.Empty(three);
+                Assert.Single(four);
+                Assert.Equal(4, four[0]);
             }
         }
 
@@ -261,17 +254,17 @@ public void TypeBasedViaTypeMulti()
                 first = multi.Read(type).Single();
                 second = multi.Read(type).Single();
             }
-            ((object)first).GetType().IsEqualTo(type);
+            Assert.Equal(((object)first).GetType(), type);
             int a = first.A;
             string b = first.B;
-            a.IsEqualTo(123);
-            b.IsEqualTo("abc");
+            Assert.Equal(123, a);
+            Assert.Equal("abc", b);
 
-            ((object)second).GetType().IsEqualTo(type);
+            Assert.Equal(((object)second).GetType(), type);
             a = second.A;
             b = second.B;
-            a.IsEqualTo(456);
-            b.IsEqualTo("def");
+            Assert.Equal(456, a);
+            Assert.Equal("def", b);
         }
     }
 }

Dapper.Tests/TransactionTests.cs

@@ -23,7 +23,7 @@ public void TestTransactionCommit()
                     transaction.Commit();
                 }
 
-                connection.Query<int>("select count(*) from #TransactionTest;").Single().IsEqualTo(1);
+                Assert.Equal(1, connection.Query<int>("select count(*) from #TransactionTest;").Single());
             }
             finally
             {
@@ -45,7 +45,7 @@ public void TestTransactionRollback()
                     transaction.Rollback();
                 }
 
-                connection.Query<int>("select count(*) from #TransactionTest;").Single().IsEqualTo(0);
+                Assert.Equal(0, connection.Query<int>("select count(*) from #TransactionTest;").Single());
             }
             finally
             {
@@ -69,7 +69,7 @@ public void TestCommandWithInheritedTransaction()
                     transaction.Rollback();
                 }
 
-                connection.Query<int>("select count(*) from #TransactionTest;").Single().IsEqualTo(0);
+                Assert.Equal(0, connection.Query<int>("select count(*) from #TransactionTest;").Single());
             }
             finally
             {

Dapper.Tests/TupleTests.cs

@@ -8,38 +8,30 @@ public class TupleTests : TestBase
         [Fact]
         public void TupleStructParameter_Fails_HelpfulMessage()
         {
-            try
-            {
-                // I can see this happening...
-                connection.QuerySingle<int>("select @id", (id: 42, name: "Fred"));
-                Assert.Fail();
-            }
-            catch (NotSupportedException ex)
-            {
-                ex.Message.IsEqualTo("ValueTuple should not be used for parameters - the language-level names are not available to use as parameter names, and it adds unnecessary boxing");
-            }
+            var ex = Assert.Throws<NotSupportedException>(() => connection.QuerySingle<int>("select @id", (id: 42, name: "Fred")));
+            Assert.Equal("ValueTuple should not be used for parameters - the language-level names are not available to use as parameter names, and it adds unnecessary boxing", ex.Message);
         }
 
         [Fact]
         public void TupleClassParameter_Works()
         {
-            connection.QuerySingle<int>("select @Item1", Tuple.Create(42, "Fred")).IsEqualTo(42);
+            Assert.Equal(42, connection.QuerySingle<int>("select @Item1", Tuple.Create(42, "Fred")));
         }
 
         [Fact]
         public void TupleReturnValue_Works_ByPosition()
         {
             var val = connection.QuerySingle<(int id, string name)>("select 42, 'Fred'");
-            val.id.IsEqualTo(42);
-            val.name.IsEqualTo("Fred");
+            Assert.Equal(42, val.id);
+            Assert.Equal("Fred", val.name);
         }
 
         [Fact]
         public void TupleReturnValue_TooManyColumns_Ignored()
         {
             var val = connection.QuerySingle<(int id, string name)>("select 42, 'Fred', 123");
-            val.id.IsEqualTo(42);
-            val.name.IsEqualTo("Fred");
+            Assert.Equal(42, val.id);
+            Assert.Equal("Fred", val.name);
         }
 
         [Fact]
@@ -47,17 +39,17 @@ public void TupleReturnValue_TooFewColumns_Unmapped()
         {
             // I'm very wary of making this throw, but I can also see some sense in pointing out the oddness
             var val = connection.QuerySingle<(int id, string name, int extra)>("select 42, 'Fred'");
-            val.id.IsEqualTo(42);
-            val.name.IsEqualTo("Fred");
-            val.extra.IsEqualTo(0);
+            Assert.Equal(42, val.id);
+            Assert.Equal("Fred", val.name);
+            Assert.Equal(0, val.extra);
         }
 
         [Fact]
         public void TupleReturnValue_Works_NamesIgnored()
         {
             var val = connection.QuerySingle<(int id, string name)>("select 42 as [Item2], 'Fred' as [Item1]");
-            val.id.IsEqualTo(42);
-            val.name.IsEqualTo("Fred");
+            Assert.Equal(42, val.id);
+            Assert.Equal("Fred", val.name);
         }
     }
 }

Dapper.Tests/XmlTests.cs

@@ -19,9 +19,9 @@ public void CommonXmlTypesSupported()
                 C = XElement.Parse("<ghi/>")
             };
             var bar = connection.QuerySingle<Foo>("select @a as [A], @b as [B], @c as [C]", new { a = foo.A, b = foo.B, c = foo.C });
-            bar.A.DocumentElement.Name.IsEqualTo("abc");
-            bar.B.Root.Name.LocalName.IsEqualTo("def");
-            bar.C.Name.LocalName.IsEqualTo("ghi");
+            Assert.Equal("abc", bar.A.DocumentElement.Name);
+            Assert.Equal("def", bar.B.Root.Name.LocalName);
+            Assert.Equal("ghi", bar.C.Name.LocalName);
         }
 
         public class Foo