Fix several issues with SQLite compatibility with NET46

geoperez · geoperez · commit ed55ef6bea52 · 2017-11-20T11:34:27.000-06:00
diff --git a/src/Unosquare.Labs.LiteLib/LiteDbContext.cs b/src/Unosquare.Labs.LiteLib/LiteDbContext.cs
@@ -16,6 +16,8 @@
     using Swan.Reflection;
 #if MONO
     using Mono.Data.Sqlite;
+#elif NET46
+    using System.Data.SQLite;
 #else
     using Microsoft.Data.Sqlite;
 #endif
@@ -58,6 +60,8 @@ protected LiteDbContext(string databaseFilePath, bool enabledLog = true)
             var databaseExists = File.Exists(databaseFilePath);
 #if MONO
             Connection = new SqliteConnection($"URI=file:{databaseFilePath}");
+#elif NET46
+            Connection = new SQLiteConnection($"URI=file:{databaseFilePath}");
 #else
             var builder = new SqliteConnectionStringBuilder
             {
diff --git a/src/Unosquare.Labs.LiteLib/Unosquare.Labs.LiteLib.csproj b/src/Unosquare.Labs.LiteLib/Unosquare.Labs.LiteLib.csproj
@@ -9,7 +9,7 @@
     <PackageId>LiteLib</PackageId>
     <DebugType>Full</DebugType>
     <CodeAnalysisRuleSet>..\..\StyleCop.Analyzers.ruleset</CodeAnalysisRuleSet>
-    <Version>0.14.3</Version>
+    <Version>0.15.0</Version>
     <Authors>Unosquare</Authors>
     <Company>Unosquare</Company>
     <Copyright>Copyright (c) 2016-2017 Unosquare</Copyright>
@@ -20,6 +20,7 @@
     <PackageIconUrl>https://raw.githubusercontent.com/unosquare/litelib/master/litelib-logo.png</PackageIconUrl>
     <RepositoryType>git</RepositoryType>
     <PackageTags>orm sqlite dapper</PackageTags>
+    <ContentSQLiteInteropFiles>true</ContentSQLiteInteropFiles>
   </PropertyGroup>
 
   <ItemGroup>
@@ -28,12 +29,11 @@
     </PackageReference>
     <PackageReference Include="Dapper" Version="1.50.2" />
     <PackageReference Include="System.ComponentModel.Annotations" Version="4.4.0" />
-    <PackageReference Include="Unosquare.Swan" Version="0.17.1" />
+    <PackageReference Include="Unosquare.Swan" Version="0.18.0" />
   </ItemGroup>
 
   <ItemGroup Condition=" '$(TargetFramework)' == 'net46' ">
-    <PackageReference Include="Microsoft.Data.Sqlite" Version="1.0.1" />
-    <PackageReference Include="SQLite" Version="3.13.0" />
+    <PackageReference Include="System.Data.SQLite.Core" Version="1.0.106" />
   </ItemGroup>
 
   <ItemGroup Condition=" '$(TargetFramework)' == 'netstandard2.0' ">
diff --git a/test/Unosquare.Labs.LiteLib.Tests/DbContextAsyncFixture.cs b/test/Unosquare.Labs.LiteLib.Tests/DbContextAsyncFixture.cs
@@ -1,9 +1,13 @@
-﻿using Microsoft.Data.Sqlite;
-using NUnit.Framework;
+﻿using NUnit.Framework;
 using System.Linq;
 using System.Threading.Tasks;
 using Unosquare.Labs.LiteLib.Tests.Database;
 using Unosquare.Labs.LiteLib.Tests.Helpers;
+#if NET46
+using System.Data.SQLite;
+#else
+using Microsoft.Data.Sqlite;
+#endif
 
 namespace Unosquare.Labs.LiteLib.Tests
 {
@@ -42,7 +46,7 @@ public async Task SelectWithParametersAsync()
 
                     // Selecting Data By name
                     var selectingData =
-                        await context.Orders.SelectAsync("CustomerName = @CustomerName", new { CustomerName = "Peter" });
+                        await context.Orders.SelectAsync("CustomerName = @CustomerName", new {CustomerName = "Peter"});
 
                     foreach (var item in selectingData)
                     {
@@ -63,7 +67,7 @@ public async Task SelectDataAsync()
 
                     // Selecting Data By name
                     var selectingData =
-                        await context.Orders.SelectAsync("CustomerName = @CustomerName", new { CustomerName = "Peter" });
+                        await context.Orders.SelectAsync("CustomerName = @CustomerName", new {CustomerName = "Peter"});
 
                     foreach (var item in selectingData)
                     {
@@ -123,7 +127,7 @@ public async Task DeletingAsyncWithParams()
                     }
 
                     var deletedData =
-                        await context.Orders.DeleteAsync("CustomerName = @CustomerName", new { CustomerName = "Peter" });
+                        await context.Orders.DeleteAsync("CustomerName = @CustomerName", new {CustomerName = "Peter"});
                     Assert.AreEqual(deletedData, TestHelper.DataSource.Count(x => x.CustomerName == "Peter"));
                 }
             }
@@ -163,8 +167,11 @@ public async Task InsertAsyncUsingUnique_ThrowsSqliteException()
                     {
                         await context.Orders.InsertAsync(item);
                     }
-
+#if NET46
+                    Assert.ThrowsAsync<SQLiteException>(async () =>
+#else
                     Assert.ThrowsAsync<SqliteException>(async () =>
+#endif
                     {
                         var newOrder = new Order
                         {
@@ -173,6 +180,7 @@ public async Task InsertAsyncUsingUnique_ThrowsSqliteException()
                             ShipperCity = "Atlanta",
                             UniqueId = "1"
                         };
+
                         await context.Orders.InsertAsync(newOrder);
                     });
                 }
@@ -183,7 +191,11 @@ public async Task InsertAsyncWithOutOfRangeString_ThrowsSqliteException()
             {
                 using (var context = new TestDbContext(nameof(InsertAsyncWithOutOfRangeString_ThrowsSqliteException)))
                 {
+#if NET46
+                    Assert.ThrowsAsync<SQLiteException>(async () =>
+#else
                     Assert.ThrowsAsync<SqliteException>(async () =>
+#endif
                     {
                         await context.Orders.InsertAsync(new Order
                         {
@@ -209,15 +221,17 @@ public async Task AsyncUpdateData()
                     }
 
                     var list = await context.Orders.SelectAsync("CustomerName = @CustomerName",
-                        new { CustomerName = "John" });
+                        new {CustomerName = "John"});
+
                     foreach (var item in list)
                     {
                         item.ShipperCity = "Atlanta";
                         await context.Orders.UpdateAsync(item);
                     }
 
                     var updatedList =
-                        await context.Orders.SelectAsync("ShipperCity = @ShipperCity", new { ShipperCity = "Atlanta" });
+                        await context.Orders.SelectAsync("ShipperCity = @ShipperCity", new {ShipperCity = "Atlanta"});
+
                     foreach (var item in updatedList)
                     {
                         Assert.AreEqual("Atlanta", item.ShipperCity);
@@ -314,8 +328,9 @@ public async Task AsyncUpdateFromSetname()
                         item.ShipperCity = "Atlanta";
                         await context.UpdateAsync(item);
                     }
+
                     var updatedItems =
-                        await context.Orders.SelectAsync("ShipperCity = @ShipperCity", new { ShipperCity = "Atlanta" });
+                        await context.Orders.SelectAsync("ShipperCity = @ShipperCity", new {ShipperCity = "Atlanta"});
                     Assert.AreEqual(TestHelper.DataSource.Length, updatedItems.Count());
                 }
             }
@@ -337,7 +352,7 @@ public async Task AsyncQueryData()
                         await
                             context.QueryAsync<Order>(
                                 $"{context.Orders.SelectDefinition} WHERE CustomerName = @CustomerName",
-                                new Order { CustomerName = "John" });
+                                new Order {CustomerName = "John"});
 
                     foreach (var item in selectedData)
                     {
diff --git a/test/Unosquare.Labs.LiteLib.Tests/DbContextFixture.cs b/test/Unosquare.Labs.LiteLib.Tests/DbContextFixture.cs
@@ -5,7 +5,9 @@
 using Unosquare.Labs.LiteLib.Tests.Database;
 using Unosquare.Labs.LiteLib.Tests.Helpers;
 #if MONO
-    using Mono.Data.Sqlite;
+using Mono.Data.Sqlite;
+#elif NET46
+using System.Data.SQLite;
 #else
 using Microsoft.Data.Sqlite;
 #endif
@@ -48,7 +50,7 @@ public void SelectDataWithParameters()
                         context.Orders.Insert(item);
                     }
 
-                    var entities = context.Orders.Select("CustomerName = @CustomerName", new { CustomerName = "John" });
+                    var entities = context.Orders.Select("CustomerName = @CustomerName", new {CustomerName = "John"});
                     foreach (var item in entities)
                     {
                         Assert.AreEqual("John", item.CustomerName);
@@ -65,14 +67,17 @@ public void SelectWithBadParameters_ThrowsException()
                     {
                         context.Orders.Insert(item);
                     }
-
+#if NET46
+                    Assert.Throws<SQLiteException>(() =>
+#else
                     Assert.Throws<SqliteException>(() =>
+#endif
                     {
-                        var entities = context.Orders.Select("Customer = @CustomerName", new { CustomerName = "John" });
+                        var entities = context.Orders.Select("Customer = @CustomerName", new {CustomerName = "John"});
                     });
                 }
             }
-            
+
             [Test]
             public void SelectingFirstOrDefault()
             {
@@ -119,7 +124,8 @@ public void DeletingUsingParams()
                         context.Orders.Insert(item);
                     }
 
-                    var deletedData = context.Orders.Delete("CustomerName = @CustomerName", new { CustomerName = "Peter" });
+                    var deletedData =
+                        context.Orders.Delete("CustomerName = @CustomerName", new {CustomerName = "Peter"});
                     Assert.AreEqual(deletedData, TestHelper.DataSource.Count(x => x.CustomerName == "Peter"));
                 }
             }
@@ -134,8 +140,14 @@ public void DeletingUsingInvalidParams_TrhowsSqliteException()
                         context.Orders.Insert(item);
                     }
 
-                    Assert.Throws<SqliteException>(() => {
-                        var deletedData = context.Orders.Delete("Customer = @CustomerName", new { CustomerName = "Peter" });
+#if NET46
+                    Assert.Throws<SQLiteException>(() =>
+#else
+                    Assert.Throws<SqliteException>(() =>
+#endif
+                    {
+                        var deletedData =
+                            context.Orders.Delete("Customer = @CustomerName", new {CustomerName = "Peter"});
                     });
                 }
             }
@@ -165,7 +177,11 @@ public void InsertUsingUnique_ThrowsSqliteException()
                         context.Orders.Insert(item);
                     }
 
-                    Assert.Throws<SqliteException>(delegate
+#if NET46
+                    Assert.Throws<SQLiteException>(() =>
+#else
+                    Assert.Throws<SqliteException>(() =>
+#endif
                     {
                         var newOrder = new Order
                         {
@@ -178,13 +194,17 @@ public void InsertUsingUnique_ThrowsSqliteException()
                     });
                 }
             }
-            
+
             [Test]
             public void InsertingWithOutOfRangeString_ThrowsSqliteException()
             {
                 using (var context = new TestDbContext(nameof(InsertingWithOutOfRangeString_ThrowsSqliteException)))
                 {
-                    Assert.Throws<SqliteException>(delegate
+#if NET46
+                    Assert.Throws<SQLiteException>(() =>
+#else
+                    Assert.Throws<SqliteException>(() =>
+#endif
                     {
                         context.Orders.Insert(new Order
                         {
@@ -213,7 +233,7 @@ public void InsertingDataList()
             [Test]
             public void InsertingEmptyDataList_TrhowsArgumentException()
             {
-                Assert.Throws(typeof(ArgumentNullException), () =>
+                Assert.Throws<ArgumentNullException>(() =>
                 {
                     using (var context = new TestDbContext(nameof(InsertingEmptyDataList_TrhowsArgumentException)))
                     {
@@ -235,14 +255,15 @@ public void UpdatingEntities()
                         context.Orders.Insert(item);
                     }
 
-                    var list = context.Orders.Select("CustomerName = @CustomerName", new { CustomerName = "John" });
+                    var list = context.Orders.Select("CustomerName = @CustomerName", new {CustomerName = "John"});
                     foreach (var item in list)
                     {
                         item.ShipperCity = "Atlanta";
                         context.Orders.Update(item);
                     }
 
-                    var updatedList = context.Orders.Select("ShipperCity = @ShipperCity", new { ShipperCity = "Atlanta" });
+                    var updatedList =
+                        context.Orders.Select("ShipperCity = @ShipperCity", new {ShipperCity = "Atlanta"});
                     foreach (var item in updatedList)
                     {
                         Assert.AreEqual("Atlanta", item.ShipperCity);
@@ -298,7 +319,7 @@ public void SetEntity()
                 {
                     var names = context.GetSetNames();
                     Assert.IsNotNull(names);
-                    Assert.AreEqual(names, new[] { nameof(context.Orders), nameof(context.Warehouses) });
+                    Assert.AreEqual(names, new[] {nameof(context.Orders), nameof(context.Warehouses)});
 
                     var orders = context.Set<Order>();
                     var ordersByName = context.Set(typeof(Order));
@@ -330,7 +351,7 @@ public void SelectFromSetname()
             [Test]
             public void InvalidSetname_ThrowsArgumentOutOfRangeException()
             {
-                Assert.Throws(typeof(System.ArgumentOutOfRangeException), () =>
+                Assert.Throws<ArgumentOutOfRangeException>(() =>
                 {
                     using (var context = new TestDbContext(nameof(InvalidSetname_ThrowsArgumentOutOfRangeException)))
                     {
@@ -389,12 +410,13 @@ public void UpdateFromSetname()
                         item.ShipperCity = "Atlanta";
                         context.Update(item);
                     }
-                    var updatedItems = context.Orders.Select("ShipperCity = @ShipperCity", new { ShipperCity = "Atlanta" });
+                    var updatedItems =
+                        context.Orders.Select("ShipperCity = @ShipperCity", new {ShipperCity = "Atlanta"});
                     Assert.AreEqual(TestHelper.DataSource.Length, updatedItems.Count());
                 }
             }
         }
-                
+
         public class Qerytest : DbContextFixture
         {
             [Test]
@@ -414,7 +436,7 @@ public void SelectingData()
 
                     var selectedData =
                         context.Query<Order>($"{context.Orders.SelectDefinition} WHERE CustomerName = @CustomerName",
-                            new Order { CustomerName = "Margarita" });
+                            new Order {CustomerName = "Margarita"});
 
                     foreach (var item in selectedData)
                     {
@@ -438,10 +460,16 @@ public void UsingBadQuery_ThrowsSqliteException()
                         }
                     }
 
-                    Assert.Throws<SqliteException>(() => {
+#if NET46
+                    Assert.Throws<SQLiteException>(() =>
+#else
+                    Assert.Throws<SqliteException>(() =>
+#endif
+                    {
                         var selectedData =
-                            context.Query<Order>($"{context.Orders.UpdateDefinition} WHERE CustomerName = @CustomerName",
-                                new Order { CustomerName = "Margarita" });
+                            context.Query<Order>(
+                                $"{context.Orders.UpdateDefinition} WHERE CustomerName = @CustomerName",
+                                new Order {CustomerName = "Margarita"});
 
                     });
                 }
diff --git a/test/Unosquare.Labs.LiteLib.Tests/Unosquare.Labs.LiteLib.Tests.csproj b/test/Unosquare.Labs.LiteLib.Tests/Unosquare.Labs.LiteLib.Tests.csproj
@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFrameworks>netcoreapp2.0;net46</TargetFrameworks>
+    <TargetFrameworks>net46;netcoreapp2.0</TargetFrameworks>
     <AssemblyName>Unosquare.Labs.LiteLib.Tests</AssemblyName>
     <PackageId>Unosquare.Labs.LiteLib.Tests</PackageId>
   </PropertyGroup>
@@ -11,18 +11,9 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.3.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.5.0" />
     <PackageReference Include="dotnet-test-nunit" Version="3.4.0-beta-1" />
-    <PackageReference Include="NUnit" Version="3.8.1" />
-    <PackageReference Include="NUnit3TestAdapter" Version="3.8.0" />
-  </ItemGroup>
-
-  <ItemGroup Condition=" '$(TargetFramework)' == 'net46' ">
-    <PackageReference Include="Microsoft.Data.Sqlite" Version="1.0.1" />
-    <PackageReference Include="SQLite" Version="3.13.0" />
-  </ItemGroup>
-
-  <ItemGroup Condition=" '$(TargetFramework)' == 'netstandard2.0' ">
-    <PackageReference Include="Microsoft.Data.Sqlite" Version="2.0.0" />
+    <PackageReference Include="NUnit" Version="3.9.0" />
+    <PackageReference Include="NUnit3TestAdapter" Version="3.9.0" />
   </ItemGroup>
 </Project>

Original file line number	Diff line number	Diff line change
`@@ -1,9 +1,13 @@`
`1`		`-using Microsoft.Data.Sqlite;`
`2`		`-using NUnit.Framework;`
	`1`	`+using NUnit.Framework;`
`3`	`2`	`using System.Linq;`
`4`	`3`	`using System.Threading.Tasks;`
`5`	`4`	`using Unosquare.Labs.LiteLib.Tests.Database;`
`6`	`5`	`using Unosquare.Labs.LiteLib.Tests.Helpers;`
	`6`	`+#if NET46`
	`7`	`+using System.Data.SQLite;`
	`8`	`+#else`
	`9`	`+using Microsoft.Data.Sqlite;`
	`10`	`+#endif`
`7`	`11`
`8`	`12`	`namespace Unosquare.Labs.LiteLib.Tests`
`9`	`13`	`{`
`@@ -42,7 +46,7 @@ public async Task SelectWithParametersAsync()`
`42`	`46`
`43`	`47`	`// Selecting Data By name`
`44`	`48`	`var selectingData =`
`45`		`- await context.Orders.SelectAsync("CustomerName = @CustomerName", new { CustomerName = "Peter" });`
	`49`	`+ await context.Orders.SelectAsync("CustomerName = @CustomerName", new {CustomerName = "Peter"});`
`46`	`50`
`47`	`51`	`foreach (var item in selectingData)`
`48`	`52`	`{`
`@@ -63,7 +67,7 @@ public async Task SelectDataAsync()`
`63`	`67`
`64`	`68`	`// Selecting Data By name`
`65`	`69`	`var selectingData =`
`66`		`- await context.Orders.SelectAsync("CustomerName = @CustomerName", new { CustomerName = "Peter" });`
	`70`	`+ await context.Orders.SelectAsync("CustomerName = @CustomerName", new {CustomerName = "Peter"});`
`67`	`71`
`68`	`72`	`foreach (var item in selectingData)`
`69`	`73`	`{`
`@@ -123,7 +127,7 @@ public async Task DeletingAsyncWithParams()`
`123`	`127`	`}`
`124`	`128`
`125`	`129`	`var deletedData =`
`126`		`- await context.Orders.DeleteAsync("CustomerName = @CustomerName", new { CustomerName = "Peter" });`
	`130`	`+ await context.Orders.DeleteAsync("CustomerName = @CustomerName", new {CustomerName = "Peter"});`
`127`	`131`	`Assert.AreEqual(deletedData, TestHelper.DataSource.Count(x => x.CustomerName == "Peter"));`
`128`	`132`	`}`
`129`	`133`	`}`
`@@ -163,8 +167,11 @@ public async Task InsertAsyncUsingUnique_ThrowsSqliteException()`
`163`	`167`	`{`
`164`	`168`	`await context.Orders.InsertAsync(item);`
`165`	`169`	`}`
`166`		`-`
	`170`	`+#if NET46`
	`171`	`+ Assert.ThrowsAsync<SQLiteException>(async () =>`
	`172`	`+#else`
`167`	`173`	`Assert.ThrowsAsync<SqliteException>(async () =>`
	`174`	`+#endif`
`168`	`175`	`{`
`169`	`176`	`var newOrder = new Order`
`170`	`177`	`{`
`@@ -173,6 +180,7 @@ public async Task InsertAsyncUsingUnique_ThrowsSqliteException()`
`173`	`180`	`ShipperCity = "Atlanta",`
`174`	`181`	`UniqueId = "1"`
`175`	`182`	`};`
	`183`	`+`
`176`	`184`	`await context.Orders.InsertAsync(newOrder);`
`177`	`185`	`});`
`178`	`186`	`}`
`@@ -183,7 +191,11 @@ public async Task InsertAsyncWithOutOfRangeString_ThrowsSqliteException()`
`183`	`191`	`{`
`184`	`192`	`using (var context = new TestDbContext(nameof(InsertAsyncWithOutOfRangeString_ThrowsSqliteException)))`
`185`	`193`	`{`
	`194`	`+#if NET46`
	`195`	`+ Assert.ThrowsAsync<SQLiteException>(async () =>`
	`196`	`+#else`
`186`	`197`	`Assert.ThrowsAsync<SqliteException>(async () =>`
	`198`	`+#endif`
`187`	`199`	`{`
`188`	`200`	`await context.Orders.InsertAsync(new Order`
`189`	`201`	`{`
`@@ -209,15 +221,17 @@ public async Task AsyncUpdateData()`
`209`	`221`	`}`
`210`	`222`
`211`	`223`	`var list = await context.Orders.SelectAsync("CustomerName = @CustomerName",`
`212`		`- new { CustomerName = "John" });`
	`224`	`+ new {CustomerName = "John"});`
	`225`	`+`
`213`	`226`	`foreach (var item in list)`
`214`	`227`	`{`
`215`	`228`	`item.ShipperCity = "Atlanta";`
`216`	`229`	`await context.Orders.UpdateAsync(item);`
`217`	`230`	`}`
`218`	`231`
`219`	`232`	`var updatedList =`
`220`		`- await context.Orders.SelectAsync("ShipperCity = @ShipperCity", new { ShipperCity = "Atlanta" });`
	`233`	`+ await context.Orders.SelectAsync("ShipperCity = @ShipperCity", new {ShipperCity = "Atlanta"});`
	`234`	`+`
`221`	`235`	`foreach (var item in updatedList)`
`222`	`236`	`{`
`223`	`237`	`Assert.AreEqual("Atlanta", item.ShipperCity);`
`@@ -314,8 +328,9 @@ public async Task AsyncUpdateFromSetname()`
`314`	`328`	`item.ShipperCity = "Atlanta";`
`315`	`329`	`await context.UpdateAsync(item);`
`316`	`330`	`}`
	`331`	`+`
`317`	`332`	`var updatedItems =`
`318`		`- await context.Orders.SelectAsync("ShipperCity = @ShipperCity", new { ShipperCity = "Atlanta" });`
	`333`	`+ await context.Orders.SelectAsync("ShipperCity = @ShipperCity", new {ShipperCity = "Atlanta"});`
`319`	`334`	`Assert.AreEqual(TestHelper.DataSource.Length, updatedItems.Count());`
`320`	`335`	`}`
`321`	`336`	`}`
`@@ -337,7 +352,7 @@ public async Task AsyncQueryData()`
`337`	`352`	`await`
`338`	`353`	`context.QueryAsync<Order>(`
`339`	`354`	`$"{context.Orders.SelectDefinition} WHERE CustomerName = @CustomerName",`
`340`		`- new Order { CustomerName = "John" });`
	`355`	`+ new Order {CustomerName = "John"});`
`341`	`356`
`342`	`357`	`foreach (var item in selectedData)`
`343`	`358`	`{`
Original file line number	Diff line number	Diff line change
`@@ -5,7 +5,9 @@`
`5`	`5`	`using Unosquare.Labs.LiteLib.Tests.Database;`
`6`	`6`	`using Unosquare.Labs.LiteLib.Tests.Helpers;`
`7`	`7`	`#if MONO`
`8`		`- using Mono.Data.Sqlite;`
	`8`	`+using Mono.Data.Sqlite;`
	`9`	`+#elif NET46`
	`10`	`+using System.Data.SQLite;`
`9`	`11`	`#else`
`10`	`12`	`using Microsoft.Data.Sqlite;`
`11`	`13`	`#endif`
`@@ -48,7 +50,7 @@ public void SelectDataWithParameters()`
`48`	`50`	`context.Orders.Insert(item);`
`49`	`51`	`}`
`50`	`52`
`51`		`- var entities = context.Orders.Select("CustomerName = @CustomerName", new { CustomerName = "John" });`
	`53`	`+ var entities = context.Orders.Select("CustomerName = @CustomerName", new {CustomerName = "John"});`
`52`	`54`	`foreach (var item in entities)`
`53`	`55`	`{`
`54`	`56`	`Assert.AreEqual("John", item.CustomerName);`
`@@ -65,14 +67,17 @@ public void SelectWithBadParameters_ThrowsException()`
`65`	`67`	`{`
`66`	`68`	`context.Orders.Insert(item);`
`67`	`69`	`}`
`68`		`-`
	`70`	`+#if NET46`
	`71`	`+ Assert.Throws<SQLiteException>(() =>`
	`72`	`+#else`
`69`	`73`	`Assert.Throws<SqliteException>(() =>`
	`74`	`+#endif`
`70`	`75`	`{`
`71`		`- var entities = context.Orders.Select("Customer = @CustomerName", new { CustomerName = "John" });`
	`76`	`+ var entities = context.Orders.Select("Customer = @CustomerName", new {CustomerName = "John"});`
`72`	`77`	`});`
`73`	`78`	`}`
`74`	`79`	`}`
`75`		`-`
	`80`	`+`
`76`	`81`	`[Test]`
`77`	`82`	`public void SelectingFirstOrDefault()`
`78`	`83`	`{`
`@@ -119,7 +124,8 @@ public void DeletingUsingParams()`
`119`	`124`	`context.Orders.Insert(item);`
`120`	`125`	`}`
`121`	`126`
`122`		`- var deletedData = context.Orders.Delete("CustomerName = @CustomerName", new { CustomerName = "Peter" });`
	`127`	`+ var deletedData =`
	`128`	`+ context.Orders.Delete("CustomerName = @CustomerName", new {CustomerName = "Peter"});`
`123`	`129`	`Assert.AreEqual(deletedData, TestHelper.DataSource.Count(x => x.CustomerName == "Peter"));`
`124`	`130`	`}`
`125`	`131`	`}`
`@@ -134,8 +140,14 @@ public void DeletingUsingInvalidParams_TrhowsSqliteException()`
`134`	`140`	`context.Orders.Insert(item);`
`135`	`141`	`}`
`136`	`142`
`137`		`- Assert.Throws<SqliteException>(() => {`
`138`		`- var deletedData = context.Orders.Delete("Customer = @CustomerName", new { CustomerName = "Peter" });`
	`143`	`+#if NET46`
	`144`	`+ Assert.Throws<SQLiteException>(() =>`
	`145`	`+#else`
	`146`	`+ Assert.Throws<SqliteException>(() =>`
	`147`	`+#endif`
	`148`	`+ {`
	`149`	`+ var deletedData =`
	`150`	`+ context.Orders.Delete("Customer = @CustomerName", new {CustomerName = "Peter"});`
`139`	`151`	`});`
`140`	`152`	`}`
`141`	`153`	`}`
`@@ -165,7 +177,11 @@ public void InsertUsingUnique_ThrowsSqliteException()`
`165`	`177`	`context.Orders.Insert(item);`
`166`	`178`	`}`
`167`	`179`
`168`		`- Assert.Throws<SqliteException>(delegate`
	`180`	`+#if NET46`
	`181`	`+ Assert.Throws<SQLiteException>(() =>`
	`182`	`+#else`
	`183`	`+ Assert.Throws<SqliteException>(() =>`
	`184`	`+#endif`
`169`	`185`	`{`
`170`	`186`	`var newOrder = new Order`
`171`	`187`	`{`
`@@ -178,13 +194,17 @@ public void InsertUsingUnique_ThrowsSqliteException()`
`178`	`194`	`});`
`179`	`195`	`}`
`180`	`196`	`}`
`181`		`-`
	`197`	`+`
`182`	`198`	`[Test]`
`183`	`199`	`public void InsertingWithOutOfRangeString_ThrowsSqliteException()`
`184`	`200`	`{`
`185`	`201`	`using (var context = new TestDbContext(nameof(InsertingWithOutOfRangeString_ThrowsSqliteException)))`
`186`	`202`	`{`
`187`		`- Assert.Throws<SqliteException>(delegate`
	`203`	`+#if NET46`
	`204`	`+ Assert.Throws<SQLiteException>(() =>`
	`205`	`+#else`
	`206`	`+ Assert.Throws<SqliteException>(() =>`
	`207`	`+#endif`
`188`	`208`	`{`
`189`	`209`	`context.Orders.Insert(new Order`
`190`	`210`	`{`
`@@ -213,7 +233,7 @@ public void InsertingDataList()`
`213`	`233`	`[Test]`
`214`	`234`	`public void InsertingEmptyDataList_TrhowsArgumentException()`
`215`	`235`	`{`
`216`		`- Assert.Throws(typeof(ArgumentNullException), () =>`
	`236`	`+ Assert.Throws<ArgumentNullException>(() =>`
`217`	`237`	`{`
`218`	`238`	`using (var context = new TestDbContext(nameof(InsertingEmptyDataList_TrhowsArgumentException)))`
`219`	`239`	`{`
`@@ -235,14 +255,15 @@ public void UpdatingEntities()`
`235`	`255`	`context.Orders.Insert(item);`
`236`	`256`	`}`
`237`	`257`
`238`		`- var list = context.Orders.Select("CustomerName = @CustomerName", new { CustomerName = "John" });`
	`258`	`+ var list = context.Orders.Select("CustomerName = @CustomerName", new {CustomerName = "John"});`
`239`	`259`	`foreach (var item in list)`
`240`	`260`	`{`
`241`	`261`	`item.ShipperCity = "Atlanta";`
`242`	`262`	`context.Orders.Update(item);`
`243`	`263`	`}`
`244`	`264`
`245`		`- var updatedList = context.Orders.Select("ShipperCity = @ShipperCity", new { ShipperCity = "Atlanta" });`
	`265`	`+ var updatedList =`
	`266`	`+ context.Orders.Select("ShipperCity = @ShipperCity", new {ShipperCity = "Atlanta"});`
`246`	`267`	`foreach (var item in updatedList)`
`247`	`268`	`{`
`248`	`269`	`Assert.AreEqual("Atlanta", item.ShipperCity);`
`@@ -298,7 +319,7 @@ public void SetEntity()`
`298`	`319`	`{`
`299`	`320`	`var names = context.GetSetNames();`
`300`	`321`	`Assert.IsNotNull(names);`
`301`		`- Assert.AreEqual(names, new[] { nameof(context.Orders), nameof(context.Warehouses) });`
	`322`	`+ Assert.AreEqual(names, new[] {nameof(context.Orders), nameof(context.Warehouses)});`
`302`	`323`
`303`	`324`	`var orders = context.Set<Order>();`
`304`	`325`	`var ordersByName = context.Set(typeof(Order));`
`@@ -330,7 +351,7 @@ public void SelectFromSetname()`
`330`	`351`	`[Test]`
`331`	`352`	`public void InvalidSetname_ThrowsArgumentOutOfRangeException()`
`332`	`353`	`{`
`333`		`- Assert.Throws(typeof(System.ArgumentOutOfRangeException), () =>`
	`354`	`+ Assert.Throws<ArgumentOutOfRangeException>(() =>`
`334`	`355`	`{`
`335`	`356`	`using (var context = new TestDbContext(nameof(InvalidSetname_ThrowsArgumentOutOfRangeException)))`
`336`	`357`	`{`
`@@ -389,12 +410,13 @@ public void UpdateFromSetname()`
`389`	`410`	`item.ShipperCity = "Atlanta";`
`390`	`411`	`context.Update(item);`
`391`	`412`	`}`
`392`		`- var updatedItems = context.Orders.Select("ShipperCity = @ShipperCity", new { ShipperCity = "Atlanta" });`
	`413`	`+ var updatedItems =`
	`414`	`+ context.Orders.Select("ShipperCity = @ShipperCity", new {ShipperCity = "Atlanta"});`
`393`	`415`	`Assert.AreEqual(TestHelper.DataSource.Length, updatedItems.Count());`
`394`	`416`	`}`
`395`	`417`	`}`
`396`	`418`	`}`
`397`		`-`
	`419`	`+`
`398`	`420`	`public class Qerytest : DbContextFixture`
`399`	`421`	`{`
`400`	`422`	`[Test]`
`@@ -414,7 +436,7 @@ public void SelectingData()`
`414`	`436`
`415`	`437`	`var selectedData =`
`416`	`438`	`context.Query<Order>($"{context.Orders.SelectDefinition} WHERE CustomerName = @CustomerName",`
`417`		`- new Order { CustomerName = "Margarita" });`
	`439`	`+ new Order {CustomerName = "Margarita"});`
`418`	`440`
`419`	`441`	`foreach (var item in selectedData)`
`420`	`442`	`{`
`@@ -438,10 +460,16 @@ public void UsingBadQuery_ThrowsSqliteException()`
`438`	`460`	`}`
`439`	`461`	`}`
`440`	`462`
`441`		`- Assert.Throws<SqliteException>(() => {`
	`463`	`+#if NET46`
	`464`	`+ Assert.Throws<SQLiteException>(() =>`
	`465`	`+#else`
	`466`	`+ Assert.Throws<SqliteException>(() =>`
	`467`	`+#endif`
	`468`	`+ {`
`442`	`469`	`var selectedData =`
`443`		`- context.Query<Order>($"{context.Orders.UpdateDefinition} WHERE CustomerName = @CustomerName",`
`444`		`- new Order { CustomerName = "Margarita" });`
	`470`	`+ context.Query<Order>(`
	`471`	`+ $"{context.Orders.UpdateDefinition} WHERE CustomerName = @CustomerName",`
	`472`	`+ new Order {CustomerName = "Margarita"});`
`445`	`473`
`446`	`474`	`});`
`447`	`475`	`}`