public void TestInstallerSelfTransient()
{
Container.Bind <Foo>().FromSubContainerResolve().ByInstance(
CreateFooSubContainer()).AsTransient().NonLazy();
Assert.IsNotNull(Container.Resolve <Foo>().Bar);
}
public void TestConcrete()
{
Container.BindFactory <IFoo, IFooFactory>()
.To <Foo>().FromSubContainerResolve().ByMethod(InstallFoo).NonLazy();
Assert.IsEqual(Container.Resolve <IFooFactory>().Create(), ConstFoo);
}
public void TestMultipleWithOneTagged()
{
Container.Bind <Bar>().AsSingle().NonLazy();
Container.Bind <Qux>().AsSingle().NonLazy();
Assert.IsNotNull(Container.Resolve <Qux>());
}
public void Test1()
{
NumInstalls = 0;
InitTest.WasRun = false;
TickTest.WasRun = false;
DisposeTest.WasRun = false;
var container = new DiContainer();
container.Bind(typeof(TickableManager), typeof(InitializableManager), typeof(DisposableManager))
.ToSelf().AsSingle().CopyIntoAllSubContainers();
// This is how you add ITickables / etc. within sub containers
container.BindInterfacesAndSelfTo <FooKernel>()
.FromSubContainerResolve().ByMethod(InstallFoo).AsSingle();
var tickManager = container.Resolve <TickableManager>();
var initManager = container.Resolve <InitializableManager>();
var disposeManager = container.Resolve <DisposableManager>();
Assert.That(!InitTest.WasRun);
Assert.That(!TickTest.WasRun);
Assert.That(!DisposeTest.WasRun);
initManager.Initialize();
tickManager.Update();
disposeManager.Dispose();
Assert.That(InitTest.WasRun);
Assert.That(TickTest.WasRun);
Assert.That(DisposeTest.WasRun);
}
public void RunTest1()
{
Container.Bind <Test1>().AsSingle().NonLazy();
Container.Bind <int>().FromInstance(1).NonLazy();
Assert.IsEqual(Container.Resolve <Test1>().val, 1);
}
public void TestInstallerSelfIdentifiersFails()
{
Container.Bind <Gorp>().FromSubContainerResolve()
.ByInstanceGetter(ctx => CreateFooSubContainer()).AsSingle().NonLazy();
Assert.Throws(() => Container.Resolve <Gorp>());
}
public void TestInstallerSelfSingle()
{
Container.Bind <Foo>().FromSubContainerResolve()
.ByInstanceGetter(ctx => CreateFooSubContainer()).AsSingle().NonLazy();
Assert.IsNotNull(Container.Resolve <Foo>().Bar);
}
public void TestIntIdentifiers2()
{
Container.Bind <Foo>().WithId(4).AsTransient();
Container.Bind <Test1>().AsTransient();
Assert.Throws(() => Container.Resolve <Test1>());
}
public void TestIntIdentifiers3()
{
Container.Bind <Foo>().WithId(5).AsTransient();
Container.Bind <Test1>().AsTransient();
Assert.IsNotNull(Container.Resolve <Test1>());
}
public void TestEnumIdentifiers3()
{
Container.Bind <Foo>().WithId(Things.Thing1).AsTransient();
Container.Bind <Test2>().AsTransient();
Assert.IsNotNull(Container.Resolve <Test2>());
}
public void TestStringIdentifiers2()
{
Container.Bind <Foo>().WithId("asdf").AsTransient();
Container.Bind <Test0>().AsTransient();
Assert.IsNotNull(Container.Resolve <Test0>());
}
public void TestConcrete()
{
Container.BindFactory <string, IFoo, IFooFactory>()
.To <Foo>().FromSubContainerResolve().ByInstaller <FooInstaller>().NonLazy();
Assert.IsEqual(Container.Resolve <IFooFactory>().Create("asdf").Value, "asdf");
}
public void TestMethodConcreteCached()
{
Container.Bind <IFoo>().To <Foo>()
.FromSubContainerResolve().ByMethod(InstallFooFacade).AsSingle().NonLazy();
Assert.IsNotNull(Container.Resolve <IFoo>().Bar);
}
public void TestInstallerSelfSingleMultipleContracts()
{
Container.Bind(typeof(Foo), typeof(Bar)).FromSubContainerResolve()
.ByInstance(CreateFooSubContainer()).AsSingle().NonLazy();
Assert.IsEqual(Container.Resolve <Foo>().Bar, Container.Resolve <Bar>());
}
public void TestInstallerSelfCachedMultipleContracts()
{
Container.Bind(typeof(Foo), typeof(IFoo)).To <Foo>().FromSubContainerResolve()
.ByInstanceGetter(ctx => CreateFooSubContainer()).AsSingle().NonLazy();
Assert.IsEqual(Container.Resolve <Foo>(), Container.Resolve <IFoo>());
}
public void TestEnumIdentifiers1()
{
Container.Bind <Foo>().AsTransient();
Container.Bind <Test2>().AsTransient();
Assert.Throws(() => Container.Resolve <Test2>());
}
public void TestInstallerSelfSingleMultipleMatches()
{
Container.Bind <Qux>().FromSubContainerResolveAll()
.ByInstanceGetter(ctx => CreateFooSubContainer()).AsSingle().NonLazy();
Assert.IsEqual(Container.ResolveAll <Qux>().Count, 2);
}
public void TestPrimitiveParamOptionalUsesExplicitDefault3()
{
Container.Bind <Test8_2>().AsSingle().NonLazy();
Container.BindInstance(2);
Assert.IsEqual(Container.Resolve <Test8_2>().Val1, 2);
}
public void TestInstallerSelfIdentifiers()
{
Container.Bind <Gorp>().FromSubContainerResolve("gorp")
.ByInstanceGetter(ctx => CreateFooSubContainer()).AsSingle().NonLazy();
Assert.IsNotNull(Container.Resolve <Gorp>());
}
public void TestParameterRequired()
{
Container.Bind <Test4>().AsSingle().NonLazy();
Assert.Throws(
delegate { Container.Resolve <Test4>(); });
}
public void TestExplicitOrder()
{
Container.Bind <PoolableManager>().AsSingle();
Container.Bind <IPoolable>().To <Foo>().AsSingle();
Container.Bind <IPoolable>().To <Bar>().AsSingle();
Container.BindExecutionOrder <Foo>(2);
Container.BindExecutionOrder <Bar>(1);
var poolManager = Container.Resolve <PoolableManager>();
CallCount = 1;
Foo.SpawnCallCount = 0;
Foo.DespawnCallCount = 0;
Bar.SpawnCallCount = 0;
Bar.DespawnCallCount = 0;
poolManager.TriggerOnSpawned();
Assert.IsEqual(Foo.SpawnCallCount, 2);
Assert.IsEqual(Bar.SpawnCallCount, 1);
Assert.IsEqual(Foo.DespawnCallCount, 0);
Assert.IsEqual(Bar.DespawnCallCount, 0);
poolManager.TriggerOnDespawned();
Assert.IsEqual(Foo.SpawnCallCount, 2);
Assert.IsEqual(Bar.SpawnCallCount, 1);
Assert.IsEqual(Foo.DespawnCallCount, 3);
Assert.IsEqual(Bar.DespawnCallCount, 4);
}
public void TestDecoratorMethod()
{
SaveHandler.NumInstances = 0;
SaveDecorator1.CallCount = 0;
bool wasCalled = false;
Container.Bind <ISaveHandler>().To <SaveHandler>().AsSingle();
Container.Decorate <ISaveHandler>()
.With <SaveDecorator1>().FromMethod((x, h) =>
{
wasCalled = true;
return(new SaveDecorator1(h));
});
CallCounter = 1;
Assert.That(!wasCalled);
Assert.IsEqual(SaveHandler.NumInstances, 0);
Assert.IsEqual(SaveDecorator1.CallCount, 0);
Container.Resolve <ISaveHandler>().Save();
Assert.That(wasCalled);
Assert.IsEqual(SaveHandler.NumInstances, 1);
Assert.IsEqual(SaveDecorator1.CallCount, 1);
}
public void TestCached2()
{
Container.Bind(typeof(Foo), typeof(IFoo)).To <Foo>().FromMethodMultiple(ctx => new[] { new Foo() }).AsSingle().NonLazy();
Assert.IsEqual(Container.Resolve <Foo>(), Container.Resolve <Foo>());
Assert.IsEqual(Container.Resolve <Foo>(), Container.Resolve <IFoo>());
}
public void TestSelf()
{
Container.BindFactory <Foo, Foo.Factory>()
.FromSubContainerResolve().ByInstaller <FooInstaller>().NonLazy();
Assert.IsEqual(Container.Resolve <Foo.Factory>().Create(), FooInstaller.Foo);
}
public void TestMissingParameterThrows()
{
Container.Bind <Test1>().AsTransient().NonLazy();
Assert.Throws(
delegate { Container.Resolve <Test1>(); });
}
public void TestTrue()
{
Assert.That(TestListComparer.ContainSameElements(
new List <int> {
1
},
new List <int> {
1
}));
Assert.That(TestListComparer.ContainSameElements(
new List <int> {
1, 2
},
new List <int> {
2, 1
}));
Assert.That(TestListComparer.ContainSameElements(
new List <int> {
1, 2, 3
},
new List <int> {
3, 2, 1
}));
Assert.That(TestListComparer.ContainSameElements(
new List <int>(),
new List <int>()));
}
public void TestSelf()
{
Container.BindFactory <string, Foo, Foo.Factory>()
.FromSubContainerResolve().ByMethod(InstallFoo).NonLazy();
Assert.IsEqual(Container.Resolve <Foo.Factory>().Create("asdf").Value, "asdf");
}
public void TestTargetConditionError()
{
Container.Bind <Test1>().AsSingle().NonLazy();
Assert.Throws(
delegate { Container.Resolve <Test1>(); });
}
public void TestResolve()
{
Container.Bind <Foo>().AsSingle().NonLazy();
Container.Bind <Bar>().AsSingle().NonLazy();
Assert.IsNotNull(Container.Resolve <Foo>());
}
public void TestConcreteTransient2()
{
Container.Bind <IFoo>().To <Foo>().AsTransient().NonLazy();
Assert.IsNotNull(Container.Resolve <IFoo>());
Assert.IsNotEqual(Container.Resolve <IFoo>(), Container.Resolve <IFoo>());
}
