public void TestSelfCached()
{
Container.Bind <Foo>().AsSingle().NonLazy();
Assert.IsNotNull(Container.Resolve <Foo>());
Assert.IsEqual(Container.Resolve <Foo>(), Container.Resolve <Foo>());
}
public void TestMultipleBindingsCached()
{
Container.Bind(typeof(IFoo), typeof(IBar)).To <Foo>().AsSingle().NonLazy();
Assert.IsEqual(Container.Resolve <IFoo>(), Container.Resolve <IFoo>());
Assert.IsEqual(Container.Resolve <IFoo>(), Container.Resolve <IBar>());
}
public void TestSelfSingleExplicit()
{
Container.Bind <Foo>().ToSelf().FromNew().AsSingle().NonLazy();
Assert.IsNotNull(Container.Resolve <Foo>());
Assert.IsEqual(Container.Resolve <Foo>(), Container.Resolve <Foo>());
}
public void TestConcrete()
{
Container.BindFactory <IFoo, IFooFactory>()
.To <Foo>().FromIFactory(b => b.To <CustomFooFactory>().AsCached()).NonLazy();
Assert.IsEqual(Container.Resolve <IFooFactory>().Create(), StaticFoo);
}
// Test that tickables get called in the correct order
public void TestOrder()
{
BindTickable <Tickable3>(2);
BindTickable <Tickable1>(0);
BindTickable <Tickable2>(1);
var taskUpdater = _container.Resolve <TaskUpdater <ITickable> >();
var tick1 = _container.Resolve <Tickable1>();
var tick2 = _container.Resolve <Tickable2>();
var tick3 = _container.Resolve <Tickable3>();
int tickCount = 0;
tick1.TickCalled += delegate
{
Assert.IsEqual(tickCount, 0);
tickCount++;
};
tick2.TickCalled += delegate
{
Assert.IsEqual(tickCount, 1);
tickCount++;
};
tick3.TickCalled += delegate
{
Assert.IsEqual(tickCount, 2);
tickCount++;
};
taskUpdater.UpdateAll();
}
public void Test1()
{
Container.BindFactory <string, Foo, Foo.Factory>().FromPoolableMemoryPool(x => x.WithInitialSize(2).WithArguments("blurg"));
var factory = Container.Resolve <Foo.Factory>();
var foo = factory.Create("asdf");
Assert.IsEqual(foo.InitialData, "blurg");
var pool = foo.Pool;
Assert.IsEqual(pool.NumActive, 1);
Assert.IsEqual(pool.NumTotal, 2);
Assert.IsEqual(pool.NumInactive, 1);
Assert.IsEqual(foo.Data, "asdf");
foo.Dispose();
Assert.IsEqual(pool.NumActive, 0);
Assert.IsEqual(pool.NumTotal, 2);
Assert.IsEqual(pool.NumInactive, 2);
Assert.IsEqual(foo.Data, null);
}
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 TestConcrete()
{
Container.BindFactory <string, IFoo, IFooFactory>()
.To <Foo>().FromSubContainerResolve().ByInstaller <FooInstaller>().NonLazy();
Assert.IsEqual(Container.Resolve <IFooFactory>().Create("asdf").Value, "asdf");
}
public void TestConcrete()
{
Container.BindFactory <IFoo, IFooFactory>()
.To <Foo>().FromSubContainerResolve().ByMethod(InstallFoo).NonLazy();
Assert.IsEqual(Container.Resolve <IFooFactory>().Create(), ConstFoo);
}
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 Test1()
{
Container.Bind <IFoo>().To <Foo1>().AsSingle();
Container.Bind <IFoo>().To <Foo2>().AsSingle();
Assert.IsEqual(Container.ResolveAll <IFoo>().Count, 2);
}
public void RunTest1()
{
Container.Bind <Test1>().AsSingle().NonLazy();
Container.Bind <int>().FromInstance(1).NonLazy();
Assert.IsEqual(Container.Resolve <Test1>().val, 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 TestInstallerSelfSingleMultipleMatches()
{
Container.Bind <Qux>().FromSubContainerResolveAll()
.ByInstanceGetter(ctx => CreateFooSubContainer()).AsSingle().NonLazy();
Assert.IsEqual(Container.ResolveAll <Qux>().Count, 2);
}
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 TestSelf()
{
Container.BindFactory <Foo, Foo.Factory>()
.FromSubContainerResolve().ByInstaller <FooInstaller>().NonLazy();
Assert.IsEqual(Container.Resolve <Foo.Factory>().Create(), FooInstaller.Foo);
}
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 TestPrimitiveParamOptionalUsesExplicitDefault3()
{
Container.Bind <Test8_2>().AsSingle().NonLazy();
Container.BindInstance(2);
Assert.IsEqual(Container.Resolve <Test8_2>().Val1, 2);
}
public void TestCase2()
{
Test0 test0;
Test1 test1;
var subContainer = Container.CreateSubContainer();
var test0Local = new Test0();
subContainer.Bind <Test0>().FromInstance(test0Local);
subContainer.Bind <Test1>().AsSingle();
test0 = subContainer.Resolve <Test0>();
Assert.IsEqual(test0Local, test0);
test1 = subContainer.Resolve <Test1>();
Assert.Throws(
delegate { Container.Resolve <Test0>(); });
Assert.Throws(
delegate { Container.Resolve <Test1>(); });
Container.Bind <Test0>().AsSingle();
Container.Bind <Test1>().AsSingle();
Assert.That(Container.Resolve <Test0>() != test0);
Assert.That(Container.Resolve <Test1>() != test1);
}
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 Test2()
{
var foo = new Foo();
Container.BindMemoryPoolCustomInterface <Foo, Foo.Pool, Foo.IFooPool>().FromInstance(foo);
Assert.IsEqual(Container.Resolve <Foo.IFooPool>().Spawn(), foo);
}
public void TestCached()
{
var foo = new Foo();
Container.Bind <Foo>().FromMethodMultiple(ctx => new[] { foo }).AsSingle().NonLazy();
Assert.IsEqual(Container.Resolve <Foo>(), foo);
}
public void Test1()
{
var foo = new Foo();
Container.BindFactoryCustomInterface <Foo, Foo.Factory, Foo.IFooFactory>().FromInstance(foo);
Assert.IsEqual(Container.Resolve <Foo.IFooFactory>().Create(), foo);
}
public void TestMultiple()
{
Container.Bind <Foo>().AsCached();
Container.Bind <Foo>().AsCached();
Container.Bind <Bar>().FromResolveAllGetter <Foo>(x => x.Bar).AsSingle();
Assert.IsEqual(Container.ResolveAll <Bar>().Count, 2);
}
public void Test5()
{
Container.BindIFactory <string, int, char, long, double, IFooFive>().To <FooFive>();
var factory = Container.Resolve <IFactory <string, int, char, long, double, IFooFive> >();
Assert.IsEqual(factory.Create("asdf", 0, 'z', 2, 3.0).P1, "asdf");
}
public void Test2()
{
Container.BindIFactory <string, FooTwo>();
var factory = Container.Resolve <IFactory <string, FooTwo> >();
Assert.IsEqual(factory.Create("asdf").Value, "asdf");
}
public void TestTransient()
{
Container.Bind <Foo>().AsSingle();
Container.Bind <Bar>().FromResolveGetter <Foo>(x => x.Bar);
Assert.IsNotNull(Container.Resolve <Bar>());
Assert.IsEqual(Container.Resolve <Bar>(), Container.Resolve <Foo>().Bar);
}
public void TestSelf()
{
Container.Bind <Foo>().AsSingle().NonLazy();
Container.BindFactory <Bar, Bar.Factory>().FromResolveGetter <Foo>(x => x.Bar).NonLazy();
Assert.IsNotNull(Container.Resolve <Bar.Factory>().Create());
Assert.IsEqual(Container.Resolve <Bar.Factory>().Create(), Container.Resolve <Foo>().Bar);
}
public void TestSelf()
{
var foo = new Foo();
Container.BindFactory <Foo, Foo.Factory>().FromInstance(foo).NonLazy();
Assert.IsEqual(Container.Resolve <Foo.Factory>().Create(), foo);
}
public void TestCustomValidatable()
{
Container.BindInterfacesAndSelfTo <Loy>().AsSingle().NonLazy();
Container.ResolveRoots();
Assert.IsEqual(Container.Resolve <Loy>().CallCount, 1);
}
