Add NUnit analyzers

.editorconfig

@@ -15,6 +15,20 @@ csharp_new_line_before_members_in_object_initializers = true
 csharp_new_line_before_members_in_anonymous_types = true
 csharp_new_line_between_query_expression_clauses = true
 
+dotnet_diagnostic.NUnit1032.severity = suggestion
+dotnet_diagnostic.NUnit1028.severity = none
+dotnet_diagnostic.NUnit2045.severity = none
+# Consider using the constraint model, Assert.That
+dotnet_diagnostic.NUnit2005.severity = suggestion
+dotnet_diagnostic.NUnit2006.severity = suggestion
+dotnet_diagnostic.NUnit2015.severity = suggestion
+dotnet_diagnostic.NUnit2031.severity = suggestion
+dotnet_diagnostic.NUnit2049.severity = suggestion
+# NUnit 4 no longer supports string.Format specification for Assert
+dotnet_diagnostic.NUnit2050.severity = suggestion
+# The SameAs constraint always fails on value types as the actual and the expected value cannot be the same reference
+dotnet_diagnostic.NUnit2040.severity = suggestion
+
 [*.xsd]
 indent_style = tab
 
@@ -34,9 +48,5 @@ indent_size = 2
 indent_style = space
 indent_size = 2
 
-[*.cshtml]
-indent_style = space
-indent_size = 4
-
 [*.g]
 indent_style = tab

src/NHibernate.Test/Async/CompositeId/CompositeIdFixture.cs

@@ -199,8 +199,8 @@ public async Task MultipleCollectionFetchAsync()
 			Assert.AreEqual(2, c.Orders.Count);
 			Assert.IsTrue(NHibernateUtil.IsInitialized(((Order) c.Orders[0]).LineItems));
 			Assert.IsTrue(NHibernateUtil.IsInitialized(((Order) c.Orders[1]).LineItems));
-			Assert.AreEqual(((Order) c.Orders[0]).LineItems.Count, 2);
-			Assert.AreEqual(((Order) c.Orders[1]).LineItems.Count, 2);
+			Assert.AreEqual(2, ((Order) c.Orders[0]).LineItems.Count);
+			Assert.AreEqual(2, ((Order) c.Orders[1]).LineItems.Count);
 			await (t.CommitAsync());
 			s.Close();
 

src/NHibernate.Test/Async/Criteria/CriteriaQueryTest.cs

@@ -3093,7 +3093,7 @@ public async Task CanSetLockModeOnDetachedCriteriaAsync()
 				var countExec = CriteriaTransformer.TransformToRowCount(ec);
 				var countRes = await (countExec.UniqueResultAsync());
 
-				Assert.AreEqual(countRes, 1);
+				Assert.AreEqual(1, countRes);
 			}
 		}
 	}

src/NHibernate.Test/Async/Criteria/SelectModeTest/SelectModeTest.cs

@@ -347,7 +347,7 @@ public async Task SelectModeFetchLazyPropertiesForEntityJoinAsync()
 
 				Assert.That(NHibernateUtil.IsInitialized(rootChild), Is.True);
 				Assert.That(NHibernateUtil.IsInitialized(parentJoin), Is.True);
-				Assert.That(NHibernateUtil.IsPropertyInitialized(parentJoin, nameof(parentJoin.LazyProp)), Is.Not.Null.Or.Empty);
+				Assert.That(NHibernateUtil.IsPropertyInitialized(parentJoin, nameof(parentJoin.LazyProp)), Is.True);
 				Assert.That(parentJoin.LazyProp, Is.Not.Null.Or.Empty);
 
 				Assert.That(sqlLog.Appender.GetEvents().Length, Is.EqualTo(1), "Only one SQL select is expected");

src/NHibernate.Test/Async/ExpressionTest/Projection/ProjectionSqlFixture.cs

@@ -74,9 +74,9 @@ public async Task QueryTestWithStrongTypeReturnValueAsync()
 		                			.Add(Projections.Min("Pay")));
 				c.SetResultTransformer(trans);
 				ProjectionReport report = await (c.UniqueResultAsync<ProjectionReport>());
-				Assert.AreEqual(report.AvgPay, 2.5);
-				Assert.AreEqual(report.MaxPay, 4);
-				Assert.AreEqual(report.MinPay, 1);
+				Assert.AreEqual(2.5, report.AvgPay);
+				Assert.AreEqual(4, report.MaxPay);
+				Assert.AreEqual(1, report.MinPay);
 			}
 		}
 
@@ -97,10 +97,10 @@ public async Task QueryTest1Async()
                 Assert.IsTrue(result[0] is object[], 
                     "expected object[] as result, but found " + result[0].GetType().Name);
                 object[] results = (object[])result[0];
-                Assert.AreEqual(results.Length, 3);
-                Assert.AreEqual(results[0], 2.5);
-                Assert.AreEqual(results[1], 4);
-                Assert.AreEqual(results[2], 1);
+                Assert.AreEqual(3, results.Length);
+                Assert.AreEqual(2.5, results[0]);
+                Assert.AreEqual(4, results[1]);
+                Assert.AreEqual(1, results[2]);
             }
         }
 
@@ -119,7 +119,7 @@ public async Task SelectSqlProjectionTestAsync()
                 IList result = await (c.ListAsync()); // c.UniqueResult();
                 Assert.IsTrue(result.Count == 1);
                 object results = result[0];
-                Assert.AreEqual(results, 2.5);
+                Assert.AreEqual(2.5, results);
             }
         }
     }

src/NHibernate.Test/Async/FilterTest/DynamicFilterTest.cs

@@ -108,7 +108,7 @@ public async Task CombinedClassAndCollectionFiltersEnabledAsync()
 				salespersons = await (session.CreateQuery("select s from Salesperson as s left join fetch s.Orders").ListAsync());
 				Assert.AreEqual(1, salespersons.Count, "Incorrect salesperson count");
 				sp = (Salesperson) salespersons[0];
-				Assert.AreEqual(sp.Orders.Count, 1, "Incorrect order count");
+				Assert.AreEqual(1, sp.Orders.Count, "Incorrect order count");
 			}
 		}
 

src/NHibernate.Test/Async/Legacy/FooBarTest.cs

@@ -1078,8 +1078,8 @@ public async Task PropertyRefAsync()
 			using (ISession s = OpenSession())
 			{
 				Holder h = (Holder) await (s.LoadAsync(typeof(Holder), hid));
-				Assert.AreEqual(h.Name, "foo");
-				Assert.AreEqual(h.OtherHolder.Name, "bar");
+				Assert.AreEqual("foo", h.Name);
+				Assert.AreEqual("bar", h.OtherHolder.Name);
 				object[] res =
 					(object[]) (await (s.CreateQuery("from Holder h join h.OtherHolder oh where h.OtherHolder.Name = 'bar'").ListAsync()))[0];
 				Assert.AreSame(h, res[0]);
@@ -1430,7 +1430,7 @@ public async Task SortablesAsync()
 			// DictionaryEntry key - not the index.
 			foreach (Sortable sortable in b.Sortablez)
 			{
-				Assert.AreEqual(sortable.name, "bar");
+				Assert.AreEqual("bar", sortable.name);
 				break;
 			}
 
@@ -1446,7 +1446,7 @@ public async Task SortablesAsync()
 			Assert.IsTrue(b.Sortablez.Count == 3);
 			foreach (Sortable sortable in b.Sortablez)
 			{
-				Assert.AreEqual(sortable.name, "bar");
+				Assert.AreEqual("bar", sortable.name);
 				break;
 			}
 			await (s.FlushAsync());
@@ -1461,7 +1461,7 @@ public async Task SortablesAsync()
 			Assert.IsTrue(b.Sortablez.Count == 3);
 			foreach (Sortable sortable in b.Sortablez)
 			{
-				Assert.AreEqual(sortable.name, "bar");
+				Assert.AreEqual("bar", sortable.name);
 				break;
 			}
 			await (s.DeleteAsync(b));

src/NHibernate.Test/Async/Legacy/MasterDetailTest.cs

@@ -184,7 +184,7 @@ public async Task CopyCascadeAsync()
 			// Save parent and cascade update detached child
 			Category persistentParent = await (s.MergeAsync(parent));
 			Assert.IsTrue(persistentParent.Subcategories.Count == 1);
-			Assert.AreEqual(((Category) persistentParent.Subcategories[0]).Name, "child2");
+			Assert.AreEqual("child2", ((Category) persistentParent.Subcategories[0]).Name);
 			await (s.FlushAsync());
 			s.Close();
 

src/NHibernate.Test/Async/Legacy/SQLLoaderTest.cs

@@ -481,7 +481,7 @@ public async Task ComponentNoStarAsync()
 			IQuery q = session.CreateSQLQuery(sql).AddEntity("comp", typeof(Componentizable));
 			IList list = await (q.ListAsync(cancellationToken));
 
-			Assert.AreEqual(list.Count, 1);
+			Assert.AreEqual(1, list.Count);
 
 			Componentizable co = (Componentizable) list[0];
 

src/NHibernate.Test/Async/Linq/ByMethod/AverageTests.cs

@@ -25,7 +25,7 @@ public async Task CanGetAverageOfIntegersAsDoubleAsync()
 			//NH-2429
 			var average = await (db.Products.AverageAsync(x => x.UnitsOnOrder));
 
-			Assert.AreEqual(average, 10.129870d, 0.000001d);
+			Assert.AreEqual(10.129870d, average, 0.000001d);
 		}
 	}
 }

src/NHibernate.Test/Async/Linq/PagingTests.cs

@@ -136,7 +136,7 @@ public async Task Customers11to20Async()
 			var query = await ((from c in db.Customers
 						 orderby c.CustomerId
 						 select c.CustomerId).Skip(10).Take(10).ToListAsync());
-			Assert.AreEqual(query[0], "BSBEV");
+			Assert.AreEqual("BSBEV", query[0]);
 			Assert.AreEqual(10, query.Count);
 		}
 
@@ -146,19 +146,19 @@ public async Task Customers11to20And21to30ShouldNoCacheQueryAsync()
 			var query = await ((from c in db.Customers
 							orderby c.CustomerId
 							select c.CustomerId).Skip(10).Take(10).ToListAsync());
-			Assert.AreEqual(query[0], "BSBEV");
+			Assert.AreEqual("BSBEV", query[0]);
 			Assert.AreEqual(10, query.Count);
 
 			query = await ((from c in db.Customers
 						orderby c.CustomerId
 						select c.CustomerId).Skip(20).Take(10).ToListAsync());
-			Assert.AreNotEqual(query[0], "BSBEV");
+			Assert.AreNotEqual("BSBEV", query[0]);
 			Assert.AreEqual(10, query.Count);
 
 			query = await ((from c in db.Customers
 						orderby c.CustomerId
 						select c.CustomerId).Skip(10).Take(20).ToListAsync());
-			Assert.AreEqual(query[0], "BSBEV");
+			Assert.AreEqual("BSBEV", query[0]);
 			Assert.AreEqual(20, query.Count);
 		}
 

src/NHibernate.Test/Async/NHSpecificTest/GH1754/Fixture.cs

@@ -8,6 +8,7 @@
 //------------------------------------------------------------------------------
 
 
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using NUnit.Framework;
@@ -86,7 +87,7 @@ public async Task CanAddChildAfterFlushAsync()
 
 				Assert.That(parent.Children, Has.Count.EqualTo(1));
 				Assert.That(parent.Children, Does.Contain(child));
-				Assert.That(parent.Children.Single().Id, Is.Not.EqualTo(0));
+				Assert.That(parent.Children.Single().Id, Is.Not.EqualTo(Guid.Empty));
 			}
 		}
 
@@ -104,7 +105,7 @@ public async Task CanAddChildAfterFlushWithoutTransactionAsync()
 
 				Assert.That(parent.Children, Has.Count.EqualTo(1));
 				Assert.That(parent.Children, Does.Contain(child));
-				Assert.That(parent.Children.Single().Id, Is.Not.EqualTo(0));
+				Assert.That(parent.Children.Single().Id, Is.Not.EqualTo(Guid.Empty));
 			}
 		}
 
@@ -132,7 +133,7 @@ public async Task CanMergeWithTransientChildAsync()
 				Assert.That(parent.Children, Has.Count.EqualTo(1));
 				// Merge should duplicate child and leave original instance un-associated with the session.
 				Assert.That(parent.Children, Does.Not.Contain(child));
-				Assert.That(parent.Children.Single().Id, Is.Not.EqualTo(0));
+				Assert.That(parent.Children.Single().Id, Is.Not.EqualTo(Guid.Empty));
 			}
 		}
 
@@ -153,7 +154,7 @@ public async Task CanMergeWithTransientChildWithoutTransactionAsync()
 				Assert.That(parent.Children, Has.Count.EqualTo(1));
 				// Merge should duplicate child and leave original instance un-associated with the session.
 				Assert.That(parent.Children, Does.Not.Contain(child));
-				Assert.That(parent.Children.Single().Id, Is.Not.EqualTo(0));
+				Assert.That(parent.Children.Single().Id, Is.Not.EqualTo(Guid.Empty));
 			}
 		}
 
@@ -179,7 +180,7 @@ public async Task CanChangeOwnershipOnFlushedParentsAsync()
 				Assert.That(parent.Children, Has.Count.EqualTo(0));
 				Assert.That(nextParent.Children, Has.Count.EqualTo(1));
 				Assert.That(nextParent.Children, Does.Contain(child));
-				Assert.That(nextParent.Children.Single().Id, Is.Not.EqualTo(0));
+				Assert.That(nextParent.Children.Single().Id, Is.Not.EqualTo(Guid.Empty));
 			}
 
 			using (var session = OpenSession())
@@ -192,7 +193,7 @@ public async Task CanChangeOwnershipOnFlushedParentsAsync()
 				Assert.That(parent.Children, Has.Count.EqualTo(0), "Reloaded data");
 				Assert.That(nextParent.Children, Has.Count.EqualTo(1), "Reloaded data");
 				Assert.That(nextParent.Children, Does.Contain(child), "Reloaded data");
-				Assert.That(nextParent.Children.Single().Id, Is.Not.EqualTo(0), "Reloaded data");
+				Assert.That(nextParent.Children.Single().Id, Is.Not.EqualTo(Guid.Empty), "Reloaded data");
 			}
 		}
 
@@ -215,7 +216,7 @@ public async Task CanChangeOwnershipOnFlushedParentsWithoutTransactionAsync()
 				Assert.That(parent.Children, Has.Count.EqualTo(0));
 				Assert.That(nextParent.Children, Has.Count.EqualTo(1));
 				Assert.That(nextParent.Children, Does.Contain(child));
-				Assert.That(nextParent.Children.Single().Id, Is.Not.EqualTo(0));
+				Assert.That(nextParent.Children.Single().Id, Is.Not.EqualTo(Guid.Empty));
 			}
 
 			using (var session = OpenSession())
@@ -228,7 +229,7 @@ public async Task CanChangeOwnershipOnFlushedParentsWithoutTransactionAsync()
 				Assert.That(parent.Children, Has.Count.EqualTo(0), "Reloaded data");
 				Assert.That(nextParent.Children, Has.Count.EqualTo(1), "Reloaded data");
 				Assert.That(nextParent.Children, Does.Contain(child), "Reloaded data");
-				Assert.That(nextParent.Children.Single().Id, Is.Not.EqualTo(0), "Reloaded data");
+				Assert.That(nextParent.Children.Single().Id, Is.Not.EqualTo(Guid.Empty), "Reloaded data");
 			}
 		}
 
@@ -254,7 +255,7 @@ public async Task CanChangeOwnershipFromFlushedParentToNonFlushedAsync()
 				Assert.That(parent.Children, Has.Count.EqualTo(0));
 				Assert.That(nextParent.Children, Has.Count.EqualTo(1));
 				Assert.That(nextParent.Children, Does.Contain(child));
-				Assert.That(nextParent.Children.Single().Id, Is.Not.EqualTo(0));
+				Assert.That(nextParent.Children.Single().Id, Is.Not.EqualTo(Guid.Empty));
 			}
 
 			using (var session = OpenSession())
@@ -267,7 +268,7 @@ public async Task CanChangeOwnershipFromFlushedParentToNonFlushedAsync()
 				Assert.That(parent.Children, Has.Count.EqualTo(0), "Reloaded data");
 				Assert.That(nextParent.Children, Has.Count.EqualTo(1), "Reloaded data");
 				Assert.That(nextParent.Children, Does.Contain(child), "Reloaded data");
-				Assert.That(nextParent.Children.Single().Id, Is.Not.EqualTo(0), "Reloaded data");
+				Assert.That(nextParent.Children.Single().Id, Is.Not.EqualTo(Guid.Empty), "Reloaded data");
 			}
 		}
 
@@ -290,7 +291,7 @@ public async Task CanChangeOwnershipFromFlushedParentToNonFlushedWithoutTransact
 				Assert.That(parent.Children, Has.Count.EqualTo(0));
 				Assert.That(nextParent.Children, Has.Count.EqualTo(1));
 				Assert.That(nextParent.Children, Does.Contain(child));
-				Assert.That(nextParent.Children.Single().Id, Is.Not.EqualTo(0));
+				Assert.That(nextParent.Children.Single().Id, Is.Not.EqualTo(Guid.Empty));
 			}
 
 			using (var session = OpenSession())
@@ -303,7 +304,7 @@ public async Task CanChangeOwnershipFromFlushedParentToNonFlushedWithoutTransact
 				Assert.That(parent.Children, Has.Count.EqualTo(0), "Reloaded data");
 				Assert.That(nextParent.Children, Has.Count.EqualTo(1), "Reloaded data");
 				Assert.That(nextParent.Children, Does.Contain(child), "Reloaded data");
-				Assert.That(nextParent.Children.Single().Id, Is.Not.EqualTo(0), "Reloaded data");
+				Assert.That(nextParent.Children.Single().Id, Is.Not.EqualTo(Guid.Empty), "Reloaded data");
 			}
 		}
 
@@ -329,7 +330,7 @@ public async Task CanChangeOwnershipFromNonFlushedParentToFlushedAsync()
 				Assert.That(parent.Children, Has.Count.EqualTo(0));
 				Assert.That(nextParent.Children, Has.Count.EqualTo(1));
 				Assert.That(nextParent.Children, Does.Contain(child));
-				Assert.That(nextParent.Children.Single().Id, Is.Not.EqualTo(0));
+				Assert.That(nextParent.Children.Single().Id, Is.Not.EqualTo(Guid.Empty));
 			}
 
 			using (var session = OpenSession())
@@ -342,7 +343,7 @@ public async Task CanChangeOwnershipFromNonFlushedParentToFlushedAsync()
 				Assert.That(parent.Children, Has.Count.EqualTo(0), "Reloaded data");
 				Assert.That(nextParent.Children, Has.Count.EqualTo(1), "Reloaded data");
 				Assert.That(nextParent.Children, Does.Contain(child), "Reloaded data");
-				Assert.That(nextParent.Children.Single().Id, Is.Not.EqualTo(0), "Reloaded data");
+				Assert.That(nextParent.Children.Single().Id, Is.Not.EqualTo(Guid.Empty), "Reloaded data");
 			}
 		}
 
@@ -365,7 +366,7 @@ public async Task CanChangeOwnershipFromNonFlushedParentToFlushedWithoutTransact
 				Assert.That(parent.Children, Has.Count.EqualTo(0));
 				Assert.That(nextParent.Children, Has.Count.EqualTo(1));
 				Assert.That(nextParent.Children, Does.Contain(child));
-				Assert.That(nextParent.Children.Single().Id, Is.Not.EqualTo(0));
+				Assert.That(nextParent.Children.Single().Id, Is.Not.EqualTo(Guid.Empty));
 			}
 
 			using (var session = OpenSession())
@@ -378,7 +379,7 @@ public async Task CanChangeOwnershipFromNonFlushedParentToFlushedWithoutTransact
 				Assert.That(parent.Children, Has.Count.EqualTo(0), "Reloaded data");
 				Assert.That(nextParent.Children, Has.Count.EqualTo(1), "Reloaded data");
 				Assert.That(nextParent.Children, Does.Contain(child), "Reloaded data");
-				Assert.That(nextParent.Children.Single().Id, Is.Not.EqualTo(0), "Reloaded data");
+				Assert.That(nextParent.Children.Single().Id, Is.Not.EqualTo(Guid.Empty), "Reloaded data");
 			}
 		}
 
@@ -404,7 +405,7 @@ public async Task CanChangeOwnershipOnNonFlushedParentsAsync()
 				Assert.That(parent.Children, Has.Count.EqualTo(0));
 				Assert.That(nextParent.Children, Has.Count.EqualTo(1));
 				Assert.That(nextParent.Children, Does.Contain(child));
-				Assert.That(nextParent.Children.Single().Id, Is.Not.EqualTo(0));
+				Assert.That(nextParent.Children.Single().Id, Is.Not.EqualTo(Guid.Empty));
 			}
 
 			using (var session = OpenSession())
@@ -417,7 +418,7 @@ public async Task CanChangeOwnershipOnNonFlushedParentsAsync()
 				Assert.That(parent.Children, Has.Count.EqualTo(0), "Reloaded data");
 				Assert.That(nextParent.Children, Has.Count.EqualTo(1), "Reloaded data");
 				Assert.That(nextParent.Children, Does.Contain(child), "Reloaded data");
-				Assert.That(nextParent.Children.Single().Id, Is.Not.EqualTo(0), "Reloaded data");
+				Assert.That(nextParent.Children.Single().Id, Is.Not.EqualTo(Guid.Empty), "Reloaded data");
 			}
 		}
 
@@ -440,7 +441,7 @@ public async Task CanChangeOwnershipOnNonFlushedParentsWithoutTransactionAsync()
 				Assert.That(parent.Children, Has.Count.EqualTo(0));
 				Assert.That(nextParent.Children, Has.Count.EqualTo(1));
 				Assert.That(nextParent.Children, Does.Contain(child));
-				Assert.That(nextParent.Children.Single().Id, Is.Not.EqualTo(0));
+				Assert.That(nextParent.Children.Single().Id, Is.Not.EqualTo(Guid.Empty));
 			}
 
 			using (var session = OpenSession())
@@ -453,7 +454,7 @@ public async Task CanChangeOwnershipOnNonFlushedParentsWithoutTransactionAsync()
 				Assert.That(parent.Children, Has.Count.EqualTo(0), "Reloaded data");
 				Assert.That(nextParent.Children, Has.Count.EqualTo(1), "Reloaded data");
 				Assert.That(nextParent.Children, Does.Contain(child), "Reloaded data");
-				Assert.That(nextParent.Children.Single().Id, Is.Not.EqualTo(0), "Reloaded data");
+				Assert.That(nextParent.Children.Single().Id, Is.Not.EqualTo(Guid.Empty), "Reloaded data");
 			}
 		}
 	}

src/NHibernate.Test/Async/NHSpecificTest/NH1098/FilterParameterOrderFixture.cs

@@ -204,7 +204,7 @@ public async Task QueryMapElementsAsync()
 
 				var a = await (query.UniqueResultAsync<A>());
 
-				Assert.AreEqual(a.C[1], "Text1");
+				Assert.AreEqual("Text1", a.C[1]);
 			}
 		}
 	}