- adapt unit tests to new nunit asserts

Test.LightweightIocContainer.Validation/IocValidatorTest.cs

@@ -221,8 +221,8 @@ public class IocValidatorTest
             Assert.Fail($"First element of {nameof(noMatchingConstructorFoundException.InnerExceptions)} is not of type {nameof(ConstructorNotMatchingException)}.");
             return;
         }
-            
-        Assert.IsInstanceOf<DirectResolveWithRegisteredFactoryNotAllowed>(iTest2CtorNotMatchingException.InnerExceptions[0]);
+        
+        Assert.That(iTest2CtorNotMatchingException.InnerExceptions[0], Is.InstanceOf<DirectResolveWithRegisteredFactoryNotAllowed>());
     }
     
     [Test]
@@ -246,8 +246,8 @@ public class IocValidatorTest
             Assert.Fail($"First element of {nameof(noMatchingConstructorFoundException.InnerExceptions)} is not of type {nameof(ConstructorNotMatchingException)}.");
             return;
         }
-            
-        Assert.IsInstanceOf<DirectResolveWithRegisteredFactoryNotAllowed>(iTest2CtorNotMatchingException.InnerExceptions[0]);
+        
+        Assert.That(iTest2CtorNotMatchingException.InnerExceptions[0], Is.InstanceOf<DirectResolveWithRegisteredFactoryNotAllowed>());
     }
     
     [Test]
@@ -271,8 +271,8 @@ public class IocValidatorTest
             Assert.Fail($"First element of {nameof(noMatchingConstructorFoundException.InnerExceptions)} is not of type {nameof(ConstructorNotMatchingException)}.");
             return;
         }
-            
-        Assert.IsInstanceOf<DirectResolveWithRegisteredFactoryNotAllowed>(iTest2CtorNotMatchingException.InnerExceptions[0]);
+        
+        Assert.That(iTest2CtorNotMatchingException.InnerExceptions[0], Is.InstanceOf<DirectResolveWithRegisteredFactoryNotAllowed>());
     }
         
     [Test]
@@ -302,7 +302,7 @@ public class IocValidatorTest
     {
         Exception exception = aggregateException?.InnerExceptions[0];
         if (exception is NoMatchingConstructorFoundException noMatchingConstructorFoundException)
-            Assert.AreEqual(typeof(T), noMatchingConstructorFoundException.Type);
+            Assert.That(noMatchingConstructorFoundException.Type, Is.EqualTo(typeof(T)));
         else
             Assert.Fail($"Exception is no {nameof(NoMatchingConstructorFoundException)}, actual type: {exception?.GetType()}");
     }

Test.LightweightIocContainer/ActionExtensionTest.cs

@@ -39,6 +39,6 @@ public class ActionExtensionTest
     public void TestConvertActionNull()
     {
         Action<IBar> barAction = null;
-        Assert.Null(barAction.Convert<IFoo, IBar>());
+        Assert.That(barAction.Convert<IFoo, IBar>(), Is.Null);
     }
 }

Test.LightweightIocContainer/AsyncFactoryTest.cs

@@ -58,7 +58,7 @@ public class AsyncFactoryTest
         ITestFactory testFactory = container.Resolve<ITestFactory>();
         ITest test = await testFactory.Create();
         
-        Assert.IsInstanceOf<Test>(test);
+        Assert.That(test, Is.InstanceOf<Test>());
     }
     
     [Test]
@@ -70,7 +70,7 @@ public class AsyncFactoryTest
         ITestFactory testFactory = container.Resolve<ITestFactory>();
         ITest test = await testFactory.Create();
         
-        Assert.IsInstanceOf<Test>(test);
+        Assert.That(test, Is.InstanceOf<Test>());
         Assert.That(test.IsInitialized, Is.True);
     }
 
@@ -85,12 +85,12 @@ public class AsyncFactoryTest
         ITest test2 = await testFactory.Create(2);
         ITest anotherTest1 = await testFactory.Create(1);
         
-        Assert.IsInstanceOf<Test>(test1);
+        Assert.That(test1, Is.InstanceOf<Test>());
         Assert.That(test1.IsInitialized, Is.True);
         
-        Assert.IsInstanceOf<Test>(test2);
+        Assert.That(test2, Is.InstanceOf<Test>());
         Assert.That(test2.IsInitialized, Is.True);
 
-        Assert.AreSame(test1, anotherTest1);
+        Assert.That(test1, Is.SameAs(anotherTest1));
     }
 }

Test.LightweightIocContainer/EnumerableExtensionTest.cs

@@ -35,7 +35,7 @@ public class EnumerableExtensionTest
     public void TestFirstOrGivenNoPredicateEmpty()
     {
         List<ListObject> list = new();
-        Assert.IsInstanceOf<Given>(list.FirstOrGiven<ListObject, Given>());
+        Assert.That(list.FirstOrGiven<ListObject, Given>(), Is.InstanceOf<Given>());
     }
 
     [Test]
@@ -50,9 +50,9 @@ public class EnumerableExtensionTest
         };
 
         ListObject listObject = list.FirstOrGiven<ListObject, Given>();
-            
-        Assert.IsNotInstanceOf<Given>(listObject);
-        Assert.AreEqual(0, listObject.Index);
+    
+        Assert.That(listObject, Is.Not.InstanceOf<Given>());
+        Assert.That(listObject.Index, Is.EqualTo(0));
     }
 
     [Test]
@@ -60,7 +60,7 @@ public class EnumerableExtensionTest
     public void TestFirstOrGivenPredicateEmpty()
     {
         List<ListObject> list = new();
-        Assert.IsInstanceOf<Given>(list.FirstOrGiven<ListObject, Given>(o => o.Index == 2));
+        Assert.That(list.FirstOrGiven<ListObject, Given>(o => o.Index == 2), Is.InstanceOf<Given>());
     }
 
     [Test]
@@ -76,8 +76,8 @@ public class EnumerableExtensionTest
 
         ListObject listObject = list.FirstOrGiven<ListObject, Given>(o => o.Index == 2);
 
-        Assert.IsNotInstanceOf<Given>(listObject);
-        Assert.AreEqual(2, listObject.Index);
+        Assert.That(listObject, Is.Not.InstanceOf<Given>());
+        Assert.That(listObject.Index, Is.EqualTo(2));
     }
 
     [Test]

Test.LightweightIocContainer/FluentFactoryRegistrationTest.cs

@@ -150,9 +150,9 @@ public class FluentFactoryRegistrationTest
 
         ITestFactory factory = _iocContainer.Resolve<ITestFactory>();
         ITest test = factory.Create();
-            
-        Assert.IsInstanceOf<ITestFactory>(factory);
-        Assert.IsInstanceOf<ITest>(test);
+        
+        Assert.That(factory, Is.InstanceOf<ITestFactory>());
+        Assert.That(test, Is.InstanceOf<ITest>());
     }
         
     [Test]
@@ -170,8 +170,8 @@ public class FluentFactoryRegistrationTest
         ITestFactory factory = _iocContainer.Resolve<ITestFactory>();
         ITest test = factory.Create();
             
-        Assert.IsInstanceOf<ITestFactory>(factory);
-        Assert.IsInstanceOf<ITest>(test);
+        Assert.That(factory, Is.InstanceOf<ITestFactory>());
+        Assert.That(test, Is.InstanceOf<ITest>());
     }
         
     [Test]
@@ -196,7 +196,7 @@ public class FluentFactoryRegistrationTest
         ITestFactory testFactory = _iocContainer.Resolve<ITestFactory>();
         ITest createdTest = testFactory.Create();
         
-        Assert.IsInstanceOf<Test>(createdTest);
+        Assert.That(createdTest, Is.InstanceOf<Test>());
     }
         
     [Test]
@@ -208,7 +208,7 @@ public class FluentFactoryRegistrationTest
         ITestFactory testFactory = _iocContainer.Resolve<ITestFactory>();
         ITest createdTest = testFactory.Create("Test");
         
-        Assert.IsInstanceOf<TestConstructor>(createdTest);
+        Assert.That(createdTest, Is.InstanceOf<TestConstructor>());
     }
         
     [Test]
@@ -220,7 +220,7 @@ public class FluentFactoryRegistrationTest
         ITestFactory testFactory = _iocContainer.Resolve<ITestFactory>();
         ITest createdTest = testFactory.CreateTest();
         
-        Assert.IsInstanceOf<TestConstructor>(createdTest);
+        Assert.That(createdTest, Is.InstanceOf<TestConstructor>());
     }
         
     [Test]
@@ -232,7 +232,7 @@ public class FluentFactoryRegistrationTest
         ITestFactory testFactory = _iocContainer.Resolve<ITestFactory>();
         ITest createdTest = testFactory.Create();
         
-        Assert.IsInstanceOf<TestConstructor>(createdTest);
+        Assert.That(createdTest, Is.InstanceOf<TestConstructor>());
     }
         
     [Test]
@@ -243,7 +243,7 @@ public class FluentFactoryRegistrationTest
         ITestFactory testFactory = _iocContainer.Resolve<ITestFactory>();
         ITest createdTest = testFactory.Create(1);
         
-        Assert.IsInstanceOf<TestByte>(createdTest);
+        Assert.That(createdTest, Is.InstanceOf<TestByte>());
     }
 
     [Test]
@@ -264,10 +264,10 @@ public class FluentFactoryRegistrationTest
             return;
         }
         
-        Assert.AreSame(obj, testNull.Obj);
-        Assert.AreEqual(content, testNull.Content);
-        Assert.AreEqual(null, testNull.Optional1);
-        Assert.AreEqual(optional2, testNull.Optional2);
+        Assert.That(testNull.Obj, Is.SameAs(obj));
+        Assert.That(testNull.Content, Is.EqualTo(content));
+        Assert.That(testNull.Optional1, Is.EqualTo(null));
+        Assert.That(testNull.Optional2, Is.EqualTo(optional2));
     }
     
     [Test]
@@ -288,11 +288,11 @@ public class FluentFactoryRegistrationTest
             return;
         }
         
-        Assert.AreSame(obj, testNull.Obj);
-        Assert.AreEqual(content, testNull.Content);
-        Assert.AreEqual(null, testNull.Optional1);
-        Assert.AreEqual(optional2, testNull.Optional2);
-        Assert.AreEqual(null, testNull.TestNullFactory);
+        Assert.That(testNull.Obj, Is.SameAs(obj));
+        Assert.That(testNull.Content, Is.EqualTo(content));
+        Assert.That(testNull.Optional1, Is.EqualTo(null));
+        Assert.That(testNull.Optional2, Is.EqualTo(optional2));
+        Assert.That(testNull.TestNullFactory, Is.EqualTo(null));
     }
         
     [Test]
@@ -309,9 +309,9 @@ public class FluentFactoryRegistrationTest
         ITest resolvedTest2 = testFactory.Create(scope1);
         ITest resolvedTest3 = testFactory.Create(scope2);
         
-        Assert.AreSame(resolvedTest1, resolvedTest2);
-        Assert.AreNotSame(resolvedTest1, resolvedTest3);
-        Assert.AreNotSame(resolvedTest2, resolvedTest3);
+        Assert.That(resolvedTest1, Is.SameAs(resolvedTest2));
+        Assert.That(resolvedTest1, Is.Not.SameAs(resolvedTest3));
+        Assert.That(resolvedTest2, Is.Not.SameAs(resolvedTest3));
     }
         
     [Test]
@@ -328,18 +328,18 @@ public class FluentFactoryRegistrationTest
         ITest resolvedTest2 = testFactory.Create(scope1);
         ITest resolvedTest3 = testFactory.Create(scope2);
         
-        Assert.AreSame(resolvedTest1, resolvedTest2);
-        Assert.AreNotSame(resolvedTest1, resolvedTest3);
-        Assert.AreNotSame(resolvedTest2, resolvedTest3);
+        Assert.That(resolvedTest1, Is.SameAs(resolvedTest2));
+        Assert.That(resolvedTest1, Is.Not.SameAs(resolvedTest3));
+        Assert.That(resolvedTest2, Is.Not.SameAs(resolvedTest3));
         
         testFactory.ClearMultitonInstance<ITest>();
         
         ITest resolvedTest4 = testFactory.Create(scope1);
         ITest resolvedTest5 = testFactory.Create(scope2);
         
-        Assert.AreNotSame(resolvedTest1, resolvedTest4);
-        Assert.AreNotSame(resolvedTest2, resolvedTest4);
-        Assert.AreNotSame(resolvedTest3, resolvedTest5);
+        Assert.That(resolvedTest1, Is.Not.SameAs(resolvedTest4));
+        Assert.That(resolvedTest2, Is.Not.SameAs(resolvedTest4));
+        Assert.That(resolvedTest3, Is.Not.SameAs(resolvedTest5));
     }
 
     [Test]

Test.LightweightIocContainer/IgnoreConstructorAttributeTest.cs

@@ -59,7 +59,7 @@ public class IgnoreConstructorAttributeTest
         container.RegisterIgnoreConstructorAttribute<IgnoreAttribute>();
 
         ITest test = container.Resolve<ITest>("name");
-        Assert.IsInstanceOf<TestIgnoreCtor>(test);
+        Assert.That(test, Is.InstanceOf<TestIgnoreCtor>());
     }
 
     [Test]

Test.LightweightIocContainer/IocContainerInterfaceSegregationTest.cs

@@ -56,10 +56,10 @@ public class IocContainerInterfaceSegregationTest
         _container.Register(r => r.Add<IBar, IFoo, Foo>().OnCreate(foo => foo.ThrowFoo()));
 
         Exception fooException = Assert.Throws<Exception>(() => _container.Resolve<IFoo>());
-        Assert.AreEqual("Foo", fooException?.Message);
+        Assert.That(fooException?.Message, Is.EqualTo("Foo"));
             
         Exception barException = Assert.Throws<Exception>(() => _container.Resolve<IBar>());
-        Assert.AreEqual("Foo", barException?.Message);
+        Assert.That(barException?.Message, Is.EqualTo("Foo"));
     }
 
     [Test]
@@ -68,13 +68,13 @@ public class IocContainerInterfaceSegregationTest
         _container.Register(r => r.Add<IBar, IFoo, IAnotherFoo, Foo>().OnCreate(foo => foo.ThrowFoo()));
 
         Exception fooException = Assert.Throws<Exception>(() => _container.Resolve<IFoo>());
-        Assert.AreEqual("Foo", fooException?.Message);
+        Assert.That(fooException?.Message, Is.EqualTo("Foo"));
 
         Exception barException = Assert.Throws<Exception>(() => _container.Resolve<IBar>());
-        Assert.AreEqual("Foo", barException?.Message);
+        Assert.That(barException?.Message, Is.EqualTo("Foo"));
 
         Exception anotherFooException = Assert.Throws<Exception>(() => _container.Resolve<IAnotherFoo>());
-        Assert.AreEqual("Foo", anotherFooException?.Message);
+        Assert.That(anotherFooException?.Message, Is.EqualTo("Foo"));
     }
 
     [Test]
@@ -83,16 +83,16 @@ public class IocContainerInterfaceSegregationTest
         _container.Register(r => r.Add<IBar, IFoo, IAnotherFoo, IAnotherBar, Foo>().OnCreate(foo => foo.ThrowFoo()));
 
         Exception fooException = Assert.Throws<Exception>(() => _container.Resolve<IFoo>());
-        Assert.AreEqual("Foo", fooException?.Message);
+        Assert.That(fooException?.Message, Is.EqualTo("Foo"));
 
         Exception barException = Assert.Throws<Exception>(() => _container.Resolve<IBar>());
-        Assert.AreEqual("Foo", barException?.Message);
+        Assert.That(barException?.Message, Is.EqualTo("Foo"));
 
         Exception anotherFooException = Assert.Throws<Exception>(() => _container.Resolve<IAnotherFoo>());
-        Assert.AreEqual("Foo", anotherFooException?.Message);
+        Assert.That(anotherFooException?.Message, Is.EqualTo("Foo"));
 
         Exception anotherBarException = Assert.Throws<Exception>(() => _container.Resolve<IAnotherBar>());
-        Assert.AreEqual("Foo", anotherBarException?.Message);
+        Assert.That(anotherBarException?.Message, Is.EqualTo("Foo"));
     }
 
     [Test]
@@ -101,19 +101,19 @@ public class IocContainerInterfaceSegregationTest
         _container.Register(r => r.Add<IBar, IFoo, IAnotherFoo, IAnotherBar, IAnotherOne, Foo>().OnCreate(foo => foo.ThrowFoo()));
 
         Exception fooException = Assert.Throws<Exception>(() => _container.Resolve<IFoo>());
-        Assert.AreEqual("Foo", fooException?.Message);
+        Assert.That(fooException?.Message, Is.EqualTo("Foo"));
 
         Exception barException = Assert.Throws<Exception>(() => _container.Resolve<IBar>());
-        Assert.AreEqual("Foo", barException?.Message);
+        Assert.That(barException?.Message, Is.EqualTo("Foo"));
 
         Exception anotherFooException = Assert.Throws<Exception>(() => _container.Resolve<IAnotherFoo>());
-        Assert.AreEqual("Foo", anotherFooException?.Message);
+        Assert.That(anotherFooException?.Message, Is.EqualTo("Foo"));
 
         Exception anotherBarException = Assert.Throws<Exception>(() => _container.Resolve<IAnotherBar>());
-        Assert.AreEqual("Foo", anotherBarException?.Message);
+        Assert.That(anotherBarException?.Message, Is.EqualTo("Foo"));
 
         Exception anotherOneException = Assert.Throws<Exception>(() => _container.Resolve<IAnotherOne>());
-        Assert.AreEqual("Foo", anotherOneException?.Message);
+        Assert.That(anotherOneException?.Message, Is.EqualTo("Foo"));
     }
 
     [Test]
@@ -126,11 +126,11 @@ public class IocContainerInterfaceSegregationTest
         IAnotherBar anotherBar = _container.Resolve<IAnotherBar>();
         IAnotherOne anotherOne = _container.Resolve<IAnotherOne>();
 
-        Assert.IsInstanceOf<Foo>(foo);
-        Assert.IsInstanceOf<Foo>(bar);
-        Assert.IsInstanceOf<Foo>(anotherFoo);
-        Assert.IsInstanceOf<Foo>(anotherBar);
-        Assert.IsInstanceOf<Foo>(anotherOne);
+        Assert.That(foo, Is.InstanceOf<Foo>());
+        Assert.That(bar, Is.InstanceOf<Foo>());
+        Assert.That(anotherFoo, Is.InstanceOf<Foo>());
+        Assert.That(anotherBar, Is.InstanceOf<Foo>());
+        Assert.That(anotherOne, Is.InstanceOf<Foo>());
     }
 
     [Test]
@@ -143,20 +143,20 @@ public class IocContainerInterfaceSegregationTest
         IAnotherBar anotherBar = _container.Resolve<IAnotherBar>();
         IAnotherOne anotherOne = _container.Resolve<IAnotherOne>();
 
-        Assert.IsInstanceOf<Foo>(foo);
-        Assert.IsInstanceOf<Foo>(bar);
-        Assert.IsInstanceOf<Foo>(anotherFoo);
-        Assert.IsInstanceOf<Foo>(anotherBar);
-        Assert.IsInstanceOf<Foo>(anotherOne);
-            
-        Assert.AreEqual(foo, bar);
-        Assert.AreEqual(foo, anotherFoo);
-        Assert.AreEqual(foo, anotherBar);
-        Assert.AreEqual(foo, anotherOne);
-
-        Assert.AreSame(foo, bar);
-        Assert.AreSame(foo, anotherFoo);
-        Assert.AreSame(foo, anotherBar);
-        Assert.AreSame(foo, anotherOne);
+        Assert.That(foo, Is.InstanceOf<Foo>());
+        Assert.That(bar, Is.InstanceOf<Foo>());
+        Assert.That(anotherFoo, Is.InstanceOf<Foo>());
+        Assert.That(anotherBar, Is.InstanceOf<Foo>());
+        Assert.That(anotherOne, Is.InstanceOf<Foo>());
+        
+        Assert.That(bar, Is.EqualTo(foo));
+        Assert.That(anotherFoo, Is.EqualTo(foo));
+        Assert.That(anotherBar, Is.EqualTo(foo));
+        Assert.That(anotherOne, Is.EqualTo(foo));
+
+        Assert.That(bar, Is.SameAs(foo));
+        Assert.That(anotherFoo, Is.SameAs(foo));
+        Assert.That(anotherBar, Is.SameAs(foo));
+        Assert.That(anotherOne, Is.SameAs(foo));
     }
 }

Test.LightweightIocContainer/IocContainerParameterRegistrationTest.cs

@@ -106,9 +106,9 @@ public class IocContainerParameterRegistrationTest
             
         _iocContainer.Register(r => r.Add<IA, A>().WithParameters(b, c));
         IA a = _iocContainer.Resolve<IA>();
-            
-        Assert.AreSame(b, a.B);
-        Assert.AreSame(c, a.C);
+        
+        Assert.That(a.B, Is.SameAs(b));
+        Assert.That(a.C, Is.SameAs(c));
     }
 
     [Test]
@@ -120,8 +120,8 @@ public class IocContainerParameterRegistrationTest
         _iocContainer.Register(r => r.Add<IA, A>().WithParameters(b));
         IA a = _iocContainer.Resolve<IA>(c);
 
-        Assert.AreSame(b, a.B);
-        Assert.AreSame(c, a.C);
+        Assert.That(a.B, Is.SameAs(b));
+        Assert.That(a.C, Is.SameAs(c));
     }
 
     [Test]
@@ -136,11 +136,11 @@ public class IocContainerParameterRegistrationTest
         _iocContainer.Register(r => r.Add<ID, D>().WithParameters((0, a), (2, a3), (3, b), (4, c)));
         ID d = _iocContainer.Resolve<ID>(a2);
 
-        Assert.AreSame(a, d.A);
-        Assert.AreSame(a2, d.A2);
-        Assert.AreSame(a3, d.A3);
-        Assert.AreSame(b, d.B);
-        Assert.AreSame(c, d.C);
+        Assert.That(d.A, Is.SameAs(a));
+        Assert.That(d.A2, Is.SameAs(a2));
+        Assert.That(d.A3, Is.SameAs(a3));
+        Assert.That(d.B, Is.SameAs(b));
+        Assert.That(d.C, Is.SameAs(c));
     }
 
     [Test]
@@ -158,9 +158,9 @@ public class IocContainerParameterRegistrationTest
 
         ID d = _iocContainer.Resolve<ID>(a);
 
-        Assert.AreSame(a, d.A2);
-        Assert.AreSame(a2, d.A);
-        Assert.AreNotSame(a, d.A3);
-        Assert.AreNotSame(a2, d.A3);
+        Assert.That(d.A, Is.SameAs(a2));
+        Assert.That(d.A2, Is.SameAs(a));
+        Assert.That(d.A3, Is.Not.SameAs(a));
+        Assert.That(d.A3, Is.Not.SameAs(a2));
     }
 }

Test.LightweightIocContainer/IocContainerRecursionTest.cs

@@ -118,9 +118,9 @@ public class IocContainerRecursionTest
         ConstructorNotMatchingException barConstructorNotMatchingException = (ConstructorNotMatchingException) noMatchingBarConstructorFoundException?.InnerExceptions[0];
             
         CircularDependencyException exception = (CircularDependencyException) barConstructorNotMatchingException?.InnerExceptions[0];
-            
-        Assert.AreEqual(typeof(IFoo), exception?.ResolvingType);
-        Assert.AreEqual(2, exception.ResolveStack.Count);
+        
+        Assert.That(exception?.ResolvingType, Is.EqualTo(typeof(IFoo)));
+        Assert.That(exception?.ResolveStack.Count, Is.EqualTo(2));
 
         string message = $"Circular dependency has been detected when trying to resolve `{typeof(IFoo)}`.\n" +
                          "Resolve stack that resulted in the circular dependency:\n" +
@@ -128,7 +128,7 @@ public class IocContainerRecursionTest
                          $"\t`{typeof(IBar)}` resolved as dependency of\n" +
                          $"\t`{typeof(IFoo)}` which is the root type being resolved.";
 
-        Assert.AreEqual(message, exception.Message);
+        Assert.That(exception.Message, Is.EqualTo(message));
     }
 
     [Test]
@@ -139,7 +139,7 @@ public class IocContainerRecursionTest
         _iocContainer.Register(r => r.Add<IC, C>());
 
         IA a = _iocContainer.Resolve<IA>();
-        Assert.IsNotNull(a);
+        Assert.That(a, Is.Not.Null);
     }
 
     [Test]

Test.LightweightIocContainer/IocContainerTest.cs

@@ -129,7 +129,7 @@ public class IocContainerTest
 
         installerMock.Received(1).Install(Arg.Any<IRegistrationCollector>());
 
-        Assert.AreEqual(_iocContainer, returnedContainer);
+        Assert.That(returnedContainer, Is.EqualTo(_iocContainer));
     }
 
     [Test]
@@ -145,7 +145,7 @@ public class IocContainerTest
         installer2Mock.Received(1).Install(Arg.Any<IRegistrationCollector>());
         installer3Mock.Received(1).Install(Arg.Any<IRegistrationCollector>());
 
-        Assert.AreEqual(_iocContainer, returnedContainer);
+        Assert.That(returnedContainer, Is.EqualTo(_iocContainer));
     }
 
     [Test]
@@ -165,7 +165,7 @@ public class IocContainerTest
     {
         _iocContainer.Register(r => r.Add<ITest, Test>());
         MultipleRegistrationException exception = Assert.Throws<MultipleRegistrationException>(() => _iocContainer.Register(r => r.Add<ITest, TestConstructor>()));
-        Assert.AreEqual(typeof(ITest), exception?.Type);
+        Assert.That(exception?.Type, Is.EqualTo(typeof(ITest)));
     }
         
     [Test]
@@ -186,7 +186,7 @@ public class IocContainerTest
     public void TestResolveNotRegistered()
     {
         TypeNotRegisteredException exception = Assert.Throws<TypeNotRegisteredException>(() => _iocContainer.Resolve<ITest>());
-        Assert.AreEqual(typeof(ITest), exception?.Type);
+        Assert.That(exception?.Type, Is.EqualTo(typeof(ITest)));
     }
 
     [Test]
@@ -196,7 +196,7 @@ public class IocContainerTest
 
         ITest resolvedTest = _iocContainer.Resolve<ITest>();
 
-        Assert.IsInstanceOf<Test>(resolvedTest);
+        Assert.That(resolvedTest, Is.InstanceOf<Test>());
     }
 
     [Test]
@@ -206,7 +206,7 @@ public class IocContainerTest
 
         Test resolvedTest = _iocContainer.Resolve<Test>();
 
-        Assert.IsInstanceOf<Test>(resolvedTest);
+        Assert.That(resolvedTest, Is.InstanceOf<Test>());
     }
 
     [Test]
@@ -223,7 +223,7 @@ public class IocContainerTest
 
         Test resolvedTest = _iocContainer.Resolve<Test>();
             
-        Assert.IsInstanceOf<Test>(resolvedTest);
+        Assert.That(resolvedTest, Is.InstanceOf<Test>());
     }
 
     [Test]
@@ -232,8 +232,8 @@ public class IocContainerTest
         _iocContainer.Register(r => r.Add<ITest, TestConstructor>());
 
         ITest resolvedTest = _iocContainer.Resolve<ITest>("Test", new Test());
-
-        Assert.IsInstanceOf<TestConstructor>(resolvedTest);
+        
+        Assert.That(resolvedTest, Is.InstanceOf<TestConstructor>());
     }
 
     [Test]
@@ -244,7 +244,7 @@ public class IocContainerTest
 
         ITest resolvedTest = _iocContainer.Resolve<ITest>("Test");
 
-        Assert.IsInstanceOf<TestConstructor>(resolvedTest);
+        Assert.That(resolvedTest, Is.InstanceOf<TestConstructor>());
     }
 
     [Test]
@@ -255,7 +255,7 @@ public class IocContainerTest
         ITest resolvedTest = _iocContainer.Resolve<ITest>();
         ITest secondResolvedTest = _iocContainer.Resolve<ITest>();
 
-        Assert.AreEqual(resolvedTest, secondResolvedTest);
+        Assert.That(secondResolvedTest, Is.EqualTo(resolvedTest));
     }
 
     [Test]
@@ -270,9 +270,9 @@ public class IocContainerTest
         ITest resolvedTest2 = _iocContainer.Resolve<ITest>(scope1);
         ITest resolvedTest3 = _iocContainer.Resolve<ITest>(scope2);
 
-        Assert.AreSame(resolvedTest1, resolvedTest2);
-        Assert.AreNotSame(resolvedTest1, resolvedTest3);
-        Assert.AreNotSame(resolvedTest2, resolvedTest3);
+        Assert.That(resolvedTest1, Is.SameAs(resolvedTest2));
+        Assert.That(resolvedTest1, Is.Not.SameAs(resolvedTest3));
+        Assert.That(resolvedTest2, Is.Not.SameAs(resolvedTest3));
     }
     
     [Test]
@@ -284,9 +284,9 @@ public class IocContainerTest
         ITest resolvedTest2 = _iocContainer.Resolve<ITest>(1);
         ITest resolvedTest3 = _iocContainer.Resolve<ITest>(2);
 
-        Assert.AreSame(resolvedTest1, resolvedTest2);
-        Assert.AreNotSame(resolvedTest1, resolvedTest3);
-        Assert.AreNotSame(resolvedTest2, resolvedTest3);
+        Assert.That(resolvedTest1, Is.SameAs(resolvedTest2));
+        Assert.That(resolvedTest1, Is.Not.SameAs(resolvedTest3));
+        Assert.That(resolvedTest2, Is.Not.SameAs(resolvedTest3));
     }
 
     [Test]
@@ -295,7 +295,7 @@ public class IocContainerTest
         _iocContainer.Register(r => r.AddMultiton<ITest, Test, MultitonScope>());
 
         MultitonResolveException exception = Assert.Throws<MultitonResolveException>(() => _iocContainer.Resolve<ITest>());
-        Assert.AreEqual(typeof(ITest), exception?.Type);
+        Assert.That(exception?.Type, Is.EqualTo(typeof(ITest)));
     }
 
     [Test]
@@ -304,7 +304,7 @@ public class IocContainerTest
         _iocContainer.Register(r => r.AddMultiton<ITest, Test, MultitonScope>());
 
         MultitonResolveException exception = Assert.Throws<MultitonResolveException>(() => _iocContainer.Resolve<ITest>(new object()));
-        Assert.AreEqual(typeof(ITest), exception?.Type);
+        Assert.That(exception?.Type, Is.EqualTo(typeof(ITest)));
     }
 
     [Test]
@@ -315,7 +315,7 @@ public class IocContainerTest
         ITest resolvedTest = _iocContainer.Resolve<ITest>();
         ITest secondResolvedTest = _iocContainer.Resolve<ITest>();
 
-        Assert.AreNotEqual(resolvedTest, secondResolvedTest);
+        Assert.That(secondResolvedTest, Is.Not.EqualTo(resolvedTest));
     }
 
     [Test]
@@ -323,7 +323,7 @@ public class IocContainerTest
     {
         _iocContainer.Register(r => r.Add<ITest, TestConstructor>());
         NoMatchingConstructorFoundException exception = Assert.Throws<NoMatchingConstructorFoundException>(() => _iocContainer.Resolve<ITest>());
-        Assert.AreEqual(typeof(TestConstructor), exception?.Type);
+        Assert.That(exception?.Type, Is.EqualTo(typeof(TestConstructor)));
     }
 
     [Test]
@@ -338,7 +338,7 @@ public class IocContainerTest
     {
         _iocContainer.Register(r => r.Add<ITest, TestPrivateConstructor>());
         NoPublicConstructorFoundException exception = Assert.Throws<NoPublicConstructorFoundException>(() => _iocContainer.Resolve<ITest>());
-        Assert.AreEqual(typeof(TestPrivateConstructor), exception?.Type);
+        Assert.That(exception?.Type, Is.EqualTo(typeof(TestPrivateConstructor)));
     }
 
     [Test]
@@ -348,8 +348,8 @@ public class IocContainerTest
         _iocContainer.Register(r => r.Add<ITest>().WithFactoryMethod(c => new TestConstructor(c.Resolve<IFoo>(), "someName")));
 
         ITest test = _iocContainer.Resolve<ITest>();
-            
-        Assert.NotNull(test);
+        
+        Assert.That(test, Is.Not.Null);
     }
 
     [Test]
@@ -359,8 +359,8 @@ public class IocContainerTest
         _iocContainer.Register(r => r.Add<IFoo, FooConstructor>().WithParameters("TestString"));
 
         ITest test = _iocContainer.Resolve<ITest>("testName");
-            
-        Assert.IsInstanceOf<TestConstructor>(test);
+        
+        Assert.That(test, Is.InstanceOf<TestConstructor>());
     }
     
     [Test]
@@ -382,12 +382,12 @@ public class IocContainerTest
     [Test]
     public void TestIsTypeRegistered()
     {
-        Assert.False(_iocContainer.IsTypeRegistered<ITest>());
+        Assert.That(_iocContainer.IsTypeRegistered<ITest>(), Is.False);
 
         _iocContainer.Register(r => r.Add<ITest, Test>());
-        Assert.True(_iocContainer.IsTypeRegistered<ITest>());
+        Assert.That(_iocContainer.IsTypeRegistered<ITest>(), Is.True);
 
         _iocContainer.Register(r => r.Add<Test>());
-        Assert.True(_iocContainer.IsTypeRegistered<Test>());
+        Assert.That(_iocContainer.IsTypeRegistered<Test>(), Is.True);
     }
 }

Test.LightweightIocContainer/MultiLayerResolveTest.cs

@@ -79,7 +79,7 @@ public class MultiLayerResolveTest
 
         IAFactory aFactory = container.Resolve<IAFactory>();
         IA a = aFactory.Create();
-        Assert.IsInstanceOf<A>(a);
+        Assert.That(a, Is.InstanceOf<A>());
     }
 
     [Test]
@@ -92,7 +92,7 @@ public class MultiLayerResolveTest
 
         IBFactory bFactory = container.Resolve<IBFactory>();
         IB b = bFactory.Create();
-        Assert.IsInstanceOf<B>(b);
+        Assert.That(b, Is.InstanceOf<B>());
     }
 
     [Test]
@@ -104,6 +104,6 @@ public class MultiLayerResolveTest
         container.Register(r => r.Add<C>(Lifestyle.Singleton).WithParameters("test"));
 
         OtherA a = container.Resolve<OtherA>();
-        Assert.AreEqual(a.BProperty.C, a.SecondB.C);
+        Assert.That(a.BProperty.C, Is.EqualTo(a.SecondB.C));
     }
 }

Test.LightweightIocContainer/MultipleMultitonRegistrationTest.cs

@@ -58,12 +58,12 @@ public class MultipleMultitonRegistrationTest
         MultitonScope scope = new();
             
         ITest test = _iocContainer.Resolve<ITest>(scope);
-        Assert.NotNull(test);
+        Assert.That(test, Is.Not.Null);
 
         IProvider provider = _iocContainer.Resolve<IProvider>(scope);
-        Assert.NotNull(provider);
-        Assert.AreEqual(test, provider);
-        Assert.AreSame(test, provider);
+        Assert.That(provider, Is.Not.Null);
+        Assert.That(provider, Is.EqualTo(test));
+        Assert.That(provider, Is.SameAs(test));
     }
 
     [Test]
@@ -75,13 +75,13 @@ public class MultipleMultitonRegistrationTest
         MultitonScope differentScope = new();
             
         ITest test = _iocContainer.Resolve<ITest>(scope);
-        Assert.NotNull(test);
+        Assert.That(test, Is.Not.Null);
 
         IProvider provider = _iocContainer.Resolve<IProvider>(differentScope);
-        Assert.NotNull(provider);
-            
-        Assert.AreNotEqual(test, provider);
-        Assert.AreNotSame(test, provider);
+        Assert.That(provider, Is.Not.Null);
+        
+        Assert.That(provider, Is.Not.EqualTo(test));
+        Assert.That(provider, Is.Not.SameAs(test));
     }
 
     [Test]
@@ -92,14 +92,14 @@ public class MultipleMultitonRegistrationTest
         MultitonScope scope = new();
             
         ITest test = _iocContainer.Resolve<ITest>(scope);
-        Assert.NotNull(test);
-        Assert.AreEqual(1, test.Number);
+        Assert.That(test, Is.Not.Null);
+        Assert.That(test.Number, Is.EqualTo(1));
 
         IProvider provider = _iocContainer.Resolve<IProvider>(scope);
-        Assert.NotNull(provider);
-        Assert.AreEqual(1, provider.Number);
+        Assert.That(provider, Is.Not.Null);
+        Assert.That(provider.Number, Is.EqualTo(1));
             
-        Assert.AreEqual(test, provider);
-        Assert.AreSame(test, provider);
+        Assert.That(provider, Is.EqualTo(test));
+        Assert.That(provider, Is.SameAs(test));
     }
 }

Test.LightweightIocContainer/OpenGenericRegistrationTest.cs

@@ -73,7 +73,7 @@ public class OpenGenericRegistrationTest
         _iocContainer.Register(r => r.AddOpenGenerics(typeof(ITest<>), typeof(Test<>)));
 
         ITest<Constraint> test = _iocContainer.Resolve<ITest<Constraint>>();
-        Assert.NotNull(test);
+        Assert.That(test, Is.Not.Null);
     }
 
     [Test]
@@ -82,13 +82,13 @@ public class OpenGenericRegistrationTest
         _iocContainer.Register(r => r.AddOpenGenerics(typeof(ITest<>), typeof(Test<>), Lifestyle.Singleton));
 
         ITest<Constraint> test = _iocContainer.Resolve<ITest<Constraint>>();
-        Assert.NotNull(test);
+        Assert.That(test, Is.Not.Null);
 
         ITest<Constraint> secondTest = _iocContainer.Resolve<ITest<Constraint>>();
-        Assert.NotNull(secondTest);
-            
-        Assert.AreEqual(test, secondTest);
-        Assert.AreSame(test, secondTest);
+        Assert.That(secondTest, Is.Not.Null);
+        
+        Assert.That(secondTest, Is.EqualTo(test));
+        Assert.That(secondTest, Is.SameAs(test));
     }
         
     [Test]
@@ -105,7 +105,7 @@ public class OpenGenericRegistrationTest
         _iocContainer.Register(r => r.AddOpenGenerics(typeof(ITest<>), typeof(Test<>)).WithFactory<ITestFactory>());
         ITestFactory testFactory = _iocContainer.Resolve<ITestFactory>();
         ITest<Constraint> test = testFactory.Create<Constraint>();
-        Assert.IsInstanceOf<Test<Constraint>>(test);
+        Assert.That(test, Is.InstanceOf<Test<Constraint>>());
     }
 
     [Test]
@@ -114,6 +114,6 @@ public class OpenGenericRegistrationTest
         _iocContainer.Register(r => r.AddOpenGenerics(typeof(ITest<>), typeof(CtorTest<>)).WithFactory<ICtorTestFactory>());
         ICtorTestFactory testFactory = _iocContainer.Resolve<ICtorTestFactory>();
         ITest<Constraint> test = testFactory.Create(new Constraint());
-        Assert.IsInstanceOf<CtorTest<Constraint>>(test);
+        Assert.That(test, Is.InstanceOf<CtorTest<Constraint>>());
     }
 }

Test.LightweightIocContainer/RegistrationBaseTest.cs

@@ -60,8 +60,8 @@ public class RegistrationBaseTest
 
         RegistrationBase testRegistration = (RegistrationBase) registrationFactory.Register<IFoo, Foo>(Lifestyle.Transient).WithParameters(bar, test);
 
-        Assert.AreEqual(bar, testRegistration.Parameters![0]);
-        Assert.AreEqual(test, testRegistration.Parameters[1]);
+        Assert.That(testRegistration.Parameters![0], Is.EqualTo(bar));
+        Assert.That(testRegistration.Parameters[1], Is.EqualTo(test));
     }
 
     [Test]
@@ -74,10 +74,10 @@ public class RegistrationBaseTest
 
         RegistrationBase testRegistration = (RegistrationBase) registrationFactory.Register<IFoo, Foo>(Lifestyle.Transient).WithParameters((0, bar), (3, test), (2, "SomeString"));
 
-        Assert.AreEqual(bar, testRegistration.Parameters![0]);
-        Assert.IsInstanceOf<InternalResolvePlaceholder>(testRegistration.Parameters[1]);
-        Assert.AreEqual("SomeString", testRegistration.Parameters[2]);
-        Assert.AreEqual(test, testRegistration.Parameters[3]);
+        Assert.That(testRegistration.Parameters![0], Is.EqualTo(bar));
+        Assert.That(testRegistration.Parameters[1], Is.InstanceOf<InternalResolvePlaceholder>());
+        Assert.That(testRegistration.Parameters[2], Is.EqualTo("SomeString"));
+        Assert.That(testRegistration.Parameters[3], Is.EqualTo(test));
     }
 
     [Test]

Test.LightweightIocContainer/SingleTypeRegistrationTest.cs

@@ -58,7 +58,7 @@ public class SingleTypeRegistrationTest
         ISingleTypeRegistration<IFoo> registration = registrationFactory.Register<IFoo>(Lifestyle.Transient).WithFactoryMethod(c => new Foo(c.Resolve<IBar>()));
 
         IFoo foo = registration.FactoryMethod!(iocContainerMock);
-        Assert.AreEqual(bar, foo.Bar);
+        Assert.That(foo.Bar, Is.EqualTo(bar));
     }
 
     [Test]
@@ -71,8 +71,8 @@ public class SingleTypeRegistrationTest
 
         IFoo foo = container.Resolve<IFoo>();
 
-        Assert.IsInstanceOf<Foo>(foo);
-        Assert.AreEqual(bar, foo.Bar);
+        Assert.That(foo, Is.InstanceOf<Foo>());
+        Assert.That(foo.Bar, Is.EqualTo(bar));
     }
 
     [Test]