SimonG
/
LightweightIocContainer
mirror of https://github.com/SimonG96/LightweightIocContainer.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

- adapt unit tests to new nunit asserts

Browse Source
master
Simon G. 1 year ago
parent ca022cbe61
commit fc8faf6b23
Signed by: SimonG
GPG Key ID: 0B82B964BA536523
15 changed files with 166 additions and 166 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 8
      Test.LightweightIocContainer.Validation/IocValidatorTest.cs
  2. 2
      Test.LightweightIocContainer/ActionExtensionTest.cs
  3. 10
      Test.LightweightIocContainer/AsyncFactoryTest.cs
  4. 12
      Test.LightweightIocContainer/EnumerableExtensionTest.cs
  5. 54
      Test.LightweightIocContainer/FluentFactoryRegistrationTest.cs
  6. 2
      Test.LightweightIocContainer/IgnoreConstructorAttributeTest.cs
  7. 68
      Test.LightweightIocContainer/IocContainerInterfaceSegregationTest.cs
  8. 26
      Test.LightweightIocContainer/IocContainerParameterRegistrationTest.cs
  9. 8
      Test.LightweightIocContainer/IocContainerRecursionTest.cs
  10. 52
      Test.LightweightIocContainer/IocContainerTest.cs
  11. 6
      Test.LightweightIocContainer/MultiLayerResolveTest.cs
  12. 28
      Test.LightweightIocContainer/MultipleMultitonRegistrationTest.cs
  13. 14
      Test.LightweightIocContainer/OpenGenericRegistrationTest.cs
  14. 12
      Test.LightweightIocContainer/RegistrationBaseTest.cs
  15. 6
      Test.LightweightIocContainer/SingleTypeRegistrationTest.cs

8
Test.LightweightIocContainer.Validation/IocValidatorTest.cs
Unescape View File

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

2
Test.LightweightIocContainer/ActionExtensionTest.cs
Unescape View File

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

10
Test.LightweightIocContainer/AsyncFactoryTest.cs
Unescape View File

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

12
Test.LightweightIocContainer/EnumerableExtensionTest.cs
Unescape View File

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

54
Test.LightweightIocContainer/FluentFactoryRegistrationTest.cs
Unescape View File

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

2
Test.LightweightIocContainer/IgnoreConstructorAttributeTest.cs
Unescape View File

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

68
Test.LightweightIocContainer/IocContainerInterfaceSegregationTest.cs
Unescape View File

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

26
Test.LightweightIocContainer/IocContainerParameterRegistrationTest.cs
Unescape View File

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

8
Test.LightweightIocContainer/IocContainerRecursionTest.cs
Unescape View File

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

52
Test.LightweightIocContainer/IocContainerTest.cs
Unescape View File

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

6
Test.LightweightIocContainer/MultiLayerResolveTest.cs
Unescape View File

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

28
Test.LightweightIocContainer/MultipleMultitonRegistrationTest.cs
Unescape View File

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

14
Test.LightweightIocContainer/OpenGenericRegistrationTest.cs
Unescape View File

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

12
Test.LightweightIocContainer/RegistrationBaseTest.cs
Unescape View File

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

6
Test.LightweightIocContainer/SingleTypeRegistrationTest.cs
Unescape View File

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

Write Preview
Loading…
Cancel
Save