- adapt to nunit changes

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

@@ -2,6 +2,7 @@
 // Created: 2019-12-11
 // Copyright(c) 2019 SimonG. All Rights Reserved.
 
+using System.Diagnostics.CodeAnalysis;
 using LightweightIocContainer;
 using NUnit.Framework;
 
@@ -27,6 +28,7 @@ public class ActionExtensionTest
         
 
     [Test]
+    [SuppressMessage("ReSharper", "PossibleNullReferenceException")]
     public void TestConvert()
     {
         Action<IBar> barAction = bar => bar.Throw();
@@ -36,9 +38,10 @@ public class ActionExtensionTest
     }
 
     [Test]
+    [SuppressMessage("ReSharper", "ExpressionIsAlwaysNull")]
     public void TestConvertActionNull()
     {
         Action<IBar> barAction = null;
-        Assert.Null(barAction.Convert<IFoo, IBar>());
+        Assert.That(barAction.Convert<IFoo, IBar>(), Is.Null);
     }
 }

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]
@@ -51,8 +51,8 @@ public class EnumerableExtensionTest
 
         ListObject listObject = list.FirstOrGiven<ListObject, Given>();
             
-        Assert.IsNotInstanceOf<Given>(listObject);
-        Assert.AreEqual(0, listObject.Index);
+        Assert.That(list.FirstOrGiven<ListObject, Given>(), 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

@@ -151,8 +151,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]
@@ -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.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.Null);
+        Assert.That(testNull.Optional2, Is.EqualTo(optional2));
+        Assert.That(testNull.TestNullFactory, Is.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(resolvedTest2, Is.SameAs(resolvedTest1));
+        Assert.That(resolvedTest3, Is.Not.SameAs(resolvedTest1));
+        Assert.That(resolvedTest3, Is.Not.SameAs(resolvedTest2));
     }
         
     [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(resolvedTest2, Is.SameAs(resolvedTest1));
+        Assert.That(resolvedTest3, Is.Not.SameAs(resolvedTest1));
+        Assert.That(resolvedTest3, Is.Not.SameAs(resolvedTest2));
         
         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(resolvedTest4, Is.Not.SameAs(resolvedTest1));
+        Assert.That(resolvedTest4, Is.Not.SameAs(resolvedTest2));
+        Assert.That(resolvedTest5, Is.Not.SameAs(resolvedTest3));
     }
 
     [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,15 @@ 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.SameAs(foo));
+        Assert.That(anotherFoo, Is.SameAs(foo));
+        Assert.That(anotherBar, Is.SameAs(foo));
+        Assert.That(anotherOne, Is.SameAs(foo));
     }
 }

Test.LightweightIocContainer/IocContainerParameterRegistrationTest.cs

@@ -107,8 +107,8 @@ 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.A2, Is.SameAs(a));
+        Assert.That(d.A, Is.SameAs(a2));
+        Assert.That(d.A3, Is.Not.SameAs(a));
+        Assert.That(d.A3, Is.Not.SameAs(a2));
     }
 }

Test.LightweightIocContainer/IocContainerRecursionTest.cs

@@ -119,8 +119,8 @@ public class IocContainerRecursionTest
             
         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

@@ -124,7 +124,7 @@ public class IocContainerTest
 
         installerMock.Received(1).Install(Arg.Any<IRegistrationCollector>());
 
-        Assert.AreEqual(_iocContainer, returnedContainer);
+        Assert.That(returnedContainer, Is.EqualTo(_iocContainer));
     }
 
     [Test]
@@ -140,7 +140,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]
@@ -160,7 +160,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]
@@ -181,7 +181,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]
@@ -191,7 +191,7 @@ public class IocContainerTest
 
         ITest resolvedTest = _iocContainer.Resolve<ITest>();
 
-        Assert.IsInstanceOf<Test>(resolvedTest);
+        Assert.That(resolvedTest, Is.InstanceOf<Test>());
     }
 
     [Test]
@@ -201,7 +201,7 @@ public class IocContainerTest
 
         Test resolvedTest = _iocContainer.Resolve<Test>();
 
-        Assert.IsInstanceOf<Test>(resolvedTest);
+        Assert.That(resolvedTest, Is.InstanceOf<Test>());
     }
 
     [Test]
@@ -218,7 +218,7 @@ public class IocContainerTest
 
         Test resolvedTest = _iocContainer.Resolve<Test>();
             
-        Assert.IsInstanceOf<Test>(resolvedTest);
+        Assert.That(resolvedTest, Is.InstanceOf<Test>());
     }
 
     [Test]
@@ -228,7 +228,7 @@ public class IocContainerTest
 
         ITest resolvedTest = _iocContainer.Resolve<ITest>("Test", new Test());
 
-        Assert.IsInstanceOf<TestConstructor>(resolvedTest);
+        Assert.That(resolvedTest, Is.InstanceOf<TestConstructor>());
     }
 
     [Test]
@@ -239,7 +239,7 @@ public class IocContainerTest
 
         ITest resolvedTest = _iocContainer.Resolve<ITest>("Test");
 
-        Assert.IsInstanceOf<TestConstructor>(resolvedTest);
+        Assert.That(resolvedTest, Is.InstanceOf<TestConstructor>());
     }
 
     [Test]
@@ -250,7 +250,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]
@@ -265,9 +265,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(resolvedTest2, Is.SameAs(resolvedTest1));
+        Assert.That(resolvedTest3, Is.Not.SameAs(resolvedTest1));
+        Assert.That(resolvedTest3, Is.Not.SameAs(resolvedTest2));
     }
 
     [Test]
@@ -276,7 +276,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]
@@ -285,7 +285,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]
@@ -296,7 +296,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]
@@ -304,7 +304,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]
@@ -319,7 +319,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]
@@ -330,7 +330,7 @@ public class IocContainerTest
 
         ITest test = _iocContainer.Resolve<ITest>();
             
-        Assert.NotNull(test);
+        Assert.That(test, Is.Not.Null);
     }
 
     [Test]
@@ -340,8 +340,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]
@@ -363,12 +363,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.SecondB.C, Is.EqualTo(a.BProperty.C));
     }
 }

Test.LightweightIocContainer/MultipleMultitonRegistrationTest.cs

@@ -58,12 +58,11 @@ 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.SameAs(test));
     }
 
     [Test]
@@ -75,13 +74,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.SameAs(test));
+        Assert.That(provider, Is.Not.EqualTo(test));
     }
 
     [Test]
@@ -92,14 +91,13 @@ 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.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,12 @@ 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.That(secondTest, Is.Not.Null);
             
-        Assert.AreEqual(test, secondTest);
-        Assert.AreSame(test, secondTest);
+        Assert.That(secondTest, Is.SameAs(test));
     }
         
     [Test]
@@ -105,7 +104,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 +113,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

@@ -52,7 +52,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]
@@ -65,7 +65,7 @@ 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));
     }
 }