Migrate to .NET 10, update dependencies, and modernize test tooling

msallin · msallin · commit cf9fde252dc9 · 2026-06-16T01:54:14.000+02:00
- Target net10.0 in the .NET Core console demo and the test project
  (the test project moves off net48).
- Point the test project at the .NET Core demo project and register the
  EF6 SQLite provider through a code-based DbConfiguration, since modern
  .NET has no app.config provider discovery. Sign the demo so the signed
  test assembly can reference it.
- Update dependencies: EntityFramework 6.5.2, System.Data.SQLite(.EF6)
  1.0.119, Moq 4.20.72, MSTest 4.2.3.
- Convert the solution from .sln to .slnx.
- Run the unit tests on Microsoft.Testing.Platform (MSTest runner),
  opted in via global.json.
- Adapt the tests to MSTest 4: replace [ExpectedException] with
  Assert.ThrowsExactly and fix Assert.AreEqual argument order.
- Replace the package's deprecated licenseUrl with the SPDX expression
  Apache-2.0.
diff --git a/SQLite.CodeFirst.Console/SQLite.CodeFirst.Console.csproj b/SQLite.CodeFirst.Console/SQLite.CodeFirst.Console.csproj
@@ -10,7 +10,7 @@
     <AssemblyOriginatorKeyFile>..\Shared\SQLite.CodeFirst.StrongNameKey.snk</AssemblyOriginatorKeyFile>
   </PropertyGroup>
   <ItemGroup>
-    <PackageReference Include="System.Data.SQLite" Version="1.0.118" />
+    <PackageReference Include="System.Data.SQLite" Version="1.0.119" />
   </ItemGroup>
   <ItemGroup>
     <Reference Include="System.ComponentModel.DataAnnotations" />
diff --git a/SQLite.CodeFirst.NetCore.Console/SQLite.CodeFirst.NetCore.Console.csproj b/SQLite.CodeFirst.NetCore.Console/SQLite.CodeFirst.NetCore.Console.csproj
@@ -1,13 +1,15 @@
-﻿<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
     <OutputType>Exe</OutputType>
-    <TargetFramework>net8.0</TargetFramework>
+    <TargetFramework>net10.0</TargetFramework>
+    <SignAssembly>true</SignAssembly>
+    <AssemblyOriginatorKeyFile>..\Shared\SQLite.CodeFirst.StrongNameKey.snk</AssemblyOriginatorKeyFile>
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="System.Data.SQLite" Version="1.0.118" />
-    <PackageReference Include="System.Data.SQLite.EF6" Version="1.0.118" />
+    <PackageReference Include="System.Data.SQLite" Version="1.0.119" />
+    <PackageReference Include="System.Data.SQLite.EF6" Version="1.0.119" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/SQLite.CodeFirst.Test/IntegrationTests/InMemoryDbCreationTest.cs b/SQLite.CodeFirst.Test/IntegrationTests/InMemoryDbCreationTest.cs
@@ -1,8 +1,8 @@
 ﻿using System.Collections.Generic;
 using System.Linq;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
-using SQLite.CodeFirst.Console;
-using SQLite.CodeFirst.Console.Entity;
+using SQLite.CodeFirst.NetCore.Console;
+using SQLite.CodeFirst.NetCore.Console.Entity;
 
 namespace SQLite.CodeFirst.Test.IntegrationTests
 {
diff --git a/SQLite.CodeFirst.Test/IntegrationTests/SqlGenerationDefaultCollationTest.cs b/SQLite.CodeFirst.Test/IntegrationTests/SqlGenerationDefaultCollationTest.cs
@@ -4,8 +4,8 @@
 using System.Data.SQLite;
 using System.Linq;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
-using SQLite.CodeFirst.Console;
-using SQLite.CodeFirst.Console.Entity;
+using SQLite.CodeFirst.NetCore.Console;
+using SQLite.CodeFirst.NetCore.Console.Entity;
 
 namespace SQLite.CodeFirst.Test.IntegrationTests
 {
diff --git a/SQLite.CodeFirst.Test/IntegrationTests/SqlGenerationTest.cs b/SQLite.CodeFirst.Test/IntegrationTests/SqlGenerationTest.cs
@@ -4,8 +4,8 @@
 using System.Data.SQLite;
 using System.Linq;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
-using SQLite.CodeFirst.Console;
-using SQLite.CodeFirst.Console.Entity;
+using SQLite.CodeFirst.NetCore.Console;
+using SQLite.CodeFirst.NetCore.Console.Entity;
 
 namespace SQLite.CodeFirst.Test.IntegrationTests
 {
diff --git a/SQLite.CodeFirst.Test/SQLite.CodeFirst.Test.csproj b/SQLite.CodeFirst.Test/SQLite.CodeFirst.Test.csproj
@@ -1,29 +1,22 @@
-﻿<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
-    <TargetFramework>net48</TargetFramework>
+    <TargetFramework>net10.0</TargetFramework>
     <AssemblyTitle>SQLite.CodeFirst.Test</AssemblyTitle>
     <Description>Contains the Unit Tests for the SQLite.CodeFirst Library.</Description>
     <Version>1.0.0.0</Version>
     <SignAssembly>true</SignAssembly>
     <AssemblyOriginatorKeyFile>..\Shared\SQLite.CodeFirst.StrongNameKey.snk</AssemblyOriginatorKeyFile>
+    <!-- Run the tests on Microsoft.Testing.Platform via the MSTest runner instead of VSTest. -->
+    <OutputType>Exe</OutputType>
+    <EnableMSTestRunner>true</EnableMSTestRunner>
   </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-    <DebugType>full</DebugType>
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-    <DebugType>pdbonly</DebugType>
-  </PropertyGroup>
-  <ItemGroup>
-    <PackageReference Include="Moq" Version="4.20.70" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.9.0" />
-    <PackageReference Include="MSTest.TestAdapter" Version="3.2.2" />
-    <PackageReference Include="MSTest.TestFramework" Version="3.2.2" />
-  </ItemGroup>
   <ItemGroup>
-    <Reference Include="System.ComponentModel.DataAnnotations" />
+    <PackageReference Include="Moq" Version="4.20.72" />
+    <PackageReference Include="MSTest.TestAdapter" Version="4.2.3" />
+    <PackageReference Include="MSTest.TestFramework" Version="4.2.3" />
   </ItemGroup>
   <ItemGroup>
-    <ProjectReference Include="..\SQLite.CodeFirst.Console\SQLite.CodeFirst.Console.csproj" />
+    <ProjectReference Include="..\SQLite.CodeFirst.NetCore.Console\SQLite.CodeFirst.NetCore.Console.csproj" />
     <ProjectReference Include="..\SQLite.CodeFirst\SQLite.CodeFirst.csproj" />
   </ItemGroup>
-</Project>
+</Project>
diff --git a/SQLite.CodeFirst.Test/TestSetup.cs b/SQLite.CodeFirst.Test/TestSetup.cs
@@ -0,0 +1,23 @@
+using System.Data.Entity;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using SQLite.CodeFirst.NetCore.Console;
+
+namespace SQLite.CodeFirst.Test
+{
+    /// <summary>
+    /// Registers the SQLite Entity Framework 6 provider once for the whole test assembly.
+    /// On .NET (Core) there is no app.config based provider discovery, so the code based
+    /// <see cref="Configuration"/> from the demo project is applied before any test runs.
+    /// Setting it explicitly (instead of relying on assembly scanning) makes the registration
+    /// independent of which DbContext the test runner happens to touch first.
+    /// </summary>
+    [TestClass]
+    public static class TestSetup
+    {
+        [AssemblyInitialize]
+        public static void Initialize(TestContext context)
+        {
+            DbConfiguration.SetConfiguration(new Configuration());
+        }
+    }
+}
diff --git a/SQLite.CodeFirst.Test/UnitTests/Statement/ColumnConstraint/CollateConstraintTest.cs b/SQLite.CodeFirst.Test/UnitTests/Statement/ColumnConstraint/CollateConstraintTest.cs
@@ -12,7 +12,7 @@ public void CreateStatement_StatementIsCorrect_NoConstraint()
             var collationConstraint = new CollateConstraint();
             collationConstraint.CollationFunction = CollationFunction.None;
             string output = collationConstraint.CreateStatement();
-            Assert.AreEqual(output, "");
+            Assert.AreEqual("", output);
         }
 
         [TestMethod]
@@ -21,7 +21,7 @@ public void CreateStatement_StatementIsCorrect_NoCase()
             var collationConstraint = new CollateConstraint();
             collationConstraint.CollationFunction = CollationFunction.NoCase;
             string output = collationConstraint.CreateStatement();
-            Assert.AreEqual(output, "COLLATE NOCASE");
+            Assert.AreEqual("COLLATE NOCASE", output);
         }
     }
 }
diff --git a/SQLite.CodeFirst.Test/UnitTests/Statement/ColumnConstraint/ColumnConstraintCollectionTest.cs b/SQLite.CodeFirst.Test/UnitTests/Statement/ColumnConstraint/ColumnConstraintCollectionTest.cs
@@ -18,7 +18,7 @@ public void CreateStatementOneColumnConstraintTest()
                 columnConstraintMock.Object
             });
             string output = columnConstraintCollection.CreateStatement();
-            Assert.AreEqual(output, "dummy1");
+            Assert.AreEqual("dummy1", output);
         }
 
         [TestMethod]
@@ -36,7 +36,7 @@ public void CreateStatementTwoColumnConstraintsTest()
                 columnConstraintMock2.Object
             });
             string output = columnConstraintCollection.CreateStatement();
-            Assert.AreEqual(output, "dummy1 dummy2");
+            Assert.AreEqual("dummy1 dummy2", output);
         }
     }
 }
diff --git a/SQLite.CodeFirst.Test/UnitTests/Statement/ColumnConstraint/DefaultValueConstraintTest.cs b/SQLite.CodeFirst.Test/UnitTests/Statement/ColumnConstraint/DefaultValueConstraintTest.cs
@@ -12,7 +12,7 @@ public void CreateStatement_StatementIsCorrect_IntDefault()
             var defaultValueConstraint = new DefaultValueConstraint();
             defaultValueConstraint.DefaultValue = "0";
             string output = defaultValueConstraint.CreateStatement();
-            Assert.AreEqual(output, "DEFAULT (0)");
+            Assert.AreEqual("DEFAULT (0)", output);
         }
 
         [TestMethod]
@@ -21,7 +21,7 @@ public void CreateStatement_StatementIsCorrect_StringDefault()
             var defaultValueConstraint = new DefaultValueConstraint();
             defaultValueConstraint.DefaultValue = @"'Something'";
             string output = defaultValueConstraint.CreateStatement();
-            Assert.AreEqual(output, "DEFAULT ('Something')");
+            Assert.AreEqual("DEFAULT ('Something')", output);
         }
 
         [TestMethod]
@@ -30,7 +30,7 @@ public void CreateStatement_StatementIsCorrect_ExpressionDefault()
             var defaultValueConstraint = new DefaultValueConstraint();
             defaultValueConstraint.DefaultValue = @"datetime('now')";
             string output = defaultValueConstraint.CreateStatement();
-            Assert.AreEqual(output, "DEFAULT (datetime('now'))");
+            Assert.AreEqual("DEFAULT (datetime('now'))", output);
         }
     }
 }
diff --git a/SQLite.CodeFirst.Test/UnitTests/Statement/ColumnConstraint/MaxLengthConstraint.cs b/SQLite.CodeFirst.Test/UnitTests/Statement/ColumnConstraint/MaxLengthConstraint.cs
@@ -12,15 +12,14 @@ public void CreateStatementTest()
         {
             var maxLengthConstraint = new MaxLengthConstraint(12);
             string output = maxLengthConstraint.CreateStatement();
-            Assert.AreEqual(output, "(12)");
+            Assert.AreEqual("(12)", output);
         }
 
         [TestMethod]
-        [ExpectedException(typeof(InvalidOperationException))]
         public void CreateStatementInvalidParameterTest()
         {
             var maxLengthConstraint = new MaxLengthConstraint();
-            maxLengthConstraint.CreateStatement();
+            Assert.ThrowsExactly<InvalidOperationException>(() => maxLengthConstraint.CreateStatement());
         }
     }
 }
diff --git a/SQLite.CodeFirst.Test/UnitTests/Statement/ColumnConstraint/NotNullConstraintTest.cs b/SQLite.CodeFirst.Test/UnitTests/Statement/ColumnConstraint/NotNullConstraintTest.cs
@@ -11,7 +11,7 @@ public void CreateStatementTest()
         {
             var notNullConstraint = new NotNullConstraint();
             string output = notNullConstraint.CreateStatement();
-            Assert.AreEqual(output, "NOT NULL");
+            Assert.AreEqual("NOT NULL", output);
         }
     }
 }
diff --git a/SQLite.CodeFirst.Test/UnitTests/Statement/ColumnConstraint/PrimaryKeyConstraintTest.cs b/SQLite.CodeFirst.Test/UnitTests/Statement/ColumnConstraint/PrimaryKeyConstraintTest.cs
@@ -11,15 +11,15 @@ public void CreateStatement_StatementIsCorrect_WithAutoincrement()
         {
             var primaryKeyConstraint = new PrimaryKeyConstraint { Autoincrement = true };
             string output = primaryKeyConstraint.CreateStatement();
-            Assert.AreEqual(output, "PRIMARY KEY AUTOINCREMENT");
+            Assert.AreEqual("PRIMARY KEY AUTOINCREMENT", output);
         }
 
         [TestMethod]
         public void CreateStatement_StatementIsCorrect()
         {
             var primaryKeyConstraint = new PrimaryKeyConstraint();
             string output = primaryKeyConstraint.CreateStatement();
-            Assert.AreEqual(output, "PRIMARY KEY");
+            Assert.AreEqual("PRIMARY KEY", output);
         }
     }
 }
diff --git a/SQLite.CodeFirst.Test/UnitTests/Statement/ColumnConstraint/UniqueConstraintTest.cs b/SQLite.CodeFirst.Test/UnitTests/Statement/ColumnConstraint/UniqueConstraintTest.cs
@@ -12,7 +12,7 @@ public void CreateStatement_StatementIsCorrect_NoConstraint()
             var uniqueConstraint = new UniqueConstraint();
             uniqueConstraint.OnConflict = OnConflictAction.None;
             string output = uniqueConstraint.CreateStatement();
-            Assert.AreEqual(output, "UNIQUE");
+            Assert.AreEqual("UNIQUE", output);
         }
 
         [TestMethod]
@@ -21,7 +21,7 @@ public void CreateStatement_StatementIsCorrect_WithConstraint()
             var uniqueConstraint = new UniqueConstraint();
             uniqueConstraint.OnConflict = OnConflictAction.Rollback;
             string output = uniqueConstraint.CreateStatement();
-            Assert.AreEqual(output, "UNIQUE ON CONFLICT ROLLBACK");
+            Assert.AreEqual("UNIQUE ON CONFLICT ROLLBACK", output);
         }
     }
 }
diff --git a/SQLite.CodeFirst.Test/UnitTests/Statement/ColumnStatementCollectionTest.cs b/SQLite.CodeFirst.Test/UnitTests/Statement/ColumnStatementCollectionTest.cs
@@ -12,8 +12,8 @@ public void CreateStatementOneEntryTest()
             var columnStatementCollection = new ColumnStatementCollection(new[] { CreateStatementMock("dummy1").Object });
 
             string output = columnStatementCollection.CreateStatement();
-            Assert.AreEqual(columnStatementCollection.Count, 1);
-            Assert.AreEqual(output, "dummy1");
+            Assert.AreEqual(1, columnStatementCollection.Count);
+            Assert.AreEqual("dummy1", output);
         }
 
         [TestMethod]
@@ -26,8 +26,8 @@ public void CreateStatementTwoEntryTest()
             });
 
             string output = createIndexStatementCollection.CreateStatement();
-            Assert.AreEqual(createIndexStatementCollection.Count, 2);
-            Assert.AreEqual(output, "dummy1, dummy2");
+            Assert.AreEqual(2, createIndexStatementCollection.Count);
+            Assert.AreEqual("dummy1, dummy2", output);
         }
     }
 }
diff --git a/SQLite.CodeFirst.Test/UnitTests/Statement/ColumnStatementTest.cs b/SQLite.CodeFirst.Test/UnitTests/Statement/ColumnStatementTest.cs
@@ -21,7 +21,7 @@ public void CreateStatement()
                 ColumnConstraints = columnConstraintsMock.Object,
             };
             string output = columnStatement.CreateStatement();
-            Assert.AreEqual(output, "[dummyColumnName] dummyType dummyColumnConstraint");
+            Assert.AreEqual("[dummyColumnName] dummyType dummyColumnConstraint", output);
         }
     }
 }
diff --git a/SQLite.CodeFirst.Test/UnitTests/Statement/CreateDatabaseStatementTest.cs b/SQLite.CodeFirst.Test/UnitTests/Statement/CreateDatabaseStatementTest.cs
@@ -16,8 +16,8 @@ public void CreateStatementWithOneKeyTest()
             };
 
             var createDatabaseStatement = new CreateDatabaseStatement(statements);
-            Assert.AreEqual(createDatabaseStatement.Count, 1);
-            Assert.AreEqual(createDatabaseStatement.CreateStatement(), "dummy1");
+            Assert.AreEqual(1, createDatabaseStatement.Count);
+            Assert.AreEqual("dummy1", createDatabaseStatement.CreateStatement());
         }
 
         [TestMethod]
@@ -30,8 +30,8 @@ public void CreateStatementWithTwoKeyTest()
             };
 
             var createDatabaseStatement = new CreateDatabaseStatement(statements);
-            Assert.AreEqual(createDatabaseStatement.Count, 2);
-            Assert.AreEqual(createDatabaseStatement.CreateStatement(), "dummy1\r\ndummy2");
+            Assert.AreEqual(2, createDatabaseStatement.Count);
+            Assert.AreEqual("dummy1\r\ndummy2", createDatabaseStatement.CreateStatement());
         }
     }
 }
diff --git a/SQLite.CodeFirst.Test/UnitTests/Statement/CreateIndexStatementCollectionTest.cs b/SQLite.CodeFirst.Test/UnitTests/Statement/CreateIndexStatementCollectionTest.cs
@@ -15,8 +15,8 @@ public void CreateStatementOneEntryTest()
             });
 
             string output = createIndexStatementCollection.CreateStatement();
-            Assert.AreEqual(createIndexStatementCollection.Count, 1);
-            Assert.AreEqual(output, "dummy1");
+            Assert.AreEqual(1, createIndexStatementCollection.Count);
+            Assert.AreEqual("dummy1", output);
         }
 
         [TestMethod]
@@ -29,8 +29,8 @@ public void CreateStatementTwoEntryTest()
             });
 
             string output = createIndexStatementCollection.CreateStatement();
-            Assert.AreEqual(createIndexStatementCollection.Count, 2);
-            Assert.AreEqual(output, "dummy1\r\ndummy2");
+            Assert.AreEqual(2, createIndexStatementCollection.Count);
+            Assert.AreEqual("dummy1\r\ndummy2", output);
         }
     }
 }
diff --git a/SQLite.CodeFirst.Test/UnitTests/Statement/CreateTableStatementTest.cs b/SQLite.CodeFirst.Test/UnitTests/Statement/CreateTableStatementTest.cs
@@ -16,7 +16,7 @@ public void CreateStatementTest()
             };
 
             string output = createTableStatement.CreateStatement();
-            Assert.AreEqual(output, "CREATE TABLE dummyTable (dummyColumnDefinition);");
+            Assert.AreEqual("CREATE TABLE dummyTable (dummyColumnDefinition);", output);
         }
     }
 }
diff --git a/SQLite.CodeFirst.Test/UnitTests/Statement/ForeignKeyStatementTest.cs b/SQLite.CodeFirst.Test/UnitTests/Statement/ForeignKeyStatementTest.cs
@@ -19,7 +19,7 @@ public void CreateStatementOneForeignKeyTest()
             };
 
             string output = foreignKeyStatement.CreateStatement();
-            Assert.AreEqual(output, "FOREIGN KEY ([dummyForeignKey1]) REFERENCES dummyForeignTable([dummForeignPrimaryKey1])");
+            Assert.AreEqual("FOREIGN KEY ([dummyForeignKey1]) REFERENCES dummyForeignTable([dummForeignPrimaryKey1])", output);
         }
 
         [TestMethod]
@@ -34,7 +34,7 @@ public void CreateStatementOneForeignKeyCascadeDeleteTest()
             };
 
             string output = foreignKeyStatement.CreateStatement();
-            Assert.AreEqual(output, "FOREIGN KEY ([dummyForeignKey1]) REFERENCES dummyForeignTable([dummForeignPrimaryKey1]) ON DELETE CASCADE");
+            Assert.AreEqual("FOREIGN KEY ([dummyForeignKey1]) REFERENCES dummyForeignTable([dummForeignPrimaryKey1]) ON DELETE CASCADE", output);
         }
 
         [TestMethod]
@@ -49,7 +49,7 @@ public void CreateStatementTwoForeignKeyTest()
             };
 
             string output = foreignKeyStatement.CreateStatement();
-            Assert.AreEqual(output, "FOREIGN KEY ([dummyForeignKey1], [dummyForeignKey2]) REFERENCES dummyForeignTable([dummForeignPrimaryKey1])");
+            Assert.AreEqual("FOREIGN KEY ([dummyForeignKey1], [dummyForeignKey2]) REFERENCES dummyForeignTable([dummForeignPrimaryKey1])", output);
         }
 
         [TestMethod]
@@ -64,7 +64,7 @@ public void CreateStatementTwoForeignKeyTwoPrimaryKeyTest()
             };
 
             string output = foreignKeyStatement.CreateStatement();
-            Assert.AreEqual(output, "FOREIGN KEY ([dummyForeignKey1], [dummyForeignKey2]) REFERENCES dummyForeignTable([dummForeignPrimaryKey1], [dummForeignPrimaryKey2])");
+            Assert.AreEqual("FOREIGN KEY ([dummyForeignKey1], [dummyForeignKey2]) REFERENCES dummyForeignTable([dummForeignPrimaryKey1], [dummForeignPrimaryKey2])", output);
         }
 
         [TestMethod]
@@ -79,7 +79,7 @@ public void CreateStatementOneForeignKeyTwoPrimaryKeyTest()
             };
 
             string output = foreignKeyStatement.CreateStatement();
-            Assert.AreEqual(output, "FOREIGN KEY ([dummyForeignKey1]) REFERENCES dummyForeignTable([dummForeignPrimaryKey1], [dummForeignPrimaryKey2])");
+            Assert.AreEqual("FOREIGN KEY ([dummyForeignKey1]) REFERENCES dummyForeignTable([dummForeignPrimaryKey1], [dummForeignPrimaryKey2])", output);
         }
     }
 }
diff --git a/SQLite.CodeFirst.Test/UnitTests/Statement/PrimaryKeyStatementTest.cs b/SQLite.CodeFirst.Test/UnitTests/Statement/PrimaryKeyStatementTest.cs
diff --git a/SQLite.CodeFirst.Test/UnitTests/Utility/HistoryEntityTypeValidatorTest.cs b/SQLite.CodeFirst.Test/UnitTests/Utility/HistoryEntityTypeValidatorTest.cs
diff --git a/SQLite.CodeFirst.Test/app.config b/SQLite.CodeFirst.Test/app.config
diff --git a/SQLite.CodeFirst.sln b/SQLite.CodeFirst.sln
diff --git a/SQLite.CodeFirst.slnx b/SQLite.CodeFirst.slnx
diff --git a/SQLite.CodeFirst/SQLite.CodeFirst.csproj b/SQLite.CodeFirst/SQLite.CodeFirst.csproj
diff --git a/ci_appveyor.yml b/ci_appveyor.yml
diff --git a/global.json b/global.json
diff --git a/release_appveyor.yml b/release_appveyor.yml

Original file line number	Diff line number	Diff line change
`@@ -12,7 +12,7 @@ public void CreateStatement_StatementIsCorrect_NoConstraint()`
`12`	`12`	`var collationConstraint = new CollateConstraint();`
`13`	`13`	`collationConstraint.CollationFunction = CollationFunction.None;`
`14`	`14`	`string output = collationConstraint.CreateStatement();`
`15`		`- Assert.AreEqual(output, "");`
	`15`	`+ Assert.AreEqual("", output);`
`16`	`16`	`}`
`17`	`17`
`18`	`18`	`[TestMethod]`
`@@ -21,7 +21,7 @@ public void CreateStatement_StatementIsCorrect_NoCase()`
`21`	`21`	`var collationConstraint = new CollateConstraint();`
`22`	`22`	`collationConstraint.CollationFunction = CollationFunction.NoCase;`
`23`	`23`	`string output = collationConstraint.CreateStatement();`
`24`		`- Assert.AreEqual(output, "COLLATE NOCASE");`
	`24`	`+ Assert.AreEqual("COLLATE NOCASE", output);`
`25`	`25`	`}`
`26`	`26`	`}`
`27`	`27`	`}`
Original file line number	Diff line number	Diff line change
`@@ -18,7 +18,7 @@ public void CreateStatementOneColumnConstraintTest()`
`18`	`18`	`columnConstraintMock.Object`
`19`	`19`	`});`
`20`	`20`	`string output = columnConstraintCollection.CreateStatement();`
`21`		`- Assert.AreEqual(output, "dummy1");`
	`21`	`+ Assert.AreEqual("dummy1", output);`
`22`	`22`	`}`
`23`	`23`
`24`	`24`	`[TestMethod]`
`@@ -36,7 +36,7 @@ public void CreateStatementTwoColumnConstraintsTest()`
`36`	`36`	`columnConstraintMock2.Object`
`37`	`37`	`});`
`38`	`38`	`string output = columnConstraintCollection.CreateStatement();`
`39`		`- Assert.AreEqual(output, "dummy1 dummy2");`
	`39`	`+ Assert.AreEqual("dummy1 dummy2", output);`
`40`	`40`	`}`
`41`	`41`	`}`
`42`	`42`	`}`