public void FieldInjectionFromNewInstancesOfType()
{
ImplWithInstanceIndex.instanceCount = 0;
BindingBuilder bb = new BindingBuilder();
bb.BindTypeToNewInstances(typeof(ImplWithInstanceIndex));
Injector injector = UniInjectUtils.CreateInjector();
injector.AddBindings(bb);
NeedsFieldInjection needsInjection1 = injector.CreateAndInject <NeedsFieldInjection>();
NeedsFieldInjection needsInjection2 = injector.CreateAndInject <NeedsFieldInjection>();
NeedsFieldInjection needsInjection3 = injector.CreateAndInject <NeedsFieldInjection>();
// Assert injection was successful
Assert.NotNull(needsInjection1);
Assert.NotNull(needsInjection2);
Assert.NotNull(needsInjection3);
// Assert that different instances were injected.
Assert.AreEqual(1, needsInjection1.implWithInstanceCounter.instanceIndex);
Assert.AreEqual(2, needsInjection2.implWithInstanceCounter.instanceIndex);
Assert.AreEqual(3, needsInjection3.implWithInstanceCounter.instanceIndex);
Assert.AreEqual(3, ImplWithInstanceIndex.instanceCount);
}
public void FieldInjectionFromSingleInstanceOfType()
{
ImplWithInstanceIndex.instanceCount = 0;
BindingBuilder bb = new BindingBuilder();
bb.BindTypeToSingleInstance(typeof(ImplWithInstanceIndex));
Injector injector = UniInjectUtils.CreateInjector();
injector.AddBindings(bb);
NeedsFieldInjection needsInjection1 = injector.CreateAndInject <NeedsFieldInjection>();
NeedsFieldInjection needsInjection2 = injector.CreateAndInject <NeedsFieldInjection>();
NeedsFieldInjection needsInjection3 = injector.CreateAndInject <NeedsFieldInjection>();
// Assert injection was successful
Assert.NotNull(needsInjection1);
Assert.NotNull(needsInjection2);
Assert.NotNull(needsInjection3);
// Assert only one instance was created
Assert.AreEqual(1, needsInjection1.implWithInstanceCounter.instanceIndex);
Assert.AreEqual(1, needsInjection2.implWithInstanceCounter.instanceIndex);
Assert.AreEqual(1, needsInjection3.implWithInstanceCounter.instanceIndex);
Assert.AreEqual(1, ImplWithInstanceIndex.instanceCount);
}
public void ConstructorInjectionWithCyclicDependenciesThrowsException()
{
BindingBuilder bb = new BindingBuilder();
bb.BindTypeToNewInstances(typeof(NeedsConstructorInjectionWithCyclicDependencies_A));
bb.BindTypeToNewInstances(typeof(NeedsConstructorInjectionWithCyclicDependencies_B));
bb.BindTypeToNewInstances(typeof(NeedsConstructorInjectionWithCyclicDependencies_C));
Injector injector = UniInjectUtils.CreateInjector();
injector.AddBindings(bb);
Assert.Throws <CyclicConstructorDependenciesException>(delegate { injector.Create <NeedsConstructorInjectionWithCyclicDependencies_A>(); });
}
public void ConstructorInjectionWithCustomKey()
{
BindingBuilder bb = new BindingBuilder();
bb.Bind("author").ToExistingInstance("Tolkien");
Injector injector = UniInjectUtils.CreateInjector();
injector.AddBindings(bb);
NeedsConstructorInjectionWithCustomKey needsInjection = injector.Create <NeedsConstructorInjectionWithCustomKey>();
Assert.AreEqual("Tolkien", needsInjection.theAuthor);
}
public void ConstructorInjectionFromExistingInstance()
{
BindingBuilder bb = new BindingBuilder();
bb.BindExistingInstance("abc");
Injector injector = UniInjectUtils.CreateInjector();
injector.AddBindings(bb);
NeedsConstructorInjection needsInjection = injector.Create <NeedsConstructorInjection>();
Assert.AreEqual("abc", needsInjection.theString);
}
public void FieldInjectionOfInterfaceThatIsBoundToAnImplementation()
{
BindingBuilder bb = new BindingBuilder();
bb.Bind(typeof(IInstanceIndexHolder)).ToSingleInstanceOfType(typeof(ImplWithInstanceIndex));
Injector injector = UniInjectUtils.CreateInjector();
injector.AddBindings(bb);
NeedsFieldInjectionOfInterface needsInjection = injector.CreateAndInject <NeedsFieldInjectionOfInterface>();
Assert.NotNull(needsInjection.interfaceInstance);
}
public void FieldInjectionFromExistingInstance()
{
BindingBuilder bb = new BindingBuilder();
bb.BindExistingInstance("abc");
Injector injector = UniInjectUtils.CreateInjector();
injector.AddBindings(bb);
NeedsFieldInjection needsInjection = new NeedsFieldInjection();
injector.Inject(needsInjection);
Assert.AreEqual("abc", needsInjection.theString);
}
public void ConstructorInjectionWithMultipleParameters()
{
BindingBuilder bb = new BindingBuilder();
bb.BindExistingInstance("abc");
bb.BindExistingInstance(123);
Injector injector = UniInjectUtils.CreateInjector();
injector.AddBindings(bb);
NeedsConstructorInjectionWithMultipleParameters needsInjection = injector.Create <NeedsConstructorInjectionWithMultipleParameters>();
Assert.AreEqual("abc", needsInjection.theString);
Assert.AreEqual(123, needsInjection.theInt);
}
public void MethodInjectionWithMultipleParameters()
{
BindingBuilder bb = new BindingBuilder();
bb.BindExistingInstance("Tolkien");
bb.BindExistingInstance(1954);
bb.Bind(typeof(IInstanceIndexHolder)).ToExistingInstance(new ImplWithInstanceIndex());
Injector injector = UniInjectUtils.CreateInjector();
injector.AddBindings(bb);
NeedsMethodInjectionWithMultipleParameters needsInjection = injector.CreateAndInject <NeedsMethodInjectionWithMultipleParameters>();
Assert.AreEqual("Tolkien", needsInjection.theAuthor);
Assert.AreEqual(1954, needsInjection.theYear);
Assert.NotNull(needsInjection.theInterfaceInstance);
}
public void ConstructorInjectionWithAcyclicDependencies()
{
BindingBuilder bb = new BindingBuilder();
bb.BindTypeToNewInstances(typeof(NeedsConstructorInjectionWithAcyclicDependencies_A));
bb.BindTypeToNewInstances(typeof(NeedsConstructorInjectionWithAcyclicDependencies_B));
bb.BindTypeToNewInstances(typeof(NeedsConstructorInjectionWithAcyclicDependencies_C));
Injector injector = UniInjectUtils.CreateInjector();
injector.AddBindings(bb);
NeedsConstructorInjectionWithAcyclicDependencies_A aInstance = injector.Create <NeedsConstructorInjectionWithAcyclicDependencies_A>();
// The dependency in A (requires B) and B (requires C) must have been resolved with new instances.
Assert.NotNull(aInstance.bInstance);
Assert.NotNull(aInstance.bInstance.cInstance);
}
public void CyclicFieldInjection()
{
NeedsFieldInjectionCyclic_A.instanceCount = 0;
NeedsFieldInjectionCyclic_B.instanceCount = 0;
NeedsFieldInjectionCyclic_C.instanceCount = 0;
BindingBuilder bb = new BindingBuilder();
bb.BindTypeToNewInstances(typeof(NeedsFieldInjectionCyclic_A));
bb.BindTypeToNewInstances(typeof(NeedsFieldInjectionCyclic_B));
bb.BindTypeToNewInstances(typeof(NeedsFieldInjectionCyclic_C));
Injector injector = UniInjectUtils.CreateInjector();
injector.AddBindings(bb);
NeedsFieldInjectionCyclic_A aInstance = injector.CreateAndInject <NeedsFieldInjectionCyclic_A>();
// The dependency in C must have been resolved with the instance of A that was created.
Assert.NotNull(aInstance.bInstance);
Assert.NotNull(aInstance.bInstance.cInstance);
Assert.NotNull(aInstance.bInstance.cInstance.aInstance);
Assert.AreEqual(aInstance.instanceIndex, aInstance.bInstance.cInstance.aInstance.instanceIndex);
}
